Commits and History
We said version control records every change to the code. The thing it records is called a commit — a saved snapshot of the project at one moment in time. When Maya finishes adding the favorites button, she makes a commit, and that exact state of Pageturn's code is captured for good.
Every commit also carries a short note from its author saying what changed and why. String the commits together in the order they were made and you get the project's history — a timeline you can read forward, or rewind to any earlier point.
What a commit is
A commit is a snapshot of the whole project at the moment you make it — every file, exactly as it stands. It isn't a copy of only the file you touched; it's the complete state of the code, frozen and labeled so you can find it again later.
Crucially, making a commit doesn't throw away the previous one. Each commit sits on top of the last, so the snapshots pile up into a record. Maya might make a dozen commits in a day, and all dozen stay, in order.
The message: a note to the future
Every commit comes with a message — a short line the author writes explaining what changed and, more importantly, why. "Fix the crash when a book title is empty" tells a story that the code alone never could.
That message is a gift to future-you and to teammates. Six months later, when someone asks why a piece of code looks the way it does, the commit message is the answer. A good history reads like a logbook of decisions, not just a pile of edits.
History: the project's timeline
Line the commits up in the order they were made and you have the project's history: a record of every change Pageturn has ever been through. You can scroll back through it much the way you'd scroll back through a chat, seeing what the code looked like at each step and who changed it.
This is what people mean when they talk about a project's history in version control — not a vague sense of the past, but an exact, ordered record you can actually open and read.
Rewinding to an earlier point
Because every snapshot is kept, you can go back. Think of commits like the save points in a video game: each one marks a moment you can return to. If a change breaks Pageturn, the team rewinds the code to an earlier commit — a known-good point from before the break — and the site works again while they track down what went wrong.
That safety net is what makes a team brave enough to change things. The unit they go back to is the commit, and "commit" is a word you'll use every single day once you reach Git for Beginners, where you'll make them yourself.
- "A commit is just hitting save on a file." Saving updates one file on your disk. A commit records a labeled snapshot of the whole project, with a message, into the history — and every earlier snapshot stays.
- "History is only the latest version." History is every version in order, not just the newest. The whole point is that the earlier ones are still there to read and return to.
- "Once you change something, the old version is gone." Every earlier commit is kept, so you can always go back to how the code was before a change.
- "The commit message is just decoration." The message is often the only record of why a change was made; for teammates and future-you, it can matter more than the changed code itself.
- A commit is the unit the rest of the pipeline acts on: in Chapter 4 you'll see automated checks run on every commit Maya pushes.
- "Commit" is everyday Git vocabulary — you'll make and read commits constantly in any real project.
- Good commit messages are how teams understand their own past; they turn the code's history into a readable record of decisions.
- The ability to rewind to an earlier commit is what lets a team change software boldly instead of fearfully — a habit you'll build in Git for Beginners.
Knowledge Check
What does a commit capture?
- A labeled snapshot of the project's code at one moment in time
- Only the single line of code that the developer just changed
- The newest version, replacing whatever the code looked like before
- A copy of the app while it is running live for users
Why does a commit message matter?
- It records why a change was made, for teammates and future-you
- It makes the commit save to disk much faster than it usually would
- It is required before the app is allowed to run at all
- It hides the change from other people on the team
What does a project's commit history let the team do?
- Rewind the code to a known-good earlier point if something breaks
- Run the app on more servers at the same time
- Stop two developers from ever editing the very same file at the same time
- Delete every old version to keep the project small
You got correct