Insights on practical software engineering, learning by building, and hands-on development
A single sigmoid unit cannot separate XOR. We train a 2-2-1 network, inspect its hidden coordinates, and see how a nonlinear layer turns the problem into one a straight line can solve.
We follow every correction made by a perceptron learning AND, inspect the boundary encoded by its weights, and see why the same algorithm can never learn XOR.
A monitoring experiment shows how sparse probes can miss most incidents while reporting accurate uptime, and why a healthy endpoint may say nothing about user-facing operations.
Two schedulers run the same two million tasks. A shared mutex makes sixteen workers five times slower than one, while local queues and rare work stealing produce a fivefold speedup.
We build a small Rust shell and trace how fork, exec, pipes, dup2, close, and wait turn a command line into cooperating Unix processes.
A Rust service has complete logs but no direct answer for a one-second delay. We replace paired log lines with tracing spans and build a Layer that preserves the request as a tree.
A schema generator recompiles 60,310 lines after an unrelated edit. Precise rerun-if directives remove that work, while an incomplete input list silently produces stale Rust types.
Three Rust pixel filters start at 2,629,023 bytes. Inspecting DWARF, Cargo profiles, wasm-bindgen, wasm-opt, the allocator, and the ABI reveals what the browser actually needs.
A recursive-descent grammar ladder and a Pratt parser build identical ASTs; binding powers cut parse calls from 3,887,015 to 594,970 across 100,000 generated expressions.
A 20-byte request over loopback taking 41 ms: how Nagle's algorithm and delayed ACK lock each other through a write-write-read protocol, two measured cures, the whole story reconstructed from ss -ti — and the flood where Nagle wins 11×.
A standalone Levenshtein implementation becomes a native PostgreSQL function through pgrx — including the contracts for NULL, the query planner, parallel workers, panics across FFI, and PostgreSQL memory contexts.
The compiler turns async fn into a state machine and walks away; everything else — a run queue, a deadline heap, epoll with parked wakers — is an ordinary program you can build and measure: 836 lines, three threads, 5000 live connections.
A hand-rolled Vec<T> with a plausible use-after-realloc bug: the compiler approves, all native tests pass — and Miri convicts the dangling pointer in 2.18 seconds, with the allocation's full biography.
Reading a 7 GB model file byte by byte — header, metadata, tensor directory — and predicting its exact size to the last byte without touching the weights.
The same five-tap blur in two shapes of one loop: the one LLVM refuses to vectorize, and the one it vectorizes badly — with the disassembly and the numbers.
Keep the app in Python, move one hot function to Rust: a 100× speedup measured end to end, with the code and the numbers.
