Saved
Software · Systems

Smalltalk

Smalltalk didn’t invent object orientation—it weaponised reflection and made the IDE inseparable from the language.

Worth your time?4.5/5Yes.Study the whole thing.What works, what does not, who it is for ↓
10:18in productionCh. 1 · For Learning First/ 10:18 · ceiling 15 min
4 chapters · 10:18Ceiling 15:00

The brief is written and checked. The video joins this page when it is cut.4 chapters · 1 min read · 10:18 planned

Read the brief

Smalltalk is a pure object-oriented language built for constructionist learning at Xerox PARC in the 1970s. Its first interpreter, Smalltalk-72, was written by Dan Ingalls in about 700 lines of BASIC for the Data General Nova in October 1972. It emerged from Alan Kay’s September 1972 bet that a message-passing core could fit on a page of code—and did so by the eighth morning. Smalltalk-80, released publicly in 1980, introduced foundational OOP ideas, featured an integrated development environment from inception, and established total reflection—both structural and computational. It has no primitive types: all values are objects, and all computation occurs via message passing. ANSI Smalltalk was ratified in 1998.

Chapters & takeaways4
  1. 1:04
    For Learning First

    Smalltalk was built for children, not corporations—and its design reflects that priority.

  2. 3:07
    A Page of Code

    The first interpreter ran in 700 lines of BASIC on a Data General Nova—proof that message passing could be minimal and executable.

  3. 4:49
    IDE as Runtime

    Its IDE wasn’t bolted on—it was the runtime, and reflection wasn’t a feature, it was the architecture.

  4. 6:20
    Pure by Design

    Smalltalk-80 defined what ‘pure’ object orientation meant—but never claimed universality, only coherence.

1 more chapterFewer chapters
Worth your time?

Yes. Study the whole thing.

4.5/ 5
What works
  • message passing as sole computational model
  • total reflection (structural and computational)
  • integrated development environment as runtime
  • pure object model with no primitives
What does not
  • Smalltalk-72 shipped as a production system
  • Smalltalk-80 achieved broad industrial adoption
  • Smalltalk made claims about performance, scale, or portability beyond its documented scope
Study it if
  • language designers
  • educational technologists
  • historians of computing
Skip it if
  • enterprise developers
  • cloud infrastructure teams
  • AI engineers
Who should study it, and who should skipHide who it is for
The written brief1 min read

What it is and the problem it solves

Smalltalk is a pure object-oriented language designed for constructionist learning. It solves the problem of making computation tangible for children by turning every value, operation, and system component into an inspectable, mutable object.

How it works

Smalltalk runs by sending messages between objects. Every value is an object. There are no primitive types. Computation happens through message passing, not function calls or operators.

What works

The message-passing model works. Total reflection works—both structural (you can query and alter class definitions at runtime) and computational (you can intercept, redirect, or rewrite method execution on the fly). The integrated development environment worked from day one.

What does not

Smalltalk-72 did not ship as a complete system. It was a proof-of-concept interpreter in BASIC. Smalltalk-80 was not widely adopted outside research and education. It made no claim to industrial scalability, and none is documented.

What it changes

It changed how programming environments are conceived: as live, inspectable, modifiable systems—not static editors plus compilers. It established that an IDE could be the language’s runtime, not a separate tool.

Is it worth your time

Yes—if you need to understand how reflection, live coding, or integrated development environments were first engineered into a language. No—if you need production tooling, performance, or ecosystem support.

Same field · Software4 of 114
8:34
Objective-C1984Objective-C is a strict superset of C that introduces Smalltalk-style message passing as its core object-oriented mechanism. It was developed by Brad Cox and Tom Love in the early 1980s and first formally described in Cox’s 1986 book. Its design centers on runtime message resolution — not compile-time method binding — enabling dynamic typing, delegation, and forwarding. Syntax for non-object features matches C exactly; object features use Smalltalk-inspired messaging syntax. The language was standardized informally through that 1986 publication and later implemented in GCC and Clang.
11:20
FortranJohn Backus · 1957Fortran is the first high-level programming language to achieve broad use. It succeeded not by abstracting away hardware, but by proving abstraction could coexist with assembly-level performance — specifically for numeric computation on the IBM 704. Its compiler introduced the basic block and Monte Carlo–driven memory layout, establishing techniques that remain standard. It made computing accessible to scientists — but only those doing number-crunching, and only on IBM hardware.
11:03
Lisp (programming language)John McCarthy · 1958Lisp is the first language to treat code as data—and the first to prove that a small set of primitives plus eval suffices for universal computation. Its cost is runtime overhead; its payoff is programmable programmability.
10:27
Orange (software)Orange replaces Python syntax with visual links between prebuilt components — making data analysis accessible, but not scalable or transparent.
Up next in Technology

Smartglasses

· 10:07

Smartglasses aren’t one thing — they’re three competing definitions stapled together with pose tracking.

10:07