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.

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.

A live-coded demo by Jonathan Blow showing how to get object-system-style expressiveness in a data-oriented way, covering structure-of-arrays layouts and composition. It shows features of his Jai language that make programs fast.

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.

A long recorded seminar in which Alan Kay discusses object-oriented programming, probably from the mid-1980s. He covers the original idea of objects, messaging and the work done at Xerox.

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.

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.

The first lecture of Andy Pavlo's CMU 15-445 Intro to Database Systems (Fall 2019), covering course introduction and the relational model.

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.

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.

Peter Norvig's UBC distinguished lecture on how massive amounts of simple data, such as for language modeling, can yield understanding that hand-built models could not.

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.

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.

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.

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.

Rich Hickey's talk on time, state, identity and values, arguing that mutable object-oriented modeling fits the world poorly. It lays out the thinking behind Clojure's approach to data and change.

Sean Parent's CppCon 2015 talk on better use of standard containers and the goal of having no incidental data structures. It argues that proper containers can greatly simplify code.

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.

A SXSW talk by W Watson that uses Lacanian psychoanalysis, with nods to Zizek, to critique popular programming languages. It argues that people choose and defend languages for emotional and ideological reasons rather than rational ones.

Brian Kernighan's 2009 talk at Princeton on the Elements of Programming Style, discussing readable code, avoiding cleverness and flawed examples in programming tutorials.

A London Haskell talk on the algebra of algebraic data types, showing how sum and product types behave like arithmetic. It frames types as numbers obeying algebraic laws.

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.

Alan Kay argues for rethinking how computer science is taught in schools, drawing on his work on object-oriented programming and GUIs. He discusses how poorly people understand complex systems and what education could do about it.

Scott Meyers explains how CPU caches work and why they matter for performance, covering cache levels, access speeds, associativity, and effects in multithreaded code. The focus is C++ and cache-aware, data-oriented programming.

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.

Douglas Crockford's YUIConf 2011 keynote on why programming style matters, particularly in JavaScript. He draws on science about the brain and shows how tools like JSLint help.

Eskil Steenberg's two-hour talk on his personal approach to writing C, covering code style, structure, naming, pointers and large-project organization. He warns it contains a fair bit of programming religion.

Joe Armstrong, creator of Erlang, interviews Alan Kay at Code Mesh. They discuss the meaning of object orientation, message passing, the META II paper, and the state of computer science.

Mark Seemann argues that functional programming naturally yields many of the best practices object-oriented developers learn painfully. He shows how functional architecture leads to a pit of success, with a pure core and impure shell.