cvs can do a lot of things for you, but it does not try to be everything for everyone.
cvs does not dictate how you build anything. It merely stores files for retrieval in a tree structure you devise.
cvs does not dictate how to use disk space in the checked out working directories. If you write your Makefiles or scripts in every directory so they have to know the relative positions of everything else, you wind up requiring the entire repository to be checked out.
If you modularize your work, and construct a build
system that will share files (via links, mounts,
VPATH
in Makefiles, etc.), you can
arrange your disk usage however you like.
But you have to remember that any such system is a lot of work to construct and maintain. cvs does not address the issues involved.
Of course, you should place the tools created to support such a build system (scripts, Makefiles, etc) under cvs.
Figuring out what files need to be rebuilt when
something changes is, again, something to be handled
outside the scope of cvs. One traditional
approach is to use make
for building, and use
some automated tool for generating the dependencies which
make
uses.
See Builds, for more information on doing builds
in conjunction with cvs.
cvs is an instrument for making sources dance to
your tune. But you are the piper and the composer. No
instrument plays itself or writes its own music.
cvs cannot determine when simultaneous changes
within a single file, or across a whole collection of
files, will logically conflict with one another. Its
concept of a conflict is purely textual, arising
when two changes to the same base file are near enough
to spook the merge (i.e. diff3
) command.
cvs does not claim to help at all in figuring out non-textual or distributed conflicts in program logic.
For example: Say you change the arguments to function
X
defined in file A. At the same time,
someone edits file B, adding new calls to
function X
using the old arguments. You are
outside the realm of cvs's competence.
Acquire the habit of reading specs and talking to your
peers.
Another aspect of change control is keeping track of
the fact that changes to several files were in fact
changed together as one logical change. If you check
in several files in a single cvs commit
operation, cvs then forgets that those files were
checked in together, and the fact that they have the
same log message is the only thing tying them
together. Keeping a gnu style ChangeLog
can help somewhat.
Another aspect of change control, in some systems, is
the ability to keep track of the status of each
change. Some changes have been written by a developer,
others have been reviewed by a second developer, and so
on. Generally, the way to do this with cvs is to
generate a diff (using cvs diff
or diff
)
and email it to someone who can then apply it using the
patch
utility. This is very flexible, but
depends on mechanisms outside cvs to make sure
nothing falls through the cracks.
commitinfo
file. I haven't
heard a lot about projects trying to do that or whether
there are subtle gotchas, however.