for-later.
- How to Think About GPUs
- A CT scanner reveals surprises inside the 386 processor's ceramic package
- Over engineering my homelab so I don't pay cloud providers
- Cognitive Decline Can Be Slowed Down With Lifestyle Changes, From Diet to Exercise and Social Time, New Study Suggests
- How to Scale Proteomics
- Gate-level emulation of an Intel 4004 in 4004 bytes of C
- Practical Static Analysis for Privacy Bugs
- How to reverse engineer an analog chip: the TDA7000 FM radio receiver
- The Making of D.
- How should we learn from bugs?
- The Math Is Haunted
- Does the Bitter Lesson Have Limits?
- HoareHoare Logic, Part I
- The many, many, many JavaScript runtimes of the last decade
- A Bytecode VM for Arithmetic: The Parser
- Emacs: The MacOS Bug
- polarizing parsers
- Behind the Scenes: My "How Computers Really Work" Series on Computerphile
- How the Brain Increases Blood Flow on Demand
- 2000 words about arrays and tables
- Why We Need to Know LR and Recursive Descent Parsing Techniques
- Writing memory efficient C structs
- Writing an OS in Rust
- Typechecking Is Undecidable When 'Type' Is A Type
- Learning Basic Electronics By Building FireFlies
- Simple and fast Rust deriving using macro_rules
- Learning Is Slower Than You Think — And That’s the Point
- LLM Embeddings Explained: A Visual and Intuitive Guide
- consensus
- You’re probably using the wrong dictionary
- Atomic Habits Summary
- Getting decent error reports in Bash when you're using 'set -e'
- Paul Dirac and the religion of mathematical beauty
- Heredocs Can Make Your Bash Scripts Self-Documenting
- Using fortune to reinforce habits
- Trust Deterministic Execution to Scale & Simplify Your Systems • Frank Yu • YOW! 2023
- Verified Assembly 2: Memory, RISC-V, Cuts for Invariants, and Ghost Code
- Advanced Rust macros with derive-deftly
- The Intel 4004 Microprocessor and the Silicon Gate Technology
- Development shells with Nix: four quick examples
- RealtimeKit and CPU Scheduling
- How often is the query plan optimal?
- Tail Latency Might Matter More Than You Think
- Why English doesn’t use accents
- Programming Extensible Data Types in Rust with CGP - Part 2: Modular Interpreters and Extensible Visitors
- Writing an IR from Scratch and survive to write a post - Eduardo Blázquez’s Personal Webpage
- Hacking Coroutines into C
- We Made Postgres Writes Faster, but it Broke Replication
- Can we test it? Yes, we can! - Mitchell Hashimoto
- Tree-Structured Concurrency II: Replacing Background Tasks With Actors — 2025-07-02
- Sort By Controversial
- Gödel's beavers, or the limits of knowledge
- Efficiency of a sparse hash table
- Austerity - Wikipedia
- How does a screen work?
- Let's Learn x86-64 Assembly! Part 0 - Setup and First Steps
- Strategies for very fast Lexers
- Human Stigmergy
- Feynman: Knowing versus Understanding
- Turing Machines: How Computers Evolved From People
- Making the assumption rule only apply to atoms
- Compiler bootstrapping in Nixpkgs
- Adding lookbehinds to rust-lang/regex
- Lessons From Creating My First Text Adventure
- Programming Extensible Data Types in Rust with CGP - Part 3: Implementing Extensible Records
- Reverse proxy deep dive
- constrained languages are easier to optimize
- A Smart Bear » Specificity: A weapon of mass effectiveness
- you are in a box
- RNA Is the Cell’s Emergency Alert System | Quanta Magazine
- Function Over Form: Why ‘Unbiological’ Neural Networks Are the Truest Simulation of the Brain #
- placing functions — 2025-07-08
- Computational Lambda-Calculus And Monads
- Program Synthesis: The λ in the Machine
- The Future of Maths May Be Deeply Weird
- My Ultimate Self-hosting Setup
- To be a better programmer, write little proofs in your head
- On The Unusual Effectiveness Of Logic In Computer Science
- Casey Muratori – The Big OOPs: Anatomy of a Thirty-five-year Mistake – BSC 2025
- Gödel’s Incompleteness Theorems
- Mario is (NP-) Hard
- What is a Transformer?
- LL and LR Parsing Demystified
- Automating Away Claude's Bad Habits with Hooks
- Hardest Problem in Computer Science: Centering Things
- A reckless introduction to Hindley-Milner type inference
- Algorithms for Modern Processor Architectures
- Cloudflare and the infinite sadness of migrations
- How to draw lambda diagrams
- To The Programmer
- Implementing a Functional Language with Graph Reduction
- Monotonic and Wall Clock Time in the Go time package
- The Future is NOT Self-Hosted
- Rust running on every GPU
- Formal specs as sets of behaviors
- What part of Hindley-Milner do you not understand?
- Basic facts about GPUs
- How NAT traversal works
- Writing a very simple JIT Compiler in about 1000 lines of C
- RE//verse 2025: Full-stack Reverse Engineering of the Original Microsoft Xbox (Markus Gaasedelen)
- Lies we tell ourselves to keep using Golang
- Rethinking Modern Asynchronous Paradigms
- Learning Containers From The Bottom Up
- Critical Architecture/Software Theory
- Propositions as Types
- The most important thing to understand about queues
- Meanings as programs: Programming Really Is Simple Mathematics
- Decomposing Transactional Systems
- How CouchDB Prevents Data Corruption: fsync
- 3 thoughts on “Paxos made visual in FizzBee”
- Implementing SQL JOIN Support in ChronDB via PostgreSQL Protocol
- Faster interpreters in Go: Catching up with C++
- Hacking the Postgres wire protocol
- SQLite Transactions and Virtual Tables
- Virtual Machine - Stack Arithmetic
- An epic treatise on error models for systems programming languages
- Practical Alloy
- Revisiting an early critique of formal verification
- An Introduction to Virtual Consensus in Delos
- Meaning as programs: Programming Really Is Simple Mathematic
- Introduction
- Concurrency bugs in Lucene: How to fix optimistic concurrency failures
- Just because you’re getting an index scan, doesn't mean you can’t do better!
- MySQL transactions per second vs fsyncs per second
- Land ahoy: leaving the Sea of Nodes
- What Fekete’s Anomaly Can Teach Us About Isolation
- How do LLMs work?
- Systems Correctness Practices at AWS
- Hacking a Smart Home Device
- Things that go wrong with disk IO
- Dice and Queues
- Size matter
- Snapshot Isolation vs Serializability
- Versioning versus Coordination
- How to Write Blog Posts that Developers Read
- Demystifying monads in Rust through property-based testing
- Comptime Zig ORM Mar 19, 2025
- Large Lambda Model
- Compiler Engineering for Substructural Languages I: The Problem with Polymorphism
- How to Sync Anything
- Flambda2 Ep. 4: How to write a purely functional compiler
- The Hitchhiker's Guide to Concurrency
- Parser Combinators Beat Regexes
- Build your own SQLite, Part 1: Listing tables
- BTrees, Inverted Indices, and a Model for Full Text Search
- How far neuroscience is from understanding brains
- Your Network, Your Rules: Take Charge With Own DNS
- How browsers REALLY load Web pages
- An HTTP Server in Go From scratch: Part 2
- A brief meditation on formal systems and lying goblins
- Anatomy of a Formal Proof
- Building a tiny Linux from scratch
- Try Snapshot Testing for Compilers and Compiler-Like Things
- Operating System in 1,000 Lines - Intro
- About 40 hours (23 min. read)
- Use of Time in Distributed Databases (part 2): Use of logical clocks in databases
- USB-C head-to-head comparison
- I Thought I Found a Bug…
- Against a universal definition of ‘type’ (pdf)
- Lock Files Considered Harmful
- Use of Time in Distributed Databases (part 1)
- A worked example of copy-and-patch compilation
- Problem Driven Development
- Post-apocalyptic programming
- Snapshot Isolation vs Serializability
- Goodhart's Law Isn't as Useful as You Might Think
- On btrfs and memory corruption
- Chi-Squared From Fundamentals
- Bayesian reasoning
- Utilizing highly synchronized clocks in distributed databases
- Parkinson's Law: It's Real, So Use It
- Property-testing async code in Rust to build reliable distributed systems
- An Intuitive Explanation of Bayes's Theorem
- Bayes theorem, and making probability intuitive – by 3Blue1Brown
- An Introduction To Bayesian Inference
- SemVer Is Not About You Nov 23, 2024
- Database mocks are just not worth it
- A Tricycle of the Mind
- The road to Emacs maximalism
- Technical Debt is Entropy In Software
- On Ada's Dependent Types, and its Types as a Whole
- Intel's $475 million error: the silicon behind the Pentium division bug
- Morris Chang and the Origins of TSMC - by Brian Potter Morris Chang and the Origins of TSMC
- Implementing and Verifying "Static Program Analysis" in Agda, Part 1: Lattices
- Reads causing writes in Postgres
- Server-Sent Events (SSE) Are Underrated
- seconds since the Epoch
- Deliver the Bare Minimum
- On long term software development: caring (enough) about the future
- How bloom filters made SQLite 10x faster
- Ideas from "A Philosophy of Software Design"
- The Canva outage: another tale of saturation and resilience
- UIs Should Be Versioned, Just Like We Version APIs
- Notes From Figma II: Engineering Learnings
- Turing Machines
- Pragmatic Category Theory | Part 1: Semigroup Intro
- Energy Cheat Sheet - by Brian Potter - Construction Physics Energy Cheat Sheet
- An Introduction to Residuality Theory - Barry O'Reilly - CPH DevFest 2024
- Pushing AMD’s Infinity Fabric to its Limits Pushing AMD’s Infinity Fabric to its Limits
- "Performance Matters" by Emery Berger
- (Mostly) Deterministic Simulation Testing in Go
- (1) How We Built a Self-Healing System to Survive a Terrifying Concurrency Bug At Netflix How We Built a Self-Healing System to Survive a Terrifying Concurrency Bug At Netflix
- How We Got the Lithium-Ion Battery - by Brian Potter How We Got the Lithium-ion Battery
- Your lying virtual eyes
- Telling Stories in Athenian Law
- Common Misconceptions about Compilers
- Networking For People Who Don't Network
- Implementing Raft: Part 0 - Introduction
- Lou's Pseudo 3d Page
- A CAP tradeoff in the wild
- In Search of an Understandable Consensus Algorithm
- Distributed Systems Horror Stories: Kubernetes Deep Health Checks
- Lectures on Relational Algebra
- Modern Hardware for Future Databases
- Dependent Types and the Art of HTTP Headers
- The Structure of a Worldview - by Regan The Structure of a Worldview
- On the Relationship Between Static Analysis and Type Theory
- The disaggregated write-ahead log
- Model checking safety of Ben-Or's Byzantine consensus with Apalache
- A Map of Sync
- Optimizers: The Low-Key MVP
- How Public Key Cryptography Really Works | Quanta Magazine
- Implementing Type Systems as Macros
- PSA: Most databases do not do checksums by default
- Extending MVCC to be serializable, in TLA+
- CAP is Good, Actually
- lorentz app
- The Prequel to SQL is SEQUEL
- Viewstamped Replication Revisited
- Transaction Isolation in Postgres, explained
- Two-phase commit and beyond
- The Soul of an Old Machine: Revisiting the von Neumann Architecture
- Building a distributed log using S3 (under 150 lines of Go)
- Disillusioning the Magic of the fork System Call Disillusioning the Magic of the fork System Call
- Quake 3 Source Code Review: Network Model (Part 3 of 5) >>
- Analytics-Optimized Concurrent Transactions
- Playground Wisdom: Threads Beat Async/Await
- An Overview of Distributed PostgreSQL Architectures
- Chapter on TLA+ - Software Specification Methods
- A Brief Introduction to Linear Types
- Checking linearizability in Go
- Real-Time Model Checking is Really Simple
- What To Use Instead of PGP
- How LLMs work
- LevelDB Explained - How to Analyze the Time Complexity of SkipLists?
- githublog/2024/11/1/sending-an-ethernet-packet.md at main · francisrstokes/githublog · GitHub
- Why I Will Always Be Angry About Software Engineering
- One thought on “Reading the Generalized Isolation Level Definitions paper with Alloy”
- Exploring Postgres's arena allocator by writing an HTTP server from scratch
- Data Modeling with Sums and Products
- Compilers: Incrementally and Extensibly
- Hey, wait – is employee performance really Gaussian distributed??
- Category Theory in Programming
- Crash Course on Notation in Programming Language Theory
- Fairness in TLA+
- Lamport clocks
- Build your own SQLite
- User Interface with Ant Tweak Bar
- The Lost Reading Items
- Linearizability in distributed systems
- Damas-Hindley-Milner inference two ways
- Surfing Complexity
- Solving the Mystery of ARM7TDMI Multiply Carry Flag
- Abstract Machines of Systems Biology
- There is No Now - ACM Queue
- Notes/Primer on Clang Compiler Frontend (1) : Introduction and Architecture - Youssef Ateya
- naklecha/llama3-from-scratch: llama3 implementation one matrix multiplication at a time
- Efficient and Insightful Generalization
- HTTP/1.0 From Scratch
- HTTP/0.9 From Scratch
- A Visual Guide to Quantization - by Maarten Grootendorst
- React Compiler, How Does It Work? [1] - Entry Point through Babel Plugin | 장용석 블로그
- Learning about PCI-e: Driver & DMA
- sigtt611-bernstein
- Introduction · Reverse Engineering
- Ray Tracing in One Weekend Series
- Intro | Putting the "You" in CPU
- Build your own SQLite, Part 1: Listing tables
- Learning LLVM (Part-2)
- RFC 677: Maintenance of duplicate databases
- interdb.jp
- How to Create a Liquid Raymarching Scene Using Three.js Shading Language | Codrops
- Linear Algebra Fundamentals
- A Race to the Bottom - Database Transactions Undermining Your AppSec · Doyensec's Blog
- An Incremental Approach to Compiler Construction
- CSS GPU Animation: Doing It Right — Smashing Magazine
- Welcome … — Physics-based Deep Learning
- time-clocks
- Modeling B-trees in TLA+ – Surfing Complexity
- What every systems programmer should know about concurrency
- A TUTORIAL ON POINTERS AND ARRAYS IN C
- Trying Kolmogorov-Arnold Networks in Practice - Casey Primozic's Homepage
- Neo Geo Architecture | A Practical Analysis
- full-issue
- A snapshot isolated database modeling in TLA+
- TLA+ modeling of a single replicaset transaction modeling
- The Work Life of Developers: Activities, Switches and Perceived Productivity
- Hermitage: Testing the “I” in ACID — Martin Kleppmann’s blog
- malloc
- Malloc_tutorial
- making regex from scratch in GO - Lewis Metcalf
- Virtualization Internals Part 1 - Intro to Virtualization | Saferwall
- Reversing Choplifter – Blondihacks
- Hacking Millions of Modems (and Investigating Who Hacked My Modem)
- Understanding V8's Bytecode
- Say Hello to 1-based indexing in JavaScript!
- Writing My Own Database From Scratch
- Introduction - Habitual Mastery (Series) - Scott H Young
- Spaced Repetition for Efficient Learning · Gwern.net
- Let's write a video game from scratch like it's 1987
- 500 Lines or LessAn Archaeology-Inspired Database
- Ownership
- Always Measure One Level Deeper – Communications of the ACM
- Exponentially Better Rotations
- Scratchapixel 4.0, Learn Computer Graphics Programming
- NULL BITMAP Builds a Database #1: The Log is Literally the Database • Buttondown
- Mediocre Engineer’s guide to HTTPS
- staniks.github.io
- The Back-to-Basics Readings of 2012 | All Things Distributed
- A Road to Common Lisp / Steve Losh
- Implementing MVCC and major SQL transaction isolation levels | notes.eatonphil.com
- ISP Column - April 2024
- adam-maj/tiny-gpu: A minimal GPU design in Verilog to learn how GPUs work from the ground up
- Parsing and all that
- Do you really need IPv4 anymore?
- Garbage Collection for Systems Programmers
- Optimizing Javascript for fun and for profit
- Type system of the React compiler
- Sega Saturn Architecture | A Practical Analysis
- So you think you want to write a deterministic hypervisor?
- The Beginner’s Guide to Queuing theory | Qminder
- Design is an Island - by Kent Beck
- Tecno S8C
- What are 1-bit LLMs?. The Era of 1-bit LLMs with BitNet b1.58 | by Mehul Gupta | Data Science in your pocket | Mar, 2024 | Medium
- Checking Causal Consistency of MongoDB
- The CAP Theorem. The Bad, the Bad, & the Ugly | Dominik Tornow
- A Deep Dive into the Underlying Architecture of Groq's LPU
- Motorola's 6809 : The Best 8-Bit? - by Babbage
- Byte Interviews the Apple Lisa Dev Team (1983)
- Airfoil – Bartosz Ciechanowski
- My thoughts on writing a Minecraft server from scratch (in Bash)
- Learn CSS Layout The Pedantic Way
- Understanding GPU caches – RasterGrid
- Demystifying GPUs for CPU-centric programmers | Medium
- Shape Up: Stop Running in Circles and Ship Work that Matters
- 2024-02-25 a history of the tty
- Build your own Database Index: part 1
- Software infrastructure 2.0: a wishlist · Erik Bernhardsson
- Bloom Filters
- Distributed Logical Time
- An intuition for distributed consensus in OLTP systems | notes.eatonphil.com
- Demystifying GPU Compute Architectures - by Babbage