Why no exception hierarchy ?

Why no exception hierarchy ?

[Mogens Jensen]

Hi all,
I am, as many others, looking into Ada95. I am currently using C++, and 
am increasingly aware of some more or less serious flaws in the C++ 
language.
  One thing that puzzles me in Ada95 is that exceptions isn't 
hierarchical like in C++ and Delphi (and others, that I don't know of :) 
). This would also help in the Numeric_Error is_a Constraint_Error problem.

As OOP has been built into the language, class hierarchies/libraries will 
be built (or transferred from C++, maybe?); and these will probably throw 
exceptions.
  As far as I can see, a hierarchy of exceptions would help a lot in such 
a library.

What is the rationale for this (I couldn't find it in either the AARM or 
the Rationale).


Greetings from Jens Jakob Jensen, Denmark  (using my fathers account)

Re: Why no exception hierarchy ?

[Michel Gauthier]

In article <3ksv4s$f9e@news.uni-c.dk>, mojemj@unidhp.uni-c.dk (Mogens
Jensen) wrote:

>>  [...]
>>  
>>  As OOP has been built into the language, class hierarchies/libraries will 
>>  be built (or transferred from C++, maybe?); and these will probably throw 
>>  exceptions.
>>    As far as I can see, a hierarchy of exceptions would help a lot in such 
>>  a library.
>>  
>>  What is the rationale for this (I couldn't find it in either the AARM or 
>>  the Rationale).

I cannot answer about the rationale for this, but I can emphasize that
something like an exception hierarchy was already implementable in Ada-83, 
indeed with a lot of genericity (and crashes of the ...X... compiler).

Using Ada-95, exception identities are very similar to an 'exception type'.
You can pass them as parameters, store them in data structures if
suitable (stacks, queues, arrays, record fields). These stored exceptions
or parameter exceptions can be raised and handled (using the equality
operator).

The use of access discriminants to exception identities permits to
use an exception as a per-object parameter.

All these features are probably sufficient (I have not yet built this exception
hierarchy ) to satisfy your needs.

So, in fact, is there any real need for more specific features ?

-- 
Michel Gauthier - Laboratoire d'informatique - 123 avenue Albert Thomas
F-87060 Limoges - fax +33()55457315
----- Are the messages that objects exchange also objects ? -----

Re: Why no exception hierarchy ?

[Tucker Taft]

Michel Gauthier (gauthier@unilim.fr) wrote:
: In article <3ksv4s$f9e@news.uni-c.dk>, mojemj@unidhp.uni-c.dk (Mogens
: Jensen) wrote:

: >>  [...]
: >>  
: >>  As OOP has been built into the language, class hierarchies/libraries will 
: >>  be built (or transferred from C++, maybe?); and these will probably throw 
: >>  exceptions.
: >>    As far as I can see, a hierarchy of exceptions would help a lot in such 
: >>  a library.
: >>  
: >>  What is the rationale for this (I couldn't find it in either the AARM or 
: >>  the Rationale).

: I cannot answer about the rationale for this, 

Early versions of Ada 9X included exception hierarchies.  However,
it was eliminated in favor of being able to pass information along
with an exception.  

It is possible to create an incredibly elaborate exception 
facility, but the truth is, exceptions are mostly used
for nearly fatal errors, or at least errors that are handled by resetting 
to some well-defined state.  In these cases, you mostly want a dump of 
(human-readable) information to log in an error file or report to the 
user.  Having lots of fine distinctions between different exceptions 
and lots of different exception handlers is probably overkill.

Similarly, exception "signatures" for subprograms are overkill, 
in my view.  They sound great in theory, but in practice, any fault 
tolerant system will end up having to have a handler for "others" anyway,
if only to handle the case when a subprogram violates its exception
signature ;-).

The test is to write a large system using exception hierarchies,
exception signatures, etc.  Do these features really make the system more
robust, or do they just add to the complexity and hence make the system
less robust?

: Michel Gauthier - Laboratoire d'informatique - 123 avenue Albert Thomas
: F-87060 Limoges - fax +33()55457315
: ----- Are the messages that objects exchange also objects ? -----

-Tucker Taft  stt@inmet.com
Intermetrics, Inc.

Re: Why no exception hierarchy ?

[Kenneth Almquist]

An example of something that the Ada 83 exception mechanism did not handle
well is binding UNIX system calls to Ada.  POSIX.5 maps all system call
errors into a single exception named POSIX_Error, and provides a per-task
error code variable.  This is dangerous.  Consider the following C code:

	if (unlink("file") < 0)
	    printf("Could not delete file: %s\n", strerror(errno));

A naive translation of this code to Ada is:

	begin
	    unlink("file");
	exception
	    when posix_error =>
		put("Could not delete file: ");
		put(image(get_error_code));
		new_line;
	end;

This translation is incorrect because "image(get_error_code)", which
corresponds to the C code "strerror(errno)" is evaluated after the first
call to "put".  If "put" modifies errno, the wrong error code will be
printed.

In short, passing data around in global variables is dangerous and leads
to unreadable code.  (Try showing the above code without the surrounding
text to your office mate and see how long it takes him/her to spot the
bug.)

As far as I can tell, Ada 95 provides two ways to resolve this problem,
neither of which I entirely like.  One is to encode the error code in the
exception message.  Then we could have:

	function get_error_code(x: exception_occurence) return error_code;

which would translate the exception_message into an error code.  This
seems to be an abuse of the intended purpose of the exception_message,
which is to provide human-readable information on the exception.  In
addition, passing the error code around as a string seems cumbersome and
inefficient.  On the plus side, it is backward compatible with the
existing POSIX.5 binding.

The other approach is to map each error code to a separate exception
and use query functions on exception identities to implement classes.
In this case, one would write:

	exception
	    when occurence : others =>
		if is_system_call_error(exception_identity(occurence)) then
		    -- code to handle exception goes here
		else
		    raise;	-- we aren't interested in this exception.
		end if;
	end;

