I’m guessing you don’t mean commits that actually bring updates from a different branch in?

No, fast-forward merges only

merge commits that catch my feature branches up to main

You’d be squashing those when you merge back down into main anyway, no?

Great question. I’m not the one you asked, but I can answer.

Yes, merge commits, though they get useful work done, cause challenges later. If you’re using GitHub you can actually disable the ‘merge commit’ pattern in the repository settings, under ‘branch protections’, and you’ll have a much nicer time moving code between branches in the future.

Since you’re working on patterns, if you’re using GitHub, here’s my best tip - it’s related but will also cause some other nice outcomes.

If you’re using GitHub, to get a much better branching experience, you can turn on branch protections on ‘main’ and specifically turn on ‘require linear history’. This will let GitHub know that you prioritize the quality of the history in ‘main’ over that of all other branches.

Related: If your team keeps a ‘develop’ branch, you’ll need to get rid of it at the same time as making this change. Using a ‘develop’ branch is not compatible with this setup. Code that used to merge to ‘develop’ should now merge to ‘main’ and git tags should be what indicates code is ready for production.

With these settings GitHub will nudge your team towards squashing and rebasing when merging, and operations to pull other people’s code into your branch will get dramatically easier. (Edit: You’ll start to see the keyword ‘fast-forward’ a lot more often, which is great.)

If you’re not using GitHub, you can still look for tools and setups to “require linear history” to get the same benefits.

I’m guessing you don’t mean commits that actually bring updates from a different branch in?

Yep, in part, I do. Say I’m working on feature which branched off from main. Time’s gone by, and there have been commits on both feature and main. I want to integrate (not I am very carefully not using the word merge!) the commits that exist on main into my feature branch so that I can use them. You can make a merge commit to do so, but there’s no point in doing so - a git pull --rebase will have the same effect (“My local branch contains both the changes from the upstream, then the changes that I myself have made ‘on top of’ them”) without requiring a merge commit.

But really, what one chooses to do in the privacy of one’s own branch is no concern of mine. I can advise and opine, but it doesn’t really affect me. What does affect me is when people insist on merging into main. That really irritates me, because it results in horrible tangled non-linear history like this. Ideally, the history of main should be a linear history of changes which each follow on from one another, and a commit and a change are in 1:1 correspondance:

• the question “which commit is the parent of this one?” should have one answer, not potentially-multiple.
• there is no value in seeing the development history of the change (all the random “bugfix”, “maybe this will work lol”, “correct typos” commits) in the history of main. They are maybe useful in the PR, but the change as seen in main should only contain the finished polished-up result.

GitHub’s confusingly named “Squash And Merge” (it’s a “merge” in the git merge sense, but it doesn’t create a Merge Commit! “Squash and commit” or “Squash and push” would be more accurate) results, I think, in the outcome - a single commit on the HEAD of the target branch containing the result of the change. And if that happens, then I don’t care if you’ve been pulling in changes from main to feature via Merge commits or (correctly IMO) via git pull --rebase - because, whatever you’ve done, your development history will be (correctly) invisible from the commit on main.

(I say “I think” there because I’ve only recently started using GitHub in a professional capacity. For the decade prior to this I worked at a Big Tech company which had its own in-house Code Review tools which - probably not by coincidence - aligned a lot more closely with how I think about how Git history should be structured)

Thanks! I’ve been tinkering with VS Code (migrating from IntelliJ) recently - I’ve found that they’re at pretty-much feature parity. VS Code makes it much harder to attach a debugger (IME, though I might just not grok it yet), but is more customizable and a lot less of a memory-hog. I think I’m comfortable adopting it as my daily driver. And, as you say, any IDE’s Merge Editor is usually clearer than the equivalent direct from the CLI!

However, I wasn’t complaining about Merge Conflicts - I do dislike them, but they’re a necessary evil (well, until AI can resolve all conflicts itself :P ). Rather, I was complaining about Merge Commits. See my comment here for more context.