Papers saying Ada as an overly complex language and hard to implement

Papers saying Ada as an overly complex language and hard to implement

[Yongxiang Gao]

Dear sir
     What papers introduce Ada as an overly complex language?
     And what papers explain why it's hard to write a compiler for?
     Thank you very much in advance.
Yongxiang

--
Home: 1633 Royal Crest, Apt.1146, Austin, TX 78741
Phone: 512-912-0291(H)    512-471-9790(O)
Email: gyx@cs.utexas.edu  Office: PAI 5.54
Homepage : http://www.cs.utexas.edu/users/gyx

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert Dewar]

<<Dear sir
     What papers introduce Ada as an overly complex language?
     And what papers explain why it's hard to write a compiler for?
     Thank you very much in advance.
Yongxiang
>>


Two comments here.

First, what does complex mean here?
Presumably it is in the sense of not-simple.

But simple can mean very different things

Simple to learn
Simple to use
Simple to describe informally
Simple to define formally
Simple to implement

These five aspects are not only different, but mutually incompatible. For
example, these days, it is generally perceived that languages need to
be fairly feature rich (Ada 95, C++, Fortran 90, OO COBOL, ...) to be
simple to use. Even Java is pretty feature rich, especially if you include
its standard libraries.

As for "hard to write a compiler for", Ada is no more difficult than
any of these other languages. These days the really hard part of any compiler
is doing a good job of optimizing the object code on modern 
architectures, and this is about the same effort for any language.

So I don't know if you can find the papers you are looking for, or what
you need them for, but papers that meet your criteria are likely to be
bogus.

(if they exist:-)

Re: Papers saying Ada as an overly complex language and hard to implement

[Brian Rogoff]

On 15 Feb 1998, Robert Dewar wrote:
> ... Robert's take on the overloading of "simple" deleted ...
> 
> As for "hard to write a compiler for", Ada is no more difficult than
> any of these other languages. These days the really hard part of any compiler
> is doing a good job of optimizing the object code on modern 
> architectures, and this is about the same effort for any language.

While this is not a field I know very well, I was under the impression
that it is in general easier to do a good job optimizing Ada than C or 
C++, due to the restrictions on access types amongst others. Was I
mistaken?

Also, the C++ grammar is tricky, you could almost say that it has made 
parsing a reasonable research topic again :-).

-- Brian

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert Dewar]

Brian says

<<While this is not a field I know very well, I was under the impression
that it is in general easier to do a good job optimizing Ada than C or
C++, due to the restrictions on access types amongst others. Was I
mistaken?

Also, the C++ grammar is tricky, you could almost say that it has made
parsing a reasonable research topic again :-).
>>

The question was about the difficulty of writing compilers. There are
some things that are easier to optimize in Ada, and somethings that are
harder (e.g. the result of separaqtely compiling subunits).

But that is more about the results of the compiler, rather than the
difficulty of writing a compiler. To a reasonable first approximation, 
writing an Ada compiler is about as easy/hard as writing a C++ compiler.

As for C++ grammar being tricky, not really, parsing is a very small part
of the problem (and relatively easy) in both cases, I don't see a difference
here of any significance.

Re: Papers saying Ada as an overly complex language and hard to implement

[Brian Rogoff]

On 16 Feb 1998, Robert Dewar wrote:
> The question was about the difficulty of writing compilers. There are
> some things that are easier to optimize in Ada, and somethings that are
> harder (e.g. the result of separaqtely compiling subunits).

Sure, I was pursuing a more interesting (to me) line of questioning about 
whether Ada allowed more optimizations in general than C++. 

> As for C++ grammar being tricky, not really, parsing is a very small part
> of the problem (and relatively easy) in both cases, I don't see a difference
> here of any significance.

Agreed that parsing is "in the noise", but I think the difficulty of
writing a correct parser which handles all of C++ is well known. That's a 
question which comes up on the compiler newsgroup frequently, and so far 
I don't think there is a freely available or PD parser which handles 
anything beyond ATT v2.x. Also, parsers are used in other source analysis 
programs than compilers, so the ease of writing a parser for a language
has some impact on other tools. 

-- Brian

Re: Papers saying Ada as an overly complex language and hard to implement

[Andi Kleen]

Brian Rogoff <bpr@shell5.ba.best.com> writes:
> 
> Agreed that parsing is "in the noise", but I think the difficulty of
> writing a correct parser which handles all of C++ is well known. That's a 
> question which comes up on the compiler newsgroup frequently, and so far 
> I don't think there is a freely available or PD parser which handles 
> anything beyond ATT v2.x. Also, parsers are used in other source analysis 
> programs than compilers, so the ease of writing a parser for a language
> has some impact on other tools. 

Both the g++ 2.8.0 parser (which is bison based) and the parser used on the
TenDRA system (which is build around a home-grown parser generator) 
parse reasonable recent C++ and are freely available.

-Andi

Re: Papers saying Ada as an overly complex language and hard to implement

[Brian Rogoff]

On 17 Feb 1998, Andi Kleen wrote:
> Brian Rogoff <bpr@shell5.ba.best.com> writes:
> > ... on the non-availability of free C++ (version>3.0) parsers ...
> 
> Both the g++ 2.8.0 parser (which is bison based) and the parser used on the
> TenDRA system (which is build around a home-grown parser generator) 
> parse reasonable recent C++ and are freely available.
> 
> -Andi

I sit corrected. Note that the g++ 2.8.0 parser is parsing "GNU C++",
which means it *may* have problems working with the AT&T line, or some of
the recent Draft ISO versions. As noted in another thread, it will be a
while before C++ is really standardized.

-- Brian

Re: Papers saying Ada as an overly complex language and hard to implement

[Geert Bosch]

Robert Dewar <dewar@merv.cs.nyu.edu> wrote:
 <<As for C++ grammar being tricky, not really, parsing is a very
   small part of the problem (and relatively easy) in both cases,
   I don't see a difference here of any significance.>>

Having read both Ada and C++ code, I find Ada code *much* easier
to parse than C++. But I'm not a machine of course ;-)

Parsing Ada and C++

[Steve Furlong]

In article <6cas6q$1ge$1@gonzo.sun3.iaf.nl>,
Geert Bosch  <geert@gonzo.sun3.iaf.nl> wrote:
>Having read both Ada and C++ code, I find Ada code *much* easier
>to parse than C++. But I'm not a machine of course ;-)

Hmmph. Handling 90 or 95% of the constructs or cases is usually pretty
easy. It's the last few percent that kick your butt. Please note
that's a general observation; I've never attempted a compiler for
the full Ada or C++ language. (I did write a forth interpreter, but
since forth has approximately one parsing rule and three syntactic
rules, it's not quite in the same league.)


Regards,
Steve Furlong

Re: Papers saying Ada as an overly complex language and hard to implement

[Yongxiang Gao]

Robert Dewar wrote:

>  These five aspects are not only different, but mutually incompatible. For
> example, these days, it is generally perceived that languages need to
> be fairly feature rich (Ada 95, C++, Fortran 90, OO COBOL, ...) to be
> simple to use. Even Java is pretty feature rich, especially if you include
> its standard libraries.

For a beginner, "rich" comes with "complex to use".

>  As for "hard to write a compiler for", Ada is no more difficult than
> any of these other languages. These days the really hard part of any compiler
> is doing a good job of optimizing the object code on modern
> architectures, and this is about the same effort for any language.

Who tells you "Ada is no more difficult than any of these other languages"?
Do you know the stories of Ada implementation in the early 80's?

>  So I don't know if you can find the papers you are looking for, or what
> you need them for, but papers that meet your criteria are likely to be
> bogus.
>
> (if they exist:-)

You're welcome to offer more constructive information.

--
Home: 1633 Royal Crest, Apt.1146, Austin, TX 78741
Phone: 512-912-0291(H)    512-471-9790(O)
Email: gyx@cs.utexas.edu  Office: PAI 5.54
Homepage : http://www.cs.utexas.edu/users/gyx

Re: Papers saying Ada as an overly complex language and hard to implement

[Jon S Anthony]

Yongxiang Gao <gyx@cs.utexas.edu> writes:

> 
> Robert Dewar wrote:
> 
> > be fairly feature rich (Ada 95, C++, Fortran 90, OO COBOL, ...) to be
> > simple to use. Even Java is pretty feature rich, especially if you include
> > its standard libraries.
> 
> For a beginner, "rich" comes with "complex to use".

That's not obvious.  Indeed, it's probably false.

> >  As for "hard to write a compiler for", Ada is no more difficult than
> > any of these other languages. These days the really hard part of any
> > compiler is doing a good job of optimizing the object code on modern
> > architectures, and this is about the same effort for any language.
> 
> Who tells you "Ada is no more difficult than any of these other languages"?
> Do you know the stories of Ada implementation in the early 80's?

Those with any clue.  BTW, Robert has been intimately involved in
implementing several languages and is probably as familiar with the
issues as anyone in the field.


> >  So I don't know if you can find the papers you are looking for, or what
> > you need them for, but papers that meet your criteria are likely to be
> > bogus.
> >
> > (if they exist:-)
> 
> You're welcome to offer more constructive information.

IMO, it was pretty much right on target.  It may not have been what
you wanted to hear, but hey, facts is facts.


/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd., Belmont, MA 02178, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert Dewar]

