The Pendrive to git (Version Control)

Before Git, before SVN, before any fancy version control system, how did people work on code together ? if you are worked with lot of shared documents, or even just your family photos you've probably faced what I like to call the "Pendrive Problem."

Before git….

In the "Pre-Git" era, managing code was less about logic and more about inventory management. Without a central brain to track changes, developers had to rely on manual, physical, and often chaotic methods to keep their projects alive. like developers used pendrives, emails, and folders like final, final_v2, latest_final

1. The Folder problem:

Developers saved multiple copies of the same project by renaming folders like:
project_final project_final_v2 project_final_v2_REAL project_final_v2_REAL_LATEST
so the problem is that ,after some time of working developers would have no idea what the difference was between REAL and LATEST. If a bug appeared in the "latest" version, you’d have to manually open old folders and compare files side-by-side to find where you went wrong.

2. Pendrive sharing problem:

In teams, code was shared using pendrives.

• One developer copied the project to a pendrive

• Gave it to another developer

• The second developer copied it to their system

If both edited the same file, one person’s work was lost.
There was no merging—only overwriting.

3. Email attachments problem:

For remote teams, code was sent by email as ZIP files.

• Multiple versions arrived in different emails

• Developers had to manually combine code

• Mistakes were common, and bugs were hard to trace

to solve all these problems GIT →The Version Control System is developed.

Version Control became Necessary

This manual way of working failed because humans are forgetful and "Latest" is a lie. Modern development moved to Version Control (like Git) because it replaced memory with automation:

• No more folders: You have one folder, but it contains a "hidden history" you can jump back into.

• No more overwriting: Git notices if two people changed the same line and forces them to "merge" instead of delete.

• No more mystery: Every change has a name, a date, and a reason attached to it.

Conclusion

The biggest difference between the Pendrive era and the Git era isn't just technology—it’s trust.

• Then (The Pendrive): You worked in a state of constant fear. Fear of hitting "Save," fear of deleting a folder, and fear of your teammate’s "final_v2" email. Collaboration was a game of Russian Roulette where the bullet was an overwritten file.

• Now (Version Control): You work with total freedom. You can experiment, break things, and delete entire files knowing that nothing is ever truly lost. Git remembers so you don't have to.

In short: We didn’t just switch to Version Control to manage code; we switched to manage our sanity. The .git folder might look like a bunch of mystery files, but it's actually a time machine that killed the "Final_v2_LATEST" nightmare for good.