Revision control

In computer software engineering revision control is any practice which tracks and provides controls over changes to a project's source code. In theory, the practice can be applied to any type of information record. In practice, however, the more sophisticated techniques and tools for revision control are rarely used outside software development circles (though they may actually be of benefit in some other areas). Software developers sometimes use revision control software to maintain documentation and configuration files as well as source code.

As software is developed and deployed, it is extremely common for multiple versions of the same software to be deployed in different sites, and for the software's developers to be working privately on updates. Bugs and other issues with software are often only present in certain versions (because of the fixing of some problems and the introduction of others as the program evolves). Therefore, for the purposes of locating and fixing bugs, it is vitally important for the debugger to be able to retrieve and run different versions of the software to determine in which version(s) the problem occurs. It may also be necessary to develop two versions of the software concurrently (for instance, where one version has bugs fixed, but no new features, where the other is where new features are worked on).

Another problem that occurs in large software development projects is that of multiple developers seeking to work on the program at the same time. If two developers try to change the same file at the same time, without some method of managing access the developers may well end up overwriting each other's work.

Some systems attempt to manage who is allowed to make changes to different aspects the program, for instance, allowing changes to a file to be checked by a designated reviewer before being added.

At the simplest level, users can simply retain multiple copies of the different versions of the program, and number them appropriately. This simple approach has been used on many large software projects (for instance, until recently, the Linux kernel). Whilst this method can work, it is inefficient (as many near-identical copies of the program will be kept around), require a lot of self-discipline on the part of developers, and often lead to mistakes.

Consequently, systems to automate some or all of the revision control process have been developed. Most use a system whereby only the differences between successive versions of files are retained, thus allowing the efficient storage of many, many different versions of files. They also provide methods for preventing "concurrent access" problems, by either simply locking files so that only one developer has write access to the central "repository" at once, and/or providing facilities to automatically or semi-automatically merge changes.

Some of the more advanced version control tools offer many other facilities, allowing deeper integration with other toolls and particularly software engineering processes.

Some common version control software:

Open source examples:

• CVS
• RCS
• Subversion
• Katie
• GNU CSSC[?] - a SCCS clone

Notable proprietary packages:

• Microsoft Visual SourceSafe [1] (http://msdn.microsoft.com/ssafe/)
• Bitkeeper (note: available at no cost under some circumstances, used in Linux kernel development)
• Perforce
• SCCS[?]

External Links

• CVS (Concurrent Version System) (http://www.cvshome.org/)
• RCS (Revision Control System) (http://www.cs.purdue.edu/homes/trinkle/RCS/)
• Perforce (Fast software configuration management system) (http://www.perforce.com/)
• CSSC (Compatibly Stupid Source Control) (http://cssc.sourceforge.net/)