References of Re-Use

@Article{	  arnold.frakes:software*1,
  author	= { R. Arnold and W. Frakes },
  title		= { Software Reuse and Reengineering },
  journal	= { CASE Trends (final draft) },
  year		= { February 1991 },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Re-Use }
}

@InProceedings{	  bailey.basili:software,
  author	= { J.W. Bailey and V.R. Basili },
  title		= { Software Reclamation: Improving Post-Development
		  Reusability },
  booktitle	= { Proceedings of the Eighth Annual National Conference on
		  Ada Technology },
  year		= { April 1990 },
  pages		= { 477-499 },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Re-Use }
}

@InProceedings{	  basili:maintenance,
  author	= {Victor R. Basili},
  year		= {October 1988},
  pages		= {3-4},
  title		= {Maintenance = Reuse-oriented Software Development},
  booktitle	= {Proceedings of the IEEE 1988 Conference on Software
		  Maintenance},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Re-Use }
}

@Article{	  basili:viewing,
  title		= {Viewing maintenance as reuse oriented software
		  development},
  author	= {V. Basili},
  journal	= {{IEEE} Software},
  volume	= {7},
  number	= {1},
  pages		= {19--25},
  year		= {1990},
  note		= { In this paper the maintenance process is incorporated in
		  the life-cycle perspective geared towards the reusability
		  of the various components},
  class		= {Reengineering_in_General, Process_Models,
		  Software_Reverse_Engineering, Re-Use}
}

@Article{	  basili:viewing*1,
  author	= {Victor R. Basili},
  year		= {January 1990},
  journal	= {IEEE Software},
  pages		= {19-25},
  title		= {Viewing Maintenance as Reuse-Oriented Software
		  Development},
  volume	= {7(1)},
  abstract	= {},
  class		= {Software_Reverse_Engineering, Re-Use }
}

@TechReport{	  biggerstaff:reusability,
  author	= {Ted J. Biggerstaff},
  title		= {Reusability Overview},
  institution	= {MCC},
  number	= {STP-168-86},
  year		= {1986},
  month		= {May},
  abstract	= { },
  class		= {Software_Reverse_Engineering, Re-Use }
}

@Book{		  biggerstaff:video,
  author	= { Ted. J. Biggerstaff },
  title		= { Video Notes - Topics in Reuse and Design Recovery },
  publisher	= { IEEE Computer Society Press },
  year		= { 1990 },
  class		= {Software_Reverse_Engineering, Re-Use }
}

@Article{	  caldiera.basili:identifying,
  author	= {Gianluigi Caldiera and Victor R. Basili},
  title		= {Identifying and Qualifying Reusable Software Components},
  journal	= {IEEE Computer},
  year		= {1991},
  pages		= {61-70},
  month		= feb,
  class		= {Software_Reverse_Engineering, Re-Use}
}

@Article{	  caldiera.basili:identifying*1,
  author	= { G. Caldiera and V.R. Basili },
  title		= { Identifying and Qualifying Reusable Software Components
		  },
  journal	= { IEEE Computer },
  year		= { February 1991 },
  pages		= { 61-70 },
  abstract	= { },
  class		= {Software_Reverse_Engineering, Re-Use }
}

@Article{	  caldiera:searching,
  author	= {Gianluigi Caldiera},
  title		= {Searching Existing Programs for Reusable Components},
  journal	= {IEEE},
  year		= {1989},
  pages		= {222-223},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  canfora.cimitile.ea:precise,
  author	= {G. Canfora and Aniello Cimitile and M. Tortorella and M.
		  Munro},
  title		= {A Precise Method for Identifying Reusable Abstract Data
		  Types in Code},
  pages		= {404-413},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {This paper presents the results of research within the
		  $RE^{2}$ project of a refinement of two existing methods
		  for identifying reusable abstract data types. These methods
		  are based on the relationships existing between the user
		  defined types and procedure-like components that use them
		  in their headings and on direct dominance trees and strong
		  direct dominance trees that are refinements of the call
		  directed graph of a program. It shows how these methods can
		  be used to give a more precise set of reusable abstract
		  data types. The method is then applied to a program and the
		  results are compared with the existing method.},
  class		= {Software_Reverse_Engineering, Re-Use,
		  Software_Reverse_Engineering, Reverse_Design,
		  System_Modularization }
}

