System partitioning and its measure, L. Belady and C. Evangelisti
@Article{ belady.evangelisti:system,
title = {System partitioning and its measure},
author = {L. Belady and C. Evangelisti},
journal = {Journal of Systems and Software},
volume = {2},
pages = {23--29},
year = {1981},
note = { A method to perform automatic clustering of data
structures and calls is described. A metric to quantify the
complexity of the resulting partitioning is given},
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design, System_Modularization}
}
Potpurri Module Detection, Frank W. Calliss and Barry J. Cornelius
@InProceedings{ calliss.cornelius:potpurri,
author = {Frank W. Calliss and Barry J. Cornelius},
title = {Potpurri Module Detection},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1990},
year = {1990},
pages = {46-51},
organization = {IEEE},
publisher = {IEEE Computer Society Press},
abstract = {A potpourri module is a module that provides more than one
service to a program. This form of module violates the idea
of a module being considered as a ''responsibility
assignment''. The existence of this form of module
increases considerably the effort that a programmer has to
expend on a maintenance operation, and increases the
likelihood of an error being introduced to a program as a
result of maintenance work. Techniques are presented for
detecting potpourri modules that appear in programs written
in a language that contains a module construct (such as Ada
and Modula-2). Many of these techniques can be automated.},
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design}
}
Extracting and Restructuring the Design of Large Systems, Song C. Choi and Walt Scacchi
@Article{ choi.scacchi:extracting,
author = {Song C. Choi and Walt Scacchi},
title = {Extracting and Restructuring the Design of Large Systems},
journal = {IEEE Software},
year = {1990},
volume = {7},
number = {1},
pages = {66-71},
month = jan,
note = { An algorithm is described that for a given initial design
description the system-reconstruction algorithm constructs
a hierarchy of the system's modules and subsystems},
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design}
}
Software Restructuring by Enforcing Localization and Information Hiding, William C. Chu and Sukesh Patel
@InProceedings{ chu.patel:software,
author = {William C. Chu and Sukesh Patel},
title = {Software Restructuring by Enforcing Localization and
Information Hiding},
pages = {165-172},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1992},
year = {1992},
publisher = {IEEE Computer Society Press},
month = nov,
abstract = {Imperative languages like C, Fortran, and Cobol do not
provide facilities for expressing system structure
information. Understanding, maintaining and reusing large
scale software systems implemented in these languages is
difficult and time consuming. In this paper the authors sho
how the semantic basis underlying modern system structure
constructs (supported in languages such as Ada and C++) can
be used to simplify the understanding of software written
in conventional imperative languages. The restructuring
technique analyzes the input source code system into a
hierarchical system struture that exploits information
hiding and localization properties. This hierarchical view
will help to accurately identify a component's dependencies
and visibility relationships with other system
sub-components. Besides obvious understandability and
maintainability benefits this form of restructure offers a
convenient framework for translating conventional languages
to languages that support modularity, abstract data types,
and hierarchical system structure.},
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design}
}
Maintenance and Intermodule Dependencies in Pascal Environment, Aniello Cimitile and Di Lucca, G. A. and P. Maresca
@InProceedings{ cimitile.di-lucca.ea:maintenance,
author = {Aniello Cimitile and Di Lucca, G. A. and P. Maresca},
title = {Maintenance and Intermodule Dependencies in Pascal
Environment},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1990},
year = {1990},
pages = {72-83},
organization = {IEEE},
publisher = {IEEE Computer Society Press},
abstract = {This paper outlines the important role that actual and,
mainly, potential intermodular dependencies play in the
maintenance phase of a software product.
The authors discuss the problem with reference to Pascal
systems and they show how reverse engineering and static
code analysis enable the identification of the actual and
the potential intermodular data flow and relationships.
Some constraints are proposed to prevent an uncontrollable
proliferation of data binding among modules and their
reciprocal calls. To achieve the consistency of the
programs respect to the adopted constraints, the
intermodular dependencies knowledge, as produced by reverse
engineering, is used to restructure both data and module
declarations also.},
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design}
}
Reverse Engineering to the Architectural Level, David R. Harris and Howard B. Reubenstein and Alex S. Yeh
@InProceedings{ harris.reubenstein.ea:reverse,
author = {David R. Harris and Howard B. Reubenstein and Alex S.
Yeh},
title = {Reverse Engineering to the Architectural Level},
booktitle = {Proceedings of the 17th International Conference on
Software Engineering },
year = {1995},
publisher = {IEEE Computer Society Press},
month = apr,
abstract = {Recovery of higher level ''design'' information and the
ability to create dynamic, task adaptable software
documentation is crucial to supporting a number of program
understanding activities. This paper presents research that
demonstrates that reverse engineering technology can be
used to recover software architecture representations fo
source code.
The authors have developed a framework that integrates
reverse engineering technology and architectural style
representations. Using the framework, analysts can recover
custom, dynamic documentation to fit a variety of software
analysis requirements. Our goal is to establish coherent
abstractions appropriate for helping analysts to understand
large software systems. The authors discuss a code coverage
metric useful for assessing the degree of program
understanding achieved.},
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design}
}
Design Extraction by Adiabatic Multi-Perspective Abstraction, Javed I. Khan
@InProceedings{ khan:design,
key = {Khan, 1994},
author = {Javed I. Khan},
title = {Design Extraction by Adiabatic Multi-Perspective
Abstraction},
pages = {191-200},
booktitle = {Proceedings of the International Conference on Software
Maintenance ~1994},
year = {1994},
publisher = {IEEE Computer Society Press},
month = sep,
abstract = {Design extraction of an unfamiliar system is a complex
cognitive task. This paper presents an approach that can
help human expert in exploring a large and complex code
information space of an unfamiliar software. It provides
her/him a platform to access the code information with
flexible, fine and delicate control over volume and
composition of the accessed information sub-space. The
proposed approach integrates two forms of abstraction.
First, it helps to comprehend complexity of the code
information space by allowing explorer to investigate the
system from numerous (combinatorial) coherent perspectives.
In the second level, it helps to overcome scale of the
information space by allowing explorer to compress or
expand any composition of its sub-spaces. This new
approach, named as adiabatic multi-perspective (AMP)
approach to program abstraction, is founded on a
symmetrical dual hierarchical (SDH) organization of code
information space and a novel formalism for abstract
dependency analysis (ADA), which is also one of the first
formalism to perform complete program dependency analysis
on abstract program models.},
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design}
}
Towards Building a Smarter Domain Knowledge Recovery Assistant, Yang Li and Hongji Yang and William Chu
Available as .
@InProceedings{ li.yang.ea:towards,
author = {Yang Li and Hongji Yang and William Chu},
title = {Towards Building a Smarter Domain Knowledge Recovery
Assistant},
booktitle = {Proceedings of the 24th IEEE Annual Computer Software and
Applications Conference (COMPSAC2000)},
publisher = {IEEE Computer Society Press},
year = {2000},
editor = {},
chapter = {},
pages = {},
address = {},
month = {Oct},
url = {},
abstract = {Legacy systems need to be ``salvaged'' to prolong their
life circle. One way for such a salvation is to recover and
maintain domain knowledge embedded in legacy code. It is
our observation that existing methods or tools for domain
knowledge recovery from source code did not provide
maintainers with sufficient assistance to reduce the size
of analysable program sections, identify program sections
having intensive domain knowledge and maintain the belief
of a network of domain knowledge extracted from source code
which can accommodate change of belief coming from a user.
In this paper, we introduce techniques which can provide
software maintainers with smart assistance for the
above-mentioned three issues. },
keywords = {program partitioning, program readability metric, belief
network, domain knowledge recovery},
note = {We incorpate human psychology knowledge with the design of
a domain knowledge recovery tool.},
class = {Automated_Reverse_Design
Knowledge-Based_Concept_Assignment Reverse_Engineering_Tool
Model_Generating Reverse_Specification
Cognitive_Processes_in_Human_Program_Understanding Metrics
Reverse_Design System_Modularization Domain_Analysis
Recovery_of_Software_Architecture
Metric-Based_Methods_in_Reverse_Design
Human_Oriented_Concept_Assignment_by_Informal_Reasoning
Software_Reverse_Engineering }
}
Fusing Ambiguous Domain Knowledge Slices in a Reverse Engineering Process, Yang Li and Hongji Yang
Available as .
@InProceedings{ li.yang:fusing,
author = {Yang Li and Hongji Yang},
title = {Fusing Ambiguous Domain Knowledge Slices in a Reverse
Engineering Process},
booktitle = {Proceedings of the 7th Asia-Pacific Software Engineering
Conference (APSEC2000)},
publisher = {IEEE Computer Society Press},
year = {2000},
editor = {},
chapter = {},
pages = {},
address = {Singapore},
month = {Dec},
url = {},
abstract = {Recovering domain knowledge from legacy code plays an
important role in the new information technology era, which
can be of help for program understanding, system evolution
and software reuse. Traditional methods for domain
knowledge recovery from source code did not sufficiently
address the issue of ambiguity handling, in particular, the
propagation of ambiguity among multiple domain knowledge
slices recovered from source code in software reverse
engineering process. In this paper, we present a novel
approach to recovering unambiguous domain knowledge from
legacy code, where isolated ambiguous domain knowledge
slices are ``fused'' together in an iterative ambiguity
propagation process and hence the disambiguity of these
recovered knowledge slices is increased. },
keywords = {reverse engineering, domain knowledge recovery,
co-operative behaviour, belief revision},
note = {This is the first of this kind of work which deals with
the ambiguity involved in recovering large-scale domain
knowledge from source code.},
class = {Automated_Reverse_Design
Knowledge-Based_Concept_Assignment Using_graphs
Model_Generating Reverse_Specification
Cognitive_Processes_in_Human_Program_Understanding
Reverse_Design Domain_Analysis
Recovery_of_Software_Architectur
Metric-Based_Methods_in_Reverse_Design
Human_Oriented_Concept_Assignment_by_Informal_Reasoning
Intermediate_Representations_of_Source_Code
Software_Reverse_Engineering }
}
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}
}
An Automated Approach to Information Systems Decomposition, D. Paulson and Y. Wand
@Article{ paulson.wand:automated,
author = {D. Paulson and Y. Wand},
title = {An Automated Approach to Information Systems
Decomposition},
journal = {IEEE Transactions on Software Engineering},
volume = {18},
number = {3},
pages = {174-189},
year = {1992},
month = mar,
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design}
}
An Intelligent Tool for Re-engineering Software Modularity, R. W. Schwanke
@InProceedings{ schwanke:intelligent,
author = {R. W. Schwanke},
title = {An Intelligent Tool for Re-engineering Software
Modularity},
booktitle = {Proceedings of the 13th International Conference on
Software Engineering },
pages = {83--92},
month = may,
year = {1991},
abstract = {The author describes a software tool that provides
heuristic modularization advice for improving existing
code. A heuristic design similarity measure is defined,
based on the Parnas' information hiding principle. The
measure supports two services: clustering, which identifies
groups of related procedures, and maverick analysis, which
identifies individual procedures that appear to be in the
wrong module. The tool has already provided useful advice
in several real programming projects. The tool will soon
incorporate an automatic tuning method, which allows the
tool to learn from its mistakes, adapting its advice to the
architect's preferences. A preliminary experiment
demonstrates that the automatically tuned similarity
function can assign procedures to modules very
accurately.},
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design}
}
A collection of software tools for analyzing designs of concurrent software systems, A. M. Stavely and D. C. Becker and S. P. Orr and G. B. Titus
@InProceedings{ stavely.becker.ea:collection,
author = {A. M. Stavely and D. C. Becker and S. P. Orr and G. B.
Titus},
title = {A collection of software tools for analyzing designs of
concurrent software systems},
pages = {111--118},
booktitle = {Proceedings of the 8th International Conference on
Software Engineering },
year = {1985},
publisher = {IEEE Computer Society Press},
month = aug,
class = {Software_Reverse_Engineering, Reverse_Design,
Metric-Based_Methods_in_Reverse_Design,
Automated_Reverse_Design}
}