Comput. Lang. Vol. 17, No. 1, pp. 1-17, 1992 0096-0551/92 $3.00+0.

00
Printed in Great Britain. All rights reserved Copyright © 1991 Pergamon Press plc

FROM BABBAGE TO BABEL AND BEYOND: A BRIEF

HISTORY OF PROGRAMMING LANGUAGES

LINDA WEISER FRIEDMAN

Department of Statistics and Computer Information Systems, Baruch College of the City University of
New York, New York, NY 10010, U.S.A.

(Received 23 January 1990; revision received 16 July 1990)

Al~tract--The history of computer programming languages is reviewed, with emphasis on the influences
of early languages on later efforts. Four generations of software are presented, beginning with machine
code, and continuing through fourth generation languages, paradigms, and environments.

History of programming languages FORTRAN LISP ALGOL COBOL APL SNOBOL BASIC
PL/1 Logo FORTH SIMULA ALGOL68 Pascal C MODULA-2 Ada PROLOG OPS
Smalltalk First-generation languages Second-generation languages Third-generation languages
Fourth-generation languages

The design and implementation of computer programming languages is a fertile field of study.
To study high-level programming languages by examining only the state of such languages as they
exist today would be incomplete. We might, for example, miss the fact that the most widely used
programming languages today are also the oldest. Why are FORTRAN and COBOL still so
popular after living through several generations of programmers, computer hardware and, yes,
programming languages?
Why did high-level languages evolve? Why aren't we still programming in machine code? On the
other hand, why haven't we gone further? Early programming languages exerted a profound
influence on later, "state of the art" languages, an influence which continues to this day. Is this
why so many languages have such similar constructs? In examining the history of programming
languages we attempt to answer questions such as these.
The literature on the subject of programming language history and evolution is rich and
fascinating. Should you desire to delve more deeply or in more detail into this area, the following
sources will be a useful starting point. Specifically, the early history of programming languages is
covered in Burks and Burks [1], Cheatham [2], Knuth [5, 6], Metropolis et al. [7], Morrison and
Morrison [8], Rosen [10], Sammet [11, 12], Stein [13], Taylor [14], and Wexelblat [15]. For a more
general history of computing, see Computerworld [3, 4], and Rosen [9].

BEFORE ELECTRONIC COMPUTERS

According to Knuth [5, 6], who has studied mathematical and numerical algorithms from
antiquity to the modern era, whereas notations for describing static functional relationships, such
as the equations used in mathematics, physics and chemistry, evolved over the centuries into a
highly sophisticated concise form, notations for dynamic processes (i.e. algorithms) did not follow
suit. Often, in order to denote an algorithm as an input-output transformation, one would simply
express it as y = f (x), where x is the input variable, y is the output variable, and f is the abstract
(or "black box") model, the (possibly numerical) algorithm. To this day, notations for algorithms
have not been highly developed and are relatively wordy and imprecise.
The earliest known "computer" is generally acknowledged to be Charles Babbage's design for
an Analytic Engine. This device--which was to provide a changeable sequence of numerical
operations and internal storage of data--was, in 1834, so far ahead of the existing technology that
it could not be built in his lifetime. However, this did not stop him and his collaborator,
mathematician Lady Augusta Ada, Countess of Lovelace (and daughter of the poet Lord Byron),
from coding programs for it. Machine-code operations on Babbage's machine were of the form:
V~ × V2 = V3, with operations (e.g. the multiply operation) and variables (in this case, the subscripts

CL 17'1-- A |
2 L1NDA WEISER FRIEDMAN

1, 2, 3) on separate punched cards (Jacquards). These cards were to be fed into the machine and
would work on internal data (the "store"). The Analytic Engine was designed to accommodate
conditional "jumps", i.e. branches to instructions out of sequence. This was to be accomplished
by a mechanical means in which a band of cards could be physically jumped over. Lady Lovelace
postulated that many processes which were composed of repetitive sequences of operations could
be coded most efficiently by the execution of a backward jump which would cause the repetitive
execution of a single band of cards. She is thus credited with innovating the concept of a loop,
or repetition construct. A working model of the Analytic Engine has finally been built and stands
in the Smithsonian as the first "computer". Just as Babbage is credited as the first computer
architect, Lovelace was the first computer programmer.
It was not until 1945, with the publication by the University of Pennsylvania of John von
Neumann's "First Draft of a Report on the EDVAC", that the stored-program computer was
described and eventually, this time, implemented. The EDVAC (_Electronic Discrete Variable
Arithmetic Computer) report describes a configuration in which the processor is tightly coupled
to primary storage, primary storage is large enough to store vast amounts of data along with the
program code, and operations are executed sequentially without the parallelism that was needed
on earlier mchines to counteract their extremely limited storage capabilities. This type of
configuration, which has since come to be known as the von Neumann architecture, has influenced
the design of many of the high-level programming languages with which we are so familiar today.

HARDWARE

Table 1 presents a historical overview of computer machinery beginning with early experimental
models and continuing on through the microcomputer revolution and Japan's Fifth Generation
Project. This table is a useful frame of reference in studying the concurrent evolution of
programming languages.
The table presents a number of innovative experimental computers leading to Remington-
Rand's UNIVAC, the first electronic computer produced specifically for commercial use. The first
UNIVAC was purchased by the U.S. Department of the Census. The UNIVAC heralded the first
generation of computers, characterized by vacuum tubes. Each successive generation of computer
hardware is defined and characterized by a new and different technology, namely, transistors,
integrated circuits, and large-scale integration.
If the 1951 introduction of the UNIVAC signalled the first generation of our modern-day
"computer revolution" then, like other revolutions, it took the experts by surprise. When the
UNIVAC I was installed in 1951, experts predicted that all of 12 computers would be in use in
the U.S. by 1975. By 1975 there were 155,000 computers in use, and so it was predicted that 1985
would see as many as 500,000 computers in use. In 1985, there were actually 9 million personal
computers in use across the U.S. and by the end of 1989 this figure was up to 54 million.

THE FIRST SOFTWARE GENERATION

In the same way that computer hardware can be classified according to "generation", so each
software generation may be defined so as to represent a different software technology. This is the
approach taken in Fig. 1, the software ladder. As can be seen, each successive software generation
provides an additional rung in the "ladder" and so extends the distance between the human user
and the computer. The higher the human user is able to climb, the more useful and pervasive will
be the effect of this relatively new discipline of computing.
The first generation of computer software is the era of machine language programming. It is
always difficult to mark the beginning and end of an era. In the case of the first software generation,
we date it from the hand-coded programming done on the Mark 1 computer (pre-first generation
machinery) at Harvard University. As to defining the end of this era, it is especially difficult in
this case since large numbers of adherents of machine-coded programs continued to resist newer
software technologies even until the release of the first FORTRAN compiler and beyond.
During the 1940s and early 1950s, all coding was done in machine language, i.e. the computer's
own internal (binary-based) instruction set. Machine coding, or "hand coding", remained popular
 A brief history of programming languages 3

long after that, long after the second-generation coding aids such as automatic code generators,
interpretive routines, and assemblers were available, long after--as with many other enterprises in
which humans are expected to change their way of doing things--it should have. Every machine
has its own built-in code and in this first generation of software every task was coded "from
scratch" with little or no opportunity for generalizing from one computer to another or from one
program to the next.
The word wasn't "programming" then, but coding, and programmers were coders. The word
programmer originated in England and when it finally crossed the Atlantic in the early 1950s it
was, naturally, considered more prestigious to be a programmer than a coder and the terminology
stuck.
There was very little in the way of formal communication among the members of the early coding
community. The Association for Computing Machinery (ACM) was first formed in 1947, and its

