Merge commit creation in Git - Deep Dive

Overview - Merge commit creation

What is it?

A merge commit is a special commit in Git that combines the histories of two branches. It records the point where branches come together, preserving the changes from both. This commit has more than one parent, showing that it merges multiple lines of development. It helps keep track of how different work streams are integrated.

Why it matters

Without merge commits, it would be hard to see how different branches combined their changes, making collaboration confusing. Merge commits solve the problem of integrating parallel work while keeping a clear history. Without them, developers might lose track of what changes came from where, leading to mistakes and conflicts.

Where it fits

Before learning about merge commits, you should understand basic Git concepts like commits, branches, and how to switch between them. After mastering merge commits, you can explore advanced topics like rebasing, conflict resolution, and Git workflows for teams.

Mental Model

Core Idea

A merge commit is a snapshot that joins two separate lines of work into one, preserving both histories.

Think of it like...

Imagine two friends writing separate chapters of a story. A merge commit is like stitching their chapters together into one book, showing where each friend’s part ends and the other begins.

Branch A ──●─────●─────●─────┐
                      \     
                       Merge Commit (joins Branch A and B)
                      /     
Branch B ──●─────●─────●─────┘

Build-Up - 7 Steps

1

Foundation

Understanding Git commits and branches

Concept: Learn what commits and branches are in Git and how they represent changes and parallel work.

A commit is like a snapshot of your project at a point in time. Branches are separate lines of development that let you work on features independently. You can switch between branches to work on different tasks without mixing changes.

Result

You can create commits and branches to organize your work in Git.

Knowing commits and branches is essential because merge commits combine these separate lines of work.

2

Foundation

What is a merge in Git?

Concept: Introduce the idea of combining two branches into one using a merge.

When you finish work on a branch, you often want to bring those changes back into the main branch. Git merge takes the changes from one branch and integrates them into another. This can happen automatically or require manual conflict resolution.

Result

You understand that merging combines work from different branches.

Understanding merging is key to collaboration and integrating parallel work.

3

Intermediate

How merge commits are created

🤔Before reading on: do you think a merge commit always happens when merging branches? Commit to your answer.

Concept: Explain that merge commits are created when Git combines branches with different histories, and when fast-forward merges are not possible.

If the branch you merge has new commits that the current branch doesn’t have, Git creates a merge commit to join them. This commit has two parents: one from each branch. If the current branch can just move forward to the other branch’s commit (fast-forward), no merge commit is made.

Result

You see that merge commits appear only when histories diverge and need joining.

Knowing when merge commits happen helps you understand your project’s history and why some merges create extra commits.

4

Intermediate

Using git merge command to create merge commits

🤔Before reading on: do you think 'git merge' always creates a merge commit or only sometimes? Commit to your answer.

Concept: Learn the command to merge branches and how to force a merge commit even if fast-forward is possible.

The command 'git merge branch-name' merges the specified branch into your current branch. If possible, Git fast-forwards. To always create a merge commit, use 'git merge --no-ff branch-name'. This keeps the merge visible in history.

Result

You can merge branches and control whether a merge commit is created.

Understanding merge options lets you keep a clear project history that shows when features were integrated.

5

Intermediate

Resolving conflicts during merge commits

🤔Before reading on: do you think Git automatically merges all changes without problems? Commit to your answer.

Concept: Introduce merge conflicts and how to resolve them before completing a merge commit.

Sometimes changes in two branches affect the same lines of code differently. Git cannot decide which to keep and stops the merge. You must open the conflicting files, choose or combine changes, then mark conflicts as resolved. After that, you complete the merge commit.

Result

You learn to handle conflicts so merges can finish successfully.

Knowing how to resolve conflicts prevents merge failures and keeps your project stable.

6

Advanced

Merge commit’s role in project history and visualization

🤔Before reading on: do you think merge commits make history more complex or clearer? Commit to your answer.

Concept: Explore how merge commits affect the Git history graph and why they are important for understanding project evolution.

Merge commits create branches in the history graph, showing where work diverged and joined. Tools like 'git log --graph' visualize this. This helps teams see which features were developed separately and when they merged, aiding debugging and audits.

Result

You can interpret Git history graphs and understand the significance of merge commits.

Recognizing merge commits in history helps you track development flow and collaboration points.

7

Expert

Surprising effects of merge commits on rebasing and workflows

🤔Before reading on: do you think merge commits simplify or complicate rebasing? Commit to your answer.

Concept: Understand how merge commits interact with rebasing and why some workflows prefer avoiding them.

