# Future interactive post ideas

Working scratch list. Same format as the NLOS post: vanilla JS, 2D canvas, scenes scoped to a single post via `<link>` and `<script>` tags in the markdown. Each idea is a candidate; most of these are one-post-sized if focused.

## Electronics

- ~~**How a transistor actually amplifies.** Draggable base current / gate voltage on a NMOS or NPN schematic, live I-V curve on the side, carrier flow animation in the channel or base region. Payoff: "small signal gain" stops being a formula and becomes something you can see.~~ *Written 2026-04-23: [how-a-transistor-amplifies](/blog/how-a-transistor-amplifies/).*
- **LC resonance from scratch.** Tank circuit with sliders for L, C, and drive frequency. Show the phasors rotating, impedance magnitude/phase sweeping, and a scope trace of voltage vs current. Payoff scene: pumping the tank at resonance and watching it ring.
- **An oscillator starting up.** Colpitts or similar. Start from noise, show the limit cycle forming, let the reader nudge the loop gain and see it either die off or run away.
- **Feedback loop stability.** Drag the poles and zeros around on the s-plane, watch the step response and the bode plot change. The moment a pole crosses into the right half plane and everything goes sideways.
- **A superhet receiver, piece by piece.** Antenna, RF amp, mixer, LO, IF filter, detector. Tunable signals scrolling through the spectrum, user drags the LO, watches the desired signal slide into the IF passband. Image rejection as a visible thing.
- **A switching power supply.** Buck converter with a slider for duty cycle. Inductor current ramping and freewheeling, output ripple. Makes the "magic efficiency" of SMPS feel earned.
- ~~**Noise figure, cascaded.** Build a receiver chain by dragging in blocks (LNA, mixer, IF amp), each with a noise figure. Live link budget at the bottom. The Friis formula stops feeling abstract.~~ *Written 2026-04-29 (scheduled): [cascaded-noise-figure](/blog/cascaded-noise-figure/).*
- **Op-amp, opened up.** Differential pair on the left, gain stage in the middle, push-pull output on the right. Slider for input differential voltage, watch the tail current redistribute and the output swing. Then close the loop with a feedback resistor and watch virtual ground appear out of nothing.
- **Schmitt trigger hysteresis.** Noisy input riding on a slow ramp. Slider for the hysteresis band. Without it the output chatters wildly at the threshold; widen the band and the chatter stops. Show the two trip points moving on the transfer curve.
- **A SAR ADC, bit by bit.** Sample-and-hold capacitor charges, then the comparator and DAC binary-search the input. Step through each bit, watch the trial voltage close in on the sample. User can change resolution and see conversion time scale.
- **PLL locking.** Reference oscillator on one side, VCO on the other, phase detector and loop filter in between. Slider for loop bandwidth. Watch the VCO drag itself into lock, then perturb the reference and see the loop track. Crank the bandwidth too high and watch it ring.
- **Linear regulator vs LDO.** Pass transistor, error amp, reference. Slider for input voltage and load current. Drop the input toward the output and watch a standard regulator fall out of regulation while the LDO holds on. Power dissipation rendered as a thermometer on the pass element.
- **Crystal oscillator startup.** Pierce topology with the crystal modeled as its motional RLC plus shunt capacitance. Start from thermal noise. Slider for negative resistance from the active stage. Too little and it never starts; just enough and you watch a clean sine build over thousands of cycles.
- **Class-D from triangle and comparator.** Audio in, triangle carrier, comparator output as a PWM stream, LC filter recovering audio. Slider for switching frequency and modulation depth. The moment the recovered waveform looks identical to the input despite the output stage being only ever fully on or fully off is the payoff.
- **Charge pump, bucket by bucket.** Two capacitors and four switches. Step through the phases by hand at first, then let it run. Output voltage climbs to roughly twice the input. Add load current and watch the output sag, then crank the switching frequency to recover it.

## Computers / networking

