The emergence of networked lightweight portable computing devices can potentially enable accessibility to a vast array of remote applications and data. In order to cope with shortage of local resources such as memory, CPU and bandwidth, such applications are typically designed as a thin-client thick-server applications. However, another highly desirable yet conflicting requirement is to support disconnected operation, due to the low quality and high cost of on-line connectivity. We present a novel programming model and a runtime infrastructure that addresses these requirements by automatically reconfiguring the application to operate in disconnected mode of operation, when voluntary disconnection is requested, and automatically resorting to normal distributed operation, upon reconnection. The programming model enables developers to design disconnected aware applications by providing a set of component reference annotations with special disconnection and reconnection semantics. Using these annotations, designers can identify critical components, priorities, dependencies, local component alternatives with reduced functionality, and state merging policies. The runtime infrastructures carries out dis- and re-connection semantics using component mobility and dynamic application layout. The disconnected operation framework, FarGo-DA, is an extension of FarGo, a mobile component framework for distributed applications.

We present a novel multi-threading programming model for frameworks that combine distributed and mobile objects, and corresponding compile-time and runtime support that realize this model. Key contributions include an automatic thread partitioning scheme that provides the abstraction of logical distributed threads, while permitting arbitrary migration of components which contain parts of the distributed threads in themselves. The distributed mobile multi-threading model is transparent to the application programmer, who uses normal syntax to encode multi-threading applications, but can lower the overhead associated with the model by specifying the migratable components. The multi-threaded model was implemented in FarGo, a Java-based middleware for dynamically-relocatable distributed applications.

Abstract Component mobility is an important enabling technology for the design of wide area pervasive applications, but it introduces new challenges in the critical aspect of access control. In particular, when mobility is used for dynamic relocation of distributed components, access from both remote and local mobile components needs to be uniformly controlled. The dynamic determination of execution location, possibly crossing multiple administrative authorities, requires dynamic establishment and enforcement of access control. The deployment over widely heterogeneous hosts and devices requires integration of access control with dynamic probing of resource availability so as to influence the relocation process. This paper presents a model for dynamic specification and enforcement of access control in the context of dynamically relocatable components, and an implementation in the Java‐basedFarGoframework. The specification follows a negotiation‐based protocol that enables dynamic matching of available and required resources by providers and consumers, respectively. Enforcement is provided through a capability‐based secure component reference architecture, which uniformly applies to both local and remote references, and through instance‐level, as opposed to type‐level (supported in Java), access control. Finally, access control is integrated into the programming model in a non‐intrusive fashion, by separating the encoding of access control from the encoding of the logic of the application. Copyright © 2001 John Wiley & Sons, Ltd.

Global network connectivity has enabled accessibility to a wide range of geographically dispersed services. By encapsulating and representing such services as components, they can be effectively composed into sophisticated wide-area applications that otherwise would be much harder to build. This paper presents a component model for encapsulating such services and a composition model for assembling encapsulated and possibly active services into new applications, while preserving the administrative autonomy of sites and individual components. The component model is dynamically and self-adaptable, allowing for the adjustment of structure and behavior of autonomous components to changing or previously unknown contexts in which they need to operate. The composition model includes a set of protocols that enable us to dynamically deploy live components into remote sites and to dynamically reconfigure the deployment scheme through reflective stubs termed Ambassadors. The component and composition models have been fully implemented in Hadas, which also includes a host of tools for the creation, deployment, and composition of autonomous components.

Dynamic application layout is the capability to move the components of a distributed program among different hosts during the execution of the application. This capability is essential for large-scale applications since it allows to adapt them to changes in resource availability which are common in wide-area environments. The FarGo system introduces a model for programming the layout of distributed applications separately from their basic logic, by attaching relocation semantics to inter-component references, and by using a built-in monitoring support for making relocation decisions. Dynamic layout policies are encoded within the application using a special API or externally using a high-level scripting language. This paper presents the design of the runtime environment that realizes the model.

No abstract available.

The design of efficient and reliable distributed applications that operate in large networks, over links with varying capacities and loads, demands new programming abstractions and mechanisms.The conventional static design-time determination of local-remote relationships between components implies that (dynamic) environmental changes are hard if not impossible to address without reengineering.This paper presents a novel programming model that is centered around the concept of 'Ldynamic application layout", which permits the manipulation of component location at runtime.This leads to a clean separation between the programming of the application's logic and the programming of the layout, which can also be performed externally at runtime.The main abstraction vehicle for layout programming is a reflective inter-component reference, which embodies co-and re-location semantics.We describe an extensible set of reference types that drive and constrain the mapping of components to hosts, and show how this model elevates application's performance and reliability yet requires minimal changes in programming the application's logic.The model was realized in the FarGo system, whose design and implementation in Java are presented, along with an event-based scripting language aid corresponding event-monitoring service for managing the layout of FarGo applications.

The explosive growth in global networking infrastructures has created the opportunity to construct systems involving large number of independent and widely-distributed computational components. Administrative and operational autonomy considerations imply that the actual establishment of agreements regarding all aspects of component interaction must be explicitly declared and effectively formed. Moreover, since agreements may evolve over time, their representation needs to be highly tailorable. Design autonomy considerations imply the need to interoperate between pre-existing components, yet not enforce a fixed interoperability standard. The HADAS system addresses both concerns by providing a model and a corresponding programmable interface to component interoperability. Specifically, it provides an integration framework in which components "live", a peer-based configuration model for forming agreements and interconnections between components, and a coordination language for explicitly programming the actual desired distributed computation using these components. The framework rests on an underlying reflective object model that supports mutability and mobility, and an infrastructure that provides object interconnectivity, security and persistence. HADAS is fully implemented in Java and comes with a full programming environment for developing and executing network-centric applications.

Mobile software objects are autonomous computational entities that travel in large-scale and widely-distributed heterogeneous systems, and whose functionality can be attached to diverse computing environments. An object model that supports mobile objects should have special characteristics such as mutability of object's structure and semantics to facilitate adjustment to different environments, self-containment of objects to allow their migration as autonomous units, and extensive support for security. We discuss the requirements and design guidelines of such a model, and present MROM, a reflective model based on these guidelines. We also discuss MROM's implementation and present a component interoperability framework that was built on top of it, as an example application of the model.

Mobile software objects are computational entities that travel in large-scale and widely-distributed heterogeneous systems, and whose functionality can be attached to diverse computing environments. When employed over decentralized sites with operational and administrative autonomy, support for mobility raises difficult issues with respect to object management services. In particular it impacts persistence, reference handling, object naming, and requires extensive support for security. This paper discusses the requirements from an object management system that incorporates mobile, autonomous and reflective objects and presents the design and implementation of the Mobile Object Manager (MOM) which fulfills these requirements.

The explosive growth in global networking infrastructures has created the opportunity to construct systems involving large number of independent and widely-distributed computational components. Administrative and operational autonomy considerations imply that the actual establishment of agreements regarding all aspects of component interaction must be explicitly declared and effectively formed. Moreover, since agreements may evolve over time, their representation needs to be highly tailorable. Design autonomy considerations imply the need to interoperate between pre-existing components, yet not enforce a fixed interoperability standard. The HADAS system addresses both concerns by providing a model and a corresponding programmable interface to component interoperability. Specifically, it provides an integration framework in which components "live", a peer-based configuration model for forming agreements and interconnections between components, and a coordination language for explicitly programming the actual desired distributed computation using these components. The framework rests on an underlying reflective object model that supports mutability and mobility, and an infrastructure that provides object interconnectivity, security and persistence. HADAS is fully implemented in Java and comes with a full programming environment for developing and executing network-centric applications.