git merge command - Deep Dive

Overview - git merge command

What is it?

The git merge command combines changes from one branch into another branch in a Git repository. It takes the contents of a source branch and integrates them into the current branch. This helps developers work on different features or fixes separately and then bring their work together. Merging keeps the project history organized and up to date.

Why it matters

Without git merge, developers would struggle to combine their work safely and efficiently. They might overwrite each other's changes or lose important updates. Merging solves the problem of collaboration by allowing multiple people to work independently and then bring their changes together smoothly. This keeps projects moving forward without confusion or lost work.

Where it fits

Before learning git merge, you should understand basic Git concepts like repositories, commits, and branches. After mastering git merge, you can explore more advanced topics like resolving merge conflicts, rebasing, and using merge strategies. It fits in the middle of the Git learning journey as a key tool for collaboration.

Mental Model

Core Idea

Git merge is the process of combining the work from two branches into one, preserving the history of both.

Think of it like...

Imagine two friends writing different parts of a story on separate notebooks. Git merge is like copying the pages from one notebook and carefully adding them into the other notebook, making sure the story flows without losing any parts.

Current branch (main)  ──┐
                          │
Source branch (feature) ──>│──> Merged branch (main with feature)
                          │
History combined here      

Build-Up - 7 Steps

1

Foundation

Understanding Git Branches Basics

Concept: Learn what branches are and why they exist in Git.

Branches in Git are like separate workspaces where you can make changes without affecting the main project. Each branch has its own history of commits. This allows multiple features or fixes to be developed in parallel.

Result

You can create and switch between branches to isolate work.

Knowing branches exist is essential because merging is about combining these separate lines of work.

2

Foundation

What Happens When You Merge

Concept: Understand the basic effect of running git merge.

When you run git merge , Git tries to combine the changes from that branch into your current branch. If the changes don't overlap, Git creates a new commit that joins the histories. If there are overlapping changes, Git asks you to fix conflicts.

Result

Your current branch now contains all changes from the merged branch.

Merging is not just copying files; it combines histories and changes carefully.

3

Intermediate

Fast-Forward vs Three-Way Merge

🤔Before reading on: do you think git merge always creates a new commit or sometimes just moves a pointer? Commit to your answer.

Concept: Learn the two main types of merges Git performs depending on branch history.

If your current branch has no new commits since branching, Git can just move the pointer forward to the merged branch's commit (fast-forward). Otherwise, Git creates a new merge commit that has two parents (three-way merge) to combine histories.

Result

Merges can be simple pointer moves or new commits that join histories.

Understanding merge types helps predict what git merge will do and how history looks afterward.

4

Intermediate

Handling Merge Conflicts

🤔Before reading on: do you think Git automatically fixes all conflicts during merge? Commit to yes or no.

Concept: Learn what happens when changes overlap and how to resolve conflicts.

When two branches change the same lines differently, Git cannot decide which to keep. It marks the conflict in files and stops the merge. You must manually edit the files to fix conflicts, then commit the result to complete the merge.

Result

Merge pauses for manual conflict resolution, then completes after your fix.

Knowing how to handle conflicts is critical to safely combining work without losing changes.

5

Intermediate

Using Merge Options and Strategies

🤔Before reading on: do you think git merge has options to control how merges happen? Commit to yes or no.

Concept: Explore options like --no-ff, --squash, and merge strategies to customize merges.

You can use --no-ff to force a merge commit even if fast-forward is possible, preserving branch history. --squash combines all changes into one commit without merging history. Merge strategies like 'ours' or 'theirs' help resolve conflicts automatically in some cases.

Result

You control how merges appear in history and how conflicts are handled.

Mastering merge options lets you keep history clean and handle complex merges better.

6

Advanced

Merging in Large Teams and CI/CD

🤔Before reading on: do you think merges in big projects are always simple? Commit to yes or no.

Concept: Understand challenges and best practices for merging in professional environments.

In large teams, merges happen frequently and can cause conflicts or broken builds. Using feature branches, code reviews, and automated tests before merging helps maintain quality. Continuous Integration systems often run merges in test environments to catch issues early.

Result

Merges become safer and more predictable in team workflows.

Knowing merge challenges in teams helps you design better collaboration and automation.

7

Expert

Internal Mechanics of Git Merge Algorithm

🤔Before reading on: do you think git merge just copies files or uses commit graphs? Commit to your answer.

Concept: Dive into how Git uses commit graphs and three-way merge algorithms internally.

Git represents commits as nodes in a graph. To merge, Git finds the common ancestor commit of the two branches, then compares changes from that ancestor to each branch. It applies these changes together using a three-way merge algorithm. This preserves history and detects conflicts precisely.

Result

Merges are accurate, history-aware, and efficient operations.

Understanding Git's internal merge algorithm explains why merges are reliable and how conflicts are detected.

Under the Hood

