• Asia pacific journal of information systems
• /
• v.9 no.1
• /
• pp.115-142
• /
• 1999

Legacy applications are valuable assets that should be integrated into next generation business systems. To gain this advantage, progressive companies can reverse engineer the legacy business operations. This paper presents a form-driven object-oriented reverse engineering(FORE) methodology by the use of business forms to recover semantics of legacy applications. They retain the user-oriented contents of business and thus are easily understandable. Our form driven object-oriented reverse engineering methodology consists of five phases: form and usage analysis, form object slicing, object structure modeling, scenario design, and model integration. Knowledge about form structure and user interaction with legacy applications is used to capture the design semantics. An object model, which consists of an object structure model and scenario results from such form knowledge. The resulting object model is more likely to help reverse engineers understand and reuse legacy systems.

• Journal of Digital Contents Society
• /
• v.10 no.1
• /
• pp.45-54
• /
• 2009

This paper proposes object-oriented learning method of using reverse-engineering based on game development environment. The game has advantages such as interest and enjoyment. Also, the reverse analysis of game help us understand the technique to be used in game. Through this process, we introduce learning method enabling us to actively understand object-oriented concept. Thus, the proposed method describes case learning based on XNA game development environment, and presents a scenario according to role of teacher and learner.

• The Transactions of the Korea Information Processing Society
• /
• v.7 no.3
• /
• pp.818-830
• /
• 2000

Automation tools for program analysis are needed in order to program understand and maintain, extract the characteristics of object-oriented program such as class name, member function and data member. In this paper, we carried out design and implementation of the automation tool for effective maintenance of object-oriented software. Being based on Reverse Engineering, this approach extracts class relationship information from C++ source code and generates object-oriented model of class diagram using UML as the standard object-oriented methodology. Therefore, this paper provides developers visualized including class information, definitions of classes, inheritance relationships, set relationships, and simple reference relationships. Finally in this paper, we propose a method that construct class relationship information to table in analysis state and make form of table construction to link form so tat developers can perform understanding and maintaining program efficiently. And this method enable to restructure and reuse in object-oriented model.

• Journal of Internet Computing and Services
• /
• v.23 no.2
• /
• pp.79-86
• /
• 2022

This paper focuses on realizing design improvement and high quality through visualization of reverse engineering-based software. As new technologies and complex software emerge in various areas of the fourth industry in the future, software verification with both stability and reliability is becoming an issue. We propose a reverse engineering-based UML design extraction and visualization for high-quality software ranging from simple computational software to machine learning-based data-oriented software. Through this study, it is expected to improve software quality through design improvement by checking the accuracy of the target design and identifying the code complexity.

• Journal of KIISE:Software and Applications
• /
• v.32 no.9
• /
• pp.847-852
• /
• 2005

Over the last decade, numerous complexity measurement techniques for Object-Oriented (OO) software system have been proposed for managing the effects of OO codes. These techniques may be based on source code analysis such as WMC (Weighted Methods per Class) and LCOM (Lack of Cohesion in Methods). The techniques are limited to count the number of functions (C++). However. we suggested a new weighted method that checks the number of parameters, the return value and its data type. Then we addressed an effective complexity measurement technique based on the weight of class interfaces to provide guidelines for measuring the class complexity of OO codes in reverse engineering. The results of this research show that the proposed complexity measurement technique ECC(Enhanced Class Complexity) is consistent and accurate in C++ environment.

• Journal of the Korea Society of Computer and Information
• /
• v.9 no.3
• /
• pp.135-141
• /
• 2004

With the diversified and enlarged softwares, the issue of software maintenance became more complex and difficult and consequently, the cost of software maintenance took up the highest portion in the software life cycle. We design Reverse Engineering Tool for software restructuring environment to object-oriented system. We design Rule - Based Reverse - Engineering using Class Information. We allow the maintainer to use interactive query by using Prolog language. We use similarity formula, which is based on relationship between variables and functions, in class extraction and restructuring method in order to extract most appropriate class. The visibility of the extracted class can be identified automatically. Also, we allow the maintainer to use query by using logical language. So We can help the practical maintenance. Therefore, The purpose of this paper is to suggest reverse engineering tool and evaluation reverse engineering tool.

