<nettime> the ultimate OS

["Vladimir Z. Nuri" <vznuri@netcom.com>]

an HTML version of this article can be found at:

   http://www8.pair.com/mnajtiv/tao.html



                                the ultimate OS
                                       
     * intro: the ultimate OS
     * what is an OS?
     * recent developments in the OS
     * predictions
     * an open OS standard
     * a new kind of OS: Tao
     * the object
     * the object browser
     * optimization
     * compatibility
     * conversion
     * object installation/upgrades
     * software philosophy
     * attitude toward failure
     * integrity, hotfixing, fault tolerance
     * security
     * Tao device principles
     * potential difficulties
     * realization of Tao
     * about the author
     * references/resources
       
intro: the ultimate OS

   This article proposes a radically new kind of operating system and
   software style that includes what I consider to be the best features
   of all existing operating systems created to date as well as many new
   innovations. It is based on ideas and inspirations I have collected
   over many years and have finally written up here. (I am motivated
   especially by recent events regarding the leaked Microsoft "Halloween
   memos" and the ensuing controversy and debate; I hope to add a
   substantial new angle.)
   
   My background, briefly, apropos to this article: I started programming
   at age ~10 on a Commodore PET. I've used Atari, Apple II, DOS,
   Macintosh, Windows, and Unix all very extensively. I have been using
   Linux since about 1996 and have watched its development closely,
   especially recently.
   
what is an OS?

   The OS of a computer has undergone many modifications over time. At
   first it was designed as a very rudimentary system that simply loaded
   programs and interfaced with the basic hardware of the computer, i.e.
   tape or disk drive, keyboard, monitor. The modern OS has grown into a
   system of astonishing breadth and complexity with much code dedicated
   to creating the GUI and supporting diverse hardware (including
   networks). Microsoft (MS) NT code numbers in the tens of millions of
   lines.
   
   Mainframe OSes often are even more complex, however the world does
   seem to be standardizing on Win95, NT, and Unix in general. The
   so-called battle between MS-based OSes and non-MS OSes is still in
   play with people taking sides whether MS will totally dominate the OS
   niche or whether an upstart such as Linux may threaten the MS
   hegemony.
   
recent developments in the OS

   Linux represents an astonishingly unprecedented new element to
   software design. The internet has allowed the creation of Linux in
   which thousands or tens of thousands of programmers, all putting in
   small amounts of time for no pay, or more exactly on the side to their
   paying jobs, have accumulated a unified system over time that is now
   fully competitive with major commercial OSes such as those by MS.
   
   Recent events such as leaked MS memos that express concern over
   "market penetration" of Linux demonstrate this quite strikingly. Of
   course the whole meaning of the word "competition" is ambiguous in
   this situation where much of Linux has been developed and distributed
   free of charge. The model some are proposing for Linux is that the OS
   can be freely distributed even as individual companies such as Red Hat
   software or small consulting companies carve out a viable economic
   niche in distributing or supporting it.
   
   Another modern development milestone to the OS is Java, a language
   that is designed to be platform independent and has largely achieved
   this goal. Java complements the web nicely, and the web browser has
   become the focus of intense development efforts within the OS at MS
   for example, and Netscape once threatened MS's OS dominance based on
   this avenue. In addition to the dramatic dethroning of Netscape,
   however, there was a setback recently as WebTV, wholly owned by MS,
   announced that they will not create a Java version of their product.
   Some outside the company question this as a tactic by MS to stall the
   creation of a kind of "network computer" (NC) that would inevitably
   result if one coupled a cheap internet computer with Java.
   
   Arguably the NC is already here (despite Oracle's Larry Ellison's
   public apologies to the contrary) when one considers that applications
   previously considered local, such as email, via packages such as
   Eudora, are now possible entirely over the web on cheap computers such
   as WebTV even without Java-enabled browsers, as evidenced by the
   convenient and popular Yahoo Mail and Hotmail services.
   
