You send a large file from your computer to a friend's. The network guarantees reliable delivery of every packet. Surely the file arrives intact? Not necessarily. The packets may have arrived perfectly and then been scrambled by a buggy buffer, a failing disk, or a memory glitch on the receiving machine. The network did its job and the file is still wrong.
That observation is the heart of a short 1984 paper by Jerome Saltzer, David Reed and David Clark. It gave network and system designers one of their most-cited rules of thumb, called the end-to-end argument. It still shapes how the Internet, databases and APIs are designed.
A function can be done completely and correctly only by the programs at the two ends of a communication. So putting that function in the middle of the system is at best a performance optimization, never a replacement for the end-to-end check.
The careful file transfer
The paper's example is a file copy from computer A to computer B, in five steps: read the file from disk, split it into packets, move the packets across the network, reassemble them, and write the file to disk. Where can things go wrong? The authors list the threats:
- The file on disk A is already wrong, because of a hardware fault.
- Software that copies and buffers the data, on either host, makes a mistake.
- A processor or memory has a transient error while copying.
- The network drops, changes, or duplicates packets.
- A host crashes partway through.
Only one of the five lives in the network. A careful designer could reinforce every step with its own checks and retries. The authors propose something simpler: end-to-end check and retry. Store a checksum with the file. After the transfer, the receiving program recomputes the checksum from the file it wrote. If it does not match, do the transfer again.
