Reportedly, Alan Kay is the inventor of the term "object oriented". And he is often quoted as having said that what we call OO today is not what he meant.

For example, I just found this on Google:

I made up the term 'object-oriented', and I can tell you I didn't have C++ in mind

-- Alan Kay, OOPSLA '97

I vaguely remember hearing something pretty insightful about what he did mean. Something along the lines of "message passing".

Do you know what he meant? Can you fill in more details of what he meant and how it differs from today's common OO? Please share some references if you have any.


4 Answers 4


TL;DR - Alan Kay wrote in 2003 that:

OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things. It can be done in Smalltalk and in LISP. There are possibly other systems in which this is possible, but I'm not aware of them.


------- Full source, for context:

Date: Wed, 23 Jul 2003 09:33:31 -0800 To: Stefan Ram [removed for privacy] From: Alan Kay [removed for privacy] Subject: Re: Clarification of "object-oriented"

Hi Stefan --

Sorry for the delay but I was on vacation.

At 6:27 PM +0200 7/17/03, Stefan Ram wrote:

Dear Dr. Kay,

I would like to have some authoritative word on the term "object-oriented programming" for my tutorial page on the subject. The only two sources I consider to be "authoritative" are the International Standards Organization, which defines "object-oriented" in "ISO/IEC 2382-15", and you, because, as they say, you have coined that term.

I'm pretty sure I did.

Unfortunately, it is difficult to find a web page or source with your definition or description of that term. There are several reports about what you might have said in this regard (like "inheritance, polymorphism and encapsulation"), but these are not first-hand sources. I am also aware that later you put more emphasis on "messaging" - but I still would like to know about "object oriented".

For the records, my tutorial page, and further distribution and publication could you please explain:

When and where was the term "object-oriented" used first?

At Utah sometime after Nov 66 when, influenced by Sketchpad, Simula, the design for the ARPAnet, the Burroughs B5000, and my background in Biology and Mathematics, I thought of an architecture for programming. It was probably in 1967 when someone asked me what I was doing, and I said: "It's object-oriented programming".

