It Began with Babbage (42 page)

As the saying goes, sometimes an invention is too far ahead of its time and the world is not quite ready for it. Perhaps Plankalkül suffered from this fate.

Such early investigators as Wheeler in Cambridge or Goldstine in Princeton did not use the word
language
. Zuse, hidden away in his village in the Alps, labored on what he called a
kalkül
—a calculus. Perhaps the earliest explicit use of “language” in the context of programming was in an unpublished report by Arthur Burks in 1951, then at the University of Michigan in
An Intermediate Program Language as an Aid in Program Synthesis
.
¹⁴
Burks's language incorporated features for assignment, conditional branching, and iteration.
¹⁵

In 1950, Zuse's Z4 computer, rebuilt, finally found a home in the Swiss Federal Institute of Technology (ETH) in Zurich, Switzerland.
¹⁶
Here, Heinz Rutihauser (1918–1970), a
Swiss mathematician and numeric analyst, embarked, circa 1951, on what in German he called “
automatische rechenplan fertigung
” (“automatic machine code generation”). This coheres with the most common term used during the early 1950s:
automatic programming—
meaning, an environment that allowed the programmer to deploy symbolic notation to specify a program at a level of abstraction higher than that of the “real” machine itself.
¹⁷

We see here the emergence of what, in present-centered language, would be called an
intermediate
or
virtual
machine more abstract than the actual physical computer. This virtual computer would be programmed in symbolic notation (representing the order code for the virtual machine), and the task of an automatic programming system would be to translate mechanically this virtual machine program into the order code for the real machine. The virtual machine was easier to program than the real machine but the two were closely coupled. Most such systems, during the early 1950s, entailed, or were elaborations of, assembly languages and assemblers, which translated the assembly language programs into the real machine's “native” language in the manner pioneered by Wheeler in Cambridge for the EDSAC (see
Chapter 9
, Section VI). The term automatic programming would prevail through the 1950s. In 1954, the Symposium on Automatic Programming for Digital Computers was held in Washington, DC, sponsored by the Office of Naval Research; and in 1960, an annual publication bearing the title
Annual Review of Automatic Programming
was launched. This publication, with that title, continued until 1994.

A certain thinking trend was, however, taking shape. This trend was toward abstraction—to move programming away, albeit cautiously, from the physical machine in a direction tending toward what humans found more natural for specifying computations. For those who were concerned with mathematical or scientific computations, this meant abstracting from the physical computer toward mathematical expressions and formulas. This was the reverse of what was previously the case. Beginning with Babbage and Lovelace, the strategy formerly had been to
reduce
mathematical thought to the level of the machine, to reduce algorithms to machine order code.

But, by around 1954, this trend was being reversed. There were those who desired to express their programs in mathematical or algebraic notation itself.
¹⁸
Automatic programming now came to mean the use of programs to
translate
efficiently algorithmic expressions and formulas stated in a mathematical language into economic machine code.
¹⁹

In fact, by 1952, the problem had been recognized as twofold: (a) to design a mathematical language in which to express computations and (b) to develop a programming system that could translate programs cheaply in such languages into efficient machine code. This was what Corrado Böhm (1923–), an Italian and later a distinguished theoretical
computer scientist, set about doing as a graduate student at ETH Zurich in 1950 to 1952. In his doctoral dissertation, Böhm described both a language and a complete translator for that language.
²⁰
This was what Halcombe Laning (1920-2012) and N. Zierler set about doing at MIT, where they created a “program for translation of mathematical equations for Whirlwind I.”
²¹
This was what, in England, Alick Glennie (1925–2003) of the Royal Armament Research Establishment desired to do when he designed a system he called AUTOCODE for the Ferranti/Manchester Mark I computer (see
Chapter 8
, section XIII, for more on the Manchester Mark I; the Ferranti Mark I was the industrial version of the Manchester University Mark I). Glennie—“the unsung hero” in the story of programming languages and automatic programming, according to Knuth and Pardo
²²
—delivered a lecture on AUTOCODE at Cambridge University in February 1953 based on notes he had prepared in December 1952,
²³
in which he asserted that programming notation must make it easier to make the programming task “comprehensible.”
²⁴

By 1953/1954, the word
compiler
was being used to mean the kind of process required to translate programs written in algebraic form into machine code.
²⁵
Indeed, Glennie's AUTOCODE system, according to Knuth and Pardo, was the first implemented compiler that was actually used.
²⁶

It was this trend in thinking toward abstraction that led John Backus (1924–2007) and his team at IBM in New York to conceive and develop an automatic programming system around a language he called FORTRAN.

The FORTRAN (an abbreviation for FORmula TRANslator) project began in early 1954. Backus, a master's degree holder in mathematics from Columbia University, joined IBM in 1950 as a programmer for one of their state-of-the-art electromechanical calculating machines. When the IBM 701 was built in 1953 (this the company's first stored-program electronic computer), Backus led the development of an
interpretive
system for the 701 called Speedcode.
²⁷
That is, a program written in Speedcode would be read an order (or statement) at a time, then translated automatically into the 701's machine code and executed immediately. In other words, the orders (or statements) are interpreted one at a time.

With the development of the IBM 704, IBM more or less came to monopolize the large-scale scientific computing arena.
²⁸
Although the IBM 704 was not delivered until 1956, the FORTRAN project began in 1954 and was prompted by the planned advent of the 704. The idea was to design a language that would enable engineers and scientists to write programs themselves for the 704. The language of programming was to be “algebraic” or “formulaic” in form.

This was not the only factor. In 1954, programming accounted for a very large portion—estimated at about three quarters—of the cost of operating a computer installation.
²⁹
Automatic programming could help reduce this cost.

