Development of a Tool for Slicing of Object-Oriented Program

Program slicing has many applications in a software development environment such as debugging, testing, anomaly detection, program understanding and many more. The concept being introduced by Weiser and it was started with static slicing calculation. Talking about static slicing, it is a subset of statements of a program which directly or indirectly affect the values of the variables computed providing a slicing criterion. Dynamic slicing is the counterpart of the static slicing i.e finding the statements which are really affected by giving the particular input value of the variable. Object-Oriented Program(OOP) has been the most widely used software development technique. OOP is still popular among many companies for their product development.There are some drawbacks of the OOP implementation. One of them is cross-cutting concerns. Aspect-Oriented Program provides separation of cross-cutting concerns from the core modules by introducing a new unit of modularization, called Aspect. In this project, we have developed a Tool which creates System dependence Graph(SDG) which is the intermediate representation of an OOP and AOP , then takes that SDG as input to compute the slicing of that program with respect to slicing criterion

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

Dynamic Slice of Aspect Oriented Program A Comparative Study

Aspect Oriented Programming (AOP) is a budding latest technology for separating crosscutting concerns . It is very difficult to achieve cross cutting concerns in object - oriented programming (OOP). AOP is generally suitable for the area where code scattering and code tangling arises. Due to the specific features of AOP language such as joinpoint, point - cut, advice and introduction, it is difficult to apply existing slicing algorithms of procedural or object - oriented programming directly to AOP. This paper addresses different types of program slicing approaches for AOP by considering a very simple example. Also this paper addresses a new approach to calculate the dynamic slice of AOP. The complexity of this algorithm is better as compared to some existing algorithms

Prioritization of Program Elements Based on Their Testing Requirements

Even after thorough testing of a program, usually a few bugs still remain. These residual bugs are usually uniformly distributed throughout the code. It is observed that bugs in some parts of a program can cause more frequent and more severe failures compared to those in other parts. It should, then be possible to prioritize the statements, methods and classes of an object-oriented program according to their potential to cause failures. Once the program elements have been prioritized, the testing effort can be apportioned so that the elements causing most frequent failure are tested more. Based on this idea, in this paper we propose a program metric called the influence of program elements. Influence of a class indicates the potential of class to cause failures. In this approach, we have used the intermediate graph representation of a program. The influence of a class is determined through a forward slicing of the graph. Our proposed program metric can be useful in applications such as coding, debugging, test case design and maintenance etc

Dynamic Slicing of Object-Oriented Programs

Software maintenance activity is one of the most important part of software development cycle. Certain regions of a program cause more damage than other regions resulting in errors, if they contain bugs. So, it is important to debug and find those areas. We use slicing criteria to obtain a static backward slice of a program to find these areas. An intermediate graphical representation is obtained for an input source program such as the Program Dependence Graph, the Class Dependence Graph and the System Dependence Graph. Slicing is performed on the System Dependence Graph using a two pass graph reachability algorithm proposed by Horwitz[3], and a static backward slice is obtained. After obtaining static slice, dynamic slice is calculated for the given input variable using an algorithm where in a statement, a set of variables and the input values for these variables are taken as input and a dynamic slice is obtained

A Graph Coloring Approach to Dynamic Slicing of Object-Oriented Programs

Program slicing is a decomposition technique, which produces a subprogram from the parent program relevant to a particular computation. Hence slicing is also regarded as a program transformation technique. A dynamic program slice is an executable part of a program whose behavior is identical, for the same program input, to that of the original program with respect to a variable of interest at some execution position. Dynamic slices are smaller than static slice, which can be used eciently in dierent software engineering activities like program testing, debugging, software maintenance, program comprehension etc. In this dissertation, we present our work concerned with the dynamic slicing of object-oriented programs. We have developed a novel algorithm, which incorporates graph coloring technique to compute dynamic slice of object-oriented programs. But in order to achieve the goal efficiently, we have contradicted the constraints of the traditional graph coloring theory. Moreover, the state restriction of the slicing criterion is taken into consideration, in addition to the dependence analysis. The advantage of our algorithm is that, it is more time ecient than the existing algorithms. We have named this algorithm, as Contradictory Graph Coloring Algorithm (CGCA)

