Earticle

Software refactoring is a process to restructure an existing software code while keeping its external behavior the same. Currently, various refactoring techniques are being used to develop more readable and less complex codes by improving the non-functional attributes of software. Refactoring can further improve code maintainability by applying various techniques to the source code, which in turn preserves the behavior of code. Refactoring facilitates bug removal and extends the capabilities of the program. In this paper, an exhaustive review is conducted regarding bad smells present in source code, applications of specific refactoring methods to remove that bad smell and its effect on software quality. A total of 68 studies belonging to 32 journals, 31 conferences, and 5 other sources that were published between the years 2001 and 2019 were shortlisted. The studies were analyzed based on of bad smells identified, refactoring techniques used, and their effects on software metrics. We found that "long method", "feature envy", and "data class" bad smells were identified or corrected in the majority of studies. "Feature envy" smell was detected in 36.66% of the total shortlisted studies. Extract class refactoring approach was used in 38.77% of the total studies, followed by the move method and extract method techniques that were used in 34.69% and 30.61% of the total studies, respectively. The effects of refactoring on complexity and coupling metrics of software were also analyzed in the majority of studies, i.e., 29 studies each. Interestingly, the majority of selected studies (41%) used large open source datasets written in Java language instead of proprietary software. At the end, this study provides future guidelines for conducting research in the field of code refactoring.

코드 리팩토링은 소프트웨어 시스템의 코드를 변경함으로써 새로운 요구사항 반영, 버그 수정, 코드 구조화 등을 달성하기 위한 유지보수 활동이다. 리팩토링 유형, 리팩토링 효과, 지원 도구 등에 관한 다양한 연구가 진행 중이다. 하지만, 많은 연구들이 자바 응용들을 대상으로 하고 있으며 파이썬 응용에 관한 리팩토링 연구는 사례가 많지 않다. 본 논문은 파이썬으로 개발된 딥러닝 시스템을 대상으로 단일 리팩토링과 복합 리팩토링을 식별하고 특성을 분석하였다. 또한, 딥러닝 응용과 일반 파이썬 응용 두 그룹에서 단일 및 복합 리팩토링 연산의 발생 빈도에 있어 통계학적 유의미한 차이가 있음을 확인하였다. 또한, 커밋 메시지의 키워드를 분석하여 소프트웨어 개발자들의 리팩토링 의도가 커밋 메시지에 반영되었는지를 분석하였다.

Code refactoring refers to a maintenance task to change the code of a software system in order to consider new requirements, fix bugs, and restructure code. There have been various studies of refactoring subjects such as refactoring types, refactoring benefits, and CASE tools. However, Java applications rather than python ones have been benefited by refactoring-based coding practices. There are few cases of refactoring stuides on Python applications. This paper finds and analyzes single refactoring operations and composite refactoring operations for Python-based deep learning systems. In addition, we find that there is a statistically significant difference in the frequency of occurrence of single and complex refactoring operations in the two groups of deep learning applications and typical Python applications. Furthermore, we analyze keywords of commit messages to catch refactoring intentions of software developers.

IT 기술 및 비즈니스의 급속한 발전에 따라 새로운 서비스를 고객에게 제공하기 위한 노력이 증가하고 있으 며, 신속한 서비스 제공을 위해 기존의 레거시 시스템에 대한 개선 및 확장이 빈번히 발생하고 있다. 이로 인하여 기존 레거시 시스템에 대한 소스 코드의 품질 확보는 서비스 요구에 신속히 대응할 수 있는 핵심적인 기술 요소가 되었다. 리팩토링은 기존 레거시 코드에 대한 품질을 확보하기 위한 공학적 기술로서, 부가가치를 제공하는 레거시 시스템의 개선 및 확장에 필수적이다. 본 논문에서는 레거시 시스템의 소스 코드 품질 향상을 위한 기존의 리팩토링 기법과 지원 도구에 대한 조사 분석을 통해 리팩토링 기법과 도구에 대한 특성을 제안한다. 제안하는 특성을 기반으 로 서비스 개발자가 레거시 시스템의 소스 코드 품질 향상을 위하여 리팩토링을 수행하고자 하는 경우, 어떠한 기법 과 도구를 활용할 것인가에 대한 가이드라인을 제공받을 수 있다. 이를 통해 보다 정확하고 시행착오 없는 레거시 시스템의 소스 코드 품질을 향상시킬 수 있으며, 새로운 서비스에 대한 신속한 대응도 가능하게 될 것이다.

