Reducing Program Comprehension Effort in Evolving Software by Recognizing Feature Implementation Convergence (original) (raw)

On Computing the Canonical Features of Software Systems

2006

Software applications typically have many features that vary in their similarity. We define a measurement of similarity between pairs of features based on their underlying implementations and use this measurement to compute a set of canonical features. The canonical features set (CFS) consists of a small number of features that are as dissimilar as possible to each other, yet are most representative of the features that are not in the CFS. The members of the CFS are distinguishing features and understanding their implementation provides the engineer with an overview of the system undergoing scrutiny. The members of the CFS can also be used as cluster centroids to partition the entire set of features. Partitioning the set of features can simplify the understanding of large and complex software systems. Additionally, when a specific feature must undergo maintenance, it is helpful to know which features are most closely related to it. We demonstrate the utility of our method through the analysis of the Jext, Firefox, and Gaim software systems

An approach for measuring software evolution using source code features

Proceedings Sixth Asia Pacific Software Engineering Conference (ASPEC'99) (Cat. No.PR00509), 1999

One of the characteristics of large software systems is that they evolve over time. Evolution patterns include modijications related to the implementation, intelfaces and the overall system structure. Consequently, system understanding and maintainability tend to degrade over time unless particular attention is paid to measure, assess and evaluate the effects of the evolution activities. Traditionally, the assessment of evolution activities has focused on the architectural level. Howevel; in many cases it is easier to extract low-level program information from the Abstract Syntax Tree rather than to discover the full architecture of a large legacy system. This paper presents techniques for analyzing the evolution of large systems even in cases where no complete architectural views of the system exist, from information obtained solely from the AST We present experimental results by analyzing the evolution patterns across different versions, of two popular systems, the Apache Web servec and the Bash shell.

Analyzing feature traces to incorporate the semantics of change in software evolution analysis

2005

Abstract Many of the approaches that analyze software evolution consider a static perspective of a system. Static analysis approaches focus on the evolution of static software entities such as packages, classes and methods. Without knowledge of the roles software entities play in system features, it is difficult to interpret the motivation behind changes and extensions in the code.

Analyzing code evolution to uncover relations

2015 IEEE 2nd International Workshop on Patterns Promotion and Anti-patterns Prevention (PPAP), 2015

This paper reports on evidence found of five possible relations (Plain Support, Mutual Support, Rejection, Common Refactoring, and Inclusion) among four bad smells (God Class, Long Method, Feature Envy, and Type Checking). We analyzed several releases of three open-source applications (16 for Log4j, 34 for Jmol, and 45 for JFreeChart) using four direct and two indirect metrics. This analysis uncovered correlations between three of these bad smells, namely, Feature Envy, Long Method, and God Class. The strongest correlation discovered was between Feature Envy and Long Method, followed by a mild correlation between Long Method and God Class, and between Feature Envy and God Class. These findings seem to provide initial evidence of the coexistence of bad smells and therefore, the need for bad smell removal plans to take into account these correlations in order to minimize code improvement efforts.

Analyzing software evolution through feature views

2006

Abstract Features encapsulate the domain knowledge of a software system and thus are valuable sources of information for a reverse engineer. When analyzing the evolution of a system, we need to know how and which features were modified to recover both the change intention and extent, namely which source artifacts are affected. Typically, the implementation of a feature crosscuts a number of source artifacts.

On increasing our knowledge of large-scale software comprehension

Empirical Software Engineering, 1997

Program comprehension is a central task during software maintenance, evolution and reuse. Some estimates put the cost of understanding software at 50% of the maintenance effort. Clearly, understanding how programmers go about comprehending software they have ...

Improving Program Comprehension in Operating System Kernels with Execution Trace Information

Operating systems are one of the most complex kinds of software systems ever built. Their complexity results from many factors, in special, the huge size and low-level issues. As consequence, there are many programming challenges to be considered at either the in-the-large level or in-the-small level. Program comprehension is a crucial problem for developers who need to contribute or reuse the code base in some way. One of the most important challenges in this scenario is to find the functions in the source code that are responsible for a specific feature of the system. Previous work has shown the benefits of using execution trace information to improve the comprehension process of features that can have their execution adequately reproduced. However, the use of execution traces in the comprehension of operating system kernel features is poorly studied. In this work, we show that execution traces can effectively improve program comprehension of kernel features when adequate filters ...