Paper Summary: W. J. Bolosky, R. P. Draves, R. P. Fitzgerald, C. W. Fraser, M. B. Jones, T. B. Knoblock and R. Rashid “Operating System Directions for the Next Millenium“, Proc. of the 6th Workshop on Hot Topics in Operating Systems, 1997

The authors of this position paper talk about the expectations they have of a new kind of “distributed” operating system for the future. They argue that advances in computer engineering have come to a point where one can start planning for such a system. They provide goals for such an operating system and the principles it should abide by. The broad objective is to raise the level of abstraction further so that users and programmers can simply focus on building solutions that do not need to consider hardware or downtime related concerns. The authors present their expectations of this distributed operating system using the Millenium project at Microsoft as an example.

The minimum requirements (goals) of such an operating system are:

• Seamless distribution. The users should not have to care about where and how computations are taking place in the system. There should be no difference between using a local machine vs using any other device part of the system.
• Worldwide scalability. With the data and computations of a system being partitioned and spread-out, logically there should still be only one system regardless.
• Fault-tolerance. The system and its applications should not be affected by resource downtimes.
• Self-tuning. The system should be able to “reason” about itself. It must make intelligent decisions about resource placement, data replication and computation without user interference
• Self-configuration. New machines entering the system should not require user interference for configuration.
• Security. Despite the appearance of a universal system, security of user data should still be maintained.
• Resource controls. Users should be able to, not have to control the resources being used.

To achieve these goals, the authors propose a system built on the following principles:

• Aggressive abstraction. Issues like data placement for load balancing and security, fault tolerance and more should be handled by the system and require no user input.
• Storage-irrelevance. Information should be accessible until it is not needed. No storage hierarchies.
• Location-irrelevance. In accordance with the seamless distribution goal, the location of data and computation should not matter.
• Just-in-time binding. Unnecessary bindings interfering with distribution and fault tolerance should be avoided. Access to a resource should be able to be redirected. Ex. domain names to IP address mappings in a DNS server.
• Introspection. The system must be able to optimize and perform load balancing and configuring decisions on its own.

The authors argue that the technological trends of their time are making this progress in operating system distribution inevitable. They argue that advances in computer science have almost always raised the level of abstraction, making the end users’ experience less complicated in each step. One example is the evolution of high level languages like C++ from assembly language. They cite the works of their peers in this and related areas - such as distributed file systems, garbage collection, JIT compilers and virtualization. They conclude by highlighting the behaviour of such a system in a range of scenarios to illustrate the advantages provided by raised abstraction.

As with every vision, several challenges arise in real-world implementation of the ideas presented in this paper. Scalability is a major concern, as a seamless, worldwide distributed system requires careful resource allocation and network optimization. Aggressive abstraction could lead to unauthorized access and compliance challenges, leading to security and privacy issues. The authors’ emphasis on self-tuning and self-configuration is difficult to achieve reliably, as fully autonomous resource management introduces trade-offs that may still require user input. Additionally, the idea that users “should be able to, not have to” control resources assumes all optimizations can be automated, whereas manual control is often needed for cost, performance, and compliance. Despite these challenges, many of the paper’s ideas have influenced modern cloud computing—concepts like seamless scalability, fault tolerance, and just-in-time resource allocation are widely used today, though they still require explicit configurations rather than achieving the fully abstracted and automated vision the authors propose. Nearly 30 years after this paper was published, many of its ideas are still relevant and wonderfully encapsulate the vision of a distributed world of computing.