Bookmarks
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Tony Hawk's Pro Strcpy
Explains a remote-code-execution exploit and provides source code, offering valuable security and reverse-engineering insights.
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.
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.
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.
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.
BLAZINGLY FAST C++ Optimizations
Focuses on techniques for high-performance C++ code, aligning with software optimization and best practices.
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.
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.
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.
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.