Earticle

시스템 최적화는 소스코드의 변경 없이 중복된 모듈을 추출하고, 추출된 모듈의 재사용을 위하여 프로그램 의 구조를 변경하는 기법이다. 구조지향 개발과 객체지향 개발은 크로스커팅 영역의 모듈화에는 효율적이나 크로스 커팅 개념을 모듈화 할 수 없다. 기존 시스템에서 크로스커팅 개념을 적용하기 위해, 각 시스템 내에 분산되어 있는 시스템 최적화 대상 모듈을 크로스커팅 영역으로 추출하는 기술이 필요하다. 본 논문에서는 개발이 완료된 시스템에 서 중복 모듈을 추출하기 위한 방법을 제안한다. 제안하는 방법은 소스코드 분석을 통해 데이터 의존관계와 제어 의 존관계를 분석하여 중복되는 요소를 추출한다. 추출된 중복된 요소는 시스템 최적화를 위하여 프로그램 의존 관계 분석에 사용될 수 있다. 중복된 의존관계 분석 결과는 제어 흐름 그래프로 변환되며, 이를 활용하여 최소 크로스커 팅 모듈을 생성할 수 있다. 의존 관계 분석을 통해 추출된 요소는 크로스커팅 영역 모듈로 설정함으로써 시스템 내 중복된 코드를 최소화 할 수 있는 시스템 최적화 방법을 제시한다.

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.

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.

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

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.

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

Refactoring is a technique to make a computer program more readable and maintainable. A bad smell is an indication of some setback in the code, which requires refactoring to deal with. Many tools are available for detection and removal of these code smells. These tools vary greatly in detection methodologies and acquire different competencies. In this work, we studied different code smell detection tools minutely and try to comprehend our analysis by forming a comparative of their features and working scenario. We also extracted some suggestions on the bases of variations found in the results of both detection tools.

The words Code smells mean certain code lines which makes problems in source code. It also means that code lines in bad design shape or any code made by bad coding habits. There are a few studies found in code smells detecting field. But these studies have their own weaknesses which are detecting only particular kinds of code smells and lack of expressing what the problems are. In this paper, we newly define code smells by using specification language OCL and use these models in auto detection. To construct our new code smells model, we first transform java source into XMI document format based on JavaEAST meta-model which is expanded from JavaAST meta-model. The prepared OCL will be run through OCL component based on Eclipse plug-in. Finally the effectiveness of the model will be verified by applying on primitive smell and derived smell in java source code.

Ontology matching is one of the most important challenges in the semantic web. It is a technique which is used to find the semantic correspondences between entities which are modeled in different ontologies. Despite many research efforts in ontology matching, the matching process still suffers from severe problems with respect to the quality of the matching results. Furthermore, finding the correspondences, for the most part, is very time-consuming. In this paper, we examine how a pre-processing phase can improve the results of the matching process. A pre-processing phase is added to the matchers for the analysis of input ontologies so as to detect some inappropriate patterns which are modeled by various developers. Then, refactoring operations are utilized on detected patterns for achieving assimilated ontologies. Finally, our proposed approach is tested by ASMOV (Automated Semantic Matching of Ontologies with Verification), which is one of the top matchers in OAEI (Ontology Alignment Evaluation Initiative). Experimental results show that ontologies achieved from this proposed approach are more efficient than the original unrepaired ones, with respect to standard evaluation measures.

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.

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.

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.

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.

기존의 교육용 소형 다관절로봇은 펌웨어를 이용하여 개발해왔다. 이런 시스템일 경우 단순동작만 수행할 수 있기 때문에 교육용으로 활용가치가 떨어진다. 그러나 교육용 소형 다관절로봇에 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 기법을 제시한다.