Along with the rapid development of IT technology and business services, the effort to provide new services to the customers has been increasing, and also the improvement and enhancement of legacy systems are continuously occurring for rapid service delivery. In this situation, the quality assurance of the source code for the legacy system became a key technical elements that can quickly respond to the service needs. Refactoring is an engineering technique to ensure the quality for the legacy code, and essential for the improvement and extension of the legacy system in order to provide value-added services. This paper proposes some features of refactoring techniques through surveying and analyzing the existing refactoring techniques and tools to enhance source code quality. When service developers want to refactor the source code of the legacy system to enhance code quality, our proposed features may provide with the guidance on what to use any technique and tool in their work. This can improve the source code quality with correct refactoring and without trial and error, and will also enable rapid response to new services.

리팩토링은 기존 레거시 코드에 대한 품질을 확보하기 위한 공학적 기술로서, 프로그램의 기능은 변하지 않으면서 내부 구조를 개선하는 작업이다. 다양한 오픈 소스 소프트웨어가 재사용되면서, 기술적 이유 또는 시장 요구로 인하여 프로그래밍 언어 변환을 통한 소스 코드 재사용이 점진적으로 요구되고 있다. 이러한 상황에서 에너지 효율성을 고려하는 언어 변환 리팩토링 기법은 임베디드 소프트웨어 개발의 생산성은 물론 품질 향상을 위한 중요한 수단으로 여겨지고 있다. 본 논문에서는 기존에 제시된 에너지 절감형 리팩토링 기법에 추가하여 프로그래밍 언어의 문법 및 구조의 비교와 매핑을 통해 다른 언어로 변환하는 코드 리팩토링 기법을 제시하였다. 제안하는 리팩토링 기법의 활용은 소프트웨어 개발 언어의 환경 변화에 대처하고, 기존 코드의 재사용을 높임으로써 신속한 소프트웨어 개발 및 품질 향상을 통한 제품의 경쟁력 향상을 기대할 수 있다.

Refactoring is an engineering technique for securing the quality of existing legacy code, improving the internal structure without changing the functionality of the software. Along with the reuse of open source software, reuse of source code through programming language conversion is increasingly required due to technical or market requirements. In this situation, the refactoring technique including language conversion as well as energy efficiency is considered to be an important means for improving the productivity and the quality of embedded software development. This paper proposes a code refactoring technique that converts the grammar and structure of a programming language into those of a different language through comparison and mapping, in addition to the existing energy efficient refactoring technique. The use of the proposed refactoring technique can expect to improve the competitiveness of the product through rapid software development and quality improvement by coping with the environment change of the software development language and enhancing the reuse of the existing code.

대형 언어 모델의 발전으로 코드 자동 생성뿐만 아니라 코드 리팩토링까지 자동화하려는 시도가 활 발히 이루어지고 있다. 그러나 단일 모델이 전체 리팩토링 과정을 처리하는 방식은 구조적 한계와 기 능 보존의 어려움을 가지는 문제를 야기한다. 본 논문은 이러한 문제를 해결하고자 역할 분담형 멀팉 에이전트 구조를 기반으로 한 코드 리팩토링 자동화 시스템을 설계하고 구현하였다. 각 에이전트는 분 석, 수정, 검증, 리뷰를 독립적으로 수행하며, 실제 리팩토링 과제를 통해 자동화 흐름과 품질 평가 체 계를 구성하였다.

