History of Programming Languages

Language Samples

First Computers: Mechanical Calculators

Schickard: 1623 (used by Kepler)

Pascal: 1642

Leibniz: 1671

Thomas: 1820 (mass produced)

Curta: 1948

Special Purpose vs General Purpose

Special Purpose: Designed to solve single kind of problem

Difference Engine: Difference equations
ABC: Differntial equations

General Purpose: Can be programmed to solve any problem

Analytic Engine
Modern computers

Turing Complete:

same computing power as a Turing Machine (except for finite memory)
Church-Turing Thesis

Stored Program, von Neumann Architecture

Easier to program if program stored in memory

Early Computers: Special Purpose or Non-Stored Program

Atanasoff-Berry Computer (ABC), 1939-41

John Atanasoff, University of Iowa
Binary
Electronic
Separate memory and computation units
Special purpose: Solve differential equations
Not programmable/not general purpose
Patent prior art to Eckert and Mauchley ENIAC
Not turing complete

Z3, 1941

Konrad Zuse, Germany
Programmable (paper tape), with loops
First general purpose computer
Not stored program (Program stored on external tape)
Binary
Floating point
Electro-mechanical (ie relays), not electronic
Destroyed by Allied bombing
Calculating Space, 1969 (Wolfram, A New Kind of Science)
Turing complete

Colossus Computer

1944, Bletchley Park, England, code breaking
Cryptanaylsys (Code breaking)
Binary
Electronic
Partially programmable (by rewiring)
Special purpose
I.J. Good, Alan Turing
Classified
Not turing complete

Harvard Mark 1 (1944)

Not stored program (Programmed with paper tape)
Howard Aiken
Electromechanical
Not binary
Turing complete

ENIAC (1946)

Not stored program
Programmed with cables and switches
Eckert and Mauchley
Electronic
Not binary
U Penn
Turing complete

Early Computers: General Purpose, Stored Program

England:

Manchester Small Scale Experimental Machine

First program: May 1948
1 K Bit memory

Manchester Mark 1
- Operational: April 1949
- Team members Conway Berners-Lee and Mary Lee Woods married: son Tim Berners-Lee ...
EDSAC
- First practical stored program computer
- First program: May 1949
- 10K Bits
- Maurice Wilkes
Pilot Ace: Alan Turing, NPL, First Program: May 1950

EDVAC

Eckert, Mauchley, von Neumann
U Penn
44 K Bits
First program: 1951
Patent fights

First Commercial, Stored Program Computers

Zuse Z4: Germany, September 1950

Ferranti Mark I: England, February 1951 (from Manchester Mark 1)

UNIVAC: US, July 1951

Precomputing Languages

Babbage and Lady Ada (1880's, never implemented)
Zuse's Plankalkul notation (1930's, first implemented: 2000)

1940's and early 1950's: First Languages

Wiring and switches
Machine code
Assembler
Interpreted codes
Macros

1950's: Invention of high level languages

Manchester Mark 1 Autocode (variables) - 1952

FORTRAN I, II - 1957-8
- John Backus, IBM, 30 person-years
- do loops with index variables
- Arrays
- arithmetic if statements
- formatted i/o
- comments (self explanatory code?)
- independent compilation
- efficient code (still true!)
- wide use (FORTRAN 95)
LISP - 1959 - LISt Processing - McCarthy, MIT
- applicative (ie functional) as basis of computation
- Recursion!
- two data types: atoms and lists
- Single page self interpreter
- good for AI - symbolic computation
- interactive
- garbage collection
- Common dialects: Scheme, Common LISP

1950-1960: Invention of HLL (cont.)

COBOL - 1960 - Adm. Grace Hopper (nanosecond)
- Business
- Academics?
- Data and execution sections with separate definitions
- Formatted output
- Records and macros
- Most widely used language
ALGOL 60 - 1960
- First use of Backus Naur Form (BNF)
- parameter modes (in and out)
- compound statements: begin, end
- Free format
- := and ;
- recursion
- Stack based implementation
- Type declarations
- never caught on in U.S., but highly influential!
APL - 1962 - Iverson
- functional flavor
- very expressive

1960's: Explosion of Languages: Larger, more complex

