**No, Clojure: Your REPL is Not New – or Best**
The world of programming has long been enamored with the Read-Eval-Print Loop (REPL) feature of Clojure. Devoted community members proudly proclaim its uniqueness, historic significance, and superiority over other languages. However, a closer examination reveals that these claims are based on rhetoric rather than fact.
Clojure is indeed a powerful language with dedicated supporters, but it's time to correct the mythology surrounding its REPL. To do this, let's take a step back in history and explore how the concept of the REPL has evolved over time.
**Lisp: The Origins of the REPL**
The Read-Eval-Print Loop originates from Lisp systems developed at MIT in the late 1950s (History of Lisp – Wikipedia). From the outset, Lisp environments supported interactive programming through their REPL. This technology was revolutionary for its time and paved the way for modern-day programming languages.
As early as 1964, L. Peter Deutsch and Edmund Berkeley implemented a Lisp on the PDP-1, which used the term "read–eval–print cycle" (Deutsch & Berkeley, 1964). Project MAC published a report by Joseph Weizenbaum describing a REPL-based language, OPL-1, implemented in his Fortran-SLIP language on the Compatible Time Sharing System (CTSS) (Weizenbaum, 1964; CTSS – Wikipedia).
By 1974, the Maclisp Reference Manual by David A. Moon explicitly referred to a "read-eval-print loop" (page 89), even though the acronym "REPL" is not yet used (Moon, 1974). From at least the early 1980s onward, the abbreviations REP loop and REPL are attested in the context of Scheme, where the term became standard (Scheme REPL terminology history).
**ML: A Typed REPL from the Early 1970s**
Alongside Lisp, the original ML language – developed in the early 1970s as part of the Edinburgh LCF project (LCF – Wikipedia) – was explicitly designed for interactive use. ML's REPL supported incremental definition, immediate evaluation, and full static type inference at the prompt.
This demonstrates that REPL-driven development under strong static typing is not a modern compromise or a reaction against Lisp. Instead, it represents a parallel tradition, older than Clojure by decades.
**Smalltalk: Pushing Live Systems Further**
Smalltalk systems went beyond REPL interaction and embraced image-based development (Smalltalk – Wikipedia), where the entire system existed as a continuously mutable artefact. Programs were edited while running; the notion of a clean restart receded into the background.
This approach predates Clojure by decades and represents a more radical commitment to liveness than Clojure's own model. The existence of Smalltalk alone undermines the idea that live, interactive programming is a modern breakthrough.
**Home Computing: The Forgotten Example**
The most consequential historical counterexample is neither Lisp nor Smalltalk. It is home computing. From the late 1970s through the mid-1980s, the overwhelming majority of home computers booted directly into a persistent BASIC environment (BASIC – Wikipedia).
Immediate mode was the primary interface. Variables survived RUN. Programs routinely relied on pre-initialised state in order to function within severe memory constraints. This behaviour was universal and far from exceptional.
**Erlang: Demonstrating Live Code in Production**
Clojure uniquely enables live mutation of running systems, or so the claim goes. However, this overlooks Erlang, the telecoms language created by Ericsson (Erlang – Wikipedia). From the late 1980s onward, Erlang supported hot code swapping in safety-critical telephony infrastructure.
Far from exploratory hacking, this was production engineering under strict uptime requirements. Live systems were already operational long before Clojure appeared.
**The Distinctive Characteristic of Clojure's REPL**
The distinctive characteristic of Clojure's REPL is not persistence per se, but the level at which persistence operates. Early BASIC systems preserved data, but control flow remained linear, and program meaning remained fixed.
Clojure extends persistence to meaning, allowing functions to be redefined live, dispatch rules to be altered, and existing call sites to acquire new behaviour without any obvious signpost. This shift increases expressive power but comes with a trade-off: reduced reconstructability and predictability.
**Conclusion**
The REPL is an immensely valuable tool with a lineage stretching back more than six decades. Clojure's indisputable power rests heavily on it, but that power arrives through inheritance rather than invention. Other languages explore the same design space differently, sometimes with stronger engineering constraints.
It's time to acknowledge the historical roots of the REPL and recognize its limitations. While Clojure has caused a stir in the programming world, its hour in the sun might be behind it, replaced by more modern alternatives like .NET and F#.
**References**
* Read–Eval–Print Loop (REPL) – Wikipedia: