Git

Before any command, build a mental model of version control as a tool that tracks every change, lets teams collaborate, and lets you travel back in time.

A Git repository is just a folder with a hidden `.git/` directory inside. Once you see what is in there, the magic dissolves.

A commit is a snapshot of your project plus a pointer to the commit before it. See the raw object Git wrote on disk.

A branch is a movable pointer to a commit. HEAD is a pointer to the branch you are currently on. See both as plain text files on disk.

Every file in a Git repo lives in one of three areas. Walk a single file through each one and watch `git status` change.

Set your name and email so Git can stamp every commit you make.

Turn an empty folder into a Git repository with one command and inspect what was created.

Read what Git knows about your working tree in three classic situations.

Move files into the staging area with single-file, bulk, and patch-mode forms of git add.

Record staged changes into history and read them back with git log.

git log walks back through commits. Plain, oneline, and limited views answer different questions.

git diff shows pending changes. Plain, --staged, and commit-range forms cover the everyday questions.

git show prints one commit's metadata and diff. Pair it with git log to audit a specific change.

git log --graph draws an ASCII tree of commits. Combined with --all and --decorate it shows every branch in one view.

Throw away unwanted edits in the working tree and unstage files with `git restore`.

Rewind history with `git reset` and feel the difference between `--soft`, `--mixed`, and `--hard`.

Undo a commit on a shared branch by adding a new commit that reverses it, instead of rewriting history.

Use `git reflog` to find commits that became unreachable after a hard reset and bring them back.

A branch is a movable pointer to a commit. `git branch` lists them, `git branch <name>` creates one.

`git switch` moves HEAD between branches. `-c` creates and switches in one step. `git checkout` is the legacy verb.

Recognize the detached HEAD state, commit safely while in it, and rescue the work with a new branch.

git merge folds one branch into another. The shape of the merge depends on whether the branches diverged.

`git branch -d` refuses to drop unmerged work. `git branch -D` forces the delete and discards the commits.

origin is just a name. It is an alias for a remote URL or path that git remembers per repo.

git clone copies a repo into a new folder and wires origin to its source. Practice it against a local bare repo.

fetch downloads without merging. pull is fetch plus merge. Practice both against two clones of the same bare repo.

git push sends local commits to a remote. -u records upstream tracking so later pushes need no arguments. --force-with-lease is the safer alternative to --force.

Generate an ed25519 SSH key, inspect a remote URL, and switch a remote from HTTPS to the SSH form.

When two branches change the same line, `git merge` stops with conflict markers. Edit the file, stage it, and commit to finish the merge.

Walk back a conflicted merge with `git merge --abort` and end up with a clean working tree on the original branch.

A realistic team scenario. A feature branch and main both edited the same config line. Merge them and resolve the conflict by hand, keeping the feature's value and main's other change, then commit the merge.