The Early History of Smalltalk (1993)

Which then influenced Mesa, Cedar, Interlisp-D inside Xerox.

Mesa and Cedar influenced Niklaus Wirth to come up with Modula-2/Lillith and Oberon.

Which had an influence on Rob Pike, on how he developed ACME for Plan 9.

Meanwhile StrongTalk, and Objective-C ended up influencing how Java came to be, and its approach to JIT compilation.

On another track Smalltalk ends up influencing Self design, which ends up having an effect on how V8 JIT was designed.

Then there is Ruby as well.

Pity that with all of this, many still never tried what actually means to use Smalltalk.

Note that Interface Builder started as a Lisp prototype, before being acquired by NeXT.

https://paulhammant.com/2013/03/28/interface-builders-altern...

An another lot of people doesn't know that Smalltalk-76 onwards implemented the Simula 67 object model (as the first language in the given completeness), which represented a fundamental departure from Smalltalk-72. See the Ingalls 1978 and 2020 papers for more information (https://dl.acm.org/doi/10.1145/512760.512762 and https://dl.acm.org/doi/10.1145/3386335, both more interesting and relevant than the one in the title, written by the person who invented most of the technology we today know as Smalltalk-80).

I got to meet Brad Cox at college when he came to visit one of my professors (who I worked with after hours). I find it interesting that instead of the objects as tiny computers of Kay he thought of software ICs and then pulled from Smalltalk to implement those concepts in Objective-C, but in the simplest way possible (almost just combining the two side-by-side) as opposed to Stroustrup being more heavily influenced by Similar (especially as he was actually building simulations) and extending C into objects to gain performance that Simula didn’t have.

In many ways NeXTSTEP can be thought of as a “pragmatic Smalltalk environment” that traded some of Smalltalk’s dynamism for improved compatibility with the Unix ecosystem. Recall that NeXT’s original target market was higher education, which even in the 1980s started relying on Unix. This was the era of the Unix workstation, and NeXT can be considered a competitor to Sun, SGI, HP, DEC, and other Unix workstation vendors. NeXT’s differentiator was its Smalltalk-inspired object-oriented environment, built on Objective-C.

I wonder, though, what a pure Smalltalk workstation would’ve looked like, and what hardware would’ve been necessary to make it fast. After all, the late 80s were the era of Lisp machines, though Lisp machines were much more expensive than NeXT cubes ever were. If I recall correctly, Smalltalk on the Xerox Alto was slow, but David Patterson (of RISC fame) had a PhD student who worked on a performant version of the Smalltalk VM, and some of that work went to a spiritual successor named Self, which heavily influenced the design of the Java VM. I remember Java feeling slow in the mid-1990s, but that might be due to bad memories of Java applets rather than a fundamental problem with Java VMs.

Interface Builder was originally a Lisp project

https://www.inria.fr/en/jean-marie-hullot-visionary-computer...

When I was in college, Brad Cox came and gave a talk about Objective-C (and more generally his 'software IC' ideas). He was pretty clear how Smalltalk was a key influence. His book on ObjC discusses it as well. Very interesting stuff, even now.

I really wish that there was a license/version/build marketed to hobbyists:

>Call or Email for Pricing

