build system

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.

A Berkeley Lab Distinguished Lecturer talk on building science, with an expert covering control layers, insulation and vapour barrier placement, and how buildings fail. The delivery is humorous.

A 1990 lecture by James Gosling on NeWS, Sun's networked window system in which clients send PostScript programs to the server for execution. It covers the high-level imaging model and compares NeWS with similar systems.

The first lecture in Martin Kleppmann's 8-lecture distributed systems series from the University of Cambridge undergraduate course. It introduces the subject, and accompanying lecture notes are available.

The first lecture of Andy Pavlo's CMU 15-445 Intro to Database Systems (Fall 2019), covering course introduction and the relational model.

Y Combinator CEO Michael Seibel lectures at Startup School on building a product people want: identifying the problem, the customer, an MVP and which customers to pursue first.

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.

Robert Sapolsky's Stanford lecture on the limbic system as the emotional part of the nervous system, covering its role in decision making, links to the cortex and the functions of its subparts.

The opening lecture of MIT 6.824 Distributed Systems (Spring 2020), introducing the course and core challenges of distributed systems. It begins a playlist that goes on to cover Raft and other consensus papers in Go.

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.

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.

David Tong, a Cambridge theoretical physicist, explains at the Royal Institution that the fundamental building blocks of nature are quantum fields rather than particles. He covers what we know about these fields and how they fit into the Standard Model.

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.

Part 10 of Dan Gelbart's prototype-building lecture series, covering flexures: flexible joints that give precise, frictionless motion. It shows how a cheap piece of aluminum can become a nanometer-accurate mechanism.

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 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 Gilbert Strang's MIT 18.06 Linear Algebra course, covering the geometry of linear equations. It opens a full 35-lecture university course.

Anders Hejlsberg whiteboards how compilers are taught versus how modern ones are actually built. He explains the shift to compilers as services with incremental, error-tolerant, IDE-oriented design, as in Roslyn and TypeScript.

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.

John Ousterhout's slides-and-voiceover lecture on Paxos, made for the Raft user study comparing how students learn Raft and Paxos. It is a full introduction to the Paxos consensus algorithm.

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.

The opening lecture of Steve Brunton's Control Bootcamp, covering the kinds of control and why closed-loop feedback matters. It starts a series that follows the control chapter of the Brunton and Kutz data-driven science book.

John Ousterhout lectures on the Raft consensus algorithm, made for the Raft user study comparing how students learn Raft and Paxos. It covers leader election and log repair.

Zach Hartwig of MIT introduces the key concepts of magnetic fusion energy and the state of fusion research. He then presents MIT's proposed pathway of using high-field superconducting magnets to build smaller, cheaper tokamaks on a climate-relevant timescale.

Part 1 of a lecture by physicist Albert Bartlett on the exponential function and its consequences for population growth, resource use and energy. It argues that steady growth rates quickly lead to enormous quantities.

Richard Hamming's 1995 recording of his talk 'You and Your Research', drawn from his graduate engineering course. He discusses how great scientists pick important problems and build careers, drawing on his years at Bell Labs.

Microsoft's Brian Beckman gives an hour-long, whiteboard-style walk through monads, building from function composition and monoids using school-level math. It is aimed at practicing programmers rather than category theorists.

An RSA Animate drawn from a Sir Ken Robinson talk arguing that current education systems are modeled on the industrial age. It discusses divergent thinking, standardization, and how schools disengage kids.

The first of Richard Feynman's 1964 Cornell Messenger Lectures, The Character of Physical Law, focusing on the law of gravitation. Feynman builds up from planetary motion to the nature of physical laws.

Peter Thiel's lecture from the How to Start a Startup course on business strategy and monopoly theory, arguing that competition destroys profits and that startups should aim to build monopolies. It covers the ideas of Zero to One.

Neil Postman's 1997 lecture at College of DuPage, based on his book, argues that Americans treat technology as a national religion and depend on it to solve larger human problems. It includes audience questions.

Simon Peyton Jones gives Churchill College's annual computer science lecture on Haskell's birth and evolution. He covers the most influential ideas, from laziness to monads and type system evolution, plus current developments and guesses about the future.

The first lecture in an 18-part series on digital photography from Marc Levoy's Stanford CS 178 course, recorded at Google in 2016. The series covers how digital cameras work and computational photography, with slides and assignments available on the course site.

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.

A professor from Illinois compares the cost of building, fueling and operating a nuclear plant against a natural gas plant, using visual charts. It shows how construction time and interest rates dominate, when the investment pays off and when costs cross over.

The final lecture of Richard Hamming's Learning to Learn course, from 1995, based on his well-known talk 'You and Your Research'. It covers how to do important work and build a career.

The first lecture of Francis Su's Harvey Mudd real analysis course, covering the construction of the rational numbers. It begins a full lecture series that follows a standard analysis text.

An RSA Animate in which Steven Pinker explains how the mind builds infinite meanings from finite language, and why people often speak indirectly. It covers ambiguity, politeness and mutual knowledge, including the emperor's new clothes example.

The first lecture of Stanford's CS107 Programming Paradigms, taught by Jerry Cain, giving an overview of the course. The course goes from C and assembly through C++, concurrency, Scheme and Python.

Lecture 1 of Harvard's Statistics 110 with Joe Blitzstein, introducing sample spaces, the naive definition of probability, counting, binomial coefficients and the sampling table.