complexity

Physicist Geoffrey West speaks at an FQXi conference on time about complexity and scaling laws. He covers how metabolism, growth and lifespan scale across organisms and how the same mathematics applies to cities and companies.

A /noclip interview with Tarn Adams of Bay 12 Games about Dwarf Fortress: where the ASCII simulation came from, how it works, and the plans for its Steam release. It includes his telling of the famous bug in which cats were poisoned by alcohol.

Kyle Hill of Because Science explains and demonstrates, using real cards, how Magic: The Gathering can be used to build a Turing machine, a computer inside the card game.

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.

Meredith Patterson and Sergey Bratus argue that networked software stays insecure because protocols and inputs are too complex to recognize safely. They propose using formal language theory and grammars to build secure, verifiable input handling.

Philip Wadler's Strange Loop talk on Propositions as Types, the link between logic and computation (the Curry-Howard correspondence). He traces its history through Church, Godel and Turing and shows how it shaped theorem provers and programming languages.

Christopher Domas's Derbycon 2015 talk on the M/o/Vfuscator, a compiler that emits only x86 mov instructions, showing mov is Turing complete. It explains how a full machine is built from mov and why the output is a nightmare to reverse engineer.

Rich Hickey's keynote at RailsConf 2012, a close sibling of his 'Simple Made Easy' talk. He distinguishes simple (not intertwined) from easy (familiar), and argues that software complexity comes from complecting things, with Rails-specific examples including large gem collections.

Veritasium's explainer on Godel's incompleteness theorems and the limits of mathematical proof, tracing set theory, Hilbert's program and the road to Turing and modern computing.

Scott Meyers' keynote at DConf 2014, drawing on 25 years of C++ experience to offer the D language community a plea about what it should avoid. It centers on the accumulated complexity and pitfalls of C++ as a cautionary tale.

Tom Stuart's Ruby Manor 3 talk builds FizzBuzz using nothing but Ruby lambdas, working through Church encodings of numbers, booleans and data structures. It is a hands-on introduction to lambda calculus.

Tom Wildenhain's guest lecture for CMU's Esoteric Programming Languages course shows that PowerPoint transitions and slides are Turing complete without macros, building up to a mind-bending fractal ending.

Matt Might's Curry On talk on ending errors in code, both software and the human genome. He covers conservative approximation of the halting problem via static analysis and a computational approach to precision medicine.

2swap explores lambda calculus using John Tromp's lambda diagrams, with animated beta-reductions, asking what PLUS times PLUS gives. It touches on Church encodings and the equivalence of Turing machines and lambda calculus.

Alan Kay's 2015 talk on the power of simplicity, arguing that systems become simpler by building on more sophisticated fundamental building blocks and that big research horizons drove invention at Xerox PARC. It ranges across computing, tools and scaling software.

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.

Brian Will critiques object-oriented programming and rewrites a roughly 3800-line OO program in a procedural style, cutting code and complexity. It is part of a series of OOP critiques.

Yehuda Katz's Railsberry 2012 talk on why Rails is hard to learn and use. He explains that the framework's many features reflect real complexity in web applications that newcomers do not yet see.

Joe Armstrong, co-inventor of Erlang, gives a funny and opinionated Strange Loop talk on the tangled state of software: build tools, package managers, entropy and the physical limits of computation. He argues for ideas like naming things by content hash and throwing away your first version.

Ilya Sutskever gives a Simons Institute talk on why neural networks generalize, framing learning as finding short descriptions, like compression. It was part of the Large Language Models and Transformers program.

Armin Ronacher, creator of Flask, explains how CPython's internals and C API leak into the language's semantics. Using examples like the complexity of the add operation, he shows why Python is hard to optimize or reimplement.

Sam Stephenson's RailsConf 2016 talk on Turbolinks 5, showing how small teams can ship fast Rails apps in the browser and hybrid iOS and Android apps sharing one set of web views.

The first lecture in Bartosz Milewski's category theory series for programmers. It covers the motivation and philosophy behind category theory and why composition matters for handling complexity.

Rob Pike's dotGo 2015 talk argues that Go only seems simple, and that its simplicity hides real complexity that is part of the design. He explains the thinking behind Go's restraint in features.

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.

Dylan Beattie's conference talk explores the history and mess behind plain text: encodings, Unicode, line endings and the many ways text goes wrong. It argues that the tidy idea of plain text hides a lot of complexity underneath everyday software.

Louis Brandy presents the most common and infamous recurring C++ bugs seen in Facebook's huge codebase, including shared_ptr data races and operator[] pitfalls. He explains the surprising complexity behind seemingly simple code.

Super Eyepatch Wolf analyzes why The Simpsons declined after its golden age, pointing to changes in the writers' room and a shift in the style and complexity of its comedy.

John A. De Goes's Scalapeno keynote argues that Scala's popularity is declining because of compile times, complexity and compatibility problems. He proposes a path for Scala to survive, including a simplified functional subset.

Nicholas Zakas of Yahoo discusses architecture for large, modular JavaScript web applications. He lays out the theory behind building front ends that scale in complexity.

A 36C3 talk that systematically evaluates OpenBSD's exploit mitigations, asking how effective they really are and what they cost in performance, complexity and inspectability. It challenges the project's security marketing.

Sandy Munro sits down with engineers from 3IS to compare the electrical architectures of the Tesla Model Y, Ford Mach-E and VW ID.4. They discuss ECU counts, bus architectures and what the differences mean for cost and integration.

Adam Tornhill's GOTO Copenhagen 2019 talk on how to prioritize technical debt in large codebases. It argues for combining code complexity with change frequency (hotspots) from version control data, rather than trying to quantify debt in the abstract.

Nicolai Josuttis's CppCon 2018 talk walks through the many forms of initialization in C++, including uniform initialization, and how their rules and effects differ. He argues the situation is confusing enough that nobody can say what to teach beginners.

Rick Beato analyzes a pop song he argues is among the most harmonically complex ever, breaking down its chords and key changes. It is a music theory deep dive aimed at general music fans.