Engineering
revision control developed from formalized processes based on tracking
revisions of early blueprints or bluelines. Implicit in this control
was the option to be able to return to any earlier state of the design,
for cases in which an engineering dead-end was reached in iterating any
particular engineering design. Likewise, in computer software
engineering, revision control is any practice which tracks and provides
controls over changes to source code. Software developers sometimes use
revision control software to maintain documentation and configuration
files as well as source code. In theory, revision control can be
applied to any type of information record. In practice, however, the
more sophisticated techniques and tools for revision control have
rarely been used outside software development circles (though they
could actually be of benefit in many other areas). However, they are
beginning to be used for the electronic tracking of changes to CAD
files, supplanting the "manual" electronic implementation of
traditional revision control.
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,
while the other version is where new features are worked on).
At the simplest level, developers 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.
Whilst this method can work, it is inefficient (as many near-identical
copies of the program will be kept around), requires a lot of
self-discipline on the part of developers, and often leads to mistakes.
Consequently, systems to automate some or all of the revision control
process have been developed.
