CS 485: Networked Operating System Programming


CS 485 is a course in systems programming, at the user space level. Its purpose is to learn how to build software with strong properties, such as security, privacy, reliability, and fault tolerance. These are very demanding requirements, which we will explore through a sequence of programming projects.

These properties cannot be achieved solely at the application level. Thus we'll study the semantics of the entire software stack from the perspective of strong properties, including Virtual Machine, Operating System, User Space Programming environment and Programming Language. Traditional software stacks, have been proved inadequate base for such purposes, especially for achieving security and privacy. Thus we will write programs for Ethos, an experimental Operating System developed at UIC, and using the Go programming language. Ethos provides much stronger properties to the application developer, and at the same time is much simpler than traditional systems.


  • The first two weeks of the semester will be remote
  • Using the following tools
    • uofi.box.com: assignments, documentation, software distribution.
      • You should have received an invite on your uic email address (if not, let me know).
      • Once you have the invite, if box is not enabled for you, go to https://box.illinois.edu/ and enable it.
    • piazza.com: discussion of class issues
    • uic.zoom.us: remote lectures
    • This page: deadlines for various assignments
  • Zoom CS 485 Zoom


  • The Go Programming Language (an introduction).
  • Virtualization and isolation.
  • Operating System Structure and Semantics.
  • User space environment
  • High Availability Systems, which survive natural disasters and deliberate attacks
  • Privacy techniques.
  • Maintaing confidentiality
  • Ensuring integrity.

Programming assignments

This is still under development.
  • Types and packages in Go. Using types to construct sophisticated packages in Go.
  • Transactional service. We'll be a serializable system which work concurrently, but appear to work with one transaction at a time.
  • File system. A file system must survive system failure, that is be fault tolerant. In this assignment an operating system will be built which will withstand (temporary) failures at arbitrary times, assuming.
  • Distributed File System. We'll construct a distributed file system which will withstand arbitrary failure.
  • Capstone project. Done in groups, a more sophisticated version of the assignment.

Workload and needed background

A solid background is needed in programming and in Operating Systems. In addition, courses in network and transactional databases are helpful, but not necessary.

Course work and grading

The course work consists of:

  • 80%: 4-5 Programs
  • 20%: Participation including class participation
Note that this breakdown is dependant on COVID, and in particular assumes we'll have in-person instruction.

Tests will cover conceptual issues from system aspects and programming techniques covered.

Academic integrity

Students who are caught cheating will immediately fail the course, and have the cheating recorded in their record. For 1st year graduate students (because this is a 5 hour course), this usually results in expulsion from the program. Students who already have been caught cheating will go through disciplinary hearings, with the goal of having them expelled from the university.

Students who fail to demonstrate on tests an understanding of the programs they have handed in will fail the course.

You are not to show your program to anyone nor to look at anyone else's program. You may discuss programming concepts but only in general term.

Covered topics

This course covers network programming and systems programming from the operating system viewpoint. Special emphasis is given on standards based APIs, with explanation of typical interfaces.

Recommended Texts

  • UNIX Network Programming, Richard Stevens, Volume 1, Second Edition, Sockets and XTI, Prentice Hall, 1998, ISBN 0-13-490012-X.
  • UNIX System Programming using C++, Terrence Chan.
  • The Design of the Unix Operating System, Maurice Bach, Prentice Hall. (Dated description of Unix internals, but very readable)
  • POSIX.4:Programming for the Real World, Bill O. Gallmeister, O'Reilly and Associates. (The book on real-time POSIX programming covering IPC, async. I/O, and more).
  • Computer Networking: A Top-Down Approach Featuring the Internet, 3rd Edition, James Kurose and Keith Ross.
  • Computer Networks (3rd Edition), Andrew S. Tannenbaum, Prentice Hall. (Detailed coverage of low level network stuff)
  • Computer Networks: A Systems Approach Larry L. Peterson and Bruce S. Davies, Morgan Kaufman. (More advanced coverage then Tannenbaum)
  • The Magic Garden Explained, Benny Goodheart and James Cox, Prentice Hall. (Describes basis for Solaris [SrV5R4] internals).
  • STL Tutorial and Reference Guide David R. Musser and Atul Saini, Addison-Wesley.