References of Re-Design

@InProceedings{	  ammann.cameron:inter-module,
  author	= {Manuel M. Ammann and Robert D. Cameron},
  title		= {Inter-Module Renaming and Reorganizing: Examples of
		  Program Manipulation in-the-Large},
  pages		= {354-361},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Maintaining software often requires repetetive and
		  errorprone manipulations of source code, particularly when
		  changes must be propagated across many modules. Practical
		  program manipulation tools can alleviate the problems by
		  automatically making changes throughout a program. Such
		  tools can become even more valuable when they allow for
		  manipulation in-the-large: the systematic modification of
		  all the modules that comprise a software project. We
		  demonstrate this concept with two prototype tools. An
		  inter-module renamer locates and renames all and only
		  appropriate instances of an identifier throughout a
		  project, ensuring that no conflicts arise. An inter-module
		  reorganizer automates the task of moving program entities
		  between modules such that import/export declarations are
		  properly updated for modules dependent on the moved entity
		  and for items on which the moved entity is dependent. Our
		  tools are designed for modern block-structured and
		  object-oriented languages such as Modula-3.},
  class		= {Alteration, Re-Design, Inter-module_Reorganization}
}

@InProceedings{	  appelbe.smith:pat,
  author	= {Bill Appelbe and Kevin Smith},
  title		= {PAT: A Retargetable Parallelizing Tool for Fortran},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {357-359},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {PAT (Parallelization Assistant Tool) is retargetable tool
		  that converts sequential Fortran to Parallel Fortran, for
		  IBM, Cray, and Sequent multiprocessors. It runs on a range
		  of UNIX workstations, using X windows to display source
		  code, program analysis and tranformation. PAT is intended
		  to help programmers convert their program from sequential
		  to parallel code, while simultaneously educating them in
		  exploiting and understanding applications level and
		  architectural parallelism. PAT has been installed at a
		  range of sites for over a year. This paper reports upon
		  experiences with PAT, limitations of it's approach, future
		  development and use of PAT's analysis for other tools.},
  class		= {Alteration, Re-Design,
		  From_Sequential_to_Concurrent_Execution}
}

@InProceedings{	  bar.ciupke:exploiting*1,
  author	= {Holger B{\"a}r and Oliver Ciupke},
  editor	= {Serge Demeyer and Jan Bosch},
  title		= {Exploiting design heuristics for automatic problem
		  detection},
  booktitle	= {Object-Oriented Technology (ECOOP'98 Workshop Reader)},
  series	= {Lecture Notes in Computer Science},
  volume	= {1543},
  publisher	= {Springer-Verlag},
  month		= jul,
  year		= {1998},
  class		= {Alteration, Re-Design, Problem_Detection}
}

@InProceedings{	  bosma.fielt.ea:scenarios,
  author	= {H. Bosma and E. Fielt and T. Wiggerts},
  title		= {Scenarios for the Identification of Objects in Legacy
		  Systems},
  booktitle	= {Fourth Working Conference on Reverse Engineering},
  publisher	= {IEEE Computer Society},
  year		= {1997},
  editor	= {I. Baxter and A. Quilici and C. Verhoef},
  pages		= {24-32},
  month		= {October},
  abstract	= {In this article we propose an incremental approach to the
		  identification of (business) objects in legacy
		  applications. In this approach different object
		  identification scenarios can be applied alternately. Three
		  different strategies are presented: function driven, data
		  driven and object driven objectification. We discuss these
		  scenarions and report on experiences gained from applying
		  them to a subsystem of a real-life mortgage system. We also
		  discuss related work.},
  keywords	= {legacy, objects, identification, extraction, scenarios,
		  experiences},
  class		= {From_Procedural_to_Object-Oriented Re-Design Alteration }
}

@Book{		  brodie.stonebraker:migrating,
  author	= {M.L. Brodie and M. Stonebraker},
  title		= {Migrating Legacy Systems --- Gateways, Interfaces \& The
		  Incremental Approach},
  publisher	= {Morgan Kaufmann Publishers, Inc.},
  year		= {1995},
  note		= {This book gives a detailed description of strategies for
		  migrating legacy systems. It advocates an incremental
		  approach for the migration instead of doing it in {\em one}
		  step. The legacy system is analyzed and the components to
		  be updated are identified. The legacy system and the new
		  system work in parallel and are connected via gateways.
		  Migrated components are removed from the legacy system and
		  added to the new system. The crucial steps in this process
		  are establishing the right ordering of the components to be
		  migrated and the use of powerful gateways. It is preferable
		  not to develop these gateways yourself but to obtain them
		  from third party software producers. A number of
		  case-studies is presented and these case-studies
		  demonstrate that these gateways are crucial even if all the
		  code of the legacy system becomes obsolete. The book
		  concludes with an extensive list of third party software
		  producers which produce gateways},
  class		= {Reengineering_in_General, Experiences, Alteration,
		  Re-Design}
}

@Article{	  calliss.cornelius:two,
  author	= {F.W. Calliss and B.J. Cornelius},
  title		= {Two Module-Factoring Techniques},
  journal	= {Journal of Software Maintenance: Research and Practice},
  year		= {1989},
  volume	= {1},
  pages		= {81-89},
  abstract	= {Module factoring is splitting a module into smaller
		  modules, each of which performs a distinct task. They
		  describe two techniques: one based on type families, one
		  based on imported entities.},
  class		= {Alteration, Re-Design, Inter-module_Reorganization }
}

@InProceedings{	  card.page.ea:criteria,
  author	= {D. N. Card and G. T. Page and F. E. McGarry},
  title		= {Criteria for software modularization},
  pages		= {372--377},
  booktitle	= {Proceedings of the 8th  International Conference on
		  Software Engineering },
  year		= {1985},
  publisher	= {IEEE Computer Society Press},
  month		= aug,
  class		= {Alteration, Re-Design, Inter-module_Reorganization}
}

@InProceedings{	  chu.patel:software*1,
  title		= {Software restructuring by enforcing localization and
		  information hiding},
  author	= {W Chu and S. Patel},
  pages		= {165--172},
  booktitle	= {SM92},
  year		= {1992},
  note		= { Starting with information describing function calls and
		  global variable usage, this paper presents a clustering
		  technique that generates Ada-like packages describing the
		  structure of a given software system. Has been applied to
		  several existing systems implemented in C},
  class		= {Alteration, Re-Design, Inter-module_Reorganization}
}

@TechReport{	  ciupke:tool,
  author	= {Oliver Ciupke},
  title		= {Tool Support for Automatic Problem Detection},
  institution	= {Forschungszentrum Informatik},
  year		= {1998},
  type		= {FAMOOS Achievement Report},
  number	= {A 2.7.1},
  month		= sep,
  id		= {impctut-ar271, ar271fzi},
  path		= {/fzi/prost/Projects/FAMOOS/doc/achievements/impctut-a271},
  class		= {Alteration, Re-Design, Problem_Detection}
}

@InProceedings{	  claßen.hennig.ea:cui,
  author	= {Ingo Claßen and Klaus Hennig and Ingo Mohr and Michael
		  Schulz},
  title		= {CUI to GUI Migration: Static Analysis of Character-Based
		  Panels},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {This paper reports on progress in the construction of an
		  integrated tool environment for the migration of
		  character-based panels of mainframe applications into
		  graphical user interfaces. It presents our approach for
		  static analysis of character-based panels that is based on
		  the identification of dialog entities in panels using
		  generalized descriptions of panel areas and describes a
		  tool supporting the identification process. The goal of our
		  approach is to increase the level of automation in the
		  migration process compared to existing migration tools. },
  class		= {Alteration, Re-Design, User_Interface_Migration}
}

@InProceedings{	  colbrook.smythe:retrospective,
  author	= {A. Colbrook and C. Smythe},
  title		= {The Retrospective Introduction of Abstraction into
		  Software},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  pages		= {166-173},
  abstract	= {The re-engineering of program control flow schemas,
		  although a widely advocated preventive maintenance
		  technique, fails to address the underlying problems of
		  software which contains poorly structured data.
		  
		  A technique is proposed which facilitates the retrospective
		  introduction of abstract data types into existing systems
		  and the corresponding software tool to aid this process is
		  presented. The resulting source code is structured in terms
		  of both data and control flow, thereby significantly
		  promoting the ease of maintenance. },
  class		= {Alteration, Re-Design,
		  Introduction_of_Abstract_Data_Types_and_Objects}
}

@Article{	  configuration-management-system:olin,
  author	= {Reengineering a Configuration-Management System},
  title		= {Olin Bray and Michael Hess},
  journal	= {IEEE Software},
  year		= {1995},
  volume	= {12},
  number	= {1},
  pages		= {55-63},
  month		= {January},
  class		= {Reengineering_in_General, Experiences, Alteration,
		  Re-Design, From_Mainframe_to_Client-Server_Architecture}
}

@InProceedings{	  csaba:experience,
  author	= {László Csaba},
  title		= {Experience with User Interface Re-engineering:
		  Transferring DOS Panels to Windows},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {This article describes a method of user interface
		  reengineering used in a project of turning a large
		  character based archaic DOS application into a modern
		  Windows application. The program was originally written for
		  mainframe environment in COBOL language. During the
		  conversion the working core had to be left unchanged. In
		  the applied method the original program - recompiled for
		  Windows with the I/O calls replaced - is run and remote
		  controlled through a communications module by the new
		  wrapping application. The new program, the Artificial User
		  Program was developed with S-Prog, a highly effective
		  visual tool. Some parts of the source were generated by
		  Word Basic macros. },
  class		= {Alteration, Re-Design, User_Interface_Migration},
  keywords	= {DOS, Windows, User Interface Reengineering, Remote
		  Controlling, Artificial User Program, S-Prog, Word Basic}
}

@Unpublished{	  fanta.rajlich:reengineering,
  author	= {Richard Fanta and Vaclav Rajlich},
  title		= {Reengineering Deteriorated Object-oriented Code},
  year		= {1998},
  class		= {Alteration, Re-Design,
		  Inhertiance_Hierarchies_Restructuring}
}

@InProceedings{	  g-snelting.tip:reengineering,
  author	= {G. Snelting, and F. Tip},
  title		= {Reengineering Class Hierarchies using Concept Analysis},
  booktitle	= {Proc. SIGSOFT Symposium on Foundations of Software
		  Engineering},
  publisher	= {ACM},
  year		= {1998},
  key		= {Concept Analysis},
  class		= {Inhertiance_Hierarchies_Restructuring
		  Software_Reverse_Engineering Static_Data_Flow_Analysis
		  Reverse_Design Re-Design Static_Control_Flow_Analysis
		  Fundamental_Methods_in_Reverse_Design Alteration
		  Static_Analysis }
}

@InProceedings{	  gifford.harrison:prets,
  author	= {Bruce Gifford and Warren Harrison},
  title		= {{pRETS}: A Parallel Reverse-Engineering Tool Set For the
		  Adaption of Sequential Programs},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {344-346},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  class		= {Alteration, Re-Design,
		  From_Sequential_to_Concurrent_Execution}
}

@InProceedings{	  jahnke.schäfer.ea:design,
  author	= {J.-H. Jahnke and W. Schäfer and A. Zündorf},
  title		= {A Design Environment for Migrating Relational to
		  Object-Oriented Database Systems},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1996},
  publisher	= {IEEE Computer Society Press},
  year		= {1996},
  abstract	= {Object-oriented technology has become mature enough to
		  satisfy many new requirements coming from areas like
		  computer-aided design (CAD) computer-integrated
		  manufacturing (CIM) or software engineering (SE). However a
		  competetive information management infrastructure often
		  demands to merge data from CAD- CIM- or SE-systems with
		  business data stored in a relational system. In addition
		  complex dependencies between those data stored in the
		  different systems might exist and should be maintained. One
		  approach for seamless integration of object-oriented and
		  relational systems is to migrate the data (and the
		  corresponding schema) from a relational to an
		  object-oriented system. In this paper we describe an
		  integrated design environment that supports the migration
		  process and overcomes major drawbacks of comparable
		  approaches.},
  class		= {Alteration, Re-Design, Database_Migration }
}

@Book{		  jahnke.schäfer.ea:generic,
  author	= {J.-H. Jahnke and W. Schäfer and A. Zündorf},
  title		= {Generic Fuzzy Reasoning Nets as a Basis for Reverse
		  Engineering Relational Database Applications},
  booktitle	= {Proceedings of the European Conference on Software
		  Engineering 1997},
  publisher	= {Springer Verlag},
  year		= {1997},
  month		= {September},
  abstract	= {Object-oriented technology has become mature enough to
		  satisfy many new requirements coming from areas like
		  computer-aided design (CAD) computer-integrated
		  manufacturing (CIM) or software engineering (SE). However a
		  competitive information management infrastructure often
		  demands to merge data from CAD- CIM- or SE-systems with
		  business data stored in a relational system. One approach
		  for seamless integration of object- oriented and relational
		  systems is to migrate from a relational to an object-
		  oriented system. The first step in this migration process
		  is reverse engineering of the legacy database. In this
		  paper we propose a new graphical and executable language
		  called Generic Fuzzy Reasoning Nets for modelling and
		  applying reverse engineering knowledge. In particular this
		  language enables to define and analyse fuzzy knowledge
		  which is usually all what is available when an existing
		  database schema has to be reverse engineered into an
		  object-oriented one. The analysis process is based on
		  executing a fuzzy petri net which is parameterized with the
		  fuzzy knowledge about a concrete data base application.},
  class		= {Alteration, Re-Design, Database_Migration }
}

@PhDThesis{	  jahnke:managing,
  author	= {Jens-Holger Jahnke},
  title		= {Managing Uncertainty and Inconsistency in Database
		  Reengineering Processes},
  school	= {University of Paderborn, Department of Mathematics and
		  Computer Science},
  year		= {1999},
  address	= {33095 Paderborn, Germany},
  month		= {August},
  abstract	= {This dissertation tackles one of the most urgent problems
		  in today's information technology, namely the renovation
		  and migration of legacy information systems to modern
		  platforms and net-centric architectures. In this context,
		  several methods, tools, and processes have been proposed to
		  support reengineering and modernizations of legacy database
		  applications. This can be a complex task because many
		  legacy databases have grown over several generations of
		  programmers and lack a sufficient documentation.
		  Computer-aided reengineering methods and processes have a
		  great potential to reduce the complexity and risks involved
		  in database design recovery and migration projects. Still,
		  current reengineering tools are hardly adopted for
		  practical problems in industry because they often make
		  idealistic assumptions about the structure of legacy
		  systems and the characteristics of reengineering processes.
		  The goal of this thesis is to provide concepts and
		  techniques to overcome these severe limitations. In
		  particular, our focus is on developing mechanisms to manage
		  uncertainty and inconsistency in computer-aided databases
		  reengineering processes. In practice, uncertain knowledge
		  plays an important role in activities aiming to recover
		  conceptual design documents for large idiosyncratic
		  implementation structures. This fact is neglected in
		  current database reengineering methods and tools. In this
		  dissertation, we identify and extend a theory that provides
		  a suitable basis to deal with uncertain reengineering
		  knowledge and allows to implement practical tools and
		  environments to support reengineering processes. The
		  requirement for consistency management considers the fact
		  that it is unrealistic to presume that database
		  reengineering processes can be executed in a number of
		  sequential phases or steps without iterations. In practice,
		  larger reengineering projects comprise many process
		  iterations due to various reasons like incomplete knowledge
		  about legacy implementation structures or necessary
		  "on-the-fly" modifications of the legacy system. Detecting
		  and removing inconsistencies caused by such iterations
		  significantly increase costs and durations of current
		  reengineering projects. In this thesis, we employ graph
		  transformation theory to develop mechanisms which allow to
		  detect and eliminate inconsistencies between legacy schema
		  implementations and their abstract representation,
		  automatically. Our results have been implemented in the
		  database reengineering environment Varlet and evaluated
		  with an industrial project. They are suitable to complement
		  many existing approaches in the domain of information
		  system reengineering and migration. As an example, we
		  describe the integration of Varlet with an existing
		  middleware product for data integration.},
  class		= {Using_graphs Database_Migration Re-Design
		  Data_Reverse_Engineering Alteration
		  Software_Reverse_Engineering
		  Intermediate_Representations_of_Source_Code },
  url		= {http://www.csr.uvic.ca/~jens/Docs/thesis.pdf}
}

@InProceedings{	  li.yang.ea:generating,
  author	= {Yang Li and Hongji Yang and William Chu},
  title		= {Generating Linkage between Source Code and Evolvable
		  Domain Knowledge for the Ease of Software Evolution},
  booktitle	= {Proceedings of IEEE International Symposium on Principles
		  of Software Evolution (ISPSE2000)},
  publisher	= {IEEE Computer Society Press},
  year		= {2000},
  editor	= {},
  chapter	= {},
  pages		= {},
  address	= {Kanazawa, Japan},
  month		= {Nov},
  url		= {},
  abstract	= {Business software systems unexceptably need to be evolved
		  to cater for new/changed requirement coming from market or
		  adapt to new operating environment. One of the most
		  significant problems in current software evolution practice
		  is that software maintainers usually find it quite
		  difficult to locate the program sections in source code
		  which need to be modified and to identify the extent to
		  which the changes in these program sections could affect
		  the rest of the software system. In this paper, we propose
		  a knowledge engineering based approach to solving this
		  problem. In particular, we match a software program with a
		  pre-defined domain knowledge base in the representation of
		  simplified semantic network we proposed in order to link
		  the source program with its domain level interpretation.
		  The domain knowledge base contains only important domain
		  knowledge where potential evolutions could occur, which
		  reduces the size of the knowledge base. Moreover, a domain
		  oriented program partitioning method is also proposed to
		  cut a program into self-contained modules with manageable
		  size. In these ways, the computational complexity involved
		  in generating the linkage is significantly reduced which
		  makes this approach applicable. An example shows that
		  software evolution can be easily carried out as the domain
		  knowledge it links with evolves. },
  keywords	= {software evolution, knowledge engineering, program
		  partitioning, evolvable domain knowledge, semantic
		  network},
  note		= {This paper gives engineering-oriented considerations to
		  link generation between domain knowledge and source code
		  prior to successful software evolution.},
  class		= {Software_Evolution Knowledge-Based_Concept_Assignment
		  Using_graphs Change_Impac
		  Cognitive_Processes_in_Human_Program_Understanding Metrics
		  Reverse_Design Re-Design System_Modularization
		  Recovery_of_Software_Architecture
		  Metric-Based_Methods_in_Reverse_Design Alteration
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning
		  Intermediate_Representations_of_Source_Code
		  Software_Reverse_Engineering }
}

@InProceedings{	  merlo.girard.ea:reverse,
  author	= {E. Merlo and J.F. Girard and K. Kontogiannis and P.
		  Panangaden and R. {De Mori}},
  title		= {Reverse engineering of user interfaces.},
  booktitle	= {Working Conference on Reverse Engineering},
  year		= {1993},
  month		= {May 21-23},
  address	= {Baltimore, Maryland},
  pages		= {171-179},
  note		= { Extracts user interface descriptions from COBOL/CICS
		  source code and translates them to abstract behaviour
		  descriptions based on process algebra (CCS). Part of the
		  analysis is done using Refine/COBOL. The translation itself
		  is done manually},
  class		= {Alteration, Re-Design, User_Interface_Migration},
  ftp		= {ftp.crim.ca/gl/public/wcre93.ps.Z}
}

@InProceedings{	  moore.rugaber.ea:knowledge-based,
  author	= {Melody Moore and Spencer Rugaber and Phil Seaver},
  title		= {Knowledge-based User Interface Migration},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  abstract	= {A significant problem in reengineering large systems is
		  adapting the user interface to a new environment. Often,
		  drastic changes in the user interface are inevitable, as in
		  migrating a text-based system to a workstation with
		  Graphical User Interface capabilities. This experience
		  report chronicles a study of user interface migration
		  issues, examining and evaluating current tools and
		  techniques. It also describes a case study undertaken to
		  explore the use of knowledge engineering to aid in
		  migrating interfaces across platforms.},
  keywords	= {User Interface, reengineering, migration, reverse
		  engineering, knowledge-based},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/uif\_migration.ps}
		  ,
  class		= {Alteration, Re-Design, User_Interface_Migration}
}

@InProceedings{	  moore.rugaber:issues,
  author	= {Melody Moore and Spencer Rugaber},
  title		= {Issues in User Interface Migration},
  booktitle	= {Proceedings of the Third Software Engineering Research
		  Forum},
  address	= {Orlando Florida},
  year		= {1993},
  month		= nov,
  abstract	= { In today's continually changing world of computing, many
		  old and outdated systems are being migrated to newer,
		  faster, and less proprietary platforms. Reengineering
		  strategies have traditionally concentrated on the
		  functional design of the program itself. User interfaces,
		  however, present some unique problems for migration, since
		  often the user interface changes drastically -- for
		  example, migrating from a text-based interface to a
		  graphical user interface. Here we present work that
		  identifies the important issues in effectively migrating
		  user interfaces between heterogeneous platforms and
		  different display technologies.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/serf.ps},
  class		= {Alteration, Re-Design, User_Interface_Migration}
}

@InProceedings{	  moore:guru,
  author	= {I. Moore},
  title		= {Guru - A tool for automatic Restructuring of Self
		  Inheritance Hierarchies},
  booktitle	= {Tools USA' 95 (Technology of Object-Oriented Languages and
		  Systems)},
  pages		= {267-275},
  year		= {1995},
  abstract	= {},
  class		= {Alteration, Re-Design,
		  Inhertiance_Hierarchies_Restructuring}
}

@InProceedings{	  moore:technique,
  author	= {Melody Moore},
  title		= {A Technique for Reverse Engineering User Interfaces},
  booktitle	= {Proceedings of the Fourth Reverse Engineering Forum},
  publisher	= {IEEE Computer Society},
  year		= {1994},
  month		= {November},
  note		= {Presentation slides available},
  class		= {Reengineering_in_General User_Interface_Migration
		  Re-Design Alteration }
}

@InProceedings{	  newcomb.markosian:automating,
  author	= {Ph. Newcomb and L. Markosian},
  title		= {Automating the modularization of large {COBOL} programs:
		  application of an enabling technology for reengineering},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {222--230},
  year		= {1993},
  note		= { Experience report using the Software Refinery to build a
		  modularization tool for COBOL},
  class		= {Alteration, Re-Design, Inter-module_Reorganization}
}

@InProceedings{	  petit.toumani.ea:towards,
  author	= {J-M. Petit and F. Toumani and J. Boulicaut and J.
		  Kouloumdjian},
  title		= {Towards the reverse engineering of denormalized relational
		  databases},
  booktitle	= {Proc. 12th International Conference on Data Engineering},
  publisher	= {S. Su},
  year		= {1996},
  editor	= {IEEE Computer Society},
  pages		= {218-227},
  address	= {New Orleans},
  month		= {Feb},
  class		= {Database_Migration Re-Design Alteration }
}

@InProceedings{	  pidaparthi.cysewski:case,
  author	= {Sagar Pidaparthi and Grzegorz Cysewski},
  title		= {Case study in Migration to Object-Oriented System
		  structure Using Design Transformation Methods},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Procedural programming languages are currently being used
		  extensively in the software industry for a wide range of
		  applications. Most of the old procedural programs, used
		  today may not have any documentation which can be used in
		  maintenance processes. In the recent time there has been a
		  paradigm shift towards object oriented design and
		  programming, from algorithmic decomposition, structured
		  design and procedural implementation. Hence, there is a
		  growing need to restructure old programs which have a poor
		  architecture during evolutionary processes. It is more
		  economic to restructure existing software into object
		  oriented topology by identifying objects within the subject
		  system than to redesign software starting from scratch.
		  Object identification relies upon program analysis and a
		  study of inter component relationships and dependencies.
		  Researchers in re-engineering have proposed some guidelines
		  to identify objects from within the subject systems. Design
		  Transformation is the first step in reengineering existing
		  programs, which can be followed by program translation
		  methods to transform a procedural program into the newly
		  identified structure. This paper reports the results of the
		  application of three object identification methods on a
		  sample procedural program. Secondly it provides a design of
		  a system for program component storage and object
		  identification },
  class		= {Alteration, Re-Design,
		  From_Procedural_to_Object-Oriented}
}

@InProceedings{	  rugaber.doddapaneni:transition,
  author	= {Spencer Rugaber and Srinivas Doddapaneni},
  title		= {The Transition of Application Programs From COBOL to a
		  Fourth Generation Language},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  month		= sep,
  abstract	= {It is becoming increasingly desirable to move older
		  application programs from their traditional mainframe
		  execution environments to networkes workstations. These
		  management information systems are most often written in
		  COBOL and store their data in files. A networked
		  environment enables the use of relational database
		  management system and its fourth generation access
		  language, SQL. A conceptual framework is described that
		  comprises a variety of stategies for making such a
		  transition. Decision citeria for selecting among them are
		  then presented. Finally, a variety of experiments intended
		  to explore the strategies are recounted. The experiments
		  include efforts to automate parts of the process.},
  address	= {Montreal, Canada},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/transit.ps}
		  ,
  class		= {Alteration, Re-Design,
		  From_Mainframe_to_Client-Server_Architecture}
}

@InProceedings{	  sneed.nyary:downsizing,
  author	= {Harry M. Sneed and Erika Nyary},
  title		= {Downsizing Large Application Programs},
  pages		= {110--119},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {There is a great demand in industry to migrate from the
		  mainframe to distributed client/server type systems. The
		  following paper proposes three methods of splitting up
		  oversized host application programs with the goal of
		  offloading them on to workstation computers. The three
		  apporaches are by procedural connection, functional
		  decomposition, and abstract data typing. The author
		  describes his experience in applying each of the methods
		  and explains what other measures are necessary to downsize
		  a program.},
  class		= {Alteration, Re-Design,
		  From_Mainframe_to_Client-Server_Architecture}
}

@InProceedings{	  sneed:migration,
  title		= {Migration of procedurally oriented {COBOL} programs in an
		  object-oriented architecture},
  author	= {H. Sneed},
  booktitle	= {\cite{SM92}},
  pages		= {105--116},
  year		= {1992},
  note		= { The subject of this paper is to describe the migration of
		  procedurally structured COBOL into functionally equivalent
		  object-oriented programs. Their major differences are
		  described together with an approach to bridge the gap
		  between the two},
  class		= {Alteration, Re-Design,
		  From_Procedural_to_Object-Oriented}
}

@TechReport{	  snelting.tip:reengineering,
  author	= {Gregor Snelting and Frank Tip},
  title		= {Reengineering Class Hierarchies Using Concept Analysis},
  organization	= {IBM T.J. Watson Research Center},
  year		= {1997},
  type		= {Technical Report},
  number	= {RC 21164(94592)24APR97},
  address	= {IBM T.J. Watson Research Center, P.O. Box 704, Yorktown
		  Heights, NY 10598, USA},
  month		= {April},
  keywords	= {concept analysis, inheritance hierarchy restructuring,
		  C++},
  note		= {There is also an extended journal version of this article
		  in ACM SIGSOFT 1998.},
  class		= {Inhertiance_Hierarchies_Restructuring Re-Design Alteration
		  }
}

@InProceedings{	  snelting.tip:reengineering*1,
  author	= {Gregor Snelting and Frank Tip},
  title		= {Reengineering Class Hierarchies Using Concept Analysis},
  publisher	= {ACM},
  booktitle	= {ACM SIGSOFT Symposium on the Foundation of Software
		  Engineering},
  year		= {1998},
  keywords	= {Reengineering of class hierarchies, OOP, object-oriented
		  programming, concept analysis},
  class		= {Reengineering Alteration Re-Design
		  Inhertiance_Hierarchies_Restructuring}
}