The Nucleus of a Multiprogramming System
by Per Brinch Hansen

Type of Paper
--------------
- Big idea with measurement

Summary
-----------
This paper describes the nucleus of a multiprogramming system which 
consists entirely of process management mechanisms, allowing for flexible
extensions to be easily added.  The desire was to createa small kernel 
which can be extended (via user programs) to implement operating 
system policies.

Key Ideas
------------
-  Small, flexible operating system 
The goal of this paper is to provide a small set of primitives that can
then be used to implement more complex operating system policies.  To achieve
this goal, the system precisely defines a process (as opposed to a program),
and provides primitives for the creation/destruction, communication, and 
manipulation of these processes.  With these primitives, operating system
designers can create higher level policies with user programs.

- Process hierarchy
The way this system allows extensions is via the process hierarchy.  Initially,
the system is in a basic state, from which parallel processes can be created.
Each of these processes can, themselves, create more processes, allocating its
resources as it sees fit.  Essentially, these parent processes act as operating
systems, establishing resource allocation policies for their children.  (Note:
CPU allocation is not handled by the parents, as CPU scheduling is handled by
a round-robin scheduler among all processes.)


- Process communication via messages.
The system introduces a method of process communication via messages.
This messaging system was implemented to overcome some of the perceived
deficiencies of semaphores.  Processes can send a message, wait for a message,
send an answer, and wait for answer.  These messaging primitives provide
a flexible communication paradigm for processes, while also providing
a method for synchronization.

General Comments/Observations
------------------------------
- It's interesting that the parent proccesses can allocate all of its
available resources to its children, with the exception of CPU time.  A
lottery-scheduling approach would seem to fit nicely within this system,
giving the parent processes complete control of allocation of its resources
to its children.

- Communication via the message passing primitives seems like a cool method
for allowing process communication, but is doesn't seem as flexible as
semaphores since it requires the processes no about each other in order to
communicate.  (ie. send message(...) requires the sender to know the "name"
of the receiver.

- Overall, a good paper with interesting ideas; laying the foundation for 
modern operating systems.