Git & Version Control Version Control Fundamentals Syllabus

What is the first thing you should configure after installing Git, and with which commands?

Your identity — user name and email — using: git config --global user.name "Your Name" and git config --global user.email "you@example.com". This identity is baked into every commit.

Which command sets your default text editor for Git commit messages?

git config --global core.editor <editor>, for example git config --global core.editor "vim".

What are the three configuration levels in Git, from lowest to highest priority?

System level (--system, /etc/gitconfig), Global/user level (--global, ~/.gitconfig or ~/.config/git/config), and Local/repository level (--local, .git/config). Higher-priority levels override lower ones.

Which config level applies to every user on the system, and where is its file stored?

The system level, set with git config --system; stored in /etc/gitconfig (or Git installation path on Windows).

Which config level takes precedence when the same key is set at system, global, and local levels?

The most specific (local/repository) level wins, overriding global, which overrides system.

How do you view all of your Git settings and see which config file each came from?

git config --list to view all settings, and git config --list --show-origin to see the file each value came from. Use git config <key> to read a single value.

Give three ways to get help for a Git command from the command line.

git help <command>, git <command> --help, and man git-<command>. A concise option summary is available via git <command> -h.

What are the three main states a file can be in within Git?

Modified, Staged, and Committed.

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).

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).

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.

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).

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.

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.

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).

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.

What does a Git tree object represent?

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

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.

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.

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.

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/.

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.

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.

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.

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.

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.

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).

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'.

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 --'.

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.

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.