CVS (Concurrent Version System) began life as a front end to
RCS developed in the early 1990s, but the
model of version control it uses was different enough that it
immediately qualified as a new design. Modern implementations don't
rely on RCS.
Unlike RCS and
SCCS, CVS
doesn't exclusively lock files when they're checked out. Instead, it
tries to reconcile nonconflicting changes mechanically when they're
checked back in, and requests human help on conflicts. The design
works because patch conflicts are much less common than one might
intuitively think.
The interface of CVS is significantly
more complex than that of RCS, and it needs
a lot more disk space. These properties make it a poor choice for small
projects. On the other hand, CVS is well
suited to large multideveloper efforts distributed across several
development sites connected by the
Internet. CVS tools on a client machine can
easily be told to direct their operations to a repository located on a
different host.
The open-source community makes heavy use of
CVS for projects such as GNOME and
Mozilla. Typically, such CVS repositories
allow anyone to check out sources remotely. Anyone can, therefore,
make a local copy of a project, modify it, and mail change patches to
the project maintainers. Actual write access to the repository is more
limited and has to be explicitly granted by the project maintainers. A
developer who has such access can perform a commit option from his
modified local copy, which will cause the local changes to get made
directly to the remote repository.
CVS has significant problems. Some
are merely implementation bugs, but one basic problem is that your
project's file namespace is not versioned in the same way changes to
files themselves are. Thus, CVS is easily
confused by file renamings, deletions, and additions. Also,
CVS records changes on a per-file basis,
rather than as
sets
of changes made to files. This
makes it harder to back out to specific versions, and harder to handle
partial check-ins. Fortunately, none of these problems are intrinsic
to the nonlocking style, and they have been successfully addressed by
newer version-control systems.