Comment on History repeats itself

GandarfDeGrape@midwest.social ⁨1⁩ ⁨year⁩ ago

• dukk@programming.dev ⁨1⁩ ⁨year⁩ ago

  Merge commits suck.

  My biggest issue with GitHub is that it always squashes and merges. It’s really annoying as it not only takes away from commit history, but it also puts the fork out of sync with the main branch, and I often end up cherry picking just to fix it. Luckily LazyGit makes this process pretty painless, but still.

  Seriously people, use FF-merge where you can.

  Then again, if my feature branch has simply gone behind upstream, I usually pull and rebase. If you’ve got good commits, it’s a really simple process and saves me a lot of future headaches.

  There’s obviously places not to use rebase(like when multiple people are working on a branch), but I consider it good practice to always rebase before merge. This way, we can always just FF-merge and avoid screwing with the Git history. We do this at my company and honestly, as long as you follow good practices, it should never really get too out of hand.

  source

  • GigglyBobble@kbin.social ⁨1⁩ ⁨year⁩ ago

    Merge commits suck.

    My biggest issue with GitHub is that it always squashes and merges.

    You are aware you're talking about two different pieces of software?

    source

    • dukk@programming.dev ⁨1⁩ ⁨year⁩ ago

      Yeah, I am. However GitHub, being the biggest Git hosting provider and all that, makes you use merge commits. FF-merges must be done manually from the command line. While this definitely isn’t a problem for me, many people out there just don’t care and merge without a second thought (which, as I said in my comment, results in having to create a new branch and cherry picking the commits onto there).

      source

      • themusicman@lemmy.world ⁨1⁩ ⁨year⁩ ago

        You should check out the repo options on GitHub. It most definitely supports rebase merges, and you can disable other merge types if desired.

        source
  • GandarfDeGrape@midwest.social ⁨1⁩ ⁨year⁩ ago

    Sounds like I just gotta get better with rebasing. But generally I do my merges clean from local changes. I’ll commit and push, then merge in, push. Then keep working. Not too hard to track but I’ve found it’s the diff at MR time that people really pay attention to. So individual commits haven’t been too crucial.

    source
• atyaz@reddthat.com ⁨1⁩ ⁨year⁩ ago

  Always merge when you’re not sure. Rebasing rewrites your commit history, and merging with the squash flag discards history. In either case, you will not have a real log of what happened during development.

  Why do you want that? Because it allows you to go back in time and search. For example, you could be looking for the exact commit that created a specific issue using git bisect. Rebasing all the commits in a feature branch makes it impossible to be sure they will even work, since they represent snapshots that never existed.

  I’ll never understand why people suggest you should default to rebasing. When prompted about why, it’s usually some story about how it went wrong and it was just easier to do it the wrong way.

  I’m not saying never squash or rebase. It depends on the situation but if you had to pick a default, it should be to simply merge.

  source
• Blamemeta@lemm.ee ⁨1⁩ ⁨year⁩ ago

  What you do is create a third branch off master, cherry pick the commits from the feature branch, and merge in the third branch. So much easier.

  source

  • yogo@lemm.ee ⁨1⁩ ⁨year⁩ ago

    That’s called rebasing

    source

    • atyaz@reddthat.com ⁨1⁩ ⁨year⁩ ago

      That is absolutely not what rebasing does. Rebasing rewrites the commit history, cherry picking commits then doing a normal merge does not rewrite any history.

      source

      • yogo@lemm.ee ⁨1⁩ ⁨year⁩ ago

        I’m sorry but that’s incorrect. “Rewriting the commit history” is not possible in git, since commits are immutable. What rebase actually does is apply each commit between upstream and head on top of upstream, and then reset the current branch to the last commit applied (This is by default, assuming no interactive rebase and other advanced uses). But don’t take my word for it, just read the manual. git-scm.com/docs/git-rebase

        source

        • -> View More Comments
    • fiah@discuss.tchncs.de ⁨1⁩ ⁨year⁩ ago

      for some reason it’s easier though

      source

      • yogo@lemm.ee ⁨1⁩ ⁨year⁩ ago

        Have you tried interactive rebase (rebase -i)? I find it very useful

        source

        • -> View More Comments
  • BabaYaga@reddthat.com ⁨1⁩ ⁨year⁩ ago

    I’ve definitely done this before…

    source
  • GigglyBobble@kbin.social ⁨1⁩ ⁨year⁩ ago

    If your cherry-pick doesn't run into conflicts why would your merge? You don't need to merge to master until you're done but you should merge from master to your feature branch regularly to keep it updated.

    source

    • Blamemeta@lemm.ee ⁨1⁩ ⁨year⁩ ago

      Git is weird sometimes.

      source
  • JDubbleu@programming.dev ⁨1⁩ ⁨year⁩ ago

    This is actually genius. Gonna start using this at work.

    source
• rookeh@geddit.social ⁨1⁩ ⁨year⁩ ago

  I’ve always merged. Rebase simplifies the history graph, but realistically I can’t think of a time where that has been important to me.

  Maybe on some projects with a huge number of concurrent branches it becomes more important, probably less so for smaller teams.

  source
• NatoBoram@lemm.ee ⁨1⁩ ⁨year⁩ ago

  It only matters if you want to be able to use the commit tree and actually find something. Otherwise, there’s no harm in using merges.

  source
• h14h@midwest.social ⁨1⁩ ⁨year⁩ ago

  I try to structure my commits in a way that minimizes their blast radius, which usually likes trying to reduce the number of files In touch per commit.

  For example, my commit history would look like this:

  • Add new method to service class
  • Use new service class method in worker

  And then as I continue working, all changes will be git commit --fixuped to one of those two commit’s hashes depending on where they occur.

  And when it’s time to rebase in full, I can do a git rebase master --interactive --autosquash.

  source

  • dukk@programming.dev ⁨1⁩ ⁨year⁩ ago

    This is the way! Small commits with descriptive commit names, then just fixup into a few feature commits. Makes rebase a breeze.

    source
• risottinopazzesco@feddit.it ⁨1⁩ ⁨year⁩ ago

  Rebase. Merge into current leaves merge commits in the dev branches.

  source