Software engineers organize source code into a dominant hierarchy of components and modules that may emphasize various characteristics over runtime behavior. In this way, runtime features may involve cross-cutting aspects of code from multiple components, and some of these features may be emergent in nature, rather than designed. Although source-code modularization assists software engineers to organize and find components, identifying such cross-cutting feature sets can be more difficult. This work presents a visualization that includes a static (i.e., compile-time) representation of source code that gives prominence to clusters of cooperating source-code instructions to identify dynamic (i.e., runtime) features and constituent behaviors within executions of the software. In addition, the visualization animates software executions to reveal which feature clusters are executed and in what order. The result has revealed the principal behaviors of software executions, and those behaviors were revealed to be (in some cases) cohesive, modular source-code structures and (in other cases) cross-cutting, emergent behaviors that involve multiple modules. In this paper, we describe our system (Cerebro), envisage the uses to which it can be put, and evaluate its ability to reveal emergent runtime features and internal constituent behaviors of execution. We found that: (1) the visualization revealed emergent and commonly occuring functionalities that cross-cut the structural decomposition of the system; (2) four independent judges generally agreed in their interpretations of the code clusters, especially when informed only by our visualization; and (3) interacting with the external interface of an application while simultaneously observing the internal execution facilitated localization of code that implements the features and functionality evoked externally.

@inproceedings{ palepu15sep,
author = "Vijay Krishna Palepu and James A. Jones",
title = "Revealing Runtime Features and Constituent Behaviors within Software",
booktitle = "Proceedings of the IEEE Working Conference on Software Visualization (VISSOFT)",
year = "2015",
month = "September",
pages = "1--10",
}

Today, many of the research innovations in software visualization and comprehension are evaluated on small-scale programs in a way that avoids actual human evaluation, despite the fact that these techniques are designed to help programmers develop and understand large and complex software. The investments required to perform such human studies often outweigh the need to publish. As such, the goal of this work (and toolkit) is to enable the evaluation of software visualizations of real-life software systems by its actual developers, as well as to understand the factors that influence adoption. The approach is to directly assist practicing software developers with visualizations through open and online collaboration tools. The mechanism by which we accomplish this goal is an online service that is linked through the projects' revision-control and build systems. We are calling this system Spider SENSE, and it includes web-based visualizations for software exploration that is supported by tools for mirroring development activities, automatic building and testing, and automatic instrumentation to gather dynamic-analysis data. In the future, we envision the system and toolkit to become a framework on which further visualizations and analyses are developed. Spider SENSE is open-source and publicly available for download and collaborative development.

@inproceedings{ ,
author = "Nishaanth H. Reddy and Junghun Kim and Vijay Krishna Palepu and James A. Jones",
title = "Spider SENSE: Software-Engineering, Networked, System Evaluation",
booktitle = "Proceedings of the IEEE Working Conference on Software Visualization, Tool Track (VISSOFT-Tool)",
year = "2015",
month = "September",
pages = "1--5",
}

Dynamic slicing is an analysis that operates on program execution models (e.g., dynamic dependence graphs) to support the interpreation of program-execution traces. Given an execution event of interest (i.e., the slicing criterion), it solves for all instruction-execution events that either *affect* or *are affected by* that slicing criterion, and thereby reduces the search space to find influences within execution traces. Unfortunately, the resulting dynamic slices are still often prohibitively large for many uses. Despite this reduction search space, the dynamic slices are often still prohibitively large for many uses, and moreover, are provided without guidance of which and to what degree those influences are exerted. In this work, we present a novel approach to quantify the relevance of each instruction-execution event within a dynamic slice by its degree of relative influence on the slicing criterion. As such, we augment the dynamic slice with dynamic-relevance measures for each event in the slice, which can be used to guide and prioritize inspection of the events in the slice. We conducted an experiment that evaluates the ability of existing dynamic slicing and our approach, using dynamic relevance, to correctly identify sources of execution influence and state propagation. The results of the experiment show that inspections that were guided by traditional dynamic slicing to find the root cause for a failure reduced the search space by, on average, 61.3%. Further, inspections guided with the assistance of the new dynamic relevance reduced the search space by 96.2%.

@inproceedings{ palepu14sep,
author = "Vijay Krishna Palepu and James A. Jones",
title = "Discriminating Influences among Instructions in a Dynamic Slice",
booktitle = "Proceedings of the International Conference on Automated Software Engineering, New Idea Track (ASE-NIER)",
year = "2014",
month = "September",
}

