References of Rigi

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

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

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

@InProceedings{	  muller.uhl:composing*1,
  author	= {Hausi A. M\"uller and James S. Uhl},
  title		= {Composing Subsystem Structures Using (K,2)-Partite
		  Graphs},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {12-19},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Subsystem composition is the process of constructing
		  composite software components out of building blocks such
		  as variables, procedures, modules, and sybsystems.
		  Hierarchical subsystem structures are formed by imposing
		  equivalence relations on the resource-flow graphs of the
		  source code. Composition algorithms often use a single
		  equivalence relation (e.g., connection strength or data
		  binding measure) to form automatically tree-shaped
		  composite structures.
		  
		  This paper describes a clustering method that uses
		  equivalence relations for identifying subsystem structures.
		  The relations are intended to embody the software
		  engineering principles that concern module interactions
		  such as low coupling, high strength, small interfaces, and
		  few interfaces. The resulting compositions are
		  (k,2)-partite graphs (a class of layered graphs) rather
		  than strict tree hierarchies. The method is supported by
		  our interactive graph editor.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Metric-Based_Methods_in_Reverse_Design,
		  Automated_Reverse_Design,
		  Software_Reverse_Engineering_Tools, Rigi}
}

@InProceedings{	  storey.mueller:graph,
  author	= {M.-A. D. Storey and H. Mueller},
  title		= {Graph Layout adjustment strategies},
  key		= {graph layout,},
  booktitle	= {Graph Drawing 1995 Proceedings},
  year		= {1995},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Software_Reverse_Engineering_Tools, Rigi}
}

@InProceedings{	  storey.mueller:manipulating,
  author	= {M-A D Storey and H. Mueller},
  title		= {Manipulating and Documenting Software Structures using
		  SHriMP Views},
  key		= {program understanding, reverse engineering, reengineering,
		  software visualization, fisheye views},
  pages		= {275-285},
  booktitle	= {International Conference in Software Maintenance},
  year		= {1995},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Software_Reverse_Engineering_Tools, Rigi}
}

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

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

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