- ~~**A TCP connection, from the packets' perspective.** Client on the left, server on the right, sequence numbers and window sizes visible, user can introduce loss or latency and watch congestion control react. Slow start, fast recovery, the window collapsing on a single dropped packet.~~ *Written 2026-04-27 (scheduled): [how-tcp-and-udp-work](/blog/how-tcp-and-udp-work/). Also covers UDP.*
- **How DNS actually resolves a name.** Recursive resolver, root, TLD, authoritative, caching. User types a hostname, watches the queries fan out with their TTLs.
- **What a CPU does per cycle.** A tiny toy ISA executing step by step. Pipeline stages, hazards, stalls. Adds a register renamer in a second scene and you get a decent intuition for why modern CPUs are fast.
- **Cache coherence (MESI).** Two cores, a shared line of memory, user issues reads and writes, arrows show the invalidations flying around. The reason your "obviously correct" lock-free code isn't is usually on this graph somewhere.
- **BGP finds a route.** A handful of ASes with peering relationships, user picks source and destination, watches announcements propagate and the path emerge. Bonus scene: a single misconfigured announcement leaking and causing a global outage.
- **Virtual memory and page tables.** Process issues a virtual address, the MMU walks the levels, TLB hits and misses, page fault handling. Good payoff if tied to a real program's memory map.
- **Diffie-Hellman in colored paint.** Two parties, a public modulus, private exponents kept hidden. Watch the shared secret emerge while an eavesdropper sees only the public exchange. Slider for prime size to show why small primes are trivially broken and large ones are not.
- **Huffman coding live.** Type a string, watch the frequency table build, then the tree assemble bottom-up, then the bit codes fall out. A second pane shows the encoded length shrinking as the message gets more redundant.
- **NAT and a stuck connection.** Two clients behind NATs trying to reach each other. Show the translation tables, the dropped SYNs, then a STUN server learning the mapped ports, then a hole punch succeeding. The reason video calls feel like dark magic becomes a diagram.
- **ARP, the unsung protocol.** A host wants to send a packet, has an IP, needs a MAC. Broadcast goes out, reply comes back, cache populates with a TTL. Second scene: a gratuitous ARP from a duplicate IP and the resulting chaos.
- **Raft electing a leader.** Five nodes on a ring, term counters, randomized election timeouts. User can pause a node, partition the network, watch a new leader emerge and then watch the old one rejoin and step down. The split-brain scenario as a movable thing.
- **Token bucket rate limiting.** Bucket fills at a steady rate, requests drain it. Slider for fill rate and burst size. Send a burst of requests and watch which get through and which get 429'd. Compare side-by-side with a leaky bucket.
- **Garbage collection, three flavors.** Same heap, same allocation pattern, three collectors running in parallel panes: mark-sweep, copying, generational. Watch pause times and fragmentation diverge. Slider for allocation rate to find where each collector falls over.
- **Branch prediction history.** A loop with a data-dependent branch. Toggle between always-taken, two-bit saturating counter, and a small perceptron predictor. Mispredict rate and pipeline bubbles rendered as wasted clock ticks.
- **A load balancer at work.** Incoming requests, a pool of backends with varying response times. Switch between round robin, least connections, and consistent hashing. Kill a backend and watch the failure modes differ.
- **Subnetting IPv4.** An address and a prefix length. Slider from /8 to /30. Bits light up in the network and host portions. Host count, usable range, broadcast address, and subnet mask all recompute live. Second scene: take a /22 and carve it into a /24 + /25 + /26 + /27 + /28 to fit a specific set of site sizes. Overlap and waste rendered visually so mixed-size CIDR carving clicks. Third scene: two hosts with given addresses and masks; show whether they're on the same subnet and, if not, what the gateway decision looks like.
- **Layer 2 and layer 3, side by side.** A small network: a few hosts, a switch, a router, two subnets. A packet leaves a host with a destination IP on the other subnet. Watch the ARP for the default gateway, the L2 frame addressed to the router's MAC, the router rewriting the L2 header and forwarding out a different interface, another ARP on the far side, final delivery. Toggle between a hub (collisions visible), a learning switch (MAC table filling in), and a router (routing table consulted per packet). Second scene introduces VLANs and trunking: the same switch logically split, a trunk port carrying tagged frames, the router-on-a-stick doing inter-VLAN routing. The phrase "broadcast domain" stops being abstract.
- **TCP in the weeds (follow-up to how-tcp-and-udp-work).** MSS negotiation, Path MTU Discovery, segmentation of a 10 KB write into 1460-byte segments, fast retransmit and SACK, delayed/accumulated ACKs, Nagle's algorithm, the PSH and URG flags, connection teardown with FIN/FIN-ACK and the TIME-WAIT state, keepalives and persist timers. One scene per mechanism with a small packet diagram each. Written for the reader who already understands the basics.

