One fixed question set, asked of every language I care to learn. The languages are the variable; the questions are the constant. Programming languages first; human languages on the same method.
The comparison matrix — every programming language against every taxonomy axis, on one page. It is the reason the questions are held constant.
The fixed question set every track answers, in the same order, with the same headings. The languages are the variable; these ten questions are the constant.
The single benchmark program every track implements, specified tightly enough that all of them produce byte-identical output. Includes the integer-arithmetic rule and why floating point is banned.
Six orthogonal tag axes instead of one. Why "full stack" is a career label rather than a language property, and what to use instead.
The runbook for taking a passing track to publishable rigor: cited sources, self-derived figures, and a de-slop pass. Run once per track; 10-c is the reference implementation.
The language every other language is implemented in. Manual memory, a standard library that gives you almost nothing, and undefined behaviour as a design choice. Build a hash table by hand and find out what the others were doing for you.
The C track's ownership rules, moved out of comments and into the type checker. Same line buffer, same borrowed fields, same copied keys, and a compiler that rejects the version with the bug. The first track to implement --shard N.
Where object orientation is actually taught properly, where lambdas arrived and moved the language's centre of gravity, and why a 2014 release is still what an enormous amount of production code is written in.
The baseline you already know, placed deliberately after Java so the dynamic tradeoff is felt rather than assumed. Also the reference implementation the whole benchmark is measured against.
A language designed by subtraction, where concurrency is cheap enough to be the default structure of a program and errors are ordinary values you cannot ignore. The cleanest contrast to Java in the series.
A 2012 language on a 1986 runtime. Millions of cheap preemptively scheduled processes, no shared memory to guard, supervision instead of defensive coding — and, since June 2026, gradual type checking that needs no annotations.
The ML family's working member: inference that removes annotations rather than adding them, sum types that make illegal states unrepresentable, and a module system that is a small language in its own right. Read it before Rust.
The UCRT-vs-MinGW printf trap, three ways a byte-exact diff breaks on Windows, and the one-line realloc leak.
Two PowerShell 5.1 traps in the installer, why the toolchain is -gnu, the three compiler errors that are the C track's bugs, and the sharded run checked at every shard count from 1 to 500.
The thenComparing ambiguity, why Locale.ROOT is not optional, and the unreachable return the compiler insists on after System.exit.
Why the golden file is frozen, the two defaults that had to be overridden, and where idiomatic Python and the spec disagree.
Passed first compile, which is its own kind of finding. Why winget hung and the zip install did not, and the three places Go's defaults removed work the other tracks had to do by hand.
The official installer dying mid-download and what replaced it, the stale reduction count everyone quotes, the regex anchor that would have passed the fixture while being wrong, and a flush that is not optional.
Three toolchain walls in a row — winget, OCAMLLIB, and a Device Guard block on flexlink — the bytecode route around the third, and the one syntax error that cost more than the rest combined.
How the programming-language method ports to Korean, Japanese, and Chinese — the fixed question set, the constant artifact that replaces logagg, and the one property that honestly does not transfer.