Search

This paper presents the Live Distributed Objects platform that makes it possible to combine hosted content with P2P protocols in a single object-oriented framework.

Ideally, according to the author, a real-time distributed programming method should be based on a general high-level style that could be easily accommodated by application programmers using C++ and Java. If such a method were to exist, these programmers could specify the interactions among distributed components and the timing requirements of various actions without expending much effort. Facilitating high-level, high precision, real-time object programming by establishing some form of language tools has consequently become a subject of great interest to the embedded systems community. This article focuses on application programming interfaces (APIs) that take the form of C++ and Java class libraries and support high-level, high precision, real-time object programming without requiring new language translators. These APIs wrap the services of the real-time object execution engines, which consist of hardware, node OSs, and middleware; they enable convenient high-level programming almost to the extent that a new real-time object language can. The author explains the API's fundamental features, how they interact among real-time objects, and how multicast channels and real-time multicast APIs contribute.

In the late 1980s, software designers introduced middleware platforms to support distributed computing systems. Since then, the rapid evolution of technology has caused an explosion of distributed-processing requirements. Application developers now routinely expect to support multimedia systems and mobile users and computers. Timely response to asynchronous events is crucial to such applications, but current platforms do not adequately meet this need. Another need of existing and emerging applications is the secure interoperability of independent services in large-scale, widely distributed systems. Information systems serving organizations such as universities, hospitals, and government agencies require cross-domain interaction. To meet the needs of these applications, Cambridge University researchers developed middleware extensions that provide a flexible, scalable approach to distributed-application development. This article details the extensions they developed, explaining their distributed software approach and the support it has provided for emerging applications.

Software development that assembles prefabricated components faces different challenges than development that starts from scratch with programming constructs. For example, it is often impossible, or at least not economical, to change the source code of components from independent suppliers. But how do you assemble the components without doing that? How do you link them with the services they require? And how do you build a distributed system and ensure system-wide security, performance, and fault tolerance without breaking the system? These are just some of the issues that designers face when using prefabricated components in a distributed system. Object-oriented distributed systems pose some specific problems. Objects communicate by invoking methods on other objects, so they must maintain static information, such as class or interface names. Thus, objects may have strong dependencies, not only on each other but also on outside services. Distributed systems built from prefabricated components require an assembly approach that separates architecture, component, and distributed object infra-structure concerns.

The integration of distributed computing and the object model leads to distributed object computing, in which objects rather than processes are distributed across multiple computers. A well-established standard for distributed object computing is the Common Object Request Broker Architecture (CORBA). Previously, you would have had to create-and enable the application to use-the components that provide such additional capabilities. Using these components requires specialized knowledge and understanding of problems outside the application domain. With the advent of interceptors-non-application components that can alter application behavior-you can enhance CORBA applications at runtime with components whose operation is transparent to both the application and the CORBA framework, modifying application behavior without modifying the application or the CORBA framework.

For digital libraries to thrive, the providers of information processing services must be able to evolve their systems autonomously. However, as the complexity of their offerings increases, software tools more sophisticated than existing Web facilities are needed. Distributed object technology may be the answer. The availability of high-volume, increasingly sophisticated information is making the need for metadata facilities more urgent. Traditional, library-based approaches break down when used in an advanced digital library. More modular mechanisms are needed, and the CORBA system is one approach. Digital libraries are affected at a deep technical level by the widely differing user traditions of Web users and library patrons. The challenge and opportunity of digital libraries will be the synthesis of these traditions. The authors set out to create a technical infrastructure to support the construction of digital libraries. In their view, a digital library comprises widely distributed resources that can be maintained autonomously by different organizations and will not require adherence to uniform interfaces.

Information repositories are just one of many services tomorrow's digital libraries might offer. Other services include automated news summarization, trend analysis across news repositories, and copyright-related facilities. This distributed collection of services has the potential to be enormously helpful in performing information-intensive tasks. It could also turn such tasks into confusing, frustrating annoyances by forcing programmers and users to learn many interfaces and by confronting users with the bewildering details of fee-based services that were previously only accessible to professional librarians. The Stanford Digital Library project is addressing the problem of interoperability, which is particularly important because standardization efforts are lagging behind the development of digital library services. The authors used CORBA to implement information-access and payment protocols. These protocols provide the interface uniformity necessary for interoperability, while leaving implementers a large amount of leeway to optimize performance and to provide choices in service performance profiles. The authors' initial experience indicates that a distributed object framework does give clients and servers the flexibility to manage their communication and processing resources effectively.

Most existing distributed systems are structured as statically compiled processes communicating with each other via messages. The system's intelligence is embodied in the processes, while the messages contain simple, passive pieces of information. This is referred to as the communicating objects paradigm. In the autonomous objects paradigm, a message has its own identity and behavior. It decides at runtime where it wants to propagate and what tasks to perform there; the nodes become simply generic interpreters that enable messages to navigate and compute. In this scenario, an application's intelligence is embodied in and carried by messages as they propagate through the network. The autonomous objects paradigm is more flexible than the communicating objects paradigm because it allows developers to change the program's behavior after it has started to run. We based our system, MESSENGERS, on autonomous objects, and intended it for the composition and coordination of concurrent activities in a distributed environment. It combines powerful navigational capabilities found in other autonomous objects based systems with efficient dynamic linking mechanisms supported by some new programming languages, like Java.

Heralded by many as a promising solution to software complexity, object technology is coming into its own. This article explores some recent trends, including distributed objects, object-oriented databases (OODBs), parallel computing, software testing and theoretical foundations. >

The basic properties of object orientation and their application to heterogeneous, autonomous, and distributed system to increase interoperability ar examined. It is argued that object-oriented distributed computing is a natural step forward from client-server systems. To support this claim, the differing levels of object-oriented support already found in commercially available distributed systems-in particular, the distributed computing environment of the open software foundation and the Cronus system of Bolt Beranek, Newman (BBN)-are discussed. Emerging object-oriented systems and standards are described, focusing on the convergence toward a least-common-denominator approach to object-oriented distributed computing embodied by the object management group's common object request broker architecture. >

The authors discuss a paradigm for structuring distributed operating systems, the potential and implications this paradigm has for users, and research directions for the future. They describe Clouds, a general-purpose operating system for distributed environments. It is based on an object-thread model adapted from object-oriented programming. >

The Galaxy research project, which is attempting to design, implement, and use a distributed computing environment, based on the idea of making gradual improvements by learning from existing systems and trying to overcome their limitations, is described. The design goals and novel aspects of the project are outlined, and the Galaxy system architecture is described. Galaxy's object naming and locating mechanisms, interprocess communication, and computation model are discussed. >

A hierarchy of questions and answers about the features of distributed computing systems (DCSs) leads to an overall system description that facilitates system comparisons. The taxonomy uses terminology from an object-based model of DCSs and emphasizes the runtime services the DCS provides to applications. It is based on the division of DCS issues into three distinct categories: threads object properties and separation. The threads subtree explores the creation, the number, and the control of threads in the DCS. The object properties subtree explores DCS features that are defined for objects in isolation. The separation subtree explores issues that arise because there are many objects in the DCS. To describe a specific DCS, a taxonomy user traces paths through the hierarchy. >

The Common Object Request Broker Architecture (CORBA) from the Object Management Group has been the most influential standard in the OO world and one of the principal steps in the industry's move to component-based development. The author gives us a preview of CORBA 3, the next step in the technology.

While the field of object-oriented real-time computing (ORC) is young, it is growing quickly because it offers such a wide range of applicability, from complex real-time systems to the next generation of computing and communication devices. The paper presents significant advances in both the art and science of ORC technology.