Table 1. Chronology of electronic computing machinery

Technological Designer
Year Computer feature team leaders Place
1939 ABC Design of the electronic John V. Atanasoff Iowa State College
prototype digital computer Clifford Berry
The ABC, the Atanasoff Berry Computer, was designed to automate certain calculations in physics and influenced later
work on the ENIAC
1941 Z3 Electromagnetic relays Konrad Zuse Berlin
1943 Mark I Electromechanical relays Howard Aiken Harvard
The Mark I was also known as the Automatic Sequence-Controlled Calculator
1943 Colossus Electronic Alan Turning England
The Colossus helped decipher German Code during World War II
1946 ENIAC Electronic J. Presper Eckert University of Pennsylvania
John Mauchly
The ENIAC, which stands for Electronic Numerical Integrator and Computer, was programmed by manually setting
jumper connections on the front panel. It took a team of 5 people at least 2 days to enter a program into the computer
1949 EDSAC Stored program Maurice Wilkes Cambridge University
The EDSAC, which stands for Electronic Delay Storage Automatic Computer, was based on the EDVAC report
published in 1945. Wilkes rushed in order to complete his machine before yon Neumann's, and was successful. The
EDSAC is thus credited as being the first stored-program computer
1950 EDVAC Stored program John yon Neumann University of Pennsylvania
J. von Neumann's innovative report on the EDVAC, or Electronic Discrete Variable Arithmetic Computer, appeared
in 1945. It was the firstly totally sequential electronic computer, with no parallelism
1951 UNIVAC I Vacuum tubes Eckert, Mauchly Remington-Rand
The first computer to be available for commercial sale, the UNIVAC I, an acronym of Universal Automatic Computer,
begins the first generation of computer machinery
[lst generation] Vaccum tubes
1951-1960 e.g. UNIVAC I; IBM's 701, 650; Burroughs' El01; Honeywell's Datamatic 1000
[2nd generation] Transistors
1959-1965 e.g. IBM's 1401, 1620; Burroughs' 5000; Honeywell's Model 800
[3rd generation] Integrated circuits
1964--present e.g. IBM 360
The first "general-purpose" machine, much of the 360 architecture design is credited to Gene Amdahl. Some 360
innovations are microcode and systems programming. Virtual memory came later, along with timesharing
1969 Nova 16-bit minicomputer Edson de Castro Data General
1969 PDP-11 16-bit minicomputer Ken Olsen DEC
[4th generation] Very large scale integration
1971-present Microprocessors
e.g. Altair, Apple, TRS-80
1972 Intel's 8008, 8-bit microprocessor
1974 Radio Electronics article on how to build a Mark 8 (using the 8008 processor), "your personal minicomputer"
1974 Altair developed at MIT by Roberts, Yates
1977 Apple computer marketed by Wozniak, Jobs
[5thgeneration] Parallel processing architecture
present-future
1981 Japan announces its Fifth Generation Project based on parallel processors and logic programming
4 L I N D A WEISER FRIEDMAN

journals did not begin publishing until several years later. On the other hand, there was plenty of
informal communication going on in the form of meetings and letter writing and the sharing of
copies of code. Very little thought was given to ownership or claim and for that reason it is often
difficult to attribute a programming "first" to a single source.
In 1947, an event occurred which is of special interest to programmers and students of
computing. Grace Murray Hopper, in investigating why the Mark I1 computer was not working
properly, discovered a small dead moth in the machine and removed it with a tweezer. The moth
went into her logbook along with a note recording the incident for posterity. From then on,
computing errors were called "bugs" and the process of finding and removing them known as
"debugging".
Around 1951 Howard Aiken proposed and constructed a "coding machine" for the Mark III.
By simply pressing a button on the console of this machine, one or more machine codes such as

5 t h generation ? HAL?? ~
(future} ? STAR TREK ?,P
? KZTT??

F/

4 t h generation NaturaL Language processing

" 4 G L s " : FOCUS,NOMAD 2
11961 - present ) .... .'3
Programming environments r~
Integrated packages
PROLOG t OPS, SmoLLtoLk ,...
RuLe - based, Logic,object - oriented programming ,~
DecLarative programming
Packages : BMD, DATATEXT, SPSS, ....

r~

r.
3rd generation C , M O D U L A - 2 tAda
11954 - present l FORTH, SIMULA, ALGOL 6 8 , Pascal rs
APL,SNOBOL, BASIC~ P L / 1 , Logo rs
FORTRAN, LISP, ALGOL 6 0 , COBOL ~
MATH - MATZC t FLOW - MATIC
Imperative , functional programming ~
r~
CompiLer Languages ~ procedural Languages
F#
I/
F~
r~

2rid generation Very early compilers ~

F~
( 1949 - 1956 ) AUTOCODE
SymboLic assemblers #~
SHORT CODE, SPEEDCODING, Sort - Merge Generator
Interpretive routines ~

1St generation "Open" subroutines f~

( 1937 - 1952 ) Machine codes F~

| "~,
r~

COMPUTER

Fig. 1. The software ladder.

 A brief history of programming languages 5

operators, operands, and signs would be punched on paper tape. This paper tape would later serve
to enter the program into the computer. In this way, the human coder would not have to bother
to memorize many complicated sequences of binary code. The human brain was now one small
step removed from the "thought" processes of the actual computer. Although this was truly a
machine, and not an example of early software, it propelled the evolution of programming
languages forward by demonstrating the usefulness of a machine as an automatic coder and
providing the initial spark for many second-generation software designers.

THE SECOND GENERATION

The second generation of software, the pre-compiler era, saw the development and distribution
of programming aids for the machine language coding specialist, including machine-code sub-
routines, interpretive routines, automatic code generators, and assemblers. It is a time period
marked by many firsts. In order to appreciate the monumental importance of these accomplish-
ments, from our vantage point as a more sophisticated generation, we have to bear in mind, firstly,
that the mindset of the coding establishment was such that anything other than hand coding was
considered to be inferior and, secondly, that those hand-coded machine language programs were
actually very complex and intricate and did as much with less storage as our sophisticated programs
do today. For example, the UNIVAC I, with 12 K of memory handled Prudential Life's entire
premium file and did the payroll for U.S. Steel.
In all fairness, much of the skepticism of the coding establishment toward automatic coding
systems was warranted. These systems almost always turned out programs which were less efficient
and more costly than the equivalent hand-coded versions produced by clever, inventive human
coders.
At about this time, programmers were no longer necessarily coding an entire program from
scratch. Many would now manually copy sections of code, such as routines for floating-point
arithmetic and input-output conversion, from one hand-coded program to another. In addition
to simply copying, an enterprise already fraught with transcription errors, this involved many
manual addition operations that were necessary in order to make sure that the subroutine was
referencing the appropriate machine language storage addresses. And, as Hooper pointed out in
[15], all of this manual work was done in order to operate a machine that was really good at copying
and adding, doing it quickly and accurately!
In 1949, John Mauchly proposed and implemented "Short-Order Code" or "Short Code" for
the BINAC computer as a set of interpretive subroutines stored in memory. It was thought of as
a "pseudo-code" for a simulated computer. The BINAC (BINary Automatic Computer) was a
pre-first generation computer built in 1949 for the Northrop Aircraft Company by J. Presper Eckert
and John Mauchly who had left the University of Pennsylvania to form their own company. (This
was later bought out by Remington-Rand.) The Short Code system was coded for use on the
UNIVAC I in 1950 and revised in 1952. Short Code executed approximately fifty times slower than
the equivalent hand-coded program.
The years 1950-1951 saw the emergence of a host of artificial machine languages, or "pseudo-
codes", for various machines. These instructions would provide for emulation of a hypothetical
computer--e.g, one that could handle floating-point storage and arithmetic--and would be
processed by an interpretive routine. John Backus' 1953 Speedcoding System for the IBM 701 was
an example of this type of programming tool.
In the early 1950s, Betty Holberton's Sort-Merge Generator was a first attempt towards using
a computer to write programs and inspired a whole family of other program generators. The
Sort-Merge Generator accepted as input the specifications for the files to be operated on and
automatically produced the sort/merge code.
In 1951, the first textbook on programming came over from England. Entitled The Preparation
of Programs for a Digital Computer, it was authored by Wilkes, Wheeler, and Gill. The book
discussed and contained several fully developed examples of machine-code subroutines and
subroutine linkage. The term "assembly routine" was introduced in this book and referred to a
piece of code which would combine a set of subroutines and allocate storage as blocks of relocatable
addresses called "floating addresses".
6 LINDA WEISERFRIEDMAN