Yongxiang Gao says

<<For a beginner, "rich" comes with "complex to use".>>

Speaking from the point of view of having taught Ada to beginners, I 
regard this unsubstantiated claim as nonsense. You do not teach beginners
all the features in a language on day one, and I have found that the
fact that Ada is feature rich has no significant impact on the process
of teaching Ada to beginners.

<<Who tells you "Ada is no more difficult than any of these other languages"?
 Do you know the stories of Ada implementation in the early 80's?>>

To which one might reply, do you know who I am??? :-)

Yes, I am very aware of the Ada implementations in the early 80's. First,
I lead the team that did the first validated implementation, and second,
I worked extensively for Alsys, one of the companies doing these
implementations.

Yes, it is true that writing an Ada compiler is not an easy task, but
neither is writing a compiler for any of the other modern large languages.
PL/1 was hurt badly early on by the difficulty of writing good compilers.
C++ compilers have taken a long time to begin to get reasonably reliable,
and almost none are fully ISO-compliant yet. The difficulty of implementing
Fortran-90 is great enough that it is still nowhere near universal, despite
the date. OO COBOL is *quite* hard to implement (I was involved deeply in
a COBOL implementation, and in some of the discussions leading up to
OO COBOL). Algol-68 was badly hurt by the amount of effort required for
good implementations.

And yet we see isolated examples in each case where good compilers have
appeared on a reasonable time scale (DEC Ada reached a good level of
maturity early on, as has, for that matter GNAT, which is only six years
old at this stage). The CDC implementation of Algol-68 was complete
and excellent. The GE implementation of PL/1 on Multics was highly
effective, and the IBM F90 is coming along nicely.

Remember the issue here is whether Ada is *more* difficult than other
languages. There is no technical reason to think the answer is yes, and
there is no experience which would indicate that the answer is yes. All
we have is your unsubstantiated belief that this is the case, and the
assumption that therefore there must be papers supporting this
belief. I know of no such papers.

As for being constructive, I am trying to be constructive, but you are
asking for papers verifying assumptions that you are making that are
simply not valid!

Re: Papers saying Ada as an overly complex language and hard to implement

[Yongxiang Gao]

Sorry for confusion.

I meant if you want to employ the richness, "rich" leads to "complex to use".
For example, if a typical C programmer want to program with C++, he or she has
to familiarize him or her with the class library of C++. Or, the richness of C++
can't be enjoyed enough.

Actually, I know little about Ada. I only heard someone claimed it's impossible
to finish the Ada project.
At the same time, my boss(I'm a TA for) here asks me to collect such papers. I
trust him.
However, I failed to find one in the internet. So I post such message on the
newsgroup.

Now I've got 4 papers about the "complex" or "difficult" problems of Ada. It's
DONE!

Here I don't mean you're wrong because the ideas are perhaps out-of-date.

Anyway, thank you very much.
Your solid and extensive knowledge is pretty impressive.

Yongxiang

--
Home: 1633 Royal Crest, Apt.1146, Austin, TX 78741
Phone: 512-912-0291(H)    512-471-9790(O)
Email: gyx@cs.utexas.edu  Office: PAI 5.54
Homepage : http://www.cs.utexas.edu/users/gyx

Re: Papers saying Ada as an overly complex language and hard to implement

[Simon Wright]

Yongxiang Gao <gyx@cs.utexas.edu> writes:

> Actually, I know little about Ada. I only heard someone claimed it's
> impossible to finish the Ada project.

> At the same time, my boss(I'm a TA for) here asks me to collect such
> papers. I trust him.

> However, I failed to find one in the internet. So I post such
> message on the newsgroup.

> Now I've got 4 papers about the "complex" or "difficult" problems of
> Ada. It's DONE!

If you go to a newsgroup on Ada and (effectively) ask the residents to
provide you with evidence that they are foolish you can't expect a
totally happy response!

Did your boss really say (in paraphrase) "Find me evidence that Ada is
too complex"? sounds very closed-minded to me! Can't see why one would
want such except to compare with other languages, in which case see
Robert Dewar's remarks.

-- 
Simon Wright                        Work Email: simon.j.wright@gecm.com
GEC-Marconi Radar & Defence Systems            Voice: +44(0)1705-701778
Command & Information Systems Division           FAX: +44(0)1705-701800

Re: Papers saying Ada as an overly complex language and hard to implement

[Yongxiang Gao]

Hi, Guy
    I put the original mail from my boss here. What are you going to say?
    Don't show off too much.
Thanks.
Yongxiang

Simon Wright wrote:

> If you go to a newsgroup on Ada and (effectively) ask the residents to
> provide you with evidence that they are foolish you can't expect a
> totally happy response!
>
> Did your boss really say (in paraphrase) "Find me evidence that Ada is
> too complex"? sounds very closed-minded to me! Can't see why one would
> want such except to compare with other languages, in which case see
> Robert Dewar's remarks.
>
> --
> Simon Wright                        Work Email: simon.j.wright@gecm.com
> GEC-Marconi Radar & Defence Systems            Voice: +44(0)1705-701778
> Command & Information Systems Division           FAX: +44(0)1705-701800

 Subject:
         another TA task
   Date:
         Thu, 12 Feb 1998 09:14:53 -0600 (CST)
   From:
         Calvin Lin <lin@cs.utexas.edu>
     To:
         gyx@cs.utexas.edu




Yongxiang,

    Could you do another literature search for me?  I'm interested in
papers that explain why Ada is an overly complex language, why it's
a hard language to write a compiler for, and other problems with Ada.

    Thanks a lot.

                        Calvin

--
Home: 1633 Royal Crest, Apt.1146, Austin, TX 78741
Phone: 512-912-0291(H)    512-471-9790(O)
Email: gyx@cs.utexas.edu  Office: PAI 5.54
Homepage : http://www.cs.utexas.edu/users/gyx

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert Dewar]

<<    Could you do another literature search for me?  I'm interested in
papers that explain why Ada is an overly complex language, why it's
a hard language to write a compiler for, and other problems with Ada.
>>


I would say that it is almost certain that the above words are written
by someone looking to justify a decision they have already made. If someone
had an open mind, they might say:

"I am concerned as to whether Ada may be overly complex, or hard to 
compile. Can you do a literature search to see what has been written
on this subject."

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert Dewar]

<<Actually, Ada is described as a complex language in a lot of places.
  However, most of them just address one or two words, so that they are
  worthless for me. >>

Yes, well you will often find people who know nothing at all about Ada
express the opinion that Ada is a complex language!

Dave Parnas made this claim in print at one point in Government Computer
News, and I challenged him to a debate on the issue. It was all set up,
and was to be televised, but then Dave was unable to participate because
of health reasons. Too bad, it would have been a nice forum to address
this unfounded impression.

Re: Papers saying Ada as an overly complex language and hard to implement

[Stanley R. Allen]

Robert Dewar wrote:
> 
> <<    Could you do another literature search for me?  I'm interested in
> papers that explain why Ada is an overly complex language, why it's
> a hard language to write a compiler for, and other problems with Ada.
> >>
> 
> I would say that it is almost certain that the above words are written
> by someone looking to justify a decision they have already made.

Since Dr. Lin is a professor who publishes papers concerning
his own favorite language (ZPL), I would guess that the real
reason for the literature request is so that he can put line
like this into some new paper he is writing:

    "ZPL is relatively easy to implement and use.  It is
    well-documented that Ada is overly complex with
    numerous problems [4,7, 9, 12]."

And so the assertion would be "proved" by the references.    

-- 
Stanley Allen
mailto:s_allen@hso.link.com

Re: Papers saying Ada as an overly complex language and hard to implement

[Markus Kuhn]

Stanley R. Allen wrote:
> Since Dr. Lin is a professor who publishes papers concerning
> his own favorite language (ZPL), I would guess that the real
> reason for the literature request is so that he can put line
> like this into some new paper he is writing:
> 
>     "ZPL is relatively easy to implement and use.  It is
>     well-documented that Ada is overly complex with
>     numerous problems [4,7, 9, 12]."
> 
> And so the assertion would be "proved" by the references.

The suitability of a language for a large scale industrial
software engineering project depends a lot on how widely
the language is available, what support is available and how
many people are familiar with it. I would say it is fair to claim
that only the following languages enjoy really wide industry
support at the moment:

  C, C++, Fortran, Cobol, Ada, Java.

