learning.
learning3 min read

learning · self-study courses for working programmers

Academic self-study series — every lesson has clear goals, a file tree, walkthrough, pitfalls, exercises and answer keys. For disciplined self-learners.

learning · self-study courses for working programmers

Self-study with discipline — your own pace, still ship the product

I built this library the way I wish someone had handed it to me back when I was teaching myself to code at 2 a.m. Every series here is shaped the same: a clear goal, a file tree you can copy line-for-line, a walkthrough I'd actually follow, the pitfalls I tripped over so you don't have to, and exercises with answer keys for when you're stuck. No mystery. No hand-waving. Just a path from clone to shipped.

You're on the entry page of that library. Every series follows a fixed template — you know in advance what each lesson covers, what you have to do, and how to tell when you've done it right.

Why study here

A friend of mine tried to learn C++ from three different sources at once and quit by week two — not because any of them were bad, but because none of them shipped a finished thing. Here is what changes when a series commits to one.

  • Your own pace. No classroom, no exam pressure, no peer to keep up with. Pause as long as you need — as long as the series ends with something that actually runs.
  • Self-grading. Every lesson has a "How to verify" section — a concrete way to check your own work without needing anyone else's eyes on it.
  • Project-driven. Each series ships a real project: a Sudoku game in C++ + ImGui, a pixel-art engine in LÖVE, a FastAPI stack deployed to a VPS… You'll learn by doing here — and reading the textbooks alongside still pays off when you want the why.

How to study

Most self-learners stall at lesson 3 — not because lesson 3 is hard, but because they skipped one step in lesson 1. Here is the order that prevents that.

  1. Read the series preface first — what this series teaches, who it's for, what the final product looks like.
  2. Set up the environment exactly as in lesson 1's "File tree" — don't skip; later lessons assume that structure.
  3. Read each lesson in order — every lesson has 10 fixed sections:
    • Goal — what this lesson must achieve
    • File tree — what the repo looks like after this lesson
    • Content to learn — knowledge summary
    • Walkthrough — step-by-step
    • Key learning — distilled lesson
    • How to verify — self-check
    • Pitfalls — common mistakes
    • Further study — extra reading
    • Exercises — extensions
    • Answers — hints after you've tried
  4. Try the exercises before opening Answers. If you're stuck, read Pitfalls first.
  5. Verify before moving on. If the test doesn't pass, don't proceed.

What you walk away with per series

What is left after the last lesson — a notebook of definitions, or something you can clone and actually run?

  • A Git repo that clones and runs out of the box.
  • A finished product — game, app, pipeline — not a sandbox toy.
  • The confidence to modify, extend, and debug what you just built — no blind copy-paste.

Series in preparation

I'm adapting the first series from a real project — it lands in the coming days. New series will appear on the main page as they ship.

In the meantime, you can switch language:

Series

1 series