Re: ARIANE-5 Failure (DC-X works)

[dewar@cs.nyu.edu (Robert Dewar)]

Samuel says

"Other posts have said the code was generated with MatrixX.  I haven't
used MatrixX, but others at my company have, so I'll try to describe it.

MatrixX isn't a language.

It's a tool that uses a graphical notation, including some standard
graphical notation for math.  You can think of it as a 4GL for
scientific calculation."

Of course it is a language, any notation is a language. Yes, it is reasonable
to think of it as a 4GL for scientific calculation. What do you think the
L in 4GL stands for.

The people writing this *are* programmers, they are programming. There is
no difference between a program and an executable specification. In fact
that's all a program is -- a specification of what needs to be done with
a method for automatic translation into a machine that does the task.

And if the people who write the MatrixX code don't maintain it, who does?

Samuel's post is a perfect companion to mine, because it shows how 
widespread the confusion is about the use of high level programming
tools.

In particular, people often thing the Ada mandate is being obeyed if the
generated code from such a tool is Ada. In fact if this generated code
is not maintained or looked at, there is absolutely no reason for it
to be in Ada, and no particular advantage in it being in Ada. The
policy of using Ada applies to the INPUT, not the OUTPUT of the programming
effort, so in this particular case, if the Ada policy applies, a waiver is
needed to program part of the aplication in MatrixX instead of in Ada.

Assuming that MatrixX is being appropriately used, and the application 
really is taking advantage of the leverage that can be obtained from the
use of such high level tools, and that the tool itself meets requirements
for reliability and maintainability, then this is undoubtedly a clear case
for a waiver.

The trouble is that the assumption tends to be that the mere fact that
something is written in a 4GL means that these criteria are met, when
the reality is that a lot of 4GL code is low level junk written in
totally inappropriate, ill-though out languages.

The use of very high level languages is a very important advance in
proramming technology, one that has been very slow in coming, but the
notion that somehow this eliminates the need for programming of
programmers is absurd and likely to lead to bad decisions.

Lambert Meertens once introduced the notion of VHLANOS, "very high
level abstract non-operational specifications", and pointed out that
one of the ways in which programming progresses is that yesterdays
VHLANOS becomes today's progrmming language.

For example, in the days of machine language programing, a simple 
algebraic expression like (a * b) + (c * d) seems like VHLANOS, but
when Fortran came along, it became programming. The rhetoric about
not needing programmers or programming any more was common as Fortran
was introduced -- at last we don't need to rely on programmers (where
the image of programming is messing with machine language), now our
scientists can do the job themselve without programming).

Yes of course, the people programming in MatrixX are not Ada programmers,
and are operating at a different level of abstraction, but they are still
programming! To describe it otherwise is confusing and damaging.