git diff for working directory changes - Deep Dive

Overview - git diff for working directory changes

What is it?

git diff is a command that shows the differences between files in your working directory and the last saved version in your Git repository. It helps you see what changes you have made but not yet saved (committed). This command is useful to review your edits before deciding to save them permanently.

Why it matters

Without git diff, you would not easily see what changes you made to your files before saving them. This could lead to mistakes, like committing unwanted changes or missing important edits. It helps you catch errors early and understand your work better.

Where it fits

Before learning git diff, you should know basic Git concepts like repositories, commits, and the working directory. After mastering git diff, you can learn about staging changes with git add and saving changes with git commit.

Mental Model

Core Idea

git diff compares your current files with the last saved snapshot to show what has changed but not yet saved.

Think of it like...

It's like proofreading a draft against the original paper to see what you added, removed, or changed before submitting it.

Working Directory
  │
  │ (changes made)
  ▼
Last Commit Snapshot

git diff shows differences between these two states.

Build-Up - 6 Steps

1

Foundation

Understanding Git Working Directory

Concept: Learn what the working directory is and how it relates to Git commits.

The working directory is where you edit your files on your computer. Git tracks changes by comparing this directory to the last saved commit. When you change a file, Git notices it but does not save it until you commit.

Result

You understand that the working directory holds your current, possibly changed files, separate from saved commits.

Knowing the working directory is the place where you make changes helps you understand why git diff compares it to saved commits.

2

Foundation

What git diff Shows by Default

Concept: git diff shows unstaged changes between working directory and last commit.

Running 'git diff' without options compares your current files to the last commit, showing lines added or removed. It highlights exactly what changed in each file.

Result

You see a list of changes in your files that are not yet staged or committed.

Understanding the default behavior of git diff helps you quickly check what edits you have made before saving.

3

Intermediate

Reading git diff Output Format

🤔Before reading on: do you think git diff shows whole files or only changed lines? Commit to your answer.

Concept: Learn how to interpret the symbols and lines in git diff output.

git diff output shows file names, then lines starting with '-' for removed lines and '+' for added lines. Context lines show unchanged code for reference. This helps you focus on what exactly changed.

Result

You can read git diff output and understand which lines were added or removed in your files.

Knowing how to read git diff output prevents confusion and helps you spot mistakes in your changes.

4

Intermediate

Comparing Staged vs Unstaged Changes

🤔Before reading on: does 'git diff' show staged changes or only unstaged? Commit to your answer.

Concept: git diff by default shows unstaged changes; to see staged changes, use 'git diff --staged'.

When you stage changes with 'git add', they move from working directory to staging area. 'git diff' shows unstaged changes only. To see staged changes, run 'git diff --staged' or 'git diff --cached'.

Result

You can check both unstaged and staged changes separately to review before committing.

Understanding the difference between staged and unstaged changes helps you control exactly what you save in your commits.

5

Advanced

Using git diff with Specific Files or Directories

🤔Before reading on: do you think git diff can limit output to one file or folder? Commit to your answer.

Concept: git diff can be run on specific files or directories to focus on particular changes.

You can run 'git diff filename' to see changes only in that file, or 'git diff foldername/' for a folder. This helps when working on large projects to narrow down what you review.

Result

You get a filtered diff output showing changes only in the specified files or folders.

Knowing how to limit git diff output saves time and reduces noise when reviewing changes.

6

Expert

Understanding git diff Internals and Patch Format

🤔Before reading on: do you think git diff output is just text or a structured format? Commit to your answer.

Concept: git diff output is a structured patch format that can be applied or reversed by Git and other tools.

git diff produces a patch showing line changes with context, file headers, and line numbers. This format allows tools to apply changes automatically or create patches for sharing. Understanding this helps with advanced workflows like code reviews and patch management.

Result

You recognize git diff output as a powerful format beyond just human reading, enabling automation.

Knowing the patch format behind git diff output reveals why it integrates well with many tools and workflows.

Under the Hood

git diff works by comparing the current state of files in the working directory against the last commit snapshot stored in Git's internal database. It reads file contents, calculates line-by-line differences, and formats these as a patch showing additions and deletions. It uses efficient algorithms to detect changes quickly even in large projects.

