References of Using_graphs

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

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

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

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

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