Late in 1951, Grace Murray Hopper, working on Remington-Rand's UNIVAC I, came up with
the notion that programs constructed from "pseudo-code" instructions, rather than being
interpreted, ought to be translated into a complete set of machine language instructions. For this,
she coined a new term: a compiling routine.
In November 1952, Millie Coss came out with her "Editing Generator" which produced the code
to take data stored in the computer, apply simply arithmetic operations, and edit it appropriately
for printed output so that it would be readable by managers and other humans. This was the first
of the RPG-type of program.
In 1953, Nathan Rochester conceived of an assembler program that could be used to convert
the symbolic equivalents of operating codes, operands, and modifiers into the appropriate machine
codes.
In 1952, Alick E. Glennie, of England's Royal Armaments Research Establishment, developed
his AUTOCODE system, a primitive, highly machine-dependent algebraic compiler which
translated algebraic statements into the machine language of the Manchester Mark I. Glennie's
system, inspired by Aiken's "coding machine", serves to link the second generation to the third
generation of computer software, in which the emphasis is on "compilers" of increasing
sophistication and, finally, on the design of compiled, high-level programming languages.

THE T H I R D G E N E R A T I O N
The early compilers
Many consider the first true working algebraic compiler to be a system developed by J. H.
Laning Jr and N. Zierler for MIT's W H I R L W I N D computer. The WHIRLWIND, designed by
Jay Forrester and Ken Olsen, was the first 16-bit minicomputer and was capable of parallel
processing and real-time computing. This first compiler was demonstrated in the Spring of 1953,
or possibly even earlier, and the system was up and running by January of 1954.
In Italy, Corrado Bohm's doctoral dissertation, submitted in 1951, describes a system which is
unusual and prophetic in that it is not only a complete compiler, but is also defined in its own
language, a concept that was not to be implemented in a programming language until many years
later. In Bohm's language, every statement is a special case of the assignment statement. For
example, an unconditional branch to a statement named S would be equivalent to "set the program
counter to the value of variable S".
Grace Murray Hopper's programming team at Remington-Rand (UNIVAC) began in 1955 to
develop an algebraic programming language that used some English keywords. Released as MATH-
MATIC in April of 1957, the original compilers had been known internally as the "A series" (A-0,
A-l, A-3, AT-3). MATH-MATIC executed very inefficiently. In 1958, FLOW-MATIC (originally,
the "B series" of compilers B-0, B-1 . . . . ) was released, a language which used English words
heavily and was geared to business data processing. FLOW-MATIC was an important factor in
the subsequent design of COBOL.

The first programming languages

In 1945, a theoretical programming language was developed in Fed. Rep. Germany by Konrad
Zuse, called Plankalkul (program calculus). This development went virtually unnoticed for a long
time by many in the computing community, especially in the U.S., and was not published in its
entirety until 1972. The language is interesting to us because it was developed completely from the
"human" point of view without regard as to whether it would ever be implemented on any
particular machine. Among its features, Zuse's language provided for hierarchical data structures
similar to those which would eventually appear in COBOL. Although it lacked expressivity and
was neither writeable nor easily readable, still it is interesting to see such an early attempt to design
a language, rather than a compiler.
FORTRAN. In 1954, John Backus led an IBM team of researchers (later named the Programming
Research Group) into uncharted territory. The aim: to design and develop an efficient automatic
translator of mathematical formulas into IBM 704 machine code. The group would accept nothing
less than a system that would produce programs at least as efficient as their hand-coded
counterparts. Due to the prevailing skepticism on the part of the coding establishment towards
 A brief history of programminglanguages 7

anything that produced automatic code, the overriding concern of the group was the efficiency of
the executable code. An automatic code generator that was highly efficient would be more likely
to be accepted by the coding community. Programming language design, which always embodies
a tradeoff of sorts between the human being's ability to express high-level concepts and the
machine's ability to operate efficiently, was all but ignored in the interest of designing and
developing a compiler that would optimize as it translated from algebraic notation to machine code.
The language design aspects were handled rather quickly, in the manner of a chore that had to
be completed before the "real" work (the design of the compiler) could be done.
The group's first report was released in 1954 and described the specifications for a proposed
FORmula TRANslating System, or FORTRAN. A large portion of the 1954 document was
devoted to a justification of the system, including the very optimistic expectation that FORTRAN
would all but eliminate coding and debugging. Although the original projected completion time
for the compiler was six months, it wasn't until October 1956 that the FORTRAN language
reference manual was published and with it a promise to provide the compiler itself by late 1956.
IBM finally delivered it in April of 1957. (Some things don't really change.)
Customers did not immediately rush to embrace the new system, but a well-written Programmer's
Primer, authored by Grace E. Mitchell and published by IBM in 1957 did a lot for the ultimate
acceptance of FORTRAN in the computing community. As it turned out, the translator was not
only as efficient as the 1954 report had anticipated but, in some cases, it could be shown to produce
code more efficient than the equivalent hand-coded program.
Among the innovations to FORTRAN's credit, in addition to its title as the first true
programming language, are: a language based on variables, expressions, statements; the form of
the arithmetic-assignment statement; conditional and repetitive branching control structures;
arrays with maximum size known at compile time; FORMAT-directed input and output which
eliminated input-output conversions; statements such as COMMON and EQUIVALENCE for
data sharing; provision for comment statements even though FORTRAN code was thought to be
thoroughly "self-explanatory"; and the optimized utilization of index registers which was based on
the expected frequency of execution of different portions of the program.
FORTRAN, like certain other languages designed during this period, was designed for a specific
machine. While many of its statements were machine dependent and have disappeared from the
language as we know it today, certain distinguishing features (such as length of instruction) which
remained in the FORTRAN language resulted from the IBM 704 computer for which it was
designed.
In 1958, FORTRAN compilers were released for the IBM 709 and the 650; in 1960, for the 1620
and 7070. These versions were not necessarily identical to the original system, and a program
written on one compiler was not guaranteed to produce identical results on another. In 1961,
FORTRAN compilers were made available for the UNIVAC and for the Remington-Rand LARC,
and an imitation called ALTAC was used on the Philco 2000. In all, by 1964 there were more than
40 different FORTRAN compilers on the market. While every new FORTRAN compiler tried,
for the customers' sake, to be somewhat consistent with the original definition of the language, a
user could not really be certain that a value computed on one machine would be the same when
computed on another machine. The day of the portable, machine-independent language had not
yet arrived.
FORTRAN II was released in 1958, followed closely by FORTRAN III, and FORTRAN IV
in 1962. FORTRAN IV was the standard for the language until FORTRAN 77 was released in
1978. It included many enhancements, such as character strings, and selection and iteration
constructs, learned from other, newer languages and from structured programming methodology.
LISP. LISP, an interactive, applicative language was designed for the IBM 704 by John
McCarthy at Dartmouth during the years 1956-1958. He began implementing it at MIT in 1959
and the first reference manual was published in 1960. LISP is a language based on lambda-calculus
and, unlike the algebraic languages which were being developed during the same time period, it
was designed for symbolic formula manipulation. Over the years, LISP (LISt Processor) has
become the lingua franca, the medium of communication, of the artificial intelligence community.
Within that application area, LISP is used as a publication language for algorithms much as
ALGOL60 has for the scientific community. Some important innovative features of LISP are: the
8 LINDA WEISERFRml)MAN