## Ham radio

- **SSB, from audio to RF.** Mic input on the left, phasing or filter method in the middle, RF out on the right. Show the audio spectrum, then the DSB-SC product, then USB after filtering or phasing. Bonus: demodulate it back on the receive side with a BFO offset and watch Donald Duck.
- **FT8 end to end.** 77 bits of payload, LDPC encoding, Costas sync, GFSK shaping, Gaussian noise, decoder pulling it back out under the noise floor. The part where you add enough AWGN to make the signal invisible and the decoder still pulls it is the Adams moment.
- **An SDR front end.** Antenna, bandpass, mixer with quadrature LO, anti-alias, ADC, decimation filters. User chooses the tuning frequency and the SDR slides through the spectrum.
- **Great circle and grid square math.** Enter two grid squares, get the path, bearing, distance. Drag either endpoint on a globe. Small but useful.
- **HF skip vs MUF.** Ionospheric layers with time-of-day and solar-cycle sliders. Rays launching at various angles, reflecting (or punching through) D/E/F layers, landing somewhere else on the globe. Great contrast piece to the NLOS post.
- **Feedline loss as a function of length, frequency, and type.** Slider for length, buttons for RG-58/RG-8/LMR-400/heliax. A visible chunk of transmit power disappearing into the coax as frequency climbs.
- **CW keying waveforms and key clicks.** A keyed carrier with adjustable rise and fall times. Time domain on the left, spectrum on the right. Hard keying produces audible-looking sidebands sprawling across the band; smooth shaping pulls them in. Slider for WPM to show the trade against keying speed.
- **QSK, in slow motion.** Transmit relay, PA, T/R switching, receiver muting, all on a millisecond timeline. User adjusts the keying speed and watches the sequencer's headroom shrink. The point at which the receiver hears its own backwave becomes obvious.
- **APRS packet over the air.** A position report becoming an AX.25 frame, then AFSK tones, then audio out. Inject noise on the channel and watch a digipeater either decode and forward or drop the frame. Second scene shows the path field accumulating hops.
- **Yagi pattern, element by element.** Start with a driven dipole. Add a reflector behind it, watch the back lobe collapse. Add directors out front one at a time, watch the main lobe sharpen and the side lobes appear. Slider for boom length sweeps gain against beamwidth.
- **Antenna tuner matching anything.** L-network with two variable components. User picks an arbitrary load on a Smith chart, watches the tuner walk the impedance toward 50 ohms. Show the loss in the tuner climbing as the mismatch gets ugly.
- **Baluns, currents, and common mode.** A coax-fed dipole with no balun, current on the shield rendered as a moving arrow. Add a choke balun, watch the common-mode current die. Receiver noise floor in a side panel drops as the feedline stops radiating.
- **Lightning and station grounding.** A strike hits the tower. Trace the current down through the ground rods, across the bond to the shack ground, and (without a single-point ground) up through the radio and out the AC mains. Toggle a proper ground window and watch the current bypass the gear.
- **QRP propagation reality check.** Slider for power from 100 W down to 100 mW. Path loss, noise floor, and required SNR for SSB, CW, and FT8 plotted as bars. The point where 5 W on FT8 still closes the link but 100 W on SSB does not is the punchline.

## Microwave / advanced RF

