Git mental model (snapshots not diffs) - Deep Dive

Overview - Git mental model (snapshots not diffs)

What is it?

Git is a tool that helps you save and manage versions of your files. Instead of just remembering changes between versions, Git takes a full picture, or snapshot, of all your files each time you save. This way, you can easily go back to any saved version or compare different versions. It works quietly in the background to keep your work safe and organized.

Why it matters

Without Git's snapshot approach, tracking changes would be confusing and error-prone, especially when many people work together. If Git only stored differences, it would be harder to restore files or understand the full state at any point. Snapshots make it simple to see exactly what your project looked like at any save point, making teamwork and recovery much easier.

Where it fits

Before learning this, you should understand basic file saving and versioning ideas. After this, you can learn about branching, merging, and collaboration workflows in Git. This mental model helps you grasp how Git stores data, which is key before diving into commands and teamwork.

Mental Model

Core Idea

Git saves your project by taking complete snapshots of all files at each save, not just the changes between saves.

Think of it like...

Imagine taking a photo of your entire desk every time you finish working, instead of just noting what you moved or added. Each photo shows exactly how your desk looked at that moment, making it easy to return to any setup.

┌─────────────┐
│ Initial     │
│ snapshot    │
│ (all files) │
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ Second      │
│ snapshot    │
│ (all files) │
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ Third       │
│ snapshot    │
│ (all files) │
└─────────────┘

Build-Up - 7 Steps

1

Foundation

What is Git and version control

Concept: Introduce Git as a tool to save and track versions of files over time.

Git is like a smart save button for your project. Each time you save (commit), Git remembers what your files look like. This helps you go back to earlier versions if needed.

Result

You understand Git's purpose: to keep track of your work history safely.

Knowing Git is about saving versions helps you see why it’s useful for both solo and team projects.

2

Foundation

Difference between snapshots and diffs

Concept: Explain the two ways to track changes: snapshots (whole files) vs diffs (only changes).

Some tools save only the changes between file versions (diffs). Git saves a full snapshot of all files each time you commit. This means Git stores the complete state, not just what changed.

Result

You can picture how Git stores data differently from other tools.

Understanding this difference clears up confusion about how Git can be fast and reliable.

3

Intermediate

How Git stores snapshots efficiently

🤔Before reading on: do you think Git stores a full copy of every file each time or something else? Commit to your answer.

Concept: Git uses clever methods to avoid wasting space even though it saves full snapshots.

Git stores snapshots by linking unchanged files to previous versions instead of copying them again. Only new or changed files are saved fully. This makes snapshots fast and space-friendly.

Result

Git saves disk space while keeping full snapshots for every commit.

Knowing Git’s storage tricks explains why snapshots don’t slow down or fill your disk quickly.

4

Intermediate

Snapshots enable easy project restoration

🤔Before reading on: do you think restoring a project from snapshots is simpler or harder than from diffs? Commit to your answer.

Concept: Snapshots let Git quickly restore your entire project to any saved state without replaying changes.

Because Git has full snapshots, it can instantly show your project as it was at any commit. You don’t need to apply a chain of changes to rebuild the state.

Result

Restoring old versions is fast and reliable.

Understanding this shows why Git is great for undoing mistakes or exploring history.

5

Intermediate

Snapshots support branching and merging

Concept: Snapshots make it easier for Git to manage multiple versions (branches) and combine them (merge).

Each branch in Git points to a snapshot. When you merge, Git compares snapshots to find differences and combine changes. This snapshot model simplifies complex workflows.

Result

You see how Git handles multiple worklines smoothly.

Knowing snapshots are the base of branches clarifies how Git manages parallel work.

6

Advanced

Internal Git objects and snapshot storage

🤔Before reading on: do you think Git stores snapshots as simple files or special objects? Commit to your answer.

Concept: Git stores snapshots as objects called 'trees' and 'blobs' inside its database.

Git breaks snapshots into blobs (file contents) and trees (folders). Each commit points to a tree representing the project state. This structure allows efficient storage and retrieval.

Result

You understand Git’s internal data structure behind snapshots.

Knowing Git’s object model reveals why it’s so powerful and flexible.

7

Expert

Surprising effects of snapshot model on performance

🤔Before reading on: do you think Git’s snapshot model makes all operations slower or faster? Commit to your answer.

Concept: Git’s snapshot approach can make some operations faster but others require clever optimization.

Because Git stores snapshots, commands like checkout and reset are very fast. However, operations like diff compute differences on demand, which can be costly for large projects. Git uses caching and compression to balance this.

Result

You see the tradeoffs Git makes for speed and storage.

Understanding these tradeoffs helps you optimize Git usage and troubleshoot performance.

Under the Hood

