Mónica Pinto

DAOP-ADL: an architecture description language for dynamic component and aspect-based development

Architecture description languages deal with the description, analysis and reuse of software architectures. This paper describes DAOP-ADL, a component- and aspect-based language to specify the architecture of an application in terms of components, aspects and a set of plug-compatibility rules between them. With the aim of connecting the specification of the application architecture to the implementation, we describe our language using XML and XML Schemas. The DAOP-ADL language was designed to be interpreted by DAOP, our own dynamic component- and aspect-oriented platform. DAOP provides a composition mechanism that plugs aspects into components dynamically at runtime. The software architect will use the DAOP-ADL language at design time to describe the architecture of the application. Later this architectural information is loaded into the DAOP platform, which needs it to establish the dynamic connections between autonomous components and aspects. Therefore, the use of DAOP-ADL closes the gap between design and implementation of component- and aspect-based applications.

A Dynamic Component and Aspect-Oriented Platform

Component-based software development (CBSD) represents a significant advance towards assembling systems by plugging in independent and (re)usable components. On the other hand, aspect-oriented software development (AOSD) is presently considered as a possible technology to improve the modularity and adaptability of complex and large-scale distributed systems. Both are complementary technologies, so it would be helpful to have models that combine them to take advantage of all their mutual benefits. Thus recent research has tried to combine CBSD and AOSD by considering aspects as reusable parts that can be woven and then attached to the individual components. Our contribution to the integration of these technologies is CAM, a new component and aspect model that defines components and aspects as first-order entities, together with a non-intrusive composition mechanism to plug aspects into components. The underlying infrastructure supporting CAM is the dynamic aspect-oriented platform (DAOP), a component and aspect platform that provides the usual services of distributed applications, as well as a composition mechanism to perform the plugging of software aspects into components at runtime.

Separation of coordination in a dynamic aspect oriented framework

Aspect-Oriented Programming separates in a new dimension, named aspect, those features that are spread over different components in a system. In this paper we present a Dynamic AO Framework where software components and aspects are first-order entities composed dynamically at runtime according to the architectural information stored in middleware layer. As an example we describe the coordination aspect, one of the most relevant and useful aspects our approach, essential to develop open distributed systems The main functionality of this aspect is to encapsulate interaction protocol among a set of components.

AO-ADL: an ADL for describing aspect-oriented architectures

Architecture description languages are a sound and convenient approach to software architecture representation. The majority of well-known ADLs provide separation of computation and communication in components and connectors, respectively. However, computation and communication are not the only crosscutting concerns that may appear in a software architecture description. Traditional ADLs do not normally provide appropriate support to separate any kind of crosscutting concerns, which frequently result in poor architectures descriptions with highly coupled components. In this paper we present the AO-ADL language, based on a symmetric decomposition model that considers components and connectors as the basic structural elements (similar to traditional ADLs). We will show how aspects are treated as specific types of components that are composed by means of connectors. In order to cope with the separation of concerns we enrich the semantic and expressivity of traditional connectors to support either aspectual and nonaspectual component interactions.

Applying multiobjective evolutionary algorithms to dynamic software product lines for reconfiguring mobile applications

Mobile applications require to self-adapt their behavior to context changes.We propose a DSPL approach to manage variability at runtime.Configurations are generated using multiobjective evolutionary algorithms.We apply a fix operator to generate only valid configurations at runtime.We demonstrate that this approach is suitable for mobile environments. Mobile applications require dynamic reconfiguration services (DRS) to self-adapt their behavior to the context changes (e.g., scarcity of resources). Dynamic Software Product Lines (DSPL) are a well-accepted approach to manage runtime variability, by means of late binding the variation points at runtime. During the systems execution, the DRS deploys different configurations to satisfy the changing requirements according to a multiobjective criterion (e.g., insufficient battery level, requested quality of service). Search-based software engineering and, in particular, multiobjective evolutionary algorithms (MOEAs), can generate valid configurations of a DSPL at runtime. Several approaches use MOEAs to generate optimum configurations of a Software Product Line, but none of them consider DSPLs for mobile devices. In this paper, we explore the use of MOEAs to generate at runtime optimum configurations of the DSPL according to different criteria. The optimization problem is formalized in terms of a Feature Model (FM), a variability model. We evaluate six existing MOEAs by applying them to 12 different FMs, optimizing three different objectives (usability, battery consumption and memory footprint). The results are discussed according to the particular requirements of a DRS for mobile applications, showing that PAES and NSGA-II are the most suitable algorithms for mobile environments.

COMPASS: composition-centric mapping of aspectual requirements to architecture

