The Birth of Programming Languages

Keywords

ver. 1.0.0, birth_of_programming_languages

A rapid historical survey connecting von Neumann hardware to major programming-language paradigms from FORTRAN and Lisp through object-orientation, functional purity, 1990s web languages, and SQL.

This unit traces how the abstract machines of theory became physical hardware with von Neumann’s EDVAC, then runs a compact history of programming languages: FORTRAN’s compiled high-level code, Lisp’s functional roots and garbage collection, C’s systems-level imperative lineage, the arrival of true object-orientation with Smalltalk and its systems incarnation in C++, the rise of pure functional Haskell, the burst of 1990s languages solving web and scripting problems, and SQL as the canonical domain-specific language. By the end, learners can situate each major language and paradigm and see how they reappear later in the course.

Full summary

The unit begins at the hardware level: von Neumann’s EDVAC turns Turing’s abstract machine into a physical architecture — CPU, memory, bus, binary data and machine code — the substrate every later language runs on. From that foundation the unit moves through four decades of language design that shaped modern programming.

FORTRAN demonstrates the breakthrough that compiled high-level languages could replace hand-crafted machine code, launching the imperative/compiled lineage. Lisp, built directly on Church’s lambda calculus, establishes the functional thread, introducing dynamic typing, garbage collection and macros; its descendants (Scheme, Clojure) trace forward from that root. C and the Unix toolchain carry the imperative systems tradition, giving rise to C++ and influencing the syntax and structure of many mainstream languages. Smalltalk and Alan Kay introduce genuine object-oriented design — objects and message passing — which Stroustrup adapts into C++ for systems programming. Haskell represents the functional line taken to its pure, statically typed extreme, showing a contrasting design point to Lisp’s dynamic, effectful model.

The 1990s produce languages targeted at specific new problems made possible by cheap computing and the web: Python for readable scripting and general-purpose programming, JavaScript for client-side interactivity, Ruby for developer-centered web frameworks, and PHP for rapid web page generation. Alongside these general-purpose trends, SQL exemplifies the power of a narrow, domain-specific language: a precisely focused language for querying relational data that became the field’s most successful DSL.

Finally, the unit ties these threads to later study: the functional lineage resurfaces in the course’s treatment of Clojure, object-orientation and DSL design reappear in the module on Kotlin, and the von Neumann machine is the common target to which all these languages ultimately compile or interpret. After this unit, learners will be able to explain how EDVAC realized abstract machines, place Lisp and object-orientation in their historical lineages, summarize why key 1990s languages were created, explain SQL’s role as a DSL, and recognize that this survey previews the detailed paradigm study that follows.

Materials

Lecture notesThe unit written out, to read at your own pacever. 1.1.0 · 2026-09-13 03:12 UTCOpen → SlidesThe deck to present fromOpen →

Source document

Course material, Ken Pu

← The Birth of Computation The Limits of Computation →

--- title: "The Birth of Programming Languages" keywords: - ver. 1.0.0 - "birth_of_programming_languages" format: html: toc: false --- **A rapid historical survey connecting von Neumann hardware to major programming-language paradigms from FORTRAN and Lisp through object-orientation, functional purity, 1990s web languages, and SQL.** > This unit traces how the abstract machines of theory became physical hardware with von Neumann's EDVAC, then runs a compact history of programming languages: FORTRAN's compiled high-level code, Lisp's functional roots and garbage collection, C's systems-level imperative lineage, the arrival of true object-orientation with Smalltalk and its systems incarnation in C++, the rise of pure functional Haskell, the burst of 1990s languages solving web and scripting problems, and SQL as the canonical domain-specific language. By the end, learners can situate each major language and paradigm and see how they reappear later in the course. ::: {.callout-note collapse="true" title="Full summary"} The unit begins at the hardware level: von Neumann's EDVAC turns Turing's abstract machine into a physical architecture — CPU, memory, bus, binary data and machine code — the substrate every later language runs on. From that foundation the unit moves through four decades of language design that shaped modern programming. FORTRAN demonstrates the breakthrough that compiled high-level languages could replace hand-crafted machine code, launching the imperative/compiled lineage. Lisp, built directly on Church's lambda calculus, establishes the functional thread, introducing dynamic typing, garbage collection and macros; its descendants (Scheme, Clojure) trace forward from that root. C and the Unix toolchain carry the imperative systems tradition, giving rise to C++ and influencing the syntax and structure of many mainstream languages. Smalltalk and Alan Kay introduce genuine object-oriented design — objects and message passing — which Stroustrup adapts into C++ for systems programming. Haskell represents the functional line taken to its pure, statically typed extreme, showing a contrasting design point to Lisp's dynamic, effectful model. The 1990s produce languages targeted at specific new problems made possible by cheap computing and the web: Python for readable scripting and general-purpose programming, JavaScript for client-side interactivity, Ruby for developer-centered web frameworks, and PHP for rapid web page generation. Alongside these general-purpose trends, SQL exemplifies the power of a narrow, domain-specific language: a precisely focused language for querying relational data that became the field's most successful DSL. Finally, the unit ties these threads to later study: the functional lineage resurfaces in the course's treatment of Clojure, object-orientation and DSL design reappear in the module on Kotlin, and the von Neumann machine is the common target to which all these languages ultimately compile or interpret. After this unit, learners will be able to explain how EDVAC realized abstract machines, place Lisp and object-orientation in their historical lineages, summarize why key 1990s languages were created, explain SQL's role as a DSL, and recognize that this survey previews the detailed paradigm study that follows. ::: ## Materials ::: {.hg-deck} <a class="hg-card" href="notes.qmd">Lecture notesThe unit written out, to read at your own pacever. 1.1.0 · 2026-09-13 03:12 UTCOpen →</a> <a class="hg-card" href="slides.qmd">SlidesThe deck to present fromOpen →</a> ::: ## Source document - Course material, Ken Pu ::: {.hg-nav} [← The Birth of Computation](../birth_of_computation/index.qmd){.hg-prev} [The Limits of Computation →](../limits_of_computation/index.qmd){.hg-next} :::