The first Fortran Reference Manual was released on October 15, 1956, six months before the first working compilers were distributed to IBM customers. While Fortran may have challengers as the first compiled computer language, it is certainly the most influential and the most durable of the early high-level languages.

The name Fortran stands for FORmula TRANslator - its full title was The IBM Formula Translating System and  it was designed specifically for the IBM 704 by a team led by John Backus.

John Backus

December 3, 1924 - March 17, 2007

Prior to Fortran every new computer had its own language - machine code tied to the architecture of the machine and designed to make the best of its features. A programmer would know how the machine worked and would carefully craft code to achieve a result that took minimum time and/or memory. Every byte was manually allocated and managed and so was the use of the machine's internal registers where the work was done. The big problem is that working in machine code is particularly unfriendly and makes creating programs time-consuming and error-prone.

To enable the move away from machine code and to enable a computer language to run on multiple machines needed a compiler. This was the breakthrough made by IBM for the 704 and it turned out to be extremely difficult to find an automatic way to translate arithmetic expressions - the task that Fortran accomplishes.

Fortran introduced many new ideas - arithmetic assignment, comments, the DO loop, subroutines and functions, formatted input/output - to name just a few. It also seeded the idea of machine independence because a machine that had a Fortran compiler could run any Fortran program.

Fortran was an IBM product but even the baby Big Blue of the time must have been surprised at how fast it became the language of computing and established IBM as the leading computer supplier.

The IBM 704 - first with Fortran

Many of the key facilities that we have come to expect of a high level language including arithmetic and logical expressions; the DO loop (an early form of the FOR loop); the IF statement; subroutines; arrays; and formatting were introduced by Fortran. And yet initially Fortran stayed close to the underlying machine with constructs such as the 3-way if:

if(expression) doneg, dozero,dopos

where the instruction that was jumped to depended on the value of the expression - negative, zero or positive. The reason for this odd instruction was the the IBM 704, for which it was created for had a machine code instruction that was a three way branch on the value in a register. 

It is difficult for us to realize how hard this problem was. It had never been done before and the team didn't really know what success would look like. Most programmers at the time simply didn't think high level languages could be made to work and assembler would always be faster and more memory efficient. As John Backus wrote some years later:

As far as we were aware, we simply made up the language as we went along. We did not regard language design as a difficult problem, merely a simple prelude to the real problem: designing a compiler which could produce efficient programs. Of course one of our goals was to design a language which would make it possible for engineers and scientists to write programs themselves for the 704. We also wanted to eliminate a lot of the bookkeeping and detailed, repetitive planning which hand coding involved. Very early in our work we had in mind the notions of assignment statements, subscribed variables, and the DO statement (which I believe was proposed by Herrick). We felt that these provided a good basis for achieving our goals for the language, and whatever else was needed emerged as we tried to build a way of programming on these basic ideas. We certainly had no idea that languages almost identical to the one we were working on would be used for more than one IBM computer, not to mention those of other manufacturers. (After all, there were very few computers around then.) But we did expect our system to have a big impact, in the sense that it would make programming for the 704 very much faster, cheaper, more reliable. We also expected that, if we were successful in meeting our goals, other groups and manufacturers would follow our example in reducing the cost of programming by providing similar systems with different but similar languages

Once something is achieved in software it becomes forever easy. Back then no one had a clear idea how to take something like:

A=B*3+(C-4)*283-Z/X

and turn it into low level assembler working with a limited range of registers. All programmers knew how to do it for any given arithmetic expression but not for any and all such arithmetic expression of any complexity you cared to think up. 

What also comes as a surprise is that after 60 years, Fortran is still a popular language for some important applications, climate modelling, for example. Having evolved from the original FORTRAN I, through FORTRAN II and II, FORTRAN 66 (also known as FORTRAN IV), it achieved great popularity with Fortran 77, the version that lost the all-caps name.  Since then there have beem Fortran 90 and Fortran 95, which is still widely used. Later versions are Fortran 2003 and Fortran 2008. Work is still underway towards Fortran 2015, which is now expected in mid 2018. Even though it has evolved it hasn't changed out of all recognition and is still so true to its original design that a FORTRAN I  programmer would be able to follow something in Fortran 2008.

As the first high-level language, Fortran is clearly important, but it also influenced many generations of programmers, especially when you take into account the popularity during the early home computer era of BASIC, which was a derived directly from Fortran.

Every single language that compiles an expression owes a debt to Fortran and to John Backus.

Comments

Make a Comment or View Existing Comments Using Disqus

or email your comment to: comments@i-programmer.info