Modern applications make heavy use of third-party libraries and components, which poses new challenges for efficient dynamic analysis. To perform such analyses, transitive dependent components at all layers of the call stack must be monitored and analyzed, and as such may be prohibitively expensive for systems with large libraries and components. As an approach to address such expenses, we record, summarize, and reuse dynamic dataflows between inputs and outputs of components, based on dynamic control and data traces. These summarized dataflows are computed at a fine-grained instruction level; the result of which, we call "dynamic dependence summaries." Although static summaries have been proposed, to the best of our knowledge, this work presents the first technique for dynamic dependence summaries. The benefits to efficiency of such summarization may be afforded with losses of accuracy. As such, we evaluate the degree of accuracy loss and the degree of efficiency gain when using dynamic dependence summaries of library methods. On five large programs from the DaCapo benchmark (for which no existing whole-program dynamic dependence analyses have been shown to scale) and 21 versions of NanoXML, the summarized dependence analysis provided 90% accuracy and a speed-up of 100% (i.e., ×2), on average, when compared to traditional exhaustive dynamic dependence analysis.

@inproceedings{ palepu13nov,
author = "Vijay Krishna Palepu and Guoqing Xu and James A. Jones",
title = "Improving Efficiency of Dynamic Analysis with Dynamic Dependence Summaries",
booktitle = "28th IEEE/ACM International Conference on Automated Software Engineering (ASE)",
year = "2013",
month = "November",
pages = "59--69",
}

In this New-Ideas-and-Emerging-Results paper, we present a novel visualization, The Brain, that reveals clusters of source code that co-execute to produce behavioral features of the program throughout and within executions. We created a clustered visualization of source-code that is informed by dynamic control flow of multiple executions; each cluster represents commonly interacting logic that composes software features. In addition, we render individual executions atop the clustered multiple-execution visualization as user-controlled animations to reveal characteristics of specific executions—these animations may provide exemplars for the clustered features and provide chronology for those behavioral features, or they may reveal anomalous behaviors that do not fit with the overall operational profile of most executions. Both the clustered multiple-execution view and the animated individual-execution view provide insights for the constituent behaviors within executions that compose behaviors of whole executions. Inspired by neural imaging of human brains of people who were subjected to various external stimuli, we designed and implemented The Brain to reveal program activity during execution. The result has revealed the principal behaviors of execution, and those behaviors were revealed to be (in some cases) cohesive, modular source-code structures and (in other cases) cross-cutting, emergent behaviors that involve multiple modules. In this paper, we describe The Brain and envisage the uses to which it can be put, and we provide two example usage scenarios to demonstrate its utility.

@inproceedings{ palepu13sep,
author = "Vijay Krishna Palepu and James A. Jones",
title = "Visualizing Constituent Behaviors within Executions",
booktitle = "1st IEEE Working Conference on Software Visualization, New Ideas and Emerging Results Track (VISSOFT-NIER)",
year = "2013",
month = "September",
pages = "1--4",
}

In this paper, we present a weighted, hybrid program-dependence model that represents the relevance of highly related, dependent code to assist developer comprehension of the program for multiple software-engineering tasks. Programmers often need to understand the dependencies among program elements, which may exist across multiple modules. Although such dependencies can be gathered from traditional models, such as slices, the scalability of these approaches is often prohibitive for direct, practical use. To address this scalability issue, as well as to assist developer comprehension, we introduce a program model that includes static dependencies as well as information about any number of executions, which inform the weight and relevance of the dependencies. Additionally, classes of executions can be differentiated in such a way as to support multiple software-engineering tasks. We evaluate this weighted, hybrid model for a task that involves exploring the structural context while debugging. The results demonstrate that the new model more effectively reveals relevant failure-correlated code than the static-only model, thus enabling a more scalable exploration or post hoc analysis.

@inproceedings{ deng12apr,
author = "Fang Deng and James A. Jones",
title = "Weighted System Dependence Graph",
booktitle = "Fifth International Conference on Software Testing, Verification and Validation (ICST)",
year = "2012",
month = "April",
pages = "380--389",
}

This paper provides techniques for aiding developers' task of familiarizing themselves with the context of a fault. Many fault-localization techniques present the software developer with a subset of the program to inspect in order to aid in the search for faults that cause failures. However, typically, these techniques do not describe how the components of the subset relate to each other in a way that enables the developer to understand how these components interact to cause failures. These techniques also do not describe how the subset relates to the rest of the program in a way that enables the developer to understand the context of the subset. In this paper, we present techniques for providing static and dynamic relations among program elements that can be used as the basis for the exploration of a program when attempting to understand the nature of faults.

@inproceedings{ deng11nov,
author = "Fang Deng and James A. Jones",
title = "Inferred Dependence Coverage to Support Fault Contextualization",
booktitle = "Proceedings of the 26th IEEE/ACM International Conference on Automated Software Engineering (ASE), Short paper track",
year = "2011",
month = "November",
pages = "512--515",
}

This paper presents a scalable, statement-level visualization that shows related code in a way that supports human interpretation of clustering and context. The visualization is applicable to many software-engineering tasks through the utilization and visualization of problem-specific meta-data. The visualization models statement-level code relations from a system-dependence-graph model of the program being visualized. Dynamic, run-time information is used to augment the static program model to further enable visual cluster identification and interpretation. In addition, we performed a user study of our visualization on an example program domain. The results of the study show that our new visualization successfully revealed relevant context to the programmer participants.

@inproceedings{ deng11sep,
author = "Fang Deng and Nicholas DiGiuseppe and James A. Jones",
title = "Constellation Visualization: Augmenting Program Dependence with Dynamic Information",
booktitle = "Proceedings of the 6th IEEE International Workshop on Visualizing Software for Understanding and Analysis (VISSOFT)",
year = "2011",
month = "September",
pages = "1--8",
}

Despite the many automated techniques that benefit from dynamic invariant detection, to date, none are able to capture and detect dynamic invariants at the interface of a program and its databases. This paper presents a dynamic invariant detection method for relational databases and for programs that use relational databases and an implementation of the approach that leverages the Daikon dynamic-invariant engine. The method defines a mapping between relational database elements and Daikon’s notion of program points and variable observations, thus enabling row-level and column-level invariant detection. The paper also presents the results of two empirical evaluations on four fixed data sets and three subject programs. The first study shows that dynamically detecting and inferring invariants in a relational database is feasible and 55% of the invariants produced for each subject are meaningful. The second study reveals that all of these meaningful invariants are schema-enforceable using standards-compliant databases and many can be checked by databases with only limited schema constructs.

@inproceedings{ cobb11,
author = "Jake Cobb and Gregory M. Kapfhammer and James A. Jones and Mary Jean Harrold",
title = "Dynamic Invariant Detection for Relational Databases",
booktitle = "Proceedings of the Ninth International Workshop on Dynamic Analysis (WODA)",
year = "2011",
month = "July",
pages = "12--17",
}

As software evolves during development and maintenance, regression testing is applied to modified versions of the software to provide confidence that the changed parts behave as intended and that the unchanged parts have not been adversely affected by the modifications. To reduce the cost of regression testing, test cases are selected from the test suite that was used to test the original version of the software---this process is called regression test selection. A safe regression-test-selection algorithm selects every test case in the test suite that may reveal a fault in the modified software. Safe regression-test-selection techniques can help to reduce the time required to perform regression testing because they select only a portion of the test suite for use in the testing but guarantee that the faults revealed by this subset will be the same as those revealed by running the entire test suite. This paper presents the first safe regression-test-selection technique that, based on the use of a suitable representation, handles the features of the Java language. Furthermore, unlike other safe regression test selection techniques, the presented technique also handles incomplete programs. The technique can thus be safely applied in the (very common) case of Java software that uses external libraries or components; the analysis of the external code is not required for the technique to select test cases for this kind of software. The paper also describes RETEST, a regression-test-selection system that implements our technique, and a set of empirical studies that demonstrate the potential savings that can be achieved using our technique. These studies show that, for the subjects we considered, the regression-test-selection algorithm can be effective in reducing the size of the test suite.

@inproceedings{ harrold01oct,
author = "Mary Jean Harrold and James A. Jones and Tongyu Li and Donglin Liang and Alessandro Orso and Maikel Pennings and Saurabh Sinha and S. Alexander Spoon and Ashish Gujarathi",
title = "Regression Test Selection for Java Software",
booktitle = "Proceedings of the ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)",
year = "2001",
month = "October",
pages = "312--326",
}

Many tools and techniques for performing software engineering tasks require control dependence information, represented in the form of control dependence graphs. Worst-case analysis of these graphs has shown that their size may be quadratic in the number of statements in the procedure that they represent. Despite this result, two empirical studies suggest that in practice, the relationship between control dependence graph size and program size is linear. These studies, however, were performed on a relatively small number of Fortran procedures, all of which were derived from numerical methods programs. To further investigate control dependence size, we implemented tools for constructing the two most popular types of control dependence graphs, and ran our tools on over 3000 C functions extracted from a wide range of source programs. Our results support the earlier conclusions about control dependence graphs size.

@article{ harrold98,
author = "Mary Jean Harrold and James A. Jones and Gregg Rothermel",
title = "Empirical Studies of Program Dependence Graph Size for C Programs",
journal = "Empirical Software Engineering Journal",
year = "1998",
volume = "3",
number = "2",
pages = "203--211",
month = "March",
}