Progress:
๐ŸŽ“

RoboDoc's GIT Course

โ€” in progress โ€”

This page is your "wall of mastery." It shows every module you've visited, completed, and scored on โ€” across all three tiers. Print it for a clean PDF certificate.

๐ŸŸฃ Tier 1 โ€” Basics

โ€” / 48 modules ยท score โ€”

Tier 1 covered the porcelain โ€” 47 user-facing commands you'll touch most days. You learned the working-tree โ†’ index โ†’ object-database flow that every other Git operation builds on. You know that a branch is a movable pointer to a commit, that HEAD is a symbolic ref to that pointer, and that fast-forward merges aren't really merges at all โ€” they're pointer moves.

The big mental shift in Tier 1 was that commits are snapshots, not diffs. Git stores the whole tree at each commit and computes diffs lazily. That's why branching is cheap (a 41-byte file), why git log walks parents (it's a DAG, not a linear list), and why git reset and git revert look superficially similar but do entirely different things โ€” one moves the pointer, the other adds a new commit.

You also met the reflog (every branch-tip move recorded for 90 days), stash (a tiny side-stack of dirty work), and the rebasing-history triad (rebase, cherry-pick, revert). You should be allergic to force-pushing shared branches by now. If you aren't, re-read module 21.

๐ŸŸช Tier 2 โ€” Intermediate

โ€” / 58 modules ยท score โ€”

Tier 2 expanded the surface area: 57 ancillary, foreign-SCM, and helper commands. You learned why Git's design ages well โ€” the porcelain has changed (think switch/restore replacing checkout), but the helpers haven't because they're already minimal and orthogonal.

You met config and its three layers (system โ†’ global โ†’ local), the reflog from a recovery angle, the remote family for managing more than one upstream, and replace for the rare situation where you need to lie to history without rewriting it. You saw how blame and annotate use merge-base under the hood, why count-objects -v is your first stop when a repo bloats, and what happens when you actually run fsck on a repo someone has been "fixing" by hand.

The bridge commands (svn, p4, cvs*) showed you that Git was designed from day one to import from anything. Most of them are crusty, but they're also durable โ€” they'll still be there in 2034 when you inherit a Mercurial repo from someone's archive.

The helpers โ€” check-attr, check-ignore, interpret-trailers, credential โ€” are the small tools that scripts and hooks lean on. Once you know they exist, you stop reaching for grep + awk and start using the things Git already ships with.

๐ŸŸซ Tier 3 โ€” Expert

โ€” / 56 modules ยท score โ€”

Tier 3 was the plumbing โ€” 55 modules that strip away every layer of porcelain. You can now read commits with cat-file -p, walk trees with ls-tree, build a brand-new commit with hash-object + mktree + commit-tree + update-ref, and understand precisely what git commit does when you press Enter.

You learned that the object database is content-addressable: blobs, trees, commits, and tags all hash to a SHA, all live as files (or in packs), and nothing โ€” nothing โ€” is mutated in place. New commits get new SHAs. Old objects stay until gc decides nothing references them anymore.

You met rev-parse (the universal revision parser) and for-each-ref (the universal ref iterator). Together they're the entire shell-scripting toolkit: with these two and a while loop, you can write any custom Git report you'd ever need.

You saw the transfer protocol: upload-pack and fetch-pack negotiating "what do you have?" and "what do I need?" before sending a pack. You saw receive-pack validating an incoming push, and update-server-info keeping dumb HTTP servers honest.

You finished with git daemon, git http-backend, and git shell โ€” the three ways to run Git as a server without depending on GitHub or anything else. Which is, of course, the point: Git is fully decentralized. Every clone is a complete repo. Every workflow is yours to choose.

That's the course. Print this page. Hang it on the wall. Get back to work.

๐Ÿ› ๏ธ Tools