I've been meaning to put up this page for some time now...
Much is mentioned on Wards Wiki of the definition of OO promulgated by Alan Kay, the inventor of Smalltalk Language. Many consider it the most authoritative of the Definitions For Oo, on the grounds that He Invented The Term. (Others disagree, that Flame War belongs on other pages and not here).
The difficulty is that there seems to be no canonical source for just what Kay considers to be OO and not OO. He has written and said quite a bit, but there isn't any single reference (that I'm aware of) where it's written down. In addition, his thoughts on the matter appear to have mutated somewhat over time. This isn't unusual or wrong, as reasonable people do modify their thinking when presented with new evidence. But it makes it a bit hard to point to a particular writing and state that it is the authorative definition.
The earliest known published reference which might reveal Kay's thinking on the matter (known to me, at any rate) is the paper Early History Of Smalltalk (which you can download by going to that Wiki Page). It contains the following definition (on page 78 if you follow the link...). As noted below, this is primarily a description of Smalltalk
2. Objects communicate by sending and receiving messages (in terms of objects).
3. Objects have their own memory (in terms of objects).
4. Every object is an instance of a class (which must be an object).
5. The class holds the shared behavior for its instances (in the form of objects in a program list)
6. To eval a program list, control is passed to the first object and the remainder is treated as its message.
This definition is derived from early versions of Smalltalk (Smalltalk-72?), and rules 5 and 6 clearly show Smalltalk's Lisp heritage. Kay remarked as such, noting that rules 4-6 would mutate as Smalltalk developed.
Objection: on page 78 it is made clear that the above are the design principles behind Smalltalk, but nowhere it is implied that they should also serve as definition of Object Oriented.
Objection noted. The purpose of this page is to explore Kay's notion of OO, and the above is one of the verifiable sources we could find--even if it reflects Smalltalk circa 1974 rather than OO as a whole, it demonstrates his thoughts (at one time, at least) on the matter.
The Alan Kay definition of OO is largely that given by Carl Hewitt for the Actors Model which is a model of computation, not a programming paradigm. Alan Kay has acknowledged explicitly this derivation.
Versions of Smalltalk before Smalltalk-80 were still largely based on the (asynchronous, unidirectional) Actors Model of computation, but with Smalltalk-80, the developers of Smalltalk Language switched entirely to the (synchronous, bidirectional) procedural model, while misleadingly retaining the Actors Model terminology (such as "messages" for what essentially are procedure calls rather than one-way notifications).
This has caused endless terminological difficulties especially when considering that the the other major sources of OO thinking--capability architectures and the SIMULA 67 research--were not in the least inspired by Actors Model thinking.
So how can you honestly claim that the above is Alan Kays Definition Of Object Oriented ?
We're trying to discover just what it is. Many make reference to it, and cite it as the canonical definition. I will edit the introductory text to clarify this point.
A somewhat modified version of Alan Kay's definition is given in Tim Budds An Introduction To Object Oriented Programming. Interestingly enough, the source (given in the text of Budd's book) for this definition is Early History Of Smalltalk; though this definition has some considerable differences from the first. According to Budd:
"Alan Kay, considered by some to be the father of object-oriented programming, identified the following characteristics as fundamental to OOP:"
2. Communication is performed by objects communicating with each other, requesting that objects perform actions. Objects communicate by sending and receiving messages. A message is a request for action, bundled with whatever objects may be necessary to complete the task.
3. Objects have their own memory, which consists of other objects.
4. Every object is an instance of a class. A class simply represents a grouping of similar objects, such as integers or lists.
5. The class is the repository for behavior associated with an object. That is, all objects that are instances of the same class can perform the same actions.
So far, similar to 1-5 above. Rule 6 is different. The reference to lists is removed, instead we have:
6. Classes are organized into a singly-rooted tree structure, called the inheritance hierarchy. Memory and behavior associated with instances of a class are available to any class associated with a descendent in this tree structure.
Alan Kay has more to say about this on Alan Kay On Messaging. While he doesn't give a newer definition in that message (which is a post to a mailing list, not a scholarly writing), he does seem to de-emphasize the construction of objects themselves, and instead focus on the interface between them.
In this regard, many of the rules listed above might be seen as observations on Smalltalk-80, rather than as prescriptions/proscriptions that all OO languages should follow. Indeed, many interesting modern OO languages, including Self Language, violate rules 4 and 6 routinely. Common Lisp Object System and its decendants (Dylan Language, Cecil Language) as well as other things (Tutorial Dee) all dispense with rule 5, and choose to move behavior out of classes.
Adding fuel to the fire, Alan Kay is reported to have remarked "I invented the term object-oriented, and I can tell you that C++ wasn't what I had in mind". Whether he was objecting to any specific feature or omission of C++, it's overall quality or philosophy, or simply engaging in a gratuitous flame of the "competition" (Java didn't exist at the time [uh, yes it did, this was in the OOPSLA '98] ), it's not clear.
In the article Is Software Engineering an Oxymoron?, Kay writes: "Until real software engineering is developed, the next best practice is to develop with a dynamic system that has extreme late binding in all aspects." While this doesn't necessarily constrain the definition of OO in his mind, it is a key statement of philosophy. C++, of course, does early binding everywhere it can--up to the point of performing Static Dispatch as a default (you have to ask for Dynamic Dispatch with the "virtual" keyword when you want it. [and even that, as in many other languages like Java, is only single dynamic dispatch. If you want "late binding everywhere," you need a much more powerful dispatch system, e.g. Common Lisp Object System's generics]).
I have asked Alan Kay about his definition of "object oriented" and he told me in 2003:
OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme Late Binding of all things.
See www.purl.org 
See also Alan Kay On Objects
See original on c2.com