José Luiz Fiadeiro

A graph transformation approach to software architecture reconfiguration

The ability of reconfiguring software architectures in order to adapt them to new requirements or a changing environment has been of growing interest. We propose a uniform algebraic approach that improves on previous formal work in the area due to the following characteristics. First, components are written in a high-level program design language with the usual notion of state. Second, the approach deals with typical problems such as guaranteeing that new components are introduced in the correct state (possibly transferred from the old components they replace) and that the resulting architecture conforms to certain structural constraints. Third, reconfigurations and computations are explicitly related by keeping them separate. This is because the approach provides a semantics to a given architecture through the algebraic construction of an equivalent program, whose computations can be mirrored at the architectural level.

A graph based architectural (Re)configuration language

For several different reasons, such as changes in the business or technological environment, the configuration of a system may need to evolve during execution. Support for such evolution can be conceived in terms of a language for specifying the dynamic reconfiguration of systems. In this paper, continuing our work on the development of a formal platform for architectural design, we present a high-level language to describe architectures and for operating changes over a configuration (i.e., an architecture instance), such as adding, removing or substituting components or interconnectons. The language follows an imperative style and builds on a semantic domain established in previous work. Therein, we model architectures through categorical diagrams and dynamic reconfiguration through algebraic graph rewriting.

Categorical semantics of parallel program design

Abstract We formalise, using Category Theory, modularisation techniques for parallel and distributed systems based on the notion of superposition, showing that parallel program design obeys the “universal laws” formulated by Goguen for General Systems Theory, as well as other algebraic properties of modularity formulated for Specification Theory. The resulting categorical formalisation unifies the different notions of superposition that have been proposed in the literature and clarifies their algebraic properties with respect to modularisation. It also suggests ways of extending or revising existing languages in order to provide higher levels of reusability, modularity and incrementality in system design.

A Formal Approach to Service Component Architecture

We report on a formal framework being developed within the SENSORIA project for supporting service-oriented modelling at high levels of abstraction, i.e. independently of the hosting middleware and hardware platforms, and the languages in which services are programmed. More specifically, we give an account of the concepts and techniques that support the composition model of SENSORIA, i.e. the mechanisms through which complex applications can be put together from simpler components, including modelling primitives for the orchestration of components and the definition of external interfaces.

Semantics of Architectural Connectors

A categorical semantics is proposed for the notion of architectural connector in the style defined by Allen and Garlan which adopts notions of parameterisation similar to those developed for Abstract Data Type specification, and adapts them to formalisms for parallel program design. We show how many of the claims made in (1) can be formally substantiated, and generalised to formalisms other than CSP. Finally, we show how the categorical formalisation lends itself to useful generalisations of the notion of connector, namely through the use of multiple formalisms in the definition of the glue and the roles.

Connectors for mobile programs

Software architecture has put forward the concept of connector to express complex relationships between system components, thus facilitating the separation of coordination from computation. This separation is especially important in mobile computing due to the dynamic nature of the interactions among participating processes. We present connector patterns, inspired in Mobile UNITY, that describe three basic kinds of transient interactions: action inhibition, action synchronization, and message passing. The connectors are given in COMMUNITY, a UNITY-like program design language which has a semantics in category theory. We show how the categorical framework can be used for applying the proposed connectors to specific components and how the resulting architecture can be visualized by a diagram showing the components and the connectors.

Algebraic software architecture reconfiguration

The ability of reconfiguring software architectures in order to adapt them to new requirements or a changing environment has been of growing interest, but there is still not much formal work in the area. Most existing approaches deal with run-time changes in a deficient way. The language to express computations is often at a very low level of specification, and the integration of two different formalisms for the computations and reconfigurations require sometimes substantial changes. To address these problems, we propose a uniform algebraic approach with the following characteristics. Components are written in a high-level program design language with the usual notion of state. The approach combines two existing frameworks—one to specify architectures, the other to rewrite labelled graphs—just through small additions to either of them. It deals with certain typical problems such as guaranteeing that new components are introduced in the correct state (possibly transferred from the old components they replace). It shows the relationships between reconfigurations and computations while keeping them separate, because the approach provides a semantics to a given architecture through the algebraic construction of an equivalent program, whose computations can be mirrored at the architectural level.

Higher-order architectural connectors

We develop a notion of higher-order connector towards supporting the systematic construction of architectural connectors for software design. A higher-order connector takes connectors as parameters and allows for services such as security protocols and fault-tolerance mechanisms to be superposed over the interactions that are handled by the connectors passed as actual arguments. The notion is first illustrated over CommUnity, a parallel program design language that we have been using for formalizing aspects of architectural design. A formal, algebraic semantics is then presented which is independent of any Architectural Description Language. Finally, we discuss how our results can impact software design methods and tools.

Interconnecting formalisms: supporting modularity, reuse and incrementality

The necessity to deal simultaneously with different formalisms seems to be intrinsic to the discipline of Software Engineering, particularly in relation to modularity, reusability and incremental ity. In order to accommodate this diversity of formalisms, some authors have proposed the adoption of a common semantic domain for the different specification languages, and their transla tion into a common style of predicate logic. In this paper, we suggest that an alternative approach may be taken where the different modelling approaches are formalised individually in a common mathematical framework – Category Theory, and relationships are established between them using functors. Several examples are adduced to support this view and the generality of the approach is illustrated by formalising reusability as a property of a functor relating two such formalisms.

Tool support for coordination-based software evolution

In todays global and highly competitive business environments, organisations are replying to the question of whether technology is forming business or vice versa by integrating their business and IT strategies, thus using technology to do business. As a consequence, there is an increasing pressure to build software systems that are able to cope with the new requirements imposed by both technological advances and different business rules. At the same time, it is now widely accepted that, although object-oriented techniques have provided useful tools for software construction, their support cannot be extended directly to evolution. Even worse, it is becoming evident that there is a lack of theoretical principles and accompanying practical tools that can effectively support software evolution. In this paper, we describe in detail a development tool that is based on sound mathematical principles and supports an architecture-based approach to evolution centred on the notion of a coordination contract - a modelling primitive that treats components as black boxes and is compositional with respect to change.