- **Rain scatter.** A rain cell, two stations not in LOS, common volume in the cell. Slider for rain rate, frequency. Show how a signal bounces off the precipitation and arrives from a totally wrong direction. Natural follow-up to the NLOS post.
- **Meteor scatter.** A meteor streaking through the ionosphere leaving a plasma trail, signal reflecting during the brief window. Ping lengths, burst rates. An argument for why 6 meters is worth owning a rig for.
- **EME (moonbounce).** Lunar geometry, path length, Doppler spread from libration, degree of polarization rotation from Faraday. Answer to "why do I need a big dish for this" becomes visually obvious.
- **Phased array beam steering.** Array of elements, user slides the phase taper, the beam sweeps. Grating lobes appear if spacing is too wide. Explains why Starlink and every modern radar system looks the way it does.
- **Smith chart, but friendly.** Drag a load impedance, watch reflection coefficient, SWR, and return loss update. Add a matching network with an L-network or stub and watch it slide to the center.
- **Parabolic dish aperture.** Slider for diameter and frequency, see gain vs beamwidth vs sidelobes. Illumination taper as a second control, showing the efficiency / sidelobe trade.
- **ITU-R P.838 rain attenuation.** Pick a frequency, a rain rate, and a path length. Curve of attenuation over the full microwave band. Useful companion to anything on 10 GHz and up.
- **S-parameters, demystified.** A two-port network with adjustable internal components. Drag a frequency cursor across the band, watch S11, S21, S12, S22 trace out on a Smith chart and a magnitude plot in lockstep. Toggle between an amplifier, a filter, and an attenuator and see what each one's signature looks like.
- **Stub matching on a transmission line.** A mismatched load at the end of a line. User slides a shorted shunt stub along the line and adjusts its length. SWR upstream of the stub plotted live. Watch the match snap into place at the right position.
- **Prime focus vs Cassegrain.** Same dish diameter, two feed geometries side by side. Ray trace the illumination, show the spillover and the blockage from each. Slider for f/D and subreflector size to see how the trades shift.
- **Polarization tracking a LEO bird.** A satellite with linear polarization passing overhead. Show the apparent polarization angle rotating from horizon to horizon as geometry changes. User dials a manual rotator to keep up, or enables auto-tracking. Signal strength dips on every degree of mismatch.
- **LNA bias network.** A GaAs FET with a gate bias tee, drain choke, and decoupling. Slider for drain voltage and gate voltage. Live IV curve, noise figure circles, and gain compression all updating. A second scene adds a missing bypass cap and shows the LNA breaking into oscillation.
- **Waveguide modes.** A rectangular guide cross-section. User picks a frequency. Below cutoff, nothing propagates; cross the TE10 cutoff and the field pattern lights up. Push higher and TE20, TE01, and TM11 appear with their distinct patterns. Group velocity slowing near cutoff is visible.
- **Sun noise as an antenna check.** Point a dish at cold sky, then drag it onto the sun. Y-factor in dB updates live. Slider for dish size and frequency derives system noise temperature from the result. Calibration without a noise source.
- **Noise temperature and noise figure, two views of one thing.** A receiver chain with a slider that toggles the unit between K and dB. Friis recomputes in both. Toss in a lossy feedline ahead of the LNA and watch the system noise temperature jump in a way the noise figure number understates.

## Signals, systems, and information theory

- **The sampling theorem, aliased in front of you.** A continuous sine wave on top, a row of sample ticks below, reconstructed signal at the bottom. Slider for sample rate. Cross below 2*f and watch the reconstruction turn into a different, slower sine pretending to be the original. The point at which a CD sampling rate stops being arbitrary and becomes a physics statement.
- **Convolution, drawn two ways.** One signal slides across another, pointwise product summed at each offset. Payoff scene: the same operation in the frequency domain, where it collapses to a multiplication. Reader sees why "filter" and "impulse response" are the same object.
- **The Fourier transform, built from sines.** Start with a square wave. Add harmonics one at a time with a slider. The Gibbs overshoot appears and refuses to go away no matter how many terms you add. Second scene flips to a single narrow pulse in time and its flat spectrum, showing the time/frequency uncertainty trade.
- **Matched filter, against noise.** A known pulse buried in Gaussian noise. Slider for SNR. On one side the raw signal is invisible; on the other the matched filter output has a sharp peak exactly where the pulse lives. The reason GPS and radar work at negative SNR stops being voodoo.
- **The FFT butterfly.** N samples, a lattice of butterfly operations, twiddle factors labeled. Step through a size-8 FFT one stage at a time and watch N*log(N) happen instead of N squared. The single piece of math that most of modern signal processing sits on top of.
- **Shannon capacity.** C = B * log2(1 + S/N). Two sliders for bandwidth and SNR. The log curve is flatter than people expect. Show how far you can push bandwidth vs how far you can push SNR, and where each one hits diminishing returns. Plot an existing mode (FT8, QPSK, 64-QAM) against the Shannon limit to see how much room is left.
- **Bit error rate vs Eb/N0, for a few modulations.** Curves for BPSK, QPSK, 16-QAM, 64-QAM. Slider shifts Eb/N0 and a live constellation shows dots dispersing through the decision boundaries. Error-correction coding as a horizontal shift of the whole curve to the left.
- **Autocorrelation and cross-correlation.** Noisy signal on top. Its autocorrelation reveals the periodic piece hidden inside. Second scene: two copies of a PRN code, slide one against the other, correlation peak narrow and tall. The trick GPS uses to pick one satellite out of many on the same frequency.
- **Quantization noise.** An analog sine feeding an N-bit ADC. Slider for N. The reconstructed signal shows steps; the residual is white-ish noise. Spectrum plot shows the noise floor rising by 6 dB for every bit you drop. Dithering appears in a second scene and un-correlates the quantization from the signal.
- **The Z-transform and the unit circle.** Drag poles and zeros around the z-plane. Frequency response magnitude is the distance from the unit circle. Poles outside the circle blow up; poles inside, bounded. FIR vs IIR stops being a taxonomy and becomes "does your filter have any poles that aren't at the origin?".

