References of Software_Reverse_Engineering

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

@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{	  appelbe.kraemer.ea:graphical,
  author	= {Appelbe, William F. and Kraemer, Eileen and Lakshmanan,
		  Bala and Stasko, John T. and Wehrli, Joseph F.},
  title		= {Graphical Support for Debugging Parallel Programs
		  (extended abstract)},
  booktitle	= {Proceedings of the 1993 ACM/ONR Workshop on Parallel and
		  Distributed Debugging, San Diego, CA},
  year		= {1993},
  pages		= {172-174},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@InProceedings{	  appelbe.stasko:utilizing,
  author	= {Appelbe, William F. and Stasko, John T.},
  title		= {Utilizing Program Visualization and Animation Techniques
		  to Aid Parallel Program Development and Debugging (extended
		  abstract)},
  booktitle	= {Proceedings of the 1991 ACM/ONR Workshop on Parallel and
		  Distributed Debugging, Santa Cruz, CA},
  year		= {1991},
  pages		= {207-209},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@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,
  author	= {Guillermo Arango and Ira Baxter and Peter Freeman and
		  Christopher Pidgeon},
  title		= {TMM: Software Maintenance by Transformation},
  journal	= {IEEE Software},
  year		= {1986},
  pages		= {27-38},
  month		= may,
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Use_of_data_bases}
}

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

@Article{	  arnold.frakes:software*1,
  author	= { R. Arnold and W. Frakes },
  title		= { Software Reuse and Reengineering },
  journal	= { CASE Trends (final draft) },
  year		= { February 1991 },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Re-Use }
}

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

@Article{	  bachmann:case,
  author	= { C. Bachmann },
  title		= { A CASE for Reverse Engineering },
  journal	= { Datamation },
  year		= { July 1, 1988 },
  abstract	= { see Arnold's book },
  class		= {Software_Reverse_Engineering,
		  General_Information_on_Reverse_Engineering }
}

@TechReport{	  badre.beranek.ea:assessing,
  author	= {Badre, Albert and Beranek, Margaret and Morris, J. Morgan
		  and Stasko, John T.},
  title		= {Assessing Program Visualization Systems as Instructional
		  Aids},
  institution	= {Graphics, Visualization, and Usability Center, Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1991},
  type		= {Technical Report},
  number	= {GIT-GVU-91-23},
  month		= oct,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  http		= {http://www.cc.gatech.edu/gvu/softviz/empir/empir.html},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Empirical_Studies_of_Software_Visualization}
}

@InProceedings{	  badre.beranek.ea:assessing*1,
  author	= {Badre, Albert and Beranek, Margaret and Morris, J. Morgan
		  and Stasko, John T.},
  title		= {Assessing Program Visualization Systems as Instructional
		  Aids},
  booktitle	= {Computer Assisted Learning, ICCAL '92, Wolfville, Nova
		  Scotia, Canada},
  year		= {1992},
  editor	= {Ivan Tomek},
  pages		= {87-99},
  publisher	= {Lecture Notes in Computer Science},
  serie		= {602},
  month		= jun,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Empirical_Studies_of_Software_Visualization}
}

@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{	  bailey.basili:software,
  author	= { J.W. Bailey and V.R. Basili },
  title		= { Software Reclamation: Improving Post-Development
		  Reusability },
  booktitle	= { Proceedings of the Eighth Annual National Conference on
		  Ada Technology },
  year		= { April 1990 },
  pages		= { 477-499 },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Re-Use }
}

@InProceedings{	  baker.eick:visualizing,
  author	= {M. J. Baker and S. G. Eick},
  title		= {Visualizing software systems},
  pages		= {59--70},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  abstract	= {There are many graphical techniques for visualizing
		  software. Unfortunately, the current techniques do not
		  scale to display large software systems and are largely
		  unused. The authors present a method for visualizing
		  statisistics associated with code that is devided
		  hierarchically into subsystems, directories, and files.
		  Using the authors' technique, the authors can display the
		  relative sizes of the components in the system, which
		  components are stable and which are changing, where the new
		  functionality is being added, and identify error-prone code
		  with many bug fixes. Using animation, the authors can
		  display the historical evolution of the code.},
  class		= {Software_Reverse_Engineering, Software_Evolution}
}

@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{	  basili:maintenance,
  author	= {Victor R. Basili},
  year		= {October 1988},
  pages		= {3-4},
  title		= {Maintenance = Reuse-oriented Software Development},
  booktitle	= {Proceedings of the IEEE 1988 Conference on Software
		  Maintenance},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Re-Use }
}

@Article{	  basili:viewing,
  title		= {Viewing maintenance as reuse oriented software
		  development},
  author	= {V. Basili},
  journal	= {{IEEE} Software},
  volume	= {7},
  number	= {1},
  pages		= {19--25},
  year		= {1990},
  note		= { In this paper the maintenance process is incorporated in
		  the life-cycle perspective geared towards the reusability
		  of the various components},
  class		= {Reengineering_in_General, Process_Models,
		  Software_Reverse_Engineering, Re-Use}
}

@Article{	  basili:viewing*1,
  author	= {Victor R. Basili},
  year		= {January 1990},
  journal	= {IEEE Software},
  pages		= {19-25},
  title		= {Viewing Maintenance as Reuse-Oriented Software
		  Development},
  volume	= {7(1)},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Re-Use }
}

@Article{	  bauer.moller.ea:formal,
  author	= {F.L. Bauer and B. Moller and H. Partsch and P. Pepper},
  title		= {Formal program construction by transformations---
		  Computer-aided, intuition-guided programming},
  journal	= {IEEE Transactions on Software Engineering},
  month		= {February},
  year		= {1989},
  volume	= {15},
  number	= {2},
  pages		= {165-180},
  abstract	= { . CIP . Transformation-based approach. },
  class		= {Software_Reverse_Engineering, Formal_Methods }
}

@TechReport{	  baumann.fassler.ea:beauty,
  author	= {P. Baumann and J. F\"assler and M. Kiser and Z. \"Ozt\"urk},
  institution	= {Department of Computer Science, University of Zurich,
		  Switzerland},
  number	= {93.39},
  title		= {Beauty and the Beast or A Formal Description of the
		  Control Constructs of Cobol and its Implementation},
  year		= {1993},
  note		= { A formal semantics for a subset of COBOL is presented
		  with the aid of denotational semantics. The subset consists
		  of the control constructs of COBOL. In \cite{BFKOR95} it is
		  argued that precisely this subset is relevant for reverse
		  engineering},
  class		= {Software_Reverse_Engineering, Formal_Methods}
}

@TechReport{	  baumann.fassler.ea:semantics-based,
  title		= {Semantics-based Reverse Engineering},
  author	= {P. Baumann and J. F\"assler and M. Kiser and Z. \"Ozt\"urk
		  and L. Richter},
  institution	= {Department of Computer Science, University of Zurich,
		  Switzerland},
  number	= {94.08},
  year		= {1994},
  note		= { Denotational semantics is advocated as a formal
		  foundation for program understanding. The ideas are
		  implemented in a tool for reverse engineering called AEMES.
		  This tool is geared towards COBOL-74},
  class		= {Software_Reverse_Engineering, Formal_Methods}
}

@Book{		  baxter.quilici.ea:proceedings,
  title		= {Proceedings of the Fourth Working Conference on Reverse
		  Engineering},
  year		= {1997},
  editor	= {Ira Baxter and Alex Quilici and Chris Verhoef},
  publisher	= {IEEE Computer Society Press},
  month		= {October},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Collections }
}

@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{	  bellay.gall:comparison,
  author	= {Berndt Bellay and Harald Gall},
  title		= {A Comparison of four Reverse Engineering Tools},
  booktitle	= {Proceedings of the 4th  Working Conference on Reverse
		  Engineering },
  publisher	= {IEEE Computer Society Press},
  year		= {1997},
  editor	= {Ira Baxter and Alex Quilici and Chris Verhoef},
  abstract	= {Reverse engineering tools support software engineers in
		  the process of analyzing and understanding complex software
		  systems during maintenance activities. The functionality of
		  such tools varies from editing and browsing capabilities to
		  the generation of textual and graphical reports. There are
		  several commercial revers e engineering tools on the market
		  providing different capabilities and supporting specific
		  source code languages. We evaluated four reverse
		  engineering tools that analyze C source code: Refine,
		  Imagix4D, Sniff, and Rigi. We investigated the capabilities
		  of these tools by applying them to a commercial embedded
		  software system as a case study. We identified benefits and
		  shortcomings of these four tools and assessed their
		  applicability for embedded software systems their usability
		  and their extensibility.},
  class		= {Software_Reverse_Engineering
		  Software_Reverse_Engineering_Tools }
}

@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{	  bertels.vanneste.ea:cognitive,
  author	= {K. Bertels and Ph. Vanneste and C. de Backer},
  title		= {A cognitive approach to program understanding},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {1--7},
  year		= {1993},
  note		= { Presents a method of program understanding based on a
		  cognitive model of programming knowledge. The approach
		  involves the generation of a high level, abstract,
		  description that is robust with respect to conceptual
		  errors and syntactic variations},
  class		= {Software_Reverse_Engineering,
		  Cognitive_Processes_in_Human_Program_Understanding}
}

@InProceedings{	  bertels.vanneste.ea:cognitive*1,
  author	= { K. Bertels and P. Vanneste and C. {De~Backer} },
  title		= { A Cognitive Approach to Program Understanding },
  booktitle	= { WCRE~'93: Proceedings of the 1993 Working Conference on
		  Reverse Engineering, {\rm (Baltimore, Maryland; May 21-23,
		  1993)}},
  year		= { May 1993 },
  pages		= { 1-7 },
  publisher	= { IEEE Computer Society Press (Order Number 3780-02)},
  abstract	= { },
  class		= {Software_Reverse_Engineering,
		  Cognitive_Processes_in_Human_Program_Understanding }
}

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

@TechReport{	  biggerstaff:nature,
  author	= {Ted J. Biggerstaff},
  title		= {The Nature of Semi-Formal Information in Domain Models},
  institution	= {MCC},
  year		= {1988},
  type		= {Technical Report},
  number	= {STP-289-88},
  month		= sep,
  abstract	= {This position paper describes the nature and importance of
		  informal and semi-formal information in the understanding,
		  interpretation and reuse of large complex programs. The
		  understanding of large, complex, existing programs is
		  sometimes called the "dusty deck" problem.
		  
		  The emphasis of this research is on how one might create a
		  model of a domain that would help in the job of
		  understanding and eventually reusing large scale designs
		  from large, comple and generally unmastered existing
		  programs. The role of informal and semi-formal information
		  is central to this domain model.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@TechReport{	  biggerstaff:reusability,
  author	= {Ted J. Biggerstaff},
  title		= {Reusability Overview},
  institution	= {MCC},
  number	= {STP-168-86},
  year		= {1986},
  month		= {May},
  abstract	= { },
  class		= {Software_Reverse_Engineering, Re-Use }
}

@Book{		  biggerstaff:video,
  author	= { Ted. J. Biggerstaff },
  title		= { Video Notes - Topics in Reuse and Design Recovery },
  publisher	= { IEEE Computer Society Press },
  year		= { 1990 },
  class		= {Software_Reverse_Engineering, Re-Use }
}

@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{	  blaha.premerlani:observed,
  author	= {michael blaha and william premerlani},
  title		= {Observed idiosyncracies of relational database designs},
  booktitle	= {Second Working Conference on Reverse Engineering},
  publisher	= {IEEE},
  year		= {1995},
  abstract	= {Several processes have been advanced in the literature for
		  reverse engineering of relational databases. The inputs to
		  these processes are relational tables and available
		  contextual information. The output is a model of the
		  underlying logical intent, apart from the implementation
		  artifacts. Most of the existing processes for database
		  reverse engineering are inadequate; they assume too high a
		  quality of input information. The authros of these
		  processes are skilled database designers and they are
		  overly optimistic about the state-of-the-art, as practiced.
		  This paper catalogs odd aspects of relational database
		  designs that we have encountered over the past several
		  years. many of these database designs are from commercial
		  software products.},
  keywords	= {reverse engineering, database, model},
  class		= {Software_Reverse_Engineering Use_of_data_bases
		  Intermediate_Representations_of_Source_Code }
}

@InProceedings{	  blaha:dimensions,
  author	= {michael blaha},
  title		= {Dimensions of database reverse engineering},
  booktitle	= {Fourth Working Conference on Reverse Engineering},
  publisher	= {IEEE},
  year		= {1997},
  abstract	= {We continue to be surprised by the variability of reverse
		  engineering problems. When we tackle new problems, we often
		  encounter situations we have not seen before. For these
		  different situations, we have to adjust our reverse
		  engineering techniques, level of effort, and expectations.
		  This paper characterizes dimentions of variation for
		  reverse engineering of databases.},
  keywords	= {database, reverse engineering, overview},
  class		= {Software_Reverse_Engineering
		  General_Information_on_Software_Reverse_Engineering }
}

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

@Article{	  blazy.facon:partial,
  author	= {S. Blazy and P. Facon},
  title		= {Partial Evaluation for the Understanding of {FORTRAN}
		  Programs},
  journal	= {International Journal of Software Engineering and
		  Knowledge Engineering},
  volume	= {4},
  number	= {4},
  pages		= {535-559},
  year		= {1994},
  note		= { A technique and a tool are described supporting the
		  partial evaluation of FORTRAN programs in order to
		  understand old programs that have become very complex due
		  to numerous alterations},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools}
}

@InProceedings{	  boldyreff.burd.ea:greater,
  author	= {C. Boldyreff and E.L. Burd and R.M. Hather and M. Munro
		  and E.J. Younger},
  title		= {Greater Understanding Through Maintainer Driven
		  Traceability},
  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_Specification,
		  Requirement_Tracability }
}

@Article{	  bowen.breuer.ea:compendium,
  title		= {A compendium of formal techniques for software
		  maintenance},
  author	= {J. Bowen and P. Breuer and K. Lano},
  journal	= {Software Engineering Journal},
  pages		= {253--262},
  volume	= {8},
  number	= {5},
  year		= {1993},
  note		= { An overview of formal techniques developed recently to
		  aid the software maintenance process and particularly
		  reverse engineering is given},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_in_General, Formal_Methods}
}

@Unpublished{	  brand.klint.ea:core,
  author	= {Mark van den Brand and Paul Klint and Chris Verhoef},
  title		= {Core Technologies for System Renovation},
  key		= {system renovation, intermediate data representation,
		  coordination language, query algebra},
  year		= {1999},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs}
}

