object-oriented programming

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.

An Alan Kay talk on programming and scaling, covering theoretical limits of code size, engineering versus tinkering, and biological cells as inspiration for object-oriented design.

Sandi Metz argues that hidden assumptions in code are missing concepts, and shows how to name and expose them so code is easier to understand and change. It covers null objects and messages in Ruby.

Noel Rappin's MountainWest RubyConf talk introduces Smalltalk to Ruby programmers. He compares the two languages' object models, blocks, 1-based arrays, simple syntax and live programming environment, and walks through sample code.

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.

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.

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.

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.

Misko Hevery's Clean Code Talk shows how to use object-oriented techniques such as polymorphism to remove repeated if and switch statements. The result is code that is easier to test, understand and maintain.

Douglas Crockford's code::dive 2022 talk on what the next programming language should look like. He presents ideas behind his Misty language, including message-passing actors.

Richard Feldman argues that functional programming is not the norm largely because of historical accidents, such as C++ popularity, platform exclusivity, marketing spend and network effects, rather than merit. He traces the history of how languages become mainstream.

Bret Victor's DBX 2013 talk, delivered in the guise of a 1973 IBM engineer with an overhead projector. It surveys forgotten ideas from 1960s and early 70s computing and warns against assuming you know what you're doing.

Felienne Hermans's Strange Loop keynote on the history and pedagogy of teaching programming. She questions exploration-only approaches like Logo and discusses research supporting explicit instruction and rote practice.

Timothy Daly, an original author of the Axiom computer algebra system, talks about turning a large Common Lisp codebase into a literate program. He argues code should be written as readable manuals, and the talk was given at Write the Docs 2013.

Aaron Hsu explains why programmers often find APL harder to learn than people with no programming background. He identifies eight patterns that contrast traditional software engineering practice with APL practice, starting from Ken Iverson's language design principles.

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.

Steven G. Johnson, MIT professor and FFTW co-author, gives a JuliaCon 2019 keynote on metaprogramming and staged programming in Julia, showing how it enables high-performance numerical code and when not to use macros.

Jim Weirich's RubyConf 2012 talk derives the Y combinator step by step, live-coding in Ruby lambdas. It builds up an understanding of functional programming and lambda calculus from first principles.

Evan Czaplicki, creator of Elm, examines how programming languages are funded. He looks at where compiler engineers' salaries come from, why Go has about 5 engineers while Dart has about 30, and how this limits language design.

Andrew Kelley, creator of Zig, introduces the language at the Recurse Center's Localhost series in 2018. He covers its goals of robustness, optimality and clarity, C interop, cross-compilation and explicit allocators.

Paul Chiusano's Strange Loop 2019 talk introduces Unison, an open-source functional language for distributed, elastic systems. It covers content-addressed code identified by hashes of the syntax tree, a codebase manager, and algebraic effects called abilities.

Aditya Siram introduces ATS, a statically typed ML-like language that compiles to C and offers type-safe pointer arithmetic and a full proof language. The Strange Loop talk shows off C interop, concurrency and verification features with non-trivial examples.

Jack Diederich's PyCon 2012 talk argues that classes are overused in Python and walks through real code, refactoring away unnecessary classes, exceptions and modules. It popularized the heuristic that a class with two methods, one being __init__, should be a function.

Sandi Metz's RailsConf 2013 talk offers practical guidelines for deciding what to test and how, so tests stay cheap and stable. She argues for testing the public interface rather than implementation and using mocks appropriately.

Stuart Sierra presents the Component library for Clojure, a way to manage stateful services like database connections and thread pools without global mutable state. He draws on both functional and object-oriented principles.

Jack Rusher's Strange Loop 2022 talk argues that most programming languages are still designed around punchcard-era assumptions. He makes the case for live, interactive programming environments, drawing on Lisp, Smalltalk and REPL-driven development.

Part 4 of John Carmack's QuakeCon 2013 keynote, covering OpenGL, functional programming, Haskell, Lisp and Scheme, typing, multithreading, events and garbage collection.

Shriram Krishnamurthi's PWLConf 2019 talk on the formal notion of expressive power of programming languages, based on Felleisen's paper. It explains how to tell when a feature adds power by whether emulating it requires global rewriting.

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.

Nada Amin's Strange Loop talk on programming languages that build on themselves, centered on towers of interpreters and nestable interpretation in Scheme. She shows how interpreters can be stacked and collapsed.

Dan Friedman and William Byrd demonstrate miniKanren, a logic programming system for Scheme, in an unconference talk. It includes generating programs by running relations in reverse.

Chris Granger presents Eve, a programming environment designed to be approachable for humans, at Strange Loop 2015. The talk covers the project's approach and design ideas.

Gerald Jay Sussman speaks at Dan Friedman's 60th birthday celebration about how programming helps formulate and clarify ideas. He argues that ambiguous mathematical notation hinders understanding.

Fons van der Plas introduces Pluto.jl, a reactive notebook for Julia that tracks references between cells and re-runs affected cells when code changes. The talk was given at JuliaCon 2020.

Rob Pike presents Go Proverbs at Gopherfest 2015, a set of pithy aphorisms about Go design such as 'Clear is better than clever' and 'A little copying is better than a little dependency'.

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.

Scott Wlaschin's NDC talk on using statically typed functional programming, F# in particular, to model a business domain. Types are used to represent the domain precisely and to encode business rules so that illegal states cannot be built, with the compiler acting as an instant unit test.

Stuart Halloway argues that simplicity is objective, with a definition and etymology useful to programmers, rather than a subjective buzzword. He shows how this view informs Clojure's design and how to make programs simpler.

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.

Bob Nystrom, author of Game Programming Patterns, gives a Roguelike Celebration 2018 talk questioning whether entity component systems are the only way to structure a game. He walks through alternative architectures drawn from roguelike development.