structured concurrency

Nathaniel J. Smith's PyCon 2018 talk introducing Trio, a Python concurrency library designed around usability and structured concurrency. He live-codes a problem and analyzes pitfalls in other async libraries.

Rob Pike's Go talk distinguishing concurrency, the structuring of independent processes, from parallelism, their simultaneous execution. It uses Go channels and goroutines to illustrate.

Rob Pike's 2010 talk at OSCON's Emerging Languages Camp on where Go's concurrency style comes from. It traces the idea from Hoare's CSP through Squeak, Newsqueak and Limbo to Go.

Jonathan Worthington's YAPC Asia 2015 talk on parallelism, concurrency and asynchrony in Perl 6. It covers the language's concurrency features.

Kevlin Henney revisits structured programming, from Go To Statement Considered Harmful to block-structured code and object orientation. He argues it still matters for how we write code today.

Rob Pike's Google I/O 2012 talk shows how goroutines and channels solve tricky concurrency problems with simple Go code. It features a playful goroutine demo with gophers passing messages and a search engine example.

Rich Hickey's long presentation on Clojure and concurrency covers locking and immutability, then goes in depth on refs, transactions and agents. It ends with a multithreaded ant colony simulation demo.

Raymond Hettinger's PyBay 2017 keynote on concurrency in Python. It covers threads, processes, asyncio, locks and the GIL, with live shell-based examples.

A panel with Tony Hoare, Joe Armstrong and Carl Hewitt, hosted by Francesco Cesarini, on the history and future of concurrency. The three creators of CSP, Erlang and the actor model discuss their differing approaches.

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.

A Google Tech Talk by the author of Kilim, a Java library for lightweight actor-style message passing. It argues that message passing can replace shared-memory concurrency and claims performance competitive with or better than Erlang for huge numbers of actors.

A RacketCon talk presenting Fructure, a prototype extensible structured editing engine in Racket. Language providers define syntactic forms and refactorings as rewrite rules, and editing operates on program structure rather than on text.

Go runtime contributor Dmitry Vyukov looks inside the Go scheduler, explaining how goroutines and channels are implemented. He covers the main scheduler components and overall operation, then goes into details such as preemption and stacks.

Jon Moore's Strange Loop 2017 talk argues that rate limiting is the wrong tool for protecting services from noisy clients. He proposes concurrency-based capacity management and quotas instead.

Sasa Juric explains what makes Erlang and Elixir suited to server-side systems, focusing on the BEAM concurrency model rather than syntax or ecosystem. He demonstrates processes, supervision, and fault tolerance.

Will Wilson of FoundationDB explains how the team tested their distributed database using deterministic simulation. By running the whole system in a simulator with injected faults and reproducible seeds, they could find rare concurrency and network bugs.

A three-minute Emacs Rocks screencast by Magnar Sveen demonstrating paredit, which edits Lisp code structurally as a tree of s-expressions rather than characters.

A Channel 9 Going Deep interview in which Brian Beckman talks with Rich Hickey, creator of Clojure, about the language's design. It covers Clojure's persistent data structures, reference types and its approach to concurrency on the JVM.

David Beazley's workshop screencast builds asynchronous programming in Python from scratch, starting from callbacks and continuations and replacing threads to show how concurrency works underneath.

Kevlin Henney argues that procedural programming never went away despite later paradigms such as OO and functional. He traces the history of structured programming and shows where procedural thinking still lives in modern code and why it matters for readability.

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.

CppCon 2014 talk by Jeff Preshing on how Ubisoft Montreal developed games for multicore hardware, before and after C++11 concurrency support. It goes into atomics and lock-free programming in practice.

A short satirical sketch in which a Q&A about web servers turns into a profane rant about threads, blocking and non-blocking I/O. It lampoons the hype around Node.js and async programming.

John Bird and John Fortune satirize the investment banking mindset in a mock interview about the subprime mortgage crisis. The sketch lampoons structured credit products and the banks' reassurances shortly before the crash.

Rob Pike presents Go Proverbs at Gopherfest 2015, a set of pithy aphorisms about Go design such as 'Clear is better than clever' and 'A little copying is better than a little dependency'.

Rob Pike's October 2009 Google Tech Talk introducing Go, a new experimental systems language designed for fast builds, concurrency and garbage collection. It covers the goals, syntax and type system.

A 2015 GDC talk by Bungie's Barry Genova on how Destiny's engine was restructured into a job graph with limited thread pre-emption. It is aimed at programmers of demanding game engines.

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.

Herb Sutter's deep C++ and Beyond 2012 talk on atomics and the C++ memory model, covering why programmers chasing top performance need to understand hardware ordering. This is part one of two.

Paul Turner of Google presents kernel interfaces for user-level scheduling of real threads, aiming at a uniform synchronous programming model across C++, Java, Go and Python. It introduces the switchto-style system calls behind Google's fibers.

A standing whiteboard conversation at Lang.NEXT 2012 among Carl Hewitt, Erik Meijer and Clemens Szyperski about the actor model. Hewitt, who originated the model, explains its foundations.

A 2007 Google Tech Talk in which Cliff Click of Azul Systems presents a lock-free concurrent hash table that scales to 768 CPUs. He explains why it is correct by reasoning in a different way than usual happens-before and memory-order arguments.

David Beazley's PyCon 2010 talk explains how the Python Global Interpreter Lock works and shows experiments where multithreaded code runs slower, even on more cores, due to lock contention and context-switching overhead.

A short Ericsson film demoing Erlang, showing concurrent processes, debugging tools, and hot code reloading, including crashing parts of a running system while calls continue.

Fedor Pikus's CppCon 2017 talk on C++ atomics, looking at what they let the programmer express and what the hardware actually does. It covers memory ordering and lock-free programming from basic to advanced.

Sasa Juric's EMPEX talk demonstrates Elixir and Erlang's process model and what makes the BEAM runtime distinctive, such as fault-tolerant parallelism by design.

A 12-minute film in which Erlang's creators demonstrate the language's fault tolerance and live-system features, including phoning each other to show it working. This version has fixed audio.

Part two of Herb Sutter's C++ and Beyond 2012 session on atomic weapons, a deep dive into the C++ memory model, atomics, memory ordering, and hardware behavior. It ends with the modern meaning of volatile.

A short film about the Erlang language, showing telecom systems built from lightweight processes and demonstrating hot code swapping. It is an edited version of the original Ericsson video.

Jon Gjengset's long live-coding Crust of Rust episode on async/await, focused on the mental model for using it rather than on Futures, Pin and Wakers internals. Topics include awaiting multiple futures, cancellation, executors and select.