logic programming

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.

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.

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.

Gabriel Lebec's Fullstack Academy talk introduces lambda calculus syntax, the history of mathematical logic, and the essence of functional programming using JavaScript. It also covers combinators, currying and Church encodings.

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

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.

Chris Granger, creator of Light Table and the Eve language, gives a Berkeley data science lecture on what computation and programming might look like in ten years. He covers the path that led to Eve and ends with demos.

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 1983 Los Angeles lecture by KGB defector Yuri Bezmenov on how the Soviets carried out ideological subversion of target societies through propaganda. He walks through demoralization and normalization stages.

A long recorded seminar in which Alan Kay discusses object-oriented programming, probably from the mid-1980s. He covers the original idea of objects, messaging and the work done at Xerox.

Robert Sapolsky's Stanford lecture on the biological underpinnings of religiosity, from his human behavioral biology course. It covers theories linking religion to stress, and schizotypal traits.

Yaron Minsky of Jane Street gave this talk to Harvard's OCaml-based CS51 class in 2010. It collects advice on being an effective ML programmer in an industrial setting.

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.

Lawrence Krauss's 2009 talk on the current picture of the universe, how it will end and how it could have come from nothing. It covers the expanding universe, cosmic background radiation and the cosmological constant.

Casey Muratori's 2005 video introducing immediate-mode GUIs as an alternative to retained widget toolkits. He explains the motivation and shows minimal-state button logic.

An eight-minute excerpt of a 1983 video featuring Seymour Papert, creator of Logo, on children learning programming and abstract ideas through embodied play. It shows kids acting out the Logo turtle.

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.

Andrej Bauer's IAS talk introduces constructive mathematics and what it feels like to do mathematics without excluded middle. It is framed as a tour for classical mathematicians.

The first lecture of MIT's 6.001 (SICP) with Abelson and Sussman, giving an overview of the course and an introduction to Lisp. It argues that computer science is about managing complexity and abstraction, not computers.

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.

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.

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.

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.

Vladimir Voevodsky's IAS lecture starts from Godel's second incompleteness theorem to explore whether first-order arithmetic could be inconsistent. It motivates his vision of univalent foundations and computer-checked proofs.

Brian Kernighan gives a talk at the University of Nottingham on how to succeed in language design without really trying. He draws on his experience with awk and other languages.

Dan Britt lectures on the history of climate, covering orbital cycles, ice ages and conditions millions of years ago. It frames current climate debate with deep-time context.

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.

An excerpt from Hal Abelson's opening SICP lecture introducing computer science and contrasting declarative and imperative knowledge. He argues that computer science is not really a science and is more like magic or engineering of ideas.

Stanford professor Robert Sapolsky lectures on depression as a real biological disease. He covers its biological and psychological causes, how it differs from ordinary sadness, and ideas such as learned helplessness. He ties these together into one account.

Dr. Russell Barkley gives a nearly three-hour lecture of essential ideas about ADHD for parents, covering what ADHD is, its effects on executive function, motivation and emotion, and how it affects children.

A lecture by Richard Feynman on how computers work, using the analogy of a filing clerk that becomes progressively dumber and faster. It also covers heuristics and how computers handle data and solve problems in finite time.

Robert Sapolsky's lecture on how the body's stress response, evolved for short-term physical emergencies, harms long-term health when triggered by psychological stressors. It was given as the inaugural Fenton-Rhodes Lecture.

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.

Jordan Peterson's first lecture in his Biblical Series examines the idea of God as sovereignty and power abstracted from any individual ruler, and as the pattern inherent in human dominance hierarchies.

A 73-minute Stanford talk by Robert Sapolsky drawn from his book Behave. It surveys the biological factors behind human behavior at its best and worst.

Geoffrey Hinton's 2025 Royal Institution Discourse on what AI has learned from biological intelligence and how it might surpass it. He explains neural networks and argues that human language use resembles what backpropagation-trained networks do.

The opening lecture of Jordan Peterson's 2017 University of Toronto personality course. He defines personality from historical, constructivist, psychoanalytic, behavioral and neuropsychological angles.

The introductory lecture of Stephen Boyd's Stanford Convex Optimization I course (EE 364A). It outlines convex sets, functions and problems, and the course's coverage of least-squares, linear and semidefinite programming, duality and interior-point methods.

Douglas Hofstadter lectures at Uppsala University on how analogy and daring thinking drove Einstein's discovery of light quanta. He argues deep insight in physics comes from imaginative leaps rather than rigid logic.

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.