Re: Modulus and Remainder operations (Was Re: Help with a bit of C code)

[bobduff@dsd.camb.inmet.com (Bob Duff)]

In article <1994Oct13.181350.10997@nosc.mil>,
Charles H. Sampson <sampson@nosc.mil> wrote:

> ...Does anyone know why programs that rely on an implementation
>of a compiler-dependent feature were not also classified as erroneous?
>
>                                   Charlie

Depending on an implementation-dependent feature makes your program
nonportable.  Erroneous execution is much worse: your program might do
anything, including delete all the files on your disk, crash the system,
and set your keyboard on fire.  Therefore, erroneousness is reserved for
situations where we really can't predict what might happen.  (A good
operating system will minimize the probability of trashing the disk, but
I know of case where an erroneous Ada program running under MS-DOS
actually destroyed the root directory.)

In Ada 9X, we have reduced the number of erroneous situations.  For
example, in Ada 83, reading an uninitialized variable was considered
erroneous.  In Ada 9X, this is defined as a "Bounded Error", which is
not quite as bad as being erroneous, since you have *some* knowledge of
what the program might do.  Either way, you shouldn't read an
uninitialized variable.  But if you do (presumably by accident), then in
Ada 9X, the damage is a bit less -- it can't trash your disk, for
example.

In general, "not portable" is not considered to be an error,
and certainly should not always be classified as "erroneous".

- Bob
-- 
Bob Duff                                bobduff@inmet.com
Oak Tree Software, Inc.
Ada 9X Mapping/Revision Team (Intermetrics, Inc.)