References of Code_Views

@Article{	  al-zoubi.prakash:program,
  author	= {Al-Zoubi, R. and Prakash, A.},
  title		= {Program View Generation and Change Analysis Using
		  Attributed Dependency Graphs},
  journal	= {Journal of Software Maintenance: Research and Practice},
  volume	= {7},
  number	= {4},
  pages		= {239-262},
  month		= {July-August},
  year		= {1995},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Static_Analysis }
}

@InProceedings{	  baecker:enhancing,
  author	= {R. Baecker},
  year		= {April 1988},
  pages		= {356-366},
  title		= {Enhancing Program Readability and Comprehensibility with
		  Tools for Program Visualization},
  booktitle	= {Proceedings of the 10th International Conference on
		  Software Engineering},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views }
}

@InProceedings{	  bailes.burnim.ea:derivation,
  author	= {P.A. Bailes and P. Burnim and M. Chapman and D. Johnston},
  title		= {Derivation and presentation of an Abstract Program Space
		  for ADA},
  booktitle	= {WPC~'96: Proceedings of the IEEE Fourth Workshop on
		  Program Comprehension, {\rm (Berlin, Germany; March 29-31,
		  1996)}},
  year		= {March 1996},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  baker.eick:visualizing*1,
  author	= { M.J. Baker and S.G. Eick },
  title		= { Visualizing Software Systems },
  booktitle	= { Proceedings of the 16th International Conference on
		  Software Engineering {\rm (Sorrento, Italy; May 16-21,
		  1994)} },
  publisher	= { IEEE Computer Society Press },
  year		= { 1994 },
  pages		= { 59-67 },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  canfora.cimitile.ea:petri,
  author	= {G. Canfora and Aniello Cimitile and De Carlini, Ugo},
  title		= {Petri Nets and Reverse Engineering in Concurrent
		  Environments},
  booktitle	= {Proceedings of the 3rd International Conference on
		  Software Engineering and Knowledge Engineering SEKE' 91},
  year		= {1991},
  pages		= {213-223},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@Article{	  cordy.eliot.ea:turingtool,
  author	= {J.R. Cordy and N.L. Eliot and M.G. Robertson},
  title		= {TuringTool: A User Interface to Aid in the Software
		  Maintenance Task},
  journal	= {IEEE Transactions on Software Engineering},
  volume	= {16},
  number	= {3},
  pages		= {294-301},
  year		= {1990},
  note		= { In this paper the approach of viewing a program in a
		  structured way is advocated. With the aid of queries the
		  user can influence the view of the program and can,
		  therefore, get a better idea of what the program is doing.
		  Things that are not important for a certain view are
		  elided, but can be accessed by clicking on them---the
		  elided text becomes visual. The program can also be edited
		  with this tool},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  cross:reverse,
  author	= {J. Cross},
  title		= {Reverse engineering of control structure diagrams},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {107--116},
  year		= {1993},
  note		= { Describes a tool for the automatic generation of a new
		  graphical representation for Ada software (Control
		  Structure Diagrams). These diagrams aim at improving the
		  comprehension of Ada programs and can potentially replace
		  the original source code},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Code_Views}
}

@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{	  gillis.wright:improving,
  author	= {Keith D. Gillis and David G. Wright},
  title		= {Improving Software Maintenance Using System-Level Reverse
		  Engineering},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {84-90},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Success in the software maintenance environment depends
		  upon the ability to read and comprehend existing source
		  code. A high level of comprehension is becoming more and
		  more more difficult to achieve as systems increase in
		  overall size and complexity. The described Fortran Reverse
		  Engineering software package programmatically analyzes
		  existing Fortran source code and generates complete
		  Structure Charts, and Module Specifications in a CASE
		  environment. The user can also select options to create
		  software trees and a variety of cross reference-tables. The
		  use of these objects can increase programmer productivity
		  by providing system-level details in a manner that can be
		  easily understood. They also aid in the software
		  maintenance process by providing the design baseline for
		  future software modifications and adds documentation of the
		  software set. Integrating a system-level reverse
		  engineering utility tool into a CASE enfivonment is just
		  one step toward improving programmer productivity and
		  increasing success in the software maintenance process.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@Unpublished{	  johnson:reverse,
  author	= {Bret Johnson},
  title		= {Reverse Engineering with a CASE Tool},
  month		= oct,
  year		= {1994},
  abstract	= {We examine using a CASE tool, Interactive Development
		  Environment's Software through Pictures (StP), to support
		  reverse engineering. We generate structure charts in StP
		  from the automated analysis of C source code. The
		  advantages of this approach are that one can use the CASE
		  tool's support for drawing, linking, and modifying
		  pictorial notations for program design in order to make it
		  easier to construct a reverse engineering tool.
		  Additionally, one can the use the design representations
		  with the CASE tool to do reengineering for maintenance.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Software_Reverse_Engineering_Tools}
}

@InProceedings{	  linos.aubet.ea:care,
  author	= {Panagiotis Linos and Philippe Aubet and Laurent Dumas and
		  Yan Helleboid and Patricia Lejeune and Philippe Tulula},
  title		= {CARE: An Environement for Understanding and
		  Re--engineering C--Programs},
  pages		= {130--139},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The focus of this paper is on facilitating incremental
		  understanding and re-enginering of existing C programs. A
		  software environement called C.A.R.E. (Computer-Aided
		  Re-engineering) is used as a vehicle towards that goal.
		  CARE maintains a repository of control-flow and data-flow
		  dependencies (i.e. entities and their relations) of C
		  programs. These dependencies can be visualized using a
		  novel representation model. Moreover, CARE entails
		  transformation tools that support various ways of
		  displaying program dependencies and facilitate incremental
		  program modifications. An empirical evaluation of the CARE
		  environement using small size C programs is performed. In
		  addition, CARE is used in order to modify the source code
		  of a medium-to-large size program. The results from this
		  empirical evaluation of CARE indicate that its presentation
		  model and transformation tools is a promising step towards
		  improving the effectiveness of understanding and
		  re-engineering existing C programs. Finally, the authors
		  discuss some issues raised during the modification exercise
		  with CARE when using a medium-to-large size program.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  long.clarke:task,
  author	= {D. L. Long and L. A. Clarke},
  title		= {Task Interaction Graphs for Concurrency Analysis},
  booktitle	= {Proceedings of the 11th  International Conference on
		  Software Engineering },
  pages		= {44--52},
  month		= may,
  year		= {1989},
  abstract	= {A representation for concurrent programs called task
		  interaction graphs, is presented. Task interaction graphs
		  divide a program into maximal sequential regions connected
		  by edges representing task interactions. This
		  representation is illustrated. It is shown how task
		  interaction graphs can be used to create concurrency graph
		  representations that are much smaller than those created
		  from control flow graph representations. Both task
		  interaction graphs and their corresponding concurrency
		  graphs facilitate analysis of concurrent programs. Some
		  analyses and optimizations on these representations are
		  also described.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views}
}

@InProceedings{	  olshefski.cole:prototype,
  author	= {D. Olshefski and A. Cole},
  title		= {A prototype system for static and dynamic program
		  understanding},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {93--106},
  year		= {1993},
  note		= { Describes the experimental PUNDIT system that combines
		  static and dynamic information for program understanding.
		  It comprises a static analyzer for C source code and a,
		  mostly language-independent, graphical user interface.
		  Gives various examples of program views},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Dynamic_Analysis, Code_Views}
}

@InProceedings{	  platoff.wagner.ea:integrated,
  author	= {Michael Platoff and Michael Wagner and Joseph Camaratta},
  title		= {An Integrated Program Representation and Toolkit for the
		  Maintenance of C Programs},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1991},
  year		= {1991},
  pages		= {129-137},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Maintaining large software systems has become an
		  increasingly common and expensive task for many
		  organizations. Understanding and modifying existing
		  programs is a major goal of the authors' Maintainer's
		  Assistant (MA) project, an environment for the maintenance
		  of software systems written in the C language. The authors
		  describe an integrated program representation that presents
		  views of the source text, architecture, syntax, static
		  semantics, and control and data flow of software systems.
		  Changes to these views are provided by a transformation
		  toolkit that supports structured modifications to the
		  representation. Modifications in one view are reflected in
		  related views. The representation and toolkit support all
		  of C, including features of the C preprocessor.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Reengineering_Tools}
}

@InProceedings{	  rajlich.damaskinos:algorithm,
  author	= {Vaclav Rajlich and Nicolas Damaskinos},
  title		= {Algorithm for Graphic Layout in VIFOR},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {142-145},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {VIFOR is a tool for maintenance of large FORTRAN programs.
		  It contains a database which stores information on all
		  nonlocal declaractions of the programs (i.e. subroutines,
		  functions, commons), all source files, and all relations
		  among them.
		  
		  The programmer accesses this database by queries which
		  produce views. Each view is a subset of the information
		  stored in the database. VIFOR displays these views in
		  browsers, which are specialized windows displaying the
		  views graphically.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Software_Reverse_Engineering_Tools, VIFOR}
}

@InProceedings{	  servello:logiscope,
  author	= {Mark A. Servello},
  title		= {LOGISCOPE and the Software Maintenance Crisis},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {104},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Gaining a complete understanding of unfamiliar source code
		  is fundamental to effective maintenance of that software.
		  LOGISCOPE performs a fast and consistent source code
		  analysis in wide variety of languages to produce graphic
		  aids and complexity metrics which can drastically reduce
		  both time and error in gaining this understanding.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Code_Views,
		  Software_Reverse_Engineering_Tools, LOGISCOPE}
}

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