References of Program_Plan_Assignment_by_Parsing

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

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

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

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

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

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

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

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

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

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

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

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