Owing to its relative simplicity and wide range of applications, static slices are specifically proposed for software maintenance and program understanding. Unfortunately, in many cases static slices are overly conservative and therefore too large to supply useful information to the software maintainer. Dynamic slicing methods can produce more precise results, but only for one test case. In this paper we introduce the concept of union slices (the union of dynamic slices for many test cases) and suggest using a combination of static and union slices. This way the size of program parts that need to be investigated can be reduced by concentrating on the most important parts first. We performed a series of experiments with our experimental implementation on three medium size C programs. Our initial results suggest that union slices are in most cases far smaller than the static slices, and that the growth rate of union slices (by adding more test cases) significantly declines after several representative executions of the program.

Static program slicing is often proposed for software maintenance-related tasks. Due to different causes static slices are in many cases overly conservative and hence too large to reduce the program-part of interest meaningfully. In this paper we further investigate the concept of union slices, which are defined as the unions of dynamic slices computed for the same (static) slicing criteria, but for different executions of the program. We verify on real-world Java programs their usefulness as a replacement to static slices. For this we investigate the sizes of a number of backward and forward dynamic and union slices, also by comparing them to the corresponding static slices. Our results show that the union slices are precise enough (backward slices are 5–20 % of the program and forward slices are 5– 10%, the corresponding static slices being 25–45%), and that with the saturation of the overall coverage given many different executions, union slices also reach a steady level and typically do not grow further by adding new test cases.

Program Slicing is a well-known decomposition technique that transforms a large program into a smaller one that contains only statements relevant to the computation of a selected function. In this paper, we present a novel predicate-based dynamic slicing algorithm for message passing programs. Unlike the more traditional slicing criteria that focus only on the parts of the program that influence a variable of interest at a specific position in the program, a predicate focuses on those parts of the program that influence the predicate. The dynamic predicate slice captures some global requirements or suspected error properties of a distributed program and computes all statements that are relevant. This article presents an algorithm and a sample computation to illustrate how the predicate slice can be computed. Additionally, we introduce a predicate trace to classify the relevance of statement executions based on the predicate slice. A compressed predicate trace can be used to reveal those instances of statement execution that turn the global predicate true, among others.

Abstract- The quality of software depends on its maintainability. Software under evolution is modified and enhanced to accommodate new requirements. As a result, the software becomes more complex and deviates from its original design, in turn lowering the quality. Program Slicing and refactoring as program re-engineering approaches, makes software systems maintainable. Effective slicing and refactoring requires proper metrics to quantitatively establish the improvement in the quality. Software metrics have proven to reflect software quality, and thus have been widely used in software quality evaluation methods. The results of these evaluation methods can be used to indicate which parts of a software system need to be reengineered. The reengineering of these parts is usually performed using refactoring and slicing- meaning refactoring and slicing are consciously used as a means to improve the quality of software. Probably the most influential factor for software quality is its design. A good design will allow a software system to evolve with little effort and less cost. Therefore by evaluating the quality of the design of a system one can estimate its overall quality. In this paper, we present refactoring and slicing as promising techniques that enhances software quality and the consideration of these techniques when software maintenance is being considered.