Home > Compilers > A Brief History of Programming Languages

A Brief History of Programming Languages




ArticlesA Brief History of Programming Languages


September 1995
/
20th Anniversary
/ A Brief History of Programming Languages

We’ve come a long way from computers programmed with wires and punch cards. Maybe not as far as some would like, though. Here are the innovations in programming.

ca. 1946

Konrad Zuse
, a German engineer working alone while hiding out in the Bavarian Alps, develops Plankalkul. He applies the language to, among other things, chess.


1949

Short Code
, the first computer language actually used on an electronic computing device, appears. It is, however, a “hand-compiled” language.


1951

Grace Hopper
, working for Remington
Rand, begins design work on the first widely known compiler, named A-0. When the language is released by Rand in 1957, it is called MATH-MATIC.


1952

Alick E. Glennie
, in his spare time at the University of Manchester, devises a programming system called AUTOCODE, a rudimentary compiler.


1957

FORTRAN
–mathematical FORmula TRANslating system–appears. Heading the team is John Backus, who goes on to contribute to the development of ALGOL and the well-known syntax-specification system known as BNF.


1958

FORTRAN II
appears, able to handle subroutines and links to assembly language.
John McCarthy
at M.I.T. begins work on LISP–LISt Processing.

The original specification for ALGOL
appears. The specific
ation does not describe how data will be input or output; that is left to the individual implementations.


1959

LISP 1.5
appears.
COBOL
is created by the Conference on Data Systems and Languages (CODASYL).


1960

ALGOL 60
, the first block-structured language, appears. This is the root of the family tree that will ultimately produce the likes of Pascal. ALGOL goes on to become the most popular language in Europe in the mid- to late-1960s.

Sometime in the early 1960s
, 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.


1962

APL
is documented in Iverson’s book,
A Pro
gramming Language
.

FORTRAN IV
appears.

Work begins
on the sure-fire winner of the “clever acronym” award, SNOBOL–StriNg-Oriented symBOlic Language. It will spawn other clever acronyms: FASBOL, a SNOBOL compiler (in 1971), and SPITBOL–SPeedy ImplemenTation of snoBOL–also in 1971.


1963

ALGOL 60
is revised.

Work begins on PL/1.


1964

APL\360
is implemented.

At Dartmouth University
, professors John G. Kemeny and Thomas E. Kurtz invent BASIC. The first implementation is a compiler. The first BASIC program runs at about 4:00 a.m. on May 1, 1964.

PL/1
is released.


1965

SNOBOL3
appears.


1966

FORTRAN 66
appears.

LISP 2
appears.

Work begins on LOGO
at Bolt, Beranek, & Newman. The team is headed by Wally Fuerzeig and includes Seymour Papert. LOGO is best known for its “turtle graphics.”


1967

SNOBOL4
, a much-enhanced SNOBOL, appears.


1968

ALGOL 68
, a monster compared to ALGOL 60, appears. Some members of the specifications committee–including C.A.R. Hoare and Niklaus Wirth–protest its approval. ALGOL 68 proves difficult to implement.

ALTRAN
, a FORTRAN variant, appears.

COBOL
is officially defined by ANSI.

Niklaus Wirth
begins work on Pascal.


1969

500 people
attend an APL conference at IBM’s headquarters in Armonk, New York. The demands for APL’s distribution are so great that the event is later referred to as “The March on Armonk.”


1970

Sometime in the early 1970s
, Charles Moore writes the first significant programs in his new language, Forth.

Work on Prolog
begins about this time.

Also sometime in the early 1970s
, work on Smalltalk begins at Xerox PARC, led by Alan Kay. Early versions will include Smalltalk-72, Smalltalk-74, and Smalltalk-76.

An implementation of Pascal
appears on a CDC 6000-series computer.

Icon
, a descendant of SNOBOL4, appears.


1972

The manuscript
for Konrad Zuse’s Plankalkul (see 1946) is finally published.

Denni
s Ritchie
produces C. The definitive reference manual for it will not appear until 1974.

The first implementation of Prolog
— by Alain Colmerauer and Phillip Roussel — appears.


1974

Another ANSI
specification for COBOL appears.


1975

Tiny BASIC
by Bob Albrecht and Dennis Allison (implementation by Dick Whipple and John Arnold) runs on a microcomputer in 2 KB of RAM. A 4-KB machine is sizable, which left 2 KB available for the program.

Bill Gates and Paul Allen
write a version of BASIC that they sell to MITS (Micro Instrumentation and Telemetry Systems) on a per-copy royalty basis. MITS is producing the Altair, an 8080-based microcomputer.

