6,336 research outputs found
Slicing Object Oriented Programs for Maintenance Purposes
Object oriented approach is growing very fast in various applications of the
computer science. Those applications may contain a lot of entity relationships which,
need to be understood by the maintainers. These relationships (involving classes,
message, variables, etc.) will make maintainers and developers face several problems
to understand, make changes, modify, or enhance a huge software system that contains
thousands of classes without automatic aids. Therefore several problems arise in the
maintenance of object oriented program that is software understanding, complex
dependencies, inheritance, polymorphism and dynamic binding.
An approach for formally defining slices for object oriented programs is an
important problem in the maintenance phase. This thesis proposes definitions of slices for
object oriented programs. Basic relations such as Usage, Affect and Inheritance are
defined, and they are extended to a family of dependence relations between entities in
object oriented programs and defines slicing techniques based on these relations. Slice collection methods for specified slice criteria are given. This approach shows how the
proposed slicing concepts and rules can be applied within the software maintenance
process by giving an illustration through examples written by Java and Delphi
programming languages.
The research also develop a prototype of an object oriented system tool (02SMt)
which represent an automatically extractable and captures an object oriented software
system dependencies i n order to aid in maintenance phase. The dependencies occurs and
explain in this research are control dependence, statement dependence on a variable,
statement dependence on a method, variable dependence on statement, variable
dependent on a method, Class-Class dependence through usage, Class-Class dependence
through inheritance, Class-Class dependence for causing side effects, method
dependence on another method, and method dependence on a variable. The 02SMt
captures program slicing according to the slicing concepts, rules and definitions to feature
out the dependencies with the basic object oriented relations.
This research also, discusses an object oriented dependence graph (02DG). The
02DG categorized according levels. The first category is class-level involving a class to
another class. The second category is method-level involving a method or a statement
within a method to another method or variable in a class. The final category is statement level
which is basically intra-method involving statements within a given method. Slices,
intum, can also be categorized according to such levels of dependencies they intend to
capture
On the computational complexity of dynamic slicing problems for program schemas
This is the preprint version of the Article - Copyright @ 2011 Cambridge University PressGiven a program, a quotient can be obtained from it by deleting zero or more statements. The field of program slicing is concerned with computing a quotient of a program that preserves part of the behaviour of the original program. All program slicing algorithms take account of the structural properties of a program, such as control dependence and data dependence, rather than the semantics of its functions and predicates, and thus work, in effect, with program schemas. The dynamic slicing criterion of Korel and Laski requires only that program behaviour is preserved in cases where the original program follows a particular path, and that the slice/quotient follows this path. In this paper we formalise Korel and Laski's definition of a dynamic slice as applied to linear schemas, and also formulate a less restrictive definition in which the path through the original program need not be preserved by the slice. The less restrictive definition has the benefit of leading to smaller slices. For both definitions, we compute complexity bounds for the problems of establishing whether a given slice of a linear schema is a dynamic slice and whether a linear schema has a non-trivial dynamic slice, and prove that the latter problem is NP-hard in both cases. We also give an example to prove that minimal dynamic slices (whether or not they preserve the original path) need not be unique.This work was partly supported by the Engineering and Physical Sciences Research Council, UK, under grant EP/E002919/1
Amorphous slicing of extended finite state machines
Slicing is useful for many Software Engineering applications and has been widely studied for three decades, but there has been comparatively little work on slicing Extended Finite State Machines (EFSMs). This paper introduces a set of dependency based EFSM slicing algorithms and an accompanying tool. We demonstrate that our algorithms are suitable for dependence based slicing. We use our tool to conduct experiments on ten EFSMs, including benchmarks and industrial EFSMs. Ours is the first empirical study of dependence based program slicing for EFSMs. Compared to the only previously published dependence based algorithm, our average slice is smaller 40% of the time and larger only 10% of the time, with an average slice size of 35% for termination insensitive slicing
Unions of slices are not slices
Many approaches to slicing rely upon the 'fact' that the union of two static slices is a valid slice. It is known that static slices constructed using program dependence graph algorithms are valid slices (Reps and Yang, 1988). However, this is not true for other forms of slicing. For example, it has been established that the union of two dynamic slices is not necessarily a valid dynamic slice (Hall, 1995). In this paper this result is extended to show that the union of two static slices is not necessarily a valid slice, based on Weiser's definition of a (static) slice. We also analyse the properties that make the union of different forms of slices a valid slice
Understanding object-oriented source code from the behavioural perspective
Comprehension is a key activity that underpins a variety of software maintenance and engineering tasks. The task of understanding object-oriented systems is hampered by the fact that the code segments that are related to a user-level function tend to be distributed across the system. We introduce a tool-supported code extraction technique that addresses this issue. Given a minimal amount of information about a behavioural element of the system that is of interest (such as a use-case), it extracts a trail of the methods (and method invocations) through the system that are needed in order to achieve an understanding of the implementation of the element of interest. We demonstrate the feasibility of our approach by implementing it as part of a code extraction tool, presenting a case study and evaluating the approach and tool against a set of established criteria for program comprehension tools
Abstract Program Slicing: an Abstract Interpretation-based approach to Program Slicing
In the present paper we formally define the notion of abstract program
slicing, a general form of program slicing where properties of data are
considered instead of their exact value. This approach is applied to a language
with numeric and reference values, and relies on the notion of abstract
dependencies between program components (statements).
The different forms of (backward) abstract slicing are added to an existing
formal framework where traditional, non-abstract forms of slicing could be
compared. The extended framework allows us to appreciate that abstract slicing
is a generalization of traditional slicing, since traditional slicing (dealing
with syntactic dependencies) is generalized by (semantic) non-abstract forms of
slicing, which are actually equivalent to an abstract form where the identity
abstraction is performed on data.
Sound algorithms for computing abstract dependencies and a systematic
characterization of program slices are provided, which rely on the notion of
agreement between program states
- ā¦