Source, runtime, protocol, compiler, machine. Each piece follows one behaviour down to the layer that decides it.
10 parts
Ten parts on what a type is and where it goes: sets of values, layouts and padding, erasure and monomorphization, the bits the processor actually sees, and what the checker knows that the binary forgets. Small programs in Rust, C, TypeScript and Python, with one script that reproduces every output.
Evidence: experiments/rust-atlas/types-under-the-hood/
3 parts
Five async Rust problems reproduced in one small tokio program: an oversized future, a future that is not Send, a blocking call, a select! loop that loses data, and a shutdown that hangs. Then the cost of async fn through dyn Trait, and cleanup when Drop cannot await.
Evidence: experiments/rust-atlas/async-symptoms/
Rust failures that are difficult to name and easy to misdiagnose, organized from symptom to mechanism, with a failing and a repaired fixture for most cases.
One small Rust function followed through real HIR, THIR, and MIR output, with a practical explanation of what each compiler representation is for.
Most WebSocket tutorials start at the API. This one starts at the wire — electrons, NIC interrupts, kernel socket buffers, the TCP state machine, the HTTP upgrade handshake, the binary frame format — and works up to what ws.send() actually does.
A practitioner’s deep dive into ops, resources, and the V8 bridge in Deno’s Rust core.
Zero-copy scanning still reads every inspected byte. It removes a second materialization in memory. I use streaming Aho-Corasick to explain automaton state, chunk boundaries, DFA dependency chains, prefilters, and honest performance measurement.
Two identifiers, two different jobs. DefId names a definition across the whole compiler pipeline and across crates. HirId points to a node in the syntax tree of the current crate. Mixing them up is the first stumbling block when reading rustc source code.
A source-to-diagnostic walkthrough of trait goals, parameter environments, candidates, associated-type normalization, and nested obligations.
What actually happens between bytes arriving on a socket and your gRPC handler running? This article walks one real request through every parsing layer — TCP, HTTP/2 frames, HPACK, gRPC envelope, protobuf — so the magic disappears.
A deep dive into what actually happens when you write #[tokio::main]. We'll tear apart the macro, expose the state machines, and reveal the work-stealing scheduler hiding beneath five lines of code.
A Rust future is Send only when every stored state is safe to move across threads. Trace captures and locals across await to fix spawn errors.
Rust async functions store every value needed after an await. Learn to measure future size, identify saved fields, and reduce it without boxing everything.
How I built a custom code execution engine backed by a Rust/Axum microservice, embedded directly in blog articles. Covers the security model, subprocess isolation with setrlimit, HMAC request signing, and the tradeoffs behind every decision.
Measured Rust enum layouts showing how invalid payload values encode Option discriminants, which optimizations are guaranteed, and what repr changes.
A Rust pointer carries an address and provenance. Learn addr, with_addr, map_addr, exposed provenance, and sound pointer-tagging patterns.
A tested Rust-and-C FFI boundary covering ABI layout, pointer validation, ownership, panics, error reporting, callbacks, versioning, and cross-language harnesses.
PhantomData stores no value, yet changes variance, Send, Sync, ownership, and drop checking. Learn to choose a marker from the real contract.
Pinning a Rust struct does not pin every field automatically. Learn structural pinning, safe projection, Drop obligations, and Future wrappers.
The usual Fn(&T) -> Fut bound cannot describe a future borrowing from each call. See how AsyncFn enables lending callbacks on stable Rust.
Follow Rust drop scopes through if let, match, and tail expressions, including the Edition 2024 changes affecting locks and temporary borrows.
A span comparison harness showing why generated Rust errors point at the macro invocation, how to preserve input spans, and how to test diagnostics with compile-fail fixtures.
Rust identifiers carry syntax context as well as text. Learn macro_rules hygiene, $crate paths, and procedural-macro spans for reliable expansion.
Trace go to definition from a cursor token through syntax, macro expansion, name resolution, semantic identity, and finally back to an editable source range.
Rust 1.97 made v0 symbol mangling the stable default. Compare real nm output, read the encoding, and know what changes for profilers, debuggers, and ABI boundaries.
Rust 1.97 forwards successful linker output through a special lint. Learn who produced the message, why -D warnings ignores it, and how to investigate it.
When you write let s: &str = "hello world", there are really two things in one line, living in two different places. Here is what each one is, where it lives, and why that explains lifetimes.
Learn how Rust's Acquire and Release memory orderings work, their importance in concurrent programming, and how they enable lock-free synchronization between threads.
A comprehensive guide to understanding the inner workings of gRPC encoding. Explore how gRPC utilizes Protocol Buffers (Protobuf) and HTTP/2 to deliver high-performance, efficient client-server communication with detailed real-life examples of request and response serialization.
The right way to learn Kafka is to build a tiny log broker — not a fake queue with ack/delete. One topic, one log file, one offset per consumer group. That is the whole model.
A tutor-style walkthrough of what a distributed database control plane actually is, why metadata is the crown jewel, where Raft fits in, and how to follow one request end-to-end to remember the whole design.
Pattern count alone cannot predict fast string search. I show how rare bytes, short literals, prefixes, alphabet size, and candidate density shape SIMD-assisted Rust performance.
Linear-time search does not promise constant speed. I explain how automaton size, cache behavior, construction, match density, and pattern shape change real Rust throughput.
A prefilter can skip most automaton work, but it is heuristic rather than free. I show how candidate frequency and pattern shape decide whether it helps a Rust search.
An automaton can recognize a cross-chunk match with little state, yet a streaming API may still need bytes. The missing distinction is recognition state versus output state.
A pattern may begin in one input chunk and finish in the next. I explain the state, offsets, and split-point tests needed to keep a Rust streaming scanner correct.
Rust's Aho–Corasick crate can build three different automata. I compare their construction cost, memory layout, search behavior, and the evidence needed before forcing one.
The same patterns and haystack can produce different correct matches. I make Rust's three Aho–Corasick match kinds concrete and show how to choose by product semantics.
A reference flow for keeping user identity, tenant, audience, and allowed actions attached to every AI tool call without trusting the model to enforce permissions.
Structured model output is not trusted application input. Validate syntax, semantics, authorization, and effect policy again at the tool execution boundary.
Older, introductory or narrower pieces on the same subject.