15226793
Code migration through transformations: an experience report
One approach to dealing with spiraling maintenance costs, manpower shortages and frequent breakdowns for legacy code is to "migrate" the code into a new platform and/or programming language. The objective of this paper is to explore the feasibility of semi-automating such a migration process in the presence of performance and other constraints for the migrant code. In particular, the paper reports on an experiment involving a medium-size software system written in PL/IX. Several modules of the system were migrated to C++, first by hand and then through a semiautomatic tool. After discovering that the migrant code was performing up to 50% slower than the original, a second migration effort was conducted which improved the performance of the migrant code substantially. The paper reports on the transformation techniques used by the transformation process and the effectiveness of the prototype tools that were developed. In addition, the paper presents preliminary results on the evaluation of the experiment.
11319559
On inserting program understanding technology into the software change process
Program understanding technologies can be applied effectively in the analysis phase of a software change process. The analysis phase naturally follows a goal driven metaprocess. Described are issues involved with inserting program understanding technology into existing practice and into such a metaprocess. The implied processes of program understanding and reverse engineering tools play an important role. These issues pose major problems for the acceptance of redocumentation tools such as Rigi, an evolvable reverse engineering tool. An example using Rigi and its analysis methodology for change impact analysis is considered.
62300434
How do program understanding tools affect how programmers understand programs?
Abstract In this paper, we explore the question of whether program understanding tools enhance or change the way that programmers understand programs. The strategies that programmers use to comprehend programs vary widely. Program understanding tools should enhance or ease the programmer's preferred strategies, rather than impose a fixed strategy that may not always be suitable. We present observations from a user study that compares three tools for browsing program source code and exploring software structures. In this study, 30 participants used these tools to solve several high-level program understanding tasks. These tasks required a broad range of comprehension strategies. We describe how these tools supported or hindered the diverse comprehension strategies used.
1805653
Domain-retargetable reverse engineering
A user programmable approach to reverse engineering is described. The approach uses a scripting language that enables users to write their own routines for these activities, making the system domain-retargetable. The environment supported by this programmable approach subsumes existing reverse engineering systems by being able to simulate facets of each one and provides a smooth transition from semi-automatic to automatic reverse engineering.<<ETX>>
991816
Wrapping coarse-grained objects using standard infrastructure technology
There are two basic approaches to migrating a particular subsystem: reengineering and wrapping. The author considers coarse-grained object wrapping. In wrapping, the original subsystem is essentially integrated into the new setting using infrastructure technologies. Legacy systems that have evolved over many years are notoriously difficult to decompose. Wrapping is most effective if the legacy system can be decomposed into a few large chunks where the number of communication paths among subsystems is minimized. The author discusses the use of infrastructure technology such as CORBA (Common Object Request Broker Architecture)
6619418
The Software Bookshelf
Legacy software systems are typically complex, geriatric, and difficult to change, having evolved over decades and having passed through many developers. Nevertheless, these systems are mature, heavily used, and constitute massive corporate assets. Migrating such systems to modern platforms is a significant challenge due to the loss of information over time. As a result, we embarked on a research project to design and implement an environment to support software migration. In particular, we focused on migrating legacy PL/I source code to C++, with an initial phase of looking at redocumentation strategies. Recent technologies such as reverse engineering tools and World Wide Web standards now make it possible to build tools that greatly simplify the process of redocumenting a legacy software system. In this paper we introduce the concept of a software bookshelf as a means to capture, organize, and manage information about a legacy software system. We distinguish three roles directly involved in the construction, population, and use of such a bookshelf: the builder, the librarian, and the patron. From these perspectives, we describe requirements for the bookshelf, as well as a generic architecture and a prototype implementation. We also discuss various parsing and analysis tools that were developed and integrated to assist in the recovery of useful information about a legacy system. In addition, we illustrate how a software bookshelf is populated with the information of a given software project and how the bookshelf can be used in a program-understanding scenario. Reported results are based on a pilot project that developed a prototype bookshelf for a software system consisting of approximately 300K lines of code written in a PL/I dialect.
62724310
3D model reconstruction by constrained bundle adjustment
The accuracy of the reconstruction of 3D objects using vision-based techniques depends ultimately on an optimization technique known as bundle adjustment. However, direct application of bundle adjustment fails to make full use of the constraints inherent in the objects' motion. Most of the scanner systems available today use a turntable to rotate an object so as to capture images of the object from different view points. For these systems, the motion of the object is constrained to rotate around a fixed axis. By incorporating this constraint into the traditional bundle adjustment method, we show that a more accurate reconstructed model can be obtained. This "constrained" bundle adjustment method must be useful in the design of low-cost, yet accurate, 3D scanners for use in manufacturing and entertainment industry.
1581000
Extracting and representing cross-language dependencies in diverse software systems
This paper presents an approach for dealing with multi-language software systems. Much of the focus of reverse engineering tools is in analyzing software systems written in one programming language. Nowadays, the abundance of new technologies and languages used to ease application development raises new challenges for reverse engineers. Therefore, this paper focuses on finding cross-language dependencies in such diverse, heterogeneous software systems. Our approach uses source navigator extractors to produce the facts inside each language. Then, we show an example for finding Java Native Interface (JNI) dependencies between facts from Java and C/C++ code. The integrated facts are produced in GXL form, and conform to a unified schema introduced in the paper. This approach is useful from several perspectives. It illustrates how to retrieve the dependencies from software systems written in more than one programming language. Also, the generated facts conform to the GXL format, which is accepted by many reverse engineering tools. The usefulness and scalability of the approach are tested in a case study.
42199214
A Technique for Improving the Convergence Characteristic of Genetic Algorithms and Its Application to a Genetic-Based Load Flow Algorithm
This paper is devoted to the development of a technique for the enhancement of the convergence of genetic algorithms. Based on the concept of solution acceleration, a technique is proposed and applied to a constrained-genetic-algorithm load-flow algorithm CGALF recently developed for solving the problem of evaluating the voltage profile and power flow in electric power networks. The enhanced CGALF algorithm is applied to a practical power system to illustrate the effectiveness of the developed method.
6429264
Research challenges in the reverse engineering community
This working session will discussfidticre directions for research and practice in sofware reverse engineering and reengineering, including the challenging issues of program transformation, dealing with net-centric applications, and improving the maturity of the reverse engineering process. 1. Program Transformation Speaker: Kostas Kontogiannis, U Waterloo, Canada An area of significant importance to the reverse engineering and reengineering community is the design and implementation of methods, techniques, and tools that support program transformation in compliance with the functional and non-functional requirements of the new migrant system. Other important areas of research include: the fransformation of procedural code to object-oriented platforms; restructuring and refactoring source code to enhance its maintainability, reliability, or performance; and developing wrapping techniques and tools so that legacy systems can be migrated to modem, net-centric platforms. Moreover, experimental studies are needed to evaluate the effectiveness, usability, and scalability of methods, techniques, and tools for analyzing and tranforming complex industrial systems.
13250119
Resolving Conflicting Arguments under Uncertainties
Distributed knowledge based applications in open domain rely on common sense information which is bound to be uncertain and incomplete. To draw the useful conclusions from ambiguous data, one must address uncertainties and conflicts incurred in a holistic view. No integrated frameworks are viable without an in-depth analysis of conflicts incurred by uncertainties. In this paper, we give such an analysis and based on the result, propose an integrated framework. Our framework extends definite argumentation theory to model uncertainty. It supports three views over conflicting and uncertain knowledge. Thus, knowledge engineers can draw different conclusions depending on the application context (i.e. view). We also give an illustrative example on strategical decision support to show the practical usefulness of our framework.