I used to work on software that still uses Fortran from the 50's and is still in maintenance and use today. IIRC, it had ~700kloc of Fortran. It may be the oldest and largest Fortran codebase still in use.

My first project there was removing all of the Hollerith from the code. Since Fortran predated strings, you had to manipulate them as integers. When you tied that to the original Fortran dynamic memory system, Dynosour, which used equivalenced arrays as pointers, it was a disaster.

It also gave me an appreciation for JavaBeanFactoryFactory. The original Fortran limited identifiers to six characters, the first of which indicated whether the variable was an integer, logical (bool), or real (float). I will take a 100 character name over ILBNK1 every single time.

GOTOs were surprisingly not a big problem, but structured code is definitely a bit easier to read, especially since it brought the practice of indentation with it.

Overall, it was a great experience but I wouldn't want to do it again, even if the work was interesting.

The Computer History Museum collected an oral history[0] of John Backus[1] and there's some discussion about what computing was like when Fortran was created.

I really enjoy CHM's oral histories. I'm slowly working my way thru all of them and there are some real gems in there (Ken Thompson, Dennis Ritchie, Margaret Hamilton, Gordon Moore, Fred Brooks, John Warnock, etc).

[0] https://www.youtube.com/watch?v=dDsWTyLEgbk

[1] https://en.wikipedia.org/wiki/John_Backus

FORTRAN was a very important language for me.

Growing up on early micros, with BASIC, my father had Fortran for the TRS-80.

I took a stab at learning it, but the documentation was reference for calling the compiler, not so much learning the language. And when I found a FORTRAN book, it was quite dated and talking about things like tapes and punches and what not.

So, that effort stalled.

But, my first quarter in college, I took a FORTRAN (77) class. FORTRAN taught on the schools CDC Cyber mainframe.

This was quite a change from 8-bit PET BASIC.

But, most importantly, it was exposure to much of the same concept that an 8-bit computer has, but from a different tact.

This gave me more of a way to view things from a higher level, since I had to make them fit the two different views of how FORTRAN looked at things, how the Cyber presented things, and how BASIC and the PET were "same thing only different".

It also gave me access to a multi-user system, and all of the interesting capabilities it offers.

I remember when they put in their first lab of PCs, and how they started teaching folks Turbo Pascal on micro computers, and I just felt that the users were missing out on a bigger world. "Anyone" can access a PC or micro computer at home, but mainframe or multi user mini access, not so much. It's just a much bigger world out there, and we tend to baby duck what we first see.

Different world today, never had to use FORTRAN professionally, but I am most grateful for the experience of learning it and its environment. Very powerful medium for broader learning.

Also FORTRAN was the only notable computer thing I had "taught" to me (outside of my 20 minute introduction to BASIC by my high school teacher), pretty much everything else I self learned from books and such, even knowing the bulk of it before taking classes in school.

I wrote Fortran for my first job as a software developer in 2018 for simulation solvers. Still like the language! Modern fortran is very very fast and much nicer to use than C for linear algebra. So in my opinion for numerical calculations it remains the best language, even today. Happy Birthday!

I have a lot of fondness for the language. When I was in college, there were a series of three 1-hour language intro courses. (C++, Lisp, and Fortran). I took all three. Lisp is the only one I use these days, but the Fortran class made an impression.

It was one of the last courses, and we were discussing optimization techniques for matrix multiplication. There were the usual three nested loops and the instructor started talking about memory access patterns and stride through the arrays. He re-nested the loops, showed the improvement in access patterns, and pointed out that the compiler itself could do that automatically. (Not to mention vectorize, etc.)

This was around mid-90's, and it gave me a strong appreciation for the fact that simpler languages can be easier to reason about, transform, and optimize. If I'd spent most of the class wondering why the language was as limited as it was, that one session gave a good explanation why it could be viewed as a strength.

Parallel to all of this, I worked a few summers for a major electric utility company. They had a cluster of Cyber mainframes (Descendents of the CDC 6600) that they used to run the grid in real time. Everything was in Fortran (77?), and the shop had a number of people well versed in the language. I didn't a whole lot of direct experience, but it was interesting to see. One thing I do remember is that the memory/disk layout of the data structures were fixed at build time. They ran quarterly builds to update the layouts to add fields, etc. and made do in the interim. Between the constraints of the language, the hardware limitations, and the need for hard real time requirements, there wasn't a lot of room for flexibility.

The company I work for, has a subscription to O'Reilly. While searching for something "side", unrelated to day by day job, I ran across the beautiful book "Modern Fortran". The Fortran in the book (2008+ standard)is very different from the clumsy lectures of F77. It is a beautiful language. I'm sold.

PS: The book creates a tsunami calculator and evolves it by adding Modern Fortran features chapter by chapter.

Bill Sky the Fortran guy on Youtube is another very elementary but excellent presentation.

