On Jul 14, 2004, at 10:15 AM, Paddy O'Brien wrote:

> Drew McCormack wrote:
>>
> [snips of what Bill Long and Keith Bierman wrote]
>
>> I agree with this. There is no doubt Fortran code can be made faster,
>> easier.
>>
> And as has been said several times in this thread, with a smaller and
> easier learning curve.
Agreed. I wouldn't trust C++ with a new developer. Fortran is much
simpler, and less prone to error. (Note that I don't think this has to
do with OO programming in general, just C++. Languages like Java are OO
and easy to use, in my view.)

>
>> One thing which I haven't seen brought up, which is in favor of higher
>> level languages like C++ and Java, is algorithmic performance
>
> I would never have classed these as "higher level".
Depends on your definition of course. But they allow for higher level
abstractions, so I consider them higher level.

>
>> The
>> algorithm you choose can often be much more important than the extra
>> cycles a compiler can save you. An advantage with C++/Java like
>> languages is simply that they are better at abstraction, and this can
>> make writing complex algorithms easier. The fortran version of the
>> algorithm would nearly always run faster, but writing the fortran
>> version may be considerably harder.
>>
> I find it very difficult to agree with this statement.  I've lost track
> of who said what, but several (IIRC, notably James Giles, who is one of
> several whose opinions I value) have said the other way around.  I.e.,
> it is harder to write other than Fortran to mimic what Fortran can do.
> Bill Long of Cray implied that more time is spent (and can be by
> compiler writers) in making Fortran efficient than on other languages.
> Cray being in existence for massive number crunching.
This is certainly true of low-level code. What I was talking about was
higher level abstraction, like representing data structures.
Representing a tree structure in Fortran 77 took quite a bit of skill;
any first-year Java programmer could do it these days, especially since
the libraries include standard data structures. In Fortran 90, with
user defined types, it is easier, but still not as easy as using a
built in tree class or dynamic array.

In my experience, Fortran works great when things fit nicely in
rectangular multidimensional arrays. If you want something more
advanced, you will have to write it yourself. You can do this with
user-defined types, but you better be ready to duplicate your container
code for each element type you want to use (or write your own
precompiler).

A good example, which I often come across, is that of a dynamical
array. You want to be able to add 'things' to the array, and have it
grow itself as needed. No problem, write a user defined type. But then
you realize you not only want to store reals, but integers, or
elephants. Now you have to use dirty tricks like the 'transfer'
function, or precompilers, or you have to duplicate what you have done,
with all the problems that leads to. Contrast this to using a prebuilt
Java dynamic array class, which can take any object, or an C++ STL
container.

This is why I say the other languages are easier for implementing
***complex*** algorithms.

> As an adjunct to Van Snyder's interesting mail, my ex-boss wanted to
> write chunks of code in C, also buying various commercial packages to
> help him. He worked on the code solely, and from about 1994 he
> targetted
> a completion date one year later.  This target date was moved a year
> each year.  In the interim, to give our users something, two of us
> wrote
> a "temporary fix" in GKS and Postscript in Fortran.  That boss retired
> in 2000, his code never surfaced, and the "temporary fix" is still in
> place.
>
> This may not help the OP, but my ex-boss had self taught himself C in
> about 1990, but myself (self-taught Fortran in middle sixties) and my
> colleague (university Fortran in the late 1970's) were able to write
> this in about 2 months.  The vagaries of C kept my ex-boss unable to
> manage much, yet he is a Ph.D in Electrical Engineering, was an expert
> at modelling and had used Fortran from slightly before me
>
> Suggest reading a book from (if spelling is correct) Andrew Koenig
> called "C Traps and Pitfalls".  Again, IIRC, he worked for AT&T Bell.
The problem I always have with these "Here is a story about how
inefficient C is, and how wonderful Fortran is"-type stories is that
they seem to ignore the overwhelming success of C. Sure there will be
cases where, for whatever reason, it has led to disaster. But my guess
is that you are writing your email on a Windows, Linux or Mac, the OSes
of which are all written in C. And an OS is not a trivial piece of
software. Could someone have written MSOffice in Fortran? Maybe, maybe
not. I think you can write bad code in any language, God knows I've
seen enough bad Fortran.

Drew
>
---------------------------------------------------------
Drew McCormack

www.maniacalextent.com