funtion as the basic program unit; the list as the basic data structure; dynamic data structures;
facilities for "garbage collection"; use of symbolic expressions as opposed to numbers; recursion
and the conditional expression as control structures; the "evar' function for interactive evaluation
of LISP statements.
There are many dialects of LISP, including CommonLISP and Scheme.
ALGOL. In 1958, a committee consisting of European and American representatives held
meetings in Zurich to design a universal high-level programming language. The European
representatives were from GAMM, a German association for applied mathematics and mechanics,
and the American delegation was provided by the Association for Computing Machinery. One of
the American members of this committee was John Backus, who had led the F O R T R A N
development group.
One of the stated purposes of this design and development effort was to facilitate the
communication and exchange of ideas among the members of the international computing
community. In actuality, there was a more practical goal, as well. The European computing
community, with the exception of England, did not go through a so-called "second generation"
of software consisting of symbolic assemblers and other coding aids. They were still hand-coding
programs in machine code and, while one might say that a compiler language was desperately
needed, the work progressed on a more theoretical and organized level than did the more
pragmatic, seat-of-the-pants, American programming research efforts. In fact, one of the reasons
that a new language was desired, rather than simply adopting FORTRAN, is that FORTRAN was
still, at the time, a proprietary language--an IBM product. A recommendation to adopt
F O R T R A N as the programming language of choice in Europe would have been considered
equivalent to a recommendation to purchase only IBM machines. Such a recommendation would
have been not only impractical but violently opposed. Many members of the ALGOL committee
were specifically interested in curtailing what they felt were IBM's efforts to dominate in Europe
as well as in America. Thus, for these reasons and because of the international character of the
design committee, the language these individuals designed can be said to be independent of both
machine and political affiliation.
The language was originally named IAL, for International Algebraic Language, and eventually
renamed ALGOL (ALGOrithmic -Language); this first version became known as ALGOL58.
ALGOL58 was implemented on a number of computers and influenced the development of many
subsequent languages. One of these was a language called JOVIAL which, in turn, exerted a
significant influence on the development of PL/1.
The committees, meeting again in Paris in 1960 to improve the language and eliminate
weaknesses that had been uncovered, revised the language and issued an official ALGOL60 Report.
Although revised, ALGOL60 retained many of the distinctive features of ALGOL58. The influence
of ALGOL60 on programming language design, and on the development of computer science
in general, has been nothing less than profound. Among the many important features of the
ALGOL60 Report is the appearance for the first time of the BNF (Backus Normal Form)
metalanguage for programming language definition, credited to John Backus and Peter Naur. BNF
has earned its own place in computing history: it has influenced and, indeed, created many areas
of computer science theory.
In the development of ALGOL (58 and 60) we have, for the first time, the programming language
itself as the object of study, rather than simply a means toward an end. ALGOL has been used
as a publication language for algorithms, in American publications as well as internationally,
although ALGOL was never as widely implemented in the U.S. as, say, FORTRAN or COBOL.
ALGOL60 was widely implemented in Europe. Some of the distinguishing features of ALGOL are:
block structure and localized data environments; nesting of program units; free-format program code;
explicit type declarations; dynamic memory allocation; parameter passing by value and by name;
recursion; if/then/else; begin/end to delimit a compound statement; arrays with dynamic bounds.
ALGOL60 has spawned a host of "ALGOL-like" languages which contain such features as
nested block structures, compound statements, scoping rules, declaration of local variables, and
parameters passed by name, value, or reference.
COBOL. In May 1959, another group met, under the auspices of the Department of Defense,
to discuss the feasibility of developing a "common" programming language, this time for data
 A brief history of programming languages 9

processing applications. This group, composed of about 40 members, represented computer

manufacturers and users from industry, universities, and government and became known as the
CODASYL Committee (COOnference on DAta SYstems Languages). The result, in April 1960, was
a language called COBOL (COmmon Business-Oriented -Language). It was in the interest of both
the computer manufacturers represented and the government (which uses the products of many
different manufacturers) to design the language so as not to cater to or become dependent upon
any one specific machine or machine family. Thus, the language started out relatively machine-
independent, unlike FORTRAN.
COBOL was influenced by such existing languages as FLOW-MATIC, FORTRAN, ALGOL58,
and English. The significance of the use of English language words and constructs must not be
underestimated. Remember that first and second generation programming was relatively esoteric
and poorly understood and was considered by many to be something of a "black art". One of
the hardest jobs ahead of the innovators of this COBOL programming language was going to be
promoting the language among managers in the data processing community. The heavy reliance
on English would not only make programming easier to do and easier to learn, but would serve
to demystify the activity of programming and the workings of computers over all. Important and
innovative features of COBOL were: the record data structure; file description and manipulation
facilities; the machine independence of data and program descriptions; the equal emphasis placed
on the data descriptions in the Data Division and the operations in the Procedure Division;
the influence of English in the use of verbs, clauses, sentences, paragraphs, sections, and divisions;
a relatively natural language style, including noise words for readability; the overall effort towards
a language that would produce self-documenting program code.
In separating the description of data from program statements, and in giving these two aspects
of the programming task equal prominence, COBOL started an important trend in programming.
This trend toward data-oriented languages has culminated in the current proliferation of database
management systems, query languages, and database-centered high-productivity programming
tools and environments.
In addition, the COBOL report described the language in its own distinctive metalanguage
which~ while not as widely used or well known as the BNF of the ALGOL60, report, has found
its way into a variety of language descriptions over the years. This COBOL-type of metalanguage
is characterized by the use of English, few verbs, and many options.
Nol the least significant factor in its eventual acceptance in the data processing community was
the widespread availability of COBOL compilers. Shortly after the CODASYL committee
completed its design work, the Department of Defense sent a strongly worded letter to all computer
manufacturers advising them that if they wanted to continue to sell computers to the Department
of Defense (the largest computer contracter and endower of research grants) they had better put
a COBOL compiler on it. The COBOL language revision in 1961 was, needless to say~ widely
implemented.
Ma.jor revisions of the COBOL language were standardized and released in 1968, 1974, and 1985.
One of the more interesting phenomena in the history of programming languages is that
FORTRAN~ COBOL, and LISP, which comprise three of the four oldest programming languages,
and which sparked a tremendous interest in programming language design and motivated the
development of a huge number of diverse languages in the 1960s and 1970s, are still among the
most widely used languages today. The fourth, ALGOL, has until recently been the medium of
choice for sharing and communication among computing professionals and scholars (Pascal and
C are now also used for this purpose).

