Re: Why don't large companies use Ada?

[mfeldman@seas.gwu.edu (Michael Feldman)]

In article <D07zvq.L3p@alsys.com>, Keith Thompson <kst@alsys.com> wrote:
>In <3bo4il$3lb@felix.seas.gwu.edu> mfeldman@seas.gwu.edu (Michael Feldman) writes:

>I'll take your word for this, but I still find it difficult to understand.
>If you're writing new PL/I or Ada code to interface to existing Fortran
>libraries, all you should need to do is swap the indices; there should
>be no need to physically transpose the arrays themselves.  

Yes, that's true. The transposition is mental. 

Don't take this personally, but the "all you should..." attitude is, in 
my experience, quite typical of computer folks who don't understand, or
don't want to understand, what it takes to get a customer to buy.
They don't focus on making it easy for the customer, by _really_
understanding the customer's needs and mentality.

>This should
>be only a small fraction of the effort required to interface to Fortran
>(for Ada, matching the types and writing the Interface pragmas; for
>PL/I, ???).  Could it be that the engineers were using this as an excuse
>to stick with Fortran, or am I missing something?

You hit the nail right on the head. Of course they were using it as an
excuse. And IBM apparently did not understand the extent to which non-
technical considerations affect a choice of language. 

In my experience, interfacing between languages - certainly for the
kind of fairly simple vector/matrix interfaces the typical Fortranner
would use (the _subprograms_ aren't simple but the _interfaces_
tend to be) - is, to a very large extent,a matter of getting the
data structures to agree. I don't understand your "small fraction"
assertion. 

There are big Fortran libraries out there (e.g. IMSL)
whose interfaces consist of a couple of arrays and (maybe) some
bounds parameters (which in "pure" Ada would be handled by
unconstrained array types). An engineer trying to use these
from PL/1 would have to keep all his arrays in transposed form,
which would make his new PL/1 code look pretty unintuitive -
what would naturally be a row suddenly becomes a column.
Why bother, if nobody is forcing you to use PL/1?

The Ada community could have observed this phenomenon, and gone
after those engineers with an Ada 83 equivalent of Interfaces.Fortran
and Pragma Convention. Nothing in LRM83 prevented an implementer from
doing it. To my knowledge, not one vendor thought all those engineers
in (say) the Fortran-dependent DoE labs were worth supporting.

My offer is still open: if _one_ implementer steps up and says "Mike, we
_did_ take a serious look at that community and our market studies
showed that it wouldn't pan out", and gave a reason or two, I'll
promise to get off the hobbyhorse.

That Interfaces.Fortran and Pragma Convention exist in Ada 9X tells me
that _somebody_ is now taking this issue seriously. All the more support
for my assertion that we should have taken it seriously 10 years ago.

Mike Feldman