Re: Java vs Ada 95 (Was Re: Once again, Ada absent from DoD SBIR solicitation)

[bobduff@world.std.com (Robert A Duff)]

In article <3264CCEB.AC0@gsfc.nasa.gov>,
Mike Stark  <michael.e.stark@gsfc.nasa.gov> wrote:
>I agree that this is a subjective judgement.  I think that it is a good
>feature for designing safe and secure systems.  In Ada systems I've 
>worked on, the exceptions raised were part of the commentary in a 
>package spec, and that is quite workable.

To me, it seems like Java's rules would end up requiring a whole lot of
"throws XXX" statements that lie, or bogus exception handlers that can
never be invoked.  This is because the compile-time rules aren't really
very smart about what exceptions can *really* be raised.

An example of this shows up in the predefined streams stuff in Java.
I forget what they call it, but there's some sort of abstract class or
interface that represents streams of bytes, and you can do operations to
get the next byte and so forth.  There's one subclass that represents
*file* streams, and file streams can raise various I/O exceptions.  The
problem is that this fact percolates up, so that *all* streams claim
that they can raise (er, I mean, throw) I/O exceptions, when it's really
only streams attached to files that can raise those exceptions.
Why should I have to have a handler for I/O errors, when I'm reading
from an in-memory stream of bytes, that has nothing whatsoever to do
with I/O?  And if somebody invents a new sort of stream, that can raise
new sorts of exceptions, they have to go back and modify some very
general class to say it can throw those exceptions, and modify all the
callers to know about it.

I agree with the sentiment -- that I would like to know what exceptions
are raised by any given call -- but I think Java's rules end up
requiring me to "cry wolf" too much.  If every routine says "throws
most-anything" then it's not much use.

Another example (in Ada) is a generic, with a procedure parameter.  An
instance of the generic can raise whatever exceptions that formal
procedure might raise, perhaps.  Expressing that precisely requires a
much more complicated mechanism than Java provides.

Note also that Java doesn't follow its own advice -- the most common
exceptions (like dereferencing a null pointer) are exempt from this
mechanism.  It's always suspicious when the predefined stuff (like
dereferencing null pointers, dividing by zero, etc) doesn't obey the
same rules that are expected of user code.

Ada's solution is not ideal, but Java's isn't either (for different
reasons).

- Bob