1. Presented by Muhammad Abu Saqer
End to End Argument in System Design By J. H. Saltzer, D. P. Reed, and D. D. Clark
Presented by
Muhammad Abu Saqer

2. Overview The paper presents a design principle
Choosing the proper boundaries between system functions.
The end-to-end argument is about where to put functionality in a layered network architecture.

3. Communication Network
OSI Reference Model
Application
Application Protocol
Presentation
Presentation Protocol
Session
Session Protocol
Transport
Transport Protocol
Network
Network Layer Host-Router Protocol
Host 1
Host 2
Interface
Data Link
Physical
Data Link Layer Host-Router Protocol
Physical Layer Host-Router Protocol
Internal Subnet Protocols
Communication Network

4. Example 1: File Transfer
Consider the problem of file transfer
During the process it could face many threats like
Crash in host A or B system
Hardware failure
Lost network connectivity
file
Network Service
Network

5. Example 1: File Transfer (cont’d)
To avoid such threats we can
Reinforce each step using duplicate copies, time-out and retry, carefully located redundancy for error detection.
Reduce the probability of each of the individual threats to an acceptance small value.

6. Example 1: Alternate approach: End-to-End check and retry
The application program follows the simple steps in transferring the file.
As the final step, host B will recalculate the checksum for the transferred file.
Then host B will send this value to be compared with the original value at host A.
If this value doesn’t mach, the file will be resend again to host A.

7. Example 1: Alternate approach: End-to-End check and retry (cont’d)
Thus, in order to achieve careful file transfer, the application program must supply E2E guarantee
In this case, a checksum to detect failures and retry-commit plan.
The Key point here is: Application program shouldn’t rely on the modeling transport mechanism for reliability, Instead It should implements it’s own E2E checksum to ensure reliability.

8. Example 2 : at MIT labs
Application programmer assumed that the network has reliable transmission.
One of the network gateway developed a transient error while it is copying data form the input buffer.
Many files corrupted as a result of this error.
Files owner were forced to do a manual comparison with the original files. Something the application programmers should have implemented.

9. Performance & Reliability Issues
If we consider a network that is somewhat unreliable, dropping one packet of each hundred packet sent
Using the above outline strategy the above network will do a bad job.
Clearly , some effort at the lower levels to improve the network reliability will significantly improve the performance.
The key idea here: The lower level need not to provide “perfect” reliability

10. Performance & Reliability Issues (cont’d)
E2E check of the file transfer application must be implemented no matter how reliable the communication system become.
The amount of effort to put into reliability within the data communication system is seen to be an engineering trade-off based on performance.

11. Performance & Reliability Issues (cont’d)
Using performance to justify placing functions in low-level subsystem must be done carefully since performing the function in the low level may cost more because:
Some application which use the same low level subsystem and doesn’t need this function will pay for it anyway.
Low-level system may not have as much information as the higher level, so it cannot do the job efficiently.

12. Example 3: Secure Transmission of Data
When data encryption is done at data transmission system:
It must be trusted to securely manage the required encryption key.
The data will be in clear format (not encrypted) and thus vulnerable as they pass through the node the target application.
The authenticity of the message must still be checked by the application.

13. Example: Secure Transmission of Data (cont’d)
If the application performs E2E encryption these source of vulnerability would be avoided:
The data are never exposed outside the application.
The application obtains it’s required authentication check.
The application can handle key management to its satisfaction.

14. Question: Identifying the ends
Using the E2E argument sometimes require subtlety of analysis of application requirement
E2E argument is a property of the specific application:
Two people in real time conversation.
Speech message system.

15. My evaluation to the paper
It is foundation paper in
Identified and named E2E arguments.
Put system design principle that organize and guide the placement of the function within system.
It becomes part of the vocabulary of network and operating system.
To some extent it is still valid.

16. The Key ideas of the paper
Philosophy behind distributed system design: Move complex operations to the edges of the network
Why? Not all applicatons may require complex options, e.g.,
reliability (audio, video)
security
options often repeated at edge anyways as safety check.

17. E2E argument implication
Implications of e2e argument to the distributed system design and the Internet is :
most complex options should be performed toward the top of the protocol stack.

18. E2E Argument Pros Keep the network simple
Application had to check to see if the network did it’s job
and repair the problem if the network didn’t do it’s job.
reduces redundant checks since app often provides checks anyways
Example of Systems Implementing E2E argument:
Banking, Reservation, Encryption, …

19. E2E Argument Cons When the network doesn't trust the application
Corporation or military using encryption in the low-level because the end user or application may not do it.
Some thing just can’t be done at the end
Routing algorithms.
May not apply to the wireless network
more responsibility lies on the application developer
longer development cycle, frequent bugs

20. Summary: End-To-End Argument
The function in question can completely and correctly be implemented only with knowledge and help of the application standing at the endpoints of communication system.
We call this line of reassigning against low-level function implementation E2E argument.
Building complex function into a network optimizes the network for one set of uses while substantially increasing the cost of a set of potentially valuable uses that may be unknown or unpredictable at design time.

21. Questions