By the Bluebook implementation of Smalltalk-80 | Hacker News Reader

By the Bluebook implementation of Smalltalk-80

github.com

176 pointshomarp49 comments

This is awesome!

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 !

[1] https://en.wikipedia.org/wiki/What_the_Dormouse_Said

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.

ETH Oberon was not derived from Smalltalk. I implemented both systems, see https://github.com/rochus-keller/Smalltalk and https://github.com/rochus-keller/Oberon and can say for sure they have very little in common.

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.

I have explicitly not stated anything about Oberon being derived from Smalltalk, rather from Xerox PARC "w̲o̲r̲k̲".

This is a thread about a Smalltalk-80 VM.

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.

That only applies to the Cedar programming environment. Show me the references otherwise pls.

And it was even more remarkable that Xerox did not use Smalltalk for its GUI applications and the systems after Alto.

You are the one wanting, for whatever reason to relate Smalltalk to Modula-2/Oberon, when everyone has replied to you about Xerox PARC "work".

The references are in bitsavers, Xerox PARC section.

>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).

Though, early Smalltalk did not support lexical closures.

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!

Did you ever see the system called “Methods” which was a TUI version of Smalltalk on the PC? I think it was by Digitalk.

It was a part of Digitalk Smalltalk/V for DOS. It can still be found at: https://winworldpc.com/product/digital-smalltalk/12-dos It does run under FreeDOS.

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.

It doesn't play well with the current largish screen sizes. I got it to run on an eeePC 701, which has a 800x480 LCD Display.

Yes, I still have the box and original media (though it ain't pretty looking)

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?

ParcPlace spun off from Xerox to sell the original Smalltalk in 1988 but they sold that to Cincom in the late 1990s: http://www.cincomsmalltalk.com/main/products/visualworks/

Cincom had previously tested the waters by buying another Smalltalk called Object Studio.

IBM sold its VisualAge Smalltalk to Instanciations: https://www.instantiations.com/products/vasmalltalk/index.ht...

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/

I consider Self to be Smalltalk, though not Smalltalk-80: https://selflanguage.org/

There are Smalltalks based on Javascript, as well as an alternative VM for Squeak and friends: https://www.amber-lang.net/ https://squeak.js.org/ http://u8.smalltalking.net/

There are probably a few that I missed that are still in use.

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.

Not having used them myself, I can't comment on the quality of the JVM based Smalltalks:

http://www.redline.st/

https://github.com/hpi-swa/trufflesqueak

Another project that I watched without trying myself was for .NET:

https://refactory.com/sharp-smalltalk/

There was also Essence# but it doesn't seem active.

> Apple had the original PARC Smalltalk

They had V1; the image provided by http://www.wolczko.com/st80 which the VM referenced in this post is based on is V2.

> There are probably a few that I missed that are still in use.

Here is one that works on the original (unmodified) Xerox image: https://github.com/rochus-keller/Smalltalk

Dolphin Smalltalk is still being developed and is open source now: https://github.com/dolphinsmalltalk/Dolphin

Right, Dolphin is still around. It seems that so is Smalltalk/X (which I used in the early 1990s), but there are now two versions:

https://www.exept.de/en/smalltalk-x.html

https://swing.fit.cvut.cz/projects/stx-jv

And I should have remembered Gemstone/S:

https://gemtalksystems.com/

Since I mentioned Little Smalltalk I should also have pointed out another educational system:

http://som-st.github.io/

This is so incredebly cool. Hat's off to you sir.

I've dreamed with doing the same. Now if you could make it compile in WASM and available from the browser window.

You might be able to bring smalltalk back to the forefront where it belongs.

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.

Emscripten supports SDL so it might be easy.

There is a Smalltalk books website out there somewhere with copies of all the old classics. I think Stefan Duccasse (Pharo professor) hosts it.

http://stephane.ducasse.free.fr/FreeBooks.html

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.

Well done. My first experience was with Smalltalk/V. I still have my well worn copy of the blue book.

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

You can try to follow these videos, but the commentaries are not in English. It shows:

- basic windows management

- expressions evaluation

- code browsing

- "explain" command

- profiler

- debugger usage, resumable exceptions

- system modification in the debugger

- objects inspection

- system reflection (objects enumeration)

- objects identity swapping

- system navigation (senders/implementors)

- all on system with only decompiled sources

https://www.youtube.com/watch?v=JyaQavN9rVA

https://www.youtube.com/watch?v=cpjOd5ge2MA

This is the most hands-on exciting post I've seen on HN this year. Congrats!

Phenomenal! Thank you for helping to preserve this piece of history.

Can somebody elaborate on what the bluebook or greenbook is? I tried googling but nothing useful turned up. At least nothing related to programming.

https://wiki.squeak.org/squeak/689:

The Xerox Parc Colored Books

- 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.

There was an article in 1975 and two in 1977, but they were about Smalltalk-72 and didn't have too many details.

http://www.vpri.org/pdf/hc_ACK_Pisa_1975.pdf

http://www.vpri.org/pdf/m1977001_dynamedia.pdf

http://dreammachin.es/Kay_SciAm_77.pdf

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.

http://stephane.ducasse.free.fr/FreeBooks/BlueBook/Bluebook....

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...

Amazing work!

Reply on news.ycombinator.com