Babel
The decades of the 1960s and the 1970s saw a truly amazing proliferation of programming
languages. It was this hubub of activity that Jean Sammet in 1969 likened to the Biblical Tower
of Babel. Only relatively few of these languages are widely known today. Some were highly
specialized languages with a small user following, or were designed for one particular machine,
or were used only at a particular installation (such as a university research group). Some rose and
shone for a short while, only to be extinguished or replaced. We consider here a small selection
of the better~known third-generation programming languages.
10 LINDA WEISERFRIEDMAN

APL. The design of APL began as early as 1957 by Kenneth Iverson at Harvard and continued
on through 1960. Iverson did not then intend for the language to be implemented but, rather,
intended to design a notation for the expression of concepts for which mathematical notation alone
was insufficient (e.g. a sorting function). The language was ultimately formally defined and
introduced to the public in a 1962 book by Iverson entitled A Programming Language. Unnamed
for many years, the language eventually took its name from this publication. APL (A Programming
_Language) is an applicative, interactive, science-oriented language that assumes the array as the
default data structure. One of its most distinguishing features is its unusually large character set
which requires the use of a special keyboard. It is suitable for applications with a heavy use of
numerical data in large multidimensional arrays. It has also been used successfully in areas which
require speedy response to queries and, therefore, also for database management systems. A subset,
APL/360 was implemented on the IBM 360 in 1966.
SNOBOL. SNOBOL, was designed in 1962 By David J. Farber, Ralph Griswold, and Ivan P.
Polonsky, working at Bell Laboratories, as a string manipulation language to be used by researchers
as a tool for formula manipulation. It was first implemented in 1963. The language was influenced
mainly by early work at Bell Laboratories in string manipulation languages (SCL) and by COMIT,
an MIT symbol manipulation language designed for use by linguists. The 1963 implementation was
actually named SEXI (_String EXpression -interpreter), but for some unknown reason that name
was considered unacceptable. When the developers realized that the language might, in fact, see
widespread use someday, they worked hard at coming up with a more appropriate name and have
been known to confess that work on the name took more time and effort than designing and
implementing the entire language. They finally settled on SNOBOL, a semi-comic, intricate acronym
of StriNg Oriented symBOlic Language, claiming that the language had the proverbial "snowball's
chance". The complexity of the acronym was intended as a humorous jab at an industry with a
well-known proclivity for acronyms.
In addition to formula manipulation, various researchers began using the language for graph
processing, text processing, and program generation. Among the initial design criteria were concise-
ness, simplicity, flexibility, and problem-orientation (rather than computer-orientation). After going
through several revisions in 1964, the language finally emerged as SNOBOL4, developed over the
years 1966-1968 by Griswold, Jim Poage, and Polonsky. SNOBOL4, released in 1968, was designed
for third generation computer hardware and is a very different language from its predecessors. It
is used interactively, in a time-shared environment. SNOBOL4 supports a multitude of data types
and treats patterns as data objects. There are a large variety of pattern types. The unique feature
of the language is its facility for string and pattern matching.
BASIC. At Dartmouth College in 1963, Thomas E. Kurtz, John Kemeny, and a succession of
undergraduate students designed a high-level language with the intension of using it to introduce
students in non-scientific disciplines to computing. The first version of BASIC (_Beginner's
All-purpose _Symbolic Instructional Code) ran in May 1964. By the fall of 1964 there were 20
time-shared terminals hooked up to the BASIC system.
Among the influences on the design of the language were FORTRAN, ALGOL, and several
earlier, more primitive compilers designed at Dartmouth itself. The major goal was to simplify the
user interface. This meant that simplicity was chosen over compiler efficiency; time-sharing was
chosen over punched cards; technical distinctions such as integer vs real were eliminated; automatic
defaults were provided for variable declarations, variable values, dimensioning arrays, and for
output formats; clear error messages were provided; and students had "open access" to computer
terminals at all times. The third version of the language in 1966 marked the first time it was
interactive, with the addition of the INPUT statement. The use of BASIC spread rapidly,
infiltrating universities, high schools, elementary schools, personal use, small businesses, and even
industry. Unfortunately, there is no universal BASIC standard--although the American National
Standards Institute has published a minimal BASIC standard--and many implementations are
markedly different from others.
PL/I.
In 1963, IBM set out to design an extension to F O R T R A N to run on new IBM computers that
were still unannounced and unreleased; an extension that would be sufficiently general, or multi-
 A brief history of programming languages 11

purpose, to bring in more customers in addition to FORTRAN's hard-core faithful engineers. The
new equipment would be the "360-family" of computers and the language would be built to cater
to users in the business, scientific, real-time, list processing, and systems programming areas. The
design committee, which was for a time referred to internally as the FORTRAN VI Committee
(FORTRAN IV had just been released in 1962), drew on design concepts of FORTRAN, COBOL,
ALGOL60, and JOVIAL. JOVIAL, developed by the System Development Corporation for
the Air Force, was designed soon after the 1958 Zurich meetings as an ALGOL58 extension for
command and control applications, and has the distinction of being the first general-purpose
programming language.
This "FORTRAN extension" got further and further away from the FORTRAN specifications
and, in March 1964, the first specifications report for a new programming language was released.
Named NPL (New _Programming Language, of course), the language was aimed at users in the
scientific, data processing, text processing, real-time, and systems programming communities.
Unfortunately, the initials NPL conflicted with those of the National Physical Laboratory in
England and when the first version was finally ready for distribution--the first compiler for the
IBM 360, implemented by an IBM research group in England, was resleased in August of 1966--it
has been renamed PL/1, for _Programming Language/one.
PL/1, the "language to end all languages," was not the immediate success that IBM had
anticipated. The first compilers were inefficient and unreliable. The language developed a reputation
as a large "monster" requiring a machine with large amounts of available memory. FORTRAN
and COBOL already had a large base of dedicated users with large libraries of trusted subroutines.
One of the reasons that PL/1 eventually generated a lot of interest, especially in the academic
community, was that it was a state-of-the-art language containing virtually every conceivable
element of language design. It is for this same reason that it has drawn much of its criticism--
as a language that is too big, with too many features. From FORTRAN, it inherited much of its
expression and statement syntax, shared data, and the external procedure; from COBOL, the
language got its data description, record and file handling, and report generation facilities; from
ALGOL, its block structure, type declarations, and recursion. In addition, it was the first language
to provide: multitasking; programmer-defined exception (interrupt) handling; defaults; explicit use
of pointers and list processing; a wide variety of alternatives for storage allocation--static,
automatic, controlled; and to consider problems arising from interacting with an operating system.
Logo. Seymour Papert of MIT, along with a group of researchers and consultants at a Cambridge
research firm, developed Logo over the years 1966-1968. It was designed specifically for
mathematics education and was actually used experimentally in elementary school classrooms in
1967. Papert wanted to find a way to make children more comfortable learning mathematics. He
had studied under the mathematician and psychologist Jean Piaget and was very strongly influenced
by Piaget's work on childhood development. Papert felt that if mathematics, an abstract discipline,
could be made more concrete for children, they could learn it more easily and at an earlier stage
of development.
Logo is very similar to LISP, relying on the use of functions and list structures. It incorporates
"turtle graphics", a vehicle for teaching geometric principles at a concrete level. The child gives
a "turtle" on the screen instructions so that it can create geometric shapes. Logo's memory
requirements are quite small and it is widely available on microcomputers.
FORTH. During the 1960s, Charles H. Moore strove to develop a language that would be
efficient enough for scientific and engineering applications yet allow for faster programming using
fewer lines of code than, say, FORTRAN. Due to these two apparently conflicting goals, the
resulting language combines features of both high-level and low-level programming, a feature
popularized later in C and MODULA-2. In FORTH, as in LISP, programs are constructed using
functions. FORTH's functions are called words, and like functions, which are built up on top
of other functions, words may be composed of smaller words. Like assembly language, FORTH
arithmetic is based on Reverse Polish notation and a stack for processing. FORTH was first used
in 1971 at the National Radio Astronomy Observatory.
The name of the language derives from its author's goal to design the first "fourth-generation
language". (Moore did know how to spell--the IBM 1103 computer on which he worked allowed
no more than five-characters in a name.) FORTH cannot be considered a fourth-generation
12 LINDA WEISERFRIEDMAN

