The Dynamic Evolution of Version Control Systems: From Source Code Control to Version Control
Version control, also known as source control, is the practice of tracking and managing changes to software code. [1]
Version control systems have become an essential tool for programmers, but their evolution can be traced back to the early days of source code control systems. Understanding this history can shed light on the transition to modern version control systems. In this article, we will explore the evolution of source code control systems and how they paved the way for the version control systems we use today.
Table of Contents
Evolution of Version Control Systems
Version Control Software in The 50s and 60s
Back in the 50s and 60s, the programmers were writing the source code using punch cards. As no two programmers were accessing the same source code punched on the punch cards, there was no need for source code control systems.
Back then, the source code control system was our desk drawer. [2]
The Early 70s
Later on, as the computer systems get more and more complex, the number of programmers working on the same source code has increased as well. The solution the programmers of the time came up with was the modularization of the source code.
They have used bulletin boards to monitor the source codes of the modules. The bulletin boards were the primitive version of the source code control systems.
In the 1970s, we started using bulletin boards. [2]
The Late 70s
With the proliferation of disks and text editors, the programmers of the time felt the need for controlling the revisions of the source code.
The first primitive version of the source code control systems emerged in the early 70s and become publicly available in the late 70s. [2]
SCCS
As soon as the programs became text files, the manual process of version controlling is automated using programs such as Source Code Control System (SCCS). [3]
Source Code Control System (SCCS) is a version control system designed to track changes in source code and other text files during the development of a piece of software. It allows the user to retrieve any of the previous versions of the original source code and the changes which are stored. [4]
The SCCS was originally developed at Bell Labs beginning in late 1972 by Marc Rochkind.
The first publicly released version was SCCS version 4 from February 18, 1977. [3]
There wasn’t the concept of storing just the difference between file versions (delta-storage). The technology was already there, but the programmers of the time weren’t culturally ready. [3]
Also, SCCS was the dominant version control system for Unix until later version control systems, notably the RCS and later CVS, gained more widespread adoption. [4]
The 80s
Revision Control System (RCS)
An innovation in RCS was the adoption of reverse deltas. With the use of this method, instead of storing every revision in a file as SCCS does, RCS stored a set of edit instructions to go back to an earlier version of the file.
The RCS was first released in 1982 by Walter F. Tichy.
Tichy claims that the use of reverse deltas is faster for most cases because the recent revisions are used more often. [5]
The practice of delta-storage became mainstream in the 1980s with Revision Control System (RCS), but the whole process still used the analogy of the file being the unit of work, as if it were a technical drawing. [5]
The idea of being able to deal with a lot of files at once took a long time to catch on, as did having more than one person working on a file at the same time. [4]
The 90s
Concurrent Versions Systems (CVS)
Concurrent Versions System (CVS, also known as the Concurrent Versioning System) is a revision control system originally developed by Dick Grune in July 1986.
CVS operates as a front end to RCS, an earlier system that operates on single files. It expands upon RCS by adding support for repository-level change tracking, and a client-server model. [6]
The 2000s
Subversion
Although Concurrent Versions Systems (CVS) was the first to break free from the idea of locking out the file to work on it, it was unreliable until the introduction of Subversion.
Even now, it is only too easy for the version control system to fail to sort out the merging of two simultaneous alterations of a version file, and ‘merge failure’ is still a phrase dreaded by most developers. [3]
By 2006 or so, Subversion was considered being the most popular and widely in use version control tool from this generation and filled important weaknesses of CVS. [5]
The Late 2000s
Up to this point, the source code was maintained in a single central master repository. Source code was checked out from that master repository, and commits were made back into that master repository.
Every commit, every reversion, every merge required network connectivity to the master. [1]
As Internet connectivity improved and geographically distributed software development became more common, tools emerged that did not rely on a shared central project repository. These allow users to maintain independent repositories (or forks) of a project and communicate revisions via change-sets. [5]
Git
Git keeps the entire history of the source code on your local machine. On your machine, you can do anything you could do with a centralized system like Subversion — except you don’t need to be connected to some central server.
Git was programmed by Linus Torvalds in 2005. [8]
Any time you like, you can connect to another user and push any of the changes you’ve made to that user. Or you can pull any changes they have made into your local repository. Neither is master. Both are equal. That’s why they call it peer-to-peer. [2]
Categorization of Version Control Systems
We can categorize the version control systems into 3 different categories. [9]
First Generation
The first-generation version control systems track changes for individual files. The checked-out files could only be edited locally by one user at a time.
- SCCS (Source Code Control System)
- RCS (Revision Control System)
Second Generation
The second-generation version control systems introduced networking which led to centralized repositories that contained the ‘official’ versions of their projects.
- CVS (Concurrent Versions System)
- SVN (Apache Subversion)
- Perforce Helix Core
Third Generation
The third generation comprises the distributed version control systems.
In distributed version control systems, all copies of the repository are created equal — there is no central copy of the repository. As mentioned in Git, the distributed nature opens the path for commits, branches, and merges to be created locally without network access and pushed to other repositories as needed.
- Git
- Mercurial
- BitKeeper
- Darcs (Darcs Advanced Revision Control System)
- Monotone
- Bazaar
- Fossil
- Pijul
References
[1] Atlassian, “What is version control | Atlassian Git Tutorial,” Atlassian, 2022. https://www.atlassian.com/git/tutorials/what-is-version-control (accessed Feb. 06, 2022).
[2] Chapter 13. Integrity, “Chapter 13. Integrity,” O’Reilly Online Learning, 2022. https://learning.oreilly.com/library/view/clean-craftsmanship-disciplines/9780136915805/ch13.xhtml#ch13lev1sec1 (accessed Feb. 01, 2022).
[3] Red, “A brief history of version control | Redgate,” Redgate, Nov. 07, 2016. https://www.red-gate.com/blog/database-devops/history-of-version-control (accessed Feb. 01, 2022).
[4] Wikipedia Contributors, “Source Code Control System,” Wikipedia, Jan. 07, 2022. https://en.wikipedia.org/wiki/Source_Code_Control_System (accessed Feb. 06, 2022).
[5] Wikipedia Contributors, “Revision Control System,” Wikipedia, Jan. 13, 2022. https://en.wikipedia.org/wiki/Revision_Control_System (accessed Feb. 06, 2022).
[6] Wikipedia Contributors, “Concurrent Versions System,” Wikipedia, Dec. 29, 2021. https://en.wikipedia.org/wiki/Concurrent_Versions_System (accessed Feb. 06, 2022).
[7] Wikipedia Contributors, “Apache Subversion,” Wikipedia, Nov. 23, 2021. https://en.wikipedia.org/wiki/Apache_Subversion (accessed Feb. 06, 2022).
[8] Wikipedia Contributors, “Git,” Wikipedia, Feb. 07, 2022. https://en.wikipedia.org/wiki/Git (accessed Feb. 07, 2022).
[9] J. Stopak, “The Evolution of Version Control System (VCS) Internals,” Initial Commit, Nov. 30, 2019. https://initialcommit.com/blog/Technical-Guide-VCS-Internals (accessed Feb. 13, 2022).