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.
I haven't used Squeak since college but I'm glad it was part of the cirriculum.
Btw, almost all of Javascript's good parts come from Smalltalk.
For me, Smalltalk's "wow" moment was the concept of a persistently running image, with the developer's job being to mould and manipulate it into the shape s/he wants.
Ive always "dreamed" of having something like the ST image but backed by persistent virtual memory, not simply RAM.
(Crudely) mmap the ST image to a 100GB file and just change pages. Let the OS flush the pages back and forth.
Maybe full boat, heap sweeping GCs would be Bad as it pages the entirety of the heap in and out. But we have (had) lots of RAM these days. We have generational GCs that leave idle stuff alone. Its no doubt impractical, but I think it would be neat to have the entirety of my historical email in the global "mailbox" array, and I can build indexes off it as I wished. But the mail isn't "on disk", it's all marshalled up as first class objects.
I don't know enough about it, no doubt it "won't work", but the idea of simply mapping the entire, large, ST VM heap to a persistent backing store, just be interesting I would think.
Dangerous too, as there is a demarcation between "running image" and "saved image". But, still think it could be interesting.
I'm also interested in this and made decent progress on a git-style content addressed image where everything is identified by hash and residency determines what's in memory. For example, there's a filesystem on the image that works this way and you can page over the "cold" non-resident bytes for very large files that you would not want to hold in memory.
You don't persist the state of the full image continuously to the host disk, but any given state (new programs, new runtime state, filesystem) can be saved via a delta, not a full rewrite, due to this representation.
So this is a little different than what you are talking about, but I'd say it's possible.
The only mainstream-ish language where that still happens? R. Too bad, there's a lot more use cases for this sort of thing now - versioning, anything non-persistent agents touch, collaboration, auditable enterprise LOB. It's 2026, why are we (or our agents) still writing serialization code? Even if the AI's write the boilerplate, the state management fragility is often a tax/risk.
I wish this didn’t go out of fashion as much as it did. An environment that you perturb makes more sense in a lot of ways than a “tear it down and restart” model.
I think the gnarlier part is that it reveals how much (and how error prone) initialization code is. When objects start glued together in the right structure a lot becomes magically easier to deal with.
I'm considering this for my language but it's a lot more complex to implement (especially with today's ecosystems) and I keep wondering if it's worth it.
Lisp, Forth, Erlang, Smalltalk, and Rebol, so easily forgotten.
All languages that multiply your insight into the nature of computer programming. A bit sad that many just stop at the first of these, and many more don’t even venture past their Pythons and Javascripts.
And that's completely natural. Compare it with woodworking.
Yes, some people would dive deep into the craft and create works of art, exquisite furniture and tools they need to make it even better.
But those are the few. For the most of woodworkers this is just something they somehow learned to do on a level needed to be able to get a job and make living.
I find that lamentation a bit funny, because the list in practice is never really complete. For instance, you forgot the mighty Prolog. Surely, tcl belongs on there too.
The more of them you explore, the more insight you get. The list does not have to be complete. It just needs to list some languages, that are truly different in how they work and what the ideas behind them are.
From what I've seen... I think if I were writing business applications, I'd reach for Elixir... if I were writing something lower level like communication software, I'd reach for Erlang.
I have written a fair amount of Elixir (and targeting business applications) and I think Elixir's expressiveness lends itself well to making more abstract models of the business processes and data seen in solving business problems. However, writing Elixir I find you end up reading a lot of Erlang and in certain problem spaces I could imagine the appeal over Elixir. I could absolutely see where if I were writing more technically oriented programs.... programs closer to the hardware in some ways or programs designed to communicate with other programs (protocols, etc.) I could see Erlang as being a more clear and direct language in these circumstances.
All of this is very hand-wavy, but it's my impression.
For me, Elixir misses the mark. If you're an unc with a background in Ruby or that era of webdev, I can see the appeal. It's a familiar set dressing. I don't have that background, I much prefer the syntactic structure of Erlang's psuedo-horn clauses. Both for similar familiarity reasons (I knew Prolog before I touched Erlang), as well as a general preference for the simplicity.
I didn't imply otherwise, nor is the story different on the Erlang-Prolog axis (actually it's even more pronounced there.) I literally called it "set dressing". Where I think you go off the rails is that you're conflating surface-level things with irrelevance. Which isn't really true, especially in matters of taste.
I find this to be a very strange thing to get defensive about. It's not exactly a subtle part of Elixir's history. It was pretty well documented to be born out of the creator's dissatisfaction with concurrency in Ruby, and simultaneously, for a more Ruby-like language on the BEAM. That doesn't mean it's literally Ruby-on-the-BEAM (which was originally attempted, and didn't work out), however mistaking that as cause to dismiss the link between the two and the carry-over appeal for developers is an unsound overcorrection.
And some months ago I was flirting with the idea of "Smalltalk and Erlang had a baby" and have Smalltalk syntax to an actor environment ran by a Erlang VM style. Plus some insanely cool ideas about a causal debugger for distributed bugs.
The problem is that as beautiful as programing in that sound, we're not even coding anymore, AIs will take the fun of it.
Although, thinking long term and for understendabilitymaxxin and reliabilitymaxxin it might still be worth having something like that.
Since Smalltalk can be so close to english and Erlang VM so reliable, humans and LLMs should thrive on it.
I was flirting with the idea ... Plus some insanely cool ideas ...
The problem is that as beautiful as programing in that sound, we're not even coding anymore, AIs will take the fun of it.
We've come to this. The mere existence of AI is discouraging people from pursuing creative ideas. This is a catastrophe! It's not just taking the fun out of life, it's destroying alternative futures we might have built.
There is this advice for dealing with tyrants and would-be tyrants: "Do not obey in advance." In your case that means pursuing and implementing your exciting ideas.
... it might still be worth having something like that.
Metalworking, lathes, precision tooling, are all way more valuable skills and tools today than they ever were before the industrial revolution.
I suspect that over time a good grasp of fundamentals and great tooling will only get more valuable in software as well as automation expands, in whichever form.
Automation expands the demand for skills. It can never diminish it. Required variety indicates that complexity doesn't go away with automation, and at some level someone will have to understand and make decisions about complex issues. You can't automate all the way down. Or, put another way, everything is already automated all the way down. The expansion of automation as we perceive it is merely the growth of complexity over new dimensions.
Or put a third way: automation means two different things: constraint and liberty. The confusion arising from not discerning which one is in force makes it seems like one can grow unbounded. Liberty requires constraint and vice versa.
> almost all of Javascript's good parts come from Smalltalk
Is this underselling the role of Self in JS’s prototype-based object system, or saying that a prototype-based object system is not one of the good parts?
I would give a lot for a version of Squeak which could instantiate standard GUI controls and easily compile to a stand-alone binary or HTML page w/ included JavaScript.
I didn't understand programming at all until I read about (not even tried) Smalltalk. And it's because of Smalltalk I write Ruby today.
My favourite thing about it is the lack of "reserved words" - just a handful of punctuation marks. It's incredibly pure - almost all of the syntax is "send this message to this object".
>Btw, almost all of Javascript's good parts come from Smalltalk.
Like what, exactly? I'm genuinely curious. There is no root object or message passing in JS, and the OO aspects are only incidentally bolted on (classes don't actually exist, prototypal inheritance was an afterthought), named params are newer sugar, and polymorphism is a struggle due to all of the above. I've always thought of JS as what Crockford himself said: "a Lisp in C's clothing".
Ignore the syntax for a moment. Minus Javascript, HTML + CSS is a green screen terminal with better fonts and image support. Message passing (fetch, XMLHttpRequest, polling, streaming, etc...) is how you build something that feels like a real tool out a system where the sandbox gets in the way of everything you want to hold locally.
That's not quite what message passing means. It's an incredibly simple concept that indeed overlaps with RPCs, etc, but Smalltalk was invented before OOP nomenclature solidified, and so it can be difficult to explain clearly without tripping over other CS concepts.
The best analogs would be Lua and possibly Python. In Lua there are no such things as methods, per se; every object has an associated index (either a table or function) that is used to retrieve a function based on the name of the "method" that was called. This is similar to JavaScript's prototypes. Except in Lua (and Python via __getattr__?) you also are passed the method name, which means everything about the call has been reified--made available as data, in a similar fashion to everything else, and without recourse to magic reflection facilities. This makes method calls a first-class construct. This isn't possible in JavaScript, IIRC, because the lookup of methods is hidden, even though the prototype member is otherwise a first-class object itself.
Long story short, because you're passed all the relevant info about the method call, including the name, you can easily forward the call to other objects, processing the arguments, too. The "message" being passed is the method call information, which is just data, and you can process it like any other form of data. In that sense it is almost exactly like XMLHttpRequest, and yet in the context of a discussion about programming language semantics and distinctions between them, it's nothing like it. Smalltalk conceived of object "methods" as "messages" (i.e. data) that are sent and received, and then built an entire language around that very abstract concept.
The main thing you’ll learn is that actually the static and inflexible abstractions of an operating system do a lot to protect the system integrity and prevent everything from blowing up. Many smalltalk VMs rely on recovery features for a reason
recovery features? how do they work? and what smalltalk runtime do you have in mind? I still have a very vague understanding on how changes could be applied to a production running images, or if there is one and preferable way to do that.
one thing I love about Smalltalk is being able to inspect the code as it's running. Especially from the GUI. You can just be like Oh I wonder where the code for this button is from, inspect it, and it takes you right to the code. It's a shame we can't have this level of introspection without negative performance implications.
We could in Java Swing (and Visual basic, but lets not talk about that) as well. Well, not runtime, but we could design applications and just right click on the objects in the IDE and go directly to the click (or double click or right click) handlers.
Then again, not having to disable this for runtime is a feature if you ask me.
Yes, current web applications are prettier and easier to upgrade but we lost a lot on the way wrt developer experience and ux.
I just downloaded on Windows 11. My antivirus (Symantec Endpoint Protection) did not like it and erased the executable. I reinstalled and got it working.
Question? Does this work with Etoys? If so, how? I tried following various directions online without success. Thanks!
Help/Useful Expressions has some EToys instructions.
The Squeakland images stopped getting upograded when Squeeak went 64-bit (I think).
You can get a "halo" on any object, click the Inspector icon (the eye) and create an etoys script from there.
Also, under Extras/Themes and Colors there is a Set Etoys Mode option. You can try that but, it didn't work last night.
Lastly, files.squeak.org/etoys has a 6.0beta image you can download. Drop the image/changes into SqueakJS [1] (that is the only way to run a 32bit image).
What are the best books/papers/blog posts to learn about Morphic's architecture? I'm not a user of any Smalltalk implementation but I'd like to learn more as the Smalltalk approach to UI is very interesting.
Oh I've posted much longer than that (see the one I linked) without getting flagged for that. Let's see how long this one lasts. Then I can edit it to contain the text that keeps getting flagged, if it does.
I vouched as well, but it's [flagged][dead] not just [dead] which is usually the result of user moderation, not the mods or auto moderation (which typically will just render as [dead] in either case). Which was odd because it was [flagged][dead] by the time it was 4 minutes old (maybe earlier, that's just when I saw it).
And after all these years, still no fixes for high-DPI displays. The UI is still pixely and slow. Perhaps I should take Fable and try myself, this was the only bug I cared about and it is not solved after 10 years at least.
Same, I've been tracking this and Pharo for high-DPI fixes. Pharo is working on a new graphics stack that is intended to address this as well, but until then no high-DPI support.
Does Glamorous Toolkit work for you? It's pharo with a different rust based GUI stack, and some batteries included for making custom inspector views and such. I don't have a high DPI display so I'm not completely confident, but my understanding is that their rust based GUI works fine with high DPI.
I see some movement on high-DPI in the latest release. What are the current gaps? I'm not familiar with the project, just curious.
> Improves high-DPI support for buttons, scroll panes, sliders, menus, multi-selection lists, trees, drop-shadows, the scratch pad, the keyboard exerciser, and others.
The UI has been a huge impediment in my getting into Squeak development. Every couple years I decide I will try it again, and then see that very little has changed.
It's a shame. Smalltalk/Squeak/Pharo was supposed to be the future, but it feels like an IDE stuck in the 90's.
I haven't used Squeak since college but I'm glad it was part of the cirriculum.
Btw, almost all of Javascript's good parts come from Smalltalk.
(Crudely) mmap the ST image to a 100GB file and just change pages. Let the OS flush the pages back and forth.
Maybe full boat, heap sweeping GCs would be Bad as it pages the entirety of the heap in and out. But we have (had) lots of RAM these days. We have generational GCs that leave idle stuff alone. Its no doubt impractical, but I think it would be neat to have the entirety of my historical email in the global "mailbox" array, and I can build indexes off it as I wished. But the mail isn't "on disk", it's all marshalled up as first class objects.
I don't know enough about it, no doubt it "won't work", but the idea of simply mapping the entire, large, ST VM heap to a persistent backing store, just be interesting I would think.
Dangerous too, as there is a demarcation between "running image" and "saved image". But, still think it could be interesting.
You don't persist the state of the full image continuously to the host disk, but any given state (new programs, new runtime state, filesystem) can be saved via a delta, not a full rewrite, due to this representation.
So this is a little different than what you are talking about, but I'd say it's possible.
All languages that multiply your insight into the nature of computer programming. A bit sad that many just stop at the first of these, and many more don’t even venture past their Pythons and Javascripts.
Yes, some people would dive deep into the craft and create works of art, exquisite furniture and tools they need to make it even better.
But those are the few. For the most of woodworkers this is just something they somehow learned to do on a level needed to be able to get a job and make living.
(Agreed that TCL is pretty cool)
I think smalltalk and erlang are so interesting because they model the idea of small computers so differently.
Lisp just feels like the purest way to understand what the units of a programming language really is.
I have written a fair amount of Elixir (and targeting business applications) and I think Elixir's expressiveness lends itself well to making more abstract models of the business processes and data seen in solving business problems. However, writing Elixir I find you end up reading a lot of Erlang and in certain problem spaces I could imagine the appeal over Elixir. I could absolutely see where if I were writing more technically oriented programs.... programs closer to the hardware in some ways or programs designed to communicate with other programs (protocols, etc.) I could see Erlang as being a more clear and direct language in these circumstances.
All of this is very hand-wavy, but it's my impression.
I find this to be a very strange thing to get defensive about. It's not exactly a subtle part of Elixir's history. It was pretty well documented to be born out of the creator's dissatisfaction with concurrency in Ruby, and simultaneously, for a more Ruby-like language on the BEAM. That doesn't mean it's literally Ruby-on-the-BEAM (which was originally attempted, and didn't work out), however mistaking that as cause to dismiss the link between the two and the carry-over appeal for developers is an unsound overcorrection.
Other than that, vanilla Erlang is THE way to go.
The problem is that as beautiful as programing in that sound, we're not even coding anymore, AIs will take the fun of it.
Although, thinking long term and for understendabilitymaxxin and reliabilitymaxxin it might still be worth having something like that.
Since Smalltalk can be so close to english and Erlang VM so reliable, humans and LLMs should thrive on it.
We've come to this. The mere existence of AI is discouraging people from pursuing creative ideas. This is a catastrophe! It's not just taking the fun out of life, it's destroying alternative futures we might have built.
There is this advice for dealing with tyrants and would-be tyrants: "Do not obey in advance." In your case that means pursuing and implementing your exciting ideas.
... it might still be worth having something like that.
Yes! Good luck with it!
I suspect that over time a good grasp of fundamentals and great tooling will only get more valuable in software as well as automation expands, in whichever form.
Automation expands the demand for skills. It can never diminish it. Required variety indicates that complexity doesn't go away with automation, and at some level someone will have to understand and make decisions about complex issues. You can't automate all the way down. Or, put another way, everything is already automated all the way down. The expansion of automation as we perceive it is merely the growth of complexity over new dimensions.
Or put a third way: automation means two different things: constraint and liberty. The confusion arising from not discerning which one is in force makes it seems like one can grow unbounded. Liberty requires constraint and vice versa.
Is this underselling the role of Self in JS’s prototype-based object system, or saying that a prototype-based object system is not one of the good parts?
https://youtu.be/HOuZyOKa91o
My favourite thing about it is the lack of "reserved words" - just a handful of punctuation marks. It's incredibly pure - almost all of the syntax is "send this message to this object".
That's E and Self erasure.
https://dl.acm.org/doi/10.1145/3386327
Like what, exactly? I'm genuinely curious. There is no root object or message passing in JS, and the OO aspects are only incidentally bolted on (classes don't actually exist, prototypal inheritance was an afterthought), named params are newer sugar, and polymorphism is a struggle due to all of the above. I've always thought of JS as what Crockford himself said: "a Lisp in C's clothing".
The best analogs would be Lua and possibly Python. In Lua there are no such things as methods, per se; every object has an associated index (either a table or function) that is used to retrieve a function based on the name of the "method" that was called. This is similar to JavaScript's prototypes. Except in Lua (and Python via __getattr__?) you also are passed the method name, which means everything about the call has been reified--made available as data, in a similar fashion to everything else, and without recourse to magic reflection facilities. This makes method calls a first-class construct. This isn't possible in JavaScript, IIRC, because the lookup of methods is hidden, even though the prototype member is otherwise a first-class object itself.
Long story short, because you're passed all the relevant info about the method call, including the name, you can easily forward the call to other objects, processing the arguments, too. The "message" being passed is the method call information, which is just data, and you can process it like any other form of data. In that sense it is almost exactly like XMLHttpRequest, and yet in the context of a discussion about programming language semantics and distinctions between them, it's nothing like it. Smalltalk conceived of object "methods" as "messages" (i.e. data) that are sent and received, and then built an entire language around that very abstract concept.
https://drcuis.github.io/TheCuisBook/The-Change-Log.html
Then again, not having to disable this for runtime is a feature if you ask me.
Yes, current web applications are prettier and easier to upgrade but we lost a lot on the way wrt developer experience and ux.
Question? Does this work with Etoys? If so, how? I tried following various directions online without success. Thanks!
[1]https://github.com/codefrau/SqueakJS
I am unaware how it evolved since then, especially given the differences between Self and Smalltalk.
https://handbook.selflanguage.org/2017.1/morphic.html
https://sin-ack.github.io/posts/morphic-intro/
Is it because of its length giving false signals ?
Love your long comments.
> Oh I've posted much longer than that (see the one I linked) without getting flagged
Those were simpler times
Oh shit, I just missed a Bakelite discussion 17 days ago!
https://news.ycombinator.com/item?id=49026992
But there's a comment from 9 days ago that's still replyable. ;)
[1] https://gtoolkit.com/
> Improves high-DPI support for buttons, scroll panes, sliders, menus, multi-selection lists, trees, drop-shadows, the scratch pad, the keyboard exerciser, and others.
https://squeak.org/release_notes/6.1/#:~:text=and%20dialog%2...
It's a shame. Smalltalk/Squeak/Pharo was supposed to be the future, but it feels like an IDE stuck in the 90's.