Weekly Paper Notes — the Seminal Paper of the Week for the 2026-11-21 digest. Area: Networking.
Authors: Vinton G. Cerf (Stanford University), Robert E. Kahn (ARPA Information Processing Technology Office) Published: IEEE Transactions on Communications, vol. COM-22, no. 5, pp. 637–648, May 1974. DOI: 10.1109/TCOM.1974.1092259
Why the paper still matters #
In 1973 there were several packet networks: the ARPANET, a packet radio net, a satellite net, France’s CYCLADES and the UK’s NPL network. Each had its own addressing, packet sizes, timing and error handling. A program on one could not talk to a program on another. The paper asks how to connect them without rebuilding any of them, and its answer is the architecture the Internet still runs on.
The paper is twelve pages and reads like an engineering memo. Many of its choices are now defaults that people rarely think to question: sequence numbers that count bytes rather than packets, a receiver-advertised window, SYN to start an association, a checksum the network never touches, 16-bit ports. Other choices didn’t survive, and those are just as instructive. The 8-bit network field is the best-known example.
This pick also completes a thread from earlier seminal posts. End-to-End Arguments (1984) gave the principle a name a decade after this paper applied it, and Congestion Avoidance and Control (1988) fixed the problem this paper left completely open.
The setup #
The paper’s first big decision is the one everything else follows from. The authors considered translating between protocols at network boundaries and rejected it. Host- and process-level protocols are too complex and too different to convert, and the alternative, “for every HOST or process to implement every protocol (a potentially unbounded number)”, is unacceptable. So they require one common protocol between hosts and say the interface between networks “should take as small a role as possible in this protocol.”
That interface is the GATEWAY. It joins two networks, and the authors suggest building it as two halves, one per network, each able to wrap an internetwork packet in its own network’s format or unwrap it. A gateway reads the destination’s network ID, re-wraps the packet in the next network’s local format, keeps accounting, and forwards it. It does not reformat the text and does not recompute the checksum. For each network, a gateway looks like just another host, so “the internal operation of each individual network” stays intact.
Inside each host sits the Transmission Control Program, the paper’s TCP. Processes give it messages, and it cuts them into segments, multiplexes them into internetwork packets and hands them to the local network. At the other end it demultiplexes them to ports. In 1974 this one program did what later split into IP and TCP.
The five decisions that defined the design #
1. Addressing is hierarchical and routing uses only the top. A TCP address is an 8-bit network ID plus a 16-bit TCP identifier. A gateway uses the top 8 bits to choose the next gateway, and the low 16 only when the destination network is directly attached. Ports get their own 16 bits, and the paper says it doesn’t “care how the 16 bits are sliced up.” Of the network field, the paper says: “allows up to 256 distinct networks. This size seems sufficient for the foreseeable future.” Address exhaustion, CIDR, NAT and IPv6 all trace back to that line. The port field is the one number in the paper that never changed.
2. Gateways fragment; only the destination reassembles. The authors refuse to set a global maximum packet size. A global maximum would tie every network’s internals to every other’s, and raising it would need everyone’s agreement. So the gateway entering a small-packet network splits packets as needed. Reassembly at the gateway is rejected explicitly. It would cause “serious buffering problems, potential deadlocks, the necessity for all fragments of a packet to pass through the same GATEWAY, and increased delay”, and the last gateway might have to fragment again anyway. The destination host does the reassembly.
3. Sequence numbers count bytes. Each byte in a port pair’s stream has a position, and a packet carries the position of its first byte plus a byte count. Two flags, ES (end of segment) and EM (end of message), mark the boundaries. Because sequencing is by byte, fragmentation needs no special rules. The paper’s example is a 600-byte packet split into two 300-byte pieces at one gateway, then retransmitted through a different path as three 200-byte pieces: “Since each byte has a sequence number, there is no confusion at the receiving TCP.” This choice is why the IP/TCP split could happen later without changing what a TCP segment means.
4. A sliding window handles both duplicates and flow control. Sequence space is finite, 0 to n−1, so the sender may have at most w unacknowledged bytes. The receiver acknowledges with its current left window edge. Packets outside the window are dropped and answered with that edge again. In-window, out-of-order packets may be kept or dropped. All arithmetic is mod n, and w must stay under n/2 so a retransmission never looks like new data. The acknowledgment also carries a “suggested window”, which the receiver can change at any time. That makes the same mechanism the flow control. The paper calls this “exceedingly powerful and flexible”, and receive windows still work this way.
5. Connections are associations, not paths. The authors rewrite the telephone-shaped idea of a connection on purpose. An association is the state two ports hold to talk in order, and “we have not said anything about a path.” A SYN bit on the first packet asks the receiver to synchronize its left window edge. A REL bit, combined with ES and EM, ends the association, and the receiver answers with its own REL. A process can LISTEN on a specific port or on “any” port.
What the paper leaves open #
The paper is candid about the problems it doesn’t solve, and the gaps line up with what later work had to add.
- Duplicate associations. Steve Crocker pointed out that if a final acknowledgment is lost, a delayed duplicate
SYN+RELmessage could be accepted as new after the receiver has forgotten the old association. The authors note that a timeout before reuse would help and add: “We recognize that this problem must be solved, but do not go into further detail here.” Ray Tomlinson’s 1975 work on choosing initial sequence numbers led to the three-way handshake, and TCP’s TIME-WAIT state is the timeout. - Timeouts. “On timeout (duration unspecified), the sender retransmits.” The conclusion lists the parameters still to be measured: how far out of order packets arrive, how long acknowledgments take, “what should retransmission timeouts be?” Jacobson answered that fourteen years later.
- Congestion. The paper says congestion “is flexibly handled owing to the robust retransmission and duplicate detection strategy.” In 1986 the Internet’s congestion collapse showed that retransmission without backoff causes collapse rather than preventing it.
- Routing and accounting. These are named as problems and left for later.
What changed, and what didn’t #
Within a few years the single TCP was split into a datagram layer (IP), which gateways read, and a reliable stream layer (TCP), which only hosts read. The split allowed protocols that didn’t want reliability, such as voice and later UDP. The ARPANET switched to TCP/IP on 1 January 1983. Network IDs grew from 8 bits to 32-bit addresses and then to IPv6’s 128. IPv6 also dropped router fragmentation entirely, so endpoints now discover the path MTU. The paper’s reluctance to make gateways do extra work turned out to be justified.
The core of the 1974 design is still there: gateways that read a small header and forward packets, a checksum checked only at the ends, byte-numbered streams, window-based flow control, SYN, 16-bit ports, and the rule that hosts carry the complexity while the network carries packets.
The same argument is running again inside machines. This week’s scale-up networking survey (arXiv:2611.26156) discusses how GPU interconnect domains should divide work between switch and endpoint: topology, protocol mechanisms, memory semantics. The multipath congestion-control paper (arXiv:2611.20766) starts from the same premise as the 1974 design. Coordination inside the network is optimal but impractical, so it approximates the optimum with independent node decisions and coordination only among one user’s subflows.
Read alongside #
- Saltzer, Reed and Clark, “End-to-End Arguments in System Design”, 1984: the general principle behind these choices (our post).
- Jacobson, “Congestion Avoidance and Control”, SIGCOMM 1988: the missing congestion story (our post).
- RFC 675, Cerf, Dalal and Sunshine, December 1974: the first TCP specification, written months after this paper.
- RFC 791 and RFC 793, 1981: IP and TCP after the split.
- David D. Clark, “The Design Philosophy of the DARPA Internet Protocols”, SIGCOMM 1988: a look back at the priorities behind these decisions.
Links #
📄 IEEE Xplore (DOI) · 📄 Reprint PDF (Princeton COS 561)
Part of the Weekly CS Paper Digest series. Written from a reread of the published paper; the diagram is original to this post.