Re: SOS: Simple Object System

[Clinton Ebadi]

"Maciek Godek" <address@hidden> writes:

> The other is that in GOOPS a method is something
> different than what is commonly known in OOP, because
> a class doesn't know its methods (and furthermore,
> methods can be created at any time of program execution,
> not only during class definition). I'm not saying that
> it's good or bad (but it's quite confusing when a few similar
> but different notions share one name)

Interestingly enough, CLOS predates C++ and Java ;-)

Separating classes and generic functions makes the language more
powerful--now two orthogonal concepts may be combined in arbitrary
ways. The classic example of having generic functions are multimethods
wherein you can dispatch on the type of every argument of the
generic. A simple example of this is the (simplified) present method
from CLIM:

  (define-generic present (instance view))

Which then allows you to do nifty things like:

  (define-method (present (instance <image>) (view <text-view>))
     (format #t "[~A]" (alt-text-of instance)))
  (define-method (present (instance <image>) (view <graphical-view>))
     (display the image somehow))

etc.

Doing this with a single-dispatch system is much less aesthetically
pleasing. Note also that multimethods are only one of many advantages
to having generic functions--they also enable method combinations and
a few other things. Stylistically, they make the OO system integrate
cleanly with the rest of the language rather than having its own
specialized syntax for method invocation.

> There is also another issue concerning the fact that
> methods are available in global namespace -- the
> performance of the interpreter is always penalized
> by the type lookup (obviously, this doesn't have to
> be the case if the code is compiled)

Type lookup in GOOPS should be very fast--there are a few fairly
simple implementation techniques that more or less eliminate the
overhead of method dispatch (or at least turn it into a few very low
overhead table lookups). /The Art of the Metaobject Protocol/ is a
good inexpensive book that gives a decent overview of how to implement
a fast CLOS.

> But the most important feature of OOP that is missed
> in GOOPS (because of global namespace methods) is the lack
> of the clean separation of interface and implementation
> in the way it's done in java, C# and the like.

Actually, CLOS/GOOPS are perhaps the cleanest way to separate
interface from implementation. You define a protocol as a set of
generic functions and define methods upon them -- with no concern for
the actual classes used with the protocol.

In this way you can do implementation sharing via class inheritance or
something akin to Java interfaces (if I understand them properly; I
refuse to use such a language) and implement the protocol for
arbitrary classes without having to arbitrarily force them to inherit
from unrelated classes.

-- 
Jessie: i stuck the phone antenna up the dogs nose and he ignored me