Advanced Git training

Lesson 1 • How Git Stores Data

Covers the four Git object types and content-addressable storage. Establishes the foundation every subsequent chapter depends on.

Lesson 2 • The Index and Working Tree

Distinguishes the three-tree model: working tree, index, and HEAD. Explains staging as a deliberate snapshot-building step.

Lesson 3 • References and the Ref Namespace

Teaches branches, tags, and HEAD as named pointers to commits. Clarifies why branches are lightweight and how detached HEAD occurs.

Lesson 4 • Commits, Trees, and History

Explains how commits chain into a directed acyclic graph. Connects object storage to the visible history students navigate daily.

Lesson 1 • Trunk-Based Development

Explains short-lived feature branches and continuous integration (CI) to trunk. Contrasts with long-lived branch models to highlight trade-offs.

Lesson 2 • Gitflow and Release Branch Models

Details the Gitflow model with develop, release, and hotfix branches. Identifies when Gitflow's overhead is justified versus counterproductive.

Lesson 3 • Branch Protection and Policy Enforcement

Covers server-side rules that enforce workflow compliance. Ensures students can configure guardrails that protect shared branches.

Lesson 4 • Forking Workflows for Open Source

Teaches the fork-and-pull-request model used in open-source projects. Connects remote management skills to collaborative contribution patterns.

Lesson 1 • Merge Strategies and Options

Explains fast-forward, recursive, and octopus merge strategies. Connects merge type selection to the history legibility goals of the team.

Lesson 2 • Cherry-Pick and Patch Application

Teaches selective commit copying with cherry-pick and format-patch. Covers legitimate use cases such as backporting fixes to release branches.

Lesson 3 • Interactive Rebase for History Cleanup

Covers squash, fixup, reword, edit, and drop operations in interactive rebase. Enables students to craft clean, reviewable commit histories.

Lesson 4 • Resolving Merge and Rebase Conflicts

Provides systematic techniques for understanding and resolving conflicts. Reduces fear of conflicts by making the three-way diff model explicit.

Lesson 1 • Handling Large Files and Binary Assets

Explains Git LFS architecture and pointer file mechanics. Prevents repository bloat caused by committing large binaries directly.

Lesson 2 • Remote Management Fundamentals

Covers adding, renaming, and removing remotes and inspecting their state. Provides the vocabulary needed for all fetch, pull, and push operations.

Lesson 3 • Working with Submodules

Teaches submodule initialization, update, and nested repository management. Addresses the common pitfalls that cause detached HEAD in submodules.

Lesson 4 • Sparse Checkout and Partial Clones

Covers cone-mode sparse checkout and blobless or treeless clones. Enables efficient work in large monorepos with minimal local disk usage.

Lesson 1 • Searching History with Pickaxe and Grep

Covers -S and -G pickaxe flags and git grep for content search. Enables rapid location of when a string or pattern was introduced or removed.

Lesson 2 • Binary Search with Git Bisect

Teaches manual and automated bisect to isolate regression-introducing commits. Reduces debugging time from hours to minutes on large histories.

Lesson 3 • Reflog and Recovery Techniques

Explains the reflog as a safety net for recovering lost commits and branches. Builds confidence to perform destructive operations without fear.

Lesson 4 • Powerful Log and Diff Techniques

Teaches log filtering, graph visualization, and diff options for deep inspection. Connects log mastery to faster code review and debugging.

Lesson 1 • Plumbing Commands and Scripting

Introduces low-level plumbing commands for scripting and tooling. Enables building reliable automation that does not depend on porcelain output.

Lesson 2 • Client-Side Hook Fundamentals

Covers pre-commit, commit-msg, and post-commit hooks with practical examples. Establishes the hook execution model before tackling server-side hooks.

Lesson 3 • Server-Side and Receive Hooks

Teaches pre-receive, update, and post-receive hooks for server enforcement. Connects server hooks to policy automation and CI trigger patterns.

Lesson 4 • Custom Git Commands and Aliases

Shows how to create git-prefixed executables and complex aliases. Extends Git's interface to match team-specific workflow requirements.

Lesson 1 • Supply Chain Integrity with Sigstore

Introduces keyless signing and transparency logs for artifact provenance. Positions Git signing within the broader software supply chain security context.

Lesson 2 • Repository Access Control Patterns

Explains deploy keys, personal access tokens, and SSH certificate authorities. Connects authentication mechanisms to least-privilege access design.

Lesson 3 • Managing Secrets and Sensitive Data

Teaches detection and removal of accidentally committed secrets. Prevents credential leaks that persist in history even after file deletion.

Lesson 4 • Rewriting History to Remove Sensitive Data

Covers git filter-repo for bulk history rewriting and its coordination requirements. Addresses the team communication needed when rewriting shared history.

Lesson 1 • Diagnosing Git Performance Issues

Covers GIT_TRACE variables and timing flags for profiling Git operations. Establishes a diagnostic methodology before applying any optimization.

Lesson 2 • Packfile Optimization and Repacking

Explains delta compression, bitmap indexes, and gc configuration. Reduces clone and fetch times by maintaining an efficient object store.

Lesson 3 • Monorepo Performance Techniques

Covers fsmonitor, index version tuning, and multi-pack indexes for large repos. Enables fast status and checkout operations in repositories with millions of files.

Lesson 4 • Repository Health and Housekeeping

Covers fsck, prune, and maintenance scheduling for long-lived repositories. Ensures data integrity and prevents gradual performance degradation.