Rebasing rewrites commit history to create a linear sequence, which can remove merge commits. This can simplify history but loses the record of branch merges. Some teams prefer merge commits to keep full context, while others use rebasing to keep history clean. Knowing this tradeoff is key to choosing workflows.

Result

You grasp the impact of merge commits on advanced Git workflows and history rewriting.

Understanding merge commits’ interaction with rebasing helps you pick the right workflow for your team’s needs.

Under the Hood

When Git creates a merge commit, it records a new commit object with two parent commits, linking the histories of both branches. Internally, Git combines the file trees from both parents, resolving differences. The merge commit stores the combined snapshot and metadata about the merge, enabling Git to track the integration point.

Why designed this way?

Merge commits were designed to preserve the full history of parallel development, making it clear when and how branches combined. Alternatives like fast-forward merges simplify history but lose this context. The two-parent commit structure allows Git to represent complex branching and merging naturally.

┌─────────────┐       ┌─────────────┐
│ Branch A    │       │ Branch B    │
│ Commit X   ─┼───────┼─ Commit Y   │
└─────────────┘       └─────────────┘
          \                 /
           └───── Merge Commit ─────┘
                 (two parents)

Myth Busters - 4 Common Misconceptions

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

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

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

Why it matters: Expecting a merge commit when none appears can confuse developers about what happened to their changes.

Quick: Can a merge commit have only one parent? Commit yes or no.

Common Belief: A merge commit is just like any other commit with one parent.

Reality: A merge commit always has two or more parents, representing the branches it merges.

Why it matters: Misunderstanding this can lead to incorrect assumptions about project history and merge behavior.

Quick: Does rebasing keep merge commits intact? Commit yes or no.

Common Belief: Rebasing preserves all merge commits in history.

Reality: Rebasing rewrites history and usually removes merge commits, creating a linear history.

Why it matters: Not knowing this can cause confusion when merge commits disappear after rebasing.

Quick: Is resolving conflicts optional during a merge? Commit yes or no.

Common Belief: Git automatically resolves all conflicts during merges.

Reality: Git stops the merge when conflicts occur and requires manual resolution before completing the merge commit.

Why it matters: Ignoring conflicts can cause broken code or incomplete merges.

Expert Zone

1

Merge commits can include detailed commit messages explaining the merge context, which is valuable for audits and reviews.

2

Using '--no-ff' forces a merge commit even when fast-forward is possible, preserving branch history explicitly.

3

Merge commits affect Git’s internal graph traversal algorithms, influencing commands like 'git bisect' and 'git blame'.

When NOT to use

Avoid merge commits in workflows that require a clean, linear history, such as when using rebase-heavy feature integration. Instead, use 'git rebase' to replay commits on top of the main branch. Merge commits are also less suitable for very small or trivial changes where history clarity is less important.

Production Patterns

Teams often use merge commits to mark feature completion points in main branches, enabling clear release tracking. Pull request merges on platforms like GitHub create merge commits by default to preserve branch context. Some projects combine merge commits with squash merges to balance history clarity and simplicity.

Connections

Version Control Systems

Builds-on

Understanding merge commits deepens knowledge of how version control systems manage parallel development and history.

Conflict Resolution

Builds-on

Merge commits often require conflict resolution skills, linking Git usage to problem-solving in collaborative environments.

Project Management

Builds-on

Merge commits provide a timeline of feature integration, helping project managers track progress and coordinate releases.

Common Pitfalls

#1 Expecting a merge commit when Git fast-forwards instead.

Wrong approach:

git merge feature-branch
# No merge commit created because fast-forward happened

Correct approach:

git merge --no-ff feature-branch
# Forces creation of a merge commit even if fast-forward is possible

Root cause:

Not understanding Git’s fast-forward behavior and how to control merge commit creation.

#2 Ignoring merge conflicts and completing merge without resolution.

Wrong approach:

git merge feature-branch
# Conflicts occur but user runs 'git commit' without resolving

Correct approach:

git merge feature-branch
# Resolve conflicts in files
git add resolved-files
git commit
# Completes merge commit properly

Root cause:

Misunderstanding that conflicts must be manually resolved before finishing a merge.

#3 Using rebase without knowing it removes merge commits.

Wrong approach:

git rebase main
# Merge commits disappear, history linearized

Correct approach:

git merge feature-branch
# Keeps merge commits and full branch history

Root cause:

Not realizing rebasing rewrites history and removes merge commits.

Key Takeaways

Merge commits join two branches by creating a commit with multiple parents, preserving both histories.

Git creates merge commits only when histories diverge; otherwise, it fast-forwards without extra commits.

Merge commits help visualize project history and collaboration points, aiding debugging and audits.

