References of Reverse_Design

@InProceedings{	  abd-el-hafiz.basili:documenting,
  author	= {Salwa K. Abd-El-Hafiz and Victor R. Basili},
  title		= {Documenting Programs Using a Library of Tree Structured
		  Plans},
  pages		= {152-161},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {This paper presents an overview of knowledge-based
		  approach which helps in the mechanical documentation and
		  understanding of computer programs. This approach performs
		  mechanical annotation of loops by first decomposing them
		  into fragments, called events. It then recognizes the
		  high-level concepts, represented by the event, based on
		  patterns, called plans, stored in a knowledge-base. We
		  focus on the design and utilization of the plans and
		  discuss how to generalize their structure. The generalized
		  tree structure can facilitate plan recognition and reduce
		  the size of the knowledge-base. A case study on a real
		  program of some practical importance, containing a set of
		  77 loops, has been performed. Results concerning the plans
		  designed for this case study are given.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@Book{		  aho.sethi.ea:compilers,
  author	= { A.V. Aho and R. Sethi and J.D. Ullman },
  title		= { Compilers: Principles, Techniques, and Tools },
  publisher	= { Reading, Mass.: Addison-Wesley },
  year		= { 1985 },
  class		= {Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis }
}

@InProceedings{	  aiken.muntz.ea:framework,
  author	= {P. Aiken and A. Muntz and R. Richards},
  title		= {A framework for reverse engineering {D}o{D} legacy
		  information systems},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {180--191},
  year		= {1993},
  note		= { Gives an overview of the reverse engineering methodology
		  used inside the DoD for the reengineering of information
		  systems},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@Book{		  aiken:data,
  title		= {Data Reverse Engineering: Slaying the Legacy Dragon},
  author	= {P. Aiken},
  publisher	= {McGraw-Hill},
  year		= {1995},
  note		= { This is the first book describing the process of
		  recovering data architectures from existing information
		  systems and using it to develop a foundation for enterprise
		  integration and other reengineering efforts},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@Article{	  al-zoubi.prakash:program,
  author	= {Al-Zoubi, R. and Prakash, A.},
  title		= {Program View Generation and Change Analysis Using
		  Attributed Dependency Graphs},
  journal	= {Journal of Software Maintenance: Research and Practice},
  volume	= {7},
  number	= {4},
  pages		= {239-262},
  month		= {July-August},
  year		= {1995},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Static_Analysis }
}

@TechReport{	  al-zoubi.prakash:software,
  author	= {Al-Zoubi, R. and Prakash, A.},
  title		= {Software Change Analysis via Attributed Dependency
		  Graphs},
  year		= {1991},
  month		= {May},
  number	= {CSE-TR-95-91},
  institution	= {Department of EECS, University of Michigan},
  class		= {Alteration, Change_Impact,Software_Reverse_Engineering,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Static_Analysis }
}

@PhDThesis{	  al-zoubi:attributed,
  author	= {Ratib H. Al-Zoubi},
  title		= {Attributed Graph-Based Representations for Software View
		  Generation and Impact-of-Change Analysis},
  school	= {The University of Michigan},
  year		= {1992},
  abstract	= {Great ref. on change analysis; mostly PITS. Good related
		  work info. Tool is called SCAN.},
  class		= {Alteration, Change_Impact,Software_Reverse_Engineering,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs}
}

@InProceedings{	  alencar.cowan.ea:formal,
  author	= {P. Alencar and D. Cowan and T. Kunz and C. Lucena},
  title		= {A Formal Architectural Design Patterns-Based Approach to
		  Software Understanding},
  booktitle	= {WPC~'96: Proceedings of the IEEE Fourth Workshop on
		  Program Comprehension, {\rm (Berlin, Germany; March 29-31,
		  1996)}},
  year		= {March 1996},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Design_Pattern_Recovery }
}

@InProceedings{	  allen.garlan:formalizing,
  author	= {R. Allen and D. Garlan},
  title		= {Formalizing architectural connection},
  pages		= {71--80},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Recovery_of_Software_Architecture}
}

@Article{	  ambras.oday:microscope,
  author	= {Ambras, James and O'Day, Vicki},
  title		= {Microscope: A Knowledge-Based Programming Environment},
  journal	= {IEEE Software},
  year		= {1988},
  month		= {May},
  pages		= {50-58},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment }
}

@InProceedings{	  ambras.oday:microscope*1,
  author	= {Ambras, J. and O'Day, V.},
  title		= {Microscope: A Program Analysis System},
  booktitle	= {Proceedings of the 20th Annual Hawaii International
		  Conference on System Sciences},
  year		= {1987},
  month		= {January},
  pages		= {460-468},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment }
}

@InProceedings{	  anger.rodriguez.ea:combining,
  author	= {Frank D. Anger and Rita V. Rodriguez and Michal Young},
  title		= {Combining Static and Dynamic Analysis of Concurrent
		  Programs},
  pages		= {89-98},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Concurrent systems are inherently more difficult to
		  analyze and visualize than sequential programs. The
		  difficulty of producing correct concurrent programs is
		  mirrored in maintenance as difficulty in extracting a
		  correct high-level model of task interactions and
		  predicting the effect of a modification to portions of a
		  system. The authors advocate a methodology that combines
		  static analysis of an abstract model with dynamic analysis
		  of source code. While the abstract model is amenable to
		  exhaustive analysis, dynamic analysis is capable checking
		  richer classes of specifications, and moreover provides a
		  check on the correctness of simplifications and assumptions
		  inherent in abstract models. We illustrate this approach by
		  combining two tools, the PAL system for compositional
		  reachability analysis and the FORESEE analysis tool for
		  temporal analysis of runtime traces, applied to a
		  simulation scenario.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Dynamic_Data_Flow_Analysis }
}

@InProceedings{	  anger.rodriguez.ea:combining*1,
  author	= { F.D. Anger and R.V. Rodriguez and M. Young },
  title		= { Combining Static and Dynamic Analysis of Concurrent
		  Programs },
  booktitle	= { Proceedings of the International Conference on Software
		  Maintenance (ICSM~'94), {\rm (Victoria, B.C.; Sept. 19-23,
		  1994)}},
  year		= { September 1994 },
  editor	= { Hausi A. M\"{u}ller and Mari Georges },
  pages		= { 89-98 },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Dynamic_Analysis},
  keywords	= {concurrency, parallelism, dynamic analysis, static
		  analysis}
}

@InProceedings{	  antonini.benedusi.ea:maintenance,
  author	= {P. Antonini and P. Benedusi and G. Cantone and Aniello
		  Cimitile},
  title		= {Maintenance and Reverse Engineering: Low Level Design
		  Documents Production and Improvement},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1987},
  year		= {1987},
  pages		= {91-100},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Process_Models_for_Reverse_Design}
}

@InProceedings{	  antonini.benedusi.ea:maintenance*1,
  author	= {Antonini, P. and Benedusi, P. and Cantone, G. and
		  Cimitile, A.},
  title		= {Maintenance and Reverse Engineering: Low-level Design
		  Documents Production and Maintenance},
  booktitle	= {CSM'87: Proceedings of the 1987 Conference on Software
		  Maintenance, {\rm (Austin, Texas; September 21-24, 1987)}},
  year		= {1987},
  pages		= {91-100},
  publisher	= {IEEE Computer Society Press (Order Number 800)},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design }
}

@Unpublished{	  antoniol.fiutem.ea:program,
  author	= {G. Antoniol and R. Fiutem and G. Lutteri and P. Tonella
		  and S. Zanfei},
  title		= {Program Understanding and Maintenance with the CANTO
		  environment},
  year		= {1998},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis,
		  Recovery_of_Software_Architecture}
}

@InProceedings{	  april.merlo.ea:reverse,
  author	= {A. April and E.Merlo and A.Abran},
  title		= {A Reverse Engineering Approach to Evaluate Function Point
		  Rules},
  booktitle	= {WCRE'97 Proceeding},
  publisher	= {IEEE},
  year		= {1997},
  abstract	= {Function Points are generally used for measuring software
		  functional size from a user perspective. This paper is
		  concerned with the problem of counting function points from
		  source code using the Function Point Analysis proposed by
		  the International Function point User Group (IFPUG) 1994
		  standards. This paper presents the Automated FP counting
		  scope and objective, the presentation of an existing
		  semi-formal model and the required extensions for the
		  definition of four IFPUG rules. Then we propose reverse
		  engineering techniques to address those four rules. },
  keywords	= {Automation of Function Point, Reverse Engineering,
		  Software Measurement, backfiring},
  class		= {Software_Reverse_Engineering Metrics Reverse_Design
		  Metric-Based_Methods_in_Reverse_Design }
}

@InProceedings{	  arango.baxter.ea:maintenance,
  author	= {Guillermo Arango and Ira Baxter and Peter Freeman},
  title		= {Maintenance and Porting of Software by Design Recovery},
  booktitle	= {CSM'85: Proceedings of the 1985 Conference on Software
		  Maintenance, {\rm (Washington, DC; November 11-13, 1985)}},
  year		= {November 1985},
  pages		= {42-49},
  abstract	= {DRACO paper on porting through transformation from source
		  code to abstraction back to new code. Captures
		  domain-specific knowledge.},
  class		= {Reengineering_in_General, Experiences, Alteration,
		  Re-Code, Program_Transformations,
		  Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning },
  keywords	= {domain modeling, domain analysis, DRACO}
}

@Article{	  arango.baxter.ea:tmm*1,
  author	= {Guillermo Arango and Ira Baxter and Peter Freeman and
		  Christopher Pidgeon},
  title		= {{TMM}: Software Maintenance by Transformation},
  journal	= {IEEE Software},
  month		= {May},
  year		= {1986},
  volume	= {3},
  number	= {3},
  pages		= {27-39},
  abstract	= { . Another DRACO-based paper. . Uses least common
		  abstractions. },
  keywords	= {domain modeling, domain analysis, DRACO},
  class		= {Reengineering_in_General, Experiences, Alteration,
		  Re-Code, Program_Transformations,
		  Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning}
}

@InProceedings{	  arthur.stevens:assessing,
  author	= {James D. Arthur and K. Todd Stevens},
  title		= {Assessing the Adequacy of Documentation Through Document
		  Quality Indicators},
  booktitle	= {CSM'89: Proceedings of the 1989 Conference on Software
		  Maintenance, {\rm (Miami, Florida; October 16-19, 1989)}},
  year		= {October 1989},
  pages		= {40-49},
  publisher	= {IEEE Computer Society Press (Order Number 1965)},
  abstract	= {Interesting SIGDOC-like paper looking at docs. in a
		  qualitative manner.},
  class		= {Software_Reverse_Engineering, Reverse_Design }
}

@InProceedings{	  baecker:enhancing,
  author	= {R. Baecker},
  year		= {April 1988},
  pages		= {356-366},
  title		= {Enhancing Program Readability and Comprehensibility with
		  Tools for Program Visualization},
  booktitle	= {Proceedings of the 10th International Conference on
		  Software Engineering},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views }
}

@InProceedings{	  bailes.burnim.ea:derivation,
  author	= {P.A. Bailes and P. Burnim and M. Chapman and D. Johnston},
  title		= {Derivation and presentation of an Abstract Program Space
		  for ADA},
  booktitle	= {WPC~'96: Proceedings of the IEEE Fourth Workshop on
		  Program Comprehension, {\rm (Berlin, Germany; March 29-31,
		  1996)}},
  year		= {March 1996},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  baker.eick:visualizing*1,
  author	= { M.J. Baker and S.G. Eick },
  title		= { Visualizing Software Systems },
  booktitle	= { Proceedings of the 16th International Conference on
		  Software Engineering {\rm (Sorrento, Italy; May 16-21,
		  1994)} },
  publisher	= { IEEE Computer Society Press },
  year		= { 1994 },
  pages		= { 59-67 },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@Article{	  baratta-perez.conn.ea:ada,
  author	= {Grace {Baratta-Perez} and Richard L. Conn and Charles A.
		  Finnell and Thomas J. Walsh},
  title		= {Ada System Dependency Analyzer Tool},
  journal	= {Computer},
  month		= {February},
  year		= {1994},
  volume	= {27},
  number	= {2},
  pages		= {49-55},
  abstract	= { Describes the Ada SDA: a simple tool that parses Ada into
		  an OO-AST and does simple analysis. Focus in on two areas:
		  portability checks (e.g., what pragma are used, when
		  non-Ada routines are called, such as X/Motif), and
		  "architectural" analysis: what subunits and packages are
		  used, what is the compilation dependency order, etc. Fairly
		  pedestrian analysis. . The ability to imbed diverse systems
		  within an application, particularly COTS software, often
		  adds to architectural complexity. This becomes more
		  apparent when software must be ported. It is then that the
		  full consequences of unweildly software architecture are
		  realized. . A major thrust of modern SE mthods, languages,
		  and tools is to promote software visibility and to present
		  information about the underlying software architecture.
		  Architecture determines whether a system can evolve, be
		  enhanced, or be reused in a cost-effective way. . With
		  large, complex software systems, automated tools are
		  indispensible for identifying the architectural components,
		  the structure that connects them, and other subtle
		  dependencies. (This is Re-DITL, my work.) . The Ada SDA is
		  a "software architecture analysis tool" (nice term to use).
		  . The SDA tool identifies Ada source code dependencies on
		  COTS products such as operating systems, compilers, the X
		  Window System, and routines written in other languages, and
		  can thus predict software portability and reliability. . (I
		  could do similar "name filtering" using scripts in Rigi.) .
		  The SDA merges two key tecknologies: compiler construction
		  and OOA, OOD, and OO-implementation. . They use ayacc and
		  aflex, Ada parsers and scanners resp. from UC Irvine's
		  Arcadia project. (NB: These are PD tools; snarf!) . They
		  allow the user to specify what they want extracted from the
		  Ada source code (extraction flexibility!) via command-line
		  options. . Identifying source code dependencies: . Bit of a
		  misonomer. . Identify potential portability stumbling
		  blocks. . A "taxonomy" of "portability errors/rules" are
		  codified; they filter the source looking for instances of
		  rule violations. (Similar to Joel's DF/FQ; I could do it
		  using scripts => App area) . Ada predefined types . Ada
		  representation clauses . Interfaces to non-Ada routines .
		  Pragmas . Unidentified withed units . Machine code
		  statements . X Windows and Motif interfaces .
		  ("Portability" is a good example of an application of
		  scripting) . Analyzing Ada source code architecture .
		  Again, a bit of a misnomer (only more so this time) . File
		  statistics (number of files, library unites, comments, ...)
		  . Subunits . Library units and dependencies . Compilation
		  order . Exceptions . Reports are vt100-style tabular
		  format. Not much tweaking by the users on report format or
		  content. . "The Ada SDA provides visibility into the
		  architecture of software systems and an indication of the
		  software's portability and reliability." . This tool may
		  become PD in the future. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis }
}

@InProceedings{	  beach:connecting,
  author	= {B. W. Beach},
  title		= {Connecting Software Components with Declarative Glue},
  booktitle	= {ICSE~14: Proceedings of the 14th International Conference
		  on Software Engineering, {\rm (Melbourne, Australia; May
		  1992)}},
  pages		= {120-137},
  year		= {May 1992},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Recovery_of_Software_Architecture }
}

@InProceedings{	  beane.giddings.ea:quantifying,
  author	= {J. Beane and N. Giddings and J. Silverman},
  title		= {Quantifying software designs},
  pages		= {314--323},
  booktitle	= {Proceedings of the 7th  International Conference on
		  Software Engineering },
  year		= {1984},
  publisher	= {IEEE Computer Society Press},
  month		= mar,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@InProceedings{	  beck.eichmann:program,
  author	= {J. Beck and D. Eichmann},
  title		= {Program and interface slicing for reverse engineering},
  pages		= {509--519},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {Reverse engineering involves a great deal of effort in
		  comprehension of the current implementation of a software
		  system and the ways in which it differs from the original
		  design. Automated support tools are critical to the success
		  of such efforts. Wh show how program slicing techniques can
		  be employed to assist in the comprehension of large
		  software systems, through traditional slicing techniques at
		  the statement level, and through a new technique, interface
		  slicing, at the module level.},
  note		= {Describes the use of program slicing for the reverse
		  engineering of Ada packages},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis, Program_Slicing}
}

@InProceedings{	  beck.eichmann:program*1,
  author	= { J. Beck and D. Eichmann },
  title		= { Program and Interface Slicing for Reverse Engineering },
  booktitle	= { WCRE~'93: Proceedings of the 1993 Working Conference on
		  Reverse Engineering, {\rm (Baltimore, Maryland; May 21-23,
		  1993)}},
  year		= { May 1993 },
  pages		= { 54-63 },
  publisher	= { IEEE Computer Society Press (Order Number 3780-02) },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing }
}

@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}
}

@InProceedings{	  benedusi.benvenuto.ea:role,
  author	= {Benedusi, P. and Benvenuto, V. and Tomacelli, L.},
  title		= {The Role of Testing and Dynamic Analysis in Program
		  Comprehension Supports},
  editor	= {Fadini, Bruno and Rajlich, Vaclav},
  booktitle	= {Proceedings of the IEEE Second Workshop on Program
		  Comprehension},
  year		= {1993},
  month		= {July},
  pages		= {149-158},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Alteration, Change_Test }
}

