Why rebasing creates linear history in Git - Quick Recap

Recall & Review

beginner

What does rebasing do to your commit history in Git?

Rebasing moves your branch's commits to start from the latest commit of the target branch, creating a straight, linear sequence of commits.

intermediate

How does rebasing differ from merging in terms of commit history?

Merging combines branches by creating a new merge commit, preserving the branch structure, while rebasing rewrites commits to create a linear history without merge commits.

beginner

Why is a linear history beneficial in Git?

A linear history is easier to read and understand because it shows a clear, step-by-step progression of changes without complex branching paths.

intermediate

What happens to your commits during a rebase?

Your commits are temporarily saved, the branch is moved to the new base commit, then your commits are reapplied one by one on top of that base.

intermediate

Can rebasing change commit hashes? Why?

Yes, because rebasing creates new commits based on the old ones but with a different parent, resulting in new commit hashes.

What is the main effect of rebasing a branch in Git?

A It deletes all commits on the branch.

B It creates a linear commit history by moving commits.

C It merges two branches with a merge commit.

D It creates a new branch without commits.

Rebasing moves commits to a new base, making the history linear.

Which Git command rewrites commit history to be linear?

A git merge

B git stash

C git clone

D git rebase

git rebase reapplies commits on top of another base commit, creating linear history.

What does rebasing do to commit hashes?

A Changes them because commits are recreated

B Deletes them

C Keeps them the same

D Merges them

Rebasing creates new commits with new hashes because the parent commit changes.

Why might developers prefer rebasing over merging?

A To delete branches

B To create more merge commits

C To keep a clean, linear history

D To avoid pushing changes

Rebasing keeps history simple and linear, making it easier to follow.

What happens to your commits during a rebase?

A They are saved, branch is moved, then reapplied

B They are deleted permanently

C They are merged into one commit

D They are pushed to remote automatically

Git saves your commits, moves the branch, then reapplies commits on top.

Explain in your own words why rebasing creates a linear history in Git.

Think about how commits are moved and reapplied on top of another branch.

Describe the difference between rebasing and merging regarding commit history.

Consider how each command affects the shape of the commit graph.

Practice

1. What is the main reason rebasing creates a linear history in Git?

easy

A. It creates a new branch automatically

B. It merges all branches into one commit

C. It deletes all previous commits

D. It moves your commits on top of the latest commit from the target branch

Solution

1. Step 1: Understand what rebasing does

   Rebasing takes your commits and places them on top of another branch's latest commit, replaying them in order.

2. Step 2: Effect on commit history

   This action removes the branching structure by making your commits appear as if they were made after the latest commit on the target branch, creating a straight line.

3. Final Answer:

   It moves your commits on top of the latest commit from the target branch -> Option D

4. Quick Check:

   Rebase = replay commits on top [OK]

Hint: Rebase replays commits on latest branch commit [OK]

Common Mistakes:

• Thinking rebase merges commits into one
• Believing rebase deletes old commits
• Confusing rebase with branch creation

2. Which Git command syntax correctly rebases the current branch onto main?

easy

A. git merge main

B. git rebase main

C. git rebase -m main

D. git checkout main rebase

Solution

1. Step 1: Identify the correct rebase command

   The correct syntax to rebase the current branch onto main is git rebase main.

2. Step 2: Check other options for errors

   git merge main merges instead of rebasing; git rebase -m main is invalid syntax; git checkout main rebase is not a valid command.

3. Final Answer:

   git rebase main -> Option B

4. Quick Check:

   Rebase syntax = git rebase branch [OK]

Hint: Use 'git rebase branchname' to rebase [OK]

Common Mistakes:

• Using merge instead of rebase
• Adding invalid flags like -m
• Combining checkout and rebase incorrectly

3. Given this commit history:

main: A --- B --- C
feature: A --- B --- D --- E

After running git rebase main on feature, what will the new commit history look like?

medium

A. main: A --- B --- Cfeature: A --- B --- C --- D' --- E'

B. main: A --- B --- Cfeature: D --- E

C. main: A --- B --- C --- D --- Efeature: A --- B --- C --- D --- E

D. main: A --- B --- Cfeature: A --- B --- D --- E

Solution

1. Step 1: Understand rebase effect on commits

   Rebasing feature onto main moves commits D and E to be based on C, replaying them as new commits D' and E'.

2. Step 2: Visualize new commit history

   The main branch remains unchanged. The feature branch now appears as if commits D' and E' were made after C, creating a linear history.

3. Final Answer:

   main: A --- B --- C
   feature: A --- B --- C --- D' --- E' -> Option A

4. Quick Check:

   Rebase = replay commits on main tip [OK]

Hint: Rebase replays commits after target branch tip [OK]

Common Mistakes:

• Assuming commits stay unchanged
• Thinking rebase merges commits
• Ignoring that rebased commits get new IDs

4. You tried to rebase your branch but got a conflict error. What is the best way to fix this and continue the rebase?

medium

A. Abort the rebase and start over with git rebase --abort

B. Run git merge --continue to resolve conflicts

C. Fix the conflicts manually, then run git rebase --continue

D. Delete the branch and create a new one

Solution

1. Step 1: Understand rebase conflict handling

   When a conflict occurs during rebase, Git pauses and lets you fix conflicts manually in the files.

2. Step 2: Continue rebase after fixing conflicts

   After resolving conflicts, you must run git rebase --continue to proceed with the rebase process.

3. Final Answer:

   Fix the conflicts manually, then run git rebase --continue -> Option C

4. Quick Check:

   Fix conflicts + git rebase --continue [OK]

Hint: Fix conflicts then run 'git rebase --continue' [OK]

Common Mistakes:

• Using merge commands during rebase
• Aborting instead of continuing after fix
• Deleting branch unnecessarily

5. You have two feature branches, feature1 and feature2, both branched from main. feature1 was rebased onto main and pushed. Now you want to rebase feature2 onto feature1. What is the main benefit of this approach?

hard

A. It creates a linear history combining both features without merge commits

B. It deletes feature1 branch automatically

C. It merges feature2 into main directly

D. It resets feature2 to main ignoring feature1

Solution

1. Step 1: Understand rebasing one feature branch onto another

   Rebasing feature2 onto feature1 places feature2's commits on top of feature1, making the history linear.

2. Step 2: Benefit of linear history

   This avoids merge commits and shows a clear sequence of changes, making history easier to read and understand.

3. Final Answer:

   It creates a linear history combining both features without merge commits -> Option A

4. Quick Check:

   Rebase feature2 on feature1 = linear combined history [OK]

Hint: Rebase feature2 on feature1 for clean linear history [OK]

Common Mistakes:

• Thinking rebasing deletes branches
• Confusing rebase with merge into main
• Ignoring the order of branches in rebase