The original conception of it had the following parts.

  • I thought of objects being like biological cells and/or individual computers on a network, only able to communicate with messages (so messaging came at the very beginning -- it took a while to see how to do messaging in a programming language efficiently enough to be useful).

  • I wanted to get rid of data. The B5000 almost did this via its almost unbelievable HW architecture. I realized that the cell/whole-computer metaphor would get rid of data, and that "<-" would be just another message token (it took me quite a while to think this out because I really thought of all these symbols as names for functions and procedures.

  • My math background made me realize that each object could have several algebras associated with it, and there could be families of these, and that these would be very very useful. The term "polymorphism" was imposed much later (I think by Peter Wegner) and it isn't quite valid, since it really comes from the nomenclature of functions, and I wanted quite a bit more than functions. I made up a term "genericity" for dealing with generic behaviors in a quasi-algebraic form.

  • I didn't like the way Simula I or Simula 67 did inheritance (though I thought Nygaard and Dahl were just tremendous thinkers and designers). So I decided to leave out inheritance as a built-in feature until I understood it better.

My original experiments with this architecture were done using a model I adapted from van Wijngaarten's and Wirth's "Generalization of Algol" and Wirth's Euler. Both of these were rather LISP-like but with a more conventional readable syntax. I didn't understand the monster LISP idea of tangible metalanguage then, but got kind of close with ideas about extensible languages draw from various sources, including Irons' IMP.

The second phase of this was to finally understand LISP and then using this understanding to make much nicer and smaller and more powerful and more late bound understructures. Dave Fisher's thesis was done in "McCarthy" style and his ideas about extensible control structures were very helpful. Another big influence at this time was Carl Hewitt's PLANNER (which has never gotten the recognition it deserves, given how well and how earlier it was able to anticipate Prolog).

The original Smalltalk at Xerox PARC came out of the above. The subsequent Smalltalk's are complained about in the end of the History chapter: they backslid towards Simula and did not replace the extension mechanisms with safer ones that were anywhere near as useful.

What does "object-oriented [programming]" mean to you? (No tutorial-like introduction is needed, just a short explanation [like "programming with inheritance, polymorphism and encapsulation"] in terms of other concepts for a reader familiar with them, if possible. Also, it is not neccessary to explain "object", because I already have sources with your explanation of "object" from "Early History of Smalltalk".)

(I'm not against types, but I don't know of any type systems that aren't a complete pain, so I still like dynamic typing.)

OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things. It can be done in Smalltalk and in LISP. There are possibly other systems in which this is possible, but I'm not aware of them.

[Also,] One of the things I should have mentioned is that there were two main paths that were catalysed by Simula. The early one (just by accident) was the bio/net non-data-procedure route that I took. The other one, which came a little later as an object of study was abstract data types, and this got much more play.

If we look at the whole history, we see that the proto-OOP stuff started with ADT, had a little fork towards what I called "objects" -- that led to Smalltalk, etc.,-- but after the little fork, the CS establishment pretty much did ADT and wanted to stick with the data-procedure paradigm. Historically, it's worth looking at the USAF Burroughs 220 file system (that I described in the Smalltalk history), the early work of Doug Ross at MIT (AED and earlier) in which he advocated embedding procedure pointers in data structures, Sketchpad (which had full polymorphism -- where e.g. the same offset in its data structure meant "display" and there would be a pointer to the appropriate routine for the type of object that structure represented, etc., and the Burroughs B5000, whose program reference tables were true "big objects" and contained pointers to both "data" and "procedures" but could often do the right thing if it was trying to go after data and found a procedure pointer. And the very first problems I solved with my early Utah stuff was the "disappearing of data" using only methods and objects. At the end of the 60s (I think) Bob Balzer wrote a pretty nifty paper called "Dataless Programming", and shortly thereafter John Reynolds wrote an equally nifty paper "Gedanken" (in 1970 I think) in which he showed that using the lamda expressions the right way would allow data to be abstracted by procedures.

The people who liked objects as non-data were smaller in number, and included myself, Carl Hewitt, Dave Reed and a few others -- pretty much all of this group were from the ARPA community and were involved in one way or another with the design of ARPAnet → Internet in which the basic unit of computation was a whole computer. But just to show how stubbornly an idea can hang on, all through the seventies and eighties, there were many people who tried to get by with "Remote Procedure Call" instead of thinking about objects and messages. Sic transit gloria mundi.


Alan Kay

  • 1
    Can you/someone clarify what is meant by "I wanted to get rid of data"? Data is an integral part of OO (i.e. it is often being encapsulated in a class, or passed around to/from classes), and whatever paradigm is used, one cannot do without data in computing, so getting rid of data no sense to me.
    – Dennis
    Commented Jul 16, 2015 at 15:42
  • Also, what is meant by the "<-" token? (I might need some context, and maybe mapping to current OO to understand this well)
    – Dennis
    Commented Jul 16, 2015 at 15:53
  • 1
    <- was the original smalltalk assignment operator Commented Jun 16, 2016 at 12:29
  • @Dennis if you think of data as all the 1's and 0's sure. But even database people see a difference between data and information. Under Alan Kay objects send messages. Whether they contain data is no one else's business. Objects don't get sent anywhere. They sit where they are and talk to other objects. Remember, this is a paradigm. It's more about what you don't do. Commented Nov 16, 2020 at 17:14

Most if not all of what Alan Kay meant by object-orientation is embodied in the Smalltalk language.

Also, from http://en.wikipedia.org/wiki/Message_passing#Influences_on_other_programming_models:

Alan Kay has argued that message passing is more important than objects in OOP, and that objects themselves are often over-emphasized. The live distributed objects programming model builds upon this observation; it uses the concept of a distributed data flow to characterize the behavior of a complex distributed system in terms of message patterns, using high-level, functional-style specifications.
  • 27
    One then wonders why he called it "Object-Oriented" rather than "Message-Oriented". Commented Mar 16, 2011 at 17:36
  • 100
    I was too blythe about the term back in the 60s and should have chosen something like "message oriented"
    – Alan Kay
    Commented Jun 8, 2011 at 16:27
  • 2
    But what is "message oriented" then? (I can think of async calls (possibly), but don't actually know any language not implementing more-or-less "normal" methods; there's a thing about return values, also, but this can be tricked with sort-of 'ref'/'out' parameters or something like that)
    – mlvljr
    Commented Jul 6, 2011 at 22:49
  • 3
    "message oriented" is basically late-binding/dynamic-typing—the message passed to the object is analyzed (by that object) at runtime. Commented Jul 7, 2011 at 2:59
  • 1
    Yes, dynamic and duck typing and method_missing, getattr, etc... was probably what was originally meant by OOP.
    – aoeu256
    Commented Aug 28, 2019 at 18:32

One of the major points that I've picked up from following the works of Alan Kay and others such as Jim Coplien is that true "object" oriented programming is about modeling computers and software in terms of HUMAN/USER mental models, rather than being just a tool for PROGRAMMERS.

As I understand it, Alan's vision of OOP was making the computer a tool that allows a human user to make whatever they want: the full capabilities of the computer are directly exposed to the end user through an intuitive interactive model. I should be able view and sculpt runtime objects and interactions DIRECTLY, not just through code.

Here is a post about my plans to attempt a some version of this in JavaScript as a proof of concept:http://www.cemetech.net/forum/viewtopic.php?p=234494#234494

From a perspective of software development / programming, Jim Coplien talks about how code can and SHOULD resemble the users mental model of it. That is, the code reads much the same way as it would sound by a person describing it's behavior. This is largely accomplished by thinking in terms of OBJECTS, rather than in terms of CLASSES and TYPES. Behavior is described on terms of the ROLES played by objects, not as part of the definition of an object's IDENTITY. You should be able to model interactions on terms of objects, which are identified by the ROLE they play in an interaction. This is how human mental models work: Waiter, Customer, Cashier, Source Account, Destination Account,... These are ROLES, not TYPES, and you want to the able to define methods for "whatever object is playing this role at the time", because that behavior is part of a system interaction between many changing objects, rather than part of the definition of some TYPE.

  • DDD uses similar concepts. Probably you are right about this. :-)
    – inf3rno
    Commented Sep 21, 2017 at 23:36

Most if not all of what Alan Kay meant by object-orientation is embodied in the Smalltalk language.

"We didn’t even do all of the idea at PARC. Many of Carl Hewitt’s Actors ideas which got sparked by the original Smalltalk were more in the spirit of OOP than the subsequent Smalltalks. Significant parts of Erlang are more like a real OOP language the the current Smalltalk, and certainly the C based languages that have been painted with “OOP paint”."

Taken from Alan Kay's comment at:


  • 1
    You have to scroll a long way down the comments, here's direct link to Alan Kay's comment: computinged.wordpress.com/2010/09/11/…
    – icc97
    Commented Oct 21, 2018 at 20:10
  • That entire comment is very useful, it starts with a potential answer to this question: "A good example of a large system I consider “object-oriented” is the Internet. It has billions of completely encapsulated objects (the computers themselves) and uses a pure messaging system of “requests not commands”, etc."
    – icc97
    Commented Oct 21, 2018 at 20:12

Not the answer you're looking for? Browse other questions tagged or ask your own question.