Carlos Andres Parra

Unifying design and runtime software adaptation using aspect models

Software systems are seen more and more as evolutive systems. At the design phase, software is constantly in adaptation by the building process itself, and at runtime, it can be adapted in response to changing conditions in the executing environment such as location or resources. Adaptation is generally difficult to specify because of its cross-cutting impact on software. This article introduces an approach to unify adaptation at design and at runtime based on Aspect Oriented Modeling. Our approach proposes a unified aspect metamodel and a platform that realizes two different weaving processes to achieve design and runtime adaptations. This approach is used in a Dynamic Software Product Line which derives products that can be configured at design time and adapted at runtime in order to dynamically fit new requirements or resource changes. Such products are implemented using the Service Component Architecture and Java. Finally, we illustrate the use of our approach based on an adaptive e-shopping scenario. The main advantages of this unification are: a clear separation of concerns, the self-contained aspect model that can be weaved during the design and execution, and the platform independence guaranteed by two different types of weaving.

Using multiple feature models to design applications for mobile phones

The design of a mobile phone application is a tedious task according to its intrinsic variability. Software designers must take into account in their development process the versatility of available platforms (e.g., Android, iPhone). In addition to this, the variety of existing devices and their divergences (e.g., frontal camera, GPS) introduce another layer of complexity in the development process. These two dimensions can be formalized as Software Product Lines (SPL), independently defined. In this paper, we use a dedicated metamodel to bridge the gap between an application SPL and a mobile device one. This meta-model is also the support for the product derivation process. The approach is implemented in a framework named Applide, and is used to successfully derive customer relationship management software on different devices.

Using constraint-based optimization and variability to support continuous self-adaptation

Self-adaptation is one of the upcoming paradigms that accurately tackles nowadays systems complexity. In this context, Dynamic Software Product Lines model the intrinsic variability of a family of systems, and dynamically support their reconfiguration according to updated context. However, when several configurations are available for the same context, making a decision about the right one is a hard challenge: further dimensions such as QoS are needed to enrich the decision making process. In this paper, we propose to combine variability with Constraint-Satisfaction Problem techniques to face this challenge. The approach is illustrated and validated with a context-driven system used to support the control of a home through mobile devices.

An SCA-Based Middleware Platform for Mobile Devices

In pervasive environments, users can potentially access a variety of services through their mobile devices. However, in order to use the new services, we need to adapt the functionality of these devices. To achieve it, we propose to load a bootstrap into them that is able to communicate with the services. However this bootstrap has to be adapted due to the diversity of services offered in the environment, which are heterogeneous regarding aspects such as communication and discovery. Our bootstrap has two layers: the application layer and the middleware layer. This paper focuses in the middleware layer. We propose an architecture based on the service component architecture (SCA). The architecture eases the reconfiguration of the components at runtime to support different communication mechanisms and service discovery protocols. Besides, using SCA, we can add new functionality to the middleware platform that can be provided by remote applications (SCA or not).

Extractive SPL adoption using multi-level variability modeling

Software Product Line engineering aims at reusing and automating software development to reduce costs, have shorter development cycles, and maintain quality. However, for organizations with settled development processes and a large code base, adopting an SPL approach may prove to be a daunting task. In this paper we present an industrial experimentation and a proposal for an SPL adoption in Heinsohn Business Technology (HBT), a software development company specialized in financial, transportation, mortgage-backed securities, and pension-fund solutions. We start by identifying and modeling multiple levels of variability inherent to the kind of developments undertaken by HBT. Next, we define restrictions inside every level as well as between the levels to fully characterize an HBT software product. To limit the impact on the organization development process, we use an extractive approach. This allows us to design core assets starting from current software artifacts. The overall approach is based on real-world software artifacts developed over the years by HBT, whose combinations result in approximately 4.88e11 possible product configurations.

An SOA approach for automating software product line adoption

Nowadays, the software industry is faced with challenges regarding complexity, time to market, quality standards and evolution. To face those challenges, two strategies that are gaining interest both in academy and industry are Service Oriented Architecture (SOA) and Software Product Lines (SPL). While SOA aims at building applications from an orchestration of services, SPL consists in building a set of core-assets and a derivation strategy based on such assets. Adopting such approaches involves important challenges with regard to existing software artifacts that must be transformed in order to respect an architecture that focus on modularity and reuse. This paper presents an industrial experience of such transformation. We propose a non-intrusive reverse engineering process for the development of modular services obtained automatically from existing software artifacts, and a variability-driven derivation process to assembly products out of such services. To validate our approach, we have implemented the reverse engineering and derivation processes using real software JEE artifacts from a component framework of reusable functionalities in several different enterprise applications. The results show important benefits in terms of the development time and flexibility.

Using domain features to handle feature interactions

Software Product Lines in general and feature diagrams in particular support the modeling of software variability. Unfortunately, features may interact with each other, leading to feature interaction issues. Even if detected at the implementation level, interaction resolution choices are part of the business variability. In this paper, we propose to use a stepwise process to deal with feature interactions at the domain level: the way an interaction is resolved is considered as a variation point in the configuration process. This method and the associated implementation are applied onto a concrete case study (the jSeduite information system).

Context distribution for supporting composition of applications in ubiquitous computing

Devices and applications reacting to each other and to the environment in which they reside is a very important part of Ambient Intelligent systems. Such context-aware systems require mechanisms to react to changes in their surrounding environment.