Git & Version Control Branching and Merging Syllabus

What does git merge --ff-only do?

It performs the merge only if it can be done as a fast-forward; otherwise it aborts with an error instead of creating a merge commit.

What is a three-way merge?

A merge that uses three commits: the two branch tips and their common ancestor (merge base). Git compares each side against the base to combine changes and creates a new merge commit with two parents.

What is the 'merge base' in a three-way merge?

The best common ancestor commit of the two branches being merged. It serves as the reference point for determining what changed on each side. You can find it with git merge-base A B.

How many parents does a merge commit created by a three-way merge have?

Two parents: the tip of the branch you were on (first parent) and the tip of the branch you merged in (second parent).

What is a squash merge, and what command performs it?

git merge --squash <branch>. It combines all changes from the branch into your working tree/index as a single set of staged changes, which you then commit as one commit. No merge commit and no second parent are recorded.

How does a squash merge affect branch history compared to a regular merge?

A squash merge produces a single new commit with no link (parent) to the merged branch, so the branch's individual commits and merge relationship are not preserved in history.

After 'git merge --squash <branch>', why must you run git commit manually?

Because --squash stages the combined changes but deliberately does not create the commit, letting you write a single consolidated commit message.

How do you abort a merge that has stopped due to conflicts?

git merge --abort. It restores the working tree and index to the state before the merge began (equivalent to resetting to MERGE_HEAD's pre-merge state).

After resolving conflicts, how do you complete/continue a merge?

Stage the resolved files with git add, then run git commit (or git merge --continue) to create the merge commit.

What does the file .git/MERGE_HEAD indicate during a merge?

It records the commit(s) being merged in and signals that a merge is in progress. Its presence lets Git know the next commit should be a merge commit and enables git merge --abort.

What do the conflict markers <<<<<<<, =======, and >>>>>>> delimit?

<<<<<<< marks the start of your current branch's version (ours), ======= separates the two versions, and >>>>>>> marks the end of the incoming branch's version (theirs).

In a conflict block, which side appears above the ======= line and which appears below?

Above =======: the current branch's content (labeled HEAD / 'ours'). Below =======: the incoming branch's content ('theirs'), ending at >>>>>>> with the branch/commit name.

What is the diff3 conflict style and what extra information does it add?

The diff3 style (git config merge.conflictstyle diff3) adds a third section marked ||||||| showing the original common-ancestor (base) content, so you can see what both sides changed from.

What are the manual steps to resolve a merge conflict?

1) Open each conflicted file. 2) Edit to keep the desired content and remove all conflict markers. 3) git add the file to mark it resolved. 4) git commit to finish the merge.

How do you list which files are currently conflicted?

git status shows them under 'Unmerged paths'. You can also use git diff --name-only --diff-filter=U to list only conflicted files.

During a conflict, what do 'git checkout --ours <file>' and '--theirs <file>' do?

They resolve the file by taking one entire side: --ours keeps the current branch's version, --theirs keeps the incoming branch's version, discarding the other side's changes for that file.

What command launches a configured graphical merge tool to resolve conflicts?

git mergetool. It opens the tool set in the merge.tool config (e.g., meld, kdiff3, vimdiff) for each conflicted file.

In a typical three-pane merge tool, what do LOCAL, REMOTE, and BASE represent?

LOCAL = your current branch's version (ours), REMOTE = the incoming branch's version (theirs), BASE = the common ancestor. The center/output pane is the merged result you produce.

How do you configure a default merge tool?

git config --global merge.tool <toolname> (e.g., meld). You can also set mergetool.<tool>.path if the executable is not on PATH.

Name three practical strategies to avoid merge conflicts.

1) Pull/rebase from the shared branch frequently to stay current. 2) Keep branches short-lived and changes small/focused. 3) Coordinate so team members avoid editing the same lines/files, and use consistent formatting to reduce spurious conflicts.

How does frequently integrating (small, frequent merges/pulls) reduce conflicts?

It keeps divergence small, so each merge reconciles fewer differences. Long-lived branches accumulate many changes that overlap, dramatically raising conflict likelihood and difficulty.

What is the fundamental difference between merge and rebase?

Merge combines two histories by creating a new merge commit, preserving the actual branching structure. Rebase replays your commits on top of another base commit, creating new commits and producing a linear history.

Does rebase modify existing commits, and what does that imply about their SHAs?

Rebase creates new commits with new SHA-1 hashes (rewriting history), even if the content is identical, because a commit's hash depends on its parent and metadata. The originals become unreferenced.

When is merge preferred over rebase, and vice versa?

Merge is preferred for integrating shared/public branches and preserving true history. Rebase is preferred for cleaning up local commits before sharing and for keeping a linear, readable history on private branches.

What command starts an interactive rebase over the last 3 commits?

git rebase -i HEAD~3. It opens an editor with a to-do list of those commits to reorder, edit, squash, or drop.

Name the common interactive rebase actions (todo commands) and their effects.

pick (keep commit), reword (change message), edit (pause to amend), squash (combine into previous, keep both messages), fixup (combine into previous, discard its message), drop (remove commit).

What is the difference between 'squash' and 'fixup' in interactive rebase?

Both merge a commit into the preceding one. squash lets you combine and edit both commit messages; fixup discards the squashed commit's message, keeping only the previous one's.

State the Golden Rule of Rebasing.

Never rebase commits that have been pushed to a shared/public branch that others may have based work on. Rebasing rewrites history and forces collaborators into painful re-syncs.

Why does violating the Golden Rule of Rebasing cause problems for collaborators?

Rebasing replaces shared commits with new ones (different SHAs). Others still have the old commits, so their histories diverge, producing duplicate commits and confusing merges when they pull.

How do you resolve conflicts during a rebase and continue?

Edit and stage the conflicted files with git add, then run git rebase --continue. Use git rebase --skip to drop the current commit, or git rebase --abort to cancel and restore the original branch.

During a rebase conflict, what do 'ours' and 'theirs' refer to (and why is it counterintuitive)?

In rebase, 'ours' is the branch you are rebasing onto (the new base), and 'theirs' is your commit being replayed. This is reversed from merge because rebase applies your commits on top of the base.

What is the difference between a lightweight tag and an annotated tag?

A lightweight tag is just a name pointing to a commit (like a fixed branch). An annotated tag is a full object stored in the database with tagger name, email, date, message, and optional GPG signature.

How do you create a lightweight tag versus an annotated tag?

Lightweight: git tag <name>. Annotated: git tag -a <name> -m "message" (or -s for a signed tag). Annotated is recommended for releases.

By default, does git push send tags to the remote, and how do you push them?

No. Tags are not pushed automatically. Push one with git push origin <tagname>, or push all tags with git push origin --tags (use --follow-tags to push annotated tags reachable from pushed commits).