This document provides a brief history of functional programming, beginning with the lambda calculus developed by Alonzo Church in 1936. It discusses the development of Lisp by John McCarthy in 1958, which pioneered many functional concepts. Peter Landin then developed the ISWIM language in 1966, which influenced ML, SASL, and Miranda. John Backus' 1977 paper promoted functional programming research. Concurrently, ML was developed, introducing strong static typing and type inference. David Turner then created SASL, KRC and Miranda between 1972-1985. Erlang was developed in 1986 for distributed systems. Haskell was developed in 1990, drawing from Miranda with purity, laziness and strong typing. Many other languages now support functional paradig

1. A Brief History of
Functional
Programming
λ

2. Introductions
• Twitter: @treLeComte
• Github:
https://github.com/trezona-
lecomte
• LinkedIn:
https://nz.linkedin.com/in/trezo
nalecomte
• Programming for about 3
years
• At work: Ruby on Rails,
MySQL
• At home: Haskell, Elm,
PostgreSQL
About me

3. Introductions
What about you?

4. Why talk about history?

5. Standing on the shoulders of giants
“Bernard of Chartres used to compare us to dwarfs perched
on the shoulders of giants. He pointed out that we see more
and farther than our predecessors, not because we have
keener vision or greater height, but because we are lifted up
and borne aloft on their gigantic stature.”
- John of Salisbury (1159)
Why talk about history?

6. We’re skipping a lot
• Ada Lovelace
• Charles Babbage
• George Boole
• Bertrand Russell
• Kurt Gödel
• Rózsa Péter
• Claude Shannon
• … so many more

7. Let’s begin with λ
• 1936: Alonzo Church published
what we now know as the
‘untyped lambda calculus’
• Often referred to as λ-calculus
• Universal model of computation

8. Let’s begin with λ
This is not a λ-calculus tutorial, so I’ll recommend:
• https://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf - a
'short and painless' introduction
• Chapter 1 of http://haskellbook.com if you’re learning
Haskell and have the $$

9. Lisp
• 1958: John McCarthy invents LISP (LISt Processor)
• Lisp pioneers:
- Higher-order functions
- Recursion
- Dynamic typing
- Conditionals
- Garbage Collection
- The REPL (Read-Eval-Print-Loop)
- Programs as data, or meta-programming

10. Higher order?
A higher-order function either:
• Takes a function as an argument
• Returns a function as a result
(define mapcar (func list)
(if (null list)
nil
(cons (func (car list)) (mapcar func (cdr list)))))

11. Note that Lisp wasn’t “purely” functional…

12. Detour: Declarative &
Imperative
“Imperative languages are characterized as having an
implicit state that is modified (i.e. side-effected) by constructs
… in the source language.”
“In contrast, declarative languages are characterized as
having no implicit state, and thus the emphasis is placed
entirely on programming with expressions (or terms). In
particular, functional languages are declarative languages
whose underlying model of computation is the function …”
- Paul Hudak

13. ISWIM
• 1966: Peter J. Landin publishes The Next
700 Programming Languages, describing
“If you See What I Mean”
• Not an actual implementation
• But hugely influential on ML, SASL, and
Miranda

14. FP
• 1977: John Backus gave his Turing Award lecture, "Can
Programming Be Liberated from the von Neumann Style?”
• Introduced a language - FP (Function Programming)
• His lecture & paper sparked the next generation of
Functional Programming research

15. ML
• Around the same time as FP: Gordon, Milner and
Wadsworth made ML (Meta-Language)
• Another ‘impure’ functional language
• Evolved into Standard ML and OCaml

16. ML
• The interesting part for us is the type system:
- Strongly and statically typed
- Type inference
- Polymorphic functions and data structures
- User-defined concrete and abstract datatypes (borrowed
from Hope)

17. SASL, KRC, Miranda
• 1972: David Turner built SASL
(St Andrews Static Language) based on ISWIM
• 1976: He redefined SASL as a lazy language
• 1979-1981: He developed KRC (Kent Recursive
Calculator), which included guards and list
comprehensions
• 1985: He released Miranda, a successor to SASL and
KRC. It’s still alive today!

18. Erlang
• First developed in 1986 at Ericsson by Joe Armstrong,
Robert Virding, and Mike Williams
• Emphasis on distributed, real-time, reliable programs
• Used a lot in Telecommunications and Networking

19. Haskell
• 1987 FPCA Conference: there is a meeting to discuss the proliferation of non-strict (lazy)
functional languages
• The result in 1990 is Haskell, named after Haskell B. Curry, based largely on Miranda:
- Purely functional with higher-order functions
- Lazy evaluation
- Strong, static typing with type inference
- User-defined datatypes with pattern matching
- List comprehensions
- Modules
- Functional I/O system

20. And the list goes on…
• 1991: Python*
• 1995: JavaScript* & Ruby*
• 2004: Scala*
• 2005: F#*
• 2007: Clojure - a Lisp dialect
• 2010: Rust*
• 2011: Elixir*
• 2012: Elm & TypeScript*
• 2014: Swift*
* multi-paradigm, supports functional programming

21. What next?
• 2018 ???

22. Thanks!
λ