data-oriented programming

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.

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.

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.

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.

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.

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.

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.

Simon Peyton Jones explains nested data parallelism and Data Parallel Haskell, an approach to exploiting multicore and distributed hardware while keeping a simple single-control-flow programming model.

Robert C. Martin (Uncle Bob) traces the history of software from 1948 to today, looking at the problems programmers faced, how they were solved, and what mistakes the profession made. He then projects where the field is going, including professionalism and regulation.

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.

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.

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.

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.

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.

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.

Michael Arntzenius's Strange Loop talk on Datafun, a functional query language that brings database-style querying into a general-purpose language. It discusses bridging database theory and programming languages.

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.

Rafal Dittwald's Clojure/north talk shows how to move from writing Java-style code in Clojure to thinking in data-driven, functional terms. He walks through a JavaScript example, refactoring imperative code step by step into a functional core.

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.

Jafar Husain's ACM keynote presents Netflix's JSON Graph and Falcor, which let web developers treat all cloud data as one virtual JSON model. It combines reactive programming with REST principles.

Tef's EMF 2012 talk on lessons from a career in programming, a candid and humorous look at why programming is so often terrible. Slides and a draft script are available online.

Sean Parent of Adobe argues that object-oriented frameworks ultimately fail to deliver scalable, high quality software and proposes combining generic and declarative programming instead. It draws on Stepanov's Elements of Programming.

Felienne Hermans argues that Excel is the world's most popular programming language and shows how spreadsheets work as a pure functional language. She implements a few mathematical problems in spreadsheet formulas to illustrate why they are so powerful and approachable.

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.

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.

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.

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.

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.

Jonathan Blow's Reboot Develop 2017 talk on making game programming less terrible, discussing software bloat, slowness and the design goals behind his own programming language.

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.

Ahmon Dancy of Franz Inc explains low-level programming in Common Lisp, including off-heap data structures used in AllegroGraph to manage memory outside the garbage collector.

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.

A one-minute clip of Peter Norvig saying that Google found programming contest success correlates negatively or poorly with job performance. The description links to a blog post discussing it.

A 1987 talk in which John Backus, creator of Fortran, presents function-level programming and the FL language, a successor to his FP work. It is an archival recording with links to the related paper.

A panel from the Lang NEXT 2014 conference on systems programming in 2014 and beyond. Language designers including Bjarne Stroustrup and Rob Pike discuss the topic, including C++ header compile times.

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.

Rich Hickey's JaxConf 2012 keynote examines what values are and why immutable values matter as information systems grow more complex and data gets bigger. It contrasts places with values and builds the case for immutability.

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.

Alan Kay's 1997 OOPSLA keynote, preserved on YouTube after being lost from Google Video. He discusses what object orientation was meant to be, messaging, system design, and the state of computing practice.