cs.
- Part I: how does gradient descent work?
- Writing an LLM from scratch, part 22 -- finally training our LLM!
- Computer Vision: Algorithms and Applications, 2nd ed.
- Evidence that Recent AI Gains are Mostly from Inference-Scaling
- fi-le.net,
- Beyond Orthogonality: How Language Models Pack Billions of Concepts into 12,000 Dimensions
- I built ChatGPT with Minecraft redstone!
- Transformers KV Caching Explained
- GPT-2 Neural Network Poetry
- Prompt Engineering Guide
- Context Engineering for AI Agents: Lessons from Building Manus
- What is a Transformer?
- Learnings from building AI agents
- Building Effective AI Agents
- Building a Linear Regression from Scratch with Python & Mathematics
- The Annotated Kolmogorov-Arnold Network (KAN)
- The Annotated Transformer
- How do LLMs work?
- Large Lambda Model
- A Field Guide to Rapidly Improving AI Products
- The 2025 AI Engineer Reading List
- The Lost Reading Items
- A Deep Dive into the Underlying Architecture of Groq's LPU
- 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
- A Visual Guide to Vision Transformers | MDTURP
- Ilya 30u30
- karpathy/LLM101n: LLM101n: Let's build a Storyteller
- NMI_Review
- Trying Kolmogorov-Arnold Networks in Practice - Casey Primozic's Homepage
- Deep-ML
- Welcome … — Physics-based Deep Learning
- Let's reproduce GPT-2 (1.6B): one 8XH100 node, 24 hours, $672, in llm.c · karpathy/llm.c · Discussion #677
- interdb.jp
- soulmachine/machine-learning-cheat-sheet: Classical equations and diagrams in machine learning
- Ask HN: What are some "toy" projects you used to learn neural networks hands-on? | Hacker News
- A Visual Guide to Quantization - by Maarten Grootendorst
- naklecha/llama3-from-scratch: llama3 implementation one matrix multiplication at a time
- Tensor Labbet · A blog of deep learnings
- How to train a model on 10k H100 GPUs?
- Monty Anderson
- Extra, Extra - Read All About It: Nearly All Binary Searches and Mergesorts are Broken
- Cache-Friendly B+Tree Nodes With Dynamic Fanout
- Bloom Filters by Example
- Breaking “provably correct” Leftpad
- Let’s Prove Leftpad
- 12 thoughts on “How to *actually* test your readme”
- Fail Fast
- Don't write bugs
- Look Out For Bugs
- Software books I wish I could read
- Lobsters Interview with Icefox
- How to draw lambda diagrams
- To The Programmer
- technicalities: "not rocket science" (the story of monotone and bors)
- Mathematics for Computer Science
- Basic facts about GPUs
- Maybe writing speed actually is a bottleneck for programming
- Inverse Triangle Inequality Jul 7, 2025
- Logical Quantifiers in Software
- Queuing Theory on a Cocktail Napkin by Dan Slimmon | DC Systems 007
- Inference in Agda
- How to Think About Time in Programming
- Variables Pt. 2
- Just fucking code.
- What Every Programmer Should Know about How CPUs Work • Matt Godbolt • GOTO 2024
- Crafting your environment
- What every computer science major should know
- The Ingredients of a Productive Monorepo
- Rethinking Modern Asynchronous Paradigms
- Critical Architecture/Software Theory
- Meanings as programs: Programming Really Is Simple Mathematics
- Solving SICP
- Push Ifs Up And Fors Down Nov 15, 2023
- Meaning as programs: Programming Really Is Simple Mathematic
- The Hitchhiker's Guide to Concurrency
- My favorite technical blogs
- The Computer Backup Rule of Three
- Philosophy and Methodology of Experiments
- Programming Really Is Simple Mathematics
- 1. Lambda Calculus - Grammar & Terms
- XOR in boolean logic
- The magic of metalinguistic programming The magic of metalinguistic programming
- Basic Awareness in Addition to Deep Understanding
- That's Not an Abstraction, That's Just a Layer of Indirection
- Against a universal definition of ‘type’ (pdf)
- Lock Files Considered Harmful
- Andrew Kelley Practical Data Oriented Design (DoD)
- Problem Driven Development
- Formal Methods: Just Good Engineering Practice?
- Post-apocalyptic programming
- On btrfs and memory corruption
- SemVer Is Not About You Nov 23, 2024
- A Tricycle of the Mind
- On Ada's Dependent Types, and its Types as a Whole
- Intel's $475 million error: the silicon behind the Pentium division bug
- Implementing and Verifying "Static Program Analysis" in Agda, Part 1: Lattices
- Server-Sent Events (SSE) Are Underrated
- seconds since the Epoch
- Turing Machines
- An Introduction to Residuality Theory - Barry O'Reilly - CPH DevFest 2024
- "Performance Matters" by Emery Berger
- Confusing or misunderstood topics in systems programming: Part 0
- GitHub - facundoolano/software-papers: 📚 A curated list of papers for Software Engineers
- The only computer science book worth reading twice?
- Probability for Computer Scientists
- Table of Contents
- On the cruelty of really teaching computing science
- Computer Organization E-book by Stephen Marz
- Dobiasd/articles: thoughts on programming
- Here is why vim uses hjkl keys as arrow keys
- An IRC client in your motherboard | Phillip Tennen
- Discrete logic IC CPU | Ivan's blog
- Double-Entry Bookkeeping as a Directed Graph · Matheus Portela
- oss-security - Make your own backdoor: CFLAGS code injection, Makefile injection, pkg-config
- Formal Methods: Just Good Engineering Practice? - Marc's Blog
- Linux text manipulation
- Tips on how to structure your home directory
- Parsing and all that
- Halo 2 in HD: Pushing the Original Xbox to the Limit – I Code 4 Coffee
- Good Ideas in Computer Science ・ Daniel Hooper
- adam-maj/tiny-gpu: A minimal GPU design in Verilog to learn how GPUs work from the ground up
- Bytecode VMs in surprising places
- Ansible is a Lisp
- Abstract Heresies: Statements and Expressions
- Study of Historical Code | ℤ→ℤ
- Figma’s journey to TypeScript | Figma Blog
- How to Build a $20 Billion Semiconductor Fab
- Why Full Text Search is Hard
- "Integration tests" are just vibes • Buttondown
- Chris's Wiki :: blog/tech/UEFIAndBIOSAndOtherPCTerms
- Safety and Liveness Properties
- Visualization Mnemonics for Software Principles - DaedTech
- Exploring Hacker News by mapping and analyzing 40 million posts and comments for fun | Wilson Lin
- GPUs Go Brrr · Hazy Research
- Bye Opam, Hello Nix | Emil Privér
- Implementing MVCC and major SQL transaction isolation levels | notes.eatonphil.com
- Reading C type declarations
- So we built a Reverse Tunnel in Go over HTTP/3 and QUIC | Flipt Blog
- A New Way to Store Knowledge
- Tools That Make You Feel Empowered
- A Road to Common Lisp / Steve Losh
- Write yourself a Git!
- Ilya 30u30
- Megaparsec tutorial
- Queueing – An interactive study of queueing strategies – Encore Blog
- Old Dogs, new CSS Tricks | Max Böck
- Evolution of the ELF object file format | MaskRay
- Writing a Unix clone in about a month
- Functional TypeScript #1: Algebraic Data Types
- CRDT: Text Buffer - Made by Evan
- What Color is Your Function? – journal.stuffwithstuff.com
- Regular, Recursive, Restricted
- Learn OpenGL, extensive tutorial resource for learning Modern OpenGL
- A (Draft) Taxonomy of SIMD Usage – Branch Free
- Data Modeling in Document Databases for the RDBMS-Minded
- Build Your Own X
- Legend of Worlds
- Proxmox vs FreeBSD: Which Virtualization Host Performs Better? - IT Notes
- staniks.github.io
- Things you wish you didn't need to know about S3
- Mediocre Engineer’s guide to HTTPS
- Making USB devices - end to end guide to your first gadget
- NULL BITMAP Builds a Database #1: The Log is Literally the Database • Buttondown
- Never, Sometimes, Always - lukeplant.me.uk
- The Law of Leaky Abstractions – Joel on Software
- Always Measure One Level Deeper
- Always Measure One Level Deeper – Communications of the ACM
- Cheng Lou - "On the Spectrum of Abstraction" summarized transcript (React Europe 2016)
- The Unix and Internet Fundamentals HOWTO
- How to Test
- How terminal works. Part 1: Xterm, user input | Thoughts-chain
- making regex from scratch in GO - Lewis Metcalf
- Differential Analysis: A Summary
- Malloc_tutorial
- malloc
- How much memory does a call to ‘malloc’ allocates? – Daniel Lemire's blog
- "Simple Made Easy" - Rich Hickey (2011)
- My programming beliefs as of July 2024
- Programmers Should Never Trust Anyone, Not Even Themselves
- The sad state of property-based testing libraries
- Reverse Engineering the Verification QR Code on my Diploma
- A TUTORIAL ON POINTERS AND ARRAYS IN C
- What every systems programmer should know about concurrency
- Serving a billion web requests with boring code - llimllib notes
- The Architecture of Open Source Applications (Volume 1)Berkeley DB
- The Architecture of Open Source Applications
- 89 things I know about Git commits · Jamie Tanna | Software Engineer
- Beating the L1 cache with value speculation
- sbensu: We need visual programming. No, not like that.
- Software Engineering Is Not Engineering | Brain Baking
- Keep perfecting your config • Buttondown
- The Backup And Sync Strategy, Revised | Brain Baking
- Parse, don’t validate
- A weekend's (re)reading list | Ludwig
- Art of Assembly Language, PDF Files
- Some Books I Like // One Year of NULL BITMAP • Buttondown
- A ToC of the 20 part linker essay [LWN.net]
- My Software Bookshelf | olano.dev
- The Fundamental Law Of Software Dependencies
- Practices of Reliable Software Design
- Books - Computing History
- Applied Mathematical Programming
- Go To Statement Considered Harmful
- Magic isn’t real - Inside thoughts
- Terminal colours are tricky
- How to convince engineers that formal methods is cool • Buttondown
- sled book shop | sled-rs.github.io
- Cognitive load
- How do Graphics Cards Work? Exploring GPU Architecture
- Arrows to Arrows, Categories to Queries
- What is Algebraic about Algebraic Effects?
- Typechecker Zoo
- Build Your Own Lisp Learn C and build your own programming language in 1000 lines of code!
- Linear types for programmers
- What Declarative Languages Are
- Implementing a Functional Language with Graph Reduction
- Programming Language Theory has a public relations problem
- What is cosh(List(Bool))? Or beyond algebra: analysis of data types.
- Access Control Syntax
- Why Algebraic Effects
- An epic treatise on error models for systems programming languages
- Flattening ASTs (and Other Compiler Data Structures)
- The magic of metalinguistic programming The magic of metalinguistic programming
- Compilers: Incrementally and Extensibly
- Crash Course on Notation in Programming Language Theory
- What implementation-independent test file formats exist for language tooling?
- How should I read type system notation?
- Terms, types, and functions
- Classic Papers in Programming Languages and Logic
- An Incremental Approach to Compiler Construction
- Programming languages resources | Max Bernstein
- What’s in an e-graph? | Max Bernstein
- Chapter 0 Preface — Programming Languages
- Alpha Conversion | Kevin Sookocheff
- glouw/c8c: The chip8 compiler, assembler, and virtual machine
- Introduction to the λ-calculus
- bytecode interpreters for tiny computers ⁑ Dercuano
- A modern approach to preventing CSRF in Go
- Go Data Structures: Interfaces
- Lies we tell ourselves to keep using Golang
- Think OS
- Writing an operating system kernel from scratch
- Building a tiny Linux from scratch
- Operating System in 1,000 Lines - Intro
- Doing more than one thing at a time: how do computers runm multiple independent programs
- Userland Disk I/O
- Setting up an x86 CPU in 64-bit mode
- advanced-linux-programming
- Tales of the M1 GPU - Asahi Linux
- Linux's Bedtime Routine – Tookmund – A place for my random thoughts about software
- Which kernel is the most readable one? | Lobsters
- Copatterns
- Controlling Copatterns: There And Back Again
- Zippers: Making Functional "Updates" Efficient
- List is a monad (part 1)
- What is Algebraic about Algebraic Effects?
- Property-Based Testing of OCaml 5's Runtime System - Midtgaard:OLIVIERFEST25.pdf
- Type Theory & Functional Programming
- Functors, Applicatives, And Monads In Pictures
- Of Course ML Has Monads!
- Monads are not like burritos
- Demystifying monads in Rust through property-based testing
- Total functions and beyond
- Lambda Calculus and Lisp, part 1
- Algebraic effects are a functional approach to manage side effects
- fold-… and monoids
- I Don’t Use Monads
- The Monads Hurt My Head — But Not Anymore
- williamdemeo/TypeFunc: Resources for type theory, functional programming, etc.
- Megaparsec tutorial
- You probably wrote half a monad by accident – Andy G's Blog
- Lensy Moore
- Agda by Example: λ-calculus
- Higher-kinded Bounded Polymorphism
- William Cotton
- A Dictionary of Single-Letter Variable Names | Blog | jackkelly.name
- Self-Extracting F3
- The Write Stuff: Concurrent Write Transactions in SQLite
- A visual explanation of the PGM Index
- Cache-Friendly B+Tree Nodes With Dynamic Fanout
- How to store ordered information in a Relational Database
- #08 - B+Tree Data Structure (CMU Intro to Database Systems)
- wal3: A Write-Ahead Log for Chroma, Built on Object Storage
- Consistency Models
- We Made Postgres Writes Faster, but it Broke Replication
- Efficiency of a sparse hash table
- NULLBITMAPGPT
- Bloom Filters by Example
- Time Series Forecasting with Graph Transformers
- Double-Entry Ledgers: The Missing Primitive in Modern Software
- SSTable and Log Structured Storage: LevelDB
- Memtable & SSTable (Sorted String Table)
- IO devices and latency
- Battle of the Mallocators
- Transactions are a protocol
- Decomposing Transactional Systems
- How CouchDB Prevents Data Corruption: fsync
- Implementing SQL JOIN Support in ChronDB via PostgreSQL Protocol
- Faster interpreters in Go: Catching up with C++
- Just Throw It Into Postgres
- Hacking the Postgres wire protocol
- SQLite Transactions and Virtual Tables
- 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
- What Fekete’s Anomaly Can Teach Us About Isolation
- Things that go wrong with disk IO
- Size matter
- Snapshot Isolation vs Serializability
- Versioning versus Coordination
- The Challenge
- Comptime Zig ORM Mar 19, 2025
- How to Sync Anything
- Build your own SQLite, Part 1: Listing tables
- 🦀 Building a search engine from scratch, in Rust: part 1
- BTrees, Inverted Indices, and a Model for Full Text Search
- It's Time to Stop Building KV Databases
- 2024's hottest topics in databases (a bibliometric approach)
- SQL Indexing and Tuning e-Book
- Added Replication Slots in
- Can we use this index, please? – Why not?
- Snapshot Isolation vs Serializability
- Reads causing writes in Postgres
- How bloom filters made SQLite 10x faster
- Lectures on Relational Algebra
- Modern Hardware for Future Databases
- Data Replication Design Spectrum
- PSA: Most databases do not do checksums by default
- The Prequel to SQL is SEQUEL
- SQLite Index Visualization: Search
- Herding elephants: Lessons learned from sharding Postgres at Notion
- Predictive Scaling in MongoDB Atlas, an Experiment
- Pessimistic or Optimistic Concurrency Control? Lessons Learned from Real-World Customer Scenarios
- 7 Databases in 7 Weeks for 2025
- SQLite Index Visualization: Structure
- Understanding the BM25 full text search algorithm
- Build your own SQLite
- Building Databases over a Weekend
- Zero Disk Architecture
- Userland Disk I/O
- PSA: SQLite does not do checksums
- Tunable Consistency in MongoDB
- B+-Tree Indexes
- Evolution of tree data structures for indexing: more exciting than it sounds · Erthalion's blog
- Bloom Filters
- Build your own Database Index: part 1
- SQLite Internals: Pages & B-trees · The Fly Blog
- How Figma's Databases Team Lived to Tell the Scale | Figma Blog
- Checking Causal Consistency of MongoDB
- Implementing MVCC and major SQL transaction isolation levels | notes.eatonphil.com
- Data Modeling in Document Databases for the RDBMS-Minded
- NULL BITMAP Builds a Database #1: The Log is Literally the Database • Buttondown
- 500 Lines or LessAn Archaeology-Inspired Database
- Counted B-Trees
- Writing My Own Database From Scratch
- antoniosarosi/mkdb: Toy Database
- Database anomalies and isolation levels |
- Introduction | Bmg documentation
- A write-ahead log is not a universal part of durability | notes.eatonphil.com
- Elaboration of the PostgreSQL sort cost model
- full-issue
- Dirty writes – Surfing Complexity
- Modeling B-trees in TLA+ – Surfing Complexity
- Synchronization is bad for scale
- O tal do Isolamento no A.C.I.D. - Alen Vieira
- A Race to the Bottom - Database Transactions Undermining Your AppSec · Doyensec's Blog
- SQLite Transactions
- Alternative Technologies
- PostgreSQL triggers and isolation levels - Vlad Mihalcea
- Build your own SQLite, Part 1: Listing tables
- Rediscovering Transaction Processing From History and First Principles
- Database Indexes & Phone Books - by Thorsten Ball
- B-trees
- Database “sharding” came from UO? – Raph's Website
- Implementing HanoiDB - Session 1: Introduction
- B-trees and database indexes
- How Discord Stores Trillions of Messages
- Integrity Constraints and the Relational Derivative • Buttondown
- How to Avoid Fighting Rust Borrow Checker
- Hypervisor 101 in Rust
- Elements of Rust - Core Types and Traits
- Advanced Rust macros with derive-deftly
- Adding lookbehinds to rust-lang/regex
- Programming Extensible Data Types in Rust with CGP - Part 3: Implementing Extensible Records
- placing functions — 2025-07-08
- Rust running on every GPU
- How much code does that proc macro generate?
- Designing Error Types in Rust Libraries
- Newtyped Indices are Proofs
- Rust Collections Case Study: BTreeMap
- The Challenge
- Demystifying monads in Rust through property-based testing
- Async from scratch 1: What's in a Future, anyway?
- How does async Rust work
- Rust versions of TAPL's System F and System F-omega type checkers
- rust-gpu.github.io
- Error Handling in a Correctness-Critical Rust Project | sled-rs.github.io
- Whence '\n'? – Casey Rodarmor's Blog
- A Guide For Wireguard VPN Setup With Pi-Hole Adblock and Unbound DNS
- VPS Setup and Security Checklist: Complete Self-Hosting Guide for 2025
- Why We're Building Stategraph: Terraform State as a Distributed Systems Problem
- How Container Filesystem Works: Building a Docker-like Container From Scratch
- iPhone DevOps - ultimate edition
- How We Migrated 30+ Kubernetes Clusters to Terraform
- Learning Containers From The Bottom Up
- Impromptu disaster recovery
- Expose an external resource with a Kubernetes Ingress
- The surreal joy of having an overprovisioned homelab
- Getting Started with OpenTelemetry Visualization - A Practical Guide
- Setting Up Prometheus, Grafana, Loki, Tempo & Mimir for end-to-end Monitoring & Logging Atmosly
- Prometheus 101: Metrics, Monitoring, Practical Setup and More
- Monitoring Your Apps in Kubernetes Environment with Prometheus
- How I backup | Derek Sivers
- Paul Butler – The hater’s guide to Kubernetes
- Linux Crisis Tools
- Building My First Homelab Server Rack · mtlynch.io
- My new home server · g/ianguid/o.today
- The Time Linkerd Erased My Load Balancer
- Proxmox vs FreeBSD: Which Virtualization Host Performs Better? - IT Notes
- A gentle guide to self-hosting your software | ᕕʕ •ᴥ•ʔ୨ Shank Space
- Understanding DNS resolution on Linux and Kubernetes
- A Guide For Wireguard VPN Setup With Pi-Hole Adblock and Unbound DNS
- Designing a Low Latency 10G Ethernet Core - Part 1 (Introduction)
- Reverse proxy deep dive
- Cloudflare and the infinite sadness of migrations
- Why your website should be under 14kB in size
- How to bring data centre-like connectivity to your home with IPTTTH
- How NAT traversal works
- Beej's Guide to Networking Concepts
- Your Network, Your Rules: Take Charge With Own DNS
- What is wrong with the architecture of the Internet?
- .arpa, rDNS and a few magical ICMP hacks
- An HTTP Server in Go From scratch: Part 2
- Quake 3 Source Code Review: Network Model (Part 3 of 5) >>
- Understanding Round Robin DNS - by Zsolt Ero Understanding Round Robin DNS
- >>> 2024-02-11 the top of the DNS hierarchy (PDF)
- Can't trust any VPN these days
- POV: I'm on my third coffee and you just asked me how the internet works
- Do you really need IPv4 anymore?
- ISP Router Design Mistakes | Brain Baking
- ISP Column - April 2024
- So we built a Reverse Tunnel in Go over HTTP/3 and QUIC | Flipt Blog
- staniks.github.io
- Mediocre Engineer’s guide to HTTPS
- The Unix and Internet Fundamentals HOWTO
- What is a CIDR trie and how can it help you? · blog | sven kanoldt
- The Hazardous Life of an Undersea Cable
- 1989 Networking: NetWare 386 | OS/2 Museum
- kiennt26's home | Linux Network Performance Ultimate Guide
- The Illustrated QUIC Connection: Every Byte Explained
- Ethernet History Deepdive – Why Do We Have Different Frame Types? – Daniels Networking Blog
- How SSH Secures Your Connection :: Noratrieb's blog
- Self-hosting DNS - GHOST
- DNS "propagation" is actually caches expiring
- NetworkManager or networkd [LWN.net]
- Visual guide to SSH tunneling and port forwarding - ITTAVERN.COM
- TCP Server in Zig - Part 1 - Single Threaded
- Why TCP needs 3 handshakes | PixelsTech
- Let the network tell you where you are: a nerd snipe story
- Understanding DNS resolution on Linux and Kubernetes
- It Takes Two to Contract
- Building and operating a pretty big storage system called S3
- "Testing Distributed Systems w/ Deterministic Simulation" by Will Wilson
- So, You Want to Learn More About Deterministic Simulation Testing?
- The FLP theorem
- Advanced Testing and Determinism
- Knowledge and Common Knowledge in a Distributed Environment, Part 2
- wal3: A Write-Ahead Log for Chroma, Built on Object Storage
- Strong Eventual Consistency - The Big Idea behind CRDTs
- Knowledge and Common Knowledge in a Distributed Environment, Part 1
- Bits and pieces
- BUGGIFY
- Optimizing our way through Metroid
- Consistency Models
- What even is distributed systems
- Viewstamped Replication: The Less-Famous Consensus Protocol
- Why You Should Build Durable Workflows With Postgres
- Implementing Viewstamped Replication protocol
- Monotonic and Wall Clock Time in the Go time package
- A distributed systems reliability glossary
- Homomorphically Encrypting CRDTs
- Conformance Checking at MongoDB: Testing That Our Code Matches Our TLA+ Specs
- How Long Must I Test?
- A Brief Tour of FLP Impossibility
- What's the big deal about Deterministic Simulation Testing?
- Can We Rely On Timers For Distributed Algorithms?
- TigerBeetle 0.16.11
- How Scale Makes Distributed Systems Slower • Jonathan Magen • GOTO 2024
- Good Performance for Bad Days
- Overcoming the Legacy Code Challenge
- Onwards to the Core: etcd
- Statistical Properties: Are We Serious?
- 3 thoughts on “Paxos made visual in FizzBee”
- Antithesis driven testing
- An Introduction to Virtual Consensus in Delos
- Systems Correctness Practices at AWS
- Distributed Systems Programming Has Stalled
- Model error
- One or Two? How Many Queues?
- Versioning versus Coordination
- Resilience: some key ingredients
- Catalog of Patterns of Distributed Systems
- Leader election with S3 and If-Match
- Queues Don't Fix Overload
- Use of Time in Distributed Databases (part 2): Use of logical clocks in databases
- Use of Time in Distributed Databases (part 1)
- Snapshot Isolation vs Serializability
- Utilizing highly synchronized clocks in distributed databases
- Property-testing async code in Rust to build reliable distributed systems
- The Canva outage: another tale of saturation and resilience
- (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
- Implementing Raft: Part 0 - Introduction
- Distributed Erlang
- In Search of an Understandable Consensus Algorithm
- Data Replication Design Spectrum
- Extending MVCC to be serializable, in TLA+
- Viewstamped Replication Revisited
- Two-phase commit and beyond
- An Overview of Distributed PostgreSQL Architectures
- Herding elephants: Lessons learned from sharding Postgres at Notion
- Real-Time Model Checking is Really Simple
- Local Optimizations Don't Lead to Global Optimums
- Read, Write, Execute
- 𝔇𝔢𝔱𝔢𝔯𝔪𝔦𝔫𝔦𝔰𝔱𝔦𝔠 𝔰𝔦𝔪𝔲𝔩𝔞𝔱𝔦𝔬𝔫 𝔱𝔢𝔰𝔱𝔦𝔫𝔤
- Fairness in TLA+
- How to do distributed locking
- asatarin/testing-distributed-systems: Curated list of resources on testing distributed systems
- Learning and reviewing system internals: tactics and psychology
- Lamport clocks
- Zero Disk Architecture
- Petnames: A humane approach to secure, decentralized naming
- TLA from first principles
- If you don’t examine what worked, how will you know what works?
- It's About the Guarantees
- Pattern: Event sourcing
- Pattern: Saga
- Sensors and gauges - Observability in distributed systems
- Five Common Misconceptions About Event-Driven Architecture
- Linearizability in distributed systems
- Surfing Complexity
- Multi-version concurrency control in TLA+
- An intuition for distributed consensus in OLTP systems | notes.eatonphil.com
- Distributed Logical Time
- The CAP Theorem. The Bad, the Bad, & the Ugly | Dominik Tornow
- CAP is Good, Actually • Buttondown
- So you think you want to write a deterministic hypervisor?
- Deterministic Simulation Testing | Resonate
- The problem with invariants is that they change over time – Surfing Complexity
- The Back-to-Basics Readings of 2012 | All Things Distributed
- CRDT: Text Buffer - Made by Evan
- A Distributed Systems Reading List
- zine-ali
- Hermitage: Testing the “I” in ACID — Martin Kleppmann’s blog
- TLA+ modeling of a single replicaset transaction modeling
- A snapshot isolated database modeling in TLA+
- Falsehoods Software Developers Believe About Event-Driven Systems · Blog · Loïc Carr
- Dirty writes – Surfing Complexity
- Modeling B-trees in TLA+ – Surfing Complexity
- Synchronization is bad for scale
- time-clocks
- untitled1.html
- RFC 677: Maintenance of duplicate databases
- time-clocks
- sigtt611-bernstein
- Let's Consign CAP to the Cabinet of Curiosities - Marc's Blog
- Consensus
- Not Just Scale - Marc's Blog
- Simple event broker tries Tiger Style
- Vector Clocks Explained
- Predicting the Future of Distributed Systems
- Best resources to learn about data and distributed systems - Pierre Zemb
- Learning about distributed systems: where to start?
- Notes on Distributed Systems for Young Bloods – Something Similar
- Distributed systems theory for the distributed systems engineer | Paper Trail
- State and time are the same thing • Buttondown
- Thoughts on "The Future of TLA+" • Buttondown
- On distributed systems | Distributed Systems by Szymon Durak
- Taming Consensus in the Wild (with the Shared Log Abstraction)
- ATProto for distributed systems engineers - AT Protocol
- Constraining writers in distributed systems
- Erasure Coding for Distributed Systems
- Raft
- CRDTs go brrr
- The Writings of Leslie Lamport
- There is No Now - ACM Queue
- An Illustrated Proof of the CAP Theorem
- Why do systems fail? Tandem NonStop system and fault tolerance
- A liveness example in TLA+ – Surfing Complexity
- start - TLA+ Wiki
- Distributed Systems Reading List
- start - TLA+ Wiki
- Type Branding in Typescript
- Land ahoy: leaving the Sea of Nodes
- Turbocharging V8 with mutable heap numbers
- How we shrunk our Javascript monorepo git size by 94%
- articles/internals_of_the_async_await_pattern_from_first_principles.md at master · Dobiasd/articles
- Using d8 · V8
- Elements kinds in V8 · V8
- Monitoring Node.js: Watch Your Event Loop Lag! - David Hettler 🥨
- How we tamed Node.js event loop lag: a deepdive | Trigger.dev
- Many Hard Leetcode Problems are Easy Constraint Problems
- Why Bloom filters?
- Rust Collections Case Study: BTreeMap
- Understanding the BM25 full text search algorithm
- Smolderingly fast b-trees
- Visualizing Algorithms
- How to implement a hash table (in C)
- Visual Data Structures Cheat-Sheet - by Nick M
- B-trees
- Walking around the compiler
- LL and LR Parsing Demystified
- Store tags after payloads
- Working through ‘Writing A C Compiler’
- Writing a very simple JIT Compiler in about 1000 lines of C
- You Are The Compiler
- What I talk about when I talk about IRs
- I wrote a compiler
- How can one write blazing fast yet useful compilers (for lazy pure functional languages)?
- Transpiler, a meaningless word
- Newtyped Indices are Proofs
- Faster interpreters in Go: Catching up with C++
- Virtual Machine - Stack Arithmetic
- Land ahoy: leaving the Sea of Nodes
- Compiler Engineering for Substructural Languages I: The Problem with Polymorphism
- Flambda2 Ep. 4: How to write a purely functional compiler
- Parser Combinators Beat Regexes
- Try Snapshot Testing for Compilers and Compiler-Like Things
- Flattening ASTs (and Other Compiler Data Structures)
- A worked example of copy-and-patch compilation
- Common Misconceptions about Compilers
- Compilers: Incrementally and Extensibly
- Compiler Theory and Reactivity
- Writing an IR from Scratch and survive to write a post - Eduardo Blázquez’s Personal Webpage
- Say Hello to 1-based indexing in JavaScript!
- Understanding V8's Bytecode
- Using d8 · V8
- An Incremental Approach to Compiler Construction
- On reading about optimizing compilers | Ludwig
- little-languages
- Learning LLVM (Part-2)
- lecture18
- How to Compile Your Language
- Crafting Interpreters with Rust: On Garbage Collection | Tung Le Vo
- The Compiler Writer Resource Page
- Efficient and Insightful Generalization
- Notes/Primer on Clang Compiler Frontend (1) : Introduction and Architecture - Youssef Ateya
- Ask HN: Resources for GPU Compilers? | Hacker News
- Dick Grune's Annotated Literature Lists
- Typed Lambda Calculus / Calculus of Constructions
- Programming with Lambda Calculus
- Programming languages resources | Max Bernstein
- How does it feel to test a compiler? | by Alexander Zakharenko | Jul, 2024 | Medium
- What’s in an e-graph? | Max Bernstein
- glouw/c8c: The chip8 compiler, assembler, and virtual machine
- bytecode interpreters for tiny computers ⁑ Dercuano
- So, You Want to Learn More About Deterministic Simulation Testing?
- Advanced Testing and Determinism
- The Fuzzing Book
- Property-testing async code in Rust to build reliable distributed systems
- Database mocks are just not worth it
- (Mostly) Deterministic Simulation Testing in Go
- 𝔇𝔢𝔱𝔢𝔯𝔪𝔦𝔫𝔦𝔰𝔱𝔦𝔠 𝔰𝔦𝔪𝔲𝔩𝔞𝔱𝔦𝔬𝔫 𝔱𝔢𝔰𝔱𝔦𝔫𝔤
- What implementation-independent test file formats exist for language tooling?
- asatarin/testing-distributed-systems: Curated list of resources on testing distributed systems
- Property-based Testing Patterns
- Crushing Castlevania with Antithesis
- Deterministic Simulation Testing | Resonate
- The sad state of property-based testing libraries
- Basic Type System Terminology
- Ownership
- Agda by Example: λ-calculus
- Hypervisor 101 in Rust
- Strategies for very fast Lexers
- a timeline -- V3.1
- Parsing is Search
- Mario is (NP-) Hard
- The Halting Problem is a terrible example of NP-Harder
- Turing Machines
- Caching is an Abstraction, not an Optimization
- Zig's New Async I/O
- Using Generics to Inject Stubs when Testing
- Zig and Emulators
- Closures in Zig
- TCP Server in Zig - Part 1 - Single Threaded
- What I talk about when I talk about IRs
- The algebra (and calculus!) of algebraic data types
- Home
- bytecode interpreters for tiny computers ⁑ Dercuano
- Homomorphically Encrypting CRDTs
- Sensibly Default
- Essays: NSA Surveillance: a Guide to Staying Secure - Schneier on Security
- Authenticated Boot and Disk Encryption on Linux
- What does "Undecidable" mean, anyway
- Pwning the Ladybird browser
- Hacking a Smart Home Device
- Bypassing regulatory locks, Faraday cages and upgrading your hearing
- oss-security - Make your own backdoor: CFLAGS code injection, Makefile injection, pkg-config
- Hacking Millions of Modems (and Investigating Who Hacked My Modem)
- Hacking a Virtual Power Plant | rya.nc
- Pwning the Ladybird browser
- How browsers REALLY load Web pages
- Properly Testing Concurrent Data Structures
- Scoped Propagators
- "Pushing the Limits of Web Browsers" by Lars Bak (2012)
- Going Buildless | Max Böck
- Tiny Emulators
- Solving the Mystery of ARM7TDMI Multiply Carry Flag
- EMUBook
- Zig and Emulators
- A new cycle-stepped 6502 CPU emulator
- Land ahoy: leaving the Sea of Nodes
- Bret Victor - Inventing on Principle
- "Simple Made Easy" - Rich Hickey (2011)
- Fixing Recursions In Grammar
- Grammars, parsing, and recursive descent
- Why cryptography is not based on NP-complete problems
- How Public Key Cryptography Really Works | Quanta Magazine
- Modern cryptography on the NES - Super Tilt Bro. for NES by sgadrat
- Implementing SHA-256 on the 6502 | Bumbershoot Software
- Why I’m Writing A Book On Cryptography
- Hacking a Virtual Power Plant | rya.nc
- How SSH Secures Your Connection :: Noratrieb's blog
- Essays: NSA Surveillance: a Guide to Staying Secure - Schneier on Security
- Lambda Calculus and Lisp, part 1
- Lou's Pseudo 3d Page
- A Roadmap to Security Game Testing: Finding Exploits in Video Games
- PlayStation 2 Architecture
- Let's write a video game from scratch like it's 1987
- Reversing Choplifter – Blondihacks
- Modern cryptography on the NES - Super Tilt Bro. for NES by sgadrat
- Neo Geo Architecture | A Practical Analysis
- Tools + Techniques for Procedural Gamedev - Casey Primozic's Homepage
- SNES: Sprites and backgrounds rendering
- CSCI 181G PO
- The guide to implementing 2D platformers | Higher-Order Fun
- User Interface with Ant Tweak Bar
- Ray Tracing in One Weekend
- Scratchapixel 4.0, Learn Computer Graphics Programming
- Exponentially Better Rotations
- The Book of Shaders
- Understanding 3D Graphics | Azeem Bande-Ali | azeemba.com
- How to Create a Liquid Raymarching Scene Using Three.js Shading Language | Codrops
- Ray Tracing Harmonic Functions
- WebGPU Unleashed: A Practical Tutorial
- Pattern: Saga
- Logging Guide
- Sensors and gauges - Observability in distributed systems
- Observability 101: Terminology and Concepts
- Getting Started with OpenTelemetry Visualization - A Practical Guide
- Setting Up Prometheus, Grafana, Loki, Tempo & Mimir for end-to-end Monitoring & Logging Atmosly
- Prometheus 101: Metrics, Monitoring, Practical Setup and More
- Monitoring Your Apps in Kubernetes Environment with Prometheus
- Putting a meaningful dent in your error backlog – Dan Slimmon
- Why is Browser Observability Hard | Hazel Weakly
- Books
- A Commentary on Defining Observability
- Five Common Misconceptions About Event-Driven Architecture
- Virtualization Internals Part 1 - Intro to Virtualization | Saferwall
- glouw/c8c: The chip8 compiler, assembler, and virtual machine
- leandromoreira/digital_video_introduction: A hands-on introduction to video technology: image, video, codec (av1, vp9, h265) and more (ffmpeg encoding). Translations: 🇺🇸 🇨🇳 🇯🇵 🇮🇹 🇰🇷 🇷🇺 🇧🇷 🇪🇸
- WebGPU Fundamentals
- Ray Tracing in One Weekend Series
- How we tamed Node.js event loop lag: a deepdive | Trigger.dev
- Efficient and Insightful Generalization
- What is Table-Oriented Programming? :: Table-Oriented Programming (TOP)
- Object-Oriented
- Object-Oriented
- A Dictionary of Single-Letter Variable Names | Blog | jackkelly.name