Re: Exceptions

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Tue, 11 Dec 2007 15:21:57 +0200, Niklas Holsti wrote:

> Exception contracts could become a considerable part of the source 
> code, especially if they would have to include the "always 
> possible" exceptions like Storage_Error and in the absence of any 
> SPARK-like analysis to exclude impossible exceptions from the contract.

Unluckily, but for backward compatibility an missing contract should be
treated as "raises exception'Class," i.e. anything. This is a problem with
most of new things recently introduced in Ada, that the defaults are more
verbose than their less safe counterparts. For example "abstract",
"interface", "overriding".

>> A typical scenario: A lazy (let's say busy) programmer designs some set of
>> low-level primitives raising some exceptions. Then he starts to write a
>> middle layer that reuses those primitives, not necessarily in exactly this
>> order, but anyway. The exceptions of the middle layer are different, and of
>> course, the lower level exceptions do not propagate out the middle layer.
>> At this point he has already forgot most of when and what the lower level
>> raises. He remembers the exceptions E3 and E10, but the rest is vanished.
>> He decides whether to use "when others" but has no clear idea what to do
>> there, so maybe he places something looking more or less appropriate there
>> hoping that the debugging phase will shed more light on the issue, or just
>> drop it, depending on how much coffee he already had. The rest is obvious.
>> Does it sound familiar?
> 
> Not really. I use informal exception contracts (in comments 
> describing each and every subprogram),

I do it as well.

> so I have not experienced 
> that kind of mess. But I have mistakenly omitted a necessary 
> handler once or twice, generally when the raise-to-handle distance 
> has been very large (fatal or semi-fatal exception).

The problem is that you have to analyse the descriptions of all m
subprograms you call in the given scope. Remember also the figure n of the
scopes where an exception propagates without handling. That gives us m x n
(width x depth) of the search as the number of things to keep in the weary
head at once. It is tedious and error prone, especially when the code gets
changed.

>> Now a contracted exceptions scenario: The programmer contracts a
>> middle-layer subprogram as non-propagating anything he does not want to. He
>> does not write any handlers, just compiles the code. The compiler complains
>> about E1. Aha - he says, where that E1 comes from? This repeats until all
>> low-level exceptions are caught, *understood* and handled.
> 
> That would be ideal, and very much in the Ada spirit. But I can see 
> why it is not an easy addition to Ada.

It would be difficult to compiler vendors, because they will have to add
exception contracts to all language constructs and library subprograms and
then maintain them upon porting the compiler to another target.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de