Instructor: Prof. Tim Wood
Prerequisites: CSCI 6212 Design and Analysis of Algorithms, CSCI 3411 undergraduate Operating Systems.
Time/Place: Fridays 12:45-3:15PM in 1776 G, C-103
Office Hours: Arranged by email
Course Description and Learning Outcomes
This course will be an in-depth study of the algorithmic and implementation challenges in building large scale distributed applications. Topics include distributed coordination, scheduling, consistency issues, and fault tolerance algorithms. The course will cover how fundamental distributed systems concepts are applied to cloud computing environments. The course will combine algorithmic concepts and practical implementations built using Amazon’s cloud services; substantial programming experience is required.
By the end of this course, students will be able to:
- Use important technologies common in today’s distributed systems such as Hadoop, Amazon’s cloud, serverless computing, etc.
- Design distributed architectures that are efficient and correct despite network delays and failures
- Implement and evaluate the performance of these systems
Workload and Grading
- 15% Programming Assignments
- 15% Midterm Exam
- 10% Class Participation
- 25% Practical Learning 1
- 25% Practical Learning 2 or Final Project
- 10% Technical Report
- 40% Programming Assignments (approximately 5)
- 10% Quizzes (approximately 1 per week)
- 15% Midterm Exam
- 15% Final Project
- 10% Research Paper Report
- 10% Class Participation
Programming load: The course will be programming-intensive. You will need to use a wide range of languages - you should be very comfortable writing code in either: C, Java, or Python, and you should be prepared to learn the basics of all of the others. The course will make use of several cloud services that typically involve Linux - you should be familiar with the command line and basic Linux administration.
Quizzes and Exams: Most weeks we will have a quiz. Some of these will simply be for attendance (i.e., you will still get full credit even if you answer all questions wrong), others will be graded normally. There will be a midterm exam on the principles of cloud and distributed systems.
Final project: You will be required to design, implement, and evaluate the performance of a distributed application as your final project. Projects will be done individually or in small groups.
Practical Learning: You will need to follow a set of hands-on tutorials to build experience in a distributed systems area of your choice. For the second round of Practical learning you can choose to either learn about a different area, or complete an in-depth final project of your choice (subject to professor approval).
Technical Report: You will need to write a report in the form a a blog post that presents an overview of a distributed systems concept or tool. Julia Evans’ blog has many excellent examples of short, technical articles designed to be educational. For example, see How big can a packet get? or How I use Wireshark.
Research paper report: You will need to write a report in the form of a blog post that presents an overview of a distributed systems research paper. This will give you practice reading a technical research paper and presenting its key ideas to a general audience.
Class participation: Class participation is a very important aspect of this class, and I will be keeping track of who speaks in class. If you are not asking or answering questions, then you will get a zero. There will be other options for participating online as well. If you are not participating online or in person each week, then you should not expect to get an A in the course.
To get full credit for participation, in each 2 week period you must participate at least once in one of the following ways:
- Ask or answer a question in class
- Ask or answer a question on piazza
- Attend office hours with the professor
For the first 3 weeks 1 participation will be sufficient.
If you have a disability that may effect your participation in this course and wish to discuss academic accommodations, please contact me as soon as possible.
Late work policy:
- Late work will lose 10% per day late.
- If you have been ill and have a doctor’s certificate to prove it, you will be eligible to take a missed quiz, provided you submit this certificate (during my office hours) reasonably soon after recovering from the affliction. Significant illnesses may be grounds for delayed assignment or project submission, but you should email me before the deadline if physically possible.
Email policy: You can send email to my GW email address. I will answer most class email during specific times set aside during the week for this purpose - so do not expect an instantaneous response. Since this is an advanced class, you may not perform “debugging by email”. That is, do not send me code snippets and ask me to identify the problem. If you want me to look at your code, you should have a specific question in mind (not just “it’s broken, why?”). Bringing code to my office hours is far more effective than sending it to me via email.
Illness policy: If you are ill and it will cause you to miss class, lab, or an assignment, you should let me know in advance if possible. I cannot extend deadlines unless you provide a note from a doctor.
Academic Integrity policy: It is very important in this course (and in life), that your work be your own. These guidelines will help you achieve that.
- Do your best to solve all homework, quizzes, and exams on your own.
- Write the names of any students you collaborated with as a comment at the top of your main file (subject to the constraints below).
- Discuss general approaches to solving the homework problems with other students.
- Have another student look at a specific snippet of your code (e.g., 10 lines) to help you debug a programming error; they can make suggestions but should not be telling you exactly what code to write.
You may not:
- Copy code to or from other students or people outside of the class.
- Have someone else write code for you.
- Copy code from the internet, unless you specifically reference the source and can explain how it works. This should be a tiny minority of the code you submit.
- Write code as a group and then submit identical or slightly modified versions—if you are working together with someone to solve a problem, each of you should be writing up your own independent solution.
The Academic Integrity Code will apply to this course. Please read through the code carefully. Penalties for violating the code or the policies described here include failing this course, and are elaborated in the GW Academic Integrity Code. Note that the minimum punishment is failure of the assignment.
Coding standards: Having completed the prereqs, you are expected to submit well-written code:
- Comments must be substantive.
- Select readable variable names and method names.
- Use consistent indentation (preferred: two or four spaces).