git diff between branches - Deep Dive

Overview - git diff between branches

What is it?

Git diff between branches shows the differences in files and content between two branches in a Git repository. It helps you see what changes exist in one branch compared to another before merging or reviewing code. This comparison includes added, modified, or deleted lines in files. It is a key tool for understanding how branches diverge.

Why it matters

Without the ability to compare branches, developers would struggle to understand what changes have been made in different lines of work. This could lead to mistakes like merging unwanted changes or missing important updates. Git diff between branches helps teams collaborate safely and review code effectively, preventing bugs and conflicts.

Where it fits

Before learning git diff between branches, you should understand basic Git concepts like commits, branches, and the working directory. After mastering this, you can learn about merging, rebasing, and resolving conflicts, which build on understanding differences between branches.

Mental Model

Core Idea

Git diff between branches is like comparing two versions of a document side-by-side to see exactly what changed.

Think of it like...

Imagine you have two drafts of a school essay saved separately. To see what you improved or changed, you place them side by side and highlight the differences. Git diff between branches works the same way for code changes.

Branch A ──────────────┐
                       │
                       ▼
                 Compare changes
                       ▲
Branch B ──────────────┘

Output: Lines added (+), removed (-), or modified between Branch A and Branch B

Build-Up - 7 Steps

1

Foundation

Understanding Git branches basics

Concept: Learn what branches are and how they represent different lines of work in Git.

A branch in Git is like a separate copy of your project where you can make changes without affecting the main code. You can switch between branches to work on different features or fixes.

Result

You know how to create and switch branches using commands like 'git branch' and 'git checkout'.

Understanding branches is essential because diffing compares these separate lines of work.

2

Foundation

What is git diff command

Concept: Learn the basic git diff command to see changes in your working directory.

The command 'git diff' shows changes between your current files and the last commit. It highlights lines added or removed but only for your current branch and working files.

Result

You can see unstaged changes in your current branch.

Knowing basic git diff prepares you to compare more complex differences like between branches.

3

Intermediate

Comparing two branches with git diff

🤔Before reading on: do you think 'git diff branch1 branch2' shows changes from branch1 to branch2 or the other way around? Commit to your answer.

Concept: Learn how to use git diff to compare the content differences between two branches.

Run 'git diff branch1 branch2' to see what changes you would get if you moved from branch1 to branch2. Lines starting with '+' are additions in branch2, '-' are removals from branch1.

Result

You get a detailed list of file changes between the two branches.

Understanding the direction of diff output helps you interpret what changes are new or removed.

4

Intermediate

Using git diff with branch names and paths

🤔Before reading on: can you limit git diff between branches to specific files or folders? Commit to your answer.

Concept: Learn to narrow down diff output to specific files or directories between branches.

You can run 'git diff branch1 branch2 -- path/to/file' to see differences only for that file or folder. This helps focus on relevant changes.

Result

Diff output shows changes only for the specified paths.

Filtering diffs saves time and reduces noise when reviewing large projects.

5

Intermediate

Viewing summary and stats of branch differences

Concept: Learn to get a quick overview of changes between branches without full details.

Use 'git diff --stat branch1 branch2' to see a summary of changed files and line counts. Use 'git diff --name-only branch1 branch2' to list only changed file names.

Result

You get concise summaries that help decide if a full diff review is needed.

Summaries speed up understanding the scope of changes before deep inspection.

6

Advanced

Diffing with merge base for accurate comparison

🤔Before reading on: do you think comparing branches directly always shows all relevant changes? Commit to your answer.

Concept: Learn to compare branches based on their common ancestor to see only new changes on one branch.

Use 'git diff $(git merge-base branch1 branch2) branch2' to compare branch2 changes since it diverged from branch1. This avoids showing unrelated changes.

Result

Diff output focuses on new changes in branch2 relative to branch1's shared history.

Using merge base prevents confusion from unrelated changes and shows true branch differences.

7

Expert

Interpreting diff output for complex merges

🤔Before reading on: can diff output between branches always predict merge conflicts? Commit to your answer.

Concept: Understand how diff output relates to merge conflicts and what it cannot show.

Diff shows line changes but does not detect conflicts caused by simultaneous edits in both branches. Conflicts appear only during merge or rebase. Reviewing diff helps anticipate but not guarantee conflict detection.

Result

You know diff is a guide, not a conflict detector.

Knowing diff limits prevents surprises during merges and encourages proper conflict resolution practices.

Under the Hood

Git stores snapshots of files in commits. Branches are pointers to these commits. When you run git diff between branches, Git compares the snapshots of the two commits the branches point to. It calculates line-by-line differences using a diff algorithm that highlights additions, deletions, and modifications.

Why designed this way?

