From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,FREEMAIL_FROM
	autolearn=unavailable autolearn_force=no version=3.4.4
X-Received: by 10.58.219.196 with SMTP id pq4mr1380477vec.4.1392326730354;
        Thu, 13 Feb 2014 13:25:30 -0800 (PST)
X-Received: by 10.182.246.133 with SMTP id xw5mr34127obc.14.1392326728846;
 Thu, 13 Feb 2014 13:25:28 -0800 (PST)
Path: 
 eternal-september.org!reader01.eternal-september.org!reader02.eternal-september.org!news.eternal-september.org!news.eternal-september.org!news.eternal-september.org!feeder.eternal-september.org!news.glorb.com!k15no19700190qaq.0!news-out.google.com!h8ni3igy.0!nntp.google.com!c10no20922633igq.0!postnews.google.com!glegroupsg2000goo.googlegroups.com!not-for-mail
Newsgroups: comp.lang.ada
Date: Thu, 13 Feb 2014 13:25:28 -0800 (PST)
In-Reply-To: <bm4ll9Fjs95U1@mid.individual.net>
Complaints-To: groups-abuse@google.com
Injection-Info: glegroupsg2000goo.googlegroups.com;
 posting-host=70.188.179.16;
 posting-account=AvekzAoAAABj-TclKcOWQmXwA49MFPGX
NNTP-Posting-Host: 70.188.179.16
References: <19ac8735-7a9c-429f-a111-a1b3c4b0985b@googlegroups.com>
 <bm4ll9Fjs95U1@mid.individual.net>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <3872de7d-2df4-4ddb-8348-45eb03b3588e@googlegroups.com>
Subject: Re: Differences between Ada 83 and other revisions
From: yoursurrogategod@gmail.com
Injection-Date: Thu, 13 Feb 2014 21:25:30 +0000
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable
Xref: news.eternal-september.org comp.lang.ada:18538
Date: 2014-02-13T13:25:28-08:00
List-Id: <comp.lang.ada>

On Thursday, February 13, 2014 2:44:47 PM UTC-5, Niklas Holsti wrote:
> On 14-02-13 17:59 , yours.....gmail.com wrote:
>=20
> > Hello.  I'm new to Ada, but I would like to get a slightly better
>=20
> > understanding of the language.
>=20
>=20
>=20
> Welcome...
>=20
>=20
>=20
> > I like how the Ada compiler is so
>=20
> > careful, something I rarely see in other languages.
>=20
>=20
>=20
> Me too.
>=20
>=20
>=20
> > From what I've read and heard, Ada 83 compiler was very strict about
>=20
> > what type of code could be compiled and as a result made code that
>=20
> > ran as programmed most of the time.
>=20
>=20
>=20
> I have personal experience of this effect, with all versions of Ada. The
>=20
> language and compiler are strict, which has two consequences: firstly,
>=20
> it encourages you to design and code more carefully and thoughtfully,
>=20
> else your code will not pass the compiler; secondly, the compiler will
>=20
> really discover some kinds of logical errors at compile time. Both make
>=20
> it more likely that the program will actually work as intended, once it
>=20
> compiles correctly.
>=20
>=20
>=20
> > However, later revisions have weakened some of these rules for
>=20
> > Ada 95 and onward.  Is this true?
>=20
>=20
>=20
> As other posters have noted, Ada 95 relaxed some Ada 83 rules which were
>=20
> more "stylistic" than logically necessary. So Ada 95 and later standards
>=20
> give more room for different coding styles, while still giving the same
>=20
> semantic rigour. I don't believe that this makes Ada programs more
>=20
> likely to fail at run time.
>=20
>=20
>=20
> However, Ada 95 and later Ada standards extend the language beyond Ada
>=20
> 83 in many ways. Some extensions include new kinds of run-time checks
>=20
> for new kinds of run-time errors, which cannot be detected at compile
>=20
> time. Ada 83 had a smaller set of run-time checks and errors, so it can
>=20
> be argued that programs using the Ada 95 and later extensions have an
>=20
> increased risk of failing at run-time even if their compilation succeeds.
>=20
>=20
>=20
> I don't know if this argument is valid; I don't see an increased risk of
>=20
> run-time failure in my own programming. But I use the new features
>=20
> rather conservatively and sparingly. Moreover, some of the new features
>=20
> make it easier to avoid some Ada 83 -level run-time errors -- for
>=20
> example, controlled types help to avoid errors in memory allocation and
>=20
> deallocation.
>=20
>=20
>=20
> --=20
>=20
> Niklas Holsti
>=20
> Tidorum Ltd
>=20
> niklas holsti tidorum fi
>=20
>       .      @       .

So it would be safe to say that the newer versions of Ada have not enabled =
the creation of less reliable code.  And that the newer versions are overal=
l qualitatively better (hence them being used in things such as Thaly's Bul=
let and more than a few aerospace projects.

Yes?