@InProceedings{	  brand.sellink.ea:generation,
  author	= {Mark van den Brand and Alex Sellink and Chris Verhoef},
  title		= {Generation of Components for Software Renovation Factories
		  from Context-free Grammars},
  booktitle	= {Proceedings of the 4th  Working Conference on Reverse
		  Engineering },
  publisher	= {IEEE Computer Society Press Los Alamitos California},
  year		= {1997},
  editor	= {Ira Baxter and Alex Quilici and Chris Verhoef},
  abstract	= { We present an approach for the generation of components
		  for a software renovation factory. These components are
		  generated from a context-free grammar definition that
		  recognizes the code that has to be renovated. We generate
		  analysis and transformation components that can be
		  instantiated with a specific transformation or analysis
		  task. We apply our approach to COBOL and we discuss the
		  construction of realistic software renovation components
		  using our approach.},
  class		= {Software_Reverse_Engineering Reengineering_Tools
		  Software_Reverse_Engineering_Tools }
}

@Article{	  breuer.bowen:decompilation,
  author	= {Peter T. Breuer and Jonathan P. Bowen},
  title		= {Decompilation: The Enumeration of Types and Grammars},
  journal	= {ACM Transactions on Programming Languages and Systems},
  volume	= {16},
  number	= {5},
  pages		= {1613-1647},
  month		= {September},
  year		= {1994},
  abstract	= { . one of the few papers that discusses decompilation,
		  from object -> source . authors are with Universidata
		  Politecnica de Madrid and Oxford . in fact, they describe a
		  "decompiler compiler", a decompiler generator similar to a
		  yacc compiler generator! Example used is for occam .
		  described as an extension to the reverse engineering work
		  in Eprit II REDO * something to pursue later at the SEI,
		  esp. for military systems },
  class		= {Software_Reverse_Engineering, Binary_Reverse_Engineering}
}

@Article{	  breuer.lano:creating,
  author	= { P.T. Breuer and K. Lano },
  title		= { Creating Specifications from Code: Reverse-engineering
		  Techniques },
  journal	= {Journal of Software Maintenance: Research and Practice},
  volume	= { 3 },
  year		= { 1991 },
  pages		= { 145-162 },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Reverse_Specification }
}

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

@Article{	  brooks:towards,
  author	= {Ruven Brooks},
  title		= {Towards a theory of the comprehension of computer
		  programs},
  journal	= {International Journal of Man-Machine Studies},
  year		= {1983},
  pages		= {543-554},
  volume	= {18},
  abstract	= {A sufficiency theory is presented of the process by which
		  a computer programmer attempts to comprehend a program. The
		  theory is intended to explain four sources of variation in
		  behavior on this task: the kind of computation the program
		  performs, the intrinsic properties of the program text,
		  such as language and documentation, the reason for which
		  the documentation is needed, and differences among the
		  individuals performing the task. The starting point for the
		  theory is an analysis of the structure of the knowledge
		  required when a program is comprehended which views the
		  knowledge as being organized into distinct domains which
		  bridge between the original problem and the final program.
		  The program comprehension process is one of reconstructing
		  knowledge about these domains and the relationship among
		  them. This reconstrucing process is theorized to be a
		  top-down, hypothesis driven one in which an initially vague
		  and general hypothesis is refined and elaborated based on
		  information extracted from the program text and other
		  documentation.},
  contents	= {A theory of how programs are comprehended: 1) The
		  programming process is one of constructing mappings from a
		  problem domain, possibly through several intermediate
		  domains, into the programming domain. 2) Comprehending a
		  program involves reconstructing part or all of these
		  mappings. 3) This reconstruction process is expectation
		  driven by the creation, confirmation, and refinement of
		  hypotheses.
		  
		  The reconstruction process (in top-down and depth-first
		  manner) constructs subsidiary hypotheses from initial
		  hypotheses. Confirmation is done by finding ``beacons''
		  (set of features that typically indicate the occurence of
		  certain structures or operations whithin the code). The
		  discovery of a beacon results in a further refinement and
		  specification of the hypothesis itself. Usually, problems
		  will occur which will manifest themselves as one of three
		  symptoms: the programmer will be unable to find code to
		  bind to a particular subsidiary hypothesis, or the same
		  code will be bound to two different hypotheses, or ther
		  will be some parts of the code which cannot be beound to
		  any hypotheses. All these kinds of errors could be cured
		  either by adopting different hypotheses or by altering and
		  adding to the bindings of code to hypotheses.
		  
		  Indicators for the meaning of a program:
		  
		  Internal to the program text 1. Prologue comments,
		  including data and variable dicitionaries 2. Variable,
		  structure, procedure and label names 3. Declarations or
		  data divisions 4. Interline comments 5. Indentation or
		  pretty-printing 6. Subroutines or module structure 7. I/O
		  formats, header, and device or channel assignments
		  
		  External 1. Users' Manual 2. Program logic manuals 3.
		  Flowcharts 4. Cross-reference listing 5. Published
		  descriptions of algorithms or techniques
		  
		  },
  class		= {Software_Reverse_Engineering,
		  Cognitive_Processes_in_Human_Program_Understanding}
}

@Article{	  brooks:towards*1,
  author	= {Ruven Brooks},
  title		= {Towards a Theory of the Cognitive Processes in Computer
		  Programming},
  journal	= {International Journal of Man-Machine Studies},
  year		= {1977},
  volume	= {9},
  pages		= {737-751},
  abstract	= {Another early Brooks paper on domain-bridging. Describes a
		  theory of programmign behavior based on problem-solving
		  theory.},
  class		= {Software_Reverse_Engineering,
		  Cognitive_Processes_in_Human_Program_Understanding }
}

@Article{	  brooks:towards*2,
  author	= {Ruven Brooks},
  title		= {Towards a Theory of the Comprehension of Computer
		  Programs},
  journal	= {International Journal of Man-Machine Studies},
  year		= {1983},
  volume	= {18},
  pages		= {543-554},
  abstract	= {},
  class		= {Software_Reverse_Engineering,
		  Cognitive_Processes_in_Human_Program_Understanding }
}

@InProceedings{	  brooks:using,
  author	= {Ruven Brooks},
  title		= {Using a Behavioral Theory of Program Comprehension in
		  Software Engineering},
  booktitle	= {ICSE'3: Proceedings of the 3rd International Conference on
		  Software Engineering, {\rm (Atlanta, Georgia; May 10-12,
		  1978)}},
  year		= {May 1978},
  pages		= {196-201},
  abstract	= {Early paper on bridging knowledge domains. Differentiates
		  between internal and external clues to PU. ** Quotes
		  Kernighan and Plauger: "The best documentation for a
		  computer program is a clean structure. The only reliable
		  documentation of a computer program is the code itself. The
		  reason is simple: whenever there are multiple
		  representations of a program, the chance for discrepancy
		  exists." [Thus, solution is to keep 'live documentation';
		  VSS.] },
  class		= {Software_Reverse_Engineering,
		  Cognitive_Processes_in_Human_Program_Understanding }
}

@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{	  cahil:practical,
  author	= {Tony Cahil},
  title		= {Practical Difficulties in Developing Tools for Analysis of
		  Large Application Systems},
  booktitle	= {3rd Reverse Engineering Forum (REF~'92), {\rm (Burlingon,
		  MA; September 15-17, 1992)}},
  month		= {September},
  year		= {1992},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Engineering_Tools }
}

@Article{	  caldiera.basili:identifying,
  author	= {Gianluigi Caldiera and Victor R. Basili},
  title		= {Identifying and Qualifying Reusable Software Components},
  journal	= {IEEE Computer},
  year		= {1991},
  pages		= {61-70},
  month		= feb,
  class		= {Software_Reverse_Engineering, Re-Use}
}

@Article{	  caldiera.basili:identifying*1,
  author	= { G. Caldiera and V.R. Basili },
  title		= { Identifying and Qualifying Reusable Software Components
		  },
  journal	= { IEEE Computer },
  year		= { February 1991 },
  pages		= { 61-70 },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Re-Use }
}

@Article{	  caldiera:searching,
  author	= {Gianluigi Caldiera},
  title		= {Searching Existing Programs for Reusable Components},
  journal	= {IEEE},
  year		= {1989},
  pages		= {222-223},
  class		= {Software_Reverse_Engineering, Re-Use}
}

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

@InProceedings{	  canfora.cimitile.ea:logic,
  author	= {G. Canfora and Aniello Cimitile and De Carlini, Ugo},
  title		= {A Logic Based Approach to Reverse Engineering Tools
		  Production},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {83-91},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {This paper analyzes some of the reasons for difficulties
		  arising in the use of design documents produced by Reverse
		  Engineering tools. With reference to intermodule data flow
		  analysis for Pascal software systems, an interactive tool
		  is proposed to more effectively help the maintainer. The
		  tool is based on: (i) the production of intermodule data
		  flow information by static analysis of the code; (ii) their
		  representation in a Prolog program dictionary; (iii) a
		  Prolog abstractor that allows specific queries of
		  maintainers to be answered. },
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Use_of_data_bases}
}

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

@Article{	  canfora.cimitile.ea:logic-based*1,
  title		= {A logic-based approach to reverse engineering tools
		  production},
  author	= {G. Canfora and A. Cimitile and U. de Carlini},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {1053--1064},
  volume	= {18},
  number	= {12},
  year		= {1992},
  note		= { Difficulties arising during the use of documents produced
		  by reverse engineering tools are discussed and analyzed},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools}
}

@Article{	  canfora.cimitile.ea:logic-based*2,
  author	= {Gerardo Canfora and Aniello Cimitile and Ugo
		  {De~Carlini}},
  title		= {A Logic-Based Approach to Reverse Engineering Tools
		  Production},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {18(12)},
  year		= {December 1992},
  pages		= {1053-1063},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Engineering_Tools }
}

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

@TechReport{	  canfora.cimitile.ea:re2,
  author	= {G. Canfora and Aniello Cimitile and M. Munro},
  title		= {$RE^{2}$: Reverse Engineering and Reuse Re-engineering},
  institution	= {University of Durham, School of Engineering and Computer
		  Science},
  year		= {1992},
  type		= {Computer Science Technical Report},
  number	= {8/92},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@Article{	  canfora.cimitile.ea:reverse,
  author	= {G. Canfora and Aniello Cimitile and De Carlini, Ugo},
  title		= {Reverse Engineering and Data Flow Diagrams in ADA
		  Environment},
  journal	= {Microprocessing and Microprogramming},
  year		= {1990},
  volume	= {30},
  pages		= {357-364},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Model_Generating}
}

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

