. Previous work has shown that program slicing can be a useful step in model-checking software systems. We are interested in applying these techniques to construct models of multi-threaded Java programs. Past work does not address the concurrency primitives found in Java, nor does it provide the rigorous notions of slice correctness that are necessary for reasoning about programs with non-deterministic behaviour and potentially infinite computation traces. In this paper, we define the semantics of a simple multi-threaded language with concurrency primitives matching those found in the Java Virtual Machine, we propose a bisimulation-based notion of correctness for slicing in this setting, we identify notions of dependency that are relevant for slicing multi-threaded Java programs, and we use these dependencies to specify a program slicer for the language presented in the paper. Finally, we discuss how these dependencies can be refined to take into account common programmin...

Program slicing has many applications in software engineering activities including program comprehension, debugging, testing, maintenance, and model checking. In this paper, we propose an approach to slicing aspect-oriented software. To solve this problem, we present a dependencebased representation called aspect-oriented system dependence graph (ASDG), which extends previous dependence graphs, to represent aspect-oriented software. The ASDG of an aspect-oriented program consists of three parts: a system dependence graph for non-aspect code, a group of dependence graphs for aspect code, and some additional dependence arcs used to connect the system dependence graph to the dependence graphs for aspect code. After that, we show how to compute a static slice of an aspect-oriented program based on the ASDG. 1.

Abstract. In this paper, we show how previous work on escape analysis can be adapted and extended to yield a static analysis that is efficient yet effective for reducing the number of interference dependence edges considered while slicing concurrent Java programs. The key idea is to statically detect situations where run-time heap objects are reachable from a single thread and use it to prune spurious interference dependence edges. We also show how this analysis can be extended to reduce the number of ready dependence edges – dependences that capture indefinite delay due to Java synchronization constructs. The analysis we describe has been implemented in the Bandera[9] slicer which is being applied to reduce the size of software models for modelchecking. Using this implementation, we give experimental results that demonstrate the effectiveness of our approach. We believe leveraging escape information in the manner we describe is a crucial element in scaling slicing techniques to larger concurrent object-oriented programs. 1

Program slicing is a technique to identify statements that may influence the computations at other statements. Precise slicing has been shown to be undecidable for concurrent programs. This work presents the first context-sensitive approach to slice concurrent programs accurately. It extends the well known structures of the control flow graph and the (interprocedural) program dependence graph for concurrent programs with interference. This new technique does not require serialization or inlining.

Chang impact analysis is an useful technique for software evolution. Many techniques have been proposed for supporting change impact analysis of procedural or object-oriented software, but no effort has been made for change impact analysis of aspect-oriented software. In this paper, we present an approach to supporting change impact analysis of aspect-oriented software based on program slicing technique. The main feature of our approach is to assess the effect of changes in an aspect-oriented program by analyzing its source code, and therefore, the process of change impact analysis can be automated completely.

Although a large body of research in software metrics has been focused on procedural or object-oriented software, there is no software metric for aspect-oriented software until now. In this paper, we propose some metrics for aspect-oriented software, which are specically designed to quantify the information ows in an aspect-oriented program. We define these metrics based on a dependence model for aspect-oriented software which consists of a group of dependence graphs each can be used to explicitly represent various dependence relations at dierent levels of an aspect-oriented program. The proposed metrics can be used to measure the complexity of an aspect-oriented program from various dierent viewpoints.

Program slicing is an important approach to testing, understanding and maintaining programs. The paper presents a slicing algorithm for concurrent Java programs.

Understanding program dependencies in a computer program is essential for many software engineering tasks such as program understanding, testing, debugging, reverse engineering, and maintenance. In this paper, we present an approach to dependence analysis of Java bytecode, and discuss some applications of our technique, which include Java bytecode slicing, understanding, and testing. 1 Introduction Java is a new object-oriented programming language and has achieved widespread acceptance because it emphasizes portability [1]. In Java, programs are being compiled into a portable binary format call bytecode. Every class is represented by a single class file containing class related data and bytecode instructions (Figure 1 shows a simple Java class Test and its corresponding bytecode instructions). These files are loaded dynamically into an interpreter, i.e., the Java Virtual Machine (JVM) [14] and executed. Recently, more and more Java applications are routinely transmitted over the int...

This paper surveys the existing slicing techniques for object-oriented programs. Many commercial objectoriented programs are concurrent in nature. Concurrency is typically implemented in the form of multithreading or message passing using sockets or both. We therefore review the available techniques in slicing of concurrent object-oriented programs. Another trend that is clearly visible in object-oriented programming is client-server programming in a distributed environment. We briefly review the existing techniques for slicing of distributed object-oriented programs.

This paper presents an approach to representing dependencies for object-oriented (OO) Ada 95 programs. This new approach distinguishes subcomponents for different objects and represents the effects of polymorphism and dynamic bindings. Based on this model, we developed approaches to slicing subprograms, packages/types and hierarchies of types. Our slicing algorithm is more efficient because most of the results can be reused, and inter-subprogram slicing is transformed to intra-subprogram slicing.