type-driven development

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.

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.

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.

Elias Martenson presents his Emacs-based workflow for building a web application (the Potato chat platform) with Common Lisp on the backend and ClojureScript on the frontend. He demonstrates SLIME, Paredit, CIDER and debugger-driven interactive development. The talk is 79 minutes and was given at Emacs SG.

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.

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.

Emily Shea explains how repetitive strain injury pushed her to program by voice using speech recognition (Talon), and gives a live coding demo. She argues voice-driven development can be pain-free, efficient and enjoyable.

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.

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.

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.

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.

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.

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.

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.

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.

Brian Bucklew of Freehold Games discusses design decisions behind Caves of Qud and Sproggiwood at IRDC 2015. The talk centers on data-driven, event-driven engine design.

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.

Ryan Gordon (Icculus) gives a high-level overview of SDL 2.0 at Steam Dev Days 2014. He covers its features and how it eases building, porting and maintaining games, including Linux ports.

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.

A Remedy engineer explains how Alan Wake 2 moved to a GPU-driven rendering pipeline built on mesh shaders, culling and rendering meshlets for dense vegetation on PS5 and Xbox Series consoles.

Tudor Girba's Curry On! 2019 talk on moldable development, the idea that developers should build custom tools and views for each software system they work on. It draws on the Pharo and Glamorous Toolkit environments.

Martin Fowler's GOTO Chicago 2017 talk on the different things people mean by event-driven architecture. He identifies four patterns, including event notification and event-carried state transfer.

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.

Rich Hickey's philosophical talk from the first Clojure Conj in 2010. He argues that good design comes from deliberate, away-from-keyboard thinking, and describes how to feed the background mind so it solves problems.

Dr. Sarah Hallberg argues in a TEDx talk that type 2 diabetes can be treated and potentially reversed through diet, especially by restricting carbohydrates. TED flagged the talk as outside its guidelines and warned against taking it as medical advice.

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.

Greg Kroah-Hartman's Git Merge 2016 talk on how the Linux kernel is developed, how fast it moves, and how git and email workflows keep it manageable. He is the stable kernel maintainer.

David Brevik's GDC 2016 post-mortem of the original Diablo, covering how it evolved from a turn-based claymation DOS game into the genre-defining action RPG. It includes development anecdotes and lessons learned.

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.

Alexander Bruce's GDC talk on making Antichamber, from working alone in a bedroom to winning acclaim at the IGF. It focuses on the psychological challenge of seven years of solo development.

A Thoughtworks conversation among Martin Fowler, Kent Beck and David Heinemeier Hansson on whether TDD is dead. They discuss the tradeoffs of test-driven development, mocking and where TDD helps or hurts design.

A five-minute C-SPAN clip of Dr. Jared Cooney Horvath testifying to a US Senate committee that screen time, including in schools, harms children's learning and cognitive development.

Ted Young of LightStep proposes trace testing, using distributed tracing data to unify testing and observability. The KubeCon-era talk argues for testing against trace data rather than treating tests and monitoring separately.

A Strange Loop talk presenting an open-source library that integrates Clojure into the Unity 3D game engine. It covers REPL-based live coding, macros, DSLs and persistent data structures for game development.

Catherine West's RustConf 2018 closing keynote on building a game in Rust and organizing a large codebase. It builds up an entity component system and generational indices step by step.

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.