** 1. History of PL **
[draw decades on top, horizontally; language families in columns]

=================================================

lambda calculus [Alonzo Church 1930s]

=================================================

Fortran [Backus et al. 57]
  * "formula translation"
  * showed that compiler is possible
  * no recursion, no pointers (no stack or heap, only static memory)
  * line-oriented syntax, ignoring whitespace =>
      DO 10 I = 1.10 bug in Venus probe
  * implicit typing via identifier name
  * later: Fortran 77, Ratfor
  * more explicitly parallel/distributed memory: F90, HPF

=================================================

COBOL [Hopper et al. 60]
  * english-like syntax => readable, but wordy
  * record 

=================================================

Basic [Kurtz & Kemeny 64]
  * line oriented

=================================================

Algol 60 [Backus et al.]
  * language for writing algorithms, independently of target platform
  * pioneered BNF, free-form syntax, type declarations, recursion,
    block structure & scoping, structured control structures
  * weird call-by-name parameter passing mode

PL/I [mid 60s]
  * integrated aspects of Fortran, A60, COBOL, Lisp, APL
  * a kitchen-sink result

Algol 68
  * orthogonality
  * way overdone: "second system syndrome" [Brookes' mythical man-month]
  * many automatic/implicit conversions from one type to another =>
      error prone
  * two-level vW grammars
  * invented new terms for everything "to avoid confusion"

Pascal [Wirth 70]
  * reaction to A68
  * simple, but not that powerful

CLU [Liskov 77]
  * abstract data types
  * exceptions, parameterized types, iterators, ...

Modula [Wirth], Modula-2 [Wirth 85]
  * add modules

Oberon [Wirth]
  * add some OO features
  * an integrated language and OS

Modula-3 [DEC SRC 91]
  * differently add some OO features

Ada [83]
  * huge

=================================================

C [Kernighan & Ritchie 74]
  * designed for low-level systems programming (a higher-level asm)

=================================================

Lisp [McCarthy 60]
  * symbolic programming, lists, dynamic typing
  * expression-oriented, side-effect-free programming
  * S-expressions for both programs and data (an accident)
  * dynamic scoping (an accident)
  * CommonLisp in 81

Scheme [Sussman & Steele 76]
  * static instead of dynamic scoping
  * an executable lambda calculus; very clean

ML [Milner 76, 80]
  * polymorphic type system, type inference
  * SML90, 97

FP [Backus 78]
  * "can programming be liberated from the von Neumann style?"

Caml, O'Caml [Remy, Leroy]
  * french ML dialects (vs. SML)
  * O'Caml adds classes (but keeps everything else!)

EML [Chambers et al. 01]
  * alternative OO version of ML

Haskell
  * consensus lazy fn'l language
  * type classes for "overloading", OO-like programming

=================================================

Simula-67 [Dahl & Nygaard]
  * extend A60 w/ classes & processes
  * for better modeling & simulation

Smalltalk [Kay, Goldberg, et al., 72, 76, 80]
  * pure OO, with "blocks"
  * originally for children
  * invented "message", "method" and other terminology
  * very extensible system, including OS
  * bytecoded virtual machine, specified in Smalltalk

Self [Ungar & Smith 87]
  * classless, purer version of Smalltalk

CLOS [Bobrow et al. 88]
  * object system for Lisp
  * multimethods, fancy multiple inheritance

C++ [Stroustrup 86]
  * C with classes, a la Simula 67

Java [Gosling 92]
  * safe, portable version of C++
  * bytecoded virtual machine

Cecil [Chambers 92]
  * merger of Self, CLOS, and static type system

Diesel [Chambers et al. 01]
  * refinement of Cecil: modular, more orthogonal design

MultiJava [Chambers et al. 00]
  * Java + multimethods + open classes, modularly

=================================================

Prolog [Colmerauer 72]
  * logic-based programming
  * a declarative model, but also imperative features like arithmetic and cut
  * incomplete solution strategy

CLP(R) [Jaffar & Lassez 87]
  * constraint-logic programming: add constraints to Prolog,
      to support more declarative treatment of arithmetic

Kaleidoscope [Freeman-Benson & Borning 94]
  * constraint-imperative (OO) programming

=================================================

APL [Iverson 62]
  * array-based programming
  * many special one-symbol operators => "write-only programming"

*Lisp, C*, C**, Sisal, Nesl, pH [various]
  * various data-parallel languages

ZPL [Snyder et al. 93]
  * array-parallel programming

=================================================

Argus [Liskov 82]
  * distributed programming

Emerald [Levy et al. 86]
  * distributed programming

=================================================

Setl [Schwartz 86]
  * set-based programming

Icon [Griswold 79]
  * goal-directed evaluation
  * string & text processing

Forth [Moore 70]
  * stack-machine syntax, virtual machine
  * fast interpretation on embedded systems

==================================================

Domain-specific languages/embedded langs

Yacc

Fran

SQL, other queries

scripting langs

specification langs