CS 6410 is an advanced course in computer systems targetted
to CS and other PhD students interested in systems as a graduate research
Getting permission to attend:
PhD students from any program at Cornell are welcome, but
non-PhD students must obtain written permission from Professor Birman to
attend this class. We often grant permission to attend CS 6410
to CS undergraduates with strong prior background and grades in systems
courses who plan to pursue PhD studies after graduating. But CS 6410
is generally not a suitable course for MEng students (they tend to find this
class very theoretical and generally prefer courses with a more pragmatic,
practical approach such as CS 5412). Further, CS 6410 might not be
suitable for undergraduates who have had difficulty in their prior systems
courses, or who are not on a PhD research "track".
To request permission to register in CS6410, email to Professor Birman
). Include a cover letter explaining why you
hope to take this class and what you hope to gain from it, your grades in
relevant systems courses, and describing any research projects you may have
worked on.CS6410 can be used to satisfy
all CS PhD program requirements in the systems area.
Starting in Fall 2014, CS6410 satisfies more of the CS PhD requirements than
was historically the case. As a Cornell CS PhD student, you are
required to demonstrate basic competence in systems at the CS 4410 level, to
take a systems breadth course, and to take at least one 6xxx course in the
"systems style". CS6410 can satisfy all of these requirements
in the past, it only addressed the breadth requirement.
In the past
you needed to take CS4410 or the CS4410 final to satisfy the basic
competence aspects, and then most students also
took CS6410 to
satisfy the graduate breadth requirement. This is no longer the case:
starting in Fall 2014, you can take CS4410 plus some other course in the
"systems style" (there is a list), or you can skip CS4410 (if you know the
material) and then just take CS6410.
For students who come in
with prior background in operating systems and who opt to just take CS640,
we still want to ensure that everyone has hands-on experience with basic O/S
ideas. With this in mind, we are adding two small homework assignments
to CS6410 that will be carried out in the first weeks of the class.
* One takes a simple program and scales it to be parallel
and to run on a very large data set. The core challenges in doing this
center on understanding the performance properties of modern multicore
processors and their memory models, and hence this will give you hands-on
experience with multithreaded concurrency and with modern systems issues in a very
* The second involves using
Amazon's EC2 system, specifically their elastic beanstalk platform.
You'll run a kind of locking service based on the Paxos protocol, and then
will explore performance issues when this is scaled up. The idea here
is to gain experience with cloud computing.
Notice that both
assignments should be valuable to you no matter what you plan to do research
on: even a person working on NLP or computer vision has to worry about
performance and might end up needing to run some software on EC2. This
isn't accidental: We picked these topics specifically with the goal that
every student should find them useful.
previously satisfied the remaining PhD level systems requirements and it still does so. Beyond the new assignments just
mentioned, you'll do a CS6410 term project, will read a pile of very
interesting papers, and present one or two of them. We'll discuss the
details of how this will work in class.
Instructor: Prof. Ken Birman
Tue/Thur 1:00-2:00pm, 435 Gates Hall, or by appointment)
Part-Time TAs: TBD, depending on class
Class Admin: Amy Finch Elser
(437 Gates Hall)
Class Meetings: Attendance is required.
This class is structured as a discussion and everyone participates.
We will meet Tuesday and
Thursday, 10:10-11:25, in Upson 205.
CS6410 is a graduate-level reading course that covers classic and recent
papers in operating systems and distributed systems. Students will:
- learn about current research perspectives on computer systems, including
advanced systems abstractions, principles, and artifacts that have had lasting value,
- understand attributes of systems research that is likely to have impact,
- become comfortable navigating the literature in this field,
- gain experience in thinking critically and analytically about systems research, and
- acquire the background needed to work on research problems currently under study at Cornell and elsewhere.
CS6410 is thus aimed primarily at the research community. In contrast,
CS5412 (Cloud Computing) offers a more practical, hands-on perspective on the
same kinds of material. MEng students are therefore encouraged to take
CS5412 and not CS6410, and PhD students (or undergraduates who plan to pursue a
PhD) are encouraged to take CS6410. Notice that we did not say "computer
science" students: CS6410 often includes PhD students from ECE, CAM, IS and
other fields. We also often have undergraduates in the class (typically,
seniors who are thinking of pursuing a PhD). And finally, MEng students
aren't turned away. We simply require that they have backgrounds as strong
as those of the PhD students and that they participate in identical ways.
Follow the instructions at the top of the "home" page for details on how to
request permission to attend.
Attendees are expected to have mastered the material in CS 3410 (CS 314) or CS 3420 (ECE 3140), and also CS 4410
(CS 414). If you didn't enjoy CS 4410, you won't have fun in CS
6410. CS6410 is definitely not a good substitute for CS 5412, so if your
real goal is to take CS 5412, don't take CS 6410 as an alternative. The
classes are very different.
If you took a solid architecture and O/S
course as an undergraduate please do not repeat those courses at Cornell.
There is no reason at all to take CS4410 at Cornell if you took a similar course
previously. CS6410 would suffice. On the other hand, if you lack
CS4410 experience and do take the course here, you won't need to take CS6410
unless you wish to do so. There are other courses in our list that can
satisfy the "systems style" requirement.
Cornell PhD students (from any PhD program) with appropriate background may enroll
without special approvals. Undergraduates and MEng students are required
to obtain Professor Birman's explicit permission before enrolling. If you
are uncomfortable with an email,
meet with Professor Birman either prior to the first day of classes, or after
class on the first day, to discuss your level of preparation and goals.
Note: We normally don't allow people to audit this class. We want everyone
in the room to be "all in".
- Assignments: As noted above, these are a new feature of CS6410 added
to make it possible to satisfy the systems competence requirement of the CS PhD
program without taking CS4410 and without taking the final exam from CS4410.
There are two assignments, one aimed at getting experience with a multicore
processor and learning about the performance-limiting features of these
architectures, and the other focused on hands-on experience with Amazon's
elastic beanstack, which is typical of cloud computing. The idea is that
this would be broadly useful to every student, including those who plan to do
research on topics remote from systems.
- Presentations: Each student is expected to prepare at least one presentation and lead a discussion one or more times during the semester (see below). A presentation/discussion will be of papers drawn from the reading list of the course.
- Participation: All students are expected to participate in class by asking questions of the speakers and participating in the follow-up discussion on the assigned readings.
Every student is expected to attend every class.
- Readings: All students are required to read papers in advance of the class and submit a review via Course Management System (CMS). Paper reviews succinctly discuss the paper's strengths, weaknesses, and potential improvements or areas of future research (See how to prepare a review below).
- Project: This is distinct from the two assignments. The project in CS 6410 is an open-ended research project, done individually
or perhaps in groups of two. The project requires an initial proposal, a midterm survey paper, a final report (both written and presented), and reviews of others' projects. More information can be found on the Project page.
Some projects involve working on a research paper of your own, some involve
running an experiment or building something, and one can even come up with
other kinds of projects that collaborate with researchers at companies like
Facebook, Microsoft or Google.
- 20% the two new assignments.
- 20% class presentations, written reviews, in-class participation.
- 20% Class Presentations. This grade will be based on both the number and quality of presentations you give. Quantity is not a substitute for quality, but failing to do your fair-share of the presentations will impact your grade.
- 10% Written reviews
- 10% Participation in class discussion.
- 50% independent projects.
- 5% Peer reviews.
- 5% Initial project proposal.
- 15% Midterm survey.
- 25% Final project (written report and demo).
- 5% Lab Assignments
- 5% Subjective factors, including regular in-class quizes based on required readings.
You may discuss the questions for each discussion paper with other
students, but you may not look at other student's answers. You must
write your answer yourself.
To draw a very clear line, you may use any idea from any other
person or group in the class or out, provided you clearly state what
you have borrowed and from whom. If you do not provide a
citation---that is, you turn other people's work in as your own---that is
cheating. Anything else is fair game. Of course, we will be grading
you on the ideas you have added, but you should always borrow as much
as you can as a starting point as there is no point in reinventing
An online syllabus with links to all the papers is
Click here and here to find out how to write a review.
Writing Paper Reviews
Paper reviews should be short, concise, and most importantly, critical.
They should include:
- Short paragraph (3-4 sentences) summarizing the paper and discussing any of the following suggest points:
- What do you feel the main contribution of this paper is?
- What did you find interesting about this work?
- What's the essential principle that the paper exploits?
- Two or three major strength of the paper (typically one sentence for each point)
- Two or three weakness of the paper (typically one sentence each point)
- One question or future work direction you think should be followed (optional)
Additionally, we will usually post a question on CMS more than 48 hours before class. The question should be answered in the review as well.
In all, a review is typically 8 to 12 sentences over two to three paragraphs.
You would need to write an additional couple of sentences if there is a question to answer.
How to Prepare and Lead a Presentation
- [Sept 4] Class participants should be prepared to select the first round of topics they will lead.
- [At least 5 class meetings (=2 weeks + 1 meeting) before the scheduled date for your presentation] Meet with the instructor to agree on what ideas to focus on and what papers to cover.
- [At least 3 class meetings (=1 week + 1 meeting) before the scheduled date for your presentation] Meet with the instructor to go over a draft of your presentation. Prior to that meeting, submit either a set of written (typeset) lecture notes if you are giving a "chalk talk" or a printed copy of slides if you are giving a powerpoint presentation.
- [At least 2 class meetings before the scheduled date for your presentation] Meet with the instructor
- for a final review / dry-run of your presentation, and
- to decide the set of papers that constitute the assigned reading
Don't expect you'll be able to schedule the above meetings at the last minute. Schedules fill up, and the instructor is not infrequently away from Ithaca. Email the instructor a week or so in advance of when you'll want to have the above meetings.
Questions or comments? email firstname.lastname@example.org
Policy on academic integrity
Last modified: June 16, 2014.