PL/1 - 1965 - IBM committee
- goal: universal
- concurrency
- exceptions
- pointers
- array slices
- complex (perhaps overly so)
- Still in use (primarily on IBM mainframes)
SIMULA 67 - 1967
- system simulation
- Dahl and Nygaard, Oslo
- classes
- coroutines
ALGOL 68 - 1968
- User defined data structures
- influential
SNOBOL: string processing and pattern matching
ISWIM: formal, mathematical definition
BASIC - 1964 - Memeny & Kurtz - Dartmouth
- easy to learn, use, and interpret
- interactive (user vs machine time)

1970's: Simplicity, Abstraction

Pascal - 1971 - Nicklaus Wirth
- Teaching language: small and simple
- Records, structured statements, parameter modes
- P-code compiler/interpreter
C - 1972 - Dennis Ritchie, Bell Labs
- Systems language: bit ops, addresses
- Powerful operators, poor typing
- Easy to write; hard to debug
- Spread with Unix

1970's: Other Languages

Barbara Liskov
MIT
Data abstraction
Iterators
Exceptions

Prolog - 1972 - Edinburgh and Marseilles
- declarative (first order logic)
- AI: intelligent database with inference queries
Smalltalk - 1972 - Alan Kay, Adelle Goldberg
- Xerox PARC
- First OO language and GUI

1980's: ADT's and Objects

Modula 2 - 1980 - Wirth
- modules
Ada - 1983
- Competitive design - standard first
- Designed goal: Reliable
- Designed goal: Lower life cycle costs
- ADT support: package, generic, overloading
- Exceptions, concurrency
- Complex, for its time
C++ - 1985 - Stroustrup, Bell labs
- oo C ("hybrid OO")
- complex
- exceptions and templates in later versions
- many versions
- Design goal: C with strong typing
Oberon and Modula 3 - 1985 - Wirth
Eiffel - 1985 - Bertrand Meyer
- "Pure OO" with clean design
- Good tools, environment, library
Functional Languages

FP: John Backus - Turing Award Lecture
Common Lisp, Scheme, ML, Haskell

1990's: OO Languages, Internet, Libraries, Scripting

Ada 95 - 1995
- First standardized OO language
- Better concurrency
- Multilingual programming
Java - 1995
- Sun - embedded devices
- Syntax - like C++
- "Pure OO" (classes only, no records)
- Reference and primitive types (for efficiency)
- Large library (API)
- Packages for organizing classes
- Applets, exceptions, multi-threading, ...
- Java 1.5: Parameterized types (like generics)
- Java 1.5: Enums (ie enumerated types)
- No operator overloading
Functional Languages

Haskell

2000's: More OO, Scripting Languages, ...

Scripting and Markup Languages

Text processing, string oriented
Typically dynically type - act as glue
Typically act as glue between applications
Heavily used on web
SNOBOL - Bell Labs - 1960's
Unix shells, AWK, and SED
Perl, Python, Tcl, Ruby
VBScript, JavaScript, PHP

C# and .NET

Anders Hejlsberg (Borland Delphi, Turbo Pascal)
CLI: Common Language Infrastructure
Generics
MSIL (MS Intermediate Language (like Java bytecode)
All types inherit from Object
Can define value semantics types (?)
Garbage collection
No MI, but interfaces
Enumerations

Ada 2005

Object notation
Java-like interfaces
Improved libraries

XML: eXtensible Markup Language

Metamarkup language: used to define data documents

2010's ...

Continuing traditional/OO languages:

Java, C++, C, C#, Objective C all continue
VB and .NET continue

Scripting languages:

Python
Perl, ruby

String typing, inferred types
Garbage collection
Robust dependency mechanism
Compiled
= for assignment, := for initializing assignment
Classes? Interfaces for types
Concurrency: Channels between processes
Pointers

Ada 2012

Conditional and case expressions
In-out parameters for functions (checks for insecurities)
Improved membership test:

Example: if (bt not in 'A'|'B'|'O') then put("invalid blood type')

Iterators
Bounded containers
Preconditions, postconditions, invariants
Quantified expressions

Example: A is sorted:(for all I in A'first .. T'Pred(A'Last) | A(I) <= A(T'Succ(I)))
Example: N is composite: (for some X in 2 .. N/2 | N mod X /= 0)

Improved multiprocessor support

Evolution of Imperative Languages (Revisited)

Control abstraction

Statement level
Structured statements
Procedural level
Exceptions
Iterators
Threads
Coroutines

Data abstraction

Records
Modules
Generics
Classes and objects
Garbage collection

Data and Control Abstraction

Iterators

[LaTeX -> HTML by ltoh]

Edward G. Okie
Last modified: Sep 3 2001 (LaTeX doc modified: Aug 23 2000)