Engineering Philosophy: Alan Kay, The Big Idea Is Messaging

Key Takeaways

• The big idea is messaging, not objects. Kay regretted coining “objects” because it points people at classes and inheritance – the lesser idea. What matters is independent things that send each other messages and let the receiver decide what a message means.
• A change in point of view is worth 80 IQ points. You do not out-think a hard problem inside the wrong frame; you find the frame in which it becomes easy. Messaging was that move for software.
• The Dynabook reframed computing as a medium for thought, not a tool for tasks – the laptop and tablet sketched in 1972, in service of letting a person think thoughts they could not think before.
• Late binding is what buys independence. Because the sender does not know how the receiver will answer, the parts can change without breaking each other – which is exactly how a system grows past what one mind can hold.

The Principle

“I’m sorry that I long ago coined the term ‘objects’ for this topic because it gets many people to focus on the lesser idea. The big idea is ‘messaging’.” – Alan Kay¹

He coined the term, won the Turing Award largely for it, and then spent decades telling people they had read it wrong. The word object makes engineers think about classes, inheritance, and the nouns in their data model – the furniture inside the box. Kay’s point is that the furniture is the lesser idea. What matters is the box and the messages between boxes: independent things that hold their own private state and interact only by sending each other messages, where the receiver, not the sender, decides what a message means.¹ That is late binding raised to a philosophy. The sender does not reach inside and operate the machinery; it asks, and trusts the thing to know how to answer.

The reason this is the big idea is that it is how you build something too large to hold in your head. Kay’s recurring metaphor is biological: a large system should be grown like a body, out of millions of cells, each one a complete computer that protects its own state and talks to its neighbors only through messages.² No cell reaches into another cell’s chemistry. The whole organism is robust because the parts are independent and the only coupling is the messages they exchange. Object-oriented programming, done the way Kay meant it, is not a way to organize data – it is a way to make a system out of many small things that negotiate, so that no single piece has to understand the whole.

The deeper move underneath all of it is a stance toward problems, not code. A change in point of view is worth 80 IQ points, Kay liked to say.³ You do not out-think a hard problem by being smarter inside the wrong frame; you find the frame in which the problem is easy. Messaging is one such frame. The personal computer was another. The conviction that the right perspective beats raw cleverness is the same conviction underneath the argument that taste is a technical system you can examine rather than a vibe you assert – the structure you choose to see a problem through is the work.

Context

Alan Curtis Kay was born May 17, 1940, in Springfield, Massachusetts.⁴ He came to computing late and sideways – a jazz guitarist and a child who read voraciously, who served in the Air Force, where an aptitude test pulled him toward programming, before finishing a degree in mathematics and molecular biology in Colorado.⁴ The biology mattered. The cell-as-computer metaphor that would organize his whole theory of software came from there, not from any programming tradition.

He arrived at the University of Utah’s ARPA-funded computer science program in the mid-1960s, where his doctoral advisor was Dave Evans and the surrounding faculty included Ivan Sutherland.⁴ On roughly his first day, Evans handed him Sutherland’s 1963 Sketchpad thesis to read. Sketchpad let a user draw directly on a screen with a light pen, and – crucially – it had masters and instances: you defined a shape once and stamped out copies that inherited from it. Kay credits that thesis, along with the Simula language he encountered soon after, as the seed of his thinking about objects.⁴ He also attended Douglas Engelbart’s 1968 “Mother of All Demos,” the live demonstration of the mouse, hypertext, and interactive computing, which he later called one of the great experiences of his life.⁴ His 1969 PhD work, the FLEX machine and language, was an early attempt to build a personal, interactive computer around these ideas.⁴

In 1970 he joined the newly formed Xerox Palo Alto Research Center and was given the Learning Research Group to run.⁴ PARC in the 1970s was the rare place where a researcher could pursue a twenty-year vision on a corporate budget. Kay had one: not a faster mainframe, not a better terminal, but a personal computer that a child could use as a medium for thought. Everything he built at PARC – Smalltalk, the windowed interface, the very idea of the laptop – was an attempt to realize that single picture.

The Work

Smalltalk and Messaging: What OOP Really Meant

