José María Conejero

Analysis of crosscutting across software development phases based on traceability

Traceability of requirements and concerns enhances the quality of software development. We use trace relations to define crosscutting. As starting point, we set up a dependency matrix to capture the relationship between elements at two levels, e.g. concerns and representations of concerns. The definition of crosscutting is formalized in terms of linear algebra, and represented with matrices and matrix operations. In this way, crosscutting can be clearly distinguished from scattering and tangling. We apply this approach to the identification of crosscutting across early phases in the software life cycle, based on the transitivity of trace relations. We describe an illustrative case study to demonstrate the applicability of the analysis.

Modernization of legacy web applications into rich internet applications

In the last years one of the main concerns of the software industry has been to reengineer their legacy Web Applications (WAs) to take advantage of the benefits introduced by Rich Internet Applications (RIAs), such as enhanced user interaction and network bandwith optimization. However, those reengineering processes have been traditionally performed in an ad-hoc manner, resulting in very expensive and error-prone projects. This situation is partly motivated by the fact that most of the legacy WAs were developed before Model-Driven Development (MDD) approaches became mainstream. Then maintenance activities of those legacy WAs have not been yet incorporated to a MDA development lifecycle. OMG Architecture Driven Modernization (ADM) advocates for applying MDD principles to formalize and standardize those reengineering processes with modernization purposes. In this paper we outline an ADM-based WA-to-RIA modernization process, highlighting the special characteristics of this modernization scenario.

On the relationship of concern metrics and requirements maintainability

Context: Maintainability has become one of the most essential attributes of software quality, as software maintenance has shown to be one of the most costly and time-consuming tasks of software development. Many studies reveal that maintainability is not often a major consideration in requirements and design stages, and software maintenance costs may be reduced by a more controlled design early in the software life cycle. Several problem factors have been identified as harmful for software maintainability, such as lack of upfront consideration of proper modularity choices. In that sense, the presence of crosscutting concerns is one of such modularity anomalies that possibly exert negative effects on software maintainability. However, to the date there is little or no knowledge about how characteristics of crosscutting concerns, observable in early artefacts, are correlated with maintainability. Objective: In this setting, this paper introduces an empirical analysis where the correlation between crosscutting properties and two ISO/IEC 9126 maintainability attributes, namely changeability and stability, is presented. Method: This correlation is based on the utilization of a set of concern metrics that allows the quantification of crosscutting, scattering and tangling. Results: Our study confirms that a change in a crosscutting concern is more difficult to be accomplished and that artefacts addressing crosscutting concerns are found to be less stable later as the system evolves. Moreover, our empirical analysis reveals that crosscutting properties introduce non-syntactic dependencies between software artefacts, thereby decreasing the quality of software in terms of changeability and stability as well. These subtle dependencies cannot be easily detected without the use of concern metrics. Conclusion: The correlation provides evidence that the presence of certain crosscutting properties negatively affects to changeability and stability. The whole analysis is performed using as target cases three software product lines, where maintainability properties are of upmost importance not only for individual products but also for the core architecture of the product line.

Early Crosscutting Metrics as Predictors of Software Instability

Many researchers claim that crosscutting concerns, which emerge in early software development stages, are harmful to software stability. On the other hand, there is a lack of effective metrics that allow software developers to understand and predict the characteristics of “early” crosscutting concerns that lead to software instabilities. In general, existing crosscutting metrics are defined for specific programming languages and have been evaluated only against source-code analysis, when major design decisions have already been made. This paper presents a generic suite of metrics to objectively quantify key crosscutting properties, such as scattering and tangling. The definition of the metrics is agnostic to particular language intricacies and can be applied to all early software development artifacts, such as usecases and scenarios. We have performed a first stability study of crosscutting on requirements documents. The results pointed out that early scattering and crosscutting have, in general, a strong correlation with major software instabilities and, therefore, can help developers to anticipate important decisions regarding stability at early stages of development.

Re-engineering legacy web applications into rich internet applications

There is a current trend in the industry to migrate its traditional Web applications to Rich Internet Applications (RIAs). To face this migration, traditional Web methodologies are being extended with new RIA modeling primitives. However, this re-engineering process is being figured out in an adhoc manner by introducing directly these new features in the models, crosscutting the old functionality and compromising the readability, reusability and maintainability of the whole system. With the aim of performing this reengineering process more systematic and less error prone we propose in this paper an approach based on separation of concerns applied to the specific case of WebML.