@InProceedings{	  canfora.cimitile.ea:software,
  author	= {G. Canfora and Aniello Cimitile and A. De Lucia and Di
		  Lucca, G. A.},
  title		= {Software Salvaging Based on Conditions},
  pages		= {424-433},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {This paper presents algorithms for isolating reusable
		  functions in large monolithic programs. The functions to be
		  isolated are specified in terms of either pre-conditions of
		  binding conditions, and these are mapped onto predicates on
		  program's variables. Code components whose execution is
		  triggered and/or bound by these predicates are then
		  isolated. Each component is a candidate to implement a
		  reusable function. The algorithms exploit a representation
		  of the subject program in the form of a program dependence
		  graph.
		  
		  This work forms part of $RE^{2}$, a research project that
		  addresses the wider issue of software reuse. $RE^{2}$
		  project aims to promote the reuse of software through the
		  exploration of reverse engineering and re-engineering
		  techniques to identify and extract reusable software
		  components from existing systems.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  canfora.sansone.ea:data,
  author	= {G. Canfora and L. Sansone and G. Visaggio},
  title		= {Data Flow Diagrams: Reverse Engineering Production and
		  Animation},
  pages		= {366-375},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {The paper puts forward the use of interactive animation
		  techniques as a support to reverse engineering processes
		  oriented to the synthesis of semantic abstractions.
		  Starting from Data Flow Diagrams, a formal model - called
		  Dynamic Data Flow Diagrams (DDFDs) - has been defined,
		  which can be used for the production of executable models
		  of a software system. A strategy for the DDFD interactive
		  animation is also put forward. Finally, the paper describes
		  a prototype tool for (i) the production of the Dynamic Data
		  Flow Diagram which models an ADA system starting from the
		  analysis of the code and (ii) the interactive animation of
		  such model according to the suggested strategy.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation}
}

@InProceedings{	  canfora.sansone.ea:data*1,
  author	= {G. Canfora and L. Sansone and G. Visaggio},
  title		= {Data Flow Diagrams: Reverse Engineering Production and
		  Animation},
  booktitle	= {CSM'92: Proceedings of the 1992 Conference on Software
		  Maintenance, {\rm (Orlando, Florida; November 9-12, 1992)}},
  year		= {November 1992},
  pages		= {366-375},
  publisher	= {IEEE Computer Society Press (Order Number 2980)},
  abstract	= {PITS approach to mapping DFDs to graphics. Interactive
		  process. Good introduction on used and motivation for RE.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_for_Program_Understanding_and_Debugging }
}

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

@Article{	  cimitile.carlini:reverse,
  author	= {Aniello Cimitile and Ugo De Carlini},
  title		= {Reverse Engineering: Algorithms for Program Graph
		  Production},
  journal	= {Software---Practice and Experience, Wiley},
  year		= {1991},
  volume	= {21},
  number	= {5},
  pages		= {519-537},
  abstract	= {The paper proposes an algebraic representation of program
		  modules, called F(p), and illustrates the algorithms that
		  use F(p) to generate program graph models for measurement,
		  documentation and testing activities. The representation
		  refers to procedural languages, D-structured programs and
		  one-in/one-out modules but its definition can be extended
		  to programs structured in terms of an arbitrary set of
		  one-in/one-out legal control structures. Since it is
		  possible to produce F(p) directly from the program code
		  using reverse engineering techniques, the algorithms
		  proposed are of considerable interest for the setting up of
		  tools supporting the program comprehension phase, which is
		  a fundamental first step in any maintenance operation.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs}
}

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

@InProceedings{	  cimitile.fasolino.ea:reuse,
  author	= {Aniello Cimitile and A. R. Fasolino and P. Marascea},
  title		= {Reuse Reengineering and Validation via Concept
		  Assignment},
  pages		= {216-225},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The first step in a Software Reuse Reengineering process
		  is to analyze the structural characteristics of the
		  existing software so as to produce software component sets,
		  each of which is a candidate for clustering and
		  reengineering into a reusable module. This step is founded
		  on one ore more Candidature Criteria and the cost of the
		  following steps depend on their quality.
		  
		  This paper introduces the notions of completeness and
		  adequacy as applied to candidature criteria and outlines
		  the need for an adquacy validation process before they are
		  applied on a software system.
		  
		  An adequacy validation process founded on the assignment of
		  a concept to the candidate modules is proposed and the
		  results coming from an application of this process are
		  described and discussed.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

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

@InProceedings{	  cimitile:towards,
  author	= {Aniello Cimitile},
  title		= {Towards Reuse Reengineering of Old Software},
  booktitle	= {Proceedings of the 4th International Conference on
		  Software Engineering and Knowledge Engineering SEKE' 92},
  year		= {1992},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  ciupke:analysis,
  author	= {Oliver Ciupke},
  title		= {Analysis of Object-Oriented Programs Using Graphs},
  booktitle	= {Object-Oriented Technology -- Ecoop'97 Workshop Reader},
  editor	= {Jan Bosch and Stuart Mitchell},
  publisher	= {Springer-Verlag},
  series	= {Lecture Notes in Computer Science},
  pages		= {270--271},
  volume	= {1357},
  month		= mar,
  year		= {1997},
  address	= {Jyv{\"a}skyl{\"a}, Finnland},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs}
}

@TechReport{	  ciupke:documentation,
  author	= {Oliver Ciupke},
  title		= {Documentation and Module Capture Method (Grouping)},
  institution	= {Forschungszentrum Informatik},
  year		= {1997},
  type		= {FAMOOS Achievement Report},
  number	= {A 2.3.1},
  month		= oct,
  id		= {docum-a231, ar231fzi},
  path		= {/fzi/prost/Projects/FAMOOS/doc/achievements/impctut-a271},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Abstraction}
}

@InProceedings{	  ciupke:grouping,
  author	= {Oliver Ciupke},
  title		= {Grouping},
  booktitle	= {ESEC/FSE'97 Workshop on Object-Oriented Reengineering},
  year		= {1997},
  address	= {Z{\"u}rich, Switzerland},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Abstraction}
}

@TechReport{	  ciupke:refined,
  author	= {Oliver Ciupke},
  title		= {Refined Grouping},
  institution	= {Forschungszentrum Informatik},
  year		= {1999},
  type		= {FAMOOS Achievement Report},
  number	= {A 2.5.2},
  month		= may,
  id		= {ar252fzi},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Abstraction}
}

@InProceedings{	  clayton.rugaber:representation,
  author	= {Richard Clayton and Spencer Rugaber},
  title		= {The Representation Problem in Reverse Engineering},
  booktitle	= {Proceedings of the First Working Conference on Reverse
		  Engineering},
  address	= {Baltimore, Maryland},
  year		= {1993},
  month		= may,
  abstract	= {Building models to understand software systems is an
		  important part of reverse engineering. Formal and explicit
		  model building is important because it focuses attention on
		  modeling as an aid to understanding and results in
		  artifacts that may be useful to others. The representation
		  used to build models has great influence over the success
		  and value of the result. Choosing the proper representation
		  during reverse engineering is the representation problem.
		  This paper examines the representation problem by
		  presenting a taxonomy of solutions. It also illustrates the
		  issues involved in choosing a represenation through an
		  example reverse engineering task.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/repr.ps},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code}
}

@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.moopen.ea:domain,
  author	= {Jean-Marc DeBaud and Bijith Moopen and Spencer Rugaber},
  title		= {Domain Analysis and Reverse Engineering},
  pages		= {326-335},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Current reverse engineering technology is typically based
		  on program analysis methods such as parsing and data flow
		  analysis. As such, it is limited in what it can accomplish.
		  Knowledge of the applicaton domain containing a program can
		  help overcome this limit and aid the comprehension process.
		  This paper discusses the relationship of application domain
		  analysis and reverse engineering. Two case studies are
		  presented. The first describes how domain knowledge,
		  expressed as an object-oriented framework, can aid the
		  reverse engineering process for a well-understood domain.
		  The second studies how reverse engineering can be used to
		  build a domain model. Issues raised by the confluence of
		  domain analysis and reverse engineering are discussed, and
		  implications on future work in the area are suggested.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@InProceedings{	  debaud.rugaber:software,
  author	= {Jean-Marc DeBaud and Spencer Rugaber},
  title		= {A Software Re-engineering Method Using Domain Models},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1995},
  address	= {Opio (Nice), France},
  year		= {1995},
  month		= oct,
  pages		= {204-213},
  abstract	= {Current software re-engineering technology is typically
		  based on program analysis methods such as parsing and data
		  flow analysis. This is inadequate for two reasons. First,
		  such methods inherently fail to capture the context or
		  purpose of the program. Second, the results of the program
		  comprehension are not directly usable in program evolution.
		  In this paper, we introduce a method that addresses both of
		  these problems. We use a domain model to understand the
		  context of a program and an object-oriented framework to
		  record that understanding. The main step of this method
		  consists of the construction of an executable domain model
		  whose scope covers a family of target programs. A program
		  is then reverse engineered using the domain model both as a
		  guide and as a recording medium. In the last step,
		  developers re-engineer the target artifact using its
		  abstract domain-driven representation. We present a
		  thorough example to illustrate this approach. Issues raised
		  by the confluence of domain analysis and representation,
		  reverse engineering, and artifact evolution are discussed.
		  Implications on future work in the area are suggested. },
  keywords	= {Program re-engineering, domain analysis, reverse
		  engineering, program evolution, program understanding,
		  reuse infrastructure, software architecture,
		  object-oriented framework.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/repwrt.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@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{	  debaud:lessons,
  author	= {Jean-Marc DeBaud},
  title		= {Lessons from a Domain-Based Reengineering Effort},
  booktitle	= {Proceedings of Working Conference on Reengineering},
  year		= {1996},
  abstract	= {We present in this paper the lessons and insights learned
		  from of a domain-centered reengineering effort. Using a
		  method we developed in a previous work, we set about to
		  understand and transition a complete legacy system from
		  COBOL to an executable domain model. Our work suggests that
		  a domain-based approach is very promising but a number of
		  issues remain to be better understood. Among these are
		  questions about domain completeness, scoping, interleaving
		  and evolution; concept matching at the granularity of both
		  the programs' architecture and the details of the
		  source-code; thoroughness and representation of the legacy
		  programs coverage, as well as the problems inherent to the
		  transition of a multi-programs system. We discuss these
		  issues in details using examples. Implications on future
		  work in the area are suggested.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@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.calliss:application,
  author	= {Suzanne W. Dietrich and Frank W. Calliss},
  title		= {The Application of Deductive Databases to Inter-Module
		  Code Analysis},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {120-128},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Inter-module code analysis is a process by which a
		  programmer can alalyse a program consisting of a collection
		  of interconnected modules. A deductive database is
		  presented that records the information needed for
		  inter-module code analysis. The application of a deductive
		  database to this domain utilises the rule capability for
		  data structuring and facilitates the declarative
		  specification of recursive operations. This deductive
		  database was derived from a conceptual schema, which
		  describes the dependencies that exist in a program. A
		  method for mapping a conceptual schema to a deductive
		  database framework is outlined. An example query is used to
		  show how this database can be used for inter-module code
		  analysis. },
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Use_of_data_bases}
}

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

@Article{	  dillon:visual,
  key		= {Dillon, 1993},
  author	= {Laura K. Dillon},
  title		= {A Visual Execution Model for Ada Tasking},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1993},
  volume	= {2},
  number	= {4},
  pages		= {311-345},
  month		= oct,
  abstract	= {A visual execution model for Ada tasking can help
		  programmers attain a deeper understanding of the tasking
		  semantics. It can illustrate subtleties in semantic
		  definitions that are not apparent in natural language
		  descriptions of Ada tasking, as well as the consequences of
		  choices made in the language design. We describe a contour
		  model of Ada tasking that depicts asynchronous tasks
		  (threads of control), relationships between the
		  environments in which tasks execute, and the manner in
		  which tasks interact. The use of this high-level execution
		  model makes it possible to see what happens during
		  execution of a program. The paper provides an introduction
		  to the contour model of Ada tasking and demonstrates its
		  use.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@Article{	  ding.mateti:framework,
  author	= {Chen Ding and Prabhaker Mateti},
  title		= {A Framework for the Automated Drawing of Data Structure
		  Diagrams},
  journal	= {IEEE Transactions on Software Engineering},
  year		= {1990},
  volume	= {16},
  number	= {5},
  pages		= {543-557},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_for_Program_Understanding_and_Debugging}
}

@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{	  dunn.knight:automating,
  author	= {M. F. Dunn and J. C. Knight},
  title		= {Automating the detection of reusable parts in existing
		  software},
  pages		= {381--390},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  class		= {Software_Reverse_Engineering, Re-Use}
}

@Article{	  duri.buy.ea:application,
  key		= {Duri et al., 1994},
  author	= {S. Duri and U. Buy and R. Devarapalli and S. M. Shatz},
  title		= {Application and Experimental Evaluation of State Space
		  Reduction Methods for Deadlock Analysis in Ada},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1994},
  volume	= {3},
  number	= {4},
  pages		= {340-380},
  month		= oct,
  abstract	= {An emerging challenge for software engineering is the
		  development of methods and tools to aid design and analysis
		  of concurrent and distributed software. Over the past few
		  years, a number of analysis methods that focus on Ada
		  tasking have been developed. Many of these methods are
		  based on some form of reachability analysis, which has the
		  advantage of being conceptually simple, but the
		  disadvantage of being computationally expensive. We explore
		  the effectiveness of various Petri net-based techniques for
		  the automated deadlock analysis of Ada programs. Our
		  experiments consider a variety of state space reduction
		  methods both individually and in various combinations. The
		  experiments are applied to a number of classical concurrent
		  programs as well as a set of ''real-world''-programs. The
		  results indicate that Petri net reduction and reduced state
		  space generation are mutually beneficial techniques, and
		  that combined approaches based on Petri net models are
		  quite effective, compared to alternative analysis
		  approaches.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code}
}

@InProceedings{	  edwards.munro:abstracting,
  author	= {Helen M. Edwards and Malcolm Munro},
  title		= {Abstracting the Logical Processing Life Cycle for Entities
		  Using the RECAST method},
  pages		= {162--171},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The Reverse Engineering into CASE Technology method
		  (RECAST) takes the source code for an existing COBOL system
		  and derives a no-loss representation of the system
		  documented in a Structured System Analysis and Design
		  Method (SSADM) format. One key element of the method is the
		  abstraction of logical processing that affects the
		  individual entities of the system. For each entity this
		  processing is extracted from the physical implementation of
		  the system using a program slicing technique and is then
		  transformed into a logical representation (as an Entity
		  Life History) using a set of translation and transformation
		  rules. This paper describes how the abstraction is achieved
		  and illustrates it with an example that was derived from an
		  existing operational system that has been used as a case
		  study for the method.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Model_Generating}
}

@InProceedings{	  edwards.munro:recast,
  author	= {H. M. Edwards and M. Munro},
  title		= {{RECAST}: reverse engineering from {COBOL} to {SSADM}
		  specification},
  pages		= {499--508},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {The Reverse Engineering into CASE Techology (RECAST) takes
		  the source code for an existing COBOL system and derives a
		  no-loss representation of the system documented in an
		  Structured Systems Analysis and Design Method (SSADM)
		  format. This representation of the system is derived
		  through the use of a series of transformations. This paper
		  describes the environment within which RECAST has been
		  developed, outlines the stages and steps of the RECAST
		  method and discusses the use of software support tools. An
		  overview is given of a case study that has been carried out
		  for a live system.},
  class		= {Software_Reverse_Engineering, Reverse_Specification, Model
		  Generating}
}

@InProceedings{	  edwards.munro:recast*1,
  author	= {H. Edwards and M. Munro},
  title		= {{RECAST}: reverse engineering from {COBOL} to {SSADM}
		  specifications},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {44--53},
  year		= {1993},
  note		= { Describes methodology and tooling for the extraction of
		  SSADM diagrams from COBOL programs},
  class		= {Software_Reverse_Engineering, Reverse_Specification, Model
		  Generating}
}

@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{	  fischer.henninger.ea:cognitive,
  author	= {G. Fischer and S. Henninger and D. Redmiles},
  title		= {Cognitive Tools for Locating and Comprehending Software
		  Objects for Reuse},
  booktitle	= {Proceedings of the 13th  International Conference on
		  Software Engineering },
  pages		= {318--328},
  month		= may,
  year		= {1991},
  abstract	= {The authors describe a conceptual framework to facilitate
		  software reuse. It is shown that high functionality
		  computer systems by themselves do not provide sufficient
		  support for software reuse. Two systems that support this
		  framework, CODEFINDER and EXPLAINER, are presented.
		  CODEFINDER addresses issues on information access for
		  software reuse. Support for comprehending software objects
		  is demonstrated with EXPLAINER. A scenario describing how
		  the two systems are used in a reuse situation is presented.
		  The authors show how these systems fit into the bigger
		  pictures of software development environments, address
		  limitations of the systems, and discuss future
		  directions.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@Article{	  fischer.lemke.ea:from,
  author	= {Gerhard Fischer and Andreas C. Lemke and Christian
		  Rathke},
  title		= {From Design to Redesign},
  journal	= {ACM},
  year		= {1987},
  pages		= {369-376},
  inhalt	= {Beispiel für Wiederverwendung eines objekt-orientierten
		  wissensbasierten Benutzerschnittstellenbaukasten.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

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

@Article{	  freeman.layzell:meta-model,
  title		= {A Meta-Model of Information Systems to Support Reverse
		  Engineering },
  author	= {M.J. Freeman and P.J. Layzell},
  journal	= {Information and Software Technology},
  volume	= {36},
  number	= {5},
  pages		= {283--294},
  year		= {1994},
  note		= { A method is discussed to help software maintainers to
		  gain a richer understanding of a software system and its
		  components. This is achieved by enhancing traditional
		  reverse-engineering tools and prevents the loss of
		  knowledge during forward engineering},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_in_General}
}

@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.klosch:capsule,
  author	= {Harald Gall and Ren\'e Kl\"osch},
  title		= {Capsule Oriented Reverse Engineering for Software Reuse},
  pages		= {418-433},
  booktitle	= {Proceedings of the European Conference on Software
		  Engineering 1993},
  year		= {1993},
  abstract	= {Much research effort concerning the reuse of software
		  components has been invested on questions such as
		  classification, attribution and organization of modules in
		  software components and their interconnection to form new
		  software systems have been discovered. Reverse engineering
		  can be used for different purposes, like maintenance effort
		  reduction, documentation improvement, etc., but also for
		  software reuse. In the process of software reuse, reverse
		  engineering can be used to extract reusable components from
		  existing software systems.
		  
		  In this paper the authors provide insigths into a reverse
		  engineering method called capsule oriented reverse
		  engineering method (COREM) that realizes the extraction of
		  object similar capsules from existing systems implemented
		  in a procedural language. For this, COREM transforms the
		  original procedural system to an object based system
		  (consisting of capsules). These capsules can then be used
		  for further object-oriented system development. By using
		  object-oriented system development methods the problem of
		  module interconnection can be skillfully solved.
		  
		  The paper points out the three main steps of the COREM
		  process and describes the framework of COREM for the
		  production of software from capsules.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

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

@TechReport{	  genler.ciupke:toolgestutzte,
  author	= {Thomas Gen{\ss}ler and Oliver Ciupke},
  title		= {Toolgest{\"u}tzte {C}odeanalyse von
		  {T}elekommunikationssoftware\ in {C}hill},
  institution	= {Forschungszentrum Informatik},
  year		= {1997},
  type		= {Systemdokumentation und {P}rojektbericht},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Information_Visualization_and_Visualization_of_Large_Systems}
		  
}

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

@Article{	  glasier:research,
  author	= {Phil Glasier},
  title		= {A Research Project: Developing a Technique for Extracting
		  Business Rules from Procedural Code},
  journal	= {Reverse Engineering Newsletter},
  pages		= {Rev-5},
  class		= {Software_Reverse_Engineering, Extracting_Business_Rules}
}

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

@TechReport{	  gu.eisenhauer.ea:falcon,
  author	= {Gu, Weiming and Eisenhauer, Greg and Kraemer, Eileen and
		  Schwan, Karsten and Stasko, John T. and Vetter, Jeffrey and
		  Mallavarupu, Nirupama},
  title		= {Falcon: On-line Monitoring and Steering of Large-Scale
		  Parallel Programs},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1994},
  type		= {Technical Report},
  number	= {GIT-CC-94-21},
  month		= apr,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@InProceedings{	  gu.eisenhauer.ea:falcon*1,
  author	= {Gu, Weiming and Eisenhauer, Greg and Kraemer, Eileen and
		  Schwan, Karsten and Stasko, John T. and Vetter, Jeffrey and
		  Mallavarupu, Nirupama},
  title		= {Falcon: On-line Monitoring and Steering of Large-Scale
		  Parallel Programs},
  booktitle	= {Proceedings of the 5th Symposium of the Frontiers of
		  Massively Parallel Computing, McLean, VA,},
  year		= {1995},
  pages		= {422-429},
  month		= feb,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

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

@Article{	  hall:overview,
  author	= {P.A.V. Hall},
  title		= {Overview of Reverse Engineering and Reuse Research},
  journal	= {Information and Software Technology},
  volume	= {34},
  number	= {4},
  month		= {April},
  pages		= {239--249},
  year		= {1992},
  note		= { It is argued in this paper that reuse of steps taken in
		  forward engineering---such as ideas, prototypes, temporary
		  solutions, etc---should be stored somehow so that new
		  systems do not need to be developed from scratch. This is
		  indeed useful when a system that is developed while saving
		  such information needs reverse engineering but for legacy
		  systems this is too late},
  class		= {Software_Reverse_Engineering, Preventive_Measures}
}

@Article{	  hanks:rosade,
  author	= {Aaron Hanks},
  title		= {ROSADE: A Methodology for the Extraction of Business
		  Rules},
  journal	= {Reverse Engineering Newsletter},
  pages		= {Rev-5 -- Rev-6},
  class		= {Software_Reverse_Engineering, Extracting_Business_Rules}
}

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

@InProceedings{	  harband:seela,
  author	= {Joel Harband},
  title		= {SEELA: Maintenance and Documenting by
		  Reverse-Engineering},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {146},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {An interactive, reverse-engineering tool, SEELA supports
		  the maintenance and documentation of structured programs.
		  It features a top-down program display that increases the
		  readability of structured programs and includes a structure
		  editor, browser, pretty printer, and source code document
		  generator. SEELA works with Ada, Cobol, C. Pascal, PL/M and
		  Fortran Code. SEELA was designed to bridge the gap between
		  the project's design description and the source code.
		  Instead of requiring a separate program-design-language
		  (PDL) description, it analyzes the source code and projects
		  it on the screen so it appears as a readable PDL code.},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools, SEELA}
}

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

@InProceedings{	  harrold.malloy:unified,
  author	= {Mary Jean Harrold and Brian A. Malloy},
  title		= {A Unified Interprocedural Program Representation for a
		  Maintenance Environment},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {138-147},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Modifying and then validating a program with many
		  interacting modules, such as procedures, is an expensive
		  and complesx task. Thus, a maintenance environment
		  containing an efficient program representation and tools
		  that access that representation to assist the user in
		  understanding, modifying, analyzing, testing and debugging
		  a program is needed, This paper presents the authors'
		  unified interprocedural graph, UIG, that combines the
		  features of existing program representations to permit
		  access to information for maintenance tasks. The main
		  benefit of this approach is the reduction in storage space
		  for the individual representations since redundant
		  information is eliminated. Another important benefits is
		  the savings in access time to the various graphs since all
		  algorithms access the UIG. A single program representation
		  also assists in program understanding since relationships
		  among program elements are incorporated inte one graph.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs}
}

@Article{	  harrold.malloy:unified*1,
  key		= {Harrold \&{} Malloy},
  author	= {M. J. Harrold and Brian A. Malloy},
  title		= {A Unified Interprocedural Program Representation for a
		  Maintenance Environment},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {584--593},
  volume	= {19},
  number	= {6},
  month		= jun,
  year		= {1993},
  location	= {CMU E \&{} S Library},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs}
}

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

@InProceedings{	  hildreth:reverse,
  author	= {Holly Hildreth},
  title		= {Reverse Engineering Requirements for Process-Control
		  Software},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  pages		= {316-325},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {A method of reverse engineering requirements for
		  process-control system software is presented along with a
		  domain-specific functional structure. Techniques are
		  demonstrated on the executable pseudocode of a commercial
		  avionics control syhstem. Resulting requirements are
		  expressed as a state-based model of externally visible
		  behavior specified completely in the language of
		  process-control.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@TechReport{	  holdbrook.tebaut:survey,
  author	= {H. B. Holdbrook and S. M. Tebaut},
  title		= {A Survey of Software Maintenance Tools that Enhance
		  Program Understanding},
  institution	= {Software Engineering Research Center, University of
		  Florida/ Purdue University},
  year		= {1987},
  number	= {SERC-TR-9-F},
  class		= {Reengineering_Tools, Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools,
		  Reengineering_in_General, Fundamentals}
}

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

@InProceedings{	  howden.pak:problem*1,
  title		= {Problem domain, structural and logical abstractions in
		  reverse engineering},
  author	= {W. Howden and S. Pak},
  pages		= {214--224},
  booktitle	= {\cite{SM92}},
  year		= {1992},
  note		= { Introduces a formal notation for documenting various
		  aspects of existing software. Has been applied, manually,
		  to sample COBOL programs},
  class		= {Software_Reverse_Engineering}
}

@InProceedings{	  hudson.stasko:animation,
  author	= {Hudson, Scott E. and Stasko, John T.},
  title		= {Animation Support in a User Interface Toolkit: Flexible,
		  Robust and Reusable Abstractions},
  booktitle	= {Proceedings of the 1993 ACM Symposium on User Interface
		  Software and Technology, Atlanta, GA},
  year		= {1993},
  pages		= {57-67},
  organization	= {ACM},
  month		= nov,
  abstract	= {Animation can be a very effective mechanism to convey
		  information in visualization and user interface settings.
		  However, integrating animated presentations into user
		  interfaces has typically been a difficult task since, to
		  date, there has been little or no explicit support for
		  animation in window systems or user interface toolkits.
		  This paper describes how the Artkit user interface toolkit
		  has been extended with new animation support abstractions
		  designed to overcome this problem. These abstractions
		  provide a powerful but convenient base for building a range
		  of animations, supporting techniques such as simple
		  motion-blur, "squash and stretch", use of arcing
		  trajectories, anticipation and follow through, and "slow-in
		  / slow-out" transitions. Because these abstractions are
		  provided by the toolkit they are reusable and may be freely
		  mixed with more conventional user interface techniques. In
		  addition, the Artkit implementation of these abstractions
		  is robust in the face of systems (such as the X Window
		  System and Unix) which can be ill-behaved with respect to
		  timing considerations.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Animation_in_User_Interfaces}
}

@TechReport{	  hudson.stasko:animation*1,
  author	= {Hudson, Scott E. and Stasko, John T.},
  title		= {Animation Support in a User Interface Toolkit: Flexible,
		  Robust and Reusable Abstractions},
  institution	= {Graphics, Visualization, and Usability Center, Georgia
		  Institute of Technology},
  year		= {1993},
  type		= {Technical Report},
  number	= {GIT-GVU-93-17},
  address	= {Atlanta, GA},
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  http		= {http://www.cc.gatech.edu/gvu/softviz/uianim/uianim.html},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Animation_in_User_Interfaces}
}

@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{	  ibba.natale:structure-based,
  author	= {R. Ibba and D. Natale},
  title		= {Structure-based Clustering of Components for Software
		  Reuse},
  pages		= {210-215},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The characterization of the code reuse practices in
		  existing production environments provides fundamental data
		  and lessons for the establishment of improvement of
		  effective reuse-oriented policies, and for the adoption of
		  up-to-date technologies supporting them. This report
		  describes the method and results of an experience of
		  metrice-aided clustering of software components, aiming at
		  detecting and characterizing implicit reuse of code and
		  reuse potential in a large-scale data processing
		  environment. Similar functionalities may be in fact
		  replicated many times, customizing an existing source code
		  component, but this phenomenon may be only partially
		  apparent in form of explicit reuse. A set of software
		  metrics has been used to create clusters of existing
		  components whose internal structures appear very similar;
		  the functional similarity check were performed involving
		  human experts. This was done in the context of a large
		  reuse project, where quantitative software quality
		  indicators are also combined to the feedback collected in
		  pilot groups who know the applications from which the
		  candidate components were extracted. The potential and
		  limitations of metric support in this field are considered
		  in the discussion of the results obtained up to now.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  iscoe.williams.ea:domain,
  author	= {Neil Iscoe and Gerald B. Williams and Guillermo Arango},
  title		= {Domain Modeling for Software Engineering},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {340-343},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Writing an application program requires an understanding
		  of both programming knowledge and application domain
		  knowledge. Programming knowledge is relatively well
		  understood. It is formal, modeled in a variety of ways,
		  explicit enough to be taught to novices, and general enough
		  to apply across many domains. Domain knowledge - although
		  it clearly exists in the minds of domain experts - it is
		  not so well understood. It is usually: 1) informal rather
		  than formal 2) implicit rather than explicit 3) ad hoc
		  instead of general purpose 4) modeled only incompletely and
		  indirectly in terms of problem-specific languages.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

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

@PhDThesis{	  jahnke:managing,
  author	= {Jens-Holger Jahnke},
  title		= {Managing Uncertainty and Inconsistency in Database
		  Reengineering Processes},
  school	= {University of Paderborn, Department of Mathematics and
		  Computer Science},
  year		= {1999},
  address	= {33095 Paderborn, Germany},
  month		= {August},
  abstract	= {This dissertation tackles one of the most urgent problems
		  in today's information technology, namely the renovation
		  and migration of legacy information systems to modern
		  platforms and net-centric architectures. In this context,
		  several methods, tools, and processes have been proposed to
		  support reengineering and modernizations of legacy database
		  applications. This can be a complex task because many
		  legacy databases have grown over several generations of
		  programmers and lack a sufficient documentation.
		  Computer-aided reengineering methods and processes have a
		  great potential to reduce the complexity and risks involved
		  in database design recovery and migration projects. Still,
		  current reengineering tools are hardly adopted for
		  practical problems in industry because they often make
		  idealistic assumptions about the structure of legacy
		  systems and the characteristics of reengineering processes.
		  The goal of this thesis is to provide concepts and
		  techniques to overcome these severe limitations. In
		  particular, our focus is on developing mechanisms to manage
		  uncertainty and inconsistency in computer-aided databases
		  reengineering processes. In practice, uncertain knowledge
		  plays an important role in activities aiming to recover
		  conceptual design documents for large idiosyncratic
		  implementation structures. This fact is neglected in
		  current database reengineering methods and tools. In this
		  dissertation, we identify and extend a theory that provides
		  a suitable basis to deal with uncertain reengineering
		  knowledge and allows to implement practical tools and
		  environments to support reengineering processes. The
		  requirement for consistency management considers the fact
		  that it is unrealistic to presume that database
		  reengineering processes can be executed in a number of
		  sequential phases or steps without iterations. In practice,
		  larger reengineering projects comprise many process
		  iterations due to various reasons like incomplete knowledge
		  about legacy implementation structures or necessary
		  "on-the-fly" modifications of the legacy system. Detecting
		  and removing inconsistencies caused by such iterations
		  significantly increase costs and durations of current
		  reengineering projects. In this thesis, we employ graph
		  transformation theory to develop mechanisms which allow to
		  detect and eliminate inconsistencies between legacy schema
		  implementations and their abstract representation,
		  automatically. Our results have been implemented in the
		  database reengineering environment Varlet and evaluated
		  with an industrial project. They are suitable to complement
		  many existing approaches in the domain of information
		  system reengineering and migration. As an example, we
		  describe the integration of Varlet with an existing
		  middleware product for data integration.},
  class		= {Using_graphs Database_Migration Re-Design
		  Data_Reverse_Engineering Alteration
		  Software_Reverse_Engineering
		  Intermediate_Representations_of_Source_Code },
  url		= {http://www.csr.uvic.ca/~jens/Docs/thesis.pdf}
}

@Article{	  jerding.stasko:information,
  author	= {Dean F. Jerding and John T. Stasko},
  title		= {The Information Mural: A Technique for Displaying and
		  Navigating Large Information Spaces},
  journal	= {Proceedings of the IEEE Symposium on Information
		  Visualization},
  year		= {1995},
  month		= nov,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Visualizing_Object-Oriented_Programs,
		  Information_Visualization_and_Visualization_of_Large_Systems}
		  
}

@TechReport{	  jerding.stasko:using,
  author	= {Jerding, Dean F. and Stasko, John T.},
  title		= {Using Visualization to Foster Object-Oriented Program
		  Understanding},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1994},
  type		= {Technical Report},
  number	= {GIT-GVU-94-33},
  month		= jul,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_for_Program_Understanding_and_Debugging,
		  Visualizing_Object-Oriented_Programs}
}

@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{	  karakostas:use,
  author	= {V. Karakostas},
  title		= {The Use of Application Domain Knowledge for Effective
		  Software Maintenance},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {170-176},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {In a way similar to activities like specification and
		  design effective maintenance of software requires an
		  understanding of the application domain. Our approach is
		  based on the assumption that a model which links the
		  concepts of the application domain to their implementations
		  will assist in tracing the changing user requirements in
		  the software system and in identifying what is to be
		  changed and why, what needs to be carried out in order to
		  implement the change and how the existing system will be
		  affected as a result. This paper discusses the application
		  of the approach to the maintenance of an object-oriented
		  programming environment.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@InProceedings{	  kazman.bass.ea:saam,
  author	= {R. Kazman and L. Bass and G. Abowd and M. Webb},
  title		= {{SAAM}: {A} method for analyzing the properties of
		  software architectures},
  pages		= {81--90},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  class		= {Software_Reverse_Engineering,
		  Recovery_of_Software_Architecture}
}

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

@InProceedings{	  ketabchi:object-oriented,
  author	= {M. A. Ketabchi},
  title		= {An Object-Oriented Integrated Software Analysis and
		  Maintenance},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {60-62},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Software systems like most engineering artifacts are
		  assemblies which have multiple aspects such as structure
		  and funtionality. An integrated software analysis and
		  maintenance system should provide functionalities to
		  define, analyze, manipulate, and maintain descriptions of
		  different software aspects and components and relationships
		  among them.
		  
		  The authors have developed a multiuser integrated software
		  analysis and maintenance system called SAMS on top of an
		  object-oriented DBMS. SAMS models the description of the
		  various aspects of software systems by persistent object
		  types and implements different software tools by operations
		  of objects. Software systems which are maintained using
		  SAMS are represented by objects instances.
		  
		  SAMS tightly integrates various software analysis and
		  maintenance functions such as cross referencing,
		  annotating, and configuration management around an
		  automatically generated object-oriented software database
		  system. Its high-level user interface delivers various
		  analysis and maintenance functions to end-users, without
		  exposing its internals and implementation characteristitcs.
		  Its tool set allows existing software to be loaded into the
		  database automaticaly. SAMS' database schema contains
		  approximately 400 classes with thousands of attributes and
		  methods.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Use_of_data_bases}
}

@Article{	  khajenoori.linton.ea:enhancing,
  title		= {Enhancing Software Reusability Through Effective Use of
		  the Essential Modelling Approach},
  author	= {S. Khajenoori and D.G. Linton and C.A. Morris},
  journal	= {Information and Software Technology},
  volume	= {36},
  number	= {8},
  pages		= {495--501},
  year		= {1994},
  note		= { It is advocated to develop new software systems by
		  reusing design components from existing ones. With the aid
		  of the so-called essential modelling approach it is
		  possible to determine reusable components},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@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{	  kinloch.munro:understanding,
  key		= {Kinloch \& Munro, 1994},
  author	= {David A. Kinloch and Malcolm Munro},
  title		= {Understanding C Programs Using the Combined C Graph
		  Representation},
  pages		= {172-180},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The process of program comprehension is often aided by the
		  use of static analysis tools to provide a maintainer with
		  different views of the code. Each view however often
		  requires a different intermediate program representation,
		  leading to redundancies and repetition of information. A
		  solution is to develop a single intermediate representation
		  which contains sufficient information to construct each
		  program view.
		  
		  This paper describes the Combined C Graph (CCG), a
		  fine-grained intermediate representation for programs
		  written in the C language from which program slices, call
		  graph, flow-sensitive data flow, definition-use and control
		  dependence views can be easily constructed. The CCG allows
		  the representation of embedded side effects and control
		  flows and value-returning functions with value parameters.
		  The effect of pointer parameters are also modelled.
		  Construction of the CCG makes use of the PERPLEX C analysis
		  tool which produces a generic Prolog fact base
		  representation of the source code. Existing data flow
		  analysis techniques are extended to allow the computation
		  of flow-sensitive data flow analysis information.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs}
}

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

@InProceedings{	  koschke.plodereder:ansatze,
  author	= {Rainer Koschke and Erhard Pl\"odereder},
  title		= {Ans\"atze des Programmverstehens},
  booktitle	= {Softwarewartung und Reengineering},
  editor	= {Franz Lehner},
  publisher	= {Gabler Edition Wissenschaft, Deutscher
		  Universit\"atsverlag},
  pages		= {159-176},
  year		= {1996},
  abstract	= {Program understanding is the process to aquire knowledge
		  on a computer program. It is a supposition for debugging,
		  enhancement, re-use, and documentation. There are a few
		  approaches that support automatic program understanding.
		  Current approaches can be classified in basic and
		  knowledge-based analyses. Basic analyses do not rely on the
		  application domain and any programming knowledge. They are
		  only based on programming language syntax and semantic.
		  Basic analyses can be distinguished into basic static and
		  basic dynamic analyses, depending on whether the
		  information is gained at compile time or runtime.
		  Knowledge-based analyses dispose of application domain
		  knowledge and programming knowledge. They can be further
		  classified in parsing approaches, if they only fall back
		  upon formal and structural program properties, and informal
		  reasoning, if they use additionally informal knowledge.
		  This paper explains the taxonomy with examples.},
  note		= {The language of this article is German},
  ftp		= {ftp.informatik.uni-stuttgart.de//ifi/ps/people/koschke/papers/regensburg96.ps.gz}
		  ,
  class		= {Software_Reverse_Engineering,
		  General_Information_on_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}
}

@InProceedings{	  kozaczynski:catch-22,
  author	= {Wojtek Kozaczynski},
  title		= {The {'Catch 22'} of Reengineering},
  booktitle	= {Proceedings of the 12th  International Conference on
		  Software Engineering },
  pages		= {119},
  month		= mar,
  year		= {1990},
  abstract	= {In the software reengineering discussion it is assumed
		  that the system can be understood on the following four
		  levels: the programming language level, the control
		  structure level, the generic algorithm level, and the
		  problem domain level. It is noted that it is now possible
		  to build tools which understand systems on the first three
		  levels. There have been considerable advances in system
		  data analysis that will lead directly to identification of
		  abstract data types and objects. It is suggested that
		  future progress will critically depend on the ability to
		  represent and reason about the problem domain. The
		  reengineering systems of tomorrow will require knowledge
		  not only of software engineering, but more important, of
		  particular problem domains.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@Article{	  kozaczynski:suzuki,
  author	= {Wojtek Kozaczynski},
  title		= {A Suzuki Class in Software Reengineering},
  journal	= {IEEE Software},
  year		= {1991},
  volume	= {8},
  number	= {1},
  pages		= {97-98},
  month		= jan,
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  kraemer.stasko:issues,
  author	= {Eileen Kraemer and John T. Stasko},
  title		= {Issues in Visualization for the Comprehension of Parallel
		  Programs},
  booktitle	= {Third Workshop on Program Comprehension},
  publisher	= {IEEE Computer Society Press},
  address	= {Washington, D.C.},
  month		= nov,
  year		= {1994},
  pages		= {116-127},
  abstract	= {Parallel and distributed computers are becoming more
		  widely used. Thus, the comprehension of parallel programs
		  is more challenging than understanding serial programs
		  because of the issues of concurrency, scale,
		  communications, shared ressources, and shared state. In
		  this article, we argue that the use of visualization and
		  animations of programs can be an invaluable asset to
		  program comprehension. We present example problems and
		  visualizations, showing how graphical displays can assist
		  program understanding. We also describe the Animation
		  Choreographer, a tool that helps programmers better
		  comprehend the temporal characteristics of their
		  programs.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/vis.parallel.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@InProceedings{	  kraemer.stasko:toward,
  author	= {Kraemer, Eileen and Stasko, John T.},
  title		= {Toward Flexible Control of the Temporal Mapping from
		  Concurrent Program Events to Animations},
  booktitle	= {Proceedings of the 8th International Parallel Processing
		  Symposium (IPPS '94), Cancun, Mexico},
  year		= {1994},
  pages		= {902-908},
  month		= apr,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@Article{	  kraemer.stasko:visualization,
  author	= {Kraemer, Eileen and Stasko, John T.},
  title		= {The Visualization of Parallel Systems: An Overview},
  journal	= {Journal of Parallel and Distributed Computing},
  year		= {1993},
  volume	= {18},
  number	= {2},
  pages		= {105-117},
  month		= jun,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@InProceedings{	  krikhaar:reverse,
  author	= {R.L. Krikhaar},
  title		= {Reverse Architecting Approach for Complex Systems},
  booktitle	= {Proceedings of the IEEE International Conference on
		  Software Maintenance},
  publisher	= {IEEE Computer Society},
  year		= {1997},
  pages		= {p4-11},
  abstract	= {Philips is an electronics company which operates world
		  wide and participates in professional as well as consumer
		  markets. The architecture of many software intensive
		  systems are currently not optimally prepared for the
		  changing market. For example the variety of systems is
		  increasing because different users or user groups demand
		  slightly different variants of a system. Good understanding
		  of systems is required to be able to follow these changes.
		  During the last years we have analysed a number of systems
		  from which we have derived a general approach for reverse
		  architecting (RA). Our approach has proved to be applicable
		  for various complex systems in different domains. It
		  consists of a number RA steps. In this paper we describe
		  three RA steps and indicate some aspects of other RA steps.
		  The description is supplemented with three case studies of
		  complex systems. The complete set of RA steps is not fully
		  independent however it is not necessary to perform all RA
		  steps for each case. },
  keywords	= {Architecture improvement reverse architecting complex
		  software software architecture reverse engineering module
		  architecture },
  class		= {Software_Evolution Software_Reverse_Engineering }
}

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

@InProceedings{	  lano.haughton:integrating,
  author	= {K. Lano and H. Haughton},
  title		= {Integrating formal and structured methods in reverse
		  engineering},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {17--26},
  year		= {1993},
  note		= { Describes the integration of formal (Z++) and structured
		  (SSADM) methods in reverse engineering as prototyped in the
		  REDO project},
  class		= {Software_Reverse_Engineering, Formal_Methods}
}

@Book{		  lano.haughton:reverse,
  author	= {K. Lano and H. Haughton},
  title		= {Reverse Engineering and Software Maintenance --- A
		  Practical Approach},
  publisher	= {McGraw-Hill},
  year		= {1994},
  note		= { This book describes a fundamental approach to reverse
		  engineering and software maintenance. After an introduction
		  in software maintenance and reverse engineering a number of
		  tools and approaches are discussed to tackle various
		  problems in these areas. An elaborate introduction in logic
		  and program semantics is given. One method (the process
		  model) to address maintenance and reverse engineering is
		  discussed in more detail. The book concludes with a number
		  of case-studies which use a formal approach based on logic
		  and program semantics},
  class		= {Software_Reverse_Engineering,
		  General_Information_on_Software_Reverse_Engineering,
		  Formal_Methods}
}

@TechReport{	  lawrence.badre.ea:empirically,
  author	= {Lawrence, Andrea and Badre, Albert and Stasko, John T.},
  title		= {Empirically Evaluating the Use of Animations to Teach
		  Algorithms},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1994},
  type		= {Technical Report},
  number	= {GIT-GVU-94-07},
  month		= mar,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  http		= {http://www.cc.gatech.edu/gvu/softviz/algoanim/algoanim.html}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Algorithm_Animation,
		  Empirical_Studies_of_Software_Visualization}
}

@InProceedings{	  lawrence.badre.ea:empirically*1,
  author	= {Lawrence, Andrea and Badre, Albert and Stasko, John T.},
  title		= {Empirically Evaluating the Use of Animations to Teach
		  Algorithms},
  booktitle	= {Proceedings of the 1994 IEEE Symposium on Visual
		  Languages, St. Louis, MO},
  year		= {1994},
  pages		= {48-54},
  month		= oct,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Algorithm_Animation,
		  Empirical_Studies_of_Software_Visualization}
}

@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{	  lindig.snelting:assessing,
  author	= {C. Lindig and G. Snelting},
  title		= {Assessing modular structure of legacy code based on
		  mathematical concept analysis},
  booktitle	= {Proceedings of the 19th  International Conference on
		  Software Engineering },
  publisher	= {IEEE Computer Society Press},
  year		= {1997},
  key		= {Concept Analysis},
  class		= {Software_Reverse_Engineering,
		  Recovery_of_Software_Architecture }
}

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

@InProceedings{	  liu.chen.ea:design,
  author	= {Xiaodong Liu and Zhiqiang Chen and Hongji Yang and Hussein
		  Zedan and William. C. Chu},
  title		= {A Design Framework for System Re-engineering},
  booktitle	= {Proceedings of Joint Asia Pacific Software Engineering
		  Conference and International Computer Science Conference},
  publisher	= {IEEE Computer Society},
  year		= {1997},
  address	= {Hong Kong},
  month		= {December},
  abstract	= { We discuss the current situation of formal methods and
		  their use in the re-engineering of computing systems,
		  especially real time systems. Based on the analysis result,
		  a solution which uses a consistent 4-sector Wide Spectrum
		  Language (WSL) is proposed, which presently includes the
		  general architecture and work flow, the structure of
		  Object-Action Model, the syntax and semantics of ObTAM
		  (Object Oriented Temporal Agent Model) and TGCL (Timed
		  Guarded Command Language). A small case study shows an
		  optimistic future of our WSL technique. Further research
		  will aim to build the complete semantic kernel of the WSL
		  and its associated algebraic laws, including transformation
		  rules and abstraction rules. },
  keywords	= {formal methods, re-engineering, wide spectrum language,
		  real-time systems, object orientation, Interval Temporal
		  Logic},
  class		= {Reengineering_in_General Requirement_Tracability
		  Software_Reverse_Engineering Reverse_Specification
		  Process_Models }
}

@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{	  liu.wilde:identifying,
  author	= {S. Liu and N. Wilde},
  title		= {Identifying Objects in a Conventional Procedural Language:
		  an Example of Data Design Recovery},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {266-271},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {While object-oriented methodologies for software design
		  and development have only been clearly enunciated in the
		  last few years, many object-like features such as data
		  grouping, abstract data types and inheritance have been in
		  use for some time. In maintaining an existing program
		  containing such features it would be very useful to have an
		  understanding of the ''objects'' the original designer had
		  in mind. This paper proposes methodologies to aid in the
		  design recovery of object-like features of a program
		  written in a non object oriented language.
		  
		  Two complementary methods are proposed, based on an
		  analysis of global data or of data types. An interactive
		  tool is proposed that would combine the two methods while
		  using human input to guide the object identification
		  process. A prototype of such a tool is currently being
		  developed.},
  class		= {Software_Reverse_Engineering, Re-Use,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@InProceedings{	  liu.yang.ea:formal,
  author	= {Xiaodong Liu and Hongji Yang and Hussein Zedan},
  title		= {Formal Methods For The Re-Engineering of Computing
		  Systems},
  booktitle	= {Proceedings of The 21st IEEE International Conference on
		  Computer Software and Application (COMPSAC'97)},
  publisher	= {IEEE Computer Society},
  year		= {1997},
  pages		= {409--414},
  address	= {Washington, D.C.},
  month		= {August},
  abstract	= { We present a short review of formal methods and their use
		  in the re-engineering of computing systems. The paper
		  considers five classes of formal notations and theories,
		  namely state/model-based, logic-based, algebraic-based,
		  process algebra and net-based formalisms together with
		  combined formalisms. },
  keywords	= {formal methods, re-engineering, wide spectrum language,
		  real-time systems, refinement, reverse engineering,
		  logic.},
  class		= {Software_Reverse_Engineering Formal_Methods }
}

@InProceedings{	  livadas.roy:program,
  author	= {Panos E. Livadas and Prabal K. Roy},
  title		= {Program Dependence Analysis},
  pages		= {356-365},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {It is generally recognized that one of the reasons that
		  software maintenance is so costly is that each modification
		  to a program must take into account the numerous complex
		  interrelationships in the existing software; an
		  understanding of program dependences is fundamental to
		  efficient software change. Such dependences can be of the
		  following types, data flow, calling, and functional
		  dependences. Furthermore, as the software community
		  gradually begins to move toward a more object-oriented
		  perspective on software development, it will become
		  increasingly important to be able to 'objectify' existing
		  software systems. Successful maintenance requires precise
		  knowledge of the data items in a system, the ways these
		  items are created and modified, and their relationships
		  between one another.
		  
		  In this paper the authors address these two issues. First,
		  they will discuss three methods of identifying objects the
		  first two of which were suggested by Liu and Wilde; the
		  third method is one that is proposed in this paper and is
		  based on the determination of the receiver of a procedure.
		  We believe that the latter method is one that is more
		  natural and precise than the former two. Second, algorithms
		  that perform precise interprocedural flow-sensitive
		  dependency analysis, as well as algorithms that identify
		  'objects', are introduced. Furthermore, the internal
		  program representation that we emply, the parse-tree-based
		  system dependence graph (SDG), is briefly discussed.
		  Finally, a unique tool that we have developed is presented
		  that accepts a subset of ANSI C (or Pascal) as input and
		  which implements all algorithms discussed in this paper.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Static_Analysis, Static_Data_Flow_Analysis,
		  Software_Reverse_Engineering, Re-Use}
}

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

@InProceedings{	  marburger.herzberg:e-cares,
  author	= {André Marburger and Dominikus Herzberg},
  title		= {E-CARES research project: Understanding complex legacy
		  telecommunication systems},
  booktitle	= {Proceedings of the 5th European Conference on Software
		  Maintenance},
  publisher	= {IEEE Computer Society Press},
  year		= {2001},
  editor	= {Pedro Sousa and J{\"u}rgen Ebert},
  pages		= {139-147},
  month		= {March},
  abstract	= {There are many reasons for reverse engineering or
		  re-engineering legacy systems. To date, many approaches
		  concerning re-engineering of legacy systems have been made.
		  The majority of these approaches are dealing with systems
		  in the field of business applications. This paper describes
		  the work performed for the E-CARES project so far. This
		  project is concerned with understanding and re-structuring
		  complex legacy telecommunication systems. In contrast to
		  business applications embedded systems, e.g.
		  telecommunication systems, have additional requirements
		  regarding fault tolerance, reliability, availability, and
		  response time. We found that these requirements have a
		  significant impact on the software part of an embedded
		  system. It has different characteristics concerning
		  structuring, inter-program communication, etc. Therefore,
		  an approach is presented that includes usage of "dynamic"
		  information, multi-level abstraction\slash visualization,
		  and user interaction to improve the understanding of
		  telecommunication systems. },
  keywords	= {reverse engineering, re-engineering, telecommunication
		  systems},
  class		= {Using_graph Intermediate_Representations_of_Source_Code
		  Software_Reverse_Engineering }
}

@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{	  mcginnes:case,
  title		= {{CASE} support for collaborative modelling: re-engineering
		  conceptual modelling techniques to exploit the potential of
		  {CASE} tools},
  author	= {S. McGinnes},
  journal	= {Software Engineering Journal},
  pages		= {183--189},
  volume	= {9},
  number	= {4},
  year		= {1994},
  note		= { It is advocated that more benefit would be obtained if
		  both analysis and design techniques were reengineered so as
		  to make the best possible use of CASE tools. Ways on how to
		  achieve this are given in the paper using examples from a
		  prototype CASE tool},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools}
}

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

@Article{	  mii.takeshita:software,
  title		= {Software Re-engineering and Reuse from a {J}apanese Point
		  of View},
  author	= {N. Mii and T. Takeshita},
  journal	= {Information and Software Technology},
  volume	= {35},
  number	= {1},
  pages		= {45--53},
  year		= {1993},
  note		= { The use of the concept of reusable pieces of software as
		  parts in the Japanese situation is reviewed. It is more
		  geared towards preventive forward engineering than to
		  reverse engineering.},
  class		= {Software_Reverse_Engineering, Preventive_Measures}
}

@InProceedings{	  mili.mili.ea:storing,
  author	= {A. Mili and R. Mili and R. Mittermeir},
  title		= {Storing and retrieving software components: {A}
		  refinement-based system},
  pages		= {91--102},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Use_of_data_bases}
}

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

@InProceedings{	  mukherjea.stasko:applying,
  author	= {Sougata Mukherjea and John T. Stasko},
  title		= {Applying algorithm animation techniques for program
		  tracing, debugging, and understanding},
  pages		= {456--467},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {Algorithm animation which presents a dynamic visualization
		  of an algorithm or program, primarily has been used as a
		  teaching aid. The higly abstract, application-specific
		  nature of algorithm animation requires human design of the
		  animation views. We speculate that the application-specific
		  nature of algorithm animation views could be a valuable
		  debugging aid for software developers as well.
		  Unfortunately, if animation development requires
		  time-consuming design with a graphics package, it will not
		  be used for debugging, where timeliness is a necessity. We
		  have developed a system called Lens that allows programmers
		  to rapidly (in minutes) build algorithm animation-style
		  program views without requiring any sophisticated graphics
		  knowledge or coding. Lens is integrated with a system
		  debugger to promote iterative design and exploration.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_for_Program_Understanding_and_Debugging,
		  Algorithm_Animation}
}

@Article{	  mukherjea.stasko:toward,
  author	= {Mukherjea, Sougata and Stasko, John T.},
  title		= {Toward Visual Debugging: Integrating Algorithm Animation
		  Capabilities within a Source Level Debugger},
  journal	= {ACM Transactions on Computer-Human Interaction},
  year		= {1994},
  volume	= {1},
  number	= {3},
  pages		= {215-244},
  month		= sep,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_for_Program_Understanding_and_Debugging,
		  Algorithm_Animation}
}

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

@InBook{	  muller.orgun.ea:reverse*1,
  author	= {Hausi A. M\"uller and Mehmet A. Orgun and Scott R. Tilley
		  and James S. Uhl},
  title		= {A Reverse Engineering Approach To Subsystem Structure
		  Identification},
  publisher	= {John Wiley \& Sons},
  year		= {1993},
  class		= {Software_Reverse_Engineering_Tools, Rigi}
}

@InProceedings{	  muller.tilley.ea:reverse,
  key		= {M\"uller et. al, 1992},
  author	= {Hausi A. M\"uller and S.R. Tilley and M.A. Orgun and B.D.
		  Corrie and N.H. Madhavji},
  title		= {A Reverse Engineering Environment Based on Spatial and
		  Visual Software Interconnection Models},
  booktitle	= {SIGSOFT'92: Proceedings of the Fifth ACM SIGSOFT:
		  Symposium on Software Development Environment},
  year		= {1992},
  pages		= {88-98},
  month		= dec,
  abstract	= {Reverse Engineering is the process of extracting system
		  abstractions and design information out of existing
		  software systems. This information can then be used for
		  subsequent development, maintenance, re-rengineering, or
		  reuse purposes. This process involves the identification of
		  software artefacts in a particulary subject system, and the
		  aggregation of these artifacts to from more abstract system
		  representations. This paper describes a reverse engineering
		  environment which uses the spatial and visual information
		  inherent in graphical representations of software systems
		  to form the basis of a software interconnection model. This
		  information is displayed and manipulated by the reverse
		  engineer using an interactive graph editor to build
		  subsystem structures out of software building blocks. The
		  spatial component constitutes information about the
		  relative positions of the meaningful parts of a software
		  structure, whereas the visual component contains
		  information about how a software structure looks. The
		  coexistence of these two representations is critical to the
		  comprehensive appreciation of the generated data, and
		  greatly benefits subsequent analysis, processing, and
		  decision-making.},
  class		= {Software_Reverse_Engineering_Tools, Rigi}
}

@InProceedings{	  muller.tilley.ea:rigi,
  author	= {Hausi A. M\"uller and Scott R. Tilley and Kenny Wong and
		  Michael J. Whitney and Margaret-Ann D. Storey},
  title		= {Rigi - A System for Reverse Engineering},
  class		= {Software_Reverse_Engineering_Tools, Rigi}
}

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

@TechReport{	  muthukumarasamy.stasko:visualizing,
  author	= {Muthukumarasamy, Jeyakumar and Stasko, John T.},
  title		= {Visualizing Program Executions on Large Data Sets Using
		  Semantic Zooming},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1995},
  type		= {Technical Report},
  number	= {GIT-GVU-95-02},
  month		= jan,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  http		= {http://www.cc.gatech.edu/gvu/softviz/infoviz/infoviz.html}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs,
		  Algorithm_Animation,
		  Information_Visualization_and_Visualization_of_Large_Systems}
		  
}

@Article{	  myers:incense,
  author	= {Brad A. Myers},
  title		= {Incense: A System for Displaying Data Structures},
  journal	= {Computer Graphics},
  year		= {1983},
  volume	= {17},
  number	= {3},
  pages		= {115-125},
  month		= jul,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_for_Program_Understanding_and_Debugging}
}

@Misc{		  n:special,
  author	= {N.N.},
  key		= {Case Outlook},
  title		= {Special Issue on ''Case Tools for Reverse Engineering''},
  journal	= {Case Outlook},
  volume	= {2},
  number	= {2},
  pages		= {1-15},
  year		= {1988},
  class		= {Reengineering_Tools, Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools,
		  Reengineering_in_General, Fundamentals}
}

@InProceedings{	  nanduri.rugaber:requirements,
  author	= {Sastry Nanduri and Spencer Rugaber},
  title		= {Requirements Validation via Natural Language Parsing},
  booktitle	= {Proceedings of the 28th Hawaii International Conference on
		  System Sciences},
  address	= {Wailea, Maui, Hawaii},
  year		= {1995},
  month		= jan,
  abstract	= {Object Oriented Analysis (OOA) has become a popular method
		  for analyzing system requirements. Unfortunately however,
		  none of the current version of OOA have included a
		  validation technique tailored to the object oriented
		  approach. Most, instead, merely recommend document reviews
		  without specifying what kinds of problems to look for. This
		  paper explores the question by applying a natural language
		  parser to a requirement document, extracting candidate
		  objects, methods and associations, composing them into an
		  object model diagram, and then comparing the results to
		  those determined by manual OOA. To do this, we have adapted
		  an automated natural language parser and used it to examine
		  several high level specifications. The results indicate
		  that with a modest amount of effort, our technique can give
		  valuable feedback to the analyst.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/hicss.ps}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Natural_Language_Processing_in_Reverse_Specification}
}

@Article{	  nanduri.rugaber:requirements*1,
  author	= {Sastry Nanduri and Spencer Rugaber},
  title		= {Requirements Validation via Automated Natural Language
		  Parsing},
  journal	= {Journal of MIS},
  year		= {1995},
  month		= jan,
  note		= {UpDated version of Nanduri:95a submitted for publication},
  abstract	= {Object Oriented Analysis (OOA) has become a popular method
		  for analyzing system requirements. Unfortunately however,
		  none of the current versions of OOA have included a
		  validation technique tailored to the object oriented
		  approach. Most, instead, merely recommend document reviews
		  without specifying what kinds of problems to look for. This
		  paper explores the question by applying a natural language
		  parser to a requirement document, extracting candidate
		  objects, methods and associations, composing them into an
		  object model diagram, and then comparing the results to
		  those determined by manual OOA. To do this, we have adapted
		  an automated natural language parser and used it to examine
		  several high level specifications. The results indicate
		  that with a modest amount of effort, our technique can give
		  valuable feedback to the analyst.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/jmis.ps},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Natural_Language_Processing_in_Reverse_Specification}
}

@InProceedings{	  narat:using,
  author	= {V\'eronique Narat},
  title		= {Using a relational database for software maintenance: a
		  case study},
  pages		= {244-251},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {This paper describes an approach to storing source code
		  using a relational database. The goal of this approach was
		  to assist in the maintenance of source code, especially in
		  producing cross references documentation.
		  
		  This paper explains why this approach was chosen and how
		  the system's architecture was set up. The emphasis in this
		  paper, however, is places upon the results obtained by
		  using this system particularly, in terms of volume and
		  response time.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Use_of_data_bases}
}

@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{	  ning.engberts.ea:recovering,
  author	= {J. Ning and A. Engberts and W. Kozaczynski},
  title		= {Recovering reusable components from legacy systems},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {64--72},
  year		= {1993},
  note		= { Gives an overview of the program segmentation facilities
		  of the COBOL/SRE system, which are based on various forms
		  of program slicing},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@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{	  ornburn.rugaber:reverse*1,
  author	= {Stephen B. Ornburn and Spencer Rugaber},
  title		= {Reverse Engineering: Resolving Conflicts between Expected
		  and Actual Software Design},
  pages		= {32-40},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {A real-time embedded system was the subject of a series of
		  experiments in reverse engineering. These experiments
		  employed a method of reverse engineering, called
		  Synchronized Refinement, that analyzes a program,
		  describing its behaviour in the vocabulary of the
		  application domain and its structure in terms of design
		  decisions. The results provide insight into the role of
		  domain knowledge in this type of analysis together with the
		  tools used in the detailed analysis of code. The
		  experiments, which included the re-design of a component
		  and the diagnosis of a critical software failure, showed
		  how the real work of software maintenance is in resolving
		  apparent inconsistencies between the expectations that have
		  been derived from domain knowledge and the facts that have
		  been uncovered by applying reverse engineering tools to the
		  software.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

@Book{		  osborne.chikofsky:special,
  title		= {Special issue on Maintenance, reverse engineering and
		  design recovery},
  editor	= {W. Osborne and E. Chikofsky},
  key		= {Osborne and Chikofsky},
  series	= {IEEE Software, 7(1):11--105},
  year		= {1990},
  note		= { In this special issue a number of papers dealing with
		  various aspects of reverse engineering are collected. Most
		  of the individual papers are discussed in this annotated
		  bibliography},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Collections}
}

@Article{	  ostertag.hendler:computing,
  key		= {Ostertag \& Hendler, 1992},
  author	= {Eduardo Ostertag and James Hendler},
  title		= {Computing Similarity in a Reuse Library System: An
		  AI-Based Approach},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1992},
  volume	= {1},
  number	= {3},
  pages		= {205-228},
  month		= jul,
  abstract	= {This paper presents an AI-based library system for
		  software reuse, called AIRS, that allows a developer to
		  browse a software library in search of components that best
		  meet some stated requirement. A component is described by a
		  set of (feature, term) pairs. A feature represents a
		  classification criterion, and is defined by a set of
		  related terms. The system allows to represent packages
		  (logical units that group a set of components) which are
		  also described in terms of features. Candidate reuse
		  components and packages are selected from the library based
		  on the degree of similarity between their descriptions and
		  a given target description. Similarity is quantified by a
		  nonnegative magnitude (distance) proportional to the effort
		  required to obtain the target given a candidate. Distances
		  are computed by comparator functions based on the
		  subsumption, closeness, and package relations. The authors
		  present a formalization of the concepts on which the AIRS
		  system is based. The functionality of a prototype
		  implementation of the AIRS system is illustrated by
		  application to two different software libraries: a set of
		  Ada packages for data structure manipulation, and a set of
		  C components for use in Command, Control, and Information
		  Systems. Finally, the authors discuss some of the ideas
		  they are currently exploring to automate the construction
		  of AIRS classification libraries.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

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

@InProceedings{	  paul.prakash:querying,
  author	= {Santanu Paul and Atul Prakash},
  title		= {Querying Source Code using an Algebraic Query Language},
  pages		= {127-136},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Querying and analyzing source code interactively is a
		  critical task in reverse engineering and program
		  understanding. Current source code query systems lack
		  sufficient formalism and offer limited query capabilties.
		  In this paper, the authors introduce the formal framework
		  of Source Code Algebra (SCA), and outline a source code
		  query system based on it.
		  
		  SCA provides a formal data model for source code, an
		  algebraic expression-based query language, and
		  opportunities for query optimization. An algebraic model of
		  source code addresses the issues of conceptual integrity,
		  expressiv power, and performance of a source code query
		  system within a unified framework.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Use_of_data_bases}
}

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

@InProceedings{	  roman.cox:program,
  author	= {G. C. Roman and K. C. Cox},
  title		= {Program Visualization: The Art of Mapping Programs to
		  Pictures},
  booktitle	= {Proceedings of the 14th  International Conference on
		  Software Engineering },
  pages		= {412--420},
  month		= may,
  year		= {1992},
  abstract	= {Program visualization is defined as a mapping from
		  programs to graphical representations. Simple forms of
		  program visualization are frequently encountered in
		  software engineering. For this reason current advances in
		  program visualization are likely to influence future
		  developments concerning software engineering tools and
		  environments. The authors provide a new taxonomy of program
		  visualization research. The proposed taxonomy becomes the
		  vehicle through which they carry out a systematic review of
		  current systems, techniques, trends, and ideas in program
		  visualization.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation}
}

@Article{	  roman.cox:taxonomy,
  author	= {Gruia-Catalin Roman and Kenneth C. Cox},
  title		= {A Taxonomy of Program Visualization Systems},
  journal	= {IEEE Computer},
  year		= {1993},
  pages		= {11-24},
  month		= dec,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation}
}

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

@TechReport{	  rugaber.tisdale:software,
  author	= {Spencer Rugaber and Victoria Tisdale},
  title		= {Software Psychology Requirements for Software Maintenance
		  Activities},
  year		= {1994},
  institution	= {Software Engineering Center Georgia Institute of
		  Technology, Atlanta, GA},
  abstract	= {Software psychology attempts to discover and describe
		  human limitations in interacting with computers. These
		  limitations can place restrictions on and form requirements
		  for computing systems intended for human interaction.
		  Hypermaint is such a system. Hypermaint is designed, with
		  human limitations in mind, to facilitate the human task of
		  maintaining software. Software maintenance encompases all
		  activities performed on a piece of software intending to
		  keep it useful. This includes efforts to keep software at
		  the same level of performance/usability, as well as efforts
		  to improve it. In the process of software maintenance,
		  source code of the software must be examined and understood
		  by the maintainer. The task of maintenance can be
		  facilitated by a system congruent with human abilities and
		  limitations.
		  
		  This paper describes areas of programming activity (namely
		  program comprehension, program composition, program
		  debugging, and program modification). It describes the
		  models of program comprehension of Shneiderman and Greeno.
		  A number of factors play a role in the transformation of
		  code to an internal semantic form. These factors deal with
		  the viewing and the style of the program code. Experiments
		  have been performed to determine the extent to which these
		  factors affect the comprehension of programs: Commenting,
		  Variable Names, and Indentation.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/softpsych.ps}
		  ,
  class		= {Software_Reverse_Engineering,
		  Cognitive_Processes_in_Human_Program_Understanding}
}

@Article{	  rugaber:position,
  author	= {Spencer Rugaber},
  title		= {Position Paper Domain Analysis and Reverse Engineering},
  journal	= {Software Engineering Techniques Workshop on Software
		  Reengineering},
  institution	= {Software Engineering Institute},
  address	= {Pittsburgh, Pennsysvania},
  year		= {1994},
  month		= may,
  abstract	= {This paper describes the reverse engineering problem. It
		  emphasizes the need for domain knowledge to fully
		  understand a given program. The terms domain, domain
		  analysis, domain representation, and the relationship to
		  reverse engineering are discussed. The issues of
		  methodolgy, representation, and tools are described.
		  Finally, some projects at Georgia's Institute of Technology
		  in the area of reverse engineering are presented.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/sei.ps},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Domain_Analysis}
}

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

@Unpublished{	  rugaber:program*1,
  author	= {Spencer Rugaber},
  title		= {Program Comprehension for Reverse Engineering},
  organization	= {College of Computing, Georgia Institute of Technology},
  address	= {Atlanta, Georgia 30332-0280},
  email		= {spencer@cc.gatech.edu},
  class		= {Software_Reverse_Engineering,
		  Cognitive_Processes_in_Human_Program_Understanding}
}

@Unpublished{	  rugaber:white,
  author	= {Spencer Rugaber},
  title		= {White Paper on Reverse Engineering},
  year		= {1994},
  month		= mar,
  abstract	= {This paper motivates and describes a research program in
		  the area of reverse engineering being conducted at the
		  Georgia Institute of Technology. Reverse engineering is an
		  emerging interest area within the software engineering
		  field. Software engineering itself is concerned with
		  improving the productivity of the software development
		  process and the quality of the systems it produces.
		  However, as currently practiced, the majority of the
		  software development effort is spent on maintaining
		  existing systems rather than developing new ones. Estimate
		  s of the proportion of resources and time devoted to
		  maintenance range from 50% to 80%. The greatest part of the
		  software maintenance process is devoted to understanding
		  the system being maintained. Fjeldstad and Hamlen report
		  that 47% and 62% of time spent on actual enhancement and
		  correction tasks, respectively, are devoted to
		  comprehension activities. These involve reading the
		  documentation, scanning the source code, and understanding
		  the changes to be made. The implications are that if we
		  want to improve software development, we should look at
		  maintenance, and if we want to improve maintenance, we
		  should facilitate the process of comprehending existing
		  programs. Reverse engineering provides a direct attack on
		  the program comprehension problem.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/white\_paper.ps}
		  ,
  class		= {Software_Reverse_Engineering,
		  General_Information_on_Software_Reverse_Engineering}
}

@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{	  selfridge.waters.ea:challenges,
  author	= {P. Selfridge and R. Waters and E. Chikofsky},
  title		= {Challenges for the field of reverse engineering},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {144--150},
  year		= {1993},
  note		= {This position paper presents ten challenges for
		  improvement of reverse engineering research in three areas:
		  (a) avoiding artificial data; (b) focusing on concrete
		  economic and technical impact; and (c) facilitating
		  researcher communication by establishing standard
		  terminology and selecting standard data sets},
  class		= {Software_Reverse_Engineering,
		  General_Information_on_Software_Reverse_Engineering}
}

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

@Article{	  sharon:reverse,
  key		= {Sharon},
  author	= {David Sharon},
  title		= {A Reverse and Re--Engineering Tool Classification Scheme},
  pages		= {Rev-3--Rev5},
  journal	= {Reverse Engineering Newsletter},
  year		= {1990},
  month		= {},
  inhalt	= { Eine Taxonomie für Werkzeuge des Reverse Engineerings
		  wird angegeben.
		  
		  1. Existierende Systeme Untersucht wird ein vorhandenes
		  System auf der Code-Ebene und Informationen auf höherer
		  Abstraktionsebene zur Verfügung gestellt.
		  
		  1.1 Enhancement Die Werkzeuge unterstützen das Verständnis
		  eines Programmes, bevor es geändert wird.
		  
		  1.2 Assessment Der Quellcode des Systems wird bezüglich
		  Industriemetriken vermessen.
		  
		  1.3 Conditioning Die Werkzeuge automatisieren den
		  Verbesserungsproze/3 eines Systems. Oft wird Quellcode in
		  eine strukturierte Form transformiert.
		  
		  2.0 Repository Load/Enhancement and Reconciliation Daten-
		  und proze/3bezogener Quellcode wird gelesen und übersetzt
		  in das Informationsmodell eines anderen Zielrepository. },
  class		= {Reengineering_Tools, Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools,
		  Reengineering_in_General, Fundamentals}
}

@TechReport{	  shilling.stasko:using,
  author	= {Shilling, John J. and Stasko, John T.},
  title		= {Using Animation to Design, Document and Trace
		  Object-Oriented Systems},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1992},
  type		= {Technical Report},
  number	= {GIT-GVU-92-12},
  address	= {Atlanta, GA},
  month		= jun,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Visualizing_Object-Oriented_Programs}
}

@Article{	  shilling.stasko:using*1,
  author	= {Shilling, John J. and Stasko, John T.},
  title		= {Using Animation to Design Object-Oriented Systems},
  journal	= {Object Oriented Systems},
  year		= {1994},
  volume	= {1},
  number	= {1},
  pages		= {5-19},
  month		= sep,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Visualizing_Object-Oriented_Programs}
}

@Article{	  shimomura.isoda:linked-list,
  author	= {Takao Shimomura and Sadahiro Isoda},
  title		= {Linked-List Visualization for Debugging},
  journal	= {IEEE Software},
  year		= {1991},
  pages		= {44-51},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_for_Program_Understanding_and_Debugging}
}

@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.jandrasics:inverse,
  author	= {Harry M. Sneed and G. Jandrasics},
  title		= {Inverse Transformation of Software from Code to
		  Specification},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1988},
  year		= {1988},
  pages		= {102-109},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering,
		  General_Information_on_Software_Reverse_Engineering}
}

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

@TechReport{	  stasko.appelbe.ea:utilizing,
  author	= {Stasko, John T. and Appelbe, William F. and Kraemer,
		  Eileen},
  title		= {Utilizing Program Visualization Techniques to Aid Parallel
		  and Distributed Program Development},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1991},
  type		= {Technical Report},
  number	= {GIT-GVU-91/08},
  month		= jun,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@InProceedings{	  stasko.badre.ea:do,
  author	= {Stasko, John T. and Badre, Albert and Lewis, Clayton},
  title		= {Do Algorithm Animations Assist Learning? An Empirical
		  Study and Analysis},
  booktitle	= {Proceedings of the INTERCHI '93 Conference on Human
		  Factors in Computing Systems, Amsterdam, Netherlands},
  year		= {1993},
  pages		= {61-66},
  month		= apr,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Algorithm_Animation,
		  Empirical_Studies_of_Software_Visualization}
}

@TechReport{	  stasko.kraemer:methodology,
  author	= {Stasko, John T. and Kraemer, Eileen},
  title		= {A Methodology for Building Application-Specific
		  Visualizations of Parallel Programs},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1992},
  type		= {Technical Report},
  number	= {GIT-GVU-92-10},
  month		= jun,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@Article{	  stasko.kraemer:methodology*1,
  author	= {Stasko, John T. and Kraemer, Eileen},
  title		= {A Methodology for Building Application-Specific
		  Visualizations of Parallel Programs},
  journal	= {Journal of Parallel and Distributed Computing},
  year		= {1993},
  volume	= {18},
  number	= {2},
  pages		= {258-264},
  month		= jun,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@TechReport{	  stasko.kraemer:toward,
  author	= {Stasko, John T. and Kraemer, Eileen},
  title		= {Toward Flexible Control of the Temporal Mapping from
		  Concurrent Program Events to Animations},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1994},
  type		= {Technical Report},
  number	= {GIT-GVU-94-10},
  month		= mar,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@TechReport{	  stasko.turner:tidy,
  author	= {Stasko, John T. and Turner, Carlton Reid},
  title		= {Tidy Animations of Tree Algorithms},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1992},
  type		= {Technical Report},
  number	= {GIT-GVU-92-11},
  month		= jun,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  http		= {http://www.cc.gatech.edu/gvu/softviz/algoanim/algoanim.html}
		  ,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Algorithm_Animation}
}

@InProceedings{	  stasko.turner:tidy*1,
  author	= {Stasko, John T. and Turner, Carlton Reid},
  title		= {Tidy Animations of Tree Algorithms},
  booktitle	= {Proceedings of the 1992 IEEE Workshop on Visual Languages,
		  Seattle, WA},
  year		= {1992},
  pages		= {216-218},
  month		= sep,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Algorithm_Animation}
}

@TechReport{	  stasko.wehrli:three-dimensional,
  author	= {Stasko, John T. and Wehrli, Joseph F.},
  title		= {Three-Dimensional Computation Visualization},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1992},
  type		= {Technical Report},
  number	= {GIT-GVU-92-20},
  month		= sep,
  http		= {http://www.cc.gatech.edu/gvu/softviz/3dcv/3dcv.html},
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, 3D_Computation_Visualization}
}

@InProceedings{	  stasko.wehrli:three-dimensional*1,
  author	= {Stasko, John T. and Wehrli, Joseph F.},
  title		= {Three-Dimensional Computation Visualization},
  booktitle	= {Proceedings of the 1993 IEEE Symposium on Visual
		  Languages, Bergen, Norway},
  year		= {1993},
  pages		= {100-107},
  month		= aug,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, 3D_Computation_Visualization}
}

@Article{	  stasko:animating,
  author	= {Stasko, John T.},
  title		= {Animating Algorithms with XTANGO},
  journal	= {SIGACT News},
  year		= {1992},
  volume	= {23},
  number	= {2},
  month		= {Spring},
  pages		= {67-71},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Algorithm_Animation}
}

@Article{	  stasko:animation,
  author	= {Stasko, John T.},
  title		= {Animation in User Interfaces: Principles and Techniques},
  journal	= {Trends in Software, Special issue on User Interface
		  Software},
  year		= {1993},
  editor	= {Bass, Len and Dewan, Prasun},
  number	= {1},
  chapter	= {5},
  pages		= {81-101},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Animation_in_User_Interfaces}
}

@TechReport{	  stasko:parade,
  author	= {Stasko, John T.},
  title		= {The PARADE Environment for Visualizing Parallel Program
		  Executions: A Progress Report},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1995},
  type		= {Technical Report},
  number	= {GIT-GVU-95-03},
  month		= jan,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

@Article{	  stasko:path-transition,
  author	= {Stasko, John T.},
  title		= {The Path-Transition Paradigm: A Practical Methodology for
		  Adding Animation to Program Interfaces},
  journal	= {Journal of Visual Languages and Computing},
  year		= {1990},
  volume	= {1},
  number	= {3},
  month		= sep,
  pages		= {213-236},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Algorithm_Animation}
}

@Article{	  stasko:tango,
  author	= {Stasko, John T.},
  title		= {TANGO: A Framework and System for Algorithm Animation},
  journal	= {IEEE Computer},
  year		= {1990},
  month		= sep,
  pages		= {27-39},
  volume	= {23},
  number	= {9},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Algorithm_Animation}
}

@InProceedings{	  stasko:using,
  author	= {Stasko, John T.},
  title		= {Using Direct Manipulation to Build Algorithm Animations by
		  Demonstration},
  booktitle	= {Proceedings of the ACM SIGCHI '91 Conference on Human
		  Factors in Computing Systems, New Orleans, LA},
  year		= {1991},
  month		= may,
  pages		= {307-314},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation, Algorithm_Animation}
}

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

@Article{	  tamassia.battista.ea:automatic,
  author	= {R. Tamassia and G. Di Battista and C. Batini},
  title		= {Automatic Graph Drawing and Readability of Diagrams},
  journal	= {IEEE Transactions on Systems, Man, and Cybernetics},
  year		= {1988},
  volume	= {18},
  number	= {1},
  month		= {January/February},
  pages		= {61-79},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs}
}

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

