A program slice extracts a semantically meaningful portion of a program, based upon a user-selected slicing criterion. As the study of program slicing has matured, a growing body of empirical data has been gathered on the size of slices, the performance of slicing tools, the applications of slicing and the beneficial psychological effects of slices on the programmers who use them. This paper presents a survey of these results, highlighting trends and areas where additional empirical investigation is required, either because of contradictory findings or scarcity of results in the existing body of empirical evidence.

Empirical data concerning the qualitative and quantitative nature of program dependence is presented for a set of 20 programs ranging from 600 lines of code to 167,000 lines of code. The sources of dependence considered are global variables and formal parameters and the targets considered are a program's predicate nodes. The results show that as the number of formal parameters available to a predicate increases, there is a decrease in the proportion of these formal parameters which are depended upon by the predicate. No such correlation was found for global variables. Results from theoretical and actual computation time analysis indicate that the computation of dependence information is practical, suggesting that the analysis may be beneficial to several application areas. The paper also presents results concerning correlations that provide strong evidence that the global and formal dependence sources are independent of one another and that the numbers of globals and formals are independent of the size of the procedure that contains them. Finally, two visualization techniques for displaying dependence information are introduced. Illustrations show how these visualizations and predicate dependence analysis can assist in activities such as testing, comprehension, and evolution.

A dependence cluster is a set of program statements, all of which are mutually inter-dependent. This paper reports a large scale empirical study of dependence clusters in C program source code. The study reveals that large dependence clusters are surprisingly commonplace. Most of the 45 programs studied have clusters of dependence that consume more than 10 % of the whole program. Some even have clusters consuming 80 % or more. The widespread existence of clusters has implications for source code analyses such as program comprehension, software maintenance, software testing, reverse engineering, reuse, and parallelization.

Program slice is a set of statements that affect the value of variable v in a statement s. In order to calculate a program slice, we must know the dependence relations between statements in the program. Program slicing techniques are roughly divided into two categories, static slicing and dynamic slicing, and we have proposed DC slicing technique which uses both static and dynamic information.

This paper proposes analysis models for representing processes of debugging unfamiliar programs focusing on how engineers comprehend each software module and locate a bug. Since actual debugging strategies relate to engineers' impressions of each software module -- either the module is faulty, not faulty or uncertain, proposed models consider both mental- and external- activities of engineers. We applied periodic interviewing method for quantitatively capturing engineers' mental activities. By characterizing target programs from multiple viewpoints such as module dependences and program slicing, engineers' debugging activities were analyzed in details based on the models. KEYWORDS# program comprehension, software maintenance, program slicing, bug localization INTRODUCTION# Recently, it is getting more and more important for software engineers to be able to quickly find and remove bugs in unfamiliar programs. Software maintenance groups often need to debug programs that are n...

When we try to debug or to comprehend a large program, it is important to separate suspicious program portions from the overall source program. Program slicing is a promising technique used to extract a program portion; however, such slicing sometimes raises difficulties. Static slicing sometimes produces a large portion of a source program, especially for programs with array and pointer variables, and dynamic slicing requires unacceptably large run-time overhead. In this paper, we propose a slicing method named "dependence-cache slicing", which uses both static and dynamic information. An algorithm has been implemented in our experimental slicing system, and execution data for several sample programs have been collected. The results show that dependence-cache slicing reduces a slice size by 30--90% from static slice size with an increased and affordable run-time overhead, even for programs using array variables. In the future, the dependence-cache slicing will become an important feature for effective debugging environments. 1.

Abstract. This study explores the relationship between program slices and faults. The aim is to investigate whether the characteristics of program slices can be used to identify faultprone software components. Slicing metrics and dependence clusters are used to characterise the slicing profile of a software component, then the relationship between the slicing profile of the component and the faults in that component are then analysed. Faults can increase the likelihood of a system becoming unstable causing problems for the development and evolution of the system. Identifying faultprone components is difficult and reliable predictors of faultproneness not easily identifiable. Program slicing is an established software engineering technique for the detection and correction of specific faults. An investigation is carried out into whether the use of program slicing can be extended as a reliable tool to predict fault-prone software components. Preliminary results are promising suggesting that slicing may offer valuable insights into fault-proneness.

Debugging is notoriously difficult and extremely time consuming. Researchers have therefore invested a considerable amount of effort in developing automated techniques and tools for supporting various debugging tasks. Although potentially useful, most of these techniques have yet to demonstrate their practical effectiveness. One common limitation of existing approaches, for instance, is their reliance on a set of strong assumptions on how developers behave when debugging (e.g., the fact that examining a faulty statement in isolation is enough for a developer to understand and fix the corresponding bug). In more general terms, most existing techniques just focus on selecting subsets of potentially faulty statements and ranking them according to some criterion. By doing so, they ignore the fact that understanding the root cause of a failure typically involves complex activities, such as navigating program dependencies and rerunning the program with different inputs. The overall goal of this research is to investigate how developers use and benefit from automated debugging tools through a set of human studies. As a first step in this direction, we perform a preliminary study on a set of developers by providing them with an automated debugging tool and two tasks to be performed with and without the tool. Our results provide initial evidence that several assumptions made by automated debugging techniques do not hold in practice. Through an analysis of the results, we also provide insights on potential directions for future work in the area of automated debugging.