Yeah learned this the hard way.

you are viewing a single comment's thread
view the rest of the comments
[–] 15 points 1 year ago (24 children)

As long as you never touch the rebase button, you'll be fine. Probably.

  • source
  • hideshow 24 child comments
  • [–] 9 points 1 year ago (6 children)

    Don't be afraid of rebases, they are an essential tool in Git.

    This particular fear can only be addressed by understanding.

  • source
  • parent
  • hideshow 6 child comments
  • [–] 1 point 1 year ago (5 children)

    I don't understand it. Every time I see something about a rebase it's some purist telling me it's "cleaner". Never got it to do what it says on the tin, and never hit a situation that I couldn't solve using more straightforward tools like merge.

  • source
  • parent
  • hideshow 5 child comments
  • [–] 2 points 1 year ago (4 children)

    What's your mental model for a Git commit, and a Git branch?

    Once I properly learned those two concepts, understanding rebases became a lot easier.

    I'll try to explain it to the best of my abilities.

    • Think of a commit being a patch - a description of how to take a particular file from one state to another
    • A branch is a list of patches to be applied in order, from the point where the branch was created until the last commit on the branch

    When you rebase a particular branch, what you're essentially doing is taking all of the commits that are currently on your branch, checking out the other branch, and then applying each of the patches in order on that new branch.

    A rebase can be cleanly applied if the premise for each commit has not changed when applied, but if the premise has changed, you get a conflict to be resolved before being able to continue the rebase.

    I mentally model a rebase a bit as a fast version of how it would look like to build the branch I was on, but on top of the branch I'm rebasing on.

  • source
  • parent
  • hideshow 4 child comments
  • [–] 1 point 1 year ago (3 children)

    That's a good explanation of what it's supposed to do. That was how I understood it as well.

    But anytime I've tried it, I've ended up with conflicts where there shouldn't be (like, I already solved that conflict when I merged earlier) and/or completely undesirable results in the end (for instance, some of my changes are just NOT in the result).

    So I just gave up on the whole feature. Simpler to just merge the source branch into mine.

  • source
  • parent
  • hideshow 3 child comments
  • [–] 1 point 1 year ago (2 children)

    Depending on how structured your commits have been, it can either be very difficult to get a rebase through or a complete breeze. There are some features to make it easier - rerere being the main one I'm thinking about.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 4 points 1 year ago (14 children)

    ... and force push.

    If you ever find yourself in a situation where rebase or a force push seems to be the solution, take a step back, clone your repo in a new directory and copy the changes into you're new checkout - 'cause you gon' and screwed somethin' up, son.

  • source
  • parent
  • hideshow 14 child comments
  • [–] 19 points 1 year ago (6 children)

    I rebase and force push daily. I like squashing all my commits, and our main branch moves quickly so I rebase off that often. Zero issues for me.

  • source
  • parent
  • hideshow 6 child comments
  • [–] 7 points 1 year ago (3 children)

    Same. And even if you were to fuck up, have people never heard of the reflog...?

    Every job I've worked at it's been the expectation to regularly rebase your feature branch on main, to squash your commits (and then force push, obv), and for most projects to do rebase-merges of PRs rather than creating merge commits. Even the, uh, less gifted developers never had an issue with this.

    I think people just hear the meme about git being hard somewhere and then use that as an excuse to never learn.

  • source
  • parent
  • hideshow 3 child comments
  • [–] 1 point 1 year ago (2 children)

    Why would you want to squash? Feels weird to willingly give up history granularity...

  • source
  • parent
  • hideshow 2 child comments
  • [–] 1 point 1 year ago (1 child)

    Because a commit should be an "indivisible" unit, in the sense that "should this be a separate commit?" equates to "would I ever want to revert just these changes?".

    IDK about your commit histories, but if I'd leave everything in there, there'd be a ton of fixup commits just fixing spelling, satisfying the linter,...

    Also, changes requested by reviewers: those fixups almost always belong to the same commit, it makes no sense for them to be separate.

    And finally, I guess you do technically give up some granularity, but you gain an immense amount of readability of your commit history.

  • source
  • parent
  • hideshow 1 child comment
  • [–] 1 point 1 year ago

    Huh. Never thought of it that way. I was never bothered by a long commit history at all. Search and filter tools in the git client always get me where I want.

    The one issue I have is when there are way too many extant branches and the graph takes up happy half my screen.

    But that's more of a Fork issue than it is a fundamental one. The Fork dev could conceivably find a solution for that.

    Either way, I guess I see what you mean. I'm just not that strict about commits. Commits just for the linter aren't a thing since we have a pre-commit hook for that, and typo-fixing commits... Well, they happen, but they're typically not numerous enough that I'd find them to be any sort of issue.

    As for whether I'd really want to revert a particular change -- while I work, yes. Afterwards, I see what you mean; i could probably squash 50 commits into 15 or something. But when I think about the time investment of reviewing every commit and thinking about how they ought to be grouped together before making my merge request... I have a lot of trouble convincing myself it's a good time investment.

    Maybe I'd think otherwise if we had a huge team. We have maybe 10 devs on this project at any given time.

  • source
  • parent
  • [–] 3 points 1 year ago (1 child)

    Yeah, I hate it when my repo is a chain of merge commits. I want to see actual changes to the code, not branch management history.

  • source
  • parent
  • hideshow 1 child comment
  • [–] 2 points 1 year ago

    I'm the opposite. I just let git take care of the stupid content. Why mess with the commit graph? Merging locally (instead of squashing) works better with merge requests because the graph clearly shows what changes went where.

    I do some branch maintenance on my local branch (rebasing) until there are conflicts, but other than that I don't see any benefit for messing with commit history.

  • source
  • parent
  • [–] 1 point 1 year ago

    Hmm, I'm less afraid of force push. It does what it says on the tin. If I pushed a fuck-uo to remote and a reset is the simplest way out, you can bet I'm force-pushing that reset.

  • source
  • parent
  • [–] 1 point 1 year ago (2 children)

    A few days ago I had to gently explain to someone why their rebase-and-force-push strategy not only prevented the use of "review latest" feature on GitHub, but was also pointless because all PRs are squash committed to main.

    They didn't get it and now they seem a little mad at me.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 2 points 1 year ago (1 child)

    I'm guessing this is in reference to a scenario where a review of the PR has already been performed, and the rebase+force push is made to introduce new changes to the PR, possibly to address PR feedback.

    I agree that these changes should be made in separate commits, for the benefit of the reviewer.

    There are other scenarios where rebases are appropriate though, such as getting potentially incompatible changes from the main branch into the PR, and here I believe a rebase+force push is the right tool for the job.

  • source
  • parent
  • hideshow 1 child comment
  • [–] 2 points 1 year ago*

    Oh there's totally a time and place for rebase strategies, this just wasn't one of them.

    Git's biggest problems come from
    people taking ritualistic views on what is "right" instead of thinking about which strategies work best for the situation, project, and team.

  • source
  • parent
  • [–] 1 point 1 year ago

    Even if you rebase you can still recover the original commits until they are garbage collected. You are generally safe as long as the .git directory isn't deleted, in which case your whole history is gone anyway.

  • source
  • parent