Re: Ada is getting more popular!

["Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr>]

Le Sat, 30 Oct 2010 02:01:46 +0200, Vinzent Hoefler  
<nntp-2010-10@t-domaingrabbing.de> a écrit:
> The problems start with the dynamic properties, where the operations on  
> the
> types can not be resolved statically anymore, because these are very hard
> to prove for correctness. They may even call subroutines which are  
> completely
> out of the scope of the unit you're calling it from.
>
> And if you don't want (or are not allowed, because the Software  
> Programmer's
> Manual says so) to use class-wide programming, then there's usually no  
> point
> in using inheritance at all. ;)

To be more precise or exact, you may have missed to point the area these  
comments applies to. I guess this is right for some requirements (you  
talked about a manual, seems to contains restrictive requirements). Say  
it's universal is less obvious.

As an example of your objections, you said “They may even call subroutines  
which are completely out of the scope of the unit you're calling it from”  
: sometime this what is expected to be possible, most commonly with  
scripted application (which can extended with script). Better say this can  
occurs while it was not expected. Said this way, I would agree.

In areas, like UIs, if you avoid inheritance (and dynamic dispatching) you  
ends up with thousands of different types (the same applies with languages  
oriented applications, graphics oriented, and others). Ancestor-types  
helps to handle this proliferation of types. This is not always  
predictable when operations comes into the place, I agree, and weither or  
not it is, depends on the design, and is not at all enforced by the  
paradigm, agree too.

May be inheritance is dedicated to large complex set of types and  
composition where it needs to be predictable.

I've understood you complained, not about inheritance and rather about  
dynamic dispatching. But when inheritance come, dynamic dispatching is  
near to be there, just because if there is inheritance, you have to say  
what the operations associated to these types will become as inheritance  
goes (you can also make them all frozen, or never use class wide types,  
true).

I am not asserting anything, these are just some thoughts (did not  
finished to read the lectures suggested by Jean-Pierre, as I get into  
troubles with a modeling application in the while, sigh).

As another question to feed the talk : will you see a way to handle large  
set of types with composition ? Does composition provides another way to  
group by similarities and handle these groups as a whole ?

Now back to J-P's lectures.

-- 
Si les chats miaulent et font autant de vocalises bizarres, c’est pas pour  
les chiens.