A model-driven approach for reusing tests in smart home systems

The continuous advances of ubiquitous and pervasive computing have contributed to the successful increase in smart home systems. However, usually these systems are developed at a lower abstraction level very tied to specific technologies. Model-driven approaches have emerged to tackle the design of these systems, improving their reusability and maintainability and decreasing their complexity. Nevertheless, the existing model-driven approaches to develop smart home systems do not cover the whole development process, and testing activities are still relegated to the final programming stages, reducing their reusability for different technologies or platforms. Some approaches have proposed the incorporation of testing activities into the model-driven process. However, the test models defined are very tied to the specific systems and they must be redesigned for every new system to test, reducing thus the reusability of the test behavior. In this setting, this paper presents a process to define reusable tests that may be automatically applied to different smart home systems. The process is integrated into a whole MDD approach that provides support for the modeling of smart home systems at two different abstraction levels, ensuring the reusability of tests also for different smart home platforms.

Analysis of crosscutting features in software product lines

Software Product Lines has emerged as a new technology to develop software product families related to a particular domain. The software products developed by this methodology are based on the combination of a set of common and variable assets. However, in order to combine these assets to build different products, coupling between common and variable parts must be highly reduced. In that sense, crosscutting features make evolution and adaptability of software difficult. In this paper we propose a framework to identify crosscutting features at early stages in order to use aspect-oriented techniques to modularize them and reduce their dependencies. This framework is based on a crosscutting pattern and uses traceability matrices to perform the analysis of crosscutting. Finally, applicability of the framework is shown by identifying crosscutting features in the Arcade Game Maker product line.

Discovering Volatile and Aspectual Requirements Using a Crosscutting Pattern

A modern software development approach needs to cope with the constant requirements changes observed in current business markets. Such volatile requirements are usually tangled with other requirements making systems evolution difficult. In this poster, we propose a conceptual framework to identify volatile requirements as well as requirements that classic approaches are unable to modularize. This framework is based on what we called the crosscutting pattern and uses traceability matrices and matrix operations.

A model-driven process to modernize legacy web applications based on service oriented architectures

Web applications (WAs) developed by companies are usually adapted to cover new business rules due to continuous changes in the organization requirements. Service Oriented Architectures (SOA) come to the scene to give a solution to these continuous changes providing a way to align business rules with underlying services. This is why there is a current trend to migrate legacy web applications to new SOAs. However, this migration requires the identification, publication and orchestration of the underlying service layer. These are complex tasks usually carried out ad hoc by manually defining and developing the service layer and its coordination. Moreover, these processes are usually performed at a low abstraction level, close to code, hindering reusability and maintainability of the obtained system. Model-Driven techniques aim at tackling the complexity of these processes since models drive the migration from a higher abstraction level. In that sense, this paper presents a Model-Driven systematic and semiautomatic process to modernize legacy WAs to SOAs. It also relies on techniques that are used to identify and classify the services offered by the different WAs of the organization. On the one hand, conceptual representations of the WAs and the service oriented architecture are obtained. On the other hand, the underlying services of the web applications are generated from models so that they may be offered as an interoperable service layer, which may be aligned with the company business rules and orchestrated with external services.

Mining early aspects based on syntactical and dependency analyses

Aspect-Oriented Requirements Engineering focuses on the identification and modularisation of crosscutting concerns at early stages. There are different approaches in the requirements engineering community to deal with crosscutting concerns, introducing the benefits of the application of aspect-oriented approaches at these early stages of development. However, most of these approaches rely on the use of Natural Language Processing techniques for aspect identification in textual documents and thus, they lack a unified process that generalises its application to other requirements artefacts such as use case diagrams or viewpoints. In this paper, we propose a process for mining early aspects, i.e. identifying crosscutting concerns at the requirements level. This process is based on a crosscutting pattern where two different domains are related. These two different domains may represent different artefacts of the requirements analysis such as text and use cases or concerns and use cases. The process uses syntactical and dependency based analyses to automatically identify crosscutting concerns at the requirements level. Validation of the process is illustrated by applying it to several systems and showing a comparison with other early aspects tools. A set of aspect-oriented metrics is also used to show this validation.