• Journal of the Korean Institute of Intelligent Systems
• /
• v.15 no.6
• /
• pp.780-787
• /
• 2005

Many researches and validations for the complexity metrics of the object-oriented systems have been studied. Most of them are aimed for the measurement of the partial aspects of the systems, for example, the coupling between objects, the complexity of inheritance structures, the cohesion of methods, and so on. But the software practitioners want to measure the complexity of overall system, not partial. We studied the complexity of the overall structures of object-oriented systems by analyzing the class diagram of UML. The class diagram is composed of classes and their relations. There are three kinds of relations, association, generalization, and aggregation, which are making the structure of object-oriented systems to be difficult to understand. We proposed a heuristic metric to measure the complexity of object-oriented systems by putting together the three kinds of the relations. Tn analyze the complexity of the structure of a object-oriented system for the maintainability of the system, we measured the degree of understandability of it, the reverse engineering time to draw a class diagram from the source codes, and the number of errors in the diagram. The results of this experiment shows that our proposed metric has a considerable relationship with the complexity of object-oriented systems. The metric will be helpful to the software developers for their designing tasks by evaluating the complexity of the structures of object-oriented systems and redesigning tasks , of them for the future maintainability.

• The Transactions of the Korea Information Processing Society
• /
• v.6 no.4
• /
• pp.932-940
• /
• 1999

Object-oriented programming is often touted as promoting software reuse. However it is recognized that objected-oriented software often need to be restructured before it can be reused. refactoring is the process that changes the software structure to make it more reusable, easier to maintain and easire to be enhanced wit new functionalities. This paper desirbes experience gained and lessons learned from restructuring OODesigner, a Computer Aided Software Engineering(CASE) tool that supports Objects Modeling Technique(OMT). this tool supports a wide range of features such as constructing object modeler of OMT, managing information repository, documenting class resources, automatical generating C++ and java code, reverse engineering of C++ and Java cod, searching and reusing classes in the corresponding repository and collecting metrics data. although the version 1.x was developed using OMT(i.e the tool has been designed using OMT) and C++, we recognized that the potential maintenance problem originated from the ill-designed class architecture. Thus this version was totally restructured, resulting in a new version that is easier to maintain than the old version. In this paper, we briefly describe its restructuring process, emphasizing the fact that the Refactoring of the tool is conducted using the tool itself. Then we discuss lessons learned from these processes and we exhibit some comparative measurements of the developed version.

• The Transactions of the Korea Information Processing Society
• /
• v.5 no.10
• /
• pp.2546-2555
• /
• 1998

Existing Systems need to be modified due to the change of environment, the emergence of new technology and the requirement of change. One of the features of system transformation is how functions of the old system is preserved in the transformed system after reverse-engineering. But, the techniques to evaluate and verigy the transformed system have proceeded more partially and fragmentarily. In this paper, we have proposed the functional coverage and developed the tool and techniques for verifying functional euivalence between a procedural software and a transformed object-oriented software. The tool and methods are efficiently used to verigy whehter the transformed program preserves the same functionality as the existing program.

• The Transactions of the Korea Information Processing Society
• /
• v.6 no.7
• /
• pp.1805-1816
• /
• 1999

This paper presents the Module Class Dependency Graph for expressing the dependency relations between classes effectively. The object-oriented language is developed independently at design time, and consists of relationship between classes. Therefore we need to consider these characteristics of independence, and to express effectively the relation of classes which is existed in class hierarchy. In the System Dependence Graph and Class Dependence Graph, the relationship of classes is not expressed. To express the class relationship, we propose the Module Class Dependence Graph, and we verify the effectiveness of this method applying to object constructor, inheritance relationship and dynamic binding. Also, we presents the expressing method of parameter to identify the member data of classes. Using this Module Class Dependency Graph, we can analyze the relationship of module class correctly at design time. This method can be applied to reverse engineering, testing, visualization and other various fields to analyze system.