Program and interface slicing for reverse engineering, J. Beck and D. Eichmann
@InProceedings{ beck.eichmann:program,
author = {J. Beck and D. Eichmann},
title = {Program and interface slicing for reverse engineering},
pages = {509--519},
booktitle = {Proceedings of the 15th International Conference on
Software Engineering },
year = {1993},
publisher = {IEEE Computer Society Press},
month = apr,
abstract = {Reverse engineering involves a great deal of effort in
comprehension of the current implementation of a software
system and the ways in which it differs from the original
design. Automated support tools are critical to the success
of such efforts. Wh show how program slicing techniques can
be employed to assist in the comprehension of large
software systems, through traditional slicing techniques at
the statement level, and through a new technique, interface
slicing, at the module level.},
note = {Describes the use of program slicing for the reverse
engineering of Ada packages},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Static_Analysis,
Static_Data_Flow_Analysis, Program_Slicing}
}
Program and Interface Slicing for Reverse Engineering , J. Beck and D. Eichmann
@InProceedings{ beck.eichmann:program*1,
author = { J. Beck and D. Eichmann },
title = { Program and Interface Slicing for Reverse Engineering },
booktitle = { WCRE~'93: Proceedings of the 1993 Working Conference on
Reverse Engineering, {\rm (Baltimore, Maryland; May 21-23,
1993)}},
year = { May 1993 },
pages = { 54-63 },
publisher = { IEEE Computer Society Press (Order Number 3780-02) },
abstract = { },
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing }
}
The Application of Program Slicing to Regression Testing, David Binkley
@Article{ binkley:application,
author = {David Binkley},
title = {The Application of Program Slicing to Regression Testing},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {583-594},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Using semantic differencing to reduce the cost of regression testing, D. Binkley
@InProceedings{ binkley:using,
title = {Using semantic differencing to reduce the cost of
regression testing},
author = {D. Binkley},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1992},
pages = {41--50},
year = {1992},
note = { Gives an algorithm using dependence graphs and program
slicing to partition a modified program in parts with
affected program behaviour and parts with unaffected
behaviour. Only the parts with affected behaviour have to
be re-tested},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Conditioned Program Slicing, Gerardo Canfora and Aniello Cimitile and Andrea De Lucia
@Article{ canfora.cimitile.ea:conditioned,
author = {Gerardo Canfora and Aniello Cimitile and Andrea De Lucia},
title = {Conditioned Program Slicing},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {595-608},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Identification and extraction of ``domain independent'' components in large programs, F. Cutillo and P. Fiore and G. Visaggio
@InProceedings{ cutillo.fiore.ea:identification,
author = {F. Cutillo and P. Fiore and G. Visaggio},
title = {Identification and extraction of ``domain independent''
components in large programs},
booktitle = {Proceedings of the 1st Working Conference on Reverse
Engineering },
pages = {83--92},
year = {1993},
note = { Uses program slicing to extract components from COBOL
programs by means of Viasoft's tools INSIGHT, SMARTDOC and
RENAISSANCE},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Dynamic Dependence in Term Rewriting Systems and its Application to Program Slicing, John Field and Frank Tip
@Article{ field.tip:dynamic,
author = {John Field and Frank Tip},
title = {Dynamic Dependence in Term Rewriting Systems and its
Application to Program Slicing},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {609-634},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Using Program Slicing in Software Maintenance, Keith Brian Gallagher and James R. Lyle
@Article{ gallagher.lyle:using,
author = {Keith Brian Gallagher and James R. Lyle},
title = {Using Program Slicing in Software Maintenance},
journal = {IEEE Transactions on Software Engineering},
year = {1991},
volume = {17},
number = {8},
pages = {751-761},
month = aug,
abstract = {Program slicing, introduces by Weiser, is known to help
programmers in understanding foreign code and in debugging.
We apply program slicing to the maintenance problem by
extending the notion of a program slice (that orginally
required both a variable and line number) to a
decomposition slice, one that captures all computation on a
given variable; i.e., is independent of line numbers. Using
the lattice of single variable decomposition slices ordered
by set inclusion, we demonstrate how to form a slice-based
decomposition for programs. We are then able to delineate
the effects of a proposed change by isolating those effects
in a single component of the decomposition. This gives
maintainers a straightforward technique for determining
those statements and variables which may be modified in a
component and those which may not. Using the decomposition,
we provide a set of principles to prohibit changes which
will interfere with unmodified components. These
semantically consistent changes can then be merged back
into the original program in linear time. Moreover, the
maintainer can test the changes in the component with the
assurance that there are no linkages into other components.
Thus decomposition slicing induces a new software
maintenance process model which eliminates the need for
regression testing.},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Static_Analysis,
Static_Data_Flow_Analysis, Program_Slicing}
}
Using program slicing in software maintenance, K. Gallagher and J. Lyle
@Article{ gallagher.lyle:using*1,
title = {Using program slicing in software maintenance},
author = {K. Gallagher and J. Lyle},
journal = {IEEE Transactions on Software Engineering},
volume = {17},
number = {8},
pages = {751--761},
year = {1991},
note = { In this paper the technique of program slicing is used to
facilitate maintenance of software systems by extending the
notion of program slice to a so-called decomposition slice
(a slice that captures all computation on a given
variable)},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
An approach to regression testing using slicing, R. Gupta and M. Harrold and M. Soffa
@InProceedings{ gupta.harrold.ea:approach,
title = {An approach to regression testing using slicing},
author = {R. Gupta and M. Harrold and M. Soffa},
pages = {299--308},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1992},
year = {1992},
note = { A new approach to data flow based regression testing is
described that uses program slicing algorithms to detect
definition-use pairs that are affected by a program change.
The advantage of this approach is that neither the data
flow history nor a recomputation of data flow is
necessary},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Automatic Extraction of Executable program subsets by simultaneous dynamic program slicing, R.J. Hall
@Article{ hall:automatic,
author = {R.J. Hall},
title = {Automatic Extraction of Executable program subsets by
simultaneous dynamic program slicing},
journal = {Automated Software Engineering},
publisher = {Kluwer Academic Publishers},
volume = {2},
year = {1995},
pages = {33-53},
note = { An algorithm to automatically extract a correctly
functioning subset of the code of a system is presented.
The technique is based on computing a simultaneous dynamic
program slice of the code for a set of representative
inputs. Experiments show that the algorithm produces
significantly smaller subsets than with existing methods},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
Program_Slicing}
}
Program Slicing, Mark Harmann and Keith Brian Gallagher
@Article{ harmann.gallagher:program,
author = {Mark Harmann and Keith Brian Gallagher},
title = {Program Slicing},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {577-582},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Data structure extraction in database reverse engineering, Henrard, Jean and Hainaut, Jean-Luc and Hick, Jean-Marc and Roland, Didier and Englebert, Vincent
Available as
hypertext.
@InProceedings{ henrard.hainaut.ea:data,
author = {Henrard, Jean and Hainaut, Jean-Luc and Hick, Jean-Marc
and Roland, Didier and Englebert, Vincent},
title = {Data structure extraction in database reverse
engineering},
booktitle = {Proc. REIS'99 Workshop (ER'99)},
year = {1999},
keywords = {database reverse engineering, data structure extraction,
database},
abstract = {Database reverse engineering is a complex activity that
can be modeled as a sequence of two major processes, namely
data structure extraction and data structure
conceptualization. The first process consists in
reconstructing the logical - that is, DBMS-dependent -
schema, while the second process derives the conceptual
specification of the data from this logical schema. This
paper concentrates on the first process, and more
particularly on the reasonings and the decision process
through which the implicit and hidden data structures and
constraints are elicited from various sources.},
url = {http://www.fundp.ac.be/recherche/publications/fr/35842.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
Program_Slicing}
}
Techniques d'analyse de programmes pour la r\'etro-ing\'enierie de bases de donn\'ees, Henrard, Jean and Hick, Jean-Marc and Roland, Didier and Englebert, Vincent Hainaut, Jean-Luc
Available as
pub-spec-paper?RP-96-018.
@InProceedings{ henrard.hick.ea:techniques,
author = {Henrard, Jean and Hick, Jean-Marc and Roland, Didier and
Englebert, Vincent Hainaut, Jean-Luc},
title = {Techniques d'analyse de programmes pour la
r\'etro-ing\'enierie de bases de donn\'ees},
booktitle = {Actes du XIV Congr\`es INFORSID},
month = {June},
year = {1996},
publisher = {AFCET},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-96-018}
,
abstract = {In this paper we will apply a generic database reverse
engineering methodology to a case study. We will sketch a
database reverse engineering methodology. Then, we will
describe the DB-MAIN CASE tool and its reverse engineering
functionality. We will explain more precisely the program
slicing. This is a powerful and useful technique to
understand a program at a given point. All will be put
together in a realistic, but small, case study.},
keywords = {reverse engineering, program slicing, DB-MAIN, database,
method},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
Static_Analysis Program_Slicing}
}
Outils d'analyse de programmes pour la r/'etro-conception de bases de donn\'ees, Henrard, Jean and Roland, Didier and Englebert, Vincent and Hick, Jean-Marc and Hainaut, Jean-Luc
Available as
pub-spec-paper?RP-98-003.
@InProceedings{ henrard.roland.ea:outils,
author = {Henrard, Jean and Roland, Didier and Englebert, Vincent
and Hick, Jean-Marc and Hainaut, Jean-Luc},
title = {Outils d'analyse de programmes pour la r/'etro-conception
de bases de donn\'ees},
booktitle = {X Congr\`es INFORSID},
address = {Montpellier},
month = {May},
year = {1998},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-98-003}
,
abstract = {The paper shows that database reverse engineering (DBRE)
needs several reasoning, techniques and tools that have
been developed in the software engineering realm, and
particularly in program understanding. Conversely, program
understanding requires an in-depth comprehension of the
semantics of the data. One of the process of the DBRE
methodology we propose is dedicated to eliciting implicit
structures and constraints buried in the application
programs. This elicitation is based on such techniques as
pattern searching, dependency graph analysis, program
slicing and program visualisation. The paper demonstrates
how these techniques can contribute to DBRE, and how that
have been integrated into the DB-MAIN CASE tool. },
keywords = {reverse engineering, program slicing, database, program
understanding, dependency graph, CASE tool},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
Program_Slicing Static_Analysis}
}
Program Understanding in Databases Reverse Engineering, Henrard, Jean and Roland, Didier and Englebert, Vincent and Hick, Jean-Marc and Hainaut, Jean-Luc
Available as
pub-spec-paper?RP-98-004.
@InProceedings{ henrard.roland.ea:program,
author = {Henrard, Jean and Roland, Didier and Englebert, Vincent
and Hick, Jean-Marc and Hainaut, Jean-Luc},
title = {Program Understanding in Databases Reverse Engineering},
booktitle = {Proc. of the DEXA'98},
address = {Vienna},
month = {August},
year = {1998},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-98-004}
,
abstract = {The main argument of the paper is that database
understanding requires sophisticated program understanding
techniques, and conversely. Database reverse engineering
(DBRE) can be carried out following a generic methodology,
one of the phases of which consists in eliciting all the
implicit and untranslated data structures and constraints.
Evidences of these hidden constructs can be found by
analysing how the programs are to use and create the data.
Hence the need for program analysis techniques such as
searching for clichés, dependency analysis, program slicing
and synthetic views. The paper explains how these
techniques contribute to DBRE, and describes DB-MAIN, a
programmable and extensible CASE environment that supports
DBRE through program understanding techniques. },
keywords = {database, data reverse engineering, methodology, program
understanding, program slicing, dependency graph, CASE
tools },
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
Program_Slicing Static_Analysis}
}
Program Understanding in Database Reverse Engineering, Henrard, Jean
Available as
hypertext.
@PhDThesis{ henrard:program,
author = {Henrard, Jean},
title = {Program Understanding in Database Reverse Engineering},
school = {University of Namur},
year = {2003},
abstract = {For many years software engineering has primarily focused
on the development of new systems and neglected maintenance
and reengineering of legacy applications. Maintenance
typically represents 70\% of the cost during the life cycle
of a system. In order to allow an efficient and safe
maintenance of a legacy system, we need to reverse engineer
it in order to reconstruct its missing or out-of-date
documentation. In data-oriented applications the reverse
engineering complexity can be broken down by considering
that the database can be reverse engineered independently
of the procedural components. Database reverse engineering
can be defined as the process of recovering the database's
schema(s) of an application from database declaration text
and program source code that use the data in order to
understand their exact structure and meaning. A database
reverse engineering methodology is broken down into three
processes: project preparation, data structure extraction
that recovers the database's logical schema and data
structure conceptualization that interprets the logical
schema in conceptual terms. In order to validate our
methodology and program understanding techniques, we have
developed tools to support them. Those tools have proved
absolutely necessary to perform database reverse
engineering of medium to larger applications in reasonable
time and at reasonable cost. To cut down on the cost of
large projects, we have stressed the need for automation to
reduce the manual work of the analyst. Our experience with
real size projects has taught us that the management
aspects of a project are essential success factors. The
management of a project comprises different aspects such as
database reverse engineering explanation, cost evaluation
and database reverse engineering result evaluation.},
url = {http://www.fundp.ac.be/recherche/publications/fr/45389.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
General_Information_on_Reverse_Engineering
Program_Slicing}
}
Interprocedural slicing using dependence graphs, Horwitz, S. and Reps, T., and Binkley, D.
@Article{ horwitz.reps.ea:interprocedural,
author = {Horwitz, S. and Reps, T., and Binkley, D.},
title = {Interprocedural slicing using dependence graphs},
journal = {ACM Transactions on Programming Languages and Systems},
volume = {12},
number = {1},
month = {January},
year = {1990},
pages = {26-60},
http = {http://www.cs.wisc.edu/~reps/reps.html#toplas90},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
The Use of Program Dependence Graphs in Software Engineering, S. Horwitz and T. Reps
@InProceedings{ horwitz.reps:use,
author = {S. Horwitz and T. Reps},
title = {The Use of Program Dependence Graphs in Software
Engineering},
booktitle = {Proceedings of the 14th International Conference on
Software Engineering },
pages = {392--411},
month = may,
year = {1992},
abstract = {This paper describes a language-independent program
representation-the program dependence graph-and discusses
how program dependence graphs, together with operations
such as program slicing, can provide the basis for powerful
programming tools that address important software
engineering problems, such as understanding what an
existing program does and how it works, understanding the
differences between several versions of a program, and
creating new programs by combining pieces of old programs.
The paper primarily surveys work in this area that has been
carried out at the University of Wisconsin.},
http = {http://www.cs.wisc.edu/wpis/papers/icse92.ps},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Application of Program Slicing in Algorithmic Debugging, Mariam Kamkar
@Article{ kamkar:application,
author = {Mariam Kamkar},
title = {Application of Program Slicing in Algorithmic Debugging},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {635-646},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Dynamic Program Slicing Methods, Bogdan Korel and Jürgen Rilling
@Article{ korel.rilling:dynamic,
author = {Bogdan Korel and Jürgen Rilling},
title = {Dynamic Program Slicing Methods},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {647-660},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Program Slicing, Jens Krinke and Gregor Snelting
@Article{ krinke.snelting:program,
author = {Jens Krinke and Gregor Snelting},
title = {Program Slicing},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {661-676},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Restructuring Programs by Tucking Statements into Functions, Arun Lakhotia and Jean-Christophe Deprez
@Article{ lakhotia.deprez:restructuring,
author = {Arun Lakhotia and Jean-Christophe Deprez},
title = {Restructuring Programs by Tucking Statements into
Functions},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {677-690},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Program Slices as an Abstraction for Cohesion Measurement, Linda M. Ott and James M. Bieman
@Article{ ott.bieman:program,
author = {Linda M. Ott and James M. Bieman},
title = {Program Slices as an Abstraction for Cohesion
Measurement},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {691-700},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Program Analysis via Graph Reachability, Thomas Reps
@Article{ reps:program,
author = {Thomas Reps},
title = {Program Analysis via Graph Reachability},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {701-726},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
On the relationships between static and dynamic models in reverse engineering Java software, Tarja Systä
Available as
~tsysta.
@InProceedings{ systä:on,
author = {Tarja Systä},
title = {On the relationships between static and dynamic models in
reverse engineering Java software},
booktitle = {Proceedings of the 6th Working Conference on Reverse
Engineering (WCRE99)},
publisher = {IEEE Computer Society},
year = {1999},
pages = {304-313},
url = {http://www.cs.tut.fi/~tsysta},
abstract = {An experimental environment for reverse engineering Java
software is discussed. Static information is extracted from
class files and viewed using Rigi reverse engineering
environment. The dynamic information is generated by
running the target software under a debugger. The debugged
event trace information is viewed as scenario diagrams
using a prototype tool called SCED. In SCED state diagrams
can be synthesized automatically from scenario diagrams.
Dynamic information can also be attached to the static Rigi
graph. Both static and dynamic views contain information
about software artifacts and their relations. Such
overlapping information forms a connection for information
exchange between the views. SCED scenario diagrams are used
for slicing the Rigi view and the Rigi view, in turn, is
used to guide the generation of SCED scenario diagrams and
for raising their level of abstraction. },
keywords = {Java, SCED, Rigi, static reverse engineering, dynamic
reverse engineering},
class = {Visualization_for_Program_Understanding_and_Debugging
Binary_Reverse_Engineering Software_Animation
Reverse_Specification Visualizing_Object-Oriented_Programs
Reverse_Design Reverse_Engineering_Tools Program_Slicing
Fundamental_Methods_in_Reverse_Design Rigi Dynamic_Analysis
Software_Reverse_Engineering Static_Analysis }
}
Static and Dynamic Reverse Engineering Techniques for Java Software Systems, Tarja Systä
Available as
~tsysta.
@PhDThesis{ systä:static,
author = {Tarja Systä},
title = {Static and Dynamic Reverse Engineering Techniques for Java
Software Systems},
school = {University of Tampere},
year = {2000},
url = {http://www.cs.tut.fi/~tsysta},
keywords = {Java, static reverse engineering, dynamic reverse
engineering, Rigi, SCED, Shimba},
class = {Visualization_for_Program_Understanding_and_Debugging
Binary_Reverse_Engineering Software_Animation
Reverse_Specification Visualizing_Object-Oriented_Programs
Reverse_Design Reverse_Engineering_Tools Program_Slicing
Fundamental_Methods_in_Reverse_Design Rig Dynamic_Analysis
Software_Reverse_Engineering Static_Analysis }
}
A survey of program slicing techniques, F. Tip
@Article{ tip:survey,
title = {A survey of program slicing techniques},
author = {F. Tip},
journal = {Journal of programming languages},
volume = {3},
pages = {121--189},
year = {1995},
note = { Surveys the state-of-the-art in program slicing and gives
many references to the literature},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Foreword to Special Issue on Program Slicing, Mark Weiser
@Article{ weiser:foreword,
author = {Mark Weiser},
title = {Foreword to Special Issue on Program Slicing},
journal = {Information and Software Technology},
year = {1998},
key = {Program Slicing},
volume = {40},
number = {11-12},
pages = {575-576},
month = {November},
note = {Special issue on program slicing},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}
Program slicing, M. Weiser
@Article{ weiser:program,
title = {Program slicing},
author = {M. Weiser},
journal = {IEEE Transactions on Software Engineering},
volume = {10},
number = {4},
pages = {352--357},
year = {1984},
note = { In this paper some properties of slices are presented. It
is shown that the use of data-flow analysis is sufficient
to find approximate slices of the generally unsolvable
problem of finding statement-minimal slices},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}