Re: ADA Popularity Discussion Request

[kevin.cline@gmail.com (Kevin Cline)]

Georg Bauhaus <sb463ba@l1-hrz.uni-duisburg.de> wrote in message news:<ch1q7n$q56$1@a1-hrz.uni-duisburg.de>...
> Kevin Cline <kevin.cline@gmail.com> wrote:
> 
> : Perhaps more importantly, how to write programs without 
> : the array and the for-loop.
> 
> I'd agree with you if this weren't about Ada arrays.

> True, some programs with little to no support for "true"
> arrays still show arrays where sets, maps, lists, etc.
> should be, using that language. But then I always miss the
> close connection of Ada's enumeration types and Ada's arrays,
> and Ada's predefined operations of array types.
> 
> Ada enums allow me to name things known at compile time. In addition,
> Ada arrays made with an Ada enum as index type can be used like
> a map. Due to the index type mechanism, completeness checks
> are made at compile time. For example, an array aggregate
> must be completely specified. A case distinction looking at
> a value of an array's index must handle each case.
> 
> Ada arrays can also be used like lists, with concatenation predefined,
> and with a NIL (null range). Using any number of dimensions.
> 
> They can be used with generic array algorithms, with built
> in bounds checking and loop index optimizations.
> They can also be used with STL like array algorithms when
> there is a simple adapter that makes them look like a
> container.
> 
> Bounds can be determined and set at run time, like index
> subtypes.
> Arrays can be returned on the stack, allowing typical recursive
> list processing subprograms. No for loops required. :-)

No doubt that Ada has fabulous support for integer-indexed arrays.  

Still, in my experience what is most often wanted in applications is
not an integer-indexed array, but a map or set.  In 25 years of
programming I have seen about 17,000 implementations of linear search
and 5,000 implementations of sorted insertion, almost all of which
could and should have been eliminated by using an associative
container of some sort.

I've seen large applications where over half the code was devoted to
looping through arrays in one way or another.  I've seen multiple
instances where someone had written array-based code with O(n^3)
run-time while vastly simpler map-based code would have run in O(n)
time.

By providing extensive facilities for array-based programming while
ignoring all other data structures, Ada leads most programmers to do
the wrong thing, and frustrates most of the remainder.