Of those, C, Fortran, and Cobol are clearly far behind the
state of the art in programming language design. C++, Ada, and
Java are the only modern programming languages that are well
enough supported today to justify a long-term investment into
them (and I'm not even sure whether this is true yet for Java).
C++ is popular because its backward compatibility with C and
and it is also well known for its complexity and pitfalls and
its unsuitability for safety critical development.

Under this view, comparing experimental academic languages
like ZPL with a widely supported production language like Ada95
would be highly misleading.

Markus

-- 
Markus G. Kuhn, Security Group, Computer Lab, Cambridge University, UK
email: mkuhn at acm.org,  home page: <http://www.cl.cam.ac.uk/~mgk25/>

Re: Papers saying Ada as an overly complex language and hard to implement

[Stanley R. Allen]

Yongxiang Gao wrote:
> 
> Hi, Guy
>     I put the original mail from my boss here. What are you going to say?
>     Don't show off too much.
> Thanks.
> Yongxiang
> 
>  Subject: another TA task
>     Date: Thu, 12 Feb 1998 09:14:53 -0600 (CST)
>     From: Calvin Lin <lin@cs.utexas.edu>
>       To: gyx@cs.utexas.edu
> 
> Yongxiang,
> 
>     Could you do another literature search for me?  I'm interested in
> papers that explain why Ada is an overly complex language, why it's
> a hard language to write a compiler for, and other problems with Ada.
> 
>     Thanks a lot.
> 
>                         Calvin

Ha, Ha!  This is a good one.

Perhaps some of the compiler vendors here should clarify matters
for Dr. Lin.  However, it is possible that his mind has already
snapped shut concerning this topic.

In the mean time, Yongxiang, please look at both sides of the
issue and make up your own mind.  Understand that every
language has its enemies as well as proponents.  It is not a
hard problem to find articles which say bad things about
Ada, C++, Java, Eiffel, COBOL, or any other computer
language.  Every time a new language comes out, "complexity"
is always one of the things it is criticized for, and this
includes languages whuch are explicitly designed to be
"simple" (yes, even Java has been criticized on this basis).

There common yearning among software developers for more
"simplicity", akin to the desire often expressed by people
for "simpler times" -- when life itself was supposedly not
so busy and complicated.  A related desire is for "pure"
programming languages, meaning different things to 
different people, e.g. "mathematically rigorous" (the
kind of thing Dr. Edsger Dijkstra wants), "perfectly
orthogonal" (all features independent and composable),
or "uni-visionary" (integrated around a single
concept: Smalltalk ["every feature is an object"],
purer versions of Lisp ["everything is a list"],
occam2 ["all statements are processes"]).

Academic research tends to theoretical concerns, so
it is not surprising that "pure" or "simple" languages
are rated more highly among language researchers (like
Dr. Lin) than pragmatic languages like Ada or C++.
Dr. Dijkstra, for example, is so emphatically
concerned with languages as theory-proof vehicles that
he even objects to implementing the languages!

Theoretical research in programming languages is very
valuable and has contributed considerably to the
success of Ada as a great implementation tool.
However, it is generally true that the original
languages developed for the theory or research were too
limited to be used by themselves as broadly-applicable
programming languages.  As an example, consider CSP
by Tony Hoare -- a great advance in the theory of
programming languages, and the foundation of the
occam language.  occam proved to be too restrictive
in practice, and so came occam2 -- which was still
too often limited in its breadth.  CSP did contribute
to the Ada rendevous concept, and thus some of its
legacy continues to be influential in a broader
context.  Likewise, Ada 95's "protected objects"
mechanism was influenced by research done by Andrew
Tannenbaum on the Orca programming language.

All of this does not mean that programming language
research has only one goal, to see new and better
features appear in general programming languages;
but it is definitely one of the goals of such
research.  And those general programming languages
(like Ada) which incorporate well-researched elements
will of necessity also include things like low-level
bit-oriented operations, extensive file I/O features
run-time library routines, and other features which
are generally excluded from languages used for
CS research.  All of these things "complicate" a
general programming language (though they will
often make the job of development simpler) and
make it more difficult to implement.

For a more positive perspective on the Ada
language than you may be getting from U Texas,
see these WWW pages:

http://sw-eng.falls-church.va.us/AdaIC/projects
http://www.acm.org/sigada/news/suny.html
http://www.adahome.com

-- 
Stanley Allen
mailto:s_allen@hso.link.com

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert I. Eachus]

In article <34EB6579.C791152D@cs.utexas.edu> Yongxiang Gao <gyx@cs.utexas.edu> writes (quoting Calvin):

 >      Could you do another literature search for me?  I'm interested in
 > papers that explain why Ada is an overly complex language, why it's
 > a hard language to write a compiler for, and other problems with Ada.

     Please remember in doing this search, to put the papers you get
in context.  For example, many of the criticisms of Ada 80 were
directed at the IO model, which was completely redesigned for Ada 83.
Yes, Ada 83 Text_IO took a lot of flack about the support for
page numbering.  But since IO was now completely an external package,
rather than a built-in feature, no one had to use Text_IO if they
didn't want to, and in fact, many compiler vendors provided--and still
provide--a "Simple_IO" package which is faster and more suited for CRTs.

     Another criticism of Ada 83 was that it would be impossible to
build a good compiler that ran on a machine with 128 K of memory.  The
third compiler validated did just that--although it was tough.
However, for many years the R&R Compiler has fit nicely on a 640 K
MS-DOS machine.  The whole compiler, not just the programs created.

     And finally, there has been an incredibly long running criticism
of the Ada (83) tasking model as overly complex.  It may be, but it is
also a COMPLETE tasking model that can serve as the tasking model
underlying and exported by an operating system--and it a couple of
cases it does.  There are also many embedded real-time executives
which support the Ada tasking model directly.  In fact, much of the
work on hard deadline scheduling has been done around Ada 83, and Ada
95 now includes support for additional scheduling models and allows
adding others.  Certainly a feature which maybe one Ada programmer in
a hundred needs--but having it in the language means that most of the
programmers on a large project never need to know it is there.
--

					Robert I. Eachus

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

Re: Papers saying Ada as an overly complex language and hard to implement

[Joe Gwinn]

Yongxiang,

 In article <34E91572.CE9CEED2@cs.utexas.edu>, Yongxiang Gao
<gyx@cs.utexas.edu> wrote:

> Now I've got 4 papers about the "complex" or "difficult" problems of Ada. It's
> DONE!
> 
> Here I don't mean you're wrong because the ideas are perhaps out-of-date.

It would be useful if you could post the citations of the four papers you
mention on this newsgroup.  Some of us would like to read them, any you
will probably also hear from the community on just what's wrong with those
papers.


As for the relative complexity of Ada83 as of ten years ago, the
comparison of the day was C, and there was no doubt then that Ada83
compilers were a great deal more complex than C compilers.  I became
curious on the issue, and compared the DEC Ada compiler with the DEC "C"
compiler on the VAXen here.  The DEC Ada compiler executable image was
about ten times larger than the DEC C compiler image.  While size is not a
direct measure of complexity, ten to one is still a significant
difference.

C++ is quite another matter, and I suspect that Ada95 and C++ compilers
are of roughly equal complexity, and the languages are of roughly equal
difficulty to learn and use.  C++ does get more and better press.

Joe Gwinn

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert Dewar]

Joe said

<<As for the relative complexity of Ada83 as of ten years ago, the
comparison of the day was C, and there was no doubt then that Ada83
compilers were a great deal more complex than C compilers.  I became
curious on the issue, and compared the DEC Ada compiler with the DEC "C"
compiler on the VAXen here.  The DEC Ada compiler executable image was
about ten times larger than the DEC C compiler image.  While size is not a
direct measure of complexity, ten to one is still a significant
difference.
>>

The factor of ten, if real, means that the C compiler was very poor indeed.
Why do I say this? Because in a good C compiler, the code generator will
be by FAR the largest component of the compiler, and the same is true
of an Ada compiler. For example, in GNAT, the gcc backend is larger
than the gnat front end.

The complexity required for high levels of optimization is staggering,
and this is by far the hardest part of a compiler. One of the things
that made GNAT possible was that we did NOT have to reinvent this.

The differences between C and C++ compilers are basically in the front
end (C-front provides a good hint that this is indeed true).

In fact I suspect the factor of ten was, for whatever reasons, an apple
and oranges comparison (all sorts of things can distort such comparisons,
e.g. static vs dynamic linked libraries, debugging information, inclusion
of tools etc.

Actually I rather suspect the C compiler for the Vax was pretty simple
minded. The Vax was one of these machines where you can write a fairly
simple minded compiler and it is not too terrible :-)

Re: Papers saying Ada as an overly complex language and hard to implement

[vonhend]

In <dewar.887765847@merv>, dewar@merv.cs.nyu.edu (Robert Dewar) writes:
>Joe said
>
><<As for the relative complexity of Ada83 as of ten years ago, the
>comparison of the day was C, and there was no doubt then that Ada83
>compilers were a great deal more complex than C compilers.  I became
>curious on the issue, and compared the DEC Ada compiler with the DEC "C"
>compiler on the VAXen here.  The DEC Ada compiler executable image was
>about ten times larger than the DEC C compiler image.  While size is not a
>direct measure of complexity, ten to one is still a significant
>difference.
>>>
I don't recall such a large difference in sizes 10 years ago.  But I was using
VMS (as opposed to Ultrix) and the system run-time libraries were all installed
as shared.  

