INES - National Institute of Science and Technology for Software Engineering
Publicado em March 21st, 2012Projects
An important competitive differential for software factories is the ability to launch similar products customized to the clients, in a fast and cost-reduced way, without compromising quality. This has been possible through software product line engineering. A software product line (PL) is a set of related software products that are generated from reusable assets. Products are related in the sense that they share common functionality. Assets correspond to components, classes, property files, and other artifacts that we compose or instantiate in different ways to specify or build the different products. This kind of reuse targeted at a specific set of products can bring significant productivity and time to market improvements.
To obtain the benefits associated to the PL approach with reduced upfront investment, we can minimize the initial PL analysis and development process by bootstrapping existing related products into a PL. Through an extraction process, we separate variations from common parts and then discard duplicated common parts. A similar process applies to PL evolution, when, for instance, adding a new product requires extracting variations from parts previously shared by a number of products.
Although useful to reduce initial investments and risks, this extraction and evolution process can be costly and tiresome. Manually extracting and modifying different code fragments, besides other kinds of assets, requires substantial effort, especially for checking necessary conditions to ensure that the evolution can be performed in a safe way. Nonetheless, it can also introduce defects, compromising the PL benefits in other cost and risk dimensions.
We believe that the PL extraction and evolution process can benefit from semi-automatic refactorings, with formal basis, to ensure correctness and avoid running tests after the refactoring. Applying semi-automatic refactorings, guided by the developer, has the advantage of guaranteeing refactoring by construction. However, it imposes restrictions over the involved assets, such as the use of reflection, and demands from the developer the knowledge of the available transformations and the ability to identify which ones are better suited for a given situation. When the developer does not have such knowledge and ability, it is important to count with an alternative: verifying, ‘a posteriori’, that modifications to a PL really consist of a refactoring can be automatically performed in various situations, and approximated in the remaining ones.
However, existing refactoring notions focus on justifying the transformation of a single program into another, they do not consider transforming a PL into another, or a set of a programs into a PL. In fact, a PL can have conflicting artifacts, such as two classes with the main method, or two versions of the same configuration file, which makes the assets from a PL an invalid program. This prevents such assets set to benefit from existing refactoring notions. Beyond such program refactoring limitations - without mentioning requirements, tests and design models - in a PL, we tipically need extra elements to automatically generate products: Feature Models (FMs) and Configuration Knowledge (CK).
For these reasons, this project intends to propose, formalize, implement, and evaluate refactorings and refactoring checkers for PLs. In particular, we will define and implement refactoring catalogues, based on a behavior-preserving refinement notion. We will have catalogues that modify the PL as a whole, as well as individually modifying FMs and CK. Separate modifications to FM and CK are important to support compositional PL evolution. Besides that, we will reuse existing program and model refactoring catalogues for different languages. Similarly, we will have checkers for specific situations, such as when we modify only a single PL element (FM, CK, or assets), and checkers for changes that affect the PL as a whole.evolution, grandes desafios, project, refactoring, Software Product Lines
Researchers from the Evidence-Based Software Engineering Project have a full paper at the Software Engineering in Practice (SEIP) track of the 34th International Conference on Software Engineering (ICSE). The paper is entitled “On the Proactive and Interactive Visualization for Feature Evolution Comprehension: An Industrial Investigation” and is authored by Renato Lima Novais, Camila Nunes, Caio Lima, Elder Cirilo, Francisco Dantas, Alessandro Garcia, Manoel Mendonça. ICSE is the flagship conference on software engineering in the world.evolution, features, ICSE, visualization
INES researchers will be presenting a paper at the 13th workshop on Formal Techniques for Java-Like Programs. This workshop is part of ECOOP’2011 and is one of the main forums for discussing ideas about new techniques for the design, implementation, and evolution of Java programs that rely on a rigorous foundation. This year, FTfJP will be held in Lancaster, United Kingdom. INES will cover the expenses with registration at the workshop for one of the authors.
More information about the workshop is available at http://www.cs.williams.edu/FTfJP2011/index.html
Publication details are as follows:
Title: On the Interplay of Exception Handling and Design by Contract: An Aspect-Oriented Recovery Approach
Authors: Henrique Rebêlo, Roberta Coelho, Ricardo Lima, Gary T. Leavens, Marieke Huisman, Alexandre Mota, Fernando Castor
Design by Contract (DbC) is a technique for developing and improving functional software correctness through deﬁnition of “contracts” between client classes and their suppliers. Such contracts are enforced during runtime and if any of them is violated a runtime error should occur. Runtime assertions checkers (RACs) are a well-known technique that enforces such contracts. Although they are largely used to implement the DbC technique in contemporary languages, like Java, studies have shown that characteristics of contemporary exception handling mechanisms can discard contract violations detected by RACs. As a result, a contract violation may not be reﬂected in a runtime error, breaking the supporting hypothesis of DbC. This paper presents an error recovery technique for RACs that tackles such limitations. This technique relies on aspect-oriented programming in order to extend the functionalities of existing RACs stopping contract violations from being discarded. We applied the recovery technique on top of ﬁve Java-based contemporary RACs (i.e., JML/jml, JML/a jml, JContractor, CEAP, and Jose). Preliminary results have shown that the proposed technique could actually prevent the contract violations from being discarded regardless of the characteristics of the exception handling code of the target application.Aspect-Oriented Programming, design-by-contract, evolution, exception handling
Publicado em February 28th, 2011Uncategorized
Prof. Christina von Flach, coordinator of the project Models, Techniques and Tools for Software Evolution, will attend the International Conference on Aspect-Oriented Software Development (AOSD.11), which is the premier conference on software modularity.
Home page of the event: http://www.aosd.net/2011/aosd, evolution
Publicado em October 21st, 2010Expenses
Researchers from the ”Models, Techniques and Tools for Software Evolution” project acquire a set of academic books to support their activities.book, evolution