The Pendrive Dilemma: Why We Need Version Control Systems

Introduction

When I started learning programming, I did not know anything about version control.
I used to save my projects in folders, copy them to a pendrive, or send them to myself on WhatsApp or email.

At that time, it felt normal.

But very soon, things started going wrong.

In this blog, I will explain why version control exists by using a very common and relatable example called the pendrive problem. I will also talk about how developers struggled to manage their code before tools like Git existed.

Why Version Control Exists

Version control exists to manage changes in code over time.

In software development:

• Code changes frequently

• Multiple people work on the same files

• Mistakes happen

• Old versions are sometimes needed again

Without version control, managing all this becomes messy, confusing, and risky.

Before tools like Git, developers had to rely on manual methods, and that’s where the problems began.

The Pendrive Analogy in Software Development

Before version control systems, developers often shared code using:

• Pendrives

• Emails

• ZIP files

• Messaging apps

• Shared folders

A typical workflow looked like this:

1. Developer A writes code and saves it

2. Copies the project to a pendrive

3. Gives the pendrive to Developer B

4. Developer B makes changes

5. Sends it back

Sounds simple, but in reality it caused many issues.

The final folder problem

Many developers had folders like:

• project

• project_final

• project_final_v2

• project_final_latest

• project_final_latest_fixed

No one was sure:

• Which one was the real final version

• What changed between versions

• Who changed what and when

This is known as the pendrive problem.

Problems Faced Before Version Control Systems

Overwriting Code

If two developers worked on the same file:

• One person's changes could overwrite the other's

• There was no easy way to merge changes

Once overwritten, the old code was usually lost forever.

Losing Previous Versions

If a new change introduced a bug:

• There was no clean way to go back

• Developers had to search old folders or emails

• Sometimes the working version was gone

No History of Changes

Without version control:

• No record of who changed what

• No timeline of changes

• No explanation of why a change was made

Debugging became very difficult.

No Team Collaboration

Working in a team was painful:

• Only one person could work at a time

• Code sharing was slow

• Conflicts were common

As teams grew, this approach completely failed.

Pendrive Workflow vs Version Control Workflow

Pendrive-based workflow:

• Manual copying

• No history

• High risk of data loss

• Poor collaboration

Version control workflow:

• Automatic tracking

• Complete history

• Safe collaboration

• Easy rollback

Why Version Control Became Mandatory

As software projects became:

• Larger

• More complex

• Team-based

Manual methods stopped working.

Version control systems were created to:

• Track every change

• Prevent data loss

• Allow multiple developers to work together

• Maintain a clean history of the project

That's why today, version control is not optional.
It is a basic requirement for modern software development.

Transition to Git

The problems of pendrives, emails, and final_final folders led to the creation of proper tools.

One of the most popular and powerful tools is Git.

Git solves:

• The pendrive problem

• The collaboration problem

• The version history problem

In the next blog, I will explain what Git is, how it works, and how beginners can start using it step by step.