Google File System (GFS)

Muddy Foreheads

Failure models

Remote Procedure Call (RPC)

Transition Systems

Primary/backup

Distributed Transition Systems

Virtual Clocks

Paxos

MultiPaxos

Leases

Consistency Models

Vector Clocks

Snapshots

Sharding

Two-phase commit

Microservices

Bigtable

Spanner

Bayou

Dynamo

IronFleet

Tapir

CSE 452 Distributed Systems University of Washington Winter 2022 This senior-level course offers deep insights into the construction of distributed systems like client-server computing, web, cloud computing, and peer-to-peer systems. Major topics include remote procedure call, error management, and consistency of distributed state. Noted for its intellectually challenging and career-relevant approach. Distributed systems are central to many aspects of how computers are used, from web applications to e-commerce to content distribution. This senior-level course will cover abstractions and implementation techniques for the construction of distributed systems, including client-server computing, the web, cloud computing, peer-to-peer systems, and distributed storage systems. Topics will include remote procedure call, preventing and finding errors in distributed programs, maintaining consistency of distributed state, fault tolerance, high availability, and scaling.

Alumni of this course say that it is among the most intellectually challenging courses that they have taken at UW, and among the most relevant to their future careers. We will attempt to live up to that recommendation. We believe the best way to learn the material is to implement the ideas presented in the course, and so there is a substantial programming project.

The [calendar page](https://courses.cs.washington.edu/courses/cse452/22wi/schedule) provides a detailed topic list for the course, including readings, problem sets, and labs. In addition, we are using Gitlab, Ed, and Gradescope for various parts of the course.   

CSE 452 Distributed Systems

Parallelism and Distributed Systems

System R

File system

Flash File Systems

Isolation Levels

Transactional Recovery

Practical Byzantine Fault Tolerance

Exokernel

Resource Allocation and Scheduling

Edge Computing

Distributed Storage

MapReduce

Column Stores

Microkernels

Spectre Attack

Unix

Databases

End-To-End Arguments in System Design

File System Reliability

Transaction Locking

Concurrency

The Byzantine Generals Problem

seL4

Virtual Machine (VM)

Peer To Peer Networks

Distributed Consensus

Apache Spark

Security

CryptDB

CS 262a Advanced Topics in Computer Systems UC Berkeley Fall 2021 A graduate survey of systems managing computation and information. Topics include volatile and persistent memory management, system support for networking, security infrastructure, extensible systems, APIs, and large software system performance analysis. Students are expected to engage in quality systems research, culminating in a publishable group project. Graduate survey of systems for managing computation and information, covering a breadth of topics: early systems; volatile memory management, including virtual memory and buffer management; persistent memory systems, including both file systems and transactional storage managers; storage metadata, physical vs. logical naming, schemas, process scheduling, threading and concurrency control; system support for networking, including remote procedure calls, transactional RPC, TCP, and active messages; security infrastructure; extensible systems and APIs; performance analysis and engineering of large software systems. Homework assignments, exam, and term paper or project required.

The main work of this class is to read frequently and deeply, while working toward a group research project of publishable quality.  Each student will be individually responsible for writing up a short summary of every paper. There will be one midterm exam (albeit near the end), and no final exam. Research projects are a critical aspect of the course.  Your goal is to do some quality systems research; that is, to add to our understanding of how to build systems.  Research projects must be written up in a term paper, and will be presented in a poster in a departmental mini-conference.  Suggested project ideas will be provided by the instructors, but you are strongly encouraged to come up with your own project ideas.  Potential projects include implementation or analysis of some piece of an OS, a DBMS, or an Internet service; extending one of these systems with new functionality; or measurement and analysis of existing systems with the goal of better understanding issues in system design.   [CS 162](https://cs162.org/), or equivalent. There is no required textbook, but some of the papers are in [*Readings in Database Systems*](http://redbook.cs.berkeley.edu/). We will read and discuss 2-4 papers per week. Likely all of the papers will be available online.

General information: ISBN-10: 0-262-69314-3, ISBN-13: 978-0-262-69314-1

Link to MIT press site: [Readings in Database Systems, 4th Edition](http://mitpress.mit.edu/catalog/item/default.asp?tid=10480&ttype=2)

CS 262a Advanced Topics in Computer Systems

Computer Systems

The Internet

Classical synchronization

Time Synchronization

Distributed Mutual Exclusion

Distributed File Systems

Concurrency Control

Logging and Crash Recovery

Fault Tolerance

RAID (Redundant Array of Inexpensive Disks)

Distributed Replication

Distributed Databases

Apache Hadoop Distributed File System (HDFS)

Data-Intensive Computing

Hadoop

In-memory cluster compute

Distributed ML

Internet Content Delivery

DNS (Domain Name System)

Content Delivery Network (CDN)

Publish-Subscribe

Kafka

Virtualization

3-tier Web Service Architecture

Security Protocols

Byzantine Fault Tolerance

P2P Network

Distributed Ledgers

Blockchain

 15-440 Distributed Systems Carnegie Mellon University Fall 2020 A course offering both theoretical understanding and practical experience in distributed systems. Key themes include concurrency, scheduling, network communication, and security. Real-world protocols and paradigms like distributed filesystems, RPC, MapReduce are studied. Course utilizes C and Go programming languages. Most software is now distributed in some sense. This course is meant to serve as an introduction to distributed systems, emphasizing techniques for creating functional, usable, and high-performance distributed systems.

This course aims to: (1) provide students with an understanding of the principles and techniques behind the design of distributed systems, such as locking, concurrency, scheduling, and communication across the network. (2) provide students with practical experience designing, implementing, and debugging real distributed systems.

Major themes covered in this course include scarcity, scheduling, concurrency and concurrent programming, naming, abstraction and modularity, imperfect communication and other types of failure, protection from accidental and malicious harm, optimism, and the use of instrumentation and monitoring and debugging tools in problem solving. As the creation and management of software systems is a fundamental goal of any undergraduate systems course, students will design, implement, and debug large programming projects. After this course, students will have learned to…

- Implement and structure distributed systems programs.
- Write programs that can interoperate using well-defined protocols.
- Debug highly concurrent code that spans multiple programs running on multiple cores and machines.
- Reason about distributed algorithms for locking, synchronization and concurrency, scheduling, and replication.
- Use standard network communication primitives such as UDP and TCP.
- Understand the general properties of networked communication necessary for distributed systems programming in clusters and on the Internet.
- Employ and create common paradigms for easing the task of distributed systems programming, such as distributed filesystems, RPC, and MapReduce. Be able to clearly elucidate their benefits, drawbacks, and limitations.
- Identify the security challenges faced by distributed systems programs.
- Be able to select appropriate security solutions to meet the needs of commonly encountered distributed programming scenarios. Because this course has a big project component, you must be proficient in C and programming on UNIX systems. We will use the [Go programming language](https://golang.org/) throughout the term. It is required that you have taken 15-213 and gotten a “C-“ or higher since many of the programming skills you will need are taught in that course. **However, if you received a C in 15-213, you must meet with your academic advisor to discuss your background before taking 15-440/640, perhaps taking an additional course to sharpen your systems skills. Your advisor must email us approval and an explanation of why you have sufficient background to take 15-440/640.** 

 15-440 Distributed Systems