@Unpublished{	  tiemens:cognitive,
  author	= {Tim Tiemens},
  title		= {Cognitive Models of Program Comprehension},
  abstract	= {This paper describes some cognitive models in program
		  comprehension. The goal is to use this knwoledge about
		  cognitive models to produce a tool (the Cognitive Support
		  Tool, CST) which can reduce the amount of effort needed to
		  understand a program. The models discussed here were
		  derived from both a human perspective ans from a source
		  code perspective. After reviewing these models, a synthesis
		  section suggests some implications of the information
		  presented. Finally, a section describing a sample
		  interactive sessions with CST is presented.},
  organization	= {Software Engineering Research Center},
  month		= dec,
  year		= {1989},
  class		= {Software_Reverse_Engineering,
		  Cognitive_Processes_in_Human_Program_Understanding}
}

@InProceedings{	  tilley.muller.ea:domain-retargetable,
  author	= {Scott R. Tilley and Hausi A. M\"uller and Michael J.
		  Whitney and Kenny Wong},
  title		= {Domain-Retargetable Reverse Engineering},
  pages		= {142--151},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Any response to the software maintenance challenge must
		  address the underlying problem of program understanding.
		  One way of doing this is through reverse engineering. A
		  successful approach to reverse engineering must be both
		  flexible and scalable. Most reverse engineering tools
		  provide a fixed palette of analysis, extraction,
		  organization, representation, and selection techniques.
		  This paper describes a user-programmable approach to
		  reverse engineering. The approach uses a scripting language
		  that enables users to write their own routines for these
		  activities, making the system domain-retargetable. The
		  environment supported by this programmable approach
		  subsumes existing reverse engineering by being able to
		  simulate facets of each one, and provides a smooth
		  transition from semi-automatic to automatic reverse
		  engineering.},
  class		= {Software_Reverse_Engineering_Tools, Rigi}
}