language today. It is highly procedural and requires a great deal of intense effort and computer
know-how on the part of a technical programmer. FORTH is not intended for the non-technical,
casual user.
SIMULA. Designed in 1962 by Kristen Nygaard and Ole-Johan Dahl at the Norwegian
Computing Center, under contract with Univac, SIMULA was motivated by a desire to create a
programming language for simulation applications--a technique of operations research that has
since been successfully used in a large number of diverse application areas--which would also serve
as a medium for describing the (simulated) system under study. The SIMULA world-view is
that of activities consisting of interacting processes. SIMULA drew heavily from ALGOL60.
SIMSCRIPT, a language for discrete-event simulation developed in 1963 at the Rand Corporation,
had considerable influence on the development of SIMULA, especially with regard to its list
processing, time scheduling, and library routines. SIMULA was implemented in 1964 on the
UNIVAC 1107 and the language reference manual was published in 1965.
SIMULA67, the 1967 revision of the SIMULA language, was of a more general nature. The class
concept, an important generalization of ALGOL's block concept which enables the programming
of coroutines, was first incorporated into this version of the language. The class concept of
SIMULA67 was an important influence on languages which were later to provide for data
abstraction and object-oriented programming.
ALGOL68. In 1968, the ALGOL committee produced a considerably revised and extended
version of ALGOL. ALGOL68 is a huge, general-purpose language, setting it apart from the
scientific orientation of ALGOL60. It was, in fact, quite a different language from ALGOL60 and
was not well accepted by many of the computing community because it was considered to be overly
complicated and impractical, and difficult for compiler writers. Compared to the profound
influence ALGOL60 has had on programming language design and on computer science itself,
ALGOL68 casts a pale shadow. In fact, many consider ALGOL68 to be a mere offshoot of
its famous ancestor while Pascal carries the tradition. To its credit, ALGOL68 innovated the
user-defined data type, a significant feature of Pascal.
Pascal. The entire ALGOL committee could not be said to favor the 1968 revision to the
language. One of the dissenters, Niklaus Wirth, felt that ALGOL68 was needlessly big and
awkward. After having first proposed in 1965 an altogether different "new" ALGOL--which
subsequently became known as ALGOL-W--he designed the Pascal programming language, which
was first implemented in 1970, in order to illustrate the direction that ALGOL should have taken.
Pascal, designed for use in education, stands out in opposition to the trend--a trend which began
with PL/1 and ALGOL68 and continues to this day with A d a - - o f enriching a language with so
many complicated features that no one user could be expected to know all of it. In fact, Pascal,
a true child of ALGOL60, has rapidly supplanted ALGOL68 in prominence.
Named after the 17th century French philosopher and mathematician Blaise Pascal, the language
has been the predominant programming language in the academic community. It has also become
increasingly popular as the language of choice for developing a wide variety of microcomputer
applications. Pascal is a narrowly defined, simple, and elegant language. Among its interesting
features are the case statement, the facility for user-defined data types, and the record structure.
C. In 1972, Bell Laboratories' Kenneth Thompson and Dennis Ritchie developed the language C
for coding the routines of the UNIX operating system. C was an extension of the language B--also
designed by Thompson--which itself drew heavily on an earlier systems programming language,
BCPL. (In fact, BCPL had, by a circuitous route, been influenced by ALGOL60.) By 1973, 90%
of the UNIX code had been rewritten in C. C, a high-level systems programming language that
contains low-level programming capability, created the notion of a portable operating system. This
benefit is currently contributing to wide and increasing support for UNIX and for C. The language
is not without its problems, however. A concise syntax makes C programs difficult to read, under-
stand, debug, and maintain. The language provides no built-in operations for handling composite
data objects such as character strings, sets, and lists. Because it is not strongly typed, rather
permissive regarding data conversions, and provides no run-time type checking, it is considered
by some not only to allow programmer errors but to encourage them. Still, the extreme degree of
portability of the language and the ability to code low-level operations in a high-level language
make C a language of choice for an increasingly large number of programmers.
 A brief history of programming languages 13

MODULA-2. MODULA-2, a direct descendent of Pascal, is another high-level language with

facilities for systems programming. Intended for use in large system software design, including
real-time and parallel-processing systems, the language supports a high degree of problem
decomposition and program abstraction. In 1978, Niklaus Wirth, of Pascal fame, directed the
design and development of MODULA-2, drawing heavily from Pascal and MODULA (MODUlar
LAnguage), an earlier experiment with multiprocessing. MODULA-2, was designed in 1978 and
released in 1980.
MODULA-2 is characterized by strong typing and syntactic style, and, of course, the module,
a type of block that can be compiled independently and easily assembled into program libraries.
The module facilitates information hiding and the decomposition of a program into subprogram
units with relatively well-defined interfaces. This is important for the definition of abstract data
types. It is also important for low-level programming in a high-level language since it allows these
"dangerous" low-level computations to be encapsulated in clearly delineated pieces of code. A
distinguishing feature of the language is the set of library modules which may be provided along
with the compiler and which is then added to by the programmer. The module library varies with
the implementation.
Ada. If PL/1 was the 1960s answer to the perceived need for a "language to end all languages"
then Ada provides that service two decades later, with about the same degee of success. Named after
the first computer programmer Lady Augusta Ada Lovelace, designed according to specifications
developed by the Department of Defense, the Ada language was intended for the programming
of embedded computer systems. Specifically, it had to be applicable to systems programming,
real-time systems, parallel and distributed processing systems, and the program development
environment. The Department of Defense discovered that it was using about four hundred different
programming languages, many of them dialects of existing common languages. This situation had
evolved over the years as one systems programmer after another had tailored languages to
applications in the interest of efficiency. Of course, while this increased the productivity of the
computer, programmer productivity suffered.
The language requirements stressed the implementation of structured programming methodology
and emphasized readability--including clarity, understandability, and modifiability--over write-
ability. The Ada language design effort marks the first time that a completely separate group---not
the one to ultimately work on language design and implementation--defined the requirements.
Documents describing the language requirements started appearing in 1975 and became progressively
more detailed and well defined. The complete language was finally proposed in 1980 as MIL-STD
1815 (the year the Lady Ada Lovelace was born). The final, standardized version appeared in 1983.
Working, usable compilers first started to appear on the scene around 1985, so experience with the
language is still rather new. One of the lures of the Ada language, at least in the computing
community, is that Ada contains virtually every known state of the art element of programming
language design. It contains facilities for exception handling, parallel processing, abstract data
types, and many other features. As with PL/1 and ALGOL68, this is also its major drawback.
The publication of that first FORTRAN report in 1954 triggered a veritable revolution in
computing. That revolution was characterized by the development of literally hundreds of program-
ming languages, all with the express goal of taming the electronic computer for high-level use by
humans in every application area. Figure 2 illustrates some of the influences on programming
language design exerted by the "ancestor" languages FORTRAN, COBOL, LISP, and ALGOL
on their descendents, culminating in the famous ALGOL family of programming languages. These
are third-generation, procedural languages. Other languages of equal importance have not been
represented in this figure simply because their lineages are short and simple and their influence over
later languages is minimal.