This approach leads to more complicated code than is ideal, because we
write two tests for the identity of the exception (the "when" clause
and the "if" statement).  In Ada 83 it is possible to determine which
exceptions are handled by a routine by simply scanning the "when" clauses;
here you have to read the "if" statement as well.

Have I missed overlooked any possibilities?
Was this problem (making UNIX bindings to Ada) discussed during the Ada 9X
revision process?
					Kenneth Almquist

Re: Why no exception hierarchy ?

[David Weller]

In article <D5z3sF.1ou@nntpa.cb.att.com>,
Kenneth Almquist <ka@socrates.hr.att.com> wrote:
>An example of something that the Ada 83 exception mechanism did not handle
>well is binding UNIX system calls to Ada.  POSIX.5 maps all system call
>errors into a single exception named POSIX_Error, and provides a per-task
>error code variable.  This is dangerous.  Consider the following C code:
>
>[snip]
>
>Have I missed overlooked any possibilities?
>Was this problem (making UNIX bindings to Ada) discussed during the Ada 9X
>revision process?

Look at the GNAT file i-cpoerr.ads (Interfaces.C.Posix_Error).  It's
in there.

(I think it _solves_ the problem, but doesn't answer your concerns)

-- 
      Frustrated with C, C++, Pascal, Fortran?  Ada95 _might_ be for you!
	  For all sorts of interesting Ada95 tidbits, run the command:
"finger dweller@starbase.neosoft.com | more" (or e-mail with "finger" as subj.)
		if u cn rd ths, u r gd enuf to chg to Ada   :-)

Re: Why no exception hierarchy ?

[Kenneth Almquist]

dweller@Starbase.NeoSoft.COM (David Weller) writes:
> Look at the GNAT file i-cpoerr.ads (Interfaces.C.Posix_Error).  It's
> in there.
>
> (I think it _solves_ the problem, but doesn't answer your concerns)

It doesn't use exceptions.  You are right, of course--any problem with
exceptions can be _solved_ by simply not using exceptions.  Why didn't
I think of that?  :-)
				Kenneth Almquist

Re: Why no exception hierarchy ?

[Larry Kilgallen, LJK Software]

In article <D5z3sF.1ou@nntpa.cb.att.com>, ka@socrates.hr.att.com (Kenneth Almquist) writes:

> An example of something that the Ada 83 exception mechanism did not handle
> well is binding UNIX system calls to Ada.  POSIX.5 maps all system call
> errors into a single exception named POSIX_Error, and provides a per-task
> error code variable.  This is dangerous.

Dangerous? Sure.  Smells of "errno" !!!

> As far as I can tell, Ada 95 provides two ways to resolve this problem,
> neither of which I entirely like.  One is to encode the error code in the
> exception message.  Then we could have:
> 
> 	function get_error_code(x: exception_occurence) return error_code;
> 
> which would translate the exception_message into an error code.  This
> seems to be an abuse of the intended purpose of the exception_message,
> which is to provide human-readable information on the exception.  In

> The other approach is to map each error code to a separate exception
> and use query functions on exception identities to implement classes.
> In this case, one would write:
> 
> 	exception
> 	    when occurence : others =>
> 		if is_system_call_error(exception_identity(occurence)) then

> Have I missed overlooked any possibilities?

On VMS, DEC Ada (83) provides the pragma IMPORT_EXCEPTION, allowing you
to assign an arbitrary Ada name to your choice of an OS-generated (or
layered-product-generated) OS-style exception.

Perhaps DEC Ada does the same thing on Unix -- I don't know.

I do not know enough about Ada 95 to understand why this would not work,
but I would be interested in comments from those who do know about Ada 95.

Larry Kilgallen

Re: Why no exception hierarchy ?

[Kenneth Almquist]

kilgallen@eisner.decus.org (Larry Kilgallen, LJK Software) writes:
> For an address representation clause, which might be used to access hardware,
> optimizing out dead assignments seems quite inappropriate.  Is there no
> Ada83 method of avoiding such an optimization for such objects?

Pragma Atomic will suppress these optimizations.
					Kenneth Almquist

Re: Why no exception hierarchy ?

[Larry Kilgallen, LJK Software]

In article <D645uH.Dqr@nntpa.cb.att.com>, ka@socrates.hr.att.com (Kenneth Almquist) writes:
> kilgallen@eisner.decus.org (Larry Kilgallen, LJK Software) writes:
>> For an address representation clause, which might be used to access hardware,
>> optimizing out dead assignments seems quite inappropriate.  Is there no
>> Ada83 method of avoiding such an optimization for such objects?
> 
> Pragma Atomic will suppress these optimizations.

I find no reference to Pragma Atomic in the manual for DEC Ada, which
is supposedly validated against the Ada83 standard.

Can you provide more information ?

Larry Kilgallen

Re: Why no exception hierarchy ?

[Kevin F. Quinn]

In article <1995Mar28.115614.9511@eisner>,
          kilgallen@eisner.decus.org (Larry Kilgallen, LJK Software) wrote:

> In article <D645uH.Dqr@nntpa.cb.att.com>, ka@socrates.hr.att.com (Kenneth Almquist) writes:
> > kilgallen@eisner.decus.org (Larry Kilgallen, LJK Software) writes:
> >> For an address representation clause, which might be used to access hardware,
> >> optimizing out dead assignments seems quite inappropriate.  Is there no
> >> Ada83 method of avoiding such an optimization for such objects?
> > 
> > Pragma Atomic will suppress these optimizations.
> 
> I find no reference to Pragma Atomic in the manual for DEC Ada, which
> is supposedly validated against the Ada83 standard.

Pragma Atomic is not required by Ada83.  And there is no equivalent
that is.  Try looking under Pragma Volatile instead - XDAda certainly
has it so DEC Ada might, given that they have the same front-end.
Couldn't tell you for sure off-hand though - I have this nagging feeling
that it's an XD enhancement.  Note that GNAT has both Atomic and
Volatile, and that they achieve different goals; Atomic forces reads
and writes to an object to be indivisible, and Volatile forces all
access to be direct to/from memory.  Volatile is the one that stops
the optimisations you're worrying about.

