I've been meaning to put up this page for some time now...
Much is mentioned on WardsWiki
of the definition of OO promulgated by AlanKay
, the inventor of SmalltalkLanguage
. Many consider it the most authoritative of the DefinitionsForOo
, on the grounds that HeInventedTheTerm
. (Others disagree, that FlameWar
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 EarlyHistoryOfSmalltalk
(which you can download by going to that WikiPage
). 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 ObjectOriented.
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.
definition of OO is largely that given by CarlHewitt
for the ActorsModel
which is a model of computation, not a programming paradigm. AlanKay
has acknowledged explicitly this derivation.
Versions of Smalltalk
before Smalltalk-80 were still largely based on the (asynchronous, unidirectional) ActorsModel
of computation, but with Smalltalk-80, the developers of SmalltalkLanguage
switched entirely to the (synchronous, bidirectional) procedural model, while misleadingly retaining the ActorsModel
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 ActorsModel
So how can you honestly claim that the above is AlanKaysDefinitionOfObjectOriented ?
- 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 AlanKay
's definition is given in TimBudd
. Interestingly enough, the source (given in the text of Budd's book) for this definition is EarlyHistoryOfSmalltalk
; 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.
has more to say about this on AlanKayOnMessaging
. 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 SelfLanguage
, violate rules 4 and 6 routinely. CommonLispObjectSystem
and its decendants (DylanLanguage
) as well as other things (TutorialDee
) all dispense with rule 5, and choose to move behavior out
Adding fuel to the fire, AlanKay
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 StaticDispatch
as a default (you have to ask for DynamicDispatch
with the "virtual" keyword when you want it.)
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 LateBinding of all things.
See also AlanKayOnObjects