predictions

   My opinion is that a network computer (NC) will play a very important
   role in the development of computing and the conventional domain of
   the OS in the near future. MS is finding itself in a similar situation
   that IBM found itself in at the birth of the PC age. IBM was reluctant
   to "cannibalize" its existing mainframe product line by selling PCs
   cheaply, even though huge (or greater) profit was still obtainable.
   The Java/WebTV announcement suggests MS is reluctant to cannibalize
   Win95 sales with the invention of a versatile new NC.
   
   It seems very safe to say that Linux will continue to gain a major new
   foothold in various areas. In some ways Linux is introducing some
   major innovative aspects to an OS that even Microsoft is not keeping
   up with. For example the standard package installation and
   de-installation system on Linux, RPM, is absolutely first rate and
   arguably far easier to use and more reliable than MS's system, which
   does not always allow deinstallation of a program and may annoyingly
   prompt the user many times merely to install a package.
   
   One could argue that it will be inevitable that the world will
   eventually standardize on an OS based on completely open standards.
   This is my position. I have noticed how the arguments in the industry
   have shifted about open vs. closed systems starting at lower level
   components such as devices and network hardware but are now focused on
   higher level components (such as the OS) now that lower-level (thereby
   less complex and more rapidly built) standards have been developed and
   stabilized. My observation is that in general proprietary and closed
   systems can compete with open ones as long as there is not a consensus
   about the best technology. But as soon as consensus emerges, open
   standards tend to follow, sometimes quickly.
   
   That is, closed systems are very useful during a stage of competition
   of different ideas, a sort of "survival of the fittest" where the best
   win out. Open systems that embody cooperation are better and actually
   preferred by the market once a consensus about design decisions has
   developed. What is the relevance of this observation to the OS?
   
an open OS standard

   An OS is one of the most complex pieces of "digital architecture" on
   the planet, and it has taken close to a decade for the industry to
   evolve a stable solution and answer to the question of "what exactly
   is an OS" for the PC (but in general the OS has been evolving for
   perhaps half a century). The debate was heated and it now seems ironic
   that for many years computer magazines had many strong and emotional
   editorials *against* the inherent desirability of say, the mouse or
   the windows GUI and other basic OS features now considered standard
   and indispensable.
   
   However, I would say that the answer to the question of "what is an
   OS" has stabilized onto the general features that are embodied in
   Linux and Win95. The NC may be the final solution to the question,
   with its implications that the browser is the OS and "the network is
   the computer" (an oft-quoted Sun motto). So now that the industry has
   arguably evolved a consensus, I expect that an open OS standard will
   soon inevitably emerge, not owned by any company much to the chagrin,
   opposition, or even "dirty tricks" of companies such as MS.
   
   This paper proposes such a uniform, open OS standard, which could
   theoretically evolve fairly easily out of Linux. This is not to say
   that Linux is already a solution to the problem of creating an open
   OS. However it doesn't embody many of the ideal aspects of an OS which
   I delineate below-- such as ease of installation and operation to the
   nontechnical user, a streamlined system of open device interfaces, an
   object-oriented kernel, etc.
   
