SPACEWAR!

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. Marino and David M. Berry, reading code at once as literature, mechanism, spatial form, and social repository.

• Mark C. Marino, "Critical Code Studies" · the founding essay (Electronic Book Review, 2006).
• Mark C. Marino, Critical Code Studies · the field's book-length statement (MIT Press, 2020).
• David M. Berry, "Reflections on Method for Critical Code Studies" · the method this project follows.

A short history of Spacewar!

Spacewar! was conceived in 1961 by Martin Graetz, Wayne Wiitanen, and Steve Russell, members of the circle around MIT's Tech Model Railroad Club, when the Hingham Institute set itself the problem of writing a program that would show off the new PDP-1. Russell wrote the core over the winter of 1961–62. Two ships, a needle and a wedge, fired torpedoes at one another across a starfield. From there it grew by accretion: Peter Samson replaced the random background with the Expensive Planetarium, the actual night sky; Dan Edwards added a central star whose gravity pulled both ships toward it; Graetz added hyperspace, a panic button that made a ship vanish and reappear elsewhere at random, at the risk of never coming back. By spring 1962 Alan Kotok and Bob Saunders had built dedicated control boxes so players need not hunch over the console switches.

Almost as soon as it existed it circulated. The source was copied from PDP-1 to PDP-1, modified, extended, and passed on, an open artefact decades before "open source" had a name. What we intend to do is read that artefact closely: to take the surviving Macro source and its assembler listing and work through them line by line, pairing technical explication with cultural interpretation, and asking what this small, much-copied program can tell us about the moment computation became interactive, playable, and shared.

The object

There is no single Spacewar! source code. What survives is a family of versions: the early MIT releases (1, 2B, 3.1), the forked 4.x generation of 1963, later reconstructions such as the Computer History Museum's 4.1f, and the many ports and clones of its long journey, each in its own dialect of assembly. The primary texts here are the Macro assembly sources, preserved alongside assembler listings, provenance notes, and a runnable PDP-1 emulator, so the reading can move between text, version, and execution. The Versions page and the Timeline lay out the whole variorum.

A note on the assembler: the 1962 source is written in Macro, the PDP-1 assembler descended from the one built for the TX-0, the porting effort that first won the TMRC hackers their access to the machines. MIDAS, often named in later accounts, is one of several later and broadly compatible assemblers built on Macro (alongside Certainly and Possible); the Spacewar! listings are Macro, not MIDAS.

/ spacewar 2b · 2 apr 1962 · pdp-1 macro assembly
/ one of many surviving versions (reconstructed by Norbert Landsteiner)

  define index A,B,C
    idx A
    sas B
    jmp C
  term

  define swap
    rcl 9s
    rcl 9s
  term

  define count A,B
    isp A
    jmp B
  term

The machine and its world

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. Each fragment is read at three levels and traced through three movements.

1. The machine that owns itself. Ontology: a self-contained program with the whole PDP-1 to itself, addressing core in octal. The lineage from SAGE and Lincoln Lab; what it takes to make the code run, then and now.
2. A language for ships. The Macro assembler's macros and the outline-compiler as a small language Russell built to write the game in: a theory of computational expression embedded in the assembler. Code that writes code, at the origin.
3. The expensive planetarium. Peter Samson's real star catalogue rendered as background; Dan Edwards's gravity. The politics and aesthetics of computational verisimilitude: what gets modelled, what gets abstracted away.
4. Hyperspace, or the random jump. Contingency, risk, and play designed into a deterministic machine. The register trick, the randomness source, the panic button as game-feel.
5. The demo and the gift. Collective authorship and the free circulation of the source to every PDP-1 site: a gift economy running inside a Cold-War defence budget. The emancipatory register held in tension with its genealogy.
6. The founding myth. A critical reading of the origin story of hacker culture itself, and on what it means for Spacewar!