CS 514: Intermediate Computer Systems

105 Ives Hall; MWF 10:10-11:00

Fall, 2003

Course discussion is by blog:  Read or Post

Assignment and regrades using CMS:  http://cms2.csuglab.cornell.edu/

Professor Paul Francis

5-9223, Upson 4108
Office hours: Monday 11:10 – 12:00, Thursday 2:00 – 3:00

Course TA: Saikat Guha

Upson 331
Office hours:  12:00-1:00, MW
call 5-1008 from the phone outside if you can't get in

MEng TA:  Aadil Abbas      maa49@cornell.edu


Course Text:


Kenneth P. Birman 

Highly Assured Distributed Computing

Overcoming The Web Services and Distributed Systems Reliability Barrier


Course Description

This course focuses on practical issues in designing and implementing modern computer systems, with some emphasis on distributed software and fault tolerance. In the spring of 2003, the course was completely updated, with a revised syllabus and far more content drawn from recent industry platforms such as Microsoft’s .NET and the C# language used to build applications in it, Sun’s J2EE environment for “industry-strength” Java applications, and Web Services.  Other topics covered will include network architecture as seen from the perspective of a distributed application (though less than in spring of 2003), object-oriented software development methodologies and tools, peer-to-peer computing systems, other styles of distributed computing, fault-tolerant systems, data centers and clusters, autonomic and grid computing, network operating systems and tools for accessing databases.  This semester, we will use Prof. Ken Birman’s textbook, which has been revised this year to reflect the course content.