Nowadays, changes in software development are inevitable. Therefore, understanding and analysis of changes considered more important than anything else. The existing version control systems, which are used for effective change management, are impossible to trace changes in the presence of refactoring. There have been a number of approaches proposed for trace changes using operation-based mechanisms or rule-based mechanisms. However, it has many limitations with excessive recording or not sufficient coverage. In this approach, we define four rules based on M.Flower’s refactoring techniques and find an origin method matching the pattern of changed source code with the pre-defined rules. The case study shows that the proposed mechanism is effective Also, case study looking for open source project code changes about the origin method show the proposed mechanism’s effectiveness.

Technical debt management requires means to identify, track, and resolve technical debt in the various software project artifacts. There are several approaches for identifying technical debt from the software implementation, but they all have their shortcomings in maintaining this information. Readily available information is a cornerstone of successful technical debt management integration. As such, this paper presents a two-partite case study that explores the role of dependency propagation in the accumulation of technical debt for software implementations. The first part, targeting a refactorization project in the ViLLE education platform, identifies a clear relation between the propagation and the accumulation in addition to making notions about special propagation characteristics. The second part considers bug reports for the Eclipse IDE, and, thus, provides further verification in observing a similar relationship at a lower implementation abstraction level for this independent data set. We conclude that formalization of this relation should lead to solutions for the technical debt information maintenance problem. As such, we use the case study herein to further improve the propagation model applied in our DebtFlag technical debt management tool.

The use of biocatalysts such as isolated enzymes and whole-cell systems for industrial applications requires high-yield and low-cost conversion for economical feasibility. One of the issues to be solved is to continuously supply cofactors that are often needed for complex enzymatic reactions but typically expensive. Allowing catalytic amounts of cofactors to be regenerated during the processes can provide a driving force to the thermodynamically unfavorable reactions and subsequently increase the yield and productivity of the bio-catalysis. In this study, we re-designed NADH-regeneration system of E. coli for the high-yield production of butyrate from glucose. The engineered strain showed a theoretical yield of 95% and volumetric productivity of 0.255g/l/h in a batch culture. Our work demonstrated that E. coli can be probably used as a butyrate producer, and this strategy can be broadly utilized for the production of various useful chemicals in the fields of metabolic engineering and synthetic biology.

Multi-threaded Java applications using synchronized or reentrant locks respectively exist performance trade-off. Parallel programmers usually use manual refactoring to test the performance of locks in a particular environment. However, manual refactoring is labor-intensive and error-prone. There is a strong need for automated support to find which one is more suitable to exert the performance of applications. This paper presents a refactoring framework to enable the transformation from synchronized locks to reentrant locks automatically. The framework analyzes global monitors based on Quad intermediate representation and visitor pattern in the Joeq compiler, validates the consistency of analysis results, and performs the transformation. The framework is evaluated on three benchmarks including red-black tree, producer-consumer problem, and SPECjbb2005. The total time is less than 4s for all three benchmarks on common desktop computer, and the successful refactoring results are observed.

Since software refactoring techniques were introduced, the process is commonly applied to alter the structure of source code. However, there is also increasing popularity in the topic of refactoring in other software artifacts at non-source code level. This paper provides a systematic literature review of existing studies in non-source code refactoring. We use two digital libraries as publication source, IEEExplore and Science Direct, to obtain published articles in non-source code refactoring topic published in between 2002 – 2014 with certain keywords. The 20 selected literatures then processed based on certain criteria, including the refactoring method and refactoring identification source. Then we use this information to provide categorization of non-source code refactoring activity and the advantages and disadvantages of each category. The systematic literature review performed has provided categorization of non-source code refactoring method and has shown that each method has certain advantages and disadvantages. Refactoring detection at non-source code level can be done in the software design model, source code with non-conventional detection, and other software artifacts. The methods used can be categorized as heuristic method, where the refactoring identification is done based on certain rules, and non-heuristic method, where the refactoring identification is done with a certain algoritm that explores every possibility of refactoring opportunities. The advantage of heuristic method is the speed and precision. The disadvantage of this method is the needed effort to produce the rules and the possibility of the non optimal result. The advantage of non-heuristic method is it can yield a generally more optimal result. The disadvantage of non-heuristic method is that the result depends strongly on the robustness of each algorithm.

