abstract algebra

The first chapter of 3Blue1Brown's Essence of Linear Algebra series, introducing vectors with animated geometric visuals. It begins a series that builds intuition for linear algebra from the basics.

A SIGGRAPH 2019 course on geometric algebra. Charles Gunn gives an intro, then Steven De Keninck gives a programmer-focused course with live examples in ganja.js.

A five-minute preview of 3Blue1Brown's Essence of Linear Algebra series, which uses animation to build geometric intuition for topics from a standard linear algebra course.

An animated introduction to geometric algebra, presented as a language that can describe most of physics. It was made with manim and covers multivectors and how they generalize familiar tools like cross products and quaternions.

Chandler Carruth argues in a CppCon 2019 talk that C++ has no truly zero-cost abstractions. Using examples like unique_ptr, ABI constraints and compile-time costs, he shows that abstractions cost runtime, compile time or human effort.

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.

A London Haskell talk on the algebra of algebraic data types, showing how sum and product types behave like arithmetic. It frames types as numbers obeying algebraic laws.

3Blue1Brown introduces group theory and abstract groups, then builds toward classification of finite simple groups and the enormous Monster group with its 196,883 dimensions.

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.

3Blue1Brown's chapter on eigenvectors and eigenvalues in the Essence of Linear Algebra series. It builds a visual intuition for what they mean, why an eigenbasis is useful, and ends with a puzzle.

Freya Holmer's Dutch Game Day 2023 talk asking why vectors can't be multiplied, building from complex numbers to a single axiom and arriving at geometric algebra, quaternions and multivectors.

Dan Abramov's talk on the wet codebase, using visualizations to show how removing all duplication too early produces wrong abstractions that are hard to unwind.

A 10-minute 3Blue1Brown chapter explaining the determinant as the factor by which a linear transformation scales area or volume. It builds the idea geometrically with animations before any formulas.

A very short clip of Carl Sagan saying that to make an apple pie from scratch you must first invent the universe. It illustrates how everything depends on a chain of prior things.

Sandi Metz takes an ugly section of conditional code and refactors it into a few simple objects, bridging object-oriented theory and practice. The talk includes her take on the Gilded Rose refactoring kata and the idea that duplication is cheaper than the wrong abstraction.

An 88-minute Microsoft Research talk that explains how quantum computers beat classical ones using basic linear algebra, qubits, superposition and gates. It works through the Deutsch oracle problem and ends with entanglement, teleportation and a live demo.

Redis Labs and Tim Davis present RedisGraph, which uses GraphBLAS to treat graph queries in Cypher as sparse linear algebra for lower latency.

Eugenia Cheng gives the opening keynote at Lambda World 2017, presenting category theory as very abstract algebra whose abstraction gives it broad applicability. She applies it to everyday questions including privilege and prejudice.

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.

Jonathan Blow's DevGAMM 2019 talk argues that software knowledge is being lost between generations and that growing layers of abstraction could lead to a decline in technological civilization.

Paul Chiusano's Strange Loop 2019 talk introduces Unison, an open-source functional language for distributed, elastic systems. It covers content-addressed code identified by hashes of the syntax tree, a codebase manager, and algebraic effects called abilities.

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.

Jiahao Chen's JuliaCon 2017 talk argues that vector transposes should be taken seriously in type systems and linear algebra libraries. It explains why treating vectors as matrices causes trouble in languages.

The first video in a 55-part series by Michel van Biezen that introduces the Kalman filter and builds from the rationale through algebraic examples to the full matrix treatment. The videos are short, blackboard-style lectures.

Steven Wittens' JSConf US 2013 talk on drawing with WebGL, using animated visuals to walk through vectors, matrices and the rendering pipeline. Despite the title, it works as a visual primer on the linear algebra behind 3D graphics.

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.

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.

Veritasium tells the history of how imaginary numbers arose from the quest for a general solution to the cubic equation, including the duels and secrecy among Renaissance mathematicians. It argues math had to give up the requirement that it mirror reality.

Sandi Metz argues that hidden assumptions in code are missing concepts, and shows how to name and expose them so code is easier to understand and change. It covers null objects and messages in Ruby.

Moral philosopher James Flynn explains the Flynn effect, the steady rise of IQ scores across the 20th century. He argues the shift reflects a move toward abstract, hypothetical thinking as cognitively demanding professions grew.

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.

Colin Smith introduces Structure and Interpretation of Classical Mechanics and his Clojure port, sicmutils. He shows how higher-order functions and a symbolic algebra system can represent Lagrangian mechanics.

A two-hour Computer History Museum oral history interview with Bjarne Stroustrup, conducted by Paul McJones in 2015. It covers his youth, education at Aarhus and Cambridge, his career at Bell Labs and elsewhere, and the design and evolution of C++.

John Ousterhout, Stanford professor and creator of Tcl, presents the ideas of his book A Philosophy of Software Design in a Talks at Google session. He covers managing complexity, deep modules and interfaces, and what he teaches in his Stanford software design course.

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.

Rich Hickey's Strange Loop 2011 keynote separates 'simple' (not intertwined) from 'easy' (familiar or near at hand) and argues that software complexity comes from complecting things. It offers a vocabulary for judging designs and abstractions.

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.

Without Boats, a Rust language team member, explains the design of Rust's async/await at RustLatam 2019. He covers the history and constraints behind zero-cost, allocation-free async state machines.

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.

Tef's EMF 2012 talk on lessons from a career in programming, a candid and humorous look at why programming is so often terrible. Slides and a draft script are available online.