a new kind of OS: Tao

   I believe this is a pivotal moment in the historical development of
   OSes and that there is now definitely room for an entirely new OS
   within this hierarchy. The ideas for it have been circulating in my
   mind for many years, but they are all clearly "in the air" of current
   industrywide trends and debate and are ripe to be plucked, so to
   speak. I will propose it here in some detail. This article is a very
   high-level design document for the system, and gives minimal
   consideration to practical limitations. It is meant to be a
   conceptually elegant system that exists in theory and in idea only at
   this point. But this article is a first step toward achieving some of
   the very desirable goals it is designed to embody. Throughout, I will
   often contrast it with existing design choices of current operating
   systems.
   
   I have mused on a name to call it for a long time, but recently came
   up with the idea of naming it "Tao". Tao is a very subtle Eastern
   philosophy espoused in simple poetry with short stanzas by the mystic
   Lao Tzu several centuries B.C. My goal is to formulate an operating
   system with the same combination of simplicity and power voiced in
   this philosophy and maybe spark the creativity, enthusiasm, and most
   ideally, the labor of others in achieving it.
   
   The creation of the Tao OS might also follow a Tao-like philosophy, in
   the sense that Linux already has. Linux development is not
   hierarchically controlled like the structure of MS yet embodies an
   overwhelming power of distributed force. This contrast is very similar
   to the metaphor of the power of water in flowing around and eroding
   any obstacles in its path, a frequent theme in Taoist poetry.
   
   Here are the key design criteria of Tao, all of which will be expanded
   in the sections below:
   
     * The system favors end-user convenience and simplicity more than
       any other criteria. Many OSes claim to do this but actually make
       subtle choices that favor "developer convenience" over user
       convenience. For example users often have to perform complicated
       installation tasks that could all be eliminated but are not, due
       to programmer laziness or lack of development time. The system
       must be extremely easy to use. If Win95 is considered "user
       friendly", then Tao is even far superior to this, say
       "conscientious". There are many aspects of Win95 that one could
       argue are "user friendly" (compared to earlier very crude or
       rudimentary means such as command line interfaces), but are
       definitely not "conscientious".
     * The system has a strong element of uniformity and coherence, both
       internally in the code and externally in all interfaces, such as
       for devices and the user GUI, via a totally unified
       object-oriented system. Many OSes are designed and various
       elements are continually added over time, and the system becomes
       "legacy software" that is hard to maintain and loses cohesion. Tao
       embraces the idea that software is continuously evolved and
       upgraded, including the OS itself.
     * The system is based on completely open standards and hence has
       excellent interoperability. It is also based on a continual
       creation of new open standards within it. In contrast commercial
       OS companies are often hostile toward open standards.
     * The system has excellent security. Viruses are impossible to
       contract on the system based on its design. In contrast people
       must be somewhat paranoid and go through all kinds of contortions
       to avoid infection on existing systems. Also, end users changing
       system configuration parameters will *never* paralyze the OS.
       Accidental corruption of the system integrity is virtually
       impossible; the system is "foolproof" no matter how ingenious the
       fool!
     * The system has extreme integrity and reliability. Many common
       failures associated with existing OSes are impossible in Tao due
       to stability features. Huge amounts of unnecessary time are wasted
       on fixing or debugging unreliable OSes today. In Tao, increasing
       functionality and components (new hardware and software) does not
       noticeably increase complexity or unreliability of the system.
       Sophisticated debugging features make troubleshooting easy even
       for the novice.
     * The user is almost always insulated from low-level concepts such
       as hard drives, cards, devices, memory, etc. For example a user
       might add a new hard drive, and simply see available "space"
       increase, without any notion of some objects being located on one
       drive or another.
     * The system is highly optimized. Possibly no loss of speed or
       performance occurs, and in fact the internal uniformity and
       coherence may make new processing gains possible in sharing or
       cleverly juggling resources.
       
the object

   In Tao the center of the OS universe is the "object" which is vaguely
   analogous to a C++ object except that it is intrinsic to the entire
   OS, any language can be associated with its code, and it has a unique
   version, as well as other differences. The entire OS is completely
   object oriented. Objects have certain basic properties:
   
     * An object can be contained in other objects, and an object can
       "contain" multiple objects, or copies of them. These objects can
       be located "elsewhere," say distributed over a network.
     * An object has several basic elements: a *name*, *type*, *version*
       *interface*, *code*, and *data*. Some data is read-only while some
       data is readable and writeable.
     * Objects can be "moved around" to different "places" either on a
       local computer or remote computers.
     * Objects "hook up" to other objects and pass data back and forth.
       These links are all carefully recorded and entire object networks
       and trees can be traversed.
       
   Every mass-produced OS so far does not use objects for certain
   intrinsic functions. For example a disk directory tree can be thought
   of as a single object that contains subobjects-- subdirectories. But
   the systems do not treat file organization in this way.
   
   Tao would not have a file system in the conventional sense. Disk space
   is mapped onto an object. Subobjects can be created within this
   object.
   
   There is another key way the existing OSes (both Linux and Win95) do
   not use objects in file systems, leading to endless difficulty. In
   Win95 and Linux both, a rather weird and troublesome convention of
   having extensions represent file types is used. In contrast, the type
   is an intrinsic property of the object and there is never any
   ambiguity.
   
   The use of objects makes Tao the most modular system possible. The
   common artificial distinctions in current OSes between disparate
   aspects such as files, directories, etc. are all dissolved and
   subsumed into the object concept. Nothing other than objects exists on
   the system, and all objects are accessable to the user and software
   via impervious safeguards.
   
