Alan Kay's True Intent: Object-Oriented Programming Is Not About "Classes"

The term “object-oriented programming” has taken on a life of its own, often diverging from its original intent. An article titled “A Love Letter to Object Orientation,” published on Lobsters on July 24, 2026, by mempko on blog.mempko.com, has sparked a thought-provoking discussion within the programming community. Through an explanation of the author’s “Abject” project, the article revisits the core of Alan Kay’s original definition of object-oriented programming—not as a framework of classes and inheritance, but as a system fundamentally rooted in “messaging.”

Misunderstandings About Object-Oriented

Programming

The author recounts how, when explaining the purpose of the Abject project, they referred to the internet as an object-oriented system—only to find that most programmers failed to grasp the idea. They attribute this disconnect to the fact that modern programming education often teaches object-oriented programming as synonymous with “classes and class hierarchies.”

This misinterpretation is significant. The internet is not a monolithic class hierarchy but rather a system of independent entities sending messages across agreed boundaries. This dynamic is precisely the essence of object-oriented programming as originally envisioned by Alan Kay.

The Core of “Messaging” as Defined by Kay

Alan Kay, who coined the term “object-oriented programming,” conceived the idea during his graduate studies, prior to developing Smalltalk. His influences included Ivan Sutherland’s Sketchpad—one of the earliest systems to embody object-oriented concepts—and his own background in biology.

For Kay, messaging was the pivotal concept. Smalltalk’s kernel was designed around mechanisms for objects to send messages to one another and a robust meta-system enabling late binding. Late binding refers to determining the meaning of a message at the time it is received, rather than predefining it in a static class hierarchy. The meta-system, in turn, allows a system to infer its own rules and safely extend itself.

In a 1998 post to the Squeak development mailing list, Kay reflected on misconceptions about object-oriented programming and emphasized the centrality of messaging:

Just a gentle reminder that I took some pains at the last OOPSLA to try to remind everyone that Smalltalk is not only NOT its syntax or the class library, it is not even about classes. 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” — that is what the kernel of Smalltalk/Squeak is all about (and it’s something that was never quite completed in our Xerox PARC phase). The Japanese have a small word — ma — for “that which is in between” — perhaps the nearest English equivalent is “interstitial.”

The key in making great and growable systems is much more to design how its modules communicate rather than what their internal properties and behaviors should be. Think of the internet — to live, it (a) has to allow many different kinds of ideas and realizations that are beyond any single standard and (b) to allow varying degrees of safe interoperability between these ideas.

If you focus on just messaging — and realize that a good metasystem can late bind the various 2nd level architectures used in objects — then much of the language-, UI-, and OS-based discussions on this thread are really quite moot.

Kay expressed regret over coining the term “objects,” as it has led many to focus on less essential ideas. The true idea, he asserted, is “messaging,” which forms the very core of Smalltalk and Squeak.

Messaging as “Ma” (The Space Between)

Kay drew on the Japanese concept of “ma,” which refers to the space between entities, to emphasize the importance of designing communication between modules. The key to creating highly extensible systems lies not in defining the internal properties or behaviors of modules, but in designing how they communicate with one another.

This perspective resonates strongly with contemporary discussions on microservices architecture and API design. Instead of focusing on internal implementation details, prioritizing interfaces and protocols—what lies in the “space between”—was a notion Kay highlighted as early as 1998.

The Disconnect with Modern Programming Practices

By Kay’s definition, much of what is implemented as “object-oriented programming” in modern languages diminishes its essence. Statically typed languages like Java and C++ emphasize class hierarchies, prioritizing compile-time decisions over the dynamic characteristics of messaging. This focus on static structures often clashes with the dynamic nature of messaging that Kay championed.

On the other hand, languages such as Erlang, with its actor model, Go, with its interface-based design, and Rust, with its trait system, adopt approaches that align more closely with Kay’s vision. These languages emphasize message passing and behavioral abstraction, downplaying reliance on rigid class hierarchies.

The Internet as a Case Study in Object Orientation

Kay’s reference to the internet as an example of an object-oriented system was no coincidence. Technologies like HTTP protocols, RESTful APIs, and JSON-based data exchanges embody Kay’s vision of “independent systems sending messages to one another.” Each server and service conceals its internal implementation and communicates via defined interfaces.

Viewed through this lens, the rise of microservices architecture represents a return to Kay’s ideal. The careful design of communication protocols between services, enabling independent evolution of each service, aligns closely with the messaging philosophy Kay pursued with Smalltalk.

Editorial Opinion

In the short term, the renewed focus on Kay’s message could influence how object-oriented programming is taught and how programming languages are designed. For developers frustrated by the complexity of class hierarchies in statically typed languages, rethinking design with an emphasis on messaging could lead to more maintainable code. Furthermore, the growing emphasis on interface design in microservices and distributed systems design underscores and accelerates the validation of Kay’s ideas.

From a long-term perspective, Kay’s advocacy for “late binding through a robust meta-system” points to the direction of future programming paradigms. As AI-driven code generation and runtime optimization advance, the emphasis on flexibility at runtime rather than decisions at compile time will likely grow in importance. However, balancing this approach with the benefits of static analysis and type safety remains a challenge.

The editorial team believes that Kay’s anecdote about regretting the term “objects” highlights the inherent risks of technical terminology developing a life of its own.

References

• “A Love Letter to Object Orientation”, by blog.mempko.com by mempko — Lobsters, 2026-07-24T20:33:34.000Z (ARR)
• Source URL: https://blog.mempko.com/a-love-letter-to-object-orientation/