@Article{	  tilley.wong.ea:programmable,
  author	= {S.R. Tilley and K. Wong and M-A.D. Storey and H.A.
		  M\"uller},
  title		= {Programmable Reverse Engineering},
  journal	= {International Journal of Software Engineering and
		  Knowledge Engineering},
  volume	= {4},
  number	= {4},
  pages		= {501-520},
  year		= {1994},
  note		= { This paper argues that most reverse engineering
		  environments are not flexible enough. They are directed
		  towards the tool builders instead of the users of the
		  environments. Besides a number of basic facilities, such as
		  parsing, the reverse engineering tool should allow a high
		  level of extensibility. The authors present an existing
		  scripting language, Tcl, to enable users to develop their
		  own routines for graph layout, metrics and analysis. Most
		  generic reverse engineering environments break down if they
		  have to deal with millions of lines of code. The
		  constructed abstract syntax trees contain too much
		  information. The reverse engineering environment should
		  allow a flexible gathering of information, not only based
		  on abstract syntax trees. The way the information is
		  gathered should be programmable. The reverse engineering
		  environments should be reusable in various application
		  domains. The user of the environment should be able to
		  program the the environment to make it suited for a
		  specific application domain},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools, Rigi}
}

@InProceedings{	  tilley:documenting,
  key		= {Tilley \& Hausi A. M\"uller \& Orgun, 1992},
  author	= {Scott R. Tilley},
  title		= {Documenting Software Systems with Views},
  booktitle	= {SIGDOC'92: Proceedings of the 10th International
		  Conference on Systems Documentation},
  year		= {1992},
  pages		= {211-219},
  organization	= {ACM},
  month		= oct,
  abstract	= {Software professionals rely on internal documentation as
		  an aid in understanding programs. Unfortunately, the
		  documentation for most programs is usually out-of-date and
		  cannot be trusted. Without it, the only reliable and
		  objective information is the source code itself. Personnel
		  must spend an inordinate amount of time exploring the
		  system by looking at low-level source code to gain an
		  understanding of its functionality. One way of producing
		  accurate documentation for an existing software system is
		  through reverse engineering. This paper outlines a reverse
		  engineering methodology for building subsystem structures
		  out of software building blocks, and describes how
		  documenting a software system with views created by this
		  process can produce numerous benefits. It addresses
		  primarily the needs of the software engineer and technical
		  manager as document users.},
  class		= {Software_Reverse_Engineering_Tools, Rigi}
}

@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{	  topol.stasko.ea:integrating*1,
  author	= {Topol, Brad and Stasko, John T. and Sunderam, Vaidy},
  title		= {Integrating Visualization Support into Distributed
		  Computing Systems},
  booktitle	= {Proceedings of the 15th International Conference on
		  Distributed Computing Systems, Vancouver, B.C.},
  year		= {1995},
  pages		= {19-26},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}

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

@Proceedings{	  waters.chikofsky:proceedings,
  editor	= {R.C. Waters and E.J. Chikofsky},
  title		= {Proceedings of Working Conference on Reverse Engineering},
  publisher	= {{IEEE} Computer Society Press},
  year		= {1993},
  note		= { All papers in these proceedings are discussed separately
		  in this bibliography},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Collections}
}

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

