Yania Crespo

A systematic mapping study on software product line evolution: From legacy system reengineering to product line refactoring

Software product lines (SPLs) are used in industry to develop families of similar software systems. Legacy systems, either highly configurable or with a story of versions and local variations, are potential candidates for reconfiguration as SPLs using reengineering techniques. Existing SPLs can also be restructured using specific refactorings to improve their internal quality. Although many contributions (including industrial experiences) can be found in the literature, we lack a global vision covering the whole life cycle of an evolving product line. This study aims to survey existing research on the reengineering of legacy systems into SPLs and the refactoring of existing SPLs in order to identify proven approaches and pending challenges for future research in both subfields. We launched a systematic mapping study to find as much literature as possible, covering the diverse terms involved in the search string (restructuring, refactoring, reengineering, etc. always connected with SPLs) and filtering the papers using relevance criteria. The 74 papers selected were classified with respect to several dimensions: main focus, research and contribution type, academic or industrial validation if included, etc. We classified the research approaches and analyzed their feasibility for use in industry. The results of the study indicate that the initial works focused on the adaptation of generic reengineering processes to SPL extraction. Starting from that foundation, several trends have been detected in recent research: the integrated or guided reengineering of (typically object-oriented) legacy code and requirements; specific aspect-oriented or feature-oriented refactoring into SPLs, and more recently, refactoring for the evolution of existing product lines. A majority of papers include academic or industrial case studies, though only a few are based on quantitative data. The degree of maturity of both subfields is different: Industry examples for the reengineering of the legacy system subfield are abundant, although more evaluation research is needed to provide better evidence for adoption in industry. Product line evolution through refactoring is an emerging topic with some pending challenges. Although it has recently received some attention, the theoretical foundation is rather limited in this subfield and should be addressed in the near future. To sum up, the main contributions of this work are the classification of research approaches as well as the analysis of remaining challenges, open issues, and research opportunities.

A case study to evaluate the suitability of graph transformation tools for program refactoring

This article proposes a case study to evaluate the suitability of graph transformation tools for program refactoring. To qualify for this purpose, a graph transformation system must be able to (1) import a graph-based representation of models of Java programs, (2) allow these models to be transformed interactively with well-known program refactorings and (3) export the resulting models in the same graph-based format used as input. The case study aims to enable comparison of various features of graph transformation tools, such as their expressiveness and their ability to interact with the user. The model of Java programs is presented and some examples for translating Java source code into the model are provided. The refactorings selected for the case study are specified in detail.

Perspectives on automated correction of bad smells

Keeping a software system conformant with a desired architecture and consistent with good design principles is a recurring task during the software evolution process. Deviations from good design principles can manifest in the form of bad smells: problems in the systems structure that can negatively affect software quality factors. Many authors have worked in identifying bad smells and in removing them with refactorings: tools have been built to suggest refactorings; successful approaches to detect bad smells have been developed, etc.. We present a comprehensive and historical review on this subject, in order to model the current state of the art and to identify the open challenges, current trends and research opportunities. We also propose a technique based on automated planning, aimed at taking one step forward in the automatic improvement of a systems structure. This proposal will allow computing complex refactoring sequences which can be directed to the achievement of a certain objective, such as the correction of bad smells.

Reuse, Standardization, and Transformation of Requirements

Correct requirements determination is a critical factor in software development. Having stored reusable requirements elements, both qualified and classified, in a repository might contribute to reducing the error probability in requirements specifications but the diversity of requirements formats is a constraint for their reuse. To solve this problem, a common requirements model allowing the standardization and transformation of some types of requirements in others is presented. The transformations use an intermediate representation based on Petri nets, which provides rigor to the models and allows its consistency to be checked. Transformation algorithms are defined and implemented as part of a requirements management and reuse tool.

Computation of refactoring plans from refactoring strategies using HTN planning

