HTTP - 2 — multiplexing, header compression (HPACK), server push: Foundations

This page builds every word, number, and symbol the parent note leans on — starting from "what is a byte" and ending at "what does $2^{14}$ mean here". If the parent note said it without explaining it, we explain it here.

1. Bit, byte, and why we count in powers of two

Before any protocol, there is the smallest thing a computer stores: a bit — a single switch that is either $0$ or $1$ . Eight bits in a row make one byte.

WHY the topic needs this: every "frame header is 9 bytes", every "24-bit Length", every "one byte for a whole header" in the parent note is literally counting these bulbs. If you can't see the bulbs, those numbers are meaningless.

Figure s01 — what it shows: eight bulbs make one byte. The pattern 0110 1010 is drawn with lit bulbs = $1$ ; each column is labelled with its place-value $2^{7}, 2^{6}, \dots, 2^{0}$ . Adding the lit place-values ( $64 + 32 + 8 + 2 = 106$ ) shows how a row of bulbs becomes a number. Read the caption bulb by bulb before moving on.

Figure — HTTP - 2 — multiplexing, header compression (HPACK), server push

$2^{7} = 128$ , so 7 bits hold $0$ to $127$ .
$2^{8} = 256$ , so 8 bits hold $0$ to $255$ (that's $256$ patterns, but the biggest single number is $255$ ).
$2^{14} = 16384$ — this is the parent's "default max frame size" (the count of possible values; the largest is $16383$ ).
$2^{24} = 16, 777, 216$ is the number of patterns a 24-bit Length field has, so it names the values $0$ to $2^{24} - 1 = 16, 777, 215$ — the largest single Length is $16, 777, 215$ , not $16, 777, 216$ .
$2^{31}$ ≈ 2.1 billion — the number of Stream IDs (we'll meet these below).

Recall Why is the max value

$2^{N} - 1$ and not $2^{N}$ ? Because we include $0$ as a valid pattern ::: with $N$ bits you get $2^{N}$ patterns numbered $0, 1, \dots, 2^{N} - 1$ , so the largest single number is $2^{N} - 1$ .

2. Text vs binary — what "binary framing" actually means

HTTP/1.1 is a text protocol: it literally sends the letters G, E, T, a space, then the path — human-readable when printed. HTTP/2 is a binary protocol: it sends raw numbers in fixed slots, not spelled-out words.

WHY hex here: the wire is bytes, and one byte = two hex digits reads far cleaner than eight bits. Every " $0x40$ " below is just a byte written in this shorthand.

WHY the topic needs this: the parent's whole "Text → binary framing" line rests on this distinction. Binary lets HTTP/2 pack a whole header line into one byte (Section 4 of the parent) — impossible with spelled-out text. And without a fixed byte order, two machines would read the same Length or Stream ID as two different numbers, so every field diagram below assumes big-endian, most-significant-byte-first.

3. Powers, exponents, and the notation $2^{14}$ , $I mod 128$ , $⌊ \cdot ⌋$

The parent's HPACK section uses three bits of math notation without defining them. Here they are.

WHY the topic needs this: the parent's prefix-integer trick emits (I' mod 128) + 128 and updates I' ← floor(I'/128). That is exactly "leftover eggs into a 7-bit carton, then count the full cartons," repeated until nothing is left. We verify the parent's example below.

Figure s02 — what it shows: the three output bytes for $1337$ as coloured boxes, left to right: the prefix 31 (blue, "full, I overflowed"), then 154 (orange, 26 + 128, its continuation flag on), then 10 (green, last byte). Arrows carry the working value $I^{'}$ from box to box, and the bottom line reproduces the arithmetic $1306 = 10 \times 128 + 26$ . Trace the arrows to see $I^{'}$ shrinking.

4. Stream ID, odd/even, and the label idea

A Stream ID is just a whole number written into 31 bits of the frame header. It is the label that says "this chunk belongs to conversation number 3."

WHY the topic needs this: multiplexing (parent §3) reassembles interleaved chunks by this label. Server push (parent §5) reserves an even ID so a pushed resource can't clash with a client request. And the parent's SETTINGS frame has to live somewhere — it lives on stream $0$ , the connection-wide channel. The 31-bit size gives $2^{31}$ possible labels — plenty.

5. The frame — one labeled chunk

Now we can read the parent's frame formula symbol-by-symbol. A frame is a fixed 9-byte header followed by a payload.

Figure s03 — what it shows: the 9-byte header drawn as a single left-to-right strip, each field a coloured box whose width is proportional to its bit-count (Length widest at 24, Stream ID next at 31, R a sliver at 1). Labels under each box give the bit-count; call-out arrows mark "no more than $2^{14}$ by default" on Length and "odd = client, even = server push, 0 = connection" on Stream ID. The strip is the byte layout you'd see on the wire.

WHY the topic needs this: every higher idea is a stream of these frames. A message (request or response) = one HEADERS frame + zero or more DATA frames sharing one Stream ID. Multiplexing = interleaving frames of different Stream IDs on one connection.

6. The layers under HTTP/2 — TCP, TLS, and RTT

HTTP/2 does not touch the wire directly; it rides on top of two lower layers the parent assumes you know.

WHY the topic needs this:

The parent's "one handshake vs six" is a claim about TCP+TLS RTTs: $T_{2} \approx 1 \times (TCP RTT + TLS RTTs)$ vs $T_{1.1} \approx 6 \times$ that.
The famous "TCP-level head-of-line blocking still exists" mistake is because TCP insists on in-order bytes — one lost packet stalls every stream. That's why HTTP-3-and-QUIC switches transports.

