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.
