Why merging combines work in Git - Why It Works This Way

Overview - Why merging combines work

What is it?

Merging in git is the process of combining changes from different branches into one. It takes the work done separately and brings it together so the project has all updates in one place. This helps teams work on different features or fixes at the same time without losing any progress. Merging ensures that everyone's contributions become part of the main project smoothly.

Why it matters

Without merging, developers would have to manually copy and paste changes, which is slow and error-prone. Merging solves the problem of combining parallel work safely and efficiently. It keeps the project history clear and helps avoid losing or overwriting someone else's work. This makes teamwork faster, less stressful, and more reliable.

Where it fits

Before learning merging, you should understand git basics like commits, branches, and how to switch between them. After mastering merging, you can explore advanced topics like resolving conflicts, rebasing, and managing complex workflows in teams.

Mental Model

Core Idea

Merging is the act of joining two sets of changes into one combined version that includes all work done.

Think of it like...

Imagine two friends writing different parts of a story on separate sheets of paper. Merging is like putting their pages together into one book so the full story is complete.

┌─────────────┐       ┌─────────────┐
│ Branch A    │       │ Branch B    │
│ (Work done) │       │ (Work done) │
└──────┬──────┘       └──────┬──────┘
       │                     │
       │                     │
       └───────┬─────────────┘
               │
         ┌─────▼─────┐
         │  Merge    │
         │ Combines  │
         │ Changes   │
         └─────┬─────┘
               │
         ┌─────▼─────┐
         │ Combined  │
         │ Branch    │
         │ (All work)│
         └───────────┘

Build-Up - 7 Steps

1

Foundation

Understanding branches in git

Concept: Branches let you work on different versions of a project separately.

In git, a branch is like a copy of your project where you can make changes without affecting the main version. You can switch between branches to work on different features or fixes independently.

Result

You can create and switch branches to isolate your work.

Knowing branches is essential because merging combines these separate lines of work.

2

Foundation

What is a commit in git

Concept: A commit records a snapshot of your project changes at a point in time.

Every time you save your work in git, you create a commit. It stores what changed and a message describing the update. Commits build the history of your project.

Result

You have a timeline of changes that can be reviewed or combined.

Understanding commits helps you see what merging actually combines.

3

Intermediate

How merging combines branches

🤔Before reading on: do you think merging replaces one branch with another or combines both? Commit to your answer.

Concept: Merging takes the changes from one branch and adds them to another, keeping all work.

When you merge, git looks at the changes made in both branches since they split. It then creates a new commit that includes all those changes together. This way, no work is lost, and the project has everything from both branches.

Result

The target branch now contains all changes from both branches.

Understanding that merging preserves all work prevents confusion about losing changes.

4

Intermediate

Fast-forward merges explained

🤔Before reading on: do you think fast-forward merges create new commits or just move pointers? Commit to your answer.

Concept: If one branch has no new commits since branching, merging just moves the pointer forward.

When the target branch has no new work, git can simply move its pointer to the latest commit of the other branch. This is called a fast-forward merge and does not create a new commit.

Result

The branch history looks like a straight line with no extra merge commit.

Knowing fast-forward merges helps you understand why sometimes merges seem invisible.

5

Intermediate

Merge commits and conflict basics

🤔Before reading on: do you think git always merges automatically without problems? Commit to your answer.

Concept: When both branches change the same part, git asks you to fix conflicts before merging.

If changes overlap, git cannot decide which to keep. It marks the conflict in files and stops the merge. You must manually choose or combine the changes, then complete the merge.

Result

The merge includes all changes after you resolve conflicts.

Understanding conflicts is key to managing merges in real projects.

6

Advanced

Three-way merge process in git

🤔Before reading on: do you think git merges by comparing only two versions or three? Commit to your answer.

Concept: Git uses three commits to merge: the two branch tips and their common ancestor.

Git finds the common ancestor commit where branches split. It compares changes from that point to each branch tip. Then it combines these differences to create the merge commit.

Result

The merge commit accurately reflects all changes from both branches.

Knowing the three-way merge explains why git can merge complex histories reliably.

7

Expert

Why merging preserves history and context

🤔Before reading on: do you think merging rewrites history or keeps all commits intact? Commit to your answer.

Concept: Merging keeps all commits from both branches, preserving the full history and context of changes.

Unlike rebasing, merging adds a new commit that links both histories without changing existing commits. This keeps the timeline clear and shows when and how work was combined.