the object browser

   In Tao, a universal object browser is available and contains the
   complete logic and interface for dealing with the entire system. The
   object browser is a cross between a web browser, an OS application
   desktop, process manager, a file viewer, and a programming
   environment. It is very cleverly constructed such that only the amount
   of information relative to the sophistication of the user is revealed.
   
   For example simple users can use it just to navigate the system and
   perform basic tasks. More advanced users can use it to troubleshoot
   and debug, "look under the hood" and even rearrange very low-level
   features of the system, or program new components. All well-written
   software on Tao also reflects this hiding of complexity to insulate
   the novice user, while retaining full power for the experienced one,
   and encourages a smooth and natural flow of progress from the former
   to the latter.
   
   The entire object browser is extremely idiot-proof yet powerful at the
   same time. Virtually anything about the system can be modified or
   changed, but there is total protection against putting the system into
   an inconsistent or inoperable state through a system-wide "undo"
   feature. In fact much of Tao is about taking the concept of "undo" to
   its full logical potential. Records are kept of all earlier
   configurations of the system and the user can switch between any
   instantaneously, without rebooting or other gratuitous operations.
   
   The object browser integrates seamlessly with other systems over a
   network. Objects can be moved around "in cyberspace" as easily as over
   a local computer, with complete safety, security, and seamlessness. An
   entire local computer is itself an "object" that can be seen in larger
   "super-objects". For example a system administrator could "drag and
   drop" some configuration parameters onto a superobject that comprises
   hundreds of computers in a network, instantly adjusting them. Or a
   similar technique could be used to transfer software or even execute
   it across a distributed system of Tao computers. Again there is total
   safety in all operations no matter what the scale, even at the complex
   superobject levels.
   
   In short, the object browser tends to blur the concept of local vs.
   remote objects to the point it is mostly not a matter of concern or
   awareness at all by the end user. Objects can be loaded off of the
   network and executed just as easily as they are loaded off a local
   hard drive.
   
optimization

   Tao is extremely intelligent and can handle multiple levels of
   caching. Local RAM and disk are both seen as intermediate caches to
   the network. The browser automatically shuffles resource usage in a
   very optimal way that minimizes execution time, "swapping", and
   "thrashing". Applications do not have to reinvent the wheel by
   inventing their own caching schemes because the Tao object browser
   system is more intelligent and streamlined than any specialized
   systems, although applications can "tweak" it.
   
   In Tao there is excellent intelligence about reusing resources. For
   example, if new software is installed over old software, if there are
   any components that are identical, no extra space is required to store
   the new components, even though they appear as unique. This applies
   within the system memory as well. (In Tao the distinction of RAM and
   disk space is totally blurred such that it makes intelligent decisions
   about where to allocate objects invisibly, automatically, and
   seamlessly.)
   
compatibility

   Compatibility is a key problem with much software. In Tao, I would say
   there ought to be an easy way for the same object of different
   versions to coexist, and a way for the user to switch between versions
   elegantly. So for example a user could install an upgrade on his
   system while the old software was still fully functional. The user
   could switch between old and new versions "on the fly" if he has
   problems with new features. When he is satisfied with the stability of
   the new software, he could delete the previous version.
   
   In other words the system embraces the concept that software is not
   static but being constantly revised in a continuous "flow" and creates
   many structures that encourage rather than hamper this process.
   
   In contrast, in existing systems, it is assumed that the software
   company will do everything right in the new version. This is a totally
   unrealistic expectation with the complexity of modern software. What
   is not needed is more or better quality control, but a system in which
   the end user has the ultimate and total control over his
   configuration. In the best case scenario, components of the OS itself
   could be added and removed on the fly, with total and foolproof
   protection against accidentally disabling the system.
   
