References of Re-Code

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

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

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

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

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

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

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

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

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