Bookmarks
Keynote: Linus Torvalds, Creator of Linux & Git, in Conversation with Dirk Hohndel
Fireside keynote with Linus Torvalds covering the evolution of the Linux kernel, open-source development practices, and future directions of operating-system engineering.
Hacking Raylib
Live-coding session in C that modifies and debugs Raylib to extend the Musializer project, covering real-time rendering techniques, event handling, and practical graphics-oriented engineering workflows.
3D in TypeScript using Ray Casting
Walk-through of implementing a classic ray-casting engine in TypeScript, rendering a 3D maze in the browser while explaining projection math and performance considerations.
03 CUDA Fundamental Optimization Part 1
Detailed lecture on foundational CUDA performance techniques—memory coalescing, occupancy, and kernel launch parameters—illustrated through hands-on code profiling and optimization steps.
Who needs malloc anyways?
Live-coded session that implements a bump allocator from scratch, demonstrates eliminating dynamic malloc calls during module initialization, and refactors dependent modules to use the custom allocator.
zig on the client, wasm on the server, what am i doing
Live-coding session that compiles a Zig simulation to WebAssembly, deploys it server-side and hooks it to a browser client, demonstrating build flags, WASM bindings and debugging workflow.
ARM Assembly: Lesson 1 (MOV, Exit Syscall)
Step-by-step lesson introducing ARM assembly programming—registers, MOV instruction, SWI syscall, compiling, and emulation—providing foundational skills for low-level ARM development.
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.
Zig Roadmap 2023 - Andrew Kelley
Andrew Kelley outlines the 2023 roadmap for the Zig programming language, detailing planned language features, compiler back-end work, tooling, and data-oriented design goals for systems-level development.
Elite: "The game that couldn't be written"
Deep dive into the 8-bit game Elite, showing how procedural generation, split-screen 3D, back-face culling and tight 6502 assembly fit a full universe into 22 KB, highlighting graphics techniques and extreme optimization on limited hardware.
How a Clever 1960s Memory Trick Changed Computing
Historical and technical tour of virtual memory—paging, MMUs and TLBs—from the Atlas supercomputer to modern x86/ARM/RISC-V, detailing how hardware and OS cooperate to enable multitasking and locality-driven performance.
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.
DragonflyDB Architecture Overview, Internals, and Trade-offs - hitting 6.43 million ops/sec
Technical deep dive into DragonflyDB’s architecture, concurrency model, memory layout, and trade-offs that enable >6 M ops/sec in a Redis-compatible distributed datastore.
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.
CRAFTING A CPU TO RUN PROGRAMS
Step-by-step project that assembles fundamental digital components into a functioning minimalist CPU, explaining instruction decoding, control signals and integration of prior ALU and memory modules.
Failure & Change: Principles of Reliable Systems • Mark Hibberd • YOW! 2018
Conference talk distilling principles and practices for designing, operating and evolving large-scale, failure-tolerant software systems, with emphasis on complexity, change management and reliability patterns.
Rendering and texturing a rotating rectangle in software
Live coding session that builds a WebAssembly software renderer from scratch, adding stb_image loading, alpha blending and rotation logic to texture-map a rectangle while profiling code size.
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.
Proficient Parallel Programming - King Butcher - Software You Can Love VC 2023
Practical talk on parallel programming that outlines why naïve multithreading can degrade performance and details debugging techniques, cache effects, and CPU utilization strategies for writing efficient concurrent code.
Casey Muratori | Smart-Pointers, RAII, ZII? Becoming an N+2 programmer
Casey Muratori analyzes smart-pointers, RAII, Rust’s borrow checker, and zero-initialization, advocating alternative memory-handling and error-handling patterns that foster clearer program design and mental models.
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.
Improving Learn OpenGL's Text Rendering Example | Adventures in Coding
Walk-through of refactoring LearnOpenGL’s font-rendering sample—profiling GPU/CPU bottlenecks, redesigning glyph batching, and achieving a 10× frame-rate improvement.
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.
Simple Code, High Performance
A case study demonstrating how refactoring large, complex codebases into simpler designs can yield order-of-magnitude speedups, with detailed profiling and optimization techniques.
Zig in Production - Jens Goldberg
A practitioner talk on adopting the Zig programming language in real-world production environments, covering build system details, tooling, deployment lessons, and low-level systems considerations.
Refterm Lecture Part 5 - Parsing with SIMD
Technical lecture showing how to accelerate text parsing by leveraging SIMD instructions, delving into low-level CPU mechanics, data alignment, and practical code optimization strategies.
Data Oriented Programming in Java 21 by Nicolai Parlog
Conference talk introducing data-oriented programming in Java 21, outlining its four core principles and showing how records, sealed classes, and pattern matching enable immutable, validated, and ad-hoc polymorphic data modeling compared to traditional OOP.
Visualizing memory layout of Rust's data types
A detailed tutorial that walks through binary loading, stack and heap operation, and the exact in-memory layout of Rust primitives, structs, enums, and smart pointers—illustrating how the Rust compiler represents and optimizes each data type.
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.
CppCon 2016: Timur Doumler “Want fast C++? Know your hardware!"
CppCon talk illustrating how cache hierarchies, branch prediction, alignment, and SIMD influence C++ performance and providing guidelines for writing hardware-conscious, high-speed code.
Simple Artificial Neural Network entirely in assembly language
Demonstrates building and training a single-layer neural network entirely in x86-64 assembly language, covering forward pass, MSE loss, back-propagation, and low-level numeric routines.
Casey Muratori on his work experience
A wide-ranging interview with Casey Muratori focusing on lessons learned from decades of writing highly optimized code and cultivating a performance-aware programming mindset.
C++ cache locality and branch predictability
Practical C++ demonstration of how cache locality and branch prediction affect real-world runtime, showcasing code patterns and optimizations to exploit modern CPU behaviour for faster programs.
Day 26 of Building An Operating System | Programming every day day 100
Daily livestream coding session that incrementally implements core kernel functionality—memory management, drivers, and boot code—while explaining practical OS development techniques from scratch.
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.
Episode 048: Why TigerBeetle Is So Slow, With Tobi!
A live coding / debugging session with the TigerBeetle team that digs into tracing, measurement and architectural choices to diagnose the latency bottlenecks inside their distributed financial-ledger database.
Jacob Pratt: "Compiler-Driven Development: Making Rust Work for You" | RustConf 2024
RustConf 2024 talk demonstrating how developers can leverage Rust’s compiler diagnostics, type system, and tooling to iteratively write correct, idiomatic code—serving as a practical tutorial in compiler-driven development.
The Tech Poutine #23: AMD's Moving to 2nm
Long-form industry analysis show covering semiconductor manufacturing roadmaps, AMD’s 2 nm “Venice” chiplets, yield calculations, HBM4, CHIPS Act developments, and organizational changes at Intel and Nvidia—providing practitioners with deep context on cutting-edge processor and foundry hardware.
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.
Why GPU Programming Is Chaotic
Walk-through of why GPU programming lacks the portability and toolchain simplicity enjoyed by CPUs, covering driver fragmentation, vendor-specific shading languages, compiler issues, market forces, and how regulations could move the ecosystem toward more standardized graphics APIs.
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.
04 CUDA Fundamental Optimization Part 2
Lecture on CUDA fundamental optimizations provides specialized technical guidance for high-performance GPU computing.
Making Systems Programming Accessible by Andrew Kelley
Conference keynote by Zig creator Andrew Kelley on lowering barriers to systems programming is directly relevant to professional development in low-level software.
Jonathan Blow on how an operating system should work
Discussion clip where Jonathan Blow outlines principles for operating-system design offers conceptual insights relevant to systems programmers.
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.
Migrating from Zig to Jai
Live-coding session showing how to port code from Zig to the experimental Jai language provides practical insight into systems-level programming and language design.
Rope Datastructure
Technical presentation of the rope data structure with code overview, useful for efficient string manipulation knowledge.
HOW TRANSISTORS REMEMBER DATA
Clear explanation of how memory storage works at the transistor level, valuable for understanding computer architecture fundamentals.
WTF is Build.Zig? by Ed Yu
Technical presentation explaining Zig’s build system (build.zig) to C++ engineers; practical content for build and tooling specialists.
Zig 0.13.0 - Overview and Updates
Provides a detailed walkthrough of the Zig 0.13 release notes, covering compiler, std-lib and build-system changes—useful for programmers using or evaluating Zig.
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.
Enter The Arena: Simplifying Memory Management (2023)
In-depth talk on arena allocators and lifetime management, offering practical memory-management strategies for systems programmers.
CppCon 2018: Stoyan Nikolov “OOP Is Dead, Long Live Data-oriented Design”
CppCon lecture presenting data-oriented design versus OOP with concrete performance case studies—highly relevant to C++ practitioners.
Know your Java? by Venkat Subramaniam
Conference talk by a well-known expert examining lesser-known Java behaviors and pitfalls—valuable for practicing developers.
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.
Tony Hawk's Pro Strcpy
Explains a remote-code-execution exploit and provides source code, offering valuable security and reverse-engineering insights.
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.
Linking can be fast (if you cheat): Roc's Surgical Linker - Brendan Hansknecht
Conference talk detailing a novel fast linking approach for the Roc language, directly relevant to compilers/linkers and build performance.
CppCon 2017: Carl Cook “When a Microsecond Is an Eternity: High Performance Trading Systems in C++”
CppCon conference talk delivering in-depth techniques for ultra-low-latency C++ systems, directly relevant to performance-critical software engineering.
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.
Expert Talk: Zig Programming Language & Linters • Andrew Kelley & Jeroen Engels • GOTO 2022
Interview with the Zig language creator discussing compiler-integrated linting and tooling—practical insights for language and tooling enthusiasts.
"Categories for the Working Hacker" by Philip Wadler
Philip Wadler’s lecture introduces category theory concepts for programmers, bridging mathematics and software development.
CppCon 2018: Alan Talbot “Moving Faster: Everyday efficiency in modern C++”
CppCon talk focused on everyday performance techniques in modern C++, directly useful for software engineers concerned with optimization.
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.
Dylan Patel - Inference Math, Simulation, and AI Megaclusters - Stanford CS 229S - Autumn 2024
Stanford CS 229S lecture on large-scale inference math and AI megaclusters—direct, advanced technical content useful to ML researchers and engineers.
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.
You Don't Know Network Programming
Although recorded as a live Twitch stream, it is a hands-on coding session on low-level TCP/network programming with references to code and technical articles, providing educational value.
Building a UI Framework with Ty Overby
Conversation with an engineer about designing a functional UI framework in OCaml, covering architecture decisions and related tooling—fits technical-educational scope.
January 2025 Q&A
Extended Q&A by a respected Rust educator covering numerous technical questions, development practices, and career advice—useful educational resource.
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.
BLAZINGLY FAST C++ Optimizations
Focuses on techniques for high-performance C++ code, aligning with software optimization and best practices.
Code walkthrough of my game written in x64 assembly
Detailed code walk-through of a game engine in x64 assembly provides valuable low-level programming insight.
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.
Fujitsu’s New ARM Chip: Focused, Fast, and Unlike Anything Else
Concise technical analysis of a forthcoming ARMv9 CPU, covering micro-architectural features, packaging, and compiler strategy—highly relevant to computer-architecture enthusiasts.
How the heck do you make a PCB?
Despite the informal Twitch-stream format, the content is a hands-on walkthrough of PCB design/fabrication, a valuable technical skill for hardware/embedded engineers.
Nix explained from the ground up
Comprehensive tutorial explaining Nix package manager, deterministic builds, and related tooling, valuable for devops and reproducible development.
Declarative C++ - Ankur Satle - C++Online 2025
Conference talk presenting advanced C++ design techniques for declarative programming, directly relevant to professional software development.
FPGA in HFT Systems Explained | Why Reconfigurable Hardware Beats CPUs
Clear technical explanation of FPGA architecture and its use in low-latency HFT systems, fitting the hardware and systems design focus.
Dennis Gustafsson – Parallelizing the physics solver – BSC 2025
Conference talk detailing techniques for parallelizing a physics solver; highly relevant to concurrency and performance optimization in software engineering.
A Flock of Functions: Lambda Calculus and Combinatory Logic in JavaScript | Gabriel Lebec @ DevTalks
How Unicode Characters Become Glyphs on Your Screen
Walk-through of the full text-rendering pipeline, showing how Unicode code points are mapped by shaping engines and font tables into the glyph bitmaps that appear on screen.
Guido van Rossum: Python and the Future of Programming | Lex Fridman Podcast #341
Guido van Rossum discusses CPython internals, the GIL, type-hinting, and forthcoming language and performance changes shaping Python’s future.
AWS re:Invent 2022 - Building next-gen applications with event-driven architectures (API311-R)
AWS chalk-talk on designing microservice systems with event-driven architectures and cloud messaging to decouple and scale enterprise workloads.
The World's First Microprocessor: F-14 Central Air Data Computer
Historical deep-dive into the MP944 F-14 Central Air Data Computer and its claim as the first microprocessor, including architecture and programming model.
How do hardware timers work?
Explains how CPUs implement hardware timers, covering divider chains, counter registers, interrupts, and their use in precise timing control.
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.
Watch kernel developer do Linux kernel development ;-)
Live coding stream showing workflow, tooling, and patch submission process for Linux kernel maintenance and security back-porting.
Memristors for Analog AI Chips
Technical overview of memristor technology and its role in power-efficient analog in-memory computing for AI accelerators.
Grounded II: Making The Last of Us Part II
Feature-length documentary exposing the production pipeline, tools, and design decisions behind Naughty Dog’s The Last of Us Part II.
How AI Discovered a Faster Matrix Multiplication Algorithm
Explains how DeepMind’s AlphaTensor discovered record-breaking tensor-decomposition algorithms that speed up matrix multiplication.
1.2 - Racing Down the Slopes of Moore’s Law (Bram Nauta)
Keynote analyzes the limits of Moore’s Law scaling and advocates mixed-signal and ADC-centric approaches for power-efficient RF/digital design.
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.
How does Groq LPU work? (w/ Head of Silicon Igor Arsovski!)
Deep technical interview on Groq’s Language Processing Unit architecture—single-cycle SIMD fabric, compiler stack, and network scaling versus GPUs.
How Particle Life emerges from simplicity
Shows how simple inter-particle attraction/repulsion rules give rise to complex “Particle Life” behaviors, with open-source code for experimentation.
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.
How do CPUs read machine code? — 6502 part 2
Details how a 6502 CPU fetches and decodes machine instructions, covering control lines, micro-sequencing, and timing states at the transistor level.
Subcategories
- computer_architecture (117)
- computer_graphics (38)
- databases (5)
- game_development (17)
- hardware_engineering (3)
- history (20)
- networking (4)
- parallel_computing (11)
- programming_languages (121)
- software_development (334)
- systems_programming (139)
- theory (280)