conversion

   A very major aspect of Tao is a unified system whereby a set of
   objects are available to convert objects in one form to objects in
   another form. So for example a file "object" in one "format" (type)
   can be converted to one in another based on the inherent objects in
   the system. In Tao, there is total knowledge about the entire object
   network and the paths through which an object may be converted. For
   example, a JPEG image object might be on the computer. The user could
   call up the object and immediately see what he can convert it to and
   the paths it might take, such as first converting it to GIF and then
   to a compressed file. Different versions of the same standard are all
   understood and handled correctly.
   
   All this is possible because the system is fully aware of what objects
   are of what type and what "conversion objects" are available, and what
   objects they convert into what (based on the interface
   specifications), that is, the entire conversion network. In fact
   automatic conversion processes can be set up within the OS such that
   objects are converted on-the-fly whenever they are needed, so for
   example whenever a compressed object is called up it is automatically
   decompressed. This same system is used for compatibility processes.
   For example if a file format is given to an application object in the
   format of an "earlier version," the system can automatically call up
   conversion processes.
   
   The conversion processes can happen with code execution as well. For
   example suppose two versions of a "function" object exist. A call is
   made to the later version with data in the form of the earlier
   version's interface. The Tao system can automatically call up a
   conversion "wrapper" that exists only to convert the interface calls
   into the new format. The system has a caching technique to optimize
   this when it occurs repeatedly.
   
   Another area where built-in conversion mechanisms is useful is
   cross-compilation. Objects that convert code from one machine type to
   another are available, so that emulation functions are totally
   intrinsic to the OS.
   
   Overall, much of the Tao OS can be seen as a streamlined conversion
   between data and code in a way that is not well understood or
   practiced today. For example in many programming languages there is a
   debate between "interpreted", "compiled", "just-in-time", etc.-- but
   all code is equivalent and these concepts are relevant only as
   optimization features within the OS, analogously to disk caching.
   Objects that are used frequently should be compiled, objects that are
   used less frequently can be just-in-time compiled, and infrequently
   used objects can be interpreted "on the fly". A well-constructed OS
   could automatically make the best decisions with the help of some
   occasional explicit tweaking by programmers.
   
object installation/upgrades

   In Tao the installation process and deinstallation process of any
   component is absolutely foolproof. Often in Win95, errors arise during
   installation or de-installation that leave the entire system in a
   "half-baked" state. In Tao there are no prompts at either installation
   or deinstallation, the entire process is always completed as a whole
   without further interruption.
   
   In Tao there is no possibility of a program leaving around "files" or
   "traces" of itself anywhere in the system, because in Tao, there is
   total knowledge by the system of all "connections" involved with an
   installed object. Objects simply cannot be "orphaned" on the system in
   any way. Contrast this to the serious and aggravating Win95 problem
   where applications may put files on a hard drive that the user cannot
   consistently locate if he wishes to uninstall the application. Often
   in the past Win95 users were sometimes forced to reformat a hard drive
   and reinstall their preferred software as the only available solution
   to this inexcusable problem!
   
   Adding a new component, either hardware or software, will *never*
   disable any currently functioning aspect of the Tao system under any
   circumstances whatsoever. In the worst case, only the new component
   will fail to function. Cross-problems such as a new component
   interfering with an existing installed component will *never* happen.
   This is the bane of virtually all existing OSes that has consumed
   perhaps millions of man-hours of the most intense frustration
   imaginable worldwide on the planet. I contend that it is due to a
   poorly designed OS that can be overcome eventually if it is made an
   explicit design goal, rather than considered an inherent property of
   software and hardware.
   
   In Tao, however, when problems do arise there are very streamlined
   systems to handle them. A bug-catching system is set up such that
   information can be relayed to companies about the complete
   configuration of a system and crucial events that led to the bug. In
   some cases the adjusting of software components to deal with bug fixes
   is completely automatic, with patches automatically downloaded and
   installed over the network. The user can be totally comfortable with
   new software as Tao prevents loss of data or function in any case
   whatsoever, even when the distributing software company fails to write
   the software correctly. In worst case the user simply reverts to older
   versions of the software or data with the ease of hitting the "undo"
   option in many software packages.
   
software philosophy

   In Tao, the user is given powerful control over the object system. The
   distinction between the application created by a company and what is
   created by a user is blurred. A user can access the internal
   connections of the objects in software and modify them to his needs.
   Powerful safeguards against disrupting any system are in place such
   that anything the user does can be easily rectified.
   
   In Tao, great emphasis is placed on "silence". An object that cannot
   accomplish a processing function without prompting the user fails in
   its purpose. Prompts that appear at arbitrary and unexpected times are
   inexcusable interruptions to the flow of a user's attention and work.
   All information required to perform an operation is passed into the
   interface of an object, and the object performs its job.
   
   There are objects that serve entirely to interface with the user, but
   they are entirely separate from objects that perform operations. This
   goal is very often violated by Win95 and software that runs in it. The
   user is often interrupted with error messages, gratuitous prompts, and
   dialog boxes that could easily be eliminated with better designed
   software. This organization reflects the basic user flow of attention
   from "specifying what needs to be done" to "doing it", two totally
   separate aspects of using a computer that should be religiously
   separated from each other in both the external operation and internal
   structure.
   
   Much software has ubiquitious arbitrary "magic limits". For example,
   eight character filenames. Or another example, an entire manual is
   dedicated to describing all the buffer parameter sizes in Oracle
   databases. In Tao, any user other than a programmer *never* has to
   deal with these arbitrary software limits. They simply don't exist in
   the software except at very low levels, and all the high level
   components insulate the user from knowledge of them. All components
   grow or shrink in "size" (memory and processing time) very smoothly,
   dynamically, and invisibly as demand fluctuates. The system always
   "flows smoothly" even when almost anything breaks.
   
