Alan Kay Did Not Invent Objects | Hacker News Reader

Alan Kay Did Not Invent Objects

hillelwayne.com

34 pointsUkiahSmith13 comments

I think more interesting than 'who made X first' is 'what did X mean to A vs B'. So irrespective of whether Simula had objects first or Smalltalk did, the debate should be how Kay's perspective of objects was different than Simula's.

E.g. Kay wrote:

> Simula can't be praised too highly, and it was a huge influence. But if you take the care to check, you will find out that what I termed "Object Oriented" was quite different from Simula in (what I thought were) important ways. And if you are looking for the earliest inventions of ideas like these, there are several that predate Simula (take a look at that HOPL II chapter mentioned above)

(via https://news.ycombinator.com/item?id=15580308)

Some of the context is covered in the write-up, but there's more. E.g. one thing I hear from Kay is that objects are some kind of replacement for thinking about computing as procedures + data structures. And perhaps that we're still exploring the objects idea stuck into the old context (of procedures) rather than a new context of objects-only.

This article seems to imply without coming out and saying it that Alan has inflated his own historical importance or claimed to invent things he didn't. But anyone familiar with even a small portion of his writing and speaking knows how eagerly and thoroughly he gives credit to others, including Nygaard and Dahl. A couple out-of-context quotes picked out of 50+ years of work don't count for much when the overall record is obvious and clear. Therefore, what a silly molehill. There's no controversy here, why create it?

> There's no controversy here

Maybe you missed it. A lot of controversy over what Kay said, when he said it, how much "jurisdiction" he has over the use of the word "Object" by others, how often he gets to amend the definition of OOP, etc, etc... was on display recently. I understood the post by Wayne as a reaction to this recent outbreak of an ongoing controversy.

I'm not sure the article is implying anything about Alan. Hard to tell, there seems to be something missing in the piece.

But one thing the article does argue about is what can and cannot be called OOP. It seems completely reasonable to me to refer to Java, Python and similar languages as OOP languages. That is the current widely accepted meaning of the term (even though these languages might be more like Simula than Smalltalk).

It also seems reasonable to say that Kay's original ideas around OOP and their evolution and refinement (not sure if we can call it a definition) overlapped with these, but were on a different trajectory. One that perhaps has not been explored extensively.

I've been seeing this meme recently that object-oriented programming is not what we think it is, but rather that it's some other ethereal quality which does not exist as a paradigm in modern languages. Isn't it fair to say that object-oriented programming is what the huge amount of C++/Java/C#/etc programmers perceive it to be, rather than some ideal envisioned by dead languages like Smalltalk and Simula?

Well, as a C++/Python/C# programmer, I see it as a combination of ways to

(a) organise procedural programs using language features that make abstract data types more powerful,

(b) obfuscate procedural programs using language features that make abstract data types more confusing.

If there is in fact some other, non procedural, paradigm called OOP that we can learn about, then maybe dead languages are the place to look for it.

One reason for distinction is that you'll get people who say "OOP is a good way of designing systems" and "OOP sucks" and one might not be aware of the other.

Generally I see "Java isn't OOP" followed by "OOP is about the messages". Somehow no better name has caught onfor this.

While I agree that at some point we need to accept that the meaning of a term is not what it was envisioned but how it is perceived, just look how "we" use the term variable and how it is used in math, I completely disagree with saying that Smalltalk is a dead language. Maybe not mainstream, but still alive with a driving community.

The reason folks are concerned about the use of the term is that earlier systems that were described as OOP (like Smalltalk) are blamed for the sins of later systems that were also described as OOP and became more popular (like Java).

This coincides with other problems. Smalltalk is actually a better language for iterative development than Java, and a big part of that is the focus on messages rather than more fragile forms of code-reuse like inheritance. Java's popularity is based on heavy marketing & manipulation of school accreditation committees by Sun, rather than by its actual applicability to any real programming task, & Smalltalk fans justifiably feel persecuted (and, less justifiably, want to take back control over a term that they feel has been abused by its application to Java).

It's not a matter of ideals versus reality. Smalltalk actually exists, people actually write code in it, and Smalltalk-style object orientation is a real, consistent, well-documented approach. This is a matter of spin: in recent memory (the late 80s), object orientation became trendy because of Smalltalk (the same way that functional programming is trendy now because of Haskell), and the response is that big companies (IBM, Microsoft, and Sun) through their weight behind trying to redefine it so that they could apply it to already-existing or already-under-development products in marketing materials without making substantial changes. These products would not have been considered object oriented to people at the time without a concerted effort to dilute the meaning of the term (in much the same way that people are busy trying to redefine 'blockchain' and apply it to everything in order to scam people who are willing to invest in anything vaguely associated with bitcoin).

Smalltalk users have pushed against this redefinition since it began, & I think a lot of Kay's later emphasis on messages is because C++-style object orientation (as adopted by Java and C#) doesn't support messages & as a result lacks the most characteristic features of Smalltalk-like OO systems.

(There's another issue: Smalltalk-style OO systems are actually easier to implement, and so the number of languages with this kind of OO system is actually much bigger than the number with C++ or Java style OO systems. These languages tend to be small & obscure -- objective c and smalltalk being most popular of the bunch -- and many more people code in C++ or Java because that's what the AP CS tests are required to use, leading to newbies thinking C++ style object orientation is representative, and leading them to go on to prefer languages that are actually worse for their productivity.)

Wayne here brings up an important point: that object orientation under simula doesn't look much like object orientation under smalltalk, & neither looks like C++. What seems like an argument over terminology is actually an argument over best practices by two crowds who are both emotionally attached to the same term, but use them to describe two different things. (Nobody is emotionally attached to Simula's idea of OO. Unlike Smalltalk, Simula actually is dead.) If we reframe it as an argument over best practices, then Kay's crowd wins hands-down, as anyone who has written a medium-to-large project in Java or C++ can attest.

Also, note:

One way to interpret Kay saying "I invented objects" is that he is claiming to have invented the first conception of objects that anybody gave a damn about (which is absolutely true).

Even though C++ doesn't have anything Kay would call an object, the reason C++ exists is that C programmers were jealous of Smalltalk. (Again, while C++ is more popular, objective C actually looks & acts sort of like Smalltalk & provides some of the benefits -- C++ is something basically unrelated that appropriated the ad copy in order to cash in on the hype, though only actual Smalltalk users would have been able to call Stroustrop's bluff in the 80s.)

Kay's 1993 writeup on Smalltalk history is a worthwhile read, if you're into OO, PL, or computing in general. He gets into his 1966 exposure to Simula.

http://worrydream.com/EarlyHistoryOfSmalltalk/

But did invent the term "Object-Oriented Programming"

The article covers this. Unfortunately the title is trolling click-bait.

Reply on news.ycombinator.com