@TechReport{	  canfora.cimitile.ea:re2,
  author	= {G. Canfora and Aniello Cimitile and M. Munro},
  title		= {$RE^{2}$: Reverse Engineering and Reuse Re-engineering},
  institution	= {University of Durham, School of Engineering and Computer
		  Science},
  year		= {1992},
  type		= {Computer Science Technical Report},
  number	= {8/92},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  canfora.cimitile.ea:software,
  author	= {G. Canfora and Aniello Cimitile and A. De Lucia and Di
		  Lucca, G. A.},
  title		= {Software Salvaging Based on Conditions},
  pages		= {424-433},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {This paper presents algorithms for isolating reusable
		  functions in large monolithic programs. The functions to be
		  isolated are specified in terms of either pre-conditions of
		  binding conditions, and these are mapped onto predicates on
		  program's variables. Code components whose execution is
		  triggered and/or bound by these predicates are then
		  isolated. Each component is a candidate to implement a
		  reusable function. The algorithms exploit a representation
		  of the subject program in the form of a program dependence
		  graph.
		  
		  This work forms part of $RE^{2}$, a research project that
		  addresses the wider issue of software reuse. $RE^{2}$
		  project aims to promote the reuse of software through the
		  exploration of reverse engineering and re-engineering
		  techniques to identify and extract reusable software
		  components from existing systems.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  cimitile.fasolino.ea:reuse,
  author	= {Aniello Cimitile and A. R. Fasolino and P. Marascea},
  title		= {Reuse Reengineering and Validation via Concept
		  Assignment},
  pages		= {216-225},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The first step in a Software Reuse Reengineering process
		  is to analyze the structural characteristics of the
		  existing software so as to produce software component sets,
		  each of which is a candidate for clustering and
		  reengineering into a reusable module. This step is founded
		  on one ore more Candidature Criteria and the cost of the
		  following steps depend on their quality.
		  
		  This paper introduces the notions of completeness and
		  adequacy as applied to candidature criteria and outlines
		  the need for an adquacy validation process before they are
		  applied on a software system.
		  
		  An adequacy validation process founded on the assignment of
		  a concept to the candidate modules is proposed and the
		  results coming from an application of this process are
		  described and discussed.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  cimitile:towards,
  author	= {Aniello Cimitile},
  title		= {Towards Reuse Reengineering of Old Software},
  booktitle	= {Proceedings of the 4th International Conference on
		  Software Engineering and Knowledge Engineering SEKE' 92},
  year		= {1992},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  dunn.knight:automating,
  author	= {M. F. Dunn and J. C. Knight},
  title		= {Automating the detection of reusable parts in existing
		  software},
  pages		= {381--390},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  fischer.henninger.ea:cognitive,
  author	= {G. Fischer and S. Henninger and D. Redmiles},
  title		= {Cognitive Tools for Locating and Comprehending Software
		  Objects for Reuse},
  booktitle	= {Proceedings of the 13th  International Conference on
		  Software Engineering },
  pages		= {318--328},
  month		= may,
  year		= {1991},
  abstract	= {The authors describe a conceptual framework to facilitate
		  software reuse. It is shown that high functionality
		  computer systems by themselves do not provide sufficient
		  support for software reuse. Two systems that support this
		  framework, CODEFINDER and EXPLAINER, are presented.
		  CODEFINDER addresses issues on information access for
		  software reuse. Support for comprehending software objects
		  is demonstrated with EXPLAINER. A scenario describing how
		  the two systems are used in a reuse situation is presented.
		  The authors show how these systems fit into the bigger
		  pictures of software development environments, address
		  limitations of the systems, and discuss future
		  directions.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@Article{	  fischer.lemke.ea:from,
  author	= {Gerhard Fischer and Andreas C. Lemke and Christian
		  Rathke},
  title		= {From Design to Redesign},
  journal	= {ACM},
  year		= {1987},
  pages		= {369-376},
  inhalt	= {Beispiel für Wiederverwendung eines objekt-orientierten
		  wissensbasierten Benutzerschnittstellenbaukasten.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  gall.klosch:capsule,
  author	= {Harald Gall and Ren\'e Kl\"osch},
  title		= {Capsule Oriented Reverse Engineering for Software Reuse},
  pages		= {418-433},
  booktitle	= {Proceedings of the European Conference on Software
		  Engineering 1993},
  year		= {1993},
  abstract	= {Much research effort concerning the reuse of software
		  components has been invested on questions such as
		  classification, attribution and organization of modules in
		  software components and their interconnection to form new
		  software systems have been discovered. Reverse engineering
		  can be used for different purposes, like maintenance effort
		  reduction, documentation improvement, etc., but also for
		  software reuse. In the process of software reuse, reverse
		  engineering can be used to extract reusable components from
		  existing software systems.
		  
		  In this paper the authors provide insigths into a reverse
		  engineering method called capsule oriented reverse
		  engineering method (COREM) that realizes the extraction of
		  object similar capsules from existing systems implemented
		  in a procedural language. For this, COREM transforms the
		  original procedural system to an object based system
		  (consisting of capsules). These capsules can then be used
		  for further object-oriented system development. By using
		  object-oriented system development methods the problem of
		  module interconnection can be skillfully solved.
		  
		  The paper points out the three main steps of the COREM
		  process and describes the framework of COREM for the
		  production of software from capsules.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  ibba.natale:structure-based,
  author	= {R. Ibba and D. Natale},
  title		= {Structure-based Clustering of Components for Software
		  Reuse},
  pages		= {210-215},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {The characterization of the code reuse practices in
		  existing production environments provides fundamental data
		  and lessons for the establishment of improvement of
		  effective reuse-oriented policies, and for the adoption of
		  up-to-date technologies supporting them. This report
		  describes the method and results of an experience of
		  metrice-aided clustering of software components, aiming at
		  detecting and characterizing implicit reuse of code and
		  reuse potential in a large-scale data processing
		  environment. Similar functionalities may be in fact
		  replicated many times, customizing an existing source code
		  component, but this phenomenon may be only partially
		  apparent in form of explicit reuse. A set of software
		  metrics has been used to create clusters of existing
		  components whose internal structures appear very similar;
		  the functional similarity check were performed involving
		  human experts. This was done in the context of a large
		  reuse project, where quantitative software quality
		  indicators are also combined to the feedback collected in
		  pilot groups who know the applications from which the
		  candidate components were extracted. The potential and
		  limitations of metric support in this field are considered
		  in the discussion of the results obtained up to now.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@Article{	  khajenoori.linton.ea:enhancing,
  title		= {Enhancing Software Reusability Through Effective Use of
		  the Essential Modelling Approach},
  author	= {S. Khajenoori and D.G. Linton and C.A. Morris},
  journal	= {Information and Software Technology},
  volume	= {36},
  number	= {8},
  pages		= {495--501},
  year		= {1994},
  note		= { It is advocated to develop new software systems by
		  reusing design components from existing ones. With the aid
		  of the so-called essential modelling approach it is
		  possible to determine reusable components},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@Article{	  kozaczynski:suzuki,
  author	= {Wojtek Kozaczynski},
  title		= {A Suzuki Class in Software Reengineering},
  journal	= {IEEE Software},
  year		= {1991},
  volume	= {8},
  number	= {1},
  pages		= {97-98},
  month		= jan,
  class		= {Software_Reverse_Engineering, Re-Use}
}

@InProceedings{	  liu.wilde:identifying,
  author	= {S. Liu and N. Wilde},
  title		= {Identifying Objects in a Conventional Procedural Language:
		  an Example of Data Design Recovery},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {266-271},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {While object-oriented methodologies for software design
		  and development have only been clearly enunciated in the
		  last few years, many object-like features such as data
		  grouping, abstract data types and inheritance have been in
		  use for some time. In maintaining an existing program
		  containing such features it would be very useful to have an
		  understanding of the ''objects'' the original designer had
		  in mind. This paper proposes methodologies to aid in the
		  design recovery of object-like features of a program
		  written in a non object oriented language.
		  
		  Two complementary methods are proposed, based on an
		  analysis of global data or of data types. An interactive
		  tool is proposed that would combine the two methods while
		  using human input to guide the object identification
		  process. A prototype of such a tool is currently being
		  developed.},
  class		= {Software_Reverse_Engineering, Re-Use,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@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{	  ning.engberts.ea:recovering,
  author	= {J. Ning and A. Engberts and W. Kozaczynski},
  title		= {Recovering reusable components from legacy systems},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {64--72},
  year		= {1993},
  note		= { Gives an overview of the program segmentation facilities
		  of the COBOL/SRE system, which are based on various forms
		  of program slicing},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@Article{	  ostertag.hendler:computing,
  key		= {Ostertag \& Hendler, 1992},
  author	= {Eduardo Ostertag and James Hendler},
  title		= {Computing Similarity in a Reuse Library System: An
		  AI-Based Approach},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1992},
  volume	= {1},
  number	= {3},
  pages		= {205-228},
  month		= jul,
  abstract	= {This paper presents an AI-based library system for
		  software reuse, called AIRS, that allows a developer to
		  browse a software library in search of components that best
		  meet some stated requirement. A component is described by a
		  set of (feature, term) pairs. A feature represents a
		  classification criterion, and is defined by a set of
		  related terms. The system allows to represent packages
		  (logical units that group a set of components) which are
		  also described in terms of features. Candidate reuse
		  components and packages are selected from the library based
		  on the degree of similarity between their descriptions and
		  a given target description. Similarity is quantified by a
		  nonnegative magnitude (distance) proportional to the effort
		  required to obtain the target given a candidate. Distances
		  are computed by comparator functions based on the
		  subsumption, closeness, and package relations. The authors
		  present a formalization of the concepts on which the AIRS
		  system is based. The functionality of a prototype
		  implementation of the AIRS system is illustrated by
		  application to two different software libraries: a set of
		  Ada packages for data structure manipulation, and a set of
		  C components for use in Command, Control, and Information
		  Systems. Finally, the authors discuss some of the ideas
		  they are currently exploring to automate the construction
		  of AIRS classification libraries.},
  class		= {Software_Reverse_Engineering, Re-Use}
}

@Article{	  podgurski.pierce:retrieving,
  key		= {Podgurski \& Pierce, 1993},
  author	= {Andy Podgurski and Lynn Pierce},
  title		= {Retrieving Reusable Software by Sampling Behaviour},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1993},
  volume	= {2},
  number	= {3},
  pages		= {286-303},
  month		= jul,
  abstract	= {A new method, called behavior sampling, is proposed for
		  automated retrieval of reusable components from software
		  libraries. Behavior sampling exploits the property of
		  software that distinguishes it from other forms of text:
		  executability. Basic behavior sampling identifies relevant
		  routines by executing candidates on a searcher supplied
		  sample of operational inputs and by comparing their output
		  provided by the searcher. The probabilistic basis for
		  behavior sampling is described, and experimental results
		  are reported that suggest that basic behavior sampling
		  exhibits high precision when used with small samples.
		  Extensions to basic behavioral sampling are proposed to
		  improve its recall and to make it applicable to the
		  retrieval of abstract data types and object classes.},
  class		= {Software_Reverse_Engineering, Re-Use,
		  Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Dynamic_Data_Flow_Analysis}
}