CS170 -- Operating Systems
- Where: PSYCH 1902
- When: Monday and Wednesday from 3:30 PM until 4:45 PM.
- Why: Because clearly Plato would have wanted it this way.
- There are NO sections scheduled for Friday, September 23, 2022.
- The instructions for enrolling in Gradescope are available on Piazza from
the CS170 Fall 2022 Welcome page.
Grades and Grading Policy
Lab and Discussion Homepage
Tutorial that may help with this class
Tutorial on a C library for doubly-linked lists and red-black trees that may help with this class
Gradescope (see Piazza for
instructions on how to sign up)
The focus of the class will be on the design and implementation
issues associated with operating systems. In particular, much of the emphasis
is on the skills necessary to understand and build a working operating system.
From this experience, however, the goal is for you to understand more
generally how systems are designed -- particularly
systems that must respond to events asynchronously.
Lectures in this class will be a combination of your instructor's various
musings that he is prone to express as lecture
the text in Silberschatz
and Galvin's "Operating Systems Concepts," 9th Edition.
The main pedagogical vehicle, however, comes in the form
of programming examples and
"lab" assignments that have been provided for your experiential enjoyment.
We will use C for all examples and
graded work, although familiarity with the Linux utility make and the
Linux system calls
will pay dividends that are sure to please the most
discerning student. The first lab is a stand-alone
assignment that is intended to both re-familiarize one with the enthusiasms
that C can engender and also to develop part of the test environment for the
rest of the class' project assignments.
The other assignments lead to the development of an operating system
for a simulated machine. Much of the course content owes its origins to
Professor Jim Plank at
the University of Tennessee. If you meet him some day, be sure to thank him.
Goals for the Class
The overall goal for the class is to allow you to become acquainted with the
development and inner-workings of asynchronous systems, in general, and
operating systems in particular.
Indeed, the most common asynchronous system in your life today is the
that runs on the computer you use. Operating systems provide the software
interface between you and the electrons that are doing your bidding in the
hardware. When you launch a web browser or an email program or music download
tool (you never do that, do you?) you are really asking another program that
is already running on your machine to start and watch over the program you've
launched. That "watcher" program is the O.S.
But the issues at hand are larger than just the design, care, and feeding of
an operating system. Many of the "hot" programming opportunities
available today (web based
programming, embedded systems, etc.) involve the implementation of software
tools and systems that can respond to asynchronous events. An asynchronous
event, loosely defined, is one that is not solicited and cannot be easily
anticipated. For example, a "web hit" is an asynchronous event from the
perspective of the victimized server. We will study operating systems
concepts as exemplars of systems design because operating systems techniques
are relatively well-established and because (unlike many of today's popular
software products) an operating system must function properly for a
computer to be useful in any way. An operating system, therefore, is just one
example of a larger class of systems with which you may already be familiar.
Programming these asynchronous systems is much different from programming
other kinds of applications. Asynchrony breeds race conditions which are
often difficult to detect and debug. Detecting and debugging them, however,
is both a skill and an art form. Thus, part of what you are learning at 4:00
in the morning the day your assignment is due is how to be an artist,
illustrating the breadth of human experience that this class encompasses.
Furthermore, performance is typically a high-priority for systems programs
making the applicable techniques fairly low-level. At the end of the class
you should have an intuitive "feel" for the rigors of systems implementation
(particularly with respect to operating systems) and you should be able to
distinguish that feel from your other programming experiences.
A big part of systems design concerns the performance tradeoffs between
competing implementation strategies. It is important to be able to reason
about the observed performance of your programs. At the end of this class,
you should also have some notion of how to evaluate the observed performance
of systems you encounter.
If you are considering a career that both involves programming computers and
provides the possibility for rapid advancement in today's job market, or you
are contemplating a career as an academic with an emphasis on systems, you
will need to understand asynchronous systems concepts and implementation
strategies. The over-arching goal of this class is to provide you with a
basis for such an understanding and to use operating systems design and
implementation to develop that basis.