CS 485: Networked Operating System Programming

Introduction

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.

News

  • Assignment 1. Due 2/26.
    • Create a Go package which is used to convert between Go types and an encoded byte slice. The Go types are structs whose fields are of type int32/int64/strings. The byte slice is a little endian byte encoding, with a typeId (a 32-bit integer), and then the fields of the struct encoded. For each struct type, you should write function Encode, Decode, and TypeId.
    • Use an Interface class to build a generic writer/reader for these types. Now encode and write these byte slices to the file system, and then read them in and convert them to slices.
  • The amount of work for this course is moderate. (A previous version of this web page said that the work level was very heavy, but that applied to the version of the course taught 11 years ago, not the current invocation.)
  • This course was last taught 11 years ago using C++, and without the security and privacy components. (I didn't teach it since then because I was busy teaching CS 486 and security courses). It will be completely revised this year, using Go and Ethos.
  • For a general introduction to the structure of an OS kernel, see Maurice Bach.

Syllabus

  • 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

In 2017, this course is being thoroughly revised to include security and privacy. It ha also consistently rated as one of the best courses in the department.

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

Course work

The course work consists of:

  • 5-6 Programs
  • 1 test
  • 1 final

Tests will cover conceptual issues from kernel design 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.