This course covers the fundamentals of operating system design and
implementation.
The course takes a hands-on approach,
emphasizing learning by studying the structure and implementation
of existing operating systems
and using this knowledge to build a new one.

Lectures:
Lectures in the first part of the course
present basic operating system ideas and concepts,
explaining how they manifest in the
xv6
operating system,
an instructional operating system that closely mirrors
the structure of modern Unix systems while being much smaller and simpler.
Some lectures will involve preparatory homework assignments
requiring students to explore important aspects of xv6
by examining its source code and running it in a virtual machine.
Later lectures will expose students to more recent operating system developments
through research papers and other readings.

Labs:
Throughout the semester,
students will work in teams to build their own version of
PIOS,
a small but real operating system,
substantially different in design from xv6
though utilizing the same general principles,
through a series of six programming labs.
While the xv6-based homework assignments are to be completed individually,
the programming labs emphasize teamwork and collaboration,
and are structured to encourage collaborative learning
and to help students develop the important skills
of reading and building on code written by others.

All of the required reference materials for this course
are available on-line on the reference page
(also available in the quick links at the top).

The primary reference for the lectures is
xv6: a teaching operating system,
an instructional operating system and draft commentary
by Russ Cox, Frans Kaashoek, and Robert Morris.
This operating system is an x86-based rewrite of an early version of Unix,
which still reflects accurately the basic structure of modern operating systems
while being small and simple enough to be understood
at source code level in a one-semester course.
The original xv6 home page is
at MIT,
but please use the local copies on the reference page
for this class
to ensure that everyone refers to the same version throughout the semester.
We will arrange for printed copies to be available
from Yale RIS
for students who would like them.

To provide a broader perspective on operating system design concepts
than the primarily Unix-oriented xv6 commentary provides,
students are encouraged to refer to the following
optional, supplementary textbook,
whose chapters will be referenced as appropriate in course lectures:

This and several other other books that may be useful in this course
have been placed on reserve at the
Becton Library.
See the reference page for a complete list,
as well as links to many relevant resources available online.

You will be using the Intel Linux PCs
in the Zoo
computing lab.
You may access them either locally on the third floor of Watson Hall,
or remotely via the following command,
which will log you into a randomly-chosen Zoo machine
in order to balance load on the cluster:

ssh netid@node.zoo.cs.yale.edu

To access these PCs, you can either directly login from their consoles
in the Zoo, or just remotely login from other
machines across the campus.

If you plan to take the course for credit, you should get an account
on these machines in the first week. Please also visit the following web
site to create a cs422 class directory (or just to sign up for a zoo account):

Do not allow anyone else to use your accounts for any purpose.
They are for your use alone, and you are responsible for any misuse.
Your passwords control access to your accounts and should be kept secret.

Many lectures have associated preparatory homework assignments,
labeled PREP: in the schedule.
Homeworks will typically involve
and answering a few questions about xv6 or other assigned material.
Written homework assignments must be turned in
at the beginning of the associated lecture;
late homework will be accepted only during
the first two-week "shopping period," until Monday January 25.

The midterm exam is scheduled in class on Wednesday March 3, 2010.
Unless prior arrangements are made,
a grade of zero will be recorded for missed exam.

Programming, like composition, is an individual creative process.
Individuals must reach their own understanding of the problem
and discover a path to its solution. During this time,
discussions with friends are encouraged.
However, when the time comes to write the code that solves the problem,
such discussions are no longer appropriate:
each team's code must be the work of the members of that team alone
(although you may ask teaching assistants or lab assistants
for help in debugging).
In your coding you are encouraged to adopt ideas suggested
by classmates or other reference sources,
but must carefully acknowledge the sources of those ideas
in your own code and/or documentation.

Do not, under any circumstances, copy
another team's code. Writing code for use by another or using
another's code in any form violates the University's academic regulations and
will be dealt with harshly.

As you work on each of the programming labs,
keep a detailed record of how you spend your time working on the lab.
Since the programming labs are team-oriented,
you are expected to work closely with your teammates on each lab,
but EACH team member must keep a separate log of time spent on the lab.
To do this, place a log file with a name of the form
'labN-netid.txt'
in the top-level lab source directory.
The log file should have the following general form,
adopted from Prof. Eisenstat's CPSC 323 course:

An estimate of the time you think will be required
to complete the lab, made prior to writing any code.
This estimate must be on the only line in the log file
containing the string ESTIMATE in all-caps.

The total time you actually spent on the lab.
This time must be on the only line in the log file
containing the string TOTAL in all-caps.

A brief discussion (100 words minimum
of the major difficulties you encountered
while writing and debugging the code
(there will always be some).

For each lab, the TA will create a directory named
/c/cs422/SUBMIT/labN.ontime,
in which you are to copy your lab solution into a subdirectory
named according to one of the teammate's NetIDs.
(We know who the other members of your team are
from the log files you include in the solution,
so be sure to include the log files!)
At the lab deadline, the TA will freeze
the labN.ontime directory
and create a labN.late1 directory
in which to submit labs that will be considered one day late.
This process will continue as needed
with directories named labN.lateD
for labs D days late.

You will be using the Git
version control system to manage source code in your programming labs,
as will be laid out in Lab 1.
When you turn in a lab, you are to include
your team's entire Git repository,
including the .git directory and all its contents.
The recommended approach to using Git is for one team member to maintain
a "master" Git repository for each lab in a known location,
and for all team members to 'git clone' that repository
to create their own working repositories.
Each team member can then work concurrently
and 'git push' their code back to the master repostiory when ready.
Team members may alternatively use completely separate Git repositories,
but in that case you should combine all of your repositories
into one before submitting:
for example, other team members can incorporate their repositories
into the submitting team member's repository as separate branches
using the command
'git push myrepositorysubmitters-repository
labN:labN-mynetid'.

Attendance at lectures is expected but will not be recorded. Students are,
however, fully responsible for all material presented in lectures, even
if some of it does not appear in the "official" lecture notes.
Class attendance is recommended strongly.

Lecture notes will be made available,
though they are by no means guaranteed to be a complete record of the class
and cannot substitute for class attendance.

The best way to contact the instructor and
the TA is by electronic mail.
To get help quickly,
your best bet is to send email to
cs422ta@cs,
where it will be seen only by the instructor and TA,
or to
cs422@cs, where your
message will also be forwarded to every student in the class.
Use of the whole-class mailing list is encouraged
especially in the case of clarifications or debugging questions,
since it is likely that other teams will be encountering
the same or similar difficulties that you are
and may offer the quickest answer.
All the course-related information will be kept on the web
(URL: http://zoo.cs.yale.edu/classes/cs422).