formal verification

Tikhon Jelvis's Compose Conference talk on using the Z3 SMT solver to analyze and verify programs, including checking invariants with bounded loops. He demonstrates verifying programs in a small language by compiling them to Z3.

Gernot Heiser presents seL4, a microkernel with a mathematical proof connecting security properties to the binary code, and explains what its open-sourcing means for users. It covers its roles as a microkernel, separation kernel and hypervisor.

Mathematician Kevin Buzzard explains why he believes the Lean theorem prover will shape the future of mathematics, and describes digitizing his university curriculum in Lean with undergraduates, plus the cultural challenges.

Jay Parlar's Strange Loop talk shows how model checkers such as Alloy can find complex bugs in a system's design without running or reading any code. He walks through modeling architectures and checking every possible sequence of operations, including a real security bug and a UI feature-interaction bug.

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.

Hillel Wayne's Strange Loop talk introducing TLA+ as a specification language for finding concurrency bugs in designs. It covers stalling, race conditions and dropped messages, with PlusCal examples.

An AdaCore webinar in which NVIDIA engineers explain why and how they adopted Ada and SPARK for security-critical firmware. It covers the business case and the engineering experience of the transition.

The first part of Robert Baruch's series on building a 6800 CPU on an FPGA with nMigen, a Python-based hardware description language. It introduces the HDL while implementing a simpler 6800 core.

Meredith Patterson and Sergey Bratus argue that networked software stays insecure because protocols and inputs are too complex to recognize safely. They propose using formal language theory and grammars to build secure, verifiable input handling.

Hillel Wayne's PyCon 2018 talk on testing beyond pytest and mypy. It introduces property-based testing with the Hypothesis library and design-by-contract with dpcontracts, and shows how to combine them with an existing test suite.

Leslie Lamport argues that programmers, like architects, should write rigorous specifications before coding, especially for concurrent and distributed systems. The talk introduces the case for writing specs (the TLA+ mindset) as a way of thinking above the code.

Vladimir Voevodsky's IAS lecture starts from Godel's second incompleteness theorem to explore whether first-order arithmetic could be inconsistent. It motivates his vision of univalent foundations and computer-checked proofs.

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.

Physicist Roger Penrose and philosopher William Lane Craig discuss the origin of the universe on the Unbelievable? show. Topics include Penrose's three realms of reality, conformal cyclic cosmology and whether fine tuning points to a creator.

PBS Space Time explains Roger Penrose's conformal cyclic cosmology, in which the far future of our universe becomes the big bang of the next. It explores what could come after the universe ends.

Microsoft's Brian Beckman gives an hour-long, whiteboard-style walk through monads, building from function composition and monoids using school-level math. It is aimed at practicing programmers rather than category theorists.

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.

Veritasium's explainer on Godel's incompleteness theorems and the limits of mathematical proof, tracing set theory, Hilbert's program and the road to Turing and modern computing.

Vsauce's roughly 24 minute explainer on the Banach-Tarski paradox, building from infinity and set theory to the decomposition of a sphere into pieces that form two spheres.

Vsauce's Michael Stevens takes viewers past infinity using transfinite numbers, ordinals and cardinals, with input from mathematician Hugh Woodin. It is a fast-paced, mind-bending tour of different sizes of infinity.

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.

Numberphile's James Grime explains Cantor's result that some infinities are bigger than others, including why the reals outnumber the integers. It is a short, accessible introduction to countable and uncountable infinity.

Guy Steele's PPoPP 2017 keynote surveying the history of computer science metanotation, including BNF, inference rules, and overline notation. He argues the field's notations are inconsistent and fragmented.

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.

The first lecture of MIT 6.042J Mathematics for Computer Science, taught by Tom Leighton, introducing mathematical proofs. It covers propositions, implication and basic proof methods.

The first lecture of an MIT course on Douglas Hofstadter's Godel, Escher, Bach, covering themes like self-reference, recursion and incompleteness. The full lecture series is on YouTube.

Markus Triska tours Prolog's most distinctive features, including its use as a database and query language, rule processing, constraint solving and compile-time rewriting. It also covers concise meta-interpreters.

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

A Clojure/conj 2016 talk demoing Barliman, a prototype smart editor that does program synthesis. Given a partial program and tests, it completes the program using a relational interpreter written in miniKanren.

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.

Veritasium shows how Hilbert's infinite hotel can still run out of room, using infinite buses of guests. It explains the surprising answer in a short animated segment.

Robert Moss's JuliaCon 2015 talk describes using Julia as a specification language for ACAS X, the next-generation airborne collision avoidance system that succeeds TCAS.

Andrej Bauer's IAS talk introduces constructive mathematics and what it feels like to do mathematics without excluded middle. It is framed as a tour for classical mathematicians.

Scott Aaronson's Harvard CMSA talk traces what mathematical truths are knowable, from Godel and Turing to the Busy Beaver function. He covers recent work on Busy Beaver values.

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.

A French-language documentary on the history of Prolog, created in Marseille by Alain Colmerauer in the early 1970s, with interviews of many people involved. It traces the origins of logic programming and later developments of the language.

Tom LaGatta's talk on category theory at a 2014 LispNYC meetup, covering objects, morphisms and the basic ideas in an informal, conversational style. It runs about 97 minutes.

Tom Scott makes a short descriptivist argument that language keeps changing and that casual internet writing conventions, like lowercase typing and dropped full stops, are legitimate. It is part of his Language Files series, written with Gretchen McCulloch.

Bryan Seely tells how he used fake Google Maps business listings to intercept phone calls meant for the Secret Service and FBI. He then turned himself in, and the talk explains the verification gaps that made it possible.

A three-minute clip from The Wire season 3 in which Stringer Bell chairs a drug-crew business meeting using Robert's Rules of Order. The scene plays the formal procedure against the criminal setting.