Re: Ada Operating System

["Marin David Condic" <dont.bother.mcondic.auntie.spam@[acm.org>]

Oh sure. I'd agree - I just don't want to get caught making extraordinary
claims that start the whole "Any Competent C Programmer Would..." kinds of
debate. While Ada is busy checking mundane kinds of things, its likely to
surface higher level mistakes. If you're tripping over all sorts of type
conflicts, for example, it probably means you need to revisit your design as
possibly needing some additional thinking. Or it might make it clear that
someone is misusing a structure in some way that reflects incorrect logic.
People often say "If you get an Ada program past the compiler, chances are
it is correct..." - but I just don't want to claim that this is, of
necessity, so.

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


"Tucker Taft" <stt@avercom.net> wrote in message
news:3C961352.DE25ADF1@avercom.net...
>
> I would go a bit further than that.  It is true that Ada is very good at
> catching "stupid" errors like leaving out a semicolon, misspelling an
> identifier, swapping the order of parameters, indexing with the wrong
> variable, etc.  But the surprising thing, once you start using a language
> like Ada, is the number of "subtle" errors that it catches.  May favorite
> analogy is that of trying to ski down a ski slope.  If there are is just
> one (slalom) gate on the slope, pretty much anyone can make it through the
gate
> and down the slope.  However, once you get a few dozen gates, you have
> to have a "deeply correct" understanding of skiing to make it through
> the "gauntlet," even though each gate is checking something "trivial."
>
> In the same way, Ada throws up several "gates" on every line of the
> program, both picky compile-time checks, and run-time checks for things
> that can't be proved correct at compile-time.  The actual number of
> checks performed compared to languages with a weaker typing model
> is quite impressive when you start counting them.  All of these
> checks are of the "mundane" variety, but the combination of them
> all creates a gauntlet that, typically, only a "deeply consistent"
> program can satisfy.  The empirical evidence is that a program
> written in a language with as many consistency checks as Ada, once
> it makes it through the compile-time and run-time gauntlets, is much
> closer to being "correct" than a program with a weaker gauntlet
> to pass.  And the overall time required to bring a program to the
> desired level of quality is significantly less because of these
> gauntlets made up of "trivial" checks.
>