References of Alteration

@InProceedings{	  abbattista.lanubile.ea:experiment,
  author	= { F. Abbattista and F. Lanubile and G. Mastelloni and G.
		  Visaggio },
  title		= { An Experiment on the Effect of Design Recording on Impact
		  Analysis },
  booktitle	= { Proceedings of the International Conference on Software
		  Maintenance (ICSM~'94), {\rm (Victoria, B.C.; Sept. 19-23,
		  1994)}},
  year		= { September 1994 },
  editor	= { Hausi A. M\"{u}ller and Mari Georges },
  pages		= { 253-259 },
  abstract	= { },
  class		= {Alteration, Change_Impact }
}

@TechReport{	  al-zoubi.prakash:software,
  author	= {Al-Zoubi, R. and Prakash, A.},
  title		= {Software Change Analysis via Attributed Dependency
		  Graphs},
  year		= {1991},
  month		= {May},
  number	= {CSE-TR-95-91},
  institution	= {Department of EECS, University of Michigan},
  class		= {Alteration, Change_Impact,Software_Reverse_Engineering,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Static_Analysis }
}

@PhDThesis{	  al-zoubi:attributed,
  author	= {Ratib H. Al-Zoubi},
  title		= {Attributed Graph-Based Representations for Software View
		  Generation and Impact-of-Change Analysis},
  school	= {The University of Michigan},
  year		= {1992},
  abstract	= {Great ref. on change analysis; mostly PITS. Good related
		  work info. Tool is called SCAN.},
  class		= {Alteration, Change_Impact,Software_Reverse_Engineering,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs}
}

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

