Let’s come to our main point of this blog. Why did even version control (don’t worry, I will explain it in the next blog if you don’t know it yet—assume it is like a collaboration platform) come into existence? Like, many developers know how to use Git and GitHub, like, "Here are the commands, and here go my project files," but why do we even use it?? Let’s understand it by a story.

The Pendrive Story

Raj and Ishu are 2 collegemates. In their 5th semester they are assigned a group project which they have to submit. They now encounter a challenge in front of them, none of them can bring their laptop to the college to work together. Raj brings up a solution, He will zip up the code, put it in the pendrive and then give it to Ishu, he can work upon the project and return it to Raj hence in a way both can work on the project. But several problems occurred when they implemented this method-

• First of all only 1 person could work on the project at a time. When Raj was working, Ishu had to wait until Pendrive was handed over to him. Same with Raj hence in a way there was no “group” in this group project, rather 2 individuals working one by one.

• Second it used to take huge amount of time to understand what changes the other person has done, what functionalities he has added, what bugs he had removed and how to merge the own idea into existing codebase.

• There was no responsibility when they used to encounter bugs or problems, once used to blame the other that he wrote the code or he made the changes into it. This used to result in ugly fights and bad communication.

• At times, due to ego clash Raj used to rewrite the whole code written by Ishu just he had smaller disagreements or fights over the project. Ishu lost his hard work just because of heat of the moment. There was no mechanism of recoverability.

In a case if Raj encounters a bug with his code after he had given the pendrive to Ishu, he will either have to explain it or wait for the pendrive. If he will make changes in its own copy, the bug would not get fixed.

ENTER THE HERO:VERSION CONTROL

Raj and Ishu thought this problem was unique

Multiply this setup by 10 people.
Then 100.
Then thousands of developers working on the same codebase.

Without structure, collaboration turns into chaos. And chaos doesn’t scale.

This is exactly the problem version control was designed to solve.

Linus Torvalds, Founder of Linux faced exactly these issues while building Linux. His project grew so big that he started Git , the most popular version control we know today as a side project :)

How does version control works?

In simple terms, Version control simply keeps tracks of what changes are being done in the file. Take this analogy- you have an old image and a new image of the same thing, you can easily tell the difference. In the same manner version control stores the differences. If a line is added, it is marked with a +.
If a line is removed, it is marked with a -.
This solves the problem of tracking. We can easily store what changes were made, by whom and when, which feature was added, and which bug was fixed.

However, this alone doesn’t fully solve the problem of collaboration. To make collaboration possible, we use a shared server where developers can sync their work. These servers are called Version Control System remotes (VCS remotes or simply remotes). GitHub, GitLab, and Mercurial are some of the most popular VCS remotes.

These remotes act as a final source of truth. Even if multiple copies of the same project exist on different machines, the version hosted on the remote is the one the team agrees on as the official state of the project.
So now we have tackled all the challenged faced during collaborating in a software project -

1. Changes can be easily tracked through git.

2. Both Raj and Ishu can work at the project at the same time. Raj can handle a sticky bug, while Ishu can test for the new feature.

3. No more fear of breaking the project
   With Git, every meaningful change is saved as a checkpoint.
   If Raj introduces a bug today, they can safely go back to a previous working version without rewriting anything.

4. Version control also provides recoverability, work is never lost even if somebody deletes it in anger or due to ego clash.

   

   What started as a pendrive being passed hand to hand was never really collaboration. It was just survival.

   Version control changes that completely. Now Raj and Ishu don’t wait on each other, don’t overwrite work in anger, and don’t lose weeks of effort because of one mistake. They work in parallel, track every change, and always have a way back.

   Git doesn’t just store code. It stores history, responsibility, and trust which is why in modern software development, version control isn’t optional. It’s mandatory.