Link analysis algorithms for static concept location: an empirical assessment

Abstract

During software evolution, one of the most important comprehension activities is concept location in source code, as it identifies the places in the code where changes are to be made in response to a modification request. Change requests (such as, bug fixing or new feature requests) are usually formulated in natural language, while the source code also includes large amounts of text. In consequence, many of the existing concept location techniques are based on text search or text retrieval. Such approaches reformulate concept location as a document retrieval problem. We refine and improve such solutions by leveraging dependencies between source code elements. Dependency information is used by a link analysis algorithm to rank the document space and to improve concept location based on text retrieval. We implemented our solution to concept location using the PageRank algorithm, used in web document retrieval applications. The results of an empirical evaluation indicate that the new approach leads to better retrieval performance than baseline approaches that use text retrieval and clustering. In addition, we present the results of a controlled experiment and of a differentiated replication to assess whether the new technique supports users in identifying the places in the code where changes are to be made. The results of these experiments revealed that the users exploiting our technique were significantly better supported in the identification of the code to be changed in response to a bug fixing request compared to the users who did not use this technique.

Appendix :

In this appendix, we summarize CLC (Scanniello and Marcus 2011), namely one of the baseline approaches we have selected for the investigation presented in this paper. The main steps are:

1. Corpus Creation. :

Each method results in one document in the corpus. All the comments and identifiers of a method are included in a document. Lead comments for the methods (if any) were also included in the corresponding document.

2. Corpus Normalization. :

The normalization is performed as for PR (see Section 3).

3. Corpus Indexing.:

A text retrieval engine is used to index the corpus. A numerical index associated with each document in the corpus is created. Later, this index is used to determine similarity measures between documents. We used VSM as text retrieval engine.

4. Computing Lexical Similarities Between Source Code Documents.:

It is a necessary step to perform the clustering. We use the cosine similarity and compute it between all the documents in the corpus.

5. Extracting Dependencies in Software.:

We represent the software system as a directed graph G=(V,E). V is the set of methods in the system, while E is the set of edges (i.e., ordered pair of elements of V). Each edge represents a directed relationship between two methods. We take a conservative approach in this work and only consider direct references between methods. That is, (m _i ,m _j )∈E, if there is a reference to the method m _j in the body of the method m _i . These dependencies have been identified by employing JRipples.

6. Clustering.:

x The graph G is is turned into a directed weighted graph G ^′=(V,E,ω). In particular, the lexical similarity (i.e., cosine similarity) between two methods m _i and m _j is used as the weight (i.e., ω(m _i ,m _j )) of the edge (if present) between the nodes corresponding to these methods. According to how the graph G ^′ is built, we can assert that it summarizes both the structural and the lexical information of a subject system.

The BorderFlow clustering algorithm (Ngomo 2009) is applied to G’. The algorithm is a general-purpose graph clustering algorithm. It can be used for soft clustering (i.e., a node of an input graph can be in one or more clusters) and hard clustering (i.e., each node of an input graph can be in exactly one cluster). The hard clustering variant is used in CLC.

The idea behind BorderFlow is to maximize the flow from the border of each cluster to its inner nodes (i.e., the nodes within the cluster) while minimizing the flow from the cluster to the nodes outside of the cluster. Therefore, a cluster X is a subset of V such that a cluster maximizes the border flow ratio:

$$F(X) = \frac{\Omega(b(X), X)}{\Omega(b(X), n(X))} $$

where b(X) is the set of border nodes of X, while n(X) is a function used to identify the set of direct neighbors of X. Ω is a function that assigns the total weight of the edges from a subset of V to another one to these subsets (i.e., the flow between the first and the second subset). This function is computed as follows:

$${\Omega} (X, Y) = \sum\limits_{x \in X, y \in Y} \omega(x, y)$$

The algorithm iteratively selects nodes from n(X) and then inserts them in X until F(X) is maximized. The selection of the nodes is performed according to the following two steps:

• 1. Computing the set C(X) that will contain all the nodes u∈X−V such that $F(X \bigcup \{u\}) > F(X)$.

• 2. Selecting the candidates u∈C(X) to get the set C _f (X). This set contains all the nodes u that maximize Ω(u,n(X)).

If $F(X \cup C_{f}(X)) \geqslant F(X)$, then the nodes of C _f (X) are added to the set X. The iterative selection of nodes concludes when |n(X)| equals to 0 for each set of nodes X identified by the BorderFlow algorithm. Each set of nodes forms a cluster.

7. Formulating a Query.:

Developers formulate textual queries based on the information they have about the change request. Most text retrieval engines do not rely on a predefined vocabulary or grammar; hence the queries do not need to be correct sentences. The query is normalized in same way as the corpus.

8. Ranking the Documents.:

In text retrieval-based approaches documents are retrieved based on their lexical similarity to the query. In CLC, the position of the methods in the ranked list is modified according to the clustering results. Specifically, for all the clusters c _k ∈C, where C is the set of identified clusters, we compute the similarity of each method m _i ∈c _k with the query q as follows:

$$S(q, m_{i}, c_{k}) = \max\limits_{{m_{j} \in c_{k}}}\{sim(q, m_{j}) | i \neq j \}$$

where s i m(q,m _j ) is the lexical similarity (or cosine similarity) between then query q and method m _j . The methods are then sorted to get a new ranked list. From a practical perspective, CLC no longer retrieves individual methods but instead clusters of related methods (related both structurally and lexically). The retrieval order of the clusters is still based on the lexical similarity to the use’s query.

Differences and Similarity between CLC and the New Approach. Steps 1, 2, and 3 are similar to the steps 1, 2, and 3 of the new approach (see Section 3). Also, the steps Extracting Dependencies in Software and Formulating a Query are similar in both the approaches. The most relevant differences are concerned with the use of the BorderFlow clustering algorithm, the computation of the lexical similarity among pairs of methods that is not required in the new approach, and how the ranked list is obtained. Due to these differences, the new approach scales better on larger systems.