Program slicing is a technique for automatically identifying all the lines in a program which affect a selected subset of variables. A large program can be divided into a number of smaller programs (its slices), each constructed for different variable subsets. The slices are typically simpler than the original program, thereby simplifying the process of testing a property of the program which only concerns a subset of its variables. Some aspects of a program's computation are not captured by a set of variables, rendering slicing inapplicable. To overcome this difficulty we make a program introspective, adding assignments to denote these `implicit' computations. Initially this makes the program longer. However, slicing can now be applied to the introspective program, forming a slice concerned solely with the implicit computation. We improve the simplification power of slicing using program transformation. To illustrate our approach we consider the implicit computation which ...

Program Slicing is the process of deleting statements in a program that do not affect a given set of variables at a chosen point in the program. In this paper the first parallel slicing algorithm for static program slicing is introduced. It is shown how the control flow graph of the program to be sliced is converted into a network of concurrent processes, thereby producing a parallel version of Weiser's original static slicing algorithm. The parallel slicing algorithm is formally defined as the least solution (containing the slicing criterion) of a set of recursion equations, derived from the program's control flow graph and is proved correct with respect to Weiser's algorithm. The parallel slicing algorithm has a number of other interesting and potentially useful properties. For example, in addition to constructing a slice, it produces a set of equivalent slicing criteria for the slice it constructs.

Software reengineering is a costly endeavor, due in part to the ambiguity of where to focus reengineering effort. Coupling and Cohesion metrics, particularly quantitative cohesion metrics, have the potential to aid in this identification and to measure progress. The most extensive work on such metrics is with slice-based cohesion metrics. While their use of semantic dependence information should make them an excellent choice for cohesion measurement, their wide spread use has been impeded in part by a lack of empirical study. Recent advances in software tools make, for the first time, a large-scale empirical study of slicebased cohesion and coupling metrics possible. Four results from such a study are presented. First, “head-to-head ” qualitative and quantitative comparisons of the metrics identify which metrics provide similar views of a program and which provide unique views of a program. This study includes statistical analysis showing that slice-based metrics are not proxies for simple size-based metrics such as lines of code. Second, two longitudinal studies show that slice-based metrics quantify the deterioration of a program as it ages. This serves to validate the metrics: the metrics quantify the degradation that exists during development; turning this around, the metrics can be used to measure the progress of a reengineering effort. Third, base-line values for slicebased metrics are provided. These values act as targets for reengineering efforts with modules having values outside the expected range being the most in need of attention. Finally, slice-based coupling is correlated and compared with slice based cohesion.

Program slicing is a technique for program simplification based upon the deletion of statements which cannot affect the values of a chosen set of variables. Because slicing extracts a subcomponent of the program concerned with some specific computation on a set of variables, it can be used to assist program comprehension, allowing a programmer to remodularise a program according to arbitrarily selected slicing criteria. In this paper it is shown that the simplification power of slicing can be improved if the syntactic restriction to statement deletion is removed, allowing slices to be constructed using any simplifying transformation which preserves the effect of the original program upon the set of variables of interest. It is also shown that quasi static slicing, first proposed by Venkatesh (and defined here in a slightly more general form), is the most suitable slicing paradigm for program comprehension. The various forms of slice are formally defined, an algorithm, based upon transf...

In this paper we outline an approach to coupling measurement based upon program slicing. We claim that our coupling metric produces more precise measurements than related information-flowbased metrics. A prototype tool has been implemented to calculate these metrics. The next step is to evaluate the coupling (and related cohesion) metrics with respect to some hypotheses relating to the predication systems in which we claim they may be embedded.

We argue for a `question--and--answer' approach to source code analysis based upon program projection. With our approach, the questions concern the behaviour of a program with respect to a projection of its semantics. The answers to such question are, themselves, programs. The programs produced as answers only preserve a projection of the semantics of the original program, however, and thus they can be simpler than the original. We use the term `projection' for a simplified version of a program which maintains a projection of the semantics of the original. Our program projections are based upon program slices, but we extend the slicing technique to include program transformation. This allows us to both improve upon the simplification power of program slicing in the construction of a projection, and to extend the application area of slicing to include implicit aspects of program quality, not captured by a subset of its variables. We give examples demonstrating how projection leads to si...

Program slicing is a technique for program simplification based upon the deletion of statements which cannot affect the values of a chosen set of variables. Because slicing extracts a subcomponent of the program concerned with some specific computation on a set of variables, it can be used to assist program comprehension, allowing a programmer to remodularise a program according to arbitrarily selected slicing criteria. In this paper it is shown that the simpli cation power of slicing can be improved if the syntactic restriction to statement deletion is removed, allowing slices to be constructed using any simplifying transformation which preserves the effect of the original program upon the set of variables of interest. It is also shown that quasi static slicing, first proposed by Venkatesh (and defined here in a slightly more general form), is the most suitable slicing paradigm for program comprehension. The various forms of slice are formally defined, an algorithm, based upon transformation, symbolic execution and conventional slicing is introduced for computing syntactically unrestricted, quasi static slices. A worked example is used to show how this approach supports program comprehension by case analysis and simplification.

Program Slicing is the process of deleting statements in a program that do not affect a given set of variables at a chosen point in the program. In this paper the first parallel slicing algorithm for static program slicing is introduced. It is shown how the control flow graph of the program to be sliced is converted into a network of concurrent processes, thereby producing a parallel version of Weiser’s original static slicing algorithm.

A large number of software metrics have been proposed in the literature, but there is little understanding of how these metrics relate to one another. We propose a novel experimental technique, based on search-based refactoring, to assess software metrics and to explore relationships between them. Our goal is not to improve the program being refactored, but to assess the software metrics that guide the automated refactoring through repeated refactoring experiments. We apply our approach to five popular cohesion metrics using eight real-world Java systems, involving 300,000 lines of code and over 3,000 refactorings. Our results demonstrate that cohesion metrics disagree with each other in 55 % of cases, and show how our approach can be used to reveal novel and surprising insights into the software metrics under investigation. Categories and Subject Descriptors D.2.8 [Software Engineering]: Metrics—Complexity measures;