Why designed this way?

git diff was designed to provide a clear, line-based view of changes to help developers review edits before saving. The patch format was chosen because it is both human-readable and machine-processable, enabling automation and collaboration. Alternatives like binary diffs were less useful for source code.

┌─────────────────────────────┐
│       Git Repository        │
│  (Last Commit Snapshot)     │
└─────────────┬───────────────┘
              │
              │ compare
              ▼
┌─────────────────────────────┐
│    Working Directory Files   │
└─────────────┬───────────────┘
              │
              │ generate
              ▼
┌─────────────────────────────┐
│        git diff Output       │
│  (Patch: + added, - removed)│
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does 'git diff' show changes that are already staged? Commit yes or no.

Common Belief: git diff shows all changes including staged ones.

Reality: git diff by default only shows unstaged changes; staged changes require 'git diff --staged'.

Why it matters: Confusing this leads to missing staged changes during review, causing incomplete commits or errors.

Quick: Does 'git diff' show changes compared to the last commit or the last push? Commit your answer.

Common Belief: git diff compares files to the last pushed version on the remote repository.

Reality: git diff compares files to the last local commit, not what is on the remote server.

Why it matters: This misunderstanding can cause confusion about what changes are actually new or already shared.

Quick: Does 'git diff' modify any files or save changes? Commit yes or no.

Common Belief: git diff changes files or saves edits automatically.

Reality: git diff only shows differences; it does not modify or save any files.

Why it matters: Thinking git diff changes files can cause accidental misuse or missed manual saving steps.

Quick: Can git diff show differences between commits or branches? Commit yes or no.

Common Belief: git diff only works for working directory changes, not between commits or branches.

Reality: git diff can compare any two commits, branches, or tags by specifying them explicitly.

Why it matters: Limiting git diff to working directory changes reduces its usefulness in code review and history analysis.

Expert Zone

1

git diff output can be customized with options like --word-diff to show changes at word level, which is useful for detailed reviews.

2

The patch format produced by git diff can be saved and applied later with git apply, enabling advanced workflows like patch sharing and code review.

3

git diff performance depends on Git's internal index and caching; understanding this helps optimize workflows in large repositories.

When NOT to use

git diff is not suitable for binary files or large files where line-based diffs are meaningless; tools like git diff --binary or external diff tools should be used instead.

Production Patterns

In professional teams, git diff is used before staging changes to verify edits, during code reviews to generate patches, and in CI pipelines to detect unexpected changes or enforce style rules.

Connections

Code Review

git diff output is the basis for code review tools showing changes between versions.

Understanding git diff helps you read and create code reviews effectively, as they rely on the same diff format.

Version Control Systems

git diff is a specific implementation of the general concept of diff in version control.

Knowing git diff deepens your understanding of how version control tracks and displays changes across all systems.

Text Comparison Algorithms

git diff uses line-based comparison algorithms to detect changes efficiently.

Learning about git diff connects to computer science concepts like the longest common subsequence algorithm used in text comparison.

Common Pitfalls

#1 Expecting git diff to show staged changes by default.

Wrong approach:

git diff

Correct approach:

git diff --staged

Root cause:

Misunderstanding that git diff only shows unstaged changes unless told otherwise.

#2 Running git diff without specifying files and getting overwhelmed by output.

Wrong approach:

git diff

Correct approach:

git diff path/to/file

Root cause:

Not knowing how to limit diff output to relevant files.

#3 Thinking git diff modifies files or commits changes.

Wrong approach:

git diff && git push

Correct approach:

git diff (review changes) then git add and git commit to save

Root cause:

Confusing git diff as a command that saves or changes files instead of just showing differences.

Key Takeaways

git diff shows the exact changes in your working directory compared to the last commit, helping you review edits before saving.

By default, git diff only shows unstaged changes; use 'git diff --staged' to see what is ready to be committed.

The output format of git diff is a structured patch that can be read by humans and applied by tools, enabling powerful workflows.

Limiting git diff to specific files or folders helps manage large projects and focus your review.

Understanding git diff deeply connects to broader concepts in version control, code review, and text comparison algorithms.