Bookmarks
The most important talk on programming by Jonathan Blow
Jonathan Blow critiques modern software practices and argues for simpler, more efficient programming models, discussing language and tooling design principles that could redefine future development.
Procedural Generation using Constraint Satisfaction
Demonstrates applying constraint satisfaction algorithms to procedural content generation, detailing algorithmic concepts and code examples for maps, plants, and textures.
Advanced C: The UB and optimizations that trick good programmers.
Explores how undefined behavior in C enables aggressive compiler optimizations, illustrating subtle performance-related bugs and best practices for writing safe, fast code.
APL vs BQN vs Uiua
Walk-through comparing array-oriented languages APL, BQN and Uiua by re-implementing and refactoring the standard-deviation algorithm, highlighting language semantics, combinators and idiomatic coding patterns.
Exploring Verse, Haskell, Language Design and Teaching (with Simon Peyton Jones)
Simon Peyton Jones discusses small-core language design in Haskell and the new Verse language, delving into functional-logic programming concepts and their educational implications.
Jonathan Blow on the Design of Jai
Jonathan Blow outlines the design philosophy, type system, and compilation goals of his Jai programming language, offering insights into modern language design trade-offs.
Jonathan Blow - The Gauntlet
Jonathan Blow’s talk “The Gauntlet” critiques contemporary software practices and outlines design principles and language-level features (drawn from his Jai work) aimed at more robust, maintainable systems.
A* Search: How Your Map Applications Find Shortest Routes
A guided derivation and proof-oriented explanation of A* search and related path-finding algorithms used in mapping applications, emphasizing optimality and heuristic design.
Understanding Compiler Optimization - Chandler Carruth - Opening Keynote Meeting C++ 2015
Chandler Carruth explains how modern C++ compilers perform optimization passes, inlining, and code generation, helping developers write code that the optimizer can better transform into efficient machine instructions.
Stephen Wolfram - Where the Computational Paradigm Leads (in Physics, Tech, AI, Biology, Math, ...)
Stephen Wolfram’s keynote explores the broad “computational paradigm” as a unifying lens across physics, technology, AI, biology and mathematics—an ideas-driven talk without focused technical implementation details.
484 - All About Dat Compiler + Some Chill Browsing (TempleOS | Livestream) [2016]
Terry A. Davis live-codes and explains portions of the TempleOS compiler and associated OS internals, providing firsthand systems-programming insight into a home-built operating system and its compilation pipeline.
What Is an Interactive Theorem Prover? | Kevin Buzzard
Live demonstration of the Lean interactive theorem prover, showing how formal logic rules are encoded, manipulated, and verified, and discussing its role in mathematical research and future software tooling.
What P vs NP is actually about
Explains the P vs NP problem by reducing arbitrary algorithms to SAT circuits, illustrating NP-completeness, reversibility, and implications for cryptography.
Understanding B-Trees: The Data Structure Behind Modern Databases
Clear, in-depth explanation of B-trees, a fundamental data structure used in databases and file systems.
"Boundaries of Language Design" with Andrew Kelley & Ginger Bill
In-depth discussion with two language designers on compiler construction and programming-language paradigms—relevant, expert-level content.
Halting Problem & Quantum Entanglement 2020 Breakthrough result [MIP*=RE]
Clear technical explanation of the groundbreaking MIP*=RE complexity-theory result—valuable foundational content for theoretical computer scientists.
Writing a Compiler and Interpreter in Rust - Part 1
Step-by-step series on writing a compiler and interpreter in Rust is a valuable, in-depth educational resource on compiler construction.
Rope Datastructure
Technical presentation of the rope data structure with code overview, useful for efficient string manipulation knowledge.
Building A Programming Language From Its Core (with Peter Saxton)
In-depth discussion on designing a programming language around its AST, covering type systems, effects, and implementation details—valuable for language and compiler enthusiasts.
Dynamic Programming isn't too hard. You just don't know what it is.
Explains the algorithmic technique of dynamic programming and is relevant for software engineers preparing for technical interviews or improving algorithmic skills.
C++26 Preview - Jeffrey Garland - C++Now 2024
Conference talk previewing upcoming C++26 language features—directly relevant technical content for software engineers.
CppCon 2018: Jonathan Boccara “105 STL Algorithms in Less Than an Hour”
CppCon lecture systematically covering all 105 STL algorithms, a high-value educational resource for C++ developers.
C3 with Christoffer Lerno -- His career and how he brought us the C3 language -- Conversation #6
Long-form technical interview with the creator of the C3 programming language covering language design and the speaker’s engineering career.
A Crash Course in Category Theory - Bartosz Milewski
Bartosz Milewski provides an intensive introduction to category theory with programming examples, fitting both educational and theoretical criteria.
Category Theory, The essence of interface-based design - Erik Meijer
Conference-style talk by Erik Meijer connecting category theory to interface-based design and Java 8 lambdas; valuable for programmers interested in theoretical underpinnings.
"Categories for the Working Hacker" by Philip Wadler
Philip Wadler’s lecture introduces category theory concepts for programmers, bridging mathematics and software development.
Type Theory for the Working Rustacean - Dan Pittman
Technical presentation linking Rust’s type system with type theory and proof techniques, valuable for language theorists and systems programmers.
A Type System From Scratch – Robert Widmann
Technical presentation on building a type system from scratch, relevant to language and compiler enthusiasts.
Category Theory for the Working Hacker by Philip Wadler
Conference talk by Philip Wadler connecting category theory to programming; foundational material for programmers interested in type theory.
Nicholas Matsakis (Co-Lead, Rust Design Team): "Rust Roadmap 2.0” | KEYNOTE | RustConf 2024
Keynote outlining the technical and organizational roadmap of the Rust language—important insight for systems programmers and language researchers.
Jonathan Blow on his programming language jai!
Long-form discussion with Jonathan Blow focused on the design and status of the Jai programming language—valuable insight into language design and game-engine tooling.
I can prove I’ve solved this Sudoku without revealing it
Clear, well-structured explanation of zero-knowledge proofs with examples—solid educational cryptography content.
The Past, Present & Future of Programming Languages • Kevlin Henney • GOTO 2024
Conference talk that surveys historical and emerging trends in programming languages, providing contextual and educational value for software engineers.
A Flock of Functions: Lambda Calculus and Combinatory Logic in JavaScript | Gabriel Lebec @ DevTalks
Donald Knuth: Algorithms, Complexity, and The Art of Computer Programming | Lex Fridman Podcast #62
Donald Knuth reflects on algorithmic analysis, computational complexity, and insights from The Art of Computer Programming.
Quantum Computing for Computer Scientists
Introduces the quantum computing model to computer scientists, deriving qubits, gates, and Deutsch’s algorithm using linear-algebra formalisms.
How AI Discovered a Faster Matrix Multiplication Algorithm
Explains how DeepMind’s AlphaTensor discovered record-breaking tensor-decomposition algorithms that speed up matrix multiplication.
The hidden beauty of the A* algorithm
Demonstrates how consistent heuristics transform Dijkstra into the A* algorithm, with proofs, implementation tips, and geographic path-finding demos.
Is this the Future of Programming Languages?
Long-form hacking session explores building a toy language front-end targeting the QBE backend, illustrating SSA IR, parsing, and register allocation.