THE COLLECTION

Library

Everything you’ve found. Nothing you need to save twice.

27 articles
Browse at your own pace.

Book Review: Seeing Like A State

This review covers James Scott's book about state planning. Scott argues that governments simplify complex systems to make them easy to measure, tax, and control. These plans often fail because they ignore local practical knowledge. The reviewer likes the historical examples but questions how far the thesis applies.

Everyone is doing Git on S3 wrong

The article argues that Git-on-object-storage designs using a write-ahead log, like Cursor's Continuity, gain durability and read scaling but remain effectively single-writer and still need full repositories on disk. The author presents Enroute, which instead uses per-repository Raft consensus, stateless compute nodes, optimistic locking, and a segment/layer format confining deltas to commit ancestry, with S3 for durability. Reported peak exceeds 7,600 pushes per second into one repository; reads benchmark near stock Git, but clients pay more to decode served deltas, and garbage collection remains unsolved.

OpenCode Reloaded

This article explains how OpenCode 2 achieves instant hot reloading of plugins, config, and MCP servers. Mutating shared state from multiple plugins causes order-dependent bugs, so plugins instead register transformation functions that OpenCode replays in order from an empty state on every rebuild. The tradeoff is that plugins give up direct, arbitrary mutation in exchange for deterministic, coordinated reloading.

Rebuilding AUTOMATIC1111 with Gradio Workflow

This article walks through Workflow1111, a rebuild of AUTOMATIC1111's stable-diffusion-webui as a 73-node Gradio Workflow canvas, arguing that node graphs can mix local Python functions with remote model calls. It shows that every output node becomes a REST endpoint and MCP tool, and that visitors can run pipelines under their own quota. Tradeoffs are acknowledged: there is no loop operator, and roughly two-thirds of nodes run in-process without a network call.

Async GRPO with LoRA across HF Jobs: a bucket, a proxy, and no NCCL

A rank-1 LoRA adapter is only a few MB, so async GRPO can span separate HF Jobs: trainer and vLLM replicas swap adapters via a mounted Storage Bucket instead of NCCL, with a proxy adding auth, broadcasting adapter loads, and routing rollouts by KV prefix. Five instrumented runs chase the bottleneck between training and generation; packing, dropping gradient checkpointing, and raising in-flight caps cut 500 steps from 3h27m to 53min at equal reward. Tradeoffs: FUSE sync lag, retry logic, concurrency caps.

Your Agent Aced the Task. Will It Do It Again?

The article argues that average benchmark accuracy hides agent unreliability: a ReAct agent on GPT-4.1 scored 77.4% Mean@5 on AppWorld but only 53.0% Pass^5 (succeeding on every run). Their Consistency Analyzer resamples decision points from a single recorded trajectory to find flip-prone steps, and the resulting injected guidelines halved the gap (24.4pp to 12.0pp) without costing average accuracy. Tradeoffs: diagnosis needs one extra LLM call per decision step, and consistency is orthogonal to capability, so a bigger model won't fix it.

On the Effectiveness of Mutational Grammar Fuzzing

The author critiques mutational coverage-guided grammar fuzzing: coverage feedback misses semantic dependencies (e.g., bugs requiring chained function calls), and greedy corpus accumulation produces highly similar samples. The proposed fix is periodically restarting fuzz workers with empty corpora while syncing with a server holding accumulated coverage and samples, alternating independent generation with combined-corpus mutation. In week-long libxslt experiments this found more unique crashes faster than uninterrupted runs, though the optimal interval T was target-dependent.

Testing race conditions with memory access tracing and stack-based delay injection

The author presents MAccConc, tooling that traces kernel memory accesses via ASAN outline instrumentation fed through KCOV, and uses count-augmented stack traces to stably identify accesses across runs, enabling delay injection that forces specific thread interleavings. This supports confirming race-condition candidates, writing reliable regression tests, and eventually fuzzing. Tradeoffs include ASAN missing some stack/global accesses, coverage loss on kernel panics, and constraint-style orderings being less deterministic than fully-specified ones; kernel patches are not yet upstream.

Migrating the GitHub Copilot runtime to Rust, using Copilot

GitHub rewrote the Copilot agent runtime from TypeScript/Node.js to 800,000+ lines of Rust, with AI agents writing most of the code across 128 incremental pull requests shipped in place rather than via a big-bang cutover. Reported gains include large reductions in startup time, memory, and CPU, plus an embeddable C-ABI surface for six SDK languages, at the cost of ~$120K in tokens, explicit lifetime management, and some regressions. The author frames it as escaping Node/V8 overhead for embedded runtimes, not a general claim that TypeScript should become Rust.

Marketing ops as code: Automating events from planning to follow-up on GitHub

A GitHub marketing lead automated event operations end-to-end by treating each event as a GitHub Issue: issue forms capture inputs, labels act as triggers, GitHub Actions stage the event, and Copilot 'skills' (Markdown runbooks) handle planning and post-event follow-up. She argues the pattern applies to any repetitive work touching tools with an API or CLI, weighing it against packaged marketing-automation platforms: regional variation favors custom pipelines with PR-based change management, though a silent cron failure shows monitoring is still required.

Building Agents that Don't Break Themselves

The article argues that an AI agent's long-lived process (its 'home') and the sandbox where it executes model-generated commands should be separate environments. It presents two Fly.io case studies: SpriteDoc uses a throwaway sandbox per session with per-command credential injection, while Hermes Agent keeps a persistent per-task sandbox. Tradeoffs include lifecycle choice, idle cost (sandboxes go cold), and replacing approval prompts with sandbox isolation plus cheap checkpoint/restore rollback.

