Git & Version Control Core Git Workflow Syllabus

What is the difference between `git rm <file>` and `rm <file>`?

`rm <file>` deletes the file from the working directory only, leaving the deletion unstaged. `git rm <file>` deletes the file AND stages the removal in the index in one step, ready to commit.

What does `git rm --cached <file>` do?

It removes the file from the index (stops tracking it) but leaves the physical file in the working directory. Useful for un-tracking a file you now want to ignore.

How does `git mv old new` compare to using the shell `mv` and then `git add`?

They are equivalent. `git mv old new` is a convenience that runs `mv old new`, then `git rm old` and `git add new`, staging the rename in one command. Git detects renames by content similarity rather than storing an explicit rename.

What does `git log` display by default?

The commit history of the current branch in reverse chronological order (newest first), showing each commit's full SHA-1 hash, author, date, and message.

What does `git log --oneline` show?

A condensed one-line-per-commit view with the abbreviated commit hash and the first line of each commit message.

What do the `--graph`, `--all`, and `--decorate` options add to `git log`?

`--graph` draws an ASCII commit/branch topology; `--all` shows commits from all refs/branches, not just the current one; `--decorate` annotates commits with the branch and tag names pointing to them.

How do you limit `git log` to the last 5 commits?

`git log -5` (or `git log -n 5`).

How do you filter commit history by author?

`git log --author="Name"`, which matches commits whose author field contains the given pattern (regex-capable).

What do `git log --since` and `git log --until` do?

They filter commits by date: `--since="2 weeks ago"` shows commits after that date and `--until="2020-01-01"` shows commits before it. They can be combined to bound a range.

What does `git log --grep="pattern"` filter on?

It shows only commits whose commit message matches the given regular-expression pattern.

What does `git log -- <path>` (or `git log <path>`) do?

It shows only the commits that touched the specified file or directory, filtering the history by path.

What does `git log -S "string"` (the pickaxe) find?

Commits that changed the number of occurrences of the given string in the code (i.e., where the string was added or removed), letting you find when a piece of code appeared or disappeared.

What does plain `git diff` (no arguments) show?

The differences between the working directory and the staging area (index) — i.e., changes you have made but not yet staged.

What does `git diff --staged` (or `--cached`) show?

The differences between the staging area (index) and the last commit (HEAD) — i.e., the changes that are staged and will go into the next commit.

What does `git diff HEAD` show?

All differences between the working directory and the last commit, combining both staged and unstaged changes.

How do you see the differences between two commits with `git diff`?

`git diff <commit1> <commit2>`, which shows the changes needed to transform the first commit's tree into the second's.

What does `git show <commit>` display?

The metadata and content of a single object; for a commit it shows the author, date, message, and the full diff (patch) introduced by that commit.

What does `git blame <file>` show?

A line-by-line annotation of the file indicating, for each line, the commit hash, author, and date of the last revision that modified that line.

What is the difference between `git blame` and `git log`?

`git log` shows commits chronologically (history of the repo/file), whereas `git blame` maps each individual line of a file to the specific commit and author that last changed it.

How do you unstage a file that you have added with `git add` (modern syntax)?

`git restore --staged <file>` (or the older `git reset HEAD <file>`). This removes it from the index while keeping the working-directory changes intact.

How do you discard unstaged changes to a tracked file, reverting it to the last committed version?

`git restore <file>` (or the older `git checkout -- <file>`). This is destructive: the uncommitted changes are lost.

What does `git revert <commit>` do?

It creates a NEW commit that applies the inverse of the changes introduced by the specified commit, undoing its effect while preserving history. It is the safe way to undo a commit that has already been shared/pushed.

How does `git revert` differ from `git reset` conceptually?

`git revert` undoes changes by adding a new inverse commit, keeping history intact (non-destructive, safe for shared branches). `git reset` moves the branch pointer backward, rewriting/removing history (destructive, best for local/unshared commits).

What does the `-n` / `--no-commit` option do with `git revert`?

It applies the inverse changes to the working tree and index but does not create the revert commit automatically, letting you combine or edit before committing yourself.

What are the three modes of `git reset` and how do they differ?

`--soft` moves HEAD only (changes stay staged); `--mixed` (default) moves HEAD and resets the index (changes become unstaged but kept in working dir); `--hard` moves HEAD and resets both index and working directory (changes are discarded).

What does `git reset --hard HEAD~1` do?

It moves the current branch back by one commit and discards all changes from that commit in both the index and working directory. This is destructive and permanently drops those uncommitted changes.

What does `git reset --soft HEAD~1` accomplish?

It undoes the last commit but keeps its changes staged in the index, effectively letting you re-commit them (e.g., to combine or rewrite the commit message).

What is the reflog and what does `git reflog` show?

The reflog is a local log recording every update to the tips of branches and HEAD (commits, resets, checkouts, rebases, etc.). `git reflog` lists these movements with their hashes, enabling recovery of commits that seem lost.

How can you recover a commit after an accidental `git reset --hard`?

Find the lost commit's hash in `git reflog`, then restore it, e.g. `git reset --hard <hash>` or `git checkout <hash>` (or create a branch at it). The reflog retains the reference even though no branch points to it.

What does `git stash` do?

It saves your uncommitted changes (staged and unstaged tracked modifications) onto a stack and reverts the working directory to a clean state matching HEAD, so you can switch context without committing.

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 top stash and removes it from the stash stack; `git stash apply` reapplies it but keeps it on the stack so it can be applied again.

How do you view the list of saved stashes and inspect one?

`git stash list` shows all stashes as `stash@{0}`, `stash@{1}`, etc.; `git stash show [-p] stash@{n}` displays its summary or full diff.

How do you apply or drop a specific (non-top) stash from multiple stashes?

Reference it by index, e.g. `git stash apply stash@{2}` to apply it or `git stash drop stash@{2}` to delete it. `git stash clear` removes all stashes.

How do you include untracked files when stashing?

`git stash -u` (or `--include-untracked`) also stashes untracked files; `git stash -a` (`--all`) additionally includes ignored files.

What does `git clean` do, and why does it require a force flag?

It removes untracked files from the working directory. Because deletion is irreversible, Git requires `-f` (`--force`) to actually delete; without it (or a dry-run) it refuses for safety.

What is the difference between `git clean -n`, `git clean -f`, and `git clean -fd`?

`-n` (`--dry-run`) lists what would be removed without deleting; `-f` force-deletes untracked files; `-fd` force-deletes untracked files AND untracked directories. Adding `-x` also removes ignored files.