Managing aspect orderings to support multiple quality concerns

When multiple aspects are composed undesired behavior may emerge due to the interference of aspects. Different interference management approaches have been proposed including detection and resolution of the conflicting aspects. It appears that the majority of the existing approaches have basically focused on functional correctness, whereby orderings of aspects are evaluated with respect to assumed contractual specification. Although functional correctness is an important quality concern also other quality concerns such as evolvability, reuse and reliability can demand a specific ordering. As such, the resulting possible set of orderings might need to be further reduced. In this paper we discuss the impact of other quality concerns than functional correctness, on the required orderings of aspects. Based on a domain analysis of existing approaches we provide a feature model and complementary to this a metamodel for defining aspect interference management approaches for multiple quality concerns. Copyright 2009 ACM

Flora: a framework for decomposing software architecture to introduce local recovery

The decomposition of software architecture into modular units is usually driven by the required quality concerns. In this paper we focus on the impact of local recovery concern on the decomposition of the software system. For achieving local recovery, the system needs to be decomposed into separate units that can be recovered in isolation. However, it appears that this required decomposition for recovery is usually not aligned with the decomposition based on functional concerns. Moreover, introducing local recovery to a software system, while preserving the existing decomposition, is not trivial and requires substantial development and maintenance effort. To reduce this effort we propose a framework that supports the decomposition and implementation of software architecture for local recovery. The framework provides reusable abstractions for defining recoverable units and the necessary coordination and communication protocols for recovery. We discuss our experiences in the application and evaluation of the framework for introducing local recovery to the open-source media player called MPlayer. Copyright 2009 John Wiley & Sons, Ltd

Optimizing decomposition of software architecture for local recovery

The increasing size and complexity of software systems has led to an amplified number of potential failures and as such makes it harder to ensure software reliability. Since it is usually hard to prevent all the failures, fault tolerance techniques have become more important. An essential element of fault tolerance is the recovery from failures. Local recovery is an effective approach whereby only the erroneous parts of the system are recovered while the other parts remain available. For achieving local recovery, the architecture needs to be decomposed into separate units that can be recovered in isolation. Usually, there are many different alternative ways to decompose the system into recoverable units. It appears that each of these decomposition alternatives performs differently with respect to availability and performance metrics. We propose a systematic approach dedicated to optimizing the decomposition of software architecture for local recovery. The approach provides systematic guidelines to depict the design space of the possible decomposition alternatives, to reduce the design space with respect to domain and stakeholder constraints and to balance the feasible alternatives with respect to availability and performance. The approach is supported by an integrated set of tools and illustrated for the open-source MPlayer software. © 2011 Springer Science+Business Media, LLC

Concern-oriented analysis and refactoring of software architectures using dependency structure matrices

Current scenario-based architecture analysis methods analyze the architecture with respect to scenarios that relate to stakeholder concerns. Albeit the primary motivation is to analyze the impact of stakeholders' concerns, it appears that concerns are not explicitly represented as first class abstractions. The lack of an explicit notion of concern in scenario-based analysis approaches can result in an incomplete analysis because scenarios are too specific and can only partially represent the concerns. We propose the concern-oriented architecture analysis method (COSAAM) that builds on scenario-based approaches but includes an explicit notion of concern in the analysis. COSAAM applies Dependency Structure Matrices (DSMs) to represent and analyze the dependencies among scenarios, concerns and architectural elements. Further, COSAAM extends DSMs by introducing explicit DSM patterns and heuristic rules for analyzing the impact of concerns on the architecture and for supporting the refactoring of the architecture. Copyright 2009 ACM

Runtime verification of component-based embedded software

To deal with increasing size and complexity, component-based software development has been employed in embedded systems. Due to several faults, components can make wrong assumptions about the working mode of the system and the working modes of the other components. To detect mode inconsistencies at runtime, we propose a "lightweight" error detection mechanism, which can be integrated with component-based embedded systems. We define links among three levels of abstractions: the runtime behavior of components, the working mode specifications of components and the specification of the working modes of the system. This allows us to detect the user observable runtime errors. The effectiveness of the approach is demonstrated by implementing a software monitor integrated into a TV system. © 2012 Springer-Verlag London Limited

Interaction-based feature-driven model-transformations for generating E-forms

One of the basic pillars in Model-Driven Software Development (MDSD) is defined by model transformations and likewise several useful approaches have been proposed in this context. In parallel, domain modeling plays an essential role in MDSD to support the definition of concepts in the domain, and support the model transformation process. In this paper, we will discuss the results of an e-government project for the generation of e-forms from feature models. Very often existing model transformation practices seem to largely adopt a closed world assumption whereby the transformation definitions of models are defined beforehand and interaction with the user at run-time is largely omitted. Our study shows the need for a more interactive approach in model transformations in which e-forms are generated after interaction with the end-user. To show the case we illustrate three different approaches for generation in increasing complexity: (1) offline model transformation without interaction (2) model transformation with initial interaction (3) model-transformation with run-time interaction. Copyright©2009 ACM

An aspect-oriented tool framework for developing process-sensitive embedded user assistance systems

Process-sensitive embedded user assistance aims to provide the end-user the necessary guidance based on the state of the process that is being followed. Unfortunately, the development of these systems is not trivial and has to meet several challenges. The main difficulties appear to be related to integration of process-sensitive guidance in the application and the crosscutting behavior of help concerns. To address these issues we developed an aspect-oriented tool framework Assistant-Pro that can be used to develop process-sensitive embedded user assistance for multiple applications. The framework provides tools for defining the process model, defining guidance related to process steps, and modularizing and weaving help concerns in the target application for which user guidance needs to be provided. The framework has been developed and validated in the context of Aselsan, a large Turkish defense electronics company. © 2011 Springer-Verlag Berlin Heidelberg