CSEP552 is a graduate course on distributed systems. Distributed
systems have become central to many aspects of how computers are used,
from web applications to e-commerce to content distribution. This
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, maintaining consistency of distributed state, fault tolerance,
high availability, and other topics. As we believe the best way to
learn the material is to build it, there will be a series of
hands-on programming projects.

Prerequisities: the basic prerequisite is to have taken an
undergraduate operating systems course (CSE
451 or equivalent) or an undergraduate networking course (CSE
461 or equivalent). If you haven't taken an undergrad OS or
networks course, please come talk to Arvind. We will not be
covering undergraduate material in this course.

Papers: you will be responsible for reading two to three
papers before each class, and contributing your thoughts on the
assigned papers to the class discussion board before the class that
covers it.

Projects: every few weeks, I'll hand out a programming
assignment related to the course material.

Grading: Course grades will be based primarily on the
programming assignments (80%), along with participation in the
discussion board (20%). The course is not curved.

Mailing list: When you register for the course, you'll
automatically be added to the class mailing list
(csep552a_wi18@uw.edu, csep552m_wi18@uw.edu). To manage your subscription, visit
the mailing
list web page for PMP students or the
page for
5th year masters students. You will be subscribed using your
u.washington.edu email address, but you can modify your
subscription to use an email address of your choice. Note that you
can only post to the mailing list from your subscribed email address.

For each lecture other than the
first, we will post a small set of discussion questions based on the
assigned papers. You're required to add a comment to the
discussion of one of the questions by noon on the day of the
class. (This is to give time for everyone to read the discussion
entries before class.) Please keep your entries short: they can be
anything that provides insight into the question being asked. We
grade posts on a two point scale: solid, or pro forma. If you say
something particularly insightful, we'll give you extra credit
(i.e., 3 points). We'll drop the lowest score during the
quarter.

Here is the schedule of papers for the quarter; this schedule might be
tweaked as we progress. The discussion board entries for the
assigned papers are due by noon on the day of the associated lecture.

The core of the course is to build a highly available, scalable, fault
tolerant NoSQL key-value storage systems. Key-value stores are widely
used in practice, and face many of the key challenges of distributed
systems design. In the project, you'll use techniques drawn from the
readings and lectures, e.g. state machine replication and Paxos
consensus, to tackle these challenges.

Late policy: We will allow a total of 5 slack days for all
assignments; you can use and distribute them between the labs in
whatever way is most convenient for you. Slack days cannot be used for
Lab 4 for 2-person groups or Lab 3 for individual submissions
(because of end-of-quarter deadlines). Once you have exhausted
your allocation of 5 slack days, we will deduct 10% of the grade for
an assignment for each day that it is submitted late.

You should be able to complete the labs on any machine that can run Java
programs. In practice, you'll probably want to use your own personal
machines; none of them require large or exceptionally powerful
machines. You may find CSE's
virtual machine images with the departmental linux
installation useful. Alternatively,
everybody registered for the course should already have had an
instructional UNIX account created for them by the department support
staff, and have been notified of it. Using this account, you can
remotely log into (via ssh) the attu.cs.washington.edu compute
cluster. You can find more information
about instructional resources here.

Collaboration is a good thing, but academic misconduct is a serious offense.
CSE's
Academic Misconduct Policy provides guidelines about the difference. For this course, our policy is simple:

Discussing ideas with others is allowed and encouraged! You should
feel free to talk with other students about the programming
assignments, and to ask for help from the instructor or TAs. You can
also make use of Google or other resources.
However, you must write all of the code you hand in yourself, except for
code that we provide you as part of the assignment. You are not
allowed to look at anyone else's solution, or at code from previous
years. You may not use someone else's code or text in your
solutions. Sharing ideas, explaining your code to someone else,and
helping someone else debug when they've run into a wall are all OK.

If you do discuss a programming
assignment with someone else or find useful sources of information
(e.g., technical descriptions on the Web), please cite or
otherwise attribute all of your sources.