Rosângela Penteado

An overall process based on fusion to reverse engineer legacy code

The fusion method for object-oriented development of systems is used for reverse engineering of legacy code. A literature survey is presented on relevant techniques available for covering most of the activities involved in conducting reverse engineering. Using these techniques, an overall process, based on the fusion method, called Fusion/RE, is presented. Fusion/RE was used to reverse engineer an existing environment for editing and simulating statecharts. Selected parts of the sample application documentation are included, together with a discussion of the benefits obtained. The main features of Fusion/RE include its extensibility to integrate new heuristics and tools for data reverse engineering and some metrics that allow one to assess the conversion effort.

An overview and an empirical evaluation of UML-AOF: an UML profile for aspect-oriented frameworks

In this paper we present UML-AOF and an empirical evaluation about it. UML-AOF is a profile that aims to make the design characteristics of aspect-oriented frameworks (AOFs) more evident in models than standard profiles for aspect-oriented programming (AOP). UML-AOF gathers several stereotypes and tagged values which represent design and architectural details commonly found in AOFs, such as some idioms, patterns and extension mechanisms. In order to evaluate the applicability of this profile, an empirical study was conducted to analyze the number of errors and the time spent by software engineers using both UML-AOF and a conventional profile for AOP. Based on the collected data, we have observed that the number of errors as well the time spent analyzing the models were significantly better than using the conventional profile.

Reengineering using design patterns

Starting from a legacy system, originally developed in C and using text files, we first conducted a reverse engineering of this system to obtain its object-oriented analysis model. Then, in a process that is called segmentation, we restructured the code, changing all data structures to abstract data types and procedures to methods, eliminating all data access anomalies. This paper presents an experiment in which part of the segmented code was reengineered to an object-oriented language (Java) and the text files were replaced by a relational database. We show how design patterns have been used to link the database with the object-oriented concepts of Java. We also report a maintenance experiment that compares maintainability of the legacy system, the segmented system, and the object-oriented version.

An experiment of legacy code segmentation to improve maintainability

An experiment with procedure oriented legacy code originally developed in C programming language and Xview graphical interface language is described. Its purpose is to segment the code to improve system maintainability. The segmentation is preceded by the legacy system reverse engineering according to an overall process called Fusion/RE. This process produces an object oriented system analysis model from procedure oriented legacy code. The segmentation is in fact a reengineering with change of orientation from procedural to object oriented preserving the system functionality and programming language. The segmentation process is described and its application to a real system case called StarSim, with 30000 lines of source code, that allows the edition and simulation of statecharts, is reported. Information about the improvement in maintainability is presented.

Quality Improvement for Use Case Model

Requirements documents tend to be inundated by requirements that are no longer meaningful, descriptions that are unnecessarily long and convoluted, duplication of information, among other shortcomings. These syntactical problems hinder the overall understandability of requirements documents throughout the whole development process. Quality evaluation strategies are not very helpful if they only include lists of expected product qualities. They should also incorporate guidelines to help practitioners to effectively measure and improve the qualities of requirements documents. AIRDoc is a step forward to fill this gap proposing a process that supports the evaluation and improvement of requirements documents specified based on use cases. This process is founded on the elaboration of goals and definition of questions that will be answered by hypotheses and metrics. The quality of requirements documents is improved through refactorings and patterns. A case study demonstrates how the process of improvement has been successfully applied in an industrial requirements document.

Reengineering legacy systems towards system of systems development

Despite the evolution of the hardware that enabled even small components to interconnect and the modern software engineering paradigms that eased information exchange, several systems still operate standalone and do not share resources naturally with each other. In this paper, we show that if these systems are reengineered appropriately using existing techniques, they can share useful resources, work cooperatively, and compose more complex systems like System of Systems (SoS). Our case study illustrates how distinct Electronic Funds Transfer (EFT) legacy systems were reengineered to compose a SoS intended to deliver an increasing number of financial operations.

