I record here what I remember of Livermore’s compiler for the IBM 701. I arrived in Livermore in the middle of 1955 and the Kompiler was already well along. A few months after I arrived I became attached to a particular physics project that was on a short time schedule to evaluate a particular weapons design using a 2D mesh and more physics that had previously been done in 2D. The IBM 701 was the fastest computer then available. It was binary and lacked floating point. The job at hand was too big to afford interpretive floating point and thus scaled fixed point was indicated as in most production jobs.

The Kompiler seemed stable and we decided to use it. Large production jobs would not fit in the 4K words of available memory (Williams tubes). Magnetic tape was used. Each cycle (time step) required reading the problem state from tape incrementally and writing it to another tape. Thousands of cycles per project were required. This pattern was familiar enough that the Kompiler supported it directly. One of the subscript values of an array reference would indicate which portion of the problem state was involved. That subscript incremented synchronously with tape I/O. Doing the tape IO was not, however automatic. The program had to explicitly cause the copying to and from tape.

Each variable had to have a specified scaling. Changing the scaling of a variable was a frequent late modification to a program for it would often depend on the particular task at hand. Often sub expressions would require scaling that became evident only as the program ran. This tuning was much easier with Kompiler than with assembler, which had been the only tool previously.

The physicists wrote equations with both subscripts and superscripts. The input was from cards, three cards per input line. Superscripts appeared on the first card, the main text on the second and subscripts on the last card. When this was printed it was pleasant to look at and might look something like:

   N+1        N           N
PHI     = (PHI       + PHI      )/2
   K, J       K+1, J      K, J-1
Conventional wisdom was that programmers would write these equations on “coding sheets” with pre-printed columns and rows. It was hell to keypunch.
Kent Elsworth was in charge of the project. Leona Fernbach (then Schloss), Bob Kuhn, John Hudson and Dorthy Monk also contributed to the Kompiler. The physics project and Kompiler were successful and a new compiler was undertaken by the same team for the IBM 704. The 704 arrived with 8K memory foreseen. The addresses had 15 bits and it was assumed that the high two bits of an address would always be ignored. A good deal of code was written on this assumption. IBM then announced a forthcoming compiler, Fortran, for the 704 and also began delivering 32K memory systems for the 704. With 32K words the assumption about the two high address bits wrong. While our plans included features not promised for Fortran, Fortran was in several ways a better language. Our 704 compiler plans were canceled and we were eventually pleased with Fortran.