The evolution of Smalltalk: from Smalltalk-72 through Squeak (2020)

Heeey, I'm learning Dolphin right now! It still looks like one of the easiest ways for doing Windows front-ends to stuff. A shame it's not been updated for 64 bits yet, though.

At least those of us on .NET, Java, Swift, Delphi, C++ Builder get a small taste of how the future might have been instead.

Everything is inspectable, discoverable, interactive. Reactive programming, live objects, build stuff and see it come alive at every step. JIT makes everything fast, eventually.

But also the whole thing is one huge global mutable state. You used to be able to redefine "constants" like true by mistake. You want to save the entire system image, because now everything works, but you're not sure how exactly did you end up with it during the interactive session. Static checks and guarantees are hard to have at best.

AFAICT, initially Alan Kay tried to build something like Erlang: hence messages and protocols, objects keep their state as if they were nodes of a network. But hardware limitations did not allow yet back then, so the design changed, and was still hugely influential.

I think certain languages end up being bellwethers and test beds, without becoming industry mainstays. Haskell and OCaml don't have much industry adoption, but Rust does. APL (and even k) don't have much industry adoption but numpy and spark (admittedly both libraries) do. Smalltalk and Self don't have much industry adoption but Ruby and Python do.

He says, on site written in Lisp, siting a language that proves the invalidity of his own statement.

For what its worth, while Lisp has never been a language with a big following in commercial development due to its focus on exploratory programming rather the delivering a "finished product", it's user base has actually been growing in the last 20 years or so.

Looking at what Smalltalkers have done and what their tooling can do (and has been able to do for decades) is inspiring and quite mind-blowing.

But despite that, I don't see a modern Smalltalk community that I'd like to be part of or Smalltalk tooling that I'd like to actually use.

(Pharo or Cuis comes the closest though)

(I should probably declare my Lisp envy as well while I'm at it.... (and my bucket list item of dropping a few months on Forth)

Lisp - everything is a function

Smalltalk - everything is an object passing messages to other objects

Forth - everything is a word operand operating on a stack

Prolog - everything is terms and relations

Saying that nobody uses Smalltalk seems a bit like saying that nobody lives in Norway.

I started learning Pharo recently, and, TBH, I don't think that's a misplaced sentiment. Programming in Pharo really is a different experience from programming in C++ or Java. The differences go deep. You know how sometimes there's this advice that in OOP you should avoid using if and switch statements, and instead use polymorphism? Well, Smalltalk doesn't even have if or switch statements. Instead, the True and False classes have methods like `ifTrue:` and `ifTrue:ifFalse:` that accept blocks (Smalltalk speak for a lexically scoped closure) as their arguments, and conditionally execute them.

So, right there, that's more than one mental shift from how most of us are used to thinking about things. First off, if you ever thought that higher-order functions were a functional programming thing, well, here's the counterexample. The language for which the term "object-oriented programming" was coined wouldn't be able to do anything useful without them, because it needs them to implement fundamental control structures. And second, it's true, you really don't need traditional if-statements in OOP. They're a procedural programming thing, and, at least in some respects, OOP really is better off without them. For example, in Smalltalk you can implement a system for trivalent logic and (compiler optimizations aside) it wouldn't be at any particular disadvantage compared to Boolean logic.

The other thing that strikes me is that I'm pretty sure that, at its core, Smalltalk is a smaller language than Scheme. Not necessarily in terms of library size (Smalltalk doesn't an equivalent to the RxRS standards, so I'm not sure this is even a comparison you can reasonably make), but in terms of the number of features that need to be built into the interpreter itself. I haven't done a methodical comparison, but my impression is that Smalltalk's core language has maybe half as many features as Scheme's.

It also is very much alive, even if it doesn't command the same mindshare that it once did. The standard-bearer I'd point people to nowadays is Pharo, which isn't technically a Smalltalk (in the same way that Racket isn't technically a Scheme), but its team has spent a lot of time working on things that a contemporary developer would expect (e.g., playing nice with Git) that you don't necessarily get with other varieties. The official MOOC is very well done and something you can breeze through pretty quickly.

My own personal take is that the thing that his holding Smalltalk back is the image-based development. Smalltalkers get very tetchy when people criticize this, perhaps even more so than lispers do about s-expressions. My personal take is that image-based development does enable a lot of very cool things, and working in an integrated development environment that is actually integrated does give you an incredible sense of power. I can see why it's a hill the community is willing to die on. But, it is a hill on which they will die. Image-based development jumbles together source code, application state, and IDE state in a way that creates collaboration challenges comparable to the ones people complain about in notebook-based development, except perhaps even more so. And, while I haven't actually tested this, I'm guessing that Squeak and Pharo both interact poorly (perhaps even not at all) with screen readers, which would - and should - be a hard stop for many workplaces.

Sure that was like 10 years ago and the app is long gone but I can totally see the use for Pharo/Squeak in a green field project even today. The parts are all there. It is super easy to get started, you download an image and have an whole development system set up. No setting up the tooling, no hunting for extensions for you IDE, nope the language already comes with an IDE that is superior to anything your are likely to have ever seen.

Nice? No! Nobody has managed to reproduce the demo :-( and I think that being written partly in Smalltalk is one of the cause..