Nifty Fifty!

2007 will mark the 50th anniversary of the Fortran language, which was first introduced in 1957. The British Computer Society is sponsoring a retrospective on Fortran in January - perhaps there will be a US event as well.

Like most programming languages, Fortran, or FORTRAN as it was known back then, has gone through a lot of changes. From 1957 until 1966, when the first ANSI standard for Fortran was approved, various vendors and compiler writers had their own idea of what Fortran ought to be, and with different names. There was FORTRAN II, FORTRAN D, and many more. Some constructs from those old versions are gone from modern Fortran, such as the FREQUENCY statement (used to give the compiler an idea of how often a section of code would be executed) and SENSE to read those switches on the front panel.

1966 brought us ANSI X3.9-1966, otherwise known as FORTRAN IV (or FORTRAN 66). The text of the standard was a whopping 36 pages, but it was a revolution in technical programming as it was now possible to write and share lots of code knowing that it was likely that others, with computers from different vendors, could use the code too.

The next revision of the Fortran standard was FORTRAN 77, or formally, ANSI X3.9-1978. Here, 1977 was the year that the standard was frozen and 1978 the year it was approved. The language had grown quite a bit, largely by formalizing extensions that many vendors had added to FORTRAN IV, such as OPEN and the CHARACTER datatype. The FORTRAN 77 standard included both a full and subset version of the language, the subset intended to be easier to implement. In practice, everyone ignored the subset and the idea was dropped from future standards. The FORTRAN 77 standard, excluding the subset, was 260 pages.

Soon afterwards, work started on the next iteration of the language, initially called FORTRAN 88 (given that it had been eleven years between the previous two standards, another eleven seemed appropriate.) As time dragged on, 88 turned to 8X and it eventually became known as Fortran 90 (ISO/IEC 1539:1991(E)). This is when FORTRAN formally became Fortran and the language added lots of concepts from other whippersnapper languages such as Ada. Fortran 90 was much more language invention than standardization of existing practice, and it took a few years for most compiler vendors to fully support it. The printed standard numbered 388 pages.

At this point, the Fortran standards committee realized that it would be best to update the language in a minor way in a few years, to accomodate issues brought up during the past standardization, and then to schedule a big revision some years after that. Fortran 95 (ISO/IEC 1539-1:1997) was a minor revision that did not add a lot of new features, but it did borrow constructs such as FORALL from a dialect called High-Performance Fortran that never really did take off.

The next big change to the standard was called, for a long time, Fortran 2000. Well known computer science researcher C.A.R (Tony) Hoare once famously opined, "I don't know what the programming language of the year 2000 will look like, but I know it will be called Fortran.") Again, a lot of new invention went into this language and it was clear that the goal of freezsing the standard by 2000 would not be met. Eventually, it became Fortran 2003 (ISO/IEC 1539:2004) and the printed standard stood at 585 pages - some sixteen times the size of FORTRAN IV.

The current state of things is that nobody has yet produced a full-language Fortran 2003 compiler. NAG is probably going to be first with a "reference implementation", as they have done so in the past. IBM is well along the way in their xlf compiler, and of course Intel has made significant progress as well. But it is likely to be several years before full Fortran 2003 compilers become commonplace.

And what's next? The Fortran standards committee is already firming up the feature set for what is being called Fortran 2008. One of the proposed features is Co-Array Fortran, a way of extending the language to provide parallel processing semantics in a way rather different from the industry standard OpenMP. Interesting times are ahead.
For more complete information about compiler optimizations, see our Optimization Notice.

3 comments

Top
Steve Lionel (Intel)'s picture

>From Peter Crouch, concerning the Fortran 50th anniversary meeting in London:

I am pleased to tell you that we had a very successful meeting in London on 25 January. Of the 60 or so people who had expressed an interest in attending 57 signed in on the day, including two delegates from Sweden and one from Germany.

Almost all the presentations and other contributions to the meeting are now on the BCS Fortran Specialist Group website and are available from http://www.fortran.bcs.org/2007/jubileeprog.php . There is a link towards the bottom of the page to some photographs which were taken at the meeting. David Muxworthy, Vice-Chairman of the Fortran SG, has written a report of the meeting which is due to be published in the April issue of the ACM's Fortran Forum, I believe.

anonymous's picture

