• The Transactions of the Korea Information Processing Society
• /
• v.4 no.11
• /
• pp.2874-2890
• /
• 1997

This paper describes a methodology for translation of concurrent software expressed in operating system (OS) calls to Ada. Concurrency is expressed in some legacy software by OS calls that perform concurrent process/task control. Examples considered in this paper are calls in programs in C to Unix and calls in programs in CMS-2 to the Executive Service Routines of ATES or SDEX-20 other software re/reverse engineering research has focused on translating the OS calls in a legacy software to calls to another OS. In this approach, the understanding of software has required knowledge of the underlying OS, which is usually very complicated and informally documented. The research in this paper has focused on translating the OS calls in a legacy software into the equivalent protocols using the Ada facilities. In translation to Ada, these calls are represented by Ada equivalent code that follow the scheme of a message-based kernel oriented architecture. To facilitate translation, it utilizes templates placed in library for data structures, tasks, procedures, and messages. This methodology is a new approach to modeling OS in Ada in software re/reverse engineering. There is no need of knowledge of the underlying OS for software understanding in this approach, since the dependency on the OS in the legacy software is removed. It is portable and interoperable on Ada run-time environments. This approach can handle the OS calls in different legacy software systems.

• The KIPS Transactions:PartD
• /
• v.15D no.1
• /
• pp.107-112
• /
• 2008

The maintenance of legacy software systems is very important in the field of a software engineering. In the maintenance, a regression test confirms the behavior preserving of the software which has been changed but most of regression tests are done in a system level and rarely done in a unit test level because there is no test case. This paper proposes how to modify legacy software systems and make unit test cases as an asset. It uses a technique with a specific module of a real software development project and analyzes test coverage results. After this, if a study about automatic restructuring techniques and a test case generation proceeds continuously, we can expect the big advance of legacy software systems maintenance.

• KSII Transactions on Internet and Information Systems (TIIS)
• /
• v.8 no.6
• /
• pp.2118-2138
• /
• 2014

Risks are involved in all phases of the software life cycle, and due to these risks, software can face various problems that can cause different negative outcomes and sometimes, in extreme cases, the failure of the software. Most of these risks lie in the legacy software migration process. These risks can create many problems, and in the worst case they can lead to the failure of the migration project. This paper explores different types of risk analysis methods such as CRAMM, CORAS, OCTAVE and VECTOR. After comparing these methods, the two suitable methods were chosen, namely, OCTAVE and VECTOR. Based on the use of these two methods, the project suggests an enhanced EOV method for risk analysis in the migration of legacy software.

• KIPS Transactions on Software and Data Engineering
• /
• v.6 no.7
• /
• pp.337-352
• /
• 2017

Clone-and-own reuse is an approach to creating new software variants by copying and modifying existing software products. A family of legacy software products developed by clone-and-own reuse often requires high maintenance cost and tends to be error-prone due to patch-ups without refactoring and structural degradation. To overcome these problems, many organizations that have used clone-and-own reuse now want to migrate their legacy products to software product line (SPL) for more systematic reuse and management of software asset. However, with most of existing methods, variation points are embedded directly into design and code rather than modeled and managed separately; variation points are not created ("engineered") systematically based on a variability model. This approach causes the following problems: it is difficult to understand the relationships between variation points, thus it is hard to maintain such code and the asset tends to become error-prone as it evolves. Also, when SPL evolves, design/code assets tend to be modified directly in an ad-hoc manner rather than engineered systematically with appropriate refactoring. To address these problems, we propose a feature-oriented method for extracting a SPL asset from a family of legacy applications. With the approach, we identify and model variation points and their relationships in a feature model separate from implementation, and then extract and manage a SPL asset from legacy applications based on the feature model. We have applied the method to a family of legacy Notepad++ products and demonstrated the feasibility of the method.

• Journal of KIISE:Software and Applications
• /
• v.29 no.9
• /
• pp.619-630
• /
• 2002

The various software engineering techniques have been come out in order to cope with the software crisis since 1980's. The software Engineering has focused on the process of software component development. The process products a development guide for a quality and productive improvement of software. But, most of the methodologies assume that a new system will be constructed and reused in the future. these do not actually support efficiently how we reuse legacy system's resources and construct a new system. In this paper, we present an efficient Reengineering Process for reusing legacy systems, RUP+re, which extends and customizes RUP. Rup+re consists of Reverse Engineering Workflow, Re-Engineering Workflow and forward Engineering Process. We describe RUP+re's workflows with their own detail steps and verify them practically through the case study. So, we provide efficient guidelines to the software Reengineering process construction which reuses the resources of a legacy system.