Complex refactoring processes, such as applying big refactorings or removing design smells are difficult to perform in practice. The complexity of these processes is partly due to their heuristic nature and to the constraints imposed by preconditions on the applicability of the individual refactorings. We introduce refactoring strategies as heuristic-based, automation-suitable specifications of a complex refactoring process. They allow us to specify correction strategies and big refactorings more formally than it is done in current catalogues. Refactoring strategies can be instantiated, for each particular case, into refactoring plans. We define refactoring plans as sequences of refactorings that are immediately applicable over the current system source code. We have developed an approach for instantiating refactoring strategies into refactoring plans that uses Hierarchical Task Network (HTN) planning. This paper describes this approach and presents a case study, in order to evaluate and characterise it.

Refactoring Generics in JAVA: A Case Study on Extract Method

The addition of support for genericity to mainstream programming languages has a notable influence in refactoring tools. This also applies to the JAVA programming language. Those versions of the language specification prior to JAVA 5 did not include support for generics. Therefore, refactoring tools had to evolve to modify their refactoring implementations according to the new language characteristics in order to assure the correct effects when transforming code containing generic definitions or using generic instantiations. This paper presents an evaluation of the behaviour of refactoring tools on source code that defines or uses generics. We compare the behaviour of five refactoring tools on a well known refactoring, Extract Method, and its implementation for the JAVA language. We distill the lessons learned from our evaluation into requirements that have to be taken into account by refactoring tools in order to fully conform to this new language feature.

Applying formal concepts analysis to the construction and evolution of domain frameworks

Framework development is a hard process. Hardness increases when dealing with domain frameworks, which should be quickly adapted to the changing requirements of the business areas they model. We show a development process especially designed for this kind of frameworks. Thanks to the formal support provided by some techniques, based on formal concepts analysis, and thanks to the set of tools that implement them, the process provide an automatic support for the construction of domain frameworks. Taking this process (of domain frameworks construction) as starting point, we propose the generalization of the employed techniques to support the whole framework life cycle. The different phases of the proposed process are analyzed with detail, making special emphasis in their automatic aspects. A tool in experimental phase is also described. Then, some results of using the tool for the analysis of a class library, are presented as case study.

Aided domain frameworks construction and evolution

Framework development is a hard process. Hardness increases when dealing with domain frameworks, which should be quickly adapted to the changing requirements of the business areas they model. This paper is devoted to show a development process especially designed for this kind of frameworks. Thanks to the formal support provided by some techniques, based on Formal Concepts Analysis, and thanks to the set of tools that implement them, the process provide an automatic support for the construction of domain frameworks.Taking this process (of domain frameworks construction) as starting point, we propose the generalization of the employed techniques to support the whole framework life cycle. The different phases of the proposed process are analyzed with detail, making special emphasis in their automatic aspects. A tool in experimental phase is also described. Then, some results of using the tool for the analysis of a class library, are presented as case study.

The Inheritance Workshop

The Inheritance Workshop at ECOOP 2002, which took place on Tuesday, 11 June, was the first ECOOP workshop focusing on inheritance after the successful workshops in 1991 [41] and 1992 [48]. The workshop was intended as a forum for designers and implementers of object-oriented languages, and for software developers with an interest in inheritance. It was organized by Andrew P. Black, Erik Ernst, Peter Grogono, and Markku Sakkinen.

Obtaining generic classes automatically through a parameterization operator. A focus on constrained genericity

Generic classes allow one, through type parameter instantiation, to obtain new classes that are adapted to different contexts. Therefore, genericity is an important support for class reuse. When the possibility of reusing a class to deal with elements of different domains arises, it is desirable to have the appropriated generic class. Nevertheless, the construction of generic classes is a task that must be planned in advance. Hence, the possibility of reusing a class in other domain can appear, but maybe the class is not prepared for this. In this paper, we present the definition of a class restructuring operator which allows one to obtain generic classes from non-generic classes. The operator is named “parameterize”. In particular, we present the operator definition for an environment that supports the reuse of Eiffel classes. First, we present briefly the operator and then we focus on those aspects concerned with how to obtain a restriction class to constrain generic parameters. All these aspects are introduced by using examples.