Ada safety road Was: Which is right ...

["Vladimir Olensky" <vladimir_olensky@yahoo.com>]

Robert Dewar wrote in message <7jb1l9$694$1@nnrp1.deja.com>...


>And to repeat, since you keep repeating the subject, both
>GNAT and OA are right here, and do what the RM intends!


Sorry, It just didn't come up to my mind to change the subject.
Even original subject was not very adequate to what I had in mind
I really did not had intention on insisting which is better in following RM.


I had other things in mind.


I was just thinking about different aspects of providing some
general kind of "foolproofness" to program written in Ada in places where RM
define program behavior as erroneous.
I think nobody would like to be on a plane that performed erroneous flight
"""' ' '  ^~\_+.
Anyone would prefer to be accidentally on board of the wrong flight instead.

One good aspect of Ada is that when it is impossible to provide compiler
solution to some problems (due to implementation cost and some other reasons
that may not be  very obvious) LRM at least honestly specifies situations
when erroneous execution is possible.

But  I see  one problem here.  All this information is scattered around  RM.

I think that to facilitate safety programming such info should be gathered
into one paper
with explanations why it was not possible to overcome such situations  and
it should contain many examples covering different aspects that leads to
erroneous execution. There should be no indirect references ("other then
...."). Everything should be directly described  and should be as simple as
possible.
I see it as some kind of "Ada safety programming roadmap".  And of course
such paper should be easily available online for all interested in it. So
far I have not seen such document available online .
If you crossing mine field and you do not have good map with red marks on it
all your life depends on your luck :-)
Such type of documents are usually top level  documents in design of any
safety critical system (at least it was in my experience).

I recently put  together all that staff  from RM  and I should mention that
this list is not very short.
So I was wondering if it is possible to do something on compiler level to
make this list shorter.

Almost five ears left since adoption of Ada 95  standard. Computing power
has increased almost tenfold since then (CPU speed, memory access time,
memory density etc.).  Some things that were costly to implement then may
have much less cost now.

Here I would like to add one more thing.
In many disputes Ada is described as mostly reliable language which allows
to catch almost all errors at compile time and others at a run time by
raising exceptions. This can  create some kind of trap for those starting to
use Ada ( to forget about cases of erroneous execution or not to pay
attention to them)
(e.g. typical comparisons between  C&C++ and Ada pointers from which the
reader may have wrong impression that Ada fully safe in this respect and as
a result not to pay proper attention to that issue. For me the most safe in
this area  is Modula-3 for very well known reasons).

Regards,

Vladimir Olensky