▶ YouTube Summaries

• YT :: https://www.youtube.com/watch?v=6JxajBbLceg
• Original title :: 🚨🚨 TheStandup: DONT LEARN PYTHON LEARN C 🚨🚨

A standup episode with Casey Muratori, TJ DeVries and Trash, prompted by Lori Wired (a Google researcher) saying CS programs are fumbling by starting students on Python rather than C or C++. The panel largely agrees with her, and Casey's argument for why is the substance of the episode: the point is not that Python is bad, it's that C is a language you can extend downward from without teaching anything new.

Opening blocker: does syntax aesthetics matter?

The prompt was a tweet claiming anyone who dislikes a language for aesthetic reasons (e.g. Rust) needs better taste. Prime likes Lua's keyword delimiters — end over curly braces — and would even accept the backwards-spelling family (~case~/~esac~, ~if~/~fi~) over braces. His actual complaint is inconsistency: C lets an if have braces or not, which also cost Java its LL(1) parser via the dangling-else problem. Odin's do for single-line bodies gets a pass.

Casey defends semicolons as terminators, on error-message grounds: a terminator tells the parser where an expression was supposed to end, so errors land at the mistake. He names OCaml as his own counter- example — a missing in can put the error a hundred lines from the cause.

Where it goes in the agent era:

• Trash: DX matters less if the agent can work with it; his own CLI argument design no longer favours humans, because agents happily handle a cajillion flags.
• TJ: the opposite. Models are trained on human corpus and are human approximator functions, so whatever communicates clearly to people will work better for them too. And tokens still cost money — a language whose errors are 130 lines from the fault makes the agent spend reasoning finding it.
• Casey: same conclusion from the cost side. Error quality is now an electricity bill.

What is a CS degree even for?

Three candidate goals, and the panel notes the field can't agree: produce good programmers, produce theoreticians who can do the pigeonhole principle on a whiteboard, or produce people who understand how a computer actually operates.

TJ wants the split maths already has — applied CS and theoretical CS, with the applied track's electives aimed at what companies hire for, partnered internships like engineering degrees have. Prime's counter-observation is structural: CS departments make their money on grants for theory but are expected to deliver practically job-ready graduates. He compares to mech and civil engineering, where you learn finite element analysis and fluid dynamics and then never do a double integral by hand on the job — nobody expects those degrees to be vocational, only CS.

Trash notes new-grad hiring already assumes they will be useless initially; the theory is the foundation and the first year is where the practical part happens. Prime, who did ~100 interviews, disagrees — he expected practicality from day one.

Prime's own scepticism about C: yes, in C you see that a struct is 24 bytes and it feels closer to the machine, but with virtual memory, paging and indirection, what you write is still not what happens. And most real debugging isn't struct layout — it's 19 microservices fanning one user request into 400 internal ones, which no language choice helps with.

Casey's argument: teach what stays true

The frame he proposes for any serious education: teach the things that remain true — the things you learned 30 years ago and did not have to relearn. He rejects the "C is not a low-level language" line as false and, more importantly, irrelevant to the argument, because the claim it's used to support — that low-level knowledge went stale as hardware changed — is simply wrong. SIMD, caches, loop caches, virtual memory: all present since around 1970. What changed is that everyone now has the best of everything in a desktop chip, where once you needed a CDC 6000 or a System/360-91 for a loop cache.

The mechanism that makes C the right teaching base is downward extension. Once a student knows basic C or Rust, you can say "here is how we make this cache-aware", "here is how we multi-thread this", "here is how we do an atomic", "here is an intrinsic that takes a SIMD vector and a mask register and packs the zero lanes" — and they need nothing beyond the C they already have plus the concept you're introducing. In a higher-level language you'd be routing through a coroutine implementation or auto-vectorisation, which hides the thing you are trying to teach. Teach someone shaders and they will never learn vectorisation, because the SIMT threading model has already absorbed it. Lori's actual words were about extending down to memory management, and that is exactly the point.

Learning a language, by contrast, is nearly free: Casey had never written Python, needed some for Substack work, and it took about five minutes. So agonising over which language a competent programmer is asked to use is not a real question; only idiomatic habits need looking up.

On "there's no difference between the stack and the heap because both live in RAM": true in a narrow sense and ridiculous as pedagogy. Push, pop, the stack pointer and the return address stack are hardware things — the return address stack isn't in RAM at all, it's inside the core. And int x translating fairly directly to a 4-byte push is a short path from source to what happens, versus tracing 30 steps in a high-level language.

His one reservation: teaching the ++ of C++ as it is now intended to be written would be just as transient as Python — nobody will care in 30 years — and he doubts that was Lori's point anyway.

Where they land on Python

Nobody argues Python is the mistake. TJ's own path is the model he endorses: Python first because you see something happen on screen and fall in love (his turtle-library moment — "I told it to turn left and it turned left"), then C or C++ immediately after for data structures. University of Maryland does the same with Java at the 100 level followed by OCaml, Rust or C. The mistake, if it's happening at all, is the absence of the second step, not the presence of the first — and Casey is careful to say he has no evidence about whether the shift Lori describes is actually occurring.

The counter-argument to leading with C++: years of tildes and destructor syntax makes programming unfun, is not a reusable skill, and drives people out. Trash did C++ in a 300-level course after VB and it nearly made him quit. If you're going to teach a non-reusable skill, at least make it exciting.

Prime's confession, and the emotional centre of the episode: he was a stellar student at Montana State in the Java era — 170% on programming language concepts tests after curving — could do register addition by hand, could balance a tree, could LeetCode like a boss. He had one shallow 100-level C class. It did not dawn on him until a couple of years after graduating that when he wrote C he was writing to the stack or the heap. He aced everything and tied none of it together, and calls it a genuine failure and a waste. That is the concrete case for downward extension.

Trash's closing

These arguments are tiring and mostly meaningless, but bringing them to light helps; ultimately whether someone goes deeper is on them, not the school. His advice for anyone job hunting now is to try much harder than they currently are, because standing out is harder. He is personally going down the low-level rabbit hole because he thinks it's the only way to stand out when he next interviews — if you just want code, you type into a text box and it appears. He admits AI is depressing him, and that building things for himself outside work is how he takes those emotions back.

Takeaways

• Lori Wired's claim was diplomatic and narrow — Python and Java are fine, but memory management needs teaching and it's easier to extend downward from C++. Most of the internet argument was people attaching their own hobby horse to a trending topic.
• The real criterion for a teaching language is not "closest to the metal" but "cheapest to extend downward from" mid-lesson.
• Hardware fundamentals have barely moved in 50-60 years; only the interconnect diagram changes. That's what makes them worth degree time.
• Passing exams on theory without ever touching the machine produces someone who can balance a tree and doesn't know where their data lives.
• Python first for motivation, C immediately after for grounding, is the sequence the panel converges on.
• In the agent era, language ergonomics arguably matter more, not less, but for a new reason: bad error locality is now paid in tokens and reasoning time.