A Comparison of four Reverse Engineering Tools, Berndt Bellay and Harald Gall
@InProceedings{ bellay.gall:comparison,
author = {Berndt Bellay and Harald Gall},
title = {A Comparison of four Reverse Engineering Tools},
booktitle = {Proceedings of the 4th Working Conference on Reverse
Engineering },
publisher = {IEEE Computer Society Press},
year = {1997},
editor = {Ira Baxter and Alex Quilici and Chris Verhoef},
abstract = {Reverse engineering tools support software engineers in
the process of analyzing and understanding complex software
systems during maintenance activities. The functionality of
such tools varies from editing and browsing capabilities to
the generation of textual and graphical reports. There are
several commercial revers e engineering tools on the market
providing different capabilities and supporting specific
source code languages. We evaluated four reverse
engineering tools that analyze C source code: Refine,
Imagix4D, Sniff, and Rigi. We investigated the capabilities
of these tools by applying them to a commercial embedded
software system as a case study. We identified benefits and
shortcomings of these four tools and assessed their
applicability for embedded software systems their usability
and their extensibility.},
class = {Software_Reverse_Engineering
Software_Reverse_Engineering_Tools }
}
Partial Evaluation for the Understanding of FORTRAN Programs, S. Blazy and P. Facon
@Article{ blazy.facon:partial,
author = {S. Blazy and P. Facon},
title = {Partial Evaluation for the Understanding of {FORTRAN}
Programs},
journal = {International Journal of Software Engineering and
Knowledge Engineering},
volume = {4},
number = {4},
pages = {535-559},
year = {1994},
note = { A technique and a tool are described supporting the
partial evaluation of FORTRAN programs in order to
understand old programs that have become very complex due
to numerous alterations},
class = {Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools}
}
Generation of Components for Software Renovation Factories from Context-free Grammars, Mark van den Brand and Alex Sellink and Chris Verhoef
@InProceedings{ brand.sellink.ea:generation,
author = {Mark van den Brand and Alex Sellink and Chris Verhoef},
title = {Generation of Components for Software Renovation Factories
from Context-free Grammars},
booktitle = {Proceedings of the 4th Working Conference on Reverse
Engineering },
publisher = {IEEE Computer Society Press Los Alamitos California},
year = {1997},
editor = {Ira Baxter and Alex Quilici and Chris Verhoef},
abstract = { We present an approach for the generation of components
for a software renovation factory. These components are
generated from a context-free grammar definition that
recognizes the code that has to be renovated. We generate
analysis and transformation components that can be
instantiated with a specific transformation or analysis
task. We apply our approach to COBOL and we discuss the
construction of realistic software renovation components
using our approach.},
class = {Software_Reverse_Engineering Reengineering_Tools
Software_Reverse_Engineering_Tools }
}
Practical Difficulties in Developing Tools for Analysis of Large Application Systems, Tony Cahil
@InProceedings{ cahil:practical,
author = {Tony Cahil},
title = {Practical Difficulties in Developing Tools for Analysis of
Large Application Systems},
booktitle = {3rd Reverse Engineering Forum (REF~'92), {\rm (Burlingon,
MA; September 15-17, 1992)}},
month = {September},
year = {1992},
abstract = {},
class = {Software_Reverse_Engineering, Reverse_Engineering_Tools }
}
A logic-based approach to reverse engineering tools production, G. Canfora and A. Cimitile and U. de Carlini
@Article{ canfora.cimitile.ea:logic-based*1,
title = {A logic-based approach to reverse engineering tools
production},
author = {G. Canfora and A. Cimitile and U. de Carlini},
journal = {IEEE Transactions on Software Engineering},
pages = {1053--1064},
volume = {18},
number = {12},
year = {1992},
note = { Difficulties arising during the use of documents produced
by reverse engineering tools are discussed and analyzed},
class = {Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools}
}
A Logic-Based Approach to Reverse Engineering Tools Production, Gerardo Canfora and Aniello Cimitile and Ugo De~Carlini
@Article{ canfora.cimitile.ea:logic-based*2,
author = {Gerardo Canfora and Aniello Cimitile and Ugo
{De~Carlini}},
title = {A Logic-Based Approach to Reverse Engineering Tools
Production},
journal = {IEEE Transactions on Software Engineering},
volume = {18(12)},
year = {December 1992},
pages = {1053-1063},
abstract = {},
class = {Software_Reverse_Engineering, Reverse_Engineering_Tools }
}
Co-transformations in Information System Reengineering, Cl\`eve, Anthony and Henrard, Jean and Hainaut, Jean-Luc
Available as
hypertext.
@InProceedings{ cleve.henrard.ea:co-transformations,
author = {Cl\`eve, Anthony and Henrard, Jean and Hainaut, Jean-Luc},
title = {Co-transformations in Information System Reengineering},
booktitle = {Proc. of the Second International Workshop on Meta-Models,
Schemas and Grammars for Reverse Engineering ({ATEM}'04)},
year = {2004},
abstract = {Database reengineering consists in transforming a legacy
database according to new technical requirements, while
keeping the information contents unchanged. Substituting a
modern data management system (relational DBMS for
instance) for an outdated manager (typically standard file
manager), or improving the logical schema to gain better
performance are popular scenarios. Transformational
engineering has proved to be both an elegant and efficient
approach to perform these processes. At the present time,
we are provided with sound concepts and techniques to model
most database engineering processes, and particularly
database migration as semantics-preserving transformations.
Migrating the application programs is another hard
challenge. Indeed, the size and the complexity of the
source code of the programs make the latter difficult to
migrate while maintaining the readability of the target
code. The paper analyzes the problem of data-centered
application programs migration following the migration of
their databases. The paper explores the feasibility of
transforming the application programs through code
transformation patterns that are automatically derived from
the database transformations. It presents the principles of
a new transformational approach that couples database and
programs migration and it describes a prototype CASE tool
based in this approach.},
url = {http://www.fundp.ac.be/recherche/publications/fr/50551.html}
,
keywords = {wrapper, migration, database reverse engineering, CASE,
program transformation, co-transformation},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Approche transformationnelle de la r\'eing\'enierie des donn\'ees, Delcroix, Christine and Thiran, Philippe and Hainaut, Jean-Luc
Available as
hypertext.
@Article{ delcroix.thiran.ea:approche,
author = {Delcroix, Christine and Thiran, Philippe and Hainaut,
Jean-Luc},
title = {Approche transformationnelle de la r\'eing\'enierie des
donn\'ees},
journal = {Ing\'enierie des Syst\`emes d'Information},
year = {2001},
volume = {6},
number = {1},
pages = {61-98},
keywords = {database engineering, schema transformation, wrapper, data
migration, XML},
abstract = {Cet article présente une démarche et une architecture
générique traitant de la traduction de schémas et de la
conversion de données. La traduction de schéma est basée
sur un modèle de spécification des données multi-niveau et
multi-paradigme et sur des opérateurs transformationnels
permettant la définition des correspondances inter-schémas.
La conversion des données s'appuie sur une architecture
générique dont les composants sont définis formellement à
partir d'opérateurs transformationnels. La traduction de
schémas ainsi que la conversion des données sont supportées
par l'AGL DB-MAIN. L'approche est illustrée au travers
d'une application de réingénierie d'un ensemble de fichiers
COBOL vers XML},
url = {http://www.fundp.ac.be/recherche/publications/fr/37741.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
LaSSIE: A knowledge-based software information system, P. Devanbu and R.J. Bachman and P.G. Selfridge and B.W. Ballard
@Article{ devanbu.bachman.ea:lassie,
author = {P. Devanbu and R.J. Bachman and P.G. Selfridge and B.W.
Ballard},
title = {La{SSIE}: A knowledge-based software information system},
journal = {Communications of the ACM},
volume = {34},
number = {5},
pages = {35-49},
year = {1991},
note = { A system called LaSSIE (Large Software System Information
Environment) is presented. It incorporates a large
knowledge base, a semantic retrieval algorithm based on
formal inference, and a powerful user interface
incorporating a graphical browser and a natural language
parser. The system is intended to help programmers find
useful information about large software systems},
class = {Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}
DB-MAIN: Un Atelier d'Ing\'enierie de Bases de Donn\'ees, Englebert, Vincent and Henrard, Jean and Hick, Jean-Marc and Roland, Didier and Hainaut, Jean-Luc
Available as
pub-spec-paper?RP-96-010.
@Article{ englebert.henrard.ea:db-main,
author = {Englebert, Vincent and Henrard, Jean and Hick, Jean-Marc
and Roland, Didier and Hainaut, Jean-Luc},
title = {{DB-MAIN}: Un Atelier d'Ing\'enierie de Bases de Donn\'ees},
journal = {Ing\'enierie des Syst\`emes d'Information},
volume = {4},
number = {1},
year = {1996},
publisher = {HERMES-AFCET},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-96-010}
,
abstract = {Cet article pr\'esente un AGL d\'edi\'e \`a l'ing\'enierie
des applications orient\'ees donn\'ees, et plus
particuli\`erement aux processus complexes de
r\'e-ing\'enierie, de maintenance et d'\'evolution. Il
d\'ecrit certains de ses aspects originaux, tels que le
mod\`ele de sp\'ecification g\'en\'erique, la boite \`a
outils transformationnelle, les fonctions de
r\'etro-ing\'enierie ainsi que les fonctions de
personnalisation fonctionnelle et m\'ethodologique.},
keywords = {CASE tools, database engineering, methodology,
reverse-engineering, evolution},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Web Site Engineering, Esti\'evenart, Fabrice and Fran\ccois, Aurore and Henrard, Jean and Hainaut, Jean-Luc
Available as
hypertext.
@InProceedings{ estievenart.francois.ea:web,
author = {Esti\'evenart, Fabrice and Fran\c{c}ois, Aurore and
Henrard, Jean and Hainaut, Jean-Luc},
title = {Web Site Engineering},
booktitle = {Proc. of the 5th International Workshop on Web Site
Evolutio},
year = {2003},
publisher = {IEEE CS Press},
abstract = {Modern technologies allow web sites to be dynamically
managed by building pages on-the-fly through scripts that
get data from a database. Dissociation of data from layout
directives provides easy data update and homogeneous
presentation. However, many web sites still are made of
static HTML pages in which data and layout information are
interleaved. This leads to out-of-date information,
inconsistent style and tricky and expensive maintenance.
This paper presents a tool supported methodology to
reengineer web sites, that is, to extract the page contents
as XML documents structured by expressive DTDs or XML
Schemas. All the pages that are recognized to express the
same application (sub)domain are analyzed in order to
derive their common structure. This structure is formalized
by an XML document, called META, which is then used to
extract an XML document that contains the data of the pages
and a XML Schema validating these data. The META document
can describe various structures such as alternative layout
and data structure for the same concept, structure
multiplicity and separation between layout and
informational content. XML Schemas extracted from different
page types are integrated and conceptualised into a unique
schema describing the domain covered by the whole web site.
Finally, the data are converted according to this new
schema so that they can be used to produce the renovated
web site. These principles will be illustrated through a
case study using the tools that create the META document,
extract the data and the XML Schema.},
keywords = {reengineering, web site, XML, data extraction},
url = {http://www.fundp.ac.be/recherche/publications/fr/50540.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
Reengineering_in_General}
}
Database CASE Tool Architecture : Principles for Flexible Design Strategies, Hainaut, Jean-Luc and Cadelli, Mario and Decuyper, Bernard and Marchand, Olivier
Available as
pub-spec-paper?RP-92-001.
@InProceedings{ hainaut.cadelli.ea:database,
author = {Hainaut, Jean-Luc and Cadelli, Mario and Decuyper, Bernard
and Marchand, Olivier},
title = {Database {CASE} Tool Architecture : Principles for
Flexible Design Strategies},
booktitle = {4th Int. Conf. on Advanced Information System Engineering
(CAiSE-92)},
address = {Manchester},
month = {May},
year = {1992},
series = {LNCS},
number = {593},
publisher = {Springer-Verlag},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-92-001}
,
abstract = {The paper describes the architectural principles of a
database CASE tool that allows more flexible design
strategies than those of traditional tools that propose
oversimplistic draw-and-generate approaches. Providing this
flexibility is based on four basic principles, namely a
unique generic specification model that allows the
definition of a large variety of specific design products,
transformational functions as major database design tools,
a toolbox architecture, allowing a maximal independence
between functions, and multiple model definition through
parametrization of the unique generic model. These
architectural characteristics themselves derive from two
fundamental paradigms, namely the process-product-
requirements approach to model design behaviours, and the
transformational approach to system design.},
keywords = {design modeling, system design, database design,
transformational approach, CASE tools},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Contribution to a Theory of Database Reverse Engineering, Hainaut, Jean-Luc and Chandelon, Murielle and Tonneau, Catherine and Joris, Michel
Available as
pub-spec-paper?RP-93-003.
@InProceedings{ hainaut.chandelon.ea:contribution*2,
author = {Hainaut, Jean-Luc and Chandelon, Murielle and Tonneau,
Catherine and Joris, Michel},
title = {Contribution to a Theory of Database Reverse Engineering},
booktitle = {Proc. of the IEEE Working Conf. on Reverse Engineering
({WCRE}'93)},
address = {Baltimore},
month = {May},
year = {1993},
publisher = {IEEE Computer Society Press},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-93-003}
,
abstract = { The paper proposes both a general framework and specific
techniques for file and database reverse engineering, i.e.
recovering its conceptual schema. The framework relies on a
process/product model that matches formal as well as
empirical design procedures. Based on the analysis of
database design processes, two major phases are defined,
namely Data structure extraction and Data structure
conceptualization. For each of them, a set of activities is
proposed. Most of these activities can be described as
transformation and integration of specifications.},
keywords = {database design, database reverse engineering},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Database Evolution - the DB-MAIN Approach, Hainaut, Jean-Luc and Englebert, Vincent and Henrard, Jean and Hick, Jean-Marc and Roland, Didier
Available as
pub-spec-paper?RP-94-016.
@InProceedings{ hainaut.englebert.ea:database,
author = {Hainaut, Jean-Luc and Englebert, Vincent and Henrard, Jean
and Hick, Jean-Marc and Roland, Didier},
title = {Database Evolution - the {DB-MAIN} Approach},
booktitle = {Proc. of the 13th Int. Conf. on Entity-Relationship
Approach},
month = {December},
address = {Manchester},
year = {1994},
publisher = {Springer-Verlag},
series = {LNCS},
number = {881},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-94-016}
,
abstract = {The paper analyses some of the practical problems that
arise when the requirements of an information system
evolve, and when the database and its application programs
are to be modified accordingly. It presents four important
strategies to cope with this evolution, namely forward
maintenance, backward maintenance, reverse engineering and
anticipating design. A common, generic, framework that can
support these strategies is described. It is based on a
generic data structure model, on a transformational
approach to database engineering, and on a design process
model. The paper discusses how this framework allows
formalizing these evolution strategies, and describes a
generic CASE tool that supports database applications
maintenance.},
keywords = {database evolution, database reengineering, reverse
engineering, transformational design, process modeling,
CASE tool },
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Database Reverse Engineering : from Requirements to CARE tools, Hainaut, Jean-Luc and Englebert, Vincent and Henrard, Jean and Hick, Jean-Marc and Roland, Didier
Available as
pub-spec-paper?RP-96-011.
@Article{ hainaut.englebert.ea:database*1,
author = {Hainaut, Jean-Luc and Englebert, Vincent and Henrard, Jean
and Hick, Jean-Marc and Roland, Didier},
title = {Database Reverse Engineering : from Requirements to {CARE}
tools},
journal = {Journal of Automated Software Engineering},
volume = {3},
number = {1},
year = {1996},
publisher = {Kluwer Academic Press},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-96-011}
,
abstract = {This paper analyzes the requirements that CASE tools
should meet for effective database reverse engineering
(DBRE), and proposes a general architecture for
data-centered applications reverse engineering CASE
environments. First, the paper describes a generic
DBMS-independent DBRE methodology, then it analyzes the
main characteristics of DBRE activities in order to collect
a set of desirable requirements. Finally, it describes
DB-MAIN, an operational CASE tool developed according to
these requirements. The main features of this tool that are
described in this paper are its unique generic
specification model, its repository, its transformation
toolkit, its user interface, the text processors, the
assistants, the methodological control and its functional
extensibility. Finally, the paper describes five real-world
projects in which the methodology and the CASE tool were
applied. },
keywords = {reverse engineering, database engineering, program
understanding, methodology, CASE tools},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
DB-MAIN: a Database Reverse Engineering CASE Tool, Hainaut, Jean-Luc and Englebert, Vincent and Henrard, Jean and Hick, Jean-Marc and Roland, Didier
Available as
pub-spec-paper?RP-95-014.
@InProceedings{ hainaut.englebert.ea:db-main,
author = {Hainaut, Jean-Luc and Englebert, Vincent and Henrard, Jean
and Hick, Jean-Marc and Roland, Didier},
title = {{DB-MAIN}: a Database Reverse Engineering {CASE} Tool},
booktitle = {Proc. of the 6th Workshop on Next Generation {CASE}
tools},
address = {Jyv\"askyl\"a (Finland)},
month = {July},
year = {1995},
editor = {G. Grosz},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-95-014}
,
abstract = {This paper proposes a general architecture for Information
systems (or data-centered applications) reverse engineering
CASE environments. Recovering the specifications of such
applications requires recovering first those of their data,
i.e. database reverse engineering (DBRE). First, the paper
describes a generic DMS-independent DBRE methodology, then
it analyses the main characteristics of DBRE activities in
order to collect a set of minimum or desired requirements.
Finally, it describes the main features of an operational
CASE tool developed according to these requirements. This
study and these developments are being carried out as part
of the DB-MAIN and DB-PROCESS projects.},
keywords = {database evolution, system evolution, database
reengineering, reverse engineering, CASE tool},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Knowledge Transfer in Database Reverse Engineering - A Supporting Case Study, Hainaut, Jean-Luc and Englebert, Vincent and Hick, Jean-Marc and Henrard, Jean and Roland, Didier
Available as .
@InProceedings{ hainaut.englebert.ea:knowledge,
author = {Hainaut, Jean-Luc and Englebert, Vincent and Hick,
Jean-Marc and Henrard, Jean and Roland, Didier},
title = {Knowledge Transfer in Database Reverse Engineering - A
Supporting Case Study},
booktitle = {Proc. of the 4th IEEE Working Conference on Reverse
Engineering ({WCRE}'97)},
address = {Amsterdam (The Netherlands)},
month = {October},
year = {1997},
publisher = {IEEE Computer Society Press},
url = {},
abstract = {},
keywords = {},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Requirements for Information Systems Reverse Engineering Support, Hainaut, Jean-Luc and Englebert, Vincent and Henrard, Jean and Hick, Jean-Marc and Roland, Didier
Available as
pub-spec-paper?RP-95-013.
@InProceedings{ hainaut.englebert.ea:requirements*1,
author = {Hainaut, Jean-Luc and Englebert, Vincent and Henrard, Jean
and Hick, Jean-Marc and Roland, Didier},
title = {Requirements for Information Systems Reverse Engineering
Support},
booktitle = {Proc. of the 2nd IEEE Work. Conf. on Reverse Engineering
({WCRE}'95)},
address = {Toronto},
month = {July},
year = {1995},
publisher = {IEEE Computer Society Press},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-95-013}
,
abstract = {This paper proposes a general architecture for Information
systems (or data-centered applications) reverse engineering
CASE environments. Recovering the specifications of such
applications requires recovering first those of their data,
i.e. database reverse engineering (DBRE). First, the paper
describes a generic DMS-independent DBRE methodology, then
it analyses the main characteristics of DBRE activities in
order to collect a set of minimum or desired requirements.
Finally, it describes the main features of an operational
CASE tool developed according to these requirements. This
study and these developments are being carried out as part
of the DB-MAIN and DB-PROCESS projects. },
keywords = {database evolution, system evolution, database
reengineering, reverse engineering, CASE tool },
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Contribution to the Reverse Engineering of OO Applications - Methodology and Case Study, Hainaut, Jean-Luc and Henrard, Jean and Hick, Jean-Marc and Roland, Didier and Englebert, Vincent
Available as .
@InProceedings{ hainaut.henrard.ea:contribution,
author = {Hainaut, Jean-Luc and Henrard, Jean and Hick, Jean-Marc
and Roland, Didier and Englebert, Vincent},
title = {Contribution to the Reverse Engineering of {OO}
Applications - Methodology and Case Study},
booktitle = {Proc. of the IFIP 2.6 WC on Database Semantics (DS-7)},
address = {Leysin (CH)},
month = {October},
year = {1997},
publisher = {Chapman-Hall},
url = {},
abstract = {While database reverse engineering is getting mature,
trying to recover the semantics of recent OO applications
seems to trigger little interest. The reason is that the
problem is underlooked because OO programs should be
written in a clean and disciplined way, and based on
state-of-the-art technologies which allow programmers to
write auto-documented code. The paper is an attempt to
explain why the reality is far from this naive vision.
Mainly through a small C++ case study, it puts forward the
main problems that occur when trying to understand actual
OO applications. The example is processed through a generic
reverse engineering methodology which applies successfully
to OO programs, thanks to logical and conceptual OO models
that can precisely describe object structures at any level
of abstraction. As a synthesis of this case study, the
paper discusses the techniques and tool support that are
needed to help analysts in reverse engineering the object
structures of OO applications.},
keywords = {database, data reverse engineering, methodology,
object-oriented applications, object-oriented
specification, semantics elicitation},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Database Design Recovery, Hainaut, Jean-Luc and Henrard, Jean and Hick, Jean-Marc and Roland, Didier and Englebert, Vincent
Available as
pub-spec-paper?RP-96-014.
@InProceedings{ hainaut.henrard.ea:database,
author = {Hainaut, Jean-Luc and Henrard, Jean and Hick, Jean-Marc
and Roland, Didier and Englebert, Vincent},
title = {Database Design Recovery},
booktitle = {Proc. of the 8th Conf. on Advanced Information Systems
Engineering (CAiSE*96)},
publisher = {Springer-Verlag},
year = {1996},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-96-014}
,
abstract = {The design of a software component, such as a database, is
the trace of all the processes, products and reasonings
that have led to the production of this artifact. Such a
document is the very basis of system maintenance and
evolution processes. Unfortunately, it does not exist in
most situations. The paper describes how the design of a
database or of a collection of files can be recovered
through reverse engineering techniques. Recording the
reverse engineering activities provides a history of this
process. By normalizing and reversing this history, then by
conforming it according to a reference design methodology,
one can obtain a tentative design of the source database.
The paper describes the baselines of the approach, such as
a wide spectrum specification model, semantics-preserving
transformational techniques, and a design process model. It
describes a general procedure to build a possible DB
design, then states the requirements for CASE support, and
describes DB-MAIN, a prototype CASE tool which includes a
history processor. Finally it illustrates the proposals
through an example.},
keywords = {design recovery, database reverse engineering, database
evolution, transformational approach, process modelling,
CASE tool},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
The Nature of Data Reverse Engineering, Hainaut, Jean-Luc and Henrard, Jean and Hick, Jean-Marc and Roland, Didier and Englebert, Vincent
Available as
hypertext.
@InProceedings{ hainaut.henrard.ea:nature,
author = {Hainaut, Jean-Luc and Henrard, Jean and Hick, Jean-Marc
and Roland, Didier and Englebert, Vincent},
title = {The Nature of Data Reverse Engineering},
booktitle = {Proc. of Data Reverse Engineering Workshop 2000
(DRE'2000)},
year = {2000},
publisher = { Zurich Univ. Publish.},
abstract = {Data Reverse Engineering is a specific information system
engineering domain aiming at rebuilding the documentation
of legacy databases. The paper explores this domain by
presenting the basic problems (such as the implicit
construct recovery problem) as well as techniques and tools
for solving them. Two main phases are described, namely
data structure extraction, through which the complete
logical schema is elicited, and data structure
conceptualization, that interpret them in conceptual terms.
The paper describes and discusses a reference process model
that identifies the main classes of problems, their solving
techniques and tools that support the processes.},
url = {http://www.fundp.ac.be/recherche/publications/fr/39185.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
General_Information_on_Reverse_Engineering}
}
Structure Elicitation in Database Reverse Engineering, Hainaut, Jean-Luc and Henrard, Jean and Roland, Didier and Englebert, Vincent and Hick, Jean-Marc
Available as
pub-spec-paper?RP-96-015.
@InProceedings{ hainaut.henrard.ea:structure,
author = {Hainaut, Jean-Luc and Henrard, Jean and Roland, Didier and
Englebert, Vincent and Hick, Jean-Marc},
title = {Structure Elicitation in Database Reverse Engineering},
booktitle = {Proc. of the 3rd IEEE Working Conference on Reverse
Engineering({WCRE}'96)},
address = {Monterey (CA)},
month = {November},
year = {1996},
publisher = {IEEE Computer Society Press},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-96-015}
,
abstract = {Recovering the semantic description of file and database
structures is an important aspect of business application
reverse engineering. It includes an important and delicate
activity, namely data structure extraction, i.e. finding
the exact data structures and integrity constraints of the
database. This process is made more complex than generally
expected due to the fact that these structures and
constraints often are not explicitly defined, but are
translated into implicit constructs, controlled and managed
through procedural code or user interface protocol for
instance. This paper describes the problem of implicit
structure elicitation. It propose an analysis of this
phenomenon, and of the techniques and heuristics that can
be used in the elicitation process. It develops a set of
efficient techniques and a strategy for the elicitation of
one of the most common implicit construct, namely the
foreign key. The paper also explains how DB-MAIN, a
general-purpose database reverse engineering CASE tool, can
help analysts elicit implicit constructs, and specifically
foreign keys. },
keywords = {database reverse engineering, program understanding,
methodology, CASE tool},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
The Nature of Data Reverse Engineering, Hainaut, Jean-Luc and Henrard, Jean
Available as
hypertext.
@InProceedings{ hainaut.henrard:nature,
author = {Hainaut, Jean-Luc and Henrard, Jean},
title = {The Nature of Data Reverse Engineering},
booktitle = {Proc. of FNRS contact day on Software (re-)engineering},
year = {2003},
abstract = {Data Reverse Engineering is a specific domain of
information system engineering aiming at rebuilding the
documentation of legacy databases. The presentation
explores this domain by presenting the basic problems, such
as the implicit construct recovery, as well as techniques
and tools for solving them. A reference process model is
proposed, that identifies the main products, the classes of
problems and their solving techniques. Two main processes
are described, namely data structure extraction and data
structure conceptualization. Through the first one, the
complete logical schema (i.e., the programmer's view) is
recovered, including both declared and implicit constructs
and constraints. The data structure conceptualization
process aims at interpreting the data structures in
conceptual terms. Finally, the presentation describes a
representative CASE environment that supports the processes
by providing schema, data and code analysis tools as well
as a rich schema transformation toolkit.},
url = {http://www.fundp.ac.be/recherche/publications/fr/44348.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Transformation-based Database Reverse Engineering, Hainaut, Jean-Luc and Tonneau, Catherine and Joris, Michel and Chandelon, Murielle
Available as
pub-spec-paper?RP-94-017.
@InProceedings{ hainaut.tonneau.ea:transformation-based,
author = {Hainaut, Jean-Luc and Tonneau, Catherine and Joris, Michel
and Chandelon, Murielle},
title = {Transformation-based Database Reverse Engineering},
booktitle = {Proc. 12th Int. Conf. on Entity-Relationship Approach},
series = {LNCS},
publisher = {Springer-Verlag},
year = {1994},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-94-017}
,
abstract = {This is an abstract of a revision of the original paper
(ER'93 pre-proceedings) that presents a DBMS-independent
database reverse engineering (DBRE) methodology based on a
generic process model and on transformation techniques.
DBRE is proposed as a two-phase process consisting in
recovering the DBMS-dependent data structures (data
structure extraction) then in recovering their semantics
(data structure conceptualization). The second phase, that
is strongly linked with the logical design phase of current
database design methodologies, can be performed by
application of a selected set of standard schema
transformations. The paper illustrates the methodology by
applying it to various DBRE processes : removing
optimization structures, untranslating database/file
structures, and finally conceptual normalization. },
keywords = {database design, dabase reverse engineering, schema
transformation, schema equivalence},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
Introduction to Database Reverse Engineering, Hainaut, Jean-Luc
Available as
hypertext.
@Book{ hainaut:introduction,
author = {Hainaut, Jean-Luc},
title = {Introduction to Database Reverse Engineering},
publisher = {LIBD Publish.},
year = {2002},
abstract = {This text is an extended abstract for a future book
devoted to database reverse engineering (DBRE), considered
as a specific, but general purpose, activity of information
system engineering, and particularly system reengineering.
To give it as large a scope as possible, we have developed
general principles that can easily be specialized for any
actual data management system, ranging from simple file
managers (COBOL or RPG) to modern DB managers such as
relational systems and OO DBMS. These principles are
organized as a general DBRE methodology that is built in a
systematic way. This methodology can be specialized
according to specific DBMS models. It can be used to
compare methodologies proposed in the literature and
through reverse engineering CASE tools.},
url = {http://www.fundp.ac.be/recherche/publications/fr/40704.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
General_Information_on_Reverse_Engineering}
}
SEELA: Maintenance and Documenting by Reverse-Engineering, Joel Harband
@InProceedings{ harband:seela,
author = {Joel Harband},
title = {SEELA: Maintenance and Documenting by
Reverse-Engineering},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1990},
year = {1990},
pages = {146},
organization = {IEEE},
publisher = {IEEE Computer Society Press},
abstract = {An interactive, reverse-engineering tool, SEELA supports
the maintenance and documentation of structured programs.
It features a top-down program display that increases the
readability of structured programs and includes a structure
editor, browser, pretty printer, and source code document
generator. SEELA works with Ada, Cobol, C. Pascal, PL/M and
Fortran Code. SEELA was designed to bridge the gap between
the project's design description and the source code.
Instead of requiring a separate program-design-language
(PDL) description, it analyzes the source code and projects
it on the screen so it appears as a readable PDL code.},
class = {Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools, SEELA}
}
Inverse Wrappers for Legacy Information Systems Migration, Henrard, Jean and Cl\`eve, Anthony and Hainaut, Jean-Luc
Available as
hypertext.
@InProceedings{ henrard.cleve.ea:inverse,
author = {Henrard, Jean and Cl\`eve, Anthony and Hainaut, Jean-Luc},
title = {Inverse Wrappers for Legacy Information Systems
Migration},
booktitle = {Wrapper Techniques for Legacy Database ({WRAP}'04)},
pages = {30-43},
year = {2004},
editor = {Thiran, Philippe and van den Heuvel, Willem-Jan},
volume = {04-34},
series = {CS Report},
publisher = {Technische Universiteit Eindhoven},
abstract = {The paper studies some problems that arise when a
technology change induces the migration of a data-centered
application. In particular, it addresses the difficult
problem of migrating application programs from a legacy
data manager, such as a COBOL file system, to a modern
DBMS, such as a relational database management system. The
approach suggested in this paper relies on the concept of
inverse wrappers, that is, wrappers that simulate the
legacy API on top of the new database. This architecture
allows (1) the design of a fully normalized database rid of
the anomalies of the legacy data, (2) future programs to be
developed on a sound basis and (3) legacy programs to work
on the new database with minimum transformation, and
therefore at low cost. The paper describes the components
of this architecture, a methodology to design them and a
CASE tool that automates their generation.},
keywords = {wrapper, migration, database reverse engineering, CASE},
url = {http://www.fundp.ac.be/recherche/publications/fr/50552.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
Source-to-Source-Translation Database_Migration}
}
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}
}
Data dependency elicitation in database reverse engineering, Henrard, Jean and Hainaut, Jean-Luc
Available as
hypertext.
@InProceedings{ henrard.hainaut:data,
author = {Henrard, Jean and Hainaut, Jean-Luc},
title = {Data dependency elicitation in database reverse
engineering},
booktitle = {Proc. of the 5th European Conference on Software
Maintenance and Reengineering (CSMR 2001)},
pages = {11--19},
year = {2001},
editor = {P. Sousa and J. Ebert},
publisher = {IEEE Computer society},
keywords = {database reverse engineering, program understanding,
program slicing, db-main},
abstract = {Database reverse engineering (DBRE) attempts to recover
the technical and semantic specifications of the persistent
data of information systems. Dependencies between records
(data dependency) form a major class that need to be
recovered. Since most of these dependencies are not
supported by the DBMS, (foreign keys are the main
exception, at least in modern relational DBMS), they have
not be explicitly declared in the database schema. Careless
reverse engineering will inevitably ignore them, leading to
poor quality conceptual schema. Several information sources
can contribute to the elicitation of these hidden
dependencies. The program source code has long been
considered the richest, but also the most complex, of them.
In this paper, we analyze and compare, through their
respective quality and cost, different program
understanding techniques that can be used to elicit data
dependencies.},
url = {http://www.fundp.ac.be/recherche/publications/fr/37327.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
Extracting_Business_Rules }
}
Strategies for Data Reengineering, Henrard, Jean and Hick, Jean-Marc and Thiran, Philippe and Hainaut, Jean-Luc
Available as
hypertext.
@InProceedings{ henrard.hick.ea:strategies,
author = {Henrard, Jean and Hick, Jean-Marc and Thiran, Philippe and
Hainaut, Jean-Luc},
title = {Strategies for Data Reengineering},
booktitle = {Proc. of the 9th Working Conference on Reverse
Engineering},
year = {2002},
publisher = {IEEE Computer Society Press},
keywords = {reengineering, migration, database, reverse, engineering,
application},
abstract = {This paper describes and analyzes a serie of strategies to
migrate data-intensive applications from a legacy data
management system to a modern DMS. Considering two ways to
migrate the data and three ways to propagate the
corresponding perturbation to the program code, the paper
identifies six reference strategies that provide different
levels of quality and induce different costs. Three of them
are discussed in detail and illustrated by the conversion
of COBOL files into a SQL database.},
url = {http://www.fundp.ac.be/recherche/publications/fr/40462.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
Reengineering_in_General Database_Migration}
}
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}
}
Maintenance et \'evolution d'applications de bases de donn\'ees, Hick, Jean-Marc and Hainaut, Jean-Luc and Englebert, Vincent and Roland, Didier and Henrard, Jean
Available as
pub-spec-paper?RP-98-005.
@InProceedings{ hick.hainaut.ea:maintenance,
author = {Hick, Jean-Marc and Hainaut, Jean-Luc and Englebert,
Vincent and Roland, Didier and Henrard, Jean},
title = {Maintenance et \'evolution d'applications de bases de
donn\'ees},
booktitle = {Actes des 1\`eres Journ\'ees de R\'e-ing\'enierie des
Syst\`emes d'Information},
address = {Lyon (France)},
month = {April},
year = {1998},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-98-005}
,
abstract = {The problems concerning the maintenance and evolution of
information systems (IS) are among the most complex ones.
This paper presents a methodological framework that makes
it possible, on the one hand, to describe the evolution
problems of the data component of IS, and on the other
hand, to suggest a series of strategies that model the
designer behaviour facing those problems. It describes then
the DB-MAIN CASE tool environment, with which a prototype
of evolution tool has been built. This tool generates
automatically the database conversion programs from the
modifications history of the database logical schema. },
keywords = {IS evolution, database conversion, evolution, schema
transformation, CASE tool},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
A Survey of Software Maintenance Tools that Enhance Program Understanding, H. B. Holdbrook and S. M. Tebaut
@TechReport{ holdbrook.tebaut:survey,
author = {H. B. Holdbrook and S. M. Tebaut},
title = {A Survey of Software Maintenance Tools that Enhance
Program Understanding},
institution = {Software Engineering Research Center, University of
Florida/ Purdue University},
year = {1987},
number = {SERC-TR-9-F},
class = {Reengineering_Tools, Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools,
Reengineering_in_General, Fundamentals}
}
A Quick Tools Strategy for Program Analysis and Software Maintenance, Bret Johnson and Stephen B. Ornburn and Spencer Rugaber
@InProceedings{ johnson.ornburn.ea:quick,
author = {Bret Johnson and Stephen B. Ornburn and Spencer Rugaber},
title = {A Quick Tools Strategy for Program Analysis and Software
Maintenance},
pages = {206-213},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1992},
year = {1992},
publisher = {IEEE Computer Society Press},
month = nov,
abstract = {Most software maintenance tasks are driven by specific
customer requests for program corrections or enhancements.
These often require detailed analyses of specific code
segments. Monolithic tools may not be flexible enough to
deal with such specific requests. This paper describes a
strategy for quickly producing new special-purpose tools.
The strategy combines existing tools including simple,
off-the-shelf text processing tools; rule-based,
language-specific analysis tools; and a commercial CASE
tool.},
ftp = {ftp.cc.gatech.edu//pub/groups/reverse/repository/quick.ps}
,
class = {Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Static_Analysis,
Static_Data_Flow_Analysis}
}
Reverse Engineering with a CASE Tool, Bret Johnson
@Unpublished{ johnson:reverse,
author = {Bret Johnson},
title = {Reverse Engineering with a CASE Tool},
month = oct,
year = {1994},
abstract = {We examine using a CASE tool, Interactive Development
Environment's Software through Pictures (StP), to support
reverse engineering. We generate structure charts in StP
from the automated analysis of C source code. The
advantages of this approach are that one can use the CASE
tool's support for drawing, linking, and modifying
pictorial notations for program design in order to make it
easier to construct a reverse engineering tool.
Additionally, one can the use the design representations
with the CASE tool to do reengineering for maintenance.},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Code_Views,
Software_Reverse_Engineering_Tools}
}
PHENIX : methods and tools for database reverse engineering, Joris, Michel and Van Hoe, R. and Hainaut, Jean-Luc and Chandelon, Murielle and Tonneau, Catherine and Bodart, Fran\ccois et al.
Available as
pub-spec-paper?RP-92-004.
@InProceedings{ joris.van-hoe.ea:phenix,
author = {Joris, Michel and Van Hoe, R. and Hainaut, Jean-Luc and
Chandelon, Murielle and Tonneau, Catherine and Bodart,
Fran\c{c}ois et al.},
title = {{PHENIX} : methods and tools for database reverse
engineering},
booktitle = {Proc. 5th Int. Conf. on Software Engineering and
Applications},
address = {Toulouse},
month = {December},
publisher = {EC2 Publish.},
year = {1992},
url = {http://www.info.fundp.ac.be/cgi-publi/pub-spec-paper?RP-92-004}
,
abstract = {The paper presents methodological principles concerning
the problem of recovering the semantic structures of actual
file and database of old and poorly documented
applications. This problem, called Database Reverse
Engineering, is related to the standard database design
paradigm, revisited in order to explain and understand
informal and empirical design behaviours. A general method
is proposed, based on two major phases, namely data
structure extraction and data structure conceptualization.
An expert assistant has been implemented to help
professionals to practice this method. },
keywords = {reverse engineering, database design, CASE tools, AI
techniques},
class = {Data_Reverse_Engineering Reverse_Engineering_Tools}
}
A Tool for Maintaining Hybrid C++ Programs, P. Linos
Available as
~care.
@Article{ linos:tool,
author = {P. Linos},
title = {A Tool for Maintaining Hybrid C++ Programs},
journal = {Journal of Software Maintenance},
year = {1996},
volume = {8},
pages = {389-419},
month = {December},
url = {http://www.csc.tntech.edu/~care},
abstract = {We present a toolset for maintaining C++ programs which
are written using a hybrid object-orientated programming
style (i.e., one that combines procedural and
object-orientated techniques). The toolset maintains a
database with control and data flow information found in
source code and it is based on a compact hybrid data model
for C++ programs. This information is visualized and
manipulated both textually and graphically. A maintenance
exercise performed on a C++ program using the toolset
demonstrates that its code visualization features,
abstraction mechanisms and graph management techniques
constitute a promising platform towards the comprehension
and maintenance of complex hybrid C++ code.},
keywords = {code visualization, data flow, control flow, inheritance
hierarchy, file dependencies, colonnade, C++},
class = {Software_Reverse_Engineering
Software_Reverse_Engineering_Tools }
}
CASE support for collaborative modelling: re-engineering conceptual modelling techniques to exploit the potential of CASE tools, S. McGinnes
@Article{ mcginnes:case,
title = {{CASE} support for collaborative modelling: re-engineering
conceptual modelling techniques to exploit the potential of
{CASE} tools},
author = {S. McGinnes},
journal = {Software Engineering Journal},
pages = {183--189},
volume = {9},
number = {4},
year = {1994},
note = { It is advocated that more benefit would be obtained if
both analysis and design techniques were reengineered so as
to make the best possible use of CASE tools. Ways on how to
achieve this are given in the paper using examples from a
prototype CASE tool},
class = {Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools}
}
A Generic Architecture for Data Flow Analysis to Support Reverse Engineering, L. Moonen
Available as
.
@InProceedings{ moonen:generic,
author = {L. Moonen},
title = {A Generic Architecture for Data Flow Analysis to Support
Reverse Engineering},
booktitle = {Proc. 2nd Int. Workshop on the Theory and Practice of
Algebraic Specifications },
publisher = {Springer-Verlag},
year = {1997},
editor = {A. Sellink},
address = {Amsterdam},
url = {http://www.springer.co.uk/ewic/},
abstract = {Data flow analysis is a process for collecting run-time
information about data in programs without actually
executing them. In this paper we focus at the use of data
flow analysis to support program understanding and reverse
engineering. Data flow analysis is beneficial for these
applications since the information obtained can be used to
compute relationships between data objects in programs.
These relations play a key role for example in the
determination of the logical components of a system and
their interaction. The general support of program
understanding and reverse engineering requires the ability
to analyse a variety of source languages and the ability to
combine the results of analysing multiple languages. We
present a flexible and generic software architecture for
describing and performing language-independent data flow
analysis which allows such transparent multi-language
analysis. All components of this architecture were formally
specified. },
keywords = {language independent data flow analysis reverse
engineering},
class = {Software_Reverse_Engineering Static_Data_Flow_Analysis
Formal_Methods Reverse_Design
Software_Reverse_Engineering_Tools
Fundamental_Methods_in_Reverse_Design Static_Analysis }
}
A Reverse Engineering Approach To Subsystem Structure Identification, Hausi A. M\uller and Mehmet A. Orgun and Scott R. Tilley and James S. Uhl
@InBook{ muller.orgun.ea:reverse*1,
author = {Hausi A. M\"uller and Mehmet A. Orgun and Scott R. Tilley
and James S. Uhl},
title = {A Reverse Engineering Approach To Subsystem Structure
Identification},
publisher = {John Wiley \& Sons},
year = {1993},
class = {Software_Reverse_Engineering_Tools, Rigi}
}
A Reverse Engineering Environment Based on Spatial and Visual Software Interconnection Models, Hausi A. M\uller and S.R. Tilley and M.A. Orgun and B.D. Corrie and N.H. Madhavji
@InProceedings{ muller.tilley.ea:reverse,
key = {M\"uller et. al, 1992},
author = {Hausi A. M\"uller and S.R. Tilley and M.A. Orgun and B.D.
Corrie and N.H. Madhavji},
title = {A Reverse Engineering Environment Based on Spatial and
Visual Software Interconnection Models},
booktitle = {SIGSOFT'92: Proceedings of the Fifth ACM SIGSOFT:
Symposium on Software Development Environment},
year = {1992},
pages = {88-98},
month = dec,
abstract = {Reverse Engineering is the process of extracting system
abstractions and design information out of existing
software systems. This information can then be used for
subsequent development, maintenance, re-rengineering, or
reuse purposes. This process involves the identification of
software artefacts in a particulary subject system, and the
aggregation of these artifacts to from more abstract system
representations. This paper describes a reverse engineering
environment which uses the spatial and visual information
inherent in graphical representations of software systems
to form the basis of a software interconnection model. This
information is displayed and manipulated by the reverse
engineer using an interactive graph editor to build
subsystem structures out of software building blocks. The
spatial component constitutes information about the
relative positions of the meaningful parts of a software
structure, whereas the visual component contains
information about how a software structure looks. The
coexistence of these two representations is critical to the
comprehensive appreciation of the generated data, and
greatly benefits subsequent analysis, processing, and
decision-making.},
class = {Software_Reverse_Engineering_Tools, Rigi}
}
Rigi - A System for Reverse Engineering, Hausi A. M\uller and Scott R. Tilley and Kenny Wong and Michael J. Whitney and Margaret-Ann D. Storey
@InProceedings{ muller.tilley.ea:rigi,
author = {Hausi A. M\"uller and Scott R. Tilley and Kenny Wong and
Michael J. Whitney and Margaret-Ann D. Storey},
title = {Rigi - A System for Reverse Engineering},
class = {Software_Reverse_Engineering_Tools, Rigi}
}
Composing Subsystem Structures Using (K,2)-Partite Graphs, Hausi A. M\uller and James S. Uhl
@InProceedings{ muller.uhl:composing*1,
author = {Hausi A. M\"uller and James S. Uhl},
title = {Composing Subsystem Structures Using (K,2)-Partite
Graphs},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1990},
year = {1990},
pages = {12-19},
organization = {IEEE},
publisher = {IEEE Computer Society Press},
abstract = {Subsystem composition is the process of constructing
composite software components out of building blocks such
as variables, procedures, modules, and sybsystems.
Hierarchical subsystem structures are formed by imposing
equivalence relations on the resource-flow graphs of the
source code. Composition algorithms often use a single
equivalence relation (e.g., connection strength or data
binding measure) to form automatically tree-shaped
composite structures.
This paper describes a clustering method that uses
equivalence relations for identifying subsystem structures.
The relations are intended to embody the software
engineering principles that concern module interactions
such as low coupling, high strength, small interfaces, and
few interfaces. The resulting compositions are
(k,2)-partite graphs (a class of layered graphs) rather
than strict tree hierarchies. The method is supported by
our interactive graph editor.},
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design,
Software_Reverse_Engineering_Tools, Rigi}
}
Special Issue on ''Case Tools for Reverse Engineering'', N.N.
@Misc{ n:special,
author = {N.N.},
key = {Case Outlook},
title = {Special Issue on ''Case Tools for Reverse Engineering''},
journal = {Case Outlook},
volume = {2},
number = {2},
pages = {1-15},
year = {1988},
class = {Reengineering_Tools, Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools,
Reengineering_in_General, Fundamentals}
}
VIFOR: A Tool for Software Maintenance, Vaclav Rajlich and Nicolas Damaskinos and W. Khorshid
Available as
~care.
@Article{ rajlich.damaskinos.ea:vifor,
author = {Vaclav Rajlich and Nicolas Damaskinos and W. Khorshid},
title = {VIFOR: A Tool for Software Maintenance},
journal = {Software---Practice and Experience, Wiley},
year = {1990},
volume = {20},
number = {1},
pages = {67-77},
url = {http://www.csc.tntech.edu/~care},
class = {Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools, VIFOR}
}
Algorithm for Graphic Layout in VIFOR, Vaclav Rajlich and Nicolas Damaskinos
@InProceedings{ rajlich.damaskinos:algorithm,
author = {Vaclav Rajlich and Nicolas Damaskinos},
title = {Algorithm for Graphic Layout in VIFOR},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1990},
year = {1990},
pages = {142-145},
organization = {IEEE},
publisher = {IEEE Computer Society Press},
abstract = {VIFOR is a tool for maintenance of large FORTRAN programs.
It contains a database which stores information on all
nonlocal declaractions of the programs (i.e. subroutines,
functions, commons), all source files, and all relations
among them.
The programmer accesses this database by queries which
produce views. Each view is a subset of the information
stored in the database. VIFOR displays these views in
browsers, which are specialized windows displaying the
views graphically.},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Code_Views,
Software_Reverse_Engineering_Tools, VIFOR}
}
LOGISCOPE and the Software Maintenance Crisis, Mark A. Servello
@InProceedings{ servello:logiscope,
author = {Mark A. Servello},
title = {LOGISCOPE and the Software Maintenance Crisis},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1990},
year = {1990},
pages = {104},
organization = {IEEE},
publisher = {IEEE Computer Society Press},
abstract = {Gaining a complete understanding of unfamiliar source code
is fundamental to effective maintenance of that software.
LOGISCOPE performs a fast and consistent source code
analysis in wide variety of languages to produce graphic
aids and complexity metrics which can drastically reduce
both time and error in gaining this understanding.},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Code_Views,
Software_Reverse_Engineering_Tools, LOGISCOPE}
}
A Reverse and Re--Engineering Tool Classification Scheme, David Sharon
@Article{ sharon:reverse,
key = {Sharon},
author = {David Sharon},
title = {A Reverse and Re--Engineering Tool Classification Scheme},
pages = {Rev-3--Rev5},
journal = {Reverse Engineering Newsletter},
year = {1990},
month = {},
inhalt = { Eine Taxonomie für Werkzeuge des Reverse Engineerings
wird angegeben.
1. Existierende Systeme Untersucht wird ein vorhandenes
System auf der Code-Ebene und Informationen auf höherer
Abstraktionsebene zur Verfügung gestellt.
1.1 Enhancement Die Werkzeuge unterstützen das Verständnis
eines Programmes, bevor es geändert wird.
1.2 Assessment Der Quellcode des Systems wird bezüglich
Industriemetriken vermessen.
1.3 Conditioning Die Werkzeuge automatisieren den
Verbesserungsproze/3 eines Systems. Oft wird Quellcode in
eine strukturierte Form transformiert.
2.0 Repository Load/Enhancement and Reconciliation Daten-
und proze/3bezogener Quellcode wird gelesen und übersetzt
in das Informationsmodell eines anderen Zielrepository. },
class = {Reengineering_Tools, Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools,
Reengineering_in_General, Fundamentals}
}
Graph Layout adjustment strategies, M.-A. D. Storey and H. Mueller
@InProceedings{ storey.mueller:graph,
author = {M.-A. D. Storey and H. Mueller},
title = {Graph Layout adjustment strategies},
key = {graph layout,},
booktitle = {Graph Drawing 1995 Proceedings},
year = {1995},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Code_Views,
Software_Reverse_Engineering_Tools, Rigi}
}
Manipulating and Documenting Software Structures using SHriMP Views, M-A D Storey and H. Mueller
@InProceedings{ storey.mueller:manipulating,
author = {M-A D Storey and H. Mueller},
title = {Manipulating and Documenting Software Structures using
SHriMP Views},
key = {program understanding, reverse engineering, reengineering,
software visualization, fisheye views},
pages = {275-285},
booktitle = {International Conference in Software Maintenance},
year = {1995},
publisher = {IEEE Computer Society Press},
class = {Software_Reverse_Engineering, Reverse_Design,
Fundamental_Methods_in_Reverse_Design, Code_Views,
Software_Reverse_Engineering_Tools, Rigi}
}
Analyzing Java Software by Combining Metrics and Program Visualization, Tarja Systä and Ping Yu and Hausi Müller
Available as
~tsysta.
@InProceedings{ systä.yu.ea:analyzing,
author = {Tarja Systä and Ping Yu and Hausi Müller},
title = {Analyzing Java Software by Combining Metrics and Program
Visualization},
booktitle = {Proceedings of the 4th European Conference on Software
Maintenance and Reengineering (CSMR 2000)},
publisher = {IEEE Computer Society},
year = {2000},
pages = {199-208},
url = {http://www.cs.tut.fi/~tsysta},
abstract = {Shimba, a prototype reverse engineering environment, has
been built to support the understanding of Java software.
Shimba uses Rigi and SCED to analyze, visualize, and
explore the static and dynamic aspects, respectively, of
the subject system. The static software artifacts and their
dependencies are extracted from Java byte code and viewed
as directed graphs using the Rigi reverse engineering
environment. The static dependency graphs of a subject
system can be annotated with attributes, such as software
quality measures, and then be analyzed and visualized using
scripts through the end-user programmable interface.
Shimba has recently been extended with the Chidamber and
Kemerer suite of object-oriented metrics. The metrics
measure properties of the classes, the inheritance
hierarchy, and the interaction among classes of a subject
system. Since Shimba is primarily intended for the analysis
and exploration of Java software, the metrics have been
tailored to measure properties of software components
written in Java. We show how these metrics can be applied
in the context of understanding software systems using a
reverse engineering environment. The static dependency
graphs of the system under investigation are decorated with
measures obtained by applying the object-oriented metrics
to selected software components. Shimba provides tools to
examine these measures, to find software artifacts that
have values that are in a given range, and to detect
correlations among different measures. The object-oriented
analysis of the subject Java system can be investigated
further by exporting the measures to a spreadsheet. },
keywords = {Java, software metrics, program visualizaton, Rigi},
class = {Binary_Reverse_Engineering Reverse_Design
Reverse_Engineering_Tools
Metric-Based_Methods_in_Reverse_Design Rig
Software_Reverse_Engineering }
}
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 }
}
Wrapper Development for Legacy Data Reuse, Thiran, Philippe and Hainaut, Jean-Luc
Available as
hypertext.
@InProceedings{ thiran.hainaut:wrapper,
author = {Thiran, Philippe and Hainaut, Jean-Luc},
title = {Wrapper Development for Legacy Data Reuse},
booktitle = {Proc. of the 8th Working Conference on Reverse
Engineering},
year = {2001},
editor = {Burd, E. and Aiken, P. and Koschke, R.},
publisher = {IEEE Computer Society Press},
keywords = {Wrapper, Legacy database, CASE-tool, Reverse-engineering},
abstract = {This paper is devoted to the technology of wrappers for
legacy data systems reuse. Their characteristics are
outlined and a generic wrapper architecture is defined.
This architecture is intended to be instanciated for
specific legacy data models and systems. A general
methodology is proposed to define the architecture
components. The methodology is supported by an operational
CASE-tool that helps developers to generate wrappers.},
url = {http://www.fundp.ac.be/recherche/publications/fr/37655.html}
,
class = {Data_Reverse_Engineering Reverse_Engineering_Tools
Software_Evolution}
}
Domain-Retargetable Reverse Engineering, Scott R. Tilley and Hausi A. M\uller and Michael J. Whitney and Kenny Wong
@InProceedings{ tilley.muller.ea:domain-retargetable,
author = {Scott R. Tilley and Hausi A. M\"uller and Michael J.
Whitney and Kenny Wong},
title = {Domain-Retargetable Reverse Engineering},
pages = {142--151},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1993},
year = {1993},
publisher = {IEEE Computer Society Press},
month = sep,
abstract = {Any response to the software maintenance challenge must
address the underlying problem of program understanding.
One way of doing this is through reverse engineering. A
successful approach to reverse engineering must be both
flexible and scalable. Most reverse engineering tools
provide a fixed palette of analysis, extraction,
organization, representation, and selection techniques.
This paper describes a user-programmable approach to
reverse engineering. The approach uses a scripting language
that enables users to write their own routines for these
activities, making the system domain-retargetable. The
environment supported by this programmable approach
subsumes existing reverse engineering by being able to
simulate facets of each one, and provides a smooth
transition from semi-automatic to automatic reverse
engineering.},
class = {Software_Reverse_Engineering_Tools, Rigi}
}
Programmable Reverse Engineering, S.R. Tilley and K. Wong and M-A.D. Storey and H.A. M\uller
@Article{ tilley.wong.ea:programmable,
author = {S.R. Tilley and K. Wong and M-A.D. Storey and H.A.
M\"uller},
title = {Programmable Reverse Engineering},
journal = {International Journal of Software Engineering and
Knowledge Engineering},
volume = {4},
number = {4},
pages = {501-520},
year = {1994},
note = { This paper argues that most reverse engineering
environments are not flexible enough. They are directed
towards the tool builders instead of the users of the
environments. Besides a number of basic facilities, such as
parsing, the reverse engineering tool should allow a high
level of extensibility. The authors present an existing
scripting language, Tcl, to enable users to develop their
own routines for graph layout, metrics and analysis. Most
generic reverse engineering environments break down if they
have to deal with millions of lines of code. The
constructed abstract syntax trees contain too much
information. The reverse engineering environment should
allow a flexible gathering of information, not only based
on abstract syntax trees. The way the information is
gathered should be programmable. The reverse engineering
environments should be reusable in various application
domains. The user of the environment should be able to
program the the environment to make it suited for a
specific application domain},
class = {Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools, Rigi}
}
Documenting Software Systems with Views, Scott R. Tilley
@InProceedings{ tilley:documenting,
key = {Tilley \& Hausi A. M\"uller \& Orgun, 1992},
author = {Scott R. Tilley},
title = {Documenting Software Systems with Views},
booktitle = {SIGDOC'92: Proceedings of the 10th International
Conference on Systems Documentation},
year = {1992},
pages = {211-219},
organization = {ACM},
month = oct,
abstract = {Software professionals rely on internal documentation as
an aid in understanding programs. Unfortunately, the
documentation for most programs is usually out-of-date and
cannot be trusted. Without it, the only reliable and
objective information is the source code itself. Personnel
must spend an inordinate amount of time exploring the
system by looking at low-level source code to gain an
understanding of its functionality. One way of producing
accurate documentation for an existing software system is
through reverse engineering. This paper outlines a reverse
engineering methodology for building subsystem structures
out of software building blocks, and describes how
documenting a software system with views created by this
process can produce numerous benefits. It addresses
primarily the needs of the software engineer and technical
manager as document users.},
class = {Software_Reverse_Engineering_Tools, Rigi}
}
The Reverse Engineering Notebook, Kenny Wong
@PhDThesis{ wong:reverse,
author = {Kenny Wong},
title = {The Reverse Engineering Notebook},
school = {University of Victoria},
year = {1999},
abstract = {Software must evolve over time or it becomes useless. Much
of software production today is involved not in creating
wholly new code from scratch but in maintaining and
building upon existing code. Much of this code resides in
old legacy software systems.
Unfortunately, these systems are often poorly documented.
Typically, they become more complex and difficult to
understand over time. Thus, there is a need to better
understand existing software systems. An approach toward
this problem would be a first step toward easing changes
and extending the continuous evolution of these systems.
This dissertation addresses the problem by enabling
continuous software understanding. There should be a base
of reverse engineering abstractions that are carried
forward during evolution.
The proposed approach seeks to redocument existing software
structure, capture the analysis decisions made, and support
personal, customizable, and live perspectives of the
software in an online journal called the Reverse
Engineering Notebook.
The premise that software reverse engineering be applied
continuously throughout the lifetime of the software has
major tool design implications. Thus, tool integration,
process, and adoption are key issues for the Notebook. In
particular, data integration requirements, control
integration via pervasive scripting, presentation
integration through the management of views, user roles,
methodology, end user needs, and goal-directed framework
for the Notebook are described.
A major theme of the dissertation is learning from the
successes and failures of studies involving tool
integration and reverse engineering technologies. Case
studies and user experiments helped to evaluate various
aspects of the Notebook approach and provide feedback into
software understanding tool requirements.
},
keywords = {reverse engineering, program understanding, tool
requirements},
class = {Interoperability Reengineering_in_General Using_graphs
Reverse_Engineering_Tools Rig Process_Models
Software_Reverse_Engineering
Intermediate_Representations_of_Source_Code Experiences }
}
The Supporting Environment for A Reverse Engineering System - The Maintainer's Assistant, Hongji Yang
@InProceedings{ yang:supporting,
author = {Hongji Yang},
title = {The Supporting Environment for A Reverse Engineering
System - The Maintainer's Assistant},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1991},
year = {1991},
pages = {13-22},
organization = {IEEE},
publisher = {IEEE Computer Society Press},
abstract = {The Maintainer's Assistant is an interactive tool which
helps the user to extract a specification from an existing
source code program. It is based on a program
transformation system, in which a program is converted to a
semantically equivalent form using proven transformations
selected from a catalogue.
This paper describes the environmental support provided in
the Maintainer's Assistant. The technical methods used in
the tool are summarized and the requirements of the
environment are stated. The current implementation is then
described and results achieved discussed. Finally, both the
expected and planned developments are summarized.},
class = {Software_Reverse_Engineering,
Software_Reverse_Engineering_Tools, Maintainer's Assistant,
Reengineering_Tools}
}