Re: ADA Popularity Discussion Request

[kevin.cline@gmail.com (Kevin Cline)]

"Richard  Riehle" <adaworks@earthlink.net> wrote in message news:<TqxUc.26181$9Y6.25639@newsread1.news.pas.earthlink.net>...
> "Kevin Cline" <kevin.cline@gmail.com> wrote in message
> news:e749549b.0408171554.2f9c48b4@posting.google.com...
> >
> > I don't your guru got it quite right.  Ada failed because most
> > programmers who tried it found Ada programming to be relative less
> > productive than programming in other available languages.  Ada never
> > attracted a large enough base of motivated users to develop the
> > libraries and IDEs that would make it easy to use.
> >
> I wonder why you think Ada is less productive than other
> available languages.   Is it the static typing?  

No, I'm very comfortable with static typing in C++.

> Is the ability to define one's own types?   

That is a problem.  User defined types are less compatable with
built-in types than they are in C++.  This makes generic programming
more difficult.  I find it more difficult to factor out duplication in
Ada than I do in C++.

> Is it the syntax?  

Yes.  The syntax, and particularly the need for explicit generic
instantiation, makes Ada programs much longer than equivalent C++
programs.  Longer programs take longer to write and longer to read.

The Ada type model, with special cases for types that overload
assignment or require a destructor, seems much more complex than the
C++ type model.

> Is it the way the ALRM is written?

The ALRM is ok, but I feel the type system is fatally flawed.

> Over the years, I have come to the conclusion that a key
> problem with Ada, in those early days, was that few of
> those involved in teaching it really understood it well
> enough to make it clear to those who needed to use it.

The early Ada compilers were horribly expensive, and horribly buggy. 
This turned a lot of programmers away from Ada, and the battle for
mindshare was quickly lost.  The battle for mindshare was lost early
when Ada failed to gain any popularity among the DARPA research
triangle of MIT, CMU, and Stanford.

> There are a few simple underlying ideas in the language. One
> of them is type safety, and that has never been beyond the
> comprehension of any programmer.   The idea that seems to
> have been difficult to grasp, even by many who consider themselves
> sophisticated software developers, is the separation of scope
> and visibility.   Chapter Eight of the ALRM is rarely read by
> anyone, it seems.
> 
> I recall being at a conference some years ago where someone
> was giving a tutorial involving Ada.  At one point I suggested
> changing a part of the design to a limited private type.  

I think the very existence of limited types is a fundamental flaw in
Ada.

> Those who had the most difficulty with Ada, and those who
> continue to have difficulty with it, are often trying to force
> the language to do things the old way.   They are unable to
> learn how a light touch, using the features of the language,
> will make one more productive, not less productive.

The difficulty of learning Ada is a flaw in the language.  

> 
> I currently teach Ada in an academic environment.   My students
> are in graduate school and very bright.  

I am too, but even among very bright people few become facile
programmers.

> 
>  Many of them have written programs in other languages.   
> When they first encounter
> Ada, they too want to approach it the way they did other
> languages.   After a short time, they learn the simple ideas behind
> the design of the language and they learn to like it (most of them).
> In fact, many like it far better than C++, Java, or many of the
> other options they have been taught.
> 
> The benefits of the visibility rules needs to be given emphasis.  Those
> rules are among the most powerful benefits of Ada, even though
> some programmers continue to see them as a nuisance.

For most applications, the benefits of the available infrastructure,
e.g. the STL and Boost for C++, the CPAN for Perl, the Java libraries,
completely dominates any possible benefit from the additional safety
afforded by Ada.  I have learned to write safe C++ code with little
effort, and have learned to use C++ templates to build extremely
powerful domain-specific libraries.

It doesn't matter to me that weak programmers can theoretically make a
mess in C++.  What matters is the amount of effort required for a good
programmer to produce sound code, and Ada is simply not competitive
for most applications.