>
>The factor of ten, if real, means that the C compiler was very poor indeed.
>Why do I say this? Because in a good C compiler, the code generator will
>be by FAR the largest component of the compiler, and the same is true
>of an Ada compiler. For example, in GNAT, the gcc backend is larger
>than the gnat front end.

Actually, the VAX/VMS C compiler was one of the best in the business.
It generated smaller and more efficient code than any other commercially
available C compiler (with the exception of the GNU C compiler, when it
came out.)
>
<snip>
>In fact I suspect the factor of ten was, for whatever reasons, an apple
>and oranges comparison (all sorts of things can distort such comparisons,
>e.g. static vs dynamic linked libraries, debugging information, inclusion
>of tools etc.
>
>Actually I rather suspect the C compiler for the Vax was pretty simple
>minded. The Vax was one of these machines where you can write a fairly
>simple minded compiler and it is not too terrible :-)
>
It wasn't simple minded at all.  See above.  It is true that a number of
features in VAX architecture and in the VMS operating system made it
easier to write an efficient C compiler, but the same argument applies
to Ada.  In fact, the VMS process model fit very nicely with the Ada task
model, so tasking worked much better under VMS than any Unix system.


Mark Von Hendy
LMTO

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert Dewar]

Mark said

<<It wasn't simple minded at all.  See above.  It is true that a number of
features in VAX architecture and in the VMS operating system made it
easier to write an efficient C compiler, but the same argument applies
to Ada.  In fact, the VMS process model fit very nicely with the Ada task
model, so tasking worked much better under VMS than any Unix system.
>>

But was rather slow. It was interesting that Ada/Ed could beat DEC Ada 83
on a VAX for a really heavy tasking program :-)

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert Dewar]

<<Actually, the VAX/VMS C compiler was one of the best in the business.
It generated smaller and more efficient code than any other commercially
available C compiler (with the exception of the GNU C compiler, when it
came out.)
>>

But the fact that a very early version of the GNU C compiler could do
better with fairly minimal effort invested says something doesn't it?

Re: Papers saying Ada as an overly complex language and hard to implement

[Simon Wright]

vonhend@ibm.net writes:

> Actually, the VAX/VMS C compiler was one of the best in the business.
> It generated smaller and more efficient code than any other commercially
> available C compiler (with the exception of the GNU C compiler, when it
> came out.)

But it had idiosyncratic features -- specifically, the system header
files were additionally held in modules in a .TLB [text library], so
if you felt perverse you could use syntax like

  #include stdio

For some reason, people seemed to feel that because Digital had
introduced this [mis]feature you had to use it! What a pain when it
comes time to port!

Re: Papers saying Ada as an overly complex language and hard to implement

[Larry Kilgallen]

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

> The factor of ten, if real, means that the C compiler was very poor indeed.
> Why do I say this? Because in a good C compiler, the code generator will
> be by FAR the largest component of the compiler, and the same is true
> of an Ada compiler. For example, in GNAT, the gcc backend is larger
> than the gnat front end.

One thing certainly missing from the first four years of the VAX C
compiler was reasonable debugger support (generating proper symbol
tables).  Although not measured in the size of the compiler, the
same team was responsible for code to go into the VMS debugger
for the language-specific command parsing, and that was also
among the missing.

I have my own opinions about the people involved not having the
habit of sticking with a project and seeing it through.  One
can avoid that rathole and say that it takes more than passing
validation tests and compiling well-formed programs correctly
to make a good compiler.  In fact if one makes the generalization
that passing a validation suite constitutes the measure of behavior
for correct programs, my primary differentiator between Ada compilers
would be how well they help me on incorrect programs.

> In fact I suspect the factor of ten was, for whatever reasons, an apple
> and oranges comparison (all sorts of things can distort such comparisons,
> e.g. static vs dynamic linked libraries, debugging information, inclusion
> of tools etc.

The VAX Code Generator (VCG) was initially built to support PL/I and C
to prove the point that a common back-end could serve two languages in
the DEC offerings.  It was subsequently used in many other DEC compilers
(not Pascal and not Fortran).  But along the way each language team added
their own enhancements to their own copy.  By the time it got to Ada it
might have grown quite a bit (perhaps to the better, but grown).

For Alpha, I believe DEC's GEM back end is more on the model of putting
all enhancements back into the common pool.

I would guess that the current DEC C for VAX compiler has a much more
elaborate front end than the former VAX C, since it must handle many
dialects, including ANSI and including the former VAX C (K&R) dialect.
Even within the latest standardized dialect, the compiler offers
options regarding how strictly to measure programs (such as the
recently discussed "ignore the results of a function").  VAX C
had none of that.

Larry Kilgallen

Re: Papers saying Ada as an overly complex language and hard to implement

[Larry Kilgallen]

In article <gwinn-1702981842290001@dh5055083.res.ray.com>, gwinn@res.ray.com (Joe Gwinn) writes:

> C++ is quite another matter, and I suspect that Ada95 and C++ compilers
> are of roughly equal complexity, and the languages are of roughly equal
> difficulty to learn and use.  C++ does get more and better press.

Well, C++ also gets worse press.  I believe a network search for pitfalls of
using C++ would produce considerably more results.  Was that assignment given
to someone else in the organization, or is this really a slanted test ?

As for the previous discussion regarding rich vs. complex vs. feature
count, that would seem to be mainly of interest if your assignment is to
"pick a language and use all possible features".  I used Ada 83 for 6
years without ever using multiple tasks.  It was not needed for what I
was doing.  I am not sure I have ever used floating point numbers in
Ada, but for the things I _do_ need, the features are there.

Larry Kilgallen

Re: Papers saying Ada as an overly complex language and hard to implement

[Dan Moran]

Larry Kilgallen wrote in message <1998Feb17.204550.1@eisner>...
...
>but for the things I _do_ need, the features are there.

...

 As a student, the transition from Pascal to Ada was not very difficult. Ada
encourages and allows code that is more like pseudocode. This involves a few
more rules than Pascal. Thus, it is at first a bit more difficult to get
used to (e.g. having three different types of strings), but it makes the
program easier to follow and logically easier to design.
 It is not an overly complex language, it just has many features that are
perhaps at first a bit overwhelming, but in the end lend to better programs.

Dan Moran
morandd @ whitman.edu


P.S. If I have made any grammar errors, please feel free to email me
personally.

Re: Papers saying Ada as an overly complex language and hard to implement

[Joe Gwinn]

In article <1998Feb17.204550.1@eisner>, Kilgallen@eisner.decus.org.nospam wrote:

> In article <gwinn-1702981842290001@dh5055083.res.ray.com>,
gwinn@res.ray.com (Joe Gwinn) writes:
> 
> > C++ is quite another matter, and I suspect that Ada95 and C++ compilers
> > are of roughly equal complexity, and the languages are of roughly equal
> > difficulty to learn and use.  C++ does get more and better press.
> 
> Well, C++ also gets worse press.  I believe a network search for pitfalls of
> using C++ would produce considerably more results.  Was that assignment given
> to someone else in the organization, or is this really a slanted test ?

C++ certainly has its fair share of pitfalls, enriching a number of
authors.  I have a number of these books, including the C++ FAQ, and
wouldn't attempt C++ without reading them.  These books are quite pointed,
and free of marketing bafflegab, which isn't to say that all C++ compilers
are good.

My bitch is that the corresponding Ada95 books don't seem to exist, for
whatever reason, dooming us to blunder into the same mistakes time after
time.  We might wish to learn from the C++ community.


Joe Gwinn

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert Dewar]

<<Now I've got 4 papers about the "complex" or "difficult" problems of Ada. It's
DONE!

Here I don't mean you're wrong because the ideas are perhaps out-of-date.

Anyway, thank you very much.
Your solid and extensive knowledge is pretty impressive.
>>


Be careful to make sure that these papers that you have dug up (you might 
want to give references) are talking about Ada, and not about the now
obsolete Ada 83 language. It sounds like your boss is trying to assemble
a case for not using Ada (without particularly wanting to know anything
about it), in which case, probably any old thing will serve as an excuse,
but if you are genuinely attempting to assess the problem of complexity,
you might want to make sure you have relevant data.

As for richness leading to complexity, that's misleading. For example, the
exception facility of Ada definitelty makes the language more complex from
the point of view of bothg implementation and definition, but it makes
*using* Ada to solve a problem that requires exception handling simpler,
and it is this kind of sinmplicitly that is most important to programmers.

Finally note that if the bottom line of all this is "Ada is complex, 
therefore we will use C++", then this is amont typical, but pathetic
excuses, and is without technical substance.

Of course much language choice is made out of ignorance and familiarity.

Personally, I would much prefer people to just admit to the random nature
of their decisions "We are using C++ because we know it", or "We are
using C++ because Joe Shmo said it was a good idea", rather than trying
to support their choices with bvogus technical arguments.

