Many would argue that future breakthroughs in software productivity will depend on our ability to combine existing pieces of software to produce new applications. An important step towards this goal is the development of new techniques to detect and cope with mismatches in the assembled parts. Some problems of composition are due to low-level issues of interoperability, such as mismatches in programming languages or database schemas. However, in this paper we highlight a different, and in manywaysmore pervasive, class of problem: architectural mismatch. Specifically, we use our experience in building a family of software design environments from existing parts to illustrate a variety of types of mismatch that center around the assumptions a reusable part makes about the structure of the application in which is to appear. Based on this experience we show how an architectural view of the mismatch problem exposes some fundamental, thorny problems for software composition and suggests poss...

As software systems become more complex, the overall system structure---or software architecture---becomes a central design problem. A system's architecture provides a model of the system that suppresses implementation detail, allowing the architect to concentrate on the analyses and decisions that are most crucial to structuring the system to satisfy its requirements. Unfortunately, current representations of software architecture are informal and ad hoc. While architectural concepts are often embodied in infrastructure to support specific architectural styles and in the initial conceptualization of a system configuration, the lack of an explicit, independently-characterized architecture or architectural style significantly limits the benefits of software architectural design in current practice. In this dissertation, I show that an Architecture Description Language based on a formal, abstract model of system behavior can provide a practical means of describing and analyzing softwar...

As the design of software architectures emerges as a discipline within software engineering, it will become increasingly important to support architectural description and analysis with tools and environments. In this paper we describe a system for developing architectural design environments that exploit architectural styles to guide software architects in producing specific systems. The primary contributions of this research are: (a) a generic object model for representing architectural designs; (b) the characterization of architectural styles as specializations of this object model; and (c) a toolkit for creating an open architectural design environment from a description of a specific architectural style. We use our experience in implementing these concepts to illustrate how style-oriented architectural design raises new challenges for software support environments.

this paper I briefly outline and compare three approaches to providing such a basis. 2. Basic Properties

This report describes PVMGraph, a graphical programming environment to support the design and implementation of parallel applications. PVMGraph offers a simple but yet expressive graphical representation for the components of a parallel application and assists the user in manipulating these components. PVMGraph also allows the evaluation of the application design and implementation. Although, PVMGraph graphical representation is general, its semantics is directed to PVM applications. This means that each graphical object is associated with a PVM/C segment of code. The description of PVMGraph is divided into two main parts: the design graphical representation (external view) and the implementation (textual) representation (internal view). The external view consists of an abstract view of components of a parallel application design, that is; the processes, their interfaces (behavioural description) and their interactions which are represented graphically. The internal view consists of th...

Parallel and distributed systems engineers are always looking for a way to speed-up their programs. They sometimes forget that well-structured programs are more flexible, and therefore easier to modify or restructure in order to improve performance or to map onto a particular architecture.

Software system builders are increasingly recognizing the importance of exploiting design knowledge in the engineering of new systems. One way to do this is to define an architectural style for a collection of related systems. The style determines a coherent vocabulary of system design elements and rules for their composition. By structuring the design space for a family of related systems a style can, in principle, drastically simplify the process of building a system, reduce costs of implementation through reusable infrastructure, and improve system integrity through style-specific analyses and checks. In this article we describe one way to realize these benefits. Specifically, we describe Aesop, an environment for architectural design that supports the definition and use of architectural styles. Aesop adopts an object-oriented approach to the representation of both styles and designs. It also provides a repository of reusable architectural design fragments. In this way it...

Most of the methods proposed for the development of high-performance systems (HPS) do not balance the software and performance engineering activities. This paper presents a method for the development of HPS which promotes the production of well-engineered, highly parallel programs the design decisions of which are also guided by their impact on performance. The method follows strong software engineering principles such as modularity, and the use of formal methods to support verification and transformation. From the point of view of performance engineering the method supports the use of prototypes for performance prediction at early stages of the development. Much of the method is language and hardware independent, and the paper illustrates the application of the method to the development of occam programs running on transputers. 1

Parallel programming is not difficult, as the programs build up their complex behaviours in a similar way to the real world (i.e through the simple interaction of independent and simple entities). The parallel system engineer needs, however, a systematic method to decomposing the networks into independent ones or composing existing processes to form new networks. In this paper, we introduce a technique for the graphical construction of hierarchical networks (or configurations) of processes. The technique focuses on the concept of templates which define reusable patterns of communication and synchronisation for processes. We introduce a set of graphical rules based on the equivalence between processes, more specifically templates, and networks (configurations) of templates. The rules can be used to decompose networks of processes by substituting a single process for an equivalent sub-network of processes, or to abstract a sub-network of processes as a single process in order to simplify complex networks.

The number of parallel and distributed programming languages available is enormous. This means that the user faces a difficult task in selecting the language which suits his/her application. Most of the facilities supported by new languages could be, however, introduced as simple extensions of existing languages. In object-oriented languages where the concepts of reusability and extensibility are natural parts of the language, extensions can easily take place by creating frameworks which provide the abstraction level required by the user. In this paper, we present a framework that supports the dynamic reconfiguration of processes. C++CL is a framework developed in C++ and layered above PVM. This means that dynamic reconfigurable systems are easily built in a C++ fashion following the CL approach. At the same time, by using PVM, we improve the portability of the framework over heterogeneous networks and can also use all tools available for tracing and debugging PVM parallel processes. T...