1970

MacLisp · Micro-Planner · MIT AI Lab, 1968–70

Reading the code at the high-water mark of symbolic AI

A critical code study of Terry Winograd's natural-language-understanding program and its tabletop blocks world, read as a cultural text.

The argument

SHRDLU is where code first appears to understand. Written across 1968–70 by Terry Winograd at the MIT Artificial Intelligence Laboratory, it let a person type ordinary English commands and questions, and watch a simulated arm rearrange coloured blocks and pyramids on a screen in answer. Ask it to pick up a big red block and it does; ask why it did something and it tells you. For a moment in the early 1970s it seemed that the problem of machine understanding had been opened.

This project reads that program as a cultural text. Following Critical Code Studies, the source is approached in its multiplicity, as language, as mechanism, as a model of a world, and as a repository of the assumptions of the artificial-intelligence programme that produced it. Reading about the history of AI is not the same as reading its code. The aim is to do the latter: to sit with the MacLisp and the Micro-Planner, the grammar written as procedures, the hand-built microworld, and the famous scripted dialogue, and to ask what this code knows, what it only appears to know, and what its founding demonstration leaves out.

pick up a big red block
The field

Critical Code Studies

Critical Code Studies (CCS) applies the interpretive methods of the humanities to computer source code, reading code, architecture, and documentation within their sociohistorical context. Its premise is that lines of code are not value-neutral: meaning grows out of what the code does but is never exhausted by it. Code can be close-read like any other text, attended to for its naming, its comments, its silences, and the assumptions it encodes, while still being held to its material test, that it must compile and run.

This reading works in the tradition developed by Mark C. Marino1 and David M. Berry2, reading code at once as language, mechanism, world-model, and social repository. SHRDLU is an unusually rich object for this method, because its central claim was itself a claim about meaning: that to represent knowledge as procedures was to let a machine understand.

1 Mark C. Marino, Critical Code Studies (Cambridge, MA: MIT Press, 2020), the field's book-length statement, following his founding essay of the same title (Electronic Book Review, 2006).

2 David M. Berry, The Philosophy of Software: Code and Mediation in the Digital Age (Basingstoke: Palgrave Macmillan, 2011); and, for the collaborative method applied to a contemporary of SHRDLU, David M. Berry and Mark C. Marino, "Reading ELIZA: Critical Code Studies in Action" (Electronic Book Review, 2024).

A companion reading

This study sits alongside the team's critical code readings of the other founding programs of the long 1960s, among them Joseph Weizenbaum's ELIZA (1966) and the MIT Spacewar! (1962). Three programs, three claims about what a computer could be made to do: ELIZA teaches the machine to talk, Spacewar! teaches it to play, and SHRDLU teaches it to understand. Read together through their source, they let us approach the origins of computational culture not through its myths but through its code, and to see how early and how confidently the claim of machine understanding was made.

Read "Reading ELIZA: Critical Code Studies in Action" →

Why SHRDLU

Why read this program now

We are once again surrounded by machines that appear to understand language. The large language models of the 2020s answer in fluent prose across an open domain, where SHRDLU could converse only about a tabletop of blocks. Yet the two stand in an instructive symmetry. SHRDLU's understanding was grounded, every word tied to procedures over a world it could inspect and act on, and it could explain its reasoning step by step, but it could not leave its microworld. Today's models are general but, in the classic phrase, arguably ungrounded: fluent everywhere, anchored nowhere, and opaque as to why they say what they say.

Reading SHRDLU's code returns us to the first, most optimistic version of the dream, and to the moment its limits became visible. The history of that disappointment, the move from microworld to scaling problem to "AI winter", is also the prehistory of the present.

OK · (does it)
What is being read

The object: a conversation about blocks

SHRDLU's world was a simulated tabletop, the paradigmatic "microworld" of the Minsky–Papert research programme: a box, a table, and a handful of blocks, cubes and pyramids in red, green and blue, moved by a simulated arm. The system was built from four parts, all in MacLisp under the ITS operating system: a parser; a grammar of English written as procedures (Winograd's PROGRAMMAR, after Halliday's systemic grammar); programs for semantic analysis; and a deductive problem-solver in Micro-Planner. The conversation here is the demonstration dialogue Winograd published, reproduced from his own transcript and running on those parts: the person types in lower case, SHRDLU answers in capitals.

Read the full demonstration dialogue, with commentary →

the machine and its world
Context · machine · artefact

The machine and its world

1968–70
written
MacLisp
under ITS
PDP-6
+ DEC-340 display
~50
words of world
AI-TR-235
thesis, Feb 1971