@InProceedings{	  biggerstaff.mitbander.ea:concept,
  author	= {Ted J. Biggerstaff and B. G. Mitbander and D. Webster},
  title		= {The concept assignment problem in program understanding},
  pages		= {482--498},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {A person understands a program because they are able to
		  relate the structures of the program and its environment to
		  their human oriented conceptual knowledge about the world.
		  The problem of discovering individual human oriented
		  concepts and assigning them to their implementation
		  oriented counterparts for a given program is the concept
		  assignment problem. The authors will argue that the
		  solution to this problem requires methods that have a
		  strong plausible reasoning component. We will illustrate
		  these ideas through example scenarios using an existing
		  design recovery system called DESIRE. Finally, the authors
		  will evaluate DESIRE based on its usage on real-world
		  problems over the years.},
  keywords	= {reverse engineering, slicing, knowledge base, domain,
		  connectionist, concept recognition, plausible reasoning},
  contents	= {To understand an unknown program one must create or
		  reconstruct the informal, human oriented expression of
		  computational intent through a process of analysis,
		  experimentation, guessing and crossword puzzle-like
		  assembly. As the informal concepts are discovered and
		  interrelated concept by concept, they are simultaniously
		  associated with or assigned to the spcific implmentation
		  structurees within the program that are the concrete
		  instances of those concepts. One operational model for the
		  concept recognition and understanding process it to view it
		  as a parsing process. The recognizer program uses a finite
		  set of pattern templates that recognize the concept
		  signatures by a parsing process, where the simplest, most
		  elemental concepts are recognized first and the these
		  concepts become features of largergrained, composite
		  concepts. For parsing technologies to be effective, they
		  rely heavily upon the premise that the concepts to be
		  recognized are completely and (mostly) unambigiously
		  determined by the formal, structural features of the entity
		  being parsed and these features are contextually quite
		  local. Another model for the concept assignment problem
		  assumes that the formal, structural features play a lesser
		  role in the recognition of concepts that are important for
		  human understanding and further, that the patterns defining
		  these important concepts are far more open to variation and
		  ambiguity than can be naturally accomodated by parsing
		  technology. The hypothesis of this paper is that a
		  parsing-oriented recognition model based on formal,
		  predominately structural patterns of programming languages
		  features is necessary but insufficient for the general
		  concept assignment problem mainly because the signatures of
		  most human oriented concepts are not constrained in ways
		  that are convenient for parsing technologies.
		  
		  The properties of concept types are:
		  
		  Property | Programming Concepts | Human Concepts
		  --------------------------------------------------------------------
		  Domain | Numerical computation and | Arbitrary domain
		  characterization | data manipulation | concepts
		  --------------------------------------------------------------------
		  Feature types | Formal elements | Formal and informal | -
		  Language syntax and | - Natural language | semantics |
		  tokens | - Data flow | - proximity and | - Control flow |
		  grouping | - Deducible properties | - design conventions |
		  | - domain conventions | | - previous solution | | states |
		  | - weight of evidence
		  _____________________________________________________________________
		  Reasoning method | Deductive or algorithmic | Plausible or
		  fuzzy | | reasoning
		  _____________________________________________________________________
		  Uniqueness of | Unique or canonical | Multiple equivalent
		  solution | | solutions
		  _____________________________________________________________________
		  Precision | Precise | Approximate
		  
		  Four scenarios for automated assistance by a concept
		  assignment tools are presented. The tools can be classified
		  into naive (call graph viewer, slicer, cluser analysis
		  tool/module view, prolog query system) and intelligent
		  tools (DM-TAO).
		  
		  1) Suggestive Data Names as First Clue 2) Suggestive
		  Function Namens as First Clue 3) Patterns of Relationships
		  as First Clue 4) Intelligent Agent Provides First Clue
		  
		  DM-TAO (using a domain model) answers the following
		  questions: 1) Conceptual Highlights: Look for any concept
		  that correspond to some concept in your domain model 2)
		  Conceptual Grep: Look for instances of a user-specified
		  concept 3) What's this?: Propose a concept assignment for
		  the currently selected code
		  
		  DM-TAO uses a domain model to drive a connectionist-based
		  inference engine. The domain model is built as a network in
		  which each concept is represented as a node and the
		  relationships between nodes are represented as explicit
		  links. The information associated with each concept
		  includes: the typical features that characterize the
		  concept, its relationships to other concepts in the domain,
		  relevant informal knowledge, the syntactic and/or
		  conceptual context this concept is likely to occur in, etc.
		  The domain model also captures the underlying semantics in
		  the target domain through a rich set of interconcept
		  relations embodying the nature and degree of the semantic
		  associations between the domain concepts. To facilitate
		  inferencing, this domain information is represented as a
		  semantic/connectionist hybrid network. The concepts an
		  their features are represented by nodes, which are of
		  different types: concept node, feature node, term node,
		  syntax node, etc., depending on the information being
		  represented. The nodes are grouped together into layers.
		  The feature, term and syntax nodes form the input layer of
		  the network, while the concept nodes are loosely organized
		  at different levels of abstractions, generally reflecting
		  the conceptual infrastructure of the domain model. The
		  different inter-concept relationships present in the domain
		  model are represented by corresponding inter-node link
		  types. Every link in the system has a real-valued weight
		  associated with it, quantifying the strength of the
		  relationship between the two nodes connected by it.
		  
		  The nodes serve as the processing units of the network and
		  generate appropriate signal strengths or activation levels
		  as a nonlinear function of the input. For most nodes
		  (except those in the input layer), the input is a function
		  of the activations generated by the nodes in the previous
		  layer that they are connected to, modulated by the weight
		  on the connecting link. Nodes in the input layer are
		  directly driven by the actions of a feature-extractor which
		  scans the target code for relevant features - such as
		  syntactic clues, lexical terms which might embody a
		  concept-reference, clustering clues, etc. Their activation
		  level is a function of the number of corresponding clues
		  found in the current target code segment, the degree of the
		  match, and the activation history of related feature notes.
		  The signals generated in the input layer a propageted
		  throughout the network via a controlled spreading
		  activation process, which continues until the concept nodes
		  compute their activation levels. If the computed output of
		  a concept node is higher than a certain value - called the
		  recognition threshold, then the domain concept represented
		  by that concept node is predicted to be present in the
		  corresponding section of code from which the relevant clues
		  were extracted.
		  
		  The accuracy of prediction of the network is a function of
		  the weights distributed on it's links. The system adapts
		  it's response via a 'training' process, which modulates
		  these weights according to certain rules to obtain an
		  optimal distribution. In DM-TAO, the training is effected
		  in two stages: (1) The network is initially primed with a
		  priori knowledge from the domain model regarding the degree
		  of the association between two connected concepts (a
		  qualitative assessment of low, medium or high provided by
		  the domain builder). (2) The network weights are adjusted
		  in a performance driven manner using qualitative relevance
		  feedback from the user regarding the validity of the
		  tentative concept assignments made by the system.
		  
		  The concept recognition tool DESIRE is evaluated. Strengths
		  and weaknesses are described. A relation to commercial
		  products and other research is given.},
  note		= {The problem of discovering abstract human oriented
		  concepts and relating them to their implementation oriented
		  counterparts is called the {\rm concept assignment
		  problem}. Describes various heuristic clues, as supported
		  by the DESIRE system, that can be used for concept
		  extraction},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning}
}

@Article{	  biggerstaff.mitbander.ea:program,
  author	= {Ted J. Biggerstaff and Bharat G. Mitbander and Dallas
		  Webster},
  title		= {Program Understanding and the Concept Assignment Problem},
  journal	= {Communications of the ACM},
  volume	= {37(5)},
  year		= {May 1994},
  pages		= {72-83},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning }
}

@InProceedings{	  biggerstaff:human-oriented,
  author	= {Ted J. Biggerstaff},
  title		= {Human-oriented Conceptual Abstractions in the
		  Reengineering of Software},
  booktitle	= {Proceedings of the 12th  International Conference on
		  Software Engineering },
  pages		= {120},
  month		= mar,
  year		= {1990},
  abstract	= {Semiformal, human-oriented, and domain-specific
		  abstractions play a critical role in both reverse and
		  forward engineering, and therefore, in reengineering. Such
		  conceptual abstractions are fundamental to the
		  reengineering process whether it is a totally manual or
		  partially automated process.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning}
}

@TechReport{	  biggerstaff:hypermedia,
  author	= {Ted J. Biggerstaff},
  title		= {Hypermedia as a Tool to Aid Large Scale reuse},
  institution	= {MCC},
  year		= {1987},
  type		= {Technical Report},
  number	= {STP-202-87},
  month		= jul,
  abstract	= {This paper argues that the largest payoff of reuse is in
		  the reuse of large scale components. In order to make such
		  reuse feasible, the component to be reused must be
		  accompanied by a model that aids the software engineering
		  in understanding the component to be reused. We illustrate
		  the use of a hypermedia tool in developing such a model and
		  present what we have discovered in the course of building
		  an example of such a model.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Hypertext}
}

@Article{	  binkley:application,
  author	= {David Binkley},
  title		= {The Application of Program Slicing to Regression Testing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {583-594},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  binkley:using,
  title		= {Using semantic differencing to reduce the cost of
		  regression testing},
  author	= {D. Binkley},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  pages		= {41--50},
  year		= {1992},
  note		= { Gives an algorithm using dependence graphs and program
		  slicing to partition a modified program in parts with
		  affected program behaviour and parts with unaffected
		  behaviour. Only the parts with affected behaviour have to
		  be re-tested},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  bizivin.lennon.ea:from,
  author	= {J. Bizivin and Y. Lennon and C. Nguyen Huu Nhon},
  title		= {From Cobol to OMT: A Reengineering Workbench Based on
		  Semantic Networks},
  booktitle	= {Tools USA' 95 (Technology of Object-Oriented Languages and
		  Systems)},
  pages		= {137-152},
  year		= {1995},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@Book{		  blaha.premerlani:object-oriented,
  author	= {michael blaha and william premerlani},
  title		= {Object-Oriented Modeling and Design for Database
		  Applications},
  publisher	= {Prentice Hall},
  year		= {1998},
  abstract	= {Chapter 20 is about reverse engineering of databases.},
  keywords	= {UML, model, database, reverse engineering},
  note		= {Chapter 20 of the book provides a simple process for
		  reverse engineering of hierarchical, network, and
		  relational databases.},
  class		= {Software_Reverse_Engineering
		  Data-Centered_Program_Understanding Reverse_Design
		  Fundamental_Methods_in_Reverse_Design }
}

@InProceedings{	  blazy.facon:interprocedural,
  author	= {Sandrine Blazy and Philippe Facon},
  title		= {Interprocedural analysis for program comprehension by
		  specialization},
  booktitle	= {WPC~'96: Proceedings of the IEEE Fourth Workshop on
		  Program Comprehension, {\rm (Berlin, Germany; March 29-31,
		  1996)}},
  year		= {March 1996},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis }
}

@InProceedings{	  briand.morasca.ea:assessing,
  author	= {L. Briand and S. Morasca and V. Basili},
  title		= {"Assessing Software Maintainability at the end of
		  High-Level Design"},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  month		= sep,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@Article{	  britcher.craig:using,
  author	= {Robert N. Britcher and James J. Craig},
  title		= {Using Modern Design Practices to Upgrade Aging Software
		  Systems},
  journal	= {IEEE Software},
  year		= {1986},
  pages		= {16-24},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  General_Information_about_Reverse_Design}
}

@InProceedings{	  browne.johnson:fast,
  author	= {Browne, J.C. and Johnson, D.B.},
  title		= {{FAST}: A Second Generation Program Analysis System},
  booktitle	= {ICSE'3: Proceedings of the 3rd International Conference on
		  Software Engineering, {\rm (Atlanta, Georgia; May 10-12,
		  1978)}},
  year		= {May 1978},
  pages		= {142-148},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis }
}

@InProceedings{	  bush:software,
  author	= {E. Bush},
  title		= {Software Reengineering Position Statement},
  booktitle	= {Proceedings of the 12th  International Conference on
		  Software Engineering },
  pages		= {121},
  month		= mar,
  year		= {1990},
  abstract	= {Software reengineering work can be divided into three
		  classes of activity: (1) choosing a calculus (it is
		  suggested that the predicate calculus is a more promising
		  medium than a data/control flow graph calculus because it
		  is easier to prove equivalence between two expressions in
		  the former); (2) building an industry standard library of
		  primitive expressions in this calculus that will cover the
		  domain of interest at its most abstract level; (3) building
		  a system to recognize and prove equivalences between these
		  high-level primitives and lower level expressions in the
		  calculus that directly express the primitive operators of
		  the original implementation.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@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}
}

@Article{	  canfora.cimitile.ea:assessing,
  author	= {G. Canfora and A. Cimitile and G. Visaggio},
  title		= {Assessing Modularization and Code Scavenging Techniques},
  journal	= {Journal of Software Maintenance: Research and Practice},
  volume	= {7},
  number	= {5},
  pages		= {317-332},
  month		= {September-October},
  year		= {1995},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  System_Modularization }
}

@InProceedings{	  canfora.cimitile.ea:case,
  author	= {Canfora, G. and Cimitile, A. and De Lucia, A. and Di
		  Lucca, G. A.},
  title		= {A Case Study of Applying an Eclectic Approach to Identify
		  Objects in Code},
  booktitle	= {International Workshop on Program Comprehension},
  pages		= {136--143},
  year		= {1999},
  month		= may,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@Article{	  canfora.cimitile.ea:conditioned,
  author	= {Gerardo Canfora and Aniello Cimitile and Andrea De Lucia},
  title		= {Conditioned Program Slicing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {595-608},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  canfora.cimitile.ea:extracting,
  author	= {G. Canfora and Aniello Cimitile and M. Munro and C.J.
		  Taylor},
  title		= {Extracting Abstract Data Types from C Programs: A Case
		  Study},
  pages		= {200-209},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {This paper presents the results of a case study in
		  identifying and extracting reusable abstract data types
		  from C programs. It applies reuse re-engineering processes
		  already established in the $RE^{2}$ project. The method for
		  identifying abstract data types uses an interconnection
		  graph called variable-reference graph and coincidental and
		  spurious connections within the graph are resolved using a
		  statistical technique. A prototype tool is described which
		  demonstrates the feasibility of the method. The tool is
		  used to analyze a C program and a number of abstract data
		  types are identified and then used in the maintenance of
		  the original program. The validity of the method is
		  assessed by a simple manual analysis of the source code.
		  The resulting reusable components are specified using the
		  formal notation Z.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@Article{	  canfora.cimitile.ea:logic-based,
  key		= {Canfora et al.},
  author	= {G. Canfora and Aniello Cimitile and G. de Carlini},
  title		= {A Logic-Based Approach to Reverse Engineering Tools
		  Production},
  year		= {1992},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {1053--1064},
  volume	= {18},
  number	= {12},
  month		= dec,
  abstract	= {This paper analyzes difficulties arising in the use of
		  documents produces by Reverse Engineering tools. With
		  reference to inter-modula data flow analysis for Pascal
		  software systems, an interactive and evolutionary is
		  proposed. The tool is based on: i) the production of
		  inter-modular data flow information by static analysis of
		  code; ii) its representaton in a Prolog program dictionary;
		  iii) a Prolog abstractor that allows the specific queries
		  to be answered.},
  location	= {CMU E \&{} S Library},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  canfora.cimitile.ea:petri,
  author	= {G. Canfora and Aniello Cimitile and De Carlini, Ugo},
  title		= {Petri Nets and Reverse Engineering in Concurrent
		  Environments},
  booktitle	= {Proceedings of the 3rd International Conference on
		  Software Engineering and Knowledge Engineering SEKE' 91},
  year		= {1991},
  pages		= {213-223},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  canfora.cimitile.ea:precise,
  author	= {G. Canfora and Aniello Cimitile and M. Tortorella and M.
		  Munro},
  title		= {A Precise Method for Identifying Reusable Abstract Data
		  Types in Code},
  pages		= {404-413},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {This paper presents the results of research within the
		  $RE^{2}$ project of a refinement of two existing methods
		  for identifying reusable abstract data types. These methods
		  are based on the relationships existing between the user
		  defined types and procedure-like components that use them
		  in their headings and on direct dominance trees and strong
		  direct dominance trees that are refinements of the call
		  directed graph of a program. It shows how these methods can
		  be used to give a more precise set of reusable abstract
		  data types. The method is then applied to a program and the
		  results are compared with the existing method.},
  class		= {Software_Reverse_Engineering, Re-Use,
		  Software_Reverse_Engineering, Reverse_Design,
		  System_Modularization }
}

@InProceedings{	  canfora.cimitile.ea:reverse*1,
  author	= {G. Canfora and A. Cimitile and M. Munro},
  title		= {A reverse engineering method for identifying reusable
		  abstract data types},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {73--82},
  year		= {1993},
  note		= { Describes a methodology and experimental Prolog-based
		  tool for the extraction of reusable data type declarations
		  from source code. Illustrated for a medium-size Pascal
		  program},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@Article{	  canfora.cimitile.ea:reverse*2,
  title		= {A Reverse Engineering Process for Design Level Document
		  Production from ADA Code},
  author	= {G. Canfora and A. Cimitile and U. De Carlini},
  journal	= {Information and Software Technology},
  volume	= {35},
  number	= {1},
  pages		= {23--34},
  year		= {1993},
  note		= { A reverse engineering process for producing design level
		  documents by static analysis of ADA code is described. This
		  is achieved via concurrent data flow diagrams describing
		  the task structure and the data flow between tasks.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Process_Models_for_Reverse_Design}
}

@InProceedings{	  canfora.cimitile.ea:reverse*3,
  author	= { G. Canfora and A. Cimitile and M. Munro },
  title		= { A Reverse Engineering Method for Identifying Reusable
		  Abstract Data Types },
  booktitle	= { WCRE~'93: Proceedings of the 1993 Working Conference on
		  Reverse Engineering, {\rm (Baltimore, Maryland; May 21-23,
		  1993)}},
  year		= { May 1993 },
  pages		= { 73-82 },
  publisher	= { IEEE Computer Society Press (Order Number 3780-02)},
  abstract	= { },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  System_Modularization }
}

@Article{	  chen.nishimoto.ea:c,
  author	= {Y-F. Chen and M.Y. Nishimoto and C.V. Ramamoorthy},
  title		= {The {C} Information Abstraction System},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {16},
  number	= {3},
  pages		= {325-334},
  year		= {1990},
  note		= { A system for analyzing program structures is described.
		  The applications of this system include: generation of
		  graphical views, subsystem extraction, program layering,
		  dead code elimination, and binding analysis},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@InProceedings{	  cheung.kramer:integrated,
  author	= {S. C. Cheung and J. Kramer},
  title		= {An integrated method for effective behaviour analysis of
		  distributed systems},
  pages		= {309--322},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@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}
}

@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}
}

@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}
}

@Article{	  cimitile.visaggio:software,
  author	= {Cimitile, A. and Visaggio, G.},
  title		= {Software Salvaging and the Call Dominance Tree},
  journal	= {Journal of Systems Software},
  year		= {1995},
  volume	= {28},
  pages		= {117--127},
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@Article{	  cohen:inductive,
  author	= {W.W. Cohen},
  title		= {Inductive Specification recovery: Understanding software
		  by learning from example behaviors},
  journal	= {Automated Software Engineering},
  publisher	= {Kluwer Academic Publishers},
  volume	= {2},
  year		= {1995},
  pages		= {107--129},
  note		= { A method for program understanding that does not rely on
		  parse-and-recognize techniques (as advocated in, for
		  example, \cite{RiWa90}) is presented. After the code has
		  been annotated the system is run on a number of
		  representative test cases, generating from the annotations
		  examples of the behaviour. Finally, inductive learning
		  techniques are used to generalize the examples, thus
		  forming an abstract, general description of the behaviour
		  of the annotated code},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment}
}