At PARC, Kay and his group – centrally Dan Ingalls, who did the foundational implementations, and Adele Goldberg, who built much of the surrounding system and documentation – created Smalltalk, one of the first fully object-oriented, dynamic programming languages.⁴⁵ In Smalltalk, everything is an object, and the only thing objects do is send messages to one another. There are no operators that reach inside another object’s state; even arithmetic is a message sent to a number. The system is dynamically typed and extremely late-bound: what a message does is resolved by the receiver at the moment it arrives, not fixed by the sender ahead of time.⁵ That late resolution is what let a running Smalltalk image be edited while it ran – the language and its environment were the same live thing.

Kay later distilled his real definition of object-oriented programming into three requirements: messaging; the local retention, protection, and hiding of state-process inside each object; and the extreme late-binding of all things.¹ Notice what is not on the list: classes, inheritance, types. Those are implementation conveniences. The non-negotiables are that state is private and that everything is decided as late as possible. When he said he had made up the term “object-oriented” and that he “did not have C++ in mind,” this is what he meant – a language can have classes and inheritance and still miss the point entirely if it lets one object reach into another’s guts.⁶

The reason messaging is the load-bearing idea, and not the objects, is that messaging is what makes independence real. If the sender knew the receiver’s internals, the two would be welded together and you would be back to one big tangled program. Because the sender only sends a message and the receiver decides how to respond, you can swap, extend, or grow the receiver without touching the sender. That is the same property that makes a body able to heal a wound or a network able to route around a dead node. Kay wanted software to scale the way biology scales, and biology scales by messages between protected cells, never by shared internals.

The Dynabook: Computing as a Medium

In 1972 Kay wrote “A Personal Computer for Children of All Ages,” presented at the ACM National Conference in Boston, and in it he described the Dynabook: a portable, notebook-sized personal computer with a flat screen, capable of holding a child’s entire library, music, drawings, and programs, that an individual would own and use anytime, anywhere.⁷ He sketched it as a thin slate roughly the size of a notebook and argued it could in principle be built with the technology of the day and sold cheaply.⁷ No such machine existed. The personal computer did not exist. He was describing the laptop and the tablet in 1972.

But the Dynabook was never really about the hardware. It was about what computing was for. Kay’s frame – drawn from the learning theories of Jerome Bruner and from Seymour Papert’s work with Logo – was that the computer is a new medium, like writing or the printing press, and the point of a medium is to let humans think thoughts they could not think before.⁴⁷ A book you can only read; a Dynabook you can author and simulate in. A child should be able to build a dynamic model of an idea and watch it run. That is why it had to be personal and portable and owned: a medium for thought has to be always at hand, the way a notebook is, or it is not a medium at all. Everything Kay built was downstream of treating the computer as a medium rather than a tool.

The PARC GUI and “Invent the Future”

The Dynabook needed an interface a child could use, so Kay’s group built one. The overlapping-window graphical user interface – windows that stack like papers on a desk, with a mouse to point and pop one to the front – was developed in his Learning Research Group at PARC and ran on the Xerox Alto, the machine the group called “the interim Dynabook.”⁴⁸ Every desktop you have ever used descends from that work. In December 1979, Steve Jobs and a group of Apple engineers visited PARC and were shown the Alto running Smalltalk: the bitmapped display, the mouse, the overlapping windows.⁸ Those ideas went into the Lisa and then the Macintosh, and from there into Windows and into the mainstream of computing.⁸ The interface the whole world now uses was built to serve a vision of children authoring in a new medium.

The animating motto of that work is Kay’s most quoted line: “The best way to predict the future is to invent it.” He has said it came out of an early 1971 PARC meeting between the researchers and Xerox planners – “in a fit of passion I uttered the quote” – when the planners wanted forecasts and Kay’s answer was that you do not forecast a future you intend to build.⁹ PARC was that sentence made operational: instead of asking what computers would become, Kay’s group decided what computers should become and then spent a decade building it. The future of personal computing was not predicted at PARC. It was invented there, on purpose.

The Computer Revolution Hasn’t Happened Yet

In 1997 Kay gave an OOPSLA keynote titled “The Computer Revolution Hasn’t Happened Yet,” and it is the necessary counterweight to the triumphal story.¹⁰ His argument was that the industry had taken the artifacts of the PARC vision – windows, the mouse, the personal machine – and missed the idea. Personal computing, he said, had mostly become the automation of paper: digital documents, digital mail, digital filing cabinets, simulating the old medium instead of becoming a genuinely new one. The revolution he meant – the computer as a medium that amplifies human thought, that ordinary people program the way they write – had not arrived. The desktop metaphor had won; the Dynabook idea had not.