The problem was that, in a culture in which programs were habitually written at virtually the level of a machine's “native language” (that is, assembly language), there was “widespread skepticism” that an automatic programming system could produce machine code as efficient as “hand-coded” programs.
³⁰
Backus and his group were, of course, acutely aware of this skepticism. They recognized that, for such a system to be accepted and used widely, they would have to demonstrate the comparative efficiency of programs produced by automatic systems.
³¹

And so even though Backus's group wanted a language to facilitate the scientist's and engineer's task of programming the 704, the design of the language itself became subservient to this imperative. The real problem, as they saw it, was to design a compiler that could produce efficient programs. The actual language design itself happened on the fly, so to speak—driven by the compiler imperative.
³²

As Backus would remember in 1981, the FORTRAN project seemed to defy the idea that all new ideas and inventions draw on prior ideas, and that something like what Arthur Koestler called
bisociation
worked to meld prior, possibly unrelated, concepts into something new (see
Chapter 13
, Section IV). The closest automatic programming system (in broad philosophy) was the one developed for the MIT Whirlwind I by Laning and Zierler (as mentioned earlier). Although this system was, as Backus acknowledged, “the world's first algebraic compiler”
³³
and was completed before the first version of FORTRAN, it had apparently no influence on the design of FORTRAN. Nor, apparently, did any of the other related projects elsewhere, many of which Backus and his group were unaware.
³⁴

The original goal was to design a language that, although algebraic or formulaic in form, was still tied to a particular computer, the IBM 704—that is, it would be a liminal computational artifact (see Prologue, Section IV). That FORTRAN would evolve into a genuinely machine-independent (or, as the term would emerge,
high-level
) programming language, an abstract computational artifact—and arguably the first language with this characteristic—lends it a special place in the early history of computer science.

But FORTRAN represented something more. Thus far in this story of programming languages, their design and the design of their translators belonged to the realm of what we may call
Little Science
. The work was done by one or two persons, reflecting almost entirely the creative spirit and ideas of these individuals—thus it was with Goldstine and von Neumann, with Wheeler, with Zuse and Rutihauser, with Böhm and Glennie, with Laning and Zierler.

FORTRAN changed all of this. Much as the design of computers in the final years of the 1940s became, relatively speaking,
Big Science
, even in university settings. For example, at the time the Manchester Mark I was commissioned, the group led by Frederic
C. Williams had at least eight members
³⁵
—so also “automatic programming” entered the realm of Big Science with the FORTRAN project.
³⁶
A paper presented at a conference in Los Angeles in 1997 titled
The FORTRAN Automatic Coding System
had 13 coauthors.
³⁷

The size of the FORTRAN team was, of course, a symptom of the complexity of the project, and this complexity lay in that FORTRAN was a
system
comprised of a language, a computer program for automatic translation, a computer, a text, and a social community. Each of these components influenced, and was in turn influenced by, one or more of the other components.

The FORTRAN language was designed, on the one hand, with an anxious eye toward its translatability into efficient IBM 704 machine code; and on the other, as a means of expressing algorithms in an algebraic form that would be “natural” to scientists and engineers, the intended users of the language. Thus, the acceptability of FORTRAN as a tool by the community of its potential users—the community of expected IBM 704 users and members of an IBM computers user group called SHARE, formed in 1955—depended both on the language as a vehicle for expressing algorithms
and
the efficiency of the executable machine code. The designers of the translator (compiler) bore responsibility of ensuring that FORTRAN programs could be translated automatically into IBM 704 machine code that would compare favorably in efficiency with “hand-coded” programs. If the FORTRAN language was the interface between the user community and an IBM 704 installation, the FORTRAN compiler was the interface between the language and the 704 machine itself.

Strictly speaking, the FORTRAN language was one part of the user community–704 installation interface. The user had to learn the language; a
text
was needed that would describe the language—a programmer's guide to FORTRAN. Like any endeavor that created practical artifacts for human use, the FORTRAN project entailed a melding of objective principles of design with subjective perceptions and beliefs—mathematics, logic, design principles fused with psychology.

The FORTRAN language design began in early 1954. Before the year's end, a preliminary 29-page report on the language was written
³⁸
and distributed to prospective IBM 704 customers.
³⁹
Armed more with faith than empirical evidence (as Backus confessed) the authors of the report, in their introduction, assured readers that FORTRAN programs would not only execute as efficiently as “laboriously” hand-coded programs would, but also that FORTRAN would facilitate the production of much more complex programs than could be hand coded.
⁴⁰

Here, “FORTRAN” meant not the language but the translator; “coding” referred not to the act of writing programs in the FORTRAN language, but to the process of producing machine code automatically by the compiler; the “human coder” was not the
FORTRAN programmer but the programmer in the 704's assembly (or machine) language. Vocabulary was being refined.

Soon after the preliminary report was written, Backus and two of his language code-signers gave talks on FORTRAN to groups of IBM customers in various cities—customers who had ordered the IBM 704 (which had been announced around May 1954). By and large, they found their audience skeptical about this new prospect.
⁴¹

The design and implementation of the FORTRAN compiler (still called
translator
, at the time)—written in the “native” language of the IBM 701 that would execute the compiler—began in earnest in early 1955.
⁴²
By summer 1956, “large parts of the system was working.”
⁴³
The complete compiler was available in early 1957.
⁴⁴
Also in summer 1956, David Sayre (1924–2012), a PhD in crystallography from Oxford University, began writing a document describing the language. The outcome was the
Programmer's Reference Manual
(1956).
⁴⁵
In early 1957, Backus and his whole group presented a paper on the FORTRAN system at the Western Joint Computer Conference in Los Angeles, California.
⁴⁶
That same year, the
Programmer's Primer
for the FORTRAN system was published by IBM.
⁴⁷