Smalltalk

Smalltalk is an object-oriented programming language and integrated development environment created at Xerox PARC in the 1970s by Alan Kay, Dan Ingalls, Adele Goldberg, and others. It is not merely a language but a complete computational environment in which programs are constructed by sending messages to objects, and the entire system — compiler, debugger, editor, and running applications — coexists in a single mutable image that can be modified while it executes. Smalltalk was the first system to treat the screen as a dynamic canvas for computational objects, the origin of the overlapping window interface, and the laboratory in which modern object-oriented programming was born.\n\n== The Object Model ==\n\nSmalltalk's object model is radical in its simplicity. Everything is an object. Every computation is a message sent to an object. There are no primitive types, no special cases, no escape hatches. A number is an object that responds to arithmetic messages. A class is an object that responds to instantiation messages. A method is an object that responds to invocation messages. This uniformity is not a cosmetic choice; it is a philosophical commitment to the idea that computation is a conversation between autonomous entities, and that the structure of software should mirror the structure of social interaction rather than the structure of machines.\n\nThis commitment makes Smalltalk a direct descendant of Lisp in spirit, if not in syntax. Where Lisp achieved computational unity through homoiconicity — the equivalence of code and data — Smalltalk achieved it through behavioral unity: every entity responds to messages, and every response is itself a computation. The two languages represent different answers to the same question: how do you build a system in which the boundaries between programmer, program, and environment dissolve?\n\nSmalltalk's answer was the image: a persistent, live environment in which programs are not files on disk but objects in memory. The image can be saved, resumed, and transmitted across machines. A Smalltalk programmer does not write code, compile it, and run it. They modify a living system, and the system changes in real time. This is Live Programming — the idea that programming is not the construction of static artifacts but the continuous cultivation of dynamic systems.\n\n== The Xerox PARC Context ==\n\nSmalltalk was born in a research culture that believed computing should be accessible to everyone, not just specialists. Alan Kay's vision of the Dynabook — a personal, portable computer for children — demanded not just new hardware but a new software paradigm. The Dynabook needed a system that children could learn, modify, and extend without understanding compilers or operating systems. Smalltalk was the software that Kay built to make the Dynabook possible.\n\nThe development of Smalltalk at Xerox PARC was inseparable from the development of the graphical user interface. Smalltalk's first implementation, Smalltalk-72, ran on the Xerox Alto, a workstation with a bitmap display and a mouse. The language and the interface co-evolved: windows were objects, buttons were objects, menus were objects, and the user's clicks were messages sent to these objects. The MVC pattern — model, view, controller — was invented in Smalltalk as a way to separate the data model from its visual representation. This architecture would later dominate software design, though most of its practitioners would never encounter it in its original form.\n\n== Influence and Decline ==\n\nSmalltalk's influence on modern computing is disproportionate to its commercial success. Java, C++, Python, and nearly every modern object-oriented language trace their conceptual lineage to Smalltalk's design decisions. The idea that a program is a collection of objects communicating through well-defined interfaces; the idea that the development environment should be an integrated, interactive system; the idea that the user interface should be built from composable, reusable components — all of these were demonstrated in Smalltalk decades before they became mainstream.\n\nYet Smalltalk itself remained a niche technology. Its image-based model was poorly suited to the file-based version control and text-based tooling that dominated software engineering from the 1980s onward. The commercial implementations were expensive, and the open-source implementations were fragmented. Smalltalk's greatest strength — the tight integration of language and environment — became its greatest weakness in an industry that valued modularity and interoperability over coherence.\n\nSmalltalk's failure to achieve mass adoption is not a technical failure but a cultural one. The computing industry chose file-based, batch-compiled, statically typed languages because they fit the organizational structures of industrial software production — large teams, formal specifications, hierarchical management. Smalltalk demanded a different kind of programmer: one who treated software as a living system to be cultivated rather than a static artifact to be manufactured. The industry was not ready for this shift, and it is still not ready. The resurgence of live programming, interactive notebooks, and REPL-driven development suggests that Smalltalk's ideas were not wrong — they were merely premature. The future of programming will look more like Smalltalk, not less.\n\n\n\n