attitude toward failure

   Often with Win95, a solution to fixing problems is to reinstall the
   entire OS, ridiculous and absurd procedure that has occupied the
   countless time of untold magnitudes of of tormented operators. Yet it
   is conceptually trivial to design software that can check its own
   *entire* integrity and flag aspects of itself that have been corrupted
   and fix them. Even better, it is possible to create an OS in which
   corruption of the system through software or user processes is
   virtually impossible. This leaves only hardware failures, which even
   that the OS can detect and adjust for automatically. In Tao, in stark
   contrast to existing OSes, it is *assumed* any failures may occur, and
   code to handle every basic failure is included. For example, the
   system can detect and avoid on the fly new bad sectors on a disk. But
   the system also invariably notifies the user of any problems that
   arise in a consistent and convenient fashion.
   
   Early versions of Win95/Win3.x reveal this dichotomy. Originally MS
   assumed that third-party developers would never call the OS in
   incorrect ways. They would point fingers at the third party developers
   when fatal errors (locking up the system) occurred merely from
   incorrect OS application calls. After much controversy, MS eventually
   relented and put protection against incorrect calls into the OS. Tao
   takes this philosophy to the utmost degree, and assumes that any
   coupling of any component may fail. For example, a new device driver
   may not run properly, etc., and Tao can help detect this and disable
   the "offensive" component without any negative effects on the
   integrity of the rest of the system.
   
   In Tao, the source of problems are always very easy to diagnose even
   by an end user. The system has a mechanism to isolate problems down to
   individual misbehaving software or hardware components that leaves
   absolutely no room for ambiguity, because the system assumes these
   will arise routinely, as amply proven by history.
   
   In my opinion no amount of cleverness or quality control will ever be
   achieved to guarantee new software or hardware will always run
   correctly in the complex and unique end-user environment, and to
   attempt to attain this objective is laughable, misguided, unrealistic,
   impossible, and most importantly unnecessary. The ubiquitous situation
   of confusion that exists everywhere today where vendors point fingers
   at each other and the OS manufacturer could be transcended with an OS
   that always flawlessly identifies what component is failing to adhere
   to the accepted standards and does not crash merely because of these
   common and unavoidable glitches.
   
integrity, hotfixing, fault tolerance

   In existing OSes there is often the problem of "lack of integrity" in
   upgrades. A person can upgrade his system with new software that only
   half works. He cannot revert to older software, nor can he correct the
   new software. This problem is extremely acute, dangerous,
   timeconsuming, and infuriating when it involves the OS itself. In Tao
   the concept of transaction integrity is followed at all levels. Even
   an entire OS upgrade is considered a "transaction" that has an
   integral circle, either successfully or unsuccessfully applied, with
   full "rollback" even on the level of the entire OS supported with
   sufficient resources!
   
   These "rollback" and "integrity" features mean that backups are
   seamlessly integrated into the system. The user does not have to worry
   about the code/data distinction with backups. The user can switch
   versions on both code and data at any time, restoring to earlier
   versions of software or data on the fly in a transaction that is
   always assuredly complete. The end user always restores and backs up
   data in whole "chunks" related to object connections, with halfway
   backups or restorations that corrupt or disable a system rendered
   nonexistent.
   
   The Tao philosophy with regard to fault tolerance can be demonstrated
   very tangibly as follows. On a non-Tao system, if a drive breaks, the
   entire OS and applications are destroyed. The user must turn off the
   system, dismantle the computer, install new hardware, reinstall the
   operating system, all software applications, etc. In contrast, in a
   "hotfix" type drive situation, a drive can fail with redundancy in
   another drive, the user is notified, the user can replace the drive
   *on*the*fly* without even shutting down the system, and the system
   will integrate the new drive quickly and once again reach the
   redundancy safety. Applying this invaluable concept of "hotfix"
   throughout the entire operating system, with *all* software and
   hardware components reflects the basic fault-tolerance design goals of
   Tao.
   
