Re: ADA Popularity Discussion Request

["Richard Riehle" <adaworks@earthlink.net>]

"Kevin Cline" <kevin.cline@gmail.com> wrote in message
news:e749549b.0409042036.5d4822a2@posting.google.com...
> jayessay <nospam@foo.com> wrote in message
news:<m3656vfgmf.fsf@rigel.goldenthreadtech.com>...
> > "Richard  Riehle" <adaworks@earthlink.net> writes:
> >  ...
> > > Ada and Eiffel are designed with more compile-time checking
capabilities
> > > than Smalltalk.
> >
> > Static typing is largely overrated - even Hindley-Milner type systems
> > such as in Haskell or ML (which are significantly more potent than the
> > type systems of Eiffel or Ada).  The whole thing sounds great in
> > theory and you can make some pretty plausible arguments for its
> > efficacy, but it just doesn't make much difference in practice.
>
> I've come to the same conclusion.  Once you decide to test code before
> you write it, strong typing loses most of it's value.  On the other
> hand, if I'm working on code without a good set of automated tests,
> then strong typing is a very nice thing to have.
>
No one argues that testing is unimportant.   However, testing is not
sufficient in the creation of dependable large-scale software systems.

We test for the expected, and design for the unexpected.   We can test
for the errors we anticipate, but must design for those we cannot
anticipate.  This is an essential idea in creating software with Ada.

Static typing is only one aspect of design.   In Ada, types have
proven over and over their value when used in conjuction with
the other design features of the language, including such things
as the visibility rules, accessibility rules, and named association.
Ada goes well beyond compile-time type checking.  In fact, if
it were nothing more than another language based solely on
type checking, much of this criticism would be justified.  Happily,
it is a far more comprehensive software design language than
seems evident from some of the criticism, so far.

No language can protect us, at compile time, from every possible
error.   No tool can prevent us from every kind of mistake, whether
it is a software tool or hardware tool.  But some kinds of tools
can reduce the number of mistakes we make.   Does it not seem
reasonable to use those tools when they make economic sense.
The type model, the visibility rules, the named association rules,
separate compilation units, the ability to truly encapsulate the
structure of types while making them usable, the restrictions
on pointers, the compiler checked generic instantiations, and the
many other aspects of Ada that can be evaluated by the compiler
simply help to improve the life of the programmer, the designer,
and the quality of the final product.   This capability, when combined
with testing, allows us to build the kind of software our customers
should expect.

We certainly can use these features incorrectly.  However, when
used properly, Ada gives the designer a better set of options for
dependable software creation than its nearest competitors.

Richard Riehle