Re: Ada vs Eiffel - Ada programmer approach

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Thu, 4 Jun 2009 02:02:01 -0700 (PDT), Ludovic Brenta wrote:

> Yannick Duch�ne wrote on comp.lang.ada:
>> On 26 mai, 20:21, "Jeffrey R. Carter"
>>
>> <spam.jrcarter....@nospam.acm.org> wrote:
>>> I agree. I never create tagged types, except to obtain finalization. I think the
>>> widespread acceptance of programming by extension, even by People Who Should
>>> Know Better, represents the triumph of those who emphasize ease of writing over
>>> ease of reading.
>>
>> So how do you do extentions ?
>> Did you never need this ?
> 
> The question is not really "how do you do extension", but "why do you
> do extension".

In order to reuse the interface and some implementations of these
operations.

> In my experience, composition is usually a more correct
> choice.

It is not a choice because composition inherits to the record type
interface and provides an implementation of the interface (e.g. member
access, assignment of the record etc). In a more general case composition
inherits to the container interface.

So the question is why do you inherit to the container rather than to
number, task, file, employee etc?

> There are, of course, some cases where extension is good but
> my inheritance hierarchies are usually very shallow.

Extension /= inheritance. It is a case of inheritance.

There is nothing that could replace inheritance, because there is no way to
"invent" a new type out of nothing. Whatever type algebra operation you
take, it always uses some building blocks (the arguments) from which you
inherit the interface of the result. There is nothing really useful beyond
inheritance. Even if you use the minimal possible type-algebraic operation
in Ada:

   type T (<>) is limited private;

you still inherit a lot of things. For example attributes, like X'Address.

> For example, if you want some record type T to become controlled, you
> don't have to make extend Ada.Finalization.Controlled; you don't even
> have to make T tagged.

All types are "controlled" in Ada, in the sense that they are properly
finalized upon destruction.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de