Re: ADA Popularity Discussion Request

[Brian May <bam@snoopy.apana.org.au>]

>>>>> "Marc" == Marc A Criley <mcNOSPAM@mckae.com> writes:

    Marc> Ada's enforcement of strong typing and runtime checks points
    Marc> out when a programmer has made a mistake, whether as a
    Marc> result of requirements, design, or coding error. (Of course
    Marc> no one is suggesting that Ada would catch all requirements
    Marc> or design errors--that's a ridiculous
    Marc> mischaracterization--but when errant reqs or design lead to
    Marc> a particular implementation, internal contradictions may
    Marc> result in type conflicts or constraint errors.)

Ada has a lot of rules which you have to comply with when
programming. I suspect some programmers find these rules obscure,
weird and limiting[1]. These people prefer the freedom in other
languages like Perl where there is infinity+1 ways of doing the same
thing.

Personally, if I make a mistake, I want to find out sooner rather then
later, and this requires good compiler time checking. Even if the
program is not a mission critical program. Ada is the language I know
with the highest level of checks at compile time.

There is the argument that languages like PHP are best for quick&dirty
prototypes.  The counter argument is that these quick&dirty prototypes
often evolve into the one complicated mess of code that everyone
relies on.

I can't understand the trend in the other direction towards languages
like PHP, if you make a typo in a function name for instance, you
won't realize until that like of code is executed, and even then you
might miss the error message (for instance if it is not on screen).

Worst case scenario I have had is if you accidently change low-usage
code (e.g. error handling) unintentionally (e.g. by typing in wrong
window), you may not realize (although a good version control system
may help, if you check every commit) until months later. You have no
need to retest this code either, it was working last time...

I have also seen cases when the programmer (myself) included have
considered the C compiler broken because it says undefined variable
when it looks identical, when in actual fact it is mistyped - the same
thing is much more confusing if you just get random results instead of
an error. Examples: "OK" instead of "Ok" and "Saved_XYZ" vs
"Save_XYZ".

Then in another extreme, while the SPIM program (MIPS emulator) is
very fussy about program code, on certain errors it won't generate any
messages, but instead ignore all code past that point. Any symbols
defined beyond that point will be flagged as undefined. Now this is
pure evil...

Ada is also seen as a procedural language as opposed to an object
orientated language. I don't know why, I believe it has all the key
features of an OO language, eg. inheritance, run-time binding to
functions, etc. Sure it doesn't have the "object->function" syntax,
but none of my notes on OO programming say this is required. As stated
elsewhere, Ada2005 will be even better.

Notes:

[1] It is interesting to note that the same arguments of "rules" vs.
"flexibility" don't only apply to programming. For instance, in
aviation, I have heard some pilots prefer flying in USA compared with
Australia because airspace rules are more flexible. At the same time,
there are air traffic controllers in USA who complain that the rules
are too flexible, and this limits safety.
-- 
Brian May <bam@snoopy.apana.org.au>