Re: ADA Popularity Discussion Request

["Richard Riehle" <adaworks@earthlink.net>]

"Kevin Cline" <kevin.cline@gmail.com> wrote in message
news:e749549b.0409051449.574ec9ce@posting.google.com...
> Kilgallen@SpamCop.net (Larry Kilgallen) wrote in message
news:<vpblkhspuA9F@eisner.encompasserve.org>...

> > But assuming perfect testing, finding the errors during compilation
> > rather than in testing saves me time, and time is money.
>
> I thought so too, until I tried incremental test-first development.
> Retesting a unit after adding a few lines of code means that type
> mismatches are caught immediately with or without strong typing.  But
> it goes faster if you don't have to compile and link every iteration.
>
This assumes that we are concerned only with type mismatches.   In
Ada, we expect the compiler to provide a great deal more than that.

For small software systems, frequent testing can often be sufficient. As
the size of the software increases, and complexity of that software grows,
we must engage all the tools available and use them appropriately to
ensure the correctness of our design.   Also, in large software systems,
it is not possible to test every path, every possible value of a variable,
and every potential timing problem.

How does one test for a race condition?   Does that test guarantee
no race condition can occur?    This is not a type checking issue, but
it is a design issue where the type model can be one of many factors
in reasoning about the stability of the design.

How does one test for a runaway pointer or dangling reference?  Again,
this is not strictly a type issue, except that Ada's overall set of rules,
including the type rules, provide some tools for reasoning about this
intelligently.

Finally, testing can only test for what we know needs to be tested.   We
must design for the unexpected, even as we test for the expected.  It is
impossible to test for the unexpected.   The Ada type model includes
both the compile-time checking and the run-time checking.   The rest
of Ada provides a wide range of compile-time checks.

Those who fail to understand this should stay away from building software
that requires a high degree of dependability.

Richard Riehle