Abstract. This paper presents a general multi-agent architecture for the management of businessprocesses,and an agent design that has been implemented within such a system. The autonomy of the agents involved in the system is considered paramount. Therefore, for agents to agree on the distribution of problem solving effort within the system they must negotiate. The knowledge sharing and negotiation functions of such an agent are focused on in this paper. 1

This paper presents an implementation of the distributed programming features of Ads 95 within the GNAT system. The work we describe is the result of an international colla- boration whose gnal is to produce a high level environment for distributed system programming. This paper focuses on issues of interprocessor communication, since this is the core element of our software architecture. We describe the design and implementation of GARLIC, an interface between the network and the application. GARLIC is an extension of the predefined interface specified by $ystem. RPC

Unlike in traditional approaches to parallel or distributed processing where normally well structured problems are implemented completely in some programming environment we are faced with the problem of integrating existing heterogeneous software systems. Furthermore, pattern analysis stresses special aspects of communication capabilities. Therefore, we propose a new communication framework dedicated to heterogeneous pattern analysis systems that handles typed structured data, enables completely symmetric interaction, and provides various call semantics. A first prototype evaluating some of the concepts in practical situations is presented.

Synchronous groupware systems allow physically separated users to interact with one another and with shared computational objects in real time. Such systems are problematic to build since their user interfaces must support multiple, concurrent users, and both their application logic and their user interfaces must be distributed across multiple platforms. This survey explores the range of software architectures that have been proposed to solve this problem. The presentation includes three distinct architectural views: reference models, which divide complete systems into named functional elements and specify data flow between those elements; architectural styles, which prescribe component and connector types and their allowed patterns of interaction; and distribution architectures, which represent the distribution of system functionality across connected computing platforms. The distribution architectures are presented using a new descriptive framework called Interlace. The architectural presentation is complemented by a brief overview of consistency maintenance

One of the problems that we experience with today's most widespread Internet Information Systems (like WWW or Gopher) is the lack of support for maintaining referential integrity. Whenever a resource is (re)moved, dangling references from other resources may occur. This paper presents a scalable architecture for automatic maintenance of referential integrity in large (thousands of servers) distributed information systems. A central feature of the proposed architecture is the p-flood algorithm, which is a scalable, robust, prioritizable, probabilistic server-server protocol for efficient distribution of update information to a large collection of servers. The p-flood algorithm is now implemented in the Hyper-G system, but may in principle also be implemented as an add-on for existing WWW and Gopher servers.

Grid systems and technologies have evolved over nearly a decade; yet, there is still no widely accepted definition for Grids. In particular, the essential attributes that distinguish Grids from other distributed computing environments have not been articulated. Most approaches to definition adopt a static view and consider only the properties and components of, or the applications supported by, Grids. The definition proposed in this paper is based on the runtime semantics of distributed systems. Rather than attempt to simply compare static characteristics of Grids and other distributed computing environments, this paper analyzes operational differences, from the viewpoint of an application executing in both environments. Our definition is expressed formally as an Abstract State Machine that facilitates the analysis of existing Grid systems or the design of new ones with rigor and precision. This new, semantical approach proposes an alternative to the currently accepted models for determining whether or not a distributed system is a Grid.

This dissertation presents an architectural model and a reference implementation for push systems. Push systems reverse the pull-based communication paradigm on the world-wide web and in most other distributed systems to support easier information dissemination and discovery for users. The pull model requires the user to issue a request whenever information is needed, whereas push systems support asynchronous information distribution: Whenever information of the user's choice becomes available, it gets distributed. In the push communication model, an information producer announces the availability of certain types of information, an interested consumer subscribes to this information, and the producer periodically publishes the information (pushes it to the consumer). This simplifies the discovery of information and provides timely information dissemination but introduces complex problems that challenge the widespread deployment of push systems: scalability to large numbers of users in terms of network bandwidth, timely notification of information availability, authenticity and integrity of information, and support for payment methods and business models. Current systems fall short in addressing these issues. Most available push systems actually use a pull-based distribution approach where clients check for new information at configurable intervals; frequently scalability is limited, many systems lack services to provide information authenticity and integrity, and moreover, the important issue of payment models is not adequately addressed by any existing system.

CORBA is increasingly popular as distributed object computing middleware for systems with stringent quality of service (QoS) requirements, including scalability and dependability. One way to improve the scalability and dependability of CORBA-based applications is to balance system processing load among multiple server hosts. Load balancing can help improve system scalability by ensuring that client application requests are distributed and processed equitably across a group of servers. Likewise, it can help improve system dependability by adapting dynamically to system configuration changes that arise from hardware or software failures. This paper presents three contributions to research on CORBA-based load balancing. First, we describe deficiencies with common load-balancing techniques, such as introducing unnecessary overhead or not adapting dynamically to changing load conditions. Second, we present a novel adaptive load balancing service that can be implemented efficiently using standard CORBA features. Finally, we present the results of benchmark experiments that evaluate the pros and cons of different load balancing strategies empirically by measuring the overhead of each strategy and showing how well each strategy balances system load. Keywords: Middleware, patterns, CORBA, load balancing. 1

We propose an object-oriented approach to the development of distributed applications emphasizing separation of concerns. Our approach combines the needs of transparency, encapsulation of distribution issues, and support for non-traditional models, where cooperation and sharing are desired. The development process is constructive, thus allowing partial verification of results. We recognize seven concerns: fragmentation, replication, naming, concurrency, failure, configuration, and communication. Each concern is perceived in three levels of abstraction: model, policy and mechanism. We also propose an integration process centered on development stages. Both concerns and stage perspectives are part of an integrated and flexible development process. 1 Introduction Sequential applications in a centralized systemuse traditional models where activities and the data they manipulate are isolated. In distributed systems activities and data are intrinsically distributed and shared. Distribution ...

Distributed language features form an important part of modern objectoriented programming. In spite of their prominence in today's computing environments, the formal semantics of distributed primitives for object-oriented languages have not been well-understood, in contrast to their sequential part. This makes it difficult to perform rigorous analysis of their behaviour and develop formally founded safety methodologies. As a first step to rectify this situation, we present an operational semantics and typing system for a Java-like core language with primitives for distribution. The language captures the crucial but often hidden concerns involved in distributed objects, including object serialisation, dynamic class downloading and remote method invocation. We propose several invariant properties that describe important correctness conditions for distributed runtime behaviour. These invariants also play a fundamental role in establishing type safety, and help bound the design space for extensions to the language. The semantics of the language are constructed modularly, allowing straightforward extension, and this is exploited by adding primitives for direct code distribution to the language: thunk passing. Typing rules for the new primitives are developed using the invariants as an analysis tool, with type soundness ensuring that their inclusion does not violate safety guarantees.