A_Reengineering_Process_for_Migrating_from_an_Object-oriente

A_Reengineering_Process_for_Migrating_from_an_Object-oriented_Legacy_System_to_a_Component-based_System

A Reengineering Process for Migrating from an Object-oriented

Legacy System to a Component-based System

Eunjoo Lee1 Byungjeong Lee2 Woochang Shin3 Chisu Wu1

1

School of Computer Science and Engineering, Seoul National University, Seoul, Korea

{banny, wuchisu}@selab.snu.ac.kr

2

School of Computer Science, University of Seoul, Seoul, Korea

bjlee@venus.uos.ac.kr

3

Dept. of Internet Information, Seokyeong University, Seoul, Korea

wcshin@imail.skuniv.ac.kr

Abstract

Computing environments are evolving from mainframe systems to distributed systems. Stand-alone programs that have been developed using object-oriented technology are not suitable for these new environments. However, programs that have been developed using a component-based technology have proven to be more suitable for the new environments due to their granularity and reusability. In this paper, we present a reengineering process for migrating from an object-oriented legacy system to a component-based system. This process consists of two steps: first, to create basic components with the relationship of their constituent classes, second, to refine components using the metrics we propose.

Keywords: reengineering, component, object-oriented, legacy system, migration, reusability

1. Introduction

Computing environments are evolving from standalone mainframe systems to distributed systems. Many legacy systems today are object-oriented and component-based. One of the most prominent maintenance objectives is system migration to distributed environments [1].

Today, on top of object-oriented techniques, an additional layer of software development, based on components is being established. The goals of componentware are very similar to those of object-orientation: reuse of software is to be facilitated and thereby increased, software shall become more reliable and less expensive [2]. And the development of distributed system is more and more based on the use of component technology [3].

Components are regarded as being more coarse-grained compared to traditional reusable artifacts, such as objects, and are intended to provide a high-level representation of

the domain. Fine-grained traditional artifacts prevent managers from effectively working with these artifacts. However, the coarse-grained domain-oriented approach used for components allows managers to identify the components that satisfy their business requirements, and to assemble them into full-scale applications [4].

Also, the increasing size and complexity of modern software systems leads to huge and complicated conglomerations of classes and objects that are hard to manage and understand. Those systems obviously require a more advanced means of structuring, describing and developing them. Componentware is a possible approach to solve to these problems [5].

For that reason, components can be used more effectively and better suited for reuse than objects. We can get maintainability and reliability of software application by reusing existing elements, classes in legacy object-orient systems. Therefore, we should derive reusable components from classes in object-oriented systems and change object-oriented systems into systems suitable for distributed systems where many systems make use of components. As part of our work, we have found that there have been several studies related to our work in each of following areas:

1. The derivation of the necessary design information

in a legacy system through reverse engineering [6, 7, 8];

2. The reengineering process of a procedural legacy

system into an object-based distributed system [9, 10];

3. Component identification [3, 4];

4. The component interface [2, 11]; and 5. The wrapping technology [12, 13].

However, there is a distinct lack of a complete methodology for reengineering an object-oriented legacy system into a system that consists of components. Moreover the ‘legacy system’ is mostly procedural systems in those studies.

A_Reengineering_Process_for_Migrating_from_an_Object-oriented_Legacy_System_to_a_Component-based_System

In this paper, we present a process to reengineer an object-oriented legacy system into a component-based system. We create components based upon the original class relationships that we determine by examining the program source code. We describe the system and process formally and suggest applicable metrics for the process. These can be used to help create components with the desired level of complexity that can operate as cohesive functional units in a distributed environment.

The rest of this paper is organized as follows. Section 2 describes our system model with formalized form. In Section 3, we define our process to create components from object-oriented classes. In Section 4, we illuminate an example system and show how our process can be used to migrate it to a component-based system. Finally, Section 5 gives our conclusions and suggestions for future work.

2. System Model

We describe our system model as follows: Inheritance relationship between classes

We say that class X and Y have a inheritance relationship or that class Y is a child of class X or class X is a parent of class Y when class X is a direct parent of class Y in a inheritance hierarchy. Composition relationship between classes

We say that class X and Y have a composition relationship or class X has class Y as a composition member class, when class X has class Y as a member variable, class Y has a strong attachment to class X and the same life cycle as class X’s. Use relationship between classes

We say that class Y uses class X when:

oAny method of class Y gets the instance x of cla …… 此处隐藏：24043字，全部文档内容请下载后查看。喜欢就下载吧 ……