Re: ObjectAda and Feb 29th

[Robert Dewar <robert_dewar@my-deja.com>]

In article <t7aek9m9kb.fsf@calumny.jyacc.com>,
  Hyman Rosen <hymie@prolifics.com> wrote:
reasonable :-)
>
> Are many ANSI/ISO standards unstable? Anyway, since you
> frequently point out that GNAT is the only Ada compiler which
> implements all of the Annexes of the Ada standard, I could
> equally well conclude that the Ada standard has not stabilized
> either.

There are two ways in which the rather ill defined term
"unstable" might be used wrt a standard:

1. Sections of the standard are not widely implemented, and
thus have not really been tested well, and are subject to
change in the future as a result.

2. Sections of the standard were simply not in very good shape
at the time the standard was approved, and are known to be
defective.

The numerics in C++ is in my view (and the view is shared by
others) in category 2.

I really know of nothing in the Ada 95 RM that is in category
2 at all.

As for category 1, it is true that some of the annexes are
implemented only by GNAT, but

(a) this means they are implemented pretty widely, GNAT is
available fully supported on 25 different configurations, and
there are several more volunteer ports around, so this to me
means that these sections are widely implemented. The fact
that there are other vendors who provide subset implementations
that do not include these annexes does not really contradict
this.

(b) in any case, I don't think an argument can be made that
this supposed lack of implementation will result in future
instability (i.e. incompatible changes), since in fact the
wide implementation on GNAT has given considerable opportunity
to experiment with and use these annexes.

(c) The annexes are in any case an ancillary non-required part
of the language, and thus even if there are instabilities there,
the fact that the central core of the language is stable is
significant (and not comparable with the C++ situation).

Often a contrast is made between languages where

a) the standard is developed in advance, and then compilers
appear

b) compilers are developed in parallel or before the standard,
so the standard reflects existing implementation experience.

Interestingly people often think of Ada being in the first
category, and C++ being in the second, but it is *EXACTLY*
the opposite way round.

In the case of both Ada 83 and (even more so) Ada 95,
Ada compilers were being
developed at the same time as the standard, and fully compliant
compilers appeared very shortly after the standard was
available. This implementation experience was very definitely
fed into the developing standard.

In the case of C++, the standard was developed before compilers
implemented many important features (such as exceptions, the
STL, namespace's etc). I think it is still the case that many
(most? all?) C++ compilers fail to implement the entire ISO
standard.




Sent via Deja.com http://www.deja.com/
Before you buy.