data-oriented design

Mike Acton of Insomniac Games argues that a program's purpose is transforming data, and shows how common C++ approaches work against that in performance-critical game development. He covers cache behavior, data layout and the limits of compilers.

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.

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.

Mark Bastian contrasts top-down object-oriented design with bottom-up, data-oriented design in Clojure. He models a board game as plain data plus small composable functions and compares it with a roughly 22-class OOP version.

Raph Levien presents his new Rust GUI framework, built on data-oriented design and ideas from entity component systems, for the Xi editor. He weighs the approach against alternatives and discusses pros and cons.

Rich Hickey, creator of Clojure and designer of Datomic, gives a JaxConf 2012 talk that takes apart traditional database architecture. He presents a different way to think about databases and explains the reasoning behind Datomic's fact-based design.

Robert C. Martin (Uncle Bob) gives a talk on the SOLID principles of object-oriented and agile design, in the context of encapsulation and clean code.

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.

Rich Hickey's 2013 talk applies language-design thinking to whole systems, covering names, queues, data, failure, and the interfaces between programs. It ends with a call to action for building systems holistically.

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.

James Powell's nearly two-hour PyData talk builds up Python's data model, decorators, generators and context managers, coding live in Vim. It aims to take intermediate programmers toward real Python expertise.

Joshua Bloch's Google Tech Talk on how to design good APIs and why it matters, with concrete principles and examples. It treats every programmer as an occasional API designer.

Blizzard's Timothy Ford explains in this 2017 GDC session how Overwatch uses an Entity Component System architecture for layered gameplay. He also covers its server-authoritative netcode with client-side prediction and how they keep the game responsive and fair.

A five-minute excerpt of Rich Hickey's Clojure Made Simple talk, with new slides, ranting about HttpServletRequest and specificity. He argues for using generic maps instead of many specific classes and getters.

Stuart Halloway's satirical talk describes how to protect yourself from industry change by spreading complexity through systems while following idiomatic practice. It uses this inversion to catalog software design anti-patterns.

Alex Martelli's Google Developers Day talk on classic design patterns (creational, structural and behavioral) and how they appear in Python. He stresses that patterns must be studied in the context of the implementing language.

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.

Robert C. Martin (Uncle Bob) talks about clean architecture and design, including keeping the database and frameworks out of the center of an application. It is an hour-long conference talk.

Erik Meijer argues that category theory is the mathematicians' version of interface-based design. He shows that Java 8 lambdas and method references form a Cartesian closed category.

Brian Bucklew of Freehold Games discusses design decisions behind Caves of Qud and Sproggiwood at IRDC 2015. The talk centers on data-driven, event-driven engine design.

John Ousterhout, Stanford professor and creator of Tcl, presents the ideas of his book A Philosophy of Software Design in a Talks at Google session. He covers managing complexity, deep modules and interfaces, and what he teaches in his Stanford software design course.

Rich Hickey's talk at Clojure's tenth anniversary on the kind of programs Clojure is designed for. He argues for situated programs that deal with changing requirements, and for dynamic typing and data over static types.

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.

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.

Sandi Metz takes an ugly section of conditional code and refactors it into a few simple objects, bridging object-oriented theory and practice. The talk includes her take on the Gilded Rose refactoring kata and the idea that duplication is cheaper than the wrong abstraction.

Juan Pedro Bolivar Puente explains immutable and persistent data structures in C++ and how they support value semantics. He presents the Immer library, rrb-trees, and a prototype text editor that opens a huge file instantly.

Evan Czaplicki, creator of Elm, talks at Curry On 2015 about user-focused language design. He explains the principles behind Elm and how to make a functional, typed language as approachable as JavaScript.

Lee Byron of Facebook explains how persistent immutable data structures work and how to use them in React apps with Immutable.js. He covers memoization benefits and avoiding coupling through shared mutable state.

The 1969 pitch film in which Saul Bass presents the Bell System logo redesign to AT&T, part of the largest corporate re-identity program in U.S. history.

TEDxStanford talk by Bill Burnett, executive director of Stanford's design program, on applying design thinking to your own life and career. He offers five practical tips such as getting curious, talking to people and trying things.

Peter Norvig's 2007 Google talk on theorizing from data, covering what huge datasets can do for language understanding, translation, information extraction and inference. It argues that more data often beats cleverer models.

John Ousterhout's Netdev 0x16 keynote arguing that nearly every aspect of TCP is wrong for the datacenter, from connections and streams to reliable delivery and congestion control. He presents the case for a replacement protocol.

Roman Mars gives a funny TED talk on vexillology, laying out five basic principles of good flag design and why many city flags fail them.

A 2001 panel with Paul Graham, John Maeda, Jonathan Rees and Guy Steele on programming language design, part of the Dynamic Languages Wizards Series.

Edward Kmett's 2013 talk at Prezi in Budapest on succinct data structures, which store data in close to the information-theoretic minimum space while supporting fast queries. It ties together the research and walks through his Haskell succinct library.

Christian Schafmeister presents CANDO at the 2016 European Lisp Symposium. It is a compiled Lisp-based language for designing macromolecules and nanoscale materials, built on the Clasp implementation of Common Lisp.

An AWS re:Invent 2019 session for advanced DynamoDB users on design patterns used by large customers, including Amazon retail. It covers GSI sharding, index overloading, graph processing, composite keys and transactional workflows.

Jon Gjengset's 2020 PhD dissertation presentation at MIT on partial state in dataflow-based materialized views, the idea behind the Noria database. The Q&A is cut out.

James Hamilton of AWS gives a Velocity 2010 keynote on datacenter infrastructure innovation, focused on power and cooling costs and a breakdown of where datacenter spending goes.

Richard Feldman's elm-conf talk on designing models so that bugs from impossible application states cannot occur, using Elm's compiler and types. It demonstrates techniques for making invalid states unrepresentable.