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

["Randy Brukardt" <randy@rrsoftware.com>]

"Kevin Cline" <kevin.cline@gmail.com> wrote in message
news:e749549b.0409241112.44f4bc85@posting.google.com...
...
> Ok, although it's not readily apparent to me why implicit
> instantiations are inherently unsafe.  Nor do I believe reference
> expressions like
>    concordance[word]
> are inherently unsafe.  Storing the reference in a variable that may
> outlive the referent is unsafe, but I don't see why this is different
> from Ada access types.

It isn't different than Ada access types, that's the point. Access types are
inherently unsafe and should be avoided when possible. (But not to go
overboard, of course.)

That's an important design issue when designing reusable libraries. My
personal rule is that such libraries should not contain access types of any
kind in their specification unless they are doing something that requires
dynamic management of objects. (That's rather rare.) In Ada, there is no
need to use access types to get OOP or to get objects sized at runtime --
those uses are common in other languages.

Ada goes to fairly great lengths to try to avoid dangling pointers (the
dreaded accessibility rules), so access types in Ada are a bit safer than
those in some other languages. But that doesn't make them safe by any means.

In this particular case, the access would have roughly the same erroneous
use rules as a cursor does, which wouldn't be that awful. But it wouldn't be
a very good example of Ada design, because the library would return an
access to a data structure that is managed by other code -- which cannot
know whether any accesses remain -- so it would be impossible to be safe.
(I'm intending an implementation of the containers library that will try to
detect dangling cursors, so there will be little chance of building buggy
code with it.)

                                 Randy.