Dynamic slicing of aspect oriented programs

As software application grows larger and become more complex, program maintenance activities such as adding new functionality, debugging and testing consume increasing amount of available resources for software development. In order to cope with this increased complexity, programmer need effective computer supported methods for decomposition and dependence analysis of programs. Program slicing is one method for such decomposition and dependence analysis. Program slicing is a decomposition technique which extracts program elements related to a particular computation from a program. A program slice consists of those parts of a program that may directly or indirectly affect the values computed at some program point of interest, referred to as a slicing criterion. A program slice can be static or dynamic. Static slice contains all the statements that may affect the slicing criterion for every possible inputs to the program. Dynamic slice contains only those statements that actually affect the slicing criterion for a particular input to the program. Aspect-oriented programming is a new programming technique proposed for cleanly modularizing the cross- cutting structure of concerns. An aspect is an area of concern that cuts across the structure of a program. The main idea behind aspect-oriented programming (AOP) is to allow a program to be constructed by describing each concern separately. Aspect J is an aspect-oriented extension to the Java programming language. Aspect J adds new concepts and associated constructs called join points, pointcuts, advices, introductions, and aspects to Java. Zhao developed the aspect-oriented system dependence graph (ASDG) to represent aspect-oriented programs and used two-pass slicing algorithm to compute static slice of aspect-oriented programs. But the disadvantage of his ASDG is that the weaving process is not represented correctly and this graph cannot be used for dynamic slicing. Our objective was to develop a suitable intermediate representation of an aspectoriented program and to develop suitable dynamic slicing technique

Handling pointers and unstructured statements in the forward computed dynamic slice algorithm

Different program slicing methods are used for debugging, testing, reverse engineering and maintenance. Slicing algorithms can be classified as a static slicing or dynamic slicing type. In applications such as debugging the computation of dynamic slices is more preferable since it can produce more precise results. In a recent paper [5] a new so-called "forward computed dynamic slice" algorithm was introduced. It has the great advantage compared to other dynamic slice algorithms that the memory requirements of this algorithm are proportional to the number of different memory locations used by the program, which in most cases is much smaller than the size of the execution history. The execution time of the algorithm is linear in the size of the execution history. In this paper we introduce the handling of pointers and the jump statements (goto, break, continue) in the C language

PROGRAM SLICING TECHNIQUES AND ITS APPLICATIONS

Program understanding is an important aspect in Software Maintenance and Reengineering. Understanding the program is related to execution behaviour and relationship of variable involved in the program. The task of finding all statements in a program that directly or indirectly influence the value for an occurrence of a variable gives the set of statements that can affect the value of a variable at some point in a program is called a program slice. Program slicing is a technique for extracting parts of computer programs by tracing the programs’ control and data flow related to some data item. This technique is applicable in various areas such as debugging, program comprehension and understanding, program integration, cohesion measurement, re-engineering, maintenance, testing where it is useful to be able to focus on relevant parts of large programs. This paper focuses on the various slicing techniques (not limited to) like static slicing, quasi static slicing, dynamic slicing and conditional slicing. This paper also includes various methods in performing the slicing like forward slicing, backward slicing, syntactic slicing and semantic slicing. The slicing of a program is carried out using Java which is a object oriented programming language

Test Case Purification for Improving Fault Localization

Finding and fixing bugs are time-consuming activities in software development. Spectrum-based fault localization aims to identify the faulty position in source code based on the execution trace of test cases. Failing test cases and their assertions form test oracles for the failing behavior of the system under analysis. In this paper, we propose a novel concept of spectrum driven test case purification for improving fault localization. The goal of test case purification is to separate existing test cases into small fractions (called purified test cases) and to enhance the test oracles to further localize faults. Combining with an original fault localization technique (e.g., Tarantula), test case purification results in better ranking the program statements. Our experiments on 1800 faults in six open-source Java programs show that test case purification can effectively improve existing fault localization techniques