CrossCutting Concerns Identification Supported by Ontologies: A Preliminary Study

Contextualization: CrossCutting Concerns (CCC) or Early-Aspects consist of software concerns that are spread and/or tangled with requirements of other concerns and can be treated by Aspect-Oriented Requirements Engineering (AORE). Problem: several AORE approaches have been proposed, however, some experimental studies have found problems regarding to the accuracy of these approaches. According to the authors of these studies these problems occur, due to: (i) the lack of knowledge presented by the users of these approaches about the crosscutting nature of CCC; and (ii) the lack of resources to support users of these approaches during the CCC identification. Goal: this work aims to improve the CCC identification accuracy from the support of domain ontologies. Hence, an ontology for the CCC domain was proposed and the Theme/Doc AORE approach was extended aiming to make it suitable for the usage of this ontology. As results, a preliminary experimental study showed a significant increasing of the recall of the extended approach, without negative effects on the precision and execution time of it.

An Overview on Aspect-Oriented Requirements Engineering Area

Background: Aspect-Oriented Requirements Engineering (AORE) is a research field that aims to provide appropriate strategies for identification, modularization and composition of crosscutting concerns (also called early-aspects). Several AORE approaches have been developed recently, with different features, strengths and limitations. Goals: the aim of this paper is threefold: (i) cataloguing existing AORE approaches based on the activities encompassed by them; (ii) describing what types of techniques have been used by these approaches for “Concern Identification and Classification” – a bottleneck activity; and (iii) identifying which are the most used means of publication of AORE-based studies and how it has been the progress of these studies over the years. Results: we have selected and analyzed 60 (sixty) papers and among them, we identified 38 (thirty-eight) AORE distinct approaches. Some interesting results are: (i) few approaches lead to “Conflict Identification and Resolution”, an activity responsible for discovering and treating the mutual influence between different concerns existing in a software; (ii) there is a lack of evaluation studies about already existing AORE approaches; (iii) the most productive research institutions on AORE in the world are located in Lancaster (UK) and Nova Lisboa (Portugal); among other.

A Version Control Tool for Framework-based Applications

Framework based application development is increasingly being adopted by software organizations. Frameworks provide reuse of both software design and code, and supply more trustable applications, as the components used to implement them have been previously tested. However, version control is more problematic than in conventional software development, as it is necessary to control both the framework versions and the versions of the applications created with it. Furthermore, aiming to minimize the impact of system requirement changes, framework based software development and reengineering processes adopt the incremental approach, which is a “must” in agile methodologies. This approach makes easier to fulfill requests for system requirements change at any time during the process application. In that context, there is a lack of tools that support version control of applications created with frameworks. This paper presents a tool that aims to aid in the fulfillment of that need, contributing to quality assurance of the products that result from software development or reengineering.

Elaboration of software requirements documents by means of patterns instantiation

Studies show that problems associated with the requirements specifications are widely recognized for affecting software quality and impacting effectiveness of its development process. The reuse of knowledge obtained from previous projects can facilitate the identification and writing of the requirements to reach the elaboration of a complete and consistent requirements document. Software patterns are a solution to capture and reuse knowledge from different contexts for the software development. On the information system domain, it is common to find a set of requirements that have similar characteristics and repeat themselves in different systems of this domain, indicating a possibility of becoming a requirements pattern. By reusing knowledge obtained in previous projects, requirements patterns can be elaborated to facilitate a more complete and consistent specification of system requirements in that domain. The advantage of using requirements patterns is to provide the software engineer a starting point for the elaboration of requirements documents, instead of starting from scratch to solve known problems. The requirements patterns can contribute to the improvement of the software quality, minimize the development time and costs, because previously defined and tested solutions are reused. This paper shows a set of functional requirements patterns and business rules elaborated to help the software engineer in the writing of the requirements document. The non-functional requirements were not considered in this project. A computational support was developed, based on that set of patterns, to facilitate the organized and complete writing of the requirements document. Case studies are presented with the use of the computational support.