Git for Distributed Software Development Course

Lesson 1 • Installing and Configuring Git

Walks through platform-specific installation and essential global configuration. Ensures a consistent, identity-correct environment before any repository work begins.

Lesson 2 • Version Control Principles and History

Covers why version control exists, the evolution from centralized to distributed systems, and Git's design philosophy. Grounds all later Git commands in conceptual purpose.

Lesson 3 • Ignoring Files and Managing .gitignore

Explains how to exclude build artifacts, secrets, and OS files from tracking. Prevents common repository pollution issues seen in distributed teams.

Lesson 4 • Initializing and Cloning Repositories

Teaches creating new repos and copying existing ones. Establishes the workspace foundation required for every subsequent workflow in the course.

Lesson 1 • Tagging Releases and Milestones

Introduces lightweight and annotated tags for marking significant commits. Connects branching knowledge to release management practices.

Lesson 2 • Creating and Switching Branches

Covers commands for creating, renaming, and switching branches safely. Directly enables the parallel workstream model used in distributed teams.

Lesson 3 • Understanding Branches and HEAD

Explains branches as lightweight movable pointers and HEAD as the current position marker. Provides the conceptual base for all branching operations.

Lesson 4 • Merging Strategies and Fast-Forward

Teaches three-way and fast-forward merges and when each applies. Builds judgment for choosing merge strategies in team workflows.

Lesson 1 • Fetching, Pulling, and Syncing Changes

Distinguishes fetch from pull and explains when each is appropriate. Prevents data loss and merge surprises common in distributed workflows.

Lesson 2 • Remote Concepts and Configuration

Defines remotes as named URL references and explains tracking branches. Provides the vocabulary needed for all push and pull operations.

Lesson 3 • Pushing Changes and Managing Permissions

Covers pushing commits, force-push risks, and branch protection concepts. Ensures developers understand safe publishing practices for shared repositories.

Lesson 4 • Authentication Methods for Remote Access

Explains HTTPS credential helpers and SSH key-based authentication. Removes access barriers that block distributed contributors from collaborating.

Lesson 1 • Rebase Fundamentals vs. Merge

Contrasts rebase and merge at the object level and explains when each preserves team clarity. Establishes the conceptual foundation for all rebase operations.

Lesson 2 • Interactive Rebase for Commit Cleanup

Uses git rebase -i to squash, reorder, edit, and drop commits. Enables developers to polish feature branches before merging into shared branches.

Lesson 3 • Filtering and Rewriting Entire History

Introduces git filter-repo for bulk history rewrites such as removing secrets. Prepares teams for repository hygiene tasks that affect all contributors.

Lesson 4 • Resolving Conflicts During Rebase

Addresses conflict resolution specific to rebase's commit-by-commit replay. Builds confidence to complete rebases without losing work.

Lesson 1 • Branching Workflow Patterns Overview

Surveys major branching models and the team contexts each suits best. Frames the decision criteria used throughout the rest of the chapter.

Lesson 2 • Enforcing Workflow Rules and Policies

Applies branch protection, required reviews, and status checks to enforce workflow compliance. Reduces human error in distributed team merges.

Lesson 3 • Implementing Git Flow

Walks through main, develop, feature, release, and hotfix branch roles. Provides a repeatable release cadence for teams with scheduled deployments.

Lesson 4 • Trunk-Based Development at Scale

Explains short-lived branches, feature flags, and continuous integration gates. Enables high-frequency delivery without sacrificing stability.

Lesson 1 • Server-Side Hooks for Repository Governance

Covers pre-receive, update, and post-receive hooks for enforcing server policies. Provides a last line of defense before commits enter shared history.

Lesson 2 • Integrating Hooks with CI/CD Pipelines

Connects local hook checks to remote pipeline triggers for end-to-end automation. Eliminates gaps between local and server-side quality enforcement.

Lesson 3 • Client-Side Hooks for Code Quality

Implements pre-commit and commit-msg hooks to enforce linting and message format. Catches issues before they reach shared branches.

Lesson 4 • Introduction to Git Hooks

Explains the hooks directory, trigger events, and exit code conventions. Establishes the mechanism underlying all automation built in this chapter.

Lesson 1 • Refs, Reflogs, and Namespace Management

Covers how refs, symbolic refs, and reflogs track branch and HEAD history. Enables precise navigation and recovery across complex repository states.

Lesson 2 • Bisecting to Find Regression Commits

Applies git bisect to binary-search commit history for the source of a bug. Dramatically reduces debugging time in long-running distributed projects.

Lesson 3 • Git Object Model Deep Dive

Examines blob, tree, commit, and tag objects stored in the object database. Provides the internal knowledge needed to understand every high-level command.

Lesson 4 • Diagnosing and Recovering Lost Commits

Uses reflog, git fsck, and dangling objects to locate and restore lost work. Builds the recovery skills essential for distributed team incident response.

Lesson 1 • Preventing Secrets from Entering Repositories

Identifies how credentials leak into Git history and applies pre-commit scanning tools. Reduces the most common and costly Git security incident type.

Lesson 2 • Access Control and Repository Permissions

Maps team roles to repository permission levels and branch protection rules. Ensures only authorized contributors can modify critical branches.

Lesson 3 • Dependency and Supply Chain Security

Addresses risks from submodules, vendored code, and third-party dependencies in Git. Connects repository governance to broader software supply chain integrity.

Lesson 4 • Auditing Commit History for Compliance

Uses git log filters, blame, and external audit tools to produce compliance evidence. Supports regulated industries requiring traceable change records.