Tag: #systems

← All posts

• Simulating Systems in the Browser — What WASM Makes Possible and What Still Blocks It

  ccsim, posted to Hacker News in late July 2026, builds two full copies of gVisor's userspace TCP stack into WebAssembly and runs them in a browser worker. v86 JIT-compiles an x86 CPU to WASM to boot Windows 98, and WebVM

  2026-07-31 · 15 min read #webassembly#wasm#simulation#browser#systems

• Native Async in WASI 0.3 — Why wasi:io Disappeared, and What's Still Not Done ♪ Listenable

  On June 11, 2026, the WASI Subgroup ratified WASI 0.3.0. The core change is that async moved down into the Component Model's canonical ABI, and as a result the wasi:io package disappeared entirely. This matters not for p

  2026-07-16 · 19 min read #webassembly#wasm#wasi#component-model#systems

• Ferrocene's Certified core — The Compiler Is ASIL D, So Why Does the Library Stop at ASIL B? ♪ Listenable

  The claim that Ferrocene's Rust compiler is 'ASIL D certified' is true, but the conclusion people usually draw from it is not. Ferrocene qualified the compiler as an ISO 26262 ASIL D / TCL 3 tool, which means 'you may de

  2026-07-16 · 23 min read #embedded#rust#ferrocene#safety#systems

• Rust Ownership, Borrowing, and Lifetimes

  How Rust guarantees memory safety with no garbage collector, through its three core ideas — ownership, borrowing, and lifetimes. Move semantics, the borrow checker's "shared XOR mutable" rule, why lifetimes exist, how to

  2026-07-03 · 14 min read #rust#ownership#systems

• Payment Systems 101: Flow, PSPs, Card Networks, Settlement

  What actually happens when you press the pay button, from an engineer's point of view. The difference between authorization, capture, and settlement; the five players (merchant, PSP/gateway, acquirer, card network, issue

  2026-07-03 · 13 min read #payments#fintech#systems

• Concurrency vs Parallelism — Dealing With vs Doing Many Things

  Rob Pike's famous distinction — concurrency is about "dealing with" many things, parallelism is about "doing" many things at once. This post walks through threads and event loops, race conditions and data races, mutexes

  2026-07-03 · 12 min read #concurrency#systems#fundamentals

• Rust Smart Pointers: Box, Rc, Arc, RefCell & Interior Mutability

  Smart pointers unlock the cases Rust ownership alone struggles to express. Put values on the heap with Box, share ownership with Rc and its thread-safe cousin Arc, move the borrow rules from compile time to run time with

  2026-06-30 · 11 min read #rust#memory#systems

• Rate Limiting Algorithms, Explained: Fixed Window, Sliding Window, Token Bucket, and Leaky Bucket ♪ Listenable

  A side-by-side tour of the main rate limiting algorithms — fixed window, sliding window log and counter, token bucket, and leaky bucket. How each handles bursts, how to implement rate limiting across a distributed fleet

  2026-06-25 · 11 min read #systems#api#reliability

• Stack vs Heap: How Memory Really Works

  The stack and the heap are not just "two regions of memory." One is a fast, fixed, LIFO world of frames; the other is a dynamic space ruled by malloc and garbage collectors. This post digs from the ground up into pointer

  2026-06-24 · 16 min read #systems#memory#fundamentals

• Cache Invalidation, Explained

  "There are two hard things in computer science: cache invalidation and naming things." This post covers why caching is so hard, strategies like TTL, write-through, write-behind, and cache-aside, the cache stampede (dogpi

  2026-06-19 · 15 min read #performance#caching#systems

• Mechanical Sympathy: Writing Code the Hardware Likes

  Two pieces of code with the same time complexity can differ by tens of times in the real world, and the reason lives in the hardware. CPU caches (L1/L2/L3) and cache lines, data locality in arrays versus linked lists, br

  2026-06-18 · 15 min read #performance#systems#cpu

• Content-Addressable Storage Is Everywhere

  One idea — address data by the hash of its content, not its location — runs identically through Git objects, Docker layers, IPFS, the Nix store, and BitTorrent. A practical look at how it hands you deduplication, integri

  2026-06-10 · 12 min read #systems#storage#hashing

• WebAssembly Beyond the Browser

  WebAssembly was born in the browser, but its real ambition is outside it. WASI, a POSIX-ish system interface; edge and serverless (Fastly, Cloudflare Workers); plugin systems in Envoy, Figma, and databases; and the compo

  2026-06-09 · 12 min read #webassembly#wasm#systems

• Rust Tokio Runtime Deep Dive — Future, Waker, Work-Stealing, Pin, Zero-Cost Async (2025)

  Rust async/await promises "infinite concurrency with no runtime", but the internals are intricate. This post dissects the Tokio runtime from the ground up: how async fn compiles into a state machine, the Future/Poll/Wake

  2026-04-15 · 15 min read #rust#tokio#async#runtime#concurrency

• Service Mesh Deep Dive — Envoy, Istio, Linkerd, Cilium eBPF, Ambient Mesh, xDS/mTLS

  Why sidecar proxies appeared — and why they are being abandoned. Envoy internals, xDS API flow, mTLS handshake, Ambient Meshs Ztunnel, and Ciliums sidecar-less eBPF mesh, all in one place.

  2026-04-15 · 10 min read #service-mesh#envoy#istio#linkerd#cilium

• LSM-Tree Deep Dive — RocksDB, LevelDB, Compaction, Bloom Filter, Write Amplification (2025)

  Everything about LSM-Tree — the 1996 O'Neil paper, Memtable and SSTable structure, WAL and flush, Leveled vs Tiered vs Universal compaction, Bloom filters and read path, the RUM conjecture (Read-Update-Memory), RocksDB c

  2026-04-15 · 13 min read #lsm-tree#rocksdb#leveldb#cassandra#scylla

• Kafka and Event-Driven Architecture Deep Dive — Partition/ISR, Exactly-Once, Outbox, Schema Registry, Flink

  Many use Kafka; few understand its internals. Partitions and Leader/ISR, Log Segment physical layout, Exactly-Once Semantics truth, Transactional Outbox, Event Sourcing vs CDC, Schema Registry, and 100ms SLA techniques.

  2026-04-15 · 9 min read #kafka#event-driven#streaming#exactly-once#schema-registry

• Git Internals Deep Dive — Object Model, Packfile, Merge Algorithms, Reflog, Protocol (2025)

  Git is a tool every developer uses daily but most treat as a black box. This guide dissects Git from first principles: its essence as a content-addressable filesystem, the blob/tree/commit/tag object model, SHA-1 hash ch

  2026-04-15 · 15 min read #git#version-control#object-model#packfile#merge

• Kubernetes Internals Complete Guide — etcd, API Server, Controller, Scheduler, kubelet, CRI/CNI/CSI Deep Dive (2025)

  Everything about Kubernetes internals — history from Google Borg, etcd Raft consensus, API Server REST and watch protocol, scheduler filter/score algorithms, controller manager reconciliation loops, kubelet Pod lifecycle

  2026-04-15 · 11 min read #kubernetes#etcd#controller#scheduler#kubelet

• eBPF Deep Dive — The VM, Verifier, XDP, and CO-RE That Made the Linux Kernel Programmable (2025)

  Injecting safe code into the kernel — that is the eBPF revolution. This post dissects eBPF from internals to practice: the VM and bytecode, the Verifier that enforces safety, maps (Hash/Array/Ring Buffer/Perf), program t

  2026-04-15 · 15 min read #ebpf#linux#kernel#xdp#observability