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.

Aaron Hsu discusses design patterns and anti-patterns in APL and why the language is productive despite its write-only reputation. He argues that idioms matter more than libraries in array languages.

Bryan Cantrill's talk on corporate open source anti-patterns, first given at FISL 2012 and again at the Liferay Symposium. He lays out the mistakes companies make when open sourcing code, such as announcing future open sourcing, and discusses licenses.

Mathematician Colin Wright demonstrates juggling and explains the mathematics of juggling patterns, including notation that led to new throwing patterns. It is a public presentation at the Museum of Mathematics aimed at a general audience.

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.

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.

A JSConf 2014 talk visually breaking down algorithms behind everyday UI patterns, such as dropdown menus that vanish when the mouse drifts and picking the nearest target to the cursor. It shows how these are implemented in JavaScript.

Douglas Crockford's Nordic.js 2014 talk on 'the better parts' of JavaScript and programming in general. He argues against `this`, `new` and ES6 classes, and for classless, composition-based object patterns, with some broader remarks on building better structures for the future.

Sebastian Markbage explains how React is moving toward a minimal API surface by leaning on language features and patterns instead of dedicated framework APIs. He also touches on JSX and syntax proposals for future JavaScript.

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.

Alan Kay's 2009 UIUC talk arguing that computing is more a pop culture than a science and that ignoring history and fundamentals leads to inferior solutions. He touches on the history of interactive environments and what the web should have been.

Java Language Architect Brian Goetz talks at a Clojure conference about the challenges of evolving a mature language like Java while preserving compatibility with existing code and developer expectations. It also gives a look at where the platform is headed.

Gary Bernhardt's RubyConf 2012 talk on testing in isolation without mocking everything. It goes through behavior versus data, mutation versus immutability, and how a functional core with an imperative shell yields natural isolation and parallelism.

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.

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.

A short animated simulation comparing how Multics and Unix were developed, showing why Unix's small composable programs and pipes gave it a efficiency advantage. It frames Unix as a moonshot achievable by a small team.

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.

Titus Winters' CppCon 2017 talk argues for C++ and Google's Abseil to be maintained as a live at head language, relying on testing and automated tooling rather than never changing or promising no compatibility. It covers Hyrum's law and the limits of semantic versioning.

Dirk Hohndel explains why the Subsurface dive log project migrated from Gtk to Qt, the obstacles encountered, and advice for other applications frustrated with Gtk. It is a linux.conf.au 2014 talk.

A short !!Con 2016 talk by blind developer Sina Bahram on how he uses a computer and writes code with a screen reader at about 1,000 words per minute. He plays how common interfaces sound and challenges the audience to go a day using only the keyboard.

Bret Victor's closing keynote at UIST and SPLASH 2014 argues that our tools for thinking ignore most of human sensory and motor capability. He sketches representations that engage more modalities beyond screens and keyboards.

Julia co-creator Stefan Karpinski explains why multiple dispatch makes Julia code and types reusable across packages with so little friction. He covers sharing basic types and sharing generic algorithms.

Joran Dirk Greef's Systems Distributed '23 talk on TigerStyle, the engineering methodology behind TigerBeetle. It covers designing safer systems in less time through up-front design, assertions, and deterministic simulation.

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

Pete Hunt of Facebook and Instagram presents React at JSConf.Asia 2013, explaining its design principles and why they seemed shocking at first. He argues that React separates concerns rather than technologies, and the talk also announces the React Chrome developer tools.

Rich Hickey's long presentation on Clojure and concurrency covers locking and immutability, then goes in depth on refs, transactions and agents. It ends with a multithreaded ant colony simulation demo.

Alan Kay speaks at the DEMO Founder School session on why real progress takes invention rather than incremental innovation. He argues for problem-oriented thinking and long-term research funding.

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.

Runar Bjarnason's Scala World talk argues that restraint and precision in components beat power and flexibility. Constraints on parts make them easier to compose into systems.

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.

Cheng Lou's react-europe 2016 talk lays out a mental framework for thinking about abstraction levels in JavaScript tooling, from Angular and Grunt to Webpack and React. It uses that framework to reason about the cost of abstractions and how to choose between competing solutions.

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.

James Mickens's 2015 Harvard colloquium argues that browsers are bloated and insecure because feature races trump clean interface design. He presents a cleaner, more secure browser architecture (Atlantis) with a much smaller API surface.

Jay Parlar's Strange Loop talk shows how model checkers such as Alloy can find complex bugs in a system's design without running or reading any code. He walks through modeling architectures and checking every possible sequence of operations, including a real security bug and a UI feature-interaction bug.

Elm creator Evan Czaplicki's talk on how a file grows and when to split code up. He argues for keeping code in one file until it hurts and warns against premature extraction.

David MacKay's 2007 Google Tech Talk presents Dasher, a text-entry system driven by continuous gestures and a language model, reaching about 35 words per minute with one finger and 25 hands-free. It explains the information-theory reasoning behind the design.

Scott Wlaschin shows how statically typed functional languages, using F# examples, can model a business domain so that invalid states cannot be represented. The type system acts almost like an instant unit test at compile time.

Ward Cunningham explains the history and intent of the debt metaphor, which he coined while refactoring the WyCash product. He says debt means code reflecting an incomplete understanding of the problem, not sloppy programming.