Copyright (C) 2016, 2017, H. Conrad Cunningham

Acknowledgements: I created these slides in Fall 2016 from my draft notes on an Introduction to Functional Programming Using Haskell. I continue to update these slides in 2017, tracking changes in the draft notes.

My language selections reflect, to some extent, my personal interests and experiences in areas such as functional programming, modular programming, object-oriented/based programming, concurrent programming, domain-specific languages, metaprogramming, software families, and formal methods.

1950’s

• Fortran, 1957; imperative, first compiler, math-like scientific programming; Backus at IBM

• Lisp, 1958; imperative and functional features, homoiconic; McCarthy at MIT

• Algol, 1958, 1960; imperative, nested block structure, lexical scoping BNF; international team

• COBOL, 1959; imperative, business programming; Grace Hopper

1960’s

• Simula 1962, 1967; imperative, simulation, Simula 67 first OO language in Scandinavian school; Dahl & Nygaard (Norway)

• Snobol, 1962; imperative, string processing, first-class patterns; Farber, Griswold, & Polonsky at AT&T Bell Labs

• PL/I, 1964; imperative, merge scientific, business, and systems programming; IBM

• BASIC, 1964; imperative, interactive timesharing; Kemeny & Kurtz at Dartmouth

• Algol 68, 1968; imperative, ambitious successor to Algol 60, very complex, great influence, not widely implemented; international team

1970’s (1 of 2)

• Pascal, 1970; imperative, simplified Algol-like language, used in teaching, on VM on early microcomputers; Wirth (Switzerland) from frustration with Algol 68

• Prolog, 1972; first logic language; Colmerauer in France

• C, 1972; imperative systems language for Unix; Ritchie at AT&T Bell Labs

• Smalltalk, 1972; imperative, first OO language in American school, message-passing; Kay at Xerox PARC

1970’s (2 of 2)

• ML, 1973; mostly functional, polymorphic static types, algebraic data types; Milner at Edinburgh

• Scheme, 1975; minimalist Lisp, lexical scoping, tail calls, continuations; Steele and Sussman at MIT

• Icon, 1977; imperative, structured programming successor to Snobol, goal-directed execution; Griswold at Arizona

1980’s (1 of 2)

• C++, 1980; C with Simula-like classes; Stroustrup in Denmark,

• Ada, 1983; imperative, modular, intended standard language for military applications; US DoD & Ichbiah in France

• Eiffel, 1985; imperative OO language, strong software engineering concepts (e.g. design by contract); Meyer in France

• Objective C, 1986; C with Smalltalk-like messaging; Cox & Love at Stepstone, selected by Jobs for NeXT, continued by Apple

1980’s (2 of 2)

• Erlang, 1986; message-passing concurrency on dynamically typed functional base (actors), fault-tolerant/real-time systems; Armstrong, Virding, & Williams at Ericsson (Sweden)

• Self, 1986; Smalltalk dialect, first prototype-based OO language, used VM with JIT; Ungar & Randall at Xerox PARC/Stanford/Sun

• Perl, 1987; dynamic imperative language, text-processing using regular expressions; Wall

1990’s (1 of 2)

• Haskell, 1990; purely functional, lazily evaluated, strictly typed, widely used in research; international committee

• Python, 1991; imperative, dynamically typed multiparadigm language; van Rossum in the Netherlands

• Ruby, 1993; imperative, dynamically typed, object-oriented, metaprogramming, DSLs; Matsumoto in Japan, popularized by Ruby on Rails

• Lua, 1993; imperative, dynamically typed, minimalistic but powerful, embedding scripting, written in standard C; Ierusalimschy, de Figueiredo, & Celes in Brazil

• R, 1993; statistical computing and graphics, open-source S; Ihaka, & Gentleman in New Zealand

1990’s (2 of 2)

• Java, 1995; imperative statically typed OO, VM, Java 8 has functional features; Sun/Oracle

• JavaScript (ECMAScript), 1995; client-side web programming, Scheme- and Self-like internals but Java-like syntax; Eich at Netscape with 12-day deadline, successful too quickly

• PHP, 1995; server-side scripting; Lerdorf from Canada, evolved organically

• OCaml (Objective Caml), 1996; ML dialect adding OO constructs, focusing on performance and practical use; Xavier Leroy in France

2000’s (1 of 2)

• C#, 2001; imperative statically typed OO; Microsoft to replace Java on Common Language Infrastructure (CLI)

• F#, 2002; OCaml adapted for Microsoft’s CLI; Syme at Microsoft Research in the UK,

• Scala, 2003; hybrid functional/object on JVM; Odersky at EPFL in Switzerland

• Groovy, 2003; dynamically typed OO scripting language on JVM; proposed by Strachan

2000’s (2 of 2)

• miniKanren, 2005; relational language, extension to other languages (e.g., Scheme, Clojure); Friedman at Indiana,

• Clojure, 2007; Lisp dialect originally on JVM, emphasis on functional programming, concurrency, & immutable data structures; Rich Hickey

2010’s (1 of 2)

• Idris, 2011-16; eagerly evaluated, Haskell-like with dependent types; Edwin Brady from UK

• Julia, 2012; dynamic language for high-performance scientific programming

• Elixir, 2012-14; functional concurrent language, Erlang VM, influenced by Erlang, Ruby, and Clojure; Jose Valim from Brazil

• Elm, 2012-17; eagerly evaluated, simplified Haskell-like functional language, compiles to JavaScript, reactive-style programming; Evan Czaplicki in senior thesis at Harvard

2010’s (2 of 2)

• Rust, 2012-15; imperative systems language, safety and performance, targeted to replace C and C++, Graydon Hoare at Mozilla

• PureScript, 2013-17; eagerly evaluated functional language, extended subset of Haskell, compiles to JavaScript, Phil Freeman (USA)

• Swift, 2014; Apple’s replacement for Objective C, safety; “Objective C without the C”

• etc.