Juergen Rilling

Dynamic program slicing methods

Abstract A dynamic program slice is that part of a program that “affects” the computation of a variable of interest during program execution on a specific program input. Dynamic program slicing refers to a collection of program slicing methods that are based on program execution and may significantly reduce the size of a program slice because run-time information, collected during program execution, is used to compute program slices. Dynamic program slicing was originally proposed only for program debugging, but its application has been extended to program comprehension, software testing, and software maintenance. Different types of dynamic program slices, together with algorithms to compute them, have been proposed in the literature. In this paper we present a classification of existing dynamic slicing methods and discuss the algorithms to compute dynamic slices. In the second part of the paper, we compare the existing methods of dynamic slice computation.

Dynamic program slicing in understanding of program execution

A dynamic program slice is an executable part of a program whose behavior is identical, for the same program input, to that of an original program with respect to a variable(s) of interest at some execution position. In the existing dynamic slicing tools, dynamic slices are represented in the textual form, i.e., a dynamic slice is displayed to programmers as a subprogram or as highlighted statements in the original program. Although dynamic slicing does narrow the size of the program, the textual representation of a dynamic slice does not provide much guidance in the understanding of program execution. During dynamic slice computation different types of information are computed and then discarded. In this paper we propose new dynamic-slicing related features that exploit this information for the purpose of understanding program execution. These features were implemented in the dynamic slicing tool that is used to improve the process of program understanding.

Identifying comprehension bottlenecks using program slicing and cognitive complexity metrics

Achieving and maintaining high software quality is most dependent on how easily the software engineer least familiar with the system can understand the systems code. Understanding attributes of cognitive processes can lead to new software metrics that allow the prediction of human performance in software development and for assessing and improving the understandability of text and code. In this research we present novel metrics based on current understanding of short-term memory performance to predict the location of high frequencies of errors and to evaluate the quality of a software system. We further enhance these metrics by applying static and dynamic program slicing to provide programmers with additional guidance during software inspection and maintenance efforts.

Change impact analysis for requirement evolution using use case maps

Changing customer needs and computer technology are the driving factors influencing software evolution. There is a need to assess the impact of these changes on existing software systems. Requirement specification is gaining increasingly attention as a critical phase of software systems development process. In particular for larger systems, it quickly becomes difficult to comprehend what impact a requirement change might have on the overall system or parts of the system. Thus, the development of techniques and tools to support the evolution of requirement specifications becomes an important issue. In this paper we present a novel approach to change impact analysis at the requirement level. We apply both slicing and dependency analysis at the use case map specification level to identify the potential impact of requirement changes on the overall system. We illustrate our approach and its applicability with a case study conducted on a simple telephony system.

Spotting working code examples

Working code examples are useful resources for pragmatic reuse in software development. A working code example provides a solution to a specific programming problem. Earlier studies have shown that existing code search engines are not successful in finding working code examples. They fail in ranking high quality code examples at the top of the result set. To address this shortcoming, a variety of pattern-based solutions are proposed in the literature. However, these solutions cannot be integrated seamlessly in Internet-scale source code engines due to their high time complexity or query language restrictions. In this paper, we propose an approach for spotting working code examples which can be adopted by Internet-scale source code search engines. The time complexity of our approach is as low as the complexity of existing code search engines on the Internet and considerably lower than the pattern-based approaches supporting free-form queries. We study the performance of our approach using a representative corpus of 25,000 open source Java projects. Our findings support the feasibility of our approach for Internet-scale code search. We also found that our approach outperforms Ohloh Code search engine, previously known as Koders, in spotting working code examples.

Program slicing in understanding of large programs

Program slicing transforms a large program into a smaller one that contains only statements relevant to the computation of a given function. It has been shown that program slicing can be useful in program understanding. Traditionally, program slices are represented in the textual form. Although slicing does narrow the size of the program, the textual representation of a slice does not provide much guidance in the understanding of large programs. In this paper we present program slicing concepts on the module level that allow for better understanding of program slices of large programs and their executions. These concepts have been developed for static and dynamic program slicing and are combined with different methods of visualization to guide programmers in the process of program understanding. The presented concepts have been implemented in the slicing tool that is used to investigate the usefulness of these concepts in the process of understanding of large programs.

Software Clustering Using Dynamic Analysis and Static Dependencies

Decomposing a software system into smaller, more manageable clusters is a common approach to support the comprehension of large systems. In recent years, researchers have focused on clustering techniques to perform such architectural decomposition, with the most predominant clustering techniques relying on the static analysis of source code. We argue that these static structural relationships are not sufficient for software clustering due to the increased complexity and behavioral aspects found in software systems. In this paper, we present a novel software clustering approach that combines dynamic and static analysis to identify component clusters. We introduce a two-phase clustering technique that combines software features to build a core skeleton decomposition with structural information to further refine these clusters. A case study is presented to evaluate the applicability and effectiveness of our approach.

An Approach for Mapping Features to Code Based on Static and Dynamic Analysis

System evolution depends greatly on the ability of a maintainer to locate source code that is specific to feature implementation. Existing feature location techniques require either exercising several features of the system, or rely heavily on domain experts to guide the feature location process. In this paper, we present a novel approach for feature location that combines static and dynamic analysis techniques. An execution trace is generated by exercising the feature under study (dynamic analysis). A component dependency graph (static analysis) is used to rank the components invoked in the trace according to their relevance to the feature. Our ranking technique is based on the impact of a component modification on the rest of the system. The proposed approach is automatic to a large extent relieving users from any decision that would otherwise require extensive domain knowledge of the system. A case study is presented to support and evaluate the applicability of our approach.

Ontological approach for the semantic recovery of traceability links between software artefacts

Traceability links provide support for software engineers in understanding relations and dependencies among software artefacts created during the software development process. The authors focus on re-establishing traceability links between existing source code and documentation to support software maintenance. They present a novel approach that addresses this issue by creating formal ontological representations for both documentation and source code artefacts. Their approach recovers traceability links at the semantic level, utilising structural and semantic information found in various software artefacts. These linked ontologies are supported by ontology reasoners to allow the inference of implicit relations among these software artefacts.

A cognitive complexity metric based on category learning

Software development is driven by software comprehension. Controlling a software development process is dependent on controlling software comprehension. Measures of factors that influence software comprehension are required in order to achieve control. The use of high-level languages results in many different kinds of lines of code that require different levels of comprehension effort. As the reader learns the set of arrangements of operators, attributes and labels particular to an application, comprehension is eased as familiar arrangements are repeated. Elements of cognition that describe the mechanics of comprehension serve as a guide to assessing comprehension demands in the understanding of programs written in high level languages. A new metric, kinds of lines of code identifier density is introduced and a case study demonstrates its application and importance. Related work is discussed.