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:
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:
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:
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: http://www.wolczko.com/st80/
And here’s (I think) the original method for creating the scroll bar:
computeMarkerRegion "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.