My take is that it still commands a lot of mindshare because it has a reputation for having been a better kind of object-oriented programming, and that nostalgia is being exacerbated by OOP's poor reputation nowadays.

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.