type-level programming

A 1987 talk in which John Backus, creator of Fortran, presents function-level programming and the FL language, a successor to his FP work. It is an archival recording with links to the related paper.

Edwin Brady, creator of Idris, presents Idris 2 and demonstrates type-driven development, where the compiler assists by filling holes and suggesting implementations from types.

Aaron Hsu's FnConf18 talk asks whether APL needs a static type system. He argues that APL's expressiveness and rapid iteration already deliver the benefits usually credited to types.

Philip Wadler's Strange Loop talk on Propositions as Types, the link between logic and computation (the Curry-Howard correspondence). He traces its history through Church, Godel and Turing and shows how it shaped theorem provers and programming languages.

Edwin Brady, creator of Idris, introduces type-driven development in a dependently typed language. He shows types being written first and programs derived with interactive editing, then extends beyond simple examples to programs that interact with users and networks.

Edwin Brady presents Idris 2, a rewrite of the Idris dependently typed language, and shows type-driven development in practice. The demos show the compiler filling in whole functions from their types.

Philip Wadler's Lambda Days talk on propositions as types, the link between logic and computation that underlies theorem provers and programming language design.

Aditya Siram introduces ATS, a statically typed ML-like language that compiles to C and offers type-safe pointer arithmetic and a full proof language. The Strange Loop talk shows off C interop, concurrency and verification features with non-trivial examples.

Tom 7's pilot episode of a series that plays with type systems and absurd programming, presented as a parody of the GPL v3 license. It mixes a typesetting experiment with a long, story-driven intro on the origin of TeX. Source code and papers are linked from the author's site.

Felienne Hermans presents Hedy, a gradual programming language for teaching kids that moves through levels from almost no syntax toward full Python. The talk covers why error messages and syntax are scary for beginners.

Felienne Hermans argues that Excel is the world's most popular programming language and shows how spreadsheets work as a pure functional language. She implements a few mathematical problems in spreadsheet formulas to illustrate why they are so powerful and approachable.

A Channel 9 conversation recorded at GOTO 2012 between Anders Hejlsberg (TypeScript) and Lars Bak (Dart). They discuss the two languages and different approaches to making JavaScript development safer, including runtime type checking.

A 1995 Sun Microsystems film about the Self programming language, a prototype-based Smalltalk relative, showing its live, graphical programming environment.

David Christiansen gives a Strange Loop 2018 introduction to dependent types, where one language serves for both compile-time and run-time code and programs unite with proofs. It draws on his book The Little Typer.

Ahmon Dancy of Franz Inc explains low-level programming in Common Lisp, including off-heap data structures used in AllegroGraph to manage memory outside the garbage collector.

A Ben Heck Show episode tearing down the Nintendo PlayStation prototype, one of the rarest consoles ever, with its owners Terry and Dan Diebold. Part 2 then gets it working again.

ElixirConf EU 2023 talk by Giuseppe Castagna and Guillaume Duboc on bringing set-theoretic types to Elixir, and the benefits such a type system could offer such as catching bugs.

Richard Feldman's elm-conf talk on designing models so that bugs from impossible application states cannot occur, using Elm's compiler and types. It demonstrates techniques for making invalid states unrepresentable.

Richard Feldman argues that functional programming is not the norm largely because of historical accidents, such as C++ popularity, platform exclusivity, marketing spend and network effects, rather than merit. He traces the history of how languages become mainstream.

Bret Victor's DBX 2013 talk, delivered in the guise of a 1973 IBM engineer with an overhead projector. It surveys forgotten ideas from 1960s and early 70s computing and warns against assuming you know what you're doing.

Brian Will makes the case for procedural programming over object-oriented programming, arguing that OOP's promised encapsulation and decoupling are largely illusory. He analyzes real code examples and the problems of tying data to behavior in classes.

Felienne Hermans's Strange Loop keynote on the history and pedagogy of teaching programming. She questions exploration-only approaches like Logo and discusses research supporting explicit instruction and rote practice.

Shriram Krishnamurthi's PWLConf 2019 talk on the formal notion of expressive power of programming languages, based on Felleisen's paper. It explains how to tell when a feature adds power by whether emulating it requires global rewriting.

Scott Wlaschin shows how statically typed functional languages, using F# examples, can model a business domain so that invalid states cannot be represented. The type system acts almost like an instant unit test at compile time.

Timothy Daly, an original author of the Axiom computer algebra system, talks about turning a large Common Lisp codebase into a literate program. He argues code should be written as readable manuals, and the talk was given at Write the Docs 2013.

Brian Will critiques object-oriented programming and rewrites a roughly 3800-line OO program in a procedural style, cutting code and complexity. It is part of a series of OOP critiques.

The SILE author's FOSDEM 2015 talk introducing SILE, a TeX-inspired typesetting system with frame-based layout, Unicode, OpenType and a Lua-based extensible design.

First lecture of Stanford's CS106A Programming Methodology by Mehran Sahami, giving a course overview and starting on programming. The course teaches software engineering principles using Java.

Aaron Hsu explains why programmers often find APL harder to learn than people with no programming background. He identifies eight patterns that contrast traditional software engineering practice with APL practice, starting from Ken Iverson's language design principles.

Pieter Levels talks at Dojo Bali about building startups without venture capital through bootstrapping, persistence and learning many skills as a generalist. He reviews his own past projects.

Steven G. Johnson, MIT professor and FFTW co-author, gives a JuliaCon 2019 keynote on metaprogramming and staged programming in Julia, showing how it enables high-performance numerical code and when not to use macros.

Jim Weirich's RubyConf 2012 talk derives the Y combinator step by step, live-coding in Ruby lambdas. It builds up an understanding of functional programming and lambda calculus from first principles.

Evan Czaplicki, creator of Elm, examines how programming languages are funded. He looks at where compiler engineers' salaries come from, why Go has about 5 engineers while Dart has about 30, and how this limits language design.

Andrew Kelley, creator of Zig, introduces the language at the Recurse Center's Localhost series in 2018. He covers its goals of robustness, optimality and clarity, C interop, cross-compilation and explicit allocators.

Paul Chiusano's Strange Loop 2019 talk introduces Unison, an open-source functional language for distributed, elastic systems. It covers content-addressed code identified by hashes of the syntax tree, a codebase manager, and algebraic effects called abilities.

Paul Turner of Google presents kernel interfaces for user-level scheduling of real threads, aiming at a uniform synchronous programming model across C++, Java, Go and Python. It introduces the switchto-style system calls behind Google's fibers.

Erik Demaine's MIT 6.006 lecture introducing dynamic programming through Fibonacci numbers and shortest paths. It covers memoization, subproblems and optimal substructure.

First lecture of MIT 6.00, an introductory computer science course taught in Python by Eric Grimson and John Guttag. It covers the goals of the course, what computation is, and data types, operators and variables.

Nadia Polikarpova's Strange Loop talk on program synthesis driven by refinement types, as in Synquid. It shows how rich type specifications can be turned into verified, executable code.

Bret Victor's talk at CUSEC 2012 in which he argues that creators need immediate feedback and should organize their work around a guiding principle. He demonstrates live-coding and animation tools that show results as you type, and describes his own principle that creators must see what they are making.