Re: Papers saying Ada as an overly complex language and hard to implement

[Yongxiang Gao]

Robert Dewar wrote:

>  Be careful to make sure that these papers that you have dug up (you might
> want to give references) are talking about Ada, and not about the now
> obsolete Ada 83 language. It sounds like your boss is trying to assemble
> a case for not using Ada (without particularly wanting to know anything
> about it), in which case, probably any old thing will serve as an excuse,
> but if you are genuinely attempting to assess the problem of complexity,
> you might want to make sure you have relevant data.

I'm afraid they are very old.
Two of them address challenges of Ada to formal semantics. One of them is about
Axiom Semantics, and it might be a classical paper about Ada.
One is about the grammar problems of Ada which makes parsing more difficult. I
think it's obvious trivial now.
The last one is about the limitation of Ada, it claims that the limitation of Ada
causes un-necessary compexity of the language. And it proposes removal of such
limitation so as to make Ada simpler and more powerful.
Actually, Ada is described as a complex language in a lot of places. However, most
of them just address one or two words, so that they are worthless for me.

I don't know my boss's motivation.
I forward you remarks on the languages to him. And he admits that the languages you
mentioned are all very complex.
Am I clear?
Thanks.
Yongxiang

--
Home: 1633 Royal Crest, Apt.1146, Austin, TX 78741
Phone: 512-912-0291(H)    512-471-9790(O)
Email: gyx@cs.utexas.edu  Office: PAI 5.54
Homepage : http://www.cs.utexas.edu/users/gyx

Re: Papers saying Ada as an overly complex language and hard to implement

[John English]

Yongxiang Gao (gyx@cs.utexas.edu) wrote:
: I'm afraid they are very old.

Maybe so, but please GIVE US THE CITATIONS! It's no good saying "I've
got four papers" and then when asked which ones saying "they are very
old", we'd actually like to know *which papers* they are...

-----------------------------------------------------------------
 John English              | mailto:je@brighton.ac.uk
 Senior Lecturer           | http://www.it.bton.ac.uk/staff/je
 Dept. of Computing        | ** NON-PROFIT CD FOR CS STUDENTS **
 University of Brighton    |    -- see http://burks.bton.ac.uk
-----------------------------------------------------------------

Re: Papers saying Ada as an overly complex language and hard to implement

[Luis Espinal]

John English <je@bton.ac.uk> wrote in article
<6cftm9$1p9@saturn.brighton.ac.uk>...
> > Yongxiang Gao (gyx@cs.utexas.edu) wrote:
> > : I'm afraid they are very old.
> 
> Maybe so, but please GIVE US THE CITATIONS! It's no good saying "I've
> got four papers" and then when asked which ones saying "they are very
> old", we'd actually like to know *which papers* they are...
> 
> -----------------------------------------------------------------
>  John English              | mailto:je@brighton.ac.uk
>  Senior Lecturer           | http://www.it.bton.ac.uk/staff/je
>  Dept. of Computing        | ** NON-PROFIT CD FOR CS STUDENTS **
>  University of Brighton    |    -- see http://burks.bton.ac.uk
> -----------------------------------------------------------------
> 
Maybe these four papers don't exists at all. This reminds me of Fermat's
Last Theorem;
he claimed that he had the solution for the problem, yet never published.
Did he really had it?
Do these four papers exists at all?

Luis Espinal.

Re: Papers saying Ada as an overly complex language and hard to implement

[Robert Dewar]

Luis said

<<Maybe these four papers don't exists at all. This reminds me of Fermat's
Last Theorem;
he claimed that he had the solution for the problem, yet never published.
Did he really had it?
Do these four papers exists at all?

Luis Espinal.
>>


Probably the questioner is no longer around. He was tasked by his boss
to find papers critical of Ada, he found some, and his job is done :-)

Re: Papers saying Ada as an overly complex language and hard to implement

[Nick Roberts]

Furthermore, as a result of his search, he designed an entire new
programming language which solved all the problems cited in the papers.
Unfortunately, he died, and all that was found was a cryptic comment in the
margin of his notebook saying "I have a wonderful solution for this" ;-)

------------ Nick Roberts
---------- Croydon, UK
-------- Nick.Roberts@dial.pipex.com
------ Voicemail & Fax +44 181-405 1124
---- Proprietor, ThoughtWing Software
-- Independent Software Development Consultant

    The oceans teem with myriad fishes:
    The land and air are with creatures rife.
    The world is filled with endless complexity;
    This is the simple truth of life. [NJR]

  *** Ada: The Language for a Complex World ***

Robert Dewar wrote in message ...
>Luis said
>
><<Maybe these four papers don't exists at all. This reminds me of Fermat's
>Last Theorem;
>he claimed that he had the solution for the problem, yet never published.
>Did he really had it?
>Do these four papers exists at all?
>
>Luis Espinal.
>>>
>
>
>Probably the questioner is no longer around. He was tasked by his boss
>to find papers critical of Ada, he found some, and his job is done :-)

Re: Papers saying Ada as an overly complex language and hard to implement

[Jonas Nygren]

Nick Roberts wrote:
> 
> Furthermore, as a result of his search, he designed an entire new
> programming language which solved all the problems cited in the papers.
> Unfortunately, he died, and all that was found was a cryptic comment in the
> margin of his notebook saying "I have a wonderful solution for this" ;-)

I read in the news that one guy had been rewarded for coming up
with a proof for Fermat's theorem. He claimed that only the 100
top mathematicians in the world would be capable of understanding
his proof.

/jonas

PS Nick, I believe it was an English guy DS 
> 
> >Luis said
> >
> ><<Maybe these four papers don't exists at all. This reminds me of Fermat's
> >Last Theorem;
> >he claimed that he had the solution for the problem, yet never published.
> >Did he really had it?
> >Do these four papers exists at all?
> >
> >Luis Espinal.

Re: Papers saying Ada as an overly complex language and hard to implement

[Larry Kilgallen]

In article <34F28B28.6C70707@ehpt.com>, Jonas Nygren <ehsjony@ehpt.com> writes:

> I read in the news that one guy had been rewarded for coming up
> with a proof for Fermat's theorem. He claimed that only the 100
> top mathematicians in the world would be capable of understanding
> his proof.

Perhaps someone could explain to those of us who are less inclined
toward math how the number who understand comes out to an even hundred :-).

Larry Kilgallen

Re: Papers saying Ada as an overly complex language and hard to implement

[Nick Roberts]

Larry Kilgallen wrote in message <1998Feb24.113944.1@eisner>...
>In article <34F28B28.6C70707@ehpt.com>, Jonas Nygren <ehsjony@ehpt.com>
writes:
>
>> I read in the news that one guy had been rewarded for coming up
>> with a proof for Fermat's theorem. He claimed that only the 100
>> top mathematicians in the world would be capable of understanding
>> his proof.
>
>Perhaps someone could explain to those of us who are less inclined
>toward math how the number who understand comes out to an even hundred :-).

The figure is exactly 100. Of course, I have a wonderful proof for this,
but, unfortunately, only the world's top 10 mathematicians would be able to
understand it!

:-)

------------ Nick Roberts
---------- Croydon, UK

Re: Papers saying Ada as an overly complex language and hard to implement

[Keith Thompson]

Larry Kilgallen (kilgallen@eisner.decus.org) wrote:
> In article <34F28B28.6C70707@ehpt.com>, Jonas Nygren <ehsjony@ehpt.com> writes:
> 
> > I read in the news that one guy had been rewarded for coming up
> > with a proof for Fermat's theorem. He claimed that only the 100
> > top mathematicians in the world would be capable of understanding
> > his proof.
> 
> Perhaps someone could explain to those of us who are less inclined
> toward math how the number who understand comes out to an even hundred :-).
> 
> Larry Kilgallen

That's easy.  If there happen to be 81 mathematicians who understand
it, you express the number in base 9; if there are 121, use base 11; if
there are 105, use base 10.246950765....  (These are top mathematicians,
after all.)

-- 
Keith Thompson (The_Other_Keith) kst@cts.com <http://www.ghoti.net/~kst> <*>
Qualcomm, San Diego, California, USA  <http://www.qualcomm.com>
It takes a Viking to raze a village.

Re: Papers saying Ada as an overly complex language and hard to implement

[Markus Kuhn]

Yongxiang Gao wrote:
> Actually, Ada is described as a complex language in a lot of places. However, most
> of them just address one or two words, so that they are worthless for me.

The notion that Ada is a "too complex" language is -- although
unfortunately still widely believed among people who never
used the language -- based on a few historic misconceptions:

- Ada was the first modern language for which a formal ANSI/ISO
  standard (the reference model) was widely published before
  good tutorials and free compilers where available. We now know
  that reading a language reference manual is a very bad way of
  getting a first impression of a language (just try to learn
  Java or C++ from the RM!). But in the early days, people
  compared the readability of the very formally written Ada83
  specification with the very informally written and incomplete
  tutorials by Wirth and K&R about their languages (Pascal and
  C). Of course Ada seemed to be much more complex. Once you
  have read both the Ada95 standard and the C++ draft standard,
  I am sure you will agree that Ada95 is in no way more difficult
  to learn and implement than C++.

