Git mental model (snapshots not diffs) - Step-by-Step Execution

Process Flow - Git mental model (snapshots not diffs)

Start: Working Directory

↓

Create Snapshot of Files

↓

Store Snapshot as Commit

↓

Link Commits in Chain

↓

Checkout Commit to Restore Files

↓

Modify Files -> New Snapshot

↓

Repeat

Git saves the whole state of your files as snapshots in commits, not just changes. Each commit stores a full picture of your project at that time.

Execution Sample

Git

git add .
git commit -m "Save snapshot"
git checkout HEAD~1

Add all files, save a snapshot as a commit, then go back to the previous snapshot.

Process Table

Step	Action	Files State	Commit Created	Commit Chain
1	Start with files in working directory	Files A, B, C (current content)	No	No commits yet
2	git add .	Files staged for commit	No	No commits yet
3	git commit -m "Save snapshot"	Files saved as snapshot	Commit 1 created	Commit 1 (root)
4	Modify File B	File B changed in working directory	No	Commit 1
5	git add .	Files staged for commit	No	Commit 1
6	git commit -m "Save snapshot 2"	Files saved as snapshot	Commit 2 created	Commit 1 -> Commit 2
7	git checkout HEAD~1	Files restored to Commit 1 state	No	Commit 1 -> Commit 2 (HEAD detached)
8	End	Files at Commit 1 snapshot	No	Commit 1 -> Commit 2 (HEAD detached)

💡 Checked out previous commit snapshot, HEAD detached at Commit 1

Status Tracker

Variable	Start	After Step 3	After Step 6	After Step 7
Working Directory Files	A,B,C original	A,B,C snapshot 1	A,B modified,C snapshot 2	A,B,C snapshot 1 restored
Commit Chain	None	Commit 1	Commit 1 -> Commit 2	Commit 1 -> Commit 2 (HEAD detached)
HEAD Pointer	None	Commit 1	Commit 2	Commit 1 (detached)

Key Moments - 3 Insights

Why does Git store snapshots of all files instead of just the changes?

Git saves the full state of files at each commit (see execution_table steps 3 and 6). This makes it faster and simpler to restore any commit without calculating changes.

What happens to the files when you checkout an older commit?

The working directory files are replaced by the snapshot from that commit (see execution_table step 7). This is why files look like they reverted to an earlier state.

Is the commit chain lost when you checkout an older commit?

No, the commit chain remains intact (see variable_tracker Commit Chain after step 7). HEAD just points to an older commit temporarily (detached HEAD).

Visual Quiz - 3 Questions

Look at the execution table at step 3. What does Git do at this step?

A Modifies files in the working directory

B Checks out the previous commit

C Creates the first commit snapshot of all files

D Deletes all files

💡 Hint

Check the 'Commit Created' and 'Files State' columns at step 3

At which step does the working directory files get restored to an earlier snapshot?

A Step 7

B Step 6

C Step 4

D Step 2

💡 Hint

Look for 'Files restored to Commit 1 state' in the 'Files State' column

If you modify files but do not commit, what happens to the commit chain?

A It adds a new commit automatically

B It stays the same

C It deletes the last commit

D It resets to the first commit

💡 Hint

See variable_tracker 'Commit Chain' after step 4 where files are modified but no commit is made

Concept Snapshot

Git saves full snapshots of your files at each commit.
Each commit stores the entire project state, not just changes.
You can restore any commit by checking it out.
HEAD points to the current commit.
Modifying files doesn't change commits until you commit.
This model makes history simple and fast to navigate.

Full Transcript

Git works by saving snapshots of your entire project files at each commit, not just the differences. When you add and commit, Git takes a picture of all your files as they are. This snapshot is stored as a commit and linked in a chain with previous commits. When you checkout a commit, Git replaces your working files with the snapshot from that commit, letting you go back in time. Modifying files alone does not affect commits until you stage and commit again. This snapshot model helps Git be fast and reliable in managing your project history.

Practice

1. What does Git save when you run git commit?

easy

A. A backup copy of your entire computer

