Static Slicing of Interprocedural Programs

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. In this project, we have developed an approach for creating an intermediate representation of a program in the form of System Dependence Graph (SDG) which is to be, again taken as input for computing the slicing of a program with respect to slicing criterion. The slicing approach computes the slices with respect to a given slicing criterion. For generating the graph, we have analysed the input program, identified the tokens and finally generated the relation between tokens as data dependent or control dependent. For calculating the slice, we have used two-phase graph reachability algorithm developed by Horwitz, Reps and Binkley, which creates a graph consisting of only those nodes that are dependent on slicing criterion. Finally we have plotted a graph between time taken to create graph versus number of functions used in program. Our approach of calculating slices has been limited only to C programs

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

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

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)

System dependence graphs in sequential Erlang

The system dependence graph (SDG) is a data structure used in the imperative paradigm for different static analysis, and particularly, for program slicing. Program slicing allows us to determine the part of a program (called slice) that influences a given variable of interest. Thanks to the SDG, we can produce precise slices for interprocedural programs. Unfortunately, the SDG cannot be used in the functional paradigm due to important features that are not considered in this formalism (e.g., pattern matching, higher-order, composite expressions, etc.). In this work we propose the first adaptation of the SDG to a functional language facing these problems. We take Erlang as the host language and we adapt the algorithms used to slice the SDG to produce precise slices of Erlang interprocedural programs. As a proof-of-concept, we have implemented a program slicer for Erlang based on our SDGs.This work has been partially supported by the Spanish Ministerio de Ciencia e Innovaci´on under grant TIN2008-06622-C03-02 and by the Generalitat Valenciana under grant PROMETEO/2011/052. Salvador Tamarit was partially supported by the Spanish MICINN under FPI grant BES-2009-015019Silva Galiana, JF.; Tamarit Muñoz, S.; Tomás Franco, C. (2012). System dependence graphs in sequential Erlang. En Fundamental Approaches to Software Engineering. Springer Verlag (Germany). 486-500. https://doi.org/10.1007/978-3-642-28872-2_33S486500Agrawal, H., Horgan, J.R.: Dynamic program slicing. In: Programming Language Design and Implementation (PLDI), pp. 246–256 (1990)Brown, C.: Tool Support for Refactoring Haskell Programs. PhD thesis, School of Computing, University of Kent, Canterbury, Kent, UK (2008)Cheda, D., Silva, J., Vidal, G.: Static slicing of rewrite systems. Electron. Notes Theor. Comput. Sci. 177, 123–136 (2007)Ferrante, J., Ottenstein, K.J., Warren, J.D.: The Program Dependence Graph and Its Use in Optimization. ACM Transactions on Programming Languages and Systems 9(3), 319–349 (1987)Field, J., Ramalingam, G., Tip, F.: Parametric program slicing. In: Proceedings of the 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 1995, pp. 379–392. ACM, New York (1995)Horwitz, S., Reps, T., Binkley, D.: Interprocedural slicing using dependence graphs. ACM Transactions Programming Languages and Systems 12(1), 26–60 (1990)Korel, B., Laski, J.: Dynamic Program Slicing. Information Processing Letters 29(3), 155–163 (1988)Larsen, L., Harrold, M.J.: Slicing object-oriented software. In: Proceedings of the 18th International Conference on Software Engineering, ICSE 1996, pp. 495–505. IEEE Computer Society, Washington, DC (1996)Liang, D., Harrold, M.J.: Slicing objects using system dependence graphs. In: Proceedings of the International Conference on Software Maintenance, ICSM 1998, pp. 358–367. IEEE Computer Society, Washington, DC (1998)Lindahl, T., Sagonas, K.F.: Typer: a type annotator of erlang code. In: Sagonas, K.F., Armstrong, J. (eds.) Erlang Workshop, pp. 17–25. ACM (2005)Lindahl, T., Sagonas, K.F.: Practical type inference based on success typings. In: Bossi, A., Maher, M.J. (eds.) PPDP, pp. 167–178. ACM (2006)Ochoa, C., Silva, J., Vidal, G.: Dynamic slicing based on redex trails. In: Proceedings of the 2004 ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation, PEPM 2004, pp. 123–134. ACM, New York (2004)Reps, T., Turnidge, T.: Program Specialization via Program Slicing. In: Danvy, O., Thiemann, P., Glück, R. (eds.) Dagstuhl Seminar 1996. LNCS, vol. 1110, pp. 409–429. Springer, Heidelberg (1996)Rodrigues, N.F., Barbosa, L.S.: Component identification through program slicing. In: Proc. of Formal Aspects of Component Software (FACS 2005). Elsevier ENTCS, pp. 291–304. Elsevier (2005)Tip, F.: A survey of program slicing techniques. Journal of Programming Languages 3(3), 121–189 (1995)Tóth, M., Bozó, I., Horváth, Z., Lövei, L., Tejfel, M., Kozsik, T.: Impact Analysis of Erlang Programs Using Behaviour Dependency Graphs. In: Horváth, Z., Plasmeijer, R., Zsók, V. (eds.) CEFP 2009. LNCS, vol. 6299, pp. 372–390. Springer, Heidelberg (2010)Walkinshaw, N., Roper, M., Wood, M., Roper, N.W.M.: The java system dependence graph. In: Third IEEE International Workshop on Source Code Analysis and Manipulation, p. 5 (2003)Weiser, M.: Program Slicing. In: Proceedings of the 5th International Conference on Software Engineering, pp. 439–449. IEEE Press (1981)Widera, M.: Flow graphs for testing sequential erlang programs. In: Proceedings of the 2004 ACM SIGPLAN Workshop on Erlang, ERLANG 2004, pp. 48–53. ACM, New York (2004)Widera, M., Informatik, F.: Concurrent erlang flow graphs. In: Proceedings of the Erlang/OTP User Conference (2005)Zhao, J.: Slicing aspect-oriented software. In: Proceedings of the 10th International Workshop on Program Comprehension, IWPC 2002, pp. 251–260. IEEE Computer Society, Washington, DC (2002