Git stores data in a hidden folder called .git. Each commit creates a tree object representing the full snapshot of the project. Files are stored as blobs, and folders as trees linking blobs and other trees. Commits point to trees and have metadata. Git uses hashing (SHA-1 or SHA-256) to identify objects uniquely. When files don’t change, Git reuses existing blobs, saving space. This object database allows Git to quickly reconstruct any project state by following commit pointers.

Why designed this way?

Git was designed by Linus Torvalds to be fast, reliable, and distributed. Storing snapshots instead of diffs simplifies many operations and reduces errors. Alternatives like diff-based systems were slower and more fragile. The snapshot model also fits well with branching and merging, which are core to Git’s power. The use of hashing ensures data integrity and easy sharing.

┌─────────────┐
│ Commit      │
│ (metadata)  │
│ points to   │
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ Tree (folder)│
│ links to    │
└─────┬───────┘
      │
      ▼
┌─────────────┐   ┌─────────────┐
│ Blob (file) │   │ Tree (subfolder)│
│ (file data) │   │ links to blobs │
└─────────────┘   └─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does Git store only the changes between file versions? Commit yes or no.

Common Belief: Git stores only the differences (diffs) between file versions to save space.

Reality: Git stores full snapshots of all files at each commit, reusing unchanged files to save space.

Why it matters: Believing Git stores only diffs can confuse users about how Git restores files and manages branches.

Quick: Is Git’s snapshot model slower than diff-based systems? Commit yes or no.

Common Belief: Saving full snapshots must be slower and use more space than saving diffs.

Reality: Git’s snapshot model is optimized to be fast and space-efficient by reusing unchanged file data.

Why it matters: Thinking snapshots are slow may lead users to avoid Git or misunderstand performance issues.

Quick: Does Git’s snapshot model mean every commit duplicates all files? Commit yes or no.

Common Belief: Each Git commit duplicates all files, causing huge storage use.

Reality: Git stores only new or changed files; unchanged files are linked to previous snapshots.

Why it matters: Misunderstanding this can cause fear of using Git for large projects.

Quick: Can Git’s snapshot model cause conflicts to be harder to resolve? Commit yes or no.

Common Belief: Because Git stores snapshots, merging and conflict resolution are more complicated.

Reality: Snapshots actually simplify merging by providing clear project states to compare.

Why it matters: This misconception can discourage users from branching and merging effectively.

Expert Zone

1

Git’s snapshot model means that even small changes create new tree objects, but blobs are reused, which affects how history is stored and accessed.

2

The hashing of objects ensures data integrity and enables Git’s distributed nature, allowing safe sharing and verification of snapshots.

3

Git’s packfiles compress and store many objects efficiently, balancing snapshot storage with performance and disk space.

When NOT to use

Git’s snapshot model is not ideal for very large binary files that change often; specialized tools like Git LFS or other version control systems designed for binaries are better.

Production Patterns

In real projects, Git snapshots enable safe branching for features, quick rollbacks, and efficient collaboration. Teams rely on snapshots to create release tags, perform code reviews, and automate deployments.

Connections

Database transaction snapshots

Both use snapshots to capture full system state at a point in time.

Understanding database snapshots helps grasp how Git ensures consistent project states and safe rollbacks.

Photography

Both capture a full image at a moment, not just changes.

Knowing how photos capture scenes helps understand why Git’s snapshots show complete project states.

Checkpointing in operating systems

Both save full system states to allow recovery after failure.

Recognizing checkpointing clarifies why Git snapshots enable reliable undo and recovery.

Common Pitfalls

#1 Assuming Git stores only changes and trying to manually patch files.

Wrong approach:

Manually editing files to apply diffs instead of using Git commands.

Correct approach:

Use Git commands like 'git checkout' or 'git reset' to restore snapshots.

Root cause:

Misunderstanding Git’s snapshot model leads to manual, error-prone workflows.

#2 Committing large unchanged files repeatedly thinking Git duplicates them.

Wrong approach:

Repeatedly committing big files without realizing Git reuses blobs.

Correct approach:

Trust Git’s storage; avoid unnecessary commits but know unchanged files don’t duplicate storage.

Root cause:

Lack of knowledge about Git’s efficient snapshot storage.

#3 Avoiding branching because of fear that snapshots complicate merges.

Wrong approach:

Working only on main branch to avoid merge conflicts.

Correct approach:

Use branches freely; Git’s snapshot model simplifies merging and conflict detection.

Root cause:

Misconception that snapshots make merges harder.

Key Takeaways

Git saves your project by taking full snapshots of all files at each commit, not just the changes.

This snapshot model makes it easy to restore any version quickly and supports powerful branching and merging.

Git stores snapshots efficiently by reusing unchanged file data, balancing speed and disk space.

Understanding snapshots clears up common confusions about how Git works internally and why it is reliable.

Snapshots are the foundation of Git’s power in managing project history and collaboration.