Abstract not found

. The notion of "time" plays an important role when coordinating

Experience has shown us that object-oriented technology alone is not enough to guarantee that the systems we develop will be flexible and adaptable. Even "welldesigned " object-oriented software may be difficult to understand and adapt to new requirements. We propose a conceptual framework that will help yield more flexible object-oriented systems by encouraging explicit separation of computational and compositional elements. We distinguish between components that adhere to an architectural style, scripts that specify compositions, and glue that may be needed to adapt components' interfaces and contracts. We also discuss a prototype of an experimental composition language called PICCOLA that attempts to combine proven ideas from scripting languages, coordination models and languages, glue techniques, and architectural specification. 1 Introduction The last decade has shown that object-oriented technology alone is not enough to cope with the rapidly changing requirements of ...

Isolating computation and communication concerns into separate pure computation and pure coordination modules enhances modularity, understandability, and reusability of parallel and/or distributed software. MANIFOLD is a pure coordination language that encourages this separation. We use real, concrete, running MANIFOLD programs to demonstrate the concept of pure coordination modules and the advantage of their reuse in applications of different nature. Performance results for the examples presented in this paper show that the overhead of using MANIFOLD to achieve this enhanced modularity and reusability is in practice small, compared to the more conventional paradigms for the design and programming of parallel and distributed software. Keywords: coordination, reusability, parallism, distributed computation, performance measurements. 1 Introduction Some of the shortcomings of the common approaches to the design and development of parallel and distributed applications stem from the fun...

Although object-oriented languages are well-suited to implement software components, they fail to shine in the construction of component-based applications, largely because object-oriented design tends to obscure a component-based architecture. We propose to tackle this problem by clearly separating component implementation and composition. In particular, we claim that application development is best supported by consciously applying the paradigm "Applications = Components + Scripts." In this chapter, we propose PICCOLA, a small "composition language" that embodies this paradigm. PICCOLA models components and compositional abstractions by means of communicating concurrent agents. Flexibility, extensibility, and robustness are obtained by modeling both interfaces of components and the contexts they live in by "forms", a special notion of extensible records. Using a concrete example, we illustrate how PICCOLA offers explicit support for viewing applications as compositions of components and show that separating components from their composition improves maintainability.

Messengers are autonomous objects, each capable of navigating through the underlying network and performing various tasks at each node. Messengers applications are written using navigational commands rather than the send/receive primitives of conventional messagepassing approaches. In this paper we contrast the two programming styles. From a software engineering viewpoint, the navigational style generally results in a smaller semantic gap between abstract algorithm descriptions and their actual implementations, which makes programs easier to construct, understand, and maintain. In terms of performance, Messengers programs are highly competitive with message-passing. We demonstrate these advantages using two concrete applications programmed using Messengers and PVM. 1 Introduction The objective of this paper is to contrast two different styles of programming in distributed systems. The first, which is by far the most prevalent among all distributed programming languages, is based on ...

Coordination languages are a new class of parallel programming languages which manage the interactions among concurrent programs. Basically, coordination is achieved either by manipulating data values shared among all active processes or by dynamically evolving the interconnections among the processes as a consequence of observations of their state changes. The latter, also called control-driven coordination, is supported by MANIFOLD. We present the formal semantics of a kernel of MANIFOLD, based on a two-level transition system model: the first level is used to specify the ideal behavior of each single component in a MANIFOLD system, whereas the second level captures their interactions. Although we apply our twolevel model in this paper to define the semantics of a control-oriented coordination language, this approach is useful for the formal studies of other coordination models and languages as well.

this paper, we first describe the Visifold project and an example of its use. In conclusion, we compare Visifold to some other existing tools. 2 Goals of the Visifold project

Coordination models and languages represent a new approach to design and development of concurrent systems. The interest in coordination has intensified in the last few years, as evidenced by the increasing number of conferences, tracks, and papers devoted to this topic, and by the recent upsurge of research activity in the theoretical computer science community in this field. The field is relatively new, and while many coordination models and languages form a tight cluster of very similar variants, some others are drastically different and they appear to have nothing in common with each other. All this makes it difficult for the uninitiated to discern the underlying similarities of various approaches to coordination. This paper is an "easy reader" introduction to coordination models and languages, their common aims and purpose, their relevance, and their place in the computing arena. The work on coordination at CWI is presented here as a specific example. 1 Introduction The size, spe...

. The fact that so many different kinds of coordination models and languages have been proposed suggests that no one single approach will be the best for all coordination problems. Different coordination styles exhibiting different properties may be more suitable for some problems than others. Like other architectural styles, coordination styles can be expressed in terms of components, connectors and composition rules. We propose an approach in which coordination styles are expressed as "component algebras": components of various sorts can be combined using operators that realize their coordination, yielding other sorts of components. We show how several coordination styles can be defined and applied using Piccola, a small language for composing software components. We furthermore show how glue abstractions can be used to bridge coordination styles when more than one style is needed for a single application. 1 Introduction We are rapidly moving towards a world of spontaneo...