The Minds Behind Functional Programming – 7 People Redefining Software
Functional programming grew from a meeting of mathematical function theory and practical language design. McCarthy made recursive symbolic functions executable in Lisp; Landin connected programming languages to lambda calculus; Backus challenged the von Neumann style; Milner, Turner, Peyton Jones, and Wadler built the typed, lazy, and practical traditions that made functional ideas central to modern language design.
TL;DR
Functional programming became a distinct tradition by repeatedly asking what programming would look like if computation were organized around evaluating and composing functions rather than updating machine state step by step. John McCarthy made recursion and symbolic functions practical in Lisp; Peter Landin connected programming-language semantics to lambda calculus and proposed ISWIM; John Backus used his Turing lecture to attack the limitations of the von Neumann style; Robin Milner built ML with polymorphic type inference; David Turner advanced pure lazy languages that directly influenced Haskell; Simon Peyton Jones helped make Haskell and its Glasgow compiler a practical research platform; and Philip Wadler helped shape type classes, monads, and the language-theory bridge that made modern functional programming expressive.[1][2][3]
Why you should read it anyway
Functional programming is worth reading about because many ideas once considered exotic are now routine even in non-functional languages: first-class functions, immutable data, pattern matching, type inference, higher-order APIs, declarative transformations, and algebraic reasoning. The history also shows theory paying off unusually directly. Lambda calculus, polymorphic type systems, type classes, and System F moved from mathematical papers into production compilers and mainstream language features. Functional programming became a laboratory in which formal ideas could be stress-tested by real programmers.[1][6]
Imagine where Functional Programming would be without them
Without these people, functions would still exist in programming, but the coherent functional tradition might have been delayed substantially. The important loss would be a sequence of mutually reinforcing demonstrations: Lisp proved recursive symbolic functions could be practical; Landin showed lambda calculus could explain languages; Backus gave functional programming a high-profile systems critique; ML showed strong inference could be usable; Miranda and Haskell made purity and laziness practical enough for large experiments. Modern language design would have fewer tested alternatives to state-heavy imperative programming.[1][5]
Time Estimate of how many years we would be hindered without them for human progress
Counterfactual estimate: 5–12 years. This is an editorial estimate rather than a historical statistic. Mathematical foundations such as lambda calculus were independent of these seven people, so functional programming was not impossible without them. The plausible delay is in the chain from theory to usable languages, implementations, type systems, and communities that demonstrated functional ideas at scale.
The 7 people behind Functional Programming
1. John McCarthy
Why they matter: McCarthy’s Lisp made recursive functions and symbolic computation concrete. Although Lisp was not purely functional, it gave programmers a practical environment where lists, recursion, function application, and symbolic expressions were central. The history of Haskell explicitly traces the functional tradition back to McCarthy’s Lisp. McCarthy therefore supplied one of the earliest working proofs that programming could be organized around a very different model from conventional numerical instruction sequences.[4][1]
2. Peter Landin
Why they matter: Landin provided a crucial intellectual bridge between programming languages and the lambda calculus. His ISWIM language and SECD machine showed how lambda expressions could serve as a compact model of evaluation and language semantics. Computer History Museum preservation material on PAL, a direct descendant of ISWIM, records this connection explicitly. Landin helped make functional programming not merely a collection of convenient features but part of a general theory of programming languages.[2][1]
3. John Backus
Why they matter: Backus returned to language research decades after FORTRAN with a critique of conventional ‘von Neumann’ programming. His 1977 Turing Award lecture proposed a functional style built from combining forms and an algebra of programs, arguing that programming languages were too closely tied to state-changing machine architecture. The proposal itself did not become the dominant language, but the lecture gave functional programming enormous visibility and framed it as a serious alternative for reasoning and composition.[3][1]
4. Robin Milner
Why they matter: Milner’s ML united functional programming with a type system that could infer polymorphic types without forcing programmers to annotate everything. Developed initially as a meta-language for the LCF theorem prover, ML demonstrated that strong static typing could support concise, expressive programs. Its descendants and its Hindley-Milner style of inference profoundly shaped later functional languages and many non-functional ones.[1]
5. David Turner
Why they matter: Turner designed a line of lazy functional languages culminating in Miranda. The University of Kent describes Miranda as a pure, non-strict, polymorphic higher-order functional language; the documented history of Haskell identifies Turner’s languages as major predecessors. Turner proved that laziness, pattern matching, higher-order functions, and concise equational definitions could form a coherent programming environment rather than remain isolated research ideas.[5][1]
6. Simon Peyton Jones
Why they matter: Peyton Jones was one of the central designers and implementers who turned Haskell into a long-lived research and practical platform. Microsoft’s Haskell history documents the international committee process, while Peyton Jones’s own accounts emphasize compiler engineering, type-system evolution, and the Glasgow Haskell Compiler. His contribution is crucial because a pure language needed an industrial-strength implementation to test whether elegant semantics could coexist with performance, interoperability, and real applications.[1][6]
7. Philip Wadler
Why they matter: Wadler repeatedly connected mathematical structure to language features programmers could use. His work helped establish type classes in Haskell and popularized monads as a way to structure effects in pure functional programs. He also helped connect theoretical systems such as System F to practical compiler design. Wadler’s distinctive role is translation between communities: logic and category-inspired abstractions on one side, concrete language mechanisms and explanatory writing on the other.[7][6]
How they each differ from one another
McCarthy supplied a practical recursive symbolic language; Landin supplied a semantic bridge to lambda calculus; Backus supplied a broad critique of state-centered programming; Milner combined functional expression with powerful static inference; Turner refined purity and laziness; Peyton Jones made the Haskell experiment durable through language and compiler engineering; Wadler connected deep theory with usable mechanisms for overloading and effects. Functional programming advanced because theory, syntax, type systems, implementation, and communication evolved together.[1][3][7]
Final Take
Functional programming’s victory is not that every programmer now writes Haskell. It is that its once-radical ideas became part of the general vocabulary of software design. Functions are passed as values, immutable structures are common, type inference is expected, pattern matching is mainstream, and even effect systems borrow concepts refined in functional-language research. These seven people helped create the intellectual alternative that made those choices visible. By showing that programs could be composed and reasoned about differently, they expanded what a programming language was allowed to be.[1][6]
Works Cited
- 01
- 02Computer History Museum Software Preservation — History of PAL and Peter Landin's ISWIM softwarepreservation.computerhistory.org
- 03
- 04Stanford Engineering — John McCarthy engineering.stanford.edu
- 05University of Kent — David Turner and Miranda cs.kent.ac.uk
- 06
- 07Philip Wadler — Type Classes and Functional Programming Research homepages.inf.ed.ac.uk
CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.
Submit a research lead