Manuel Barrio-Solórzano

Architectural aspects of architectural aspects

This document studies in some detail the recently developed concept of aspect at the architecture level. This concept introduces a novel kind of modularization and composition in software, and therefore it defines new structures which must be studied by Software Architecture, determining the architectural features of aspects. However the opposite strategy can also be considered; namely, a new conceptual model can be defined, including an architecture-level notion of aspect. This would provide a new abstraction to describe software structures, thus effectively providing an additional dimension in architecture description, and would enable the study of the specific compositional problems in this dimension. The document starts by addressing the relevance of this kind of study, and continues by discussing why the new notions are necessary. Then it continues by including a brief enumeration of the more relevant notions derived from this aspectual framework, with particular emphasis on their relationship with software components. Next the document explores the different forms in which these notions could be incorporated into the context of Software Architecture, revealing a rather extensive variety of approaches, and also the relationships and partial equivalences between them.The paper concludes by noting a number or open questions and futures areas of research within this context.

UML Automatic Verification Tool with Formal Methods

The use of the UML specification language is very widespread due to some of its features. However, the ever more complex systems of today require modeling methods that allow errors to be detected in the initial phases of development. The use of formal methods make such error detection possible but the learning cost is high.This paper presents a tool which avoids this learning cost, enabling the active behavior of a system expressed in UML to be verified in a completely automatic way by means of formal method techniques. It incorporates an assistant for the verification that acts as a user guide for writing properties so that she/he needs no knowledge of either temporal logic or the form of the specification obtained.

Reflection-Based, Aspect-Oriented Software Architecture

The Software Architecture discipline is devoted to the study and description of structures, created by the composition of software modules. At the same time, the most important merit of Aspect Orientation is the fact that it introduces a new kind of modularization, deployed in a range of new dimensions, orthogonally to traditional models. These fields are able not only to combine, but also to complement and extend each other. They show also remarkable coincidences in some of their key concepts, such as multiple viewpoints and connectors. This paper explores their relationship, in particular from the point of view of the specification of “aspect-oriented architectures” in terms of existing Architecture Description Languages (Adls). Specifically, we consider the language \(\mathcal {PIL}\)ar: a reflective, process-algebraic Adl conceived for the description of dynamic architectures. It has three conceptual foundations which have also been proposed as a basis for aspect-orientation, namely reflection, superimposition and process algebras. We show how, due to the semantics of its reification relationship, \(\mathcal {PIL}\)ar is capable to directly describe “architectural aspects” with no need for syntactic extensions. At the same time, we suggest that the addition of these extensions could be very useful anyway. The discussion is supported by an example of a coordination aspect in \(\mathcal {PIL}\)ar, based on the classical Paxos Consensus algorithm.

Coordination in a Reflective Architecture Description Language

Software Architecture studies the structure of software systems, as described by Architecture Description Languages (Adls). When these capture structures of change, they are comparable to Coordination Languages. Previous work suggests that the combination with Reflection concepts renders a general framework for the description of such evolving structures. This paper describes a reflective Adl named PiLar designed to provide such a framework. It consists of a structural part, which describes the static skeleton, and a dynamic part, which defines patterns of change. The major novelty is the reification relationship, which structures a description in several meta-layers, such that the architecture is able to reason and act upon itself. The paper includes a complete PiLar example, to show the languages use and some of its most relevant features. It describes a Tuple Space model, illustrating the analogy with existing Coordination Models. We conclude by emphasizing PiLars generality and applicability.

Introducing Reflection in Architecture Description Languages

This document describes the structure of PiLar, an Architectural Description Language based on concepts from the field of Reflection, following a proposal suggested in previous work. First, motivations and ideas behind its design are outlined. Next, the language is divided in two parts: a declarative Structural Language, which makes possible to define an architecture’s static skeleton; and an imperative Dynamic Language, which appears as a set of constraining rules written in a concurrent language. Both languages are intertwined with the reification concept, which has a reflective origin. Its meaning and consequences are commented in detail. After this, the language’s formal semantics are informally described; it is conceived as a system of concurrent processes, communicating by means of channels. It is argued that this semantics fits perfectly with architectural concepts. Finally, a solution for the classical problem of the Dining Philosophers is included as an example, to show how this Adl describes the dynamic evolution in a system. The paper concludes emphasizing the generality and usefulness of the language.

Temporal superimposition of aspects for dynamic software architecture

The well-known Separation of Concerns Principle has been revisited by recent research, suggesting to go beyond the limits of traditional modularization. This has led to the definition of an orthogonal, invasive composition relationship, which can be used all along the software development process, taking several different forms. The object-like entity known as aspect is the best known among them, but in the most general case it can be defined as a new kind of structure. Software Architecture must be able to describe such a structure. Moreover, as most Adls have a formal foundation, this can be used to provide an adequate formalization for the aspectual composition relationship, which is still under discussion. In this paper, we propose to base this architecture-level definition in the concept of superimposition, integrating the resulting framework into the process-algebraic, dynamic Adl named

Coordination as an Architectural Aspect

{\mathcal{P}i\mathcal{L}ar}

Coordination in architectural connection : Reflective and aspectual introduction

. This language has a reflective design, which allows us to define that extension without redefining the semantics; in addition, the extended syntax can be used to avoid the use of reflective notions. Nevertheless, the language must provide the means to define general patterns to guide the weaving. Such patterns must not only identify locations in the architecture, but also the adequate states of the corresponding process structure. Therefore, we suggest to use temporal logic, specifically the μ-calculus, as the quantification mechanism. To illustrate this approach, we expose a case study in which all these ideas are used, and conclude by discussing how the combination of temporal logic and aspect superimposition, in this context, provides also an alternative way to describe architectural dynamism.

Formal Methods for UML

Modularization is a traditional consequence of the Principle of Separate of Concerns, which states that different abstractions should be dealt with in separate entities. Interactions between these entities define compositional structures, which are studied by Software Architecture. Recent research has revisited the original Principle, suggesting a different modularization strategy. Along with classic components, this approach explicitly considers additional concerns, defining modules which crosscut traditional barriers. The best known example is Aspect Orientation. This strategy defines a novel kind of interactions and compositional structures, which are of particular interest to Software Architecture. Moreover, several of those crosscutting concerns are best described at the architecture level. Coordination is an obvious example of such an architectural aspect: a higher-order interaction abstraction which could extend its influence to the whole system. In this paper, we propose a way to integrate these concepts into an existing language, using the notion of superimposition as a foundation. The chosen target is PiLar, a reflective, process-algebraic Adl. The concept of architectural fragment or chevron is introduced as an architecture-level aspect. To show the applicability of these ideas, we describe a case study consisting on the weaving of a coordination architectural aspect, encapsulating the Paxos distributed consensus algorithm, and a simple pipeline-style architecture, and obtaining a coordinated version of the initial system.

An “abstract process” approach to algebraic dynamic architecture description

Coordination is an essential, architecture-level concern, which defines a pattern of behaviour scattered throughout architectural connections. Architecture Description Languages should be able to separate this concern and make it explicit. We propose to describe this coordination model as a set of specific components, which will be introduced into architectural connections to influence their behaviour. Two approaches are discussed: the first one defines reflection as a new architectural dimension, while the second one provides a conceptually simpler aspectual perspective. To show that these approaches are feasible, we provide an example using both techniques, where an initial pipeline-style architecture is extended by introducing a coordination infrastructure which encapsulates the classic Paxos consensus algorithm.