🚀 go-pugleaf

>I might argue that Ada is a better language
>than Modula 2, simply because it has better concurancy primitives. But, if
>the application at hand had no use for these features, my argument would be
>invalid. Indeed, Modula 2 would be the better choice since the implementation
>would be smaller, resulting in tighter code, and in the long run more
>maintainable.

If your do not need any concurrency in your application, a smart Ada
compiler will generate code not containing any provision for
concurrency.  Therefore there is no reason to believe that the code
generated from the Modula-2 program will be smaller.
--
Rahul Dhesi         UUCP:  <backbones>!{iuvax,pur-ee,uunet}!bsu-cs!dhesi

# Personally, I tend to distrust approaches that depend on the compiler
# being "smart".  Typically compilers aren't.  E.g. it is widely know that
# a smart compiler can implement tail-recursion with a tight loop and eliminate
# the recursive procedure call.  However, I only know of two compilers that
# actually perform that optimization.
#
# Building an Ada compiler so that it passes the verification suite is
# such a herculean task that I doubt seriously the compiler writers
# have the resources to spare for clever optimizations.
#
# Also, I would suggest that the size and complexity of the
# Ada language and its compilers could make many usually feasible
# optimizations much more difficult.  I have been told by those in the
# trenches writing Ada compilers that they are orders of
# magnitude more complex and difficult to write than the compilers for
# simpler and more elegant languages such as Algol, C, Pascal, and Modula.
#
#
# Regarding 0/1-based arrays:  Trust me, 0-based is better.  Just get
# used to saying "a collection of N elements, e[0],...,e[N-1]" when
# stating the problem and you'll find it makes the world simpler.
# (You can also say: "a collection of N+1 elements, e[0],...,e[N], if you like.)
#
# I don't advise switching back and forth between 1-based and 0-based, you'll
 make
# mistakes.  I have my theories as to why 0-based leads to simpler programs,
# but I won't state them here.  I do find that the best programmers and
# mathematicians I know seem to agree with me that 0-based indexing simply
# works better in practice.  I think its the sort of issue where only personal
# experience can convince.  To be convinced, you have to try it.
#
# I understand that some of Galileo's contemporaries refused to look through his
# telescope so they could maintain their position that Jupiter had no moons.
# Now, with the renaissance at hand, who wants to program in the middle ages?
#
#-----------------------------------------------------------------------------
# Mark Cornwell                cornwell@nrl-css.arpa
# Naval Research Laboratory
#
# 0,..N-1: the right way ;)