Git Practice Exercises

Begin your Git journey by initializing a repo and performing your first commits.

Build a small project's history one commit at a time.

Read an existing project's history and answer questions about its commits.

Learn the difference between Git's two diffs by creating both at once.

Unstage a file without losing your work and commit only what you meant.

Inspect what past commits changed using diffs and summaries.

Discard bad working tree edits and bring one file back from an older commit.

Fix the last commit's message and add its forgotten file without creating a new commit.

Preview and then safely delete untracked junk while every tracked edit survives.

Give each feature its own branch from a shared base and keep their commits apart.

Rename, safely delete, and force delete branches according to what each one deserves.

Commit valuable work on a detached HEAD and rescue it onto a real branch.

Integrate an ahead branch by fast-forward and see exactly when that stops being possible.

Join two diverged lines with a real merge commit, and force one even where fast-forward was possible.

Land a noisy feature branch as one clean commit while the branch itself stays intact.

Clone a shared repository and see the remote and tracking setup it configures for free.

See what fetch moves and what it does not, then integrate the fetched work with pull.

Push a new branch with its upstream in one step and delete a delivered branch from the shared repository.

Set a machine-wide identity and a repository-local override, show where each value comes from, and prove which one commits use.

Ignore patterns, a whole directory and a negated exception inside it - then stop tracking an already-committed secrets file while keeping it on disk.

Define machine-wide aliases for the team's long commands, including one that takes its argument at the call site, and prove each reproduces its command.

Start a merge that halts on conflicts, read the markers to combine both sides of two files by hand, and conclude the merge as a two-parent commit.

Begin a conflicting merge, abandon it mid-resolution, prove the repository came back to its exact pre-merge state, then redo the merge to the correct resolution.

Resolve a three-file merge conflict by taking whole sides - local for one file, incoming for another, a chosen side for a binary - and conclude the merge.

Replay a feature branch's commits onto an advanced main line, then catch the main line up without a merge commit, keeping history perfectly linear.

Integrate a diverged shared history by replaying local commits on top of the fetched tip instead of merging, then make that the default so the next plain pull stays merge-free too.

Replay only the fix commits from an unfinished feature branch onto the main tip, leaving the feature branch and its half-written work behind.

Interactively rebase a branch to replay its four commits in the right narrative order and fix two wrong commit messages, leaving every commit's content and the final tree untouched.

Collapse a trail of 'wip', 'typo' and 'oops' commits into three reviewable ones, letting two fixup-marked late fixes fold automatically into the different earlier commits they name, with the final tree unchanged.

Rewrite a branch so one commit that mixes a bug fix with a feature becomes two clean commits, the fix first, with everything stacked above it preserved.