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

Developers can reuse not only class code but also wide range of knowledge on domain by reusing framework. Existing Object-Oriented Methodology and Catalysis Methodology were presented when redefining component in the course of redesigning framework. However, existing methodologies have weakness that entire process is waterfall mode or design of interface lays too much stress on implementation stage. So, this thesis will present Component-Oriented Methodology for the reuse of framework, and construct the environment for framework and domain development. That is, domain is analyzed by input of domain knowledge on real world to create software based on component, and hotspot is identified through analyzed information, and refactoring by putting additional information on users and developers. After that, I will create domain framework and application framework depending on domain. In this Component-Oriented Methodology, information is searched, understood and extracted or composite through component library storage internally. Then this information is classified into the information on component, and used as additional information in redesigning. With this, developer can obtain reusability, easiness and portability by constructing infrastructure environment that allows to register, update and delete component through Component Management System(CMS) under he development environment which can be easily applied to his own application using framework component, in this thesis, CoRBA(Common Object Request Broker Architecture) environment.

• Journal of the Korea Society of Computer and Information
• /
• v.26 no.1
• /
• pp.11-17
• /
• 2021

In this paper, we demonstrate a performance boost by parallelizing a purely functional bisimulation algorithm on a multicore processor machine. The key idea of this parallelization is exploiting the referential transparency of purely functional programs to minimize refactoring of the original implementation without any parallel constructs. Both original and parallel implementations are written in Haskell, a purely functional programming language. The change from the original program to the parallel program is minuscule, maintaining almost original structure of the program. Through benchmark, we show that the proposed parallelization doubles the performance of the bisimulation test compared to the original non-parallel implementation. We also shaw that similar performance boost is also possible for a memoized version of the bisimulation implementation.

• 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:Computing Practices and Letters
• /
• v.14 no.1
• /
• pp.81-85
• /
• 2008

The coupling measurements of object oriented programs can be valuable information for various maintenance tasks and there exists a variety of metrics proposed by numerous researchers. Those metrics, however, cannot measure the strength of dependencies between classes, but only imply the existence of dependencies. Hence they are of limited value for assisting maintenance tasks such as refactoring and system decomposition, which requires information about the strength of dependency. In this paper, a coupling metric which can measure the strength of dependence as well as detect the existence of dependencies is proposed. Our coupling metric is evaluated based on the cost required for performing the maintenance tasks. We have applied the proposed coupling metric to an example of system decomposition in an effort to assess the potential benefits of our approach for maintenance tasks.

• KIPS Transactions on Computer and Communication Systems
• /
• v.9 no.10
• /
• pp.213-220
• /
• 2020

The power consumption and performance of hardware-based mobile and IoT embedded systems that require high specifications are one of the important issues of these systems. In particular, the problem of excessive power consumption is because it causes a problem of increasing heat generation and shortening the life of the device. In addition, in the same environment, software also needs to perform stable operation in limited power and memory, thereby increasing power consumption of the device. In order to solve these issues, we propose a Low level power improvement via identifying performance dissipation. The proposed method identifies complex modules (especially Cyclomatic complexity, Coupling & Cohesion) through code visualization, and helps to simplify low power code patterning and performance code. Therefore, through this method, it is possible to optimize the quality of the code by reducing power consumption and improving performance.

• Journal of KIISE:Software and Applications
• /
• v.36 no.11
• /
• pp.891-900
• /
• 2009

The priority of software maintenance researches has been increasing, since the lengths of software lifecycle are more increasing. Measuring couplings among software entities provides a good quantitative source for analyzing source code and point out candidate refactoring positions. Logical-coupling measures how strongly two software entities are related with each other from the evolutionary point of view. The researches on logical-coupling have been focusing on improving the correctness and explaining more aspects that are hiding by measuring logical-coupling among finer-grained entities. However, existing researches on logical-coupling fails to consider characteristics of developers and projects reflected in transactions. The research proposes a logical-coupling measurement method based on transaction time, size and expertise of developer to improve the correctness by considering characteristics of developers and projects reflected in transactions. The method has been validated by applying it to three open-source projects.

• The KIPS Transactions:PartB
• /
• v.13B no.5 s.108
• /
• pp.547-552
• /
• 2006

There have been various cohesion measurements studied considering reference relation among attributes and methods in a class. Generally, these cohesion measurement are camed out in one class. If the range of reference relation considered are extended from one class to two classes, we could find out the reference relation between two classes. Tn this paper, we proposed a neural network to determine the method location. Neural network is effective to predict output value from input data not to be included in training and generalize after training input and output pattern repeatedly. Learning vector is generated with 30-dimensional input vector and one target binary values of method location in a constraint that there are two classes which have less than or equal to 5 attributes and methods The result of the proposed neural network is about 95% in cross-validation and 88% in testing.

• KIISE Transactions on Computing Practices
• /
• v.21 no.2
• /
• pp.148-153
• /
• 2015

In our domestic software industries, it is focused on such a high quality development/ testing process, maturity measurement, and so on. But the real industrial fields are still working on a code-centric development. Most of the existing legacy systems did not keep the design and highly increased the code complexity with more patching of the original codes. To solve this problem, we adopt a code visualization technique which is important to reduce the code complexity among modules. To do this, we suggest a tool chaining method based on the existing open source software tools, which extends NIPA's Software Visualization techniques applied to procedural languages. In addition, it should be refactored to fix bad couplings of the quality measurement indicators within the code visualization. As a result, we can apply reverse engineering to the legacy code, that is, from programming via model to architecture, and then make high quality software with this approach.

• Journal of Digital Convergence
• /
• v.15 no.3
• /
• pp.181-186
• /
• 2017

The system optimization is a technique that changes the structure of the program in order to extract the duplicated modules without changing the source code, reuse of the extracted module. Structure-oriented development and object-oriented development are efficient at crosscutting concern modular, however can't be modular of crosscutting concept. To apply the crosscutting concept in an existing system, there is a need to a extracting technique for distributed system optimization module within the system. This paper proposes a method for extracting the redundant modules in the completed system. The proposed method extracts elements that overlap over a source code analysis to analyze the data dependency and control dependency. The extracted redundant element is used to program dependency analysis for the system optimization. Duplicated dependency analysis result is converted into a control flow graph, it is possible to produce a minimum crosscutting module. The element extracted by dependency analysis proposes a system optimization method which minimizes the duplicated code within system by setting the crosscutting concern module.

• The Journal of the Korea Contents Association
• /
• v.11 no.5
• /
• pp.75-83
• /
• 2011

Aspect-oriented programming is the paradigm which extracts crosscutting concern from a system and solves scattering of a function and confusion of a code through software modularization. Existing aspect developing method has a difficult to extract a target area, so it is not easy to apply aspect mining. In an aspect minning, it is necessary a technique that convert existing program refactoring elements to crosscutting area. In the paper, it is suggested an aspect mining technique for extracting crosscutting concern in a system. Using abstract syntax structure specification, extract functional duplicated relation elements. Through Apriori algorithm, it is possible to create a duplicated syntax tree and automatic creation and optimization of a duplicated source module, target of crosscutting area. As a result of applying module of Berkeley Yacc(berbose.c) to mining process, it is confirmed that the length and volume of program has been decreased of 9.47% compared with original module, and it has been decreased of 4.92% in length and 5.11% in volume compared with CCFinder.