The gap between artifact and idea became his life’s late critique. Through the Viewpoints Research Institute, which he founded in 2001, Kay pushed back hard against the bloat of modern software: tens of millions of lines of code to do what he argued could be done in a tiny fraction of that, if the system were grown from clean, message-passing parts instead of accreted from libraries nobody fully understands.⁴¹¹ His “STEPS” project tried to rebuild an entire personal-computing system – operating system, applications, and all – in roughly twenty thousand lines, as an existence proof that the bloat is a choice, not a necessity.¹¹ The messaging conviction runs straight through to the complaint: a system you cannot comprehend is a system whose parts were not properly independent. Bloat is what happens when the boundaries leak.

The Method

The method is consistent across fifty years – a language, a machine, an interface, and a critique.

Find the point of view that makes the problem easy. Kay’s first move is never to attack a problem head-on but to change the frame it sits in. Messaging instead of procedures; a medium instead of a tool; cells instead of code. The 80-IQ-points line is the method stated as a slogan: the leverage is in the perspective, not the effort.³

Build from independent things that message, not procedures that call. The unit of construction is an object that protects its own state and exposes only messages. You grow a large system the way biology grows an organism – by composing many small, independent, message-passing parts – so that no piece depends on another’s internals.¹²

Bind as late as possible. Decide things at the last responsible moment. Late binding is what keeps the system soft enough to change while it runs and keeps senders ignorant of receivers’ internals. Early binding buys speed and forfeits the independence that lets a system grow.¹

Treat the computer as a medium for human thought. The Dynabook standard is not “what can this tool do for a task?” but “what can a person now think, make, and simulate that they could not before?” The question reframes the entire enterprise from automation toward amplification.⁷

Invent the future rather than predict it. When asked to forecast, decide instead. The PARC discipline was to pick the world you wanted and build it, on the conviction that a vision pursued for a decade beats any prediction.⁹

Influence Chain

Who Shaped Him

Ivan Sutherland and Sketchpad. The 1963 thesis Dave Evans handed Kay on arrival – with its masters and instances, its direct manipulation on a screen – is the documented seed of his thinking about objects and interactive graphics.⁴ (Direct influence)

Simula and the object idea. The Simula language gave Kay the concrete notion of objects bundling state with behavior, which he then radicalized into “everything is an object, talking by messages.”⁴ (Direct influence)

Seymour Papert and Logo, by way of Piaget. Papert’s work on children programming – and the developmental psychology of Piaget and Bruner behind it – gave Kay the conviction that computing’s real audience was learners and its real purpose was a medium for thought, not data processing. The Dynabook is Logo’s ambition in portable form.⁴⁷ (Formative influence)

Biology. Kay’s training in molecular biology supplied the master metaphor: the cell as a complete, self-protecting computer, and the organism as millions of them messaging. Object-orientation, for him, is software trying to be biology.² (Formative influence)

Who He Shaped

Every object-oriented language. Smalltalk’s model – objects, message sends, dynamic dispatch – runs directly into Objective-C, Ruby, and Java, and its vocabulary is now the default furniture of programming. Even the languages that ignored his warning about messaging inherited the term he coined.⁵⁶

The graphical user interface, and through it the Mac and Windows. The overlapping-window GUI from his group at PARC, shown to Jobs in 1979 on the Alto, became the Lisa, the Macintosh, and then the interface of essentially every personal computer since.⁸

The laptop and the tablet. The Dynabook described, in 1972, the portable personal computer the whole world now carries. The machine on your desk and the slate in your bag are both, in outline, the thing Kay sketched.⁷

The Throughline

Barbara Liskov made data abstraction a programming primitive – a type is the contract it keeps, and a subtype must honor every promise its supertype makes. That is Kay’s messaging conviction stated as type theory: what matters is the contract between objects, not their innards, and a caller should be able to send a message and trust the response without ever reading how it is produced. Where Thompson and Ritchie built Unix from small programs that “do one thing well” and compose through clean pipes, Kay built systems from small objects that do one thing and compose through clean messages – the same bet that a big system should be many independent small things, coupled only at their interfaces. And Grace Hopper insisted the computer should meet humans in their own language, moving translation into the machine so a person could reason in their own terms; Kay took that to its limit with the Dynabook – the computer not merely speaking the human’s language but becoming a medium the human thinks in. The line then runs forward to Steve Jobs, who walked into PARC in 1979, saw Kay’s interface, and carried it to the world. (Series bridge)

