Scientific computing has lost the simplicity that it once had. In the 1960s, any serious programming was done in either Algol or Fortran. More basic programs could be written in Basic. During the 1970s, as Algol fell out of use, Fortran became the standard scientific programming language - the lingua franca, for all except specialist applications such as simulation. This was not particularly a result of any superiority of Fortran as a language, but rather the dominance of IBM in the computing marketplace. The result of this is that there is now an enormous volume of 'legacy' code written in Fortran.
However, the introduction of microcomputers and especially the IBM PC during the 1980s threatened Fortran's position. The initial problem was that Fortran was a compiled language and not well suited to the new interactive computing style. Basic, as a simpler interpreted language, was seen as more suitable, though its flexibility and power - and the processing speed of Basic programs - were all inferior to those of Fortran.
At the same time, however, other languages were also becoming available. The two main contenders were Pascal and C. Pascal was a direct descendant of Algol, and shared its strictly structured approach and syntax. It was definitely a much more elegant language for programmers than Fortran or Basic. However, until its adoption by Borland in the Delphi product it failed to make much impression on the general scientific market. A variant of Pascal, Ada, was restricted essentially to the defence engineering sector.
The other new language, 'C', though less elegant than Pascal, was much more powerful. It was the language in which the Unix operating system was written, and it included all the functionality of an assembly language. However, its high-level numerical processing was rudimentary. A souped-up version of C, named C++, was developed to provide the higher-level capabilities.
With the present day dominance of Microsoft, and its Visual C++ and Visual Basic programming environments, a common perception is that both Fortran and Pascal have entered a terminal decline. Borland's Delphi offers a similar visual programming environment to Microsoft's products, but its market is limited. With Fortran the problems are even worse. There is no standard Windows interface for Fortran programs. There are products such as the Winteracter library and Salford Software's Clearwin+ which give a great deal of Windows functiionality, but it remains that without an integrated visual programming environment, much of the interactive logic must be hand-crafted.
Nevertheless, I believe that Fortran has a substantial future. The sheer volume and excellence of existing numeric and other code that is available only in Fortran should not be underestimated. Furthermore, the Fortran community have quietly been updating the language itself, so that Fortran 90 (and its updated version Fortran 95) now contains fully structured scientific programming capabilities that cannot be matched. The other quiet revolution in Fortran is the development of an active open-source movement similar to that centred on Linux.
The choice of Fortran compilers is now more restricted than it used to be - but that is largely due to disappearance of the manufacturer-specific compilers from the days of the mainframe computer. Nevertheless, a good selection of compilers can still be purchased for the PC (and many are available also in Linux and other versions):-
There are a number of good Fortran information websites - many with free software to download. These include
Information on the evolving Fortran standards can be found at the J3 website: (http://www.j3-fortran.org/). J3 is the US Fortran standards committee, a technical subcommittee of the National Committee for Information Technology Standards (NCITS). J3 developed the Fortran 66, Fortran 77, Fortran 90, and Fortran 95 standards. Working closely with ISO/IEC/JTC1/SC22/WG5 (see "WG5"), the international Fortran standards committee, J3 is the primary development body for Fortran 200x. Fortran 200x is an upwardly-compatible extension of the current Fortran standard, Fortran 95, adding, among other things, support for exception handling, object-oriented programming, and improved interoperability with the C language.
A definition of "European Standards For Writing and Documenting Exchangeable Fortran 90 Code" is to be found at http://www.met-office.gov.uk/sec5/NWP/NWP_F90Standards.html. This is a very useful set of recommendations to be followed by all government departments within the European Union.
One great advantage of continuing to use Fortran is that most of the new compilers are backward compatible to the extent that old Fortran-66 and Fortran-77 code will compile perfectly happily and can be included in new software applications.
Postscript - Letter to Computer Weekly, 9 May 2002
C++ is an applications hazardfrom Peet Morris
As a one-time member of C++ standards group X3J16, I must say that Nick Langley's comment that "C++ is a mid-level language" (Computer Weekly, 25 April) is incorrect and dangerous. C++ is a low-level language designed to act as a portable assembler, ie they can be used to write efficient systems-level code. Moreover, that code can then be taken cross-platform, where another C++ compiler can convert it into a binary. This makes such a language useful for writing compilers, operating systems, debuggers etc. In my opinion, it should never be used to write applications.
Unfortunately, because such languages map so closely to th workings of the machine, C++ may be used to write anything, and, unfortunately, it has.
In the distant past, when programs ran standalone and memory was limited, the efficiency of C++ was very welcome. However, now that machine memory is so cheap, this necessity is no longer required. More importantly, modern programs are no longer standalone, they use system extensions in vast quantities. For example, modern Windows programs spend just 7% of their total execution time in the code the developer actually writes. Therefore, the efficiency of C/C++, when used to write a modern piece of application software is diluted until it almost vanishes.
The language is dangerous and should be used only where it is absolutely necessary. The danger is obvious when one mixes with C++ gurus. One of the first things these developers write (and keep with them) is a templated smart-pointer class. This class is used instead of pointers in the code being developed and is there to prevent (or at least signal) potential memory leaks. The fact that these people carry such a class in their toolkit should ring loud alarm bells.Peet Morris.