Modern HTTP Knowledge Check 6
Modern HTTP Knowledge Check 6
animation
http
protocols
InlineKnowledgeCheck({
containerId: "kc-http-modern-6",
question: "An IoT gateway is sending both real-time sensor telemetry (temperature readings every second) and firmware updates (large binary chunks) over the same HTTP/2 connection. A packet from the firmware download is lost. What happens?",
options: [
{text: "Only the firmware stream pauses while waiting for retransmission; telemetry continues unaffected", feedback: "Incorrect for HTTP/2. QUIC can let other HTTP/3 streams progress, though shared congestion can still slow them. HTTP/2 multiplexes streams at the application layer, but the underlying TCP transport delivers bytes in strict order. A lost firmware packet blocks later bytes behind the gap in the TCP receive buffer, including telemetry bytes, until retransmission. This transport-layer head-of-line blocking is HTTP/2's key limitation."},
{text: "Later bytes on both streams wait behind the TCP loss gap", feedback: "Correct! HTTP/2 provides application-layer multiplexing, but TCP guarantees in-order, reliable delivery. A lost segment blocks later bytes on that TCP connection, including telemetry bytes behind the gap, until retransmission completes. HTTP/3 QUIC solves this by making each stream independent at the transport layer."},
{text: "The connection is dropped and must be re-established", feedback: "Incorrect. A single lost packet does NOT drop the TCP connection. TCP's retransmission mechanism recovers the lost packet without terminating the connection. However, all data in the TCP receive buffer behind the lost packet is delayed (head-of-line blocked) until the retransmission arrives — the connection persists while later bytes behind the gap wait."},
{text: "HTTP/2 automatically prioritizes telemetry over firmware", feedback: "Incorrect. HTTP/2 does support stream priority hints (PRIORITY frames), but priority only influences how the sender allocates bandwidth between streams — it does NOT bypass TCP's head-of-line blocking. Once a packet is lost, TCP holds later bytes behind the gap regardless of stream priority, because it delivers bytes in order."}
],
correctIndex: 1,
explanation: "This is a key limitation of HTTP/2: while it provides application-layer multiplexing, it still runs over TCP. TCP's reliable, in-order delivery means that when a packet is lost, ALL data behind that packet must wait for retransmission - this is called head-of-line (HOL) blocking. In this scenario, even though the telemetry streams are logically independent, they're blocked by the firmware packet loss at the TCP layer. HTTP/3 solves this by using QUIC, which provides independent streams at the transport layer.",
difficulty: "advanced"
})