@Article{	  ammarguellat:control-flow,
  title		= {A Control-flow normalization algorithm and its
		  complexity},
  author	= {Z. Ammarguellat},
  journal	= {{IEEE} Transactions on Software Engineering},
  volume	= {18},
  number	= {3},
  pages		= {237--251},
  year		= {1992},
  note		= { A simple method is presented for normalizing the
		  control-flow of programs to facilitate program
		  transformations, program analysis, and automatic
		  parallelization. This method does not make use of code
		  replication. The normalization results in a restructuring
		  of the code that obviates the need for control dependency
		  relations},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@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{	  arango.baxter.ea:maintenance,
  author	= {Guillermo Arango and Ira Baxter and Peter Freeman},
  title		= {Maintenance and Porting of Software by Design Recovery},
  booktitle	= {CSM'85: Proceedings of the 1985 Conference on Software
		  Maintenance, {\rm (Washington, DC; November 11-13, 1985)}},
  year		= {November 1985},
  pages		= {42-49},
  abstract	= {DRACO paper on porting through transformation from source
		  code to abstraction back to new code. Captures
		  domain-specific knowledge.},
  class		= {Reengineering_in_General, Experiences, Alteration,
		  Re-Code, Program_Transformations,
		  Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning },
  keywords	= {domain modeling, domain analysis, DRACO}
}

@Article{	  arango.baxter.ea:tmm*1,
  author	= {Guillermo Arango and Ira Baxter and Peter Freeman and
		  Christopher Pidgeon},
  title		= {{TMM}: Software Maintenance by Transformation},
  journal	= {IEEE Software},
  month		= {May},
  year		= {1986},
  volume	= {3},
  number	= {3},
  pages		= {27-39},
  abstract	= { . Another DRACO-based paper. . Uses least common
		  abstractions. },
  keywords	= {domain modeling, domain analysis, DRACO},
  class		= {Reengineering_in_General, Experiences, Alteration,
		  Re-Code, Program_Transformations,
		  Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Human_Oriented_Concept_Assignment_by_Informal_Reasoning}
}

@InProceedings{	  arnold.bohner:impact,
  author	= {Robert S. Arnold and Shawn A. Bohner},
  title		= {Impact Analysis - Towards a Framework for Comparison},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  pages		= {292-301},
  abstract	= {The term ``impact analysis'' is used with many meanings.
		  We define a three-part framework for characterizing and
		  comparing diverse impact analysis approaches. The parts
		  correspond to how an appraoch is used to accomplish impact
		  analysis, how an approach does impact analysis internally,
		  and the effectiveness of the impact analysis approach. To
		  illustrate the frameworks's application, we classify five
		  impact analysis approaches according to it.},
  class		= {Alteration, Change_Impact}
}

@InProceedings{	  ash.alderete.ea:using,
  author	= { D. Ash and J. Alderete and P.W. Oman and B. Lowther },
  title		= { Using Software Maintainability Models to Track Code
		  Health },
  booktitle	= { Proceedings of the International Conference on Software
		  Maintenance (ICSM~'94), {\rm (Victoria, B.C.; Sept. 19-23,
		  1994)}},
  year		= { September 1994 },
  editor	= { Hausi A. M\"{u}ller and Mari Georges },
  pages		= { 154-160 },
  abstract	= { },
  class		= {Alteration, Maintainability }
}

@InProceedings{	  ashcroft.manna:translation,
  title		= {The translation of GOTO programs into WHILE programs},
  author	= {E. Ashcroft and Z. Manna},
  booktitle	= {Proceedings of {IFIP} Congress 71},
  editor	= {C.V. Freiman and J.E. Griffith and J.L. Rosenfeld},
  volume	= {1},
  pages		= {250--255},
  publisher	= {North-Holland},
  year		= {1972},
  note		= { It is shown that every flowchart program can be written
		  without go to statements by using while statements. The
		  transformation does not give rise to less efficient
		  programs and, moreover, the structure of the original
		  flowchart program is preserved},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@InProceedings{	  avellis:case,
  author	= {Giovanna Avellis},
  title		= {{CASE} Support for Software Evolution: A Dependency
		  Approach to Control the Change Process},
  booktitle	= {{CASE'92}: Proceedings of the fifth international workshop
		  on computer-aided software engineering, {\rm (Montr\'{e}al,
		  Qu\'ebec; July 6-10, 1992)}},
  year		= {July 1992},
  pages		= {62-73},
  publisher	= {IEEE Computer Society Press (Order Number 2960)},
  abstract	= {},
  class		= {Alteration, Change_Impact }
}

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

@Article{	  baxter:design,
  author	= {Ira D. Baxter},
  title		= {Design Maintenance Systems},
  journal	= {Communications of the ACM},
  month		= {April},
  year		= {1992},
  volume	= {35},
  number	= {4},
  pages		= {73-89},
  abstract	= { . DMS . Advocates a transformational approach to SM at
		  the design level. . Maintain the design, generate the
		  implementation. . Uses TCL (!): Transformation Control
		  Language. . "Maintenance deltas": maintenance = applying
		  deltas to design. },
  class		= {Alteration, Re-Code, Program_Transformations }
}

@InProceedings{	  benedusi.benvenuto.ea:role,
  author	= {Benedusi, P. and Benvenuto, V. and Tomacelli, L.},
  title		= {The Role of Testing and Dynamic Analysis in Program
		  Comprehension Supports},
  editor	= {Fadini, Bruno and Rajlich, Vaclav},
  booktitle	= {Proceedings of the IEEE Second Workshop on Program
		  Comprehension},
  year		= {1993},
  month		= {July},
  pages		= {149-158},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Dynamic_Analysis,
		  Alteration, Change_Test }
}

@InProceedings{	  benedusi.cimitile.ea:postmaintenance,
  author	= {P. Benedusi and Aniello Cimitile and De Carlini, Ugo},
  title		= {Postmaintenance Testing based on Path Change Analysis},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1988},
  year		= {1988},
  pages		= {352-361},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  class		= {Alteration, Change_Test}
}

@InProceedings{	  bennet.bull.ea:transformation,
  title		= {A transformation system for maintenance: turning theory
		  into practice},
  author	= {K. Bennet and T. Bull and H. Yang},
  pages		= {146--155},
  booktitle	= {\cite{SM92}},
  year		= {1992},
  note		= { Describes the architecture of the Maintainer's Assistant,
		  a reverse engineering tool based on program
		  transformations. Discusses the role of metrics in selecting
		  appropriate transformations. Also see~\cite{WB93}},
  class		= {Alteration, Re-Code, Program_Transformations}
}

@InProceedings{	  blaha.premerlani:catalog,
  author	= {michael blaha and william premerlani},
  title		= {A catalog of object model transformations},
  booktitle	= {Third Working Conference on Reverse Engineering},
  publisher	= {IEEE},
  year		= {1996},
  abstract	= {The process of software development is gradually achieving
		  more rigor. Proficient develoeprs now construct software
		  indirectly through the abstraction of models. Models allow
		  a developer to focus on the essential aspects of an
		  application and defer details. Transformations extend the
		  power of models, as the developer can substitute refinement
		  and optimization of models for tedious manipulation of
		  code. This paper catalogs object modeling transformations
		  that we have encountered in our application work.},
  keywords	= {model, reverse engineering, transformation},
  class		= {Re-Code Program_Transformations Alteration }
}

@Article{	  boehm.jacopini:flow,
  author	= {C. Boehm and G. Jacopini},
  title		= {Flow Diagrams, Turing Machines and Languages with only Two
		  Formation Rules},
  journal	= {Communications of the ACM},
  year		= {1966},
  pages		= {366-371},
  month		= may,
  abstract	= {This paper contains a proof that every program with gotos
		  can be transformed into a semantically equivalent program
		  without goto. A transformation algorithm is given. },
  contents	= {Wolfgang Gellerich: Die Autoren beweisen(!), dass man ohne
		  GOTO auskommt und geben, wenn ich mich richtig erinnere,
		  auch einen allgemeinen Umstrukturierungsalgorithmus an, der
		  aber fuer die Praxis nicht taugt.},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

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

@InProceedings{	  bush:automatic,
  author	= {Eric Bush},
  title		= {The Automatic Restructuring of COBOL},
  booktitle	= {CSM'85: Proceedings of the 1985 Conference on Software
		  Maintenance, {\rm (Washington, DC; November 11-13, 1985)}},
  year		= {November 1985},
  pages		= {35-41},
  abstract	= {Reduction of flow graphs in COBOL programs into so-called
		  normal form. PITS},
  class		= {Alteration, Re-Code, Control_Flow_Normalization }
}

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

@InProceedings{	  chu:re-engingeering,
  author	= {William C. Chu},
  title		= {A Re-engingeering Approach to Program Translation},
  pages		= {42--50},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Traditional program translation takes a program written in
		  some source language and creates a semantically equivalent
		  program in some target language. A translation via
		  transliteration and refinement is the major approach, in
		  which the source program is first transliterated into the
		  target language on a line-by-line basis and various
		  refinements are then applied to improve the produced target
		  program. In many cases, it serves the purpose of
		  correctness but it is quite liminted to satisfy the other
		  goals, such as the improvement of readability,
		  maintainability, and reusability. Another approach,
		  translation via abstraction and reimplementation, was
		  proposed to satisfy these goals. However, this approach is
		  currently not able to apply to the programs of commercial
		  size and complexity. This paper presents a re-engineering
		  approach to program translation.},
  class		= {Alteration, Re-Code, Source-to-Source-Translation}
}

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

@PhDThesis{	  cremer:graphbasierte,
  author	= {Katja Cremer},
  title		= {Graphbasierte Werkzeuge zum Reverse Engineering und
		  Reengineering},
  school	= {RWTH Aachen},
  year		= {2000},
  address	= {ISBN 3-8244-0497-4, Deutscher Universitätsverlag},
  class		= {Re-Code Program_Transformation Alteration }
}

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

@TechReport{	  gray.bickmore.ea:reengineering,
  author	= {R. Gray and T. Bickmore and S. Williams},
  institution	= {InVision Software Reengineering, Software Technology
		  Center, Lockheed Palo Alto Laboratories},
  title		= {Reengineering Cobol Systems to Ada},
  year		= {1995},
  note		= { This paper describes the reengineering of 50,000 lines of
		  Cobol code and the translation to Ada. The goal was to do
		  it as automatically as possible. An inferential method was
		  used to obtain all needed information from the Cobol code
		  itself, no external information from users or programmers
		  was needed. The authors claim that inferential methods will
		  be the basis of the reengineering technology of the 21th
		  century},
  class		= {Alteration, Re-Code, Program_Transformations,
		  Source-to-Source-Translation}
}

@Article{	  grisworld.notkin:automated,
  key		= {Grisworld \& Notkin, 1993},
  author	= {Wiliam Grisworld and David Notkin},
  title		= {Automated Assistance for Program Restructuring},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1993},
  volume	= {2},
  number	= {3},
  pages		= {228-269},
  month		= jul,
  abstract	= {Maintenance tends to degrade the structure of software,
		  ultimately making maintenance more costly. At times, then,
		  it is worthwhile to manipulate the structure of a system to
		  make changes easier. However, manual restructuring is an
		  error-prone and expensive activity. By separating
		  structural manipulation from other maintenance activities,
		  the semantics of a system can be held constant by a tool,
		  assuring that no errors are introduced by restructuring. To
		  allow the maintenance team to focus on the aspects of
		  restructuring and maintenance requiring human judgment, a
		  transformation-based can be provided - based on a model
		  that exploits preserving data flow dependence and control
		  flow dependence - to automate the repetitive, error-prone,
		  and computationally demanding aspects of restructuring. A
		  set of automatable transformations is introduced; their
		  impact on structure is desribed, and their usefulness is
		  demonstrated in examples. A model to aid building
		  meaning-preserving restructuring transformations is
		  described, and its realization in a functioning prototype
		  tool for restructuring Scheme programs is discussed.},
  class		= {Alteration, Re-Code, Source-to-Source-Translation}
}

@InProceedings{	  harrold.malloy:data,
  author	= {Mary Jean Harrold and Brian A. Malloy},
  title		= {Data Flow Testing of Parallelized Code},
  pages		= {272-281},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {Although there is much interest in reengineering programs
		  for parallel execution, little work has been done to assist
		  the maintainer in testing these programs in their new
		  environment. The authors present a new system for
		  reengineering and retesting programs for execution in a
		  shared memory multiprocessor environment. Our system
		  consists of two main components: a compiler that
		  reengineers a sequential program for execution on shared
		  memory multiprocessors and a data flow tester for the
		  parallelized code. We have made several important
		  enhancements to an existing parallelizing compiler,
		  including an efficient intermediate program representation
		  on which we perform data flow analysis. Our compiler also
		  inserts probes in a parallelized program to make it
		  testable in its new environment. By inserting the probes in
		  appropriate places, a compact execution trace is produced.
		  Our data flow tester uses a new dynamic data flow analysis
		  algorithm to determine the test case coverage.},
  class		= {Alteration, Change_Test}
}

@Article{	  hartmann.robson:techniques,
  title		= {Techniques for selective revalidation},
  author	= {J. Hartmann and D.J. Robson},
  journal	= {{IEEE} Software},
  volume	= {7},
  number	= {1},
  pages		= {31--36},
  year		= {1990},
  note		= { A systematic and automated approach is discussed to
		  effectively revalidate modified software while minimizing
		  the time and cost involved in maintenance testing},
  class		= {Alteration, Change_Test}
}

@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{	  johnson:substring,
  author	= {Howard Johnson},
  title		= {Substring Matching for Clone Detection and Change
		  Tracking},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  pages		= {120-126},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Legacy systems pose problem to maintainers that can be
		  solved partially with effective tools. A prototype tool for
		  determining collections of files sharing a large amount of
		  text has been developed and applied to a 40 megabyte source
		  tree containing two releases of the gcc compiler.
		  Similarities in source code and documentation corresponding
		  to software cloning, movement and inertia between releases,
		  as well as the effects of preprocessing easily stand out in
		  a way that immediately conveys nonobvious structural
		  information to maintainer taking responsibility for such a
		  system.},
  class		= {Alteration, Differences_between_Source_Code_Versions}
}

@Article{	  kozaczynski.ning.ea:program,
  key		= {Kozaczynski et al.},
  author	= {Wojtek Kozaczynski and Jim Q. Ning and Andre Engberts},
  title		= {Program Concept Recognition and Transformation},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {1065--1075},
  volume	= {18},
  number	= {12},
  month		= dec,
  year		= {1992},
  note		= { An approach to automated concept recognition and its
		  application to maintenance-related program transformations
		  is described. An interesting point here is that
		  transformation of code can be expressed as transformation
		  of abstract concepts},
  abstract	= {Syntactically, a computer program is a sequence of
		  characters. Semantically, however, it contains abstract
		  high-level conceptual information or concepts. The
		  automated recognition of these concepts can greatly aid the
		  understanding of programs and therefore support many
		  software maintenance and reengineering activities. This
		  paper describes an approach to automated concept
		  recognition and its application to maintenance-related
		  program transformations. A unique characteristic of this
		  approach is that transformations of code can be expressed
		  as transformations of abstract concepts. This significantly
		  elevates the level of transformation specifications.},
  location	= {CMU E \&{} S Library},
  class		= {Alteration, Re-Code, Source-to-Source-Translation}
}

@InProceedings{	  kung.gao.ea:change,
  key		= {Kung et. al, 1994},
  author	= {D. Kung and J. Gao and P. Hsia and F. Wen and Y. Toyoshima
		  and C. Chen},
  title		= {Change Impact Identification in Object Oriented Software
		  Maintenance},
  pages		= {202-211},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1994},
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {In the object-oriented (OO) paradigm, new features (such
		  as encapsulation, aggregation, inheritance, polymorphism
		  and dynamic binding) introduce new problems in software
		  testing and maintenance. One of them is the difficulty of
		  identifying the affected components (such as classes) when
		  changes are made in object-oriented class libraries or
		  programs. This paper discusses the types of code changes in
		  an object-oriented class library, and provides an automated
		  solution to identify different kinds of code changes and
		  their impact. In addition, an OO software maintenance
		  environment that implements the research result is
		  described. Our experience with the environment prototype
		  shows promising results.},
  class		= {Alteration, Change_Impact}
}

@InProceedings{	  laski.szemer:identification,
  title		= {Identification of program modifications and its
		  applications in software maintenance},
  author	= {J. Laski and W. Szemer},
  pages		= {282--290},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  note		= { One of the problems in software maintenance is the
		  revalidation of modified code. Such a process should
		  preferably be restricted only to those parts of the program
		  that are affected by the modifications. In this paper a
		  formal method is described to identify modifications made
		  in a program},
  class		= {Alteration, Differences_between_Source_Code_Versions}
}

@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{	  loyall.mathisen:using,
  author	= {Joseph P. Loyall and Susan A. Mathisen},
  title		= {Using Dependence Analysis to Support the Software
		  Maintenance Process},
  pages		= {282-291},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1993},
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= sep,
  abstract	= {Dependence analysis is useful for software maintenance
		  because it indicates the possible effects of a software
		  modification on the rest of a program. This helps the
		  software maintainer evaluate the appropirateness of a
		  software modification, drive regression testing, and
		  determine the vulnerabiltiy of critical sections of code.
		  This paper presents a definition of interprocedural
		  dependence analysis and its implementation in a prototype
		  tool that supports software maintenance.},
  class		= {Alteration, Change_Impact}
}

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

