static analysis

Matt Might's Curry On talk on ending errors in code, both software and the human genome. He covers conservative approximation of the halting problem via static analysis and a computational approach to precision medicine.

Julien Verlaguet of Facebook describes applying static analysis and type inference to a very large PHP codebase, using OCaml. The work led to the Hack language.

Steve Yegge's Stanford seminar on GROK, Google's internal large-scale, cross-language source code analysis system. It covers how the system helps with code search and understanding across Google's huge codebase.

Richard Feldman's GOTO Copenhagen 2022 talk on why dynamic languages like Python, Ruby, PHP and JavaScript rose in the 1990s and why each now has a popular static type checker. It argues that modern static typing recovers the advantages that made dynamic languages attractive.

Herb Sutter's CppCon 2015 plenary on writing safe, modern C++ by default using the C++ Core Guidelines. It includes a demo of lifetime-checking static analysis tooling.

John Carmack's keynote at QuakeCon 2011, an hour and a half of wide-ranging talk about id Software, Rage, engine open-sourcing, patents and programming practices.

Troy Hunt argues that even static, non-secret websites need HTTPS, demonstrating attacks such as injected content and China's Great Cannon. It accompanies his blog post of the same name.

Rasmus Lerdorf marks 25 years of PHP at phpday 2019 with a look at the highlights and lowlights of the language. He argues for upgrading PHP versions, covering performance, static analysis, zero-cost profiling and dead code elimination.

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.

Bruce Dang of Microsoft gives a 27C3 talk on how the Stuxnet vulnerabilities were found and analyzed. He walks through the techniques used to triage them and the details of each zero-day exploit, down to the opcode level.

Andrew Kelley's Zig SHOWTIME talk on an experiment to ship static Linux executables that can do graphics and gaming, followed by an interview. It covers the problems of Linux binary stability, dynamic linking and the graphics ABI.

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.

A SXSW talk by W Watson that uses Lacanian psychoanalysis, with nods to Zizek, to critique popular programming languages. It argues that people choose and defend languages for emotional and ideological reasons rather than rational ones.

David Kriesel's 36C3 talk, in an English translation, analyzes a year of scraped Deutsche Bahn data covering every stop of every long-distance train in Germany. It explores delays and how punctuality is actually measured.

Robert Bussard's 2006 Google Tech Talk on inertial electrostatic confinement fusion, a compact approach he argued could be cheap and clean, using boron-hydrogen fuel without neutron radiation. It runs about 93 minutes and covers the physics, funding history and his proposed development path.

A 13-minute OSCON 2010 talk in which Rob Pike argues about what is wrong with mainstream languages like C++, Java and C#, and presents Go as a response. He discusses verbosity and what lightness means in a language.

Stuart Halloway shows how Clojure's spec library lets you build programs that are both agile and robust. He covers declarative, predicate-based specification layered on interactive REPL development.

A 2006 Google Tech Talk by Robert Bussard on inertial electrostatic confinement (polywell) fusion as a cheap, clean alternative to conventional thermonuclear reactors. He argues it could be made viable with modest funding.

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.

Svelte creator Rich Harris explains moving reactivity into the compiler and language rather than tracking state at runtime, with a history of spreadsheets as reactive systems and comparisons to React.

Rob Pike shows how the Go text/template lexer is built, using state functions, goroutines and channels. The talk was given at a Google Technology User Group in Sydney in 2011.

William Byrd presents at Papers We Love NYC on what he calls the most beautiful program ever written, a Lisp interpreter written in Lisp. He walks through the metacircular interpreter and related ideas, and demos relational programming and program synthesis near the end.

Jason Turner's CppCon 2016 talk builds a simple Commodore 64 game using C++17, showing how constexpr and const let a modern compiler produce tight 6502 code. He walks through assembly output to show abstractions being optimized away.

Christian Schafmeister's Google Tech Talk on designing spiroligomer molecules and building Clasp, a Common Lisp on LLVM that interoperates with C++, to program molecular design. It covers the chemistry, automatic differentiation for force fields, and how the compiler is built.

Tom7 explains how he built a SIGBOVIK 2017 paper made only of printable ASCII bytes that is also a valid DOS executable. He writes a C compiler targeting printable x86 without self-modifying code and solves the puzzles the constraint creates.

Christopher Domas's Derbycon 2015 talk on the M/o/Vfuscator, a compiler that emits only x86 mov instructions, showing mov is Turing complete. It explains how a full machine is built from mov and why the output is a nightmare to reverse engineer.

David Beazley's PyCon India closing keynote, in which he live-codes a stack machine and grows it into an interpreter that runs WebAssembly, then uses it to play a Rust-written game. It requires no prior WebAssembly knowledge.

Miguel de Icaza's GodotCon 2023 talk on Swift bindings for Godot. He argues that garbage-collector pauses in C# are a persistent problem and that Swift's reference counting avoids them.

Matt Godbolt's CppCon 2017 talk shows what modern compilers do with your C++ code, using Compiler Explorer to inspect generated assembly. It covers surprising optimizations and how the tool works.

A two-hour live stream in which Aaron Hsu explains the architecture, design history and aesthetic of Co-dfns, his parallel APL compiler. He walks through the code and the reasoning behind its dense style.

Richard Feldman explains how pure functional languages can match or beat imperative ones on performance. Compilers can turn immutable code into in-place mutation, avoiding naive copying. The talk draws on his work on the Roc language.

Cliff Click of Azul Systems gives a Google Tech Talk on running Java business applications on a machine with about a thousand cores. He covers hardware and software codesign, including garbage collection hardware and the JIT.

Cliff Click of Azul Systems asks what a JVM is supposed to do, in a Google Tech Talk from 2011. He covers the services a JVM provides, such as garbage collection and compilation, and the messy reality beneath the abstractions.

Cliff Click, author of HotSpot's JIT compiler, shares hard-won advice for people writing virtual machines at the VMSS16 workshop. Topics include interpreters, JITs and performance lessons.

Simon Peyton Jones explains nested data parallelism and Data Parallel Haskell, an approach to exploiting multicore and distributed hardware while keeping a simple single-control-flow programming model.

Emery Berger argues that performance is hard to measure and deliver on modern systems, showing how code layout and link order can swamp optimization effects. He presents tools that evaluate performance more reliably.

Max Brunsfeld introduces Tree-sitter, a parsing system for developer tools that offers incremental parsing and robust error recovery through a uniform C API. The talk explains the design, based on LR extended to GLR parsing.

Andrew Adams, a Halide developer, presents the Halide language for image processing and tensor computation. The talk explains the separation of algorithm from schedule with illustrated examples of parallelism, locality and redundancy tradeoffs.

Chandler Carruth's CppCon 2016 talk tries to defuse the heated debate over undefined behavior in C and C++. He explains from the compiler writer's perspective why UB exists and how it enables optimization.

David Ungar of IBM Research reflects at Stanford on the Self language project and argues the real legacy of ideas is the people. He covers its history, philosophy, successes and failures.