- Ada has some features that look complicated at first when
  you learn the language, but you have to realize that these
  features add a lot to the safety of the language.

  For instance, Ada has the following more complex mechanism
  that are much simpler in C/C++ but are much safer in Ada:

    - Much more sophisticated pointers that make dangling
      references and memory leaks much more unlikely.

    - Sophisticated arrays (slices, aggregates) make the
      dangerous memcpy/memfil/memcmp mechanisms of C
      unnecessary that escape proper type checking.

    - Ada has many features that make it easier to write code
      for which certain properties can quickly be proofen
      formally. For instance the simple fact that "for" loop
      variables are inside the block constants guarantees that
      Ada "for" loops always terminate (unless you do messy
      "unchecked" things which can easily be spotted and are
      extremely rarely necessary).

Writing verifyably correct C/C++ code is a many orders of magnitutes
more complex task than writing verifyably correct Ada code.
Therefore Ada won rather quickly the markets of safety and
security critical applications where code inspection costs much
more than code development.

Most of the negative press that Ada got before 1995 (before
Ada was revised into the modern 1995 version and before GNAT
was available) should be considered completely out-of-date
today!

Ada95 is is a modern state-of-the-art language for large
scale universal application software engineering. With some
restrictions, the same applies for Java. The Java vs. Ada
view of the industry is strongly biased by the enormous marketing
hype that has been created for Java in the context of being a
Web language. C is becoming a rather old language and seems
to slowly join Fortran and Cobol as old-fashioned but
never dieing languages. C++ suffers fundamentally from all the
problems of C and is only interesting because Microsoft supports
it well. If you look at a high-quality production language in 1998,
Java and Ada95 are the ones you should consider. The advantage
of Ada over Java is that Ada is not designed for the byte code
interpretation model. Ada software therefore executes more
efficiently and Ada in contrast to Java has excellent facilities
for low-level system programming (e.g., for writing device drivers)
and for interfacing with other programming languages (especially
C, which is important because of all the excellent C libraries
and the many C APIs out there).

I've been using C intensively for over eight years now and I
have had some experience with both C++ and Java. I am now moving
to Ada95, and so far it has been a lot of fun and a good
experience. I love C, but I am well aware of its problems, which
can be a real pain in large or safety critical applications.
I am uncomfortable with C++ and I think it is fair to describe
it more as a object-oriented luxury assembler and not as a modern
high-level programming language. Java is a neat modern
state-of-the-art language, as is Ada95. Ada95 is in some ways
less restricted than Java and certainly better suited for
low-level and system programming as well as for safety critical
systems.

Just my private experience, feel free to forward it to your boss ...

Markus

-- 
Markus G. Kuhn, Security Group, Computer Lab, Cambridge University, UK
email: mkuhn at acm.org,  home page: <http://www.cl.cam.ac.uk/~mgk25/>

Re: Papers saying Ada as an overly complex language and hard to implement

[Laurent Guerby]

Markus Kuhn <Markus.Kuhn@cl.cam.ac.uk> wrote:
> [...]
> The Java vs. Ada view of the industry is strongly biased by the
> enormous marketing hype that has been created for Java in the context
> of being a Web language
> [...]

   There is no (or shouldn't be ;-) "Java vs. Ada" debate. There
   already is an Ada 95 compiler that generates JVM code (so the Java
   platform hype can be reused for Ada ;-). And a Java back-end for
   GNAT is being developped. And since the interoperability level 
   between Ada 95 and Java is high, you can choose the language you 
   prefer if your target is the JVM.
 

-- 
Laurent Guerby <guerby@gnat.com>, Team Ada, Linux/GNU addict
   "Use the Source, Luke. The Source will be with you, always (GPL)."

Re: Papers saying Ada as an overly complex language and hard to implement

[Matthew Heaney]

>Subject:  Re: Papers saying Ada as an overly complex language and hard to
implement
>From: Yongxiang Gao <gyx@cs.utexas.edu>
>Date: 1998/02/18

>Hi, Guy
>    I put the original mail from my boss here. What are you going to say?
>    Don't show off too much.
>Thanks.
>Yongxiang
>
>Simon Wright wrote:
>
>> If you go to a newsgroup on Ada and (effectively) ask the residents to
>> provide you with evidence that they are foolish you can't expect a
>> totally happy response!
>>
>> Did your boss really say (in paraphrase) "Find me evidence that Ada is
>> too complex"? sounds very closed-minded to me! Can't see why one would
>> want such except to compare with other languages, in which case see
>> Robert Dewar's remarks.
>>
>> --
>> Simon Wright                        Work Email: simon.j.wright@gecm.com
>> GEC-Marconi Radar & Defence Systems            Voice: +44(0)1705-701778
>> Command & Information Systems Division           FAX: +44(0)1705-701800
>
> Subject:
>         another TA task
>   Date:
>         Thu, 12 Feb 1998 09:14:53 -0600 (CST)
>   From:
>         Calvin Lin <lin@cs.utexas.edu>
>     To:
>         gyx@cs.utexas.edu
>
>
>
>
>Yongxiang,
>
>    Could you do another literature search for me?  I'm interested in
>papers that explain why Ada is an overly complex language, why it's
>a hard language to write a compiler for, and other problems with Ada.
>
>    Thanks a lot.
>
>                        Calvin
>
>--
>Home: 1633 Royal Crest, Apt.1146, Austin, TX 78741
>Phone: 512-912-0291(H)    512-471-9790(O)
>Email: gyx@cs.utexas.edu  Office: PAI 5.54
>Homepage : http://www.cs.utexas.edu/users/gyx

Here are some articles on the subject of Ada's complexity.  Many are from
the early 80's, when the language was still being standardized.

On the GREEN Language Submitted to the DoD
Edsger Dijkstra
SIGPLAN Notices, Vol 13, No 10, Oct 78, p16-21
- Dijkstra critiques an early version Ada.  Companion articles in the same
issue critique the other three finalists in the language competition

The Emperor's Old Clothes
C. A. R. Hoare
1980 Turing Award Lecture
ACM Turing Award Lectures, 1966-1985
ACM Press
also in
The Ada Programming Language: A Tutorial
Sabina Saib and Robert Fritz
IEEE Computer Science Presss, 1983
- Ada's reputation as a language too big and too complex can be traced
directly back to Hoare's speech, in which argues for an Ada subset.  Hoare
claimed that Ada was an unsafe language not appropriate for use on
safety-critical systems - ironically, the very domains for which Ada was
designed.

"At first I hoped that such a technically unsound project would collapse
but I soon realized it was doomed to success."

"And so, the best of my advice to the originators and designers of Ada has
been ignored.  In this last resort, I appeal to you, representatives of the
programming profession in the United States, and citizens concerned with
the welfare and safety of your own country and of mankind: Do not allow
this language in its present state to be used in applications where
reliability is critical..."

<mailto:hoare@prg.ox.ac.uk>

That speech did permanent damage to Ada's reputation, and spawned a whole
movement to scale back the size of Ada.  However, Hoare does give a
lukewarm endorsement of Ada in the Foreward to David Watt's book:

"The language incorporates many excellent structural features which have
proved their value in many precursor languages such as Pascal and Pascal
Plus....One can now look forward to a rapid and widespread improvement in
programming practice, both from those who use the language and from those
who study its concepts and structures."

Ada: Language and Methodology
David Watt, Brian Wichmann, and William Findlay
Prentice-Hall, 1987

<mailto:daw@dcs.gla.ac.uk>
<mailto:baw@npl.co.uk>


Programs-Simple or Complex
ACM Forum
CACM, July 81, Vol 24, No 7, p475-478
-Letters to the editor defending Ada against Hoare's attacks.  Hoare
himself responds to the letters.  Here's his opening paragraph:

"I am glad Saib finds Ada simpler than Algol 68 and PL/I, but I fear there
is little to support this view.  I cannot accept that the extraordinary
series of technically unsound documents entitled "strawman, woodenman,
tinman, ironman," and the technically inadequate management and review
processes, give grounds for confidence in the quality of the resulting
design."

Hoare later says that "All my advice has been placed in the public domain,
along with the other project documents, and may be freely consulted."  I
have been unable to find these documents.  If anyone knows where I can find
Hoare's original comments, please let me know. --mjh

More Commentary on Ada
ACM Forum
CACM, Nov 81, Vol 24, No. 11, p783-785
- More letters to the editor.  There's a funny one by Roy Nutt (an
appropriate name, I'd say):  "Although not for the same reasons as C.A.R.
Hoare, I too think that Ada is a terrible mistake.  Ada is awful.  Ada is
stupid, clumsy, and arrogant."


Answering an Ada Adversary
David Watt
CACM, Jan 82, Vol 25, No. 1, p80-81
- David Watt responds to Nutt, calling his letter "ill-mannered invective"
and xenophobic.  Even none other than Edsger Dijkstra responds with "I hope
he [Nutt] regrets his paragraph as much as I do."

Pete Wegner writes (in the same column) his Reflections on the Ada
controversy, making poignant comments about Ada's design (see the
references to his other papers).  In a statement that foretold the Ada 95
design:  "Parallels with Algol 60 suggest a revised Ada report by early
1983, and a new version of Ada (say, Ada 88) by 1990."   Oh well, you were
only off by 7 years, Peter!