security

   The security is such that a virus or vicious application is simply
   impossible to create on the system, in the same way that a
   microprocessor can protect some areas of code as "read only" without
   any exception. Nothing that an application is permitted to do can have
   a pathological effect on the system. In Tao there are robust limits on
   all finite resources such as memory, disk space, screen space, and
   processing time such that no processing can take on any pathological
   aspects. Certain operations such as formatting a disk cannot even be
   called by non-OS software components.
   
   In Tao there is very good security if those components are installed.
   The entire system supports encryption of all kinds of flows of data
   and code objects, partly through the automated conversion features.
   Every user in a multiuser system exists totally in a "sandbox" that is
   a fully separate and inviolable space. Every user sees a different
   "view" of every object existing on the system and has special rights
   relative to each.
   
   The security is completely uniform even when the Tao OS is operating
   on a network. The security is intrinsic to the OS and the same basic
   principles apply over a network without specialized exceptions or
   additional systems.
   
Tao device principles

   One of the greatest headaches for both programmers and end users with
   existing OSes is the integration of hardware devices. I strongly
   disapprove of the Win95 solution in which MS dedicated armies of
   internal programmers to create device drivers compatible with
   virtually all third-party hardware known to man. At best, the system
   was inelegant and not distributed, involving an unnecessary and very
   time consuming development bottleneck. At the worst, it could be
   reasonably seen as an embarrassing failure of MS to successfully
   cooperate, communicate with, and adequately direct their own
   supporting vendors.
   
   Obviously a distributed or third-party friendly system is needed.
   There is some work on developing a device/driver standard on
   Unix/Linux systems, and I believe this will progress favorably in the
   future, to the point there will be basic standards for the common
   devices that are easily and widely supported by the manufacturers:
   mouse, keyboard, disk drive, monitor, network cards, etc. Such a
   system is crucial for Tao.
   
   In Tao *everything* is *always* "plug-and-play". All hardware, all
   software, everything. Anything can be connected or disconnected at any
   time with the system handling it elegantly in every situation.
   Contrast this to the bizarre and ridiculous procedure in Win95 and
   WinNT of rebooting the computer in any of many diverse situations. I
   consider this a bogus "solution" that should have not been tolerated a
   long time ago.
   
   The user is *always* completely isolated from *all* low level device
   details. Concepts such as IRQs, cylinder/head counts, screen sizes,
   memory sizes, etc.-- the user has absolutely no need to be aware of
   any of these concepts to install the device or use the computer, and
   manufacturers and developers (both for drivers and the OS) that
   require any knowledge whatsoever of this arcane minutia for successful
   installation in my opinion have failed a basic goal of creating
   "conscientious hardware/software". Clearly Win95 and Linux both tend
   to fail severely on this demand, and it is a sign of a poorly designed
   OS that does not take into account the key Tao philosophy of
   simplicity and convenience to the user, if that is a design goal
   (which arguably is not with Linux, but that's also a problem).
   
   Obviously to achieve this kind of pervasive plug-and-play, many new
   software and hardware standards need to be devised, which will be
   difficult in a climate that is still often hostile to them. However, a
   standardized object system of Tao can expedite this process. The
   devices can contain Tao objects that interact with the computer. Tao
   can handle the upgrade tasks and logic, much of which is sometimes
   handled by third-party companies today. In Tao, new standards are
   frequently and routinely created with far less resistance and
   reluctance, because conversion between different standards is not
   tricky and intrinsic to the OS.
   
potential difficulties

     * Some may complain that a totally object-oriented OS may be slow,
       or that other ideas here cannot be efficiently implemented. But I
       generally disagree. I think good ingenuity and design decisions
       will actually make the speed of the Tao OS as fast or faster than
       existing systems, because of the overall coherence of the system.
       And again Moore's law is always applicable, such that a more
       complex OS embodying the demanding aspects of Tao will become more
       feasible in the near future. There will be a price to pay for
       every aspect of Tao but in my opinion the end result will be well
       worth it.
     * Open standards will be difficult to achieve with many companies
       thinking that they cannot make money without proprietary systems,
       and the cooperation of many companies that think they compete. But
       it may be that Linux is showing that now even an entire OS can be
       "open" and benefit the entire worldwide computing community while
       supporting companies can still be economically viable.
     * New programming standards and OSes always face heated, almost
       religious opposition at certain stages from entrenched interests
       for ambiguous and arcane reasons. I certainly hope that Tao
       development never takes on the aspects of these notorious "holy
       wars," but if it begins to gain momentum, this would probably be
       inevitable.
     * Many programmers have a hostile attitude toward developing OSes
       that minimize the technical knowledge required to install and use
       them. This attitude is gradually being resolved as a realization
       sets in that there is no net savings of time "in the long run" and
       that programmer laziness can multiply exponentially user
       frustration and time spent debugging problems that could have been
       avoided.
     * Some hardware devices will have to be redesigned to support new
       standards. For example, Win95 requires rebooting partly due to
       hardware card constructions. My opinion is that hardware cards are
       redesigned so often now, and that the overall standard might make
       constant redesigns somewhat less necessary, that this is really a
       minor objection.
     * Some will object to any proposal for a new system, focusing solely
       on spurious elements such as the reputation or background of the
       creator or proponents as the gauge for its validity rather than
       the inherent ideas, invoking the "genetic fallacy". Others may
       object that merely coming up with such an idea does not involve
       any progress toward the goal espoused. Another simple but crude
       objection would be in the form, "it's never been done that way,"
       which of course is exactly the point of Tao.
       
realization of Tao

   Tao will be difficult to realize! Many aspects of its design may seem
   technically unrealistic, infeasible, or even impossible. Yet it is
   clearly a highly desirable OS in theory with aspects that far
   transcend even the best current OSes.
   
   Tao will be opposed by companies that favor a proprietary OS such as
   MS, which is a very powerful impediment and obstacle. However it could
   be favored by those who champion open standards, i.e. the Linux
   community. One tantalizing possibility is harnessing the existing
   Linux code and massive talent force toward "gently massaging" Linux
   code in the direction of Tao over time. Arguably many aspects of Linux
   are already evolving in the direction of Tao anyway.
   
   However, Tao embodies the concept of absolute convenience to the end
   user over all other criteria. Linux is still very much a hacker's OS
   in which knowledge of programming is often required to run it. One
   possibility is a Tao-like interface built on top of Linux.
   
   There is some effort to increase the sophistication of GUIs in Linux,
   and I consider this a noble effort, but not consistent with the nature
   of Tao as enumerated here. Beneath a powerful GUI, Linux is a very
   complex Unix operating system, which is far more difficult to install
   and run than Win95, which itself is very complex. Tao embodies a
   complete reformulation of the concept of an OS starting at the very
   lowest level.
   
   Tao is not merely an open OS but in fact an open computation universe.
   I think its design goals are inherently desirable and practical and
   will eventually be achieved in some form one day not too far in the
   future.
   

- about the author

  V.Z.N. is a software engineer and web designer/programmer who 
  founded the "theory-edge" mailing list for the discussion of
  cutting-edge mathematical advances,

    http://www8.pair.com/mnajtiv/edge/edge.html

  and contributes intermittently to the "Mad Genius Research Lab":

    http://www8.pair.com/mnajtiv/

- references/resources

  The key Linux site with information and archives:

    http://www.linux.org

  Uniform Driver Interface (UDI) - new driver standard being developed
  for Unixes and potentially other PC OSes and supported by many
  major vendors

    http://www.sco.com/UDI/

  Universal Serial Bus (USB) - emerging standard with plug-and-play 
  connectivity for many peripheral devices, also supported by major
  vendors

    http://www.usb.org

  Tao of Programming - short humorous paperback with Taoist wisdom as 
  applied to programming

    http://www.amazon.com/exec/obidos/ASIN/0931137071/madgeniusresearc/

  Recent Microsoft memos against Linux:

    1st memo leak, Wired/C.Oakes

      http://www.wired.com/news/news/technology/story/15990.html

    2nd memo leak, Wired/C.Oakes

      http://www.wired.com/news/news/technology/story/16084.html

    Eric Raymond's page with many links to press coverage and commentary

      http://www.opensource.org/halloween.html
---
#  distributed via nettime-l : no commercial use without permission
#  <nettime> is a closed moderated mailinglist for net criticism,
#  collaborative text filtering and cultural politics of the nets
#  more info: majordomo@desk.nl and "info nettime-l" in the msg body
#  URL: http://www.desk.nl/~nettime/  contact: nettime-owner@desk.nl