References of Intermediate_Representations_of_Source_Code

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

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

@Article{	  arango.baxter.ea:tmm,
  author	= {Guillermo Arango and Ira Baxter and Peter Freeman and
		  Christopher Pidgeon},
  title		= {TMM: Software Maintenance by Transformation},
  journal	= {IEEE Software},
  year		= {1986},
  pages		= {27-38},
  month		= may,
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Use_of_data_bases}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@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:fusing,
  author	= {Yang Li and Hongji Yang},
  title		= {Fusing Ambiguous Domain Knowledge Slices in a Reverse
		  Engineering Process},
  booktitle	= {Proceedings of the 7th Asia-Pacific Software Engineering
		  Conference (APSEC2000)},
  publisher	= {IEEE Computer Society Press},
  year		= {2000},
  editor	= {},
  chapter	= {},
  pages		= {},
  address	= {Singapore},
  month		= {Dec},
  url		= {},
  abstract	= {Recovering domain knowledge from legacy code plays an
		  important role in the new information technology era, which
		  can be of help for program understanding, system evolution
		  and software reuse. Traditional methods for domain
		  knowledge recovery from source code did not sufficiently
		  address the issue of ambiguity handling, in particular, the
		  propagation of ambiguity among multiple domain knowledge
		  slices recovered from source code in software reverse
		  engineering process. In this paper, we present a novel
		  approach to recovering unambiguous domain knowledge from
		  legacy code, where isolated ambiguous domain knowledge
		  slices are ``fused'' together in an iterative ambiguity
		  propagation process and hence the disambiguity of these
		  recovered knowledge slices is increased. },
  keywords	= {reverse engineering, domain knowledge recovery,
		  co-operative behaviour, belief revision},
  note		= {This is the first of this kind of work which deals with
		  the ambiguity involved in recovering large-scale domain
		  knowledge from source code.},
  class		= {Automated_Reverse_Design
		  Knowledge-Based_Concept_Assignment Using_graphs
		  Model_Generating Reverse_Specification
		  Cognitive_Processes_in_Human_Program_Understanding
		  Reverse_Design Domain_Analysis
		  Recovery_of_Software_Architectur
		  Metric-Based_Methods_in_Reverse_Design
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  Intermediate_Representations_of_Source_Code
		  Software_Reverse_Engineering }
}

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

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

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

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

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

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

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

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