Fortran is not FORTRAN

Fortran is not FORTRAN.

I regard Fortran as a different language that conveniently benefits from the abundant libraries in FORTRAN without bearing the historical burden.

See Fortran - Wikipedia.

When people mistakenly claim that PRIMA is in FORTRAN, I responded as above.


I am not sure if I would go as far as call them different languages, but they are definitely products of different times. One being substantially more evolved than the other, and we should strive to make that difference clear.

I remember having a chat , almost 2y ago, with a project manager for some nuclear fusion codes and how it’s difficult to maintain legacy codes because they are written in Fortran. Imagine his surprise when I told him they are very well written Fortran 2008+ and that Fortran /= FORTRAN!


Strangely, the upper case is smaller than the lower case… :upside_down_face:
Fortran > FORTRAN

Having a long history is difficult in computer science… You are considered like the poor Neanderthal… Maybe modern Fortran should have been renamed Fortran++. Or Fortran** to use its syntax (Fortran two stars or Fortran too star?).


Fortran is a re-branding of FORTRAN with the introduction of modern features and removal of limitations of f77.

Fortran$$: Learn Fortran, get rich.


I think of Fortran as a superset of FORTRAN.

I don’t care anymore if people write FORTRAN when they meant Fortran, since that’s what they know. The best we can do is correct and carry on. It takes a generation to change this.


I did, it failed…


Given that Fortran was introduced in 1990, I would say it takes 2 generations, possibly 3.


Elsewhere, we are still fighting LISP vs. Lisp. I think they started using “Lisp” in the late 70’s (e.g., the “Lisp Machine Lisp Manual”.)

I was in a graduate class last term where it still was written as “LISP” on all the prof’s slides.

Maybe 3 generations. Maybe 4. Maybe never. Perhaps it should be treated as a microaggression. Putting Lisp and Fortran in all-caps feels like a put-down to me.

1 Like

I had a teacher who went ballistic when some poor student called a liquid crystal display an “LCD display”. :grin:

Let him chew on WINE: WINE Is Not an Emulator.

1 Like

What is “Fortran” ?
For some of us, it could be the major changes that Fortran 90/95 introduced to FORTRAN. Significant changes included:

  • Free format
  • allocate and dynamic arrays
  • implicit none
  • module
  • derived types
  • array syntax

But other changes, not so much:

  • kind did not address what IEEE 754 has achieved
  • libraries can be placed in a module, but this ignored the strength of libraries in FORTRAN.
  • Array sections have caused many problems for contiguous memory
  • FORALL and later DO CONCURRENT have both failed as they were only a part of a solution for HPC

Then there are other very significant changes that have come since, especially the introduction of OOP, which has dramatically changed the style of Fortran, but has not really propelled the promence that FORTRAN achieved in the 20th Century.

So perhaps we could say the latest Fortran is not Fortran. What does this mean for the future ?


I have a different perspective on all of these. First, IEEE 754 came before f90, not after. The KIND system was introduced in f90 as a way for programmers to write portable numerical codes, something that was difficult, or even impossible in some ways, with f77 and earlier versions of the language. I do not know of any major conflicts between the IEEE conventions and the fortran KIND system. Indeed, since 1985, the IEEE conventions have expanded in various ways, including 128-bit and 16-bit formats and also decimal formats. All of these are consistent with the fortran KIND system, which just shows how powerful and open-ended the idea was in the first place.

I’m unsure of the meaning of your library comment. As a practical matter, the object files that are created when a module is compiled can be placed in an object library, just like object files that are created when external subprograms are compiled.

I would say that the requirements for contiguous memory have caused problems with the use of array sections, not the other way around. It works, in a technical sense, within the language, but it sometimes requires inefficient copy-in/copy-out to occur. This requires the programmer to know the details of his compiler in order to write efficient code, something that a high-level language should strive to avoid.

The FORALL and DO CONCURRENT constructs were never expected to address all aspects of HPC, they were intended from the beginning to address only part of the HPC issues. Some of the remaining issues are addressed by fortran coarrays and OpenMP, the former being a distributed-memory approach and the latter being a shared-memory approach. Modern HPC architectures are likely to require both approaches working together, a complicated and demanding approach on the programmer. Other HPC issues involve GPU programming, which overlaps somewhat with ongoing DO CONCURRENT and OpenMP efforts, but which also requires more general support.

In general regarding the thread topic, I agree with the comments above that Fortran is the modern version of FORTRAN. The language has evolved in a mostly forward-compatible way over the last seven decades.


Indeed, the Fortran 90 standard introduction states that:

With limitations noted in 1.4.1, the syntax and semantics of the International Standard commonly known as “FORTRAN 77” are contained entirely within this International Standard. Therefore, any standard-conforming FORTRAN 77 program is standard conforming under this International Standard.

There are just five points in 1.4.1, and two of them are processor dependent.

Therefore, it is quasi-true that \text{FORTRAN} \subset \text{Fortran 90} . That standard also introduced a section “B.1 Deleted features” but it was still empty, and began to be filled only in Fortran 95.

A fun fact is that in Fortran 90, “FORTRAN 77” is written with a small caps font, although it was in capitals in the FORTRAN 77 standard. Another rare exception I know was in the Programmer’s Reference Manual (October 15, 1956), which used also small caps in its text.