[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Jonathan Rees on OO

   Date: Wed, 12 Dec 2001 10:17:05 -0500
   From: Jonathan A Rees <jar1@mumble.net>

   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.

		   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

   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.