Suggestions for merging system?

[Richard Cobbe]

Greetings, all.

I'm trying to come up with a better model for managing merges and branches
than that which we currently use with our CVS repository at work.

First, a brief description of the structure of our working area.  We're
working on a single software system which consists of a number of
executables and shared libraries.  The source code for each of these
binaries is stored in a separate directory in a large tree.  The entire
tree is administered by CVS.

All of the documentation I've read (both the Cederqvist and the Fogel book)
seems to assume that the trunk is for active development, and side branches
are primarily for fitting bugfixes into previously-released versions of the
software system.  At work, we do this the other way.  Now, cvs can
obviously merge in both directions, but there are some difficulties with
our current set-up.

After we complete a release, we can shut down bugfixing on the previous
release, retiring that branch.  Since, however, that branch is in fact the
trunk, we have to "retire" this "branch" by merging the current state of
the active branch onto the trunk.  This will work, but if we've done any
prior merges from the trunk to the branch, then merging the other direction
is going to cause a lot of conflicts.  (We could avoid these by being
clever with tags and doing many separate merge commands, but that's rather
a hassle.)  In addition, this makes it very difficult to continue
development on that "branch" should it become necessary at a later time.

The other alternative, of course, is retiring the trunk, and doing all
subsequent development on the branch.  That's pretty ugly; it makes life
difficult for new folks trying to check out a copy of the repository for
the first time; and I'd like to avoid it if I can.

So, I'd like to recommend swapping the two: the trunk should be our main
development effort, and the branch our bugfix area.  However, the fact that
the currently-stable version of our software will be on branches makes it
somewhat more difficult to get a copy of the software for building a bugfix
release, especially if the various subdirectories have branched
independently, as we now have to worry about making sure each directory was
checked out from the right branch.  (Unfortunately, doing each of the
branches at the root of the project wouldn't really help, especially since
many of the branches would be rooted at unstable points in various
subdirectories.)

Has anyone found a successful way to handle this situation?  I'd like to
preserve the ability of individual developers to branch their sub-projects
as necessary.

Now, we could create a shell script to do the necessary cvs checkout and
update commands separately in each directory, place this script under CVS's
control, and have the developers update the script whenever we do a
branch.  This is the only possible solution I've been able to find, and I'm
still hoping there's a better alternative.

I'd greatly appreciate any suggestions and advice.

Thanks in advance,

Richard