Re: Ada Popularity: Comparison of Ada/Charles with C++ STL (and Perl)

["Robert Kawulak" <tigrisek@interia.pl>]

Hi,

>>> This "same interface" is not a language object. It is a fiction, which
>>> cannot be described in language terms independently on its
>>> implementation.
>>> So you physically unable to program in terms of this interface. It
>>> simply
>>> does not exist.
>>
>>   It's not a fiction, it's a kind of agreement. The language doesn't see
>> this interface directly, but you can use it. And if you try to violate it
>> in
>> a place where conformance to this interface is crucial, your program
>> won't
>> compile.
>
> Yes. For *you*, it is not a fiction, because you know its semantics. The
> problem is how you communicate your personal percept of semantics to other
> people. It is what a language all about...

    Similarily, I could say that Ada has no classes. Of course it has
packages, tagged records etc. but no true classes with true methods. Classes
in Ada are just as fictious as interfaces in C++ template metalanguage, yet
it doesn't mean you can't use OOP in Ada (and interfaces for templates in
C++).

> Templates constitute a meta-language. That is
> inherently bad, provided there is a way to solve the problem within the
> native language (maintaining a reasonable level of expressiveness).

    I'm afraid that our discussion will never reach its conclusion ;-) The 
reason is our opposite approach to templates and using them to implement 
containers. Of course everything that is done using templates may be as well 
done without them (although not always so easily). The point is that in many 
cases they simplify the design and, what is crucial for C++, they provide 
containers with efficiency. There's no need for dynamic binding, wrappers 
and those ugly downcasts :-P. Statically and dynamically polymorphic 
containers are just two different points of view, two different 
philosophies. It's nearly impossible to objectively say which one is the 
proper, for it depends on what is important to you. Both approaches have 
pros and cons (as we both tried to show in all our posts) and both aren't 
ideal in all cases. I think C++ chose the templates approach because it's 
closer to C++'s 'spirit' (don't pay for what you don't use, make built-in 
and UDTs the same etc). For contrary, Java has taken the opposite approach. 
And you are forced to use dynamic dispatching and downcasting, which doesn't 
sound attractive to me (at least you don't need wrappers, because Java 
object hierarchy is single-rooted).
    Anyway, I promise to have a look at the links you've provided (thanks), 
I'm sure I'll learn something new.

> Ada has S'Class'Input attribute (ARM
> 13.13.2) which represents a factory pattern. Basically it reads the type
> tag from stream and then dispatches to an appropriate constructor, which
> is
> *guaranteed* to exist. The result is a class-wide object.

    Good to know ;-)

Best regards,
Robert Kawulak