Re: Ada vs Fortran for scientific applications

[<adaworks@sbcglobal.net>]

"Tom Linden" <tom@kednos.com> wrote in message 
news:op.tci6xqiizgicya@hyrrokkin...
On Tue, 11 Jul 2006 08:02:47 -0700, <adaworks@sbcglobal.net> wrote:

My comments were not restricted to PL/I, but apply generally to
any compiler, and specifically Ada was intended.  Since I had put
in the scaffolding for producing the info in cross reference listings
I also played with generating precisely the sort of warnings that you
refer to, but found it generated too much "clutter" of questionable
value.  That was my view, FWIW
>
I think you are right about clutter in programs that contain a lot
of global variables.   For example, in a COBOL program, where
the data is organized (pre-OOCOBOL) in a DATA DIVISION,
these kinds of warnings would be clutter.

In other languages with global variables the same would be true.
I recall early Ada programs where the designers would create

       package COMMON is             -- Fortran programmers
       package DATA_DIVISION is  -- COBOL Programmers
       package COMPOOL is            -- CMS-2 and Jovial programmers

thereby thwarting the good programming practices available to them.

However, when these kinds of messages are localized to the specific
module to which they apply, they are quite helpful.   This is especially
true when the language separates the concerns of scope and visibility,
as Ada does.   We can know that an artifact in scope, is never
referenced through a warning.   From that warning we might ask
whether we have that artifact at the right place in a program
design.

The above example of scope is not simply academic.   I recall a
very large Ada project, a weapon system of several million lines
of code, where the compiler did not issue such warnings (in
the mid-1980's) even though it could have.  As a consequence,
many packages were "with'ed" too early in the design.   The
programs worked fine, but those artifacts could have been
brought into scope much later in the design (usually at the
package body level instead of at the specification level) to
improve compilation time and later debugging.   When the
group doing development finally realized this, they were able
to move those artifacts to the correct level of scope.  However,
that early compiler failed to notify them, even though it could
have been designed to do so.   No modern Ada compiler
would fail to take advantage of this capability.

In part, it is Ada's package module and powerful separate
compilation capability that helps make this a worthwhile
feature of a compiler.    Most modern languages, including
Java and C++ fall short in this regard.   Even Eiffel, a
language I like a lot, does not support this kind of thing
as well as I would prefer.

If the warnings are "clutter," so be it.   I don't like to release
a program for production until the clutter is attended to.  I
would rather have the clutter than the unitialized variable,
the inability to produce a program where every artifact
was exactly where it needed to be, and the knowledge
that I did not have formal parameters in a method that
I forgot to use in the computation in that method.

FWIW.

Richard Riehle