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.

[#39] DVUI - David Vanderson

Developer Productivity, v2 with ThePrimeagen | Preview

Nix explained from the ground up

Comprehensive tutorial explaining Nix package manager, deterministic builds, and related tooling, valuable for devops and reproducible development.

Typst is pretty neat

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.

Tiger Style

Deep Dive into Yann LeCun’s JEPA

ai

Lego Mindset vs. Woodworking Mindset

How hard is constraint programming?

Design Of This Website

Reversing the technical interview

Hexing the technical interview

Zig Build System

Arena allocator tips and tricks

brotli-2015-09-22

Introduction

1024cores

You're Not Sick of Programming

FreeType

Pain we forgot

Reflections on a decade of coding

Don't write bugs

Mitchell Hashimoto

xorvoid

MCC15-04

Rounding floats with f-string [duplicate]

Latent Interfaces

How Netflix Really Uses Java

Scheduling Internals

Subcategories