Networking & Protocols
HTTP: the request-response language of the web
TLS sealed the channel. TCP numbered the bytes. Now comes the protocol on top: HTTP — the language browsers and servers speak to request and receive web pages, APIs, images, fonts, and scripts. For thirty years, HTTP/1.1 handled nearly all traffic. Then browsers demanded more.
What HTTP does in one sentence
HTTP (HyperText Transfer Protocol) is the request-response language browsers and servers use to exchange web pages, APIs, images — everything you see in a browser. The client asks, the server answers. That’s it. But how they ask and answer is where the versions diverge.
The restaurant metaphor
Think of HTTP as a waiter taking orders at a restaurant.
HTTP/1.1: One waiter per table, one order at a time per waiter — you wait for each plate before ordering the next. To go faster, the restaurant hires six waiters per customer (six parallel connections). It works, but it’s wasteful.
HTTP/2: One waiter takes ten orders at once and brings dishes back in whatever order the kitchen finishes them. One connection, many requests in flight simultaneously.
HTTP/3: Same as /2, but a delayed dish in the kitchen no longer makes other dishes wait — they come out independently. Built on a different transport (QUIC over UDP) that isolates delays per request.
- HTTP/1.1 parallel TCP connections per origin
- 6–8
- HTTP/2 streams per connection
- ≥100 (RFC default)
- HTTP/3 deployment (April 2026, Cloudflare Radar)
- 21.1% of web traffic
- HTTP/2 site support
- >95% of web
- Connection warm-up (HTTP/3 with resumption)
- 0 RTT for request
- HPACK header savings (avg vs HTTP/1.1)
- ~80–90% after first request
One scenario end to end
You navigate to a site. The browser does DNS, TCP, TLS, then sends the first HTTP request. The page’s HTML names dozens more files; the browser fires those requests using whatever HTTP version the server agreed to during ALPN (Application Layer Protocol Negotiation — a TLS extension that lets the client and server pick h2, h3, or http/1.1 during the handshake). Modern sites get HTTP/2 or HTTP/3; old origins still see HTTP/1.1.
Bea the browser to Sven the server: “GET /index.html.” Sven replies with the HTML. Bea sees <script src="app.js"> inside and immediately says: “GET /app.js.” In HTTP/1.1, Bea waits for each file to finish on the same connection before asking for the next. In HTTP/2 and /3, Bea fires all the GETs at once and Sven streams them back interleaved.
The core antagonist: head-of-line blocking
Head-of-line (HOL) blocking is the pattern where a slow item at the front of a queue stalls everything behind it. HTTP/1.1 has HOL blocking at the request level — each connection can carry only one in-flight request-response at a time. HTTP/2 fixed HOL blocking at the HTTP layer by multiplexing streams, but TCP underneath still has HOL blocking at the transport layer. HTTP/3 fixed HOL at both layers by using QUIC, which has stream-level loss recovery.
Why this works
Why not just open more connections? HTTP/1.1’s workaround of six parallel TCP connections costs six separate handshakes (each 1–2 RTT), six congestion windows starting from zero (TCP slow start), and server-side state for all six. On a 100 ms RTT link, those six cold-starts cost 100–200 ms each. HTTP/2’s single connection pays that cost once.
What is the main reason HTTP/1.1 is slow for modern web pages?
What is the headline win of HTTP/3 over HTTP/2?
Order the HTTP versions chronologically:
- 1 HTTP/1.0 — one request per connection, no keep-alive
- 2 HTTP/1.1 — keep-alive, pipelining (rarely worked in practice)
- 3 HTTP/2 — multiplexing many streams over one TCP connection + HPACK header compression
- 4 HTTP/3 — same shape but over QUIC (UDP) so packet loss is per-stream
Fill in the blank: HTTP is the _______ format browsers and servers use to ask for and send back web content.
- 01In one sentence: why did people invent HTTP/2 and HTTP/3 if HTTP/1.1 already worked?
- 02What is ALPN and when does it run?
- 03Why does HTTP/2 still have HOL blocking even though it multiplexes streams?
HTTP is the request-response protocol that browsers and servers use to exchange pages, APIs, and assets. HTTP/1.1 parallelises by opening 6–8 TCP connections per origin — each connection handles one request at a time. HTTP/2 introduced stream multiplexing on a single TCP connection, eliminating application-layer HOL blocking, but TCP’s ordered delivery still causes transport-layer HOL blocking on packet loss. HTTP/3 moves to QUIC over UDP, giving each stream independent loss recovery. All three versions coexist: ALPN negotiates which to use during the TLS handshake on every connection.
appears again in5
- MVCC: why readers and writers never wait for each otherjunior
- Act 7 in depth: sharding, co-location, and the seven-tier tradeoff cascademiddle
- Observability, anti-patterns, and production triagesenior
- Raft in the real world: partitions, slow disks, and client routingmiddle
- Raft in production: membership changes, Multi-Raft, and observabilitysenior