type systems

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.

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.

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.

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.

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.

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.

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.

The Michigan TypeScript group shows the Doom engine running entirely inside the TypeScript type system. It is open source, and two follow-up videos cover why and how they did it.

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.

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.

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.

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.

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, 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.

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.

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 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.

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.

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.

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.

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.

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.

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.

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.

Jeff Dean of Google describes his experiences building Google's systems and how its infrastructure evolved over time. The Stanford talk covers search, scaling tipping points and lessons from building large-scale software.

CuriousMarc inspects a newly arrived Teletype Model 19, an early military unit built around a Model 15 keyboard and printer, after an initial rough cleaning. It is the first part of a restoration series and touches on 5-bit Baudot code.

An AWS re:Invent 2014 talk on the core distributed systems primitives behind AWS and Amazon.com, such as consensus, key-value stores and transactional logging. It describes how AWS builds large services from a few common building blocks.

Professor Brailsford of the University of Nottingham describes how the university set out to print its own mathematics exam papers in the 1980s. The story centers on getting a Mergenthaler Linotron 202 typesetter to work with their own software.

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.

Aditya Siram introduces Shen, a small hosted Lisp with macros, a built-in Prolog and an optional type system. The talk demos a full web app moving between functional, logic and imperative styles, including turning JSON into a type with macros.

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

Chris Houser's Clojure/conj talk on why Clojure's exceptions destroy information as the stack unwinds, unlike Common Lisp's condition system, which can resume from the error site. He surveys the existing libraries that approximate conditions, explains why they don't compose with each other, and considers what a better design would look like.

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.

Timothy Roscoe of ETH Zurich delivers the joint USENIX ATC/OSDI 2021 keynote arguing that operating systems must reckon with modern hardware, which is a heterogeneous collection of processors, firmware and coprocessors rather than a simple machine. It shows how much runs below and beside Linux.

CuriousMarc connects a restored 1930 Model 15 Teletype to a Linux machine and uses it as a terminal, after commenters requested it. The video shows the challenges of linking a 5-bit mechanical device to a modern OS.

The first lecture in Martin Kleppmann's 8-lecture distributed systems series from the University of Cambridge undergraduate course. It introduces the subject, and accompanying lecture notes are available.

Joe Duffy's RustConf 2017 closing keynote on his experience at Microsoft building Midori, an operating system written in a Rust-like safe systems language. He covers the technical and cultural challenges of applying those lessons to Windows.

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.

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.