The Minds Behind Version Control Systems – 7 People Redefining Software

TL;DR

Version control evolved from tracking revisions of individual files to coordinating teams and finally to fully distributed development. Tichy created RCS; Grune and Berliner evolved the CVS model; McVoy pushed replicated distributed source control through BitKeeper; Torvalds created Git; Hamano matured it; Mackall independently created Mercurial.^[1][4][6]

Why you should read it anyway

Version control is the memory of software development. It answers who changed what, lets teams work simultaneously, enables experiments on branches, restores older states, and provides the audit trail through which large projects understand themselves.

Imagine where Version Control Systems would be without them

Without these systems, software teams would rely longer on manual file copies, centralized locks, emailed patches, and ad hoc release directories. Open-source collaboration across continents would be slower, and large-scale parallel development would require more managerial coordination to avoid overwriting work.

Time Estimate of how many years we would be hindered without them for human progress

Editorial counterfactual estimate: 5–10 years. Revision history is an unavoidable need, but each architectural jump—from file versioning to project repositories to distributed graphs—removed a major coordination bottleneck.

The 7 people behind Version Control Systems

1. Dick Grune

Why they matter: Grune created the original CVS as shell scripts layered on top of RCS and published them in 1986. GNU’s CVS manual states that although the current code no longer contains those scripts, many of CVS’s conflict-resolution ideas came from them.^[2] His contribution shifted version control from isolated file histories toward coordinated work across a collection of project files.

2. Walter Tichy

Why they matter: Tichy created RCS, the Revision Control System, in the early 1980s. The Mercurial history describes RCS as a major predecessor to CVS and later systems.^[1] RCS stored revision deltas and made version history a normal part of software development, but it remained primarily file-oriented and local, creating the problem space CVS later expanded.

3. Brian Berliner

Why they matter: Berliner designed and coded the C implementation of CVS in 1989. GNU’s own manual explicitly credits him with that rewrite and later module/vendor-branch design work by Jeff Polk.^[2][7] Berliner transformed Grune’s prototype model into a production-quality centralized system used by many major open-source projects.

4. Larry McVoy

Why they matter: McVoy built BitKeeper after earlier work on replicated source management at Sun. The BitKeeper repository describes it as an early widely used distributed source-control system and explains McVoy’s goal of giving Linux a tool that could handle decentralized kernel development.^[3] BitKeeper’s ideas strongly influenced the requirements Torvalds later set for Git.

5. Linus Torvalds

Why they matter: Torvalds created Git in 2005 after the Linux kernel project lost free access to BitKeeper. Git’s official history lists his core requirements: speed, simple design, distributed operation, nonlinear branching, and the ability to handle Linux-scale development.^[4] His contribution was to treat version control as a content-addressed distributed data system rather than a centralized file-history service.

6. Junio Hamano

Why they matter: Hamano took over Git maintainership shortly after its creation and turned the early kernel-focused tool into a mature general-purpose system. Git project history records his long-running maintainer role.^[5] His contribution is sustained evolution: reviewing thousands of changes while keeping compatibility, performance, and project governance coherent.

7. Matt Mackall

Why they matter: Mackall created Mercurial in 2005 as another distributed system designed for very large projects. Early Mercurial release announcements signed by Mackall describe its scalable distributed design, append-only history, fast network operations, and compact Python implementation.^[6] Mercurial demonstrated that the DVCS transition was larger than Git alone.

How they each differ from one another

Tichy focused on revisioned files; Grune extended that model toward projects; Berliner engineered CVS into a practical centralized tool; McVoy explored distributed replication; Torvalds created Git’s content-addressed DVCS design; Hamano stabilized and expanded Git; Mackall built a parallel DVCS lineage in Mercurial. Each generation changed the unit of collaboration.

Final Take

Version control became more powerful as it moved closer to the structure of software development itself. Programs are not one file, teams do not make one change at a time, and developers are not always online. Modern DVCS tools reflect those realities by treating history as a graph that every participant can possess and extend.

RESEARCH / PROVENANCE

Works Cited

7 SOURCES

1. 01
   Mercurial — Definitive Guide: A Brief History of Revision Control ↗book.mercurial-scm.org
2. 02
   GNU CVS Manual — What is CVS? ↗gnu.org
3. 03
   BitKeeper — Source Repository ↗github.com
4. 04
   Git — A Short History of Git ↗git-scm.com
5. 05
   Git Rev News — Junio Hamano Maintainer History ↗git.github.io
6. 06
   Mercurial Mailing List — Mercurial 0.6b ↗lists.mercurial-scm.org
7. 07
   GNU CVS Manual — CVS History ↗gnu.org

CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.