Git & Version Control Version Control Fundamentals Flashcards

24 sample cards from the Version Control Fundamentals 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 a file can be in within Git?

   Modified, Staged, and Committed.

2. Define the 'modified' state in Git.

   The file has been changed in the working directory but the change has not yet been staged (added to the index).

3. Define the 'staged' state in Git.

   A modified file has been marked (via git add) to go into the next commit; it sits in the staging area (index).

4. Define the 'committed' state in Git.

   The data is safely stored in the local Git database (the .git directory); the staged snapshot has been recorded permanently as a commit.

5. What are the three main sections/trees of a Git project that correspond to the three states?

   The working directory (working tree), the staging area (index), and the Git directory (.git repository/database).

6. What is the staging area (index) in Git?

   A file, generally in the .git directory, that stores information about what will go into your next commit; it lets you build up commits selectively before recording them.

7. Outline the basic Git workflow across the three trees.

   You modify files in the working directory, selectively stage the changes you want (git add) into the index, then commit (git commit) to store a permanent snapshot in the .git directory.

8. What are the four fundamental object types Git stores in its database?

   Blob (file contents), tree (directory listing pointing to blobs and other trees), commit (a snapshot with metadata), and tag (annotated tag object).

9. What does a Git blob object store?

   The raw contents of a file — just the data, with no filename or metadata; the blob is identified by the SHA-1 of its contents.

10. What does a Git tree object represent?

    A directory: it lists filenames and permissions, pointing to blob objects (files) and other tree objects (subdirectories).

11. What information does a Git commit object contain?

    A pointer to the top-level tree (the snapshot), the author and committer with timestamps, the commit message, and pointers to zero or more parent commits.

12. How is a Git object's identity/storage key determined, making Git a content-addressable filesystem?

    By computing the SHA-1 hash of the object's contents; identical content always yields the same hash, so objects are stored and retrieved by their checksum.

13. What is the .git directory, and what does it contain?

    It is the repository — the hidden directory Git creates on git init or git clone that stores all objects, refs, the config, HEAD, the index, hooks, and logs; it is the heart of a Git repo.

14. Name key items you would find inside the .git directory.

    objects/ (the object database), refs/ (branch and tag pointers), HEAD (current ref), config (local config), index (staging area), hooks/, and logs/.

15. What is a reference (ref) in Git?

    A human-friendly named pointer to a commit SHA-1, stored under .git/refs (e.g., branches in refs/heads, tags in refs/tags), so you don't have to remember raw hashes.

16. What is HEAD in Git?

    A pointer to the current branch reference (usually a file .git/HEAD containing something like 'ref: refs/heads/main'); it indicates the branch/commit you currently have checked out.

17. What does it mean to be in a 'detached HEAD' state?

    HEAD points directly to a specific commit rather than to a branch, so new commits are not on any branch and can be lost if you switch away without creating a branch.

18. Where are local branch pointers stored inside .git, and what do they contain?

    In .git/refs/heads/, one file per branch, each containing the SHA-1 of the commit at the tip of that branch.

19. What is a shell (or terminal) and why is it central to using Git?

    A shell is a command-line interpreter (e.g., Bash, Zsh, PowerShell) that runs typed commands; Git's full functionality is exposed through its command-line interface, run in a terminal.

20. Name a few essential shell navigation/file commands a Git user should know.

    pwd (print working directory), ls (list files), cd (change directory), mkdir (make directory), rm (remove), and cp/mv (copy/move).

21. What is a Git alias, and how do you create one?

    A shortcut for a longer Git command, created with git config, e.g., git config --global alias.co checkout lets you type 'git co' instead of 'git checkout'.

22. Give an example of a useful Git alias that shortens a common command.

    git config --global alias.st status (so 'git st' runs 'git status'); other common ones are alias.ci commit, alias.br branch, and alias.unstage 'reset HEAD --'.

23. Compare Git GUI clients versus the command-line interface (CLI).

    The CLI is the only place all Git commands are available and works everywhere identically; GUI clients (e.g., GitKraken, Sourcetree, GitHub Desktop) are more visual and beginner-friendly but implement only a subset of features, so learning the CLI ensures full capability.

24. Why is it recommended to learn the Git command line even if you plan to use a GUI?

    Because GUIs only expose a subset of Git's functionality; knowing the CLI means you can perform any operation, understand what the GUI does under the hood, and work on any system where only a terminal is available.

What this deck covers

Version Control Fundamentals flashcards FAQ