this post was submitted on 12 Feb 2024
165 points (94.1% liked)
Programmer Humor
32479 readers
492 users here now
Post funny things about programming here! (Or just rant about your favourite programming language.)
Rules:
- Posts must be relevant to programming, programmers, or computer science.
- No NSFW content.
- Jokes must be in good taste. No hate speech, bigotry, etc.
founded 5 years ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
How do you avoid conflicts happening in the first place?
You don't. One of the core aspects of Git is that it fully expects conflicts to be inevitable, and it gives you tools to resolve them.
I will say that if you learn to aggressively rebase branches, you can at least occasionally reduce the complexity of conflicts.
If you are working on a long branch and three other branches that conflict with your changes land in the meantime, a simple merge will force you to reconcile all of those conflicts in one big stinky merge commit.
If you instead rebase after each individual branch lands, you resolve the same number of conflicts but in three smaller, focused steps instead of one big ugly one. You also don't get a merge commit full of redundant deltas that serve only to resync your branch to master; all the conflict resolution becomes baked in to your individual branch commits.
Spreading out the problem is not reducing the problem. But it can make fixing the problem less daunting, which has a similar effect.
That was the point of my comment, unless they wrote this ironically.
Sorry you went through the trouble of writing all of this explanation, I hope this is useful to someone else
It's kind of difficult to explain in the same way git is difficult to grok on the first try.
Perhaps it's convincing enough to just say:
I.e. whether a conflict will happen is not some totally unpredictable random event. It's possible to engineer a project's code & repo so that conflicts are less common.
I can think of some "programming best practices" that can help with reducing merge conflicts, such as making small functions/methods, but I see it as a positive side effect.
I don't think avoiding merge conflicts should be a goal we actively try to reach. Writing readable code organized in atomic commits will already help you get fewer conflicts and will make them easier to resolve.
I've seen too many junior and students being distracted from getting their task done because they spent so much time "coordinating" on order to avoid these "scary" merge conflicts
No, not like that -- you misunderstand. I'm not talking about actively avoiding conflicts. Coordinating to avoid merge conflicts is the same work as resolving a merge conflict anyway, just at a different time.
I'm talking about creating practices and environments where they're less likely to happen in the first place, never incurring the coordination cost at all.
One example at the individual level is similar to what you mentioned, but there's more to it. E.g. atomically renaming and moving in separate commits, so git's engine better understands how the code has changed over time and can better resolve merges without conflict.
But there're other levels to it, too. A higher-order example could be a hot module where conflicts frequently occur. Sure, atomic commits and all that can help "recover" from conflict more easily, but perhaps if the hot module were re-designed so that interface boundaries aligned with the domains of changes that keep conflicting, future changes would simply not conflict anymore.
IMO the latter has an actual productivity benefit for teams/orgs. Some portion of devs just aren't going to be that git proficient, and in this case, good high level organization is saving them from losing hours to incorrect conflict resolutions that can cause lost work, unintended logical conflicts (even though not lexical conflict), etc. Plus, it implies abstraction boundaries better match the changes demanded by the domain, so the code is likely easier to understand, too.