FORTRAN programming language

The invention: The first major computer programming language,
FORTRAN supported programming in a mathematical language
that was natural to scientists and engineers and achieved unsurpassed
success in scientific computation.
The people behind the invention:
John Backus (1924- ), an American software engineer and
manager
John W. Mauchly (1907-1980), an American physicist and
engineer
Herman Heine Goldstine (1913- ), a mathematician and
computer scientist
John von Neumann (1903-1957), a Hungarian American
mathematician and physicist
Talking to Machines
Formula Translation, or FORTRAN—the first widely accepted
high-level computer language—was completed by John Backus
and his coworkers at the International Business Machines (IBM)
Corporation in April, 1957. Designed to support programming
in a mathematical language that was natural to scientists and engineers,
FORTRAN achieved unsurpassed success in scientific
computation.
Computer languages are means of specifying the instructions
that a computer should execute and the order of those instructions.
Computer languages can be divided into categories of progressively
higher degrees of abstraction. At the lowest level is binary
code, or machine code: Binary digits, or “bits,” specify in
complete detail every instruction that the machine will execute.
This was the only language available in the early days of computers,
when such machines as the ENIAC (Electronic Numerical Integrator
and Calculator) required hand-operated switches and
plugboard connections. All higher levels of language are implemented by having a program translate instructions written in the
higher language into binary machine language (also called “object
code”). High-level languages (also called “programming languages”)
are largely or entirely independent of the underlying
machine structure. FORTRAN was the first language of this type
to win widespread acceptance.
The emergence of machine-independent programming languages
was a gradual process that spanned the first decade of electronic
computation. One of the earliest developments was the invention of
“flowcharts,” or “flow diagrams,” by Herman Heine Goldstine and
John von Neumann in 1947. Flowcharting became the most influential
software methodology during the first twenty years of
computing.
Short Code was the first language to be implemented that contained
some high-level features, such as the ability to use mathematical
equations. The idea came from JohnW. Mauchly, and it was
implemented on the BINAC (Binary Automatic Computer) in 1949
with an “interpreter”; later, it was carried over to the UNIVAC (Universal
Automatic Computer) I. Interpreters are programs that do
not translate commands into a series of object-code instructions; instead,
they directly execute (interpret) those commands. Every time
the interpreter encounters a command, that command must be interpreted
again. “Compilers,” however, convert the entire command
into object code before it is executed.
Much early effort went into creating ways to handle commonly
encountered problems—particularly scientific mathematical
calculations. A number of interpretive languages arose to
support these features. As long as such complex operations had
to be performed by software (computer programs), however, scientific
computation would be relatively slow. Therefore, Backus
lobbied successfully for a direct hardware implementation of these
operations on IBM’s new scientific computer, the 704. Backus then
started the Programming Research Group at IBM in order to develop
a compiler that would allow programs to be written in a
mathematically oriented language rather than a machine-oriented
language. In November of 1954, the group defined an initial version
of FORTRAN.A More Accessible Language
Before FORTRAN was developed, a computer had to perform a
whole series of tasks to make certain types of mathematical calculations.
FORTRAN made it possible for the same calculations to be
performed much more easily. In general, FORTRAN supported constructs
with which scientists were already acquainted, such as functions
and multidimensional arrays. In defining a powerful notation
that was accessible to scientists and engineers, FORTRAN opened
up programming to a much wider community.
Backus’s success in getting the IBM 704’s hardware to support
scientific computation directly, however, posed a major challenge:
Because such computation would be much faster, the object code
produced by FORTRAN would also have to be much faster. The
lower-level compilers preceding FORTRAN produced programs
that were usually five to ten times slower than their hand-coded
counterparts; therefore, efficiency became the primary design objective
for Backus. The highly publicized claims for FORTRAN met
with widespread skepticism among programmers. Much of the
team’s efforts, therefore, went into discovering ways to produce the
most efficient object code.
The efficiency of the compiler produced by Backus, combined
with its clarity and ease of use, guaranteed the system’s success. By
1959, many IBM 704 users programmed exclusively in FORTRAN.
By 1963, virtually every computer manufacturer either had delivered
or had promised a version of FORTRAN.
Incompatibilities among manufacturers were minimized by the
popularity of IBM’s version of FORTRAN; every company wanted
to be able to support IBM programs on its own equipment. Nevertheless,
there was sufficient interest in obtaining a standard for
FORTRAN that the American National Standards Institute adopted
a formal standard for it in 1966. Arevised standard was adopted in
1978, yielding FORTRAN 77.
Consequences
In demonstrating the feasibility of efficient high-level languages,
FORTRAN inaugurated a period of great proliferation of programming languages. Most of these languages attempted to provide similar
or better high-level programming constructs oriented toward a
different, nonscientific programming environment. COBOL, for example,
stands for “Common Business Oriented Language.”
FORTRAN, while remaining the dominant language for scientific
programming, has not found general acceptance among nonscientists.
An IBM project established in 1963 to extend FORTRAN
found the task too unwieldy and instead ended up producing an entirely
different language, PL/I, which was delivered in 1966. In the
beginning, Backus and his coworkers believed that their revolutionary
language would virtually eliminate the burdens of coding and
debugging. Instead, FORTRAN launched software as a field of
study and an industry in its own right.
In addition to stimulating the introduction of new languages,
FORTRAN encouraged the development of operating systems. Programming
languages had already grown into simple operating systems
called “monitors.” Operating systems since then have been
greatly improved so that they support, for example, simultaneously
active programs (multiprogramming) and the networking (combining)
of multiple computers.