Version Control History

Enjoy comparing the history of the version control systems with the history of war birds.

Plastic SCM War bird
The history of war birds is truly awesome, like the history of version control software. That's why we use airplanes as an inspiration to visualize the many version control systems throughout the years. This is an ongoing work and you can contribute adding comments and voting for the ones you've used.
Version control systems are the backbone of the software development process (including the continuous delivery pipeline). As such, many have been created and evolved through the years and many are still alive decades after being initially released As one of the core development tools, version control software is hated or loved by developers and they are the fire behind many passionate flame wars. As version control developers, we share the passion for this kind of software and a willingness to learn more about its history. That's why we have created this site and we hope you enjoy it as much as we do.

The beginnings

There was a time when you stored your versions manually. Ok, for many of you this time wasn't the 70s, but a few years back when you were at college naming your source-code archives exercise.zip, exercise-0.zip, exercise-good.zip, exercise-good-final.zip, and so on. Well, believe it or not, there was a time without real SCMs. It was always dark and people were living in caves.

Biplanes the first war birds

Two wings

World War II

From the 1st jet fighters to the 3rd generation

In the 1945-1955 period, the first jet fighters were born: the MIG 15 and F-86 Sabres ruled the air.

Later came the F-4 Phantom with incredible improvements over the previous generations.

In version control, we included some legendary systems but the one who deserves to play the F-4 role is certainly ClearCase, a big step ahead from any previous system and still able to fly quite fast although not a contender for modern version control systems anymore.

4th generation jet fighters

The 4th gen of fighter jets included a sensible number of legendary war birds: the F-14 and F-15 belong here and were designed back in the 70s.

In version control, we include some systems that evolved through the 90s and some quite recent creations that are a little bit ‘outdated’ in terms of pure version control features.

4.5th generation jet fighters

The jet fighters active during the 80s (based on designs from the 70s) were upgraded during the 90s with new avionics based on the new microcontrollers. These upgraded jet fighters were known as the 4.5th generation.

In version control, we included here the version control systems that were clearly better than the previous file based generation in terms of underlying technology but which didn't 'cross the chasm' to become part of the mainstream distributed version control age.

5th generation jet fighters

In 2005, the version control status quo was broken. A new age of version control was born, the distributed version control systems lead by Linus Torvalds with Git.

DVCS was not only about being disconnected but about using fast and reliable merging (saying good bye to the preceding dark age of Subversion).

GitHub (2008) turned Git into a social network for programmers and nowadays is very strange not to find version control related stories on top programming news sites on a daily basis.

The open source world moved to DVCS first (all major oss projects abandoned SVN in the 2008-2010 period) and now the enterprise is catching up.

Next Generation

Aurora project

Version control is in constant evolution as a core piece of modern development practices such as Continuous Delivery and Agile Development.

It is not easy to figure out what is going to be next in version control, only 10 years ago it wouldn't have been easy to find that DVCS was going to be the next big thing.

But, as version control developers ourselves, there are some important steps ahead that we envision:

  • Going Semantic: we already started the trip towards semantic version control with www.semanticmerge.com. Understanding the code structure to merge files (and diff) is something developers have been asking for, and we believe it will be great to boost refactoring and code quality. Maybe it will become part of our daily workflow (see semantic history) and there won't be way back, like code completion :P
  • Extracting valuable information from the version control to assist the developer while coding: annotate while you edit is not new, knowing whether a block of code has been involved in many modifications or not, or if it is buggy, or if it was modified by many people will let you make more informed decisions. Version control is not just a delivery mechanism (checkin and that's all) but a productivity tool for the programmer, something that stores valuable data that properly mined can be really helpful.
  • Enterprise level DVCS: finally eradicating arcane working patterns like pessimistic locking, enabling flexible collaboration among distributed teams while still adhering to the required regulations and security policies required by enterprises.
  • Better visualization tools: to make easier to understand changes, branching and merging, to track fixes and new features.
  • And of course, even better performance and revisited usability.