Recall Why can multiplexing remove application HOL blocking but not transport HOL blocking?

Streams are independent at the HTTP layer, but they all share one TCP byte-stream ::: TCP delivers bytes strictly in order, so one lost packet forces every stream to wait for the retransmission — a transport-level stall HTTP/2 can't dodge.

7. Compression prerequisites — Huffman, varint, and the CRIME idea

HPACK (parent §4) stitches together three ideas that each have their own vault note. None is new machinery invented for HTTP/2 — HPACK just combines them, so meeting each one now makes the parent's §4 read as assembly rather than magic.

Intuition How the three fit together — and WHY each is needed

Walk one header field through HPACK to see each tool earn its place:

Is this exact header already known? If yes, HPACK sends a single index number — and index numbers can be large, so they are written with the varint encoding (Section 3). Without varint, every index would waste a fixed number of bytes.
If it is a brand-new literal string, its characters are squeezed with the fixed Huffman table. Without Huffman, long literal cookie/user-agent strings would travel at full size.
Why a fixed table and not adaptive gzip? Because gzip adapts to whatever bytes it sees, mixing attacker text with secret text — exactly the CRIME leak. HPACK's fixed, non-adaptive design refuses to let attacker input change how a secret compresses. Without CRIME-awareness, the whole scheme would be insecure.

So: varint shrinks the index numbers, Huffman shrinks the leftover literal text, and CRIME-awareness dictates the fixed (non-adaptive) design that keeps secrets safe. Three tools, three distinct jobs.

Figure s04 — what it shows: one header field entering HPACK and taking one of two forks. Fork A (green, "already known") → a varint index number → tiny output. Fork B (orange, "new literal") → Huffman-coded characters → small output. A red guard box labelled "fixed table, no adaptive mixing" sits across both forks with the caption "blocks CRIME length-leak." Follow whichever fork applies to see which tool does the shrinking.

WHY the topic needs this: without Huffman you can't explain "literal header encoded in fewer bits"; without varint you can't read the index bytes; without the CRIME idea you can't explain why the parent insists "HPACK is not just gzip."

8. How it all feeds the topic

The map below reads top-to-bottom: an arrow $X \to Y$ means "you need $X$ before $Y$ makes sense." The bottom node "HTTP 2 topic" is the parent note; every other node is a foundation built on this page. Follow any path down and you retrace the order we taught these ideas.

Left branch (blue foundations): bit/byte → powers of two → Stream ID and frame header → multiplexing.
Transport branch: TCP in-order bytes feeds both multiplexing and the TCP HOL blocking caveat.
Right branch (compression): Huffman, varint prefix int, and the CRIME idea all feed HPACK.
Push branch: even Stream ID feeds server push.

Equipment checklist

Test yourself — say the answer before revealing it.

How many distinct patterns can

N

bits show?

2^{N}

(numbers

0

2^{N} - 1

), where

N

is a nonnegative whole number.

What is the biggest single number a 24-bit Length field can name?

2^{24} - 1 = 16, 777, 215

(there are

2^{24}

patterns, but the largest value is one less).

What is

2^{14}

, and where does it appear in HTTP/2?

16384

— the default maximum frame payload size.

What is the difference between a text protocol and a binary protocol?

Text carries meaning in readable characters and separators; binary carries meaning in fixed byte positions and lengths.

What does the

0x

prefix mean, and how many hex digits are in one byte?

It marks a hexadecimal (base-16) number; one byte = two hex digits.

In what byte order do HTTP/2 multi-byte fields appear on the wire?

Network byte order = big-endian, most significant byte first.

What does

I mod 128

compute?

The remainder after dividing

I

128

(a value from

0

127

What does

⌊ x ⌋

mean?

Round

x

down to the nearest whole number.

In the prefix-integer algorithm, what is

I^{'}

and what is its initial value?

The overflow part of

I

that didn't fit the prefix; it starts at

I^{'} = I - (2^{N} - 1)

Why do varint continuation bytes carry only 7 bits of value?

The top bit of each byte is a continuation flag (1 = more bytes follow, 0 = last), leaving 7 bits for value.

What is a Stream ID and how many bits is it?

A number labeling which stream a frame belongs to; 31 bits (the top bit is Reserved).

Which parity of Stream ID does the client use, and which does server push use?

Client uses odd IDs, server push uses even IDs — so they never collide.

What is Stream ID 0 used for?

It is reserved for connection-level frames like SETTINGS, PING, WINDOW_UPDATE, and GOAWAY.

Name the five fields of the 9-byte frame header.

Length (24), Type (8), Flags (8), R (1), Stream ID (31).

Which two lower layers does HTTP/2 ride on, and what does each guarantee?

TCP (reliable in-order bytes) and TLS (encryption/privacy).

Why does TCP still cause head-of-line blocking under HTTP/2?

TCP delivers bytes strictly in order, so one lost packet stalls all streams until retransmission.

Which three prior ideas combine to make HPACK, and what job does each do?

Varint (shrinks index numbers), Huffman (shrinks literal text), and CRIME-awareness (dictates the fixed non-adaptive design).

Return to parent: HTTP/2 topic note · Prev generation: HTTP-1.1 · Next: HTTP-3-and-QUIC.