A dev log on coding, electrical engineering, and mathematics.
Ten predictions and observations from the beautiful madness of the AI era. The good and the bad: moats, the supervisor economy, regulation as the real bottleneck, and the end of universities as we know them.
Back to wires: Introduction, Part 7. What alternating current is and where its sine shape comes from, how a generator makes it, why it beat DC for the grid, and the tools for working with it: RMS, phasors, reactance, impedance, and power.
In 1500 a country of a million people invented the ship that opened the world, got rich beyond its size, and then lost everything to latecomers with deeper pockets. Frontier AI labs are sailing the same caravel. Why the model was never the moat, and the two narrow ways out.
Back to wires: Introduction, Part 6. How capacitors store charge, how inductors store current, why both resist change, and the exponential curves that follow when a circuit switches.
Back to wires: Introduction, Part 5. How changing electric and magnetic fields generate each other, why that produces a self-sustaining wave at the speed of light, and how special relativity reveals them as one field.
Back to wires: Introduction, Part 4. What a field is, how charge creates electric fields and current creates magnetic fields, and how stored field energy is the foundation of capacitors and inductors.
Back to wires: Introduction, Part 3. Kirchhoff's laws, mesh and nodal analysis, Thévenin and Norton equivalents, superposition, capacitors and inductors, and the exponential curves that first bring time into a circuit.
Back to wires: Introduction, Part 2. Charge, current, voltage, resistance, and power: the five quantities everything else rests on, and the single law that ties them together. Ohm's law, series and parallel circuits, internal resistance, and why a real source droops under load.
Back to wires: Introduction, Part 1. A complete, ground-up course in electrical theory and code: how it's built, the shape of each lesson, and the ground it covers across eight areas from fundamentals to maintenance.
Two npm supply chain attacks in early 2026: the Axios compromise by Sapphire Sleet and the Mini Shai-Hulud worm by TeamPCP. What happened, how to check if you were hit, how to harden, and an honest look at how Pent would have mitigated these.
Vector search: The problem, Part 4. Compressing the database vectors so a billion-vector index fits in a fraction of its raw memory. Scalar quantization (one byte per value), product quantization (the workhorse of every billion-scale vector index), how compressed vectors are searched without ever decompressing them, and how the codebook is kept fresh as data drifts.
Almost every public article online is written with AI assistance now. So are the articles on this site. A note on how I write now, and why.
Vector search: The problem, Part 3. How to scale HNSW from millions to billions of vectors when the data no longer fits in RAM. Why graph indexes are friendly to SSD IO patterns, what DiskANN and Vamana change about HNSW for disk residency, and the typical production stack.
Vector search: The problem, Part 2. Approximate nearest neighbor search by walking on a graph. From the naive proximity graph and its local-minimum failure, through Watts-Strogatz small-world graphs, to HNSW, the workhorse of every modern vector database.
Vector search: The problem, Part 1. Why nearest neighbor search is easy in 1D, manageable in 2D, and falls apart in 768D. The first post in a series on vector search, working from the problem itself before the algorithms.
A writeup of building formalang, a compiler frontend, with Claude in the loop. The actual workflow, what it cost in time and reading, where the agent helped most, and a final scorecard.
Deploy Mistral's Devstral Small 2 (24B coding model) with vLLM on a 48 GB workstation GPU or rented cloud instance, then connect it to OpenAI-compatible agentic clients (Cline, Continue, OpenCode).
The exponential thread: The puzzle, Part 2. What makes e ≈ 2.71828 structurally special among all exponentials, and why every other exponential turns out to be a stretched copy of e^x. The unique calibration at which calculus has no correction factors.
The exponential thread: The puzzle, Part 1. Starting from a 3rd-grade equation and arguing that it is the entry point to the deepest unification in modern mathematics. e, ln, sin, cos, complex exponentials, matrices, and Lie groups all turn out to be the same object viewed from different angles. The first post in a nine-part series.
Rust for Swift devs: The type system, Part 6. Cargo bundles package management, build, test, lint, doc, and benchmark behind one command; Swift's toolchain spreads the same roles across SwiftPM, the swift CLI, Xcode, and third-party tools. The closing post in the Rust-for-Swift-devs series compares the two, then covers conditional compilation, C FFI, and macros against property wrappers, result…
Rust for Swift devs: The type system, Part 5. Both Rust and Swift now gate cross-thread data sharing at compile time: Rust through Send and Sync auto traits and the Arc<Mutex<T>> recipe, Swift through Sendable and the actor primitive. The fifth post in the Rust-for-Swift-devs series maps each Swift Concurrency mechanism onto its Rust counterpart, then walks async/await with Tokio 1.x and the parts…
Rust for Swift devs: The type system, Part 4. Lifetimes are how Rust names the regions over which references are valid, so the compiler can prove a borrow never outlives its referent. The fourth post in the Rust-for-Swift-devs series translates Swift's runtime ARC contract into compile-time lifetime annotations, walks through elision, structs holding references, 'static, and lifetime bounds on…
Rust for Swift devs: The type system, Part 3. Memory and ownership is where Rust's design diverges most clearly from Swift's. The third post in the Rust-for-Swift-devs series translates Automatic Reference Counting (ARC), the Law of Exclusivity, weak/unowned references, and copy-on-write into Rust's single-owner moves, the borrow checker, Rc/Arc, Weak, and Cow.
Rust for Swift devs: The type system, Part 2. Swift's throws and Rust's Result<T, E> are two presentations of the same idea. The second post in the Rust-for-Swift-devs series translates throws, try, and do/catch into the Result type, the ? operator, and the From/Into conversion machinery, then covers thiserror, anyhow, and when to panic.
Rust for Swift devs: The type system, Part 1. Coming to Rust from Swift is a shorter transition than most assume. The first post in a series, starting with the type system: structs, enums, traits, generics, and the dyn/impl distinction.
Deploying Rust on AWS Lambda in 2026: how the toolchain has changed since 2019, and what a minimal, idiomatic setup looks like today.