AI serving
How an LLM writes the next word
Follow one prompt through a real model: tokenizer, embeddings, attention, sampling and the KV cache, then down to why serving is bound by memory bandwidth and how tensor cores do the actual work.
Long-form technical dives. Each one starts with why a piece of technology exists, then keeps going through the API, the runtime, the kernel and the bytes on the wire until it reaches the hardware. Most have parts you can run, step through and break.
Three dives that show what this site is about.
AI serving
Follow one prompt through a real model: tokenizer, embeddings, attention, sampling and the KV cache, then down to why serving is bound by memory bandwidth and how tensor cores do the actual work.
Web and networking
One round trip to agree on keys, prove a server’s identity and hide an HTTP request. Follow TLS 1.3 from the first visible byte to the silicon doing the encryption.
Systems and hardware
Follow one malloc(64) all the way down: the allocator's free lists, virtual addresses and page faults, the page-table walk and the TLB, cache lines, DRAM banks, and the leaking capacitor that finally holds your bit.
How neural networks learn from data and get shaped into assistants, and the architectures that turn text, images and sound into predictions.
6 dives · 1 note · 4.1 h of reading
What it takes to run a model once it is trained: generating tokens fast, fitting weights into memory, coping with long prompts, and connecting models to data and tools.
6 dives · 8 notes · 4.8 h of reading
Everything between a URL and a pixel: the protocols that carry bytes across the internet and keep them private and fresh, and the browser machinery that turns them into a page.
12 dives · 10 notes · 8.8 h of reading
The machine under all the software: how a processor executes instructions, what memory really is, and how a GPU keeps thousands of threads busy.
6 dives · 4 notes · 4.6 h of reading
The work a language runtime does on your behalf: scheduling goroutines, collecting garbage, and running portable bytecode safely and fast.
6 dives · 5 notes · 4.5 h of reading
Deploying and operating software: Kubernetes workloads, Helm releases, Ansible automation, Raspberry Pi clusters and the practical checks that keep systems running.
6 notes · 0.3 h of reading
Building applications and data workflows: framework patterns, Django and Wagtail models, Next.js integration, identity schemas and practical data scripts.
5 notes · 0.2 h of reading
Search dives and notes, or narrow by topic.
34 dives, newest first
Web and networking16 Nov 2026
Press play on a ten-minute talk. Follow the first picture, the next segment and a sudden tunnel through HLS, DASH, adaptive bitrate, browser buffers and the silicon that turns bytes into motion.
38 min9 levels
Web and networking15 Nov 2026
Ana signs in without sharing a secret. Follow her passkey from a phone to a laptop, through the browser’s origin checks, a real signature, the USB frames and the hardware boundary that protects the key.
36 min9 levels
Web and networking14 Nov 2026
One product card, from arriving bytes to a glowing display. Build its DOM, resolve its CSS, and find out why moving a badge can cost a frame.
42 min9 levels
Languages and runtimes14 Nov 2026
One distance function, four execution tiers, and an assumption that breaks. Step through real bytecode, build hidden classes, feed an inline cache, and follow a deoptimization down to the machine instructions that caused it.
43 min9 levels
Web and networking13 Nov 2026
Your chat tab is closed. Ana is running five minutes late. Follow one encrypted message through keys, queues, a sleeping phone and the bytes that wake it.
43 min10 levels
Web and networking12 Nov 2026
Ana is behind her home router. Ben is behind a carrier NAT. Follow their video call through negotiation, hole punching, encryption and the packets that arrive just in time.
50 min10 levels
AI serving11 Nov 2026
Follow one issue-tracker lookup through a model, a host, JSON-RPC, authorization and the kernel. Build messages, break a stream and inspect the bytes, with the 2026 and 2025 protocols kept apart.
38 min7 levels
AI models10 Nov 2026
Say “We see a cat.” Follow the air pressure through samples, Fourier transforms, mel filters and a Whisper decoder, all the way to the bytes and arithmetic that turn sound into text.
38 min9 levels
AI models9 Nov 2026
A receipt says $12.50. Follow its pixels through tensors, patches, attention and a language model to see how an image becomes evidence for an answer.
38 min9 levels
AI models7 Nov 2026
Turn noise into structure with a real diffusion sampler, then follow an image through denoising, guidance, latent patches and the GPU arithmetic behind every step.
42 min9 levels
AI serving6 Nov 2026
Follow a CUDA thread into a warp and onto an SM. Make branches diverge, scatter a memory request across sectors, and fix a transpose one bank conflict at a time.
42 min9 levels
AI serving4 Nov 2026
A million tokens can hold a codebase. Following one question through them reveals three different limits: attention work, growing caches, and what a compressed state can remember.
42 min9 levels
AI models3 Nov 2026
Follow a token into a sparse expert layer: router scores, balance and capacity, expert parallelism, token permutation, and the memory traffic behind conditional computation.
42 min8 levels
AI serving1 Nov 2026
Follow one search for a laptop that will not charge: learned geometry, graph navigation, compressed codes, filtered retrieval, and the memory traffic behind every similarity score.
45 min9 levels
AI serving30 Oct 2026
Squeeze a 70-billion-weight model into fewer bytes. Explore the floating-point encodings, tame outliers, compensate rounding errors, then unpack four-bit weights inside a GPU kernel.
40 min8 levels
AI models29 Oct 2026
Follow one coding request through chat templates, supervised fine-tuning, preference learning and reinforcement learning, down to the log-probabilities and memory that make it work.
40 min9 levels
AI models27 Oct 2026
Turn prediction errors into gradients, build a tiny autograd engine, and train a real network in your browser. Then follow one weight update through optimizer memory, GPU collectives, pipeline schedules and the compute budget of a language model.
45 min9 levels
AI serving25 Oct 2026
Follow one prompt through a real model: tokenizer, embeddings, attention, sampling and the KV cache, then down to why serving is bound by memory bandwidth and how tensor cores do the actual work.
55 min9 levels
Web and networking23 Oct 2026
Your app can reach the API. Why can’t it read the reply? Follow one JSON order through origins, preflights, cookies and the browser’s response filter, down to HTTP/2 frames.
38 min8 levels
Web and networking21 Oct 2026
Open a news article twice. Follow its HTML, JavaScript, logo and comments through freshness checks, validators, service workers and the back/forward cache to see which requests ever reach a server.
38 min9 levels
Web and networking19 Oct 2026
Why the web needed a full-duplex pipe, how an HTTP request turns into one, and what every bit of a WebSocket frame means on top of a TCP stream.
40 min8 levels
Web and networking17 Oct 2026
How HTTP moved off TCP: head-of-line blocking, QUIC streams and packets, a TLS 1.3 handshake folded into the transport, and the UDP datagrams carrying it all.
45 min10 levels
Web and networking14 Oct 2026
One round trip to agree on keys, prove a server’s identity and hide an HTTP request. Follow TLS 1.3 from the first visible byte to the silicon doing the encryption.
42 min11 levels
Web and networking12 Oct 2026
Your laptop knows a name. The network needs an address. Follow a café Wi-Fi lookup through delegation, caches, signed answers and encrypted transports, down to every byte on the link.
43 min10 levels
Web and networking10 Oct 2026
Start with real C zlib compressing your text in this tab. Then go down through the JavaScript boundary, the module format and the stack machine to the guard pages and x86-64 an engine uses to run it fast and safely.
40 min10 levels
Languages and runtimes8 Oct 2026
Build a tiny binary protocol with types as values, a derived packet codec and a CRC table. Follow ordinary Zig code through compile-time evaluation into the bytes and instructions that survive.
40 min8 levels
Languages and runtimes5 Oct 2026
Follow a batch of log lines through moves, borrow checking, threads and async suspension. See what the compiler proves, what a future stores, and the instructions that remain.
42 min8 levels
Languages and runtimes2 Oct 2026
Follow a 64-byte cache entry through allocation, concurrent marking and sweeping. Break a collector, tune a heap goal, read real runtime output, and see why Green Tea changes the order in which memory is touched.
45 min8 levels
Languages and runtimes30 Sept 2026
What makes goroutines and channels different, the patterns they unlock and the bugs they invite, then down through the G-M-P scheduler, the inside of a channel, OS threads and the netpoller, to the two instructions that make stacks growable.
45 min8 levels
Systems and hardware28 Sept 2026
Two threads write, then read. Both can read the old value. Follow a log record through a lock-free queue to understand the language contract, compiler instructions, store buffers, and the cache lines moving between cores.
42 min8 levels
Systems and hardware24 Sept 2026
A call begins as five bytes with a hole. Follow a tiny C program through ELF objects, symbol resolution, relocation, the PLT and GOT, and the loader that makes those bytes runnable.
42 min7 levels
Systems and hardware21 Sept 2026
Follow one HTTP request through a privilege boundary, a sleeping thread, epoll’s ready list and io_uring’s shared rings. Three ways to serve 10,000 connections, down to registers and the packet that wakes a core.
38 min8 levels
Systems and hardware19 Sept 2026
Follow one malloc(64) all the way down: the allocator's free lists, virtual addresses and page faults, the page-table walk and the TLB, cache lines, DRAM banks, and the leaking capacitor that finally holds your bit.
50 min9 levels
Systems and hardware16 Sept 2026
From a line of C to the transistor: the instruction set contract, a RISC-V CPU you can clock by hand, the datapath, pipelines and caches, adders built from logic gates, and the switch at the bottom of it all.
50 min9 levels
Use Event Timing to separate input delay, handler work and presentation delay, then correlate slow interactions with long animation frames and a DevTools trace.
Generate fresh challenges, bind them to the ceremony, and verify origin, RP ID, flags and signatures before creating a session or storing a credential.
Use V8 optimization traces to identify the invalidated assumption, then reproduce it with a controlled input change before changing application code.
Generate a VAPID identity, save a browser subscription, and build an encrypted push request with Node crypto before sending it to the subscription endpoint.
Register a schema-validated tool with @modelcontextprotocol/server and connect it over stdio. Use MCP Inspector to list and call the tool.
Use faster-whisper with word_timestamps and VAD, consume its segment generator, and preserve source-time offsets. Choose model size and compute type for your machine.
Report prefill throughput, decode throughput and time to first token separately. A bandwidth estimate gives an optimistic bound for small-batch dense decoding.
Start with default graph settings, tune ef_search against exact results, and enable iterative scans for filtered queries. Build memory and graph construction settings solve different problems.
For unit-normalized embeddings, cosine similarity, dot product and squared L2 produce the same ranking. Match your index operator and ordering to the embedding model.
Compare exact GGUF file sizes, benchmark all three with fixed settings, and reject candidates that fail a quality threshold. A Llama 3 8B example favors Q5_K_M under a six-GiB weight budget.
Compute GQA cache bytes from layer count, KV heads, head dimension and retained tokens. Use a separate latent-cache calculation for MLA models.
Use tiktoken for a known OpenAI encoding or a Hugging Face checkpoint’s tokenizer files. Reserve output space and account for chat templates before checking context and cost.
Choose response directives by whether data is public, how long staleness is acceptable, and whether a stored response may be reused without validation.
Use SSE for server-to-page text updates, WebSockets for bidirectional streams, and long polling when ordinary request handling is the simplest fit.
Check client support, inspect HTTP/3 advertisements, then confirm the actual connection protocol with curl or browser DevTools.
Use OpenSSL to check the certificate chain, hostname and negotiated parameters; use curl to see the HTTP request on the same connection.
Compare recursive and authoritative answers, inspect status and TTLs, and distinguish DNSSEC signals from local validation.
Select the target explicitly with zig cc -target or a build script using standardTargetOptions. Verify the file format separately from whether the artifact runs on the target.
Keep the owner alive through the last borrow use, or return owned data. Five examples cover locals, borrowed structs, closures, temporaries and iterators.
Use GOGC to trade heap growth for collection frequency and GOMEMLIMIT to constrain Go-managed memory. Set container headroom explicitly: Go 1.27.3 does not derive this limit from cgroups.
Compare goroutine stacks after work has drained, identify the missing exit path, and cancel and join workers before returning.
Compare adjacent atomic counters with cache-line-separated counters, then use perf c2c to locate contended lines when PMU access is available.
Inspect ELF dependency metadata with readelf or objdump instead of invoking the loader. Use LD_DEBUG only when you intentionally execute a trusted program.
Trace the blocked syscall, follow its file descriptor and identify the thread or peer that must wake it. Use syscall duration rather than summary CPU time to measure waiting.
Use a project-local inventory, test SSH and Python connectivity, then preview a small privileged playbook. Keep package refreshes separate from upgrades.
Read, clean, filter and aggregate one complete dataset. Use explicit types, safe assignment and month-end resampling without disconnected snippets.
Give navigation and actions separate HTML controls. A sibling link and button work with the mouse, keyboard and assistive technology without event-cancellation patches.
Diagnose a blocked browser fetch by checking the origin, preflight response and credential policy. CORS controls what scripts can read; it does not authenticate a request.
Create a separate Job from a CronJob template, follow its logs and distinguish a successful run from a failed one. The schedule stays unchanged.
Use small abstract models for repeated fields, then account for the save paths that do not update timestamps. UUIDs change identifiers, not authorization.
Expose a small Django model in the Wagtail admin using the built-in ModelViewSet. Choose list columns, search fields and form fields explicitly.
Prepare 64-bit Pi nodes, join them deliberately and verify cluster health. Worker count, control-plane availability and durable storage are separate decisions.
Check boot order before reflashing anything, prepare a separate USB system disk and diagnose power or adapter problems independently of the bootloader.
Constrain a username to 4–20 ASCII letters, digits or underscores. Put the rule in the identity schema and distinguish validation from identifier uniqueness.
Fix a rollout that needs the old Pods gone before new ones start. Configure the Deployment strategy, then check what your Helm chart actually renders.
Send an authenticated POST after the CMS transaction commits. Revalidate the public path and register receivers for concrete Wagtail page models.
Nothing matches. Try a broader word, or look through every topic.