type-level programming

A London Haskell talk on the algebra of algebraic data types, showing how sum and product types behave like arithmetic. It frames types as numbers obeying algebraic laws.

A roughly 3.7-hour Lex Fridman podcast with Pieter Levels, the solo developer behind over 40 startups. They discuss programming, viral AI products, indie hacking and digital nomad life.

Matthias Felleisen's keynote uses weather prediction as an analogy for type systems, arguing they forecast problems so you can act on them. It draws on his experience developing Typed Racket.

Simon Peyton Jones's first lecture on types in Haskell from the Oregon Programming Languages Summer School 2013. It covers type classes and how they relate to OOP, subtyping and polymorphism.

An interview with Anders Hejlsberg, lead architect of TypeScript, about porting the TypeScript compiler to Go. He covers the 10x type-checking speedup, lower memory use, and why Go was chosen.

Jon Purdy's Stanford EE380 seminar giving an overview of concatenative programming, from function composition theory and history down to low-level implementation and correctness benefits.

José Valim's ElixirConf US 2023 closing keynote on the foundations of the Elixir type system, covering set-theoretic types and gradual typing with strong arrows.

Yaron Minsky of Jane Street gave this talk to Harvard's OCaml-based CS51 class in 2010. It collects advice on being an effective ML programmer in an industrial setting.

Jonathan Blow's Reboot Develop 2017 talk on making game programming less terrible, discussing software bloat, slowness and the design goals behind his own programming language.

A panel from the Lang NEXT 2014 conference on systems programming in 2014 and beyond. Language designers including Bjarne Stroustrup and Rob Pike discuss the topic, including C++ header compile times.

Robert C. Martin (Uncle Bob) traces the history of software from 1948 to today, looking at the problems programmers faced, how they were solved, and what mistakes the profession made. He then projects where the field is going, including professionalism and regulation.

A SXSW talk by W Watson that uses Lacanian psychoanalysis, with nods to Zizek, to critique popular programming languages. It argues that people choose and defend languages for emotional and ideological reasons rather than rational ones.

Kevlin Henney argues that procedural programming never went away despite later paradigms such as OO and functional. He traces the history of structured programming and shows where procedural thinking still lives in modern code and why it matters for readability.

Edward Kmett speaks at the Boston Haskell meetup about type classes and the design tradeoffs of global coherence compared with other approaches to implicit instances. It covers why uniqueness of instances matters for reasoning and refactoring.

Kevlin Henney revisits structured programming, from Go To Statement Considered Harmful to block-structured code and object orientation. He argues it still matters for how we write code today.

Brian Kernighan's 2009 talk at Princeton on the Elements of Programming Style, discussing readable code, avoiding cleverness and flawed examples in programming tutorials.

A 2008 Google Tech Talk in which Slava Pestov introduces Factor, a concatenative language influenced by Forth, Lisp and Smalltalk. It covers the interactive environment, metaprogramming, and the language's modern high-level features and libraries.

Tef's EMF 2012 talk on lessons from a career in programming, a candid and humorous look at why programming is so often terrible. Slides and a draft script are available online.

Guy Steele's Strange Loop 2010 talk argues that programmers should not have to think about parallelism, and that languages should support algorithms built on independence and divide-and-conquer. He also recounts fitting a program onto a single punch card.

Douglas Crockford's YUIConf 2011 keynote on why programming style matters, particularly in JavaScript. He draws on science about the brain and shows how tools like JSLint help.

Tested gets hands-on with four Meta Reality Labs research VR headset prototypes testing resolution, brightness, focus shifting and form factor, plus an interview with Mark Zuckerberg on display technology.

Rich Hickey's Clojure/Conj 2018 keynote argues that Maybe/Option types and rigid type signatures are a poor way to model data that changes over time. He builds the case around optionality, schema growth and compatibility, and presents the ideas behind Clojure spec as an alternative.

Douglas Crockford's first Yahoo lecture puts JavaScript in historical context. He traces the language's structure and quirks back through the early decades of computer science and programming language history.

Jonathan Blow's first talk on designing a new programming language for games, which became Jai. He explains the problems with C++ and why Go, Rust and D do not fit game development.

Gabriel Lebec's Fullstack Academy talk introduces lambda calculus syntax, the history of mathematical logic, and the essence of functional programming using JavaScript. It also covers combinators, currying and Church encodings.

David Ungar of IBM Research reflects at Stanford on the Self language project and argues the real legacy of ideas is the people. He covers its history, philosophy, successes and failures.

Day 1 of Casey Muratori's Handmade Hero, a live-coded game built from scratch in C on Windows. It reviews C on Windows, sets up a minimal build system and WinMain entry point, and shows a first MessageBox.

John Carmack's roughly three-hour QuakeCon 2013 keynote, delivered from a few bullet points. Topics include his Haskell experiments with functional programming and static typing, game state, and cloud gaming.

A five-hour Lex Fridman interview with John Carmack covering Doom, Quake, VR, AGI, programming, games and rockets.

Lex Fridman's long podcast conversation with Chris Lattner, creator of Swift, LLVM and MLIR and co-founder of Modular. Topics include the Mojo language, the future of programming and AI, and hardware.

Simon Peyton Jones presents linear types for Haskell, showing how practical linearity can fit into a higher-order polymorphic language. The talk covers motivations such as resource handling and relates the ideas to Rust.

Sean Parent of Adobe argues that object-oriented frameworks ultimately fail to deliver scalable, high quality software and proposes combining generic and declarative programming instead. It draws on Stepanov's Elements of Programming.

Jonathan Blow's LambdaConf 2025 keynote demonstrates the Jai programming language and explains its design. It includes demos of metaprogramming and tools that visualize programs.

A Lambda Days keynote by Simon Peyton Jones and Tim Sweeney introducing Verse, Epic's functional logic language for the metaverse. It covers existential variables, unification and expressions yielding multiple values.

A long recorded seminar in which Alan Kay discusses object-oriented programming, probably from the mid-1980s. He covers the original idea of objects, messaging and the work done at Xerox.

A Lex Fridman podcast conversation with the four creators of Cursor, the AI-assisted code editor. They discuss how the editor integrates models into programming workflows, including custom completion models and techniques like speculative decoding to speed up applying edits.

Jonathan Blow demos his prototype programming language, covering the base language and compile-time execution, including running a game while compiling. The video is about 70 minutes of demo followed by Q&A.

Lex Fridman's long interview with Chris Lattner, creator of LLVM and Swift, covering the future of computing and programming languages. It touches on compilers, hardware, and his work at Apple, Tesla, Google and SiFive.

A roughly hour-long live hacking session in which Go team members Andrew Gerrand and Brad Fitzpatrick write the new version of tip.golang.org, the site serving leading-edge Go documentation. It is unedited pair programming on a real Go project.

Guy Steele's invited talk at Clojure/conj on the informal metanotation computer scientists use in papers to describe languages. He traces how this notation developed and why it is often unspecified and arcane.