Low diatribe

I learned Python in the 90s.

Thirty years ago, I knew a guy who knew a guy studying computer science, and the two of them had an idea: a website that would be part marketplace, part social network, built around trading comic books. This was the mid-90s — before eBay, before Facebook, before any of the infrastructure that would eventually make that idea seem obvious. At the time it felt radical. It felt like the future.

My friend suggested I learn Python so I could help build it.

I drove to a physical bookstore and procured a copy of Internet Programming with Python. I then spent the summer of 1997 working my way through it. Fast forward: the site never launched. The conversations slowed, became less frequent. We each found ourselves drawn into other efforts.

But I had learned Python.

Before it was the obvious choice. Before it was the first language taught in universities, the default tool for data science and machine learning, the thing everyone means when they say they "know how to code." Before it was ubiquitous.

In the 90s, Python was a curiosity. A language that believed in readability as a virtue, that whitespace was meaningful, that there should be one obvious way to do things. It was elegant and a little opinionated and not particularly fashionable. I liked it immediately.

The languages you learn shape how you think. Not just about code — about problems. About what a solution looks like. About what counts as good.

Python taught me that clarity is a design choice. That the person reading the code matters as much as the machine running it. That constraints can be generative — the one obvious way isn't a limitation, it's a shared language.

Then I learned Perl.

My first proper engineering job came with a boss who was deeply into Perl. That made it the de facto choice — you use what the room uses. Perl was the opposite philosophy made into syntax.

TIMTOWTDI — There Is More Than One Way To Do It — wasn't just a motto, it was a worldview. Perl didn't care how you got there. It cared that you got there. The language was expressive to the point of anarchy, dense with shortcuts and sigils and ways of doing the same thing that looked nothing like each other. Two Perl programmers solving the same problem would produce code that barely resembled each other's work.

This drove some people insane. I found it liberating.

There's something honest about a language that admits there's more than one way. That your path through a problem is yours. That the solution space is wider than any single approach can map. Python said: here is the right way. Perl said: here are ten ways, pick the one that fits your mind.

I needed both of those things. I didn't know that yet.

Ruby came later, through a small startup that was migrating a legacy Tomcat codebase to a brand-new, pre-release version of Rails. I walked into the beginning of that transition and everything was different again.

If Python was clarity and Perl was freedom, Ruby was joy. Matz designed it to make programmers happy — not efficient, not correct, happy. The language had opinions, like Python, but they were warm opinions. It read like something a person would say. It bent to fit the programmer rather than asking the programmer to bend.

I fell for it completely.

Ruby never became what Python became. The world moved on — or moved past — and Ruby became the language people used to use, the one that shaped Rails and a generation of web developers and then receded as other things rose. I still reach for it when I'm thinking. The syntax lives in my hands the way a first language lives in your mouth — not always the most useful, but the one that comes naturally when you're not performing.

I came out the other side a different programmer. I hadn't noticed how the process was shaping me.

The languages in between were mostly practical. The ones the job required, the ones the team used, the ones that got the thing done. I learned them. I used them. Some I got good at. None of them felt like mine the way the others did.

JavaScript was the longest relationship of that kind. It was everywhere — unavoidable, load-bearing, the language the browser spoke whether you liked it or not. I didn't dislike it. I just never had anything good to say about it. You use what the environment requires.

Then Node arrived and gave it legitimacy. The same language, suddenly doing serious work on the server. My relationship with it didn't change because JavaScript changed — it changed because the context did. That's a different kind of formative than Python or Perl or Ruby. Those shaped me through philosophy. JavaScript shaped me through circumstance.

That's not a complaint. That's just what it means to work in a field that moves. You learn what's needed. You carry what resonates. You let the rest be useful without being formative — until it is.

I'm back in Python now.

The same language, thirty years later, and it's not the same language. It's not the same person either. Python grew into exactly what it always believed it could be — the obvious choice, the one everyone reaches for, the language that won. It's more powerful than it was, more capable, more everywhere. The readability is still there. The one obvious way is still the philosophy.

And I'm different too. The things I needed from Perl — the freedom, the expressiveness, the permission to find my own path — I've made my own. I don't need the language to give me that anymore. The things I needed from Ruby — the joy, the warmth, the sense that the work should feel good — I carry those as values now, not as syntax.

Coming back to Python feels like returning to a place you left when you were young and finding it mostly as you remembered, but seeing it differently because you've been other places since.

The language didn't change what it was. I changed what I needed.

There's something I didn't expect to find when I came back.

The current project has the same texture as that first one — the comic book marketplace that never launched. Siloed contributors, each working cleanly in their own corner, throwing work into the hopper. Roughly mercenary. Not malicious, just separate.

And it works. That's the thing I keep coming back to. Everyone's piece fits. The code is clean, the interfaces hold, the system coheres — not because we coordinated, but because Python's consistency made coordination optional. The one obvious way turns out to be a shared language even when no one is speaking directly to each other.

Perl would have forced the collision earlier. You couldn't stay separate because the code was already tangled — the expressiveness that gave each programmer their own path also made those paths visible to everyone else. Python lets you defer the negotiation. The modularity is load-bearing. The silos work because the language holds them together at the seams.

Conway's Law says the system reflects the communication structure of the team. This might be the complement: a language with enough consistency can carry a collaboration that the team itself never quite had. The one obvious way does the coordinating so the people don't have to.

I couldn't have seen that in the 90s. I needed Perl first.

Returning to Python after years away from the craft itself — after a long stretch where the work was almost entirely human systems, leadership, the organizational layer above the code — has been its own kind of recalibration. The muscle memory is there. But I bring things to the work now that I didn't have the first time. Patience with the problem. Comfort with not knowing. A different relationship to the work itself.

That's what the years between gave me. Not just more languages.

The one obvious way is still good advice.

But I know now that finding it sometimes requires the detour through the ten other ways first. That the anarchy of Perl and the joy of Ruby weren't distractions from Python's clarity — they were the long way around to understanding why the clarity matters.

You learn the languages you need when you need them. You carry the ones that shaped you. You return to the beginning and find it's not where you started.

I learned Python in the 90s.