How we got Java instead of Self — a short history, the JIT breakthroughs, and a “Sliding Doors” take

1) From Smalltalk → Self (1986–1991)

Roots: Self was designed in 1986 by David Ungar and Randall Smith as a radical simplification of Smalltalk: no classes, just prototypes (objects cloning and specialising other objects). Early work started at Xerox PARC, then moved to Stanford; the first compiler appeared in 1987. Public release: 1990. In 1991 the team joined Sun Microsystems. (Self Language, Wikipedia)
The feel of the system: a live, image-based environment (like Smalltalk), with the Morphic GUI later ported to Squeak/Pharo and even the Lively Kernel. (Wikipedia, Gbracha)
Why performance mattered: Self aimed for interactive, exploratory programming and speed. By the mid-90s, Self’s VMs hit ~½ the speed of optimised C on some benchmarks—astonishing for a dynamic, prototype-based language then. (Wikipedia)

2) The JIT revolution born in Self (1991–1995)

Self’s VM research basically wrote the playbook for modern high-performance dynamic runtimes:

Polymorphic Inline Caches (PICs) cut dynamic dispatch overhead and gather runtime type info, enabling later optimisations. (Hölzle, Chambers, Ungar, OOPSLA ’91.) (SpringerLink, Self Language Bibliography)
Type feedback & adaptive recompilation (“optimise the hot spots”)—the compiler inlines and specialises based on observed types, then recompiles when the world changes. (Hölzle PhD, SELF-93 system.) (Stanford University, Self Language Bibliography)
Dynamic deoptimisation and on-stack replacement (OSR)—let the system bail out of speculative optimisations, or jump between compiled/interpreted code while running. These techniques were pioneered in Self and are now table stakes in modern VMs. (Season Lab, Purdue University Computer Science)

(Add generational GC pedigree from Ungar’s earlier work, heavily used in Self.)

3) The fork in the road: Sun backs Java, Self goes quiet (1994–1999)

Context flip (1995): the Web explodes; Sun bets the company brand on Java (“Write once, run anywhere”). Resources and marketing swing behind applets and the Java platform. Self at Sun winds down circa 1995. (Wikipedia)
Animorphic/LongView (1994–1997): several Self/Smalltalk VM wizards—Urs Hölzle, Lars Bak, Gilad Bracha, David Griswold, et al.—form LongView Technologies (Animorphic) to build Strongtalk, applying Self’s type-feedback ideas to a high-performance Smalltalk VM. Sun acquires the company in 1997. (Wikipedia, Wikipedia, ctinsider.com)
HotSpot (1999): Sun productises the tech as the Java HotSpot VM, carrying across PICs, type feedback, adaptive recompilation, deopt/OSR—the Self playbook repurposed for Java bytecode. HotSpot ships in 1999 and becomes the de facto JVM. (Wikipedia)

Net effect: Self wasn’t “commercialised”; its VM innovations emigrated into Java. Self at Sun was effectively abandoned as a sponsored research line, though the community later revived it with releases in 2006, 2010, 2017—and even 2024.1. (Wikipedia)

4) Why Java won that moment (the boring but decisive reasons)

Security model & bytecode verification: an easily verifiable, class-file format with static typing was a better fit for applet sandboxes and corporate IT risk.
Familiar C-ish syntax & classes: easier sell to the 90s enterprise developer base than prototypes and image-based development.
Portability & vendor push: Sun poured money and marketing into “write once, run anywhere,” plus tooling and partnerships (Netscape, server vendors).
Timing: Java hit exactly when the web needed a “safe, portable” language; Self was a research environment that didn’t map cleanly onto the browser/server product story.

(These are widely recorded in Java/HotSpot histories; the specific Self → HotSpot line is explicit in Sun/HotSpot retrospectives.) (Wikipedia)

5) “Sliding Doors”: the world where Self won

Imagine two trains leaving 1995:

Track A (our world): Sun cancels Self to chase Java. The Self team’s JIT ideas power HotSpot; the industry standardises on class-based Java for enterprise and Android. Prototypes still slip in through JavaScript (itself influenced by Self) but without Self’s live, image-centred environment. (Wikipedia)
Track B (the other door): Sun doubles down on Self as a product:
- Browsers embed a live Self runtime; you script the web with prototypes and direct manipulation, not class hierarchies.
- The default dev loop is liveness: patch objects in a running system, instant feedback, images as first-class artefacts.
- Education and tooling normalise prototypes; far fewer “design patterns” whose purpose is to simulate dynamism in static, class-based worlds.
- Server VMs still adopt Self’s adaptive JITs—but the language riding them is the beautiful one, not its class-shaped derivative.

We didn’t get that door. We got the VM. The soul of Self survived—but under Java’s syntax, type system, packaging, and ecosystem choices.

6) Consolations and echoes

HotSpot is Self’s runtime philosophy, re-targeted; most modern high-perf VMs (JVMs, JavaScript engines) owe a debt to Self’s JIT work. (Wikipedia, SpringerLink, Self Language Bibliography)
Morphic lives on in Squeak/Pharo and inspired later UIs (e.g., Lively Kernel; Scratch descends via John Maloney). (Wikipedia, Gbracha)
Prototypes made it to the mainstream via JavaScript (and earlier NewtonScript)—both explicitly influenced by Self. (Wikipedia)

TL;DR

Self (born from Smalltalk) invented the JIT tricks—PICs, type feedback, adaptive recompilation, deoptimisation/OSR—that modern VMs use. Sun ended Self’s run and bought the Self-descended Animorphic VM, shipping it as HotSpot for Java. In the “sliding doors” universe, we keep Self’s language and environment; in ours, we kept its VM and wrapped it with Java’s “enterprise-friendly” aesthetics. (SpringerLink, Stanford University, Season Lab, Wikipedia)

Generated by GPT-5 in response to the pathetic ranting of Eleanor

intellectronica/sliding-doors-we-were-promised-smalltalk-without-classes-we-got-fucking-java.md