Lerina Aversano

How Clones are Maintained: An Empirical Study

Despite the conventional wisdom concerning the risks related to the use of source code cloning as a software development strategy, several studies appeared in literature indicated that this is not true. In most cases clones are properly maintained and, when this does not happen, is because cloned code evolves independently. Stemming from previous works, this paper combines clone detection and co-change analysis to investigate how clones are maintained when an evolution activity or a bug fixing impact a source code fragment belonging to a clone class. The two case studies reported confirm that, either for bug fixing or for evolution purposes, most of the cloned code is consistently maintained during the same co-change or during temporally close co-changes

An empirical study on the evolution of design patterns

Design patterns are solutions to recurring design problems, conceived to increase benefits in terms of reuse, code quality and, above all, maintainability and resilience to changes. This paper presents results from an empirical study aimed at understanding the evolution of design patterns in three open source systems, namely JHotDraw, ArgoUML, and Eclipse-JDT. Specifically, the study analyzes how frequently patterns are modified, to what changes they undergo and what classes co-change with the patterns. Results show how patterns more suited to support the application purpose tend to change more frequently, and that different kind of changes have a different impact on co-changed classes and a different capability of making the system resilient to changes.

An algorithm for Web service discovery through their composition

The Web services stack of standards is designed to support the reuse and the interoperation of software components on the Web. A critical step in the process of developing applications based on the service oriented architecture is the service discovery. This paper shows how service composition can be used as a technique to support service discovery. The paper discusses the current state of research in this area and introduces a semantic matching algorithm that exploits the possibility to compose multiple services in order to satisfy a service request.

Migrating legacy systems to the Web: an experience report

A key to successfully moving to the Internet while salvaging past investments in centralised, mainframe-oriented software development is migrating core legacy applications towards Web-enabled client-server architectures. This paper presents the main results and lessons learned from a migration project aimed at integrating an existing COBOL system into a Web-enabled infrastructure. The original system has been decomposed into its user interface and server (application logic and database) components. The user interface has been migrated into a Web browser shell using Microsoft Active Server Pages (ASP) and VBScript. The server component has been wrapped with dynamic load libraries written in Microfocus Object COBOL, loaded into Microsoft Internet Information Server (IIS), and accessed by the ASP pages.

Business process reengineering and workflow automation: a technology transfer experience

In the last few years many public and private organizations have been changing the way of thinking their business processes to improve the quality of delivered services while achieving better efficiency and efficacy. This paper presents results and lessons learned from an on-going technology-transfer research project aimed at introducing service and technology innovation within a peripheral public administration while transferring enabling workflow methodologies and technologies to local Small and Medium Enterprises (SMEs). We discuss a process reverse engineering approach and its application in the technology transfer project. We also discuss an approach for evaluation and assessment of workflow technology and present a prototype implementation for a selected process of the subject organization.

Handling preprocessor-conditioned declarations

Many software systems are developed with configurable functionality, and for multiple hardware platforms and operating systems. This can lead to thousands of possible configurations, requiring each configuration-dependent programming entity or variable to have different types. Such configuration-dependent variables are often declared inside preprocessor conditionals (e.g., C language). Preprocessor-conditioned declarations may be a source of problems. Commonly used configurations are type-checked by repeated compilation. Rarely used configurations are unlikely to be recently type checked, and in such configurations a variable may have a type not compatible to its use or it may contains uses of variables never defined. This paper proposes an approach to identify all possible types each variable declared in a software system can assume, and under which conditions. Inconsistent variable usages can then be detected for all possible configurations. Impacts of preprocessor-conditioned declaration in 17 different open source software systems are also reported.

Learning from bug-introducing changes to prevent fault prone code

A version control system, such as CVS/SVN, can provide the history of software changes performed during the evolution of a software project. Among all the changes performed there are some which cause the introduction of bugs, often resolved later with other changes. In this paper we use a technique to identify bug-introducing changes to train a model that can be used to predict if a new change may introduces or not a bug. We represent software changes as elements of a n-dimensional vector space of terms coordinates extracted from source code snapshots. The evaluation of various learning algorithms on a set of open source projects looks very promising, in particular for KNN (K-Nearest Neighbor algorithm) where a significant tradeoff between precision and recall has been obtained.

A framework for measuring business processes based on GQM

The evolution of business processes and supporting software systems requires their analysis and assessment from both quantitative and qualitative points of view. The analysis and evaluation activities need the support of methodological and technological tools, customizable to the innovation requirements of the chosen processes and supporting software systems. This paper proposes a measurement framework based on the goal-question-metric (GQM) paradigm. It is generally applicable to any business process and supporting software system after its instantiation. The collaborative software environment WebEv, Web for the Evaluation, is proposed for facilitating the collection and elaboration of the required measures. Finally, the paper describes the application of the measurement framework in a real context.

Integrating document and workflow management tools using XML and web technologies: a case study

A critical point for developing successful information systems for distributed organisations is the need for integrating heterogeneous technologies and tools. This paper reports a case study of integrating two key enabling technologies, namely workflow and document management. Integration is achieved by combining several approaches, including software engineering and hypertexts. In this way, we raise the integration problem from the level of a purely technical issue to a level of conceptual modelling: integration is not focused solely on the information/software systems but involves, and is driven by, the related business processes and the documents they deal with.

Assessment and impact analysis for aligning business processes and software systems

Business processes and existing software systems must be aligned so that software systems can adequately support the business processes in order to be effectively used within them. The alignment characteristic needs to be considered even during the execution of an evolution process. In particular, a strict relationship exists between the evolution of a legacy system and that of the supported business process. Therefore, the requirements for evolving a software system embedded in a business process are to be defined on the basis of the change needing to be performed on the process activities. In fact, any modification performed in the business process activities and/or supporting software system may impact the process activities in terms of input/output and/or purpose of the software system and, therefore, cause misalignment. A coarse grained strategy is proposed for detecting misalignment between software systems and supported business processes when a change is executed. In addition, the strategy supports the identification of all the objects, either software system components or process activities, affected by a change and needing to be considered during the evolution process, for keeping the alignment and ensuring the technological support to the business process. The strategy proposes the exploitation of quality parameters, for codifying the alignment concept, and impact analysis techniques, for propagating the change and identifying all the objects affected by a change and requiring new evolution interventions.