The purpose of the course is to introduce you to the foundational concepts of modern operating systems, such as processes, threads, virtual memory, file systems, synchronization, and disk management. At the same time, an emphasis is made on system programming: both in the C language and in the assembly language.

Understanding the organization of operating systems allows you to comprehend how the software that you develop behaves in certain environments, what are the costs and benefits of certain programming solutions, what are the general trade-offs and fundamental limitations of computer systems. Every important concept is analyzed from three complementary points of view: functional (what does a component do and why?), structural (how does the component accomplish its mission?), and technical (how to obtain the services provided by the component from the application software?)
Due to the recent epidemic proliferation of embedded computing devices with limited resources (cell phones, wireless and wired sensors, and PDAs, to name a few), an additional stress is made on assembly programming, which puts you into the most intimate contact with computer hardware, at the level where every byte and every cycle count.
Because of the limited time, many important operating system concepts have been excluded from the consideration, including, but not limited to networking, real-time operating systems, and parallel and distributed systems. Students willing to learn more about these fields are encouraged to register for more advanced courses.
At the end of the semester, you will:

1. Understand the organization of modern operating systems, their algorithms and data structure.
2. Understand the trade-offs encountered by OS designers and system programmers, and learn how to determine important OS performance metrics.
3. Learn how to work with the most commonly used part of the portable operating system interface (POSIX)
4. Know how the most crucial parts of an OS (scheduler, dispatcher, boot loader, etc.) can be implemented in an assembly language.

Course Description

There are three approaches to studying operating systems: reading about them (a ``theoretical'' approach), learning how to use them (a ``practitioner's'' approach), and implementing them (a ``Linus Torvalds'' approach). However, each ``pure'' approach has its deficiencies. For example, knowing the theory of multithreading does not really enable you to write concurrent multithreaded programs, just as knowing how to write a superb process dispatcher in an assembly language does not make you a scheduling guru.
In this course, I use all three approaches in a multithreaded fashion. Every theoretical concept is supplemented with a fair amount of C language programming aimed at practicing this concepts in application software, and with an assembly project targeting the concept's implementation issues.
The official development platform of the course is C language (no C++!) / Linux operating system / Intel Pentium CPU. However, most programming assignments (with few noticeable exceptions) demand that you use POSIX -- the portable operating system interface that makes your programs compatible with other POSIX platforms.
To practice assembly programming, you will use Clown -- a simple simulator of an Intel-style microprocessor. The simulator has an assembler, a linker, and a disk formatting tool. Clown spares you from the hassles of the real Intel system programming, while preserving its conceptual spirit and important technical details.
This course can be taken by graduate students as a Computer Science foundational course. Its number for graduate students is CMPSC-F605.