Re: Any research putting c above ada?

[clines@delete_this.airmail.net (Kevin Cline)]

"John G. Volan" <johnvolan@sprintmail.com> wrote:

>Kevin Cline wrote:
>> 
>> Alan Brain <aebrain@dynamite.com.au> wrote:
>> 
>> >Simple really, and a real example. Nary a pointer or access type
>> >anywhere.
>> 
>> Someone has to manage that storage.  Presumably in this case it is the
>> run-time library.  So the pointers exist in the generated code, even though
>> hidden from the user.
>
>Nope, you're in the weeds here. A mutable record (discriminated record
>with default initialization on the discriminant(s)) can be implemented
>by simply providing it with enough space to house the largest possible
>variant. It might not use all that space all the time, but it won't have
>to allocate/reallocate anything.
>
>Bottom line, if you declare one of these beasts in the ordinary way,
>your Ada compiler can certainly allocate it on the stack, and pass it
>back and forth on the stack.

Of course, that's trivial to do, and extremely impractical if the object is
usually small but can occassionally be very large.   Remember the original
problem that started this thread?  The poster claimed that it was easy to
write a program that read a file into an array of lines since Ada allowed
arrays of size determined at run-time to be returned as function values.
The I pointed out that:

1. Most files do not begin with a line count.  That's certainly a ridiculous
requirement for manually prepared input.

2. Returning such an object is very inefficient because most compilers copy
the entire object.

Now you tell me that variable-length arrays can easily be handled in Ada
without dynamic storage allocation.  But then you indicate that the arrays are
not truly variable in size, but are restricted to a compiled-in maximum size.
That's fine for embedded applications where the amount of data to be handled
is carefully defined ahead of time.  It's useless for desk-top applications,
where the size of the data to be handled, and the physical resources available
to handle it vary widely from user to user.  For those applications, you must
resort to truly dynamic data structures, and Ada's arrays are of little use.

This is one of the biggest blind spots I observed in experienced Ada
programmers in a shop a few years ago.  Ada programmers tend to use arrays
instead of more dynamic data structures, resulting in inefficient and
inflexible applications.  OTOH, I have observed that the availability of the
C++ STL containers is already expanding the toolkit of average C++ developers.