SHRDLU ran on the MIT AI Lab's DEC PDP-6, with the blocks world drawn as line graphics on a DEC Type 340 display attached to it; the conversation itself was carried on a teletype. The program was written in MacLisp, the lab's Lisp dialect, under the Incompatible Timesharing System (ITS), with its deductive reasoning expressed in Micro-Planner, a practical subset of Carl Hewitt's Planner implemented at the lab by Gerald Sussman, Winograd and Eugene Charniak.

The world it modelled was deliberately tiny. A microworld in the Minsky–Papert sense is small enough that all the relevant knowledge can be hand-built into the program: a closed domain of a few solids and the relations "on", "in", "supports", "bigger than". That smallness is the condition of SHRDLU's apparent fluency.

BLOCKS WORLD · CUBES · PYRAMID · BOX
A still from the original SHRDLU demonstration on the DEC-340 display: white wireframe cubes, a pyramid and an open box with a gripper arm above a stack, and the teletype exchange 'PUT THE BLUE PYRAMID ON THE BLOCK IN THE BOX. OK.' answered by 'NO, ONLY FOUR OF THEM: THE RED CUBE, TWO LARGE GREEN CUBES AND A LARGE RED BLOCK.'
The blocks world as it actually appeared: a still from the original SHRDLU demonstration on the DEC Type 340 vector display, the gripper poised above a stack as the dialogue scrolls overhead. Object ID 2007.020.027.

That wager has lately returned. After the success of large language models and diffusion models, much of contemporary AI has turned to world models: the argument, pressed by Yann LeCun in his work on predictive world models (his JEPA programme) and by Fei-Fei Li under the name "spatial intelligence", that an agent which acts in the world needs an internal model of it, and not only a facility with text or images. SHRDLU is an early, miniature instance of exactly that idea, a program that kept and reasoned over a model of its world, which is why its microworld is worth reading closely now rather than only as history. The overview follows that thread to the philosophical question it raises.

Context

A microworld at the AI Lab

SHRDLU was the showpiece of the microworlds programme run by Marvin Minsky and Seymour Papert, Winograd's doctoral advisor. The wager: master a small closed world completely, then scale up.

Method

Grammar as procedures

Winograd's thesis was that knowledge, grammar included, is best represented as procedures. His parser PROGRAMMAR expressed the rules of English as little programs, drawing on M. A. K. Halliday's systemic grammar.

Artefact

It could say why

Because its actions were driven by a Micro-Planner goal stack, SHRDLU could be asked "why?" and trace its own reasoning back, command by command, to "because you asked me to". An early, readable model of machine self-explanation.

Approach

Reading, and re-running

We read the surviving source across the registers of CCS, and treat programming as scholarship, drawing on the preserved code and modern reconstructions so interpretation is tested against the artefact.

read · spiral outward
Method

The reading

The study works across the registers of Critical Code Studies, pairing close technical explication of a code fragment with the cultural constellation that spirals out from it.

  1. A name that means nothing. ETAOIN SHRDLU: a pseudo-acronym drawn from Linotype letter-frequency columns by way of Mad magazine and, probably, a 1942 science-fiction story about an AI typesetter. A program about meaning, named with a deliberate non-word.
  2. Procedures as representation. The thesis at the program's heart: that to represent knowledge as procedures is to let a machine understand. PROGRAMMAR, systemic grammar, and procedural semantics, read as a theory of meaning embedded in code.
  3. The closed world. The blocks world as microworld: we look at what gets modelled, what is abstracted, and how the limited domain is important for enabling a world model to function.
  4. The goal stack speaks. A machine that can answer "why?" because its reasoning is an explicit stack of goals. Self-explanation as designed effect, and its distance from understanding.
  5. Demo or die. The scripted dialogue as artefact. Winograd's own later verdict, the "Potemkin village", and the microworld scaling problem that bridges to the AI winter.
  6. Grounded but not general. SHRDLU read against the large language models: the symmetry of grounding and generality, and what the first dream of understanding can still tell us.
The artefact, talking

Read the 1970 demonstration

The full conversation Winograd published, forty-two exchanges from "pick up a big red block" to "you're welcome", reproduced verbatim with its original typos and read closely.

▶ Enter the dialogue
further reading
Background

Further reading

See the full bibliography for more readings.

Method

SHRDLU and its critics

With grateful acknowledgement to Terry Winograd, whose own SHRDLU pages preserve the source code, the demonstration dialogue, and the story of the program's name, on which this project draws.

contact
The project

Contact

The SHRDLU reading is a Critical Code Studies project. Correspondence and corrections are welcome.

Project co-lead

Professor David M. Berry

University of Sussex

d.m.berry@sussex.ac.uk

Project co-lead

Professor Mark C. Marino

University of Southern California

mcmarino@usc.edu

Critical Code Studies

The CCS Working Group

github.com/critical-code-studies

github.com/critical-code-studies/SHRDLU