## EM and wave physics

- **Maxwell, one equation at a time.** Four scenes, one per equation. Gauss with a charge surrounded by flux lines; Gauss for magnetism with none escaping; Faraday with a changing B-field inducing a loop voltage; Ampere-Maxwell with a current plus a changing E-field producing B. Final scene stacks all four to produce a self-propagating wave.
- **Plane wave versus spherical wave.** A point source radiates a spherical wave in one pane; a far-field observer sees it as locally planar in another. Slider for distance from source. The "when is it OK to treat this as a plane wave?" question becomes a number instead of a hunch.
- **Polarization, linear through elliptical.** Two orthogonal sinusoids with adjustable amplitude and phase delay. The resulting E-field vector traces a line, ellipse, or circle depending on the sliders. A receiver with a fixed linear antenna shows its extracted amplitude in real time.
- **Near field versus far field.** An antenna with its reactive near field, radiating near field, and far field zones shaded. Slider for observation distance. At what point does the pattern stop changing shape and only change amplitude? Spoiler: about 2*D^2/lambda from the aperture.
- **Poynting vector and where power flows.** A coaxial cable carrying DC and a coax carrying RF. Field lines, current, and the Poynting vector direction rendered. The surprise that energy flows in the dielectric, not the copper, demonstrated without words.
- **Skin depth as a function of frequency.** A conductor cross-section. Current density falls off exponentially from the surface. Slider for frequency and material. At 1 GHz in copper the skin depth is a couple of micrometers; at 50 Hz in iron it is centimeters. Explains why Litz wire exists and why silver-plating an audio connector is witchcraft.
- **Standing waves and SWR, visualized on a line.** A transmission line with adjustable load impedance. Forward wave, reflected wave, and their sum rendered as animated sinusoids. The voltage maxima and minima settle into the standing-wave pattern; SWR comes out as the ratio of max to min. The Smith chart becomes less mysterious once this has clicked.
- **Snell's law and total internal reflection.** Two media with adjustable refractive indices. Drag the incident ray angle. Watch the refracted ray bend; push past the critical angle and watch it disappear entirely. The physics underneath both fiber optics and moonrise mirage.
- **Reciprocity.** An antenna pattern used for transmit, then used for receive. The gain pattern is the same both ways. Slider animates between modes. Explains why a great receive antenna is also a great transmit antenna, and vice versa.
- **Radiation resistance and antenna efficiency.** A dipole with adjustable length. Input impedance, radiation resistance, loss resistance, efficiency. Shorten the dipole: loss resistance dominates and efficiency tanks. This is why a mobile HF whip hates 80 meters.

## Semiconductors, from physics up