@Article{	  miller.straus:implications,
  title		= {Implications of automatic restructuring COBOL},
  author	= {J. Miller and B. Straus III},
  journal	= {{ACM} Sigplan Notices},
  volume	= {22},
  number	= {6},
  pages		= {76--82},
  year		= {1987},
  note		= { The question whether or not mechanical transformations of
		  unstructured program code to a structured equivalent can
		  provide an improvement in the understanding of that program
		  is addressed. As an example the language COBOL is examined.
		  The paper also discusses a tool (called Structured
		  Retrofit) that performs such transformations for COBOL
		  mechanically},
  class		= {Alteration, Re-Code, Control_Flow_Normalization,
		  Program_Transformations }
}

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

@Article{	  oulsnam:unraveling,
  title		= {Unraveling unstructured programs},
  author	= {G. Oulsnam},
  journal	= {The Computer Journal},
  volume	= {25},
  number	= {3},
  pages		= {379--387},
  year		= {1982},
  note		= { A method for transforming unstructured program flowcharts
		  into structured ones is presented. The form of the derived
		  structured programs is such that the original unstructured
		  programs can be easily recovered, thus revealing what
		  overheads in space and time are inherent in the structured
		  forms},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@Article{	  partsch.steinbruggen:program,
  author	= {A. Partsch and R. Steinbruggen},
  title		= {Program Transformation Systems},
  journal	= {Computing Surveys},
  year		= {1983},
  volume	= {15},
  number	= {10},
  month		= sep,
  pages		= {199-236},
  class		= {Alteration, Re-Code, Source-to-Source-Translation}
}

@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{	  pleszkoch.linger.ea:eliminating,
  title		= {Eliminating non-traversable paths from structured
		  programs},
  author	= {M. Pleszkoch and R. Linger and A. Hevner},
  pages		= {156--164},
  booktitle	= {\cite{SM92}},
  year		= {1992},
  note		= { Considers the problem of control variables (i.e., ranging
		  over the Booleans or some small enumeration type) that
		  obscure the structure of otherwise structured programs.
		  Control flow is represented by regular expressions which
		  are further processed (subset construction) to find a
		  version of the program without redundant control paths},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@Article{	  ramshaw:eliminating,
  title		= {Eliminating goto's while preserving program structure},
  author	= {L. Ramshaw},
  journal	= {Journal of the {ACM}},
  volume	= {35},
  number	= {4},
  pages		= {893-920},
  year		= {1988},
  note		= { A method is described to eliminate GO-TO statements from
		  a program while the program's original structure is being
		  preserved},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

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

@Article{	  urschler:automatic,
  title		= {The automatic restructuring of programs},
  author	= {G. Urschler},
  journal	= {{IBM} Journal of Research and Development},
  volume	= {19},
  pages		= {181--194},
  year		= {1975},
  note		= { A method is described that allows the translation of an
		  unstructured program into a set of top-down structured,
		  semantically founded, go-to-free modules. This method leads
		  to a certain amount of code replication},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@InProceedings{	  ward.bennett:practical,
  author	= {M. Ward and K. Bennett},
  title		= {A practical program transformation system for reverse
		  engineering},
  booktitle	= {Proceedings of the 1st  Working Conference on Reverse
		  Engineering },
  pages		= {212--221},
  year		= {1993},
  note		= { Uses program transformation techniques as a basis for
		  reverse engineering. Source files are first translated into
		  WSL (wide-spectrum language). By means of a large
		  collection of WSL transformation and user guidance, the WSL
		  program is simplified. Next it can be translated back into
		  the original source language or into the specification
		  language Z. The process is supported by the ReForm tool
		  which contains parsers for IBM assembly language and for a
		  Basic subset. Also see~\cite{BBY92}},
  class		= {Alteration, Re-Code, Source_Code_Transformations}
}

@Article{	  waters:program,
  key		= {Waters},
  author	= {R. C. Waters},
  title		= {Program Translation via Abstraction and Reimplementation},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {1207--1228},
  volume	= {14},
  number	= {8},
  month		= aug,
  year		= {1988},
  abstract	= {Essentially all program tranlators (both source-to-source
		  translators and compilers) operate via transliteration and
		  refinement. The source program is first tranliterated into
		  the target language on a statement-by-statement basis.
		  Various refinements are then applied in order to improve
		  the quality of the output. Although acceptable in many
		  situations, this approach is fundamentally limited in the
		  quality of the output it can produce. In particular, it
		  tends to be insufficiently sensitive to global features of
		  the source program and too sensitive to irrelavant local
		  details.
		  
		  This paper presents an alternate translation paradigm -
		  abstraction and reimplementation. Using this paradigm, the
		  source program is first analyzed in order to obtain a
		  programming-language-independent understanding of the
		  computation performed by the program as a whole. The
		  program is then reimplemented in the target language based
		  on this understanding. The key to this approach is the
		  abstract understanding obtained. It allows the translator
		  to see the forest for the trees, benefiting from an
		  appreciation of the global features of the source program
		  without being distracted by irrelevant details.
		  
		  Translation via abstraction and reimplemenation is one of
		  the goals of the Programmer's Aprprentice project. A
		  translator which translates Cobol programs into Hibol (a
		  very-high-level business data processing language) has been
		  constructed. A compiler which generates extremly efficient
		  PDP-11 object code for Pascal programs has been designed.
		  Currently, work is proceeding toward the implementation of
		  a general-purpose, knowledge-based translator.},
  location	= {CMU E\&{}S Library},
  class		= {Alteration, Re-Code, Source-to-Source-Translation,
		  Software_Reverse_Engineering, Reverse_Design,
		  Knowledge-Based_Concept_Assignment,
		  Program_Plan_Assignment_by_Parsing},
  note		= { The translation paradigm of abstraction and
		  reimplementation, which is one of the goals of the
		  Programmer's Apprentice project \cite{RiWa90} is presented.
		  A translator has been constructed which translates Cobol
		  programs into Hibol (a very high level, business data
		  processing language)}
}

@Article{	  williams.ossher:conversion,
  title		= {Conversion of unstructured flow diagrams into structured
		  form},
  author	= {M. Williams and H. Ossher},
  journal	= {The Computer Journal},
  volume	= {21},
  number	= {2},
  pages		= {161--167},
  year		= {1978},
  note		= { Various already proposed methods to convert unstructured
		  flow diagrams into equivalent structured ones are
		  discussed. Moreover a general method for performing such
		  conversions is discussed},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@Book{		  zima.chapman:supercompilers,
  author	= {H. Zima and B. Chapman},
  title		= {Supercompilers for Parallel and vector Computers},
  publisher	= {Addison-Wesley},
  year		= {1991},
  series	= {ACM Frontier Series},
  abstract	= {This book contains (beside other topics) a description how
		  to discover loops in programs with gotos and how to
		  tranform those structures into while or repeat loops.},
  contents	= {Wolfgang Gellerich: Gute Darstellung wie man in
		  GOTO-Programmen Schleifen findet und sie gegen WHILE- oder
		  REPEAT-Schleifen ersetzt.},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}