REDESIGNING LEGACY SYSTEMS INTO THE OBJECT-ORIENTED PARADIGM

2004 ◽  
Vol 14 (03) ◽  
pp. 255-276
Author(s):  
W. ERIC WONG ◽  
JENNY LI
Keyword(s):  
Inventory Management ◽  
Source Code ◽  
Object Oriented ◽  
Original System ◽  
Software Systems ◽  
Legacy Systems ◽  
Dynamic Binding ◽  
Legacy Software ◽  
Original Program

Object-oriented languages support many modern programming concepts such as information hiding, inheritance, polymorphism, and dynamic binding. As a result, software systems implemented in OO languages are in general more reusable and reliable than others. Many legacy software systems, created before OO programming became popular, need to be redesigned and updated to OO programs. The process of abstracting OO designs from the procedural source code has often been done with limited assistance from program structural diagrams. Most reengineering focuses on the functionality of the original program, and the OO redesign often results in a completely new design based on the designers' understanding of the original program. Such an approach is not sufficient because it may take a significant amount of time and effort for designers to comprehend the original program. This paper presents a computer-aided semi-automatic method that abstracts OO designs from the original procedural source code. More specifically, it is a method for OO redesign based on program structural diagrams, visualization, and execution slices. We conducted a case study by applying this method to an inventory management software system. Results indicate that our method can effectively and efficiently abstract an appropriate OO design out of the original C code. In addition, some of the code from the original system can be automatically identified and reused in the new OO system.

scholarly journals Software Archeology: A Case Study in Software Quality Assurance and Design

2009 ◽  
Author(s):  
Cameron J. Turner ◽  
John M. MacDonald ◽  
Jane A. Lloyd
Keyword(s):  
Quality Assurance ◽  
Software Quality ◽  
National Laboratory ◽  
Quality Assurance Program ◽  
Software Quality Assurance ◽  
Software Systems ◽  
Legacy Systems ◽  
Los Alamos National Laboratory ◽  
Legacy Software

Ideally, quality is designed into software, just as quality is designed into hardware. However, when dealing with legacy systems, demonstrating that the software meets required quality standards may be difficult to achieve. Evolving customer needs, expressed by new operational requirements, resulted in the need to develop a legacy software quality assurance program at Los Alamos National Laboratory (LANL). This need led to the development of a reverse engineering approach referred to as software archaeology. This paper documents the software archaeology approaches used at LANL to demonstrate the software quality in legacy software systems. A case study for the Robotic Integrated Packaging System (RIPS) software is included to describe our approach.

An Effortless Approach for Migrating from Legacy Software Systems to Web Services

2012 ◽  
pp. 219-225
Author(s):  
K. Velmurugan ◽  
M.A. Maluk Mohamed
Keyword(s):  
Web Services ◽  
Reverse Engineering ◽  
Software Metrics ◽  
Software Systems ◽  
Legacy Systems ◽  
Legacy Software ◽  
Internet Infrastructure ◽  
Business Applications ◽  
Simple Implementation ◽  
Business To Business

One of the vital reasons for reverse engineering legacy software systems is to make it inter-operable. Moreover, technological advancements and changes in usability also motivate reverse engineering to exploit new features and incorporate them in legacy software systems. In this context, Web services are emerging and evolving as solutions for software systems for business applications in terms of facilitating interactions between business to business and business to customers. Web services are gaining significance due to inherent features like interoperability, simple implementation, and exploiting the boom in Internet infrastructure. Thus, this work proposes a framework based strategy using .net for effortless migration from legacy software systems to Web services. Further, this work also proposes that software metrics observed during the process of reverse engineering facilitate design of Web services from legacy systems.

scholarly journals Config: A Case Study in Combining Software Engineering Techniques

2000 ◽  
Vol 8 (2) ◽  
pp. 59-71
Author(s):  
David Maley ◽  
Ivor Spence
Keyword(s):  
Software Engineering ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Substantial Contribution ◽  
Software Systems ◽  
Generic Programming ◽  
Design By Contract ◽  
R Matrix ◽  
Orthogonal Dimension

Config is a software component of the Graphical R-Matrix Atomic Collision Environment. Its development is documented as a case study combining several software engineering techniques: formal specification, generic programming, object-oriented programming, and design by contract. It is specified in VDM++; and implemented in C++, a language which is becoming more than a curiosity amongst the scientific programming community. C++supports object orientation, a powerful architectural paradigm in designing the structure of software systems, and genericity, an orthogonal dimension to the inheritance hierarchies facilitated by object oriented languages. Support in C++ for design by contract can be added in library form. The combination of techniques make a substantial contribution to the overall software quality.

scholarly journals Extending programming language to support object orientation in legacy systems

2013 ◽  
Vol 10 (4) ◽  
pp. 1661-1672
Author(s):  
Hemang Mehta ◽  
S.J. Balaji ◽  
Dharanipragada Janakiram
Keyword(s):  
Programming Language ◽  
Object Orientation ◽  
Exception Handling ◽  
Target System ◽  
Software Systems ◽  
Legacy Systems ◽  
Performance Study ◽  
Tight Coupling ◽  
Runtime Support