Scheme
, a LISP dialect by G.L. Steele and G.J. Sussman, appears.

Pascal User Manual
and Report
, by Jensen and Wirth, is published. Still considered by many to be the definitive reference on Pascal.

B.W. Kerninghan
describes RATFOR–RATional FORTRAN. It is a preprocessor that allows C-like control structures in FORTRAN. RATFOR is used in Kernighan and Plauger’s “Software Tools,” which appears in 1976.


1976

Design System Language
, considered to be a forerunner of PostScript, appears.


1977

The ANSI standard for MUMPS
— Massachusetts General Hospital Utility Multi-Programming System — appears. Used originally to handle medical records, MUMPS recognizes only a string data-type. Later renamed M.

The design competition that will produce Ada
begins. Honeywell Bull’s team, led by Jean Ichbiah, will win the competition.

Kim Harris
and others set up FIG, the FORTH interest group. They develop FIG-FORTH, which they sell for around $20.

Sometime in the late 1970s
, Kenneth Bowles produces UCSD Pascal, which makes Pascal available on PDP-11 and Z80-based computers.

Niklaus Wirth
begins work on Modula, forerunner of Modula-2 and successor to Pascal.


1978

AWK
— a text-processing language named after the designers, Aho, Weinberger, and Kernighan — appears.

The ANSI standard
for FORTRAN 77 appears.


1980

Smalltalk-80
appears.

Modula-2
appears.

Franz LISP
appears.

Bjarne Stroustrup
develops a set of languages — collectively referred to as “C With Classes” — that serve as the breeding ground for C++.


1981

Effort begins
on a common dialect of LISP, referred to as Common LISP.

Japan begins
the Fifth Generation Computer System project. The primary language is Prolog.


1982

ISO Pascal
appears.

PostScript
appears.


1983

Smalltalk-80: The Language and Its Implementation
by Goldberg et al is published.

Ada appears
. Its name comes from Lady Augusta Ada Byron, Countess of Lovelace and daughter of the English poet Byron. She has been called the first computer programmer because of her work on Charles Babbage’s analytical engine. In 1983, the Department of Defense directs that all new “mission-critical” applications be written in Ada.

In late 1983
and early 1984, Microsoft and Digital Research both release the first C compilers for microcomputers.

In July
, the first implementation of C++ appears. The name is coined by Rick Mascitti.

In November
, Borland’s Turbo Pascal hits the scene like a nuclear blast, thanks to an advertisement in BYTE magazine.


1984

A reference manual
for APL2 appears. APL2 is an extension of APL that permits nested arrays.


1985

Forth
controls the submersible sled that locates the wreck of the Titanic.

Vanilla SNOBOL4
for microcomputers is released.

Methods
, a line-oriented Smalltalk for PCs, is introduced.


1986

Smalltalk/V
appears–the first widely av
ailable version of Smalltalk for microcomputers.

Apple releases Object Pascal
for the Mac.

Borland
releases Turbo Prolog.

Charles Duff
releases Actor, an object-oriented language for developing Microsoft Windows applications.

Eiffel
, another object-oriented language, appears.

C++
appears.


1987

Turbo Pascal
version 4.0 is released.


1988

The specification for CLOS
— Common LISP Object System — is published.

Niklaus Wirth
finishes Oberon, his follow-up to Modula-2.


1989

The ANSI C
specification is published.

C++ 2.0
arrives in the form of a draft reference manu
al. The 2.0 version adds features such as multiple inheritance and pointers to members.


1990

C++ 2.1
, detailed in
Annotated C++ Reference Manual
by B. Stroustrup et al, is published. This adds templates and exception-handling features.

FORTRAN 90
includes such new elements as case statements and derived types.

Kenneth Iverson
and Roger Hui present J at the APL90 conference.


1991

Visual Basic
wins BYTE’s Best of Show award at Spring COMDEX.


1992

Dylan
— named for Dylan Thomas — an object-oriented language resembling Scheme, is released by Apple.


1993

ANSI releases the X3J4.1 technical report
— the first-draft proposal for (gulp) object-oriented COBOL. The standard is expected to be finalized in 1997.


1994

Microsoft
incorporates Visual Basic for Applications into Excel.


1995

In February
, ISO accepts the 1995 revision of the Ada language. Called Ada 95, it includes OOP features and support for real-time systems.


1996

Anticipated release of
first ANSI C++ standard
.


Her HindSight and ForeSight Were Both 20/20

photo_link (36 Kbytes)

“It’s better to ask forgiveness than it is to get permission.”–The Late Rear Admiral Grace Hopper, who led the effort to create COBOL


Categories: Compilers
  1. No comments yet.
  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: