Brian P. Eddy

Configuring latent Dirichlet allocation based feature location

Feature location is a program comprehension activity, the goal of which is to identify source code entities that implement a functionality. Recent feature location techniques apply text retrieval models such as latent Dirichlet allocation (LDA) to corpora built from text embedded in source code. These techniques are highly configurable, and the literature offers little insight into how different configurations affect their performance. In this paper we present a study of an LDA based feature location technique (FLT) in which we measure the performance effects of using different configurations to index corpora and to retrieve 618 features from 6 open source Java systems. In particular, we measure the effects of the query, the text extractor configuration, and the LDA parameter values on the accuracy of the LDA based FLT. Our key findings are that exclusion of comments and literals from the corpus lowers accuracy and that heuristics for selecting LDA parameter values in the natural language context are suboptimal in the source code context. Based on the results of our case study, we offer specific recommendations for configuring the LDA based FLT.

Evaluating source code summarization techniques: Replication and expansion

During software evolution a developer must investigate source code to locate then understand the entities that must be modified to complete a change task. To help developers in this task, Haiduc et al. proposed text summarization based approaches to the automatic generation of class and method summaries, and via a study of four developers, they evaluated source code summaries generated using their techniques. In this paper we propose a new topic modeling based approach to source code summarization, and via a study of 14 developers, we evaluate source code summaries generated using the proposed technique. Our study partially replicates the original study by Haiduc et al. in that it uses the objects, the instruments, and a subset of the summaries from the original study, but it also expands the original study in that it includes more subjects and new summaries. The results of our study both support the findings of the original and provide new insights into the processes and criteria that developers use to evaluate source code summaries. Based on our results, we suggest future directions for research on source code summarization.

Efficient and scalable omniscient debugging for model transformations

This paper discusses a technique for supporting omniscient debugging for model transformations, which are used to define core operations on software and system models. Similar to software systems developed using general-purpose languages, model transformations are also subject to human error and may possess defects. Existing model-driven engineering tools provide stepwise execution to aid developers in locating and removing defects. In this paper, we describe our investigation into a technique and associated algorithms that support omniscient debugging features for model transformations. Omniscient debugging enables enhanced navigation and exploration features during a debugging session beyond those possible in a strictly stepwise execution environment. Finally, the execution time performance is comparatively evaluated against stepwise execution, and the scalability (in terms of memory usage) is empirically investigated.

Toward a metrics suite for source code lexicons

In this paper we present an empirical study of relationships between three source code lexicons: the identifier, comment, and literal lexicons. We conjecture that shared and unique properties of these lexicons for the given subject system can inform the configuration of a source code retrieval technique for a particular software understanding activity or software evolution task. Thus, we seek to discover these lexicon properties, and so we investigate five lexicon measures that consider term frequency, term density, and term provenance.

Using Structured Queries for Source Code Search

Software maintenance tasks such as feature location and traceability link recovery are search-oriented. Most of the recently proposed approaches for automation of search-oriented tasks are based on a traditional text retrieval (TR) model in which documents are unstructured representations of text and queries consist only of keywords. Because source code has structure, approaches based on a structured retrieval model may yield improved performance. Indeed, Saha et al. Recently proposed a feature location technique based on structured retrieval that offers improved performance relative to a technique based on traditional TR. Although they use abstract syntax tree (AST) information to structure documents, they nonetheless use content-only (keyword) queries to retrieve documents. In this paper we propose an approach to source code search using AST information to structure queries in addition to documents. Such queries, known as content and structure (CAS) queries, allow developers to search for source code entities based not only on content relevance, but also on structural similarity. After introducing the structured retrieval model, we provide examples that illustrate the trade-off between the simplicity of content-only queries and the power of CAS queries.

CDEP: Continuous Delivery Educational Pipeline

Due to the desire to decrease the time to market of modern applications and software, a number of new agile processes have emerged. Continuous integration and continuous delivery which allow developers to easily push changes to software are common practices in industry, however in education there seems to be a lack of teaching in these practices. This is because of the complexity that these practices entail by having to create an automated software development pipeline that tests and deploys software. These pipelines are often difficult to understand and the setup, configuration, and instruction of such a pipeline is often difficult to include in a traditional software engineering course. A lightweight and portable pipeline for educational purposes is required. This pipeline needs to be simple enough for easy setup and detailed enough to teach various aspects of continuous integration and delivery. This paper introduces the design and implementation of such a pipeline as well as the proposed usage in academia.

Impact of structural weighting on a latent Dirichlet allocation–based feature location technique

Text retrieval–based feature location techniques (FLTs) use information from the terms present in documents in classes and methods. However, relevant terms originating from certain locations (eg, method names) often comprise only a small part of the entire method lexicon. Feature location techniques should benefit from techniques that make greater use of this information. The primary objective of this study was to investigate how weighting terms from different locations in source code can improve a latent Dirichlet allocation (LDA)‐based FLT. We conducted an empirical study of 4 subject software systems and 372 features. For each subject system, we trained 1024 different LDA models with new weighting schemes applied to leading comments, method names, parameters, body comments, and local variables. We conducted both a quantitative and qualitative analysis to identify the effects of using the weighting schemes on the performance of the LDA‐based FLT. We evaluated weighting schemes based on mean reciprocal rank and spread of effectiveness measures. In addition, we conducted a factorial analysis to identify which locations have a main impact on the results of the FLT. We then examined the effects of adding information from class comments, class names, and fields to the top 10 configurations for each system. This results in an additional 640 different LDA models for each system. From our results, we identified a significant effect in the performance of an LDA‐based weighting configuration when applying our weighting schemes to the LDA‐based FLT. Furthermore, we found that adding information from each methods containing class can improve the effectiveness of an LDA‐based FLT. Finally, we identified a set of recommendations for identifying better weighting schemes for LDA.

Searching for answers: an exploratory study of the formation, use, and impact of queries during debugging

This paper presents the results of an exploratory study investigating the formation, use, and impact of queries during debugging tasks. The results of this study provide additional evidence regarding the impact of query-based debuggers and can inform efforts that are focused on developing and improving query-based debuggers.

Analysis of a High-Performance TSP Solver on the GPU

Graphical Processing Units have been applied to solve NP-hard problems with no known polynomial time solutions. An example of such a problem is the Traveling Salesman Problem (TSP). The TSP is one of the most commonly studied combinatorial optimization problems and has multiple applications in the areas of engineering, transportation, and logistics. This article presents an improved algorithm for approximating the TSP on fully connected, symmetric graphs by utilizing the GPU. Our approach improves an existing 2-opt hill-climbing algorithm with random restarts by considering multiple updates to the current path found in parallel, and it allows k number of updates per iteration, called k-swap. With our k-swap modification, we show a speed-up over the existing algorithm of 4.5× to 22.9× on data sets ranging from 1,400 to 33,810 nodes, respectively.

Structured source retrieval for improving softwaresearch during program comprehension tasks

During the software maintenance and evolution phase, the majority of a developers time is spent on programming comprehension tasks. Feature location (i.e., finding the first location to make a modification), impact analysis (i.e., determining what and to what extent a program is affected by a change), and traceability (i.e., determining where requirements are implemented in the program), are all examples of such tasks. Recent research in the area of program comprehension has focused on using textual information, structural information (i.e., information regarding the creation and use of objects and methods within the code), and execution traces to develop tools that ease the burden on developers and decrease the time spent in each task. Furthermore, new studies in automating these tasks have started using text retrieval techniques, such as the vector space model (VSM), latent semantic indexing (LSI), and latent Dirichlet allocation (LDA) for searching software. This doctoral symposium summary presents two promising areas for improving existing techniques by combining structural information with text retrieval. The first is a methodology for evaluating the usefulness of text obtained from a program by looking at the structural location of terms (e.g., method name, comments, identifiers). The second focuses on improving the existing text retrieval approaches by providing more flexible queries (i.e., search strings). These two areas are complementary to each other and may be combined.