The ACM Position on Standardization of the Ada Language
Patrick G. Skelly
CACM, Reb 82, Vol 25, No 2, p118-120
- Skelly explains why the ACM Standards Committee rejected the Ada language
for ANSI standardization.  Includes responses from an Ada committee member
(unfortunately not identified; John Goodenough maybe?), defending their
decisions.


Letter to the Ada Canvassees from the DoD
Larry Druffel
CACM, Feb 82, Vol 25, No. 2, p161-162
- Text of a letter sent to members of the Ada Canvass by the director of
the Ada Joint Program Office, "summarizing the outcome of the balloting and
outlining a resulting course of action."


Scaling Down Ada (Or Towards a Standard Ada Subset)
Henry Ledgard and Andrew Singer
CACM, Feb 82, Vol 25, No.2, p121-125
- Argue that Ada should be subsetted, and suggest things to get rid of. 
They were running with the subset idea suggested by Hoare.


Is Ada Too Big?  A Designer Answers The Critics
Brian Wichmann
CACM, Feb 84, Vol 27, No 2, p98-103
- a response to Ledgard and Singer
<mailto:baw@npl.co.uk>


Is Ada Too Big? (letter to the editor)
David Parnas
CACM, Nov 84, Vol 27, No. 11, p1155-1156
- a letter to the editor in response to the Wichmann article


Accomplishments and Deficiencies of Ada
Peter Wegner 
IEEE Software, Jul 84, p39-42
- suggests we ought to "throw Ada away and use what we have learned from
Ada to develop a new well-integrated language, environment, and
methodology"


Comparing and Assessing Programming Languages: Ada, C, Pascal
Alan Feuer, Narain Gehini, eds
Prentice-Hall, 1984
- Has some stuff about Ada.  This book has been out of print, but I found
it an a used bookstore only recently, so I haven't read it yet.


On Understanding Types, Data Abstraction, and Polymorphism
Luca Cardelli, Peter Wegner
ACM Computing Surveys, Vol 17, No 4, Dec 85, p471-522
- A classic paper that I find very abstruse.  Reading it is worthwhile,
though, because it explains Wegner's philosophy of language design, and to
helps you understand the basis of his criticism of Ada.

Learning the Language
Peter Wegner
Byte, March 89, p 245-253
- A more palatable explaination of the design of object-oriented languages;
start with this one before trying to get through Cardelli & Wegner.

Concepts and Paradigms of Object-Oriented Programming (OOPSLA-89 Keynote)
Peter Wegner
June 1990
- Makes the same tired arguments against packages.  "Its notion of type
does not uniformly handle its rich and almost baroque module structure."  I
wonder what he'd say about Ada 95's module structure?!

Wegner's frequent criticisms of Ada seem to be based on the assumption that
the principle abstraction mechanism in Ada is the package; this is why he
labelled Ada an "object-based" rather than a "class (type)-based" language. 
All his papers argue that the package is not a first-class citizen as a
language  construct; for example, it doesn't have a type and can't be
passed as a subprogram argument.  The argument seems to be that since Ada
programming is based packages, and packages aren't first-class language
citizens, Ada itself is an inferior language.


Object-Oriented Software Construction
Bertrand Meyer
Prentice-Hall
- Ada is the subject of chapter 33 in the 2nd edition.  I haven't read the
2nd yet (the 1st was great). From what I've skimmed of it, he often makes
criticisms of C++, but fails to point out how the weaknesses in that
language have been corrected in Ada 95.

I often feel that, in spite of his obvious mastery of language theory, he
hasn't done a lot of Ada programming, and thus doesn't completely
understand the Ada way of thinking.  As Robert Dewar pointed out, you have
to spend a long time - years in fact - immersing yourself in a language to
really understand it.

My criticisms of certain Ada coding styles is based on this philosophy. 
Many Ada programmers - even ones doing it for a long time - don't really
"think" in the language.  You sometimes have to read between the lines of
the RM and Rationale to understand what the correct and intended usage of
the language is.

For example, a guy who really understands the Ada way of thinking is David
Emery.  He had a big hand in the writing of the POSIX 1003.5a (?) bindings,
which are far and away the best Ada bindings ever written.  A great example
of correct Ada 83 programming.  Everyone should read that standard, and
learn from it.

The SERC Ada X/Motif bindings, on the other hand, are truly pathetic.  It's
painfully obvious that the people who wrote those bindings had no idea what
they were doing.

I defended Bertrand on a thread about Design by Contract, but politely
disagreed with his assessment of Ada.  He sent me this funny note:

>Thank you very much for your comments. See my message
>on the newsgroups.
>
>By the way, I have great admiration for Ada 83 (although
>not for Ada 95).
>
>Best regards,
>
>-- BM

I had always thought he didn't like Ada 83; that's the impression I got
from reading the 1st ed of his book.  The 2nd edition discusses Jean's
falling out with the rest of the Ada 95 design team, and suggests his
leaving was because he felt the language was getting too complex.  (Others,
among them Robert Dewar and Bryce Bardin, have offered different
interpretations of the split.) 

Meyer seems to be trying to draw a parrallel between Ichbiah's leaving the
Ada 95 design, and the famous incident of Tony Hoare, Nik Wirth, and Edsger
Dijkstra leaving the Algol-68 design, because of their belief that
Algol-68's complexity was getting out of control.

In the end, you'll have to decide for yourself whether you think Ada is too
complex.

<mailto:bertrand@eiffel.com>
<mailto:ichbiah@twsolutions.com>


Some articles on the history of Ada are:

History of Programming Languages
Thomas Bergin and Richard Gibson, eds
Ada - The Project (in part V, Ada Session)
William Whitaker
- John Goodenough provides some insight into the design meetings with Jean
Ichbiah, saying how many votes went 10-to-1 and 12-to-1 against, with
Ichbiah's one vote having veto power over the rest of the design team.

I think that type derivation was one of the things everyone wanted to get
rid of, but Ichbiah fought for it and vetoed everyone else.  At least in
Ada 83, this is a language feature little understood and exploited by the
many Ada programmers I've met.  For this reason, I came to the conclusion
that this really would have been a good thing to not have included in the
language, and in fact Ledgard and Singer recommended subsetting it out. 
Even Wichmann put it under the "Changes that are possible but of
questionable value" category, saying that "There has been a lively debate
within the Ada community on this one."

Without type extension, I think derivation is of questionable usefulness. 
(One good use, though, is to effect the "transitivity of visibility"
technique, to gain direct visibility to a type and its operations.) 
However, Ada 95's designer, Tucker Taft, used this somewhat superfluous Ada
83 feature as the cornerstone of the object-oriented extensions to that
language.


Why Ada is Not Just Another Programming Language
Jean E. Sammet
CACM, Aug 86, Vol 29, No 8, p722-732
- Written by the author of the mother of all programming language books,
Programming Languages: History and Fundamentals

Abstraction Techniques in Modern Programming Languages
Mary Shaw
IEEE Software, Oct 84, p10-26
- discusses Ada's place in the evolution of abstraction features of languages



Proposals for Enhancement of the Ada Programming Language: A Software
Engineering Proposal
Mats Weber
- His PhD thesis. Discusses many of Ada's idiosyncrasies.

<mailto:mats.weber@lglsun.epfl.ch>


What Orientation Should Ada Objects Take?
J.P. Rosen
CACM, Nov 92, Vol 35, No 11, p71-76
-Jean-Pierre defends Ada's abstraction composition mechanisms.   I love
this paper!  It's one of the few that challenge the assumption that
inheritence is better than aggregation.

Jean-Pierre is a frequent contributor to comp.lang.ada.
<http://perso.wanadoo.fr/adalog/adalog2.htm>


Ada 9x: A Technical Summary
S. Tucker Taft
CACM, Nov 92, Vol 35, No 11, p77-81

Ada 9x: From Abstraction-Oriented to Object-Oriented
S. Tucker Taft
OOPSLA 93 proceedings, p127-135
- a pair of articles from Ada 95's lead designer

<mailto:stt@inmet.com>


I've been thinking of writing a book about Ada's history, and have been
collecting articles like this.  I'd like to write a book that explains how
to think in Ada, and explicates Ada programming philosophy.  There's some
of this sort of thing in Norm's book, but I'd like to have a (shorter) book
that condenses the essential concepts.

Feel free to write or call if you have any questions.

Re: Papers saying Ada as an overly complex language and hard to implement

