code structure

The first lesson of Uncle Bob (Robert C. Martin)'s "Coding Better World Together" series. It makes the case for clean code and for treating software craftsmanship as an ethical and professional responsibility. It runs about 109 minutes.

Erik Demaine's MIT 6.851 Advanced Data Structures lecture introducing succinct data structures, covering rank, select and tries. It is part of the Spring 2012 course.

Casey Muratori's invited lecture on where bad code comes from, rebroadcast from a Twitch stream. He critiques conventional wisdom such as SOLID and Clean Code and argues about how those habits lead to slow, poorly structured software.

The first lecture of MIT's 1986 6.001 Structure and Interpretation of Computer Programs, given by Harold Abelson, introducing Lisp and the idea of computer science as the study of process.

Casey Muratori's University of Twente guest lecture is a case study in how straightforward code can cut thousands of lines and tens of seconds of runtime down to a few dozen lines running in under a second. It uses concrete examples to show why software is often an order of magnitude slower than it should be.

Irving Finkel of the British Museum lectures at the Royal Institution on the invention and decipherment of cuneiform writing in Mesopotamia, and why it is so hard to translate.

Lecture 1B of MIT's 6.001 Structure and Interpretation of Computer Programs (1986) with Gerald Sussman, covering procedures, processes and the substitution model. It includes the line about the power of naming things.

Kurt Vonnegut's 2004 Case College lecture, with Spanish subtitles, in which he sketches the shapes of stories on a blackboard. He plots story arcs as good and bad fortune against time.

A short lecture in which Kurt Vonnegut graphs the simple shapes of stories, such as Man in Hole and Boy Gets Girl. He sketches how fortune rises and falls over a narrative.

Andrej Karpathy builds the GPT tokenizer from scratch, implementing byte pair encoding along with encode and decode. He shows how many odd LLM behaviors trace back to tokenization, and covers Unicode byte encodings along the way.

Chris Shore of the Centre for Computing History explains how Colossus was built, how it worked, and how it affected the course of World War II. It is an hour-long museum lecture on the codebreaking computer.

Milton Friedman explains why the US tax code is enormously complex and why meaningful reform is unlikely. He argues that politicians profit from the complexity, since tax breaks are products they sell and the code works as a tool of reward and punishment. The clip is about 14 minutes from his lecture series.

Dr. Jason Fung lectures on why obesity became an epidemic since the 1970s, arguing insulin and hormones rather than calories drive weight gain. He explains why calorie counting fails and touches on low-carb eating and fasting.

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.

A guest lecture Jon Gjengset gave at Two Sigma on using Rust for large, high-performance systems. It covers why Rust suits such projects, the Noria research database, a concurrent data structure used in it, and practical experience.

Lecture 7A of the 1986 MIT 6.001 SICP course, with Gerald Sussman presenting the metacircular evaluator, part 1. It shows how a Lisp evaluator can be written in Lisp itself.

Andrej Karpathy's first Neural Networks: Zero to Hero lecture, which builds micrograd, a tiny autograd engine, from scratch in Python. It explains backpropagation and neural network training step by step, assuming only basic Python and some high-school calculus.

Douglas Crockford's first Yahoo lecture puts JavaScript in historical context. He traces the language's structure and quirks back through the early decades of computer science and programming language history.

Casey Muratori's lecture, originally given at the Technical University of Madrid, arguing that Conway's Law is the only viable candidate for a true law of software architecture. He explains how software mimics the organization over time, using examples like Windows' multiple volume controls.

A lecture from MIT's Missing Semester course covering version control with git. It builds up git from its data model rather than from commands.

The first lecture of Jordan Peterson's 2017 Maps of Meaning course, setting out the Cold War context for his theory of belief and culture. He introduces the narrative structure of culture and archetypal characters for the individual, the known and the unknown.

Leo Dirac explains how transformer models have replaced LSTMs in NLP. He gives background from bag of words through RNNs and LSTMs, then a technical deep dive into multi-headed self-attention and positional encoding, with sample code.

Jeff Dean of Google describes his experiences building Google's systems and how its infrastructure evolved over time. The Stanford talk covers search, scaling tipping points and lessons from building large-scale software.

Erik Demaine's MIT 6.006 lecture introducing dynamic programming through Fibonacci numbers and shortest paths. It covers memoization, subproblems and optimal substructure.

Ian Piumarta's 2007 Stanford EE380 lecture on building a dynamic programming environment from the ground up, from the Viewpoints Research Institute's work. It covers the design of a language and system with a recursive design, parsing through code generation, and the COLA architecture.

A recording of Andres Duany's 1991 'San Antonio By Design' seminar on suburban sprawl. He lays out how codes, zoning and policy produce sprawl and makes the case for new urbanism.

Philosopher Jeffrey Kaplan summarizes Peter Singer's 1972 essay 'Famine, Affluence, and Morality', arguing that failing to give to save lives is morally comparable to letting a child drown. It is a short lecture on the argument's structure.

First lecture of Stanford's CS106A Programming Methodology by Mehran Sahami, giving a course overview and starting on programming. The course teaches software engineering principles using Java.

The final part of Dan Gelbart's 18-part Building Prototypes series, focused on mechanical design. It opens with a demonstration of stiffness and covers practical design principles for prototype machines.

A long Mill Computing lecture on the Mill CPU's compiler toolchain, covering the specializer that targets family members, scheduling and latency passes, and the belt. It explains how the compiler handles a wide-issue, exposed-pipeline design.