History of Version Control Systems

The history of source code control becoming version control

Photo by Noah Howard on Unsplash

Version control, also known as source control, is the practice of tracking and managing changes to software code. [1]

As programmers, we all use version control systems. The transition from source code control systems to version control systems can be better understood once we understand the history of the source code control systems. Therefore, to make the transition clear, here in this article, I would like to review the history of the source code control systems.

The 50s and 60s

Punch cards [2]

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

A bulletin board [2]

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

PDP-11 By Living Computers

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]


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

Photo by Lorenzo Herrera on Unsplash

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

Photo by v2osk on Unsplash

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

Photo by Tim Swaan on Unsplash


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

Photo by Robert Lukeman on Unsplash

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 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


[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).

Leave a Reply

Your email address will not be published. Required fields are marked *