Git stores commits as snapshots linked by parent pointers forming a graph. When merging, Git finds the latest common ancestor commit between branches. It compares changes from this ancestor to each branch and applies them together using a three-way merge algorithm. If changes overlap, Git flags conflicts for manual resolution. This process preserves the full history and ensures no changes are lost.

Why designed this way?

Git was designed for distributed development with many parallel branches. The three-way merge algorithm allows combining independent work safely while preserving history. Alternatives like simple file copying or patch application would lose history or cause errors. This design balances accuracy, speed, and collaboration needs.

┌───────────────┐       ┌───────────────┐
│ Common Ancestor│──────▶│ Branch A Head │
└──────┬────────┘       └──────┬────────┘
       │                       │
       │                       │
       ▼                       ▼
┌───────────────┐       ┌───────────────┐
│ Branch B Head │──────▶│ Merge Commit  │
└───────────────┘       └───────────────┘

Git finds common ancestor, compares changes, and creates merge commit.

Myth Busters - 4 Common Misconceptions

Quick: Does git merge always create a new commit? Commit yes or no.

Common Belief: Git merge always creates a new commit to combine branches.

Reality: Git merge only creates a new commit if histories have diverged; otherwise, it fast-forwards the branch pointer.

Why it matters: Expecting a merge commit when none is created can confuse history reading and cause misunderstandings about what changed.

Quick: Can git merge automatically fix all conflicts? Commit yes or no.

Common Belief: Git merge automatically resolves all conflicts without user input.

Reality: Git stops and asks for manual conflict resolution when changes overlap and cannot be merged automatically.

Why it matters: Ignoring conflicts can cause lost work or broken code if unresolved changes are committed.

Quick: Does git merge delete the source branch? Commit yes or no.

Common Belief: After merging, the source branch is deleted automatically.

Reality: Git merge does not delete branches; you must delete them manually if desired.

Why it matters: Assuming branches are deleted can lead to cluttered repositories and confusion about active work.

Quick: Is git merge the only way to combine branches? Commit yes or no.

Common Belief: Git merge is the only method to combine changes from different branches.

Reality: Git also offers git rebase and cherry-pick as alternative ways to integrate changes.

Why it matters: Not knowing alternatives limits flexibility and can lead to suboptimal history or collaboration workflows.

Expert Zone

1

Merge commits can have multiple parents, which is key to preserving the full history graph and understanding project evolution.

2

Using --no-ff forces a merge commit even when fast-forward is possible, which helps keep feature branches visible in history.

3

The choice of merge strategy (recursive, ours, theirs) can drastically affect conflict resolution and history shape, especially in complex projects.

When NOT to use

Avoid git merge when you want a linear history without merge commits; use git rebase instead. Also, do not use merge if you want to selectively apply changes; use cherry-pick. In some workflows, merges are discouraged to keep history clean.

Production Patterns

In professional teams, feature branches are merged into main branches after code review and passing tests. Continuous Integration systems often perform merges in test environments before final integration. Large projects use merge strategies and options to keep history readable and conflicts manageable.

Connections

Version Control Systems

git merge is a core operation in distributed version control systems like Git.

Understanding git merge helps grasp how distributed teams collaborate and manage code changes safely.

Conflict Resolution in Negotiations

git merge conflict resolution parallels resolving disagreements in human negotiations.

Knowing how to resolve merge conflicts can improve skills in finding compromises and solutions in real-world conflicts.

Graph Theory

Git's commit history is a directed acyclic graph, and merging involves graph traversal and common ancestor finding.

Understanding graph concepts clarifies how Git efficiently manages complex histories and merges.

Common Pitfalls

#1 Trying to merge without updating the current branch first.

Wrong approach:

git merge feature-branch
# without pulling latest changes on current branch

Correct approach:

git pull origin main
# then
git merge feature-branch

Root cause:

Not updating current branch leads to unexpected conflicts or outdated merges.

#2 Ignoring merge conflicts and committing incomplete merges.

Wrong approach:

git merge feature-branch
# conflicts appear
# user runs git commit without fixing conflicts

Correct approach:

git merge feature-branch
# resolve conflicts manually
# then git add and git commit

Root cause:

Misunderstanding that conflicts must be resolved before completing merge.

#3 Using git merge when a rebase would keep history cleaner.

Wrong approach:

git merge feature-branch
# creates unnecessary merge commits

Correct approach:

git rebase main
# then fast-forward merge or direct push

Root cause:

Not knowing when to use rebase vs merge leads to cluttered history.

Key Takeaways

Git merge combines changes from one branch into another, preserving history and enabling collaboration.

Merges can be fast-forward or create new commits depending on branch divergence.

Conflicts occur when changes overlap and must be resolved manually to complete the merge.

Merge options and strategies give control over how history looks and how conflicts are handled.

Understanding Git's internal merge algorithm explains why merges are reliable and how they preserve project history.