Result

Project history remains complete and understandable for future review.

Understanding history preservation helps you choose merging for safe collaboration.

Under the Hood

Git stores commits as snapshots linked by pointers. When merging, git finds the common ancestor commit of the branches. It compares changes from that ancestor to each branch tip, then combines these changes into a new merge commit. This commit has two parents, linking both histories. If changes overlap, git flags conflicts for manual resolution. Fast-forward merges simply move the branch pointer without creating a new commit.

Why designed this way?

Git was designed for distributed teams working independently. The three-way merge and merge commits preserve all work and history, enabling safe collaboration without overwriting. Alternatives like linear history rewriting (rebasing) exist but can lose context or cause confusion. The merge approach balances safety, clarity, and flexibility.

Common Ancestor
      │
 ┌────┴────┐
 │         │
Branch A  Branch B
 │         │
 └────┬────┘
      │
  Merge Commit
 (combines both)

Myth Busters - 4 Common Misconceptions

Quick: Does merging delete the source branch automatically? Commit yes or no.

Common Belief: Merging deletes the source branch and its work.

Reality: Merging only combines changes; it does not delete any branch or its commits.

Why it matters: Believing this causes confusion and fear of losing work when merging.

Quick: Does git always merge changes automatically without conflicts? Commit yes or no.

Common Belief: Git merges always happen automatically without any manual work.

Reality: Git can require manual conflict resolution when changes overlap.

Why it matters: Ignoring conflicts leads to broken code or lost changes.

Quick: Does a fast-forward merge create a new commit? Commit yes or no.

Common Belief: All merges create a new merge commit.

Reality: Fast-forward merges just move the branch pointer without new commits.

Why it matters: Misunderstanding this leads to confusion about project history.

Quick: Does merging rewrite history by changing old commits? Commit yes or no.

Common Belief: Merging rewrites existing commits and changes history.

Reality: Merging preserves all commits and adds a new merge commit without rewriting history.

Why it matters: Confusing merging with rebasing can cause mistakes in collaboration.

Expert Zone

1

Merge commits provide a clear record of when and how branches combined, which is crucial for auditing and debugging.

2

Fast-forward merges keep history linear but hide the fact that work was done on a separate branch, which can be misleading in complex projects.

3

Conflict markers in files are temporary and must be removed carefully to avoid introducing bugs.

When NOT to use

Merging is not ideal when you want a clean, linear history; in such cases, rebasing is preferred. Also, avoid merging large, long-lived branches frequently without syncing, as conflicts become harder to resolve.

Production Patterns

Teams often use feature branches merged into main branches via pull requests. Merge commits document integration points. Continuous integration systems trigger tests on merge commits to ensure combined work is stable.

Connections

Version Control Systems

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

Understanding merging deepens comprehension of how distributed teams coordinate changes safely.

Conflict Resolution in Negotiations

Both involve combining differing inputs and resolving disagreements to reach a shared outcome.

Knowing how git handles merge conflicts can inspire better strategies for resolving human conflicts by identifying overlaps and compromises.

Database Transactions

Merging changes is similar to combining multiple transactions ensuring consistency and no data loss.

Seeing merging as a consistency mechanism helps appreciate its role in maintaining project integrity.

Common Pitfalls

#1 Trying to merge without committing local changes first.

Wrong approach:

git merge feature-branch
# Error: You have uncommitted changes.

Correct approach:

git add .
git commit -m "Save work"
git merge feature-branch

Root cause:

Git requires a clean working directory to merge safely; uncommitted changes block merging.

#2 Ignoring merge conflicts and forcing merge completion.

Wrong approach:

git merge feature-branch
git commit -m "Merge" --no-edit
# Conflict markers remain in files

Correct approach:

git merge feature-branch
# Resolve conflicts manually
git add resolved-files
git commit

Root cause:

Conflicts must be resolved manually; skipping this leaves broken code.

#3 Deleting a branch before merging its changes.

Wrong approach:

git branch -d feature-branch
git merge feature-branch
# Error: branch not found

Correct approach:

git merge feature-branch
git branch -d feature-branch

Root cause:

You must merge first to combine work, then delete the branch safely.

Key Takeaways

Merging in git combines changes from different branches into one unified project version.

It preserves all commits and history, making collaboration safe and clear.

Fast-forward merges move pointers without new commits, while three-way merges create merge commits.

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

Understanding merging is essential for effective teamwork and managing parallel development.