array programming

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.

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.

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.

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.

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.

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

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.

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.

Jonathan Blow's first talk on designing a new programming language for games, which became Jai. He explains the problems with C++ and why Go, Rust and D do not fit game development.

A 2008 Google Tech Talk in which Slava Pestov introduces Factor, a concatenative language influenced by Forth, Lisp and Smalltalk. It covers the interactive environment, metaprogramming, and the language's modern high-level features and libraries.

John Carmack's roughly three-hour QuakeCon 2013 keynote, delivered from a few bullet points. Topics include his Haskell experiments with functional programming and static typing, game state, and cloud gaming.

Jon Purdy's Stanford EE380 seminar giving an overview of concatenative programming, from function composition theory and history down to low-level implementation and correctness benefits.

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.

Jonathan Blow's LambdaConf 2025 keynote demonstrates the Jai programming language and explains its design. It includes demos of metaprogramming and tools that visualize programs.

A Lambda Days keynote by Simon Peyton Jones and Tim Sweeney introducing Verse, Epic's functional logic language for the metaverse. It covers existential variables, unification and expressions yielding multiple values.

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.

A two-hour live stream in which Aaron Hsu explains the architecture, design history and aesthetic of Co-dfns, his parallel APL compiler. He walks through the code and the reasoning behind its dense style.

Chuck Moore, creator of Forth, gives his annual Fireside Chat at Forth Day 2011 at Stanford. He talks about his multi-core GreenArrays chip design and demonstrates code running on it.

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.

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.

Dylan Beattie's NDC London talk on code written for art, fun and curiosity rather than utility. It includes quines, live music programming with Sonic Pi, and a memorable closing.

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.

Gerald Sussman's 2011 Strange Loop keynote argues we still do not know how to compute, comparing biological systems with how we program machines. It touches on propagators, constraint programming and robustness.

David Heinemeier Hansson's RailsConf 2014 keynote argues that programming is closer to writing than to science, with clear code produced by iterating through drafts. It prioritizes clarity and craft over technical superiority.

David Ungar of IBM Research reflects at Stanford on the Self language project and argues the real legacy of ideas is the people. He covers its history, philosophy, successes and failures.

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.

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.

Guy Steele's JuliaCon 2016 keynote on the Fortress language, its features and the lessons learned from the project.

William Byrd presents at Papers We Love NYC on what he calls the most beautiful program ever written, a Lisp interpreter written in Lisp. He walks through the metacircular interpreter and related ideas, and demos relational programming and program synthesis near the end.

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 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.

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.

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.

Scott Wlaschin demystifies functional programming terms like monads, monoids, functors and catamorphisms by showing how they fit into a small toolkit. He applies them to problems such as missing data, list handling, and functional dependency injection.

Timur Doumler's CppCon 2015 talk on how C++ is used in the audio industry. It covers the patterns and tools audio developers rely on, including handling real-time constraints.

Scott Wlaschin's NDC Oslo talk on four 1970s languages, SQL, Prolog, ML and Smalltalk. It explains their philosophies and what practical principles they still offer modern developers.

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

Jonathan Blow speaks at UC Berkeley's CSUA about how to program independent games. He argues for keeping code simple, avoiding unnecessary work, and shipping.