[Monotone-devel] advice, please, on organising branches

[hendrik]

I'm working on in a compiler that will at some time have multiple code 
generators.  These will target different so-called machine-independent 
intermediate codes, and will be appropriate in different execution 
environments.

The obvious way to organise this is as a tree of branches

        A
       /|\
      / | \
     J  L  C

where A is the ancestral compiler with a skeletal code generator (which 
generates no code), and where J, L, and C are the same skeletal code 
generator fleshed out to the different intermediate codes.

A bug in L could, for example, be fixed in L of in A depending on how 
branch-specific it is, and then merged into J and L.  That's one of the 
recommended best practices on the wiki.

The trouble is that what I have checked in now is the code for the J 
branch, and the code for the A branch does not exist (and never has).

I'd have to build a common ancestor A from J, and then spawn L and C.

How awkward!

Now I could just discard J as a separate branch, since its target 
intermediate code is technically obsolete and has no surviving 
implementation (the compiler is ancient; so is J) and just derive

        J
        |\
        | \
        L  C

or even

        J
        |
        |
        A
        |\
        | \
        L  C

which would be technically more honest.

Could anyone advise which organisation they consider better?  Or is 
there another I'm missing completely?

-- hendrik