B. Only the changes made since the last commit

C. A list of all commands you typed

D. A snapshot of all your files at that moment

Solution

1. Step 1: Understand what git commit does

   It records the current state of your project files as a snapshot.

2. Step 2: Differentiate snapshot from changes

   Unlike some systems, Git saves the whole snapshot, not just the changes.

3. Final Answer:

   A snapshot of all your files at that moment -> Option D

4. Quick Check:

   Git saves snapshots, not diffs [OK]

Hint: Remember: Git snapshots whole files, not just changes [OK]

Common Mistakes:

• Thinking Git saves only changes (diffs)
• Confusing commit with backup
• Believing commit saves command history

2. Which of the following is the correct command to create a snapshot in Git?

easy

A. git snapshot

B. git save

C. git commit

D. git backup

Solution

1. Step 1: Recall Git commands for saving work

   The command to save a snapshot is git commit.

2. Step 2: Verify other options

   Commands like git snapshot, git save, and git backup do not exist in Git.

3. Final Answer:

   git commit -> Option C

4. Quick Check:

   git commit creates snapshots [OK]

Hint: Use git commit to save snapshots [OK]

Common Mistakes:

• Using non-existent commands like git save
• Confusing commit with backup commands
• Trying git snapshot which is invalid

3. Given this sequence of commands:

echo "Hello" > file.txt
git add file.txt
git commit -m "First snapshot"
echo "World" >> file.txt
git add file.txt
git commit -m "Second snapshot"

What does the second commit snapshot contain?

medium

A. Only the line "World" added to file.txt

B. The entire file.txt with both "Hello" and "World" lines

C. Only the line "Hello" in file.txt

D. An empty file.txt

Solution

1. Step 1: Understand what each commit saves

   Each commit saves a full snapshot of the file at that time, not just changes.

2. Step 2: Analyze the second commit content

   After appending "World", the second commit snapshot includes both "Hello" and "World" lines in file.txt.

3. Final Answer:

   The entire file.txt with both "Hello" and "World" lines -> Option B

4. Quick Check:

   Git snapshots save full file content [OK]

Hint: Each commit saves full file content, not just added lines [OK]

Common Mistakes:

• Thinking commit saves only new lines
• Confusing snapshots with diffs
• Assuming commit saves partial file

4. You ran git commit but Git says "nothing to commit, working tree clean". What is the most likely reason?

medium

A. There are no changes since the last snapshot

B. You forgot to add files with git add before commit

C. Your Git repository is corrupted

D. You need to restart your computer

Solution

1. Step 1: Understand the message meaning

   "Nothing to commit, working tree clean" means no changes are detected compared to last commit.

2. Step 2: Check if files were changed

   If no files changed, Git has no new snapshot to save, so commit does nothing.

3. Final Answer:

   There are no changes since the last snapshot -> Option A

4. Quick Check:

   No changes = no new snapshot [OK]

Hint: No changes means no new commit possible [OK]

Common Mistakes:

• Assuming you must always run git add before commit even if no changes
• Thinking repository is corrupted
• Restarting computer unnecessarily

5. You want to save your project state but only some files changed. How does Git store this when you run git commit?

hard

A. Git saves a full snapshot of all files, but reuses unchanged files from previous commits internally

B. Git saves only the changed files as diffs

C. Git saves only the changed files as full copies

D. Git saves nothing until you run git push

Solution

1. Step 1: Recall Git snapshot model

   Git saves a full snapshot of the project at commit time, not just diffs.

2. Step 2: Understand Git's storage optimization

   Internally, Git reuses unchanged files from previous commits to save space efficiently.

3. Final Answer:

   Git saves a full snapshot of all files, but reuses unchanged files from previous commits internally -> Option A

4. Quick Check:

   Snapshots with internal reuse = Git saves a full snapshot of all files, but reuses unchanged files from previous commits internally [OK]

Hint: Git snapshots all files but stores unchanged ones efficiently [OK]

Common Mistakes:

• Thinking Git saves only diffs
• Believing commit saves nothing until push
• Assuming changed files are saved as full copies only