Wanted: Ancient Fortran FFT source code

Click For Summary
SUMMARY

The discussion centers on the search for ancient Fortran source code implementing the Cooley-Tukey FFT algorithm, specifically pre-Fortran 77 versions. The original code, believed to be from the mid-1960s and possibly authored by someone at UC Berkeley, is characterized by implicit typing, single-letter variable names, and a lack of comments. Participants highlight the historical context of programming practices during that era, emphasizing that code aesthetics were secondary to functionality. A reference to the FFTPACK library on Netlib is provided as a potential resource for similar algorithms.

PREREQUISITES
  • Understanding of the Cooley-Tukey FFT algorithm
  • Familiarity with Fortran programming language, particularly versions prior to Fortran 77
  • Knowledge of legacy code practices and challenges
  • Awareness of historical computing contexts, such as punched card programming
NEXT STEPS
  • Research the historical development of the Cooley-Tukey FFT algorithm
  • Explore the FFTPACK library available at Netlib for FFT implementations
  • Study best practices for maintaining and refactoring legacy Fortran code
  • Investigate the impact of programming aesthetics on code performance and maintainability
USEFUL FOR

Software developers, computer scientists, and historians interested in legacy programming practices, particularly those dealing with Fortran and FFT algorithms.

cdenzler
Messages
1
Reaction score
0
Hi.

I'm new here and wasn't sure which forum to post this request on, but this one seemed a good start.

I am developing a talk/seminar on dealing with legacy code. In the late 1990s I was working for a large corporation in a software capacity and one day idly wondered what the source code looked like that was actually performing the FFT in the application I was working on.

As near as I can recall, the code had the following features: Implicit typing, single letter variable names, source code in all caps, no commenting, and was very terse. I think I recall at the top of the file, the code was written by someone at UC Berkeley, but I could be wrong about that. I recall clearly that there was a date in the header comments, from the mid-1960s. It must have been an early implementation of the Cooley-Tukey algorithm.

At the time I was shocked that at the bottom of the call stack was this (then) 30-year old Fortran code that was doing an enormous amount of heavy lifting for this (very large) corporation. The code was ugly to look at, but there must have been a reason that it was still in use at the time.

I am looking for the source code, pre Fortran77, of this ugly gem if it rings any bells.

Thank for any pointers,

- Chris
 
Technology news on Phys.org
There is nothing very shocking about this. The compiler doesn't care if the code looks ugly, so long as it works.

Most high speed computer printers from the 1970s era only printed upper case letters.

Creating a deck of punched cards for program input, there were NO editing options whatever, except for throwing away a card and retyping the complete line. That didn't encourage using longVariableNamesWithRandomlyInsertedUpperAndLowerCaseCharacters.

In any case, the mathematical description of the FFT would have been written with one-character "variable names", just like almost every other piece of mathematics. Making the variable names longer when you translated the math into Fortran didn't add any value - in fact it was a good way to make mistakes.

"Real programmers" have better things to do than rewrite working code just to make it look pretty!
 

Similar threads

Fortran Identify explicit shape spec list in the FORTRAN code
  • · Replies 1 ·
Replies
1
Views
2K