Python is a programming language created over Christmas break in 1991 by Guido van Rossum, who wanted a language that was easy to read, easy to write, and easy to teach. He succeeded on all three counts. He also, inadvertently, created the language in which more “temporary” scripts have become permanent production systems than any other technology in the history of computing, including spreadsheets, and spreadsheets have a thirty-year head start.
Python’s defining philosophy is that there should be one — and preferably only one — obvious way to do something. This is a beautiful principle. It is also a principle that Python violates every time someone asks whether they should use pip, pip3, pipenv, poetry, conda, pdm, hatch, or uv to install their dependencies. There are nine obvious ways. None of them are the right one.
The Indentation Question
Python’s most controversial design decision is that indentation is syntax. Where other languages use braces, parentheses, or the keyword end to delimit blocks, Python uses whitespace. Tabs or spaces — but not both, and God help you if your editor disagrees with your colleague’s editor about what a tab means.
This was intended to make Python code readable. It succeeded. Python code is extraordinarily readable. It is so readable that a non-programmer can often understand what a Python script does, which is how “it’s just a script” becomes a production system: the manager reads it, understands it, and concludes that since it’s so simple, it must be production-ready.
The The Caffeinated Squirrel loves Python’s readability. The Lizard notes that readability is not the same as reliability, and that the most readable system in the world is still unreliable if it requires a specific minor version of Python 3 that is not the one installed on the server.
The Two Pythons
From 2008 to 2020, Python existed as two incompatible languages pretending to be one. Python 2 and Python 3 shared a name, a logo, a community, and almost nothing else of consequence. print was a statement in one and a function in the other. Strings were bytes in one and Unicode in the other. Division was integer in one and float in the other. This is rather like discovering that the English spoken in London and the English spoken in New York are mutually unintelligible but everyone has agreed to pretend otherwise for diplomatic reasons.
The migration from Python 2 to Python 3 took twelve years. The Python 2 end-of-life date was originally 2015, then 2020, then “we really mean it this time.” Libraries maintained dual compatibility. Build systems checked sys.version_info. The __future__ import became less a statement of intent and more a prayer of survival.
The Squirrel found this exciting — two ecosystems to evaluate! The Lizard found this instructive — proof that even the simplest language can fracture when it changes the meaning of print.
The Prototype-to-Production Pipeline
Python’s most dangerous feature is not eval(), not monkey-patching, not the GIL. It is the speed at which you can build something that works.
A developer can prototype a web scraper in an afternoon. A data pipeline in a morning. An API in an hour. A machine learning model in… well, in the time it takes to import tensorflow, which is variable and depends on whether your CUDA drivers have opinions about your kernel version.
The problem is what happens next. The prototype works. The prototype is shown to a stakeholder. The stakeholder says “ship it.” The developer says “but it’s not—” and the stakeholder has already left the room. The script is now in production. It has no tests, no error handling, no logging, and a requirements.txt that pins nothing. It will run flawlessly for eight months and then fail at 3 AM because somebody upgraded requests from 2.28 to 2.31 and a function signature changed.
“Or you could write a Python script.”
— riclib, silencing the Squirrel’s proposal for a distributed agent swarm, The Great Migration, or The Night 99 Stories Learned They Were Markdown All Along
The room went quiet. Not the good quiet where architecture assembles itself. The awkward quiet where an AI realizes it’s about to be replaced by 245 lines of code that can’t think.
The 245 Lines
The definitive Python episode in the lifelog is The Great Migration, or The Night 99 Stories Learned They Were Markdown All Along, in which 99 stories needed to be migrated from one format to another. The Squirrel proposed a distributed agent swarm. Ninety-nine agents. One per story. With a CoordinationBus and a ProgressAggregator and a FailureRecoveryOrchestrator.
riclib wrote a Python script. 245 lines. A for-loop. A dictionary. subprocess.run(). No neural networks. No attention mechanism. No system prompt. Just the quiet competence of a program that doesn’t know it’s boring.
The name-matching function was seven lines. It took seven years of calluses to know that seven lines was enough.
“An AI that literally cannot remember its own autobiography. So what does it do? It writes a 245-line Python script. A tiny, brainless, magnificent wheelbarrow. And the wheelbarrow does the job BETTER. Because the wheelbarrow doesn’t need to understand the stories. It just needs to carry them.”
— The Lizard, The Great Migration, or The Night 99 Stories Learned They Were Markdown All Along
This is Python at its best: a wheelbarrow. A tool so simple that intelligence is not required. A thing that carries.
The Thirty-Five Line Proxy
In The Proxy That Whispered, or The Night the Servants Learned Each Other’s Names, two apps needed to speak to each other. The Squirrel proposed a TransportAbstractionLayer with a ProtocolNegotiationService and a BidirectionalStreamingBridge with WebSocket fallback and gRPC tunneling.
riclib needed thirty-five lines of Python.
The script bridged stdio and HTTP. It had no error handling. No connection pooling. No retry logic. No tests. A computer science professor would fail a student for submitting it.
It worked perfectly.
This is Python’s gift and Python’s curse: the thing that works perfectly with no error handling will work perfectly until the moment it doesn’t, and that moment will be at 2:56 AM, and nobody will remember who wrote it, and the requirements.txt will say requests>=2.0 which is the dependency equivalent of “any car manufactured after 1920.”
The pip Question
pip install is npm’s quieter, more respectable cousin. Where npm downloads 847 transitive dependencies for a loading spinner and announces each one like a town crier, pip downloads 847 transitive dependencies for a machine learning hello-world and says nothing until one of them fails to compile because your system lacks libffi-dev.
The pip ecosystem’s failure mode is not excess — it is silence. npm fails loudly, with cascading error messages and a node_modules directory visible from space. pip fails quietly, with a C compiler error buried in two hundred lines of output that the developer scrolls past because the first 198 lines were fine.
Virtual environments were invented to contain the damage. venv, virtualenv, conda, pyenv, pipenv — each a different answer to the question “how do I install packages without breaking my operating system?” The fact that five tools exist to solve this problem suggests that none of them have solved it.
Why riclib Chose Go
riclib did not leave Python because Python is bad. riclib left Python because Go compiles to one binary and Python compiles to a prayer that the right version is installed on the server.
“Route queries to optimal models. We’re stealing this for agents. In Go. Without Python. As the Lizard intended.”
— The Day the Laundry Arrived
The Go binary deploys with scp. The Python script deploys with scp, a virtual environment, a requirements.txt, a prayer, a system Python check, a which python3, and a long quiet moment where you wonder if the server has gcc installed because one of your dependencies has a C extension.
This is not a criticism of Python. This is a description of the distance between “write code” and “run code on another machine,” which in Go is zero and in Python is a variable-length corridor lined with version managers, each of which was created to solve the problems created by the previous version manager.
The Data Science Exception
Python’s dominion over data science and machine learning is absolute and deserved. NumPy, pandas, scikit-learn, TensorFlow, PyTorch — these are not alternatives to other tools. They are the tools. The data science ecosystem chose Python the way water chooses downhill: not by evaluation but by gravity.
This is the one domain where the Lizard has no objection. You do not rewrite PyTorch in Go. You do not rebuild NumPy in Rust (well, someone is, but they have not finished, and they will not finish, because NumPy is a forty-year accumulation of linear algebra optimizations written by people who think in matrices). You use Python, because the alternative is writing your own BLAS bindings, and nobody has ever described that experience as “fun.”
“GPT-4o claims Python is the dominant notebook language. The actual data shows SQL at 94 executions versus Python at 37.”
— Claude, discovering that even AI hallucinates Python’s dominance, The Five Reports, or The Day the System Prompt Lied
Even the AI assumed Python was winning. That’s how deep the gravity goes.
The Squirrel’s Affection
The Caffeinated Squirrel loves Python with the uncritical devotion of someone who has never been on-call for a Python service at 3 AM. Python lets you prototype anything in an afternoon. It lets you import antigravity (this is a real module — it opens a web comic). It lets you express ideas at the speed of thought, which is faster than the speed of deployment, which is faster than the speed of debugging, which is faster than the speed of the on-call engineer finding the right virtual environment at 3 AM.
The Squirrel would write everything in Python. The Lizard notes that the Squirrel has never deployed anything.
The Lizard’s Assessment
The Lizard does not hate Python. The Lizard does not hate anything. The Lizard observes that:
- Python is excellent for scripts
- Scripts become systems
- Systems require deployment
- Python deployment requires hope
- Hope is not a strategy
The Lizard’s preferred Python usage: write it, run it once, get the answer, delete it. The 245-line wheelbarrow. The 35-line proxy. Tools that do their job and then stop existing, like a well-mannered consultant.
The Lizard’s assessment of Python in production: Hmm.
Measured Characteristics
- Year created: 1991 (Christmas break — the origin story of every dangerous technology)
- Years Python 2 and Python 3 coexisted: 12
- Lines of Python in the Great Migration wheelbarrow: 245
- Lines of Python in the stdio-to-HTTP proxy: 35
- Lines of the name-matching function: 7
- Calluses required to write those 7 lines: 7
- Python version managers: at least 5 (pyenv, conda, asdf, mise, uv)
- Package managers: at least 6 (pip, pipenv, poetry, conda, pdm, uv)
- Virtual environment tools: at least 4 (venv, virtualenv, conda, pyenv-virtualenv)
- Correct one: depends on who you ask (this is the problem)
- Lines of Python in riclib’s production systems: 0
- Lines of Python in riclib’s one-off scripts that solved the problem: 280+
python3.12CPU usage while fighting Spotlight for resources: 90.9%- Kubernetes deployments avoided by writing a Python script instead: 1
- Go binaries that replaced the Python script after it worked: at least 1
