The Past, Present & Future of Programming Languages • Kevlin Henney • YOW! 2025

Kevlin Henney explores the slow but profound evolution of programming languages, revealing how many 'new' features are decades-old concepts. He analyzes language popularity rankings, highlighting the dominance of 20th-century languages and the impact of the "von Neumann bottleneck." The talk delves into historical innovations from Fortran to Algol, coroutines to functional programming, and concludes by examining how Large Language Models (LLMs) are becoming clients of existing languages, further entrenching the mainstream rather than causing radical change, often due to their training data favoring established codebases.

August 11, 2026 3 min read

The Past, Present & Future of Programming Languages • Kevlin Henney • YOW! 2025 — source: https://www.youtube.com/watch?v=nNWROjHZzuU

Kevlin Henney takes a comprehensive tour through the past, present, and future of programming languages, challenging the notion of rapid change in the mainstream landscape and highlighting the enduring influence of historical concepts, even as new technologies like LLMs emerge.

The Enduring Legacy of the Past

Henney begins by observing that programming language evolution, particularly in the mainstream, occurs at a much slower pace than often perceived. Many concepts developers consider “new” are decades old. He illustrates this with several examples:

John Backus and Fortran: Backus’s 1977 Turing Award speech, “Can Programming Be Liberated from the von Neumann Style?”, advocated for functional programming as an escape from the limitations imposed by von Neumann architectures. Henney notes that Fortran, developed by Backus, was initially a proof-of-concept for compilers in the 1950s, not a language designed for elegance, yet IBM commercialized it—a common modern problem of releasing proof-of-concepts.
Conceptual Foundations from the 1960s and 1970s: Many fundamental ideas in modern languages originate from this era.
- Algol 68: Introduced keywords and linguistic constructs (e.g., int, char) that are still prevalent. It was also expression-oriented, allowing procedures to return values naturally without explicit return statements.
- Structured Programming: Edsger Dijkstra’s 1968 paper, “Go To Statement Considered Harmful” (originally “A Case Against the Go To Statement,” retitled by Niklaus Wirth), was foundational to structured programming. This era saw the formalization of control structures.
- Plankalkül (1948): Konrad Zuse’s early language, though not widely adopted, contained influential concepts like block structuring and conditional guards, even if it lacked an explicit else clause.
- The for loop: Its origins trace back to Heinz Rutishauser’s work in the early 1950s, demonstrating a German root (für).
- if-then-else: The compound if-then-else structure, now ubiquitous, was “invented” by Klaus Samelson and integrated into Algol 60, contrasting with earlier if-then-otherwise or simple guard structures.
Coroutines: Melvin Conway introduced coroutines in 1958, an idea that predates Conway’s Law. These concepts, representing peer-to-peer execution without a single master program, influenced languages like Simula (which had coroutines before classes) and later found modern resurgence in languages like Python (yield), C#, and C++ (C++20).
Communicating Sequential Processes (CSP): C.A.R. Hoare’s 1970s work on CSP heavily influenced the concept of channels for inter-process communication, famously adopted by languages like Occam (known for its brutal type system and strictness) and later Go.
Functional Programming: Lisp, developed by John McCarthy in 1960, was the first functional language and was intrinsically tied to symbolic AI. While pure functional languages like Haskell remain niche, mainstream languages have increasingly adopted functional features (e.g., lambdas, higher-order functions) in response to renewed interest, leading to a “hybrid” approach rather than a full paradigm shift.