On mainframes, things usually don't fail, and they don't crash. Or to be more accurate: Things fail all the time, but they keep running, perhaps a little slower than usual , or with less disk space or less memory. That is until a junior programmer by mistake manages to crash the OS from a user process (in Fortran, no assembly required). The third time it happened, one of the operators came out to my terminal, and asked me to "not do that again, and show us exactly what you did". I had been wondering why the machine crashed every time I wanted to compile/link/run my analysis program.
The answer, by the way, was a wonderfully subtle bug. When you program in Fortran 77, it so happens that the entry part of the program (not a subroutine, but the main body) is implicitly in a subroutine that is called "MAIN". You don't know that, it's not documented, it's just an internal convention. My problem was that I had defined a subroutine that was also called MAIN, which did most of the work of the program (I probably had other subroutines with names like SETUP, READINP and WRTRSLT. The problem happened because our system ran a combination of the Hitachi F77 compiler with the IBM linker. The compiler happily prepared a module called MAIN (with the main program), and another module called MAIN (with the subroutine). The linker would take the first one and copy it into the executable. It would then notice that a subroutine named MAIN is being called, and put another copy of the first one in (not the second one, due to an incompatibility between Hitachi and IBM). It would then notice that a subroutine called MAIN is being called, and put yet another copy of the first one in. The linker "knew" that Fortran programs can't be recursive, and it "knew" that object modules have unique names, and it was supposed to have a table of all modules it had already linked, but the incompatibility in naming convention between Hitachi and IBM broke that. So the linker would create the executable in memory, trying to copy infinitely many copies of MAIN into memory. Unfortunately, the linker is a system program, so it is exempt from things like memory quota, and it exhausted and overwrote all memory on the machine, causing an OS crash.
No problem, I would go have a snack. After a while, the machine comes back up, I remembered what I had been working on, and I restarted the compile/link/execute cycle, causing another snack break. And again. During the third time, the operators had noticed the number of the terminal that was running the last process before the machine went down, and they found me because I had my coffee mug and all my paperwork sitting there and always returned to the same place. So I explained it to them. They went and got some of the system programmers, who looked at my code, and looked at some IBM documentation, and looked at some logs of the machine, and after an hour or so they told me that I had rediscovered a bug that was known to IBM but not yet to customers. All I had to do to fix the program was to rename the subroutine to anything other than MAIN, and it worked perfectly.
