CS385 - Syllabus

Operating System Concepts and Design

Instructor Dr. Jakob Eriksson <jakob@uic.edu>
Meets 3:30-4:45 pm TR, in LC D2
  4-4:50 pm W, in LC D2
Office hours Wed 4:50-6 pm (in ERF 2054)
Teaching Assistant Timothy Merrifield <tmerri4@uic.edu>
TA Office Hours TH 4:45-6, FRI 11-noon (in ERF 2054)
Lab Phone 312-413-2103


By the end of this course, you will have a good understanding of the main elements that work together to form an Operating System. You will have significant experience with C programming for low-level application development, and some exposure to operating system development. You will have acquired familiarity with standard tools for revision control, debugging, application performance and system diagnostics.

While the class combines theory and practice, there will be a focus on practical demonstrations in lecture and extensive hands-on programming experience. Plan to spend 10 +/- 5 hours per week on homework programming, depending on your current proficiency.


We will be using the 8th edition of the main textbook below, but you should be able to get by with the 7th edition as well.

Operating System Concepts 8/e
Silberschatz, Galvin and Gagne

All assignments are done in C. This is an excellent (and classic) introduction to the language.

The C Programming Language
Kernigan and Ritchie
Prentice Hall

Any architecture-specific discussions, as well as all the Linux kernel code we will be studying, will be based on the x86-64 (a.k.a. amd64) architecture. These will be handy references for the x86-64 architecture and the System V application binary interface:

additional materials will be supplied throughout the course in the form of URLs.


This class is programming intensive, with all assignments done in C. C programming will be taught in the class, but our approach to C will be based on a prior understanding of assembly language. CS366 is a required prerequisite: concurrent enrollment only with instructor consent, and strongly not recommended unless you have prior assembly experience.


Evaluation will be done through 1 midterm (20 points), 1 final (30 points) and 10 homeworks (75 points). Totals of 100 points or higher will count as 100 points for the purpose of the final grade. Grades will be based on a relative curve, determined after the final exam.

NOTE: Homeworks may either be graded on the turn-in, or by a quiz on the homework due date - thus you should strive to both solve the homework problems and fully understand the concepts encountered in the homework.


Consulting with your classmates on assignments is encouraged, except where noted. However, turn-ins are individual, and copying code from your classmates is considered plagiarism. For example, give the question "how did you do X?", a great response would be "I used function Y, with W as the second argument. I tried Z first, but it doesn't work". An inappropriate response would be "here is my code, look for yourself".

To avoid suspicion of plagiarism, you must specify your sources together with all turned-in materials. List classmates you discussed your homework with and webpages from which you got inspiration or copied (short) code snippets. All students are expected to understand and be able to explain their turned-in materials. Plagiarism and cheating, as in copying the work of others, paying others to do your work, etc, is obviously prohibited, is grounds for failing the course, and will be reported.

TOPICS COVERED (tentative)

  1. The C programming language
    1. from source code to executable
    2. relationship to assembly language
    3. types and expressions
    4. functions and function calls
    5. dynamic memory management
    6. essential programmer tools
  2. Purpose, Function and Structure of an OS
    1. Boot
    2. Processes
    3. User / Supervisor modes, privileged instructions
    4. System Calls
    5. Contexts
  3. Process Management
    1. Linking and loading
    2. Processes vs. Threads
    3. CPU Scheduling
  4. Concurrency
    1. Interrupts, multiprocessing, simultaneous multithreading
    2. Synchronization mechanisms
    3. Race conditions and deadlocks
  5. Memory Management
    1. Operation of malloc()
    2. Virtual memory and paging
    3. Memory mapping with mmap()
  6. Understanding and Diagnosing Program Performance
    1. Profiling and the 80/20 rule
    2. The memory hierarchy
    3. Threaded vs. Event-driven programming
  7. Storage Management
    1. File systems
    2. Mass storage devices
  8. I/O and Device Drivers
  9. Protection and Security

This topic: CS385spring11 > WebHome > Syllabus
Topic revision: r12 - 2011-02-01 - 18:05:08 - Main.tmerri4
Copyright 2016 The Board of Trustees
of the University of Illinois.webmaster@cs.uic.edu
Helping Women Faculty Advance
Funded by NSF