Nineteen gyms is a menu, not a path. This is the path. A Makefile is the oldest dependency graph in software: a target, what it needs first, and the recipe. Every gym below is listed after the ones it needs, with the reason on the edge.
The road, in two minutes
› read the transcript instead
1. What the job is
Someone taps Pay. The tap becomes a request. It crosses a network to a server. Code runs. It asks a database. The answer travels all the way back. That trip is the job: knowing what happens between the tap and the answer.
2. The model writes now
Today a model writes most of that code, in seconds. It is usually right. Here, one line is not. Writing got cheap. Judging did not. Someone has to read it: you.
3. The floor
Reading starts lower than code. Everything is typed into a prompt: shell. Every change is a commit, and a diff is two commits compared: git. And you run the program in your head. b = a; b.push(3). What is a? Both. They are the same list. That is run, the first gym. Optional extras: regex to read patterns, vim to stop thinking about your editor.
4. Reading
Back to the line nobody noticed. Review: find the defect, then prove it with one input that breaks it. Test: a green suite is a claim. Break the code and see if it notices. This is the whole idea. The rest is reading in special places.
5. The trip: data and wire
Now replay the trip. Every stop is a place you will learn to read. The database: a query is a program (sql), and a migration is a lock (schema). The wire: DNS, TCP, TLS and HTTP before your code sees anything (net). The machine: processes and pipes (linux), two threads at once (concurrency).
6. The trip: ship and operate
Shipping: packed in a container, rolled out by deploy, servers declared by infra. License: trace the grants, notices and source obligations in the release. Operating: build a system and break it under load (system-design). Find the hole, and prove it with one request (secure). It breaks at 3am. You get paged, read the trace, prove why (debug).
7. Why gyms
Not a video and a quiz. A gym. Predict what happens. A real engine runs it. See if you were right. Real engines, grading you can check, no account. Free.
8. Where you start
So, where do you start? Never written a loop? Learn to code first. start8 is for that. Can write a loop? Start at run, and follow the path below.
Complete beginner? Run make all and start at the top. Know what you want? Pick a goal and the list shrinks to what that goal actually needs. Mark what you already have as up to date; make skips those.
There is no syntax course or algorithms gym at the top, and that is deliberate. Both grade you on writing code that passes, which is the part a model now does. The top is run: the code already exists, and you say what it will do before it does it. Sorting and caching still turn up there, as programs to predict rather than problems to solve.
Never written a line of code? Learn to code anyway, even though the model will write most of it — you cannot judge code you have never written. start8 ↗ teaches exactly that, outside the path. Come back to run when you can write a loop over a list.
The whole path, every target in dependency order. Start here if you do not know what you would fail.
resolving 19 targets for ‘all’ …19 targets for ‘all’
Dependency graph
the graph · left needs nothing, right needs everything · click a target to jump to its rule
# ── 1. The floor ───────────────────────────────
# What you type into, and what happens when you press enter. Every other gym is driven from a prompt and written in a language; the machine under the program, the shell, the object model under your commits, and the patterns in your greps are the substrate.
[1/19]run.liter8.shstart here
Run — Predict the state before you press run
# Needs nothing, and everything after it assumes it. This is where a basic-programming or algorithms course would sit, and it is neither: those grade code you wrote, and a model now writes that. Before you can read what a model wrote you have to be able to execute it in your head: what a name holds, which two names hold the same object, and what runs next.
first
if you cannot write a loop over a list yet: start8 ↗ — outside the path.
# A diff is the unit of review, and a diff is a difference between two commits. Learn what a commit points to before you read what changed between them.
needs
Shellgit is a command-line tool; the prompt, paths and pipes are assumed
# The thesis of the site. The model writes the code; you make the call — and reading is how you make it. Everything after this is a specialised way of reading.
[6/19]review.liter8.sh
Review — Read the diff like it's lying to you
# The thesis. Read a diff the model wrote, find the one defect, prove it with an input. Never skip this.
needs
Runa defect is something the program does; you cannot find one in a diff you cannot execute in your head
Gita diff is a difference between commits; you need the object model to know what a diff is
# A green suite is a claim about the code. You have to be able to read the code before you can judge the claim; then watch an engine break the code under your tests.
needs
Reviewmutation testing is code review run backwards: you judge whether the test would catch the defect you learned to spot
Deploy — Declare the state, then watch the loop fight you
# A rollout is old and new code running side by side against one database, in containers a scheduler placed, behind probes that speak HTTP. Three gyms, all at once.
needs
Containerpods are containers; SIGTERM and the entrypoint are the same story
Netreadiness probes, timeouts and the retry loop are network behaviour
Schemaold and new application code against one live table is the schema gym's central exercise
unlocks
— a leaf.
skip if
you know what a failing readiness probe does to a rollout
# Read a generated handler, prove the exploit with a request, ship the fix. Review gave you the reading, net gave you the request, sql gave you the injection.
needs
Reviewthe same loop: find the defect, prove it with a witness
Netthe attacker console speaks HTTP; you need to know what a request is
SQLinjection is the canonical class; you need to know what the query would have done