Which is the correct name for a system which stores versions of source code, like SVN or TFS?
I've always called it source control, but places like Wikipedia calls it revision control?
To make this more complicated sites like this one have a tag for both?
Revision Control is the more generic term, used for source-control tools but also for other tools (Word, OpenOffice, ...). It references a version.
Source Control offers revision control with branching and merging which are not always available in all revision tools (Word is not a Source Control, but offer revision control features)
Version Control is a more general term than Source Control in that it manages version of anything (sources or binaries, or any kind of documents)
Note: SCM stands for Source Code Management, but also for Software Code Management, to reflect the same idea (not just "sources" are managed).
Plus SCM introduces the notion of dependencies between group of files.
And it can also includes the notion of change lifecycle (start a change, close a change, ...) which leads to change request system.
I like to think of it this way:
Revision Control is what they do.
Source Control is what I use them for.
:-)
There are three synonyms describing almost the same thing:
- Revision control. Deals with revisions (document/artifact reviews and subsequent versions of document/artifact) or numbers (as an abstraction of revision concept).
- Source control. Deals with text (source) files, not binary. This difference plays a great role as long as it is much more easier to perform comparison and get difference between text files. There is a whole range of basic tools related to source control:
diff,diff3,patch, etc. This set of tools can be extended to form source control solution. Example of such solution is RCS. - Source code management. Deals with more complex operations over the source code: storing it in a
repositorywith the possibility of creating separatebranches. It is also assumed that branches can bemerged. Another part of source code management istagging. One problem with source code management is that it has abbreviation SCM. This abbreviation is used to describe more broad set of activities - Software Configuration Management. There's a lot of confusion because source code management is a subset of software configuration management which also deals with such activities as build management, deployment management, continuous integration, dependencies management, release management, etc. - Version control. It is used as substitution for such term as source code management in order to avoid ambiguity. It incorporates both concepts of revision control and source control making it to describe almost the same concept. Currently, both terms revision control, source control are substituted with version control as more appropriate taking into account the wide range of tools (CVS, SVN, Git, Mercurial, ClearCase, Perforce, VSS, etc) which solve both tasks of revision control and source control simultaneously.
Picture to illustrate more clearly distinction between all of these concepts:
- Version Control System (VCS) is the most commonly used term
- Source Code Management (SCM) is used in git, but it's sort of invented and can be confused with Software Configuration Management which is already used in the software industry and it's not the same thing.
Certain systems (like SVN) have a term revision which stands for a number associated with a specific set of versions of all files in the repository. In such systems revision (SVN revision) essentially means version (sources version). Otherwise revision control and version control are the same terms.
The terminology used is not very precise. There is an article describing the five relevant dimensions. Data management tools for software development don't tend to support more than three of them consistently at the same time. If you want to support all five you have to describe a development proces:
- Version (semantics: modification)
- View (semantics: equivalence, derivation)
- Hierarchy (semantics: consists of)
- Status (semantics: approval, accessibility)
- Variant (semantics: product variations)
Peter van den Hamer and Kees Lepoeter (1996) Managing Design Data: The Five Dimensions of CAD Frameworks, Configuration Management, and Product Data Management, Proceedings of the IEEE, Vol. 84, No. 1, January 1996
There's not a "correct" name, the four common names are:
- Version control system
- Revision control system
- Source control system
- Source code management system
another name is: version-control
Based on the tags used on this site, "source control" is the most popular one (which is quite normal, since this site is about programming):
- source control (633 tags)
- version control (587)
- revision control (31)
MIL-STD 973 Describes Configuration management.
Software Configuration Management is done exactly the same.
See the CMMI for a nice explanation of SCM/CM.
The systems of which you speak are version control systems. They version things.
Old SCCS was a Source Code Control System.
Source code control systems maintain revision history.
Say you change a file from revision
1.1 , 1.2, 1.3.
At 1.3 we release "Awesome Edition" of our product.
1.3 is a revision AwesomeEdition is a version.
In systems like CVS, revisions happen as numbering changes , and tags mark versions. SVN type repository revision numbering confuses government customers who expect MIL-STD kind of behaviour.
The great thing about standards in change management is that there are so many to choose from.
If historic precedence is anything to go by, the term should be Source Code Control - see http://en.wikipedia.org/wiki/Source_Code_Control_System
So, what exactly are you looking for now?
I don't think there is one right term. Both terms, as well as some other already mentioned in other replies are used for basically the same thing.
Persons you are talking to will connect it to slightly different meaning even when using the same word for it - and they can mean really exactly the same thing, even when using another word.
Then again, the vocabulary used around these things can also be different(or attached to different meanings) in circles around different software implementations of this concept.
While writing this, it comes to my mind that this is a very natural phenomenon - in other areas you also have multiple words standing for basically the same meaning - while some would argue there are actually slight differences, some others would say these differences do not really exist or aren't worth thinking about. And it's never guaranteed that when two people use the exact same word, that they really mean the exact same thing.
I added a comment, but I think it can qualify for an answer as well. I have a little different view then some of the other comments already expressed.
In general SCM (Software Configuration Management) or (Source Code Management - derived term) it is easy to understand as it is used as an umbrella term which includes both revision control as well as other techniques like baseline management. See http://en.wikipedia.org/wiki/Software_configuration_management. In general modern SCM tools which range from CVS to Git include both of these techniques and many more useful features like: permission control, rights management, security auditing, allow customization of the SCM flow (ClearCase), integrate with build-system and issue tracking software, etc... I think the list is open because anything related to software change and management can enter here.
So the main confusion comes from understanding the difference between Revision Control, Version Control and possibly Source Control. First of all, all terms which include "source" are all derived terms, by that I mean some people are bothered by all these generic terms (configuration management - what's that?) and insist that they work with source code in particular and they don't care about other use-cases; which is fair point.
Regarding Revision Control vs Version Control I think the correct term (in context of tools like SVN, Git) is Revision Control. In my view, with the term Revision Control the emphasis is on managing the change (besides managing the versions) of the (not only) source code files, while with Version Control the emphasis falls on managing only the versions of the files.
In theory someone could write a piece of software which allows tracking and management of binary files with no binary diff and merging support and would call this Version Control System. However in case of tools like SVN, Git these additionally allow managing the changes to the files: diffing, merging and in case of Git the famous rebasing.
So in conclusion Revision Control includes Version Control and is more appropriate in naming tools like CVS, SVN, Git; while Source Control is a derived term and should be avoided if one would like to name a specific SCM aspect.
SCM > Revision Control > Version Control
来源：https://stackoverflow.com/questions/1056912/source-control-vs-revision-control