Quake Shareware, a CD-ROM just a little too full

A retrospective on id Software's 1996 Quake shareware CD-ROM, which bundled encrypted full versions of id games that buyers could unlock via a phone order system built by TestDrive Corp. The scheme relied on security by obscurity: the on-disc unlock program generated serial codes locally, so GNOMON cracked it in 39 days, aided by plaintext files and bugs. The experiment failed commercially, leaving id with ~150,000 unsold CDs.

ryg_rans is not a library

The author explains that ryg_rans is a toy demonstration of rANS—like a hardware-store board displaying fastener options—not a production library, and that its static byte model, alias-table variant, multiple SIMD interleaving variants, and bitstream format are all unfit for real use. He gives concrete recommendations: 32/16 or 64/32-bit state renormalization, two-state implicit interleaving, forward modeling with backward encoding, and adaptive EMA models, preferring tANS when probabilities are static.

How we saved 100 terabytes of memory by optimizing 1.1.1.1’s DNS cache

Cloudflare details five Rust memory-layout changes to its 1.1.1.1 DNS cache — dropping Vec/String capacity fields, merging record lists with u16 offsets, omitting owner names when they match the query key, boxing large enum variants, and storing record data as wire-format bytes — cutting per-entry memory 56% and freeing roughly 100 TB fleet-wide. Performance also improved (inserts +43%, lookups −19%), though each change carries tradeoffs: allocator overhead and poor locality from boxing, sequential-only access for wire-format buffers, and records no longer self-contained.

Uber’s Real-Time Push Platform

Uber replaced mobile app polling—which reached 80% of gateway traffic—with RAMEN, a server-push platform built on Server-Sent Events plus a custom sequence-number/acknowledgment protocol for at-least-once delivery. Scaling forced a rewrite from Node.js with Ringpop gossip sharding to Netty with ZooKeeper/Helix, reaching 1.5M concurrent connections and 250K messages/sec. A newer gRPC bidirectional streaming version addresses delayed acks, unidirectional transport, and text-only payload limits.

Infrastructure Update: Pushing the edges of our global performance

Dropbox explains how it reduced transfer latency for distant users by deploying Points of Presence and edge proxy servers in multiple regions, absorbing the TCP slow-start and TLS handshake delays that undersea-cable round trips impose. Proxies hold persistent connections to data centers over private backbone links, with TLS 1.2, PFS, and certificate pinning preserving security. Reported gains vary by market (40% to 3x median speedups), and implementation details remain high-level.

How Discord Resizes 150 Million Images Every Day with Go and C++

Discord replaced a Python image-resizing proxy with a Go service after the original showed uneven workload distribution and high latency variance. Because no Go resizing package could beat pillow-simd, they built Lilliput, a Go package wrapping OpenCV and C image libraries via Cgo—accepting forked dependencies, manual memory management, and hard-to-debug leaks and race conditions. The rewrite cut server instances by 60% and reduced latency variance, but required extensive profiling, fuzzing, and custom GIF and video handling.

How Tailscale Peer Relays saved my holiday: a 12.5X performance boost from India

An engineer traveling from the US to India found direct Tailscale connections failed due to symmetric CGNAT on Indian ISPs, forcing traffic through shared DERP relays throttled to ~2.2 Mbits/sec. Self-hosted Tailscale Peer Relays (a node with an open UDP port) restored 27-35 Mbits/sec and cut latency ~150ms by removing the Chicago relay hop. The article explains NAT diagnosis tools and relay setup; DERP remains the fallback, and the tradeoff is operating and exposing a relay on your own infrastructure.

Service-Oriented Architecture: Scaling the Uber Engineering Codebase As We Grow

Uber recounts migrating from a monolithic codebase to a microservices SOA (500+ services) to handle rapid growth, which solved coupling and deployment problems but introduced issues of obviousness, safety, and resilience. They adopted Apache Thrift for strict cross-language service contracts and built client-publishing tooling, drawing on Netflix Hystrix and Twitter Finagle for fault tolerance. Tradeoffs include immature Thrift tooling for Python and Node, and no header support complicating authentication and tracing.

Laya — 33ms Multilingual System 1 Decision Engine

The author introduces Laya, an open-source family of bidirectional encoder models that answer typed questions (choice, ordinal score, boolean) with calibrated probabilities in roughly 33 ms, arguing generative LLMs are overkill for high-volume triage and routing. Self-reported benchmarks claim speed, calibration, and cost advantages over the proprietary Jev API. Acknowledged tradeoffs: choice questions degrade beyond ~20 options, base checkpoints are near-random zero-shot and require fine-tuning, and temperature calibration is needed.

Improving infrastructure efficiency for growing demand in the age of AI

Dropbox argues that as AI-driven demand grows, getting more from existing infrastructure matters as much as building new data centers. The post describes a system-level approach spanning power management (Deep Sleep), workload rebalancing, higher storage density via SMR drives, and failure-rate-driven hardware lifecycle decisions, reporting watts per petabyte improved over 50% since 2020. Tradeoffs include density versus power/cooling needs, energy savings versus latency, and longer hardware life versus reliability risk.

How we used DSPy to turn AI evaluations into better responses in Dash chat

Dropbox built trajectory-based LLM-as-judge evaluations for its Dash chat agent, then used DSPy's GEPA and MIPROv2 optimizers in two stages: calibrating judges against a small human-labeled set, then optimizing the agent's system prompt via offline replay of historical chats. Reported gains include 26% fewer incomplete answers, 13% fewer missed key aspects, and 5.4% lower token usage. The tradeoffs: automation requires strict guardrails, and weak evaluation signals risk brittle improvements.