Refactoring: improving the design of existing code

Bostonxxi, 431 p.: illus.; 25 cm

30 Years of Software Refactoring Research:A Systematic Literature Review

Due to the growing complexity of software systems, there has been a dramatic increase and industry demand for tools and techniques on software refactoring in the last ten years, defined traditionally as a set of program transformations intended to improve the system design while preserving the behavior. Refactoring studies are expanded beyond code-level restructuring to be applied at different levels (architecture, model, requirements, etc.), adopted in many domains beyond the object-oriented paradigm (cloud computing, mobile, web, etc.), used in industrial settings and considered objectives beyond improving the design to include other non-functional requirements (e.g., improve performance, security, etc.). Thus, challenges to be addressed by refactoring work are, nowadays, beyond code transformation to include, but not limited to, scheduling the opportune time to carry refactoring, recommendations of specific refactoring activities, detection of refactoring opportunities, and testing the correctness of applied refactorings. Therefore, the refactoring research efforts are fragmented over several research communities, various domains, and objectives. To structure the field and existing research results, this paper provides a systematic literature review and analyzes the results of 3183 research papers on refactoring covering the last three decades to offer the most scalable and comprehensive literature review of existing refactoring research studies. Based on this survey, we created a taxonomy to classify the existing research, identified research trends, and highlighted gaps in the literature and avenues for further research.Comment: 23 page

Advances and Challenges in Software Refactoring: A Tertiary Systematic Literature Review

Software refactoring is one of the most critical aspects of software maintenance. It improves the quality of the software, reduces potential occurrence of bugs and keeps the code easier to maintain, extend and read. The process of refactoring supports and enables the developers to improve the design of software without changing the behavior. However, the automation of this process is complex for developers and software engineers since it is subjective, time and resource consuming. In this context, many literature reviews have analyzed the existing effort made by researchers to facilitate refactoring, as a core software engineering practice. This paper, aims in integrating all the existing research outcomes by performing a tertiary study on all the secondary studies, done in the area of refactoring. Based on our analysis we notice that there are many area of software refactoring that are under studied. As an outcome of this review, several classifications of existing studies were provided to showcase all the studies targeting the automation of refactoring along with explaining what metrics and objectives were used as means to drive refactoring and how it was assessed. This thesis also aims in unveiling areas of future directions for the research community in order to consolidate their efforts in improving the refactoring as a practice

Can feature requests reveal the refactoring types?

Software refactoring is the process of improving the design of a software system while preserving its external behavior. In recent years, refactoring research has been growing as a response to the degradation of software quality. Recent studies performed an in-depth investigation in (1) how refactoring practices are taking place during the software evolution, (2) how to recommend refactoring to improve the design of software, and (3) what type of refactoring operations can be implemented. However, there is a lack of support when it comes to developers’ typical programming tasks, including feature updates and bug fixes. The goal of this thesis is to investigate whether it is possible to support the developer through recommending appropriate refactoring types to be performed when the developer is assigned a given issue to handle. Our proposed solution will take as input the text of the issue along with the source code and tries to protect the appropriate refactoring type that would help in adapting efficiently the existing source code to the given feature request. To do so, we rely on the use of supervised learning. We start with collecting various issues that were handled using refactoring. This data will be used to train a model that will be able to predict the appropriate refactoring, given as input an Open issue description. We design a classification model that inputs a feature request and suggests a method-level refactoring. The classification model was trained with a total of 4008 feature request examples of four refactoring types. Our initial results show that this solution suffers from several challenges including the class imbalance: not all refactoring types are equally used to handle issues. Another challenge we detected is related to the description of the issue itself which typically does not explicitly mention any potential refactoring. Therefore, there will be a need for a large set of issues to be able to appropriately learn any patterns among them that would discriminate towards a given refactoring type

Analisis dan Implementasi Refactoring Untuk Mendapatkan Strategy Pattern Pada Kode Program Berorientasi Objek (Studi Kasus : Aplikasi Transaksi Penjualan Kredit Indohome Bandung)

