A novel approach for computing dynamic slices of object-oriented programs with conditional statements

Program slices are useful in debugging, testing, maintenance, and understanding of programs. The conventional notion of a program slice, the static slice , is the set of all statements that might affect the value of a given variable occurrence. In this paper, we investigate the concept of the dynamic slice consisting of all statements that actually affect the value of a variable occurrence for a given program input. The sensitivity of dynamic slicing to particular program inputs makes it more useful in program debugging and testing than static slicing. Several approaches for computing dynamic slices are examined. The notion of a Dynamic Dependence Graph and its use in computing dynamic slices is discussed. The Dynamic Dependence Graph may be unbounded in length; therefore, we introduce the economical concept of a Reduced Dynamic Dependence Graph, which is proportional in size to the number of dynamic slices arising during the program execution.

This paper proposes a novel dynamic slicing technique for object oriented concurrent programs. We introduce the notion of object oriented concurrent program dependence graph (OOCPDG). Our dynamic slicing technique uses OOCPDG as the intermediate representation and is based on marking and unmarking the dependence edges as and when the dependences arise and cease at runtime. Our approach eliminates the use of trace files and is more efficient than existing algorithms. Besides, it encompasses different aspects of object oriented programming paradigm viz. inheritance, polymorphism from the slicing arena. It can handle dynamically created object based processes. It can also handle process interactions through shared memory and message passing. The updating to the intermediate representation is truly concurrent. Multiple processors execute different object based processes concurrently and require special handling. We also report a dynamic slicing tool called CDSOOCP (concurrent dynamic sheer for object oriented concurrent programs) which implements our dynamic slicing technique.

Program Slicing minimizes the program to substatements, which produces the same behaviour where the subset of the program also called the program slice comprises of the chunks or statements of the program which impact the values calculated at a point of absorption called as the slicing criterion. The concept of slicing was introduced by Weiser using a data-flow diagram [1]. If you look at static slicing, it does not make any suppositions about the input of a particular program, whereas the dynamic slicing counts on a distinct test case. Object-oriented programming is an extensively used software development technique. In this paper, we will create an approach to compute a static slice as well as a dynamic slice of a set of programs by creating an intermediary representation of the program, i.e. a Java program dependence graph and Java system dependence graph (JSysDG) (in case of multiple functions) and then use it as input and apply the slicing algorithm in order to compute slice of the program with respect to the slicing criterion and analyze the results as well.

Program slicing is an effective decomposition technique to relevant parts of a program or application during debugging and analysis activities. It extracts slice of codes from a developed program, which have been affected by value of variable for some point of interest. A variant of slicing, dynamic slicing based on specific execution when debugged, yeilds more precise executable slices. Moreover, the dynamic slicing obtained for web application is useful in analysis and testing of web sites. In this paper we have proposed an algorithm for computing dynamic slices of web based applications. We have used a dependence based intermediate program representation, which is named as Web Application Dependency Graph (WADG) for representing a web based application embedded with a scripting language. The WADG is a directed digraph which represents the various types of dependencies like data, control and link that may exists between different statements of web application. After user entered details, our proposed algorithm computes slice by marking and unmarking the executed edges of WADG appropriately.

Program slicing techniques are widely used in the field of program debugging and testing, It is divided into static slicing and dynamic slicing. Existing dynamic slicing methods are inadequate, To solve these problems, A new dynamic slicing algorithm is designed, This algorithm based on coverage testing, The core idea is to establish a dynamic dependence graph, And the construction of this dependence graph is based on the coverage testing. This algorithm not only uses the static information, but also uses the dynamic execution information, The advantage of this algorithm is that it does not recalculate when the standard of slice changes.

Now a day's object oriented program is the strongest tool in programming. Many factors such as code reusability, garbage handling and exception handling makes this approach stand out. So in the real field of development and maintenance object oriented program is heavily used. While static slicing of object oriented program is lengthy dynamic slicing approach gives upper hand mainly in debugging and software testing and maintenance. Dynamic slicing process extracts statements in the practical scenario, means having required input values. As code reusability and communication in object oriented program(OOP) is mainly achieved through inheritance and friend function, which are complex in nature we have presented methods in the paper which deals with these problem mainly in C++ language. We have used program dependency as the medium of finding slices. Here we have discussed slicing a C++ program in case of friend function and single inheritance.

This paper presents a context-sensitive dynamic slicing technique for concurrent AOPs having multiple threads. To effectively represent the concurrent AOP, we propose an intermediate graph called Multithreaded Aspect-Oriented Dependence Graph (MAODG). Based on this intermediate representation, we design a precise and accurate dynamic slicing algorithm for concurrent AOPs. This algorithm takes the MAODG of the concurrent AOP and a slicing criterion as input and computes the dynamic slice for the given concurrent AOP.

We present a framework for computing dynamic slices of concurrent programs using a form of dependence graph as intermediate representations. We introduce the notion of a Dynamic Program Dependence Graph (DPDG) to represent various intra- and interprocess dependences of concurrent programs. We construct this graph through three hierarchical stages. Besides being intuitive, this approach also enables us to display slices at different levels of abstraction. Wehave considered interprocess communication using both shared memory and message passing mechanisms.

