Andrzej Olszak

Remodularizing Java programs for improved locality of feature implementations in source code

Explicit traceability between features and source code is known to help programmers to understand and modify programs during maintenance tasks. However, the complex relations between features and their implementations are not evident from the source code of object-oriented Java programs. Consequently, the implementations of individual features are difficult to locate, comprehend, and modify in isolation. In this paper, we present a novel remodularization approach that improves the representation of features in the source code of Java programs. Both forward and reverse restructurings are supported through on-demand bidirectional restructuring between feature-oriented and object-oriented decompositions. The approach includes a feature location phase based on tracing of program execution, a feature representation phase that reallocates classes into a new package structure based on single-feature and multi-feature packages, and an annotation-based reverse transformation of code. Case studies performed on two open-source projects indicate that our approach requires relatively little manual effort and reduces tangling and scattering of feature implementations in the source code.

Detection of seed methods for quantification of feature confinement

The way features are implemented in source code has a significant influence on multiple quality aspects of a software system. Hence, it is important to regularly evaluate the quality of feature confinement. Unfortunately, existing approaches to such measurement rely on expert judgement for tracing links between features and source code which hinders the ability to perform cost-efficient and consistent evaluations over time or on a large portfolio of systems. In this paper, we propose an approach to automating measurement of feature confinement by detecting the methods which play a central role in implementations of features, the so-called seed methods, and using them as starting points for a static slicing algorithm. We show that this approach achieves the same level of performance compared to the use of manually identified seed methods. Furthermore we illustrate the scalability of the approach by tracking the evolution of feature scattering and tangling in an open-source project over a period of ten years.

Evolution of Feature-­Oriented Software: How to Stay on Course and Avoid the Cliffs of Modularity Drift

With time software systems easily become obsolete if not updated to reflect the ever-changing needs of their users. This update process is far from trivial as each feature is not necessarily captured by a single module, but rather scattered across a number of different modules. The situation is further aggravated by the fact that a module can encompass a number of different features. Our goal is to measure and evaluate how easy it is to trace back and update a given piece of software based on its modularity. Modularity is known as the degree to which a system’s components may be separated and recombined. The approach that we propose is based on the idea of using relative, as opposed to absolute, modularity metrics that measure the distance between the actual metric values for a given source code and their values achievable for the source code’s ideally modularized counterpart. The approach, termed modularization compass, computes the modularity drift by optimizing the feature-oriented modularization of source code based on traceability links between features and source code. The optimized modularizations are created automatically by transforming the groupings of classes into packages, which is guided by a multi-objective grouping genetic algorithm. The proposed approach was evaluated by application to long-term release histories of three open-source Java applications.

Modularization of Legacy Features by Relocation and Reconceptualization: How Much is Enough?

As programs become larger and start evolving, they often need to be split into modules, in order to facilitate independent evolution of end-user features and consolidate reusable core abstractions. Achieving this for legacy object-oriented software is, however, problematic due to scattering and tangling of feature implementations. While relocation of classes among packages can be used to significantly reduce these phenomena, achieving complete separation of features requires reconceptualization of existing classes. In this paper, we investigate the tradeoffs between relocation and reconceptualization of classes during a migration of the NDV is neuroscience application to the Net Beans Module System. We do this by comparing the manually modularized version of NDV is with three automatically optimized designs that exhibit various degrees of relocation and reconceptualization. The obtained findings shed new light on the actual degree and impact of relocation and reconceptualization during modularization of legacy features.

Understanding Legacy Features with Featureous

Feature-centric comprehension of source code is essential during software evolution. However, such comprehension is oftentimes difficult to achieve due the lack of correspondence between functional features and structural units of object-oriented programs. We present a tool for feature-centric analysis of legacy Java programs called Feature us that addresses this issue. Feature us allows a programmer to easily establish feature-code trace ability links and to analyze their characteristics using a number of visualizations. Feature us is an extension to the Net Beans IDE, and can itself be extended by third-party plugins.

Featureous: A Tool for Feature-Centric Analysis of Java Software

Feature-centric comprehension of source code is necessary for incorporating user-requested modifications during software evolution and maintenance. However, such comprehension is difficult to achieve in case of large object-oriented programs due to the size, complexity, and implicit character of mappings between features and source code. To support programmers in overcoming these difficulties, we present a feature-centric analysis tool, Featureous. Our tool extends the NetBeans IDE with mechanisms for efficient location of feature implementations in legacy source code, and an extensive analysis of the discovered feature-code relations through a number of analytical views.

Modularization compass navigating the white waters of feature-oriented modularity

Successful software systems have to adapt to the evolving needs of their users. However, adding and extending functional features often becomes more difficult over time due to aggregated complexity and eroded modularity. This erosion can be quantified by measuring scattering and tangling of feature implementations in the source code, to track long-term regressions and to plan refactorings. This paper argues that the traditional usage of only the absolute values of modularity metrics is, however, insufficient and proposes to use their relative values instead. These relative values are referred to as the drift of feature-oriented modularity, and are defined as the distance between the actual metric values for a given source code and their values achievable for the source codes ideally modularized counterpart. The proposed approach, called modularization compass, computes the modularity drift by optimizing the feature-oriented modularization of source code based on traceability links between features and source code. The optimized modularizations are created automatically by transforming the groupings of classes into packages, which is guided by a multi-objective grouping genetic algorithm. The proposed approach was evaluated by application to long-term release histories of three open-source Java applications.

Meta-Level Runtime Feature Awareness for Java

The existing body of feature-location research focuses on discovering feature-code trace ability links for supporting programmers in understanding and modifying static artifacts of software. In this paper, we propose a different utilization of this type of reverse-engineering information. We introduce the concept of runtime feature awareness that enables a running program to establish and make use of its own feature-code trace ability links. We present an implementation of this idea, a dynamic-analysis Java library called JAwareness. JAwareness provides a meta-level architecture that can be non-invasively added to a legacy program to enable it to act upon the activations of its own features. We demonstrate the feasibility of runtime feature awareness by discussing its three applications: error reporting, usage statistics and behavior adaptation.