@Article{	  cordy.eliot.ea:turingtool,
  author	= {J.R. Cordy and N.L. Eliot and M.G. Robertson},
  title		= {TuringTool: A User Interface to Aid in the Software
		  Maintenance Task},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {16},
  number	= {3},
  pages		= {294-301},
  year		= {1990},
  note		= { In this paper the approach of viewing a program in a
		  structured way is advocated. With the aid of queries the
		  user can influence the view of the program and can,
		  therefore, get a better idea of what the program is doing.
		  Things that are not important for a certain view are
		  elided, but can be accessed by clicking on them---the
		  elided text becomes visual. The program can also be edited
		  with this tool},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  cowan.german.ea:enhancing,
  key		= {Cowan et. al, 1994},
  author	= {D.D. Cowan and D.M. Germ\'an and C.J.P. Lucena and A. von
		  Staa},
  title		= {Enhancing Code for Readability and Comprehension Using
		  SGML},
  pages		= {181-190},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Reading and understanding programs is a key activity in
		  software reengineering, development, and maintenance. The
		  ability of people to understand programs is directly
		  related to the ease with which the source code and
		  documentation can be read. Thus, enhancements to the style
		  of presentation should heighten this comprehensibility. The
		  authors describe methods that use markup laguages such as
		  SGML to embed information about the syntax and semantics of
		  a program in the program code, and then show how these can
		  be used to enhance its presentation style. The authors also
		  briefly discuss the extension of these markup language
		  concepts to text databases, and indicate how they can
		  support various structural views of the code through
		  browsing techniques associcated with database queries.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Reformatting_and_Markup_Languages}
}

@InProceedings{	  cross:reverse,
  author	= {J. Cross},
  title		= {Reverse engineering of control structure diagrams},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {107--116},
  year		= {1993},
  note		= { Describes a tool for the automatic generation of a new
		  graphical representation for Ada software (Control
		  Structure Diagrams). These diagrams aim at improving the
		  comprehension of Ada programs and can potentially replace
		  the original source code},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Code_Views}
}