Students in COM S 514 undertake a substantial software project. This year, the suggested project in involves building a Web Services application with a data replication mechanism and client “roll-over” in the event that a server fails or becomes inaccessible.  Either .NET (from Visual Studio C#) or J2EE may be used to build your application.  While the Web Services aspect of this project can be developed using built-in features of .NET or J2EE, you’ll need to code the protocols to support replication and roll-over.   However, students can also propose and develop alternative projects if they have a suitable idea.  COM S 514 students are encouraged to work either on their own, or in a small team of up to three members on these projects.  (If you have never used C#, no need to worry: the language is essentially identical to Java, although the runtime libraries are different; we’ll provide the software for free so that you can use lab machines or your own PC).

The basic project is suitable for a one-person effort.  Obviously, a team effort should be more ambitious than a solitary one.  For example, a team project may tackle security issues, implement additional fault tolerance, or demonstrate high scalability.

Historically, many students in COM S 514 have expanded the project, obtaining additional project credit by co-registering in COM S 790 (the “MEng Project” Course number).  If you do this for 3 credits, you can use your COM S 514 project to satisfy the MEng degree “software project” requirement.  You need our permission for this, and to get it, you’ll need to convince us that what you have in mind is ambitious enough to represent a suitable MEng project.  We expect you to do some work for those extra three credits, so your project will be bigger and more time consuming than if you didn’t opt to use the COM S 514 project for this purpose.  Something important to know is that no incompletes are granted in COM S 514 during the spring semester.  You must complete your project by the “project demo day!”

We will run the course (grades, homework assignments, etc.) from the Cornell Computer Science Course Management System (http://cms1.csuglab.cornell.edu/).  Please login here and check to see that you are entered as a student.  If you are not, please contact Saikat and let him know.

There will be occasional homework assignments.  A few of these may be problems or essay type questions, but most of them will be small programming assignments or project reports.  The programming assignments will serve two purposes.  First, they will reinforce the lecture material.  Second, they will prevent you from putting off the project until the last minute by forcing you to implement milestones that are required for the project anyway.  You will have one week to do the problem/essay type homework assignments, and 2-3 weeks to finish the programming type homework assignments, depending on the difficulty of the assignment.  Easy homework assignments will carry less weight in the grading than hard homework assignments (i.e. a homework that takes three weeks will count 3 times as much as one that takes one week.)  Homework will be graded on a simple “check” scale, where “check plus” means you did well, “check” means you did alright, “check minus” means you did poorly. 

There will be two take-home prelim exams.  These will be problems/essays on the course material, and it will be possible (and required!) to complete these in 90 minutes.  They are open book, but of course you must complete them on your own---no collaboration is allowed.

Grading will be as follows:




40% (split evenly)

Final Project


Note that since some of the homework is programming, in fact roughly ½ of the course grade will be based on development.

In order to request a regrade, you must submit a request in writing (email is ok) within a week of when you received your grade.  The request should clearly state the reason for the regrade.  Regrade requests submitted later than one week will not be approved.  It is up to you to review your graded papers, comparing with other students if necessary, within that week.

All lectures will be available online shortly before or after class.  Reading assignments will be typically posted one week or so in advance of their corresponding lectures.


Important Dates

(academic calendar)

First Prelim (take home)

Handed out Thursday 10/16, Due midnight Sunday 10/19

Final Exam

Handed out midnight Sunday Dec. 7, due midnight Tuesday Dec. 9.

Last Lecture


Non-MEng project demo day


MEng project demo day



Course Content

The course is broken roughly into five parts, as follows:

Part 1:  Introductions to the course, to web services, and to the networks they run on

Roughly six lectures.  This part of the course introduces the “framework” within which many modern distributed computer systems find themselves.  It discusses J2EE/Java, .NET/C#, Web Services (SOAP RPC, JDDI, XML, etc.), and event (publish/subscribe, or message bus) systems.  It also discusses the network over which these protocols run (TCP/UDP, IP, DNS, etc.).  This part essentially motivates the rest of the course.

Part 2:  Performance and Scaling Issues

Roughly nine lectures.  Ultimately, performance and scalability are achieved through replication¾ for instance replication of servers in a server cluster or server farm, and replication through caching.  This part introduces concepts of replication and caching, including consistency, hard/soft state, load balancing, and transactions.  We also discuss network performance issues and their impact.

Part 3:  Security Issues

Roughly three lectures.  In this part, we broadly cover web security (HTTPS/SSL, PKIs and certificates), network security (VPNs, DMZs), and denial of service.  We also look at security issues in emerging Web Services.

Part 4:  Reliability and Fault Tolerance (and Performance) Issues

Roughly twelve lectures.  This part looks at the reliability issues that arise from data replication.  We drill down into RPC issues, virtual synchrony, transaction concepts like 2/3 phase commit and serializability, and multicast.  We examine why it is hard to get strong fault tolerance and performance at the same time.

Part 5:  Advanced Topics

Roughly ten lectures.  This part consists of various advanced topics, including discovery issues in the web and in peer-to-peer (P2P) systems (DNS, DHTs, Google), P2P networks for file and data replication (Napster, Gnutella, Freenet, CFS, PAST), mobility challenges (Coda, Rover), more multicast, Resilient Overlay Networks, Grid computing, and Autonomic computing.


Course Lectures and Assignments

(to be filled in as needed during the course of the course)






8/29, 9/1

Course Overview and Themes


9/1, 9/3, 9/5

Introduction to Object Oriented Distributed Systems and Web Services

Chapters 3 and 10

Additional reading:

Werner’s article

Article about versioning WSDL

9/8, 9/10

Introduction to the Network

Chapter 2


Introduction to Message Oriented Middleware (MOM)

Chapter 11, Chapter 6





Performance of the Internet WAN


9/19, 9/22

Load Balancing Options

Chapters 3 and 13 (in advance of upcoming lectures)


Cluster Computing:  Guest lecture from Werner Vogels


9/26, 9/29, 10/1

Overview of Reliability Techniques

Sections 14.1 through 14.5


Open Issues in Content Distribution Networks:  Guest lecture from Pablo Rodriguez, MSR Cambridge


10/6, 10/8

Time and Ordering

Sections 15.5 through 15.14

10/10, 10/15

Tracking Group Membership (part 2)

Remainder of Chapter 14

10/17, 20

Gossip Protocols



Astrolabe (and other gossip tricks)

Section 23.4

10/24, 10/27

Reliable Multicast (part 2)

Section 23.3

10/29, 10/31, 11/3

Security (part 1)

Chapter 20

11/5, 11/7

Firewalls and VPNs (excerpts from these two lectures)



Kerberos network authentication system



Chandy-Lamport Snapshots



Clock Synchronization (annotated slides to be posted after lecture)

Chapter 21

11/17, 11/19

Unstructured P2P Networks (FreeNet, Gnutella)

Section 23.1

11/19, 11/24

Distributed Hash Tables (Chord, Pastry, CAN, Kelips)



Ken’s ISIS Lectures (new, old)



Challenges of Mobility









Last modified 11/25/2003