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.

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.

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.

Model-Driven Exception Management Case Study

2010 ◽  
pp. 153-173
Author(s):  
Susan Entwisle ◽  
Sita Ramakrishnan ◽  
Elizabeth Kendall
Keyword(s):  
Programming Languages ◽  
Fault Tolerant ◽  
Exception Handling ◽  
Software Systems ◽  
Management Framework ◽  
Low Level ◽  
Model Driven ◽  
Level Of Abstraction ◽  
Management Case Study

Programming languages provide exception handling mechanisms to structure fault tolerant activities within software systems. However, the use of exceptions at this low level of abstraction can be errorprone and complex, potentially leading to new programming errors. To address this we have developed a model-driven exception management framework (DOVE). This approach is a key enabler to support global distributed solution delivery teams. The focus of this paper is the evaluation of the feasibility of this approach through a case study, known as Project Tracker. The case study is used to demonstrate the feasibility and to perform an assessment based on quality and productivity metrics and testing of the DOVE framework. The results of the case study are presented to demonstrate the feasibility of our approach.

AUTOMATIC RESULT VERIFICATION BY COMPLETE RUN-TIME CHECKING OF COMPUTATIONS

2001 ◽  
Vol 12 (01) ◽  
pp. 97-124 ◽  
Author(s):  
EDGAR F. A. LEDERER ◽  
ROMEO A. DUMITRESCU
Keyword(s):  
Programming Language ◽  
Error Detection ◽  
Program Execution ◽  
Good Efficiency ◽  
Result Verification ◽  
Coordination Model ◽  
Functional Specification ◽  
Time Result ◽  
Run Time

Two-Stage Programming (2SP) is an experimental programming language, the first implementation of the Specification-Consistent Coordination Model (SCCM). The SCCM proposes a new, mixed-paradigm (functional/imperative) approach to developing reliable programs based on complete run-time checking of computations with respect to a given specification. A 2SP program consists of a functional specification and an imperative coordination tightly connected to the specification. The coordination maps the specification to an imperative and possibly parallel/distributed program. Normal termination of a 2SP program execution implies the correctness of the computed results with respect to the specification, for that execution. We present the basic feautures of the SCCM/2SP, a new message-spassing system of 2SP with integrated run-time checking, and a larger case study. We show that 2SP provides: functional specifications, specification-consistent imperative coordinations, automatic run-time result verification and error detection, enhanced debugging support, and good efficiency.

The Architecture Framework with Exception Handing in SOA

2010 ◽  
Vol 20-23 ◽  
pp. 992-997 ◽  
Author(s):  
Qing Wu ◽  
Shi Ying ◽  
You Cong Ni ◽  
Hua Cui
Keyword(s):  
Exception Handling ◽  
Software Systems ◽  
Separation Of Concerns ◽  
Clear Separation ◽  
Reliable Service ◽  
Architecture Framework ◽  
Service Oriented ◽  
Business Function ◽  
Oriented System

Service-oriented software systems are inherently complex and have to cope with an increasing number of exceptional conditions in order to meet the system’s dynamic requirements. This work proposes an architecture framework which has exception handling capability. This framework ensures the credibility of service-oriented software, during the architectural stage, by adding exception handling-related architecture elements and modeling exception handling process. It allows a clear separation of concerns between the business function and the exception handling unit, using reflection mechanism. It plays an important guiding role for achieving reliable service-oriented system.

Application of Prognostics and Health Management (PHM) to Software System Fault and Remaining Useful Life (RUL) Prediction

2021 ◽  
Author(s):  
Mohammad Rubyet Islam ◽  
Peter Sandborn
Keyword(s):  
Health Management ◽  
Standard Test ◽  
Remaining Useful Life ◽  
Software Systems ◽  
Prognostics And Health Management ◽  
Performance Parameters ◽  
Statistical Validation ◽  
Useful Life ◽  
Test Beds

Abstract Prognostics and Health Management (PHM) is an engineering discipline focused on predicting the point at which systems or components will no longer perform as intended. The prediction is often articulated as a Remaining Useful Life (RUL). RUL is an important decision-making tool for contingency mitigation, i.e., the prediction of an RUL (and its associated confidence) enables decisions to be made about how and when to maintain the system. PHM is generally applied to hardware systems in the electronics and non-electronics application domains. The application of PHM (and RUL) concepts has not been explored for application to software. Today, software (SW) health management is confined to diagnostic assessments that identify problems, whereas prognostic assessment potentially indicates when in the future a problem will become detrimental to the operation of the system. Relevant areas such as SW defect prediction, SW reliability prediction, predictive maintenance of SW, SW degradation, and SW performance prediction, exist, but all represent static models, built upon historical data — none of which can calculate an RUL. This paper addresses the application of PHM concepts to software systems for fault predictions and RUL estimation. Specifically, we wish to address how PHM can be used to make decisions for SW systems such as version update, module changes, rejuvenation, maintenance scheduling and abandonment. This paper presents a method to prognostically and continuously predict the RUL of a SW system based on usage parameters (e.g., numbers and categories of releases) and multiple performance parameters (e.g., response time). The model is validated based on actual data (on performance parameters), generated by the test beds versus predicted data, generated by a predictive model. Statistical validation (regression validation) has been carried out as well. The test beds replicate and validate faults, collected from a real application, in a controlled and standard test (staging) environment. A case study based on publicly available data on faults and enhancement requests for the open-source Bugzilla application is presented. This case study demonstrates that PHM concepts can be applied to SW systems and RUL can be calculated to make decisions on software version update or upgrade, module changes, rejuvenation, maintenance schedule and total abandonment.

Sign in / Sign up

Export Citation Format

Share Document