As a software is developed, it is common to have a software functionality that
previously worked as desired, and is no longer working, after changes has been
made to the program. The level of difficulty on debugging increases as software
application grows in size and complexity. Therefore, as time goes by, a software
gets harder to understand and maintain. Especially, locating the new bugs
could be the hardest task to Software Testers. Once the bug is found, it
can be easy to fix. One of the reason that a bug can be hard to find is
that there can be a lot of lines of codes in that part of program, but not
all of them will have an effect on the statements of interest. Thus, The
essence of Program Slicing is to reduce the program to a minimal form,
which will still produce the same behavior of the originals. The reduced
program, formally, called ’slice’, is an independent program guaranteed to
completely represent the original program within the domain of the specified
behaviors[1]. In other words, through the slicing technique, we preserves
only the statements, which have some effect with respect to the selected
criterion.
However, unstructured control flow (such as ’goto’ statements), or any indirection
in a program ( pointer, use of array, or object orientation) makes slicing more
difficult. In fact in the general case program slicing is an undecidable problem
[3].
There are many forms of slices, but typically software engineers separates them
into two aspects of criterion, semantic and syntactic dimensions. A semantic
perspective describes which part of program is to be preserved, whereas a
syntactic dimension decides how the sliced fragments is to be preserved. We first
review static and dynamic slicing in the point of semantic paradigm,
then we consider amorphous variation of program slicing in syntactic
perspective.