git-imerge

git rebase conflict resolution is a lot less scary with the zdiff3 merge.conflictStyle option. Also incremental rebasing with mergify/git-imerge/git-mergify-rebase/etc is really helpful for long-lived branches that aren't merged upstream. https://github.com/brooksdavis/mergify https://github.com/mhagger/git-imerge https://github.com/CTSRD-CHERI/git-mergify-rebase https://gist.github.com/nicowilliams/ea2fa2b445c2db50d2ee650... I also love git-absorb for automatic fixups of a commit stack. https://github.com/tummychow/git-absorb

See also: https://github.com/mhagger/git-imerge

More options: https://github.com/CTSRD-CHERI/git-mergify-rebase https://github.com/mhagger/git-imerge/ https://github.com/brooksdavis/mergify/

A few more implementations of the bisect-rebase idea: https://github.com/CTSRD-CHERI/git-mergify-rebase https://github.com/mhagger/git-imerge/ https://github.com/brooksdavis/mergify/

That gist seems like a simplified version of https://github.com/mhagger/git-imerge, so check that out if you haven't. (I haven't looked at git-imerge in a long time, so I should read about it again myself.)

One way to help solve merge conflicts is incremental merge/rebase - bisect the merge to find which commit causes the conflict, then let the programmer solve that, then repeat again. I'm using git-imerge for this, but there is also mergify and a faster fork of it called git-mergify-rebase. https://github.com/mhagger/git-imerge https://github.com/brooksdavis/mergify https://github.com/CTSRD-CHERI/git-mergify-rebase

I wonder what criteria you apply to determine the trustworthiness of a project. For me, signing a CLA or otherwise not using inbound=outbound licensing is a major one, as well as any project backed by a company with VC funding. Any project backed by a single organisation instead of a group of people from lots of different organisations is a red flag, with some exceptions for long-term known-trustworthy non-profits. None of that helps with a situation like Audacity/MuseCore though, if developers are willing to sell out their project copyrights, that isn't something that you can really protect against, except maybe discussing people's opinions on that openly. The other issue with withholding changes from upstream is the potentially infinite cost of updating your changes as the project evolves, things like git-imerge, mergify or git-mergify-

https://github.com/mhagger/git-imerge > Reduce the pain of resolving merge conflicts to its unavoidable minimum, by finding and presenting the smallest possible conflicts: those between the changes introduced by one commit from each branch. I'm not sure this would've helped in my scenario. famitracker had no public repo, and the Qt fork and 0cc-famitracker came from different Git repositories and were rooted in different subdirectories. I created a synthetic Git and Pijul history for the purpose of this merge. But it might be helpful in other situations. I'll look into it. > Allow a merge to be saved, tested, interrupted, published, and collaborated on while it is in progress. This does seem useful.

Just discovered this tool while doing a messy rebase, and can't believe it has had very little discussion I can find. https://github.com/mhagger/git-imerge No previous commentary on it so far on HN: https://hn.algolia.com/?query=git%20imerge&dateRange=all So, can anyone find any interesting discussion about this tool? If you'd prefer reading rather than listening to the talk, here's an article which covers some of the same concepts: https://wilsonmar.github.io/git-imerge/ The crux of it is that the tool does an efficient pairwise merge of all commits from the donor branch onto master. It can also be configured to run the test suite to detect conflicts. Then you resolve conflicts in pairs of commits, which is only a small amount of work. The histories of your individual resolutions are preserved, so you can pause and resume the task.

I use mostly https://github.com/mhagger/git-imerge for complex merges. imerge + meld is wonderful...

A team of developers all working off of master doesn't necessarily require much communication about who's working where. If your code is well organized into modules broken down by functional area, it should reduce the number of potential conflicts. Also, fear of merge conflicts is somewhat unjustified; most conflicts can be resolved and rebased against using git rebase without that much work; the git rerere option [1] and git imerge [2] can also help with this. If developers would actually learn how to resolve merge conflicts, and not be afraid of the occasional conflict resolution which requires understanding the other change and how to write new code that incorporates both changes, it's less overhead than communicating about pending changes. [1] https://git-scm.com/docs/git-rerere [2] https://github.com/mhagger/git-imerge