@InProceedings{	  cutillo.fiore.ea:identification,
  author	= {F. Cutillo and P. Fiore and G. Visaggio},
  title		= {Identification and extraction of ``domain independent''
		  components in large programs},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {83--92},
  year		= {1993},
  note		= { Uses program slicing to extract components from COBOL
		  programs by means of Viasoft's tools INSIGHT, SMARTDOC and
		  RENAISSANCE},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@Article{	  cytron.ferrante.ea:efficiently,
  author	= {Ron Cytron and Jeanne Ferrante and Barry K. Rosen and Mark
		  N. Wegman and F. Kenneth Zadeck},
  title		= {Efficiently Computing Static Single Assignment Form and
		  the Control Dependence Graph},
  journal	= {ACS Transaction on Programming Languages and Systems},
  year		= {1991},
  volume	= {13},
  number	= {4},
  pages		= {451-490},
  month		= {October},
  abstract	= {In optimizing compilers, data structure choices directly
		  influence the power and efficiency of practical program
		  optimization. A poor choice of data structure can inhibit
		  optimization or slow compilation to the point that advanced
		  optimization features become undesirable. Recently, static
		  single assignment form and the control dependence graph
		  have been proposed to represent data flow and control flow
		  propertiee of programs. Each of these previously unrelated
		  techniques lends efficiency and power to a useful class of
		  program optimization. Although both of these structures are
		  attractive, the difficulty of their construction and their
		  potential size have discouraged their use. We present new
		  algorithms that efficiently compute these data structures
		  for arbitrary control flow graphs. The algorithms use
		  dominance frontiers, a new concept that may have other
		  applications. We also give analytical and experimental
		  evidence that all of these data structures are usually
		  linear in the size of the original program. This paper thus
		  presents strong evidence that these structures can be of
		  practical use in optimization.},
  keywords	= {algorithms languages control dependence control flow graph
		  def-use chain dominator optimizing compilers ssa},
  class		= {Software_Reverse_Engineering Static_Data_Flow_Analysis
		  Reverse_Design Static_Control_Flow_Analysis
		  Fundamental_Methods_in_Reverse_Design Static_Analysis }
}

@InProceedings{	  das:knowledge-based,
  author	= {Bikas K. Das},
  title		= {A Knowledge-Based Approach to the Analysis of Code and
		  Program Design Language (PDL)},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {290-296},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {This paper presents a knowledge-based technique for
		  understanding programs (program design language (PDL) and
		  the corresponding code) in terms of their plans. The
		  technique has been used successfully to enhance PDL's role
		  in maintaining and modifying code. This success is
		  illustrated by an example in this paper. The methodology
		  from which this technique evolved was derived from an
		  earlier approach we used in developing a knowledge-based
		  prototype that inspects and quality assures software
		  components. The prototype model offers a unified
		  representation of the components that have been used here
		  to represent PDL and code segments. Recent approaches to
		  program analysis and understanding for use in software
		  maintenance are discussed. The authors argue that unlike
		  other research advances in this area, the authors' approach
		  is more realistic and takes advantage of a structured
		  environment (standards for PDL, for example) commonly
		  practiced in a software community. Yet the methodology is
		  fairly general and immediately applicable in other software
		  activities. Interesting directions for future work are
		  outlined also.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@InProceedings{	  debaud:dare,
  author	= {Jean-Marc DeBaud},
  title		= {DARE: Domain-Augmented ReEngineering},
  booktitle	= {Proceedings of the Fourth 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 in this article the principles of a
		  domain-augmented reengineering approach (DARE) as well as
		  our initial experience applying sections of it. The
		  principal characteristic of the DARE approach is its focus
		  upon the computational context of a software system i.e.
		  the business or scientific domain to which it relates. This
		  context information is used both to drive the program
		  understanding as well as for the program evolution phases
		  of reengineering. In DARE a domain model (concepts and
		  associated relationships) serves as the structure denoting
		  context and is used for two purposes. First a dictionary of
		  possible domain concept realizations is populated. Second a
		  set of mappings from the domain to an existing tool or
		  library related to the domain is defined. Reengineering
		  then proceeds as follows: First a legacy system is analyzed
		  and annotated with the dictionary of domain concept
		  realizations. Then these matched concepts are transitioned
		  to the tool or library using the predefined mapping set.
		  Program evolution can then take place at the level of the
		  tool or library. Using our initial experience we discuss
		  DARE present an analysis and suggest implications for
		  future work.},
  class		= {Software_Evolution Software_Reverse_Engineering
		  Model_Generating Reverse_Specification Reverse_Design
		  Domain_Analysis Process_Models_for_Reverse_Design
		  Knowledge-Based_Concept_Assignmen }
}

@InProceedings{	  desclaux.ribault:macs,
  author	= {Christine Desclaux and Michel Ribault},
  title		= {MACS: Maintenance Assistence Capability for Software
		  Maintenance},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {2-11},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {MACS goal is to offer a customizable software maintenance
		  assistance system. Its main concern is to help the
		  maintainer in gaining a deep understanding of existing or
		  in-progress applications, of the factual data (Change
		  Management World and Abstraction Recovery World) and the
		  design decisions rationale (Reasoning World), the mapping
		  of domain to programming components (Interconnection
		  World). Moreover this broad reverse-engineering approach is
		  enhanced by impact analysis techniques to better perceive
		  the interaction between components. The MACS supervisor
		  proposes a set of maintenance process models to guide the
		  maintainer through the MACS worlds. Knowledge Base and
		  Expert-System techniques are used in conjunction with
		  Software Engineering techniques, which makes MACS a KADME,
		  Knowledge Assistance for Development and Maintenance
		  Environment. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Reengineering_in_General, Process_Models}
}

@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}
}

@InProceedings{	  devanbu.brachman.ea:lassie,
  author	= {P. Devanbu and R. J. Brachman and P. G. Selfridge and B.
		  W. Ballard},
  title		= {{LaSSIE}: A Knowledge-based Software Information System},
  booktitle	= {Proceedings of the 12th  International Conference on
		  Software Engineering },
  pages		= {249--261},
  month		= mar,
  year		= {1990},
  abstract	= {The authors discuss the important problem of invisibility
		  that is inherent in the task of developing large software
		  systems. It is pointed out that there are no direct
		  solutions to this problem; however, there are several
		  categories of systems-relational code analyzers, reuse
		  librarians, and project management databases-that can be
		  seen as addressing aspects of the invisibility problem. It
		  is argued that these systems do not adequately deal with
		  certain important aspects of the problem of
		  invisibility-semantic proliferation, multiple views, and
		  the need for intelligent indexing. A system called LaSSIE,
		  which uses knowledge representation and reasoning
		  technology to address each of these three issues directly
		  and thereby help with the invisibility problem, has been
		  built. The authors conclude with an evaluation of the
		  system and a discussion of open problems and ongoing
		  work.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Knowledge-Based_Concept_Assignment}
}

@Article{	  devanbu.rosenblum.ea:generating,
  key		= {DRW96},
  author	= {P.T. Devanbu and D.R. Rosenblum and A.L. Wolf},
  title		= {Generating Testing and Analysis Tools},
  journal	= {ACM Transactions on Software Engineering and Methodology},
  year		= {1996},
  volume	= {5},
  number	= {1},
  pages		= {42-62},
  note		= {This article describes tools for analysing C/C++ programs
		  for programming understanding. These tools are generated
		  and support a procedural mechanism to retrieve information
		  from the C/C++ programs.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Source_Code_Queries}
}

@InProceedings{	  devanbu:genoa,
  author	= {P. T. Devanbu},
  title		= {{GENOA} - {A} Customizable, language- and Front-end
		  Independent Code Analyzer},
  booktitle	= {Proceedings of the 14th  International Conference on
		  Software Engineering },
  pages		= {307--317},
  month		= may,
  year		= {1992},
  abstract	= {Programmers working on large software systems spend a
		  great deal of time examining code and trying to understand
		  it. Code analysis tools (e.g. cross referencing tools such
		  as CIA and Cscope) can be very helpful in this process.
		  This paper describes GENOA, an application generator that
		  can produce a whole range of useful code analysis tools.
		  GENOA is designed to be language- and front-end
		  independent; it can be interfaced to any front-end for any
		  language that produces an attributed parse tree, simply by
		  writing an interface specification. While GENOA programs
		  can perform arbitrary analyses on the parse tree, the GENOA
		  language has special, compact iteration operators that are
		  tuned for expressing simple, polynomial time analysis
		  programs. It describes the system, provides several
		  practical examples, and presents complexity and
		  expressivity results for the above-mentioned sublanguage of
		  GENOA.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  dietrich.nackman.ea:saving,
  author	= {W. C. Dietrich and L. R. Nackman and F. Gracer},
  title		= {Saving a Legacy with Objects},
  booktitle	= {OOPSLA},
  pages		= {77-83},
  year		= {1989},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@InProceedings{	  doval.mancoridis.ea:automatic,
  author	= {Doval, D. and Mancoridis, S. and Mitchel, B.S and Chen, Y.
		  and Gansner, E.R.},
  title		= {Automatic Clustering of Software Systems using a Genetic
		  Algorithm},
  booktitle	= { Proceedings of the International Conference on Software
		  Tools and Engineering Practice},
  year		= {1999},
  month		= aug,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  dumke.kompf:came,
  author	= {Reiner R. Dumke and Gunnar Kompf},
  title		= {CAME Tools for an Efficient Software Maintenance},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {This paper describes the role of the metrics tools as
		  Computer Assisted Software Measurement and Evaluation
		  (CAME) tools in the software life cycle, especially in the
		  maintenance phase. The most CAME tools are designed for
		  code analysis and measurement. They are predestined to be
		  applied to the implementation and maintenance development
		  phases. But, more and more tools are developed for the
		  earlier phases of software development to estimate the
		  effort, complexity, and size of the software that will be
		  created. This paper will provide an overview of the present
		  situation on the area of the CAME tools and discuss their
		  efficient use in the software maintenance. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics}
}

@InProceedings{	  emerson:discriminant,
  author	= {T. Emerson},
  title		= {A Discriminant Metric for Module Cohesion},
  year		= {1984},
  publisher	= {IEEE Computer Society Press},
  month		= mar,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@InProceedings{	  engberts.kozaczynski.ea:concept,
  author	= {Andre Engberts and Wojtek Kozaczynski and Jim Q. Ning},
  title		= {Concept Recognition-Based Program Transformation},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {73-82},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Traditionally, program transformation has been used mostly
		  for forward program development: the generation of
		  executable code from specifications. This paper describes
		  an approach that applies a transformation paradigm to
		  automate software maintenance activities. A very unique
		  characteristic of this approach is its use of concept
		  recognition, the understanding and abstraction of
		  high-level programming and application domain entities in
		  programs, as the basis for transformations. A program
		  transformation tool has been developed to support the
		  migration of a large manufacturing control system written
		  in COBOL. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@InProceedings{	  fantechi.nesi.ea:object-oriented,
  author	= {A. Fantechi and Paolo Nesi and E. Somma},
  title		= {Object-Oriented Analysis of COBOL},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {The object-oriented paradigm is presently considered the
		  one which best guarantees the investments for renewal. It
		  allows to produce software with high degrees of reusability
		  and maintainability, satisfying in a certain measure also
		  quality characteristics. These features are not obviously
		  automatically guaranteed by the simple adoption of an
		  object-oriented programming language, a process of
		  re-analysis is needed. In this view, several methods for
		  reengineering old applications according to the
		  object-oriented paradigm were defined and proposed. In this
		  paper, a method and tool (C2O2, COBOL to Object-Oriented)
		  for analyzing COBOL applications in order to extract its
		  object-oriented analysis is presented. The tool identifies
		  classes and their relationships by means of a process of
		  understanding and refinement in which COBOL data structures
		  are analyzed, converted in classes, aggregated, and
		  simplified semiautomatically. The algorithm is also capable
		  of detecting data structures which can cause problems
		  passing to the next millennium, as demonstrated with an
		  example.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@InProceedings{	  favre:cpp,
  author	= {Jean-Marie Favre},
  title		= {CPP Denotational Semantics and its Application to Software
		  Maintenance},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Very often, portability of large software products is
		  achieved via the empirical use of old tools like CPP, the
		  preprocessor of the C language. Though powerful low level
		  features like conditional compilation cause serious
		  maintenance problems. There is a lack of adequate tools to
		  support such activities. This paper presents our approach
		  to this problem. We introduce APP, an abstract language
		  semantically equivalent to CPP but based on traditional
		  programming-in-the-small concepts. A rigorous description
		  of the semantics of this language makes it possible to
		  develop reliable reverse engineering tools. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Configuration_Structures}
}

@Article{	  field.tip:dynamic,
  author	= {John Field and Frank Tip},
  title		= {Dynamic Dependence in Term Rewriting Systems and its
		  Application to Program Slicing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {609-634},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  fletton.munro:redocumenting,
  author	= {N. T. Fletton and M. Munro},
  title		= {Redocumenting Software Systems Using Hypertext
		  Technology},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1988},
  year		= {1988},
  pages		= {54-59},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Hypertext}
}

@Article{	  forgacs:double,
  key		= {Forgacs, 1994},
  author	= {Istv\'an Forg\'acs},
  title		= {Double Iterative Framework for Flow-Sensitive
		  Interprocedural Data Flow Analysis},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1994},
  volume	= {3},
  number	= {1},
  pages		= {29-55},
  month		= jan,
  abstract	= {Compiler optimization, parallel processing, data flow
		  testing, and symbolic debugging can benefit from
		  interprocedural data flow analysis. However, the live,
		  reaching definition, and most summary data flow problems
		  are theoretically intractable in the interprocedural case.
		  A method is presented that reduces the exponential time
		  bound with the help of an algorithm that solves the problem
		  in polynomial time. Either the resulting sets contain
		  precise results or the missing (or additional) results do
		  not cause any problems during their use. The authors also
		  introduce the double iterative framework, where one
		  procedure is processed at a time. The results of the
		  intraprocedural analysis of procedures the propagates along
		  the edges of the call multi-graph. In this way the intra
		  and interprocedural analyses are executed alternately until
		  there is no change in any result set. This method can be
		  applied to any known interprocedural data flow problem.
		  Here the algorithms for the kill, live variables, and
		  reaching definitions problems are presented. Besides for
		  precision, the algorithms can be used for very large
		  programs, and since inter and intraprocedural analyses can
		  be optimized separately, the method is fast as well.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  friedrich.witschurke:fapu,
  author	= {Horst Friedrich and Reiner Witschurke},
  title		= {The FAPU Workbench},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Before software can be adapted to changing economical,
		  organizational and technical conditions, it has to be
		  ABunderstoodBB. Understanding involves obtaining all the
		  information belonging to the application system in question
		  by means of analysis, interpretation and evaluation of the
		  software's structures (the individual programs of the
		  various program systems plus existing documentation) and of
		  the context and exact nature of its use (e.g. business
		  processes and workflows). Within a program of research into
		  tools supporting application understanding, the Fraunhofer
		  ISST has developed a prototype of the FAPU Workbench (FAPU
		  - FORTRAN Application and Program Understanding). A special
		  feature of FAPU is that it distinguishes between program
		  information and non-program information and enables
		  interactive linking within and between these two types of
		  information. FAPU can handle files consisting of a mixture
		  of programs in different languages, control commands and
		  data. Its robust parser can analyse a wide range of FORTRAN
		  dialects and deal with unknown constructs. The location of
		  comments within source code is preserved, new comments can
		  be added and existing ones modified. The analysis is always
		  performed with respect to a platform model containing
		  information about the computer type, the operating system,
		  and the compiler. As well as many analysis options and the
		  synchronization of their presentation, FAPU also enables
		  visualization of COMMON blocks. This paper presents the
		  tool developed at the Fraunhofer ISST. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@InProceedings{	  fukunaga:prompter,
  author	= {K. Fukunaga},
  title		= {PROMPTER: a knowledge-based support tool for code
		  understanding},
  pages		= {358--363},
  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,
		  Knowledge-Based_Concept_Assignment}
}

@InProceedings{	  g-snelting.tip:reengineering,
  author	= {G. Snelting, and F. Tip},
  title		= {Reengineering Class Hierarchies using Concept Analysis},
  booktitle	= {Proc. SIGSOFT Symposium on Foundations of Software
		  Engineering},
  publisher	= {ACM},
  year		= {1998},
  key		= {Concept Analysis},
  class		= {Inhertiance_Hierarchies_Restructuring
		  Software_Reverse_Engineering Static_Data_Flow_Analysis
		  Reverse_Design Re-Design Static_Control_Flow_Analysis
		  Fundamental_Methods_in_Reverse_Design Alteration
		  Static_Analysis }
}

@InProceedings{	  gall.klösch.ea:resolving,
  author	= {Gall, H. and Klösch, R. and Weidl, J.},
  title		= {Resolving Uncertainties in object oriented
		  re-architecturing of procedural code},
  booktitle	= { Proceedings of the 7th International Conference on
		  Information Processing and Management of Uncertainty in
		  Knowledge Based Systems},
  year		= {1998},
  month		= jul,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@Article{	  gallagher.lyle:using,
  author	= {Keith Brian Gallagher and James R. Lyle},
  title		= {Using Program Slicing in Software Maintenance},
  journal	= {IEEE Transactions on Software Engineering},
  year		= {1991},
  volume	= {17},
  number	= {8},
  pages		= {751-761},
  month		= aug,
  abstract	= {Program slicing, introduces by Weiser, is known to help
		  programmers in understanding foreign code and in debugging.
		  We apply program slicing to the maintenance problem by
		  extending the notion of a program slice (that orginally
		  required both a variable and line number) to a
		  decomposition slice, one that captures all computation on a
		  given variable; i.e., is independent of line numbers. Using
		  the lattice of single variable decomposition slices ordered
		  by set inclusion, we demonstrate how to form a slice-based
		  decomposition for programs. We are then able to delineate
		  the effects of a proposed change by isolating those effects
		  in a single component of the decomposition. This gives
		  maintainers a straightforward technique for determining
		  those statements and variables which may be modified in a
		  component and those which may not. Using the decomposition,
		  we provide a set of principles to prohibit changes which
		  will interfere with unmodified components. These
		  semantically consistent changes can then be merged back
		  into the original program in linear time. Moreover, the
		  maintainer can test the changes in the component with the
		  assurance that there are no linkages into other components.
		  Thus decomposition slicing induces a new software
		  maintenance process model which eliminates the need for
		  regression testing.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis, Program_Slicing}
}

@Article{	  gallagher.lyle:using*1,
  title		= {Using program slicing in software maintenance},
  author	= {K. Gallagher and J. Lyle},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {17},
  number	= {8},
  pages		= {751--761},
  year		= {1991},
  note		= { In this paper the technique of program slicing is used to
		  facilitate maintenance of software systems by extending the
		  notion of program slice to a so-called decomposition slice
		  (a slice that captures all computation on a given
		  variable)},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  gillis.wright:improving,
  author	= {Keith D. Gillis and David G. Wright},
  title		= {Improving Software Maintenance Using System-Level Reverse
		  Engineering},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {84-90},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Success in the software maintenance environment depends
		  upon the ability to read and comprehend existing source
		  code. A high level of comprehension is becoming more and
		  more more difficult to achieve as systems increase in
		  overall size and complexity. The described Fortran Reverse
		  Engineering software package programmatically analyzes
		  existing Fortran source code and generates complete
		  Structure Charts, and Module Specifications in a CASE
		  environment. The user can also select options to create
		  software trees and a variety of cross reference-tables. The
		  use of these objects can increase programmer productivity
		  by providing system-level details in a manner that can be
		  easily understood. They also aid in the software
		  maintenance process by providing the design baseline for
		  future software modifications and adds documentation of the
		  software set. Integrating a system-level reverse
		  engineering utility tool into a CASE enfivonment is just
		  one step toward improving programmer productivity and
		  increasing success in the software maintenance process.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@TechReport{	  girard.briand:reengineering,
  author	= {Girard, J.F and Briand, L.},
  title		= {Reengineering Concepts, Techniques and Tools for Component
		  Extraction},
  institution	= {CRIM, Montreal, Canada},
  year		= {1996},
  number	= {CRIM95/04-26},
  month		= may,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  girard.koschke.ea:comparison,
  author	= {Jean-Francois Girard and Rainer Koschke and Georg Schied},
  title		= {Comparison of Abstract Data Type and Abstract State
		  Encapsulation Detection Techniques for Architectural
		  Understanding},
  booktitle	= {Proceedings of the 4th  Working Conference on Reverse
		  Engineering },
  publisher	= {IEEE Computer Society Press},
  year		= {1997},
  abstract	= {In the context of the authors' research on architectural
		  features recovery, abstract data type (ADT) and abstract
		  state encapsulation (ASE, also called abstract object) have
		  been identified as two of the smallest components which are
		  useful to build a significant architectural over view of
		  the system. The authors have named these the atomic
		  components of an architecture. This paper compares five
		  published techniques which extract ADT and ASE from source
		  code. A prototype tool implementing each techniques has
		  been developed and applied to three medium size systems
		  written in C (each over 30 Kloc). The results from each
		  approach are com pared with the atomic components
		  identified by hand by a group of software engineers. These
		  people did not know the automatic techniques which were
		  going to be applied to the systems. },
  class		= {Software_Reverse_Engineering Reverse_Design
		  Encapsulation_and_Finding_Objects_in_Legacy_Code }
}

@Article{	  girard.koschke.ea:metric-based,
  author	= {Girard, J.F. and Koschke, R. and Schied, G.},
  title		= {A Metric-based Approach to Detect Abstract Data Types and
		  Abstract State Encapsulation},
  journal	= {Journal on Automated Software Engineering, Kluwer Academic
		  Publishers},
  year		= {1999},
  volume	= {6},
  number	= {4},
  pages		= {357--386},
  month		= oct,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  girard.koschke.ea:metric-based*1,
  author	= {Jean-Francois Girard and Rainer Koschke and Georg Schied},
  title		= {A metric-based approach to detect abstract data types and
		  state encapsulations},
  booktitle	= {Proceedings of the 12th International Automated Software
		  Engineering Conference, ASE'97},
  publisher	= {IEEE Computer Society Press},
  month		= {November},
  year		= {1997},
  pages		= {82-89},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@Article{	  girard.koschke:comparison,
  author	= {Girard, J.F. and Koschke, R.},
  title		= {A Comparison of Abstract Data Type and Objects Recovery
		  Techniques},
  journal	= {Journal Science of Computer Programming, Elsevier},
  year		= {2000},
  volume	= {36},
  number	= {2--3},
  pages		= {149--181},
  month		= mar,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  girard.koschke:finding,
  author	= {Jean-Francois Girard and Rainer Koschke},
  title		= {Finding Components in a Hierarchy of Modules - a Step
		  towards Architectural Understanding},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1997},
  publisher	= {IEEE Computer Society Press},
  year		= {1997},
  abstract	= {This paper presents a method to view a system as a
		  hierarchy of modules according to the information hiding
		  ideas and to identify architectural component candidates in
		  this hierarchy. The result of the method eases the under
		  standing of a system's underlying software architecture. A
		  prototype tool implementing this method was applied to
		  three systems written in C (each over 30 Kloc). For one of
		  these systems an author of the system created an architec
		  tural description. The components generated by our method
		  correspond to those of this architectural descrip tion in
		  almost all the cases. For the other two systems most of the
		  components resulting from the method corre spond to
		  meaningful system abstractions.},
  class		= {Software_Reverse_Engineering Reverse_Design
		  System_Modularization }
}

@InProceedings{	  gopal.schach:using,
  author	= {Rajeev Gopal and Stephan R. Schach},
  title		= {Using Automatic Program Decomposition Techniques in
		  Software Maintenance Tools},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {132-141},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Program decomposition can assist maintenance programmers
		  in all three phses of maintenance, namely comprehension,
		  modification and debugging. Visibility flow graphs are
		  introduced to represent the information about the static
		  semantics of a program. Using static analysis of programs,
		  it is possible to approximate their dynamic behaviour. More
		  precise analysis is possible if the program is monitored
		  during its execution. For dynamic semantics, dependence
		  relations are used that reflect the dependency of
		  statements on the input value of variables and of the
		  output value of variables on the statements. These
		  relations are generated both at static analysis time, and
		  also during program execution. Some sample sessions with a
		  prototype program analyzer for a subset of Ada are also
		  included.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Static_Analysis, Static_Data_Flow_Analysis,
		  Dyanmic_Analysis, Dynamic_Data_Flow_Analysis}
}

@InProceedings{	  gulla:improved,
  author	= {Bjorn Gulla},
  title		= {Improved Maintenance Support by Multi-Version
		  Visualizations},
  pages		= {376-383},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {Software repositories are becoming increasingly more
		  popular. Multiple versions of software components and
		  systems and associated information are stored and managed.
		  Such integrated systems aim for supporting the whole life
		  cycle, including specification, design, development and
		  maintenance.
		  
		  However, current systems exhibit only limited support for
		  software maintenance tasks. The main problem is the lack of
		  powerful and easily accessible user facilities. In this
		  paper we propose a set of visualization techniques intended
		  to improve the support for maintenance of large software
		  systems. The novel contribution is the active use of
		  version information. We will use the term multi-version
		  visualization, since visual representation containing
		  information aggregated from several versions of the
		  software are computed.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Configuration_Structures}
}

@InProceedings{	  gupta.harrold.ea:approach,
  title		= {An approach to regression testing using slicing},
  author	= {R. Gupta and M. Harrold and M. Soffa},
  pages		= {299--308},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  note		= { A new approach to data flow based regression testing is
		  described that uses program slicing algorithms to detect
		  definition-use pairs that are affected by a program change.
		  The advantage of this approach is that neither the data
		  flow history nor a recomputation of data flow is
		  necessary},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  hainaut.chandelon.ea:contribution,
  author	= {J.-L. Hainaut and M. Chandelon and C. Tonneau and M.
		  Joris},
  title		= {Contribution to a theory of database reverse engineering},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {161--170},
  year		= {1993},
  note		= {Gives a methodology for recovering the conceptual schema
		  of databases. Illustrated with various COBOL examples},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@Article{	  hall:automatic,
  author	= {R.J. Hall},
  title		= {Automatic Extraction of Executable program subsets by
		  simultaneous dynamic program slicing},
  journal	= {Automated Software Engineering},
  publisher	= {Kluwer Academic Publishers},
  volume	= {2},
  year		= {1995},
  pages		= {33-53},
  note		= { An algorithm to automatically extract a correctly
		  functioning subset of the code of a system is presented.
		  The technique is based on computing a simultaneous dynamic
		  program slice of the code for a set of representative
		  inputs. Experiments show that the algorithm produces
		  significantly smaller subsets than with existing methods},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Program_Slicing}
}

@InProceedings{	  hall:generalized,
  author	= {Robert J. Hall},
  title		= {Generalized Behavior-based Retrieval},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {The user of a large reuse library faces the formidable
		  discovery problem of searching for all and only those
		  components useful in solving the current programming task.
		  This paper describes a retrieval technique that generalizes
		  the simple idea of executing each component on test inputs,
		  reporting those that compute correct outputs. One
		  generalization improves recall by considering small
		  programs constructible from library components, rather than
		  just single components. Furthermore, functional modeling of
		  components allows the technique to handle complex
		  behaviors, such as side effects. I motivate, describe, and
		  analyze the technique and a working prototype, GBR, which
		  has been tested on two libraries: one containing general
		  programming components, the other containing (some) Unix
		  shell commands.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Dynamic_Data_Flow_Analysis}
}

@MastersThesis{	  hanssen:extraktion,
  author	= {Sven Hanssen},
  title		= {Extraktion statischer Traces zur Wiedergewinnung von
		  Protokollen},
  school	= {Institut für Informatik, Universität Stuttgart},
  year		= {2000},
  note		= {The language is German.},
  type		= {Studienarbeit Nr. 1768},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Others}
}

@Article{	  harandi.ning:knowledge-based,
  author	= {Mehdi T. Harandi and Jim Q. Ning},
  title		= {Knowledge-Based Program Analysis},
  journal	= {IEEE Software},
  year		= {1990},
  volume	= {7},
  number	= {1},
  pages		= {74-81},
  month		= jan,
  inhalt	= {Es gibt vier Ebenen, auf denen Programme betrachtet werden
		  können: 1) Implementierungsebene, z.B. abstrakte
		  Syntaxbäume 2) Strukturebene, z.B. - Daten- oder
		  Kontrollflu\3graphen - Daten- oder
		  Kontrollabhängigkeitsgraphen - interprozedurale
		  Aufrufrelationen - ripple-effect-Graphen - Petrinetze -
		  Strukturdiagramme 3) Funktionsebene Abstrakte
		  Repräsentation einer Klasse von funktional äquivalenter,
		  aber strukturell unterschiedlicher Implementierungen. 4)
		  Domänen-Ebene abstrahiert die Funktionsebene durch
		  Ersetzung deren algorithmischer Natur mit Konzepten der
		  Anwendungs-Domäne; z.B. statt Löschen eines Elementes aus
		  einer Liste, das Verabschieden eines Mitarbeiters aus dem
		  Unternehmen.
		  
		  In diesem Artikel geht es um die Funktionsebene. Es wird
		  beschrieben, wie in einem Programm bestimmte
		  Programmierkonzepte erkannt werden können. Die
		  Programmierkonzepte sind in einer Planbasis enthalten und
		  werden mit den Informationen über das Programm (Events)
		  abgeglichen. Die Events sind in einer Klassenhierarchie
		  gegliedert. Die gefundene Abgleichung wird
		  natürlich-sprachlich paraphrasiert. },
  note		= { Automatic program analysis with a tool called PAT is used
		  to understand programs on a high level. The applications
		  are maintenance for large complex programs},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@Article{	  harmann.gallagher:program,
  author	= {Mark Harmann and Keith Brian Gallagher},
  title		= {Program Slicing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {577-582},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@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}
}

@Article{	  harrison.magel.ea:applying,
  author	= {W. Harrison and K. Magel and R. Kluczny and A. DeKock},
  title		= {Applying Software Complexity Metrics to Program
		  Maintenance},
  journal	= {IEEE Computer},
  year		= {1982},
  volume	= {15},
  number	= {9},
  month		= sep,
  pages		= {65-79},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Maintenance_Metrics}
}

@PhDThesis{	  hartman:automatic,
  author	= {John Hartman},
  title		= {Automatic Control Understanding for Natural Programs},
  school	= {University of Texas at Austin},
  year		= {1991},
  month		= may,
  abstract	= {Program understanding involves recognizing abstract
		  concepts like ``read-process-loops'' in existing programs.
		  Programmers spend much of their time understanding
		  programs, so studying and automating the process has many
		  benefits.
		  
		  Programming plans are units of programming knowledge
		  connecting abstract concepts and their implemenations.
		  Existing research assumes that plan instances can be
		  recognized to recover the programmer's abstract concepts
		  and intentions, but this approach has not been confirmed
		  empirically.
		  
		  We present a practical method for bottom-up control concept
		  recognition in large, unstructured imperative programs.
		  Control concepts are abstract notions about interactions
		  between control flow, data flow and computation, such as
		  ``do loop'', ``read-process-loop'', and ``bounded linear
		  search''. They are recognized by comparing an abstract
		  program representation against a library of standard
		  implementation plans. The program representation is a
		  hierarchical control flow/data flow graph decomposed into a
		  tree of sub-models using propers (single entry/exit conrol
		  flow sub-graphs). Plans are represented by similar graphs
		  with added qualifications. Recognition is based on simple
		  matching between sub-models and plans. The method was
		  implemented in the UNPROG program understander and tested
		  with Cobol and Lisp source programs.
		  
		  This method is robust, efficient and scalable. The program
		  represenation can be formed for all language construct
		  which permit static determination of control and data flow.
		  Comparing sub-models and plans is efficient because
		  sub-models are small; have restricted, canonical control
		  flow; and focus recognition on criterial program features.
		  The number of sub-models and comparisions increases
		  linearly with program size.
		  
		  UNPROG has been applied to automatic Cobol restructuring.
		  Knowledge associated with plans and concepts permits more
		  specific and insightful transformation, code generation,
		  and documentation than is possible with syntactic methods.
		  Control understanding can similarly raise the level of
		  other reverse engineering and re-engineering tools for
		  applications like analysis, documentation, and translation.
		  
		  We also showed how our method and UNPROG can be used for
		  empirical study of programs at the conceptual level.
		  Results can be used to improve recognizer performance,
		  acquire plans, catalog natural plans and concepts, test the
		  hypothesis that programs are planful, and characterize
		  program populations. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing, UNPROG}
}

@InProceedings{	  hartman:understanding,
  author	= {John Hartman},
  title		= {Understanding Natural Programs Using Proper
		  Decomposition},
  booktitle	= {Proceedings of the 13th  International Conference on
		  Software Engineering },
  pages		= {62--73},
  month		= may,
  year		= {1991},
  abstract	= {The author presents a practical method for automatic
		  control concept recognition in large, unstructured
		  imperative programs. Control concepts are abstract notions
		  about interactions between control flow, data flow, and
		  computation, e.g., read-process loops. They are recognized
		  by comparing a language-independent abstract program
		  representation against standard implementation plans.
		  Recognition is efficient and scalable because the program
		  representation is hierarchically decomposed by propers
		  (single entry/exit control flow subgraphs). A recognition
		  experiment using the UNPROG program understander shows the
		  method's performance, the role of proper decomposition, and
		  the ability to use standard implementations in a sample of
		  programs. How recognized control concepts are used to
		  perform Cobol restructuring with quality not possible with
		  existing syntactic methods is described.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing, UNPROG}
}

@Article{	  hattori.ishii:method,
  author	= {Norihide Hattori and Naohiro Ishii},
  title		= {A method to remove variations in source codes},
  journal	= {Information and Software Technology},
  volume	= {38},
  pages		= {25-36},
  year		= {1996},
  abstract	= {Variations in source codes of computer programs cause
		  difficult problems in source code handling systems, such as
		  program understanding systems. This paper proposes a new
		  method to remove these variations. First, a representation
		  method of programs is discussed. The proposed
		  representation is free from three kinds of variations and
		  it can be easily rewritten. Next, a prototype variation
		  removal system is evaluated. The system utilizes the
		  representation and removes 13 kinds of variations by
		  program rewriting. It has removed 20 - 83 \% variations in
		  the source codes implemented by undergraduates and
		  postgraduates. },
  keywords	= {Variation removal; Source code; Rewriting},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Others}
}

@Article{	  hausler.pleszkoch.ea:using,
  author	= {P.A. Hausler and M.G. Pleszkoch and R.C. Linger and A.R.
		  Hevner},
  title		= {Using Function Abstraction to Understand Program
		  Behavior},
  journal	= {IEEE Software},
  volume	= {7},
  number	= {1},
  pages		= {55-63},
  year		= {1990},
  note		= { In this paper it is avocated to improve the understanding
		  of programs by structuring them. The authors think that the
		  potential exists for an automated tool to take unstructured
		  code and derive its functionality},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Functional_Abstraction}
}

