Back-end Web Developement Version Control Flashcards

24 sample cards from the Version Control deck

Sampled from the end of the deck, so these are different cards from the ones shown on the syllabus page.

1. What are the three main states of a pull request on most platforms?

   Open (under review and discussion), Merged (changes integrated into the target branch), and Closed (rejected or abandoned without merging).

2. What are the three common merge strategies offered when completing a pull request?

   Merge commit (preserves all commits plus a merge commit), Squash and merge (combines all commits into one), and Rebase and merge (replays commits onto the base with no merge commit).

3. What is a 'draft' pull request?

   A draft pull request marks work as in-progress and not yet ready for review or merging. It blocks merging and signals to reviewers that changes are still being developed.

4. What is the purpose of a code review?

   A code review is the systematic examination of proposed code changes by peers to catch bugs, ensure adherence to standards and style, improve design, share knowledge, and maintain overall code quality before merging.

5. In code review, what is the difference between an 'Approve', 'Request Changes', and 'Comment' review outcome?

   Approve signals the changes are acceptable to merge; Request Changes blocks the merge until issues are addressed; Comment provides feedback without explicit approval or blocking.

6. What is a CODEOWNERS file used for in code review?

   A CODEOWNERS file defines individuals or teams responsible for specific files or directories, so that changes to those paths automatically request review from the designated owners.

7. What are 'branch protection rules' in the context of pull requests and reviews?

   Branch protection rules are repository settings that enforce requirements before merging into a protected branch, such as requiring approving reviews, passing status checks (CI), or up-to-date branches, and disallowing force-pushes.

8. What is 'nit' feedback in a code review?

   A 'nit' (nitpick) is a minor, non-blocking comment about style or small preferences that the author may optionally address without holding up the merge.

9. What is rebasing in Git?

   Rebasing moves or replays a sequence of commits onto a new base commit. It rewrites history to produce a linear sequence, as if the work had been started from the newer base.

10. What is the key difference between merging and rebasing?

    Merging preserves history and combines branches with a merge commit, creating a non-linear history. Rebasing rewrites commits onto a new base, producing a clean linear history but changing commit hashes.

11. What command rebases the current branch onto main?

    git rebase main (while on the feature branch), which replays the feature branch's commits on top of the latest main.

12. What is interactive rebase and how is it started?

    Interactive rebase lets you edit, reorder, squash, drop, or reword commits during a rebase. It is started with git rebase -i <base>, opening an editor with a list of commits and actions.

13. What is the 'golden rule of rebasing'?

    Never rebase commits that have been pushed to a shared/public branch that others may have based work on, because rewriting shared history forces disruptive updates for collaborators.

14. In interactive rebase, what is the difference between the 'squash' and 'fixup' commands?

    squash combines a commit into the previous one and lets you edit the combined commit message; fixup does the same but discards the squashed commit's message, keeping only the previous one.

15. How do you continue or abort a rebase that has stopped due to a conflict?

    Resolve conflicts and run git rebase --continue to proceed, or git rebase --abort to cancel and restore the branch to its original state.

16. Why do commit hashes change after a rebase?

    A commit hash is computed from its content including its parent. Rebasing gives commits new parents (the new base), so their hashes are recalculated, producing brand-new commit objects.

17. What is cherry-picking in Git?

    Cherry-picking applies the changes introduced by one or more specific commits from another branch onto the current branch, creating new commits with the same content but new hashes.

18. What command cherry-picks a commit, and what identifies the commit?

    git cherry-pick <commit-hash>, where the commit is identified by its SHA hash (or a reference resolving to it).

19. When is cherry-picking most useful?

    When you need a specific fix or feature from one branch without merging the entire branch — for example, applying a hotfix commit to a release branch while leaving other changes behind.

20. How does cherry-picking differ from merging?

    Merging integrates all changes and history from a branch, whereas cherry-picking copies only selected individual commits' changes onto the current branch, without bringing over the rest of the branch's history.

21. What does git cherry-pick -n (or --no-commit) do?

    It applies the commit's changes to the working directory and staging area but does not create a commit automatically, allowing you to review or combine changes before committing.

22. What is stashing in Git and which command creates a stash?

    Stashing temporarily shelves uncommitted changes (modified tracked files and staged changes) so you can switch context with a clean working directory. It is created with git stash (or git stash push).

23. How do you reapply the most recent stash, and what is the difference between git stash pop and git stash apply?

    git stash pop reapplies the most recent stash and removes it from the stash list; git stash apply reapplies it but keeps it in the stash list for reuse.

24. How do you include untracked files when stashing, and how do you view the list of stashes?

    Use git stash -u (or --include-untracked) to stash untracked files as well; use git stash list to view all saved stashes (indexed as stash@{0}, stash@{1}, ...).

What this deck covers

Version Control flashcards FAQ