Skip to content
End-to-End Arguments in System Design 4 min

J. H. Saltzer, D. P. Reed, D. D. Clark · ACM Transactions on Computer Systems 1984

End-to-End Arguments in System Design

Why reliability belongs at the ends of a system, not in the middle. A careful file transfer, a flaky gateway and the performance exception, with a fault-injection playground.

Read the original paper

Networking · White Belt · Pro · 4 min read

End-to-End Arguments in System Design

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:

  1. The file on disk A is already wrong, because of a hardware fault.
  2. Software that copies and buffers the data, on either host, makes a mistake.
  3. A processor or memory has a transient error while copying.
  4. The network drops, changes, or duplicates packets.
  5. A host crashes partway through.
The paper's 'careful file transfer'. Several things between the disk on A and the disk on B can corrupt the file, and most of them are not in the network at all.

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.

Keep reading with Pro

This paper is part of Pro. Pro and Architect open the full breakdown, with animated diagrams, interactive elements you can play with and a quiz. A few papers stay free to read in full.

Still to read

2 more sections, 1 more diagram and 2 interactive elements to play with

  • A real story: the gateway with a flaky memory
  • So should the network do nothing?

Found this breakdown useful?

Share it with someone else wrestling with this paper.

Discussion0

Join the Discussion

Sign in to leave comments, reply to others, or like insights.

Sign In to ScaleDojo

No comments yet. Be the first to start the thread!

Enjoyed this? Get more like it.

New paper breakdowns, levels, and one concept worth knowing, straight to your inbox.

No spam, ever. Unsubscribe in one click.

Enjoyed this content?

Your support keeps us creating free resources

We put a lot of hours into researching and writing these guides. If it helped you, consider buying us a coffee. Every bit goes toward keeping ScaleDojo's content free and growing.

$

One-time payment via Stripe. ScaleDojo account required.