Syllabus

The tentative schedule (subject to change) is as follows. Please see below the schedule the rationale behind the syllabus.

We will study three building blocks for constructing successful systems that perform complex tasks (these concepts can be found in almost every field of engineering, and are primarily aimed at mitigating complexity):
  • Modularity (i.e., "break a bigger system into smaller individual parts that are separate from each other")
  • Abstraction (i.e., "give each module a well defined, independent behavior")
  • Indirection (i.e., "provide a universal glue to connect modules" – this enables composing modules that do not know of each other a priori; in computer systems, indirection is achieved via naming)

Abstraction is about turning the otherwise arbitrary behavior of a module (or group of modules) into a set of well understood behaviors; this is typically done by excluding the undesired behaviors. The design of an abstraction dictates both the modularization and the interfaces of each resulting module. Using abstraction enables us to compose modules and reason about the resulting behavior (i.e., executions) of the composition. We will study four attributes of abstractions that have proven useful over time, as well as the inherent trade-off between the benefit of getting a given attribute (e.g., the benefit of reduced inter-module complexity) and its cost (e.g., the cost of increased intra-module complexity):

  • Atomicity ("for all actions in a group, either all take place or none does" – this excludes all executions in which an external observer can see only some of the actions take place)
  • Declarativity ("express what you want, not how to get it" – this excludes all executions that, to the external observer, differ from other executions solely in their intermediate steps)
  • Least privilege ("give the least power necessary to complete the job" – excludes all executions in which unnecessarily high privilege is held and potentially abused)
  • Consistency ("even though separate, some modules are still governed by a common set of rules" – excludes the executions in which those modules act in an uncoordinated fashion)

We will study five system structuring principles (i.e., that govern "where to place what functionality"):

  • Layering
  • Hierarchy
  • End-to-end
  • Minimum TCB (trusted computing base)
  • Simulation / interpretation

We will study five principles for obtaining good balance of performance and availability, two core system properties that typically have to be traded one against the other (the principles are about "where to place what state" and "when to do what"):

  • Locality
  • Redundancy of computation and/or data
  • Laziness / speculation
  • Adaptivity
  • State partitioning (hard state vs. soft state vs. stateless)

In order to have a productive discussion of these principles, students must be thoroughly familiar with a wide range of systems from the realms of operating systems, databases, networking, programming languages, and computer architecture. Please see the administrivia page for details on the required background.