Python — The Universal Glue
Origin story
Designer, institution, year
Python was conceived in the late 1980s. “Implementation started in December 1989 by Guido van Rossum at CWI in the Netherlands” (Wikipedia: History of Python).
Guido’s own account: “In the late 1980s, Guido van Rossum worked at Centrum Wiskunde & Informatica (CWI), a mathematical and computer science research center in Amsterdam. He was developing Amoeba, a distributed operating system intended to make a network of computers appear as a single computer using a distributed kernel” (Guido van Rossum, IEEE early years).
Timeline:
| Date | Event |
|---|---|
| December 1989 | Implementation started at CWI |
| February 1991 | Python 0.9.1 published to alt.sources |
| 1994 | comp.lang.python newsgroup formed |
| November 1994 | First Python workshop at NIST, Gaithersburg |
| 1995 | Guido moved to CNRI in Reston, Virginia |
| 2000 | Guido left CNRI; Python 2.0 released Oct 16 |
| December 3, 2008 | Python 3.0 released |
| July 12, 2018 | Guido stepped down as BDFL |
| January 1, 2020 | Python 2 support ended |
The motivating problem
Amoeba. “The Amoeba team wanted the system to be self-hosting and needed many user-level tools, including an editor, a mail program, a login utility, a backup tool. Because Amoeba’s file-system model was very different from Unix systems, existing Unix utilities could not be used. A small team was writing the tools in C, but progress was slow” (Guido van Rossum IEEE).
The predecessor was ABC, on which Guido had worked at CWI. ABC “was very high-level and abstract, not well suited to communicating with servers, file systems, and processes, good for talking about a user’s data, good for using general-purpose data structures such as lists and dictionaries.” Guido concluded ABC “could have become the language of spreadsheets” but was wrong for Amoeba tooling; Python began as an ABC-like language “with the ability to interact with the operating system” (Guido van Rossum IEEE).
The name came from Monty Python’s Flying Circus — Guido was reading the scripts during his December 1989 holiday break (Wikipedia: History of Python).
Initial reception
Guido’s office mates were “almost instantly taken with Python.” He released Python publicly in February 1991 via alt.sources, received “useful and positive feedback,” and by 1994 the community was large enough that “some adopters were US government agencies that wanted to help grow and stabilize the Python community. NIST invited Guido to come to the United States for a couple of months” (Guido van Rossum IEEE). CNRI then hired him in 1995.
Design philosophy
Core principles — The Zen of Python
Tim Peters distilled Python’s philosophy in PEP 20 (2004):
- Beautiful is better than ugly.
- Explicit is better than implicit.
- Simple is better than complex.
- Readability counts.
- There should be one — and preferably only one — obvious way to do it.
Python 3.0’s guiding principle was “reduce feature duplication by removing old ways of doing things,” “in keeping with the Zen of Python: ‘There should be one— and preferably only one —obvious way to do it’” (Wikipedia: History of Python).
What Python rejected
- Braces. “Python uses whitespace indentation, rather than curly brackets or keywords, to delimit blocks… sometimes termed the off-side rule. The recommended indent size is four spaces” (Wikipedia: Python).
- Static typing (originally). Python “uses dynamic typing… uses duck typing… has typed objects but untyped variable names. Type constraints are not checked at definition time. Operations on an object may fail at usage time if the object is not of an appropriate type. Python is strongly typed despite being dynamically typed” (Wikipedia: Python).
- Compiled distribution. Python is interpreted (with bytecode caching).
- Complex declaration syntax.
Cultural values
Readability, “batteries included” standard library, community consensus through PEPs (Python Enhancement Proposals), gradual evolution.
Language features
Syntax
Off-side indentation, def, class, if/elif/else, for/in, while, try/except/finally, with (Python 2.5, September 2006), list/dict/set comprehensions (list comps from Python 2.0, 2000), generator expressions, decorators, f-strings (Python 3.6), pattern matching (Python 3.10, PEP 634).
Type system
Dynamic, duck-typed, strongly typed. Since Python 3.5 (2015, PEP 484), optional type annotations: “Beginning with Python 3.5, capabilities and keywords for typing were added to the language, allowing optional static typing. Python supports optional type annotations. Type annotations are not enforced by the language. External tools such as mypy may use type annotations to catch errors” (Wikipedia: Python). Related PEPs: 526 (variable annotations), 544 (protocols/structural typing), 585 (generic types in stdlib), 604 (X | Y), 646 (variadic generics), 695 (type parameter syntax, Python 3.12).
Memory model
Reference counting plus a cycle-detecting garbage collector (added in Python 2.0, 2000: “a cycle-detecting garbage collector, reference counting, memory management” — Wikipedia: History of Python).
Concurrency
Threads exist but are limited by the Global Interpreter Lock (GIL): “The Global Interpreter Lock (GIL) limits typical implementations when scaling multithreading to thousands of cores. The multiprocessing module supports concurrency and parallelism. Running multiple tasks simultaneously can help overcome limitations of the GIL in CPU tasks” (Wikipedia: Python).
PEP 703 (2023, accepted) — “Making the Global Interpreter Lock Optional in CPython” — Python 3.13 (2024) introduced a “free-threaded” build (python3.13t) that removes the GIL, marked experimental. Related: asyncio (Python 3.4, PEP 3156, 2014) for coroutines; async/await keywords (Python 3.5, PEP 492).
Error handling
Exceptions with try/except/else/finally. The else clause on try was original from Modula-3 influence (“Python’s exception model resembled Modula-3’s, with the addition of an else clause” — Wikipedia: History of Python).
Metaprogramming
Powerful: metaclasses, __init_subclass__, decorators, descriptors, __slots__, dynamic class creation via type(), ast module for source manipulation, importlib, sys.settrace. No macros in the Lisp sense; but Python’s runtime introspection is deep.
Module system
“The initial release included a module system borrowed from Modula-3. Van Rossum described the module as ‘one of Python’s major programming units’” (Wikipedia: History of Python). import, packages via __init__.py, namespace packages (PEP 420), relative imports.
Notable innovations (in the mainstream)
- The off-side rule as mainstream syntax.
- The interactive REPL as first-class development mode.
- List/dict/set comprehensions in an imperative language.
- Duck typing named and celebrated.
- Optional gradual typing model (PEP 484) later borrowed by TypeScript, Ruby (Sorbet), PHP.
Implementation
CPython
“CPython is the reference implementation of Python. CPython is written in C. CPython has met the C11 standard since version 3.11. Older versions use the C89 standard with several selected C99 features” (Wikipedia: Python).
“CPython compiles Python programs into intermediate bytecode. The bytecode is executed by a virtual machine. CPython is distributed with a large standard library written in a combination of C and native Python” (Wikipedia: Python).
Lexer, parser, IR
Python 3.9 (2020) replaced the venerable LL(1) parser with a PEG parser (PEP 617). Compilation is Python source → AST → bytecode. Since Python 3.11 (2022, “Faster CPython” led by Mark Shannon) and continuing through 3.12 and 3.13, the interpreter uses specialized instructions, adaptive interpreter, and a new frame representation.
Runtime and GC
Reference counting + cycle collector. Python 3.12 added an incremental GC pass. Python 3.13’s free-threaded build uses biased reference counting and deferred reclamation.
Performance
CPython is famously slow compared to native code: “Energy usage for typically written code — Worse by a factor of 75.88; Throughput for typically written code — Worse by a factor of 71.9; Average memory usage for typically written code — Worse by a factor of 2.4” (compared with C) (Wikipedia: Python). This has driven ecosystem tooling around C-extensions and JIT alternatives.
Bootstrapping
The Python compiler is written in C plus a bootstrapping Python implementation. The PEG parser generator is Python-hosted.
Alternative implementations
- PyPy — tracing JIT written in RPython; often 5–10x faster on pure-Python workloads.
- Jython — Python on JVM.
- IronPython — Python on .NET.
- MicroPython — Python for microcontrollers.
- Pyston, Cinder (Meta), Pyjion — historical/limited JIT projects.
- Nuitka — Python-to-C compiler.
- mypyc — subset compiler using type annotations.
Ecosystem
Package manager
pip + PyPI (Python Package Index) — the standard. conda for scientific/data workflows. Poetry, PDM, hatch, uv (Astral, 2024, Rust-based, dramatically faster) for modern project management.
Standard library
Vast: os, sys, re, collections, itertools, functools, datetime, json, http, socket, subprocess, multiprocessing, asyncio, sqlite3, logging, unittest, pathlib, typing. “Batteries included.”
Tooling
pylint, flake8, ruff (Astral, Rust-based). black, isort for formatting. mypy, pyright (Microsoft), pyre (Meta) for type checking. pytest dominates testing. VS Code, PyCharm dominate IDEs.
Scientific stack
The reason for Python’s data-science dominance. NumPy (Travis Oliphant, 2006) unified Numeric and numarray; SciPy, pandas (Wes McKinney, 2008), Matplotlib, scikit-learn, Jupyter, PyTorch, TensorFlow, JAX, transformers (Hugging Face). “Most high-performance Python libraries use C or Fortran under the hood instead of the Python interpreter” (Wikipedia: Python). Python is the Lingua Franca of ML because the compute lives in C++/CUDA kernels while orchestration is in Python.
Governance
Python Software Foundation (PSF) owns the trademark; language design is via PEPs. Guido was BDFL (“Benevolent Dictator for Life”) until stepping down on July 12, 2018 (Wikipedia: History of Python). Now a five-member Steering Council elected annually.
Adoption
Where it dominates
- Data science and machine learning — almost total dominance.
- Scripting and automation — the universal glue.
- Web backend — Django, Flask, FastAPI (a top framework as of 2024–2026).
- Education — the number-one teaching language globally.
- DevOps and infrastructure — Ansible, SaltStack, most cloud SDKs.
- Scientific computing and academic research — the successor to MATLAB/Fortran.
- Bioinformatics — Biopython.
Where Python doesn’t win
- Systems programming (C/C++/Rust).
- Mobile app development.
- Frontend web (JavaScript/TypeScript, WebAssembly).
- Games (C++/C#/Rust).
- High-frequency trading.
Current momentum (2026)
Overwhelming. TIOBE, PYPL, and RedMonk indices consistently place Python at #1. Python 3.13 (October 2024) introduced experimental free-threaded builds; 3.14 (October 2025) continues the pattern. LLM tooling (LangChain, LlamaIndex) is Python-first. uv and ruff (Rust-based) modernized the tooling story, dramatically speeding up installs and linting. The GIL removal effort accepted in PEP 703 (2023) is landing incrementally.
Criticism and open problems
- Performance. CPython is slow; the reason the scientific ecosystem is a wrapper over C/Fortran/CUDA.
- The GIL. Historically ruled out multi-core parallelism inside pure Python. PEP 703’s free-threaded build is the answer.
- Packaging. Long-standing complaint — competing formats, virtual environments, dependency resolution. Improving with uv and PEP 621.
- Dynamic typing at scale. Large Python codebases (Instagram, Dropbox) have driven massive investments in static typing (Meta’s Pyre, Microsoft’s Pyright, Dropbox’s mypy). Even so, gradual typing remains gradual.
- The 2→3 transition. Widely cited as a case study in how not to break a language — 12 years of parallel maintenance (2008–2020).
- Startup time. Python’s import cost hurts CLI tools and serverless.
python -X importtimehelped;PEP 725and lazy imports address more.
Influence on other languages
- Ruby (Matsumoto) — different but overlapping niche, cited Python as reference.
- Julia — designed for scientific computing with Python interop as an explicit design goal.
- Swift, Rust, Go — all cite Python-like readability as an aesthetic target.
- TypeScript — Python’s PEP 484 type-annotation model (gradual, external checker) is directly analogous to TypeScript’s model over JavaScript.
- Elixir — Valim has said Ruby (a Python cousin) inspired much of its ergonomics.
- F#, Kotlin — used Python-style significant whitespace ideas selectively.
Key sources
- Guido van Rossum, “The Early Years of Python”, IEEE, 2015.
- Guido van Rossum, “The History of Python” blog series (2009).
- Python Enhancement Proposals (PEPs), especially: PEP 8 (style), PEP 20 (Zen), PEP 484 (typing), PEP 492 (async/await), PEP 617 (PEG parser), PEP 634 (structural pattern matching), PEP 703 (GIL removal).
- Wikipedia: History of Python.
- Wikipedia: Python (programming language).
- Python.org and CPython source: github.com/python/cpython.