Rebase vs merge mental model in Git - Hands-On Comparison

Rebase vs Merge Mental Model

📖 Scenario: You are working on a shared project with a friend. Both of you make changes in separate branches. Now, you want to combine your friend's changes into your branch. There are two ways to do this: merge and rebase. Understanding the difference helps keep the project history clean and easy to follow.

🎯 Goal: Learn how to use git merge and git rebase commands to combine changes from one branch into another, and understand the difference in how they affect the project history.

📋 What You'll Learn

Create two branches: main and feature

Add commits to both branches

Use git merge to combine feature into main

Use git rebase to replay feature commits on top of main

Observe the difference in commit history

💡 Why This Matters

🌍 Real World

Developers often work on separate branches and need to combine their work. Choosing between merge and rebase affects how the project history looks and how easy it is to understand changes.

💼 Career

Knowing when and how to use git merge and rebase is essential for collaboration in software teams, making you a better team player and improving code quality.

1

Setup initial repository and branches

Initialize a new git repository. Create a file called file.txt with the text Initial content. Commit this change on the main branch. Then create a new branch called feature.

Git

# Initialize git repo and create main branch commit
# Your code here

Hint

Use git init to start the repo. Use echo to create the file. Use git add and git commit to save changes. Use git branch feature to create the branch.

2

Add commits to both branches

Switch to the feature branch. Add a line Feature work to file.txt and commit it with message Feature commit. Then switch back to main branch. Add a line Main work to file.txt and commit it with message Main commit.

Git

git init
...
git branch feature
# Add commit on feature branch and main branch
# Your code here

Hint

Use git checkout to switch branches. Use >>> to add lines to the file. Commit each change with git commit -m.

3

Merge feature branch into main

On the main branch, run git merge feature to combine the changes from feature branch. This will create a merge commit.

Git

git init
...
git commit -m "Main commit"
# Merge feature branch into main
# Your code here

Hint

Make sure you are on main branch, then run git merge feature.

4

Rebase feature branch onto main

Reset the repository to before the merge (for example, by running git reset --hard HEAD~1 on main). Then switch to the feature branch and run git rebase main to replay feature commits on top of main. Finally, switch back to main and merge feature with a fast-forward merge using git merge feature.

Git

git init
...
git merge feature
# Reset merge commit, rebase feature on main, then fast-forward merge
# Your code here

Hint

Use git reset --hard HEAD~1 to undo the merge commit. Then rebase feature on main. Finally, merge with fast-forward.

Practice

1. What is the main difference between git merge and git rebase?

easy

A. git merge rewrites commit messages; git rebase preserves commit messages.

B. git merge deletes the source branch; git rebase deletes the target branch.

C. git merge only works on remote branches; git rebase only works on local branches.

D. git merge combines histories preserving all commits; git rebase rewrites history to create a linear sequence.

Solution

1. Step 1: Understand git merge behavior

   git merge combines two branches by creating a new commit that preserves the history of both branches without changing existing commits.

2. Step 2: Understand git rebase behavior

   git rebase moves or reapplies commits from one branch onto another, rewriting history to make it look like a straight line.

3. Final Answer:

   git merge combines histories preserving all commits; git rebase rewrites history to create a linear sequence. -> Option D

4. Quick Check:

   Merge preserves history, rebase rewrites it [OK]

Hint: Merge keeps history; rebase rewrites it linearly [OK]

Common Mistakes:

• Thinking merge deletes branches
• Believing rebase only works on remote branches
• Confusing which command rewrites history

2. Which of the following is the correct syntax to rebase the current branch onto main?

easy

A. git rebase main

B. git merge main

C. git rebase origin/main

D. git checkout main && git rebase

Solution

1. Step 1: Identify the command to rebase current branch

   The command git rebase main rebases the current branch onto the main branch.

2. Step 2: Check other options for correctness

   git merge main merges, not rebases; git rebase origin/main rebases onto remote tracking branch which may be outdated; git checkout main && git rebase is invalid syntax.

3. Final Answer:

   git rebase main -> Option A

4. Quick Check:

   Rebase current branch onto main = git rebase main [OK]

Hint: Use 'git rebase branch-name' to rebase current branch [OK]

Common Mistakes:

• Using merge instead of rebase
• Rebasing onto remote branch without fetching
• Incorrect chaining of commands

3. Given the following commands executed in order on branch feature:

git checkout feature
git rebase main
git log --oneline --graph

What will the commit history look like compared to using git merge main instead?

medium

A. A linear history with feature commits on top of main commits.

B. A merge commit combining main and feature histories.

C. No change in history; feature branch remains separate.

D. Feature branch commits are deleted.

Solution

1. Step 1: Understand effect of git rebase main on feature branch

   Rebasing moves feature commits to be based on the latest main commits, creating a straight, linear history.

2. Step 2: Compare with git merge main effect

   Merging creates a new merge commit that combines histories, preserving the branch structure and showing a branch point.

3. Final Answer:

   A linear history with feature commits on top of main commits. -> Option A

4. Quick Check:

   Rebase = linear history; merge = merge commit [OK]

Hint: Rebase = linear history; merge = merge commit [OK]

Common Mistakes:

• Thinking rebase creates merge commits
• Believing history stays unchanged after rebase
• Assuming commits are deleted after rebase

4. You ran git rebase main on your feature branch but got conflicts. After resolving conflicts, which command should you run to continue the rebase?

medium

A. git commit -m 'resolved conflicts'

B. git merge --continue

C. git rebase --continue

D. git rebase --abort

Solution

1. Step 1: Identify the correct command to continue rebase after conflicts

   After resolving conflicts during a rebase, git rebase --continue tells Git to proceed with applying remaining commits.

2. Step 2: Understand other options

   git merge --continue is for merge conflicts, not rebase; git commit -m is manual commit but rebase expects --continue; git rebase --abort cancels the rebase.

3. Final Answer:

   git rebase --continue -> Option C

4. Quick Check:

   Continue rebase after conflicts = git rebase --continue [OK]

Hint: Use 'git rebase --continue' after resolving conflicts [OK]

Common Mistakes:

• Using merge commands during rebase
• Trying to commit manually instead of continuing
• Aborting instead of continuing rebase

5. You want to update your feature branch with the latest changes from main but keep a clean, linear history without merge commits. Which sequence of commands achieves this safely?

hard

A. git checkout feature; git merge origin/main

B. git checkout feature; git fetch origin; git rebase origin/main

C. git checkout main; git pull; git checkout feature; git merge main

D. git checkout feature; git pull origin main

Solution

1. Step 1: Fetch latest changes from remote main branch

   git fetch origin updates local remote tracking branches without changing working branches.

2. Step 2: Rebase feature branch onto updated origin/main

   git rebase origin/main reapplies feature commits on top of latest main commits, keeping history linear and clean.

3. Final Answer:

   git checkout feature; git fetch origin; git rebase origin/main -> Option B

4. Quick Check:

   Fetch then rebase for clean update [OK]

Hint: Fetch first, then rebase onto remote main for clean history [OK]

Common Mistakes:

• Merging instead of rebasing for linear history
• Pulling directly on feature branch causing merge commits
• Not fetching latest remote changes before rebase