Re: GNAT for MS Visual Studio

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

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 2526 bytes --]

"Pascal Obry" <pascal@obry.net> wrote in message
news:4707A3D0.3070702@obry.net...
> Matthew Heaney a �crit :
> > No, this is incorrect.  The container keeps track of nested calls
> > (e.g. Query_Element, Iterate) using a count, in order to prevent
> > container misuse (e.g. deleting the element while it's being
> > queried).  So even though the logical view of the container doesn't
> > change, then physical view does change, and so the standard requires
> > that multiple tasks accessing a container must be properly
> > synchronized, even when the access is read-only.
>
> Outch! Big mistake to require this to me :(
>
> Maybe something like "Don't let best be enemy of good" !
>
> That's probably the first time I'm very surprised and annoy by an Ada
> design decision. It seems that there is good reasons... but frankly not
> something really user friendly to me :(

If you want dangerously unsafe containers, you are welcome to write them
yourself. But they don't belong in the standard (surely not as the sole
example of containers).

For me, the most important advantage of the containers is that they can be
made safe (in the absence of unsafe operations on an object containing a
container). It's not necessary to have any operations that fail to detect
dangling cursors and the like -- this is a big advantage over directly using
access types to create a list or vector. But such implementations require
housekeeping even for reading.

Similarly, the case that Matt mentioned would make it trivial to have
undetected errors that could cause serious trouble down the road. We were
explicitly asked to minimize the cases of erroneous execution (that is,
totally unpredictable result); it's quite possible that the containers would
have been rejected altogether if we had not followed that recommendation.

The implementations that I've been planning to use for the containers would
require locking in order to provide any task safety -- meaning that I would
have had to either give up on safety or performance -- not a good trade-off.

The containers having different rules than those for *all* other Ada
libraries (including things like matrix operations) would be weird, to say
the least.

Anyway, the point is that a lot of thought and debate went into this
decision. We also started a project to create a set of protected containers
for multitasking use (not much is happening with it, though, as its priority
is lower than the ASIS update and fixing bugs in the standard).

                      Randy.