I think some Ada83 compilers implement a pragma Atomic that does the
job of pragma Volatile; but I'm not sure.

I would have thought that anything with an address clause would not be
optimised in such a way, and that the compiler would make no assumptions
as to its stability.  The '95 LRM says this explicitly:

  13.3.19 If the Address if an object is specified, or it is imported
          or exported, then the implementation should not perform
          optimizations based on assumptions of no aliases.

Note that this means that you could use pragma Export, for example,
to achieve the desired effect.  Just because you export something
doesn't mean you actually have to use it outside the Ada environment :)

You should check this with the '83 LRM et. al. though.


Try writing something like:

  with System;
  procedure ResetKevsASIC is
    Kevs_Command_Register : Integer;
    for Kevs_Command_Register use at System.To_Address(16#101010#);
  begin
    Kevs_Command_Register := 16#0000#;
    Kevs_Command_Register := 16#0123#;
  end Test;

and compile with assembly listing switched on (ADA/LIS/MAC <file>) and
take a peek at the output.  If you see two writes to the relevant
location, you should be alright.  If you just see one (where the value
is 16#1234#) then you know that you need something else.  I'd be
surprised though... (horrified might be a better adjective :) )

pragma Volatile of course allows you to stop those optimisations from
occurring on data that isn't located specifically with an address
clause.  That's the important difference.


P.S. Forgive me if the System.To_Address bit is wrong; I don't
have DEC Ada to hand here.  You might need to use
UnChecked_Conversion from Integer to System.Address.
-- 
Kevin F. Quinn           * "No-one ever made any money out of good
kevq@banana.demon.co.uk  *  looks and charm."
kevq@cix.compulink.co.uk * "You obviously haven't met Lady Hamilton..."
Compu$erve: 100025,1525  *                               Blackadder III

Re: Why no exception hierarchy ?

[Kevin F. Quinn]

In article <19950329.215548.46@banana.demon.co.uk>, I wrote:

> Try looking under Pragma Volatile instead - XDAda certainly
> has it so DEC Ada might, given that they have the same front-end.
> Couldn't tell you for sure off-hand though - I have this nagging feeling
> that it's an XD enhancement.

It does exist in DEC Ada.  And it works.

(And surprisingly enough, I was right about System.To_Address as well -
must have been a good day :) )

-- 
Kevin F. Quinn           * "No-one ever made any money out of good
kevq@banana.demon.co.uk  *  looks and charm."
kevq@cix.compulink.co.uk * "You obviously haven't met Lady Hamilton..."
Compu$erve: 100025,1525  *                               Blackadder III

Re: Why no exception hierarchy ?

[Kenneth Almquist]

> In article <D645uH.Dqr@nntpa.cb.att.com>, ka@socrates.hr.att.com (Kenneth Almquist) writes:
>> kilgallen@eisner.decus.org (Larry Kilgallen, LJK Software) writes:
>>> For an address representation clause, which might be used to access hardware,
>>> optimizing out dead assignments seems quite inappropriate.  Is there no
>>> Ada83 method of avoiding such an optimization for such objects?
>> 
>> Pragma Atomic will suppress these optimizations.

My mistake; I meant pragma Shared.  Pragma Atomic is that Ada 95
replacement for pragma Shared.

Pragma Shared might not do what you want on some implementations
because the the description refers to actions of other tasks.  The
intended implementation of pragma Shared is the same as that of
pragma Atomic, but a smart compiler might use its knowledge of the
other tasks and the way the run time scheduler works to perform
optimizations that would be prohibited by pragma Atomic.
				Kenneth Almquist

Re: Why no exception hierarchy ?

[Robert Dewar]

pragma Atomic is in Ada 85, it is not found in the obsolete language defined
by the previous standard.

Seriously, we should from now on consider on this newsgroup that Ada means
Ada 95 by default. If people want to ask questions or make comments about
Ada 83 they should be careful to specify that this is what they are talking
about.

Is "Ada" 95 or 83? (was: Re: Why no exception hierarchy ?)

[Theodore Dennison]

dewar@cs.nyu.edu (Robert Dewar) wrote:
>pragma Atomic is in Ada 85, it is not found in the obsolete language defined
>by the previous standard.
>
>Seriously, we should from now on consider on this newsgroup that Ada means
>Ada 95 by default. If people want to ask questions or make comments about
>Ada 83 they should be careful to specify that this is what they are talking
>about.

I think that will be a good idea, once a validated Ada 95 compiler exists.

Gnat, R.R., and others have compilers that are damn close, perhaps even 
actually conform, but at the moment there is no Ada 95 compiler.

This should only be an issue for another month or so. You guys can wait 
that long, can't you?

T.E.D. (structured programming mafioso)

Re: Is "Ada" 95 or 83? (was: Re: Why no exception hierarchy ?)

[Robert Dewar]

T.E.D. says we mustn't think Ada means Ada 95 till there are validated
compilers.

Hmm! maybe we could get the C++ folks to follow that same rule :-)

One interesting effect of GNAT of course is that now there are more andd
more students to whom Ada only means Ada 95 (one of the nice things about
the academic world is that you don't get shot if you use a GASP! 
unvalidated compiler)

Re: Ada means what version by default ?

[Michael Feldman]

In article <1995Apr4.210804.9579@eisner.decus.org>,
Larry Kilgallen <kilgallen@eisner.decus.org> wrote:

>I strongly disagree.  That language which has validated commercial
>compilers most widely available should be the default.

I think that is a reasonable expectation in this forum.

>Of course, in the spirit of Ada, it would seem that the version should
>be fully specified in all postings where it matters.

Certainly, but I'd like to try and extract a promise from all us regulars
that we won;t flame newbies who get it wrong. Please. Let's be polite
and helpful. THAT will aid Ada's acceptance in a big way.