THE F O U R T H G E N E R A T I O N
The von Neumann-type of computer architecture, while serving as catalyst for a generation of
programming languages may also, it appears, be guilty in large part for the degree of stagnation
we have seen in the conceptual development of programming language technology. The stored
program concept binds computer control directly and intimately with program variables representing
14 LINDA WEISERFlttEDMAN

memory locations and involves the use of a single counter that controls program flow by a sequence
of instructions. Programming language paradigms relying on this underlying computer architecture
tend to be statement-oriented, assuming the sequential execution of a limited number of operations.
Programs written in these languages are composed of vast numbers of lines of code. The debugging
of a complex program, while a definite improvement over hand-coded machine language versions,
is often an arduous and lengthy task. Also, maintenance is time-consuming and costly. Third
generation programming languages are largely procedural. This includes imperative, statement-
oriented languages like F O R T R A N and ALGOL and their descendants and the function-oriented
languages like LISP and its progeny, although functional languages are less procedural than
imperative languages. One might say that while imperative languages were developed because of
the von Neumann architecture, functional languages were developed in spite of it. Both, however,
rely on the programmer's ability to completely specify in detail precisely how the computing is to
be done.
A fourth generation language is declarative, i.e. its instructions to the computer concentrate more
on what is to be done rather than on describing in detail how to do it. You may wish to refer again
to the illustration of the "software ladder" in Fig. 1. Fourth generation software tends toward an
emphasis on high productivity, choosing to optimize human labor over computer time, and is
frequently aimed at the non-technical user in a particular application area. Programs are shorter,
as well as easier to code, debug, and maintain. Some of the trends in fourth generation software
include: declarative languages; packaged software; integrated packages; user-friendly interactive
environments; query languages; high-productivity programming tools; and the integration of
languages, programming tools (e.g. editor, linker, translators, file handler, etc.), and the user
interface within a single interactive system. Clearly, some of the languages (or systems) labeled as
fourth generation are only partly non-procedural; the classification, as always, is arbitrary.
Packages. We mark the beginning of this fourth generation of software with the development
in 1961 of the statistical package, BMD, at the University of California at Berkeley. BMD
(BioMeDicalpackage) was implemented in F O R T R A N on the IBM 7090. It was followed soon
after by a host of others, including DATATEXT, developed at Harvard University in 1967 under

1954
1956 FORTRAN
FLOW-
1958 / I\ ~ MATIC ~ T A L ( ALGOL58) LISP

1960 / I\ I.-' OWL .LOOL60

1962
1964 SIMSCRIPT BASIC p~ LA 1 /
1966
BCPL / I SIMULA 67 Logo
1968
1970
\
1972
1974

1976
cZ /°i
1978
1980 Smat~totk-80
Ada
1982
1984
Fig. 2. Some influences on programming language design.
 A brief history of programming languages 15

the direction of Arthur S. Couch and aimed at social scientists. Although BASIC, a procedural
language whose prime objective was ease of use and a more "natural" user interface, was also
developed during this time period, it is obvious that an instruction such as, for example:
COMPUTE REGRESSION (STATUS ON AGE, IQ, INCOME)
would be easier for social scientists (or anyone) than learning how to code solutions to the
regression equation in BASIC. While BMD, DATATEXT and other statistical packages such as
SPSS, SPSS-X, BMD-P, and SAS undoubtedly contain procedural elements as well, the major
thrust is toward a declarative programming orientation. Packaged, off-the-shelf software has
continued to proliferate, especially with the advent of the personal computer, and now extends into
a large number of application areas.
PROLOG. PROLOG (PROgramming in LOGic), was developed in 1970 by Alain Colmerauer
and Phillipe Roussel of the University of Marseille's artificial intelligence group, in collaboration
with Robert Kowalski of the University of Edinburgh. First implemented in 1972 in ALGOL-W,
for the purpose of natural-language processing, this logic-oriented language is declarative in nature.
It has a firm mathematical basis, grounded as it is in the principles of predicate calculus. A PROLOG
program expresses a problem in the terminology of logic, describing the problem in terms of facts
and rules, and the system uses deductive reasoning to find possible solutions for the problem. This
language has been used for such application areas as natural language processing, building expert
systems, building relational databases, and the intelligent querying of such databases. Until the
1980s, it was popular mainly in Europe; in the U.S., LISP, along with its many dialects, is still a
strong contender in the artificial intelligence community. Since 1981, when PROLOG became closely
associated with Japan's Fifth Generation Project, use of the language has become increasingly
widespread both in this country and in the internal computing community.
Collaboration between Marseilles and Edinburgh ended at about 1975, and since research into
the language continued at both locations, there exist two slightly different versions of the language,
M-PROLOG and E-PROLOG. Edinburgh PROLOG has become the de facto standard.
OPS. OPS is a production-system, or rule-based, language used in the field of artificial
intelligence. A production is another name for a condition-action rule; a set of these rules is called
a production system. OPS, named somewhat tongue-in-cheek as the Official P_roduction System,
was developed at Carnegie-Mellon University in 1970 and is still maintained there. The latest
version, OPS5 was released in 1977 and has been implemented on microcomputers.
Smalltalk. Smalltalk was designed and implemented in 1972 at the Xerox Palo Alto Research
Center (PARC) as the software component of Alan Kay's legendary Dynabook, a notebook-sized
personal computer for the non-technical user. This early implementation took the form of a one
thousand-line BASIC program. Later that year, the system was rewritten in assembly code by
Daniel H. H. Ingalls, who is also responsible for later versions of the language.
Smalltalk can actually be considered a language embedded within a environment. Both of these
components are composed totally of objects, small encapsulated pieces of code that are cousins
to MODULA-2's modules and Ada's packages. It is interesting to note that, with its roots in
SIMULA67, an imperative language, and Logo, a functional language, Smalltalk created and
continues to defines the object-oriented approach to programming. In this approach, a program
is designed as a system of objects which communicate ("talk") with one another and with the
human user by sending messages. Although the language can be implemented without the
environment, the environment--a user-friendly, interactive interface with multiple overlapping
windows, graphical and textual menus, a mouse for selecting and pointing--is an integral part of
the Smalltalk approach to program development. In fact, this is a characteristic of most
fourth-generation software. That the environment can be implemented without the language was
demonstrated by Steve Jobs, then of Apple Computer, when he used it as the basis of the Lisa and
subsequently the Macintosh operating system.
Smalltalk went through a series of revisions at Xerox PARC, where it was strictly a proprietary
product, until 1983 when Smalltalk-80 was released to the general public. Since then, the language
itself has become increasingly popular but, more than that, the distinctive features of Smalltalk--
including its object-orientation and graphical interface--have profoundly influenced many other
languages, software products, and computer science methodology.
16 LINDA WEISERFRIEDMAN

