Re: Ada exception block does NOT work?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Maciej Sobczak <no.spam@no.spam.com> writes:

> Jeffrey R. Carter wrote:
> 
> > Ada has had exceptions, well integrated with the rest of the language,
> > since Ada 80. Ada's terminology is that exceptions are raised and
> > handled.
> 
> OK, but the question is not about terminology, really.

It is unfortunate that different programming languages use different
terminology for what is essentially the same concept.  "Raise" and
"handle" mean essentially the same thing as "throw" and "catch".
There are important differences in syntax and semantics among different
languages, but terminology differences just get in the way of
understanding the "real" differences.  And the differences between C++
and Java are just as important as the differences between C++ and Ada,
even though C++ and Java use more-similar terminology.

Anyway, if you say "throw" in an Ada newsgroup, folks ought to know what
you're talking about.

> If you claim that exceptions were "patched" on to the C++ language that
> did not have them originally, then let's switch the context to other
> language that has no history issue like this.
> 
> I don't know the full history of Java, but I suppose that it had
> exceptions from the very beginning.

Yes, it did.

>... If not, let's take C#. Whether those
> languages tried to mimic the syntax from C++ does not matter at all when
> it comes to discussion how well the mechanism is integrated into the
> language.

Agreed.

> Why do you claim that Ada's exceptions are "better integrated into the
> language than in the languages that throw and catch them"?

Well, given something that ought to be considered an "error", the
language designer has to decide how to deal with it: make it raise/throw
an exception, or make it return a well-defined but likely-wrong answer,
or make the behavior "unpredictable", or restrict things so it can be
detected at compile time, or ....

The raise/throw exception choice was not available to Stroustrup when he
designed C++, since C++ at that time had no exception facility, and
since he intended to be compatible with C.  This has nothing to do with
whether you call it "raise" or "throw".  But it does mean that
exceptions are not well-integrated, since certain run-time errors that
really ought to cause exceptions do not.  For example, overflow on
signed integer arithmetic.  On this point, I agree with Jeff Carter.

On the other hand, the Java designers were not trying to be compatible
with C, and could well have made signed integer overflow throw an
exception.  But they chose instead to make it return a probably-wrong
answer; that is, they unwisely chose wraparound arithmetic.

On the third hand, *unsigned* integer arithmetic is wrap-around in C,
C++, Java, *and* Ada.

----------------

As to the syntax: I think the try/catch statement or whatever is
*better* than the Ada syntax, because it makes it quite clear which
region of code is protected by the handler.  In Ada:

    procedure P(...) is
        ... -- (1)
    begin
        ... -- (2)
    exception
        when Some_Error =>
            Do_Something;
    end P;

An exception at (2) is handled by the handler, whereas an exception at
(1) is not.  But it *looks* like both should be handled, from the
syntax, and the usual indentation.  More importantly, one moves code
above/below the "begin" line based on criteria having nothing to do with
exceptions -- whether it's needed to initialize or constrain things, for
example.

There are, of course, good reasons why exceptions at (1) are not handled
by the above handler.  But I think the try/catch syntax deals with these
issues more neatly.

> Note that those other languages can throw regular objects as exceptions,
> thus enabling polymorphism when they are handled. One could say that
> *this* is the point of good integration and that Ada's exceptions are a
> conceptual patch that did not integrate with the rest of the object
> model, leading to two separate spaces of language entities instead of
> only one.

I agree.  If you want to attach information to an exception in Java, you
do it in the same way you attach information to any other sort of object
-- you declare record fields in a type extension (i.e. in a class in the
exception hierarchy).  In Ada, you have to use a special gizmo.  The
Java way is clearly more well-integrated with the rest of the language.

Besides, the Java way is type safe at compile time, whereas the Ada
gizmo is not.

On the other hand, in C++, an exception can be *anything* -- you can
throw a string, or an int.  I don't like that.

> Note that I'm learning Ada and I'm likely to misunderstand things.

Perhaps, but you seem to understand the exception-related issues just
fine.  ;-)

>... But
> I'm curious about your way of reasoning and I want to better understand
> the differences between languages (and that's why I'm provoking you with
> the above inverted claim ;) ).

- Bob