A Re-engingeering Approach to Program Translation, William C. Chu
@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}
}
Reengineering Cobol Systems to Ada, R. Gray and T. Bickmore and S. Williams
@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}
}
Automated Assistance for Program Restructuring, Wiliam Grisworld and David Notkin
@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}
}
Program Concept Recognition and Transformation, Wojtek Kozaczynski and Jim Q. Ning and Andre Engberts
@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}
}
Program Transformation Systems, A. Partsch and R. Steinbruggen
@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}
}
Program Translation via Abstraction and Reimplementation, R. C. Waters
@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)}
}