I had the honor of first learning Smalltalk (and C++ and a bit of object databases) in a class taught by Bob Beck from Sequent. We actually had many students running Smalltalk on X terminals hanging off a Sequent server. https://en.wikipedia.org/wiki/Sequent_Computer_Systems
Smalltalk was a crazy-productive programming environment in the '90s, and easy to love. (A bit like Lisp, in that regard, but also very different.)
What's even more amazing than that PARC was doing this in the 1970s, was that what we know as Smalltalk was only one part or step towards grand goals they were heading towards, not the end product. http://worrydream.com/EarlyHistoryOfSmalltalk/
When we find ourselves strutting around about how smart we are, how we'll change the world, as we move fast and break things (with what power we can seize and exercise over our users, with our app)... a needed dose of humility comes from seeing that the Smalltalk (and other) people, of decades earlier, seem a thousand years ahead of where we are now, in thinking.
According to "What the Dormouse said" [1], there were a couple main differences between them and us:
1. They grew up in a world without personnal computers, and had the time to _read_ _books_ ;
2. They had the pressure of either coming up with very bright ideas to impress their Pentagon-related funders, or get send to play real-life Call of Duty in Vietnam ;
3. They were almost free to invent whatever they had in mind since the class of "managers / deciders which no technical roots" had not really emerged yet ;
4. They were periodically high on LSD.
Whereas we're mostly now working in a billion dollars industry with strong incentive for conservativeness of products, with a pop-culture discipline rather than engineering culture, where it's pretty easy to get "something" on the screen, lots of high paying but menial jobs available - and we have to do it only on coffee !
Which is why I was only impressed by UNIX until I started digging into Xerox PARC work, and its influences on Apple Lisa/Mac and ETHZ Oberon derived OSes.
The few UNIX variants that I actually still find interesting was the NeWS approach, NeXTSTEP and its descendants.
Wirth was inspired by the Alto, Dorado and the Mesa and Cedar programming systems. The Alto OS (the first GUI desktop and WYSIWYG word processor and DTP applications Bravo and Gypsy) was implemented in BCPL (precursor of C), not in Smalltalk. Many people seem not to know, but you can look at all the source code at the Computer History Museum.
There were common style elements across all the Xerox PARC software systems, the one not mentioned so far is Interlisp-D. I don't think you can claim that Wirth was only influenced by the BCPL and Mesa group.
I just repeat what he said and wrote. You can have a look yourself at the Oberon System, see e.g. https://github.com/rochus-keller/OberonSystem. Not quite similar, isn't it? Wirth didn't like overlapping windows.
As he writes he was influenced by the Mesa language when he developed Modula-2/Lilith and by Cedar when he implemented Oberon/Ceres.
In fact, Mesa and Mesa/Cedar developers explicitly refer to their goal to replicate Smalltalk and Interlisp-D developer experiences on XDE and Cedar, across their papers.
>Smalltalk was a crazy-productive programming environment in the '90s,
I did some in college and then professionally in the early 2000s. Easily the most enjoyable and productive tool I used in my software development career. While I understand HNs fascination with functional languages and programming, I can't help but think it is very unfortunate that Smalltalk and it's OOP has been left as a kind of evolutionary dead end.
The modern fascination with "functional" is, in part, because we have redefined "functional" to apply to basically any language with first-class anonymous functions that are closures - witness all the talk about "functional JS" and how it's "almost like Lisp".
By that criteria, Smalltalk was one of the first industrial-strength functional languages. In fact, it's better than most, because its closures close over not just the variables, but also over the execution context (i.e. a closure can execute a non-local return from the function in which it was created).
Congratulations!!
I started a ST-80 on my TRS-80 w/an external gfx board in Z-80 asm, then tried to continue on my first PC in C, swapping floppies for each C compiler pass while temp files went to a RAM drive -- between the pitiful state of the "dev environment" and the difficultly in getting the ST VM image in the correct "magic" state for startup (and my inexperience) I never finished the thing. (I should have gone more the route of "A Little Smalltalk".)
The experience makes me appreciate your work and the orig. impl. even more!
Thanks for the pointer! Very cool. As I understand it, it was the proof of concept for Smalltalk/V. Unfortunately, Smalltalk/V trashes the screen under DosBox with EGAColor, so I'll have to look into making it work better.
The Smalltalk books were a big influence on me when they came out, so I was happy when a company I was working for sublet space from Xerox PARC and we had meetings there. :)
Is anybody familiar with the various Smalltalk releases today and willing to do an overview of what's available?
Apple had the original PARC Smalltalk but never did anything with it until it evolved into Squeak in 1996, which was Apple's very first open source product. Later two forks went in different directions: Cuis and Pharo.
https://squeak.org/https://cuis-smalltalk.org/https://pharo.org/
Forking Little Smalltalk (an early open source text based Smalltalk) is a rather popular thing to do, so I won't give all the links. A bit more sophisticated is GNU Smalltalk:
https://www.gnu.org/software/smalltalk/
Are there any quality implementations for Java or .NET VMs? One would think that this is the easiest way to get a high-quality GC today. And both ecosystems have some special sauce in them for dynamically typed languages - DLR in .NET, and I'm not sure if there's a single brand for that in Java land, but they've been busy adding features for the likes of JRuby for a while now.
There is actually a Squeak VM in Javascript (http://squeak.js.org) and there is at least Amber Smalltalk implemented in JS.
http://amber-lang.net. No need for WASM.
This is a good resource and includes my favorite Smalltalk book SmalltalkDesignPatternCompanion. This
book made the classic GangOf4 patterns much easier to understand because it uses Smalltalk meaning much easier syntax focused solely on OOP which those patterns are much about. Design patterns are simple(r) when expressed in syntactically simple pure OOP.
Unfortunately it seems that something is missing here there is no chapter for the Visitor pattern which I remember as especially insightful. I had that book but it got burned when the house I lived in burned.
Cool! I have a copy of the Bluebook sitting next to me on my bookshelf here, for many years, have often pondered doing the same. I had a similar reaction back in the 80s reading about Smalltalk. I had a set of encylopedias that included a page about Smalltalk with a couple tiny screenshots that blew my mind.
Thing is once I finally got to play with Smalltalk-80 in the 90s with Squeak, it just didn't click with me. I love and understand the language, I just don't find myself expressive in it.
Looks very interesting and have always been interested in this era of optimistic computing. Does anyone know a tutorial or quickstart guide on how to get started using it? I don't really have a clue what I'm doing after opening it
- Blue Book "Smalltalk-80: The language and its implementation"; The original reference
- Green Book "Bits of History, Words of advice", Ed. Glenn Krasner. Advice from early implementers
- Red Book ""The interactive Programming Environment" Explains the use of development environment, one of the first books about a GUI. (also known as the Orange Book)
- Purple Book "Smalltalk 80 - The Language"; more than adequate for an intro, and the portions of the Blue Book that were left out are now available on the Web.
In 1978 the Smalltalk group at Xerox tried to build a computer that people could buy. The Notetaker used several 8086 processors in a sewing machine form factor (like the later Osborn I) so you could carry around a computer with floppy disks, a mouse and windows. An executive came from the headquarters specifically to kill the project because Xerox didn't want to sell microcomputers.
Frustrated, the group got permission to license the language to run on other people's computers. All the other companies would have to do would be to implement their own version of the virtual machine and the rest of the system would just work. They made a deal with Apple, HP, Tektronix and DEC where these companies would get the language in exchange for having a small team help Xerox clean up the system and the draft of a book about the system by trying to do their own implementations.
This was eventually published with the title "Smalltalk-80: The Language and its Implementation" and became known as the blue book since that was the main color on the cover. It had four parts:
1) an explanation about the language and its concepts
2) a reference for all the classes and methods in the system
3) a large example in the form of a discreet event simulator
4) the definition of the virtual machine in the form of explanations and Smalltalk-80 code written in a style that could easily be translated to Pascal or C
Years later a version without the fourth part was released with a purple cover.
Before the book came out, a series of articles about Smalltalk-80 were published in the August 1981 issue of Byte magazine.
Another book was "Smalltalk-80: The Interactive Programming Environment" about the GUI. It became known as the orange book. There was another book that was planned but never released.
As part of the efforts of the implementation groups (now 5 since DEC shared its license with Berkeley) they had some mini conferences to share experiences and decided it would be great to make that into a book as well. "Smalltalk-80: Bits of History, Words of Advice" was the result and became known as the green book.
> Before the book came out, a series of articles about Smalltalk-80 were published in the August 1981 issue of Byte magazine.
Smalltalk-76 was the first version that mostly (besides "one metaclass per class" and "blocks with arguments") corresponds to what we understand by Smalltalk today. It was developed by Ingalls and published already in 1978, see https://dl.acm.org/doi/abs/10.1145/512760.512762. This was the earliest publication about Smalltalk as far as I know.
Interesting, thanks. Smalltalk-72 was a rather different system, i.e. didn't have much in common with Smalltalk-80 (in contrast with Smalltalk-76 which was almost there). I already have the Smalltalk-72 instruction manual from 1976, but I will gladly read the referenced articles too.
The blue book is "Smalltalk-80 - The Language and Implementation", a reference book for Smalltalk. The green book is "Smalltalk-80, Bits of History, Words of Advice", a collection of case studies of Smalltalk implementations on different systems.
Some of the most intelligent and thoughtful comments I’ve read on are on this thread. Sometimes the most vivid dreams are the early ones, before people adjust to the possible. There are a whole host of ideas of days passed that deserve revisiting. I wrote a little about them here: https://blog.eutopian.io/the-next-big-thing-go-back-to-the-f...
I had the honor of first learning Smalltalk (and C++ and a bit of object databases) in a class taught by Bob Beck from Sequent. We actually had many students running Smalltalk on X terminals hanging off a Sequent server. https://en.wikipedia.org/wiki/Sequent_Computer_Systems
Smalltalk was a crazy-productive programming environment in the '90s, and easy to love. (A bit like Lisp, in that regard, but also very different.)
What's even more amazing than that PARC was doing this in the 1970s, was that what we know as Smalltalk was only one part or step towards grand goals they were heading towards, not the end product. http://worrydream.com/EarlyHistoryOfSmalltalk/
When we find ourselves strutting around about how smart we are, how we'll change the world, as we move fast and break things (with what power we can seize and exercise over our users, with our app)... a needed dose of humility comes from seeing that the Smalltalk (and other) people, of decades earlier, seem a thousand years ahead of where we are now, in thinking.