Alan Kay did not invent objects

Original author: Hillel Wayne
  • Transfer

People continue to argue that modern object-oriented languages ​​are in fact "not quite object-oriented" because they do not meet the definition of OOP Alan Kay. In my opinion, this makes sense, although I do not agree with the conclusion. Recently, I have met people who say that it was Kay who invented the objects. This is actually not true.

Alan Kay did not invent objects. They were in Simula , which leads as the main source of inspiration the manual for Smalltalk-72 (p. 117). A 1981 issue of Byte, a popular magazine that popularized Smalltalk and OOP, said that "the basic idea of ​​objects, messages, and classes came from SIMULA." It says that Simula allows users to create "object-oriented systems", which is perhaps too, but nonetheless. The Smalltalk team knew the Simula object system well and drew inspiration from it.

One of the reasons why such a myth is still alive was what Kay himself said in 1998 :

I just remind you that at the last OOPSLA I tried to convey to everyone that Smalltalk is not only NOT a syntax or class library, but not even classes. I am very sorry that I previously coined the term “objects” for this topic, as it makes many people focus on a smaller idea.

And further in this interview he continues:

I mean, I invented the term "objects." Since we made objects first, there were no other objects to radicalize this.

He later stopped saying this , but people still continue to use that quote as a fact.

Alan Kay invented the term "Object Oriented Programming"

This is absolutely true.

OOP was in classes and objects

Recently, many continue to argue that OOP is actually not in classes and objects, and that in fact, the most important messages are. In a 1998 post, after Kay said he regrets “objects,” he also says that “a great idea is messaging.” He further writes :

OOP for me is just messages, local retention and protection, hiding the state and later binding everything. This can be done in Smalltalk and in LISP. There are probably other systems where this is possible, but I do not know about them.

In the early OOP, messages were largely considered important, primarily for servicing facilities. Here's how Don Ingalls explains OOP in his introduction to Smalltalk-76 :

Smalltalk is more object oriented rather than function oriented, and this often confuses people with experience in computer science. For example, compute +4means send to the +4object as a message. The main difference is that everything controls the object, not +. If it is an integer of 3, then the result will be an integer of 7. However, if it was a string 'Meta', the result may be Meta4. Thus, the semantic load goes along with the objects of the system, and the code remains an abstract form, simply directing the flow of messages.

In Microelectronics and the Personal Computer, Kay talks about a message-to-action system in which “every action belongs to a family,” and talks about expanding activities in the “point of view” of object relations as a future frontier. In the Smalltalk-72 manual, he writes (p. 18):

The main idea when writing Small talk programs is to define classes that handle the relationships between objects in the created environment.

When viewing early sources, the picture is formed that OOP consists of three main ideas: classes that define the protocol and implementation, objects as instances of classes and messages as means of communication. The idea that classes and objects were secondary to messages came much later.

Smalltalk was the first real object oriented language

ACM presented the Turing Premiere to Dahl and Nyugor, and called them "PLO co-authors." Byte also writes that Simula was object-oriented, and in the article "The Computer Revolution hasn't happened yet," Kay calls Sketchpad "very object-oriented." In my opinion, this does not recognize the merits of Smalltalk to the proper degree. Unlike other systems, in Smalltalk:

  • There were no objectless primitives: numbers were objects, errors were objects, classes were objects, messages were objects.
  • You could pass a message to any object, including other messages.
  • Methods and implementations were associated with objects, not with a session.

The last point is the most tricky and possibly the most important, although no one really explains what makes it so special. In Simula, invoking a missing method causes an error. This is part of the Simula specification. In Smalltalk-80, if no method matches the message, the default object returns a message doesNotUnderstand. The caller can respond to it, or pass a message on, or signal an error. A class can also override the default action and do something other than return doesNotUnderstand.

This also means that the messaging system does not depend on the internal structure of objects. They don’t even have to be part of one project. It follows that you can do such things as sending messages to objects written in different languages , sending object definitions by mail , sending messages via SMS, etc. In my opinion, this is precisely the power of "messaging", but at the same time it is one of the least studied aspects.

Smalltalk had an ambient context

People do not invent tools spontaneously. They have specific situations and tasks, and they are trying to find a solution to these problems. Innovations in Smalltalk and OOP are no exception.

Alan Kay was interested in the topic of personal computers. His work on FLEX, Dynabook, and Smalltalk builds around this. In his opinion, the PC should have been completely under the control of the user; everything, from the logic of the core of the system to the graphic rendering, could be set up and explored during operation. Message passing and late binding solve a number of problems. If a child installs a new game, do I need to recompile the entire OS to use the new program? No: make it possible to send an arbitrary message to any object and rely on protocol processing during work to complete the task. (*) If a person violates the logic of the sound system, should the entire OS fall? Of course not, so let the objects decide how to process the messages themselves. Objects perform well here.

Ole Dahl and Kirsten Nyugor tried to solve a completely different problem. They were interested in the simulation . One study in the Simula guide is modeling the spread of infection among a fixed population. The system is completely closed: you have a fixed set of code, you run the simulation and get the result. For them, messaging is useless. But the ability to define simulations in terms of other simulations, to specialize entities and model time as an object of the first class is incredibly useful. Objects also perform well here.

So who used the objects "correctly"? This is an unreasonable question. They did different things because they had different tasks. Our modern OOP idea is a synthesis of all their ideas, as well as the ideas of Adele Goldberg, Barbara Liskov, David Parnassus, Bertrand Meyer, Gul Ag and many others. But none of them can say what “OOP” is. Concepts evolve, as do tasks.

tl; dr

Interviews taken more than 30 years ago are not good sources.

* Perhaps this makes Powershell the spiritual successor to Smalltalk.

Also popular now: