What is version control?
Summary: a version control system (VCS) is software that records every modification of a set of files, lets you return to any past version, and tells you who did what and why. This lesson gives the precise definition, useful analogies, and traces the evolution across three generations.
1. The definition in one sentence
A version control system is a tool that tracks the evolution of a project over time, recording every change along with its author, its date and its reason.
It is not just a backup. It is a dated, signed journal of everything that happened in a project, ready to be exploited at will.
2. Three analogies to picture it well
Analogy 1 · A photo at every step
Imagine you take a photo of all your code after every important change. Those photos form a comic strip of the project.
Each photo is complete (the whole project), but Git is smart: it only stores the differences from the previous photo. On disk, it stays light.
Analogy 2 · The time machine
A VCS turns your project into a time machine.
You do not start from scratch. You restart from a known state that worked, and apply the fix from there.
Analogy 3 · Wikipedia
Every Wikipedia article has a "History" tab. There you see:
- Who changed what.
- On which date.
- A reason (the edit summary).
- The ability to revert to an earlier version in one click.
A VCS does exactly that, for code.
3. What a VCS actually records
At each save point (called a commit), the system stores:
| Element | Example |
|---|---|
| Modified files | app.js, README.md |
| Lines added / removed | +12 lines, −4 lines |
| Author | Alice Martin <[email protected]> |
| Exact date and time | 2025-03-14 09:47:22 |
| Commit message | "Fix email validation" |
| Unique identifier | a1b2c3d4… (cryptographic fingerprint) |
That unique identifier guarantees that the version cannot be modified silently: if a single character changes, the identifier changes too. This is what makes Git tamper-proof.
4. A bit of history: the three generations of VCS
Version control was not born with Git. Here are the three big steps.
Generation 1 · Local (1970s–80s)
SCCS (1972), then RCS (1982). Versioning lives only on your disk.
Simple, but dangerous: one disk failure = the whole project and its history evaporated. And no collaboration possible: everyone has their own isolated history.
Generation 2 · Centralized (1990s–2000s)
CVS (1990), then Subversion / SVN (2000). A single central server stores the project's truth. Each developer downloads the latest version and sends their changes back to the server.
That was real progress — remote collaboration became possible. But two limits:
- No fault tolerance: server down = team at a standstill.
- No offline commits: on the train, at home without network, impossible to record an intermediate step.
Generation 3 · Distributed (since 2005)
Git (2005, created by Linus Torvalds for the Linux kernel), and its cousin Mercurial. Every developer holds a complete copy of the project, with its entire history.
This is the model that won. The advantages:
- The server can go down: every machine holds the whole project and its history.
- You can work without a network: train, plane, internet outage.
- Synchronizing with the team is voluntary, not forced at every save.
5. Why "distribution" changed everything
The difference between centralized and distributed is not just technical — it is cultural.
| Aspect | Centralized (SVN) | Distributed (Git) |
|---|---|---|
| Recording a change | Requires the network | Local, instant |
| Creating a branch to experiment | Costly, rarely done | Free, ~1 second |
| Merging two ideas | Painful | Guided by the tool |
| Contributing to an unknown project | Requires a server account | Just download a folder |
| Losing the server | Catastrophe | No impact |
It is that culture of lightness (branch, test, throw away, redo, without fear) that let Git become the foundation of modern DevOps, CI/CD, GitOps, and all of today's open source.
Remember in 30 seconds
- A VCS = a dated, signed journal of all a project's modifications.
- Three useful analogies: the photo, the time machine, the Wikipedia history tab.
- Three generations: local, centralized, distributed.
- Git won because it is distributed: every machine is autonomous, collaboration is voluntary, branching costs nothing.