Mike Feldman

Re: Ada means what version by default ?

[Larry Kilgallen]

In article <3lv3g2$eek@felix.seas.gwu.edu>, mfeldman@seas.gwu.edu (Michael Feldman) writes:
> In article <1995Apr4.210804.9579@eisner.decus.org>,
> Larry Kilgallen <kilgallen@eisner.decus.org> wrote:

>>Of course, in the spirit of Ada, it would seem that the version should
>>be fully specified in all postings where it matters.
> 
> Certainly, but I'd like to try and extract a promise from all us regulars
> that we won;t flame newbies who get it wrong. Please. Let's be polite
> and helpful. THAT will aid Ada's acceptance in a big way.

Absolutely!  There is an individual in another newsgroup who will flame
any questioner who does not fully specify their problem environment (hey,
if the questioner knew it all, they wouldn't be asking, would they).

Others will answer politely presuming one environment either implicitly
(not good) or explicitly (good).

What I have seen on comp.language.ada, however is much better.  Many
folks will give _both_ the Ada 83 and Ada 95 answer.  The crucial point
is to make sure it comes across not as "if you are smart enough to have
version X", but rather "if you happen to have version X available to you".

Even if every vendor past and present were to instantaneously release an
Ada 95 compiler, being the commercial money-grubbing capitalists that they
are :-), they would probably charge for it.  Not every user can afford to
buy a new compiler, even if they are required to use commercial compilers.
Correspondingly, some who can afford to buy a new compiler are not allowed
to switch compilers in mid-contract.

So there are lots of non-technical reasons to use Ada 83 for many years.
Don't let this newsgroup become elitist.

Larry Kilgallen

Re: Ada means what version by default ?

[Jean D. Ichbiah]

In article <1995Apr6.072906.9591@eisner.decus.org> kilgallen@eisner.decus.org (Larry Kilgallen) writes:

>Even if every vendor past and present were to instantaneously release an
>Ada 95 compiler, being the commercial money-grubbing capitalists that they
>are :-), they would probably charge for it.  Not every user can afford to
>buy a new compiler[...]

The cost of the compiler is but the tip of the iceberg: if you are running
a project of a million line or so, you are likely to have baselined your
compiler and the cost of changing (and confronting 95 incompatibilities)
could very well be several order of magnitude higher than the
compiler costs.

>So there are lots of non-technical reasons to use Ada 83 for many years.

For example, the fact that a given target may be used for your project, have
a decent Ada compiler, but be insufficiently present on the market to entice
any vendor to supply a 95 compiler.


Jean D. Ichbiah

Re: Ada means what version by default ?

[Robert Dewar]

Larry, even if every vendor released an Ada 95 compiler right now, and
offered you a free upgrade, it might well be unwise to accept it! You may
well find it would cause trouble. Caution is needed in making the switch,
and you are right, people will be using Ada 83 for a while to come for
all sorts of reasons. If you have a good Ada 83 compiler, and it meets
your needs, then there is no rush to change!

Of course if you have to start a new project, and you have to have a
validated compiler, then at some point (several years off), you will have
no choice but to switch to Ada 95, because eventually Ada 83 validation
will expire!

Re: Ada means what version by default ?

[Kevin F. Quinn]

In article <1995Apr4.210804.9579@eisner.decus.org>,
          kilgallen@eisner.decus.org (Larry Kilgallen) wrote:

> In article <3ls5sb$nl8@gnat.cs.nyu.edu>, dewar@cs.nyu.edu (Robert Dewar) writes:
> > Seriously, we should from now on consider on this newsgroup that Ada means
> > Ada 95 by default.
> 
> I strongly disagree.  That language which has validated commercial
> compilers most widely available should be the default.
> 
> Of course, in the spirit of Ada, it would seem that the version should
> be fully specified in all postings where it matters.

I'd agree there.  Robert D. is in a bit of a special position w.r.t.
Ada95; most Ada use out there is Ada83 (by a very long way).  And that
will probably continue to be the case for a good few years yet, given the
duration of a typical Ada project and the availability (or lack) of tried,
tested and trusted compilers. 

I would also submit that when people refer to Ada95, it is likely
that they will mention it, often by reference to which version of
GNAT they are using - partly 'coz the version of GNAT is often
important, and partly because they recognise the as-yet weak penetration
of Ada95 into the market.  Whereas an Ada83 user is much more likely
just to say "Ada", and is often completely unaware that Ada95 even
exists.

I certainly intend to specify both ways as far as this group was
concerned, and I humbly submit that this is the best way to go,
for a while at any rate.  That way any newcomers will see immediately
that there are two types of Ada, Ada83 and Ada95

-- 
Kevin F. Quinn           * "No-one ever made any money out of good
kevq@banana.demon.co.uk  *  looks and charm."
kevq@cix.compulink.co.uk * "You obviously haven't met Lady Hamilton..."
Compu$erve: 100025,1525  *                               Blackadder III

Re: Ada means what version by default ?

[Robert Dewar]

Kevin says:            

"I'd agree there.  Robert D. is in a bit of a special position w.r.t.
Ada95; most Ada use out there is Ada83 (by a very long way).  And that
will probably continue to be the case for a good few years yet, given the
duration of a typical Ada project and the availability (or lack) of tried,
tested and trusted compilers."

Hmm! this reflects a view that Ada is only used on giant projects. More and
more a typical Ada project is a couple of hundred lines long, if that,
written by a student for some project. 

It would be interesting to know how many professional Ada programmers
there are in the world working on big projects. 

We estimate that between 5,000 and 10,000 people have downloaded GNAT
from us and various mirror sites. And of course, when students are using
the compiler, they don't download it individually, furthermore we have
no way of including the number of people who get it off CD ROM's etc.

How do you want to do the comparison?

