Re: Array mappings

[Richard G. Hash <rgh@shell.com>]

In <3d2qk0$qop@felix.seas.gwu.edu> mfeldman@seas.gwu.edu (Michael Feldman) writes:
> >Fortran friendly arrays would have been a big advantage, but Ada failed
> >for other reasons, too. Some problems were calculating exp(2x) instead
> >of exp(x) (we lost a whole week on this),  not correctly passsing
> >parameters from the 7th parameter on, etc... Yes, I know these are
> >compiler issues, but Ada was blamed for it.

[...]

> Deep sigh. I rest my case. An Ada implementer who really cared about this
> potential market would've delivered compilers that did the right thing
> for this group of customers.
> Mike Feldman

I just can't buy this, and I was there (if you consider seismic
processing an 'engineer' type thing).

I agree that Fortran friendly arrays would have been nice, along with a
couple thousand other things. But they just didn't rate more than a blip
on the map compared to, oh, let's say, working compilers? Ones where you
didn't have to recompile a quarter million lines once a week because the
library structure got hosed up with great regularity (recompiling was an
event which took about 30 hours at the time). Ones where the generated
code was 9 times slower than equivalent Fortran code. Ones where the 7th
argument to a routine didn't end up in the weeds. Ones that had actual
working math libraries that gave the right results.

Let's face it, if you were introduced to Ada in 1986 and were trying
to convert a bunch of Fortran programmers over - you had an uphill
struggle. The compilers were not all that great back then (there were
some exceptions, I'll grant you), and the optimizations were not what
they are today. Fairly or not, they gave the impression of slow, buggy,
pain the the derriere ^&@#$^, and were the butt of many a joke. Can you
not remember back?

On machines like the Cray, the Fortran compilers were superb, and you
could tune a piece of code so tight it would make your head spin. The
Ada compiler(s?) available just could not compete very well.

I don't think the compiler vendors weren't trying, it was just a matter
of scale. Vendors had been tuning Fortran compilers and their code
generation for a decade or more, Ada was new on the scene, and I think
it was a little tougher to implement than many folks thought.

By and large, to the Fortran community, it was a matter of "why
bother with the hassle", things work well enough as they are.
I would like to think that things are quite different now.

--
Richard G. Hash                                      email: rgh@shell.com
Shell Development Company, Bellaire Research Center  phone: (713) 245-7311
Member Team Ada                Free Ada94 compilers: cs.nyu.edu:/pub/gnat