Moose Revision 0!

[Gary D. Duzan]

=>First off, there is a mention of how we're aiming to support the 2-8MB
=>RAM PC market, yet we want multi-user support.  8MB, in my estimation,
=>seems a little bit small for multiple users.  And, does it seem we
=>need multi-user support in the PC arena anyway?

   Good question. I think it goes without saying that we need some
protection mechanism, but how far should we go, and what should the
mechanism be? Access Rights Lists? Capabilities? User/Group/World a la
Unix? A simple User vs. Supervisor mechanism? Capabilties seem to make
sense in an object-oriented system, but they may be more powerful than
we want.
   Personally, I am of the opinion that any system that is going to be
on a network should have some security, especially if it is going to
provide network services. Ideally, an object system should extend
through a network to access objects on another system, and that would
require security. This is obviously not a feature for the base system,
but it should be possible to add it later.

=>Also, should we take into consideration the design of the Motorola chips
=>before we begin?  

   I think I covered this in an earlier note.

=>Also, our OS will not run on anything less than a 386SX, so is there
=>perhaps a similar cutoff in the Motorola chips.  I mean, is there such
=>a difference between, say, the 68020 and the 68030, that we should not
=>develop for anything less than the 68030?

   This is a good question. Does anyone have a suggestion for a
reference for the 680x0 series?After the 80386 and the 680x0, we can
start on the Sparc, RS/6000, MIPS, Alpha, and the Cray. :-)

=>And, about Mac support, isn't the user interface part of a Mac OS in
=>ROM?

   I imagine there is a way to bypass the ROM routines.

=>Section E concerns scheduling.  I'd like to see four priority classes.
=>We could have a time-critical class, then perhaps some type of
=>class where we could let threads run that need to run before those of
=>a user class, such as server maintenance threads and the like, then of
=>course a user class, and finally a daemon or idle thread class.  Within
=>each priority class we'd have just a simple round-robin dispatching.
=>Sound like it will fly?

   Sounds pretty straightforward to me.

=>Anyway, I've talked on a low level here, but I think there a some very
=>low-level questions such as these that need to be considered early on,
=>just as those high-level design considerations.

   That's what we're here for.

                                        Gary Duzan
                                        Time  Lord
                                    Third Regeneration
                         Humble Practitioner of the Computer Arts