if you allow only big DoD projects in the comparison, no doubt Kevin
is right, but if you count all programmers who have written in Ada,
or even count lines of code, the switch over may be faster than you
think (students churn out lots of code pretty fast :-)

Re: Why no exception hierarchy ?

[Michael Feldman]

In article <3ls5sb$nl8@gnat.cs.nyu.edu>, Robert Dewar <dewar@cs.nyu.edu> wrote:

>Seriously, we should from now on consider on this newsgroup that Ada means
>Ada 95 by default. If people want to ask questions or make comments about
>Ada 83 they should be careful to specify that this is what they are talking
>about.

Sorry, Robert. This is a reasonable expectation only for folks like you
and me (and other regulars) who have hung around this group and
the Ada community for years.

We bemoan Ada's lack of acceptance; we can contribute a good deal to Ada's
acceptance by being very careful to be polite to newbies who may not
be up to date on what's 83 and what's 95. Some of them even spell the
name wrong.

It really is not that much work to be nice to these guys. The Ada community
is far too incestuous; let's make sure we are not acting as our own
enemy. Flip remarks about "obsolete languages" really aren't helpful.

Mike Feldman

Re: Why no exception hierarchy ?

[Jean D. Ichbiah]

In article <3ls5sb$nl8@gnat.cs.nyu.edu> dewar@cs.nyu.edu (Robert Dewar) writes:

>pragma Atomic is in Ada 85, it is not found in the obsolete language defined
>by the previous standard.

>Seriously, we should from now on consider on this newsgroup that Ada means
>Ada 95 by default. If people want to ask questions or make comments about
>Ada 83 they should be careful to specify that this is what they are talking
>about.

Dear Robert,

Since when have you become an adept of the Soviet practice of
rewriting history? There is no such thing as Ada 83: it is called
Ada. Moreover, look at the cover of the new standard and as 
far as I can read it refers to a language called Ada 95!

As a Gnat vendor your zeal at burrying Ada prematurely is 
clearly understandable, but let us be a bottle of Dom  Perignon
that total lines of Ada 95 do not exceed those of Ada before 2000?

Please respond if you accept the bet. We probably have
hundreds of witnesses in this newsgroup.

Best regards,

Jean

P.S. You realize this is a bet I cannot loose: in 2000 I will 
celebrate my 60th and Dom Perignon will be quite proper.

Re: Why no exception hierarchy ?

[Robert A Duff]

In article <ichbiah.271.2F82D56D@jdi.tiac.net>,
Jean D. Ichbiah <ichbiah@jdi.tiac.net> wrote:
>Since when have you become an adept of the Soviet practice of
>rewriting history? There is no such thing as Ada 83: it is called
>Ada. Moreover, look at the cover of the new standard and as 
>far as I can read it refers to a language called Ada 95!

Jean,

The title of the ISO standard is "Information Technology -- Programming
languages -- Ada".  No "95" there.  A different cover was added to the
version that was sent out by the Ada 9X office.

The Foreword says, "This second edition cancels and replaces the first
edition (ISO 8652:1987), of which it constitutes a technical revision."

So as far as ISO is concerned, "Ada" refers to the 1995 version of the
language.  (Also, as far as ISO is concerned, Ada 83 is really Ada 87!)

- Bob

Re: Why no exception hierarchy ?

[Jean D. Ichbiah]

In article <D6Ky3v.DGn@world.std.com> bobduff@world.std.com (Robert A Duff) writes:
>From: bobduff@world.std.com (Robert A Duff)
>Subject: Re: Why no exception hierarchy ?
>Date: Wed, 5 Apr 1995 20:55:07 GMT

>In article <ichbiah.271.2F82D56D@jdi.tiac.net>,
>Jean D. Ichbiah <ichbiah@jdi.tiac.net> wrote:
>>Since when have you become an adept of the Soviet practice of
>>rewriting history? There is no such thing as Ada 83: it is called
>>Ada. Moreover, look at the cover of the new standard and as 
>>far as I can read it refers to a language called Ada 95!

>Jean,

>The title of the ISO standard is "Information Technology -- Programming
>languages -- Ada".  No "95" there.  A different cover was added to the
>version that was sent out by the Ada 9X office.

This  is by a factor of 100 the document that  will be available to the 
public.

>The Foreword says, "This second edition cancels and replaces the first
>edition (ISO 8652:1987), of which it constitutes a technical revision."

This is the Soviet practice of thinking you can "cancel history"


Jean D. Ichbiah

P.S. How about writing "This new edition cancels the previous version 
of Robert  Duff of which it constitutes a technical revision". :-)

Re: Why no exception hierarchy ?

[Robert Dewar]

Jean says:                               

">The Foreword says, "This second edition cancels and replaces the first
>edition (ISO 8652:1987), of which it constitutes a technical revision."

This is the Soviet practice of thinking you can "cancel history" "

Gosh, I guess when Jean talks about PC's he means a 4.77 MHz machine using
an 8088, except perhaps in the SU (which I notice itself has been canceled)
where no doubt the practice is to use PC to mean a somewhat different 
machine.

Superceding old technology with new technology has nothing to do with
rewriting history, it simply has to do with technological progress.
The ISO standard for any language (COBOL, Fortran etc.) always means
the most recent version.

We really have two usages to consider here:

  Popular usage. When people say Fortran, they typically mean the latest
  version they are using. Right now for example, that is mostly Fortran
  77, but is rapidly switching to Fortran 90.

  Official usage. As dictated by the standards body. In this usage, Ada
  definitely means the current standard and no other.

Note that in neither usage does COBOL refer to the original version. When
the word Fortran is used, no one means the original Fortran (this was true
even in 1965, when Fortran already meant Fortran-2).

So I am afraid that Jean's understandable insistence that Ada mean only
the language he originally designed won't have much effect.

For Ada, the informal popular usage is mixed. Already when someone asks
a question about Ada (undesignated) on this newsgroup, answers come in
assuming the meaning was Ada 95, and as time goes on that will be more
common.