Enhancing software maintenance productivity is very important in the modern information society, where demand for software surges. To enhance productivity, active tool support is necessary. Especially, a refactoring tool that can alter the internal structure of software to more easily understandable and modifiable structure hugely affects software maintenance productivity. This paper proposes a code model to support software maintenance tool developers to easily access and handle software source codes. Also, this paper shows the implementation method of software refactoring operation using the proposed code model.

Software refactoring is a collection of reengineering activities that aims to improve software quality. Refactorings are commonly used in agile software processes to improve software quality after a significant software development or evolution. There is belief that refactoring improves quality factors such as understandability, flexibility, and reusability. However, there is limited empirical evidence to support such assumptions. The aim of this study is to confirm such claims using a hierarchal quality model. We study the effect of software refactoring on software quality. We provide details of our findings as heuristics that can help software developers make more informed decisions about what refactorings to perform in regard to improve a particular quality factor. We validate the proposed heuristics in an empirical setting on two open-source systems. We found that the majority of refactoring heuristics do improve quality; however some heuristics do not have a positive impact on all software quality factors. In addition, we found that the impact analysis of refactorings divides software measures into two categories: high and low impacted measures. These categories help in the endeavor to know the best measures that can be used to identify refactoring candidates. We validated our findings on two open-source systems—Eclipse and Struts. For both systems, we found consistency between the heuristics and the actual refactorings.

Software refactoring is a technique that transforms the various types of software artifacts to improve the software internal structure without affecting the external behavior. Refactoring is commonly applied to improve the software quality after a significant amount of features are added. Researchers in the area have studied the different angles of refactoring and developed the right evidence, knowledge and skill. And they published their research findings through journals and conference papers to provide an easy access to everyone. Eventually, the knowledge accumulated in these literatures is huge, so that it needs structuring and organizing. The main purpose of this study is to extend a previously conducted study by covering more literatures and applying a systematic literature review method to increase the accuracy and validity of the study. We study a collection of literature from different electronic databases, published since 1999 to understand and extract the software refactoring knowledge through classification and summarization. The classification and summarization can reveal the research pattern, common concerns and statistics of the published papers in the last fifteen years. The extracted information should help the researchers to formulate better research topics that can solve the crucial problems in software refactoring and save the researchers effort and time.

Software testing is a set of activities that typically consumes roughly 50% of the total time and cost of testers during the software development process. Developing an enhanced technique to test mobile application becomes a necessity considering the high demand of mobile applications, android specifically, hence the need for software quality assurance. Adapting software testing model would not only lessen the cost incurred in the process of mobile application development but also increase the reliability of the software under test. In this paper, we discuss mobile application testing and its challenges. The Reweb and Testweb frameworks are also discussed followed by an adaptation model from both frameworks to improve testing of android applications. Asides from adapting these web application testing frameworks, another major contribution of our approach is the refactoring the source code before generating test cases to reduce redundancy in the test case library thereby improving the generated test case. Keywords: Refactoring, Android Application, Software

