program analysis

Jack Rusher's Strange Loop 2022 talk argues that most programming languages are still designed around punchcard-era assumptions. He makes the case for live, interactive programming environments, drawing on Lisp, Smalltalk and REPL-driven development.

A 2023 LLVM Developers' Meeting keynote by Abdul Dakkak, Chris Lattner and Jeff Niu introducing Mojo, a Python-family systems language built on MLIR and LLVM for heterogeneous computing.

Felienne Hermans presents Hedy, a gradual programming language for teaching kids that moves through levels from almost no syntax toward full Python. The talk covers why error messages and syntax are scary for beginners.

Guy Steele's Strange Loop 2010 talk argues that programmers should not have to think about parallelism, and that languages should support algorithms built on independence and divide-and-conquer. He also recounts fitting a program onto a single punch card.

Evan Czaplicki, creator of Elm, examines how programming languages are funded. He looks at where compiler engineers' salaries come from, why Go has about 5 engineers while Dart has about 30, and how this limits language design.

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.

Gabriella Gonzalez argues that developers misunderstand marketing as deception or hype, and applies the technology-adoption ideas of Crossing the Chasm to Haskell. She looks at what keeps Haskell from reaching mainstream programmers and what a community can do about it.

Jonathan Blow's LambdaConf 2025 keynote demonstrates the Jai programming language and explains its design. It includes demos of metaprogramming and tools that visualize programs.

A Lambda Days keynote by Simon Peyton Jones and Tim Sweeney introducing Verse, Epic's functional logic language for the metaverse. It covers existential variables, unification and expressions yielding multiple values.

Douglas Crockford's code::dive 2022 talk on what the next programming language should look like. He presents ideas behind his Misty language, including message-passing actors.

Casey Muratori's two-hour talk tracing the history of object-oriented programming back to the 1960s and examining how its ideas, and later entity component systems, came about. It is followed by a Q&A.

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.

Dylan Beattie's NDC London talk on code written for art, fun and curiosity rather than utility. It includes quines, live music programming with Sonic Pi, and a memorable closing.

Gerald Sussman's 2011 Strange Loop keynote argues we still do not know how to compute, comparing biological systems with how we program machines. It touches on propagators, constraint programming and robustness.

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.

A talk by Yuri Iozzelli at a WebAssembly meetup on CheerpX, an x86 virtual machine running in the browser. It uses a JIT compiler that emits WebAssembly at runtime to run real native applications. It covers the architecture and demos such as porting a multiplayer C++ game.

Chris Lattner's ASPLOS 2021 keynote on the golden age of compiler design in an era of hardware and software co-design, covering compiler infrastructure for accelerators and unifying hardware IRs.

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.

Daniel Lemire's QCon talk on how simdjson parses gigabytes of JSON per second. It covers SIMD vectorization, branch prediction and the lessons learned building a fast parser.

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.

Brandt Bucher presents his prototype JIT compiler for CPython at the 2023 Core Developer Sprint. He explains the copy-and-patch approach, the implementation and its performance.

Andrew Kelley's 2024 Zig roadmap talk, followed by a Q&A, covers the language's priorities and the state of the project. Topics include compilation speed, moving off LLVM toward a self-hosted toolchain, async, and the path to 1.0.

Andrew Kelley's roadmap talk on upcoming Zig compiler milestones, focused on compilation speed. It was given at a Zig community event in 2022.

Chandler Carruth's CppNow 2023 talk on modernizing compiler design for the Carbon toolchain, using data-oriented design and modern hardware assumptions. It covers lexing, parsing and compact data structures aimed at compiler performance.

A React Conf talk by Xuan Huang previewing React Forget, a compiler that automatically memoizes components. It argues for making memoization the default so developers need not write useMemo or useCallback by hand.

An Apple WWDC24 session introducing Embedded Swift, a subset of Swift with no runtime that targets tiny microcontrollers. It demonstrates the idea on an off-the-shelf Matter smart home device.

A short excerpt of Rob Pike's Lang.NEXT 2014 talk where he describes Go's target audience as young Google programmers who are not researchers. The language has to be easy for them to understand and adopt.

Fons van der Plas introduces Pluto.jl, a reactive notebook for Julia that tracks references between cells and re-runs affected cells when code changes. The talk was given at JuliaCon 2020.

Chuck Moore, inventor of Forth, presents GreenArrays' 144-core asynchronous chip at Strange Loop 2013. He explains how idle cores draw almost no power and how tight code minimizes energy use.

Destin Sandlin of Smarter Every Day gives a talk to an aerospace audience, comparing how Apollo was engineered and managed with NASA's Artemis program. He raises concerns about unresolved details, the number of launches and in-orbit fuel transfer needed to reach the Moon, and the loss of institutional knowledge.

Casey Muratori argues against smart pointers and RAII, advocating grouped-element thinking, zero-is-initialization and stubs as better ways to structure memory and handle errors.

Guy Steele's classic 1998 OOPSLA keynote on how a programming language must grow with its user community. He delivers it in a playful style, starting with only monosyllabic words and defining new terms as he goes.

James Long's dotJS 2019 talk on how CRDTs enable local-first apps and how simple they can be to implement. He shows how to use them to build robust offline-capable frontends.

Martin Kleppmann surveys current research on CRDTs, the algorithms for merging concurrent edits across offline replicas. He covers the hard parts such as rich text, moves and merge results that are technically correct but poor.

A JuliaCon talk by a NASA Launch Services Program engineer on modeling spacecraft separation dynamics in Julia. He describes replacing a Simulink-based workflow for checking launch vehicle separation requirements with Julia and ModelingToolkit, with large speedups and much shorter code.

A Graphics Programming Conference talk on how the game Tiny Glade renders meadows, trees and player-built castles. It covers real-time global illumination, tilt-shift depth of field, stable shadows with continuous time of day, ray marching and GPU-driven rendering on old hardware.

Jeremy Howard defends Jupyter notebooks as a serious development environment, especially when paired with nbdev. He responds directly to Joel Grus's talk about why he dislikes notebooks, and contrasts REPL-style and notebook-style work.

Isaac Freund, author of the River Wayland compositor, talks about writing a Wayland compositor in Zig. He covers why he chose Zig over C and Rust and how Zig can wrap a hairy C library.

Luca Sas's ACCU 2021 talk on Modern C, a style of C and C-like C++ aligned with data-oriented design. It covers centralized memory management, zero-is-initialization, error handling and API design.

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.