Recap — Fast-Forward, Three-Way, and Merge Commits

# Fast-Forward, Three-Way, and Merge Commits Merging combines work from two branches. The mechanics depend on the history shape. ## Creating and switching branches ```bash git branch feature # create branch (doesn't switch) git switch feature # switch to it git switch -c feature # create AND switch in one command # Older syntax (still works): git checkout -b feature ``` Branches point to commits. Switching moves HEAD. ## Listing branches ```bash git branch # local branches git branch -r # remote-tracking branches git branch -a # all git branch -v # with last commit info ``` The current branch has `*` next to it. ## Fast-forward merge When the target branch hasn't diverged — i.e., all your changes are direct descendants of the current branch — Git just moves the pointer forward. No merge commit needed. ``` Before: main ────→ A → B feature ─────────→ C → D After git switch main; git merge feature: main ────→ A → B → C → D ↑ (just moved the pointer) ``` This is called "fast-forward". No new commit; just pointer movement. When this happens: - The current branch hasn't had any new commits since you branched off. - The branch you're merging in is "ahead" of you. ## Three-way merge When both branches have new commits since they diverged, Git creates a MERGE COMMIT with two parents. ``` Before: → C → D (feature) / main → A → B → E (main moved forward too) After git switch main; git merge feature: → C → D ──┐ / \ main → A → B → E → F (F is the merge commit; two parents: E and D) ``` Git finds the common ancestor (A), then combines: - Changes from main since A (i.e., B, E). - Changes from feature since A (i.e., C, D). - Result becomes commit F. If the changes don't conflict, the merge is automatic. ## Merge conflicts If both branches modified the SAME LINES in the SAME FILE differently, Git can't decide automatically — you get a conflict. ``` Auto-merging file.txt CONFLICT (content): Merge conflict in file.txt Automatic merge failed; fix conflicts and then commit the result. ``` The file has conflict markers: ``` >>>>>> feature ``` You manually edit to resolve: ```python def greeting(): return "Hello, world!" # keep main's version ``` Then: ```bash git add file.txt git commit # finalize the merge ``` ## Abort a merge If a merge got messy and you want to back out: ```bash git merge --abort # restore pre-merge state ``` Safe; nothing lost. ## --no-ff (force a merge commit even when fast-forward is possible) ```bash git merge --no-ff feature ``` Creates a merge commit even if fast-forward would work. Useful for: - Keeping branch history visible. - Required by some team workflows. Trade-off: cleaner linear history vs explicit branch structure. ## Practical patterns ### Pattern 1: Short-lived feature branch (most common) ```bash git switch -c feature/login # work, commit, work, commit git switch main git pull # sync with remote git merge feature/login git push git branch -d feature/login # delete local branch git push origin --delete feature/login # delete remote branch ``` ### Pattern 2: Update feature branch with main's changes While on a feature branch, main got new commits. You want them: ```bash git switch main git pull git switch feature git merge main # bring main's changes into feature # OR rebase (next lesson) ``` ### Pattern 3: Continue when fast-forward isn't an option ```bash git switch main git pull # main has new commits git merge feature # may conflict if both touched same files # resolve conflicts if any git push ``` ## Common merge mistakes 1. **Merging without pulling first.** Push fails because remote is ahead. 2. **Resolving conflicts incorrectly.** Take both sides without thinking; logic breaks. 3. **Forgetting to commit after resolving conflicts.** The merge isn't done until you commit. 4. **Deleting unmerged branches without `--force`.** Git refuses; for safety. 5. **Merging into the wrong branch.** Read carefully before merging. ## Naming branches Conventions vary; common patterns: - `feature/short-description` — new feature. - `bugfix/issue-123` — bug fix tied to an issue. - `hotfix/critical-issue` — urgent production fix. - `release/v1.2` — release branch. Slashes are just naming; Git treats it as a regular branch. ## Deleting branches ```bash git branch -d feature # delete; refuses if unmerged git branch -D feature # force delete (dangerous) git push origin --delete feature # delete on remote ``` Delete merged branches to keep things tidy. ## Takeaway Branches = movable pointers (cheap to create). Switching = move HEAD. Two main merge ty