I remember the first time I truly understood object-oriented programming. It wasn’t in Java. It wasn’t in C++. It was in a 30-year-old environment called Smalltalk. And it changed everything.
For years, I thought I knew OOP. I’d used classes, inheritance, polymorphism. I’d read the Gang of Four book. I’d argued about design patterns. But I was wrong. I was using a car that had the shape of an object-oriented vehicle but ran on procedural fumes.
Learning Smalltalk doesn’t teach you a language — it rewires how you think about code.
There’s a reason the top comment on the Squeak/Smalltalk 6.1 release notes says: ‘Just like learning Lisp will make you rethink programming languages, and learning Erlang will make you understand the true power of concurrency: learning Smalltalk will make you understand what “object oriented” actually means.’ That commenter isn’t being nostalgic. They’re being honest.
I’ve spent the last decade in the .NET and Java ecosystems. Both claim to be object-oriented. But walk into a codebase and count the number of places where you actually send a message to an object — not just call a method on a class. The difference is subtle but profound. In Smalltalk, everything is an object, and everything happens through message passing. No static methods. No primitives. No ‘if’ statements that aren’t messages. The language doesn’t just support OOP — it is OOP.
Modern OOP languages are class-oriented, not object-oriented. They borrowed the syntax but abandoned the soul.
You’ve probably felt it too. That nagging sense that your code is fighting you. That you’re writing more boilerplate than logic. That the ‘objects’ you create are just data bags with attached functions. Smalltalk reveals the lie: the industry never fully committed to the paradigm it claims to follow. We got half the philosophy and all the complexity.
Here’s the twist: Smalltalk is not a relic. It’s a prophecy. The live coding environment, the image-based development, the debugger that lets you change code while it’s running — these aren’t historical curiosities. They’re the future that didn’t happen. And they’re still more radical than anything in today’s mainstream tools.
Smalltalk is to OOP what Lisp is to programming — a pure, unfiltered glimpse of what could have been.
I’m not saying you should rewrite your production system in Smalltalk. That would be insane. But I am saying that if you’ve never spent an afternoon with it, you’re missing a fundamental part of your education. The feeling of watching a live object inspector, of sending a message and seeing the world respond, of debugging by changing code in a running system — it’s not a trick. It’s a different way of thinking.
And that’s the point. The value of Smalltalk isn’t its runtime performance or its library ecosystem. It’s the mental model. It’s the reminder that our tools are not neutral — they shape how we think. And if we only ever use the tools that won the popularity contest, we risk assuming that the way we do things is the only way.
The industry moved on, but it moved in the wrong direction.
We traded purity for familiarity. We traded concepts for syntax. We traded message passing for method calls. And we told ourselves it was progress. But every time you feel that OOP isn’t working for you, ask yourself: did you ever learn what OOP actually meant? Or did you just learn the easy version?
Go open Squeak. Download the 6.1 release. Spend an hour. It’s not nostalgia. It’s a wake-up call.
FAQ
Q: Isn't Smalltalk just a niche language with no practical use today?
A: Practical use isn't the point. It's a mental model. Understanding Smalltalk makes you a better programmer in any language by revealing the assumptions baked into today's tools. It's like studying philosophy for engineers.
Q: Should I actually learn Smalltalk in 2025?
A: Yes, even if you never use it in production. Spend an afternoon with Squeak or Pharo. The live coding environment, the message-passing paradigm, and the pure OOP model will change how you design systems in any language.
Q: Isn't this just nostalgia from old-timers who never moved on?
A: No. The concepts are more relevant than ever. Modern systems like live coding, REPL-driven development, and dynamic object inspection are finally catching up to what Smalltalk had decades ago. It's not nostalgia — it's a reminder of what we lost.