Internet-scale Distributed Systems
This was one of my favorite courses at Tufts. It was taught by Noah Mendelsohn and it explores the history of the World Wide Web, the design decisions that enabled its success, and from there discusses a number of important design principles to consider when designing a distributed system like the Web. Some of the topics covered include:
- Metcalfe's Law: the value of a network grows with the square of the number of nodes that are connected to the network
- The End-to-End Principle: a process involving intermediate network nodes should perform validation (for features like error-checking and reliability) at the end nodes, otherwise you cannot guarantee correctness
- Idempotence: the property of an operation which can be performed multiple times and still preserve the same result
- Stateless Protocols: protocols in which each message can be handled without the context of other messages
- Naming: global names, uniqueness, opaque names, collisions
- RPC (remote procedure call): the ability for one machine to perform a procedure entirely on another machine, but with code that is completely ignorant that the procedure is occurring remotely
- Leaky Abstractions: an abstraction that, through some limitation or exposed detail, reveals information about the underlying mechanism
- Caching: storing a copy of information somewhere that's easily accessible to speed up requests (though doing it well is far easier said)
- Versioning: new releases of software can support backwards compatibility (where new versions accept old formats), forwards compatibility (where old versions accept new formats), and full compatibility (where you get both!)
- Postel's Law: also known as the robustness principle, it says that software should be liberal with what it accepts and conservative with what it sends. In other words, software should be flexible when handling requests and send simple requests to others
We also covered declarative v.s. imperative languages, the CAP theorem, ACID, DTPC, and more (somehow).
We experienced these concepts first-hand by implementing a file copy program in C for highly unreliable networks and an RPC protocol that generates remoting code for C functions.
Check out the official course description here.