Re: Depending on passing mechanism

[hbaker@netcom.com (Henry Baker)]

In article <EIDpr3.ut@world.std.com>, bobduff@world.std.com (Robert A
Duff) wrote:
> When you gripe about some supposed flaw in Ada, you should make it clear
> what you're comparing it to -- C? C++? Common Lisp? Some obscure
> functional language?  Some ideal language in your head? -- all of those
> can be valuable criticisms, but it's helpful to know whether "Ada's
> limited types suck" is said in relation to a language that even *has* a
> concept of limited types!

Ada was the product of forcing a number of ill-conceived and inconsistent
requirements (Steelman) into a single language.  Many additional inelegancies
were added during the period prior to 1983 by torturing the syntax and
semantics in unnatural ways.  Due to the requirements of compatibility,
Ada95 was not allowed to actually _fix_ any of the really bad things in
Ada83, but did allow many program-arounds due to additional new features
which interacted in non-orthogonal ways with the old features.

This is not to take anything away from those who worked on this process.
In many ways, they were too clever for their own good.  Instead of forcing
certain things to be discarded or fixed, they managed to live with them.
If one believes that more code will be programmed in the future than in
the past, this unwillingness to fix old code is penny-wise and pound-foolish,
because all new code pays for the mistakes of the past.

In any _real_ system, the overall goals of portability and tool sharing
cannot be obtained, because one can never trust the new compilers on the
old code during maintenance, thus forcing the DoD to keep around not only
lots of old code, but also lots of old code tools, compilers, workstations,
etc.  If Ada is like any other language, you can't even find a modern
workstation that will run circa 1985 compilers without recompiling the
compiler, and how many people have the resources and access to the code
to do this?

The whole Ada process was an interesting experiment, but the process
was fundamentally flawed.  You can't design a language without writing
a huge number of applications at the same time.  Ada's attempt to define
_and then cast in concrete_ a language before a significant literature
of applications had been programmed was fatal.  Furthermore, the early
(negative) feedback from actual programmers was not taken seriously, and
the process had acquired such political momentum that it could not be
redirected.