So perhaps it is premature to point out that eventually Ada will mean
only Ada 95 in popular usage, but it is certainly the case that using
Ada to mean Ada 83 is going to be increasingly confusing.

So, to repeat my second suggestion, I think it is a good idea if everyone
on this newsgroup clearly says Ada 83 or Ada 95 to make the disctinction
clear. We will know that Jean means Ada 83 when he says Ada, but then he
doesn't need to ask beginner's questions about Ada 83 anyway :-)

Re: Why no exception hierarchy ?

[Garlington KE]

Jean D. Ichbiah (ichbiah@jdi.tiac.net) wrote:
: Since when have you become an adept of the Soviet practice of
: rewriting history? There is no such thing as Ada 83: it is called
: Ada. Moreover, look at the cover of the new standard and as 
: far as I can read it refers to a language called Ada 95!

Actually, mine just says "Information technology - Programming languages - Ada".

: As a Gnat vendor your zeal at burrying Ada prematurely is 
: clearly understandable, but let us be a bottle of Dom  Perignon
: that total lines of Ada 95 do not exceed those of Ada before 2000?

Ummm.. if I compile my Ada [not 95] code with my Tartan 9X compiler in 
a couple of years, will that make it Ada 95 code?

If so, this might be an interesting bet! Will enough Ada [not 95] compilers
support Ada 95 by 2000 that most of the existing Ada code has been recompiled
under at least one of them by one user?

--------------------------------------------------------------------
Ken Garlington                  GarlingtonKE@lfwc.lockheed.com
F-22 Computer Resources         Lockheed Fort Worth Co.

If LFWC or the F-22 program has any opinions, they aren't telling me.

Versions of Ada (was Why no exception hierarchy ?)

[Larry Kilgallen]

In article <3lurur$esb@butch.lmsc.lockheed.com>, l107353@cliffy.lfwc.lockheed.com (Garlington KE) writes:
> Jean D. Ichbiah (ichbiah@jdi.tiac.net) wrote:

> : As a Gnat vendor your zeal at burrying Ada prematurely is 
> : clearly understandable, but let us be a bottle of Dom  Perignon
> : that total lines of Ada 95 do not exceed those of Ada before 2000?
> 
> Ummm.. if I compile my Ada [not 95] code with my Tartan 9X compiler in 
> a couple of years, will that make it Ada 95 code?
> 
> If so, this might be an interesting bet! Will enough Ada [not 95] compilers
> support Ada 95 by 2000 that most of the existing Ada code has been recompiled
> under at least one of them by one user?

Even though I am a teetotaller, I do not want to stand between these two
folks and their Dom Perignon.  I do think, however, that what is crucial
is not what goes on inside the computer, but what goes on inside the mind
of the programmer.

Even if Ada 95 is "better" for some purposes, It is not better for all.

I used Ada for 6 years without ever using Tasking.  I had no need for
Tasking.  Last year a new project brought me to Ada specifically due
to a need for Tasking.  That is in a project situation where Ada
would otherwise be a total non-contender due to lack of a supported
compiler, particularly on the Macintosh.  (P.S., supported on the
Macintosh means the vendor stays up to date with each new toolbox
as Apple distributes it to thousands of developers six months in
advance of public release.)

Don't _ever_ turn up your nose at _any_ Ada user who lacks a need for
every bell and whistle ever invented.  Until you are able to point to
solid supported commercial compilers for every platform (in my environment)
and freeware compilers for every platform (for education environments),
every Ada convert should be received lovingly regardless of version
affiliation. (By the way, most of my latest project is in Pascal, due
to widespread availability.  There is a bit of VAX Scan, however, to
convert between Pascal dialects on various platforms.  That is why
I love Ada -- compilers at least attempt to comply with standards.)

Larry Kilgallen
using Ada without government mandate

Re: Versions of Ada (was Why no exception hierarchy ?)

[Garlington KE]

Larry Kilgallen (kilgallen@eisner.decus.org) wrote:
: Even if Ada 95 is "better" for some purposes, It is not better for all.

: I used Ada for 6 years without ever using Tasking.  I had no need for
: Tasking.

I think this was my point. You can use "Ada 95" without using all of "Ada 95".
Even if you don't use a single new major feature in "Ada 95," I would still
think it would be better to use an Ada 95 compiler just to get rid of some of
those annoying parts of Ada pre-95. Of course, Dr. Ichbias' comments about
conversion costs are very valid, but for a new project, I would always start
with Ada 95 if I could.

Of course, if you want to use a Tartan compiler anytime after the next couple
of years, you're going to get Ada 95 whether you want it or not, pretty much.
For my project, I think this is a Good Thing.  

And, boy, those static pointers are going to be GREAT! <g>

Oddly enough, back in the late '80's I was routinely told by various
Air Force and Navy types that we _weren't_ using Ada, since we didn't use
tasking either. I hear a lot less of that these days...

--------------------------------------------------------------------
Ken Garlington                  GarlingtonKE@lfwc.lockheed.com
F-22 Computer Resources         Lockheed Fort Worth Co.

If LFWC or the F-22 program has any opinions, they aren't telling me.

Re: Versions of Ada (was Why no exception hierarchy ?)

[Robert Dewar]

I absolutely agree that we should not turn up our noses at any user of Ada,
whatever version they are using!

What we need to avoid is the now quite common occurrence where some use
of an Ada-83 compiler asks a question about "Ada", and several people
give what turn out to be unhelpful assumptions that Ada 95 is involved.

Example:

 Someone using Dec Ada on a VAX under VMS: How do I read command line
	parameters.

 Several helpful responses that turn out not so helpful: No problem use
	the Ada.Command.Line package

