References of Knowledge-Based_Concept_Assignment

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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