Git was designed for speed and efficiency. Comparing snapshots instead of entire histories allows quick difference calculation. Using branches as pointers makes it easy to compare any two points in history without copying files.

┌─────────────┐       ┌─────────────┐
│ Branch A    │──────▶│ Commit A    │
│ (pointer)   │       │ (snapshot)  │
└─────────────┘       └─────────────┘
         │                     │
         │                     │
         ▼                     ▼
┌─────────────┐       ┌─────────────┐
│ Branch B    │──────▶│ Commit B    │
│ (pointer)   │       │ (snapshot)  │
└─────────────┘       └─────────────┘

Git diff compares Commit A snapshot to Commit B snapshot line-by-line.

Myth Busters - 4 Common Misconceptions

Quick: Does 'git diff branch1 branch2' show changes from branch1 to branch2 or branch2 to branch1? Commit to your answer.

Common Belief: Many think git diff branch1 branch2 shows changes from branch2 to branch1.

Reality: Git diff branch1 branch2 shows changes needed to get from branch1 to branch2, meaning additions are in branch2 compared to branch1.

Why it matters: Misreading diff direction can cause wrong assumptions about which branch introduced changes, leading to incorrect merges.

Quick: Does git diff between branches detect merge conflicts? Commit to your answer.

Common Belief: Some believe git diff between branches will show all merge conflicts before merging.

Reality: Git diff only shows line differences; it does not detect conflicts that arise from simultaneous edits in both branches during merge.

Why it matters: Relying on diff alone can cause unexpected conflicts during merge, delaying integration.

Quick: Does comparing branches directly always show only new changes? Commit to your answer.

Common Belief: People often think git diff branch1 branch2 shows only new changes on branch2 since branching.

Reality: Direct diff compares the two branch tips, including unrelated changes if branches have diverged or merged other branches.

Why it matters: This can confuse reviewers by showing irrelevant changes, making code review harder.

Quick: Can git diff between branches show changes in untracked files? Commit to your answer.

Common Belief: Some assume git diff between branches includes untracked files differences.

Reality: Git diff compares committed snapshots; untracked files are not part of commits and do not appear in diff output.

Why it matters: Ignoring untracked files can cause missing important local changes during review.

Expert Zone

1

Git diff output can be customized with options like --color-moved to better visualize moved code blocks, which is often missed by beginners.

2

Using merge-base for diffing is crucial in complex workflows with multiple merges to avoid misleading diff results.

3

Diff algorithms (like Myers or Patience) affect output readability; experts choose algorithms based on codebase characteristics.

When NOT to use

Git diff between branches is not suitable for detecting merge conflicts or for comparing uncommitted local changes. For conflict detection, use 'git merge' or 'git rebase' with conflict resolution tools. For local changes, use 'git diff' without branch arguments.

Production Patterns

In professional workflows, developers use git diff between feature branches and main branches to review code before pull requests. Continuous integration systems run diffs to generate change logs and trigger tests only on changed files.

Connections

Version Control Systems

git diff between branches builds on the general idea of comparing versions in version control.

Understanding git diff deepens knowledge of how version control tracks and compares changes over time.

Code Review Process

git diff output is the foundation for code review tools that highlight changes for human inspection.

Knowing how diffs work helps reviewers focus on meaningful changes and improves collaboration quality.

Textual Diff Algorithms

git diff uses diff algorithms to calculate line differences between files.

Learning about diff algorithms from computer science explains why some diffs are easier to read and how moved code is detected.

Common Pitfalls

#1 Confusing diff direction and misinterpreting which branch's changes are shown.

Wrong approach:

git diff feature main

Correct approach:

git diff main feature

Root cause:

Not understanding that git diff A B shows changes to get from A to B, so the order matters.

#2 Expecting git diff between branches to show uncommitted or untracked changes.

Wrong approach:

git diff main feature (expecting local uncommitted changes to appear)

Correct approach:

git diff (to see local changes) or git status (to see untracked files)

Root cause:

Misunderstanding that git diff between branches compares committed snapshots only.

#3 Using direct branch diff without merge-base in complex histories, causing confusing output.

Wrong approach:

git diff branch1 branch2

Correct approach:

git diff $(git merge-base branch1 branch2) branch2

Root cause:

Not accounting for common ancestor leads to showing unrelated changes.

Key Takeaways

Git diff between branches compares the snapshots of two branches to show what changed from one to the other.

The order of branches in the git diff command matters and determines the direction of changes shown.

Using merge-base helps focus diffs on relevant changes since branches diverged, avoiding noise.

Git diff does not detect merge conflicts or show uncommitted/untracked changes; it only compares committed snapshots.

Mastering git diff between branches is essential for safe code review, collaboration, and understanding project history.