References of Encapsulation_and_Finding_Objects_in_Legacy_Code

@InProceedings{	  bizivin.lennon.ea:from,
  author	= {J. Bizivin and Y. Lennon and C. Nguyen Huu Nhon},
  title		= {From Cobol to OMT: A Reengineering Workbench Based on
		  Semantic Networks},
  booktitle	= {Tools USA' 95 (Technology of Object-Oriented Languages and
		  Systems)},
  pages		= {137-152},
  year		= {1995},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@InProceedings{	  canfora.cimitile.ea:case,
  author	= {Canfora, G. and Cimitile, A. and De Lucia, A. and Di
		  Lucca, G. A.},
  title		= {A Case Study of Applying an Eclectic Approach to Identify
		  Objects in Code},
  booktitle	= {International Workshop on Program Comprehension},
  pages		= {136--143},
  year		= {1999},
  month		= may,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  canfora.cimitile.ea:extracting,
  author	= {G. Canfora and Aniello Cimitile and M. Munro and C.J.
		  Taylor},
  title		= {Extracting Abstract Data Types from C Programs: A Case
		  Study},
  pages		= {200-209},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {This paper presents the results of a case study in
		  identifying and extracting reusable abstract data types
		  from C programs. It applies reuse re-engineering processes
		  already established in the $RE^{2}$ project. The method for
		  identifying abstract data types uses an interconnection
		  graph called variable-reference graph and coincidental and
		  spurious connections within the graph are resolved using a
		  statistical technique. A prototype tool is described which
		  demonstrates the feasibility of the method. The tool is
		  used to analyze a C program and a number of abstract data
		  types are identified and then used in the maintenance of
		  the original program. The validity of the method is
		  assessed by a simple manual analysis of the source code.
		  The resulting reusable components are specified using the
		  formal notation Z.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@InProceedings{	  canfora.cimitile.ea:reverse*1,
  author	= {G. Canfora and A. Cimitile and M. Munro},
  title		= {A reverse engineering method for identifying reusable
		  abstract data types},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {73--82},
  year		= {1993},
  note		= { Describes a methodology and experimental Prolog-based
		  tool for the extraction of reusable data type declarations
		  from source code. Illustrated for a medium-size Pascal
		  program},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@Article{	  cimitile.visaggio:software,
  author	= {Cimitile, A. and Visaggio, G.},
  title		= {Software Salvaging and the Call Dominance Tree},
  journal	= {Journal of Systems Software},
  year		= {1995},
  volume	= {28},
  pages		= {117--127},
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  dietrich.nackman.ea:saving,
  author	= {W. C. Dietrich and L. R. Nackman and F. Gracer},
  title		= {Saving a Legacy with Objects},
  booktitle	= {OOPSLA},
  pages		= {77-83},
  year		= {1989},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@InProceedings{	  doval.mancoridis.ea:automatic,
  author	= {Doval, D. and Mancoridis, S. and Mitchel, B.S and Chen, Y.
		  and Gansner, E.R.},
  title		= {Automatic Clustering of Software Systems using a Genetic
		  Algorithm},
  booktitle	= { Proceedings of the International Conference on Software
		  Tools and Engineering Practice},
  year		= {1999},
  month		= aug,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  fantechi.nesi.ea:object-oriented,
  author	= {A. Fantechi and Paolo Nesi and E. Somma},
  title		= {Object-Oriented Analysis of COBOL},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {The object-oriented paradigm is presently considered the
		  one which best guarantees the investments for renewal. It
		  allows to produce software with high degrees of reusability
		  and maintainability, satisfying in a certain measure also
		  quality characteristics. These features are not obviously
		  automatically guaranteed by the simple adoption of an
		  object-oriented programming language, a process of
		  re-analysis is needed. In this view, several methods for
		  reengineering old applications according to the
		  object-oriented paradigm were defined and proposed. In this
		  paper, a method and tool (C2O2, COBOL to Object-Oriented)
		  for analyzing COBOL applications in order to extract its
		  object-oriented analysis is presented. The tool identifies
		  classes and their relationships by means of a process of
		  understanding and refinement in which COBOL data structures
		  are analyzed, converted in classes, aggregated, and
		  simplified semiautomatically. The algorithm is also capable
		  of detecting data structures which can cause problems
		  passing to the next millennium, as demonstrated with an
		  example.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@InProceedings{	  gall.klösch.ea:resolving,
  author	= {Gall, H. and Klösch, R. and Weidl, J.},
  title		= {Resolving Uncertainties in object oriented
		  re-architecturing of procedural code},
  booktitle	= { Proceedings of the 7th International Conference on
		  Information Processing and Management of Uncertainty in
		  Knowledge Based Systems},
  year		= {1998},
  month		= jul,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@TechReport{	  girard.briand:reengineering,
  author	= {Girard, J.F and Briand, L.},
  title		= {Reengineering Concepts, Techniques and Tools for Component
		  Extraction},
  institution	= {CRIM, Montreal, Canada},
  year		= {1996},
  number	= {CRIM95/04-26},
  month		= may,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  girard.koschke.ea:comparison,
  author	= {Jean-Francois Girard and Rainer Koschke and Georg Schied},
  title		= {Comparison of Abstract Data Type and Abstract State
		  Encapsulation Detection Techniques for Architectural
		  Understanding},
  booktitle	= {Proceedings of the 4th  Working Conference on Reverse
		  Engineering },
  publisher	= {IEEE Computer Society Press},
  year		= {1997},
  abstract	= {In the context of the authors' research on architectural
		  features recovery, abstract data type (ADT) and abstract
		  state encapsulation (ASE, also called abstract object) have
		  been identified as two of the smallest components which are
		  useful to build a significant architectural over view of
		  the system. The authors have named these the atomic
		  components of an architecture. This paper compares five
		  published techniques which extract ADT and ASE from source
		  code. A prototype tool implementing each techniques has
		  been developed and applied to three medium size systems
		  written in C (each over 30 Kloc). The results from each
		  approach are com pared with the atomic components
		  identified by hand by a group of software engineers. These
		  people did not know the automatic techniques which were
		  going to be applied to the systems. },
  class		= {Software_Reverse_Engineering Reverse_Design
		  Encapsulation_and_Finding_Objects_in_Legacy_Code }
}

@Article{	  girard.koschke.ea:metric-based,
  author	= {Girard, J.F. and Koschke, R. and Schied, G.},
  title		= {A Metric-based Approach to Detect Abstract Data Types and
		  Abstract State Encapsulation},
  journal	= {Journal on Automated Software Engineering, Kluwer Academic
		  Publishers},
  year		= {1999},
  volume	= {6},
  number	= {4},
  pages		= {357--386},
  month		= oct,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  girard.koschke.ea:metric-based*1,
  author	= {Jean-Francois Girard and Rainer Koschke and Georg Schied},
  title		= {A metric-based approach to detect abstract data types and
		  state encapsulations},
  booktitle	= {Proceedings of the 12th International Automated Software
		  Engineering Conference, ASE'97},
  publisher	= {IEEE Computer Society Press},
  month		= {November},
  year		= {1997},
  pages		= {82-89},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@Article{	  girard.koschke:comparison,
  author	= {Girard, J.F. and Koschke, R.},
  title		= {A Comparison of Abstract Data Type and Objects Recovery
		  Techniques},
  journal	= {Journal Science of Computer Programming, Elsevier},
  year		= {2000},
  volume	= {36},
  number	= {2--3},
  pages		= {149--181},
  month		= mar,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  jacobson.lindstrvm:re-engineering,
  author	= {I. Jacobson and F. Lindstrvm},
  title		= {Re-engineering of old systems to an object-oriented
		  architecture},
  booktitle	= {OOPSLA},
  pages		= {340-350},
  year		= {1991},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@TechReport{	  kazman.carričre:playing,
  author	= {Kazman, R. and Carričre, S.J.},
  title		= {Playing detective: reconstructing software architecture
		  from available evidence},
  institution	= {Software Engineering Institute},
  year		= {1997},
  optkey	= {CMU/SEI-97-TR-010},
  type		= {Technical Report},
  number	= {CMU/SEI-97-TR-010},
  address	= {Pittsburgh, USA},
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@Article{	  khan.al-aali.ea:object-oriented,
  author	= {E. H. Khan and M. Al-A'ali and M. R. Girgis},
  title		= {Object-Oriented Programming for Structured Procedural
		  Programmers},
  journal	= {IEEE Computer},
  pages		= {48-57},
  year		= {1995},
  month		= oct,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@InProceedings{	  koschke.eisenbarth:international,
  author	= {Koschke, R. and Eisenbarth, T},
  title		= {International Workshop on Program Comprehension},
  booktitle	= {A Framework for Experimental Evaluation of Clustering
		  Techniques},
  year		= {2000},
  month		= jun,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@PhDThesis{	  koschke:atomic,
  author	= {Koschke, R.},
  title		= {Atomic Architectural Component Detection for Program
		  Understanding and System Evolution},
  school	= {University of Stuttgart},
  year		= {2000},
  address	= {Universit\"atsstrasse 38, 70569 Stuttgart, Germany},
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  koschke:incremental,
  author	= {Koschke, R.},
  title		= {An Incremental Semi-Automatic Method for Component
		  Recovery},
  booktitle	= { Working Conference on Reverse Engineering },
  pages		= {256--267},
  year		= {1999},
  month		= oct,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@Article{	  lakhotia:unified,
  author	= {Lakhotia, A.},
  title		= {A Unified Framework for Expressing Software Subsystems
		  Classification Techniques},
  journal	= {Journal Systems Software, Elsevier Science Publisher},
  year		= {1997},
  volume	= {36},
  pages		= {211--231},
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@Article{	  liu.ogando.ea:object,
  author	= {Sying S. Liu and R. M. Ogando and Norman Wilde and S. S.
		  Yau},
  title		= {An Object Finder for Program Structure Understanding in
		  Software Maintenance},
  journal	= {Software Maintenance: Research and Practice},
  volume	= {6},
  pages		= {261-283},
  year		= {1994},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@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{	  miller.znayenko:classifying,
  author	= {G. G. Miller and Z. O. Znayenko},
  title		= {Classifying Forms of Encapsulation in Object-Oriented
		  Languages},
  booktitle	= {Tools USA' 95 (Technology of Object-Oriented Languages and
		  Systems)},
  pages		= {107-117},
  year		= {1995},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@Article{	  muller.orgun.ea:reverse,
  author	= {M\"uller, H.A. and Orgun, M.A. and Tilley, S.R. and Uhl,
		  J.S.},
  title		= {A Reverse Engineering Approach to Subsystem Structure
		  Identification},
  journal	= {Journal of Software Maintenance: Research and Practice},
  year		= {1993},
  volume	= {5},
  number	= {4},
  pages		= {181--204},
  month		= dec,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sahraoui.melo.ea:applying,
  author	= {Sahraoui, H. and Melo, W. and Lounis, H. and Dumont, F.},
  title		= {Applying Concept Formation Methods to Object Identfication
		  in Procedural Code},
  booktitle	= { International Conference on Automated Software
		  Engineering },
  pages		= {210--218},
  year		= {1997},
  month		= nov,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi.kontogiannis.ea:architectural,
  author	= {Kamran Sartipi and Kostas Kontogiannis and F. Mavaddat},
  title		= {Architectural Design Recovery using Data Mining
		  Techniques},
  booktitle	= { European Conference on Software Maintenance and
		  Reengineering },
  pages		= {129-139},
  year		= {2000},
  month		= feb,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi.kontogiannis.ea:pattern,
  author	= {Kamran Sartipi and Kostas Kontogiannis and F. Mavaddat},
  title		= {A Pattern Matching Framework for Software Architecture
		  Recovery and Restructuring},
  booktitle	= {International Workshop on Program Comprehension},
  pages		= {37-47},
  year		= {2000},
  month		= jun,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi.kontogiannis:component,
  author	= {Kamran Sartipi and Kostas Kontogiannis},
  title		= {Component Clustering Based on Maximal Association},
  booktitle	= { Working Conference on Reverse Engineering },
  pages		= {103-114},
  year		= {2001},
  month		= oct,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi.kontogiannis:graph,
  author	= {Kamran Sartipi and Kostas Kontogiannis},
  title		= {A Graph Pattern Matching Approach to Software Architecture
		  Recovery},
  booktitle	= { International Conference on Software Maintenance },
  pages		= {408-419},
  year		= {2001},
  month		= nov,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi:alborz,
  author	= {Kamran Sartipi},
  title		= {Alborz: A Query-based Tool for Software Architecture
		  Recovery},
  booktitle	= {International Workshop on Program Comprehension},
  pages		= {115-116},
  year		= {2001},
  month		= may,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  sartipi:software,
  author	= {Kamran Sartipi},
  title		= {A Software Evaluation Model Using Component Association
		  Views},
  booktitle	= {International Workshop on Program Comprehension},
  pages		= {259-268},
  year		= {2001},
  month		= may,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  siff.reps:identifying,
  author	= {Michael Siff and Thomas Reps},
  title		= {Identifying Modules via Concept Analysis},
  booktitle	= {Proc. of. the Internation Conference on Software
		  Maintenance},
  pages		= {170-179},
  month		= {October},
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering Reverse_Design
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}

@Article{	  tonella:concept,
  author	= {P. Tonella},
  title		= {Concept analysis for module restructuring},
  journal	= { IEEE Computer Society  Transactions on Software
		  Engineering},
  year		= {2001},
  volume	= {27},
  number	= {4},
  pages		= {351--363},
  month		= apr,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  tzerpos.holt:acdc,
  author	= {Vassilios Tzerpos and Richard C. Holt},
  title		= {ACDC: An Algorithm for Comprehension-Driven Clustering},
  booktitle	= { Working Conference on Reverse Engineering },
  year		= {2000},
  month		= nov,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  tzerpos.holt:mojo,
  author	= {Vassilios Tzerpos and Richard C. Holt},
  title		= {MoJo: A Distance Metric for Software Clustering},
  booktitle	= { Working Conference on Reverse Engineering },
  year		= {1999},
  month		= oct,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  tzerpos.holt:on,
  author	= {Vassilios Tzerpos and Richard C. Holt},
  title		= {On the Stability of Software Clustering Algorithms},
  booktitle	= {International Workshop on Program Comprehension},
  year		= {2000},
  month		= jun,
  publisher	= { IEEE Computer Society  Press },
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  tzerpos.holt:software,
  author	= {Vassilios Tzerpos and Richard C. Holt},
  title		= {Software Botryology: Automatic Clustering of Software
		  Systems},
  booktitle	= {International Workshop on Large-Scale Software
		  Composition},
  year		= {1998},
  month		= aug,
  class		= {Encapsulation_and_Finding_Objects_in_Legacy_Code
		  System_Modularization Reverse_Design
		  Software_Reverse_Engineering}
}

@InProceedings{	  yeh.harris.ea:recovering,
  author	= {A.S. Yeh and D. Harris and H. Reubenstein},
  title		= {Recovering abstract data types and object instances from a
		  conventional procedural language},
  booktitle	= {Proc. of. the Second Working Conference on Reverse
		  Engineering},
  pages		= {227­236},
  month		= {July},
  year		= {1995},
  publisher	= {IEEE Computer Society Press},
  class		= {Software_Reverse_Engineering Reverse_Design
		  Encapsulation_and_Finding_Objects_in_Legacy_Code}
}