ABSTRAKSI: Refactoring merupakan proses memperbaiki desain perangkat lunak yang sudah ada tanpa mengubah external behavior perangkat lunak tersebut. Design pattern secara singkat adalah pola desain perangkat lunak yang digunakan untuk memecahkan masalah tertentu yang selalu berulang-ulang sebelumnya. Menurut Joshua Kerievsky dalam bukunya Refactoring to Pattern, untuk mengaplikasikan design pattern sebelum implementasi ternyata sangat sulit. Oleh karena itu, pada tugas akhir ini akan diimplementasikan refactoring pada kode program berorientasi dari perangkat lunak Aplikasi Transaksi Penjualan Kredit Indohome Bandung yang sudah ada sebelumnya. Design Pattern yang akan dituju adalah Strategy Pattern dimana pattern ini akan menyediakan sebuah interface strategy untuk menyediakan antar-muka bagi kelas client untuk memilih algoritma implementasi yang tepat pada saat program berjalan (runtime). Refactoring akan dilakukan pada bagian kode program yang sudah teridentifikasi mengandung bad smells in code. Hasil yang diharapkan setelah implementasi refactoring adalah kemiripan struktur diagram kelas hasil refactoring dengan diagram kelas yang menggunakan Strategy Pattern.Kata Kunci : refactoring, design pattern, strategy pattern, bad smells in codeABSTRACT: Refactoring is the process of improving the design of existing software without changing the external behavior of such software. Design pattern in brief is a software design pattern that is used to solve a specific problem that is always repeated before. According to Joshua Kerievsky in his book Refactoring to Patterns, to apply design patterns before implementation was very difficult. Therefore, the final project will be implemented in program code-oriented refactoring of software applications Indohome Bandung Credit Sales Transactions that already exists. Design Pattern to be addressed is Strategy Pattern in which the pattern of this strategy will provide an interface to provide the interface for the client class to choose the right algorithm implementations when the program runs (runtime). Refactoring will be done on the program code that has been identified containing the bad smells in code. Results are expected after the implementation of refactoring is the similarity of the structure of a class diagram with class diagram refactoring results using the Strategy Pattern.Keyword: refactoring, design pattern, strategy pattern, the bad smells in cod

A heuristic-based approach to code-smell detection

Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache

Refactoring, reengineering and evolution: paths to Geant4 uncertainty quantification and performance improvement

Ongoing investigations for the improvement of Geant4 accuracy and computational performance resulting by refactoring and reengineering parts of the code are discussed. Issues in refactoring that are specific to the domain of physics simulation are identified and their impact is elucidated. Preliminary quantitative results are reported.Comment: To be published in the Proc. CHEP (Computing in High Energy Physics) 201

Improving Prolog programs: Refactoring for Prolog

Refactoring is an established technique from the object-oriented (OO) programming community to restructure code: it aims at improving software readability, maintainability and extensibility. Although refactoring is not tied to the OO-paradigm in particular, its ideas have not been applied to Logic Programming until now. This paper applies the ideas of refactoring to Prolog programs. A catalogue is presented listing refactorings classified according to scope. Some of the refactorings have been adapted from the OO-paradigm, while others have been specifically designed for Prolog. The discrepancy between intended and operational semantics in Prolog is also addressed by some of the refactorings. In addition, ViPReSS, a semi-automatic refactoring browser, is discussed and the experience with applying ViPReSS to a large Prolog legacy system is reported. The main conclusion is that refactoring is both a viable technique in Prolog and a rather desirable one.Comment: To appear in Theory and Practice of Logic Programming (TPLP

Refactoring Process Models in Large Process Repositories.

With the increasing adoption of process-aware information systems (PAIS), large process model repositories have emerged. Over time respective models have to be re-aligned to the real-world business processes through customization or adaptation. This bears the risk that model redundancies are introduced and complexity is increased. If no continuous investment is made in keeping models simple, changes are becoming increasingly costly and error-prone. Though refactoring techniques are widely used in software engineering to address related problems, this does not yet constitute state-of-the art in business process management. Process designers either have to refactor process models by hand or cannot apply respective techniques at all. This paper proposes a set of behaviour-preserving techniques for refactoring large process repositories. This enables process designers to eectively deal with model complexity by making process models better understandable and easier to maintain