equally if the questioner is indeed an Ada 95 user, then it is not very
helpful for someone to write an answer:

  Well on the VAX is use (some strange Dec dependent stuff). Hope that
	helps! (but of course it doesn't help at all)

So we can probably all agree on the need to encourage everyone to 
distinguish between Ada 83 and Ada 95. Clearly from this interchange,
it is going to cause confusion to use just Ada if we are talking
technical issues.

Re: Why no exception hierarchy ?

[Robert Dewar]

well I understand Jean may like to think that Ada still means Ada 83, but
that is not the way that the international standardization of a language
works.

The standardized language is called Ada, not Ada 95. The name "Ada 95" has
no official status, it is just a convenient handle for advertising, like
Fortran 77 (the official language name is simply Fortran).

So if you ask what is standard Ada, the only existing standards for Ada
are for the new version, which we call Ada 95. In ISO and ANSI terms, it
is not even valid to reference the old standards, because they have been
obsoleted by the new standards. This is how all language standards work.

My recomendation that Ada mean the new language has nothing to do with
me being involved with GNAT, it is merely in line with the proper usage
of both the ANSI and international standards.

Since this newsgroup is generally discussing latest technology, more and
more posts are concerned with the current Ada, rather than the now obsolete
version, and that trend will probably continue.

It is certainly a good idea to be clear on what version you mean. But if
people use Ada on its own, it is reasonable to suggest that we have a 
consistent understanding of what this means. Since it definitely means
the new version in ISO and ANSI speak, and we cannot change that usage,
we may as well be consistent with it.

Jean says there is no such language as Ada 83, true, in this same sense 
there is no such language as Ada 95. These are just informal usages. If
you get a copy of the ISO standard, it will not say Ada 95, it will just
say Ada. Note that the copies of RM 6.0 recently mailed out by the Ada 9X
project office are NOT official copies of the standard (you can tell by
the paragraph numbers, paragraph numbers are not allowed in ISO standards).

Probably the best recommendation is to clearly specify which version you
are talking about, using Ada 83 and Ada 95, since these are the common
informat designations we are used to. People using Ada on its own, assuming
that people will realize they mean Ada 83, will find themselves increasingly
misunderstood.

Re: Why no exception hierarchy ?

[Jean D. Ichbiah]

In article <dewar.797220950@schonberg> dewar@cs.nyu.edu (Robert Dewar) writes:


>The standardized language is called Ada, not Ada 95. The name "Ada 95" has
>no official status, it is just a convenient handle for advertising, like
>Fortran 77 (the official language name is simply Fortran).

This notion of "official" status or name diKtated by ISO gives it
more power to rewrite history than they really can.

Following you, then, you must be saying Windows to mean the
latest version: Windows NW 3.51 and this instantly has all 3.1
users disappear in a blackhole that not even 95 will rescue.

Safer to state full name.

Jean D. Ichbiah

Re: Why no exception hierarchy ?

[Robert Dewar]

JDI says:

"Following you, then, you must be saying Windows to mean the
latest version: Windows NW 3.51 and this instantly has all 3.1
users disappear in a blackhole that not even 95 will rescue."

Actually since Windows is not a standard, it is just a trademark of MS,
no such statements can be made. Standards make a big difference.

For instance, it is quite important for people in this newsgroups to
distinguish between Ada (the standardized language), and Ada (the
language implemented by their local compiler). The confusion between
the two is the source of many problems (in Ada and all other standardized
languages).

Re: Why no exception hierarchy ?

[Garlington KE]

Robert Dewar (dewar@cs.nyu.edu) wrote:
: So if you ask what is standard Ada, the only existing standards for Ada
: are for the new version, which we call Ada 95.

Although, to be fair, it is still valid to reference MIL-STD-1815(A) if
you work for the good old US DOD.

--------------------------------------------------------------------
Ken Garlington                  GarlingtonKE@lfwc.lockheed.com
F-22 Computer Resources         Lockheed Fort Worth Co.

If LFWC or the F-22 program has any opinions, they aren't telling me.

Re: Why no exception hierarchy ?

[Norman H. Cohen]

In article <dewar.797220950@schonberg>, dewar@cs.nyu.edu (Robert Dewar) writes: 

|>          Note that the copies of RM 6.0 recently mailed out by the Ada 9X
|> project office are NOT official copies of the standard (you can tell by
|> the paragraph numbers, paragraph numbers are not allowed in ISO standards).

The following special Competitive Upgrade Offer from ISO is good only
during the first week of april: 

   For a fraction of the cost of an official ISO standard, they will send
   you an Upgrade Kit, consisting of a bottle of opaquing fluid that you
   can use to hide the paragraph numbers in RM 6.0.

--
Norman H. Cohen    ncohen@watson.ibm.com

Re: Why no exception hierarchy ?

[Robert Dewar]

I am happy to accept this bet. We now estimate that there are over 5000
users of GNAT, and we are accumulating code at a rapid rate, and people
only send us bugs :-)

Of course if we get rid of all the bugs, then no one will send us any
more code.

How do we adjudicate this comparison?

Re: Why no exception hierarchy ?

[Jean D. Ichbiah]

In article <dewar.797221436@schonberg> dewar@cs.nyu.edu (Robert Dewar) writes:

>I am happy to accept this bet.[...]

>How do we adjudicate this comparison?

If it is obvious we will know, if not we will toss a coin.


Jean D. Ichbiah

Re: Why no exception hierarchy ?

[Robert Dewar]

There is only one condition on the bet, and that is that whoever pays for
the bottle, we have to drink it together, OK?

Robert

Re: Why no exception hierarchy ?

[Jean D. Ichbiah]

In article <dewar.797221638@schonberg> dewar@cs.nyu.edu (Robert Dewar) writes:
>From: dewar@cs.nyu.edu (Robert Dewar)
>Subject: Re: Why no exception hierarchy ?
>Date: 6 Apr 1995 22:27:59 -0400

>There is only one condition on the bet, and that is that whoever pays for
>the bottle, we have to drink it together, OK?

>Robert

Was there ever any other possible interpretation?

Re: Why no exception hierarchy ?

[Robert Dewar]

"Was there ever any other possible interpretation?"

