Programmer Humor

19735 readers

744 users here now

Welcome to Programmer Humor!

This is a place where you can post jokes, memes, humor, etc. related to programming!

For sharing awful code theres also Programming Horror.

Rules

Keep content in english
No advertisements
Posts must be related to programming or programmer topics

founded 1 year ago

MODERATORS

[email protected]

1093

Rebase Supremacy (programming.dev)

submitted 8 months ago by [email protected] to c/[email protected]

216 comments fedilink hide all child comments

you are viewing a single comment's thread
view the rest of the comments

[–] [email protected] 3 points 8 months ago (2 children)

I wouldn't recommend it. The Git documentation itself doesn't recommend rebase for more than moving a few unpushed commits to the front of a branch you are updating. Using it by default instead of merge requires you to use --force-push as part of your workflow which can lead to confusing situations when multiple developers end up commiting to the same branch, and at worst can lead to catastrophic data loss. The only benefit is a cleaner history graph, which is rarely used anyway, and you can always make the history graph easier to read with a gui without incuring any of the problems of rebase.

[–] surge_1 6 points 8 months ago (2 children)

Bad take IMO,

At 10+ YOE, I use rebase almost exclusively. Branch from main, rebase to clean up commit history before putting up a PR. If commits are curated properly you don't run into conflicts very often. Branches really shouldn't be shared too often anyway, and the ones that are should be write protected.

Catastrophic data loss isn't really possible either with git since it's all preserved and you can git reflog even if you mess up.

The meme is right. Git good

[–] [email protected] 1 points 8 months ago (1 children)

When rebasing, it applies the changes without the commit history?

Does that mean that when you fast forward your main/dev branch and commit, you then add a single commit that encompasses every changes that were rebase?

[–] [email protected] 2 points 7 months ago* (last edited 7 months ago)

No, there are no fast-forwards with rebasing. A rebase will take take the diff of each commit on your feature branch that has diverged from master and apply those each in turn, creating new commits for each one. The end result is that you have a linear history as though you had branched from master and made your commits just now.

If you had branched like this:

A -> B -> C (master)
   \
     \ -> D (feature)

It would like this after merging master into your feature branch:

A -> B -> C (master) ->   E (feature)
  \                                    /
    \ -> D -------------------> /

And it would like this if you instead rebased your feature branch onto master:

A -> B -> C (master) -> D' (feature)

This is why it's called a "rebase": the current state of master becomes the starting point or "base" for all of your subsequent commits. Assuming no conflicts, the diff between A and D is the same as the diff between A and D'.

[–] [email protected] 0 points 8 months ago (1 children)

Years of experience don't really matter here, that's just call to authority, in this case yourself. You might as well be the worst git user ever after 20 years of usage, or the best after 2. We don't know that.

Anyway, what you're saying basically requires a perfect world to be true. Feature branch flow is perfectly fine, but you do end up with merge conflicts constantly, unless you have cordoned off areas of the repo for certain users. Two people working on unrelated features, both change a signature of some helper/util method, merge conflict. Nothing serious, can be fixed in a minute, and rebasing or merging won't help for either.

Merge is perfectly fine. And arguing about which strategy to use is one of those autistic debates we as an industry seemingly love to have. It doesn't matter, but you'll find people screaming at each other about it. See Emacs vs. Vi. Same crap.

[–] surge_1 0 points 8 months ago

Merge is fine, but not knowing both rebase and merge is dumb. And I guess I've been in a perfect world this whole time in huge technical orgs lol.

[–] [email protected] 5 points 8 months ago (1 children)

This a really bad take and fundamentally misunderstands rebasing.

First off, developers should never be committing to the same branch. Each developer maintains their own branch. Work that needs to be tested together before merging to master belongs on a dedicated integration branch that each developer merges their respective features branches into. This is pretty standard stuff.

You don't use rebasing on shared branches, and no one arguing for rebasing is suggesting you do that. The only exception might be perhaps a dedicated release manager preparing a release or a merge of a long-running shared branch. But that is the kind of thing that's communicated and coordinated.

Rebasing is for a single developer working on a feature branch to produce a clean history of their own changes. Rebasing in this fashion doesn't touch any commits other than the author's. The purpose is to craft a high quality history that walks a reader through a proposed sequence of logical, coherent changes.

Contrary to your claim, a clean history is incredibly valuable. There's many tools in git that benefit significantly from clean, well-organizes commits. git bisect, git cherry-pick... Pretty much any command that wants to pluck commits from history for some reason. Or even stuff like git log -L or git blame are far more useful when the commit referenced is not some giant amalgamation of changes from all over the place.

When working on a feature branch, if you're merging upstream into your branch, you're littering your history with pointless, noisy commits and making your MR harder to review, in addition to making your project's history harder to understand and navigate.

[–] surge_1 0 points 8 months ago

1000 times this