Weinreb and Moon Respond to JAR on Object-Oriented

Date: Sun, 16 Dec 2001 01:54:28 -0500 (EST)
From: Dan Weinreb
To: Jonathan Rees [and others]
Subject: Re: Jonathan Rees on OO

Date: Wed, 12 Dec 2001 10:17:05 -0500
From: Jonathan A Rees

If CLOS and Dylan claim to be OO, then their definition of OO has to be Lisp's (c, above). But they obviously aren't OO in the Simula or Actors senses.

Gee, it seems to me that CLOS and Dylan have so much in common with Simula and Smalltalk that it makes sense to use the term "object-oriented" to cover all of these languages in the same sense.

That is, to me, it seems that if you take a simple example Smalltalk-80 program that you'd use in a tutorial to explain the basic ideas of "object-oriented programming" in the sense that Smalltalk-80 means it, then you could translate that into CLOS in an extremely straightfoward way and the tutorial would make just as much sense and would teach the same teachings.

I guess when you compare the two, you are focusing on different aspects than I am; it must be one of those things like glass-half-full vs. glass-half-empty or the Necker Cube effect.

JAR: This is exactly what you like about them. But the terminology confusion may contribute to the lack of acceptance of generic functions in mainstream languages. You are trying to invade linguistic territory (the space of the meaning of "OO") where you're not wanted. I can see why you'd want to do that, since OO has such cachet, but perhaps a different buzzword would be in order.

"Generic Object Oriented", as proposed in later mail, might be a workable compromise.

JAR:I don't know how to trace the precedent of the Lisp definition. My hunch is that it's relatively late, perhaps having to do with Hewitt (1974) and/or the growth of new types (yes, "object" types) in Maclisp and Interlisp. When I was at MIT in 1979 the term "object" still felt new and stylish. But no one said Lisp itself was object-oriented that I can remember, until maybe Sussman and Abelson's course came along (scholarship anyone?).

Speaking for the Maclisp/Common Lisp world, we did not use the phrase "object-oriented" until we first learned about Smalltalk. That would be Smalltalk-76; we learned about it in, I think, the summer of 1977. We were all quite psyched as soon as we figured out what it was about, and lots of us started prototyping various Smalltalk-like things in Lisp. You saw Lisp code running around looking like

  (send stream 'read)
  (<- window 'redisplay)
The "<-" was supposed to indicate an arrow. The idea that the first element of the form would be a symbol denoting the method didn't come along until later. We had been using the word "object" previously just to mean, basically, that which could be passed as an argument or returned as a value, or that to which a variable could be assigned. And a lot of us kept using it that way. I am pretty sure that the Lisp Machine Manual consistently maintained that a cons cell was an "object" despite the fact that you could not add methods to "cons cell". So we clearly went for many years using the word "object" in two different senses, based on context, obviously not what one would do if one had designed everything (language and terminology) from a clean slate. Carl Hewitt was using the word "actor" but I am pretty sure he was not using the phrase "object-oriented", at least not before the news about Smalltalk hit.

Subject: object-oriented
Date: Fri, 18 Jan 2002 13:10:13 -0500
From: "David A. Moon"
To: "Jonathan Rees" [and others]

Re http://www.paulgraham.com/reesoo.html

When I say object-oriented, I am often referring to yet a different property, which I think is a good property for most languages to have. It's not the same as your "5.Everything is an object" although it might sometimes be called "Everything is an object":

Things are independent of their names. To put it another way, as much as possible of the machinery is exposed as an object that gets named by binding an identifier to it, and you operate on the object, not on the name. Classes work this way in CLOS, they don't work this way in C++. Modules work this way in Dylan, modules (packages) don't work this way in Common Lisp, modules (packages) almost but don't quite work this way in Java. Method invocation works this way in CLOS (generic functions are objects), it doesn't work this way in Smalltalk and Objective C (method selectors are like Lisp symbols). I think most things done in Scheme work this way.

Arc probably follows this principle even though you claim it's not object-oriented.

One advantage is if you don't like the name of something you can rename it by manipulating identifier bindings; there are no or few reserved words. (I decided that "reserved words" are words that we don't want to hear our children say.)

Another advantage is you can make things anonymous. It also might become easier to expose the guts of the language for extension by users ("meta objects").

Another advantage is the language gets the conceptual simplicity that comes from making things orthogonal. I think that is the real advantage.

--Dave Moon