rpeglar@csinc.UUCP (Rob Peglar) (05/31/90)
In article <1990May30.230248.6200@Neon.Stanford.EDU>, philip@Kermit.Stanford.EDU (Philip Machanick) writes: > In article <1935@key.COM>, sjc@key.COM (Steve Correll) writes: > > In article <402@newave.UUCP>, john@newave.UUCP (John A. Weeks III) writes: (deletions) > > This "is the Mac OS an OS" line seems to assume that an OS _only_ defines > multitasking. I always thought it defined a whole bunch of abstractions, like > the file system. The Mac does most of this conventional stuff, plus a sort > of abstract machine model for graphics. Maybe the implementation is not great > because you can break the abstractions too easily, but that's a different > issue. Been following this thread for a while, here we go. If one can define a term in context, take a look at history. In the 1950's world of computing, there was the concept of "open shop" Open shop was one user on one system, literally from powerup. At powerup, you loaded in your program - via wire patchboards, whatever - and "kicked" it into action (typ. a rocker switch or some such that loaded the program counter ...) Your program had to contain all external device handling - and also all resource allocation. In the VonNeumann model, this was CPU, memory, input, output (briefly). If you wanted to read from an external device, you did it yourself (the program, that is). The early push toward an "operating system" was given impetus from the early programmers disdain for having each and every (standalone-) program do the same things, like read from a drum or output to tubes. Hence, the "OS==library of code" came about. Multiple people used the same code segments. Everyone patched in the same code into their own programs. This was the first glimpse of an OS. The next stage was the separation of "user" and "supervisor" states, to use old (IBM-ish) terms. Instead of the user (program) having to perform i/o by hard code, a "supervisor" would perform this task. Only a jump to a particular address was necessary - the code segment remained memory-resident for the duration (typ. about one hour :-)). Note, before the linker/loader paradigm. Everything was absolute addresses. While the supervisor ran, the user did not. This was the second stage - the separation of powers. However, the user (program) still managed its own - and only one program ran at once. Some form of manual loading (physically speaking) was required. The next stage was what many people now call an "OS" - the supervisor code handling all resources without manual intervention. Loading of programs (punched card input) and viewing results (LED and/or paper output) without anyone having to intervene. Note, the model did not yet include multitasking or multiuser, but the late 50's/early 60's people were delighted. Now, instead of "open shop", one at least could camp out by the card reader/line printer (instead of the console). Multitasking and multiuser, and the rest, is history. The keys are the logical separation of entities, like files, processes, resources, etc. from one another, and the management of these entities. So where is DOS? Where is MacOS? Where is Unix? Judge them however you wish. There is a spectrum of "supervisor" capability, and how the user interacts with the supervisor. Where these systems fall is opinion. Rob -- Rob Peglar Comtrol Corp. 2675 Patton Rd., St. Paul MN 55113 A Control Systems Company (800) 926-6876 ...uunet!csinc!rpeglar