Re: Upstream merging and conflicts (was Re: Using cvs2git to track an external CVS project)

On 6/9/05, Linus Torvalds [off-list ref] wrote:

Yes, and right now that "manual" part is actualyl fairly high. I'll fix
that thing up (today, I hope), making nontrivial merges much easier.

Wow -- I'll be tracking your tree closely then ;-)

It's true that you can't skip patches, since a merge is always
all-or-nothing, and the global history really requires that (in a very
fundamental way). However, you _can_ merge from the HEAD, and then say
"that patch is no longer relevant in this tree", and remove it. Then
you'll never need to worry about that patch any more, because you've
merged it and in your merged result, it no longer exists).

I had that strategy in my back-pocket already, but it doesn't sound right. 

That said, I don't claim that this is what you always want to do. In fact,
we have this exact issue in the kernel, and I think it's a great thing to
use a combination of a patch-based system _and_ git. You use git for the
"core", you use the patch-based system for the more fluid stuff. In the
case of the kernel, the patch-based system that seems to be used the most
is "quilt", but that's a detail. The big issue is that git is simply part
of a bigger process:

Sounds like I'll be reading up on quilt then. I guess that's what I
was looking for...

Yes. I think this is fundamental. "git" needs to converge. It's how git
works. git also "crystallizes" the history and makes it unbreakable.
Both of these things are _wonderful_ for what they mean, but both of these
fundamental issues are _horrible_ for other reasons.

Fair enough -- and actually I'm not convinced it's a horrible thing.
Having worked with forever-diverging tools like Arch, I can appreciate
the value of crystallizing and identifying when you've converged --
and rebasing all steps forward on the fact that you've converged. This
is huge.

A patch-based workflow is needed in the periphery of HEAD -- but
patch-based tools fail to see when they've converged. What I am
salivating about is the idea of some basic patch smarts based on
git/cogito that I can use to track things in simplistic scenarios.
Right now as soon as I'm one patch "off" all of git support breaks
down and it's really hard to keep merging forward. Unless I merge &
reverse as discussed.

So I don't think that you should necessarily think of git as "the" souce
control management in the big picture. 

Yup. And quilt or other tools in the periphery. Something like the
git-aware darcs (which I haven't looked at yet).

So I don't think any development effort that is big enough necessarily
wants to use git as the _only_ way of doing development and merging stuff.
The kernel certainly does not. Not now, and not in the long run.

Agreed. I'm happy to roll out some custom perl scripts around git (or
extend cogito a bit) if git can expose some stable holding points for
external tools to try and do some lightweight patch tracking.

Whether the kernel model is applicable to anything else, I dunno.

I don't know either -- but I'm sure the toolset around git can support
a range of dev models. I don't think any other project has such a
large pool and strong convergence dynamics as the kernel. But git and
its tools and practices can be (I'm hoping) quite flexible to support
a range of dev models.

cheers,


martin