기존의 교육용 소형 다관절로봇은 펌웨어를 이용하여 개발해왔다. 이런 시스템일 경우 단순동작만 수행할 수 있기 때문에 교육용으로 활용가치가 떨어진다. 그러나 교육용 소형 다관절로봇에 RTOS를 적용하면 다양한 동작의 수행이 가능하다. RTOS를 적용하면 시스템의 효율이 높아지지만 SW 복잡도가 높아져 교육용으로 사용하기 어려운 문제가 있다. 이런 문제를 해결하기 위해서 본 논문에서는 디자인 패턴과 리팩토링을 적용한다. 디자인 패턴과 리팩토링을 적용하여 RTOS를 설계하면 이미 알려진 패턴의 개념이 사용되기 때문에 RTOS의 전문 개발자가 아니어도 이해하기 쉬워진다. 뿐만 아니라 설계가 문서화되기 때문에 기존의 RTOS를 이용하여 새로운 시스템에 알맞은 RTOS로 변경이 용이해 진다. 그래서 본 논문에서는 디자인패턴을 사용하여 RTOS를 설계하고 RTOS 코드에 리팩토링을 적용하였다.

The traditional small educational multi-joint robots were developed on firmware. In these system's case, we cann't give a chance to educate good practices due on executing just robot's simple movements. But it may be possible for RTOS to control the elaborate movement of the robot with assembling each part on firmware. With this RTOS, we can enhance the efficiency of robot's movements, but too difficult to use the education as increasing the complexity of robot system. To solve the problem, we apply with Design pattern and Refactoring for the Education. Applying robot's design with Design pattern and Refactoring. There may be easily understand what and how to design RTOS for any level ones. We may easily change/upgrade RTOS for new system with this approach. This paper mentions to design RTOS with Design patterns and to apply RTOS's source code with Refactoring.

리팩토링은 코드의 동작이나 의도는 유지하면서 코드의 구조, 재사용성, 가독성을 개선해 전체 디자인을 개선하는 방법이다. 현재 많은 IDE (통합 개발 환경)에서 반자동 리팩토링 기능이 이용되고 있다. 반자동 리팩토링은 리팩토링을 할 소스 코드의 위치와 적용하는 리팩토링 패턴을 지정함으로써 소스 코드 재작성을 자동으로 실행하는 기능이다. 반자동 리팩토링 기능은 리팩토링을 효율적으로 할 수 있기 때문에 효과적인 기능이지만 조작이 복잡하고 사용하기 어렵다는 문제점이 있다. 따라서 단순하고 직관적으로 사용할 수 있는 리팩토링 조작방법이 필요하다고 하겠다. 본 연구에서는 대화형 작업을 이용한 리팩토링 기법을 제안한다. 이 기법은 작업을 단순화하고, 시행착오를 줄일 수 있도록 Eclipse 플러그인으로 구현하도록 한다.

Refactoring the code, while maintaining the action or intention of the structure of the code, reusability, and improved readability of how to improve the overall design. Many IDE (Integrated Development Environment) have been used in semi-automatic refactoring. Semi-automatic refactoring is a of source code, specify the location and applying refactoring patterns rewrite the source code is the ability to automatically run. Semiautomatic refactoring is effective because they can efficiently function, but operation is complicated and difficult to use problems. Therefore, the refactoring can be used as a simple and intuitive method of operation will require. In this study, using interactivity refactoring techniques is proposed. The technique is to simplify and reduce the trial-and-error to allow the implementation of an Eclipse plug-in.

소프트웨어 유지보수는 노력과 시간이 많이 소요된다. 유지보수 되는 기존의 시스템들을 규모가 크고 복잡하기 때문에 운영비용의 대부분이 소프트웨어 유지보수에 소요되는 실정이다. 소프트웨어의 재사용은 이러한 문제점들을 해결하기 위하여, 소프트웨어 역공학, 재공학, 컴포넌트와 같은 많은 기법들이 제안되었다. 이런 기법들 중에서 재공학은 재사용 하려는 소프트웨어를 분석, 재정의, 재문서화 등의 소프트웨어 역공학 방법을 통하여 좀더 효율적으로 소프트웨어를 분석할 수 있고, 순공학을 통해 문제점들의 교환과 새로운 구조와 시스템의 수정을 통해 더욱 경제적인 시스템을 만들 수 있다. 본 논문에서는 시스템의 유지보수와 재사용을 위한 재공학 Refactoring 기법을 제시한다.

