Networking & Protocols
The physical frontier
Every few years a vendor announces a link technology that sounds like science fiction — light through air, terahertz radio, quantum-secured keys. Most engineers feel they have to relearn the physical layer each time. They don’t: one model decodes them all.
Long-haul fibre is an analog fight
Light through 5,000 km of single-mode glass is not a clean digital channel — it is an analog signal being slowly destroyed. Three impairments dominate. Chromatic dispersion: different wavelengths travel at slightly different speeds, so a pulse spreads out and bleeds into the next symbol. Polarisation-mode dispersion (PMD): the two orthogonal polarisations of light arrive at slightly different times. Four-wave mixing: in a DWDM system packing 60+ wavelengths into one fibre, nonlinear effects make adjacent channels generate spurious tones that interfere with their neighbours.
For decades the fix was physical: dispersion compensation modules (DCMs) — spools of specially designed fibre that bend the dispersion back. Modern long-haul has moved the fight into DSP. Coherent detection recovers not just the amplitude of the light but its phase, the same way a radio receiver mixes against a local oscillator. Once you have phase, you can run higher-order modulation (16-QAM, 64-QAM on light) and let a digital signal processor undo chromatic dispersion and PMD in software after the fact. The payoff is dramatic: a modern coherent transceiver carries 800 Gbps on a single wavelength, and 60+ wavelengths share one fibre — tens of terabits per fibre pair.
FEC is what makes the SNR margin real
The raw optical channel on a long submarine span has a bit error rate around 1e-6 — one bad bit in a million, far too noisy to ship. Yet the delivered BER is better than 1e-12. The entire gap is forward error correction. Long-haul optics use a concatenated scheme: an LDPC (Low-Density Parity Check) inner code with iterative soft-decision decoding, wrapped in a Reed-Solomon outer code that mops up residual burst errors. The result is 10 dB or more of coding gain — the channel behaves as if it had ten decibels more signal than it physically does, which translates directly into more bits per symbol or longer reach between amplifiers.
The trade is latency and silicon: FEC adds redundant bits (overhead, typically 7–25%), the decoder burns power and adds a fixed processing delay, and once you are FEC-limited the channel fails as a cliff — degrade the SNR slightly past the correction threshold and BER jumps from 1e-12 to unusable, with no gradual warning.
- Coherent long-haul
- 800 Gbps/wavelength, 60+ λ/fibre
- FEC coding gain (submarine)
- raw BER 1e-6 → post-FEC 1e-12, 10+ dB
- Wi-Fi 7 (802.11be)
- 320 MHz channels, 4096-QAM (12 bits/symbol)
- Hollow-core fibre
- ~50% faster than solid glass (light in air)
- QKD over fibre
- ~100 km range without quantum repeaters
- Post-quantum (ML-KEM)
- shipping in TLS now, NIST FIPS 203
The radio frontier: Wi-Fi 7, 5G-Advanced, 6G
Radio keeps mining the same Shannon levers — more bandwidth, more bits per symbol. Wi-Fi 7 (802.11be) doubles the channel width to 320 MHz, pushes modulation to 4096-QAM (12 bits per symbol versus 10 for Wi-Fi 6), and adds Multi-Link Operation — one client transmitting on 2.4, 5, and 6 GHz concurrently rather than picking one. 5G-Advanced (3GPP Release 18, finalised in 2024) is the mid-life upgrade to 5G: AI/ML optimisation of the air interface, 20%+ RAN power reduction, and tighter satellite (non-terrestrial network) integration. 6G research (2030+) is reaching for terahertz frequencies, an AI-native air interface designed around learned components from day one, and integrated sensing — the network using its own radio to map the physical environment, not just carry data.
Why this works
Why hollow-core fibre is a bigger deal than it sounds. Light in solid glass travels at ~200,000 km/s — the glass slows it by a third. Hollow-core fibre guides light through air held inside a microstructured glass lattice, so it propagates at close to vacuum speed: roughly 50% faster than solid glass. For most workloads that is irrelevant. For latency-bound businesses — high-frequency trading, where a transatlantic round-trip shaved by milliseconds is worth real money — it rewrites the economics. It is the rare physical-layer change that lowers the latency floor itself, the floor that no software optimisation can touch. Field trials are running now; broad deployment is the work of the late 2020s.
Co-packaged optics, LEO, and the quantum question
Two more shifts worth tracking. Co-packaged optics (CPO) moves the optical transceiver off the pluggable front panel and integrates it directly into the switch ASIC package — cutting the electrical distance signals travel, slashing per-port power, and enabling denser fabrics as port speeds climb past 800G. LEO satellite constellations (Starlink and peers) reshape the latency-versus-coverage trade: an orbit at ~550 km gives 20–50 ms RTT, an order of magnitude better than GEO’s ~600 ms, while reaching places no fibre will ever go.
Then the quantum question, where it pays to separate hype from practice. Quantum key distribution (QKD) uses the physics of photons to detect any eavesdropper on a key exchange — but it runs over fibre with a hard range limit near 100 km, because you cannot amplify a quantum state and quantum repeaters are still a research problem. The practical thing here now is the opposite: post-quantum cryptography. ML-KEM and ML-DSA (NIST’s standardised lattice algorithms, FIPS 203/204) are classical software that resists attack by a future quantum computer, and they are already shipping inside TLS handshakes. QKD is a decade-plus from changing day-to-day networking; post-quantum crypto is changing it this year.
Which IEEE 802.11 amendment defines Wi-Fi 7, with 320 MHz channels and 4096-QAM?
A vendor pitches QKD as the answer to quantum computers breaking your TLS. What is the realistic position for a fullstack engineer today?
The durable model
Standards documents for link technologies run to hundreds of pages, and they keep arriving. You do not need to read them cover to cover. When you hit an unfamiliar link technology — a new Wi-Fi version, an optical standard, an industrial fieldbus — three sections tell you 80% of what you need:
- Physical medium — copper, fibre, or a radio band. This sets the propagation speed (latency floor) and the noise environment.
- Encoding scheme — modulation order, line coding, and FEC. This sets bits per symbol and how gracefully the link degrades.
- Frame format — header, payload boundaries, MTU. This sets overhead and how the link layer hands off to the network layer.
Cross-reference those three and you can estimate bandwidth, latency, error behaviour, and where real deployments will struggle — without reading the spec front to back.
A high-frequency trading firm wants the lowest possible NYC↔Chicago round-trip latency. Pick the physical-layer investment.
Applying the three-question model
1/3- 01What does coherent detection recover that direct detection does not, and why does that matter for long-haul fibre?
- 02Raw BER on a submarine span is ~1e-6 but delivered BER is ~1e-12. Explain the gap and its cost.
- 03What three things should you read about any unfamiliar link technology, and what does each tell you?
Long-haul single-mode fibre is an analog fight against chromatic dispersion, PMD, and four-wave mixing; coherent detection recovers phase so a DSP can undo those impairments and run higher-order modulation, carrying 800 Gbps per wavelength. FEC — LDPC inner plus Reed-Solomon outer — buys 10+ dB of coding gain, turning a raw 1e-6 BER into a delivered 1e-12, at the cost of overhead and cliff-edge failure. The radio frontier mines the same Shannon levers: Wi-Fi 7 with 320 MHz channels and 4096-QAM, 5G-Advanced (3GPP Release 18), and 6G research toward terahertz. Hollow-core fibre is the rare change that lowers the latency floor itself; post-quantum cryptography (ML-KEM) is the practical quantum defence shipping in TLS today, while QKD remains range-limited research. The durable takeaway: read three things — medium, encoding, frame format — and any new link technology is 80% decoded.
appears again in162
- The journey of a request: seven stops from socket to responsejunior
- Accept and parse: from kernel queue to a typed requestmiddle
- Routing and middleware: choosing what runs, and in what ordermiddle
- Handler and response: from business logic to bytes on the wiremiddle
- Streaming and backpressure: when the client reads slower than you writesenior
- Timeouts and tail latency: budgets, deadlines, and the fan-out trapsenior
- Middleware and DI: the two patterns that shape every backendjunior
- Writing middleware: signatures, next(), and the three framework modelsmiddle
- Inversion of control: how dependencies reach a classmiddle
- DI scopes and lifecycles: singleton, request, transientmiddle
- DI as a testing seam: fakes, mocks, and the boundary that matterssenior
- DI containers in production: resolution graphs, circular deps, and when not tosenior
- Blocking vs non-blocking I/O: two ways to waitjunior
- The event loop: one thread, ordered phasesmiddle
- What blocks the loop: CPU work and sync callsmiddle
- Offloading CPU work: worker threads and the libuv poolmiddle
- Backpressure and bounded concurrencysenior
- Throughput under load: tail latency and saturationsenior
- Why pool: the cost of creating a connectionjunior
- Pool sizing: why bigger is not fastermiddle
- Acquisition and timeouts: the wait queue is the real latency dialmiddle
- Retry strategies: backoff, jitter, and thundering herdmiddle
- Observability, production failures, and global-scale designsenior
- Tasks, microtasks, and scheduler.yield()middle
- Timer accuracy, throttling, and idle workmiddle
- Node.js event loop: phases, nextTick, and loop lagsenior
- Rendering strategies: SSG, SSR, ISR, streaming, and hydrationjunior
- SSG, SSR, ISR, streaming, and RSC — how each worksmiddle
- Hydration cost: selective, progressive, islands, resumabilitymiddle
- Core Web Vitals: what LCP, INP, and CLS measurejunior
- LCP: four phases, one dominant costmiddle
- INP: input delay, processing, presentationmiddle
- Lab vs field: why the two disagree and how to use eachmiddle
- Metric tradeoffs, RUM attribution, and the CI+field loopsenior
- The full picture: URL to LCP to INP as a relay racejunior
- Eight layers traced: from the service worker to the second navigationmiddle
- Five canonical breaks: where production reliably diessenior
- The three-track method: reading traces and building a monitored systemsenior
- What an index is and how it speeds up queriesjunior
- The leading-column rule and composite index designmiddle
- Partial, expression, and covering indexesmiddle
- Index types: GIN, GiST, BRIN, Hash, Bloom, and HOT updatesmiddle
- Index-only scans, the Visibility Map, and INCLUDEsenior
- Production failure modes and the index audit playbooksenior
- Index design exercise: full-text search strategysenior
- EXPLAIN and execution plans: what the planner decides and whyjunior
- Scan types: Seq, Index, Bitmap, Index-Onlymiddle
- Join algorithms and the row-estimate cascademiddle
- pg_statistic, ANALYZE, and production observabilitymiddle
- Extended statistics: fixing correlated-column estimate failuressenior
- Plan cache, cost-constant tuning, and planner internalssenior
- Production failure modes and plan stabilitysenior
- Connection pools: amortising the cost of a Postgres backendjunior
- PgBouncer session, transaction, and statement modesmiddle
- Pool sizing: the (cores × 2) + spindles formula and the two-layer stackmiddle
- Pool exhaustion and idle-in-transaction: the 3 AM failure modemiddle
- Migrating to transaction mode: rollout playbook and PgBouncer 1.21 prepared statementsmiddle
- The Postgres process model and why raising max_connections degrades throughputsenior
- Pooler landscape 2026, serverless connection storms, and the full failure-mode taxonomysenior
- ADD COLUMN: instant in PG 11+ vs rewrite in older Postgresjunior
- The lock-queue failure mode: why instant DDL can freeze the databasemiddle
- Safe DDL patterns: NOT VALID, CONCURRENTLY, and unsafe-op fixesmiddle
- Migration failure taxonomy and production disciplinesenior
- Shard-key selection: hash, range, list, and directory strategiesmiddle
- Co-location and Citus: the invariant that makes sharding usablemiddle
- The hot-shard failure mode: detection, isolation, and durable policymiddle
- Online resharding, 2PC, and the operational cost of shardingsenior
- The seven acts: from CREATE TABLE to Citusjunior
- Acts 1–3 in depth: schema, indexes, and planner statisticsmiddle
- Acts 4–6 in depth: MVCC bloat, connection pooling, and safe migrationsmiddle
- Act 7 in depth: sharding, co-location, and the seven-tier tradeoff cascademiddle
- Observability, anti-patterns, and production triagesenior
- What the three signals are: logs, metrics, and tracesjunior
- Metrics and cardinality: the cost model of a time-series databasemiddle
- Logs and volume: the cost model of structured loggingmiddle
- Traces and sampling: the cost model of distributed tracingmiddle
- Join keys and exemplars: making the three signals composemiddle
- Observability 2.0: wide events and the cost shiftsenior
- Failure modes and engineering practice: cardinality budgets, PII, and samplingsenior
- Why structured logs exist: the diary vs the spreadsheetjunior
- The production log schema: fields every line must carrymiddle
- Log levels and alert routingmiddle
- Sampling strategies and log costmiddle
- PII redaction and log injectionsenior
- Trace context propagation in logssenior
- OTel Logs Data Model and audit logs as a subsystemsenior
- OTel signals, Semantic Conventions, and the OTLP wire formatmiddle
- Auto-instrumentation and manual spans: the 80/20 of OTelmiddle
- The OTel Collector: receivers, processors, exporters, and deployment patternsmiddle
- Sampling strategies: head, tail, and parent-basedmiddle
- Vendor neutrality, eBPF instrumentation, the Operator, and browser/serverless OTelsenior
- Operating the OTel Collector: reliability, version skew, failure modes, and governancesenior
- RED and USE: two checklists, one triage disciplinejunior
- Instrumenting RED in Prometheus: counters, histograms, and cardinality disciplinemiddle
- USE on Linux: CPU, memory, disk, network, and PSImiddle
- Golden signals, dashboard layout, and service mesh auto-REDmiddle
- Cardinality as a cost driver: labels, PII, exemplars, and samplingmiddle
- Native histograms, SLO tie-in, and production failure patternsmiddle
- Choosing SLIs and SLO targets: ratios, not feelingsmiddle
- Multi-window multi-burn-rate alerting: why AND beats ORmiddle
- Error budget policy, latency SLOs, and composite journeysmiddle
- Iceberg SLIs, composite SLO math, and SLA vs SLOsenior
- Flame graphs: reading the picture that shows where time goesjunior
- Sampling vs instrumentation profiling: why 99 Hz wins in productionmiddle
- Profile types: CPU, memory, off-CPU, mutex — which one to reach formiddle
- Continuous profiling: always-on flame graphs with eBPF and trace-id correlationmiddle
- How flame graphs are built from samples, and the production workflows that use themmiddle
- Linux perf, eBPF internals, PGO, and the limits of samplingsenior
- Profiling in production: security, war stories, OTel profiles, and the infrastructure designsenior
- The debugging funnel: SLO → RED → trace → profilejunior
- OTel architecture: one SDK, four signals, one wire formatmiddle
- Cost discipline: keeping observability under 5% of infra spendmiddle
- Scale, security, and the ROI of observable systemssenior
- Why profile first: measure where time actually goesjunior
- Amdahl''''s law and self-time: the ceiling on every speedup you can shipmiddle
- The measurement loop: microbench, macrobench, prod profile, observer effectmiddle
- Reading flame graphs: shapes, per-language profilers, and the 60-second scanmiddle
- Statistical baselines: why one run is not a measurementmiddle
- Profiler history and microbenchmark pitfalls: Knuth to GWPsenior
- Hardware counters, cold-start profiles, and profile securitysenior
- Continuous profiling at scale: costs, CI gates, trace correlation, and anti-patternssenior
- What makes a hot path: symptom vs causejunior
- Five shapes of hotspot: CPU, alloc, cache, lock, syscallmiddle
- Reading parent and child chains: where to apply the fixmiddle
- JIT deopt, the fix-and-verify loop, and PR-time profilingmiddle
- Hardware counters and Intel TMA: sub-category diagnosissenior
- False sharing and native-bridge hot pathssenior
- Hot paths in production: security, tail latency, and tooling lineagesenior
- Memory hierarchy: why the same O(N) loop can be 17x slowerjunior
- Row-major vs column-major: access order and the 9x gapjunior
- Branch prediction and branchless codemiddle
- Hardware prefetcher, TLB, and memory-level parallelismsenior
- GC basics: what the runtime taxes you forjunior
- GC algorithms: generational, concurrent, and per-runtimemiddle
- GC tradeoffs: pause, throughput, heap — and object poolingmiddle
- GC tuning: pacing, heap shape, and allocation observabilitymiddle
- GC internals: tri-color invariant, write barriers, and per-runtime deep-divessenior
- GC in production: observability, security, edge cases, and fleet governancesenior
- N+1: one logical operation, many round-tripsjunior
- Fix families: JOIN, IN, preload, and DataLoadermiddle
- Detecting N+1: query logs, APM traces, and CI gatesmiddle
- DataLoader: batching across resolver treesmiddle
- Cross-protocol N+1: HTTP fan-out and Redis MGETmiddle
- N+1 at scale: pool exhaustion, plan changes, and denormalisationsenior
- Batching: amortize fixed cost per operationjunior
- The batching window: size and wait timemiddle
- Batching in Kafka and Postgresmiddle
- io_uring and observability of batchingmiddle
- From Nagle to io_uring: evolution of batchingmiddle
- Backpressure, failure isolation, and batch security in productionsenior
- What a bundle actually costs: download, parse, compile, executejunior
- Core Web Vitals: LCP, INP, and CLSmiddle
- Code splitting: route-level, component-level, vendor splittingmiddle
- Tree shaking and compression: removing what you don''''t usemiddle
- Third-party scripts: the silent budget killermiddle
- CI enforcement and RUM: making budgets stickmiddle
- V8 JIT pipeline, HTTP priorities, and bundle securitysenior
- The performance loop: discipline, not a projectjunior
- Classify and fix: matching bottleneck families to remediesmiddle
- Observability stack and CI gates: catching regressions before they shipmiddle
- Incident to enforcement: SLO burn to verified fix in 35 minutesmiddle
- Culture, economics, and org-scale performancesenior