🎓 Git Introduction

What is Git?

Imagine you're writing a novel. By the time you reach Chapter 50, you suddenly feel that the ending you wrote in Chapter 3 was actually better and want to revert — but you've already changed it 8 times and can't remember what you originally wrote.

If only you had a "time machine" that lets you freely travel between any version... Well, Git is the time machine of the code world.

Git is a Distributed Version Control System (DVCS), created by Linus Torvalds, the father of Linux, in 2005. That's right, the same person who created Linux — and rumor has it he wrote the first version of Git in just about 10 days. We can only dream of being that brilliant.

💡 Tip: In simple terms: Git is a "save system" for your code. In a video game, you save your progress at each level — Git works the same way, except it saves your code and lets you return to any save point at any time.

Why not just "copy folders" to manage versions?

I know what you're thinking: why not just copy the folder and name them project_v1, project_v2, project_final, project_final_for_real, project_final_never_touching_again...

Don't laugh, I actually did this back in the day. What happened?

• My hard drive was stuffed with 20 nearly identical folders, running out of space
• Couldn't remember which version changed what
• Want to merge changes from two versions? Manually? Yeah right
• Collaborating with teammates? Sending zip files back and forth? Give me a break

Git elegantly solves all of this.

Centralized vs Distributed

Before Git, the mainstream version control systems were centralized, like SVN and CVS. They worked like a class sharing a single notebook:

📦 Centralized Version Control (e.g., SVN)

┌─────────────┐
│  Central Server  │  ← All version history lives here
└──────┬──────┘
       │ Network
  ┌────┼────┐
  │    │    │
  ▼    ▼    ▼
Alice  Bob  Charlie   ← Everyone only has the latest version

The problem is obvious: server goes down = everyone's work is gone. Network goes down = can't work.

🌐 Distributed Version Control (e.g., Git)

  ┌──────┐    ┌──────┐    ┌──────┐
  │ Alice │    │  Bob  │    │Charlie│
  │(Full  │    │(Full  │    │(Full  │
  │History)│←→ │History)│←→ │History)│
  └──────┘    └──────┘    └──────┘
  Everyone has the full repository! Works offline!

📝 Note: Remember this key difference: centralized systems store only "deltas" (differences), while Git stores "snapshots." Each commit is like taking a photograph, recording the complete state of all files at that moment. While this sounds like it takes more space, Git is smart — unchanged files are stored as pointers, so there's no duplication.

Snapshots vs Deltas

Comparison	Snapshots (Git)	Deltas (SVN/CVS)
Storage method	Saves complete snapshot per commit	Saves differences from previous version
Viewing history	Direct access, extremely fast	Requires rebuilding from the beginning
Branch cost	Nearly zero (just creates a pointer)	Needs to copy entire directory
Offline work	Fully supported	Not supported
Data integrity	SHA-1 hash verification	Relies on server

Git's Design Philosophy

Understanding these philosophies will make Git's command design feel very logical:

• Integrity first — Git uses SHA-1 hashes to identify everything; no change can go undetected
• Append-only — Git almost never deletes data; most operations just add new data
• Local-first — The vast majority of operations happen locally, making them blazing fast
• Three-state design — Modified, Staged, Committed (covered in detail later)