There is an increasing amount of material out there and the people on Fortran Discourse are very knowledgeable and helpful.

Used to man the free help desk for programming problems at the uni computing centre I worked at. "Have you got a current listing of the program" got rid of most of them.

Saddest case was a PhD student in chemical engineering near the end of his thesis work struggling to get reproducible results. After half an hour of debug I realised he was using un-initialised Fortran array state for his data. I suspect his discovery went up in smoke.

Having written an open source Fortran library (for x ray scattering and absorption in a particular regime so this is fairly “niche” shall we say), genuinely curious: what if any advantages or strengths does Fortran have these days over other language choices? Are there circumstances where it’s arguably the “right” choice?

I started off programming in FORTRAN in my first job, 40 years ago. There was a lot of terrible stuff in FORTRAN from a software engineering point of view: COMMON blocks, GOTOs, ENTRY points (to enter a subroutine part way through!), but it was one of the first high level language and language designers had a lot to learn.

At some point I was quite interested in how the very first version of FORTRAN looked like, so I wrote a FizzBuzz [1] in it.

It was a very bare-bones language, felt more like a high-level assembly macro language. One thing it did well was expressing formulas with the usual "mathematical" notations (+,-,*,/, parentheses to group operations, variables). I guess this was revolutionary at the time. But the control structures were very limited, everything was basically jumps and gotos. The IF was merely a syntactic sugar for conditional jumps. Of course, functions did not exist in the language.

[1] https://mveg.es/posts/fizzbuzz-in-fortran-1/

An ex got me "A Fortran Coloring Book" years ago while I was working with astronomers. I was still in grad school and it gave me an excuse to learn it.

In the mid 90s I used Fortran to model a distillation column in a chemical engineering plant. Here I read that it is still the go to language for nuclear engineering. I am amazed but for some reason happy about this.

One of my favorite stories was my walking past a PhD math guy agonizing over a bug in his massive Fortran code. The print out was two inches thick. I made my usual comment, not even slowing my pace as I walked by his desk…. something like: that comma looks like it is in column 80 on your list of passed arguments. Well, that was his bug and I think I forever got more respect from him than I ever deserved.

More precise:

Many years of FORTRAN. Followed by many years of Fortran.

I wanted to learn Fortran in the 1990s and borrowed a Fortran book from the university library. On the first or second page it stated "To mark comments, just punch a letter 'C' into the first column of the punch card." I returned the book and never learned Fortran.

Having said that, so many foundational libraries were implemented in Fortran (BLAS, LINPACK/EISPACK, LAPACK, MINPACK, FISHPACK, FFTPACK, etc.) - thanks for that.

