The History of Version Control — LayerVault Blog
LayerVault Simple version control for designers. Try it free.

The History of Version Control

Whenever developing a new take on an old subject, it pays to know your roots. You can only take a step forward if you know where you’ve been. At LayerVault, we care very deeply about the idea of version control for designers, as well as some of the shortcomings of that phrase.

The idea of version control is not new. The theory now is the same as it has always been: keep track of how a document has changed over time, and who changed it. It is sometimes just as important as what the document itself contains.

Documents and ledgers have been crucial to modern industry. Who owns what and what do we agree to be true. It pays to have a safety net, a place to return when things go south. Thus, version control existed long before programmers gave it a name and a suite of tools.

This blog post will discuss the history of version control in the obvious and less-than-obvious places, and where we think it’s headed.

Before Software

Although there were probably different copies of cuneiform tablets, we’ll keep this post scoped to the 20th and 21st centuries. In the 20th century, keeping a history of a document was usually done through carbon copies or rote copying. After the introduction of the Xerox 914 in 1959, this process became much easier. The storage mechanism was always the same: a filing cabinet.

In the case of publishing, these documents were separated into drafts and the final product. In the case of a republishing, you would create a new edition. If one were to collect all of these, you could be able to see an author’s subtly changing perceptions over time.

Around the same time, some sectors were wont to discard past copies for legal reasons. In public accounting, for example, a paper trail of draft audit workpapers was seen as a potential liability. When an audit was complete, the only documents that existed were the final workpapers. Contrast this with banking and insurance industries, where it was incredibly important to keep a full record of document drafts and who made which edit.

The Beginning of Computer-Aided Version Control

Manually keeping full records of every past document did not seem sensible. As computer software became more and more complex inside places like like Bell Labs, IBM, and Xerox, the need arose for simple way of recording the changes to source code files. Thus, Marc Rochkind developed the Source Code Control System (SCCS) at Bell Labs in 1972.

When just a single character difference can result in a program compiling or not, tracking changes byte-by-byte was incredibly important to the nascent software industry. As with any promising new technology, it becomes the new norm and later “not good enough.”

Years later, Walter Tichy developed the Revision Control System (RCS) while at Purdue University. It provided the technological foundation for CVS, one of the major open-source version control systems.

Although byte-level accuracy of changes was important in early systems, there was another important factor: space. Maintaining many sets of nearly identical files can eat up hard drives quickly. Space was extremely expensive. Now, universities use these old hard drives as doorstops. (They are about the size and weight of 8 bricks.) Thus, maintaining a history of your work only made sense if it could also be done in a space-efficient way.

The Evolution of Computer-Aided Version Control

Since then, version control for code has improved by leaps and bounds. The introductions of Subversion, Perforce, git, Mercurial, and many others improved a programmer’s ability to track changes to source files over time.

Each iteration in version control also made the concept of working with others easier, both through interfaces and new technology. The interface of a “branch” allows a programmer to isolate her work from the “trunk” of the canonical history. A branch is an effective, safe test bed for new work.

So too has the technology improved. Smarter algorithms around merging source files have lessened the inherent friction in collaboration.

Over time, the version control systems became good enough to become central to software development itself. The credit for this goes squarely to GitHub. Started by four friends in 2008, GitHub pioneered the idea of “social coding.” But they have advanced the idea of version control beyond just version tracking and collaboration: they have made version control central to how software is developed, tested, and deployed.

Using a system like GitHub, continuous integration and continues development becomes easier by an order of magnitude. They have made the git tool crucial to starting any software project, no matter how large or small.

Version Control for the Rest of Us

In parallel to the advances of version control for software developers, a few ideas leaked into more consumer settings. Microsoft Word 2007 introduced the idea of tracked changes. Google Docs likewise has a robust revision history on each document.

Finally, version control has also been introduced at the file level through a few consumer-facing products. Apple introduced Time Machine with OS X Leopard in 2007, and now defaults to tracking different versions of files with many applications. Dropbox, Box, and other cloud syncing services also allow limited tracking of history for files as well.

A typical software developer might not consider these applications of version control: they are too simple. It’s true in a purely technical sense. All of these implementations take a highly linear approach to a document’s history. The result, however, is good enough for that industry.

Version control in any context helps the author tell her story. Watching something evolve over time often eliminates confusion. It makes the conversation around the finished product much more productive. Most importantly, it instantly establishes trust among everyone invested.

The Next Evolution in Version Control

The next evolution in version control is to bring the idea to the masses. The tools for versioning software are good enough for a large majority of the users. The real value is building on top of this technology, much like GitHub has. Kryder’s Law (the storage-related sibling to Moore’s Law) has made the financial viability of version control for larger files a reality.

That is what we are trying to do at LayerVault: apply this history of collective learning to designers. The team over at Splice is doing it for musicians. Before we can run, we need to walk. Figuring out what version control looks like for musicians, designers, lawyers, doctors, and more must be the focus. In most applications, the result will be more linear than graphical. That is to say, merely recording the history of files over time will suffice rather than worrying about how to merge different sets of work.

Once each industry has its version of SCCS or RCS, then we can begin to run. What type of value you can introduce once you know the entire history of every file? What are some simple things that become immensely valuable? For LayerVault customers, having discussions around files over time is just that. Leaving comments on files is nothing new, but having discussions tied to the evolution of work is powerful. It eliminates confusion and makes each conversation more productive.

The next evolution in version control won’t look much like it has for software. Different industries have different programs, and the solutions must be built with those in mind. Splice works with Ableton Live, FL Studio, and Logic Pro. LayerVault works with Photoshop, Sketch, Illustrator, and more. The next evolution has a strong network component where the entire history is constantly at your fingertips. The next evolution has an extremely simple interface, where you are building a history without any extra effort.

This is what’s most exciting: marrying this technical power with the creative process. Version control is both a safety harness and a supercharger for creators. When a designer no longer needs to fear that any idea could be lost, it becomes much easier to explore all avenues. Both the quantity and the quality of work improves drastically.

Whatever happens, one thing is for sure: the next evolution will be tracked.

Thank you for reading. If you are interested in trying out LayerVault, it’s free for the first 30 days. Splice is free as well.

Although we primarily track design files, we also track some text documents. You can see this article evolve over time on this LayerVault page.

If you want to discuss this article, you can do so on Designer News.

  1. opexxx reblogged this from layervault
  2. kleptomaniacskeptic-blog reblogged this from layervault and added:
    Well, that’s pretty awesome. Source control is really useful
  3. machinedog reblogged this from layervault
  4. lauraelizabethphelps-blog reblogged this from layervault
  5. hugomano reblogged this from layervault
  6. upning reblogged this from layervault
  7. kellysutton-blog reblogged this from layervault and added:
    I nerded out a bit on the company blog.
  8. layervault posted this