Abstract
Object-oriented distributed programming is often misunderstood as merely wrapping existing distributed systems in object-oriented "dressing" or attempting to make remote calls indistinguishable from local ones. This paper argues that true object-oriented distributed programming involves identifying and classifying the fundamental abstractions of distributed computing—such as failure detection and consensus—and treating them as first-class objects. By moving away from the "myth of transparency," researchers can build more robust and modular distributed operating systems.
Introduction: The Allure of Acronyms
In the late 1990s, the landscape of distributed computing was dominated by a suite of "sexy" acronyms: CORBA, DCOM, and RMI. These technologies promised a world of "distributed objects" where the complexities of the network were hidden behind familiar object-oriented interfaces. The prevailing marketing wisdom of the era suggested that if a customer didn't understand an acronym, using it more frequently would establish authority. However, beneath this veneer of sophistication lay a fundamental misunderstanding of what it means to program across a network.
Rachid Guerraoui’s seminal position paper challenges the industry's obsession with "distribution transparency"—the idea that a remote call should look and behave exactly like a local function call. He argues that this pursuit is not only futile but dangerous, leading to fragile systems that fail to account for the inherent physics of distributed environments.
The Problem: The Myth of Transparency
The core issue with early distributed object frameworks was their attempt to provide "OO dressing" for monolithic toolkits. This approach ignored three harsh realities that distinguish distributed systems from local ones:
- Latency: Remote calls are orders of magnitude slower than local memory access. Hiding this difference leads to performance bottlenecks that are difficult to diagnose.
- Partial Failure: In a local program, a memory fault typically crashes the entire process. In a distributed system, one node might fail while others continue, leaving the system in an ambiguous state. A transparent interface provides no mechanism to handle this partiality.
- Concurrency and Unreliability: Messages in a network can be lost, delayed, or reordered. Local programming models are ill-equipped to handle the non-determinism of the wire.
By attempting to make the network invisible, developers lost the ability to manage these critical factors, resulting in systems that were modular in name only.
A New Perspective: Distribution as the Application Domain
Guerraoui proposes a radical shift in how we apply object-oriented principles. Instead of using OO to build a distributed application (like a bank or a library), we should use OO to model the mechanisms of distribution itself.
In this view, the "objects" are not just business logic components, but the fundamental building blocks of distributed systems: messages, processes, and failure detectors. By treating these as first-class objects, we can leverage the true strengths of the OO paradigm—encapsulation, inheritance, and polymorphism—to build flexible and reusable distributed protocols.
The "Hollywood Principle" for Distribution
A key insight in this framework is the "Hollywood Principle": Don't call us, we'll call you. Rather than a library providing a rigid, monolithic Remote Procedure Call (RPC) mechanism, it should provide fine-grained abstractions that the programmer can customize. For example, a developer should be able to define exactly how a call handles a timeout or a retry by extending a base class, rather than being stuck with a hard-coded policy inside a "transparent" wrapper.
Concrete Abstractions: First-Class Failure Detectors
The paper’s most compelling example of this approach is the treatment of failure detection. In traditional systems, timeouts are often buried deep within the communication stack. Guerraoui suggests treating a FailureDetector as an abstract class.
- A
PushFailureDetectormight use heartbeats. - A
PullFailureDetectormight use polling. - A
DualFailureDetectorcould combine both through inheritance.
By making the failure detector an object, the system becomes modular. A consensus protocol can be written to interact with a generic FailureDetector interface, allowing the underlying detection mechanism to be swapped out or improved without rewriting the entire protocol.
Conclusion: A Roadmap for Research
The transition from "distributed objects" to "object-oriented distributed programming" represents a shift from hiding complexity to managing it. While this approach introduces a higher degree of complexity for the programmer—requiring them to handle distribution explicitly—it yields systems that are significantly more robust and extensible.
The primary challenge remaining for the research community is the identification and classification of these basic abstractions. Defining a standard library of distributed components (agreement, multicast, failure detection) is the necessary next step toward a true distributed operating system.
Summary updated