• The KIPS Transactions:PartD
• /
• v.14D no.7
• /
• pp.763-772
• /
• 2007

Due to increased software development cost, interest about the method and automated tool for reusing legacy system have been running high. Therefore, In this study, it proves the definition, concept and also background of legacy system by showing real market and technology trend. Automation tool is designed and developed to handle the concrete development methodology, procedure and reference. Also, we implemented the process that analyze the legacy system and extract, refine, store and reuse the candidate components by using LM(Legacy to Modern System) supporting tool presented in this paper. If LM supporting tool is applied to legacy system migration, we can expect cutting costs, shortening the developing period and succeeding the intellectual property by software re-engineering.

• The KIPS Transactions:PartD
• /
• v.10D no.5
• /
• pp.845-858
• /
• 2003

The various software engineering techniques have been come out in order to cope with the software crisis since 1980's. These days the software Engineering has focused on the process of software development which is the guide for a qualify and productive improvement of software. But, most of the methodologies assume that a new system will be constructed and reused in the future. these do not support how we reuse legacy system's resources and construct a new system efficiently. In this paper, we present an efficient Reengineering Process for legacy system evolutions, RUP+re, which extends and customizes RUP. RUP+re consists of Reverse Engineering Workflow, Transformation Workflow and Evolution Workflow based on Small-h model. We describe RUP+re's workflows with their own detail steps and verify the process through the case study practivally. So, we provide efficient guidelines to the software Reengineering process construction which evolutes the resources of a legacy system.

• The KIPS Transactions:PartD
• /
• v.13D no.2 s.105
• /
• pp.251-258
• /
• 2006

Aspect-Oriented Software Development is new software development method. It has many advantages related to software performance, maintenance and repair. Also it offers modularization method to a existing programming language for secondary function such as security and fault tolerance. But the present problem is that we have to use new aspect-oriented programming language. Further more when we apply Aspect to legacy system, we have to recompile the source code in order to build software system based on AOSD. In this paper, we propose and design Connector that can be composed with Aspect in legacy system dynamically. To elaborate this work, we use the information of operations about Core and Aspect, and the information of pointcut described with XML. We validate that the proposed Connector has features such as no need of new compiler, no recompilation and no modification of legacy system through case study.

• The Journal of Society for e-Business Studies
• /
• v.8 no.2
• /
• pp.113-129
• /
• 2003

Component-based software development (CBSD) has been recognized effective reuse techniques for software development by many of researchers and companies. The purpose of CBSD is to produce a high quality software system quickly through using verified software component which is contained fine-grained business logics. This paper suggests the metrics and techniques for to extract component and its interface from legacy object oriented application. For extract component, we apply metrics to measure complexity, cohesion and coupling to the legacy system.

• The KIPS Transactions:PartD
• /
• v.12D no.5 s.101
• /
• pp.797-806
• /
• 2005

The objective of the In-h(High Level Architecture) have recommended by DoD(Department of Defense) is to facilitate interoperability among simulations and to promote reuse of their components. There are many legacy simulation softwares developed before the HLA becomes simulation standard. The integration of legacy simulations into federations using the HLA is an important research topic in M&S(Modeling and Simulation) area. Legacy simulation softwares of the mission critical industry such as nuclear and aerospace are generally use Fortran language. However, the reuse of those is not easy because the HLA is not support Fortran language. This paper suggests a integration method which minimizes the modification of legacy simulation software and migrates the legacy simulation software to HLA federation. Each federate participating in federation have the separated executables that communicate via a shared memory created at run-time. Two types of shared memory blocks are used for publication and subscription. Declaration block for global variables used in legacy simulation software is separated for publication and subscription and then mapped as classes of objects and interactions for the HLA FOM design. To validate the suggested method, we approached the HLA integration of legacy nuclear simulation code being used in plant design and to observe the integration results, we used the FMT(Federation Management Tool). The diagnostic information which the FTM displays showed that our method can be successfully and effectively used for a HLA federation.