Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: $Revision: 1.6.2.16 $; site ada-uts.UUCP
Path: utzoo!watmath!clyde!burl!ulysses!allegra!mit-eddie!think!ada-uts!richw
From: richw@ada-uts.UUCP
Newsgroups: net.lang
Subject: Re: Orphaned Response
Message-ID: <15100023@ada-uts.UUCP>
Date: Sat, 25-Jan-86 21:28:00 EST
Article-I.D.: ada-uts.15100023
Posted: Sat Jan 25 21:28:00 1986
Date-Received: Thu, 30-Jan-86 00:23:51 EST
References: <26@hplabsc.UUCP>
Lines: 49
Nf-ID: #R:hplabsc:-2600:ada-uts:15100023:177600:2170
Nf-From: ada-uts!richw    Jan 25 21:28:00 1986


"What does 'object-oriented' mean?" is a good question.

I thought I knew, but now I'm not so sure.  I tend to use
the term to describe a style of programming (and hence
avoid getting into trouble with those that know it's "real"
meaning).

Something which has recently affected my feel for the term
is the difference between the way procedures are called in
Smalltalk and in C/Clu/most-other-languages.  In the latter,
the basic conceptual "execution-step" involves looking at the
name of the procedure being called, finding the code for it,
and executing it.  In Smalltalk, one FIRST looks at the OBJECT
which is "receiving a message" (a message is roughly equivalent
to a procedure name), then finds that code for that message
in the list of messages defined for that type of object.

The latter makes it somewhat easier to write code which
will call one version of procedure "foo" when dealing
with an object of type A, and another version of procedure
"foo" when dealing with an object of type B.  Emphasis on
the somewhat, though; I'm not sure.  In Smalltalk, it seems
easier to do this because type-checking is done at
run-time.  Nevertheless, you can do the same in the other
class of languages (where the execution revolves around
finding the code based on the procedure name).

In Clu and Ada, there are the notions of "parameterized
clusters" and "generic packages", respectively, which
help you write "generic" procedures.  I'd rather not go
into further detail, though.  Note that the type of
an object will influence the "lookup of code" (since
procedure names in these languages are prefixed by type
names or package names) in Clu and Ada, but my point is
that this is conceptually different than what happens
in Smalltalk.  Smalltalk seems "more object-oriented"
because the type of the object/receiver determines the
code executed by a procedure-call/message-pass.

Isn't it wonderful trying to talk about different langauges
with different terminologies for similar, but not-quite-
the-same semantics.   :-)

Sorry if this was impossible to read.  This was written
rather hastily.  Hopefully some of you got the gist.

Dazed-and-confused,
Rich Wagner