Torsten Meyer

Dynamic Change Management by Distributed Graph Transformation: Towards Configurable Distributed Systems

In this contribution we consider the application of distributed graph transformation to the problem of specifying dynamic change in distributed systems. Change in distributed systems is related to at least two levels. One is the management of change in a local node of the distributed system and how such a local change is then propagated to those nodes which need to know about the change. The other aspect is changing the structure of the distributed system itself. This implies e.g. to add and/or remove a local node or an entire subsystem to/from the distributed system. In some important application areas such operations must be done during runtime without disturbing the unmodified rest of the distributed computing system. We first give an overview of our model of change and how exactly the two aspects of change interact. We describe distributed graph transformation as a technique to realize our change model. An example – a ring database – then shows how our approach can be applied to a small but nontrivial distributed system. This example shows nicely how the two aspects of change can be described uniformly using graph transformation rules and how the interaction of the two change aspects can be defined in an adequate way. Since this is ongoing work we conclude with an assessment of our approach and a brief discussion of further work.

ViewPoint-oriented software development by distributed graph transformation: towards a basis for living with inconsistencies

Software development is a staged and evolutionary process. Multiple stakeholders with different needs and views collaborate to build a system from interoperating and heterogeneous development artifacts. In such a setting, one has to cope with requirements changing dynamically during the entire lifetime of the system. Within this changing world living with inconsistencies is natural. Tool support is needed to tolerate inconsistencies and help developers to use them to drive the development process forward. In this contribution we consider the application of distributed graph transformation to the problem of formalizing the integration of multiple perspectives in software development called ViewPoints. Our work concentrates on requirements engineering. We demonstrate how inconsistency management can be used as a tool for requirements analysis by presenting a sample integration of architecture design and performance evaluation views.

ViewPoint-Oriented Software Development: Tool Support for Integrating Multiple Perspectives by Distributed Graph Transformation

Co-operative development of distributed software systems involves to address the multiple perspectives problem: many stakeholders with diverse domain knowledge and differing development strategies collaborate to construct heterogeneous development artifacts using different representation schemes. The ViewPoints framework has been developed for organizing multiple stakeholders, the development processes and notations they use, and the partial specifications they produce. In this contribution we present a tool environment supporting ViewPoint-oriented software development based on a formalization by distributed graph transformation.

Towards Integrating Multiple Perspectives by Distributed Graph Transformation

In order to support multiple perspectives in software development one needs a scheme which expresses explicitly all the views held by the various stakeholders like requirements engineer, software architect, client, user etc. The View Points framework has been developed in the past as a conceptional framework for expressing such a multiple perspective setting in software development projects. In this contribution we describe how this framework is formally described by distributed graph transformation and we demonstrate the applicability of our approach by presenting a non-trivial sample system.In order to support multiple perspectives in software development one needs a scheme which expresses explicitly all the views held by the various stakeholders like requirements engineer, software architect, client, user etc. The ViewPoints framework has been developed in the past as a conceptional framework for expressing such a multiple perspective setting in software development projects. In this contribution we describe how this framework is formally described by distributed graph transformation and we demonstrate the applicability of our approach by presenting a non-trivial sample system.

Formal Design and Perfomance Evaluation of Parallel and Distributed Software Systems

The advantages of parallel and distributed software systems in terms of additional reliability, redundancy, work load balancing etc. are easily outweighed by the additional complexity parallelism and distribution introduce into a software architecture. In this paper we consider an approach to describe the architecture of parallel and distributed software systems. This approach is based on a component model of software which contains special constructs for concurrency control and additional information about distribution. Rather than describing the distribution properties within a component most of these properties are stated with the use relation between components which may be local or remote. We describe how this design approach can be implemented on top of CORBA and how performance-related properties of remote use relations are used to quantitatively assess the software architecture. Thus the design of complex, hierarchically structured distributed software systems making full use of parallelism can be assessed wrt. response time of remote operation invocations, for example.

Dynamic semantics negotiation in distributed and evolving CORBA systems: towards semantic-directed system configuration

Modern distributed software systems are designed often in such a way that they accommodate change by adding or removing components during run-time. This implies that the architecture of the distributed system has to accommodate such additions and removals after design time. We argue that semantic information about the components has to be available in order to achieve always a functioning system in the presence of such change actions. Thus it is the aim to go beyond the currently available plug-in architectures where the semantics of the public interfaces is often only implicit. In order to achieve such a semantics-directed configuration we discuss a graph based approach for representing and matching semantic descriptions of software components. Based on such an approach (sub-)structures of the architecture can be designed that the components organize themselves on the basis of their semantic concepts.

On detecting and handling inconsistencies in integrating software architecture design and performance evaluation

We consider the problem of detecting and handling inconsistencies in software development processes using a graph based approach. It seems to be a natural way to express the various options and possibilities in attacking the problem. We apply the techniques developed in the area of software architecture design which uses in a structured way performance models in order to produce a design which incorporates also nonfunctional requirements in terms of quantitative performance.

Tool Support for ViewPoint-oriented Software Development

In this contribution we present tool support addressing the multiple perspectives problem. For organizing and integrating multiple stakeholders, the development processes and notations they use, and the partial specifications they produce we use the ViewPoints framework. A formalization of the View-Points framework based on distributed graph transformation builds the foundation of our tool.

Design and Evaluation of Distributed Component-Oriented Software Systems

In this contribution we consider an approach to describe the architecture of distributed software systems. This approach is based on a component model of software which contains additional information about distribution. Using the design description as a basis a distributed object-oriented implementation compliant with OMGs CORBA standard can be generated automatically. We discuss how a performance model can be derived systematically from the architecture description. Thus the design of complex, hierarchically structured distributed software systems can be assessed wrt. e.g. response time of remote operation invocations.

WWW-based software architecture design support for cooperative representation and checking

1. ABSTRACT In this contribution we consider a light weight approach to support software architecture design over the web. We outline the architecture description language we use for this purpose which is based on the concept of a self contained software component. Based on this concept a loosely coupled approach to combine remote repositories is supported. A number of analysis tools are sketched which are available as back end services within this approach. These tools not only allow to check syntactic and semantic properties but also allow to assess a given architecture wrt. quantitative properties like performance.