and the upgrade pricing is four figures (per set per year I'm guessing?).

Ages ago, I actually bought a Smalltalk for Windows compiler, but never got around to doing anything with it (which I regret) --- I suppose I should try Dolphin SmallTalk....

Was it at Carleton? Ottawa seems to have a fondness for Smalltalk and seems to have been a… hotspot for it.

You're not a horrible person to enjoy that. However, the schadenfreude is only in your head. 2026 is the most amazing year of building software in human history, so far.

I for one already have the popcorn at the ready. Can't wait for it.

Blame IBM and other Smalltalk vendors.

They were the ones that almost on day one pivoted their Smalltalk offerings into Java.

Eclipse still has the Visual Age Smalltalk object browser.

If you look into OS/2 documentation, and SOM (OS/2 version of COM), you will find out Smalltalk on OS/2 had a role similar to .NET on Windows.

I think AI is the revenge of Lisp, dealing with Python without JIT, and the whole 4 GLs, CASE tooling that tried to automate programming in the 1990's, this time around it goes.

Interesting!

Were you using IBM Visual Age Smalltalk?

What is the Structural Object Processor?

Another hardware project was MUSHROOM [1]

[1] https://www.wolczko.com/mushroom/index.html

Burroughs Large System (aka B5000-B8500) still (virtually) exist as Unisys Clearpath MCP. You could download a VM if you wanted to try it (I assume you still can).

BiiN and i960 are sorta the same thing to the extent that Intel took the BiiN work after that project died and commercialized it as the i960. Unfortunately, except for the early i960MC, XA & XM versions, Intel was busy stripping feature out of it to make an embedded processor instead of making use of the really cool parts. What might have been...

> it was the older brother of Logo

Logo predated Smalltalk, so Smalltalk is more like an evolution on the idea and a younger brother.

EDIT: Looked up the dates. Logo was made in 1967, Smalltalk started development in 1969.

I'd like to see LOGO but with support for 3-D, accelerated with CUDA

Logo is essentially just Lisp without parens. And Brian Harvey argues that it should have dynamic binding, because that's easier to teach to children.

Brian Harvey on dynamic binding, in the Snap! forum thread "Hygienic macros":

https://forum.snap.berkeley.edu/t/hygienic-macros/3258

I've summarized his points in moollm's snap-macros-metaprogramming.yml under dynamic_binding_and_scope:

https://github.com/SimHacker/moollm/blob/main/designs/snap/s...

He wishes Snap! had dynamic binding, at least for learners. This comes from decades of teaching Logo to kids, and he finds it easier to explain.

In Logo without lambda, the dynamic environment includes everything the lexical one would, plus more of the caller's variables.

Logo's MAP with ? wants name capture: the called procedure reads a variable the caller set.

Logo debugging works in the same language at the REPL, with every relevant local visible at the error.

Name capture rarely bites kids, who write one-off helpers for one or two callers.

He proposed hybrid scope and a DYNAMIC VARIABLES block. Neither shipped. Jens argued for lexical scope only, because blocks must be interchangeable.

https://forum.snap.berkeley.edu/t/hygienic-macros/3258/6

Brian Harvey> I admit that my slogan "Snap! is Scheme disguised as Scratch" would sort of push in the direction of hygienic macros. But historically we built Snap! more with the idea of Logo disguised as Scratch. It was just when we added lambda that we started thinking more in Scheme terms.

https://github.com/YootTowerManagement/YootTower/blob/main/Y...

Alan Kay> The fact that kids were to be the users, and the simplicity and ease of use of the already existing LOGO, whose own parents were LISP and JOSS (which set a standard for the esthetics for interaction that has not yet been surpassed), provided lots of motivation to have programs and transactions appear as simple as possible-i.e. moving from left to right, procedures gather their own messages, etc. It is no accident that simple SMALLTALK programs look a bit like LOGO!

https://news.ycombinator.com/item?id=23054174

Don Hopkins> Here is the source code to LLogo in MACLISP, which I stashed from the MIT-AI ITS system. It's a fascinating historical document, 12,480 lines of beautiful practical lisp code, defining where the rubber meets the road, with drivers for hardware like pots, plotters, robotic turtles, TV turtles, graphical displays, XGP laser printers, music devices, and lots of other interesting code and comments.

Lars Brinkhoff suggests that this comp.lang.logo thread with Brian Harvey and Leigh Klotz is required reading:

https://groups.google.com/forum/#!topic/comp.lang.logo/UqOvE...

https://news.ycombinator.com/item?id=23054236

Brian Harvey> Wally Feurzeig started the whole thing by organizing a group at Bolt, Beranek, and Newman, Inc., to study the educational effects of teaching kids a programming language. The first language they used, like most programming languages, was focused on numeric computation, and it was Wally's idea that kids would find it more natural to work in an area they knew better, namely natural language; therefore, he set up a team to design a language featuring words and sentences. Wally made up the name "Logo."

Brian Harvey> The team Wally put together at BBN included Seymour Papert and Dan Bobrow. The three of them are credited as the designers of the first version of the language; Dan wrote the first implementation.

Leigh Klotz> In the mid 1970's, when the AI Lab Lisp Machine project was just getting underway, Marvin Minsky and Danny Hillis (later to found Terrapin, and still later, Thinking Machines) put together a project to build a Logo machine.

Lars Brinkhoff> Now also BBN PDP-10 Logo, MIT CLOGO, MIT Lisp Logo, and hopefully soon MIT Apple II Logo (direct ancestor of Terrapin Apple II Logo).

My summary from http://canonical.org/~kragen/human-folly/day/02025-07-22.htm...:

https://www.youtube.com/watch?v=wo84LFzx5nI Casey #Muratori’s keynote about, largely, #disjoint-unions and how it is sad that #C++ doesn’t have them. “I’m not saying OOP was a mistake. I’m saying this [a compile-time hierarchy of encapsulation that matches the domain model] was a mistake.” Also traces the #history of records in #programming-languages through Simula and Hoare’s record-handling paper and the “plex” of Douglass Ross of the MIT Servomechanisms Laboratory in AED, Algol Extended for Design, and also #Sketchpad, which had in-memory records (“chickens”) linked together in circular linked lists, which apparently was an idea he got from Ross (“n-component elements”). Both Ross’s plexes and Sketchpad had function pointers in the records. (But the constraint solver was “the most unencapsulated thing that you could possibly imagine”.) Also documents how Looking Glass in 01998 introduced the #Entity-Component-System pattern in Ultima II Underworld, but really introduced it with Tom Leonard’s Thief: The Dark Project. At 82'40” he points out that he independently invented a worse version of ECS at definitionSIX for Negaman in 01997. “It’s just, I sucked at it, and Looking Glass was good.” Basically his “35-year mistake” thesis is that we almost had ECS in 01963 with Sketchpad, but it took until 01998. He likens 01990s OOP dogma to playing Magic: The Gathering, which I think is insightful. At 136'45” he tells his devotee Ryan Fleury that he has snatched the stone from his hand and may now leave. Nice quote: “You should focus on the hardest stuff. You should say, ‘what solves the hardest problems?’ because we can always then take that and scale it down, and remove things from it or dumb it down, for people to use in cases that aren't as hard. But it’s almost impossible to take something that only solves simple problems and scale it up to something that solves hard ones.”

I'm interested to see the results of your digestion too!

There's been a term for the phenomenon for decades: "Amiga Persecution Complex":

https://freedictionary.org/search/amiga_persecution_complex

The disorder suffered by a particularly egregious variety of bigot, those who believe that the marginality of their preferred machine is the result of some kind of industry-wide conspiracy (for without a conspiracy of some kind, the eminent superiority of their beloved shining jewel of a platform would obviously win over all, market pressures be damned!) Those afflicted are prone to engaging in flame wars and calling for boycotts and mailbombings. Amiga Persecution Complex is by no means limited to Amiga users; NeXT, NeWS, OS/2, Macintosh, LISP, and GNU users are also common victims. Linux users used to display symptoms very frequently before Linux started winning; some still do. See also newbie, troll, holy wars, weenie, Get a life!.

Oddly it doesn't mention Smalltalk!

    From: "Pandora B. Berman" <CENT@AI>
    Subject: request
    Date: 17 December 1989 at 12:06:15 GMT+1
    To: till@____

        Date: Tue, 12 Dec 89 14:52:39 PST
        From: Don Tillman <till@____>
        To: Postmaster@AI
        Subject: request

        Hiya.  Would it be possible for me to get added to the Unix-haters
        mailing list?  Thanks muchly.

    many things are possible. Moon might turn blue, for instance (if we lock
    him outside without his jacket for too long, say). it is certain, though,
    that as official a body as Postmaster@AI would not touch such a request
    with a 10" light pen; that might be construed as giving official sanction
    to discussion of such a subversive topic, and besides the unix-haters are
    anarchists and would never stand for it.  However, if you can provide us
    with sufficient good cause -- a short flame, say, on your pet piece of unix
    braindeath, or references from recognized authorities that you are a unix
    hater in good standing -- then we will be glad to give your request all due
    consideration..

Funny, but it was originally intended for the average person to develop their own software for the upcoming PC revolution. So the language was meant to be small and easy to learn. Something a child could learn to use.