Networking

Loss-based TCP congestion control whose window grows as a cubic function of time since the last loss; the default on Linux, Windows and macOS.

Model-based congestion control that paces at the measured bottleneck bandwidth and caps inflight near one BDP, instead of reacting to loss.

Encrypted, multiplexed transport over UDP with 1-RTT setup, independent streams and connection migration; the transport of HTTP/3.

One thread waits on thousands of non-blocking sockets with epoll_wait and handles only ready ones; the core of nginx, Redis and tokio.

Linux async I/O through two shared-memory rings (submissions in, completions out), batching or eliminating syscalls for sockets and files alike.

Move bytes between files, sockets and NICs by passing page references instead of copying through user space: sendfile, splice, MSG_ZEROCOPY, kTLS.

User space (DPDK, AF_XDP) or an in-driver eBPF hook (XDP) handles packets straight from NIC rings, skipping sockets, for 10-40 Mpps per core.

Split a byte stream (TCP, TLS, pipes) into messages by writing each message's length before it; O(1) boundary detection with no escaping.

Full-duplex message framing over one upgraded HTTP connection; the standard way to push real-time data to browsers.

Wire formats laid out like in-memory structs (FlatBuffers, Cap'n Proto, SBE, rkyv) so readers access fields in place with no decode pass or allocation.

Consistent hashing into a fixed prime-size lookup table filled by per-backend permutations; O(1) lookups, near-perfect balance, little disruption on backend changes.

Pick two random backends and send to the less loaded one; exponentially better balance than random, with no global state and no herding.

Announce one IP prefix from many sites over BGP; routing sends each client to its preferred site, and a failed site leaves by withdrawing the route.

A server-side intermediary that terminates client connections and forwards each request to one of a pool of upstream servers, with routing, health checks, timeouts and safe retries.

Parse HTTP/1.1 requests and responses incrementally from a byte stream: RFC 9112 body-length rules, chunked decoding and the strictness that stops request smuggling.

Binary multiplexed framing for HTTP over one TCP connection: streams, per-stream and per-connection credit windows, HPACK header compression and the limits that contain abuse.

The rules (RFC 9111) that decide whether a stored response is still fresh, and how a cheap conditional request revalidates it when it is not.

Ask for byte offsets with Range and get a 206 slice back; the standard way to resume, seek and read big remote files piecewise.

One long-lived HTTP response carries text events one way; each event may carry an id, so a reconnecting client names its last one and the server resumes.

The client asks "anything after cursor X?"; the server holds the request until there is news or a timeout, and the client immediately asks again.

Open an upload session, send the body in offset-addressed chunks, and after any failure ask the server how much it committed and continue from there.

Reliable server-to-server HTTP callbacks: signed POSTs, 2xx-means-done, retries over days with jitter, endpoint disabling, SSRF guards and idempotent receivers.

Binary query/response format of DNS (RFC 1035) and how a stub client uses it: record types, name compression, UDP/TCP/EDNS sizes, TTL caching.

Find the registrable domain (eTLD+1) of a host name by matching the longest rule in a community-maintained list of shared suffixes.

Send each datagram once to a class D group address; the network copies it to every joined receiver, and sequence numbers let receivers find loss.

SPF authorizes sending IPs, DKIM signs the message, DMARC requires either to match the visible From domain and says what to do on failure.

Sending notifications through APNs and FCM: HTTP/2 requests, token hygiene, collapse keys, TTL and priority, and the retry rules that keep you un-throttled.