technologybriefs
10:18in productionCh. 1 · For Learning First/ 10:18 · ceiling 15 min
Software · Systems

Smalltalk

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

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.

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
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 102
10:03
Go (programming language)Robert Griesemer, Rob Pike, Ken Thompson · 2009Go is a statically typed, compiled programming language designed in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson at Google to improve programming productivity for multicore, networked machines and large codebases. It combines static typing and runtime efficiency like C, readability and usability like Python, and high-performance networking and multiprocessing. Publicly announced in November 2009 and released as version 1.0 in March 2012, Go emphasizes simplicity, safety, and developer tooling — especially around concurrency via goroutines and channels, packaging, testing, and deployment — while deliberately omitting features like inheritance, assertions, pointer arithmetic, and implicit type conversions. Its design reflects a focus on the software development process itself rather than just language syntax or semantics.
9:44
Apache CassandraFacebook · 2008Cassandra is a distributed, wide-column database built for write-heavy, multi-datacentre workloads. It prioritises availability and scalability over consistency. It requires upfront schema design aligned to access patterns. It was developed at Facebook for inbox search and released open-source in July 2008.
10:00
Apache HadoopYahoo · 2006Hadoop is not a database or a query engine. It is a fault-tolerant batch-processing substrate built for scale, not speed or simplicity.
10:34
Amiga 10001985The Amiga 1000 is not defined by what it promised, but by what it delivered on day one: a working, shipped, ROM-locked implementation of preemptive multitasking — alongside deliberate physical design choices that treated the case as functional infrastructure. Its limitations are architectural, not aspirational.
Up next in Technology

Smartglasses

· 10:07

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

10:07