Why Version Control Exists: The Pendrive Problem

Version Control Systems(VCS) are tools which are used to track changes in a file or multiple files in a directory. It keeps a record of the changes applied on a file(s), who changed what and when, enables collaboration across teams.

Today VCS have become essential tools for development workflow. They make life super easy with their hallmark features for millions of developers around the world. But what about before? How was code tracked and managed? How did teams collaborate?

The Pendrive Analogy

Before the advent of lightning-fast internet and centralized servers, the primary way to move large amounts of data between devices was physical. Developer teams collaborated by manually locking files, shared code through pendrives, floppy disks, shared network drives, emails etc.

If you and I were building a website together in 1999, our workflow might look something like this:

1. I work on the homepage layout all morning on my desktop.

2. At lunchtime, I plug in a USB(pendrive), copy the project folder onto it.

3. I handover the USB to you(this physical transport of data was known as "Sneaker-net").

4. You plug the drive in, copy the files to your desktop, and start working on the news feed.

Sounds simple right? But it comes with significant problems.

What happens when realize I made a critical mistake in the morning after I already gave you the drive?
I can work on it provided that I have a copy on my machine, else I have no choice but to wait. Stuck.

Or what if I’ve already completed my tasks but the pendrive is being used someplace else? Stuck.

What happens when more developers are added?

Some Common Nightmares

1. The Final_Final_v3 Folder: Without a system to track changes over time, developers had to invent their own. Every developer’s desktop looked like a graveyard of abandoned progress:

   MyProject_v1
MyProject_v2_fixed_bug
MyProject_FINAL
MyProject_FINAL_REAL_v2
MyProject_PLEASE_WORK_THIS_TIME_v3
MyProject_God_Have_Mercy
   
   If something broke on Tuesday, and you needed to know what the code looked like last Friday, good luck. Good luck unzipping five different folders and manually comparing the code, line by line, trying to find what broke.

2. Overwriting: I give you the drive at noon.

   1:00 PM: You are busy styling the footer.
   1:30 PM: I realize I forgot something critical in the header. I open my local copy for correction.
   3:00 PM: You finish your work, put it on the pendrive, bring it back to me.
   3:05 PM: I copy the pendrive contents onto my device.

   My header fix from 1:30 PM is gone. Overwritten by your version, which was based on my old code from noon. Countless hours of work lost simply because the last save wiped out everyone else's contributions.

3. What Broke The Build?: Without version control, there is no history. If the application worked fine today but crashed a few hours later or tomorrow, there was no way to know who changed what file at what time. Meetings and brainstorming sessions can easily become finger pointing. Since there was no way to track changes, debugging meant blindly searching through the entire codebase hoping to spot the error.

4. Risk of Data Loss: Heavy reliance on pendrives to share code and collaborate across teams is risky and time consuming. In an event where the pendrive is damaged or corrupted and there is no local copy stored anywhere, countless hours of work goes to waste. A single hardware failure results in permanent loss of entire projects.

5. Manual Merging Madness: Before VCS tools, merging conflicting changes into one master file was a manual task. One needs to go through all the files, from the original to the changes applied on it, identify the differences line by line and resolve the issue. For example:

    //original function
    function calculateTotal(price, tax) {
        return price + tax;
    }
   

    function calculateTotal(price, tax, discount) { 
        return (price + tax) - discount; //my change
    }
   

    function calculateTotal(price, tax, shipping) { 
        return price + tax + shipping ; //your change
    }
   

   The maintainer has to go through all the files, see the changes and resolve them.

    function calculateTotal(price, tax, discount, shipping) { 
        return (price + tax + shipping) - discount;
    }
   

6. Unsecured Communication: Sharing code through email isn’t a good practice either. There are no safeguards for data integrity, privacy, verification or ownership. By default emails are unencrypted i.e. often sent in plain text. Once sent, the sender loses access control; the receiver can potentially send the code to unauthorized third parties or store them privately. And while email serves as a record, it is unverifiable. Modern VCS systems have GPG signing to verify who changed what and when.

Transition to VCS

As software became more complex and teams grew from two people in a garage to hundreds of engineers, sneaker-net became unsustainable. The friction of manual management was costing companies millions in lost time and buggy releases. Gradually, various solutions surfaced to solve this.

Source Code Control System (SCCS, 1973) and Revision Control System (RCS, 1982) were two early file based VCS designed to track changes in text files. They were succeeded by centralized VCS like CVC, SVN, Perforce etc. Eventually distributed tools came into the picture like Git, Mercurial, Bazaar etc.

Version Control Systems introduced concepts that transformed how things work:

• History: VCS records snapshots of the project over time. You no longer need final_v2 folders. You have one folder, and you can scroll back through time to see exactly what it looked like yesterday, last week, or last year.(Those who forget history are condemned to repeat it💀)

• Safety Net: Modern VCS is smart. If you change line 10 and I change line 50 of the same file, the system merges them together automatically. If we both change line 10, it stops and generates an alert that a conflict has risen, and to resolve it before proceeding. Nothing gets accidentally wiped out.

• Audit Trail: Every single line of code is tagged with the name of the author and the exact second it was written. This brings accountability and it's crucial for understanding why a piece of code was written that way in the first place.

Conclusion

Things were irritating and a costly mess before the advent of VCS. Manual Version Control was inefficient and unsustainable in the long run. Modern Version Control Systems have transformed development workflows; made collaboration across teams easier, faster and more efficient.

The next time you type git commit and feel annoyed by having to write a commit message, take a moment to appreciate it.