Query languages. Query languages were developed in the early 1970s in response to the great
proliferation of databases in business. Managers did not want to be dependent on programmers
using COBOL to query databases for them. Querying a database using a procedural language such
as COBOL requires a skilled programmer and may take a great deal of time. Database management
systems were developed for mainframes in the late 1960s. These included SystemR, INGRES,
ADABAS, and ORACLE.
To make databases accessible to people with minimal training, query languages were developed
to be user-friendly. Beginning in the early 1970s, formal query languages began to be paired with a
database management system. For example, QUEL was developed for INGRES, SQL for SystemR,
and NATURAL for ADABAS. Query languages may contain other features besides the ability to
query a database. Many allow the user to also define the structure of the data, to manipulate and
to update the data, and to delineate security constraints for the data file. Formal query languages
have highly stylized commands. They are easier to use than, say, COBOL, but are still difficult to
learn. The late 1970s saw the development of menu systems and the natural language front end
as a user interface to the query language. This type of product searches the user input for certain
key words and then converts them into the syntax of the formal query language or even lower-level
computer instructions.
Some representative query languages are QBE, developed in 1975 by Moshe Zloof at IBM; SQL,
also designed at IBM, first marketed in 1979 by Oracle; and INTELLECT, developed in 1977 by
Larry Harris, a query language that uses natural language processing.
High-productivity programming tools and environments. A fourth-generation high-productivity
tool is largely non-procedural, user-friendly, and problem-oriented. An integrated package of these
high-productivity programming tools, coming together to produce a friendly, often intelligent,
programming environment, can significantly speed up the development and implementation of
application programs. These systems have been centered around a database and include the
components of a database management system, and are fairly "taking over" in the busifness/data
processing community, where they have been referred to for some time as "4GLs" (for 4th
__Generation __Language). A "full-function 4GL" is likely a system that contains: a central database
and data dictionary, a non-procedural query language, a data definition language, a graphics
component, a statistical or decision support component, an interactive programming environment,
and a report generator. The full-function "4GLs" include FOCUS, NOMAD2, and RAMIS II.
Some of the systems in this category are intended for use by programming professionals, but others,
equipped with a natural-language front end, are designed so that the non-technical end user can
write applications without professional assistance.

SUMMARY
While the trend in computer hardware evolution has been to produce computers that are
increasingly more powerful, smaller, and less costly, the story of computer software evolution began
with human beings that were forced to "think" in the code of a specific machine--Grace Murray
Hopper tells of accidentally balancing her checkbook in octal--and developed eventually into
computer systems that can communicate and "think" much like human beings or, at least, act as
if they can.
The proliferation of computer programming languages--the "Tower of Babel"--continues to
this very day. There have probably been more than one thousand programming languages designed
and implemented, although many of these have been used solely for "in-house" production rather
than marketed for commercial use. At any rate, the "traditional" languages, such as FORTRAN,
COBOL, BASIC, and Pascal, no longer command the exclusive attention of the computing
community.
There are a lot of exciting things happening today in the realm of programming languages: the
design of Ada, a language that represents the culmination of a long line of development beginning
with F O R T R A N and ALGOL and including such influences as PL/1, Pascal, MODULA-2, and
SIMULA67, structured programming methodology, data abstraction, and concurrent processing
techniques; renewed interest in artificial intelligence and LISP; PROLOG and commercial expert
systems; user-friendly integrated packages; natural language processing; the high-productivity
 A brief history of programming languages 17

p r o g r a m m i n g e n v i r o n m e n t s o f " 4 G L s " as the t e r m is used in business d a t a processing; a n d the

o b j e c t - o r i e n t e d p r o g r a m m i n g l a n g u a g e s a n d p r o g r a m m i n g e n v i r o n m e n t s which m a y well c a r r y
s t r u c t u r e d p r o g r a m m i n g m e t h o d o l o g y a n d large systems d e v e l o p m e n t into the twenty-first century.
M a n y o f these l o n g - a w a i t e d a d v a n c e s in software are first possible n o w because o f the r e a d y
a v a i l a b i l i t y o f inexpensive h a r d w a r e , user-friendly o p e r a t i n g systems, a n d p o w e r f u l p r o g r a m m i n g
environments.
V i r t u a l l y all o f the l a n g u a g e s in wide use t o d a y have a long a n d v a r i e d history. F i g u r e 2
s u m m a r i z e d the m a j o r influences on the initial design o f s o m e p r o g r a m m i n g l a n g u a g e s in wide use
t o d a y . H o w e v e r , a l t h o u g h the oldest l a n g u a g e s were first released m a n y years a g o a n d u n d e r w e n t
i n d e p e n d e n t research a n d d e v e l o p m e n t efforts at the time, they are all c h a r a c t e r i z e d by a lengthy
p e r i o d o f d e v e l o p m e n t which c o n t i n u e s to the c u r r e n t day. T h e n u m e r o u s revisions o f these
p r o g r a m m i n g l a n g u a g e s have, over the years, exerted c o n s i d e r a b l e influence over each other as
m u c h as over the newer l a n g u a g e s a n d dialects. P e r h a p s t h a t is why they are still so very m u c h
alive.

Acknowledgement--The material in Table 1 and Figs 1 and 2 were obtained with permission from the author's recent book
Comparative Programming Languages: Generalizing the Programming Function, Prentice-Hall, 1991.

REFERENCES
1. Burks, A. R. and Burks, A. W. The First Electronic Computer: The AtanasoffStory. Ann Arbor, Mich.: University of
Michigan Press; 1988.
2. Cheatham, T. E. Jr. The recent evolution of programming languages. In Information Processing 71: Proceedings of the
IFIP Congress 1971 (Edited by Freiman, C. V.), Vol. 1, pp. 298-313. New York: North-Holland; 1972.
3. Computerworld. History of computing. (November 3): special section; 1986.
4. Computerworld. In depth: the IBM 360 turns 25. (April 24): I, 81 +; 1989.
5. Knuth, D. E. Ancient Babylonian algorithms. Commun. ACM 15: 671-677; 1972. Also, Errata, Commun. ACM 19:
108; 1976.
6. Knuth, D. E. and Pardo, L. T. The early development of programming languages. In A History of Computing in the
Twentieth Century: .4 Collection of Essays (Edited by Metropolis N. et al.), pp. 197-273. New York: Academic Press;
1980.
7. Metropolis, N., Howlett J. and Rota, G.-C. (Eds) A History of Computing in the Twentieth Century: A Collection of
Essays. New York: Academic Press; 1980.
8. Morrison, P. and Morrison, E. (Eds) Charles Babbage and His Calculating Engine. New York: Dover; 1961.
9. Rosen, S. Electronic computers: a historical survey. ACM Comput. Surv. 1: 8-36; 1969.
I0. Rosen, S. Programming systems and languages 1965-1975. Commun. ACM 15: 591-600; 1972.
I 1. Sammet, J. E. Programming Languages: History and Fundamentals. Englewood Cliffs, N.J.: Prentice-Hall; 1969.
12. Sammet, J. E. Programming languages: history and future. Commun. ACM 15: 601-610; 1972.
13. Stein, D. Ada: A Life and a Legacy. Cambridge, Mass.: MIT Press; 1985.
14. Taylor, D. Languages: past, present, and future. Comput. Lang. 4: 57-62; 1987.
15. Wexelblat, R. L. (Ed.) History of Programming Languages. New York: Academic Press; 1981.

About the Author--Linda Weiser Friedman received the B.A. degree from Baruch College of the City
University of New York in 1977. She received the M.S. degree in 1980 and the Ph.D. degree in 1983 from
Polytechnic Institute of New York. Dr Friedman has been on the faculty of Baruch College of the City
University of New York since 1981, where she is currently Associate Professor of Statistics and Computer
Information Systems. Her research interests are in the areas of statistical analysis of computer simulation
experiments, applied statistics, and computer languages. She has recently published a textbook, Com-
parative Programming Languages: Generalizing the Programming Function, Prentice-Hall 1991.

CL 17/I--B