A couple of years ago, I had the opportunity to program on a Cray X1 with Co-array Fortran. I liked it. It is a very elegant and straightforward way of abstracting the processor-to-processor communication using syntax that should be easy to pick up for most Fortran users.

Later on, I switched to a cluster environment and recoded the processor-to-processor communication in MPI. With MPI, I had to be very careful about types/rank/sizes, which is easy in theory, but can be annoying in practice, especially when you're collecting or distributing data (non-uniformly!) across multiple processors.

I would definately choose CAF over MPI so long as it was implemented correctly. There's so much abstraction going on in CAF that if something went wrong behind the scenes you wouldn't necessarily know what was causing it (deadlock, asynchrony, etc). On the other hand, the initial coding is probably a lot quicker!

My two cents!
-Howard

anonymous's picture

Some claim that Fortran is even a couple of months older as the Fortran (not FORTRAN [on the title]) programmer's reference manual is dated October 15, 1956; see http://www.fh-jena.de/~kleine/history/languages/FortranAutomaticCodingSystemForTheIBM704.pdf

But according to the BCS, which Steve cited, the presentation and the release were indeed in 2007.

The transition from Fortran 77 to Fortran 9x marked also another, though more gradual, transtion: Before all compilers had several extensions, heavily used in by most Fortran programs. With Fortran 9x the adherence to standards by both the compilers as by the programmers increased a lot. Most programmers want to have nowadays Fortran 9x programs, which can be run everywhere. Another thing which also greatly improved is the error checking by the compilers. (Although my knowledge of Fortran 77 compilers is limited to little g77 usage.)

Part in the slow adaption of Fortran 9x was that no free f90 compiler existed. (g77 was widely spread, that way one could use it on the Linux/FreeBSD box and had the good ones on the big machines.) Intel actually helped - in my opinion - a lot by providing a free non-commercial Fortran 95 compiler (though less free than many researchers think). Now with two GNU Fortran compilers ("Just as with buses, so with Open Source compilers for Fortran95: you wait ages for one, then two arrive at once." - Clive Page), the free Sun compiler and the limited-free Intel Compiler one can expect (hope?) that more people a drawn to Fortran.

Fortran 2008's co-arrays look like a nice feature since they make it easier to create a parallel-runnable program for distributed memory machines. I know a couple of programmers (at universities), which use OpenMP, since this makes it easy to go from a single to a multi-threaded program, and which do not want to go beyond and create a MPI version of their program.
However, the big question is how long it will take until a large chunk of Fortran compilers will understand co-arrays (and be it only on the level to create a single-threaded program)? Nowadays, three years after Fortran 2003 has been released, most programmers still try to be only Fortran 95 compliant and interesting features such as Bind(c) or IEEE are not yet supported by all mayor compilers.
Thus the interest might be there, but maybe a cluster-enhanced OpenMP will be more important as it is already supported by many compilers (on shared-memory systems) and Intel's cluster OpenMP even supports it on distributed-memory machines. (Let's see what OpenMP 3 will bring.)
Adding things like the error and Bessel functions are overdue, however.

Compared with the other commentators and Steve, I'm really new to Fortran: I started with Fortran in 2003, using the Intel compiler [and missing a GNU compiler at home] - and I'm extremely successful in turning any Fortran 77 program into a Fortran 9x or 2003 program in minutes. (That I had for a while only J3's Fortran 2003 draft didn't help with staying with Fortran 9x or even 77 commands. Now I have http://gcc.gnu.org/wiki/GFortranStandards and as great reference Metcalf/Reid/Cohen's fortran 95/2003 explained.)
Currently, I'm involved in a couple of programs (in academia) which strive for Fortran 95 compatibility and I use Fortran 95 + some 2003 bits (e.g. command-line arguments) for my small utility programs.
My primary compiler is still ifort, but especially gfortran is gaining some ground. NAG f95's is my checking compiler (best diagnostics and F95 conformance checking, F2003 features). (Plus some other compilers to check or to run on other platforms.)
Using several compilers I can really recommend. That way I found already countless programming errors, a couple of compiler bugs and filled also some feature requests of things I missed in one compiler and found in the other [or in none].
(In gfortran I even fixed some tiny bugs myself ;-)

Tobias

Add a Comment

Have a technical question? Visit our forums. Have site or software product issues? Contact support.