Object-Oriented Programming — Orange Pill Wiki
CONCEPT

Object-Oriented Programming

The programming paradigm Alan Kay named and formalized in Smalltalk — code organized as communities of objects that communicate through messages, modeled on biological cells.

Object-oriented programming is the paradigm Kay developed at Xerox PARC in which software is structured as collections of objects — self-contained units that combine state and behavior — that interact by sending each other messages. Each object knows what it is and what it can do, but it does not know the internal workings of the objects it communicates with. This architecture mirrors biological cells and, Kay argued, mirrors the architecture of human knowledge itself. Every domain of expertise is a self-contained object that communicates with other domains through shared concepts, arguments, and analogies — messages — without requiring each domain to understand the others' internal workings.

In the AI Story

Hedcut illustration for Object-Oriented Programming
Object-Oriented Programming

The paradigm emerged from Kay's conviction that the complexity of large software systems would eventually exceed human cognitive capacity unless the architecture of the software mirrored an architecture that biology had already solved. A single human body contains trillions of cells, each a relatively simple unit, organized into tissues, organs, and systems through message-passing at every scale. The body works because no cell needs to understand the whole. Software, Kay argued, should work the same way.

Kay has consistently insisted that the OOP that the industry adopted is not the OOP he proposed. Languages like C++ and Java took the surface features — classes, inheritance, method syntax — and missed what Kay considered the essential points: the radical independence of objects, the centrality of message-passing as the only form of inter-object communication, and the late binding that would let systems be modified while running. Kay has called the industry's version of OOP "a kind of abomination." What he proposed was a language of biological metaphors; what the industry built was a bureaucratic type system.

In the AI age, Kay's original OOP becomes newly relevant. A large language model is in some sense an object — it receives messages (prompts) and responds with behavior (outputs). But it violates Kay's principle at the critical level: the user cannot open it up and understand how it works. Encapsulation has become opacity. The message arrives, the response arrives, and the internal process is not merely hidden (which Kay accepted) but inaccessible to inspection even in principle (which Kay would reject). This is the interpretability problem restated in object-oriented terms.

Kay's framework also clarifies what ascending friction, as described in The Orange Pill, actually means. Each layer of abstraction in computing — assembly, compilers, operating systems, applications, natural language — is a new layer of objects whose internal complexity is hidden. The question Kay would ask at each layer is not whether the hiding is efficient but whether the user can, when needed, open the hood and see what the layer is doing. A layer that cannot be opened is not abstraction; it is concealment.

Origin

Kay coined the term "object-oriented" in 1967 while working on the FLEX Machine at the University of Utah, though the full realization came with Smalltalk at PARC in the 1970s. The intellectual lineage traces through Simula 67 (the first language with class-like constructs), LISP (the first language with fully dynamic binding), Ivan Sutherland's Sketchpad (which demonstrated that graphical objects could behave as self-contained entities), and Kay's biology training at the University of Colorado.

The paradigm became commercially dominant through C++ (1985), which added OOP features to C while preserving C's low-level performance, and then through Java (1995), which enforced OOP as the primary paradigm. Both languages, in Kay's view, captured the letter and lost the spirit.

Key Ideas

Cells, not procedures. Software should be organized as communities of relatively simple objects, not as long sequences of procedural instructions.

Messages as the only interface. Objects communicate only by sending messages; they do not reach into each other's internal state.

Encapsulation with accessibility. Each object hides its complexity from routine callers but remains openable by the user who needs to understand or modify it.

Late binding. The meaning of a message is resolved at the moment of sending, not at compile time — which lets systems evolve while running.

Industry misreading. What the industry adopted as OOP retained the syntactic features and abandoned the live, biological, inspectable character Kay had designed.

Debates & Critiques

Is OOP as Kay envisioned it still achievable in mainstream software, or has the industry's version permanently defined what the paradigm means? Kay's own work on Croquet and STEPS demonstrates the ideal remains reachable. Whether it scales commercially is a separate question.

Appears in the Orange Pill Cycle

Further reading

  1. Alan Kay, The Early History of Smalltalk (ACM SIGPLAN, 1993)
  2. Alan Kay, The Computer Revolution Hasn't Happened Yet (OOPSLA keynote, 1997)
  3. Ole-Johan Dahl and Kristen Nygaard, Simula 67 Common Base Language (1968)
  4. Bertrand Meyer, Object-Oriented Software Construction (Prentice Hall, 1997)
Part of The Orange Pill Wiki · A reference companion to the Orange Pill Cycle.
0%
CONCEPT