Currently, Blake Jones (blakej@foo.caltech.edu), and John Langford
(jl@crush.caltech.edu) are interested in working on it.  email either of
us if you are interested in working on it.

The basic idea is to allow distributed files in a manner superior to NFS.
Improvements over NFS:
1. local caching of files.
2. Strong security
3. More customizability.

The first improvement, local caching of files could have a large impact in
several ways.  Pulling binaries down over NFS is a pretty poor option
generally, because as soon as the program is done executing, no local
record will remain.  This means it will need to be pulled across the net
at the next execution.  One could imagine an operating system that
consisted of local configuration files and a cacheing NFS, for all system
programs...  The disk space required for caching should be somewhat lower
than that required for a full OS distribution. In addition, the user would
have access to the full distrubition, even if the full distribution
exceeded the capacity of the hard drive.
There are also several settings you could imagine involving cache updates.
Options include: 
1. rabid updating, as soon as the file changes on the
server, attempt to update the cache on all machines which currently have
the file.
2. at use, as soon as the file is used by the local OS, if it is cached,
check to see if it has changed.
3. second use, whenever a file is used, spawn a second process that checks
to see if the file has changed, and update it after this use has finished.
4. decaying time updates.
5. no updating.

Strong security is necessary in light of the potential use as a core piece
of operating system.  It would be nice to find a good way to include
crypto.

Customizability would also be quite useful.  Currently, you can NFS export
directories and all of their contents.  Under this local caching scheme,
there is no reason why you wouldn't allow full local versions of the
files. The scenario would be that the server would have a base
configuration.  Then, the clients could go alter there local version of
the file, setting it to never be updated.  This would allow local system
configuration.

Furthermore, there is no reason why this idea isn't scalable.  A client
could be a server to other clients, although dependency loops should be
avoided.

You can imagine a scheme for memory:
1 registers
2 L1 cache
3 L2 cache
4 RAM
5 Virtual RAM (swapping)
6 Hard disk 
7 Net program servers (practical with a caching NFS system)

The actual amount of functionality we implement is quite dependent on what
tools we can find and help we can get.  Maximum advantage of existing
software will be taken in implementing this.  Blake has come up with a way
to implement (at least a large portion of) the functionality working with
existing NFS servers under Linux.

Does it seem like a good project?  Do you have any knowledge as far as
what is doable? What to do and not do?  I'd like to put a fairly high
priority on producing something that will be useful at large outside of
class.  Linux/gnu seems like the choice operating system to work with
because of availability of code.