Dara's script reads eighteen months of exports from a bicycle counter and prints the busiest hour of each weekday. It is forty lines of Python, it is correct, and it runs on exactly one computer.
The forty lines took an evening. The second computer took the rest of the week, and none of what went wrong on it was Python.
Eight topics, and five of them are places rather than subjects
Three of the eight are true no matter what you end up building. Foundations is the one you would keep if every language you know were taken away: what a loop costs, what a hash table is for, and why a bug hides. The syntax and the ecosystem, one language at a time is where a language and the several hundred packages around it get written down. Shipping is everything that happens after the program works and before anybody else can use it.
The other five are not subjects picked out of interest. Each is a set of constraints, defined by the thing that kills a program written for it. On everything between a browser and a server you own neither machine your code runs on, there are two of them, and the network between them fails in ways that neither one reports. In apps on a device someone carries the limits are a battery, a store review before anybody sees it, and a phone you cannot log into to see what happened. Storing data so you can get it back answers to one requirement the other four do not have, which is that the data has to still be there after the power fails halfway through a write. On a ledger nobody owns the code is public, permanent and usually holding money, so there is no second deploy. And in systems, art and code, shipped as something you play the budget is sixteen milliseconds a frame, sixty times a second, and going over it is visible to every player.
Filed the other way round, by language, one page called Python has to cover a web request, a training run, a game loop and a script that renames files, and it can only say what is true of all four, which is the syntax. That is the argument for a language being one topic of eight here rather than the top level, and it is the same argument for why two people who both write Go fluently can be unable to do each other's work.
One job in this pillar has no topic of its own, and that is deliberate. Reading code somebody else wrote has no syllabus; it is what you are doing inside all eight of them, and the only way to practise it is to open a project you did not write. The division costs something, and it shows from Knowledge has a shape: no other world on the site carries as many clusters, because a question settled on the web has to be settled again on a phone, and again inside a game.
One language, until something of yours runs somewhere you are not sitting
Yasamin has written JavaScript for three years, Python for one, and Go since March. She can read all three. Nothing she has written in any of them has ever run on a machine other than her own laptop. A second language is the most expensive way to avoid the second subject.
It is tempting for a reason worth saying out loud: a new language gives back the first month. Everything is new again, every evening ends with something that worked, and the syntax already in your head makes week one feel fast. Shipping gives you none of that for a fortnight and then gives you an address somebody else can open.
So the order is one language, held until a program of yours runs somewhere you are not sitting, then widened. The ideas that survive every change of language are not a prerequisite course to be finished first, whatever the university order suggests. They arrive on the afternoon Dara's script starts checking each of eighty thousand rows against a list of every station it has already seen, and the same job written with a dictionary finishes before the fan comes on. That lesson does not land in the abstract, which is what makes taking it in the abstract the other wrong order.
Week six
The fork after the first program that works
Both arms feel like progress. Only one of them ends with something a stranger can open.
- What almost everybody doesStart a second languageMonth one again, and it reads as progress because everything in it is new
- Syntax you already have, spelled differently
- Still nothing of yours running anywhere
- The gap widens quietly, in both languages
- What paysPut the same program on a machine that is not yoursA fortnight of nothing working, and then an address
- A terminal you opened yourself
- A repository with the versions pinned
- One link somebody else can click
It does not say the second language is a mistake. It says it is not week six, and the people who take it at week six are usually taking it instead.
The stall is the first day the code has to run where you configured nothing
Everyone in this field knows the sentence for it: it works on my machine. Somebody who has made steady progress for four months stops making any, and concludes they are bad at programming. They are not. They have walked into a second subject that nobody told them was a subject, and it arrives disguised as failure at the first one.
Dara's forty lines assume four things that appear nowhere in the file: a Python that came with the operating system and is two releases behind, a library installed in 2023 by an installer nobody remembers running, a folder path with a username in it, and a text encoding chosen by whichever machine wrote the CSV. None of the four is Python. None of the four is written down. All four have to be true before line one runs.
The reason nobody warns you is honest enough: the people teaching the language do not count the environment as part of the language, which is correct and useless. The answer has a name, shipping the environment along with the code, and it is a fortnight of work rather than a year, once somebody says the name out loud. The other half of the same stall is the terminal, which has its own grammar and lives next door under the layer between hardware and everything you run.
The stall
The syllabus of the subject nobody told you was a subject
Four months of steady progress end at a bank, and the far side is week one of something else with its own beginner level.
- 01A terminal, and the fact that a path is a thingWhere a command runs from decides what it can find
- 02A lockfile, so the versions are yours on purposeSomebody else's code, pinned rather than newest
- 03A repository, before there is anything to loseThe undo that survives closing the laptop
- 04One machine you did not configureIt has none of your four years on it, which is the point
Four planks and no fifth. This subject is finite, which is the part nobody mentions while you are standing on the first bank.
What to open in 2026
VS Code has been the default editor since about 2016 and it is free. It replaced Sublime Text and Atom, and Atom was archived in December 2022, four years after its own maker was bought by the maker of VS Code, which settles it more plainly than any comparison. Two alternatives are serious: the JetBrains editors, which know one language deeply and earn their price for somebody in that language all day, and Neovim, which earns its learning curve for somebody whose work happens on machines that are not theirs. The mistake is thirty extensions installed before anything is written: each is a thing that can break, and none is the thing being learned.
Git was written in 2005 for the Linux kernel, it replaced Subversion and the habit of copying a folder before changing anything, and it is free. It is a topic here rather than a tool tip, and it sits under the history of a project, and working in parallel. The mistake is learning add, commit and push as a three word spell, so that the first time something goes wrong the only known move is to clone the repository again and paste the edits back in. git restore --staged unstages a file and leaves the edit alone, and that one command is the whole difference between undoing and starting over.
An assistant inside the editor is the largest change to this work since GitHub Copilot became generally available in 2022, and half the people reading this are learning with one. It replaced the search for somebody who had already asked your question. It is very good at code you could have written yourself slowly, which is most code. It is confidently wrong at anything unusual, in fluent and well formatted output that looks exactly like the code that works. And a beginner cannot yet tell which of the two is on the screen, because telling them apart is the subject itself. The free tiers are real and are enough to learn with. The habit that survives that last sentence is to make it explain the line you did not write and then check the explanation against something that runs, which is the same move as getting a useful answer instead of a plausible one.
The fourth belongs on no list of editors, because it answers the stall rather than the work. For Python, uv arrived in 2024, it is free and open source, and it replaced pip, virtualenv and pyenv, which had been three tools doing one job: uv installs the runtime version a project asks for and pins every package in a lockfile, so a machine that clones your repository gets what you had rather than what is newest today. Every ecosystem has its own version of that lockfile. The mistake is reading it as generated noise and keeping it out of the repository, which throws away the only thing it was for.
The three month signal is a repository you did not write
The measure is not how much syntax you can produce from memory. It is whether you can take a stranger's project, clone it, and get it running on your own machine, alone, in an afternoon.
At one month this fails, and it fails in a way you cannot describe: something did not work and there is no name for which thing. At three months it either runs, or it does not and you can name the step that stopped it. The runtime is a release behind what the project asks for. A system library the packages compile against is missing. It expects a database answering on port 5432 and nothing is listening there. It wants an environment variable nobody documented. Naming the failing step is the skill, and fixing it afterwards is a search.
A smaller one is checkable this afternoon: when a program fails, the frame that names a file you wrote is the one to open, because the error was noticed inside a library and caused in your own file, and the library line has told you almost nothing about why. The other one takes a colleague, who should be able to run what you have from the repository, at their own desk, without you on the phone.
The signal
The same program in four states, each with less of you in it
Nothing in the code changes between the first frame and the last. What changes is how much of your own machine it is still leaning on.
- 01It runs when you press playInside the editor that installed everything for you
- 02It runs in a terminal you openedSame machine, nothing helping
- 03It runs from a fresh cloneYour repository, and the first honest audit of what you never wrote down
- 04It runs where you have never logged inThe frame in which the program stops being yours
The frames are not evenly spaced in time. The last one usually costs more than the three before it together, and a strip cannot draw that.
Where to go in
Foundations and Languages are where nearly everyone starts, and the honest split between them is that one survives a change of language and the other is the change. Take the second only far enough to make the first visible. Getting code off your machine and keeping it running is the one to open earlier than feels reasonable, because version control, tests, containers and a deploy are all easier to learn on a program of forty lines than on a program of four thousand.
Of the five places, the web is the one to open first without a reason to prefer another, and the reason is not technical: a stranger sees the thing you made by clicking a link, which at month two counts for more than any argument about languages. Mobile is for when the thing only makes sense in a pocket, and the price is a signing certificate and a review queue standing between the code and the first user. Databases is reached late and worth reaching early, because nearly every program that is not a game has to remember something, and tables designed wrongly are the expensive kind of wrong. Games has the shortest feedback loop in this pillar and the hardest constraint, which is why people who learn there learn performance early. Blockchain is the narrowest of the eight and the least forgiving, and it is for people who genuinely need a record no single party can quietly amend.
What is left is the question almost everybody arrives with, which is which language to start in. It matters less than the hours spent choosing, and it is not arbitrary either. What the choice actually depends on, and what it does not is where that gets settled, and the short version is that the right first language is the one used by the people who will answer your questions.