- **The PN junction forming.** Two doped regions being brought into contact. Electrons and holes diffuse across, leave behind charged dopant atoms, create a depletion region and a built-in potential. Apply forward bias and watch the depletion region shrink; reverse bias and watch it grow. Diode I-V curve falls out.
- **A BJT in three regions.** A cross-section of an NPN with adjustable base current. Watch carriers injected from emitter across the thin base and swept into the collector. Slider moves the device from cutoff to active to saturation. The current-gain ratio beta emerges as "what fraction of emitter carriers make it to the collector."
- **A MOSFET forming a channel.** NMOS cross-section. Slider for gate voltage. Below threshold, nothing. Cross Vt and an inversion layer appears under the gate. Crank Vds and watch the channel pinch off at the drain end; saturation current stops depending on Vds. The place where the square-law equations actually come from.
- **Band diagrams, the short version.** Conduction and valence bands plotted through a device. Add a PN junction and the bands tilt. Apply a bias and they tilt more. The Fermi level stays level at equilibrium, and offsets from each other at bias. Every semiconductor behavior comes out of this picture if you read it right.

## Circuits, the foundations

- **Kirchhoff, on a circuit you actually made.** A real schematic with a few loops and nodes. Solve it by KVL, then by KCL, then by superposition. Each method animated as a separate pass over the same circuit. Same answer, three ways, and you get to pick the shortest one for your specific case.
- **Thevenin and Norton, interchangeable.** A messy network of sources and resistors. Collapse it to a Thevenin source and series resistor. Second scene converts to Norton. Slider changes a load; current and voltage at the load match in all three representations.
- **RC time constant, charging and discharging.** A capacitor through a resistor from a step source. Slider for R and C. Voltage rises as 1 - e^(-t/tau); discharge falls as e^(-t/tau). Tau drawn on the curve as the 63% point. The same math that shows up in every decoupling, debouncing, and low-pass filter problem.
- **RLC transient response.** Step into a series RLC. Underdamped rings, critically damped settles in one shot, overdamped crawls in. Slider for damping ratio. Shows up anywhere a system has both storage and resistance, which is everywhere.
- **Maximum power transfer.** A source with internal resistance Rs driving a load Rl. Slider for Rl. Power delivered to the load peaks exactly at Rl = Rs. Half the total power dissipates in Rs at that point, which is the price of matching. Useful for RF and audio alike.
- **Three-phase power, why three.** Three sinusoids, 120 degrees apart, summed on a neutral wire. The neutral current is zero at balanced load. Unbalance the loads and the neutral starts carrying the difference. The reason your oscilloscope doesn't see a flickering line voltage in a commercial building.

## Digital fundamentals

- **A CMOS inverter switching.** NMOS and PMOS stacked. Input sweeps from 0 to Vdd. Both transistors' operating regions rendered live. The switching point, short-circuit current spike, and propagation delay all show up on a time trace in a second pane.
- **A flip-flop, a latch, and metastability.** Data and clock signals drive a D flip-flop. Hold-time and setup-time violations cause a metastable output that takes an uncertain time to resolve. Slider for data-edge-to-clock-edge offset. The probability curve of resolution time is a separate scene.
- **PWM, as seen by a motor.** A square wave with adjustable duty cycle driving an RL load. Current follows an exponential average. Slider for switching frequency. Below a certain frequency the current ripples audibly; above it the ripple is invisible. The case for fast switching rendered as a ripple amplitude.
- **SPI, I2C, and UART on a scope.** Three short protocol exchanges side by side, same payload. SPI's clock and separate lines; I2C's start condition and address byte; UART's start, stop, and baud-rate-defined bit widths. The tradeoffs (speed, wire count, addressing, ack) made visible.
- **Clock domain crossing.** Two clocks at unrelated frequencies. A signal from one domain sampled by the other. Metastability events highlighted. Add a two-flop synchronizer and watch them disappear. Add a FIFO for multi-bit signals and watch the timing close.

## Operating systems, from the kernel's side