What I Take From This

The lesson I keep is that the hardest part of any system is choosing the frame, and that the frame is worth more than the cleverness inside it. Kay’s 80-IQ-points line is the most useful sentence in this whole series, because it tells you where to spend your effort: not on grinding harder inside a bad model, but on finding the model in which the problem dissolves. Messaging was that move for software. Treating the computer as a medium was that move for personal computing. The discipline is to keep asking what point of view makes this easy? before writing a line. That is the same standard as quality being the only variable – the question is never “can I make the wrong design work harder?” but “have I found the right one?”

In the world I build in now – agents, tool loops, AI systems – Kay’s real definition of object-orientation is the most load-bearing idea on this site, and almost nobody names it. An agent is a Kay object: it holds private state, you cannot read its internals, and you interact with it only by sending it a message and trusting it to decide how to respond. A multi-agent system is exactly Kay’s biological vision – many independent computers, each protecting its own context, growing into something larger by messaging, never by reaching into each other’s memory. The whole reason that works, when it works, is late binding: the sender does not know how the receiver will answer, and that ignorance is the feature, because it is what lets the parts change independently. Building agents well is building Kay’s cells – and the failures are always the same failure, a boundary that leaked. That conviction, that systems should be grown from small things that message rather than assembled from parts that reach inside each other, is the throughline from a 1972 Dynabook sketch to a 2026 agent harness, and it is exactly why the evidence gate checks a component’s response, not its insides.

FAQ

What is Alan Kay’s engineering philosophy?

Kay’s core conviction is that a system too large to hold in your head must be built from independent objects that protect their own private state and communicate only by sending messages – grown like a biological organism out of many small cells, never assembled from parts that reach inside each other. Underneath that is a stance toward problems: a change in point of view is worth more than raw cleverness, so the work is to find the frame in which a hard problem becomes easy. He applied this to programming (Smalltalk), to the computer itself (the Dynabook, the computer as a medium for thought), and to the industry (his critique that the real computer revolution has not yet happened).¹³⁷¹⁰

What did Alan Kay mean by “object-oriented programming” and “messaging”?

Kay coined the term “object-oriented,” but he later said he regretted it because it makes people focus on objects, classes, and inheritance – “the lesser idea.” His real definition has three parts: messaging; the local retention, protection, and hiding of each object’s state; and the extreme late-binding of all things.¹ The big idea is messaging: objects never reach into one another’s internals; a sender sends a message and the receiver decides what it means at the moment it arrives. Notice that classes and inheritance are not on the list – a language can have both and still miss the point if it lets one object operate on another’s private state. Messaging is what makes the parts genuinely independent, which is what lets a large system grow and change without becoming a tangle.¹⁶

What was the Dynabook?

The Dynabook was the portable personal computer Kay described in his 1972 paper “A Personal Computer for Children of All Ages,” presented at the ACM National Conference: a notebook-sized, flat-screen machine an individual would own and use anywhere, holding their library, music, drawings, and programs.⁷ No such machine existed; he was describing the laptop and tablet decades early. But its real point was conceptual – the computer as a new medium for human thought, like writing or print, in which a person (especially a child) could build and run dynamic models of ideas, not just consume content. The Xerox Alto was built as “the interim Dynabook,” and the laptops and tablets we carry today are the vision realized in hardware.⁴⁷

Why did Alan Kay win the Turing Award?

The ACM awarded Kay the 2003 A.M. Turing Award “for pioneering many of the ideas at the root of contemporary object-oriented programming languages, leading the team that developed Smalltalk, and for fundamental contributions to personal computing.”¹² The citation captures both halves of his work: the language and message-passing model that shaped how software is built, and the Dynabook and PARC graphical-interface work that shaped what a personal computer is. He was the key figure behind Smalltalk, the overlapping-window GUI that Steve Jobs saw at PARC in 1979 and carried into the Macintosh, and the very concept of the personal, portable computer as a medium for thought.⁴⁸

Sources