2018

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.

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.

Raymond Hettinger explains Python's dataclasses module, showing the problem it solves and its key design decisions. He places it in a progression from tuples and dicts through named tuples and attrs.

Michael Levin's NeurIPS 2018 talk on bioelectric computation outside the nervous system, showing how cell electrical networks shape development and regeneration. It covers morphological information processing in living tissue.

Rick Houlihan's AWS re:Invent 2018 deep dive on advanced DynamoDB design patterns. It covers index overloading, GSI sharding, composite keys, graph processing and transactions.

Catherine West's RustConf 2018 closing keynote on building a game in Rust and organizing a large codebase. It builds up an entity component system and generational indices step by step.

Liz Rice live-codes a minimal container runtime in a few lines of Go at GOTO Amsterdam 2018. She explains namespaces, control groups and what a host knows about its containers.

Captain Disillusion's comedic talk at the 2018 Blender Conference recounts how he uses Blender as a production tool for his VFX-debunking web series. It is part case study and part love letter to the Blender community.

Daniel Azuma's ElixirConf 2018 talk on whether Docker and OTP conflict. He shows they can coexist and uses Horde and DeltaCrdt, with a live tank-game demo, to keep state alive across container kills.

Kevlin Henney's GOTO 2018 talk argues that much of what looks new in software is a recycling of concepts with long histories. It draws on history to show the slow, steady current beneath constant churn in frameworks and trends.

A GDC 2018 talk by Valve's John McDonald on VACNet, a deep learning system that analyzes CS:GO gameplay to detect cheaters. It covers how the model is trained on human-reviewed Overwatch cases and how its output feeds human moderation.

Chris McCord's ElixirConf 2018 keynote introduces Phoenix LiveView, which renders HTML on the server and updates the page over websockets. It includes a demo showing that latency is not the bottleneck one might expect.

Erlang co-creator Joe Armstrong's Code BEAM SF 2018 keynote revisits good ideas from the history of computing that were dropped, and asks which should be revived. It also touches on Erlang and Elixir.

Benno Rice's BSDCan 2018 talk on why systemd exists and what it got right and wrong. It traces the history of Unix init and why Linux distributions adopted it, while asking what the BSDs should learn.

Jonathan Blow talks at Gamelab 2018 about the design decisions behind Jai, the programming language he is building for game programmers. He covers low-friction development, quality of life and the effects of compile times.

A CppCon 2018 talk arguing that OOP has failed to deliver on reuse and performance, and presenting data-oriented design for C++ with practical worked examples from real systems.

Sam Aaron, creator of Sonic Pi, gives a demo-heavy GOTO Chicago 2018 talk on live coding music. He covers the history of Sonic Pi, how it evolved, and what it can do for education and professional musicians.

Joe Armstrong's GOTO 2018 talk contrasts the problems computer scientists study with the problems users have. He revisits forgotten great ideas such as tuple spaces, flow-based programming, Xanadu and Unix pipes, with anecdotes.

Michael Feathers' GOTO Chicago 2018 talk on reducing error checks and conditional logic in code. He offers a framework for handling errors and decisions at the level of code and architecture.

Malte Skarupke's C++Now 2018 talk on hash table performance, explaining why std::unordered_map is slow and memory hungry and presenting faster designs, including his bytell hash map.

An AWS re:Invent 2018 session in which Holly Mesrobian and Marc Brooker explain how AWS Lambda is built, including its sandboxing, isolation and scaling architecture. It covers what happens under the hood when serverless code runs.

Joe Armstrong, inventor of Erlang, gives a GOTO Chicago 2018 talk on building fault-tolerant systems. He covers what to do and avoid when handling errors, arguing for letting processes fail and recover.

An AWS re:Invent 2018 talk on how AWS limits the blast radius of failures. It covers design techniques such as cell-based architecture and shuffle sharding.

An AWS re:Invent 2018 session on how DynamoDB was built as a hyper-scale NoSQL database. It discloses underpinnings of the service and how it is run for over 100,000 customers.

Raymond Hettinger's PyBay 2018 keynote on preventing, finding and fixing bugs under a time budget. He covers testing practice, type annotation tradeoffs and the limits of coverage metrics.

Hana Dusikova's CppCon 2018 talk presenting a C++ library that builds regular expressions from compile-time strings, using a C++20 feature. It avoids runtime parsing cost and covers implementation details, problems she hit, and benchmarks.

An AWS re:Invent 2018 session diving into the Nitro system, a set of hardware offload and security building blocks behind next-generation EC2 instances. It covers the design and architecture and how Nitro enables new instance types.

Martin Kleppmann's Kafka Summit 2018 keynote asks whether Kafka can be considered a database. He covers event logs and related data-systems ideas.

Nicolai Josuttis's CppCon 2018 talk walks through the many forms of initialization in C++, including uniform initialization, and how their rules and effects differ. He argues the situation is confusing enough that nobody can say what to teach beginners.

Gor Nishanov's CppCon 2018 talk on using tiny C++ coroutines to hide memory latency, interleaving useful work while prefetches bring cache lines in from main memory.

Oskar Stalberg explains how Wave Function Collapse assembles island dioramas from handcrafted tilesets in Bad North. He covers the theory, implementation, tooling, and how he blends art and technology.

Bryan Cantrill argues that programming languages and platforms reflect core values, and compares languages through that lens, with Rust as a main example. He draws on his experience with Solaris, DTrace and ZFS.

Nickolas Means recounts the 1979 Three Mile Island accident minute by minute, from the control rod insertion to the operator's decision to switch off emergency cooling. He argues that finding systemic causes is more useful than blaming individuals.

Joseph White, creator of PICO-8, retraces the design of the fantasy console and how tools can shape and guide creative work. He discusses cozy, constrained design spaces and the influence of user-made cartridges.

Aditya Siram argues that functional programming has much to learn from Smalltalk's interactivity, using Pharo and Squeak to show live, visual, explorable programming environments.

Matt Godbolt, creator of Compiler Explorer, tours surprising optimizations modern compilers perform, such as turning loops into closed-form sums and using popcount instructions. He explores what the compiler does behind the scenes.

Kiran Pamnany's Cambridge Julia Meetup talk on Julia's shared memory parallelism and its new task scheduler. It argues that fork-join and work-stealing models nest poorly and presents depth-first scheduling for composable parallelism.

Hyrum Wright shares lessons from five years of mass code migrations in Google's huge C++ codebase. He covers why to migrate, how hard it really is, and how Google updates core libraries and their users continually.

Chris Stucchio presents the ethical principles behind algorithmic decision making and shows with examples from lending, criminology and education that they cannot all be satisfied at once. The talk frames AI fairness as a set of quantitative tradeoffs.

Alen Ladavac of Croteam talks about continuous integration and automated testing pipelines in games, with case studies from The Talos Principle and Serious Sam.