Revision Control Systems

by Steven J. Owens (unless otherwise attributed)

Programmers use source code revision control systems, like RCS, CVS, Subversion, Microsoft Visual SourceSafe, Perforce, or Clearcase, to name the ones I can think of off the topof my head.

Typically these systems provide three functions:

1) storing a centralized archive of one or more sets of source code files

2) maintaining a log of changes - both the actual substance of the changes as well as the details of who made them, when, and associated notes.

3) managing the process of multiple users making changes

Storing a centralized archive is simple enough; projects in the past can and did simply use a commonly accessible hierarchy of directories (on a multi-user system, like Unix). Examining the archive (listing files, copying them, etc) was done with standard system commands.

In more advanced revision control systems, the system either has to provide similar commands or an interface (GUI or otherwise) to accomplish the same thing.

In some cases, for example ClearCase, the revision control system actually provides substitute versions of the standard commnands, so users interact with the archive as if it were a normal file system, and the ClearCase takes care of stuff related to the second and third functions under the covers.

Then there are others, like CVS, which stands for Concurrent Versioning System. CVS is open source and is the most popular system in the open source world, for a couple of reasons besides the fact that CVS is open source. One of those reasons is that CVS has good support for interacting with the CVS archive via network, and only having a very small CVS client on the machine you're working on. (I'll get to the other reason below).

Maintaining a log of changes is one of the most important things a revision control system gives you - and probably why they're generally called "revision control systems" instead of "source code archive systems". There's not that much difference between an archive and a file system; the revision control aspects are the first big difference.

It's like "Undo" on steroids. Having a revision control system provides you with a log of the changes, which means you never end up in a dead-end without a way out; when you end up there, you can review the changes to see how you got there and how to get out. I'm sure you can see how useful this is for things like writing a document in English; imagine how much more important it is when you're working on code, where making a tiny wrong thing change can break the system beyond running!

In addition to the actual "log the changed version of the file", most revision control systems provide extra tools to make it easier to review the changes and compare different generations of a file. They also use this to prevent the archive from growing to huge proportions, since otherwise they'd have to keep dozens of copies of a given file, as files are worked on and new versions are saved.

See original (unformatted) article


Verification Image:
Your Email Address:
Confirm Address:
Please Post:
Copyright: By checking the "Please Post" checkbox you agree to having your feedback posted on notablog if the administrator decides it is appropriate content, and grant compilation copyright rights to the administrator.
Message Content: