Somewhere deep in our harts, we all have a deep appreciation for Smalltalk and its legacy in programming language design, it's just that no one is actually interested to use it anymore. It's gone, it's part of the history, never to come back. People just upvote an article about it and proceed with the life.
Same can be said for (Common) Lisp, which still live its half-life in form of Clojure, but is far away from the mainstream.
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.
Rails is extremely far from those dynamic Smalltalk application environments. Nothing is live. Object graphs are built up to serve a single request, then torn down immediately — a bizarre kind of kamikaze OOP. To me it's the worst of Smalltalk and PHP in one, as all the interesting aspects of dynamic typing are wasted and just become a source of bugs.
Ruby has no such thing: it's pretty much only used for Rails and plain-jane Unix scripting. It's fair to judge the language in context of its actual applications.
Most, not all: https://www.gnu.org/software/smalltalk/manual/html_node/Over...
Although it looks like somewhere along the path with the "new" graphical browser they dropped the tag line "Smalltalk for those who can type".
Rails is a monster, and historically pretty poor ruby code quality INMHO. That said, ruby does indeed miss an "image" concept, but is quite dynamic and object oriented. Some smalltalk patterns would work well with ruby, I think.
There's also (the abandoned?) maglev ruby on top of gemstone/s object db for smalltalk.
For a glimpse of "what is possible", take a look at TkInspect (1), a set of gems that I'm working on that provide some of the goodies of that GUI, like an interactive, graphical console, a live inspector, a class browser or turtle graphics.
At the moment it's not more than a toy, but it does definitely show what can be done.
It was actually Dan Ingalls who built it (btw. 15 years before Erlang was invented); he's also the author of the referenced worth reading paper; never understood why he didn't get the Turing price.
Sorry, I don't get the metaphor. It's a reference to a game I think?, but not sure which one, and I could be wrong. I'm very familiar with Ingalls and Kay, but not the other two, besides hearing Carmack's name around here sometimes.
Carmack was the programmer who wrote the core bits that made the game possible. He didn't engage with the popular press, and when he did engage in discussions with the media or with fans, it was at a very deep and technical level.
You may also think about it in terms of Wozniak and Jobs. Point being that Alan Kay was out there, engaging the press and talking about Smalltalk's big ideas (objects, messaging, computers as medium, how they relate to children, etc.). He was the frontman. Whereas Dan Ingalls deserves the bulk of the credit for actually writing Smalltalk.
Fun fact: Ingalls wrote early Smalltalk versions... in BASIC.
And yet we suffer the experience of web "apps" like Gmail, which have some similar properties (which I'm reminded of every time I hit shift-ctr-c rather than ctrl-c to copy something in office365/Outlook - and the dev tools pop up).
No, really not by mistake — intentionally, because someone told you that it was possible and you wondered what that would break.
> not sure how exactly did you end up with it during the interactive session
Well, every change you made "during the interactive session" was logged as a sequence of Smalltalk change-set actions in the changes file.
So, actually, you could just read what you did ;-)
> Smalltalk … don't have much industry adoption…
Now.
Then:
"Smalltalk, C++ knock heads. Computerworld 29, 45 (Nov. 6, 1995 )
https://books.google.com/books?id=oKDIlxbMaS4C&pg=PA153&lpg=...
But there were and are much fewer Smalltalk jobs in the industry than C++ jobs (though the Smalltalk jobs paid better).
Much like there were more number-crunching C++ jobs than APL or k jobs, up until some key ideas of APL were made available wrapped in Python, and numpy jobs skyrocketed. Maybe something similar will happen to some key Smalltalk ideas!
No, that was technology developed for the Self programming language which didn't have much in common with ST (see e.g https://dl.acm.org/doi/10.1145/1238844.1238853, there is also an interesting talk by Ungar and Smith). The same technology was also used for an ST dialect (Strongtalk) which was quickly discontinued in favor of Java Hotspot. The influence of ST is generally overstated.
My understanding was always that self grew out of smalltalk? But I suppose the jit work in particular was developed for/in self?
https://dl.acm.org/doi/10.1145/800017.800542 "Efficient implementation of the smalltalk-80 system" by L. Peter Deutsch and Allan M. Schiffman in POPL '84: Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languages, January 1984, Pages 297–302
This motivated the creation of the ParcPlace spinoff to commercialize this technology. It was not the first JIT, but quite a few modern ones were inspired by it.
Self started out as one of the "Smalltalk-86" projects at Xerox PARC with Randy Smith collaborating with Berkeley's David Ungar. It was supposed to be a simpler and purer Smalltalk even if that made practical implementations impossible. But with David Ungar becoming a professor at Stanford, he found students that helped him make it possible, and eventually even much faster than existing Smalltalks. Craig Chambers worked on type inference for Self 1 and 2 and then Urs Hölzle worked on adaptive compilation with type feedback for Self 3 and 4.
https://dl.acm.org/doi/10.1145/191080.191116 "A third-generation SELF implementation: reconciling responsiveness with performance" by Urs Hölzle and David Ungar in OOPSLA '94: Proceedings of the ninth annual conference on Object-oriented programming systems, language, and applications, October 1994, Pages 229–243
This is the technology that became "Hot Spot" for Java. But very few virtual machines have this level of sophistication.
My guess is the influence of Strongtalk is in this context taken to be influence of Smalltalk.
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.
Saying that nobody uses Smalltalk seems a bit like saying that nobody lives in Norway.
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
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.
Anything interesting we might want to know about it? Is it public?
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)
Dan Ingalls seems to be this unsung hero that does not get mentioned often enough in my opinion. Admittedly, when I first learned about him from FLOSS Weekly podcast[0], I've been a bit of a fanboy. Since then I have read and listened his interviews and lectures that I have been able to find. He seems to be a very modest man with a lot of interesting anecdotes.
The whole era when Smalltalk was invented is fascinating. I'm currently reading through the book "The Dream Machine" just to learn more about the Xerox PARC, Alan Kay, Dan Ingalls and his involvement in Smalltalk and related innovations.
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.
Nice? No! Nobody has managed to reproduce the demo :-( and I think that being written partly in Smalltalk is one of the cause..
I’m sure there are other good options too. Racket comes to mind but I haven’t tried that
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.
Already, back in 1988 —
"The fact that Smalltalk proved to be an excellent prototyping tool should not be surprising, as Smalltalk’s developers had themselves used the system in this manner. … While we have have found the Smalltalk language a very effective tool for building complex systems, we believe it is currently unrealistic to expect that an excellent rapid prototyping system can also be an excellent application delivery system. If Smalltalk is to be widely used to develop production applications, then the language, its development environment, and its implementations need to be re-engineered for that purpose."
"An Overview of Modular Smalltalk"
https://static.miraheze.org/triplescriptswiki/4/49/Wirfs-Bro...
And then let the environment run headless and export a language server and debugging API that lets me get most the practical benefit without having to leave my favorite editor, and also integrates more easily with existing build tools, stuff like that. Right now, Smalltalk effectively wants to either be the prima ballerina, or have no part in the production. That's a real difficult line to try to hold in the modern software landscape.
That said, it's still a great language, and one of those rare ones that I'd encourage everyone to learn, because it will change the way you think about programming.
"Design, Implementation, and Evaluation of the Resilient Smalltalk Embedded Platform"
https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.84...
At least those of us on .NET, Java, Swift, Delphi, C++ Builder get a small taste of how the future might have been instead.
Sure the JDK was free beer, and there was this wannabe GCC compiler, but that was it.