Why We Need Git

Lesson information

• Section: Git and GitHub
• Lesson: 1
• Duration: 8m 20s

Key concepts

• What version control means
• Problems with manual file copies
• Tracking changes
• Collaboration between developers

What Goes Wrong Without Git

Before Git, developers often managed different versions of a project by manually copying files and creating folders with names such as:

• project-final
• project-final-v2
• project-final-fixed
• project-final-really-fixed

This approach quickly becomes confusing and unreliable, especially when several developers are working on the same project.

Git exists to replace this chaos with a tracked, organized, and reversible history of changes.

1. Overwrite Risk

Someone’s work can disappear because of an incorrect copy-and-paste operation or because another developer replaces the same file.

Without version control, recovering the overwritten work may be difficult or even impossible.

2. No Single Source of Truth

A team may have several copies of the project, and every copy may be described as the “final” version.

This creates an important question: which version is correct, and which one should be released?

Git gives the team one shared and reliable source of truth.

3. No Change History

Manual file copies do not clearly show:

• What was changed?
• Who changed it?
• When was it changed?
• Why was it changed?

Git records the project’s history and allows developers to understand how the code evolved over time.

4. Fragile Backups

Creating manual backup copies may work for a small personal project, but it does not scale when working with a team.

Copies can be lost, become outdated, or contain conflicting changes. Git provides a structured and dependable way to preserve the project history.

The Role of Git

Git helps developers track every change, protect their work, collaborate safely, and return to an earlier version whenever necessary.

The Solution: A Version Control System (VCS)

A Version Control System, commonly abbreviated as VCS, is a tool used in software development and collaborative projects to track and manage changes made to source code.

Instead of creating separate manual copies such as V1, V2, and V3, a version control system stores the project’s changes in an organized history.

A Version Control System allows developers to:

• Track changes made to the source code.
• Keep a history of different project versions.
• Identify who made each change.
• Understand when and why a change was made.
• Return to an earlier version when necessary.
• Collaborate without overwriting each other’s work.

You guessed it!

Git is a distributed version control system.

Git is not the only version control system, but it is the most widely used version control system in modern software development.

What Does “Distributed” Mean?

“Distributed” means that every developer has a complete copy of the repository on their own computer, including the project files and the full history of changes.

This allows developers to work locally, create commits, and review previous changes without needing a permanent connection to a central server.

Save Points for Your Code

Git commits are similar to checkpoints in a video game.

In a game, you save your progress at different checkpoints. You can continue playing, and if something goes wrong, you can return to the last saved checkpoint instead of restarting the entire game.

Git applies the same idea to source code. Each commit acts as a save point that records the project at a specific moment.

Think of Git Like a Game

If a boss fight goes wrong, you reload the last checkpoint—you do not restart the entire game.

The same idea applies to code: a commit is a save point that you can return to when necessary.

Example Development Timeline

1. Start

   Empty project

   The project has just been created.

2. Checkpoint

   Login works

   The login feature is complete and saved in a commit.

3. Checkpoint

   Dark theme added

   The dark theme is complete and saved in another commit.

4. You Are Here Now

   Still coding

   The developer is currently working on new changes.

If the current changes cause a problem, the developer can return to checkpoint 2 or checkpoint 3 without losing the earlier, working versions of the project.

What Is a Commit?

A commit is a saved snapshot of the project at a specific point in time.

Each commit contains the changes that were recorded at that moment, along with a message explaining what was changed.

Commits allow developers to:

• Save meaningful stages of their work.
• Review previously recorded changes.
• Compare different versions of the project.
• Return to an earlier stable version.
• Understand how the project developed over time.

A commit is not the same as saving a file with Ctrl + S.

Ctrl + S saves the current file on your computer, while a Git commit records a meaningful version of the project in Git’s history.