@InProceedings{	  wehrli.stasko:interactive,
  author	= {Wehrli, Joseph F. and Stasko, John T.},
  title		= {Interactive Three-Dimensional Visual Debugging in
		  Massively Parallel Computation (extended abstract)},
  booktitle	= {Proceedings of the 1993 ACM/ONR Workshop on Parallel and
		  Distributed Debugging, San Diego, CA},
  year		= {1993},
  pages		= {235-237},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs,
		  3D_Computation_Visualization}
}

@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.gomez.ea:locating,
  title		= {Locating user functionality in old code},
  author	= {N. Wilde and J. Gomez and T. Gust and D. Strasburg},
  pages		= {200--205},
  booktitle	= {\cite{SM92}},
  year		= {1992},
  note		= { Proposes a probabilistic technique to match expected
		  functionality with the actual functions as implemented in
		  existing code. An experiment reveals that the method works
		  reasonable but cannot replace human experts},
  class		= {Software_Reverse_Engineering, Reverse_Specification}
}

@InProceedings{	  wilde.gomez.ea:locating*1,
  author	= {Norman Wilde and Juan A. Gomez and Thomas Gust and Douglas
		  Strasburg},
  title		= {Locating User Functionality in Old Code},
  pages		= {200-205},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {Software maintainers often have to recover requirements
		  traceability in old code. In other words, they need to
		  answer the question: 'In which parts of this program is
		  functionality X implemented?' This paper proposes a
		  methodology for answering this question based on the use of
		  carefully designed test cases as probes into the code.
		  While the methodology is not applicable to all kinds of
		  requirements and may not find all relevant code components,
		  it should often provide a maintainer with good starting
		  points for studying a large and poorly documented system.
		  Two formulations of the methodology are suggested and some
		  encouraging experimental results are presented from a case
		  study of a typical old program.},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Natural_Language_Processing_in_Reverse_Specification}
}

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

