DevOps Version Control Systems Syllabus

What does git remote add origin <url> do?

It registers a new remote named 'origin' pointing at the given URL, so you can push to and fetch from that repository by name.

What is the difference between git fetch and git pull?

git fetch downloads new commits and refs from the remote but does NOT modify your working branch. git pull is effectively git fetch followed by git merge (or rebase), integrating the changes into your current branch.

What does git push -u origin main accomplish?

It uploads local commits on main to the remote 'origin' and the -u (--set-upstream) flag records origin/main as the tracking branch, so future git push/pull can be run without arguments.

What is a tracking (upstream) branch?

A local branch that has a direct relationship to a remote branch (e.g., main tracks origin/main). It lets Git report ahead/behind status and lets push/pull default to the right remote branch.

What does git rebase do conceptually?

It reapplies (replays) a series of commits from your branch onto a new base commit, producing a linear history as if you had branched from that newer base. It rewrites commit hashes.

State the core conceptual difference between merging and rebasing.

Merge is non-destructive: it preserves the true branch history and creates a merge commit joining two lines. Rebase rewrites history to produce a linear sequence, moving commits onto a new base and giving them new hashes.

Why should you avoid rebasing commits that have already been pushed/shared?

Rebasing rewrites commit hashes and history. If others have based work on the original commits, rewriting them causes divergence and forces disruptive history reconciliation (the 'golden rule of rebasing': never rebase public/shared branches).

What is the command to interactively rebase the last 3 commits?

git rebase -i HEAD~3, which opens an editor to reorder, squash, edit, or drop those commits.

What is the trade-off summarized as merge vs rebase for history?

Merge keeps complete, true history but adds merge commits (more cluttered, non-linear). Rebase yields clean linear history but rewrites commits and loses the exact context of when work diverged.

What does git cherry-pick do?

It applies the changes introduced by one (or more) specific existing commit(s) onto the current branch, creating a new commit with the same content but a different hash.

Give a typical use case for cherry-picking.

Applying a specific bug-fix commit from one branch to another (e.g., backporting a hotfix to a release branch) without merging the entire source branch.

What is the command to cherry-pick a commit without immediately committing it?

git cherry-pick -n <commit> (or --no-commit), which applies the changes to the working tree/index but lets you commit manually.

What does git stash do?

It temporarily shelves (saves) uncommitted changes in the working directory and index, reverting the working tree to a clean HEAD state, 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 most recent stash and removes it from the stash list. git stash apply reapplies it but keeps it in the stash list for reuse.

How do you list saved stashes and apply a specific one?

git stash list shows all stashes (e.g., stash@{0}, stash@{1}). Apply a specific one with git stash apply stash@{n} (or pop stash@{n}).

By default, does git stash include untracked files? How do you include them?

No, by default git stash only saves tracked, modified files. Use git stash -u (--include-untracked) to also stash untracked files, or -a (--all) to include ignored files as well.

What does git clean do, and why is the -n flag important?

git clean removes untracked files from the working directory. The -n (--dry-run) flag previews what would be deleted without removing anything, which is important because the deletion is not recoverable via Git.

What does git clean -fd do?

It forcibly (-f) removes untracked files and also removes untracked directories (-d). The -f flag is required because Git refuses to clean by default for safety.

What is a Git hook?

A Git hook is a script that Git automatically executes when certain repository events occur (e.g., committing, merging, pushing), allowing you to automate or enforce custom actions and policies.

Where are Git hooks stored, and are they shared via the repository by default?

They live in the .git/hooks directory of a repository. By default they are local and NOT copied/cloned with the repo, so they are not shared automatically (tools like a tracked hooks dir or pre-commit framework are used to share them).

What is the difference between client-side and server-side hooks?

Client-side hooks run on the developer's machine for actions like committing and merging (e.g., pre-commit, prepare-commit-msg, post-merge). Server-side hooks run on the remote receiving pushes (e.g., pre-receive, update, post-receive) to enforce policies.

What does the pre-commit hook do and a common use for it?

It runs before a commit is finalized; if it exits non-zero, the commit is aborted. It is commonly used to run linters, formatters, or tests to reject substandard commits.

What does the commit-msg hook do?

It runs after the commit message is entered and receives the path to the message file; it can validate or enforce message format (e.g., requiring a ticket number or conventional-commit style) and abort the commit if invalid.

What must a hook script have to actually run?

It must be named exactly the hook name (no extension, e.g., pre-commit) inside .git/hooks and must be executable (chmod +x). Sample hooks ship with a .sample suffix, which disables them.

What is the difference between git reset and git revert?

git reset moves the branch pointer (and optionally the index/working tree) to a previous commit, rewriting/removing later history locally. git revert creates a new commit that undoes a previous commit's changes, preserving history (safe for shared branches).

What do git reset --soft, --mixed, and --hard each affect?

--soft moves HEAD only (keeps index and working tree, changes left staged). --mixed (default) moves HEAD and resets the index (changes left unstaged). --hard moves HEAD and resets both index and working tree, discarding changes.

What is HEAD in Git?

HEAD is a reference (pointer) to the currently checked-out commit, normally pointing to the tip of the current branch. A 'detached HEAD' means it points directly at a commit rather than a branch.

What is the purpose of a .gitignore file?

It specifies intentionally untracked file patterns that Git should ignore (e.g., build artifacts, secrets, logs), preventing them from being staged or committed. It does not affect files already tracked.

How can you view the commit history compactly as one line per commit?

git log --oneline, which shows each commit as an abbreviated hash plus the commit summary; adding --graph --all visualizes branch and merge structure.