Re: Have you ever had a bug caused by...

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

The point is fair, but usually what gets considered a "Bug" is something
that makes it out of development and is discovered during some kind of
formal test or into a fielded system. The developer going through the
edit-compile-link-run development cycle and generating an error in the
process doesn't really count as a "defect" in the end product.

I understand what you are saying: Ada programmers can still make the same
mistakes in coding that C programmers can make. But the point is that those
errors may not get past the compiler and/or the initial execution fo the
code.

There is also an advantage to getting some kind of runtime exception in a
fielded system as well. If an index gets out of range under unusual
conditions not tested for, yes this is a programmer error. But unlike
silently running off the end of an array and scrogging memory with possibly
non-fatal, yet serious problems being generated, Ada is going to halt the
code and (if the implementation is nice!) report where it stopped and why.
In most apps that is *usually* a good thing.

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


"David Bolen" <db3l@fitlinxx.com> wrote in message
news:usncbuz01.fsf@ctwd0143.fitlinxx.com...
> mjsilva697@earthlink.net (Mike Silva) writes:
>
> > While discussing (er, pushing) Ada with some C-coding co-workers today
> > I asked a question to which I knew the answer (always the best kind!):
> >  "Have you ever had a bug caused by accessing off the end of an
> > array?"  Well, of course, they all had to say yes.  Then I started
> > thinking of other bugs that they would have to admit to, and which
> > wouldn't occur in Ada.  Nothing new here (Ada prevents many bugs...),
> > but I thought it would be fun and useful to develop a group list as an
> > Ada advocacy tool.  For example:
>
> I'm curious as to how Ada _prevents_ such bugs.  Are you saying that
> no Ada programmer has ever had a bug caused by walking off the end of
> an array either?
>
> I'll buy that Ada will catch that error more quickly than in C, and
> probably help isolate the problem more quickly.  And even that by
> using attributes such as Range, Low and High that you can write more
> robust code to avoid the issue (which is no small benefit).  But given
> that you can still compute indices and then attempt to dereference
> based on those computations, there has to be the occasional bug that
> is introduced through the use of indices that overflow the array.
>
> And that's different from saying "wouldn't occur in Ada" ... there's a
> difference between better handling of the bug, and not having the bug
> ever occur.  Or to put it another way, if I have a bug that creates
> this condition (or say, tries to set a value outside its range, as in
> another example), generating an exception - even if handled - still
> implies the bug exists.
>
> Some of the suggested items appear to be language checks that are
> completely possible at compile time, for which I'd buy the "can't
> happen" argument.  But any issues that can occur at runtime and
> require runtime checks and exceptions don't, IMHO, prevent bugs, but
> simply act to make it easier to diagnose and manage them when they do
> occur.
>
> --
> -- David
> --
> /-----------------------------------------------------------------------\
>  \               David Bolen            \   E-mail: db3l@fitlinxx.com  /
>   |             FitLinxx, Inc.            \  Phone: (203) 708-5192    |
>  /  860 Canal Street, Stamford, CT  06902   \  Fax: (203) 316-5150     \
> \-----------------------------------------------------------------------/