On page 168 of the April 1988 issue of BYTE Magazine, available online courtesy of the extraordinary Internet Archive, we can read an article introducing “two new compilers” for the FORTRAN (still all in uppercase) programming language. On the other hand, page 736, section 10.5, titled “Computer Languages” of the 33rd edition of the quintessential “CRC Standard Mathematical Tables and Formulas” by CRC Press (published in 2018), prefaced with the phrase “Common computer languages used by scientists and engineers,” does not even mention either FORTRAN or Fortran. What happened in those 30 years?
The truth is that Fortran (in whatever spelling) was already on the way out when I started my career in IT, merely 9 years after the publication of the BYTE Magazine article mentioned above. Whatever happened, it was already underway in 1997. The times of John Backus creating the language at IBM were a lonely, distant memory.
We could dive into the reasons why Fortran was pushed aside in the toolbox of most software programmers, but instead we are also going to imagine a world in which Fortran not only never faded away but instead remained a major player in the field. Why not? After all, and I recommend you do that, you can always use apt, dnf, or pkg to install one of the latest versions of GNU Fortran 2023 on your workstation, and you will discover a beautifully simple language, terribly fast, very modern, easy to write and read, and that is perfectly capable of doing anything you want (“Turing-complete,” remember?)
Fortran, against all odds, is still there after more than 70 years since the first program written with it ran on September 20th, 1954. In those pre-historic times, when mainframes roamed the Earth, variable names had a maximum limit of six characters, and variables holding integers must have a name starting with I, J, K, L, M, or N. Talk about Hungarian notation.
And it was more than that: it was actually the language of choice for Real Programmers™®©, as stated in a letter to the editor published in the July 1983 issue of “Datamation” magazine:
The easiest way to tell a Real Programmer from the crowd is by the programming language he (or she) uses. Real Programmers use Fortran. Quiche Eaters use Pascal. Nicklaus Wirth, the designer of Pascal, gave a talk once at which he was asked, “How do you pronounce your name?”. He replied, “You can either call me by name, pronouncing it ‘Veert’, or call me by value, ‘Worth’.” One can tell immediately by this comment that Nicklaus Wirth is a Quiche Eater.
(I guess we should be thankful the author added “or she” to their description of Real Programmers.)
How little has the industry changed in 43 years? Le sigh. Where was I? Ah, yes, trends.
The first hype train that Fortran arguably missed was, let us be honest, object-oriented programming. To be taken “seriously” in the 1980s, you needed to support objects, and there was no way to avoid that. And the first Fortran standard that actually did that came in 2003… that is, 8 years after Java had eaten the whole OOP cake.
Imagine if Fortran OOP features had been available in 1990 already. Polymorphism, inheritance, encapsulation, and so many other buzzwords that the Gang of Four, the Three Amigos, and many other jazz bands of the era were so happy to repeat ad nauseam at each conference. But Fortran had already been slow at introducing structured programming in the 1970s, so the inertial forces that drove its evolution were already at play decades before.
That is probably the most important reason why Fortran missed the OOP hype train: its committee-design nature, which involved particularly long discussion sessions, sometimes seemingly endless ones, in which little or no progress would be made. Mark Jones Lorenzo, in his 2019 book about the history of Fortran, induces deep sigh after deep sigh in the reader while enumerating the various moments into which the language slipped into oblivion. There were many, and they are all unfortunate.
(Actually, no, scratch that: it was not that the committee was slow; it was also that the industry moved at an incredibly fast pace. To give them some credit, it was not entirely their fault. Driven by marketing and hype, the best was buried by the popular, as is usually the case.)
I would argue that the web was the second big trend that Fortran missed; fast-forward to 2026, where are the server-side frameworks to build REST APIs in pure Fortran? There was one available framework out there, called Fortran.io, but I have to point the user to a snapshot on the Internet Archive (again) from May 2026, because the owners of the domain let it slip away, and now somebody has cybersquatted the domain with some gaming stuff you do not want to see.
The web was my first contact with IT in 1997, and it was a domain where you would use C++ to build browsers, JavaScript to add pizzazz to your web pages, and Java to build backends. Well, and (sadly, may I add) also VBScript, which was the choice for quick-and-dirty database-backed websites (or “3-tier architectures” as we called them back in the day) in a world of Microsoft NT-powered servers crippled with Back Orifice exploits. There was no Fortran in sight. Nothing at all. Nope. Nada.
I let you choose between the possible third (and following) missed trains: in no particular order, we can imagine a world where Bitcoin and other cryptocurrency brokers were created and ran with Fortran. Or another in which developers could create iOS and Android apps with it. Or where developers could run Fortran-based APIs in their Kubernetes cluster (see above). And another where Jupyter Notebooks would run Fortran kernels natively (ok, this last one actually is possible, thanks to the LLVM-based LFortran project), and this would have displaced Python as the default language for AI applications and scientists.
It is all sad indeed. Python (arguably, mostly through NumPy and SciPy) ate Fortran’s lunch and ruthlessly pushed the old man aside, with bad manners and leaving the scientific and engineering communities to deal with a (let us be honest here) slower language (oh, but it is interpreted, not compiled. Big deal.) Did Fortran deserve better? Yes, of course it did. Was the Fortran committee up to the task? Hardly.
Not all is lost, however. The LLVM Fortran compiler has been officially available since last year. Intel is still distributing and documenting its Fortran compiler… and there are more compilers available if all else fails. NASA is still heavily using it. It is still very much used in high-performance computing (HPC) applications. Compilers compatible with the 2023 standard can compile FORTRAN 77 programs without problem. And for whatever it is worth, Fortran made it to the 10th position of the TIOBE Index in May 2024 (at the time of this writing, it is still featured in a very honorable 19th position.)
Fortran is still compiling and still running, and this is for the foreseeable future. The community around the language is still strong, vocal, and active, seemingly “resurrecting” the language and keeping its legacy alive, hopefully with stronger will and more agility than the previous generations.
A 2022 paper titled “The State of Fortran” (freely downloadable from arXiv) summarizes the situation in much better words than this article ever could, but suffice to quote the following:
Fortran is perceived in some software development circles as archaic, lacking the features and conveniences of newer languages, and characterized by an obtuse syntax. However, such considerations typically stem from a lack of familiarity with Fortran standards later than Fortran 77.
Say it again louder for the ones in the back. Also, I do not know who needs to hear this, but just in case: in Fortran 2023 you can have variable names longer than six characters, and integer ones do not need to start with I, J, K, L, M, or N.
For a language still supporting the GOTO keyword, Fortran was much luckier than BASIC ever was.
Cover photo by NASA Hubble Space Telescope on Unsplash.