현재 기업들은 거의 모든 부분이 전산화 작업으로 이루어지고 있으며, 기업의 중요한 업무는 모두 방대한 시스템이 사람을 대신해서 처리해 주고 있는 실정이다. 하지만 시스템 유지보수의 체계적인 프로세스에 대해서는 현재 연구된 바가 없어 쉽게 적용할 수 없는 문제가 존재한다. 재공학은 재사용하려는 소프트웨어를 분석, 재정의, 재문서화 등의 소프트웨어 역공학 방법을 통하여 좀더 효율적으로 소프트웨어를 분석할 수 있고, 순공학을 통해 문제점들의 교환과 새로운 구조와 시스템의 수정을 통해 더욱 경제적인 시스템을 만들 수 있다. 객체지향 어플리케이션의 Refactoring에서는 대표적으로 클래스간의 공통성을 추출하고, 이를 일반화시켜 추상클래스를 생성 및 삭제, 이동하는 과정을 통해 소프트웨어의 구조를 변경시켜 시스템의 성능향상을 도모하게 된다. 본 논문에서는 시스템의 재사용을 위한 실증적인 객체지향 Refactoring 기법을 제시한다.

We have released five Java Application Programming Interface (API) packages for viewing three-dimensional structures of proteins from the Protein Data Bank. To this end, the user interface of an earlier version has been refactored in an object-oriented fashion, in which refactoring is the process of changing a software system to improve its internal structure, without altering the external behavior. Various GUI design and features have been provided conveniently thanks to the Model-View-Control (MVC) model, which is an architectural pattern used in software engineering. Availability: The source code and API specification can be downloaded from https://sourceforge.net/projects/j3dpsv/.

기업에서는 급속한 컴퓨터 환경 변화 및 사용자 요구 증가 등의 요구들에 대응하기 위하여 많은 시간과 비용을 들여 기 개발되어 운영중인 시스템을 유지보수 한다. 하지만 대부분 임시적인 이러한 작업들은 많은 코드의 중복과 최적화 되지 않은 시스템 구조를 산출하여 결국에는 전체적인 성능 저하를 가져오는 등의 문제를 발생시키게 된다. 또한 초기 개발 후 다른 개발자에 의해 작성된 코드는 개발관련 문서의 분실 및 부족, 기존 시스템 개발자의 부재 등의 문제로 코드의 이해와 재사용의 어려움 등의 한계점을 갖게 되었다. 이번 연구는 이러한 코드 재사용의 한계를 극복하기 위하여 객체단위를 재사용 할 수 잇는 객체지향 기반의 Refactoring 프로세스를 제시하고, 이를 D사에서 개발한 윈도우 시스템 개발 도구인 D2D에 적용한다. 또한 이의 과정에서 얻어진 시스템 성능 향상과 개발 및 유지보수 비용의 감소, 구조와 클래스들의 최적화 등의 실제적인 효과 증대 사례를 보인다.

The company invests its time and money for temporary maintenance to satisfy the fast change of the computer use environment and the user's demands. Therefore, various problems occur including low performance because of duplication of codes and unstable structures from the restructuring and redevelopment. Furthermore, if a developer, who did not participate in initial process of development, wrote additional program codes to upgrade or restructure, it would cause many problems such as lack or lose of development documentation, understanding of documentation and reuse of existing program language. This study, Object-oriented Refactoring Process, suggests that the developers can reuse object unit to overcome the limit of the reusing code. In addition, this paper shows case study to verify our process by adjusting the project called "D2D", which is a case tool for developing windows system from Company D. Our works get positive results such as improvement of system pelfonnance, decreased cost of development and maintenance and optimizing structure and class.