@PhDThesis{	  wong:reverse,
  author	= {Kenny Wong},
  title		= {The Reverse Engineering Notebook},
  school	= {University of Victoria},
  year		= {1999},
  abstract	= {Software must evolve over time or it becomes useless. Much
		  of software production today is involved not in creating
		  wholly new code from scratch but in maintaining and
		  building upon existing code. Much of this code resides in
		  old legacy software systems.
		  
		  Unfortunately, these systems are often poorly documented.
		  Typically, they become more complex and difficult to
		  understand over time. Thus, there is a need to better
		  understand existing software systems. An approach toward
		  this problem would be a first step toward easing changes
		  and extending the continuous evolution of these systems.
		  
		  This dissertation addresses the problem by enabling
		  continuous software understanding. There should be a base
		  of reverse engineering abstractions that are carried
		  forward during evolution.
		  
		  The proposed approach seeks to redocument existing software
		  structure, capture the analysis decisions made, and support
		  personal, customizable, and live perspectives of the
		  software in an online journal called the Reverse
		  Engineering Notebook.
		  
		  The premise that software reverse engineering be applied
		  continuously throughout the lifetime of the software has
		  major tool design implications. Thus, tool integration,
		  process, and adoption are key issues for the Notebook. In
		  particular, data integration requirements, control
		  integration via pervasive scripting, presentation
		  integration through the management of views, user roles,
		  methodology, end user needs, and goal-directed framework
		  for the Notebook are described.
		  
		  A major theme of the dissertation is learning from the
		  successes and failures of studies involving tool
		  integration and reverse engineering technologies. Case
		  studies and user experiments helped to evaluate various
		  aspects of the Notebook approach and provide feedback into
		  software understanding tool requirements.
		  
		  },
  keywords	= {reverse engineering, program understanding, tool
		  requirements},
  class		= {Interoperability Reengineering_in_General Using_graphs
		  Reverse_Engineering_Tools Rig Process_Models
		  Software_Reverse_Engineering
		  Intermediate_Representations_of_Source_Code Experiences }
}

