A program slice consists of the parts of a program that (potentially) affect the values computed at some point of interest, referred to as a slicing criterion. The task of computing program slices is called program slicing. The original definition of a program slice was presented by Weiser in 1979. Since then, various slightly different notions of program slices have been proposed, as well as a number of methods to compute them. An important distinction is that between a static and a dynamic slice. The former notion is computed without making assumptions regarding a program's input, whereas the latter relies on some specific test case. Procedures, arbitrary control flow, composite datatypes and pointers, and interprocess communication each require a specific solution. We classify static and dynamic slicing methods for each of these features, and compare their accuracy and efficiency. Moreover, the possibilities for combining solutions for different features are investigated....

The conventional notion of a program slice---the set of all statements that might affect the value of a variable occurrence---is totally independent of the program input values. Program debugging, however, involves analyzing the program behavior under the specific inputs that revealed the bug. In this paper we address the dynamic counterpart of the static slicing problem---finding all statements that really affected the value of a variable occurrence for the given program inputs. Several approaches for computing dynamic slices are examined. The notion of a Dynamic Dependence Graph and its use in computing dynamic slices is discussed. We introduce the concept of a Reduced Dynamic Dependence Graph whose size does not depend on the length of execution history, which is unbounded in general, but whose size is bounded and is proportional to the number of dynamic slices arising during the program execution.

Program slicing, introduced by Weiser, is known to help programmers in understanding foreign code and in debugging. We apply program slicing to the maintenance problem by extending the notion of a program slice (that originally required both a variable and line number) to a decomposition slice, one that captures all computation on a given variable; i.e., is independent of line numbers. Using the lattice of single variable decomposition slices, ordered by set inclusion, we demonstrate how to form a slice-based decomposition for programs. We are then able to delineate the effects of a proposed change by isolating those effects in a single component of the decomposition. This gives maintainers a straightforward technique for determining those statements and variables that may be modified in a component and those that may not. Using the decomposition, we provide a set of principles to prohibit changes that will interfere with unmodified components. These semantically consistent ch...

We examine the functional cohesion of procedures using a data slice abstraction. Our analysis identifies the data tokens that lie on more than one slice as the "glue" that binds separate components together. Cohesion is measured in terms of the relative number of glue tokens, tokens that lie on more than one data slice, and super-glue tokens, tokens that lie on all data slices in a procedure, and the adhe- siveness of the tokens. The intuition and measurement scale factors are demonstrated through a set of abstract transfor- mations.

Program slicing is a decomposition technique that elides program components not relevant to a chosen computation, referred to as a slicing criterion. The remaining components form an executable program called a slice that computes a projection of the original program’s semantics. Using examples coupled with fundamental principles, a tutorial introduction to program slicing is presented. Then applications of program slicing are surveyed, ranging from its first use as a debugging technique to current applications in property verification using finite state models. Finally, a summary of research challenges for the slicing community is discussed.

This paper presents a dynamic technique for statistically estimating three program characteristics that affect a program's computational behavior: (1) the probability that a particular section of a program is executed, (2) the probability that the particular section affects the data state, and (3) the probability that a data state produced by that section has an effect on program output. These three characteristics can be used to predict whether faults are likely to be uncovered by software testing.

Traditional, syntax-preserving program slicing simpli es a program by deleting components (e.g., statements and predicates) that do not aect a computation of interest. Amorphous slicing removes the limitation to component deletion as the only means of simpli cation, while retaining the semantic property that a slice preserves the selected behaviour of interest from the original program. This leads to slices which are often considerably smaller than their syntax-preserving counterparts.

Software testing is very Iahor intensive and expensive and accounts for a significant portion of software system development cost. If the testing process could he automated, the cost of develaplng software could be significantly reduced, Test data generation in program testing is the proc(,ss of identifying a set of test data that satisfies a selected testing criterion, such as statement coverage and branch coverage. In this article we present a chain~ng approach for automated s.oftlvarc test data generation which builds on the current theory of execution-oriented test data gcn[,ration In the chaining approach, test data are derived based on the actual execwtinn of the program under test, For many programs, the execution of the selected statement may require prior execution of some other statements. The existing methods of test data generstioo may not efficiently generate test data for these types of programs because they only use control flow information of a program during the search process. The chaining ~pproach US(>Sdata dependence analysis to guide the search process, i.e., data dependence snaly~l> autt)maticall ~ identifies statements that affect the execution of the selected statement ‘f’h(,chaining approach uses these statements to form a sequence of statements that is to be executed prior to the execution of the selected statement. The experiments have shown

There is significant room for improving users' experiences with model checking tools. An error trace produced by a model checker can be lengthy and is indicative of a symptom of an error. As a result, users can spend considerable time examining an error trace in order to understand the cause of the error. Moreover, even state-of-the-art model checkers provide an experience akin to that provided by parsers before syntactic error recovery was invented: they report a single error trace per run. The user has to fix the error and run the model checker again to find more error traces.

Previous work has shown that a relationship exists between cohesion and the slice profile of a program. In this paper, we explore the use of several metrics based on such slice profiles to give a quantitative estimate of the level of cohesion in a module. Example modules are used to analyze the behavior of the metric values as the modules are modified such that the cohesion is changed. The sensitivity of the metrics to the various types of changes is discussed. 1 Introduction High module cohesion, as defined by Constantine and Yourdon [3], is often suggested as a desirable property of program modularity. However, cohesion, as originally defined, is a subjective measure and the subjective nature of the definition of cohesion makes it difficult to use in practice. Because of this, several researchers have attempted to make this concept more tangible. These include the suggested use of a decision tree as proposed by Page-Jones [21], relating the cohesiveness of a module to its program de...