Aspect-oriented Programming (AOP) is a recent programming paradigm that focuses on modular implementations of various crosscutting concerns. The typical features of AOP such as join-point, advice, introduction, aspects etc. make it difficult for applying slicing. Program slicing is a method to extort statements that are relevant to a particular variable. Program slicing, as initially defined by Weiser is based on static dataflow examination on the flow graph of the program. Program slicing has been applied in parallel processing, program debugging, program integration,program understanding , software testing and maintenance etc.In this paper, we proposed a technique for dynamic slicing of aspectoriented software based on the UML 2.0 Communication diagram. Here, we can use slicing at the architectural level to find the slicing of communication diagram at an earlier stage of software development. To represent the various unique features of AOP in UML diagrams is very difficult and complex in nature. For this purpose, we first draw the communication diagram for aspect-oriented program considering the classes, pointcuts, advices and aspects. Next, we have generated an intermediate representation from the communication diagram. Then, we proposed an edge marking dynamic slicing algorithm that traverses the intermediate representation and finds the slices for the communication diagram of the given problem scenario. The novelty in our approach is that we present the communication diagram for the aspect-oriented software. Also, we proposed an algorithm to find the slice from it. The advantage of using communication diagram is that it mainly focuses on the interaction between the objects involved in the problem scenario.

Dynamic program slicing is an effective technique for narrowing the errors to the relevant parts of a program when debugging. Given a slicing criterion, the dynamic slice contains only those statements that actually affect the variables in the slicing criterion. We propose a method to dynamically slice object-oriented (OO) programs based on dependence analysis. It uses the object program dependence graph and other static information to reduce the information to be traced during program execution. It deals with OO features such as inheritance, polymorphism and dynamic bindings. Based on this model, we present methods to slice methods, objects and classes. We also modify the slicing criterion to fit for debugging.

Developing high-performance software is a difficult task that requires the use of low-level, architecture-specific programming models (e.g., OpenMP for CMPs, CUDA for GPUs, MPI for clusters). It is typically not possible to write a single application that can run efficiently in different environments, leading to multiple versions and increased complexity. Domain-Specific Languages (DSLs) are a promising avenue to enable programmers to use high-level abstractions and still achieve good performance on a variety of hardware. This is possible because DSLs have higher-level semantics and restrictions than general-purpose languages, so DSL compilers can perform higher-level optimization and translation. However, the cost of developing performance-oriented DSLs is a substantial roadblock to their development and adoption. In this article, we present an overview of the Delite compiler framework and the DSLs that have been developed with it. Delite simplifies the process of DSL development by providing common components, like parallel patterns, optimizations, and code generators, that can be reused in DSL implementations. Delite DSLs are embedded in Scala, a general-purpose programming language, but use metaprogramming to construct an Intermediate Representation (IR) of user programs and compile to multiple languages (including C++, CUDA, and OpenCL). DSL programs are automatically parallelized and different parts of the application can run simultaneously on CPUs and GPUs. We present Delite DSLs for machine learning, data querying, graph analysis, and scientific computing and show that they all achieve performance competitive to or exceeding C++ code.

Object-oriented finite element analysis and programming in VC++

The acquisition of problem-solving and programming skills in the era of knowledge society seems to be particularly important. Due to the intrinsic difficulty of acquiring such skills various educational tools have been developed. Unfortunately, most of these tools are not utilized. In this paper we present the programming microworlds Karel and objectKarel that support the procedural-imperative and Object-Oriented Programming (OOP) techniques and can be used for supporting the teaching and learning of programming in various learning contexts and audiences. The paper focuses on presenting the pedagogical features that are common to both environments and mainly on presenting the potential uses of these environments.KeywordsKnowledge SocietyProgramming SkillPedagogical FeatureEducational SoftwareProgramming ConceptThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Program slicing is a well-known technique that extracts from a program those statements which are relevant to a particular criterion. While static slicing does not consider any input data, dynamic slices are computed from a particular program execution. Thus, dynamic slicers are usually easier to design and implement.In this work, we present a program specialization technique for lazy functional logic programming which is based on dynamic slicing. Our method exploits the code size reduction capabilities of slicing in order to produce a version of the original program specialized w.r.t. a given criterion. We also introduce some simple, post-processing transformations that allow us to further simplify the specialized program. The kind of specialization performed by our approach cannot be achieved with other related techniques like partial evaluation.

This paper describes the development and experimental evaluation of a rigorous approach for effective object-oriented (OO) code inspection. Since their development, inspections have been shown to be powerful defect detection strategies but little research has been done to investigate their application to OO systems, which have very different structural and execution models compared to procedural systems. Previous investigations have demonstrated that the delocalised nature of OO software - the resolution of frequent non-local references, and the incongruous relationship between its static and dynamic representations, are primary inhibitors to its effective inspection. The experiment investigates a set of three complementary code reading techniques devised specifically to address these problems: one based on a checklist adapted to address the identified problems of OO inspections, one focused on the systematic construction of abstract specifications, and the last centered on the dynamic slice that a use-case takes through a system. The analysis shows that there is a significant difference in the number of defects found between the three reading techniques. The checklist-based technique emerges as the most effective approach but the other techniques also have noticeable strengths and so for the best results in a practical situation a combination of techniques is recommended.