Dynamic Slicing of Object-Oriented and Aspect-Oriented Softwares

Slicing is generally based on program code. An alternative approach to compute the slice is from specifications developed using formalism such as Unified Modeling Languages(UML). UML is widely used for object-oriented modeling and design. In our research, we focus on UML communication diagram to compute the dynamic slices. We first develop a suitable intermediate representation for communication diagram named as Communication Dependence Graph (CoDG). Then, we propose two dynamic slicing algorithms. We have named the first algorithm edge marking dynamic slicing algorithm for communnication diagram (EMACD) and the second node-marking dynamic slicing algorithm for communnication diagram (NMACD). We have implemented our algorithms and also calculated the space and time complexity. Aspect-oriented Programming (AOP) is a recent programming paradigm that focuses on modular implementations of various crosscutting concerns. In our research, we proposed a technique for dynamic slicing of aspect-oriented software based on the UML communication diagram. Next, we generate an intermediate representation from the communication diagram which we named as Communication Aspect Dependency Graph (CADG). Then, we proposed an edge marking dynamic slicing algorithm named as Aspect-Oriented Edge Marking Algorithm (AOEM). The novelty in our approach is that we present the communication diagram for the aspect-oriented software. We have implemented the algorithm and also found the space and time complexity of the algorithm

A review of slicing techniques in software engineering

Program slice is the part of program that may take the program off the path of the desired output at some point of its execution. Such point is known as the slicing criterion. This point is generally identified at a location in a given program coupled with the subset of variables of program. This process in which program slices are computed is called program slicing. Weiser was the person who gave the original definition of program slice in 1979. Since its first definition, many ideas related to the program slice have been formulated along with the numerous numbers of techniques to compute program slice. Meanwhile, distinction between the static slice and dynamic slice was also made. Program slicing is now among the most useful techniques that can fetch the particular elements of a program which are related to a particular computation. Quite a large numbers of variants for the program slicing have been analyzed along with the algorithms to compute the slice. Model based slicing split the large architectures of software into smaller sub models during early stages of SDLC. Software testing is regarded as an activity to evaluate the functionality and features of a system. It verifies whether the system is meeting the requirement or not. A common practice now is to extract the sub models out of the giant models based upon the slicing criteria. Process of model based slicing is utilized to extract the desired lump out of slice diagram. This specific survey focuses on slicing techniques in the fields of numerous programing paradigms like web applications, object oriented, and components based. Owing to the efforts of various researchers, this technique has been extended to numerous other platforms that include debugging of program, program integration and analysis, testing and maintenance of software, reengineering, and reverse engineering. This survey portrays on the role of model based slicing and various techniques that are being taken on to compute the slices

Program Tailoring: Slicing by Sequential Criteria

Protocol and typestate analyses often report some sequences of statements ending at a program point P that needs to be scrutinized, since P may be erroneous or imprecisely analyzed. Program slicing focuses only on the behavior at P by computing a slice of the program affecting the values at P. In this paper, we propose to restrict our attention to the subset of that behavior at P affected by one or several statement sequences, called a sequential criterion (SC). By leveraging the ordering information in a SC, e.g., the temporal order in a few valid/invalid API method invocation sequences, we introduce a new technique, program tailoring, to compute a tailored program that comprises the statements in all possible execution paths passing through at least one sequence in SC in the given order. With a prototyping implementation, Tailor, we show why tailoring is practically useful by conducting two case studies on seven large real-world Java applications. For program debugging and understanding, Tailor can complement program slicing by removing SC-irrelevant statements. For program analysis, Tailor can enable a pointer analysis, which is unscalable to a program, to perform a more focused and therefore potentially scalable analysis to its specific parts containing hard language features such as reflection