Why GIT Exists: The Pendrive Problem

If you are a developer, you must already be aware of Git and GitHub. But do you know

• why Git was created?
• What problems existed before Git?
• And how was the world of coding managed before version control systems?

In this article, you’ll find answers to all these questions.

How Was the World of Coding Before Git?

Let’s go back in time and imagine a world without Git.

You are a developer working smoothly on a project. One day, you need help to develop a new feature, so you ask your developer friend, Rishi. Rishi agrees and asks for the code.

To share the code, you zip the project, copy it to a pendrive, and hand it over to him. Rishi develops the feature, zips the updated code along with the existing code, and returns the pendrive to you.

When you unzip the project, the first problem you notice is that there is a lot of code, and you have no idea which part was written by whom. Since the feature works fine, you ignore this issue and continue working with the updated code.

A few days later, you discover a bug in the feature your friend wrote. You ask Rishi to fix it. Once again, you copy the entire project to the pendrive and give it to him. He fixes the bug, patches the code, and returns the pendrive.

Now you know the code has changed — but you don’t know exactly what changed or where. To understand the modifications, you have to sit with your friend, discuss the changes line by line, and this takes time.

Another major issue is conflicts and wasted time. Sometimes, while fixing a bug, some important code gets modified or removed without your knowledge. As a result, you may have to debug the entire project again.

Problems Faced Before Git

By now, you can clearly see the problems developers faced:

• Code Sharing: Every time a feature needed to be developed or a bug needed fixing, the code had to be zipped and shared via a pendrive repeatedly.
• Difficult to Track Code Changes: You had no visibility into what changes your friend made or which files were modified.
• Hard to Collaborate: If multiple developers needed to work on the same project, tracking changes became almost impossible. Also, only one person could work at a time — the one who had the pendrive.

Thinking About a Solution

Now let’s think about solving these problems.

The first challenge is to track who made what changes. To solve this, imagine creating a software system that:

• Tracks code changes
• Stores the author of each change
• Shows differences between old and new code
• Maintains version history

This solution would address the first two problems: tracking changes and identifying contributors.

However, collaboration is still an issue. Only one developer can work at a time because the source code still exists in a single physical location.

To solve this, you think of creating a single source of truth for the code. You purchase a server, install this code-tracking system on it, and upload your entire project there.

Now, your friends can pull the code from the server, work independently, and push their changes back. Other developers can then pull the updated code from the same server.

This is exactly what Git (the code-tracking system) and GitHub (the hosted server) do.

The Birth of Git

Git was created by Linus Torvalds to manage the Linux project. As Linux grew larger day by day, tracking changes became extremely difficult. To solve this problem, Linus developed Git — a distributed version control system (VCS).

Alternatives to Git

• AWS CodeCommit
• Apache Subversion
• Unity Version Control
• Fossil
• Concurrent Versions System (CVS)

Alternatives to GitHub

• Bitbucket
• GitLab
• Gitea
• Codeberg

This was all about why Git was needed — the problems developers faced before version control systems and how Git solved those challenges. Understanding this background makes it much easier to appreciate Git’s power and importance in modern software development.

In the next article, we’ll dive into how Git actually works, explore its internal concepts, and take a closer look at the folder structure of the .git directory to understand what happens behind the scenes.