Grace Murray Hopper"
1951 - 1957: FLOW-MATIC & The First Compiler
Known for her discovery of a moth in a relay of the Mark I computer in 1945 which lead to the term "computer bug", Grace Hopper develops the first computer compiler which is called A-0, in 1951.
In 1949 Hopper joined the Eckert-Mauchly Computer Corporation as a Senior
Mathematician where she worked with John Eckert and John Mauchly on the UNIVAC computer. While there,
she designed an improved compiler, a program which translated a programmer's instructions into
computer codes. Hopper's reason for designing a compiler was, she wrote later, because she was lazy
and hoped that the introduction of compilers would allow the computer programmer to return to being a
mathematician.
The Remington Rand Corporation had acquired the Eckert-Mauchly Computer Corporation in 1951, and
changed its name to the UNIVAC Division of Remington Rand. Hopper became a Systems Engineer and
Director of Automatic Programming Development of the UNIVAC Division. She continued her work on
compilers, publishing her first paper on that topic in 1952. In 1957 her division
developed a new version of the A-0 compiler called Math-Matic, the first English-language
data-processing compiler.
Her next triumph was A-2; what we today call an assembly language compiler. As a front-end translator
to A-0, A-2 implemented a three-address machine code (e.g., to add x to y to give z, you use
[ADD 00X 00Y 00Z]). Next Hopper developed the A-3 and the AT-3, both of which were languages with
a mathematical flavor (AT-3 was similar to FORTRAN), and respectively marketed as ARITH-MATIC and
MATH-MATIC, by Remington Rand in the hopes of making them more appealing to customers.
Hopper would later assist in the work to produce specifications for a common business language. Since
Flow-Matic was the only existing business language at that time, it was inevitable that it should
provide the foundations for the specification of the language COBOL (COmmon Business-Oriented
Language) which eventually came out in 1959. FLOW-MATIC's key technical contributions included the
use of data names instead of short symbolic names, such as UNIT-PRICE and INVENTORY, the use of full
English words for commands, such as DIVIDE and COMPARE, the allocation of less than a full machine
word for each data item (thus saving on memory), and the separation of data descriptions from
instructions, a technique taken for granted by most programmers.
1952: Autocode
Alick E. Glennie, in his spare time at the University of Manchester, devises a programming system called AUTOCODE, a rudimentary compiler.
1957: The Development of FORTRAN I
The first major language appears in the form of FORTRAN, short for FORmula
TRANslating system. FORTRAN was designed by IBM for scientific computing. The components were very
simple, and provided the programmer with low-level access to the computers innards. It included the
IF, DO, and GOTO statements, which were a major step forward when it was released. Data-types in use
by today's languages got their start in FORTRAN. These included the logical variables (TRUE or FALSE),
and numerical variables (integer, real, and double-precision numbers).
The first FORTRAN compiler was a milestone in the history of computing. At the time of its
development, computers had very small memories (on the order of 15KB, it was common then to count
memory capacities in bits), were slow, and had very primitive operating systems, if they had them at
all.
The pioneers of FORTRAN didn't invent the idea of writing programs in a High Level Language (HLL) and
compiling the source code to object code with an optimizing compiler, but they produced the first
successful HLL. They designed an HLL that is still widely used, and an optimizing compiler that
produced very efficient code, in fact the FORTRAN I compiler held the record for optimizing code for
20 years!
This first FORTRAN compiler was designed and written from scratch between 1954-57. The new invention
caught on quickly because programs computing nuclear power reactor parameters took now hours instead
of weeks to write, and required much less programming skill. Another great advantage of the new
invention was that programs now became portable. Fortran won the battle against Assembly language,
and was adopted by the scientific and military communities, where it was used extensively in the
Space Program and military projects.
1958: The Development of FORTRAN II & III
Adding the capability for separate compilation of program modules, FORTRAN II was a
significant improvement, allowing assembly language modules to be 'linked loaded' with FORTRAN modules.
Although it was never released, FORTRAN III made it possible to use assembly language code right in
the middle of FORTRAN code. Such "inlined" assembly code can be more efficient, but the advantages of
an HLL such as portability and ease of use are lost.
1958: LISP
John McCarthy of MIT creates the LISt Processing (LISP) language. It was designed
for Artificial Intelligence (AI) research, and because of which, had syntax which had rarely been seen
before or since its introduction. LISP v1.5 would appear in 1959.
The most obvious difference between LISP and other languages is that the basic and only type of data
is the list, denoted by a sequence of items enclosed by parentheses. LISP programs are written as a
set of lists, so that LISP has the unique ability to modify itself, and therefore grow on its own.
The LISP syntax was known as "Cambridge Polish" as it was very different from the standard Boolean
logic. An example of this is often noted as the following:
x V y --Cambridge Polish, what was used to describe the LISP program
OR(x,y)-parenthesized prefix notation, what was used in the LISP program
x OR y--standard Boolean logic
Due to its highly specialized and abstract nature, LISP has remained in use to this day. All Lisp
implementations since the late 1960s have offered a set of programming features tough to equal in any
language, even today: macros, string handling, recursion, closures, reflection, packaging, arrays, and
extensive IO facilities. Modern Lisp systems support object-oriented programming, database access, GUI
construction, and all other forms of general-purpose programming. A very mature language, Lisp is
extremely well-documented, and the most widespread dialect, Common Lisp, is also codified by ANSI and
international standards.
Click to view a sample LISP program
1958: ALGOL 58
Created originally in 1958 by a committee for scientific use, ALGOL was the first
block-structured language that appears. A later version, ALGOL 60, was released in 1960 and would
serve as the root of the family tree that will ultimately produce other languages such as Pascal, C,
C++, and Java. ALGOL is the first language with a formal grammer, known as Backus-Naar Form or BNF.
It also implemented some novel concepts, such as recursive calling of functions.
Even though ALGOL at first was ahead of its time, it would gain most of its popularity in the mid to
late 1960's, mainly in Europe. Eventually, by the time ALGOL 68 is released in 1968, the language has
become bloated and difficult to use, leading to its substitution by the very languages it helped to
spawn, Pascal and C.
Click to view a sample ALGOL program
1959: COBOL
Although FORTRAN was good at handling numbers, it was not so good at handling
input and output, which mattered to most business computing. When business computing began to take
off in 1959, COBOL was developed to fill the need that FORTRAN could not. Created by the Conference
on Data Systems and Languages (CODASYL), COBOL was developed from the ground up as the language for
business men. The only data types were numbers and strings of text. It allowed for these to be
grouped into arrays and records so that data could be tracked and organized better. Because of this,
a COBOL program is built much like a written essay, with four or five major sections that build to
create a finished product. COBOL statements have a very English-like grammar, making it quite easy to
learn, especially for the business men for which it was designed.
A COBOL program normally consists of four divisions: identification, environment, data, and procedure.
COBOL's environment division is an attempt to make programs more portable by forcing the programmer to
enumerate all in one place the resources and facilities that the program would require. Traditional
COBOL's feature set is idiosyncratic: only static data structures are supported, numeric variables can
be binary or decimal, with extensive support for range checking and output formatting, extensive
string manipulation support, and simple flow-control constructs. Record structures and arrays are the
primary means for organizing data, but no pointers or references are available. The language is very
often employed along with a database, and most implementations include extensive database support.
COBOL's support for complicated calculations is modest, and some implementation don't even support
recursion.
Click to view a sample COBOL program
1960: APL
Kenneth Iverson begins work on the language that will become APL--A Programming
Language. It uses a specialized character set that, for proper use, requires APL-compatible I/O
devices. APL is an interpreted mathematical language characterized by its terse syntax and bizarre
non-ASCII character set. It is very strong in all forms of arithmetic and matrix manipulation.
APL would later be documented in Iverson's book "A Programming Language", which is published
in 1962.
According to its fans, its expressive power allows a skilled programmer to create complex applications
in a very short time. Sometimes, entire complex mathematical analyses can be coded in a couple of
lines of code. However, APLs unconventional structure and odd character set make it challenging to
learn and master. Today, APL is used mainly in niches in the scientific, financial, and econometric
communities
Click to view a sample APL program
1961: FORTRAN IV
As noted before, FORTRAN III was never implemented, causing the version in use to jump from FORTRAN II to FORTRAN IV when it was released in 1961. Considered a "clean up" of FORTRAN II, it improved things like the implementation of the COMMON and EQUIVALENCE statements, and eliminating some machine-dependant language irregularities. A FORTRAN II to FORTRAN IV translator was used to retain backward compatibility with earlier FORTRAN programs.
1962: SNOBOL
Designed by three people at Bell Laboratories: (D.J. Farber, R.E. Griswold, and
F.P. Polensky, SNOBOL (StriNg-Oriented symBOlic Language) is a special purposed language developed to
provide a powerful means of doing character string manipulation. Accordingly SNOBOL has a collection
of powerful operations for doing string pattern matchings. The most common early application of SNOBOL
was to write text editors. Because of the dynamic nature of SNOBOL and its interpreter implementation,
it is now considered too slow for such applications. Infact SNOBOL is now close to being completely
unused.
Despite its specialized nature, SNOBOL will in 1971, give rise to FASBOL, a SNOBOL compiler, and
SPITBOL (SPeedy ImplemenTation of snoBOL).
Click to view a sample SNOBOL program
1963: PL/I
PL/I (Programming Language 1) is a large, complex block-structured language invented by IBM in 1963, and first released in 1964 in conjunction with the influential System/360 line of computers. PL/I was intended to be THE all-around language for mainframe system and application development, and therefore it had a very large feature set. PL/I was widely used by the IBM community, and by the early 1980s, PL/I included the following language facilities:
IBM spent a lot of effort developing an optimizing compiler for PL/I, and a lot of seminal research on
high-level language optimization was done in the late 1960s and early 1970s on the PL/I optimizing
compiler. Today, commercial PL/I compilers are available for IBM mainframes, PCs running WindowsNT
and OS/2, and some UNIX workstations. No free PL/I compilers are currently available (although there
was a subset compiler named PL/C that was free at one time).
PL/I was an attempt to compile the best features of Algol (program structure, semantics), FORTRAN
(calculations), and COBOL (data structuring, I/O) into one new, all-purpose language. T he result was a
very complex language, but one that did serve most programming purposes quite well. However, the
complexity of the language and the resulting complexity of the compilers and their diagnostics made
writing and debugging PL/I code burdensome for many users.
PL/I was invented in the age of punch cards, but the language syntax is only slightly tarnished with
column-specific formatting rules. Newer versions of PL/I have entirely shed their punched-card legacy.
There is a great deal of legacy PL/I code in the IBM mainframe community, and skilled PL/I
programmers were in demand as the year 2000 deadline approached and systems needed to be updated or
changed.
Click to view a sample PL/I program
1964: BASIC
The Beginners All-purpose Symbolic Instruction Code (BASIC) was designed in 1964 by
two graduate students at Dartmouth, John Kennedy and Thomas Kurtz, to be an easy first language for
programming neophytes, especially those who weren't "computer-science" oriented. Though the first
version was compiled, most Basic systems were interpreters.
Original Basic had a simple syntax that included a line number for every source line. Control
structure mostly consisted of GOTO ### and GOSUB ###; simple conditional and bounded loop constructs
were also available. Original Basic provided numeric, string, and array datatypes, but no structures
or objects.
Basic has enjoyed steady popularity and usage since about 1965, and has evolved greatly since then.
Modern Basic dialects, such as Visual Basic, eschew line numbers, support objects, libraries, GUIs,
databases, optimizing compilers, garbage collected dynamic memory management, and much more. Basic was
and still is loosely typed, and has poor support for enforcing program portability.
Dialects and subsets of Basic are often designed as extension or macro languages for programming
systems on PC.
Click to view a sample BASIC program
1966: FORTRAN 66
The new ASA standard was published in 1966, and was known accordingly as FORTRAN 66.
This was a very important step that made it worthwhile for vendors to produce FORTRAN systems for
every new computer, making FORTRAN an even more popular HLL.
Original development of the standard began in 1962, yet even four years later, it would still be the
first HLL standard in the world.
Click to view a sample FORTRAN program
1966: Logo
Logo is a functional language designed to teach programming and problem-solving
principles to children. It is a functional language, related to Lisp, with a simple syntax and a
graphics-oriented feature set.
The Logo language provides a set of built-in procedures, a means to create new procedures, a simple
data framework with symbols, numbers, and lists, and simple control structures. The language is
surprisingly small, but like Lisp can be used to create very complex behavior.
A central concept in Logo is the turtle. Logo was designed for use with a graphics display, and the
turtle wanders around the display under the control of the Logo program, drawing lines. Some of the
most fundamental statements in Logo move and rotate the turtle. By using Logo's recursive nature, a
programmer can cause the turtle to draw all sorts of figures.
Commercial and free implementations of Logo are available for PC/Windows, Macintosh, and UNIX
platforms. New releases of Logo implementations in 1993 and later have added sound, images, and
multi-tasking to the basic language. Massively parallel, hardware-embedded, and object-oriented
extended implementations of Logo have also been developed. Logo has been used primarily for education,
but has also been employed for AI research, robotics, and graphics creation.
Logo is a simple language to learn, but amazingly functional. Many elementary schools have used Logo
to teach children how to think about really controlling computers (not just point-n-click). Many of
the sites listed below have links to these educational projects.
Click to view a sample Logo program
1967: BCPL
Originally developed by Marin Richards at Cambridge University in 1966, the first
implementation of BCPL took place at MIT in 1967. The name BCPL stands for Basic Combined
Programming Language. BCPL was an early block-structure procedural language, fairly low-level, and
used for system and small application programming. It would develop into the inspiration for two
systems programming languages developed at Bell Telephone Laboratories in the 1970's, B and C.
BCPL is an operator-typed language; the data types of variables are defined by the operators applied
(rather than being declared for the variable, as in Algol). Data items were untyped cells labeled with
identifiers. Data types supported by BCPL included integers, reals, bit patterns, I/O streams, various
kinds of references, and vectors. Strings could only be used as constants. The language supported
simple control constructs like loops and conditionals, as well as means to declare subroutines and
functions. The BCPL system library, which evolved along with the language, provided I/O support and
very simple memory management.
Early versions of BCPL were machine native compilers, but nearly all recent versions have been
translators. In other words, the BCPL compiler translates the BCPL code to an abstract machine
language called INTCODE. The INTCODE data is then interpreted by a simple, fast virtual machine
(typically coded in assembly language, C, or a mixture of the two).
Click to view a sample BCPL program
1970: Forth
Charles Moore writes the first significant programs in his new language, Forth. It
is an interpreted stack-based language with a very simple syntax and elegant abstract exection
model. Designed for efficiency and simplicity, Forth is noted for the very small size of the language
system.
A Forth program is a sequence of words such that each word is independent, and causes some specified
action. Even constants are words: the word "12" is just a command to push the number 12 onto the data
stack. Sequences of words can be grouped as procedures, and employed to build up modular programs. In
order for this to work, of course, operators and operands must be given in reverse polish order
(operands followed by operator). All data manipulation takes place on the data stack, so Forth offers
several operations for manipulating the stack.
Forth implementations vary in the range of data types they provide, but most provide a conventional
set of numeric and string types, plus arrays. Forth offers regular control structures: If-Else,
While-Do, and For-Next, albeit with peculiar ordering of the keywords. Most dialects of Forth provides
simple file handling and I/O support.
Meant to be extensible at every level, Forth programmers can define new words, and implement them in
Forth itself, in some other high-level language, or in machine code.
Click to view a sample Forth program
1970: Smalltalk
Developed at Xerox PARC, led by Alan Kay, Smalltalk is a dynamic object-oriented
language which was originally designed as an experiment, but evolved into a powerful application
development language.
Smalltalk is a pure object-oriented language: all data are encapsulated as objects, and all operations
and functions are performed by sending messages to objects. All objects inherit from an Smalltalk's
programming model is very rich and mature, supporting inheritance, abstract data types, polymorphism,
automatic memory management with garbage collected, delegation, reflection, and persistence.
Unlike some newer OOP languages, Smalltalk is not strongly typed. The language typically does not
enforce type constraints, and method declarations usually do not include type declarations.
Fundamental data types supported by the language include integers, reals, strings, booleans, and
arrays. The standard class library distributed with every Smalltalk system includes a wide variety of
collection classes (such as vectors, trees, hash tables, etc.), stream-oriented I/O facilities, object
persistence support, and graphical user interface classes.
Early Smalltalk implementation was interpreted, but most modern implementations employ translation to
abstract machine intermediate codes and/or dynamic native compilation (so-called "Just-in-time" code
generation).
Smalltalk, which is mainly used for application development, has also been used to teach OOP
principles. Unlike C or Java, Smalltalk represents everything as an object, making the language much
more consistent in its treatment of data aggregations. While the Smalltalk language and its object
model were very influential, its run-time environment was even more so. Smalltalk was the first
language to support a multi-window graphical user interface. Later windowing systems, like the Xerox
Star, the Apple Lisa and Macintosh, the X Window System, and Microsoft Windows all took ideas (and
sometimes even personnel) from the Smalltalk development efforts.
The Smalltalk GUI uses a very powerful conceptual framework: the Model-View-Controller (MVC) paradigm.
In this framework, every GUI element has a model that holds its data, a view that draws its display,
and a controller that responds to activities and causes the object to react. By keeping these three
aspects of GUI elements separate, Smalltalk allows the programmer great flexibility. (The MVC
framework was also employed in the NeXTStep GUI, which was written in Objective-C.)
While early versions would include Smalltalk-72, Smalltalk-74, Smalltalk-76, and Smalltalk-80, several commercial
and free Smalltalk implementations exist, for all sorts of platforms. On of the more popular free
implementations, for Unix systems, is GNU Smalltalk. IBM and ObjectShare are the primary commercial
Smalltalk vendors.
Click to view a sample Smalltalk program
1970: Icon
A decendent of SNOBOL (see 1962 above) known as Icon is first introduced. It is a
procedural language with high-level semantics for string and data aggregate processing. The language
definition includes a large number of operators and funtions for manipulating strings and sequences,
as well as novel semantics: conventional imperative control structures and goal-directed backtracking.
Built-in data types in the language are integers, reals, strings (text), sets, lists, arrays,
associative tables, files, and records. Icon variables are typed, but the language performs automatic
type casting, so it cannot be said to support strong type checking in the sense of Ada or Modula-2.
Icon also supports a very simple form of exception handling; procedures can return one or many values,
or they can fail. Failures do not automatically propogate up the procedure call stack as they do in
Java or C++.
Icon is normally interpreted, but there is also a translator that generates compilable C code from
Icon code. Icon was originally implemented for UNIX, but has been ported to VMS, MS-DOS, 32-bit
MS-Windows, OS/2, and the Macintosh.
Click to view a sample Icon program
| History Index | Back: 1941-1950 | Next: 1971-1990 |