Introduction to the Special Issue

Implementation projects are crucial to the clear understanding of
operating systems concepts. Without projects, it is difficult for students
to understand some of the basic OS abstractions. Semaphores, for instance,
is an abstraction usually found difficult to grasp at the undergraduate   
level. Projects help students comprehend how the different pieces of an OS
fit together. Projects also motivate students and bring them the
confidence that they are capable of building and understanding code-level
details of operating systems.  This special issue is dedicated to papers
describing experience with teaching operating systems with projects of
various sizes.

The first paper by Raphael Finkel describes Chimaera, a software
environment for toy operating system development at the senior
undergraduate level.  Chimaera consists of a virtual machine simulation
module and a C-threads package.  Students build their operating systems as
a single Unix process on top of Chimaera. The paper presents three
projects on CPU scheduling and semaphores, virtual memory and demand
paging, and IO management and its interaction with virtual memory.

The second paper by Michael Kifer and Scott Smolka describes OSP, a
simulation environment of a modular operating system. It is intended for
use at the undergraduate level. The core of OSP is a virtual machine. In 
addition, OSP provides a number of modules such as device scheduling, CPU 
scheduling, interrupt handling, file management, process management, and 
interprocess communication. By omitting a subset of these modules, the
instructor is able to generate a project, in which the students are to
implement the missing (hidden) modules. OSP is written in C and runs under
most flavors of Unix.

The third paper by Wolfgang Burke describes Viskosy, a simulation and a  
visualization aid for operating system concepts. It seems appropriate to
use Viskosy at the senior undergraduate level.  Viskosy emphasizes the
demonstration and experimentation of OS concepts more than the generation
of implementation projects.  The simulation offers a spectrum of workloads
and configurations for each OS manager. To experiment with a concept, the
student chooses the configurations and workload parameters. Simulation can
be run in measurement or demonstration modes. In the latter mode,
animation is used to visualize the behavior of OS algorithms such as
algorithms for disk scheduling.

The fourth paper by Stephen Taylor provides a variety of OS projects that
can be used from the senior undergraduate to the first year graduate
level. Interesting small-size projects are described including
experimental projects to measure process startup time, measure context  
switch time, and page-fault handling time. Larry McVoy's Imbench tools are
used in these projects. Other small projects include building a
time-of-date clock and writing Sun-RPC client/server memo system.  For   
first year graduate students, two toy operating system environments are
provided. The 32-bit PC OS is protective mode time-sharing system, parts
of which are provided to the students. A port of Gnu C compiler and
assembler are also provided. Students complete routines for clock and
keyboard interrupt handling, process creation, and memory allocation and
paging, among others.

The 16-bit PC OS is a BIOS-based, non-preemptive multi-tasking system,
parts of which are provided. Students complete routines such as message  
passing, disk scheduling, and file systems.

The fifth paper by G. Rodriguez Lopez et al. describes an OS project
required at the advanced graduate level. The project is to implement a
Unix-like OS on top of the Mach microkernel. The project consists of an
emulation library, a file server, and a task server.  The file server
provides Unix functionalities for accessing character and block devices,
whereas the task server manages the processes and their interaction with
the file server. The emulation library provides the Unix-flavored call  
interface. The project requires students to understand both Unix and the  
Mach microkernel. It also provides the students with the opportunity to
compare the structure of Unix to a microkernel OS.

The last paper by Golden Richard III describes Perl-based client/server 
projects in the senior undergraduate level. The paper emphasizes Perl and
provides a quick introduction to socket-based, multi-tasking client/server
programming. The paper offers a fully documented example.

I thank the authors for their contributions and hope you benefit from this
issue and from the resources made publically available by the authors.


Sumi Helal
helal@mcc.com