The contemporary software systems written in C face maintainability issues because of tight coupling. Introducing object orientation can address these problems by raising the abstraction to objects, thereby providing better programmability and understandability. However, compiling a C software with a C++ compiler is difficult because of the incompatibilities between C and C++. Some of the incompatibilities such as designated initializers are nontrivial in nature and hence are very difficult to handle by automation such as scripting or by manual efforts. Moreover, runtime support for features such as global constructors, exception handling, runtime type inference, etc. is also required in the target system. Clearly, the traditional procedural language compiler cannot provide these features. In this paper, we propose extending programming language such as C++ to support object orientation in legacy systems instead of completely redesigning them. With a case study of Linux kernel, we report major issues in providing the compile and runtime support for C++ in legacy systems, and provide a solution to these issues. Our approach paves the way for converting a large C based software into C++. The experiments demonstrate that the proposed extension saves significant manual efforts with very little change in the g++ compiler. In addition, the performance study considers other legacy systems written in C and shows that the overhead resulting from the modifications in the compiler is negligible in comparison to the functionality achieved.

The Determination of the Uniqueness of Polymorphism in C++

2013 ◽  
Vol 336-338 ◽  
pp. 2157-2163
Author(s):  
Meng Ting Liu ◽  
Yong Min Mu ◽  
Wei Na Dong ◽  
Bin Fan ◽  
Li Ni Ma
Keyword(s):  
Source Code ◽  
Object Oriented ◽  
Control Logic ◽  
Dynamic Binding ◽  
Call Graph ◽  
Function Call ◽  
Path Coverage ◽  
Testing Cost ◽  
The One

The polymorphism is the one of the main features of the object oriented program. The compiler determines the uniqueness of polymorphism by dynamic binding. In a static source code, there will be one function calling point corresponding to several called functions. As the consequence, there will be many redundant function calling paths. It is the key to improve the efficiency of the path coverage test based function call graph with control logic determining the uniqueness of polymorphism. This paper analyzes the feature of the polymorphism in C++ and proposes an algorithm to determine the uniqueness of polymorphism statically in C++. The algorithm can find the unique called function from the several called functions without running the program. The result shows that the algorithm can obtain the unique called function correctly and eliminate the redundant paths. It improves the testing efficiency and reduces the testing cost.

An Approach to Evolving Legacy Software System into Cloud Computing Environment

2013 ◽  
pp. 207-229
Author(s):  
Shang Zheng ◽  
Feng Chen ◽  
Hongji Yang ◽  
Jianzhi Li
Keyword(s):  
Cloud Computing ◽  
Banking System ◽  
Software Systems ◽  
Legacy Systems ◽  
Problem Solution ◽  
Cloud Environment ◽  
New Paradigm ◽  
Legacy Software ◽  
Service Oriented ◽  
Resources Sharing

Cloud computing is a new paradigm for the intent of distributed resources sharing and coordinated problem solution. Affected by the Cloud trend and Service-Oriented need, many existing software systems will become legacy systems. These legacy software systems will need Cloud Oriented reengineering, which can facilitate the legacy systems reusable in Cloud Oriented architecture and allow the integration of legacy resources with Cloud features. This research focuses on establishing a general framework to assist with the evolution of legacy systems into Cloud environments. The methodology includes various phases, which use reverse engineering techniques to comprehend and decompose legacy systems, represent legacy resources by XML as Cloud component and integrate these Cloud components into Cloud environment. In this research, a legacy banking system has been chosen as a case study to prove the feasibility of the proposed approach. The legacy banking system can be transformed to run as a Service-Oriented Cloud application, which illustrates the proposed approach is powerful for utilising reusable legacy resources into Cloud environment.

USING DOMAIN KNOWLEDGE TO IMPROVE REVERSE ENGINEERING

1996 ◽  
Vol 06 (03) ◽  
pp. 477-505 ◽  
Author(s):  
HARALD C. GALL ◽  
RENÉ R. KLÖSCH ◽  
ROLAND T. MITTERMEIR
Keyword(s):  
Reverse Engineering ◽  
Program Transformation ◽  
Domain Knowledge ◽  
Source Code ◽  
Object Oriented ◽  
Transformation Process ◽  
Legacy Systems ◽  
General Domain ◽  
Basic Concepts ◽  
Architectural Transformation

Integrating application domain knowledge into reverse engineering is an important step to overcome the shortcomings of conventional reverse engineering approaches that are based exclusively on information derivable from source code. In this paper, we show the basic concepts of a program transformation process from a conventional to an object-oriented architecture which incorporates extraneous higher-level knowledge in its process. To which degree this knowledge might stem from some general domain knowledge, and to which extent it needs to be introduced as application dependent knowledge by a human expert is discussed. The paper discusses these issues in the context of the architectural transformation of legacy systems to an object-oriented architecture.

OBJECT MODELING TO RE-ENGINEER LEGACY SYSTEMS

2000 ◽  
Vol 10 (04) ◽  
pp. 471-485 ◽  
Author(s):  
JIANG GUO ◽  
LUQI
Keyword(s):  
Software Architecture ◽  
Source Code ◽  
Object Oriented ◽  
Software Component ◽  
Simulation System ◽  
Legacy Systems ◽  
Object Modeling ◽  
Domain Experts ◽  
Combat Simulation

This paper summarizes our experiences in using computer-supported methods to develop a software architecture to support the re-engineering of the Janus Combat Simulation System. We have analyzed the Janus FORTRAN source code, interviewed Janus domain experts, developed an object-oriented architecture for the Janus Combat Simulation subsystem, and validated the architecture with an executable prototype. In this paper, we propose methods to facilitate the evolution of the software component of these systems by recovering the behavior of the systems using systematic methods, and illustrate their use in the context of the Janus System.

Sign in / Sign up

Export Citation Format

Share Document