References of Use_of_data_bases

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

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

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

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