- **A scheduler picking the next task.** A ready queue of tasks with priorities and time slices. Tick by tick, the scheduler picks a task, runs it, updates its virtual runtime, puts it back. Completely Fair Scheduler's red-black tree animated. Second scene is realtime FIFO, third is round-robin. Contrast in one page.
- **A syscall round-trip.** User process issues a read(). Registers loaded, `syscall` instruction fires, CPU jumps to the kernel entry point, privileges flip, kernel code runs, bytes move, registers restored, user resumes. Each step a frame. The cost of a syscall as a visible number of cycles.
- **A page fault handled.** Virtual address that isn't mapped. MMU raises a fault, kernel handler decides: demand page from disk, copy-on-write fork duplicating a shared page, stack growth, segfault. Four different fates for the same hardware event, selected by which bit was missing.
- **Copy-on-write fork.** Parent process with memory mapped. fork() makes a child sharing those pages read-only. Write to one; the kernel copies only the touched page. Scene counts pages copied as the parent and child diverge, showing why fork() is cheap even for giant processes.
- **A mutex, spinning and sleeping.** Two threads contending for a resource. First scene: spinlock, burning CPU. Second: a futex that sleeps when contended. Slider for expected critical-section length. The tradeoff between cache-thrash and context-switch cost rendered.
- **Interrupts vs polling.** A NIC receiving packets. First scene polls constantly, CPU busy 100%. Second uses interrupts, CPU idle between packets. Third adds interrupt moderation (NAPI): an interrupt arms a poll loop when traffic is heavy. The reason 10 gigabit NICs do the thing they do.

## Databases and storage

- **A B-tree growing.** Empty B-tree of order 4. Insert keys one at a time. Watch the root split, then a level split, then a level split a level split. The reason every disk-based index on earth is some variation on this.
- **Write-ahead logging and crash recovery.** A transaction touches several pages. Redo records written to the WAL first, then pages updated in memory, then eventually flushed. Pull the plug mid-flush; the WAL replays to recover. The durability half of ACID made concrete.
- **MVCC, multiple readers, one writer.** Row with three historical versions tagged by transaction id. Reader at txn id X sees the version visible to X, even while a writer creates a new version. The scene where your long-running report doesn't block the application writing to the same table.
- **Two-phase commit, and how it fails.** Coordinator and three participants. Prepare phase, commit phase. At each possible crash point, the protocol's recovery logic is shown. The one crash window that leaves a participant blocked forever (the textbook liveness problem) is highlighted.
- **Paxos in slow motion.** Three acceptors, two proposers. Proposal numbers and acceptance states tracked. Reader steps through a run where a leader is elected, a value is chosen, and a network partition is tolerated. Second scene shows a failure mode (dueling proposers) and how to avoid it.
- **Consistent hashing for a sharded store.** A ring of hash slots. Drop a key onto the ring; it lands on the next node clockwise. Add a node: only keys between the new node and its predecessor move. Remove a node: its keys migrate to the next one. The reason every distributed cache and database on earth uses some version of this.

## Cryptography, from numbers up

- **RSA, key generation and encryption.** Pick two small primes. Compute modulus and totient. Choose e and derive d. Encrypt a tiny integer with (e, n); decrypt with (d, n). All numbers small enough to see. Second scene shows why you can't factor the modulus when the primes are 1024 bits.
- **An elliptic curve and point addition.** A real curve y^2 = x^3 + ax + b plotted. Pick two points; draw the chord; reflect the third intersection; that's the sum. Scalar multiplication by doubling. Second scene switches to the same group over a finite field and the pretty curve turns into a cloud of points, which is the one that actually secures TLS.
- **TLS 1.3 handshake.** ClientHello to Finished, message by message. Key schedule derivation at each stage. What is encrypted, what is not, what is signed. The round trips counted. The difference between 1.3 and 1.2 made visible.
- **A Merkle tree verifying a leaf.** A tree of hashes. Verifier has the root; prover provides a leaf plus a log(N) path of sibling hashes. Verifier recomputes the root and compares. The thing Bitcoin, Git, and every modern certificate transparency log are built on.
- **AES, one round at a time.** 16-byte state as a 4x4 grid. SubBytes, ShiftRows, MixColumns, AddRoundKey rendered as distinct operations. Step through all 10 rounds for AES-128 and watch the state diverge from plaintext to ciphertext.
- **Diffie-Hellman and MITM.** A clean DH exchange in one scene. In a second, an active attacker intermediates: the two honest parties each share a key with the attacker and think they share one with each other. The reason TLS adds authentication on top.
- **Hash collisions, and why SHA-256 doesn't.** A small hash function like SHAKE-8 with a visible output space. Birthday paradox on the collision probability as inputs accumulate. Second scene scales up: SHA-256 at 2^128 birthday bound, and what that number actually means.

