Position & proposal

[Dave Mason]

Mike McDonald writes:
> 
>   Adding multiuser capability causes all sorts of headaches concerning
> who can do what? when? who does it affect? when does it affect them?
> For instance, you're off modifying some system service. Do the other
> users get your new modified services or do they use the old service?
> When do they get the new service? Remember, the goal of using lisp is
> so you can make these types of modifications on the fly, without
> rebooting. I don't know how to support both the ability to change
> things and protect others from those changes. Seems like you can't
> have it both ways.

It should be possible to do most updates in a sandbox, including
iteratively debugging, with only processes sharing the hacker's
environment seeing the hacked versions until at some point you commit,
and everyone sees the new environment.  Think database.

E.g.	(define global (current-environment))
	(new-environment)
--> now in new environment
	(define (mouse-tracker) ...)
	(define (keyboard-handler) ...)
--> play with this definition, if we decide we like it, say:
	(set! (global . mouse-tracker) mouse-tracker)
--> play with other things, eventually abandoning them by saying:
	(set-environment global)

This might be difficult in a timesharing environment if you wanted to
debug say the disk driver that had hardware interactions with the
already running disk driver, but virtually any part of the OS that
doesn't share hardware state should be no problem at all!

../Dave