van Rossum, Guido

creator of Python

Guido van Rossum: Python

Lex Fridman Podcast · Nov 22, 2018

• Guido van Rossum
• Python programming language
• Python 3 transition
• BDFL resignation
• PEP 572
• machine learning vs. traditional programming
• consciousness and intelligence spectrum
• language design philosophy
• iteration speed
• Python packaging and concurrency

Core ideas

Van Rossum traces his early technical interests to building electronics kits as a teenager in the Netherlands, admitting he initially followed instructions without truly understanding underlying analog phenomena (coils, capacitors, unwanted megahertz-level oscillation) that caused mysterious circuit failures — a formative lesson in the gap between having a correct-looking schematic and something that actually works. He recalls first hearing the word "computer" at age 18 at a Math Olympiad, and only encountering one at university; his earliest personal project of note was implementing Conway's Game of Life in Pascal on a batch computer with severely limited compute budget, where he combined his electronics background (designing a boolean-logic circuit on paper first) with bit-packing tricks to compute 60 cells per generation in roughly eight instructions — a hack he remains more personally proud of than the emergent complexity of the simulation itself, since his focus was always on the craft of programming rather than the philosophical implications of what a program produces.

On intelligence and consciousness, Van Rossum states he's long been a convinced atheist and materialist (he doesn't believe in a soul or a non-physical source of mind) but pushes back against a "no magic" claim being taken as though the hard engineering problem were already solved — comparing the situation to knowing a human body is "made of atoms" while still lacking any practical, reconstructable path from atoms to organs, and arguing AI has similarly not yet bridged the many intermediate layers of abstraction between raw sensory input and genuine scene or language understanding. He proposes that intelligence and consciousness are not all-or-nothing properties but exist on a spectrum tracking increasingly sophisticated sensory processing across evolutionary history (citing cats, dogs, mice, and fish as each having some degree of intelligence), and connects this directly to autonomous vehicles: driving requires far more than following traffic rules — it demands reading social context (an elderly pedestrian near a mailbox, a shopping district's implicit behavior patterns) — leading him to speculate that if any artificial system develops something resembling consciousness, it's more likely to be a self-driving car (which must model and predict humans) than a data-center network of computers with no comparable embodied interaction need.

Reflecting on Descartes-era rationalism (the idea that all reasoning could be formalized into logic and calculation), Van Rossum argues 17th-century thinkers underestimated how much of cognition — like face recognition — depends not on discrete symbolic rules but on massive parallel pattern-matching against enormous amounts of accumulated data and context, something they had no framework to imagine. He illustrates the concept of layered abstraction using compiler internals (a parser transforms raw text into an abstract syntax tree, a data structure irrelevant to the original text) as an analogy for how even simple organisms (a fly detecting motion and light/dark contrast) build internal representations far removed from raw sensory input, with humans possessing vastly more elaborate, largely unconscious internal machinery (e.g., face recognition) whose underlying mechanism remains opaque even to the person using it.

Pressed on modern machine learning ("software 2.0" — training neural networks on input/output examples rather than writing explicit, provably correct rules), Van Rossum draws a sharp definitional line: for him, an algorithm has historically meant something fully understood and mathematically provable (citing the Sieve of Eratosthenes as an example), which stands in contrast to systems whose builders can't fully explain or formally verify their behavior — and he resists calling this activity "programming" at all, comparing it instead to how a genuinely new field or discipline (like biochemistry emerging from cell biology) eventually earns its own name once a technique is well enough understood to no longer be filed under "AI," a pattern he's observed recur throughout AI's history. He extends this into the practical reality of programming as actually practiced today: even "traditional" (1.0) programming abandoned the ideal of provably bug-free software long ago, since most software developers only address bugs frequent enough to be genuinely annoying, and modern systems are built with pervasive retries, timeouts, and fallback mechanisms — precisely the kind of graceful degradation he suspects biological systems also rely on for survival. He also notes that most introductory programming education only ever covers "programming in the small," where any bug can be found and fixed by inspection — leaving students unprepared for the qualitatively different challenges of engineering at the scale of large real-world systems (citing summer interns at Dropbox being consistently surprised by this gap).

On Python's design origins, Van Rossum describes a deliberately narrow, pragmatic three-month timeline and scope: he wanted a language positioned between shell scripting and C, aimed specifically at improving his own team's productivity in a specific environment, not solving every language design problem simultaneously — a focus he credits as essential, since trying to address every possible complaint at once would have been paralyzing. He explains his design methodology as deliberate borrowing rather than invention from scratch: coming to the project in his mid-30s with substantial prior experience implementing parsers and having spent years debating the design of the ABC language, he consciously reused specific concrete features he liked from multiple existing languages (indentation-based blocks and other syntax from ABC; string literal and number handling from C), arguing this kind of language design requires the accumulated experience a very young, inexperienced language designer typically wouldn't have. On what distinguishes Python's productivity gains, he frames it in terms of iteration speed: since much more programmer time is typically spent writing and rewriting code than running it (especially during exploratory work), a language and ecosystem with fewer low-level details to get right before code compiles and runs, backed by a large library of pre-built components, dramatically shortens the "sketch it, run it, see what's wrong, fix it" loop — drawing an explicit analogy to breadboarding a rough, fragile electronics prototype before later designing a robust, soldered PCB once the design is validated.

Discussing the contentious, non-backward-compatible transition to Python 3, Van Rossum frames it as a deliberate, collectively-reasoned tradeoff: certain long-recognized "warts" in the language couldn't be fixed while preserving backward compatibility, and after years of accepting them as permanent imperfections, the community concluded they were significant and worsening enough to justify a breaking change — while other well-known Python shortcomings (relative to features in Java, R, or Visual Basic) were consciously left alone because they could be mitigated through documentation, static analysis, or linting rather than breaking changes. He recounts his own resignation as Python's "Benevolent Dictator For Life" as directly triggered by the exhausting, personally draining debate over PEP 572 (assignment expressions, the "walrus operator") — describing waking up the morning after finally approving it and deciding, within about 15-20 minutes of writing, to step back permanently rather than continue enduring similarly stressful, often personally targeted disputes over what is or isn't "Pythonic." He notes the announcement (posted to what he assumed was an internal-only forum) leaked to public Twitter discussion within roughly five minutes, and clarifies that despite the dramatic, open-ended tone of his resignation letter (deliberately not naming a successor), he felt genuinely confident handing off control specifically because Python's core developer community — a group of 50-100 people spanning diverse technical backgrounds and experience levels — was healthy enough to self-govern, even while acknowledging he wasn't fully confident about which specific governance model (of several competing proposed "constitutions") the community would ultimately adopt.

On community dynamics and technical debate more broadly, Van Rossum argues that ongoing critical feedback (even at small scales, like code review comments suggesting a better approach) is healthy and productive, distinguishing it from outright hostility, which he considers corrosive rather than constructive. Closing on several forward-looking technical topics: he expresses skepticism that Python will ever become a genuinely high-concurrency, high-parallelism language given its design, typical usage patterns, and implementation, though he considers asyncio a reasonably successful, narrower solution specifically for high-throughput I/O-bound workloads; for true CPU parallelism, he points to compiled, C++-implemented packages (like NumPy) that internally parallelize across CPUs/GPUs while Python code merely orchestrates them at a high level. On packaging (which he calls his least favorite topic), he describes the fundamental tension between OS-level and language-specific package managers, and states his own practical approach — using the system package manager to install Python itself, then pip for Python packages, alongside a separate but coexisting scientific/numerical ecosystem (Anaconda) — while noting that Python packaging has improved dramatically compared to a decade earlier.

Closing on a personal note, Van Rossum names Python as unambiguously the accomplishment he's most proud of — framing it not merely as an invention but as something he actively raised, nurtured, and ultimately "set free" to take care of itself, in a manner he explicitly likens to raising a child.

Excerpts