Currently there are several approaches available for aspect-oriented requirements engineering and architecture design. However, the relationship between aspectual requirements and architectural aspects is poorly understood. This is because aspect-oriented requirements engineering approaches normally extend existing requirements engineering techniques. Although this provides backward compatibility, the composition semantics of the aspect-oriented extension are limited by those of the approaches being extended. Consequently, there is limited or no knowledge about how requirements-level aspects and their compositions map on to architecture-level aspects and architectural composition. In this paper, we present COMPASS, an approach that offers a systematic means to derive an aspect-oriented architecture from a given aspect-oriented requirements specification. COMPASS is centred on an aspect-oriented requirements description language (RDL) that enriches the usual informal natural language requirements with additional compositional information derived from the semantics of the natural language descriptions themselves. COMPASS also offers an aspect-oriented architecture description language (AO-ADL) that uses components and connectors as the basic structural elements (similar to traditional ADLs) with aspects treated as specific types of components. Lastly, COMPASS provides a set of concrete mapping guidelines, derived from a detailed case study, based on mapping patterns of compositions and dependencies in the RDL to patterns of compositions and dependencies in the AO-ADL. The mapping patterns are supported via a structural mapping of the RDL and AO-ADL meta-models.

Specifying aspect-oriented architectures in AO-ADL

Abstract Context Architecture description languages (ADLs) are a well-accepted approach to software architecture representation. The majority of well-known ADLs are defined by means of components and connectors. Architectural connectors are mainly used to model interactions among components, specifying component communication and coordination separately. However, there are other properties that cut across several components and also affect component interactions (e.g. security). Objective It seems reasonable therefore to model how such crosscutting properties affect component interactions as part of connectors. Method Using an aspect-oriented approach, the AO-ADL architecture description language extends the classical connector semantics with enough expressiveness to model the influences of such crosscutting properties on component interactions (defined as ‘aspectual compositions’ in connectors). Results This paper describes the AO-ADL language putting special emphasis on the extended connectors used to specify aspectual and non-aspectual compositions between concrete components. The contributions of AO-ADL are validated using concern-oriented metrics available in the literature. Conclusion The measured indicators show that using AO-ADL it is possible to specify more reusable and scalable software architectures.

Collaborative virtual environment development: an aspect-oriented approach

Nowadays, the interest in collaborative environments has increased considerably, probably due to current technological advances, especially in Internet computing. However, the lack of a standard reference architecture for the development of these systems makes the development of useful collaborative environments, that can be used in real work, difficult. Our goal is the development of a framework for the construction of collaborative virtual environments. We consider aspect-oriented programming to be very suitable for both the design and implementation of these systems. Thus, we present an aspect-oriented approach for the development of collaborative virtual environments.

Self-adaptation of mobile systems driven by the Common Variability Language

The execution context in which pervasive systems or mobile computing run changes continually. Hence, applications for these systems require support for self-adaptation to the continual context changes. Most of the approaches for self-adaptive systems implement a reconfiguration service that receives as input the list of all possible configurations and the plans to switch between them. In this paper we present an alternative approach for the automatic generation of application configurations and the reconfiguration plans at runtime. With our approach, the generated configurations are optimal as regards different criteria, such as functionality or resource consumption (e.g. battery or memory). This is achieved by: (1) modelling architectural variability at design-time using the Common Variability Language (CVL), and (2) using a genetic algorithm that finds nearly-optimal configurations at run-time using the information provided by the variability model. We also specify a case study and we use it to evaluate our approach, showing that it is efficient and suitable for devices with scarce resources. We specify an approach for the dynamic reconfiguration of mobile applications.We model a mobile application with variability which can be reconfigured at runtime.We simulate the execution of the mobile application when our dynamic reconfiguration service is applied and not applied, respectively.We measure the battery life as well as the overall utility of the application perceived by the user.Applying our dynamic reconfiguration, the battery life is incremented by 45.9% and the utility is incremented by 10.31%.

Run-time adaptation of mobile applications using genetic algorithms

Mobile applications run in environments where the context is continuously changing. Therefore, it is necessary to provide support for the run-time adaptation of these applications. This support is usually achieved by middleware platforms that offer a context-aware dynamic reconfiguration service. However, the main shortcoming of existing approaches is that both the list of possible configurations and the plans to adapt the application to a new configuration are usually specified at design-time. In this paper we present an approach that allows the automatic generation at run-time of application configurations and of reconfiguration plans. Moreover, the generated configurations are optimal regarding the provided functionality and, more importantly, without exceeding the available resources (e.g. battery). This is performed by: (1) having the information about the application variability available at runtime using feature models, and (2) using a genetic algorithm that allows generating an optimal configuration at runtime. We have specified a case study and evaluated our approach, and the results show that it is efficient enough as to be used on mobile devices without introducing an excessive overhead.