Conflicts during merges must be resolved manually before completing the merge commit.

Understanding merge commits’ interaction with rebasing helps choose the right workflow for your team.

Practice

1. What does a git merge <branch-name> command do in Git?

easy

A. Combines changes from the specified branch into the current branch with a merge commit

B. Deletes the specified branch from the repository

C. Creates a new branch named after the specified branch

D. Resets the current branch to the specified branch's state without merging

Solution

1. Step 1: Understand the purpose of git merge

   The git merge <branch-name> command is used to combine changes from another branch into the current branch.

2. Step 2: Identify the result of the merge

   This operation creates a merge commit that records the integration of changes from both branches.

3. Final Answer:

   Combines changes from the specified branch into the current branch with a merge commit -> Option A

4. Quick Check:

   Merge command = combine branches with commit [OK]

Hint: Merge means combine branches with a commit [OK]

Common Mistakes:

• Confusing merge with branch deletion
• Thinking merge creates a new branch
• Assuming merge resets branch without commit

2. Which of the following is the correct syntax to create a merge commit from branch feature into the current branch?

easy

A. git merge feature

B. git merge -b feature

C. git merge --delete feature

D. git merge --reset feature

Solution

1. Step 1: Recall the basic merge syntax

   The correct syntax to merge a branch is git merge <branch-name> without extra flags for a normal merge commit.

2. Step 2: Evaluate the options

   git merge feature matches the correct syntax. The other options use invalid or unrelated flags.

3. Final Answer:

   git merge feature -> Option A

4. Quick Check:

   Simple merge = git merge branch [OK]

Hint: Use 'git merge branch-name' to merge simply [OK]

Common Mistakes:

• Adding unnecessary flags like -b or --delete
• Confusing merge with branch creation or deletion commands
• Using reset flag which is unrelated to merge

3. Given the following commands executed in order:

git checkout main
git merge feature

What will Git do if there are no conflicts between main and feature and the branches have diverged?

medium

A. Reset main branch to feature branch state without commit

B. Delete the feature branch automatically

C. Create a merge commit combining changes from feature into main

D. Fail with an error asking to resolve conflicts

Solution

1. Step 1: Understand the merge process without conflicts

   If there are no conflicts and the branches have diverged, Git will automatically create a merge commit combining changes from the feature branch into main.

2. Step 2: Confirm no branch deletion or errors occur

   Git does not delete branches or reset branches automatically during merge without conflicts.

3. Final Answer:

   Create a merge commit combining changes from feature into main -> Option C

4. Quick Check:

   No conflicts + diverged = auto merge commit [OK]

Hint: No conflicts + diverged means merge commit created automatically [OK]

Common Mistakes:

• Thinking feature branch is deleted after merge
• Expecting errors when no conflicts exist
• Confusing merge with reset or branch deletion

4. You run git merge feature but Git reports conflicts. What should you do next to complete the merge?

medium

A. Delete the current branch and recreate it to fix conflicts

B. Run git merge --abort to cancel the merge and delete the feature branch

C. Run git reset --hard to force merge without fixing conflicts

D. Manually fix conflicts in files, then run git add and git commit

Solution

1. Step 1: Understand conflict resolution process

   When Git reports conflicts, you must manually fix the conflicting files by editing them.

2. Step 2: Complete the merge after fixing conflicts

   After fixing, stage the changes with git add and finish the merge with git commit.

3. Final Answer:

   Manually fix conflicts in files, then run git add and git commit -> Option D

4. Quick Check:

   Fix conflicts, add, commit to complete merge [OK]

Hint: Fix conflicts manually, then add and commit [OK]

Common Mistakes:

• Aborting merge and deleting branches unnecessarily
• Using reset to skip conflict resolution
• Deleting branches instead of resolving conflicts

5. You want to merge branch feature into main but avoid creating a merge commit. Which command should you use?

hard

A. git merge --no-ff feature

B. git merge --squash feature

C. git merge --ff-only feature

D. git merge --abort feature

Solution

1. Step 1: Understand merge commit creation options

   The --squash option merges changes without creating a merge commit by combining all changes into one commit.

2. Step 2: Compare other options

   --no-ff forces a merge commit, --ff-only only merges if fast-forward is possible, and --abort cancels merges.

3. Final Answer:

   git merge --squash feature -> Option B

4. Quick Check:

   Squash merges without merge commit [OK]

Hint: Use --squash to merge without merge commit [OK]

Common Mistakes:

• Using --no-ff which forces merge commit
• Confusing --ff-only with no commit creation
• Trying to abort merge to avoid commit