Re: Cumbersome Polymorphism

[bobduff@world.std.com (Robert A Duff)]

In article <5c9put$48t@hetre.wanadoo.fr>,
J-P. Rosen <Rosen.Adalog@wanadoo.fr> wrote:
>Richard Irvine <irv@eurocontrol.fr> wrote:
>>Before using Ada I used Smalltalk.
>>A Smalltalk variable can hold an instance of any class.
>>Of course, this is possible because a Smalltalk variable is just 
>>a pointer to dynamically allocated storage.
>>The important point though is that the pointers and the problems of 
>>allocation and deallocation are hidden from the Smalltalk programmer,
>>while the Ada programmer is obliged to be (painfully) aware of them 
>>much of the time.

The problems of allocation and deallocation are hidden from the
Smalltalk programmer (and from the Ada programmer, if you can find a
garbage-collected implementation of Ada, which isn't easy).  But the
pointers are not hidden in either language: The fundamental thing that
makes a pointer a pointer is that two pointers can point at the same
thing.  This is what makes pointers useful.  And this happens in both
languages, despite the fact that dereferencing the pointer is always
implicit in Smalltalk.  In Ada, you are forced to use a pointer if you
have something that changes size, and this is indeed unfortunate from
the functionality point of view.  In Smalltalk, you are forced to use a
pointer ALWAYS, and IMHO that's even more unfortunate.

Note that in Ada, if you have to use a pointer for low-level
implemenation reasons, like the fact that the thing changes size, you
can hide this fact from clients.  You can't do that in Smalltalk, if I
remember correctly, since assignment in Smalltalk is always allowed, and
always means "copy the pointer" -- there's no simple way of preventing
the client from evilly making aliases.

- Bob