The Weekly Learning Plan

A calendar-shaped version of the roadmap, for people who prefer a schedule to a checklist. Sixteen weeks at roughly 8–12 hours per week — evenings and one weekend session.

Adjust freely. The only rule that matters is the one from the teaching method: do not move on until the current behavior can be inspected and explained. A week that ends with working code you cannot explain is a week you will repay with interest in week 11.

The Shape of the Course

   W0     ▓                    Warm-up + mental model            no code
   W1-3   ▓▓▓                  Section 1: PTYs and processes      M1-M3
   W4-8   ▓▓▓▓▓                Section 2: the terminal core       M4-M6
   W9-11  ▓▓▓                  Section 3: the graphical frontend  M7-M8
   W12-14 ▓▓▓                  Section 4: the multiplexer         M9-M12
   W15    ▓                    Section 5: architecture            M13
   W16    ▓                    Compatibility + capstone           M14

Sections 3 and 4 are independent — both depend only on Section 2. If multiplexers interest you more than fonts, swap weeks 9–11 with 12–14.

Week 0: Orientation

Gate: you can define TTY, PTY, line discipline, emulator, shell, and multiplexer without using any of the other five in the definition.

Tip: Commit answers-m0.md even though it is wrong in places. You re-answer the same twelve questions at the capstone, and the diff is the most direct measure of what you learned.

Weeks 1–3: Section 1 — The PTY Laboratory

Week 1 — Raw mode and the first PTY

Gate: every key decoded; stty -a identical before and after; the terminal restored on panic.

Week 2 — Sessions, job control, and spawning a shell

Gate: vim and top run inside your runner; no "no job control in this shell"; you can recite the spawn syscall list with each one's failure mode.

Warning: Week 2 is where people fall behind, because job control is genuinely harder than it looks and the failure modes are misleading. Budget the extra evening. If Ctrl+C does nothing, the answer is in that chapter's failure-mode table.

Week 3 — The event loop

Gate: resize propagates to vim; yes does not freeze anything; a recorded session replays deterministically; all seven experiments written up with predictions.

Weeks 4–8: Section 2 — The Terminal Core

The longest stretch, and the one that most rewards patience.

Week 4 — The parser

Gate: feeding any recording one byte at a time produces an identical action stream. This is non-negotiable — everything after it assumes the property holds.

Week 5 — The screen

Gate: mini-term run --cols 10 -- printf '0123456789' reports col=9 pending_wrap=true.

Week 6 — Sequences and color

Gate: ten golden cases; deterministic across ten runs; the four required PTY integration tests.

Week 7 — Unicode

Gate: the spacer property test passes over 20,000 random operations.

Week 8 — Modes, regions, and strings

Gate: vim, less, and top render correctly under mini-term. You now have a terminal emulator — it simply has no window.

Weeks 9–11: Section 3 — The Graphical Frontend

Week 9 — Pixels

Gate: a shell in a window; vim and top work; idle CPU ~0%; yes does not freeze the UI.

Week 10 — Input

Gate: every table row unit-tested; Alt+B works in bash; pasting into vim does not staircase.

Week 11 — Interaction and the trace

Gate: you can produce the debug log for one keystroke and explain every line.

Weeks 12–14: Section 4 — The Multiplexer

Week 12 — Sessions and panes

Gate: the tiling property test over 1,000 random trees; a hidden top still current after 60s.

Week 13 — Client and server

Gate: kill -9 on the client leaves shells running, proven with ps.

Week 14 — Attach, detach, copy mode

Gate: two clients attached at different sizes, both working; reattach after 5 minutes is instant and correct.

Week 15: Section 5 — Architecture

Gate: the audit passes in CI; four consumers of one unmodified core; wasm32 builds.

Tip: Do the audit on day one of week 15, before reading the fixes. The list of failures is the week's syllabus, and it is more instructive than any chapter.

Week 16: Compatibility and the Capstone

Gate: the demonstration runs end to end; the write-up is done; you have scored yourself honestly.

Compressed Schedules

Eight weeks (~20 h/week)

Double up. Sections 1 and 2 stay at full length — they are the foundation and compressing them is false economy. Compress Sections 3–5 instead.

   W1   Warm-up + M0 + Section 1 weeks 1-2
   W2   Section 1 week 3 + Section 2 week 4
   W3   Section 2 weeks 5-6
   W4   Section 2 weeks 7-8
   W5   Section 3 (all)
   W6   Section 4 weeks 12-13
   W7   Section 4 week 14 + Section 5
   W8   Compatibility + capstone

"I only care about X"

Sections 3 and 4 are genuinely optional relative to each other. Section 5 assumes you did at least two of Sections 3, 4, and the CLI.

Keeping Yourself Honest

Weekly, ten minutes:

• Did I write predictions before every experiment this week?
• Can I explain everything I built, or only run it?
• Are the tests still green, including last week's?
• Did I commit? (The git history is a capstone deliverable.)
• Did I add a crate I was told to avoid? Check Cargo.lock.

At every section gate: re-read that section's "Section Profile" table and check each row against what you can actually do.

When You Fall Behind

You will. The three common causes and their fixes:

And the meta-fix: the schedule is not the point. Sixteen weeks is an estimate for a person with a job. If week 5 takes three weeks because you actually understood pending wrap, that is the plan working.

Next: Milestone 0 — The Terminal Mental Model.