Angela Lozano

Assessing the effect of clones on changeability

To prioritize software maintenance activities, it is important to identify which programming flaws impact most on an applicationpsilas evolution. Recent empirical studies on such a flaw, code clones, have focused on one of the arguments to consider clones harmful, namely, that related clones are not updated consistently. We believe that a wider notion is needed to assess the effect of cloning on evolution. This paper compares measures of the maintenance effort on methods with clones against those without. Statistical and graphical analysis suggests that having a clone may increase the maintenance effort of changing a method. The effort seems to increase depending on the percentage of the system affected whenever the methods that share the clone are modified. We also found that some methods seem to increase significantly their maintenance effort when a clone was present. However, the characteristics analyzed in these methods did not reveal any systematic relation between cloning and such maintenance effort increase.

Evaluating the Harmfulness of Cloning: A Change Based Experiment

Cloning is considered a harmful practice for software maintenance because it requires consistent changes of the entities that share a cloned fragment. However this claim has not been refuted or confirmed empirically. Therefore, we have developed a prototype tool, CloneTracker, in order to study the rate of change of applications containing clones. This paper describes CloneTracker and illustrates its preliminary application on a case study.

Tracking clones' imprint

Cloning imprint is the lasting effect of cloning on applications. This paper aims to analyze the clone imprint over time, in terms of the extension of cloning, the persistence of clones in methods, and the stability of cloned methods. Such level of detail requires an improvement in the clone tracking algorithms previously proposed, which is also presented. We found that cloned methods are cloned most of their lifetime, cloned methods have a higher density of changes, and that changes in cloned methods tend to be customizations to the clone environment.

Empirical Studies of Open Source Evolution

This chapter surveys a sample of empirical studies of Open Source Software (OSS) evolution. According to these, the classical findings in proprietary software evolution, such as Lehman’s laws of software evolution, might need to be revised, at least in part, to account for the OSS observations. The book chapter summarises what appears to be the empirical status of each of Lehman’s laws with respect to OSS and highlights the threats to validity that frequently emerge in this type of research.

Design principles in architectural evolution: A case study

We wish to investigate how structural design principles are used in practice, in order to assess the utility and relevance of such principles to the maintenance of large, complex, long-lived, successful systems. In this paper we take Eclipse as the case study and check whether its architecture follows, throughout multiple releases, some principles proposed in the literature.

Assessing architectural evolution: a case study

This paper proposes to use a historical perspective on generic laws, principles, and guidelines, like Lehman’s software evolution laws and Martin’s design principles, in order to achieve a multi-faceted process and structural assessment of a system’s architectural evolution. We present a simple structural model with associated historical metrics and visualizations that could form part of an architect’s dashboard. We perform such an assessment for the Eclipse SDK, as a case study of a large, complex, and long-lived system for which sustained effective architectural evolution is paramount. The twofold aim of checking generic principles on a well-know system is, on the one hand, to see whether there are certain lessons that could be learned for best practice of architectural evolution, and on the other hand to get more insights about the applicability of such principles. We find that while the Eclipse SDK does follow several of the laws and principles, there are some deviations, and we discuss areas of architectural improvement and limitations of the assessment approach.

Evaluating the relation between changeability decay and the characteristics of clones and methods

In this paper we propose a methodology to evaluate if there is a relation between two code characteristics. The methodology is based on relative risk, an epidemiology formula used to analyze the effect of toxic agents in developing diseases. We present a metaphor in which the disease is changeability decay, measured at method level, and the toxic agent is a source code characteristic considered harmful. However, the formula assesses the strength of the relation between any toxic agent and any disease. We apply the methodology to explore cloning as a toxic agent that increases the risk of changeability decay. Cloning is a good agent to analyze given that although there is some evidence of maintainability issues caused by clones, we do not know which clones are harmful, or to what extent. We compare cloning with other possible dasiatoxic agentspsila, like having high complexity or having high fan-in. We also use the technique to evaluate which clone characteristics (like clone size) may indicate harmful clones, by testing such characteristics as toxic agents. We found that cloning is one of the method characteristics that affects the least changeability decay, and that none of the clone characteristics analyzed are related with changeability decay.

Mendel: Source code recommendation based on a genetic metaphor

When evolving software systems, developers spend a considerable amount of time understanding existing source code. To successfully implement new or alter existing behavior, developers need to answer questions such as: “Which types and methods can I use to solve this task?” or “Should my implementation follow particular naming or structural conventions?”. In this paper we present Mendel, a source code recommendation tool that aids developers in answering such questions. Based on the entity the developer currently browses, the tool employs a genetics-inspired metaphor to analyze source-code entities related to the current working context and provides its user with a number of recommended properties (naming conventions, used types, invoked messages, etc.) that the source code entity currently being worked on should exhibit. An initial validation of Mendel seems to confirm the potential of our approach.

An overview of techniques for detecting software variability concepts in source code

There are two good reasons for wanting to detect variability concepts in source code: migrating to a product-line development for an existing product, and restructuring a product-line architecture degraded by evolution. Although detecting variability in source code is a common step for the successful adoption of variability-oriented development, there exists no compilation nor comparison of approaches available to attain this task. This paper presents a survey of approaches to detect variability concepts in source code. The survey is organized around variability concepts. For each variability concept there is a list of proposed approaches, and a comparison of these approaches by the investment required (required input), the return obtained (quality of their output), and the technique used. We conclude with a discussion of open issues in the area (variability concepts whose detection has been disregarded, and cost-benefit relation of the approaches).

A methodology to assess the impact of source code flaws in changeability, and its application to clones

Some characteristics of source code are perceived as harmful because they evidence that design principles were not applied in certain parts of the application. This work proposes a methodology that assesses the effect of so called source code flaws in changeability. Our methodology is based on measures and indicators of the effort of changing methods. The measures are calculated with information automatically extracted from source code repositories, being therefore objective. We analyze the effect of clones in methods using the methodology, and we show its potential for better understanding the effect of low level structure in changeability.