Re: Teaching new tricks to an old dog (C++ -->Ada)

[Georg Bauhaus <sb463ba@user1.uni-duisburg.de>]

Ioannis Vranos wrote:
> Georg Bauhaus wrote:
> 
>> Compare log(10^6) to 1.
>>
>> I can't see how O(log(n)) isn't huge when compared to
>> O(1), in an inner loop for containers of size 10^6.
> 
> 
> OK, but besides the fact that only explicit entries in map occupy space,

Yet another issue having nothing to do with how
Ada arrays compare to C++ style arrays when the problem
requires plain arrays, not sparse arrays.

> Also, as I said it is not difficult to define an array that takes 
> arbitrary signed ranges, but this does not make much sense in C++.

Any evidence?


> In other words, the direct equivalent of your array is probably 
> valarray/vector, ignoring the signed ranges.

"ignoring" seems to be an attitude in your responses. ;-)

 > built-in arrays, which means is not of much  use.

Do you know what a built in array really is, and what it does?


> Also the lack of a "STL like" library in Ada until now probably sounds 
> like that Ada lacks much of the high-level abstraction that C++ provides.

Oh, come on. You are making claims about a language and
then guess about it? For many things a library was just not
needed in Ada. The language already provided what was needed,
including the high level of abstraction.

I've tried to picture the higher level of abstraction
in the Ada base type system that is just not present in C++.
For example, there is no need for .begin() and .end() in Ada
because it has always had these as attributes. In Ada it has always
been possible to write a generic array algorithm simply by requiring
that the G in <typename G, ...> is of an array type. There was
no need to add the hot new things like Can_Copy because they
were already in the language.

There have always been well designed ADT libraries (including
graph support). One of them has actually been ported from Ada 83 to C++,
and later to Ada 95 (Booch components).

Come to think of it, I don't know of anything like task *types*
and shared variable *types* built into the language C++.
This is right under your nose as high level abstractions
in plain Ada program structuring.

�C++ adds concurrency support to the C++ type system, at a somewhat
lower level of abstraction than Ada.
Still, �C+++ reimports the weaknesses of the precursor languages.
Sad, but successful because of mass momentum.

Georg