@Book{		  hecht:flow,
  title		= {Flow analysis of computer programs},
  author	= {M. Hecht},
  publisher	= { Elsevier North-Holland},
  year		= {1977},
  note		= { A classical book on the theory and implementation of
		  algorithms for data flow analysis},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@MastersThesis{	  heiber:semi-automatische,
  author	= {Timo Heiber},
  title		= {Semi-automatische Herleitung von Komponentenprotokollen
		  aus statischen Verwendungsmustern},
  school	= {Institut für Informatik, Universität Stuttgart},
  year		= {2000},
  type		= {Diplomarbeit Nr. 1822},
  note		= {The language is English, even though the title is
		  German.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Others}
}

@Article{	  horwitz.reps.ea:interprocedural,
  author	= {Horwitz, S. and Reps, T., and Binkley, D.},
  title		= {Interprocedural slicing using dependence graphs},
  journal	= {ACM Transactions on Programming Languages and Systems},
  volume	= {12},
  number	= {1},
  month		= {January},
  year		= {1990},
  pages		= {26-60},
  http		= {http://www.cs.wisc.edu/~reps/reps.html#toplas90},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  horwitz.reps:use,
  author	= {S. Horwitz and T. Reps},
  title		= {The Use of Program Dependence Graphs in Software
		  Engineering},
  booktitle	= {Proceedings of the 14th  International Conference on
		  Software Engineering },
  pages		= {392--411},
  month		= may,
  year		= {1992},
  abstract	= {This paper describes a language-independent program
		  representation-the program dependence graph-and discusses
		  how program dependence graphs, together with operations
		  such as program slicing, can provide the basis for powerful
		  programming tools that address important software
		  engineering problems, such as understanding what an
		  existing program does and how it works, understanding the
		  differences between several versions of a program, and
		  creating new programs by combining pieces of old programs.
		  The paper primarily surveys work in this area that has been
		  carried out at the University of Wisconsin.},
  http		= {http://www.cs.wisc.edu/wpis/papers/icse92.ps},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  howden.pak:problem,
  author	= {W. E. Howden and Suehee Pak},
  title		= {Problem Domain, Strutural and Logical Abstractions in
		  Reverse Engineering},
  pages		= {214-224},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {Reverse Engineering abstractions are considered. Three
		  kinds of abstractions are identified: problem domain,
		  strutural, and logical. Problem domain abstractions
		  correspond to concepts from a program's application area.
		  Structural abstractions are used to eliminate
		  implementation details and redundant information. Logical
		  abstractions are properties that can be logically derived
		  from code. A method for generating functional
		  specifications is described, which incorporates the
		  abstraction techniques. It has been applied to a variety of
		  COBOL programs and been found to generate 'natural'
		  abstract program descriptions. The paper describes work in
		  progress, and we expect the methods to evolve. An analysis
		  tool is being concstructed that will be used to help verify
		  the approach and to assess its complexity and computational
		  requirements.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Functional_Abstraction}
}

@Article{	  hutchens.basili:system,
  title		= {System structure analysis: clustering with data bindings},
  author	= {D. Hutchens and V. Basili},
  journal	= {{IEEE} Transactions on Software Engineering},
  volume	= {{SE}-11},
  number	= {8},
  pages		= {749--757},
  year		= {1985},
  note		= { The use of cluster analysis as a tool for system
		  modularization is examined. It appears that the clustering
		  of data bindings provides a meaningful view of system
		  modularization},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  System_Modularization}
}

@InProceedings{	  jacobson.lindstrvm:re-engineering,
  author	= {I. Jacobson and F. Lindstrvm},
  title		= {Re-engineering of old systems to an object-oriented
		  architecture},
  booktitle	= {OOPSLA},
  pages		= {340-350},
  year		= {1991},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@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}
}

@InProceedings{	  johnson.ornburn.ea:quick*1,
  title		= {A quick tools approach to program analysis and software
		  maintenance},
  author	= {B. Johnson and S. Ornburn and S. Rugaber},
  booktitle	= {\cite{SM92}},
  year		= {1992},
  note		= { Describes the use of standard Unix tools like (Awk, Lex,
		  Yacc) for extracting information from PL/M code. The
		  information is then visualized using a commercial CASE tool
		  (Software Through Pictures)},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@InProceedings{	  johnson.soloway:proust,
  author	= {W. L. Johnson and Elliot Soloway},
  title		= {{PROUST}: knowledge-based program understanding},
  pages		= {369--380},
  booktitle	= {Proceedings of the 7th  International Conference on
		  Software Engineering },
  year		= {1984},
  publisher	= {IEEE Computer Society Press},
  month		= mar,
  abstract	= {This paper describes a program called PROUST which does
		  on-line analysis and understanding of Pascal written by
		  novice programmers. PROUST takes as input a program and a
		  nonalgorithmic description of the program requirements and
		  the code. This mapping is in essence a reconstruction of
		  the design and implementation steps that the programmer
		  went through in writing the program. A knowledge base of
		  programming plans and strategies, together with common bugs
		  associated with them, is used in construction this mapping.
		  Bugs are discovered in the process of relating plans to the
		  code; PROUST can therefore give deep explanations of
		  program bugs by relating the buggy code to its underlying
		  intentions.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@Article{	  johnson.soloway:proust*1,
  title		= {{PROUST}: knowledge-based program understanding},
  author	= {W. Johnson and E. Soloway},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {{SE}-11},
  number	= {3},
  pages		= {267--275},
  year		= {1985},
  note		= { This paper describes a tool to help novice programmers to
		  learn how to program. It is based on a knowledge base and
		  has also a tutoring aspect. The tool is not intended for
		  large scale program understanding but the ideas underlying
		  this paper may very well be applicable to it},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@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}
}

@Article{	  jorgensen:experience,
  title		= {Experience with the accuracy of software maintenance task
		  effort prediction models},
  author	= {M. Jorgensen},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {674--681},
  volume	= {21},
  number	= {8},
  year		= {1995},
  note		= {Eleven software maintenance effort prediction models are
		  discussed},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Maintenance_Metrics}
}

@Article{	  kamkar:application,
  author	= {Mariam Kamkar},
  title		= {Application of Program Slicing in Algorithmic Debugging},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {635-646},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@TechReport{	  kamper.rugaber:reverse,
  author	= {Kit Kamper and Spencer Rugaber},
  title		= {A Reverse Engineering Methodology for Data Processing
		  Applications},
  number	= {GIT-SERC-90/02},
  institution	= {Software Engineering Center Georgia Institute of
		  Technology, Atlanta, GA},
  year		= {1990},
  month		= mar,
  note		= {Figures are missing},
  abstract	= {Reverse engineering produces a high-level representation
		  of a software system from a low-level one. This paper
		  describes a methodology for reverse engineering that
		  constructs an architectural design for a system from its
		  source code and related documentation. The methodology
		  makes use of several techniques normally used during the
		  forward software development process as well as a new
		  technique called Synchronized Refinement. Synchronized
		  Refinement is a systematic approach to detecting design
		  decisions in source code and relating the detected
		  decisions to the functionality of the system. Examples are
		  given demonstrating the application of the methodology to
		  the reverse engineering of a production software system.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/synchronized.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Process_Models_for_Reverse_Design,
		  Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design}
}

@InProceedings{	  kazman.burth:assessing,
  author	= {Rick Kazman and Marcus Burth},
  title		= {Assessing Architectural Complexity},
  year		= {1998},
  publisher	= {IEEE Computer Society},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Recovery_of_Software_Architecture}
}

@TechReport{	  kazman.carrière:playing,
  author	= {Kazman, R. and Carrière, S.J.},
  title		= {Playing detective: reconstructing software architecture
		  from available evidence},
  institution	= {Software Engineering Institute},
  year		= {1997},
  optkey	= {CMU/SEI-97-TR-010},
  type		= {Technical Report},
  number	= {CMU/SEI-97-TR-010},
  address	= {Pittsburgh, USA},
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@Article{	  khan.al-aali.ea:object-oriented,
  author	= {E. H. Khan and M. Al-A'ali and M. R. Girgis},
  title		= {Object-Oriented Programming for Structured Procedural
		  Programmers},
  journal	= {IEEE Computer},
  pages		= {48-57},
  year		= {1995},
  month		= oct,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@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}
}

@InProceedings{	  kontogiannis.demori.ea:localization,
  author	= {K. Kontogiannis and R. DeMori and M. Bernstein and E.
		  Merlo},
  title		= {Localization of Design Concepts in Legacy Systems},
  pages		= {414-423},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Complete automation of design recovery of large systems is
		  a desirable but impractical goal due to complexity and size
		  issues, so current research efforts focus on
		  redocumentation and partial design recovery.
		  
		  Pattern matching lies at the center of any design recovery
		  system. In the context of a larger project to develop an
		  integrated reverse engineering environment, the authors are
		  developing a framework for performing clone detection, code
		  localization, and plan recognition. This paper discusses a
		  plan localization and selection strategy based on a dynamic
		  programming function that records the matching process and
		  identifies parts of the plan and code fragment that are
		  most 'similar'. Program features used for matching are
		  currently based on data flow, control flow, and structural
		  properties. The matching model uses a transition network
		  and allows for the detection of insertions and deletions,
		  and it is targeted for legacy C-based systems.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@Article{	  korel.rilling:dynamic,
  author	= {Bogdan Korel and Jürgen Rilling},
  title		= {Dynamic Program Slicing Methods},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {647-660},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  koschke.eisenbarth:international,
  author	= {Koschke, R. and Eisenbarth, T},
  title		= {International Workshop on Program Comprehension},
  booktitle	= {A Framework for Experimental Evaluation of Clustering
		  Techniques},
  year		= {2000},
  month		= jun,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@PhDThesis{	  koschke:atomic,
  author	= {Koschke, R.},
  title		= {Atomic Architectural Component Detection for Program
		  Understanding and System Evolution},
  school	= {University of Stuttgart},
  year		= {2000},
  address	= {Universit\"atsstrasse 38, 70569 Stuttgart, Germany},
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  koschke:incremental,
  author	= {Koschke, R.},
  title		= {An Incremental Semi-Automatic Method for Component
		  Recovery},
  booktitle	= { Working Conference on Reverse Engineering },
  pages		= {256--267},
  year		= {1999},
  month		= oct,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  kozaczynski.ning:sre,
  author	= {Wojtek Kozaczynski and Jim Q. Ning},
  title		= {{SRE}: {A} Knowledge-based Environment for Large-scale
		  Software Re-engineering Activities},
  booktitle	= {Proceedings of the 11th  International Conference on
		  Software Engineering },
  pages		= {113--122},
  month		= may,
  year		= {1989},
  abstract	= {The authors address issues related to the reengineering of
		  large-scale software systems. The key to the software
		  reengineering activity is the ability to recover
		  (reengineer) lost or otherwise unavailable information
		  concerning specification and system design decisions from
		  the information available in the existing system source
		  code. Subsequently, a forward engineering step can
		  reimplement and possibly upgrade the existing systems. A
		  description is also given of the underlying principles of a
		  knowledge-based software reengineering environment that is
		  intended to provide high-level support to various software
		  maintenance and reengineering activities.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment}
}

@Article{	  krinke.snelting:program,
  author	= {Jens Krinke and Gregor Snelting},
  title		= {Program Slicing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {661-676},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  krone.snelting:on,
  author	= {M. Krone and G. Snelting},
  title		= {On the inference of configuration structures from source
		  code},
  pages		= {49--58},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  abstract	= {The authors apply mathematical concept analysis to the
		  problem of infering configuration structures from existing
		  source code. Concept analysis has been developed by German
		  mathematicans over the last years; it can be seen as a
		  discrete analogon to Fourier analysis. Based on this
		  theory, the authors' tool will accept source code, where
		  configuration-specific statements are controlled by the
		  preprocessor. The algorithm will compute a so-called
		  concept lattice, which - when visually displayed - allows
		  remarkable insight into the structure and properties of
		  possible configurations. The lattice not only displays
		  fine-grained dependencies between configuration threads,
		  but also visualizes the overall quality of configuration
		  structures according to software engineering principles.
		  The paper presents a short introduction to concept
		  analysis, as well as experimental results on various
		  programs. },
  key		= {Concept Analysis},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Configuration_Structures}
}

@InProceedings{	  kung.gao.ea:design,
  author	= {C. Kung and JH. Gao and P. Hsia and J. Lin and Y.
		  Toyoshima},
  title		= {Design recovery for software testing of object-oriented
		  programs},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {202--211},
  year		= {1993},
  note		= {Describes a methodology for testing OO software},
  class		= {Software_Reverse_Engineering, Reverse_Design}
}

@Article{	  l.r.ea:relational,
  author	= {Feijs L. and Krikhaar R. and Ommering R. van},
  title		= {A Relational Approach to Support Software Architecture
		  Analysis},
  journal	= {Software - Practice and Experience},
  year		= {1998},
  volume	= {28},
  number	= {4},
  pages		= {371-400},
  month		= {April},
  abstract	= {This paper reports on our experience with a relational
		  approach to support the analysis of existing software
		  architectures. The analysis options provide for
		  visualisation and view calculation. The approach has been
		  applied for reverse engineering. It is also possible to
		  check concrete designs against architecture-related rules.
		  The paper surveys the theory, the tools and some of the
		  applications developed so far.},
  keywords	= {software structuring; reverse engineering; relational
		  algebra; software architecture},
  class		= {Software_Reverse_Engineering Reverse_Design
		  Recovery_of_Software_Architecture }
}

@Article{	  lakhotia.deprez:restructuring,
  author	= {Arun Lakhotia and Jean-Christophe Deprez},
  title		= {Restructuring Programs by Tucking Statements into
		  Functions},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {677-690},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  lakhotia:rule-based,
  author	= {Arun Lakhotia},
  title		= {Rule-based approach to computing module cohesion},
  pages		= {35--44},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {Stevens, Myers, and Constantine introduced the notion of
		  cohesion, an ordinal scale of seven levels that describes
		  the degree to which the actions performed by a module
		  contribute to a unified function. The provided rules,
		  termed as 'associative principles' to examine the
		  relationships between 'processing elements' of a module and
		  designate a cohesion level to it. Stevens et. al., however,
		  did not give a precise definition for the term 'processing
		  element', thereby leaving it open for interpretations.
		  
		  This paper interprets the 'output variables' (not
		  statements) of a module as its processing elements. Stevens
		  et. al.'s associative principles are transformed to relate
		  the output variables based on their 'data' and 'control
		  dependence' relationships. What results is a rule-based
		  approach to computing cohesion. Experimental results show
		  that, but for temporal cohesion, the cohesion associated to
		  a module under our reinterpretation and that due to the
		  original definitions are identical for all examples.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@Article{	  lakhotia:unified,
  author	= {Lakhotia, A.},
  title		= {A Unified Framework for Expressing Software Subsystems
		  Classification Techniques},
  journal	= {Journal Systems Software, Elsevier Science Publisher},
  year		= {1997},
  volume	= {36},
  pages		= {211--231},
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@Article{	  letovsky.soloway:delocalized,
  author	= {Stanley Letovsky and Elliot Soloway},
  title		= {Delocalized Plans and Program Comprehension},
  journal	= {IEEE Software},
  year		= {1986},
  pages		= {41-40},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@InProceedings{	  li.yang.ea:clarity,
  author	= {Yang Li and Hongji Yang and William Chu},
  title		= {Clarity Guided Belief Revision for Domain Knowledge
		  Recovery in Legacy Systems},
  booktitle	= {Proceedings of the 12th International Conference on
		  Software Engineering and Knowledge Engineering (SEKE2000)},
  publisher	= {Knowledge System Institute},
  year		= {2000},
  editor	= {Daniel E. Cooke and Joseph E. Urban},
  chapter	= {},
  pages		= {248-255},
  address	= {Chicago, USA},
  month		= {June},
  url		= {},
  abstract	= {Program understanding is the process of acquiring
		  knowledge from a computer program. Although research work
		  utilising knowledge engineering techniques has been
		  undertaken in this field, it is our observation that a
		  thorough application of AI methodology has not been
		  sufficiently explored. In this paper, we present a clarity
		  guided belief revision approach to domain knowledge
		  recovery in legacy software systems. Novel solutions are
		  given to three key AI issues in the context of domain
		  knowledge recovery from source code: knowledge
		  representation, where concrete semantic network is
		  separated from abstract semantic network to better
		  accommodate uncertainty reasoning and propagation;
		  uncertainty reasoning, which borrows ideas from
		  confirmation theory and recasts them in the context of
		  semantic network reasoning; heuristic search, which is
		  designed on the principle of programming psychology. Our
		  approach is light-weighted. It can be used stand-alone or
		  as a complement to traditional heavy-weighted domain
		  knowledge recovery methods. },
  keywords	= {program understanding, knowledge recovery, semantic
		  network, belief revision, heuristic search, programming
		  psychology},
  note		= {This paper describes our innovative work where
		  psychology-based methodology was brought into the area of
		  Articial Intelligence and was applied in the field of
		  domain knowledge recovery from source code.},
  class		= {Knowledge-Based_Concept_Assignment System_Modularizatio
		  Model_Generating Reverse_Specification Metrics
		  Reverse_Design Domain_Analysis
		  Metric-Based_Methods_in_Reverse_Design
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  Software_Reverse_Engineering }
}

@Article{	  li.yang.ea:concept-oriented,
  author	= {Yang Li and Hongji Yang and William Chu},
  title		= {A Concept-Oriented Belief Revision Approach to Domain
		  Knowledge Recovery from Source Code},
  journal	= {Journal of Software Maintenance: Research and Practice},
  year		= {2000},
  volume	= {12},
  number	= {6},
  abstract	= {Domain knowledge is the soul of software systems. After
		  decades of software development, domain knowledge has
		  reached a certain degree of saturation. The recovery of
		  domain knowledge from source code is beneficial to many
		  software engineering activities, in particular, software
		  evolution. In the real world, the ambiguous appearance of
		  domain knowledge embedded in source code constitutes the
		  biggest barrier to recovering reliable domain knowledge. In
		  this paper, we introduce an innovative approach to
		  recovering domain knowledge with enhanced reliability from
		  source code. In particular, we divide domain knowledge into
		  inter-connected knowledge slices and match these knowledge
		  slices against the source code. Each knowledge slice has
		  its own authenticity evaluation function which takes the
		  belief of the evidences it needs as input and the
		  authenticity of the knowledge slice as output. Moreover,
		  the knowledge slices are arranged to exchange beliefs with
		  each other through inter-connections, i.e., concepts, so
		  that a better evaluation of the authenticity of these
		  knowledge slices can be obtained. The decision on
		  acknowledging recovered knowledge slices can therefore be
		  made more easily. Rooted in cognitive science and social
		  psychology, our approach is also widely applicable to other
		  knowledge recovery tasks. },
  keywords	= {domain knowledge recovery, uncertainty reasoning,
		  cooperative behaviour, semantic network},
  note		= {It is the first attempt of applying social psychology
		  theory to the field of knowledge recovery, in particular
		  design recovery.},
  class		= {Knowledge-Based_Concept_Assignment Using_graphs
		  Model_Generating Reverse_Specification
		  Cognitive_Processes_in_Human_Program_Understanding
		  Reverse_Design Domain_Analysis
		  Human_Oriented_Concept_Assignment_by_Informal_Reasonin
		  Intermediate_Representations_of_Source_Code
		  Software_Reverse_Engineering }
}

@InProceedings{	  li.yang.ea:generating,
  author	= {Yang Li and Hongji Yang and William Chu},
  title		= {Generating Linkage between Source Code and Evolvable
		  Domain Knowledge for the Ease of Software Evolution},
  booktitle	= {Proceedings of IEEE International Symposium on Principles
		  of Software Evolution (ISPSE2000)},
  publisher	= {IEEE Computer Society Press},
  year		= {2000},
  editor	= {},
  chapter	= {},
  pages		= {},
  address	= {Kanazawa, Japan},
  month		= {Nov},
  url		= {},
  abstract	= {Business software systems unexceptably need to be evolved
		  to cater for new/changed requirement coming from market or
		  adapt to new operating environment. One of the most
		  significant problems in current software evolution practice
		  is that software maintainers usually find it quite
		  difficult to locate the program sections in source code
		  which need to be modified and to identify the extent to
		  which the changes in these program sections could affect
		  the rest of the software system. In this paper, we propose
		  a knowledge engineering based approach to solving this
		  problem. In particular, we match a software program with a
		  pre-defined domain knowledge base in the representation of
		  simplified semantic network we proposed in order to link
		  the source program with its domain level interpretation.
		  The domain knowledge base contains only important domain
		  knowledge where potential evolutions could occur, which
		  reduces the size of the knowledge base. Moreover, a domain
		  oriented program partitioning method is also proposed to
		  cut a program into self-contained modules with manageable
		  size. In these ways, the computational complexity involved
		  in generating the linkage is significantly reduced which
		  makes this approach applicable. An example shows that
		  software evolution can be easily carried out as the domain
		  knowledge it links with evolves. },
  keywords	= {software evolution, knowledge engineering, program
		  partitioning, evolvable domain knowledge, semantic
		  network},
  note		= {This paper gives engineering-oriented considerations to
		  link generation between domain knowledge and source code
		  prior to successful software evolution.},
  class		= {Software_Evolution Knowledge-Based_Concept_Assignment
		  Using_graphs Change_Impac
		  Cognitive_Processes_in_Human_Program_Understanding Metrics
		  Reverse_Design Re-Design System_Modularization
		  Recovery_of_Software_Architecture
		  Metric-Based_Methods_in_Reverse_Design Alteration
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  Intermediate_Representations_of_Source_Code
		  Software_Reverse_Engineering }
}

@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 }
}

@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 }
}

@InProceedings{	  linos.aubet.ea:care,
  author	= {Panagiotis Linos and Philippe Aubet and Laurent Dumas and
		  Yan Helleboid and Patricia Lejeune and Philippe Tulula},
  title		= {CARE: An Environement for Understanding and
		  Re--engineering C--Programs},
  pages		= {130--139},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The focus of this paper is on facilitating incremental
		  understanding and re-enginering of existing C programs. A
		  software environement called C.A.R.E. (Computer-Aided
		  Re-engineering) is used as a vehicle towards that goal.
		  CARE maintains a repository of control-flow and data-flow
		  dependencies (i.e. entities and their relations) of C
		  programs. These dependencies can be visualized using a
		  novel representation model. Moreover, CARE entails
		  transformation tools that support various ways of
		  displaying program dependencies and facilitate incremental
		  program modifications. An empirical evaluation of the CARE
		  environement using small size C programs is performed. In
		  addition, CARE is used in order to modify the source code
		  of a medium-to-large size program. The results from this
		  empirical evaluation of CARE indicate that its presentation
		  model and transformation tools is a promising step towards
		  improving the effectiveness of understanding and
		  re-engineering existing C programs. Finally, the authors
		  discuss some issues raised during the modification exercise
		  with CARE when using a medium-to-large size program.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@Article{	  liu.ogando.ea:object,
  author	= {Sying S. Liu and R. M. Ogando and Norman Wilde and S. S.
		  Yau},
  title		= {An Object Finder for Program Structure Understanding in
		  Software Maintenance},
  journal	= {Software Maintenance: Research and Practice},
  volume	= {6},
  pages		= {261-283},
  year		= {1994},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@InProceedings{	  long.clarke:task,
  author	= {D. L. Long and L. A. Clarke},
  title		= {Task Interaction Graphs for Concurrency Analysis},
  booktitle	= {Proceedings of the 11th  International Conference on
		  Software Engineering },
  pages		= {44--52},
  month		= may,
  year		= {1989},
  abstract	= {A representation for concurrent programs called task
		  interaction graphs, is presented. Task interaction graphs
		  divide a program into maximal sequential regions connected
		  by edges representing task interactions. This
		  representation is illustrated. It is shown how task
		  interaction graphs can be used to create concurrency graph
		  representations that are much smaller than those created
		  from control flow graph representations. Both task
		  interaction graphs and their corresponding concurrency
		  graphs facilitate analysis of concurrent programs. Some
		  analyses and optimizations on these representations are
		  also described.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@Article{	  lukey:understanding,
  author	= {F. J. Lukey},
  title		= {Understanding and debugging programs},
  journal	= {Journal of Man Machine Studies},
  year		= {1980},
  volume	= {12},
  number	= {1},
  pages		= {189-202},
  abstract	= {A theory of program understanding and debugging is
		  proposed. The theory is discussed with reference to a
		  computer system that embodies many aspects of the theory.
		  Program understanding is viewed as the construction of
		  program description. The theory's approach to debugging is
		  based on the use of these descriptions. The role of
		  programming knowledge is stressed},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@Article{	  marlowe.ryder:properties,
  author	= {Marlowe and Ryder},
  title		= {Properties of Data Flow Frameworks. {A} Unified Model},
  journal	= {Acta Informatica},
  publisher	= {Springer-Verlag},
  volume	= {28},
  year		= {1990},
  pages		= {121-163},
  note		= { An overview of data flow frameworks and their
		  characterizing properties is given. Contains many
		  references to the field of data flow analysis},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  matwin.ahmad:reuse,
  author	= {Stan Matwin and Affa Ahmad},
  title		= {Reuse of Modular Software with Automated Comment
		  Analysis},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  pages		= {222-231},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The paper presents an approach to software reuse based on
		  automatic analysis of program comments. First, domain terms
		  are extracted from the comments in a semi-automatic
		  procedure. Those terms are then used in an off-th-shelf
		  Case-based Reasoning system as indices for software
		  modules. oun phrases extracted from comments in LINPACK
		  (widely distributed linaer algebra package) form the basis
		  of simple domain models for linaer systems. The process of
		  constructing a reuse system is broken into three steps. A
		  file containing comments from all LINPACK routines is
		  processed to yield a list of technical phrases. The second
		  step involves building domain models based on an anylysis
		  of these technical phrases and then indexing cases
		  according to these models. Finally, tools provided by the
		  REMIND Case Based Reasoning (CBR) shell are used to create
		  a case library incoporationg this domain knowledge. Early
		  experiments described in the paper show that noun phrases
		  automatically extracted from the comments can provide
		  useful functional description of the routines. The
		  resulting simple domain models are usually sufficient for
		  softeare reuse application. Finally, we found standard CBR
		  technology to be a viable means of constructing
		  compositional software reuse libraries.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning}
}

@Article{	  mendelzon.sametinger:reverse,
  title		= {Reverse Engineering by visualizing and querying},
  author	= {A. Mendelzon and J. Sametinger},
  journal	= {Software---Concepts and Tools},
  pages		= {170--182},
  volume	= {16},
  number	= {4},
  year		= {1995},
  note		= { A tool called Hy+ is described that can be used for
		  reverse engineering. Hy+ is a general-purpose data
		  visualization system for querying and visualizing
		  information about object-oriented software systems. Hy+
		  supports this for arbitrary graph-like databases. The use
		  is demonstrated with the evaluation of software metrics,
		  verifying constraints and identifying design patterns},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Source_Code_Queries,
		  Reverse_Specification, Software_Animation,
		  Visualization_for_Program_Understanding_and_Debugging}
}

@InProceedings{	  mendonça.kramer:quality-based,
  author	= {Nabor C. Mendonça and Jeff Kramer},
  title		= {A Quality-Based Analysis of Architecture Recovery
		  Environments},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Architecture recovery is a recent research area which aims
		  at providing reverse engineering technologies to extract
		  high-level architectural information from the source code
		  of legacy systems. In this paper we review the main (only?)
		  architecture recovery environments proposed thus far. The
		  environments are analyzed with respect to different quality
		  attributes, and their features and limitations are
		  discussed. This allows us to highlight problems yet to be
		  addressed in the area and, for some of them, suggest
		  possible alternatives. We believe that this analysis is
		  useful for the design of more effective architecture
		  recovery tools. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@InProceedings{	  miller.znayenko:classifying,
  author	= {G. G. Miller and Z. O. Znayenko},
  title		= {Classifying Forms of Encapsulation in Object-Oriented
		  Languages},
  booktitle	= {Tools USA' 95 (Technology of Object-Oriented Languages and
		  Systems)},
  pages		= {107-117},
  year		= {1995},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@Article{	  muller.orgun.ea:reverse,
  author	= {M\"uller, H.A. and Orgun, M.A. and Tilley, S.R. and Uhl,
		  J.S.},
  title		= {A Reverse Engineering Approach to Subsystem Structure
		  Identification},
  journal	= {Journal of Software Maintenance: Research and Practice},
  year		= {1993},
  volume	= {5},
  number	= {4},
  pages		= {181--204},
  month		= dec,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  muller.uhl:composing,
  title		= {Composing subsystem structures using (K,2)-partite
		  graphs},
  author	= {H. Muller and J. Uhl},
  booktitle	= {{IEEE} Conference on Software Maintenance},
  pages		= {12--19},
  year		= {1990},
  note		= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  System_Modularization}
}

@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}
}

@InCollection{	  nillson:translation,
  title		= {The translation of {COBOL} data structures to
		  entity-relationship conceptual schema},
  author	= {E. Nillson},
  editor	= {P. Chen},
  booktitle	= {Entity Relationship Approach: The Use of {ER} Concepts in
		  Knowledge Representation},
  publisher	= {{IEEE} CS Press},
  year		= {1986},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@InProceedings{	  olshefski.cole:prototype,
  author	= {D. Olshefski and A. Cole},
  title		= {A prototype system for static and dynamic program
		  understanding},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {93--106},
  year		= {1993},
  note		= { Describes the experimental PUNDIT system that combines
		  static and dynamic information for program understanding.
		  It comprises a static analyzer for C source code and a,
		  mostly language-independent, graphical user interface.
		  Gives various examples of program views},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Dynamic_Analysis, Code_Views}
}

@Article{	  oman.cook:book,
  title		= {The book paradigm for improved maintenance},
  author	= {P.W. Oman and C.R. Cook},
  journal	= {{IEEE} Software},
  volume	= {7},
  number	= {1},
  pages		= {39--45},
  year		= {1990},
  note		= { It is shown that traditional typographical formats used
		  in books work very well to aid program understanding},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Reformatting_and_Markup_Languages}
}

@InProceedings{	  oman.hagemeister:metrics,
  author	= {Paul Oman and Jack Hagemeister},
  title		= {Metrics for Assessing a Software System's
		  Maintainability},
  pages		= {337-344},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {The factors of software that determine or influence
		  maintainability can be organized into a hierarchical
		  structure of measurable attributes. For each of these
		  attributes we show a metric definition consistent with the
		  published definitions of the software characteristic being
		  measured. The result is a tree structure of maintainability
		  metrics which can be used for purposes of evaluating the
		  relative maintainability of the software system. In this
		  paper the authors define metrics for measuring the
		  maintainability of a target software system and discuss how
		  those metrics can be combined into a single index of
		  maintainability.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Maintenance_Metrics}
}

@InProceedings{	  ornburn.rugaber:reverse,
  title		= {Reverse engineering: resolving conflicts between expected
		  and actual software designs},
  author	= {S. Ornburn and S. Rugaber},
  booktitle	= {\cite{SM92}},
  pages		= {32--40},
  year		= {1992},
  note		= { Experience report describing the application of the
		  Synchronized Refinement method ~\cite{ROL90} to a real-time
		  embedded system},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Process_Models_for_Reverse_Design}
}

@InProceedings{	  ott.bieman:effects,
  author	= {Linda M. Ott and James M. Bieman},
  title		= {Effects of Software Changes on Module Cohesion},
  pages		= {345-353},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {We use program slices to model module cohesion. For our
		  purpose, a slice is a projection of program text that
		  includes only the data tokens relevant to one output. We
		  define six cohesion metrics in terms of these slices, and
		  evaluate the effects of classes of module changes on these
		  metrics. We find that the effects on cohesion metrics are
		  notably more predictable when the changes result from
		  adding code rather than from moving code. In general, the
		  effects that software changes have on the cohesion metrics
		  match our intuition.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@Article{	  ott.bieman:program,
  author	= {Linda M. Ott and James M. Bieman},
  title		= {Program Slices as an Abstraction for Cohesion
		  Measurement},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {691-700},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  ott.thuss:relationship,
  author	= {Linda M. Ott and J. J. Thuss},
  title		= {The Relationship Between Slices and Module Cohesion},
  booktitle	= {Proceedings of the 11th  International Conference on
		  Software Engineering },
  pages		= {198--204},
  month		= may,
  year		= {1989},
  abstract	= {The authors examine the relationship between the data flow
		  in a module and its level of cohesion using a processing
		  element flow graph (PFG). Based on these PFGs, they regroup
		  the original seven levels of cohesion into four
		  classifications. Slice profiles are then defined by
		  generating slices for all output variables of a module. A
		  relationship is then shown between these slice profiles and
		  the PFG used to indicate levels of cohesion. It is
		  suggested that these slice profiles can be used to
		  determine more easily the cohesiveness of a module.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@InProceedings{	  patel.chu.ea:measure,
  author	= {Sukesh Patel and William C. Chu and R. Baxter},
  title		= {A Measure for Composite Module Cohesion},
  booktitle	= {Proceedings of the 14th  International Conference on
		  Software Engineering },
  pages		= {38--48},
  month		= may,
  year		= {1992},
  abstract	= {An important software design activity is the decomposition
		  of complex systems into conceptually independent modules
		  that cooperate to achieve a desired result. This
		  modularization represents a significant software
		  engineering activity that continues to receive considerable
		  research attention. The authors illustrate how software may
		  be modularized by automatically determining the
		  cohesiveness of modules in the system. Module cohesion is
		  defined to be a quality attribute that seeks to measure the
		  singleness of purpose of a module. They propose a metric
		  that measures the cohesion of individual subprograms of a
		  software system as related to each other. This metric is
		  illustrated with detailed examples and is supported with
		  empirical evidence supporting the viability of the
		  measure.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Module_Cohesion}
}

@Article{	  paul.prakash:framework,
  title		= {A framework for source code search using program
		  patterns},
  author	= {S. Paul and A. Prakash},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {463--475},
  volume	= {20},
  number	= {6},
  year		= {1994},
  note		= { It is argued that existing solutions to locating source
		  code fragments that match certain patterns are
		  insufficient. A framework in which pattern languages are
		  used to specify interesting code features is presented.
		  These are obtained by extending the source programming
		  language with pattern-matching symbols. This is implemented
		  in a tool called SCRUPLE},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Source_Code_Queries}
}

@Article{	  paul.prakash:supporting,
  author	= {S. Paul and A. Prakash},
  title		= {Supporting Queries on Source Code: A Formal Framework},
  journal	= {International Journal of Software Engineering and
		  Knowledge Engineering},
  volume	= {4},
  number	= {3},
  pages		= {325-348},
  year		= {1994},
  note		= { A source code query system is a powerful mechanism to
		  obtain crucial information necessary to successfully
		  performing a reverse engineering task. A source code
		  algebra (SCA) is developed which is strongly based on
		  relational algebras as well as on many sorted algebras. Two
		  types of data types are distinguished in the source code
		  algebra model: \begin{itemize} \item atomic data types,
		  such as integer, float, etc. \item composite data types
		  (so-called objects): \begin{itemize} \item singular
		  objects, such as while-statement, identifier, etc. \item
		  collective objects, such as statement-list, etc.
		  \end{itemize} \end{itemize} The objects are extended with
		  four kinds of attributes, namely, components, references,
		  annotations, and methods. An extensive set of source code
		  algebra operators are defined, such operators defined for
		  atomic data types, individual objects, and collections,
		  i.e., sets and sequences. The operators for the collections
		  are strongly influenced by the operators from the
		  relational algebra domain},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Source_Code_Queries}
}

@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}
}

@Article{	  pickard.carter:field,
  title		= {A Field Study of the Relationship of Information Flow and
		  Maintainability of COBOL Programs},
  author	= {M.M. Pickard and B.D. Carter},
  journal	= {Information and Software Technology},
  volume	= {37},
  number	= {4},
  pages		= {195--202},
  year		= {1995},
  note		= { The results of a field study of the relationship of
		  information flow to the maintainability of COBOL modules in
		  a data processing environment are presented. There is a
		  significant correlation between maintainability and
		  information flow and with (information flow) metrics it is
		  possible to identify poorly maintained modules},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Maintenance_Metrics}
}

@InProceedings{	  platoff.wagner.ea:integrated,
  author	= {Michael Platoff and Michael Wagner and Joseph Camaratta},
  title		= {An Integrated Program Representation and Toolkit for the
		  Maintenance of C Programs},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {129-137},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Maintaining large software systems has become an
		  increasingly common and expensive task for many
		  organizations. Understanding and modifying existing
		  programs is a major goal of the authors' Maintainer's
		  Assistant (MA) project, an environment for the maintenance
		  of software systems written in the C language. The authors
		  describe an integrated program representation that presents
		  views of the source text, architecture, syntax, static
		  semantics, and control and data flow of software systems.
		  Changes to these views are provided by a transformation
		  toolkit that supports structured modifications to the
		  representation. Modifications in one view are reflected in
		  related views. The representation and toolkit support all
		  of C, including features of the C preprocessor.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Reengineering_Tools}
}

@Article{	  podgurski.pierce:retrieving,
  key		= {Podgurski \& Pierce, 1993},
  author	= {Andy Podgurski and Lynn Pierce},
  title		= {Retrieving Reusable Software by Sampling Behaviour},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1993},
  volume	= {2},
  number	= {3},
  pages		= {286-303},
  month		= jul,
  abstract	= {A new method, called behavior sampling, is proposed for
		  automated retrieval of reusable components from software
		  libraries. Behavior sampling exploits the property of
		  software that distinguishes it from other forms of text:
		  executability. Basic behavior sampling identifies relevant
		  routines by executing candidates on a searcher supplied
		  sample of operational inputs and by comparing their output
		  provided by the searcher. The probabilistic basis for
		  behavior sampling is described, and experimental results
		  are reported that suggest that basic behavior sampling
		  exhibits high precision when used with small samples.
		  Extensions to basic behavioral sampling are proposed to
		  improve its recall and to make it applicable to the
		  retrieval of abstract data types and object classes.},
  class		= {Software_Reverse_Engineering, Re-Use,
		  Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Dynamic_Data_Flow_Analysis}
}

@InProceedings{	  premerlani.blaha:approach,
  author	= {W. Premerlani and M. Blaha},
  title		= {An approach for reverse engineering of relational
		  databases},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {151--160},
  year		= {1993},
  note		= { Experience report describing the reverse engineering of
		  several relational databases to OMT (Object Modeling
		  Technique) diagrams. The process is partly automated using
		  a variety of tools},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@InProceedings{	  quilici:hybrid,
  author	= {A. Quilici},
  title		= {A hybrid approach to recognizing programming plans},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {126--133},
  year		= {1993},
  note		= { Based on an experiment regarding human understanding of a
		  given C program, a new organization for a plan library is
		  presented. It consists of a plan definition, a plan
		  recognition rule, and specialized constraints. Extends the
		  plan library developed by Andersen Consulting},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@Article{	  quilici:memory-based,
  author	= {Alex Quilici},
  title		= {A Memory-Based Approach to Recognizing Programming Plans},
  journal	= {Communications of the ACM},
  volume	= {37},
  number	= {5},
  pages		= {85-93},
  year		= {1994},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@InProceedings{	  quilici:reverse,
  author	= {Alex Quilici},
  title		= {Reverse Engineering of Legacy Systems: A Path Toward
		  Success},
  booktitle	= {Proceedings of the 17th  International Conference on
		  Software Engineering },
  publisher	= {IEEE Computer Society Press},
  pages		= {333-336},
  year		= {1995},
  month		= apr,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@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}
}

@InProceedings{	  rajlich:incremental,
  author	= {Vaclav Rajlich},
  title		= {Incremental Redocumentation with Hypertext},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Redocumentation is the recovery and recording of software
		  comprehension. Since software comprehension is the most
		  expensive part of software maintenance, redocumentation is
		  the key to software maintainability. This paper describes
		  the process and tools of incremental redocumentation where
		  the comprehension of the software is recorded in hypertext,
		  in the style of World Wide Web. The paper describes the
		  tools which support redocumentation, and gives several
		  examples. },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Hypertext}
}

@Article{	  reps:program,
  author	= {Thomas Reps},
  title		= {Program Analysis via Graph Reachability},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {701-726},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  reubenstein.piazza.ea:separating,
  author	= {H. Reubenstein and R. Piazza and S. Roberts},
  title		= {Separating parsing and analysis in reverse engineering
		  tools},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {117--125},
  year		= {1993},
  note		= { Experience report describing the extension of an existing
		  analysis tool with a new syntactic front-end. Concludes
		  that language-independence as well separation of parsing
		  and analysis are essential for extensibility},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@Book{		  rich.waters:programmers,
  author	= {C. Rich and R.C. Waters},
  title		= {The {P}rogrammer's {A}pprentice},
  publisher	= {Addison-Wesley},
  year		= {1990},
  note		= { This book, named after the project it reports on, is
		  intended both to serve as an example of a general method to
		  the builders of many and diverse computer-aided design
		  tools and to study how software is analyzed, modified,
		  verified, and documented with the goal to automate such
		  typically software engineering tasks. A demonstration
		  system has been completed within the Programmer's
		  Apprentice project that illustrates most of the key
		  capabilities of it, albeit that this system is restricted
		  to the task of program implementation},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@Article{	  rich.wills:recognizing,
  author	= {Charles Rich and Linda M. Wills},
  title		= {Recognizing a Program's Design: A Graph-Parsing Approach},
  journal	= {IEEE Software},
  year		= {1990},
  volume	= {7},
  number	= {1},
  pages		= {82-89},
  month		= jan,
  inhalt	= {Ein prototypisch implementierter Recognizer erkennt
		  sogenannte Cliches im Programmcode. Cliches sind häufig
		  verwandte Programmiermuster wie binäre Suche oder
		  Listenverarbeitung. Die Cliches sind als Plangraphen in
		  einer Datenbasis abgelegt. Der Programmcode wird
		  gleichfalls anhand des Kontroll- und Datenflusses in einen
		  Plangraphen umgewandelt. Der Recognizer versucht
		  Plangraphen der Datenbasis mit dem Plangraphen des
		  Programmcodes zur Deckung zu bringen, um so Cliches zu
		  entdecken. Bei gefundener Deckung wird das Programmstück
		  natürlichsprachlich (mittels Schablonen) beschrieben.},
  note		= {In this paper it is assumed that most programmers use
		  similar structures to program. Such so-called cliches can
		  be recognized automatically and can then be used to
		  generate the documentation of the program},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing, Recognizer}
}

@InProceedings{	  ritsch.sneed:reverse,
  author	= {H. Ritsch and H. Sneed},
  title		= {Reverse engineering programs via dynamic analysis},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {192--201},
  year		= {1993},
  note		= { Describes a dynamic analysis of COBOL programs. By
		  inspection of transaction files assertions are generated
		  capturing the input and output requirements of each
		  database operation},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis}
}

@Article{	  rugaber.ornburn.ea:recognizing,
  author	= {Spencer Rugaber and Stephen B. Ornburn and Richard J.
		  LeBlanc, jr.},
  title		= {Recognizing Design Decisions in Programs},
  journal	= {IEEE Software},
  year		= {1990},
  volume	= {7},
  number	= {1},
  pages		= {46-54},
  month		= jan,
  abstract	= {The importance of capturing design decisions is described.
		  Design desicions are categorized in (1) composition and
		  decomposition (2) encapsulation and interleaving (3)
		  generalization and specialization (4) representation (5)
		  data and procedures (6) function and relation.
		  
		  The detection of design decision is bottom-up and
		  incremental with the following activities: (1) interleaving
		  program fragments (2) representing structured control flow
		  (3) interleaving by code sharing (4) data interleaving by
		  reusing variable names (5) generalizing code (6) variable
		  introduction (7) describing program architecture.
		  
		  The found decisions should be represented. A representation
		  should: (1) be easy to construct during development (2) be
		  easy to reconstruct during reverse engineering (3)
		  facilitate queries and report generation (4) be formal
		  enough to being automatically manipulated (5) let all
		  design information be attached (high level specification,
		  architectural overviews, detailed interfaces, resulting
		  code) (6) support requirements tracing, informal
		  annotations, version information.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/software.ps.gz}
		  ,
  note		= {In this paper it is advocated that in order to effectively
		  maintain an existing system, the maintenance programmer
		  must be able to sustain decisions made earlier in the
		  design process. To accomplish this, she/he must be able to
		  recognize and understand this decisions. A way is given to
		  characterize such decisions},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  General_Information_about_Reverse_Design}
}

@Unpublished{	  rugaber.stirewalt.ea:detecting,
  author	= {Spencer Rugaber and Kurt Stirewalt and Linda M. Wills},
  title		= {Detecting Interleaving},
  organization	= {College of Computing, Georgia Institute of Technology},
  address	= {Atlanta, Georgia 30332-0280},
  email		= {spencer@cc.gatech.edu},
  abstract	= {The various goals and requirements of a system are
		  realized in software as fragments of code that are
		  typically ``interleaved'' in that they may be woven
		  together in the same contigous textual area of code. The
		  fragments of code are often delocalized and overlap rather
		  than beiing composed in a simple linear sequence.
		  Interleaving severely complicates software comprehension
		  and maintenance. To address this problem, we are developing
		  analysis tools, based on the Software Refinery. This paper
		  describes our experiences in detecting interleaving in a
		  corpus of mathematical software written in Fortran from the
		  Jet Propulsion Laboratory. In particular, it discusses how
		  feasible it is to detect interleaving of various types and
		  the ability of existing tools to assist these types of
		  detection.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Others}
}

@InProceedings{	  rugaber.stirewalt.ea:interleaving,
  author	= {Spencer Rugaber and Kurt Stirewalt and Linda M. Wills},
  title		= {The Interleaving Problem in Program Understanding},
  booktitle	= {2nd Working Conference on Reverse Engineering},
  address	= {Toronto, Ontario, Canada},
  month		= jul,
  year		= {1995},
  abstract	= {One of the factors that can make a program difficult to
		  understand is that code responsible for accomplishing more
		  than one purpose may be woven together in a single section.
		  We call this interleaving, and it may arise either
		  intentionally - for example, in optimizing a program, a
		  programmer may use some intermediate result for several
		  purposes - or unintentionally, dut to patches, quick fixes,
		  or other hasty maintenance practices. To understand this
		  phenomenon, we have looked at a variety of interleaving
		  instances in actual programs and have distilled
		  characteristic features. If the characterization proves to
		  be robust then it will enable the design of tools for
		  detection of interleavings and the extraction of the
		  individual strands of computation.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/interleaving.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  General_Information_about_Reverse_Design}
}

@Article{	  rugaber:program,
  author	= {Spencer Rugaber},
  title		= {Program Understanding},
  journal	= {Encyclopedia of Computer Science and Technology},
  year		= {1996},
  note		= {To Appear},
  abstract	= {Program comprehension is the process of acquiring
		  knowldege about a computer program. Increased knowledge
		  enables such activities as bug correction, enhancement,
		  reuse, and documentation. While efforts are underway to
		  automate the understanding process, such significant
		  amounts of knowledge and analytical power are required that
		  today program understanding is largely a manual task.
		  
		  This paper explaines relationship to other activities such
		  as reverse engineering, design recovery, and reengineering.
		  It answers the question why program understanding is that
		  difficult. It gives a brief overview about human and
		  automated program understanding and program comprehension
		  tools.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/encyc.draft.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  General_Information_about_Reverse_Design}
}

@InProceedings{	  ryder:ismm,
  author	= {Barbara G. Ryder},
  title		= {ISMM: The Incremental Software Maintenance Manager},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {142-157},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {ISMM, the Incremental Software Maintenance Manager, is a
		  prototype software maintenance tool which uses incremental
		  static analysis to assess the scope of proposed source code
		  changes. These effects can be predicted a priori, that is
		  without actually having to perform the software change,
		  thus anabling maintainers to choose between alternative
		  enhancements or bug fixes on the basis of their predicted
		  system impact. Incremental analysis efficiently updates
		  data flow information describing the definition, use and
		  sharing of data in an evolving software system, keeping
		  this information consistent with the current system state.
		  ISMM addresses problems in maintenance, program
		  understanding enhancement, system restructuring and
		  intelligent code reuse for C systems. Recently, ISMM has
		  provided the basis for an empirical study of the calling
		  structure of C systems. ISMM has also been used to profile
		  the on the average performance of our incremental analysis
		  algorithms; it clearly validates their usefulness,
		  especially for large systems. This paper describes the
		  design and implementation of ISMM and summarizes our
		  empirical studies.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  sahraoui.melo.ea:applying,
  author	= {Sahraoui, H. and Melo, W. and Lounis, H. and Dumont, F.},
  title		= {Applying Concept Formation Methods to Object Identfication
		  in Procedural Code},
  booktitle	= { International Conference on Automated Software
		  Engineering },
  pages		= {210--218},
  year		= {1997},
  month		= nov,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sametinger:tool,
  author	= {Johannes Sametinger},
  title		= {A Tool for the Maintenance of C++ Programs},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {54-59},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {This paper describes a tool that helps programmers
		  understand object-oriented software systems written in C++,
		  a language that is expected to gain widespread use in
		  industry. This task is accomplished by providing
		  information about the set of classes and files comprising
		  the system and the relationships among them. The tool
		  described enables its users to easily browse through the
		  system based on the relations amoung its classes, files and
		  even identifiers. In addition, the flexible use of global
		  text styles enhances the readability of the source code.
		  
		  The second part of the paper describes some details about
		  the implementation of the tool. In particular, problems are
		  mentioned that arise when performing static analysis of C++
		  programs. This analysis is necessary for obtaining
		  information needed about the program system.
		  
		  The primary goal of developing the tool has been to support
		  software maintenance, but its use is in no way limited to
		  that process},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  sartipi.kontogiannis.ea:architectural,
  author	= {Kamran Sartipi and Kostas Kontogiannis and F. Mavaddat},
  title		= {Architectural Design Recovery using Data Mining
		  Techniques},
  booktitle	= { European Conference on Software Maintenance and
		  Reengineering },
  pages		= {129-139},
  year		= {2000},
  month		= feb,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi.kontogiannis.ea:pattern,
  author	= {Kamran Sartipi and Kostas Kontogiannis and F. Mavaddat},
  title		= {A Pattern Matching Framework for Software Architecture
		  Recovery and Restructuring},
  booktitle	= {International Workshop on Program Comprehension},
  pages		= {37-47},
  year		= {2000},
  month		= jun,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi.kontogiannis:component,
  author	= {Kamran Sartipi and Kostas Kontogiannis},
  title		= {Component Clustering Based on Maximal Association},
  booktitle	= { Working Conference on Reverse Engineering },
  pages		= {103-114},
  year		= {2001},
  month		= oct,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi.kontogiannis:graph,
  author	= {Kamran Sartipi and Kostas Kontogiannis},
  title		= {A Graph Pattern Matching Approach to Software Architecture
		  Recovery},
  booktitle	= { International Conference on Software Maintenance },
  pages		= {408-419},
  year		= {2001},
  month		= nov,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi:alborz,
  author	= {Kamran Sartipi},
  title		= {Alborz: A Query-based Tool for Software Architecture
		  Recovery},
  booktitle	= {International Workshop on Program Comprehension},
  pages		= {115-116},
  year		= {2001},
  month		= may,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi:software,
  author	= {Kamran Sartipi},
  title		= {A Software Evaluation Model Using Component Association
		  Views},
  booktitle	= {International Workshop on Program Comprehension},
  pages		= {259-268},
  year		= {2001},
  month		= may,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@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}
}

@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}
}

@InProceedings{	  siff.reps:identifying,
  author	= {Michael Siff and Thomas Reps},
  title		= {Identifying Modules via Concept Analysis},
  booktitle	= {Proc. of. the Internation Conference on Software
		  Maintenance},
  pages		= {170-179},
  month		= {October},
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering Reverse_Design
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@InProceedings{	  sneed.kaposi:study,
  author	= {Harry M. Sneed and Agnes Kaposi},
  title		= {A study on the Effect of Reengineering on
		  Maintainability},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {91-99},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {The report presented here on the effect of reengineering
		  upon software maintainablility stems from a laboratory
		  experiment conducted within the METKIT research project of
		  the European ESPRIT program for the study and promotion of
		  the use of metrics in Software-Engineering. The experiment
		  was conducted as a case study in measuring software
		  complexity and maintainablility. However, the results also
		  serve to assess the benefits of reengineering old programs.
		  Maintainability is defined as the effort to perform
		  maintenance tasks, the impact domain of the maintenance
		  actions and the error rate caused by those actions.
		  Complexity is defined as a combination of code, data, data
		  flow, structure, and control flow metrics. From the data
		  collected it demonstrates that reengineering can decrease
		  complexity and increase maintainability, but that
		  restructuring has only a minor effect on maintainability.},
  class		= {Reengineering_in_General, Experiences,
		  Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics,
		  Maintenance_Metrics}
}

@Article{	  snelting:reengineering,
  author	= {G. Snelting},
  title		= {Reengineering of configurations based on mathematical
		  concept analysis},
  journal	= {ACM Transactions on Software Engineering and Methodology},
  year		= {1986},
  volume	= {5},
  number	= {2},
  pages		= {146-189},
  month		= {April},
  key		= {Concept Analysis},
  class		= {Configuration_Structures Software_Reverse_Engineering
		  Reverse_Design }
}

@Article{	  soloway.ehrlich:empirical,
  author	= {Elliot Soloway and Kate Ehrlich},
  title		= {Empirical Studies of Programming Knowledge},
  journal	= {IEEE Transactions on Software Engineering},
  year		= {1984},
  volume	= {SE-10},
  number	= {5},
  pages		= {595-609},
  month		= sep,
  abstract	= { We suggest that expert programmers habe and use two types
		  of programming knowledge: 1) programming plans, which are
		  generic program fragments that represent stereotypic action
		  sequences in programming and 2) rules of programming
		  discourse, which capture the conventions in programming and
		  govern the composition of the plans into programs. We
		  report here on two empirical studies that attempt to
		  evaluate the above hypothesis. Results from these studies
		  do in fact support our claim. },
  keys		= {Cognitive models of programming, novice/expert
		  differences, program comprehension, software psychology.},
  class		= {Software_Reverse_Engineering,
		  Cognitive_Processes_in_Human_Program_Understanding,
		  Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@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}
}

