Influence of BYTE's Smalltalk issue

The Smalltalk paper is interesting because ST had quite a formative impact on me back in the day.

I remember the Byte Smalltalk issue in 1981. This was, of course, during the heyday of Byte when they dedicated every August issue to some language. I still have a copy of this issue. I, like many, had lots of copies of Byte that were eventually discarded, but the Smalltalk issue I kept.

But the truly extraordinary event that impacted me the most was in 1985. By then I had an early Macintosh, founding member of the campus Mac User group, and in 1985, Apple was having some shindig on campus at college.

Someone, I stumbled upon an Apple person who happened to have a Mac Plus running the Apple port of Smalltalk. Apple was one of the 4(?) companies that took on the task of porting the Xerox Smalltalk image to their hardware. The only other company, as I recall, that really approached the effort with any seriousness, was Tektronix who came out with an actual, commercial Smalltalk workstation.

Apple never did. You could get access to the ST image and the Apple runtime through their developer group. But it was mostly a novelty.

But here it was, in all its crude glory, on this Mac Plus that this guy was showing me.

And he demonstrated to me one of the most amazing things I’d had seen on a computer to that point.

ST-80 runs on a virtual machine, and ships as an image of byte codes along with 2 associated files. The source code, and the changes file. The source code is exactly that, the source of ST-80 (but NOT the actual underlying VM). Every time you make a change to the system, that change is logged in the changes file. It’s essentially a transaction log. If the system were to crash, you can load up an older image, and play forward the changes log to the point, ideally, before you did something that crashed the system. And since the entirety of the system was laid bare before you, it’s quite easy to do devastating things to the running image. As time goes on, you do a consolidation process which merges the changes file with the source file.

So, this fellow was showing me the famous ST tools, notably the Class Browser which you used to explore the classes and source code that made up the system. ST-80 had a novel, albeit crude GUI, with notably things like scroll bars.

Unlike most modern GUIs, the scollbars of each pane popped out as you moused in to the pane. They weren’t a permanent fixture like they are today. You float the mouse across the Class Browser, and the scrollbars come and go from pane to pane along with the mouse.

This is a simple example:
Screenshot 2020-06-13 21.34.05

You’ll notice that the scroll bar has a thumb (dark gray box) and that may note that the thumb in proportional to the size of the area to be scrolled.

What he did, however, took my breath away.

He browsed to where the width of the scroll bar was defined:
Screenshot 2020-06-13 21.37.08

He then change the value from 8 to something else (I picked 12), and then “accepted it” (which saves the change). And guess what instantly happens:
Screenshot 2020-06-13 21.38.30

I must stress “instantly”. No recompiling, no reloading, no repainting. Instantly, the scrollbar was bigger. Now, naturally, all of that did happen. It was recompiled (the individual method), it was reloaded (actually, it was simply replaced), and it was repainted (the scrollbar goes away when you run the command and it immediately repainted).

But in comparison to the normal development cycle we are all used too, it was a jaw dropping demonstration. It showed the effect of editing live, running code, in place. Changing the tires of a moving vehicle.

This had a great impact on how I viewed computers and systems. While I got to dabble with it later, I never actually got that much in to actual ST coding. In the mid-90’s, ST was having some pretty good commercial success, but I wasn’t really able to cross paths with it. Then Java came along and showed ST the door.

But in the mid-90s, more that 10 years later, Squeak appeared. Squeak was a new implementation of the ST VM, written IN ST (and then translated in to C). And, it was based on the APDA ST-80 image, which is a direct descendent of the original Xerox ST-80 image.

It was exciting when it came out, and it was a marvel to consider what was inside that ST image. A piece of living history. Simply, especially early on (though not so much today), there was source code in that image that was probably last changed in 1980. Running source code that had lineage back to the mid-70s, and carried forward all the way up to the mid-90s.

Even in the current Squeak image there may well still be some of that. Over the past 25 years, the Squeak image has been walked through and over again and again and again.

Those screenshots are from the latest Squeak image, as Squeak still includes the original “MVC” experience (you have to dig a bit to get it, but it’s there). For example, in the original ST, I’m pretty sure they didn’t have a Preferences class like this one does to hold things like the Scrollbar width. The modern Squeak image is enormous compared to what it was in 2.x or 3.x.

But the heritage is there.

FYI you can get the actual original Xerox ST image and sources here:

And here’s (I think) the original method for creating the scroll bar:

        "Answer the rectangular area in which the gray area of the scroll bar
        should be displayed."

        ^[email protected] extent: 10 @
                        ((view window height asFloat /
                                                view boundingBox height *
                                                        scrollBar inside height)
                                 rounded min: scrollBar inside height)

In this case, the width is that 10 of the 10 @ line. Change that 10 to something else, and voila, magic.


That issue of Byte had a huge impact on me as well, and I have been designing Smalltalk computers since 1984.

Here are two implementations of virtual machines for the original Xerox Smalltalk image that have been released in the past couple of months:


Nice clip from Dan Banay’s readme:

Should I try to emulate the Alto file system? I decided against that and followed the approach used by Tektronix in the Greenbook – I subclassed FileDirectory, File, and Page and created PosixFileDirectory, PosixFile, and PosixPage. I fired up VSCode and wrote an implementation for them that I could copy and paste into my Smalltalk (I added a way to paste characters from the clipboard into the input queue). After I had those implemented, I tested them, and once I was satisfied, I created the SourceFiles array with file streams for Smalltalk-80.sources and Smalltalk-80.changes. Once I did that --the instant I assigned that variable – the magic happened. BANG! All of a sudden I could browse real source code in the browser! Now that I had a working file system, I re-pasted my implementation which was then stored by the system (to the changes file) and I could finally see my implementation with real temporary names and comments! It was the very delightful bootstrapping experience that makes you grin from ear to ear.

(BTW I split this thread from the parent, which is multi-topical - hope that’s OK with everyone.)

I remember that Byte issue. So it did make an impact on me as well, but, as with so many of the other “special” issues, there was no way I could actually try out any of it. I’ve yet to come across an actual Smalltalk system. So, along with Prolog and other stuff presented in Byte it passed me by back when I was still sucking up new ideas. Unfortunately. If I was handed an ST system today I would probably not bother - too many other things to do, and lots of tools to focus on.

1 Like

Never know until you try!

That dbanay Smalltalk above is pretty well perfect implementation of the original. I was playing with it yesterday, this is a “vintage” experience. You will want to have Smalltalk-80: The Interactive Programming Environment (i.e. the “orange” book) as essentially the manual for the system. Oh, and the _ key is used for the assignment ← character in this system. is the modern rendition from the same folks that wrote the original system. is a very modern Smalltalk based on Squeak focusing very heavily on community development. A lot of work on new VMs and JIT systems have been done in Pharo, as well as new UI and tools. Pharo is very fast moving.


Previous Smalltalks used several odd characters, but for getting Smalltalk-80 “out to the world” they decided to replace them all with ASCII. But for DEC and Xerox that meant 1963 ASCII and not the final standard which had replaced the left arrow with underscore and the up arrow with ^.

Methods from Digitalk ran on the PC text mode and since they expected most of their users to come from Pascal they replaced the left arrow with :=. When they moved to graphical mode for Smalltalk/V they kept this convention and eventually other Smalltalks adopted it either as an option or as the standard.

1 Like