@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{	  woon.jarzabek:towards,
  author	= {Irene Woon and Stan Jarzabek},
  title		= {Towards a precise description of reverse engineering
		  methods and tools},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_in_General}
}

@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{	  yang:supporting,
  author	= {Hongji Yang},
  title		= {The Supporting Environment for A Reverse Engineering
		  System - The Maintainer's Assistant},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {13-22},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {The Maintainer's Assistant is an interactive tool which
		  helps the user to extract a specification from an existing
		  source code program. It is based on a program
		  transformation system, in which a program is converted to a
		  semantically equivalent form using proven transformations
		  selected from a catalogue.
		  
		  This paper describes the environmental support provided in
		  the Maintainer's Assistant. The technical methods used in
		  the tool are summarized and the requirements of the
		  environment are stated. The current implementation is then
		  described and results achieved discussed. Finally, both the
		  expected and planned developments are summarized.},
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools, Maintainer's Assistant,
		  Reengineering_Tools}
}

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

@TechReport{	  zhao.stasko:visualizing,
  author	= {Zhao, Qiang A. and Stasko, John T.},
  title		= {Visualizing the Execution of Threads-based Parallel
		  Programs},
  institution	= {Graphics, Visualization, and Usability Center Georgia
		  Institute of Technology, Atlanta, GA},
  year		= {1995},
  type		= {Technical Report},
  number	= {GIT-GVU-95-01},
  month		= jan,
  ftp		= {ftp://ftp.cc.gatech.edu/pub/gvu/tech-reports},
  class		= {Software_Reverse_Engineering, Reverse_Specification,
		  Software_Animation,
		  Visualization_of_Parallel_and_Distributed_Programs}
}