@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}
}

@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}
}

@InProceedings{	  tan.dietz:abstracting,
  key		= {Tan \& Dietz, 1994},
  author	= {Eng-Siong Tan and Henry G. Dietz},
  title		= {Abstracting Plan-like Program Information: a
		  Demonstration},
  pages		= {262-271},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Most programmers spend far more time understanding and
		  modifying existing programs than they spend developing new
		  programs. Current program views used for understanding
		  programs seek to support understanding mainly at the
		  program analysis level. That is, many views are often
		  graphical representations of program analysis concepts,
		  such as the program's data and control dependence graphs,
		  abstract syntax trees of call graphs. However, it may be
		  tedious to understand a program using only such
		  analysis-centered views that support a more abstract level
		  of program understanding, by describing plan-like program
		  information. In this paper, we show how our views can
		  succinctly present widely-scatteres but logically-related
		  program information to describe how certain program effects
		  (e.g. the pattern of occurrrence of a global variable) are
		  implemented in a program, and how programmers can
		  interactively manipulate these program views, through view
		  composition and refinement.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@Article{	  tan.ling:recovery,
  title		= {Recovery of Object-Oriented Design from Existing
		  Data-intensive Business Programs},
  author	= {H.B.T. Tan and T.W. Ling},
  journal	= {Information and Software Technology},
  volume	= {37},
  number	= {2},
  pages		= {67--77},
  year		= {1995},
  note		= { A method is given for the recovery of a specification
		  from an existing data-intensive business program using an
		  augmented model that is proposed in the paper},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@Article{	  tangorra.chiarolla:methodology,
  title		= {A Methodology for Reverse Engineering Hierarchical
		  Databases},
  author	= {F. Tangorra and D. Chiarolla},
  journal	= {Information and Software Technology},
  volume	= {37},
  number	= {4},
  pages		= {225--231},
  year		= {1995},
  note		= { The steps of a reverse engineering process for
		  translating a hierarchical data scheme into a conceptual
		  description in the extended entity-relationship model are
		  described. Contains a case study},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design,
		  Data-Centered_Program_Understanding}
}

@Article{	  tip:survey,
  title		= {A survey of program slicing techniques},
  author	= {F. Tip},
  journal	= {Journal of programming languages},
  volume	= {3},
  pages		= {121--189},
  year		= {1995},
  note		= { Surveys the state-of-the-art in program slicing and gives
		  many references to the literature},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  tonella.antoniol.ea:variable,
  author	= {Paolo Tonella and Giuliano Antoniol and Roberto Fiutem and
		  Ettore Merlo},
  title		= {Variable Precision Reaching definitions Analysis for
		  Software Maintenance},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {A flow analyzer can be very helpful in the process of
		  program understanding, by providing the programmer with
		  different views of the code. As the documentation is often
		  incomplete or inconsistent, it is extremely useful to
		  extract the information a programmer may need directly from
		  the code. Program understanding activities are interactive,
		  thus program analysis tools may be asked for quick answers
		  by the maintainer. Therefore the control on the trade-off
		  between accuracy and efficiency should be given to the user.
		  
		  This paper presents an approach to interprocedural reaching
		  definitions flow analysis based on three levels of
		  precision depending on the sensitivity to the calling
		  context and the control flow. A lower precision degree
		  produces an overestimate of the data dependences in a
		  program. The result is anyhow conservative (all dependences
		  which hold are surely reported), and definitely faster than
		  the more accurate counterparts. A tool supporting reaching
		  definition analysis in the three variants has been
		  developed. The results on a test suite show that three
		  orders of magnitude can be gained in execution times by the
		  less accurate analysis, but 57.4 % extra dependences are on
		  average added. The intermediate variant is much more
		  precise (1.6 % extra dependences), but gains less in times
		  (one order of magnitude). },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  tonella.antoniol:object,
  author	= {Paolo Tonella and Guilio Antoniol},
  title		= {Object Oriented Design Pattern Recovery},
  booktitle	= {Proceedings of the International Conference on Software
		  Maintenance},
  publisher	= {IEEE Computer Society},
  year		= {1999},
  keywords	= {concept analysis, design pattern recovery},
  class		= {Software_Reverse_Engineering Design_Pattern_Recovery
		  Reverse_Design }
}

@InProceedings{	  tonella.fiutem.ea:augmenting,
  author	= {P. Tonella and R. Fiutem and G. Antoniol and E. Merlo},
  title		= {Augmenting Pattern-Based Architectural Recovery with Flow
		  Analysis: Mosaic - A Case Study},
  booktitle	= {Working Conference on Reverse Engineering},
  publisher	= {IEEE Computer Society},
  year		= {1996},
  abstract	= {Understanding the overall organization of a software
		  system, i.e. its software architecture, is often required
		  during software maintenance: tools can help maintainers in
		  managing the evolution of legacy systems, by showing them
		  architectural information. In this paper, the analysis of a
		  medium-sized application using a pattern based
		  architectural recovery environment is presented. The
		  results obtained give useful information about the system
		  architecture but also show some limitations of a purely
		  pattern based approach. To overcome such limitations,
		  architectural analysis algorithms have been augmented with
		  information about control and data flow and the case study
		  application has been re-analyzed. Complementing pattern
		  matching with flow information has allowed to detect
		  architectural constructs also when they are spread over
		  different procedures in source code and to extract useful
		  additional information through the use of constant
		  propagation and slicing. },
  keywords	= {program understanding, software architectures, reverse
		  engineering, pattern matching, flow analysis, Mosaic.},
  class		= {Knowledge-Based_Concept_Assignment
		  Software_Reverse_Engineering Reverse_Design
		  Program_Plan_Assignment_by_Parsing }
}

@Article{	  tonella:concept,
  author	= {P. Tonella},
  title		= {Concept analysis for module restructuring},
  journal	= { IEEE Computer Society  Transactions on Software
		  Engineering},
  year		= {2001},
  volume	= {27},
  number	= {4},
  pages		= {351--363},
  month		= apr,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  tzerpos.holt:acdc,
  author	= {Vassilios Tzerpos and Richard C. Holt},
  title		= {ACDC: An Algorithm for Comprehension-Driven Clustering},
  booktitle	= { Working Conference on Reverse Engineering },
  year		= {2000},
  month		= nov,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  tzerpos.holt:mojo,
  author	= {Vassilios Tzerpos and Richard C. Holt},
  title		= {MoJo: A Distance Metric for Software Clustering},
  booktitle	= { Working Conference on Reverse Engineering },
  year		= {1999},
  month		= oct,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  tzerpos.holt:on,
  author	= {Vassilios Tzerpos and Richard C. Holt},
  title		= {On the Stability of Software Clustering Algorithms},
  booktitle	= {International Workshop on Program Comprehension},
  year		= {2000},
  month		= jun,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  tzerpos.holt:orphan,
  author	= {Vassilios Tzerpos and R.C. Holt},
  title		= {The Orphan Adoption problem in Architecture Maintenance},
  booktitle	= {Proceedings of the Fourth 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	= {A lot of research time has been devoted to finding a
		  solution to the problem of automatic clustering especially
		  in the field of Reverse Engineering where decomposing a
		  legacy system to subsystems could be the key to
		  understanding it. Maintaining the obtained structure as a
		  system evolves however is a problem that has attracted much
		  less attention. In this paper we present the Orphan
		  Adoption problem in architecture maintenance and propose an
		  algorithm to solve it. We also present case studies that
		  validate the usefulness of our algorithm. },
  class		= {Software_Reverse_Engineering Reverse_Design
		  Recovery_of_Software_Architecture }
}

@InProceedings{	  tzerpos.holt:software,
  author	= {Vassilios Tzerpos and Richard C. Holt},
  title		= {Software Botryology: Automatic Clustering of Software
		  Systems},
  booktitle	= {International Workshop on Large-Scale Software
		  Composition},
  year		= {1998},
  month		= aug,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  vanek.culp:static,
  author	= {Leonard I. Vanek and Mark N. Culp},
  title		= {Static Analysis of Program Source Code using EDSA},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {192-199},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {ESDA is a tool that uses static analysis of source code to
		  help gain an understanding of existing code. This may be
		  for the purpose of tracking down a bug or to determine in
		  advance whether an intended change will have any
		  undesirable side effects. In either case, the phase of the
		  development life cycle that will most benefit from a tool
		  like EDSA is the maintenance phase.
		  
		  ESDA provides three kinds of facilities. It helps to browse
		  through code following either the control flow or data flow
		  rather than the order in which the code happens to be
		  written. It displays code with unimportant source lines
		  elided, so that the user can get a more global view of the
		  program. Finally, it provides search management to make it
		  easier to examine all possibilities when browsing.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@Article{	  waters:program,
  key		= {Waters},
  author	= {R. C. Waters},
  title		= {Program Translation via Abstraction and Reimplementation},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {1207--1228},
  volume	= {14},
  number	= {8},
  month		= aug,
  year		= {1988},
  abstract	= {Essentially all program tranlators (both source-to-source
		  translators and compilers) operate via transliteration and
		  refinement. The source program is first tranliterated into
		  the target language on a statement-by-statement basis.
		  Various refinements are then applied in order to improve
		  the quality of the output. Although acceptable in many
		  situations, this approach is fundamentally limited in the
		  quality of the output it can produce. In particular, it
		  tends to be insufficiently sensitive to global features of
		  the source program and too sensitive to irrelavant local
		  details.
		  
		  This paper presents an alternate translation paradigm -
		  abstraction and reimplementation. Using this paradigm, the
		  source program is first analyzed in order to obtain a
		  programming-language-independent understanding of the
		  computation performed by the program as a whole. The
		  program is then reimplemented in the target language based
		  on this understanding. The key to this approach is the
		  abstract understanding obtained. It allows the translator
		  to see the forest for the trees, benefiting from an
		  appreciation of the global features of the source program
		  without being distracted by irrelevant details.
		  
		  Translation via abstraction and reimplemenation is one of
		  the goals of the Programmer's Aprprentice project. A
		  translator which translates Cobol programs into Hibol (a
		  very-high-level business data processing language) has been
		  constructed. A compiler which generates extremly efficient
		  PDP-11 object code for Pascal programs has been designed.
		  Currently, work is proceeding toward the implementation of
		  a general-purpose, knowledge-based translator.},
  location	= {CMU E\&{}S Library},
  class		= {Alteration, Re-Code, Source-to-Source-Translation,
		  Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing},
  note		= { The translation paradigm of abstraction and
		  reimplementation, which is one of the goals of the
		  Programmer's Apprentice project \cite{RiWa90} is presented.
		  A translator has been constructed which translates Cobol
		  programs into Hibol (a very high level, business data
		  processing language)}
}

@TechReport{	  webster:desire-88,
  author	= {Dallas Webster},
  title		= {DESIRE-88 Prototype Tools},
  institution	= {MCC},
  year		= {1989},
  type		= {Technical Report},
  number	= {STP-069-89},
  month		= feb,
  abstract	= {DESIRE is an STP activity whose goal is to develop and
		  support a process for recovering design information from
		  the artifacts (e.g. code, specifications and user
		  documentation) of existing designs. This report presents a
		  snapshot of the initial phase of that activity, showing its
		  status by discussing some prototype tools that we have been
		  experimenting with an evaluating.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design}
}

@Article{	  weiser:foreword,
  author	= {Mark Weiser},
  title		= {Foreword to Special Issue on Program Slicing},
  journal	= {Information and Software Technology},
  year		= {1998},
  key		= {Program Slicing},
  volume	= {40},
  number	= {11-12},
  pages		= {575-576},
  month		= {November},
  note		= {Special issue on program slicing},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@Article{	  weiser:program,
  title		= {Program slicing},
  author	= {M. Weiser},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {10},
  number	= {4},
  pages		= {352--357},
  year		= {1984},
  note		= { In this paper some properties of slices are presented. It
		  is shown that the use of data-flow analysis is sufficient
		  to find approximate slices of the generally unsolvable
		  problem of finding statement-minimal slices},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Program_Slicing}
}

@InProceedings{	  wilde.huitt.ea:dependence,
  author	= {Norman Wilde and Ross Huitt and Scott Huitt},
  title		= {Dependence Analysis Tools: Reusable Components for
		  Software Maintenance},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {126-131},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Software Maintenance is costly because of the many complex
		  interrelationships in a large software system; an
		  understanding of these program dependencies is fundamentral
		  to efficient software change. This paper describes a
		  general purpose toolset that is now being developed to
		  capture and analyze software dependencies. The tools are
		  designed to serve as reusable components. They may be used
		  not only to aid programmers directly in understanding
		  programs but also as a basis from which other specialized
		  tools can be constructed.
		  
		  The tools use the concept of a dependency graph as a basic
		  abstraction to simplify the understanding of software
		  relationships. Definitional, calling, functional and
		  data-flow dependencies are analyzed. An external dependency
		  graph for each function is developed to encapsulate the
		  effects of function calls.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Static_Analysis, Static_Data_Flow_Analysis}
}

@Article{	  wilde.huitt:reusable,
  title		= {A reusable toolset for software dependency analysis},
  author	= {N. Wilde and R. Huitt},
  journal	= {Journal of Systems and Software},
  volume	= {14},
  number	= {2},
  pages		= {97--102},
  year		= {1991},
  note		= { A general purpose tool set that has been developed to
		  capture and analyse software dependencies is described. A
		  prototype of this so-called dependency analysis tool set
		  has been implemented to analyze C code},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis}
}

@TechReport{	  wills:automated,
  author	= {Linda Mary Wills},
  title		= {Automated Program Recognition by Graph Parsing},
  institution	= {Massachusetts Intitute of Technology - Artificial
		  Intelligence Laboratory},
  year		= {1992},
  type		= {Technical Report},
  number	= {1358},
  month		= jul,
  abstract	= {The recoginition of standard computational structures
		  (clich\'es) in a program can help an experienced programmer
		  understand the program. Based on the known relationships
		  betwwen the clich\'es, a hierarchical description of the
		  program's design can be recovered. We develop and astudy a
		  graph parsing approach to automating program recognition in
		  which programs are represented as attributed dataflow
		  graphs and a library of clich\'es in the code.
		  
		  We demonstrate that this graph parsing approach is feasible
		  and useful way to automate program recognition. In studying
		  this approach, we have experimented with two medium-sized,
		  real-world simulator programs. There are three aspects of
		  our study. First, we evaluate our representation's ability
		  to suppress many common forms of program variation which
		  hinder recognition. Second, we investigate the
		  expressiveness of our graph grammar formalism for capturing
		  programming clich\'es. Third, we empirically and
		  analytically study the computational costs of our
		  recognition approach with respect to the real-world
		  simulator programs.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@InProceedings{	  wills:flexible,
  author	= {L. Wills},
  title		= {Flexible control for program recognition},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {134--143},
  year		= {1993},
  note		= { Uses chart parsing (a graph-based parsing technique) for
		  recognizing program plans. The GRASPR tool implements this
		  technique and can be applied to Common Lisp programs (less
		  than 1000 lines)},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@InProceedings{	  wills:flexible*1,
  author	= {Linda M. Wills},
  title		= {Flexible Control for Program Recognition},
  booktitle	= {Working Conference on Reverse Engineering},
  address	= {Baltimore, Maryland},
  year		= {1993},
  month		= may,
  pages		= {134-143},
  abstract	= {Recognizing commonly used data structures and algorithms
		  is a key activity in reverse engineering. Systems developed
		  to automate this recognition process have been isolated,
		  stand-alone systems, usually targeting a specific task. We
		  are interested in applying recognition to multiple tasks
		  requiring reverse engineering, such as inspecting,
		  maintaining, and reusing software. This requires a
		  flexible, adaptable recognition architecture, since the
		  tasks vary in the amount and accuracy of knowledge
		  available about the program, the requirements on
		  recongnition power, and the resources available. We have
		  developed a recognition system based on graph parsing. It
		  has a flexible, adaptable control structure that can accept
		  advice from external agents. Its flexibility arises from
		  using a chart parsing algorithm. We are studying this graph
		  parsing approach to determine what types of advice can
		  enhance its capabilities, performance, and scalability.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/flexible.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing, Recognizer}
}

@InProceedings{	  wills:using,
  author	= {Linda M. Wills},
  title		= {Using Attributed Flow Graph Parsing to Recognize
		  Programs},
  booktitle	= {Int. Workshop on Graph Grammars and Their Application to
		  Computer Science},
  address	= {Williamsburg, Virginia},
  year		= {1994},
  month		= nov,
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/ggram.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing, Recognizer}
}

@Article{	  withrow:error,
  title		= {Error density and size in {Ada} software},
  author	= {C. Withrow},
  journal	= {{IEEE} Software},
  volume	= {7},
  number	= {1},
  pages		= {26--30},
  year		= {1990},
  note		= { In this paper we can find an empirical study of the
		  relation between error density and the length of an Ada
		  module. The results show that there is an optimal length
		  and that shorter modules and larger ones contain more
		  errors. For reverse engineering such metrics can give an
		  indication for the status of the software},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design, Metrics}
}

@Article{	  wolf.clarke.ea:adapic,
  key		= {Wolf et al.},
  author	= {A. L. Wolf and L. A. Clarke and J. C. Wileden},
  title		= {The AdaPIC Tool Set: Supporting Interface Control and
		  Analysis Throughout the Software Development Process},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {250--263},
  volume	= {15},
  number	= {3},
  month		= mar,
  year		= {1989},
  location	= {CMU E & S Library},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@Article{	  wong.tilley.ea:structural,
  author	= {Kenny Wong and Scott Tilley and Haus Mueller and
		  Margaret-Anne Storey},
  title		= {Structural Redocumentation: A Case Study},
  journal	= {IEEE Software},
  year		= {1995},
  volume	= {12},
  number	= {1},
  pages		= {46-54},
  month		= {January},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Recovery_of_Software_Architecture}
}

@InProceedings{	  woods.quilici:some,
  author	= {Steven Woods and Alex Quilici},
  title		= {Some Experiments Toward Understanding How Program Plan
		  Recognition Algorithms Scale},
  booktitle	= {Proceedings of the third Working Conference on Reverse
		  Engineering},
  pages		= {21--30},
  year		= {1996},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing}
}

@InProceedings{	  yang.liu.ea:tackling,
  author	= {Hongji Yang and Xiaodong Liu and Hussein Zedan},
  title		= {Tackling the Abstraction Problem for Reverse Engineering
		  in a System Re-engineering Approach},
  booktitle	= {proceedings of the IEEE Conference on Software Maintenance
		  (ICSM'98)},
  publisher	= {IEEE Computer Society},
  year		= {1998},
  address	= {Washington D.C., USA},
  month		= {November},
  abstract	= {It is widely accepted that reverse engineering has three
		  components: restructuring, comprehension and production of
		  formal specification. In this paper, we advocate that the
		  three components could be achieved in a {\bf systematic}
		  approach by successfully applying a series of sound rules.
		  
		  The key approach to comprehension and the production of
		  formal specification is a notion of abstraction.
		  Abstraction is often interpreted as the act of hiding
		  irrelevant details. What constitute as relevant details is
		  often left open to different interpretations.
		  
		  A unified approach for reverse engineering is described
		  within which the notion of abstraction is classified and
		  precisely defined. Abstraction rules are given and applied
		  to various small examples. },
  keywords	= {reverse engineering, re-engineering, wide spectrum
		  language, abstraction, object oriented, Interval Temporal
		  Logic. },
  class		= {Reengineering_in_General Software_Reverse_Engineering
		  Reverse_Specification Formal_Methods Reverse_Design
		  Process_Models }
}

@InProceedings{	  yeh.harris.ea:recovering,
  author	= {A.S. Yeh and D. Harris and H. Reubenstein},
  title		= {Recovering abstract data types and object instances from a
		  conventional procedural language},
  booktitle	= {Proc. of. the Second Working Conference on Reverse
		  Engineering},
  pages		= {227­236},
  month		= {July},
  year		= {1995},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering Reverse_Design
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}