100% free3 lessons available

Git and GitHub: History, Collaboration, and Review

A complete Git and GitHub path in the same shape as the JavaScript course: focused lessons, a unit project at the end of each unit, then a planned assessment and capstone. You will move from a first local commit to a protected default branch with reviewed history.

33 focused lessons 6 unit projects 36 modules planned

Start Git course

Learn GitHistory · Review · GitHub

HOW THIS COURSE WORKS

From your first commit to a reviewed GitHub workflow

No Git experience is required. You should already be able to create files, open a terminal or editor, and follow a folder on disk. GitHub account setup is introduced when remotes begin.

01 · LEARN

Build the mental model

Start with snapshots, the index, and the commit graph. Commands come after you can predict what Git will record, move, or refuse.

02 · PRACTICE

Inspect and repair history

Read status, log, and diff before you rewrite anything. Each unit teaches a recovery move you can explain, not a shortcut you copy.

03 · APPLY

Complete an independent lab

Work in a real repository: stage a precise change, resolve a conflict, or open a pull request from a brief instead of a finished recipe.

04 · PROVE

Ship the unit project

Every unit ends with an integrated project. A later assessment and capstone will connect local Git, GitHub review, and checks.

YOU WILL BE ABLE TO

Record, integrate, review, and recover complete Git history

Create commits with a working tree, index, and message you can defend.
Inspect and undo local work without destroying published history.
Branch, merge, rebase, and resolve conflicts as graph operations.
Push to GitHub, open pull requests, and review with evidence.
Protect a default branch with checks, owners, and secret hygiene.
Present 6 unit projects as practical collaboration evidence.

COURSE CONTENTS

Build the snapshot graph before the GitHub buttons.

Beginners and working developers who want a durable Git model before collaborating on GitHub. You should already be comfortable creating files in a terminal or editor; no prior Git experience is required. This path uses the same structure as the JavaScript course: 6 units, 33 lessons, 6 unit projects, then an assessment and capstone. Published lessons include explanation, practice, and a knowledge check. Remaining titles stay visible and do not link until they are ready.

1. Git Foundations

Why History MattersSee version control as a record of decisions, not a backup folder, and learn how this course moves from a first commit to a reviewed GitHub workflow.
40 min
Version Control, Snapshots, and CollaborationDistinguish copies, backups, and a snapshot graph so later Git commands have a model instead of a memorized recipe.
50 min
Git, GitHub, and the Rest of the ToolchainSeparate the local Git engine from GitHub hosting, issues, pull requests, and Actions so you know which layer owns each job.
45 min
Install Git and Configure IdentityInstall Git, set user.name and user.email, choose a default branch name, and inspect the resulting configuration with intent.
04 · Planned
Working Tree, Index, and Object DatabaseTrace a change through the working tree, the index, and Git objects so status and add stop feeling like magic.
05 · Planned
init, status, add, and the First CommitCreate a repository, stage a precise set of files, write a useful commit message, and prove the snapshot exists.
06 · Planned
.gitignore, Secrets, and What Not to CommitKeep generated files, environment secrets, and machine-specific noise out of history before they become expensive to remove.
07 · Planned
Unit Project: Personal Learning Journal RepositoryInitialize a real journal repo with a README, ignore rules, two meaningful commits, and a status check you can explain.
08 · Project · Planned

2. Everyday History

Reading Commits with log and showNavigate history with log formats, follow a single file, and inspect one commit until the snapshot and message are both clear.
09 · Planned
diff: Working Tree, Index, and CommitsCompare unstaged, staged, and committed states so you can preview exactly what the next commit will record.
10 · Planned
Amending, Restoring, and Resetting SafelyChange the last unpublished commit, restore files, and use mixed, soft, and hard reset only when you can name the risk.
11 · Planned
revert versus reset: Public and Private HistoryUndo a published change with revert, keep shared history intact, and reserve rewrite commands for commits nobody else has.
12 · Planned
stash, Worktrees, and Unfinished WorkPark incomplete changes, switch context without losing work, and know when a second worktree is clearer than a stash.
13 · Planned
Unit Project: Recover a Messy Local RepositoryDiagnose a cluttered working tree, recover the intended files, and leave a clean status with an explained history.
14 · Project · Planned

