programming languages

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.

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.

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.

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.

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.

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.

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.

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.

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.

Devine Lu Linvega of Hundred Rabbits talks about low-power, offline computing, esoteric languages and the Uxn virtual machine, informed by years of sailing the Pacific. The talk frames computing sustainability through a permaculture lens.

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.

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.

RustConf 2020 closing keynote by Sian Griffin that dives into Pokemon Blue glitches, notably Missingno and arbitrary-code-execution tricks. It uses them to explain how memory unsafety works and how memory-safe languages like Rust prevent such bugs.

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.

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.

Jon Gjengset's Rust NYC talk explaining what `unsafe` in Rust actually means, why it is dangerous, and why it is sometimes necessary. He works through the Rustonomicon to separate fair concerns from overblown ones.

Peter Munch-Ellingsen explains at NimConf 2021 why he wrote his own keyboard firmware in Nim instead of using QMK or Arduino. He shows that the resulting firmware is very small.

Isaac Yonemoto's ElixirConf 2021 talk on Zigler, a library for writing Elixir NIFs in Zig. He looks at its internals and how it bridges the two languages while keeping the NIFs well behaved on the BEAM.

Lars Bergstrom of Google presents how Rust improves team productivity beyond safety and speed, with data on rewrites, defects and review. It compares Rust teams to those on legacy native languages and Go.

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.

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.

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.

Bryan Cantrill of Oxide Computer Company gives a Stanford EE380 talk on rethinking the server. He argues that hyperscaler-style rack-scale machines with open firmware, RISC-V and Rust should be available to everyone, not just the giants.

Herb Sutter's CppCon 2022 talk on whether C++ can become ten times simpler and safer. He introduces his experimental Cpp2 syntax and the cppfront transpiler, explaining the limits on incremental improvement.

Andrew Kelley, creator of Zig, presents practical data-oriented design techniques for shrinking memory footprint and making programs cache friendly. He ends with a case study of how these ideas sped up the Zig compiler.

Khalil Estell's CppCon 2024 talk argues C++ exceptions can reduce binary size in firmware. He digs into how exceptions work and how to shrink their code footprint on embedded platforms.

Charlie Marsh of Astral explains how uv, a Rust Python package manager, got so fast. He covers allocators, concurrency, zero-copy tricks and the challenges of Python packaging.

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.

Zig creator Andrew Kelley's RedisConf 2020 talk on modeling data flow with asynchronous I/O in Zig. It explains how Zig's async/await avoids function coloring, and Loris Cro demonstrates OkRedis, a zero-allocation Redis client.

Konrad Malawski's Strange Loop 2023 talk shows how the FoundationDB team adopted Swift incrementally in a C++ codebase. It covers Swift's C++ interoperability, which let them move single functions or entire types over one at a time.

John McCall of Apple's Swift team presents at CppNow 2023 on introducing a memory-safe successor language into large C++ code bases. He argues incremental improvement of C++ hits hard limits and explains Swift's C++ interoperability for gradual migration.

Robert Collins explains why rustup installs were painfully slow on Windows and how changes to rustup and Windows cut install time from 3m30s to 14s. The talk covers NTFS, small files and the cost of antivirus hooks on file close.

Rik Arends presents Makepad, a Rust UI framework, at RustNL 2023. The talk covers designing modern, GPU-fast UIs with Rust and includes live-coded demos of an IDE and a synthesizer.