## Control theory, practical

- **Pole placement on the s-plane.** Drag poles around, watch the step response change. Poles on the real axis damp without oscillation; complex pairs ring at the imaginary part and decay at the real part. Cross into the right half plane and the system runs away. Engineering instinct in one picture.
- **Root locus, drawn live.** An open-loop transfer function with a variable gain K. As K sweeps, the closed-loop poles trace paths from open-loop poles to open-loop zeros. The one time a graphical method earns its keep against a computer.
- **State-space, for somebody who's only seen transfer functions.** A second-order system written both ways. A slider changes the system matrix A. Eigenvalues of A are the poles of the transfer function; watch them move in lockstep. Once the equivalence clicks the formalism stops being intimidating.
- **A Kalman filter tracking a noisy target.** Position and velocity states. Noisy measurements coming in. The filter's state estimate and covariance update with each measurement. Slider for process noise and measurement noise. Crank measurement noise up and the filter trusts its model more; crank process noise up and it trusts the measurements more.

## Numerical methods

- **Newton's method finding a root.** A curve, a starting guess, the tangent line hitting zero, the next guess, the next tangent. Converges quadratically when you are near the root. Pick a pathological starting point and watch it diverge or oscillate forever.
- **Gradient descent on a real loss surface.** 2D loss function with adjustable step size. Too small and it takes forever; too big and it diverges. Add momentum and watch it ride through flat regions. Add adaptive step sizes (Adam) and watch it handle badly-conditioned basins. The whole animation you wish somebody had shown you the first time you trained a model.
- **Finite differences for a PDE.** Heat equation on a rod. Discretize space and time, march forward. Slider for dt/dx^2. Cross the stability bound and watch the simulation explode. Fix it with implicit Euler and watch it behave. The CFL condition rendered as "don't do this."
- **Conjugate gradient, step by step.** A quadratic loss in 2D. Regular gradient descent zig-zags toward the minimum. Conjugate gradient picks directions that don't undo previous progress and converges in exactly N steps for an N-dimensional problem. Side-by-side.

## Longer arcs

A couple of ideas that would be a whole series, not one post.

- **"Build a receiver from first principles."** Start at an antenna picking up an EM wave, end at a speaker playing audio. Every stage a scene. Takes the shape of a short book.
- **"What the atmosphere is doing right now."** Live data from prop.w5isp.com, rendered as an interactive cross-section of North Texas atmosphere at the current hour. Refractivity aloft, ducts forming and collapsing, paths scored against real conditions. Operational rather than explanatory.
- **"Every component in my station, demystified."** One post per piece of gear. Transverter, PA, sequencer, rotator, preamp. Each one a scene that makes the internal thing you pay for make sense.
- **"How GPS knows where you are."** A series. One post on pseudoranges and trilateration with four satellites, one on the navigation message and clock corrections, one on ionospheric and tropospheric delay, one on RTK and carrier phase. Each scene builds the previous post's output into its inputs.
- **"A radar, from pulse to picture."** Start with a single pulse and a target return. Add pulse compression with a chirp and matched filter. Add Doppler processing across a pulse train. Add MTI to suppress clutter. End at a synthetic aperture image of a patch of ground. Each step a scene, each scene reusing the prior one's signal.
- **"Light down a fiber."** A series on optical comms. Modes in a step-index fiber, then graded index, then single mode. Chromatic and polarization-mode dispersion as time-domain pulse smearing. EDFA gain. Coherent detection and DSP equalization. The series ends with a 400G link budget that actually closes.
- **"Control loops that don't ring."** PID tuning as a sandbox. A plant (motor, thermal mass, antenna rotator) with adjustable P, I, D. Step responses, disturbance rejection, integrator windup. Second post on cascaded loops. Third on feedforward. By the end the reader has tuned a real-feeling system without wanting to throw the rotator off the tower.

## House style

Keep each post focused, one topic, deep. No survey posts. Interactive bits earn the page weight, static bits carry the prose load. No em-dashes. Adams when it fits, silence when it doesn't.