Git Fundamentals: Commits, Branches, Merge, and Rebase

FAUN.dev() is where engineers from GitHub, Netflix, and Shopify go to stay ahead — fast.

An effortless, straightforward way to keep up with technologies...so you can keep your tabs closed and your mind open!

70,000+ developers already joined our ecosystem ⭐⭐⭐⭐⭐
Trusted by engineers at:

Google • Microsoft • AWS • Netflix

Take the quiz

Your score will show up right here.

Git Fundamentals: Commits, Branches, Merge, and Rebase

A 10-question quiz on how Git actually works under the hood, escalating from easy to hard. It covers what a commit really stores, branches as pointers, fast-forward vs merge commits, what rebase does to your history, the golden rule of rebasing, reset vs revert, and detached HEAD.

What does a Git commit actually store?

Only the set of line-by-line changes (a diff) relative to the previous commit.
A complete snapshot of the tracked project state, referenced through a tree object, plus metadata such as author and message and a pointer to its parent commit or commits.
A fresh copy of the entire repository history up to that point.

In Git, what is a branch?

A lightweight, movable pointer to a single commit.
A separate copy of the repository's files kept in its own directory.
The full range of commits from the project's first commit up to where the branch forked off.

You merge a feature branch into main, and main has received no new commits since the feature branch was created. By default, what does Git do?

It creates a merge commit with two parents to record the integration.
It automatically rebases the feature commits onto main.
It performs a fast-forward, simply advancing the main pointer to the feature branch's tip, with no merge commit created.

How many parent commits does a normal (non-fast-forward) merge commit have?

One
Two
Zero

What does git rebase do when you rebase your feature branch onto main?

It sets your feature commits aside, moves the branch base to the tip of main, then replays your commits one by one on top, creating new commits.
It moves your original commit objects unchanged onto main and deletes main's recent commits.
It creates a single merge commit that ties the two branches together.

After rebasing your feature branch, how do the rebased commits compare to your original ones?

They are the exact same commit objects, with identical hashes, just reordered.
They keep their original hashes but each gains a second parent.
They contain the same changes but have new hashes, because a commit's hash depends on its content and its parent, and the rebase gave each one a new parent.

What is the "golden rule" of rebasing?

Always rebase instead of merging, so that history stays perfectly linear.
Never rebase commits that have already been pushed and shared with other people.
Only rebase after first creating a merge commit to preserve the old history.

What is the key difference between git reset and git revert when undoing a commit?

reset moves the branch pointer backward, dropping commits from the branch's history, while revert creates a new commit that applies the inverse of the target commit, leaving history intact.
reset only ever touches the staging area and can never affect commits, while revert only changes the working directory.
They are two names for the same operation, differing only in how verbose their output is.

After integrating a feature branch, how do merge and rebase compare in terms of the final file contents (the working tree)?

Rebase always produces different final files, because it rewrites the changes themselves.
Merge always ends up with more of the code, since rebase drops some commits.
Both can produce identical final file contents; the difference is the shape of the recorded history, not the end state of the files.

You run git checkout on a specific commit hash rather than a branch name. What state are you in?

Git has automatically created a new branch named after the commit hash.
You are in a "detached HEAD" state, where HEAD points directly at that commit instead of a branch, so any new commits you make belong to no branch.
You have permanently reset main to point at that commit.