The list of things I read or watched in 2025
December
How Modern Christmas was Invented
Trading at light speed: designing low latency systems in C++ - David Gross - Meeting C++ 2022
Inside a Real High-Frequency Trading System | HFT Architecture
What are wide characters?
A Culpa Histórica do Brasileiro
Clock Synchronization Is a Nightmare
What makes entrepreneurs entrepreneurial?
Best of metadata in 2025
Por que Muitos Jovens Não Vão Conseguir Comprar um Apartamento (e Não é Culpa Deles)
Why Reliability Demands Functional Programming: ADTs, Safety, and Critical Infrastructure
On Metastable Failures and Interactions Between Systems
G-single (Single Anti-dependency Cycle)
P4 (Lost Update)
Reconstructing History with XTDB (Jeremy Taylor + James Henderson)
Distributed Systems 6.2: Raft
Cheating the CAP Theorem by Jeff Swenson
Legends of the RISC Wars
Can We Rely On Timers For Distributed Algorithms?
Jepsen: Read Your Writes
Do tightly synchronized clocks help consensus?
How Do Atomic Clocks Work?
LeaseGuard: Raft Leases Done Right*
LeaseGuard: Raft Leases Done Right!
The Folly of Liberal History
Delta encoding
Handling Overload
Ternary Computing: Theoretically Better than Binary
The Last Job On Earth
Japanese Supercomputers Led to the Internet
TLA+ modeling tips
Latency Profiling and Optimization - Dmitry Vyukov
How hackers reverse Math.random()
The physics behind diffusion models
The Breakthrough Behind Modern AI Image Generators | Diffusion Models Part 1
You can now train a 70b language model at home
How to Build a Brain (without losing yours): Intro to Neuromorphic computing
On Idempotency Keys
Towards interplanetary QUIC traffic
Get in Line - superfast SPSC Queue
When is “ACID” ACID? Rarely.
Weak vs. Strong Memory Models
COMPLETE EMBEDDED SYSTEMS Roadmap - What Arduino Won’t Teach You
Manual memory management in Go using jemalloc
Building a Distributed Filesystem for Scalable Research
Using Quint to Harden Your Specifications and Catch Hidden Bugs
Designing Rust FDB Workloads That Actually Find Bugs
Jepsen: NATS 2.12.1
TigerBeetle as a file storage
Why Fighter Jets Ban 90% of C++ Features
How Computers Almost Killed the Chinese Language
Your intellectual fly is open
Getting from tested to battle-tested
Testing a single-node, single threaded, distributed system written in 1985
The biggest shift in computer vision
Freeing HTTP/1.1 Connection
November
AI and the Death of the Career Ladder
Why AI Needs Pain
The Ultimate Guide to Building a Quadcopter From Scratch
Thinning layers
Formal Specification for Authorization: Clarity Before Implementation
The Heartbeat of Modern CPUs
Demystifying Determinism in Durable Execution
Temporal Shrinking
Erlang: The Movie
How I Fell in Love with Erlang
What Now? Handling Errors in Large Systems
Does Dioxus spark joy?
How 100 Servers Sync in Just 4 Rounds
Delta Lake Atomicity
Building a Durable Execution Engine With SQLite
Why Strong Consistency?
Your computer is a distributed system
Writing your own BEAM
What Everyone Should Know About Kubernetes Memory Limits, OOMKilled Pods, and Pizza Parties
Ten Years of Erlang
Erlang’s Tail Recursion is Not a Silver Bullet
The Cameras Tracking You Are A Security Nightmare
Why is a Goroutine’s stack infinite ?
Monkey Patching in Go
Recreating the AWS Outage in 67 Lines (Race Conditions Are Wild)
What is Virtual memory?
Heartbeats in Distributed Systems
antirez: Is Redlock safe?
Hermit: Deterministic Linux for Controlled Testing and Software Bug-finding
Database Synchronous vs Asynchronous IO
TLA+ Modeling of AWS outage DNS race condition
Salary Negotiation: Make More Money, Be More Valued
Actually tracking Stealth Fighters with cheap webcams - An Actual Q&A.
You’ll never see attrition referenced in an RCA
Absurd Workflows: Durable Execution With Just Postgres
TUN/TAP
The Green Tea Garbage Collector
October
Virtual networking 101: bridging the gap to understanding TAP
Building and Testing Resilient Ruby on Rails Applications
I’m too dumb for Zig’s new IO interface
Distributed Unique ID Generation
Testing Distributed Systems for Linearizability
Linearizability versus Serializability
Distributed Systems 101 : From a Beginners POV
Building a programming language using SQLite’s VM - Pt 1
Tracking Time Without Clock
Model checking safety of Ben-Or’s Byzantine consensus with Apalache
Paxos made visual in FizzBee
Cloudflare Durable Objects are Virtual Objects
Tutorial: Apalache (Part1)
Using Java’s Project Loom to build more reliable distributed systems
The Profit Paradox
1000x: The Power of an Interface for Performance by Joran Dirk Greef
Beyond Indexes: How Open Table Formats Optimize Query Performance
Cache Eviction Policies in Storage Engines
Message Soup: the Secret Sauce for Consensus Specifications
Infrasound: What You Can’t Hear CAN Hurt You
An MVCC-like columnar table on S3 with constant-time deletes
CASPaxos Linearizable databases without logs
DNS sinkhole
Viewstamped Replication Revisited and Implemented
Paper: VR Revisited - Checkpoint-Based Replica Recovery (part 6)
Paper: VR Revisited - Log-Based Replica Recovery (part 5)
Paper: VR Revisited - Application state and commit-number monotonicity (part 4)
Paper: VR Revisited - State Transfer (part 3)
Paper: VR Revisited - View changes - Answers (part 2)
Paper: VR Revisited - View changes - Questions (part 1)
Paper: VR Revisited - An analysis with TLA+
Data 101: The Fundamentals of Data Science
gRPC Load Balancing on Kubernetes without Tears
OSWALD—Object Storage Write-Ahead Log Device
September
01. Intro – Stateright Actor Framework
Harvest and Yield: Not A Natural Cure for Tradeoff Confusion
Availability and availability
Let’s Consign CAP to the Cabinet of Curiosities
Is there a CAP theorem for Durability?
Unit of Work: Your best friend in the Repository Pattern
Keeping CALM: When Distributed Consistency Is Easy
RSA ANIMATE: The Secret Powers of Time
Haydex: From Zero to 178,600,000,000 rows a second in 30 days
CAP theorem
Scylladb: PACELC Theorem
Chain replication for supporting high throughput and availability
Is this consensus?
Schema Evolution, Career Edition
Apache Parquet docs
Run-length encoding
CockroachDB: Scaling Raft
The Saddest Moment
Meet Rayhunter: A New Open Source Tool from EFF to Detect Cellular Spying
Many Hard Leetcode Problems are Easy Constraint Problems
In response to a developer asking about systems
Geohot: AI Coding
Apache Arrow DataFusion Architecture Part 1
Achieve a 10x Reduction in Telemetry Traffic Using OpenTelemetry Protocol with Apache Arrow
Delta Lake: High-Performance ACID Table Storage over Cloud Object Stores
wal3: A Write-Ahead Log for Chroma, Built on Object Storage
Using Merkle trees to detect inconsistencies in data
An Overview of AMM Mechanisms by Matt Deible | Devcon Bogotá
Stanford Seminar - Evolution of a Web3 Company
Setsum - order agnostic, additive, subtractive checksum
Why Do Wind Turbines Have Three Blades?
Columnar Database Compression: Dictionary Encoding
Building a Database on S3
When more threads make things worse
Building a distributed log using S3 (under 150 lines of Go)
Zero Disk Architecture
Announcing Spiral
Why does an escalator handrail move faster than the stairs?
Disaggregated Storage - a brief introduction
Sometimes Assertions
BUGGIFY
Testing: prevention vs discovery
Introducing Apache Arrow Flight: A Framework for Fast Data Transport
Apache Arrow, Parquet, Flight and Their Ecosystem are a Game Changer for OLAP
Rust can be difficult to learn and frustrating, but it’s also the most exciting thing in software development in a long time
InfluxDB IOx Tech Talks: Catalogs - Turning a Set of Parquet Files into a Data Set
Disaggregation: A New Architecture for Cloud Databases
Announcing InfluxDB IOx - The Future Core of InfluxDB Built with Rust and Arrow
Designing a Parquet Catalog for InfluxDB IOx
Syncing with Postgres: Logical Replication vs. ETL
Cost Efficiency @ Scale in Big Data File Format
Jepsen 18: Serializable Mom by Kyle Kingsbury
The Most Useful Curve in Mathematic: Logarithms
All About INOTIFY - Watch Your Filesystem with the Linux Kernel!
Oldest recorded transaction
The Future of Math is Programming
How the Lean language brings math to coding and coding to math
Design YouTube
The fairness puzzle that sparked probability
How AI Datacenters Eat the World
Breaking verifiable abstractions
August
Replacing a cache service with a database
Efficient Layer 7 Proxying
SQLite commits are not durable under default settings v2
Demystifying Write Durability
SurrealDB is sacrificing data durability to make benchmarks look better
Finding Bugs in a Coding Agent with Lightweight DST
Netflix Ditched Kafka for THIS in CQRS
Testing Time (and other asyncronicities)
Linearizability testing S2 with deterministic simulation
Breaking The Creepy AI in Police Cameras
How the Two Generals’ Problem Almost Caused WWIII
Performance: SIMD, Vectorization and Performance Tuning | James Reinders, former Intel Director
Laura Summers - Ok, Doomer | PyData Amsterdam 2023
The Hasan Summit with Hasan Piker
How Amazon Built The Soviet Dream
The Future of Observability: Observability 3.0
Parquet page index: Layout to Support Page Skipping
How does it work? Example Benefits Comparison Min-Max (Zonemap) Index
I’m an award-winning mathematician. Trump just cut my funding.
Opentelemetry: Exponential Histograms
Apache Arrow: High-Performance Columnar Data Framework (Wes McKinney)
The AI that solved IMO Geometry Problems | Guest video by @Aleph0
The Formation of Unreflected Beliefs
Apache Arrow DataFusion: A Fast, Embeddable, Modular Analytic Query Engine (Andrew Lamb)
1 billion row challenge in Rust using Apache Arrow
The hidden beauty of radix sort
Stop Writing if (!x) — Here’s Why It’s Bad Software Design
HoliPaxos: Towards More Predictable Performance in State Machine Replication
How rqlite is tested
Faster Reads, Same Guarantees: Linearizable Consistency in rqlite 8.32
Consistency Over Availability: How rqlite handles the CAP Theorem
Don’t Forget To Flush by Andrew Kelley
Why Deep Learning Works Unreasonably Well
Lecture 5: Neural Networks
Stop Copying the Customer Table in Every Service
The evolution of effective B-tree: Page organization and techniques: A personal account
Lecture 4: Optimization
Postgres Replication Slots: Confirmed Flush LSN vs. Restart LSN
ACID Jazz - Kyle Kingsbury
All the cool kids are doing it
Scaling Correctness: Marc Brooker on a Decade of Formal Methods at AWS
July
Getting Started with Randomised Testing
How bright was the Trinity test and what did Oppenheimer mean?
The Math Is Haunted
Our $100M Series B
The Long Read: How Helsing Sees the World
Store tags after payloads
Who Invented Backpropagation?
Heisenberg and the German Bomb
You Are Witnessing the Death of American Capitalism
Logic behind the scenes
Formal specs as sets of behaviors
Sorry. Your Car Will Never Drive You Around.
The Really Dark Truth About Bots
7 Concerning Levels Of Acoustic Spying Techniques
I Saved a PNG Image To A Bird
Who’s Adam and What’s He Optimizing? | Deep Dive into Optimizers for Machine Learning!
What is Gradient Descent?
Learning representations by back-propagating errors
What are Markov chains? And why are they so useful?
Inverted Index - The Data Structure Behind Search Engines
Lecture 3: Linear Classifiers
PSA: SQLite WAL checksums fail silently and may lose data
Why Numpy Is Better Than ALL Your Code
Lecture 2: Image Classification
Lecture 1: Introduction to Deep Learning for Computer Vision
P Verified Log 5: Single Producer And Outlook
P Verified Log 4: Debugging With Peasyviz
P Verified Log 3: Introducing Failures
P Verified Log 2: Modeling The Happy Path
Demis Hassabis: Future of AI, Simulating Reality, Physics and Video Games | Lex Fridman Podcast #475
REPL-driven development (RDD) with Clojure
P Verified Log 1: The Need For Verification
Strange Phenomena caused by Nuclear Bombs
How AI Learns Concepts
Deep mind: The Universal Approximation Theorem
Perceptron Research from the 50’s & 60’s, clip
The Most Important Algorithm in Machine Learning
What is Gradient Descent?
4 Pictures that Explain LSH - Locality Sensitive Hashing Tutorial
Just make it scale: An Aurora DSQL story
What Textbooks Don’t Tell You About Curve Fitting
What is the Traveling Salesman Problem?
Introduction to Optimization: Calculating Derivatives
Introduction To Optimization: Gradient Free Algorithms (2/2) Simulated Annealing, Nelder-Mead
Introduction To Optimization: Gradient Free Algorithms (1/2) - Genetic - Particle Swarm
Introduction To Optimization: Gradient Based Algorithms
Introduction To Optimization: Gradients, Constraints, Continuous and Discrete Variables
Introduction To Optimization: Objective Functions and Decision Variables
Introduction to Optimization: What Is Optimization?
The Man Who Should Be As Famous As Einstein
NIH Is Far Cheaper Than The Wrong Dependency
The History of Calculus -A Short Documentary | Newton & Leibniz
When to Use Machine Learning? | Neural Networks
Example Applications | Neural Networks
Backpropagation Algorithm | Neural Networks
Gradient Descent | Neural Networks
Neural Network | Neural Networks
Activation Function | Neural Networks
Overview | Neural Networks
Perceptron Network | Neural Networks
Perceptron | Neural Networks
The First Neural Networks
Feynman: Knowing versus Understanding
How Do Turing Machines ACTUALLY Work?
Actually precisely tracking Stealth fighters using cheap cameras without AI.
LevelDB
To be a better programmer, write little proofs in your head
Reflections on OpenAI
Amazon S3 Vectors
Specifications Don’t Exist
Gradient Descent vs Evolution | How Neural Networks Learn
Ants that are Computers
Bloom Filters: The Secret Weapon for Lightning-Fast LSM Tree Lookups
Jepsen: Redis
Ratio - Make Some Chocolate Crispies
Ratios
Why Neural Networks can learn (almost) anything
How You’ve Accidentally Trained Yourself To Be Helpless
On Mathematical Maturity (2) Thomas Garrity
On Mathematical Maturity (1) Thomas Garrity
What is linear regression?
Watching Neural Networks Learn
The Origin of ChatGPT
James Simons - Mathematics, Common Sense, and Good Luck: My Life and Careers
Rapid Prototyping a Safe, Logless Reconfiguration Protocol for MongoDB with TLA+
Move 37 of the markets: Why AI is the future of market efficiency
Understanding Calculus With A Bank Account Metaphor
Zig’s New Async I/O
Experiments on the mechanization of game-learning Part I. Characterization of the model and its parameters
How AI Thinks
A Gentle Introduction To Learning Calculus
Gradient (Slope) of a Straight Line
Feedforward neural network
Decision boundary
The Most Important Concept in Physics. #SoME4
Intro to Multi-Agent RL
Proofs are Programs
How to understand/retain complex concepts 10x better
Type Theory in Computer Science, Linguistics, Logic
How to LAND on the Moon in 2025 (ft. Firefly)
Hiring is Hard
History of the Perceptron
Wikipedia: Perceptron
Wikipedia: Offline learning
Wikipedia: Linear classifier
THE PERCEPTRON: A PROBABILISTIC MODEL FOR INFORMATION STORAGE AND ORGANIZATION IN THE BRAIN
Hewitt, Meijer and Szyperski: The Actor Model (everything you wanted to know…)
I know why you are not getting hired
The Bitter Lesson
Property-Based Testing Against a Model of a Web Application
You Suck at Marketing
Breaking Distributed Systems with Kyle Kingsbury from Jepsen
What are L4 Load Balancers and how do they work?
Building a Supersonic Rocket Guidance System
160 Core RISC-V supercluster on a single M.2
Vector Database from a Beginners POV
Annotated History of Modern AI and Deep Learning
Are we the baddies?
How to Find a Least Squares Regression Line (Part 1: Intuition)
How a straight line teaches machines to learn
Sequences
Sigma Notation
Linear Regression Using Least Squares Method - Line of Best Fit Equation
Least Squares Regression
Equation of a Straight Line
What is Machine Learning?
What Is Linear Regression?
What is Least Squares?
Minimizing Sum of Squared Errors
Learn ALL THE MATH IN THE WORLD from START to FINISH
Introduction to Euclidean Spaces
What exactly is a differentiable function? Differentiability examples
RankBrain
Tensor Processing Unit
Algebra Basics: What Is Algebra? - Math Antics
Vectors | Chapter 1, Essence of linear algebra
That XOR Trick
Extending that XOR Trick to Billions of Rows - an Introduction to Invertible Bloom Filters
MySQL EXPLAIN ANALYZE
Logical Quantifiers in Software
Stevey’s Google Platforms Rant
June
Stevey’s Google Platforms Rant
A.I., Mars and Immortality: Are We Dreaming Big Enough? | Interesting Times with Ross Douthat
Nuclear 101: How Nuclear Bombs Work Part 1/2
Want to meet people, try charging them for it?
Actually Tracking Stealth Fighters with Cheap Cameras Without AI or Radar in Real time.
The Stock Market Always Wins
IPC: To Share Memory Or To Send Messages
What the Heck Is Envelope Encryption in Cloud Security?
Postgres Is All You Need for Full Text Search (Seriously)
How To Perform A TCP Check | Grafana Synthetic Monitoring
Specification Refinement
TLA+ for startups (part 1)
How To Perform A DNS Check | Grafana Synthetic Monitoring
Paper #55. Protocol-Aware Recovery for Consensus-Based Storage
Durability and the Art of Consensus by Joran Dirk Greef
aphyr: The trouble with timestamps
Verifying Software Traces Against a Formal Specification with TLA+ and TLC
clojure: Structural Editing
clojure: Transient Data Structures
Wikipedia: Skip list
rocksdb: MemTable
Implementing and Improving Skiplists
Career advice, or something like it
Astonishing discovery by computer scientist: how to squeeze space into time
Reproducing a Memory-Tracking Bug with TLA+
What is computer architecture?
99% of Developers Don’t Get JIT Compilers
Rendezvous Hashing Explained
Efficient Gossip in Distributed Systems
The plight of the misunderstood memory ordering
Richard Feynman on education in Brazil
I never understood why this math object is found everywhere…until now!
MySQL - Lock an entire table with a delete statement
How does MVCC (Multi-Version Concurrency Control) work
How does database pessimistic locking interact with INSERT, UPDATE, and DELETE SQL statements
Bypassing GitHub Actions policies in the dumbest way possible
MySQL gap lock, next key lock by example
(mysql.info.gz) InnoDB Next-key locking
Skip Lists: Done Right
Let’s talk SkipList
Controlling Nondeterminism in Model-Based Tests with Prophecy Variables
Simulating Some Queues
Log-Structured Merge Trees (LSMs) Bloom Filters
eXtreme Modelling in Practice (Jesse Davis, Max Hirschhorn, Judah Schvimer)
The Verification Gap: A Major Hurdle for the Industry Adoption of Formal Methods
Log-Structured Merge Tree
Introduction to LSM Trees: May the logs be with you
How to Durably Write a File on POSIX Systems
How Hardware Assist Software When Multitasking
Vertical Slice Architecture
Advanced Testing and Determinism
Machine Code Isn’t Scary
Analyzing Metastable Failures in Distributed Systems
Unlocking Tokio’s Hidden Gems: Determinism, Paused Time, and Local Execution
Deep dive into Apache Kafka storage internals: segments, rolling and retention
jemalloc Postmortem
The Most DANGEROUS but POWERFUL Concept in Programming!
LSM-based Storage Techniques: A Survey
Implementing Message Queues in Relational Databases
SELECT … FOR UPDATE on non-existent rows
MySQL 8.0.1: Using SKIP LOCKED and NOWAIT to handle hot rows
The Mechanics of SELECT FOR UPDATE in SQL
The Weirdest Bug in Programming - Race Conditions
Reed Solomon Tutorial: Backblaze Reed Solomon Encoding Example Case
Lightweight transactions in Cassandra 2.0
Rich Hickey: Deconstructing the Database
The Log: What every software engineer should know about real-time data’s unifying abstraction
Atomic broadcast
Can We Rely On Timers For Distributed Algorithms?
The Holy Grail of Computer Science
Jepsen: TigerBeetle 0.16.11
How to send alerts from self-hosted Grafana to Grafana Cloud IRM
XSS like you’ve never seen before
Specification language
Go Fuzzing
Conformance Checking at MongoDB: Testing That Our Code Matches Our TLA+ Specs
Episode 071: Reviewing Replica Recovery
Model-guided Fuzzing of Distributed Systems
De Bruijn and why we use it
Using Strace for performing fault injection in system calls
May
The virtue of unsynn
Enough With All The Raft
Erasure Coding for Distributed Systems
Deep dive into Apache Kafka storage internals: segments, rolling and retention
What does “Undecidable” mean, anyway
A no-maths guide to monads
Performance Optimization Methodology for Valkey - Part 1
Chapter 5: Multiversion Concurrency Control (Concurrency Control Book)
You Can Choose Tools That Make You Happy
Cheerleading
The problem of time in statistics
What Works (and Doesn’t) Selling Formal Methods
Jepsen: Snapshot Isolation
Snapshot isolation
Write–read conflict
Read–write conflict
Write–write conflict
Snapshot Isolation vs Serializability
Implementing MVCC and major SQL transaction isolation levels
Epoxy: ACID Transactions Across Diverse Data Stores
GopherCon UK 2021: Nick Craig-Wood - Deadlocks: The Dark Side of Concurrency
Hybrid Logical Clocks
Modular verification of MongoDB Transactions using TLA+
I can prove I’ve solved this Sudoku without revealing it
Circuit Breaker em Go: Protegendo Seus Serviços com Resiliência
Refs and Transactions
Multiversion concurrency control
How to Get Transactions Between (Almost) Any Data Stores
Go synctest: Solving Flaky Tests
Making Postgres distributed with FoundationDB
The Birthday Problem in Probability: P(A) = 1 - P(not A)
Set Theory in Probability: Sample Spaces and Events
Counting Probabilities with Combinatorics and the Factorial
Gentle Introduction to Probability: Counting Coin Flips and Dice
the most magical exploit i’ve ever seen
What Happens When a Program Calls Sleeps?
Good Performance for Bad Days
Transactions Are Not Locks
Flame Graphs for Go With pprof
Debugging memory leaks in Postgres, heaptrack edition
A Run of CRDT Posts
Fix the new things first!
HYTRADBOI 2025 | Rocket science of simulation testing!
An intuitive approach for understanding electricity
Leslie Lamport: How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs
Memory Consistency Models: A Tutorial
Clean Up Bloated CQRS Handlers with Domain Logic & Pipelines
Go Cryptography Security Audit
sqlite: Write-Ahead Logging
1.0 File Locking And Concurrency In SQLite Version 3
Easily Understand RDMA Technology
Modern Hardware for Future Databases
Introduction to Inductors
How Electricity Works - for visual learners
The Big Misconception About Electricity
Chapter 3: Two Phase Locking (Concurrency Control Book)
ModelFuzz: Model guided fuzzing of distributed systems - Srinidhi Nagendra
Crushing Castlevania with Antithesis
Demo: How to Use Grafana Advisor to Keep Your Instances Running Smoothly and Securely | Grafana 12
Back to Basics: A Primer on Communication Fundamentals
Aurora Paper Deep Dive: Distributed Database Fundamentals & Storage-Compute Separation (Section 1)
Boltzmann Machines
Taking out the Trash: Garbage Collection of Object Storage at Massive Scale
10 Years of Stable Rust: An Infrastructure Story
Reinforcement Learning: Essential Concepts
The Most Famous Algorithm In Computer Graphics
Desired state systems
Introduction To Browser Checks | Grafana Cloud Synthetic Monitoring
Chapter 2: Serializability Theory (Concurrency Control Book)
Blacksmith: How The Economics of Multitenancy Work
WW3 Will Be Fought With Money
Positive and Negative Charge
A Better Way To Picture Atoms
What is electrical resistance? - Electricity Explained - (4)
What is voltage? - Electricity Explained - (3)
What is ampere? - Electricity Explained - (2)
What is electricity? - Electricity Explained - (1)
What is Electric Charge? (Electrodynamics)
What Are Atoms Made Of?
What Is An Atom And How Do We Know?
What’s Inside an Atom? Protons, Electrons, and Neutrons!
Atoms, Electrons, Photons, and Light
How Computers Compute (Science Out Loud S2 Ep5)
What Is A Semiconductor?
Engineering professor explains semiconductors
What is Photodiode? | Explained its Working and Application
Laser microphone
light can’t change direction ~ so how does it reflect?
I Built a CIA Spy Device (Laser Mic)
Ignore drive write messaging… SSDs are more reliable than HDDs, Period.
Concerning the mistaken belief that key value databases chew up SSDs
How key value databases shorten the lifespan of SSDs
Double Dispatch in DDD: When Injecting Dependencies Makes Sense
ChatGPT is made from 100 million of these - The Perceptron
The Misconception that Almost Stopped AI
This Simple Algorithm Powers Real Interpreters: Pratt Parsing
Ian Lance Taylor: Leaving Google
The value of model checking in distributed protocols design
Exploring TLA+ with two-phase commit
Specifying and simulating two-phase commit in Lean4
Use JSON columns with care
Category Theory for Busy Programmers
How a straight line teaches machines to learn
Murat Demirbas & Will Schultz - TLA+ Modeling of MongoDB Transactions
TCP/IP in OCaml Part 2 - Concurrency Design with OCaml Multicore and EIO
JSON in Go is FINALLY getting a MASSIVE upgrade!
What’s the fuss about formal specifications?
Notes from the TLA+ Community Event
Matt Godbolt sold me on Rust (by showing me C++)
Prometheus native histograms in Grafana Cloud
Swarm Testing Data Structures
jemalloc memory allocator
PostgreSQL vs. fsync How is it possible that PostgreSQL used fsync incorrectly for 20 years, and what we’ll do about it.
How the Lockheed SR-71 Blackbird Works
Deno’s Decline (6 Regions and Falling)
April
Challenges in Building Large-Scale Information Retrieval Systems
The Story of Information Theory
Jepsen: Amazon RDS for PostgreSQL 17.4
Authorization: Domain or Application Layer?
How do indexes make databases read faster?
The byte order fallacy
What If We Could Rebuild Kafka From Scratch?
do you know how “return” works under the hood? (are you SURE?)
Grafana Learning Journeys: Connect to a Prometheus data source in Grafana Cloud
Multi-Grained Specifications for Distributed System Model Checking and Verification
TikTok VM Reverse Engineering (webmssdk.js)
Burn your title
Toward Common Patterns for Distributed, Concurrent, Fault-Tolerant Code
AI Overviews Reduce Clicks by 34.5%
Decomposing Firebolt transactions
Torn Write Detection and Protection
What if we embraced simulation-driven development?
Decomposing Aurora DSQL
Decomposing Transactional Systems
The tail at scale: Software techniques that tolerate latency variability are vital to building responsive large-scale Web services
An Overview of the Grafana Infinity Data Source Plugin | Grafana Labs
Understanding B-Trees: The Data Structure Behind Modern Databases
The promise of Rust
Good models protect us from bad models
Bug Bash 2025 Conference Experience
Queues invert control flow but require flow control
Ensuring Safety in FoundationDB’s Rust Crate
So, You Want to Learn More About Deterministic Simulation Testing?
Creating 256 Bytes of RAM (in a simulation)
99% of Developers Don’t Get RPCs
Knowing where your engineer salary comes from
Latency Numbers Every Programmer Should Know
Dice and Queues
What I’d do as a College Freshman in 2025
The Animated Elliptic Curve Visualizing Elliptic Curve Cryptography
Hands-on: X25519 Key Exchange Let’s exchange a secret to start a secure conversation.
The Illustrated TLS 1.3 Connection Every byte explained and reproduced
Intuiting TLS
I’ve operated petabyte-scale ClickHouse® clusters for 5 years
Stop CRUD-Sourcing: Why Your Event Streams Are Bloated and Broken
How to use custom variables in Grafana dashboards
Blending Turmoil and MadSim Takeaways Published on April 2, 2025 DST for async Rust
Celebrate 50 years of Microsoft with the comapny’s original source code
Experiences with Semi-Formal Proofs with Justin Moore
Why Everyone’s Talking About MCP?
Regex for Email Validation? Think Again!
March
Understanding SAT by Implementing a Simple SAT Solver in Python
Viewstamped Replication Revisited
Paper #74. Viewstamped Replication Revisited
How to implement a work queue without skip locked
What is SELECT FOR UPDATE in SQL (with examples)?
One or Two? How Many Queues?
Goodbye core types - Hello Go as we know and love it!
New in 11.6: LBAC for Metrics Data Sources | Demo | Grafana Labs
System Design : What can you learn from @amazonwebservices Aurora DSQL ?
Sell yourself, Sell Your Work …
Cyanview: Coordinating Super Bowl’s visual fidelity with Elixir
Reverse Engineering with TLA+ Calvin Loncaric, Oracle
Practical Insights from Datadog’s Use of TLA+ and Simulations Arun Parthiban, Datadog
Demodulating NTSC for fun and profit (I)
Just write a test for it
Data Race Patterns in Go
Coding isn’t Programming - Closing Keynote with Leslie Lamport - SCaLE 22x
Making 100% code coverage as easy as flipping a coin
50 things we’ve learned about building successful products
“Simulation Testing” by Michael Nygard
Locks, leases, fencing tokens, FizzBee!
Cedar: A New Language for Expressive, Fast, Safe, and Analyzable Authorization
Announcing the Bytecode Alliance: Building a secure by default, composable future for WebAssembly
Word Squares
Andrew Kelley Practical Data Oriented Design (DoD)
Why Are Birthrates Plummeting Worldwide?
How (memory) safe is zig?
Pain we forgot
From Coding Bootcamp Graduate to Building Distributed Databases
Assorted thoughts on zig (and rust)
Generate All the Things
Load balancing and scaling long-lived connections in Kubernetes
How to implement a distributed and auto-scalable WebSocket server architecture on Kubernetes
False Sharing
My Time at MIT
Grafana 11.6 Now Available! Here’s the TL;DR | Grafana Labs
“Building a Sync Engine in Clojure” by Stepan Parunashvili
Why Separate Databases? Explaining Like You’re Five
Sync Engines are the Future
“Designing Dope Distributed Systems for Outer Space with High-Fidelity Simulation” by Toby Bell
Properly Testing Concurrent Data Structures
Keynote: TLA+ at Microsoft: 16 Years in Production - David Langworthy
Graceful behavior at capacity
Coding a database proxy for fun
“Tackling Concurrency Bugs with TLA+” by Hillel Wayne
Parallel property-based testing with a deterministic thread scheduler
Why aren’t we all getting rich from compound interest?
JVM Internals: Garbage Collector Algorithms - Challenges
TCP vs UDP performance (Round 3)
Loosely Coupled Monolith - Software Architecture - 2025 Edition
Modelling distributed locking in TLA+
redlock: unsafe at any time
Getting Started with Grafana Cloud IRM | Grafana Labs
Defining Safety and Liveness
Learning formal verification by writing a spec for verifying a zero-downtime database migration in PlusCal
A 10x Faster TypeScript
Securing Keys with HSMs (Hardware Secure Module)
Seastar: Message Passing
Seastar: Shared-nothing Design
viewstamped replication
Asynchronous program question
Ways to debug Clojure code: println, pprint, hashp & debugger
Functional vs Data-Driven development: a Case-Study in Clojure & OCaml
Unexplanations: relational algebra is math
Lock convoy
Weak and Strong Fairness
The Business Case for Formal Methods
What Every Programmer Should Know About SSDs
2 Bytes Was Enough To Breach The US Treasury
Landscale of Lisp
Introduction To Grafana Faro | Frontend Observability
How to write your own Deterministic Simulator
Why Prediction Markets Beat The Experts
How Math Academy pulled me out of the Valley of Despair
Service Discovery in Kubernetes: Combining the Best of Two Worlds
0030: lsm perf, colorblind concurrency, tracing, evacuating preimp, reading, fixing my shoulders
How the CPU predicts jumps
Multi-Paxos
Do you know this common Go vulnerability?
Case Study: Formalizing Grug’s Jellyfish Merkle Tree with Quint
(Mostly) Deterministic Simulation Testing in Go
Search trees and core.logic
HYTRADBOI 2025 postmortem
Workers - what can they do and what do they look like? Lets make a model in Go.
Mitchell Hashimoto: “As Code”
A More Modular reqwest
Take a break: Rust match has fallthrough
Database Migration Strategies: Keeping Your Schema and Code in Sync
How does stack work in a CPU? Why do we need it?
FoundationDB or: How I Learned to Stop Worrying and Trust the Database (Markus Pilman, Snowflake)
The Trouble with Leader Elections (in distributed systems)
How debuggers work
Use of time in distributed databases
Enough with all the Raft
Language agonostic simulation testing on a budget
Distributed Systems Programming Has Stalled
Netflix’s Distributed Counter Abstraction
The Demoralization is just Beginning
“Simple Made Easy” - Rich Hickey (2011)
Why do frame pointers matter for OCaml?
Gleam, coming from Erlang
TCP vs UDP Performance: HUGE Improvement!
How UNIQLO, H&M, and ZARA Conquered Fashion
Why you need a “WTF Notebook”
Write better code with pure functions
Socrates is a state machine
Using Formal Methods to Model a Smart School System via TLA+ and its TLC Model Checker for Validation
We built a new SQL Engine on Arrow and DataFusion
February
S2024 #04 - Query Execution & Processing Part 1 (CMU Advanced Database Systems)
Fast columnar JSON decoding with arrow-rs
Levenshtein distance
Why We Designed TigerBeetle’s Docs from Scratch
Building and operating a pretty big storage system called S3
Python interpreter adds tail calls
Announcing the glorious advent of XeDN
Globally Distributed Object Storage with Tigris
That One Time I Needed a Linked List
Databases in 2024: A Year in Review
Transactional outbox pattern
The Exit Interview: JP Phillips
BPF, XDP, Packet Filters and UDP
TCP vs UDP Performance (Latency & Throughput)
Lean Into Verified Software Development
How we built Cedar with automated reasoning and differential testing
The Distributed Systems Mistake Nobody Warns You About!
8 Most Important Tips for Designing Fault-Tolerant System
Deterministic simulation test – the next step
Formalizing Stability and Resilience Properties
Why Clojure?
What makes concurrency so hard?
Simple Simulations for System Builders
Getting into formal specification, and getting my team into it too
How we use formal modeling, lightweight simulations, and chaos testing to design reliable distributed systems
It’s Time to Replace TCP in the Datacenter
Data, Consensus, Execution: Three Scalability Bottlenecks for State Machine Replication
Lambda Calculus and Lisp, part 1
Concurrency bugs in Lucene: How to fix optimistic concurrency failures
Revenge of the Nerds
Some tests are stronger than others
Five Kinds of Nondeterminism
Advice to the young
What makes entrepreneurs entrepreneurial?
Async Runtimes
Streamlet in TLA+
CppCon 2017: P. McKenney, M. Michael & M. Wong “Is Parallel Programming still hard? PART 2 of 2”
“How to Have your Causality and Wall Clocks, Too” by Jon Moore
Three Clocks are Better than One
What Nobody Tells You About The THREAD STACK
Announcing Rust 1.85.0 and Rust 2024
Map internals in Go 1.24
Tigerbeetle: Safety
Quint Deserves Rust
Enum of Arrays
Snapshot Testing For the Masses
Understanding Little’s Law
Using Little’s Law to scale applications
Representing graphs in Postgresql with SQL/PGQ
Representing graphs in Postgresql
Why I’m Writing a Scheme Implementation in 2025 (The Answer is Async Rust)
Amazon S3 adds new functionality for conditional writes
Leader Election vs Distributed Consensus - Which One Is Harder?
Leader Election With S3 Conditional Writes
Learn Datalog Today
MySQL: 17.7.2.4 Locking Reads
Little’s law
Semaphores
Writing the Worst Datalog Ever in 26loc
Making a simple Datalog Engine in Clojure
These are the storytelling lessons I learned from Steve Jobs
‘Modules Matter Most’ for the Masses
A Descent Into the Vᴏ̈ʀᴛᴇx
“Stop Rate Limiting! Capacity Management Done Right” by Jon Moore
Large Scale Model Checking 101
Parallel Streaming Pattern in Go: How to Scan Large S3 or GCS Buckets Significantly Faster
Rust nomicon: Data Races and Race Conditions
Race Conditions & Data Races
On becoming competitive when joining a new company
Push Ifs Up And Fors Down
How Antithesis finds bugs (with help from the Super Mario Bros.)
Coding Projects that ACTUALLY Impress
How to make your own luck
The Slippery Slope of In-Memory Message Bus – Beware!
The Only Unbreakable Law
Apple’s M-series CPUs just got hacked
Smuggling arbitrary data through an emoji
Modeling a CLH lock in TLA+
Intro to Fugato (by David Nolen)
Orchestration and choreography
Temporal Properties
Lock convoy
Weak and Strong Fairness
Modeling B-trees in TLA+
Testing Race Conditions
How to disaggregate a log replication protocol
How do Garbage Collection Algorithms work?
Teaching Computers to Learn, Part 1
Mathematical Origins of Machine Learning | Teaching Computers to Learn, Part 2
Perceptrons: The First Trainable Neural Networks | Teaching Computers to Learn, Part 3
File-driven testing in Go
The state of Rust trying to catch up with Ada
Instrument the Rust standard library with safety contracts
Good engineers are right, a lot
Modeling Redux with TLA+
Modeling Condition Variables using Formal Methods
Using TLA+ for data modeling
What every systems programmer should know about concurrency
The case for sans-io
Event-Driven Architectures - Queue vs Log - A Case Study
Why Trees Without Branches Grow Faster: The Case for Reducing Branches in Code
How Protobuf Works—The Art of Data Encoding
Systems Correctness Practices at AWS
A Systematic Literature Review on a Decade of Industrial TLA + Practice ⋆
Event-Driven Architectures - The Queue vs The Log
The teacher’s nemesis
Modelling and verifying the BookKeeper protocol (TLA+ Series Part 3)
A Guide to the BookKeeper Replication Protocol (TLA+ Series Part 2)
What is mutual authentication? | Two-way authentication
Versioning versus Coordination
Hanging in there
GOMEMLIMIT is a game changer for high-memory applications
Performance Under Load
Using load shedding to survive a success disaster—CRE life lessons
Why Snowflake wants streaming
Detecting Bugs in Data Infrastructure using Formal Methods (TLA+ Series Part 1)
Token bucket
Scaling your API with rate limiters
Basic concept of TCP-Vegas
AIMD Algorithm
January
Why Self-Checkout Failed to Replace Cashiers
Clojure Atom Internals, AtomicReference and Implementation Details
Safety and Liveness Properties
The importance of liveness properties (with TLA+ Part 2)
Challenges in Designing at Scale: Formal Methods in Building Robust Distributed
The importance of liveness properties (with TLA+ Part 1)
Learning first that you can learn
The Law of Large Numbers: A Foundation for Statistical Modeling in Distributed Systems
Obtaining statistical properties through modeling and simulation
FizzBee, TLA+, and (Practical) Formal Software Verification with JP Kadarkarai
Distributed Locks with Redis
Compiling Distributed System Models Into Implementations with PGo (Shayan Hosseini)
The original LSM paper
Evolution of tree data structures for indexing: more exciting than it sounds
The Burdens of Data
Why Applications Are Operating-System Specific
Trampolines for SQL
An explosion of transitive dependencies
You should write “without bugs”
core.async.flow rationale
Paper: VR Revisited - Log-Based Replica Recovery (part 5)
LEARN BITMAP INDEXES
API Caching is Hard! Pitfalls you need to know
Paper: VR Revisited - Application state and commit-number monotonicity (part 4)
Paper: VR Revisited - State Transfer (part 3)
Paper: VR Revisited - View changes - Answers (part 2)
Paper: VR Revisited - View changes - Questions (part 1)
Paper: VR Revisited - An analysis with TLA+
Elixir code generation from TLA+ specifications
TLA+ model checking made symbolic
Lecture 3: The Goods Market
A Beginner’s Guide to TLA+ Exploring State Machines & Proving Correctness | Jeff Weiss | Code BEAM V
Specification and Verification of Multi-Paxos
Formal Specification of a Web Services Protocol
Debugging Concurrent Systems with a Model Checker
TLA+ Specifications of the Consistency Guarantees Provided by Cosmos DB
Specifying and Model Checking Workflows of Single Page Applications with TLA +
The Essential Leslie Lamport
Leslie Lamport — The Paxos algorithm or how to win a Turing Award. Part 2.
How to think clearly as a programmer with mathematics and TLA+ - Leslie Lamport @ HLF 2019
Learntla: Example: Rate Limiting
Finding bugs in systems through formalization
A Conversation with Turing Award Winner Leslie Lamport
Haskell: A Great Procedural Language
Jepsen: consistency models - Linearizability
Jepsen: consistency models - Strong Serializability
Jepsen: consistency models - Serializability
How to Durably Write a File on POSIX Systems
The Path of a Packet Through the Linux Kernel
Cache Invalidation using SNS + SQS at Atlassian and then they moved away!
Teaching Concurrency
Leslie Lamport — The Paxos algorithm or how to win a Turing Award. Part 1.
Wolf, goat and cabbage problem TLA+ modeling
TLA+ is easy if you know how to abstract
Train Sidings – A TLA+ Example
TLA⁺ is more than a DSL for breadth-first search
Why I use TLA+ and not(TLA+): Episode 1
Estudo do uso de TLA+ para formalização de uma ferramenta de materialização de consultas com base em streaming1
Serializability, linearizability, and locality
The trouble with timestamps
Hybrid Logical Clocks
It’s About Time!
Optimistic and Pessimistic Locks
An unexpected discovery: Automated reasoning often makes systems more efficient and easier to maintain
DSQL Vignette: Aurora DSQL, and A Personal Story
Snapshot Isolation vs Serializability
Use of Time in Distributed Databases (part 5): Lessons learned
Consistency is an invisible exponential line.
Optimize observability and slash costs without losing insights
Specifying Systems
Building A “Simple” Distributed System - Formal Verification
Building A “Simple” Distributed System - The Protocol
Building a “Simple” Distributed System - The What
Solving Towers of Hanoi with TLA+
Formal Methods: Just Good Engineering Practice?
Modeling a merge queue with TLA+
Modeling Zero-Downtime Deployments with TLA+
Using TLA+ to Model Cascading Failures
PlusCal / TLA+ : An Annotated Cheat Sheet
Dr. TLA+ Series - Byzantine Paxos
Using TLA+ in the Real World to Understand a Glibc Bug
How does the Kernel handle TCP requests?
Heidi Howard: Flexible paxos
Bloom Filters
Why you should use modeling with TLA+/PlusCal
Going Beyond an Incident Report with TLA+
Two-phase commit and beyond
My experience with using TLA+ in distributed systems class
TLA+ modeling of MongoDB logless reconfiguration
Composing TLA+ Specifications with State Machines
History of AI Reasoning (AlphaGo, MuZero, LLMs)
Dr. TLA+ Series - Global Snapshot
Measuring the size of the cache line empirically