dependent types

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.

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.

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.

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.

Anders Hejlsberg introduces the native port of the TypeScript compiler, written in Go, which promises roughly 10x faster tooling. He demos compiling VS Code and explains where the speedup comes from.

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.

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.

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.

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.

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

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.

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.

Jonathan Blow speaks at UC Berkeley's CSUA about how to program independent games. He argues for keeping code simple, avoiding unnecessary work, and shipping.

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.

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.

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.

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.

David Nolen explains how ClojureScript is used at Vouch.io to build mobile and web software with a single language and REPL-driven workflow. The talk includes a live coding demo of React Native development.

Glenn Vanderburg presents Cló, a Clojure library that reimplements TeX's core typesetting algorithms as composable functions. He shows what translating procedural, literate-programming code into functional form teaches.

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.

Adam Conover's talk at a millennial marketing conference argues that generations are an unscientific, condescending idea and that millennials do not exist as a real category. The description notes that researcher Jean Twenge later said he misrepresented some of her work.

David Epstein argues in this TED talk that improving athletic records owe much to technology, training and the selection of specialized body types, not just humans getting inherently better. He gives counter-intuitive examples across sports.

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.

UCLA professor Dario Nardi presents brain-imaging research suggesting that different Myers-Briggs personality types use their brains in different ways. He discusses how each type can reach a state of creative flow. It is aimed at a general audience.

Mike Hearn's talk at the 2012 London Bitcoin Conference on the future of Bitcoin, new applications and rebuilding the banking system. He covers lesser-known protocol features such as contracts, escrow and scripting.

A HOPE09 talk on how modern computer chips are manufactured, from 22nm transistors to ultra-clean fabs and the tricks used to pattern tiny features with light. It frames chipmaking as hacking electrical engineering and physics.

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.

Rich Hickey's talk at Clojure's tenth anniversary on the kind of programs Clojure is designed for. He argues for situated programs that deal with changing requirements, and for dynamic typing and data over static types.

Scott Wlaschin's NDC talk on using statically typed functional programming, F# in particular, to model a business domain. Types are used to represent the domain precisely and to encode business rules so that illegal states cannot be built, with the compiler acting as an instant unit test.

Rich Hickey introduces transducers in Clojure, a way to make map, filter and similar algorithms composable independent of the data source. This avoids duplicated implementations and intermediate collections across sequences, channels and streams.

Julia co-creator Stefan Karpinski explains why multiple dispatch makes Julia code and types reusable across packages with so little friction. He covers sharing basic types and sharing generic algorithms.

Jiahao Chen's JuliaCon 2017 talk argues that vector transposes should be taken seriously in type systems and linear algebra libraries. It explains why treating vectors as matrices causes trouble in languages.

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.

Rob Pike's Go talk distinguishing concurrency, the structuring of independent processes, from parallelism, their simultaneous execution. It uses Go channels and goroutines to illustrate.

Sean Parent's CppCon 2015 talk on better use of standard containers and the goal of having no incidental data structures. It argues that proper containers can greatly simplify code.

Dan Abramov's JSConf Iceland talk on what came after React 16, with live-coded prototypes of async rendering and time slicing. It previews the ideas that became concurrent mode and suspense.

A DEF CON 21 talk by Karl Koscher and Eric Butler on how SIM cards work, including Java Card applets, the SIM toolkit and the OS running on the card. It shows how much control the network and the card have independent of the phone.

Morten Rand-Hendriksen's WordCamp Europe 2017 talk presents CSS Grid Layout as a native two-dimensional layout system that changes how web pages are structured, including responsive layouts independent of source order. It was given as browsers began shipping support.

Konrad Malawski's Strange Loop 2023 talk shows how the FoundationDB team adopted Swift incrementally in a C++ codebase. It covers Swift's C++ interoperability, which let them move single functions or entire types over one at a time.

A Zig SHOWTIME talk by Benjamin Feng on what a memory allocator is, followed by an interview. It covers allocation strategies and different allocator types in Zig.