3. Branches and Integration

Branches, HEAD, and Detached HEADTreat a branch as a movable pointer, follow HEAD, and recover from detached HEAD without discarding wanted commits.
15 · Planned
Merging: Fast-Forward and Merge CommitsPredict when Git can fast-forward, when it creates a merge commit, and how the resulting graph should be read.
16 · Planned
Merge Conflicts and How to Resolve ThemRead conflict markers, choose a correct combined result, and finish the merge with a message that records the decision.
17 · Planned
Rebase, Interactive Rebase, and When Not ToReplay commits onto a new base, edit a local series, and refuse rebase on published history that other people already use.
18 · Planned
cherry-pick, Tags, and Annotated HistoryApply a single commit elsewhere, mark releases with tags, and distinguish lightweight pointers from annotated records.
19 · Planned
Unit Project: Feature Branch with a Real ConflictCreate a feature branch, produce a genuine conflict, resolve it, and merge with a graph you can explain on paper.
20 · Project · Planned

4. Remotes and GitHub

remotes, fetch, pull, and pushConnect a local repository to a remote, update remote-tracking branches, and push without guessing which branch moves.
21 · Planned
HTTPS, SSH, and Credential HelpersChoose a transport, store credentials safely, and recover from auth failures without pasting tokens into the repository.
22 · Planned
GitHub Repositories, Visibility, and READMECreate a GitHub repository, set visibility, write a README that tells a stranger how to clone and run the project, and push the first history.
23 · Planned
Forks, origin, upstream, and SyncingClone, fork, and add upstream remotes so your copy can receive updates without overwriting someone else's default branch.
24 · Planned
GitHub Issues and Discussing WorkOpen issues that describe a problem, expected result, and reproduction steps instead of dumping a vague complaint.
25 · Planned
Releases, Tags, and GitHub PagesPublish a versioned release from a tag and understand when Pages is a static site host rather than a substitute for Git.
26 · Planned
Unit Project: Publish and Sync Two ClonesPush a repository, clone it a second time, exchange commits, and prove both copies share the intended history.
27 · Project · Planned

5. Collaboration on GitHub

Pull Requests as a Review SurfaceOpen a pull request with a clear change set, description, and linked issue so review can start from evidence.
28 · Planned
Code Review: Comments, Requests, and MergingGive and receive review that talks about behavior and risk, then merge with a strategy you can justify.
29 · Planned
GitHub Flow, Trunk-Based Development, and Git FlowCompare common branching models and choose one that matches team size, release cadence, and review needs.
30 · Planned
Protected Branches, Required Checks, and CODEOWNERSStop accidental pushes to the default branch and require review or checks before history can move.
31 · Planned
Templates, Labels, and Project BoardsGive issues and pull requests a repeatable shape so the team does not reinvent the same missing context.
32 · Planned
Contributing to Other People's RepositoriesRead a contributing guide, fork or branch correctly, keep a small diff, and respond to review without rewriting shared history.
33 · Planned
Unit Project: Open, Review, and Merge a Pull RequestTake a change through issue, branch, pull request, review comments, and merge so the GitHub conversation matches the Git graph.
34 · Project · Planned

6. Automation and Professional Git

GitHub Actions for Tests and ChecksAdd a workflow that runs on pull requests, fails on a real defect, and reports a result reviewers can trust.
35 · Planned
Git Internals: Blobs, Trees, Commits, and RefsInspect objects and refs until commit, branch, and tag are locations in a graph rather than product-button names.
36 · Planned
reflog, bisect, blame, and RecoveryFind a lost commit, isolate a regression, and attribute a line of history without treating blame as a personnel tool.
37 · Planned
Signing, Tokens, and Secret HygieneSign commits when the project requires it, keep tokens out of history, and rotate a leaked credential as a documented incident.
38 · Planned
Unit Project: Team Repository with CI and ProtectionAssemble a default branch, protection rules, a failing-then-passing check, and a merged pull request as release evidence.
39 · Project · Planned

Prove the whole path

Git and GitHub assessmentProve the path with scenario questions on history, remotes, review, and recovery. Published when the lessons exist.
Planned
Capstone: Collaborative release repositoryShip a small public project with issues, protected main, reviewed pull requests, tags, and a passing check.
Capstone · Planned