• The KIPS Transactions:PartD
• /
• v.18D no.1
• /
• pp.23-34
• /
• 2011

Refactoring has been actively used in recent software developments. Many studies on the processing of more large scaled composite refactorings have been conducted through the composition of elementary refactorings. It is important to verify the possibility of composition before the refactoring is performed, because the composite refactorings are processed to the sequence of composed elementary refactorings. In conventional studies, they verify the possibility of composition using the precondition of composite refactorings which are computed from the precondition and postcondition of elementary refactorings. They can not verify the possibility of composition in case which composite refactorings do not have a specification of precondition. Thus, we plan to verify the possibility of composition by using the elementary refactorings only without any additional definitions of the preconditions of composite refactorings. To achieve this goal, we proposes a specification method of elementary refactorings and a method for the composition check of refactorings. Then, we develop a prototype tool based on these methods. In addition, we verify the efficiency of our methods through case studies.

• 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 Computing Science and Engineering
• /
• v.7 no.4
• /
• pp.251-262
• /
• 2013

Bad smells are usually related to program source code, arising from bad design and programming practices. Refactoring activities are often motivated by the detection of bad smells. With the increasing adoption of Design-by-Contract (DBC) methodologies in formal software development, evidence of bad design practices can similarly be found in programs that combine actual production code with interface contracts. These contracts can be written in languages, such as the Java Modeling Language (JML), an extension to the Java syntax. This paper presents a catalog of bad smells that appear during DBC practice, considering JML as the language for specifying contracts. These smells are described over JML constructs, although several can appear in other DBC languages. The catalog contains 6 DBC smells. We evaluate the recurrence of DBC smells in two ways: first by describing a small study with graduate student projects, and second by counting occurrences of smells in contracts from the JML models application programming interface (API). This API contains classes with more than 1,600 lines in contracts. Along with the documented smells, suggestions are provided for minimizing the impact or even removing a bad smell. It is believed that initiatives towards the cataloging of bad smells are useful for establishing good design practices in DBC.

• 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.

• The KIPS Transactions:PartA
• /
• v.18A no.6
• /
• pp.271-280
• /
• 2011

Time-Triggered Architecture (TTA), one of real-time software design paradigms which executes tasks in timely manner, has long been advocated as being better suited in fore-sighting system behavior than event-triggered architecture (ETA). To gain this valuable feature of TTA, however, precise task designing process is mandatory. Alternatively, ETA tries to execute tasks whenever paired events are occurred. It provides intuitive and flexible basement to add/remove tasks and, moreover, better response time performance. However ETA is difficult to analyze because system behavior might be different depending on the order of interrupts detected by the system. Many previous researches recommended TTA when developing safety-critical real-time systems, but cost problem of task designing process and insufficient consensus for applying rigorous software engineering practice are still challenging in practice. This paper describes software refactoring process which applying TTA approach into ETA based embedded software in artificial heart system. We implemented dedicated interrupt monitoring program to capture existing tasks' real-time characteristics. Based on the captured information, proper task designing process is done. Real-time analysis using RMA (Rate-Monotonic Analysis) verified that new design guarantees timeliness of the system. Empirical experiments revealed that revised design is as efficient, when measured in terms of system's external output, as the old design and enhances predictability of the system behavior as well.

• Proceedings of the Korea Information Processing Society Conference
• /
• 2022.11a
• /
• pp.85-87
• /
• 2022

고품질 코드를 위한 정적 분석은 아직도 매우 필요한 영역이며, 또한 코드의 가시화는 개발자들에게 코드의 복잡한 모듈에 대한 가이드에 필요하다. 기존의 코드 가시화는 정적 분석의 코드 내부 정보들을 DB 테이블화 및 품질 지표(CK Metrics, Coupling, # function Calls, Bed smell) 질의어화, 그리고 추출된 정보를 가시화하는 것에만 초점을 두었다. 문제는 코드 내부 정보(Class, method, parameters, etc) 테이블들에 대한 join 연산 시 엄청난 시간과 리소스가 소모된다. 이 문제를 해결하기 위해, 우리는 테이블 설계의 정규화를 제안한다. 또한 필요한 품질 지표의 질의를 통해 코드 내부 정보 추출하여 데이터 및 제어 복잡 모듈을 식별하여 refactoring 를 가이드 한다. 앞으로는 이 부분의 AI learning 을 통해 bad/good program 을 식별을 기대한다.

• Journal of Multimedia Information System
• /
• v.4 no.4
• /
• pp.255-262
• /
• 2017

In recent software development, repetitive code fragments (i.e., clones) are common due to the copy-and-paste programming practice, the framework-based development, or the reuse of same design patterns. Such similar code fragments are likely to introduce more bugs but are easily disregarded by a code reviewer or a programmer. In this paper, we present a code review tool to help code reviewers identify important code changes written by other programmers and recommend which changes need to be reviewed first. Specifically, to identify important code changes, our approach detects code clones across revisions and investigates them. Then, to help a code reviewer, our approach ranks the identified changes in accordance with several software quality metrics and statistics on those clones and changes. Furthermore, our approach allows the code reviewer to express their preferences during code review time. As a result, the code reviewer who has little knowledge of a code base can reduce his or her effort by reviewing the most significant changes that require an instant attention. To evaluate our approach, we integrated our approach with a modern IDE (e.g., Eclipse) as a plugin and then analyzed two third-party open source projects. The experimental results indicate that our approach can improve code reviewer's productivity.

• 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.

• International Journal of Advanced Culture Technology
• /
• v.10 no.4
• /
• pp.175-180
• /
• 2022

To develop computational thinking skills, university students are learning how to solve problems with algorithms, program commands and grammar, and program writing. Because non-computer majors have difficulty with computer programming-related content, they need a learning method to acquire coding knowledge from the process of understanding, interpreting, changing, and improving source codes by themselves. This study explored clone coding, refactoring coding, and coding methods using reconstruction tools, which are practical and effective learning methods for improving coding skills for students who are accustomed to coding. A coding learning process with the code reconstruction principle was designed to help non-computer majors use it to understand coding technology and develop their problem-solving ability and applied the coding technology learning method used in programmer education.

• Proceedings of the Korean Society of Computer Information Conference
• /
• 2020.07a
• /
• pp.389-390
• /
• 2020

배포된 소프트웨어는 고객의 새로운 요구사항을 반영하면서 기능을 추가하거나 수정한다. 수정된 소프트웨어는 문제없이 동작하지만, 내부의 구조는 점점 더 복잡해지면서 유지보수가 어려워지고, 수정 시 버그 발생 확률이 높아지게 된다. 이에 따라 잘못된 코드 구조를 개선하고, 소프트웨어의 품질을 향상시켜야한다. 본 논문에서는 개발된 ERP 근태관리 시스템이 지속적인 요구사항을 반영하면서 발생한 잘못된 코드 구조인 코드 스멜을 탐지하고 분석하는 연구를 진행하였다.