[Stanley R. Allen]

Matthew Heaney wrote:
> 
> [the sad history of anti-Ada statements by influential people]
>

What I want to know is: where are they now?  Now that
C++ is gaining ground in areas where Ada has some footholds
(large, real-time, embedded, safety-critical), where are
the articles and speeches by "big names" denouncing C++,
the urban sprawl of programming languages?

The folks who criticized Ada at the beginning because it
didn't match their ideas of an "ideal" programming language,
and whose comments helped to cramp the acceptance of the
language, should consider whether C++ is a better match.

A lot of those early comments by language researchers
who "warned the committee about the bad path Ada is
taking" sound suspiciously like academic sour grapes.
"Those Ada proponents didn't incorporate *my* ideas
into the programming language."  Whaaaa!  Their
conclusions can be considered foregone.

Well, they got their way -- Ada became marginalized.
Nature, abhoring a vacuum, ushered in the era of C/C++.
I find it hard to believe that their current silence 
about this result can be considered benign approval.

I challenge any of the academics who criticized Ada for
being "too complex" to come out in favor of C++ over
Ada today.

-- 
Stanley Allen
mailto:s_allen@hso.link.com

Ada's complexity

[Steve Furlong]

In article <dewar.887723305@merv>, Robert Dewar <dewar@merv.cs.nyu.edu> wrote:
>As for richness leading to complexity, that's misleading. For example, the
>exception facility of Ada definitelty makes the language more complex from
>the point of view of bothg implementation and definition, but it makes
>*using* Ada to solve a problem that requires exception handling simpler,
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>and it is this kind of sinmplicitly that is most important to programmers.

Which would be, what, all programs?


Ta,
Steve Furlong

Re: Ada's complexity

[Markus Kuhn]

Steve Furlong wrote:
> 
> In article <dewar.887723305@merv>, Robert Dewar <dewar@merv.cs.nyu.edu> wrote:
> >As for richness leading to complexity, that's misleading. For example, the
> >exception facility of Ada definitelty makes the language more complex from
> >the point of view of bothg implementation and definition, but it makes
> >*using* Ada to solve a problem that requires exception handling simpler,
>                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> >and it is this kind of sinmplicitly that is most important to programmers.
> 
> Which would be, what, all programs?

In most software I write, more code is dedicated to the handling
of error conditions than to actually solving the problem. The
actual algorithms gets in languages without exception handlers
easily lost between all the checks that are necessary to ensure
robust behaviour of high-quality code under all imagineable
situations. Exception handlers allow to separate rather nicely
the error handling code from the actual algorithm and can
contribute a lot to the readability of software that is not
just a rapid prototype but that has to fulfill strict robustness
requirements.

Markus

-- 
Markus G. Kuhn, Security Group, Computer Lab, Cambridge University, UK
email: mkuhn at acm.org,  home page: <http://www.cl.cam.ac.uk/~mgk25/>

Re: Papers saying Ada as an overly complex language and hard to implement

[Ralph Paul]

Yongxiang Gao wrote:
> 
> Robert Dewar wrote:
> 
> >  These five aspects are not only different, but mutually incompatible. For
> > example, these days, it is generally perceived that languages need to
> > be fairly feature rich (Ada 95, C++, Fortran 90, OO COBOL, ...) to be
> > simple to use. Even Java is pretty feature rich, especially if you include
> > its standard libraries.
> 
> For a beginner, "rich" comes with "complex to use".
That's simply not true. Just because a language such as Ada offers
you many feature for many different application areas, it doesn't have
to be complex. If you restrict yourself at the beginning to a subset of
the complete 
language you will see that Ada is really not that complex. Actually many
things are done in a more reasonable way than in C/C++ for example.
If you know Pascal or Modula-2, you should not have much trouble to 
get used to Ada. If you come from a Fortran-77 prespective then there
might be quite a few new things to learn but that's not different for 
C/C++, Java, Oberon-2, Python, Eiffel, ..... .


> 
> >  As for "hard to write a compiler for", Ada is no more difficult than
> > any of these other languages. These days the really hard part of any compiler
> > is doing a good job of optimizing the object code on modern
> > architectures, and this is about the same effort for any language.
> 
> Who tells you "Ada is no more difficult than any of these other languages"?
> Do you know the stories of Ada implementation in the early 80's?

Do you know those stories ? Alot of that seems to be of the urban legend
type : people that have heard from other people that have heard .....

I think Robert Dewar should be in a position to talk about early Ada
implementation ( see www.gnat.com or cs.nyu.edu: lool for Ada-Ed (:-)
or check www.dejanews.com for Robert's Name (;-)).
 
> >  So I don't know if you can find the papers you are looking for, or what
> > you need them for, but papers that meet your criteria are likely to be
> > bogus.
> >
> > (if they exist:-)
> 
> You're welcome to offer more constructive information.

You're the one making the claim. Not the comp.lang.ada
So where is your story (;-).

Regards,


Ralph Paul

	Ralph.Paul@ibm.net

Re: Papers saying Ada as an overly complex language and hard to implement

[Brian Rogoff]

On Mon, 16 Feb 1998, Yongxiang Gao wrote:
> Robert Dewar wrote:
> 
> >  These five aspects are not only different, but mutually incompatible. For
> > example, these days, it is generally perceived that languages need to
> > be fairly feature rich (Ada 95, C++, Fortran 90, OO COBOL, ...) to be
> > simple to use. Even Java is pretty feature rich, especially if you include
> > its standard libraries.
> 
> For a beginner, "rich" comes with "complex to use".

Its quite easy to learn to use a subset of Ada which isn't that much more 
complex than Pascal. Indeed I subset every software tool I learn. So I
would argue that your statement is not accurate. It would be accurate if 
you needed to learn all of Ada's features and how they interacted before 
you did anything at all, but that isn't the case. That doesn't mean that I 
can't imagine a simpler beginner's language, like Scheme, just that your
statement above is plainly false.

> >  As for "hard to write a compiler for", Ada is no more difficult than
> > any of these other languages. These days the really hard part of any compiler
> > is doing a good job of optimizing the object code on modern
> > architectures, and this is about the same effort for any language.
> 
> Who tells you "Ada is no more difficult than any of these other languages"?
> Do you know the stories of Ada implementation in the early 80's?

Early Fortran implementations took a lot longer to write than they would
now because we (we software engineers that is) learned a lot about how to 
write compilers since then. The same can be said about the early Ada
implementations; many features in Ada 83 were not in use in other
mainstream languages, and so much was learned about compiling them. 
From my own experience as a user, I can assure you that C++ compilers of
the late 80's and early 90's were no great testament to the compilability
of that language.

While "argument from authority" is worthless, I have to say that I think
Robert Dewar is intimately familiar with several compiler implementations, 
and I would tend to believe his assessments of their relative complexities, 
since he has authored Ada, Cobol, and Spitbol compilers. 

Do you have a reasoned argument that an Ada compiler will be significantly 
more complex than a C++ compiler?

-- Brian

Re: Papers saying Ada as an overly complex language and hard to implement

[nabbasi]

In article <34E7B551.115C289F@cs.utexas.edu>, Yongxiang says...
>
>Dear sir
      ^^^

does this mean that a woman can not answer your post? or is it
that you are only interested to only a response from men only? 

Nasser

Re: Papers saying Ada as an overly complex language and hard to implement

[Yongxiang Gao]

nabbasi@earthlink.net wrote:

> In article <34E7B551.115C289F@cs.utexas.edu>, Yongxiang says...
> >
> >Dear sir
>       ^^^
>
> does this mean that a woman can not answer your post? or is it
> that you are only interested to only a response from men only?
>
> Nasser

Sorry for that. In China, "sir" is used opon a man or woman deserving
especial respect.

--
Home: 1633 Royal Crest, Apt.1146, Austin, TX 78741
Phone: 512-912-0291(H)    512-471-9790(O)
Email: gyx@cs.utexas.edu  Office: PAI 5.54
Homepage : http://www.cs.utexas.edu/users/gyx

Re: Papers saying Ada as an overly complex language and hard to implement

[nabbasi]

In article <34E8ABC0.9BA223CC@cs.utexas.edu>, Yongxiang says...
>
>> In article <34E7B551.115C289F@cs.utexas.edu>, Yongxiang says...
>> >
>> >Dear sir
>>       ^^^
>>
>> does this mean that a woman can not answer your post? or is it
>> that you are only interested to only a response from men only?
>
>Sorry for that. In China, "sir" is used opon a man or woman deserving
>especial respect.

oh, ok, no problem then. Now I just have to remember when I go visit China to
address women as "sir", and hopefully I won't get hit on the head for that :)

enough of that, now back to Ada talk..

Nasser
>
>--
>Home: 1633 Royal Crest, Apt.1146, Austin, TX 78741
>Phone: 512-912-0291(H)    512-471-9790(O)
>Email: gyx@cs.utexas.edu  Office: PAI 5.54
>Homepage : http://www.cs.utexas.edu/users/gyx
>
>
>