Why Version Control Exists

If you have done any kind of Software project in your life, you must have folders in your systems named like these:

project, project_modified, project_sam, project_latest, project_final

Then you already have some idea what this blog is about.

If you did not get it, the next section is especially for you.

Pendrive: One Man Army

I learned about the importance of Version Control in a very early age.

Year 2009, my uncle was in his final year in BTech. He had a few pen-drives in his collection, of various sizes. Some of ‘em contained media, some had important project files. I remembered he had a friend with whom he used to share one of his pen-drive with. It was a fancy looking one, 16GB stick. He explicitly forbed to touch that pen-drive out of all.

So one day, I touched and took the pen-drive and went to a gaming parlor to “load” the new GTA IV to it.

The transfer started, after a while I got an error of insufficient storage. Now you get where this is going.

I saw a file named “BMS_final.zip”, and I deleted it. Thank God I did not know shift + del back then.

My uncle got back his project file inside the recycle bin of a random PC inside the game parlor, but that was not enough to stop myself from getting smacked.

This story highlighted a grave issue of using Pendrives, a single point of failure.

And I got to know the other issues when I had to use it myself.

Me and my team was building a website. Areej works on the homepage, copies her changes to a pendrive, and emails it to Ankit. Ankit makes his updates, but his pendrive corrupts. Meanwhile, Priyanshu has been working on the same files for two days, unaware that Areej already modified them. When Priyanshu finally shares his version, Areej’s changes vanish into the void.

The pendrive, like a baton in a relay race, hurt parallel programming.

An alternative approach was by mail, but it did not fix versioning problems.

The problems were endless. Someone would overwrite someone else's work. Critical changes would disappear. Nobody knew who changed what, when, or why. If you needed to revert to last week's working version? Good luck finding it among 47 folders named variations of "final."

Collaboration Catastrophe

The real nightmare began when multiple developers touched the same file.

Imagine three people editing a recipe simultaneously, each with their own copy. One adds salt, another removes sugar, and the third changes the oven temperature. When you try to combine their work, you end up with a recipe that's simultaneously too salty, missing sugar, and has conflicting cooking instructions.

Developing software this way was just not inconvenient, it was counterproductive. Builds broke, bugs that resolved previously re-appeared in someone else’s overwrite, there was no history on who changed what, teams spent more time on managing files rather than actual development.

The Silent Guardian: Version Control

Version control systems emerged from this chaos as a fundamental answer: what if every change was tracked, every developer could work simultaneously, and you could travel back in time to any previous state of your code?

Modern Version Control Systems like Git became a watchful productivity protector and versioning moderator.

They track every changes, by a complete history of who, when, where and why.

They embrace collaboration where multiple developers can modify the same file without overwriting, or overwriting under developer’s sane control and supervision.

They provide instant rollback to a previous state if something breaks on the current state.

Code Reviews became easier than ever before merging a change into the main codebase.

VCS is not optional

Version Control is an integral part of Software Development. Even a solo developer uses it, because the real enemy is not other developers overwriting your code, it's forgetting what worked, losing track of changes, and having no safety net when things break.

Developers who are getting started in today’s era may not face the pendrive problem, or they may face it like us; in either case this blog is for them, to remind how Version Control transformed development from a chaotic relay race to a symphony where every note is preserved, every musician can be heard, and you can always replay the part that worked.