No of course not, but I want other to be clear on that. Sometimes people
have heard us arge fiercely, e.g. in the ARG, and concluded that we must
be in the mode of avoiding one another on the street :-)

My favorite memory was one ARG meeting, where you got up and said

"Ah yes, now that Robert has called my ideas 'incredible junk', I see I
 must be completely wrong :-)"

(and yes, the smiley belongs *inside* the quotes here!)

Re: Ada means what version by default ?

[Robert I. Eachus]

In article <ichbiah.280.2F856EEB@jdi.tiac.net> ichbiah@jdi.tiac.net (Jean D. Ichbiah) writes:

  > The cost of the compiler is but the tip of the iceberg: if you are
  > running a project of a million line or so, you are likely to have
  > baselined your compiler and the cost of changing (and confronting
  > 95 incompatibilities) could very well be several order of
  > magnitude higher than the compiler costs.

    Could be, but the evidence so far is that the differences between
compilers are more likely to cause problems, and that has not been a
major problem in Ada.  In many cases moving to 9X has been compile,
rerun tests, and go.  (But first you must get to the point where your
major problem is not compiler bugs in the 9X compiler.)

  > For example, the fact that a given target may be used for your
  > project, have a decent Ada compiler, but be insufficiently present
  > on the market to entice any vendor to supply a 95 compiler.

    This is turning out to be the major issue, but it is cutting both
ways.  For a few hardware architectures, most notably the 68K family,
staying with 83 seems currently to be the prudent choice.  With many
other architectures, such as the Power PC, Ada 95 compilers seem to be
more mature today...

    (Flame retardant: Just so I don't get overly toasted, I'm not just
talking general software development, but in particular embedded
systems.  Compiler, toolset, chapter 13, existing bindings, and long
term support are all important, and two projects with the same target
can and will reach different conclusions.)

--

					Robert I. Eachus

with Standard_Disclaimer;
use  Standard_Disclaimer;
function Message (Text: in Clever_Ideas) return Better_Ideas is...

Re: Why no exception hierarchy ?

[Robert Dewar]

The rationale for not having a hierarchy of exceptions is simply simplicity.
We looked at proposals for such extensions early on (see some of the arly
mapping documents for details), but decided that the complexity was not
worth it. There really is no problem with numeric_error and constraint_error
except that the original language goofed in trying to distinguish exception
conditions too finely, as became apparent later on. The current definition
is just a kludge for backwards compatibility, really no Ada 95 programmer
should even know about Numeric_Error.

The overuse of exceptions, and in particular the over specification of
fine distinctions in exceptions is a common design error in Ada programs,
which would no doubt be encouraged by a fancier exception mechanism.

For example, in one early version of the Posix interface, every error
condition was mapped into a separate exception, but it becamse clear that
it is much better to have a single exception with an error code.

When Jean considered this particular point (the Posix point), he wondered
to me whether perhaps a better language design would have been to have only
one exception with an error code ...

Re: Why no exception hierarchy ?

[Jean D. Ichbiah]

In article <3l1mgn$ppb@gnat.cs.nyu.edu> dewar@cs.nyu.edu (Robert Dewar) writes:

>The overuse of exceptions, and in particular the over specification of
>fine distinctions in exceptions is a common design error in Ada programs,
>which would no doubt be encouraged by a fancier exception mechanism.

>For example, in one early version of the Posix interface, every error
>condition was mapped into a separate exception, but it becamse clear that
>it is much better to have a single exception with an error code.

>When Jean considered this particular point (the Posix point), he wondered
>to me whether perhaps a better language design would have been to have only
>one exception with an error code ...

Well said Robert.  In the Ada design (83) I spent several years reducing the 
18 or so exceptions of preliminary Green to the 5 of Ada.  I tried to convince
others to reduce it to one but was not convincing enough.

The logic for one is that there is not much you con do most of the 
time with the knowledge  of which exception.  You do know the current
process failed. But usually you do not have much information on where
it failed. So the only thing that matters is that you have to provide
a replacement solution.

The only proper way to be really sure of where an exception occurs
is to corner it within a narrow block (begin ... exception ... end) and once
you do this, the name of the exception does not matter much, nor does
the error code.

Jean D. Ichbiah

Re: Why no exception hierarchy ?

[Mats Weber]

In article <3l1mgn$ppb@gnat.cs.nyu.edu>, dewar@cs.nyu.edu (Robert Dewar) wrote:

> For example, in one early version of the Posix interface, every error
> condition was mapped into a separate exception, but it becamse clear that
> it is much better to have a single exception with an error code.

And how are tasks dealt with ? I guess the error code given by the last
exception is returned by a global function or variable (like UNIX's
errno), but that mechanism doesn't work in a multitasking environment.

This is why I like Modula-3's parameterized exceptions. Combined with
inheritance, they are as powerful as exception hierarchies, but simpler to
specify.

Re: Why no exception hierarchy ?

[Robert Dewar]

Mats, the Posix design for error identification works perfectly well
in the multi-tasking situation (could you really think they had 
neglected this obvious point ...)

Re: Why no exception hierarchy ?

[Mats Weber]

In article <3ls5v8$nma@gnat.cs.nyu.edu>, dewar@cs.nyu.edu (Robert Dewar) wrote:

> Mats, the Posix design for error identification works perfectly well
> in the multi-tasking situation (could you really think they had 
> neglected this obvious point ...)

Of course not. But then, how is it done, since there are no task
identifications in Ada 83 ?

Re: Why no exception hierarchy ?

[Kenneth Almquist]

Mats.Weber@matrix.ch (Mats Weber) asks:
> not. But then, how is it [POSIX error identification] done, since there
> are no task identifications in Ada 83 ?

The interface to errno defined by POSIX.5 is procedural.  Get_Error_Code
returns the current value of errno, and Set_Error_Code sets errno.  This
allows a variety of implementations.  As far as I can tell, all require
some assistance from the run time system, but since other parts of POSIX.5
require assistance from the run time system, this is not a major issue.
				Kenneth Almquist