The Loop That Came Before the Window

The REPL — a Read-Eval-Print Loop, an interactive programming session that reads an expression, evaluates it and prints the result without a separate compile step — is old enough to have outlasted two generations of programming fashion and to be thriving in a third. Its origins lie in Lisp, and Lisp's origins lie in 1958, when John McCarthy at MIT began designing a language in which the interpreter and the program were barely distinguishable from each other.

By the early 1960s, time-sharing systems at MIT allowed multiple users to submit expressions to a Lisp interpreter in real time, each receiving a printed response on a teletype. No bitmapped display, no mouse, no window — only a roll of paper and the almost-immediate return of a computed value. The cycle was already read, eval, print; the word "loop" simply named the fact that you could do it again. This was not a limitation dressed up as a feature: it reflected McCarthy's conviction that computation should be interrogable, that a programmer should be able to probe a running system rather than compile, link, run and read a post-mortem.

A desk given over to one application, its panels arranged around the work.

The Lisp systems, notably MACLISP and INTERLISP variants, that ran through the 1970s extended this into something closer to an environment. State persisted across expressions. A function defined in one exchange was available in the next. Errors did not crash the session; they dropped the programmer into a nested REPL from which the broken call stack could be inspected and the offending function redefined — then resumed. This error-recovery idiom was genuinely novel: the program remained alive while the programmer repaired it, a capability that compiled-language toolchains of the same era could not approach.

The rise of Pascal, C and later C++ pushed interactive evaluation to the periphery for most working programmers. Compiled languages demanded the separate edit-compile-run cycle, and the IDEs that crystallised around them — Borland's Turbo environments, then Microsoft's Visual Studio — organised their interfaces around that cycle. The REPL was not absent from this period, but it was mostly confined to scripting and to academic Lisp work. APL retained an interactive interpreter with its own distinctive terminal culture. Smalltalk at Xerox PARC built a persistent image that shared the REPL's philosophical core: you evaluated expressions in a workspace and the system responded, live, in the same window.

What kept the REPL alive through the 1980s and 1990s was the scripting tier of larger systems — shell pipelines, AWK, later Perl and Python — where the cost of a compile step was never justified. Guido van Rossum designed Python with an interactive interpreter as a first-class mode, not an afterthought; the Python shell became a standard exploratory tool for a new generation of programmers who had never touched a Lisp machine. The interactive mode was simple enough to be documented in a page, powerful enough to prototype a module in an afternoon.

The form evolved once more when scientific computing demanded a combination of code, output and prose in a single persistent document. Project Jupyter's notebook format, which grew from the IPython project in the early 2010s, organised REPL interactions into numbered cells whose outputs — including plots, tables and formatted text — were stored alongside the code that produced them. The notebook was, in structure, a REPL session made archivable and shareable; the loop was still there, now segmented into cells rather than lines.

JupyterLab, the environment that succeeded the original Jupyter Notebook interface, extended this further, placing notebooks alongside terminals, file browsers and text editors in a multi-panel workspace that resembles — without quite becoming — a conventional IDE. The REPL had travelled from a teletype roll in 1960 to a browser tab, carrying the same essential contract: enter an expression, receive a result, continue. The graphical IDE arrived between those two points and changed almost everything about programming tooling. The loop, quiet and patient, was there before it, and it is still running.