Thaís Vasconcelos Batista

Managing dynamic reconfiguration in component-based systems

We propose a meta-framework called ‘Plastik which i) supports the specification and creation of runtime component-framework-based software systems and ii) facilitates and manages the runtime reconfiguration of such systems while ensuring integrity across changes. The meta-framework is fundamentally an integration of an architecture description language (an extension of ACME/Armani) and a reflective component runtime (OpenCOM). Plastikgenerated component frameworks can be dynamically reconfigured either through programmed changes (which are foreseen at design time and specified at the ADL level); or through ad-hoc changes (which are unforeseen at design time but which are nevertheless constrained by invariants specified at the ADL level). We provide in the paper a case study that illustrates the operation and benefits of Plastik.

On the modular representation of architectural aspects

An architectural aspect is a concern that cuts across architecture modularity units and cannot be effectively modularized using the given abstractions of conventional Architecture Description Languages (ADLs). Dealing with crosscutting concerns is not a trivial task since they affect each other and the base architectural decomposition in multiple heterogeneous ways. The lack of ADL support for modularly representing such aspectual heterogeneous influences leads to a number of architectural breakdowns, such as increased maintenance overhead, reduced reuse capability, and architectural erosion over the lifetime of a system. On the other hand, software architects should not be burdened with a plethora of new ADL abstractions directly derived from aspect-oriented implementation techniques. However, most aspect-oriented ADLs rely on a heavyweight approach that mirrors programming languages concepts at the architectural level. In addition, they do not naturally support heterogeneous architectural aspects and proper resolution of aspect interactions. This paper presents AspectualACME, a simple and seamless extension of the ACME ADL to support the modular representation of architectural aspects and their multiple composition forms. AspectualACME promotes a natural blending of aspects and architectural abstractions by employing a special kind of architectural connector, called Aspectual Connector, to encapsulate aspect-component connection details. We have evaluated the applicability and scalability of the AspectualACME features in the context of three case studies from different application domains.

An exploratory study of fault-proneness in evolving aspect-oriented programs

This paper presents the results of an exploratory study on the fault-proneness of aspect-oriented programs. We analysed the faults collected from three evolving aspect-oriented systems, all from different application domains. The analysis develops from two different angles. Firstly, we measured the impact of the obliviousness property on the fault-proneness of the evaluated systems. The results show that 40% of reported faults were due to the lack of awareness among base code and aspects. The second analysis regarded the fault-proneness of the main aspect-oriented programming (AOP) mechanisms, namely pointcuts, advices and intertype declarations. The results indicate that these mechanisms present similar fault-proneness when we consider both the overall system and concern-specific implementations. Our findings are reinforced by means of statistical tests. In general, this result contradicts the common intuition stating that the use of pointcut languages is the main source of faults in AOP.

An aspect-oriented approach to business process modeling

Traditional methods to business process modeling build the model in a unified way, which gives rise to complex models, where different concerns are scattered and tangled. In this paper we propose the use of an aspect-oriented approach to modularize business process modeling. We propose a meta Aspect Oriented Process Modeling Language (AOPML) that is independent of any specific business process language. In order to show the applicability of the approach we instantiate it using the Business Process Model Notation (BPMN) in a case study that takes advantage of AOPML.

Reflections on the modularity of business process models: The case for introducing the aspect‐oriented paradigm

Purpose – The aspect‐oriented (AO) paradigm is first proposed to deal with programing modularity issues, but different researchers have been exploring AO concepts in the designing and definition of software systems. The goal of this paper is to discuss and present a proposal that addresses the application of AO concepts to the design of business processes (BPs) in order to improve usability and understandability of process models.Design/methodology/approach – The paper departs from previous work on analyzing the application of AO for software design. The observations were backed by a case study, which was used to illustrate the issues by means of examples.Findings – The paper presents findings on important issues related to the integration of AO paradigm and BP modeling, such as crosscutting representation, crosscutting composition, quantification, and join point exposure.Originality/value – The paper explores a new frontier: the application of AO concepts to the design of BPs. As of now, few works have e...

Mapping ADL Specifications to an Efficient and Reconfigurable Runtime Component Platform

Recent research has recognised the potential of coupling ADLs with underlying runtime environments to support systematic and integrated specification-todeployment architectures. However, while some promising results have been obtained, much of this research has not considered the crucial issue of causally-connected dynamic reconfiguration and has considered only domain-specific areas. In this paper we discuss a specification-to-deployment architecture called Plastik that employs an extended generalpurpose ADL and is underpinned by an efficient runtime that is suited both for high-level application development and low-level systems development (e.g. embedded systems). Runtime reconfiguration is supported both at the ADL level and at the runtime level, and both programmed reconfiguration and adhoc reconfiguration are supported. The paper focuses on the mapping of ADL-level specifications to runtime instantiations and on the necessary runtime support for causally-connected dynamic reconfiguration.

On the Quantitative Analysis of Architecture Stability in Aspectual Decompositions

Architectural aspects are expected to modularize widely-scoped concerns that naturally crosscut the boundaries of system components at the software architecture level. However, there is no empirical knowledge about the positive and negative influences of aspectual decompositions on architecture stability. This paper analyzes the influence exerted by the aspect-oriented composition mechanisms in the stability of crosscutting concerns in an evolving multi-agent software architecture. Our investigation encompassed a comparative analysis of aspectual and non-aspectual decompositions based on different architectural styles. In particular, we assessed various facets of components and compositions stability through such alternative designs of the same multi-agent system using conventional quantitative indicators. The evaluation focused upon a number of architecturally-relevant changes that are typically performed through real-life maintenance tasks.

On the symbiosis of aspect-oriented requirements and architectural descriptions

With iterative development increasingly becoming the de factopractice in mainstream software processes, distinct early lifecycle artifacts need to be synchronized in order to leverage their correspondences. Requirements engineering and software architecture models have been recently enriched with aspect-oriented (AO) abstractions and composition mechanisms. In this context, this paper proposes a symbiotic relation between early AO development phases by specifying mapping rules between a requirements model, AOV-graph, and an architecture description language, AspectualACME. AOV-graph and Aspectual ACME are, respectively, symmetric AO extensions to the V-graph goals model and the ACME language, with features to modularize crosscutting concerns. The meta-models of these modeling languages offer abstractions that are recurrently supported in other requirements models and architectural approaches. Hence, this paper also discusses how the proposed suite of mapping rules can be exploited in other similar approaches. The evaluation of the mappings is carried out in the context of a case study called Health Watcher.

Using aspects and dynamic composition to provide context-aware adaptation for mobile applications

Mobile systems characterize by dynamic environments, thus requiring adaptive and context aware mechanisms to perceive changes in the execution context and to dynamically adapt to them. We propose a framework for developing adaptive context aware applications which employs aspect-oriented techniques and dynamic composition to modularize the adaptive behavior and to keep apart the application logic from this behavior.

Towards Aspect-Oriented Programming for Context-Aware Systems: A Comparative Study

Development of modular context-aware applications has been a deep challenge to software engineers. One of the main reasons is the crosscutting nature of certain context-awareness concerns. Specific distributed aspect-oriented programming (AOP) techniques have recently emerged as a promising candidate to address these shortcomings. This paper reports our ongoing effort on the definition of relevant criteria to perform a comparative analysis of five emerging AOP approaches for context-aware systems. We evaluate to what extent their specialized linguistic mechanisms scale to distributed systems, in particular context-aware mobile systems.