I never used FORTRAN 77 (which I'm grateful for) but I enjoyed using Fortran 95 a few times in the early 2000s. Apart from the I/O stuff which always felt clunky but I was also very inexperienced in those day (now I would just wrap it in a Python library). I did try to use it a couple of years ago for a personal DSP project but had a problem finding libraries that were up to date/modernised and so I didn't get very far. I know that there's fpm now but it was just before that happened, maybe I'll try again.

Right out of college, I wrote my first ray tracer in Fortran in the mid-80's at the Xerox Research Centre of Canada. I remember the setup being a VAX 11/750 with a RasterTech color monitor (512x512 if memory serves). [0]

My implementation was based on David Rogers' "Procedural Elements for Computer Graphics", one of only two texts available on 3D graphics, the other being Foley and VanDam.

I remember managing my own stack in a language which didn't support recursion. I learned a lot. Good times.

[0] https://medium.com/@kaveh808/8-summer-at-xerox-in-24-bit-col...

Circa 2013, one course in our masters program (hydrogeology) allowed us to pick and choose an assignment question. There was a 5000 word essay (can't remember topic) or build flow models using analytical solutions and discuss their limitations. Most people picked the former while I picked the latter. Bugs werent penalised as the ultimate secondary lesson was about "black boxes" and never to rely on numerical model outputs without calculating analytical solutions to verify by hand.

Happy birthday! I think this has to be the oldest programming language still in use. 70 years is quite an eternity in the sphere of computing. Before Fortran, there was (almost?) nothing but assembler and plug board connectors.

People sometimes scoff at computing languages as old as Fortran, but they should realize Fortran has remained relevant because it's still really good at what it does. It's syntax for mathematical operations is head and shoulders above most more recent languages. It's fast and offers great control of the hardware too. Even today, if you want to write a numerical simulation that's heavy on the math and hard on the hardware, Fortran should be considered.

Everyone who has used it also has horror stories though. It is a very old language and sometimes artifacts pop up. One time I was parallelizing some older code and ran into an infuriating bug where it seemed like some boundary conditions just weren't being passed properly. There were no compiler errors or warnings. Some MPI commands were simply being ignored, but not others. It turned out that the jank-ass compiler I was using for the project had decided to go into Fortran-77 mode (without saying anything) and stripped them out in the precompiling stage (without saying anything) if they were longer than the 72 character limit that Fortran-77 had. I was coding on a computer new enough to have no CD or DVD drive, but was running into the character limit of a 60's punch card system without knowing it!

It's 30 years since I last used Fortran to pass my Civil & Structural Bachelor's and Masters. Loved the simplicity of it, modelling spring stiffness in concrete and steel piles hammers into the ground and tie rods being pulled out of their grout anchors. However, what blows my mind is that something I did on a 386/ 486 as a 3-6 month research degree is now modelled by AI and run on my desktop in minutes.

My first job programming was in a geophysics lab. I had to read fortran 77 codes and write in some slightly more modern variant (I can't remember now which). They were simulating the Earth's mantle and used it because it was fast.

Have people moved on from Fortran 77?

It was frustrating that, 30 years after Fortran 77, professors were insisting in writing in that dialect. Thank God I escaped that hell.

Edit: Since people don't understand my point - I'm well aware of the existence of newer Fortran standards. But in much of academia, the professors insisted on sticking with Fortran 77.

I studied Fortran at university (1985-1988) and got a first in that course module. I quite enjoyed it.

I often consider getting back into programming and a few years ago, when I rejoined USENET and started looking around, the Fortran newsgroup `comp.lang.fortran` was active. The community there was as welcoming and supportive as I've met, and I got some interesting info.

I knew FORTRAN 77 and looked at some FORTRAN IV code. Now it's a very different language indeed -- I can't read the modern version at all, it's totally unfamiliar -- but you can still write old-style code in the new language, or mix in some new features in older-style code. It looks pretty good, TBH.

My second university co-op placement, which led to my first real job of 16 years, included writing a FORTRAN 77 compiler front end. It's crazy by modern standards; in some cases you have to see as far as the second-last character of a multi-line statement to determine what kind of statement it is.

I learned programming in FORTRAN II on an IBM 1620 in 1965.

FORTRAN is also the origin of using 'i', 'j', 'k', etc as loop variables in code, since 'i' was the first variable name that could be used for that purpose. The original language design was constrained by very primitive computers.

There is one under-appreciated aspect of Fortran.

Here is something that started as a specification of the input format of one particular program-tool. That input format was then cloned and mutated by dozens of me-too program-tools. Eventually that format was able to support an interpretation as a language with its own language-like abstractions. That is astonishing and I think was not on the radar of computing machinery people in the 50s.

It's crazy to think that any programming language is that old.

One of the most "fun" things with Fortran is the EQUIVALENCE stmt. It specifies that two variables share the same memory, even if they are different types. You can also do array equivalences, so:

  INTEGER ARR1(10), ARR2(5)
  EQUIVALENCE (ARR1(6), ARR2)
  ARR2(1) = 10

A not very well known fact: older versions of the numpy python library still require Fortran for its build process. I think newer versions don't need the GNU Fortran compiler any longer.

https://numpy.org/doc/1.19/user/building.html

I learned Fortran 77 in 1988, oh weird memories

After learning Pascal I thought fortran was definitely strange and moved on, never to touch it again

I'm from Norway and as many may already know, we are above average curious about what happens out in the sea - because of oil mainly. There is a lot of research and simulations and stuff going on in that field, and most of that is still based on Fortran.

Google published a short video this week about how they used Gemini 4 Argon to migrate a Fortran code base to Rust: https://www.youtube.com/watch?v=biOWEPYyS5c

I remember a piece called SPAG (I think) that could turn FORTRAN spaghetti code (with lots of GOTOs) into relatively clean, structured code. It was very useful.

I learned to program Fortran at 13, 55 years ago, it was old then

My second language to learn... The first was Algol 68 :)

On DEC VAX, it compiled for one assembler instuction per operator

Horray! I'm partial, of course, to Fortran 77 and until very recently, still used it. Mostly taking consulting jobs moving it to Matlab or Numpy and verifying it.

I abandoned FORTRAN for good when I discovered C.

still blows my mind that half the python data science stack is basically just a wrapper around 40 year old fortran code.

Congrats! Here's to 70 more years!

"A good FORTRAN programmer can write FORTRAN in any language"

My first language, I should try and mess with it again. It has been decades since I used it.

I worked on BLAS. Amazing language and tremendous impact it's had over the decades.

Learn FORTRAN once, understand the C/C++/... linkage model forever.

"I don’t know what the scientific language of the year 2050 will look like, but I know it will be called Fortran."

Thank you,Fortran!

FORTRAN 77 was the language for the first programming language course I took. I absolutely hated computers and programming after that course. Later I took CS courses and used Pascal -- one day the concept of abstraction hit me as we were developing data structs in the 2nd semester and the light went on. That is when I first started to love programming. FORTRAN was thereafter referred to as the F language. Sorry to be a bummer, but I still recoil when I hear about that language.

Rust is the fortran of its age.

the real test will be on the longevity side.