Refactoring Techniques Research Articles

Profiling expression strategies for a type III polyketide synthase in a lysate-based, cell-free system

Some of the most metabolically diverse species of bacteria (e.g., Actinobacteria) have higher GC content in their DNA, differ substantially in codon usage, and have distinct protein folding environments compared to tractable expression hosts like Escherichia coli. Consequentially, expressing biosynthetic gene clusters (BGCs) from these bacteria in E. coli often results in a myriad of unpredictable issues with regard to protein expression and folding, delaying the biochemical characterization of new natural products. Current strategies to achieve soluble, active expression of these enzymes in tractable hosts can be a lengthy trial-and-error process. Cell-free expression (CFE) has emerged as a valuable expression platform as a testbed for rapid prototyping expression parameters. Here, we use a type III polyketide synthase from Streptomyces griseus, RppA, which catalyzes the formation of the red pigment flaviolin, as a reporter to investigate BGC refactoring techniques. We applied a library of constructs with different combinations of promoters and rppA coding sequences to investigate the synergies between promoter and codon usage. Subsequently, we assess the utility of cell-free systems for prototyping these refactoring tactics prior to their implementation in cells. Overall, codon harmonization improves natural product synthesis more than traditional codon optimization across cell-free and cellular environments. More importantly, the choice of coding sequences and promoters impact protein expression synergistically, which should be considered for future efforts to use CFE for high-yield protein expression. The promoter strategy when applied to RppA was not completely correlated with that observed with GFP, indicating that different promoter strategies should be applied for different proteins. In vivo experiments suggest that there is correlation, but not complete alignment between expressing in cell free and in vivo. Refactoring promoters and/or coding sequences via CFE can be a valuable strategy to rapidly screen for catalytically functional production of enzymes from BCGs, which advances CFE as a tool for natural product research.

Toward a novel taxonomy to capture code smells caused by refactoring

Code smells tend to have an impact on software quality attributes such as reusability, maintainability, and understandability. These are code flaws that do not necessarily prevent the system from operating; rather, they increase the possibility of defects occurring in the future. Hence, to maintain code quality, code smells should be detected and corrected through refactoring. The objective of this paper is to investigate the associated risk of applying refactoring techniques and reveal the bad smells that may appear when fixing other bad smells. We conducted several controlled experiments to identify the smells that emerge after refactoring. The experiments resulted in a novel taxonomy revealing 9 bad smells that may appear as a result of fixing other bad smells. This represents the first study attempting to systematically identify and organize such refactoring-smell relationships into a taxonomy. The research results can assist developers in relating different bad smells to each other and helping them determine the refactoring technique that should be applied when certain smells are present. Moreover, the results can be beneficial in breaking the cycle of bad smells. Such knowledge tends to enhance code refactoring, which in turn will improve software quality and avoid technical debt.

Detecting and resolving feature envy through automated machine learning and move method refactoring

Efficiently identifying and resolving code smells enhances software project quality. This paper presents a novel solution, utilizing automated machine learning (AutoML) techniques, to detect code smells and apply move method refactoring. By evaluating code metrics before and after refactoring, we assessed its impact on coupling, complexity, and cohesion. Key contributions of this research include a unique dataset for code smell classification and the development of models using AutoGluon for optimal performance. Furthermore, the study identifies the top 20 influential features in classifying feature envy, a well-known code smell, stemming from excessive reliance on external classes. We also explored how move method refactoring addresses feature envy, revealing reduced coupling and complexity, and improved cohesion, ultimately enhancing code quality. In summary, this research offers an empirical, data-driven approach, integrating AutoML and move method refactoring to optimize software project quality. Insights gained shed light on the benefits of refactoring on code quality and the significance of specific features in detecting feature envy. Future research can expand to explore additional refactoring techniques and a broader range of code metrics, advancing software engineering practices and standards.

Affirmative Refactoring: A Cognitive Behavioral Approach for Rewriting Limiting Beliefs

Coach Daria Trutneva offers a unique technique known as Affirmative Refactoring, designed to address limiting beliefs by combining elements of cognitive behavioral psychotherapy and psychoanalysis. This paper provides an in-depth exploration of Affirmative Refactoring technique, outlining its key steps and examining its effectiveness in assisting people to overcome their limiting beliefs. By delving into each stage of the process, this paper seeks to shed light on how this approach leverages cognitive restructuring and introspection to empower individuals to transform their thought patterns and ultimately enhance their psychological well-being.

A refactoring categorization model for software quality improvement.

Refactoring, a widely adopted technique, has proven effective in facilitating and reducing maintenance activities and costs. Nonetheless, the effects of applying refactoring techniques on software quality exhibit inconsistencies and contradictions, leading to conflicting evidence on their overall benefit. Consequently, software developers face challenges in leveraging these techniques to improve software quality. Moreover, the absence of a categorization model hampers developers' ability to decide the most suitable refactoring techniques for improving software quality, considering specific design goals. Thus, this study aims to propose a novel refactoring categorization model that categorizes techniques based on their measurable impacts on internal quality attributes. Initially, the most common refactoring techniques used by software practitioners were identified. Subsequently, an experimental study was conducted using five case studies to measure the impacts of refactoring techniques on internal quality attributes. A subsequent multi-case analysis was conducted to analyze these effects across the case studies. The proposed model was developed based on the experimental study results and the subsequent multi-case analysis. The model categorizes refactoring techniques into green, yellow, and red categories. The proposed model, by acting as a guideline, assists developers in understanding the effects of each refactoring technique on quality attributes, allowing them to select appropriate techniques to improve specific quality attributes. Compared to existing studies, the proposed model emerges superior by offering a more granular categorization (green, yellow, and red categories), and its range is wide (including ten refactoring techniques and eleven internal quality attributes). Such granularity not only equips developers with an in-depth understanding of each technique's impact but also fosters informed decision-making. In addition, the proposed model outperforms current studies and offers a more nuanced understanding, explicitly highlighting areas of strength and concern for each refactoring technique. This enhancement aids developers in better grasping the implications of each refactoring technique on quality attributes. As a result, the model simplifies the decision-making process for developers, saving time and effort that would otherwise be spent weighing the benefits and drawbacks of various refactoring techniques. Furthermore, it has the potential to help reduce maintenance activities and associated costs.

Correspondence of OOP Refactoring Techniques in PL\SQL Environment: A Case Study of Agile Project Code

Correspondence of OOP Refactoring Techniques in PL\SQL Environment: A Case Study of Agile Project Code

Revisiting Scenarios of Using Refactoring Techniques to Improve Software Systems Quality

Refactoring is one of the most widely used techniques in practice to improve the quality of existing software. However, it is observed that refactoring does not continually improve all software quality attributes. Recent studies indicated that different refactoring techniques have significantly different, sometimes opposite, and conflicting effects on software quality attributes. In other words, there is contradictory evidence on the refactoring benefit. As a result, developers face challenges in selecting appropriate refactoring techniques when they use them to improve software quality. To the best of our knowledge, no study has investigated factors that may explain inconsistent or diverging results concerning the effect of refactoring techniques on software quality. Therefore, in this study, scenarios of using refactoring techniques factor have been identified, investigated, and thoroughly analyzed. Ten of the most commonly used refactoring techniques in practice have been chosen and individually applied in seven case studies of varying sizes (small, medium, and large). The Quality Model for Object-Oriented Design (QMOOD) is used to assess how refactoring techniques affect quality attributes. The findings provide strong evidence that this factor plays a significant role in producing the various effects of refactoring techniques on quality attributes. These findings can help software developers understand how to use refactoring techniques to improve software quality while taking this factor into account. The best scenario for using each refactoring technique to improve software system quality has been identified. The findings can provide guidelines for software developers to use refactoring techniques to improve the quality of software systems based on the best scenarios of using the refactoring techniques.

Search based Software Engineering of Software Metrics, Code Smells and Refactoring Techniques Using Optimization Algorithms

Software refactoring is a technique for reorganising and improving the efficiency of existing software code. By refining the non-functional aspects of software, numerous refactoring methods are currently being employed to build more intelligible and less composite codes. By applying multiple systems to the source code, refactoring can improve code maintainability even further, preserving the behaviour of the code. Refactoring allows for the eradication of bugs and the expansion of the program's capabilities. This paper provides a comprehensive assessment of source code with foul odours, the influence on software quality of using certain refactoring methodologies to eradicate the foul smell. Between 2008 and 2010, a total of 76 studies from 42 journals, 20 conferences, and 14 additional sources in the year 2008 and 2022 were available. This study was graded on the number of unpleasant odours identified, refactoring strategies applied, and their impact on software metrics. The foul smells of "method of long," "envious feature “and” class of data" were discovered or corrected in the majority of inquiries. The odour of "envious feature" was detected in 39.66 per cent of nominated investigations. The majority of studies looked at the effects of restructuring on software intricacy and coupling measures. Surprisingly, instead of patented software, the majority of the investigations employed massive opensource datasets released in Java. Finally, this research makes suggestions for further into the refactoring research code.

Energy Efficiency Analysis of Code Refactoring Techniques for Green and Sustainable Software in Portable Devices

Code refactoring is a time-consuming and effort-intensive process that is applied for making improvements to source codes. There exist several refactoring techniques to improve software quality. Some of them aim to reduce the energy consumption of the software. However, the combination of applied refactoring techniques is crucial to the success rate. In addition, to provide sustainable services on portable devices such as mobile phones and laptops, which rely on batteries, improving and optimizing the energy efficiency is important. This study focuses on examining the effect of code refactoring techniques on energy consumption. A total of 25 different source codes of applications programmed in the C# and Java languages are selected for the study, and combinations obtained from refactoring techniques are applied to these source codes. The combinations applied are analyzed using the maintainability index. Power consumption estimation tools are used to measure the energy consumption of the original and refactored codes. The results show that the combinations significantly improve the software’s energy efficiency. The results will provide a better understanding of the relationship between the energy efficiency of software and refactoring techniques. Moreover, they will help developers to improve their object-oriented code in terms of both energy efficiency and sustainability.

Refactoring Codes to Improve Software Security Requirements

Refactoring is one of the most widely used techniques in practice to improve the quality of software, such as maintainability, testability, and understandability. However, there is a lack of studies investigating the effect of refactoring on security. The effect of refactoring on security is poorly understood and understudied. A limited number of studies provide the categorization of refactoring techniques based on their effect on quality attributes to assist developers in achieving their design objectives by selecting the most beneficial techniques and applying them at the right places with respect to specific software quality attributes. However, security was not considered in these studies. Therefore, this study aims to investigate the effect of refactoring techniques on security in terms of information hiding. The aforementioned objectives were achieved by conducting several steps starting with selecting suitable refactoring techniques, selecting five case studies, selecting security metrics, applying the refactoring techniques, and conducting multi-case analysis. Then, the chosen refactoring techniques were categorized based on their effect on security. The results of this study identify and analyze the effect of the refactoring techniques on security metrics and then propose a categorization of the refactoring techniques based on their effect on security metrics. The finding will help the developers select appropriate refactoring techniques to improve existing software security.

Supporting refactoring of BDD specifications—An empirical study

Behavior-driven development (BDD) is a variant of test-driven development where specifications are described in a structured domain-specific natural language. Although refactoring is a crucial activity of BDD, little research is available on the topic. To support practitioners in refactoring BDD specifications by (1) proposing semi-automated approaches to identify refactoring candidates; (2) defining refactoring techniques for BDD specifications; and (3) evaluating the proposed identification approaches in an industry context. Using Action Research, we have developed an approach for identifying refactoring candidates in BDD specifications based on two measures of similarity and applied the approach in two projects of a large software organization. The accuracy of the measures for identifying refactoring candidates was then evaluated against an approach based on machine learning and a manual approach based on practitioner perception. We proposed two measures of similarity to support the identification of refactoring candidates in a BDD specification base; (1) normalized compression similarity (NCS) and (2) similarity ratio (SR). A semi-automated approach based on NCS and SR was developed and applied to two industrial cases to identify refactoring candidates. Our results show that our approach can identify candidates for refactoring 6o times faster than a manual approach. Our results furthermore showed that our measures accurately identified refactoring candidates compared with a manual identification by software practitioners and outperformed an ML-based text classification approach. We also described four types of refactoring techniques applicable to BDD specifications; merging candidates, restructuring candidates, deleting duplicates, and renaming specification titles. Our results show that NCS and SR can help practitioners in accurately identifying BDD specifications that are suitable candidates for refactoring, which also decreases the time for identifying refactoring candidates.

Empirical Analysis of Re-Factoring Techniques

Abstract: The process or technique of Code Re-factoring is restructuring the existing source code by making changes in factoring without any changes in external behaviour. The main intention of re-factoring is to improve non-functional attributes of the software. The advantages include improving the code readability and reducing the complexity of any given source code, and these can overall enhance code maintainability and produce a much more elaborated internal architecture or objectoriented model to boost the extensibility of the code. The effect that re-factoring has on any software project is analysable and customisable. But, before customising the factoring techniques, it is essential to have a complete knowledge of all possible refactoring techniques, and all its possible effects. Our main focus will be on few main re-factoring techniques like Red-Green refactoring, preparatory re-factoring, Abstraction re-factoring, composing methods re-factoring etc. Every software project has both internal and external attributes, that highly influence the software’s maintainability, reusability, understandability, flexibility, testability, extensibility, reliability, efficiency, modularity, complexity and composition. The research mainly focuses on the effect of re-factoring on them. Study of researched data will give us comparative analysis, pointing out both the positive and negative impacts, re-factoring can have. Overall, the project aims to perform an empirical study to find out the impacts of refactoring techniques. The research aims to explore the change in the quality of the code after re-factoring. Improvement, decrement and stability are analysed. Study is also done to find the possibilities of applying more than one re-factoring techniques, independently or in an aggregation. Keywords: maintainability; extensibility; reliability; modularity

Automatic migration from synchronous to asynchronous JavaScript APIs

The JavaScript ecosystem provides equivalent synchronous and asynchronous Application Programming Interfaces (APIs) for many commonly used I/O operations. Synchronous APIs involve straightforward sequential control flow that makes them easy to use and understand, but their "blocking" behavior may result in poor responsiveness or performance. Asynchronous APIs impose a higher syntactic burden that relies on callbacks, promises, and higher-order functions. On the other hand, their nonblocking behavior enables applications to scale better and remain responsive while I/O requests are being processed. While it is generally understood that asynchronous APIs have better performance characteristics, many applications still rely on synchronous APIs. In this paper, we present a refactoring technique for assisting programmers with the migration from synchronous to asynchronous APIs. The technique relies on static analysis to determine where calls to synchronous API functions can be replaced with their asynchronous counterparts, relying on JavaScript's async/await feature to minimize disruption to the source code. Since the static analysis is potentially unsound, the proposed refactorings are presented as suggestions that must be reviewed and confirmed by the programmer. The technique was implemented in a tool named Desynchronizer. In an empirical evaluation on 12 subject applications containing 316 synchronous API calls, Desynchronizer identified 256 of these as candidates for refactoring. Of these candidates, 244 were transformed successfully, and only 12 resulted in behavioral changes. Further inspection of these cases revealed that the majority of these issues can be attributed to unsoundness in the call graph.

Empirical Studies on Software Refactoring Techniques in the Industrial Setting

Software refactoring is an approach that aims to improve software system quality by restructuring its internal design without altering the functionality of the software system. The software refactoring has gained comprehensive attention from the research community in software engineering since its emerging in 1999. Empirical studies were carried out to investigate whether the software refactoring indeed can achieve improvement in the software system quality. It is widely believed that refactoring has a favorable quality impact. However, several researchers have opposed this belief. This paper presents a systematic literature review (SLR) of the empirical studies that have been conducted in the industrial setting. Twenty studies were chosen and analyzed in depth as primary studies.The objectives of this SLR are to identify the refactoring techniques examined, and software quality attributes investigated as well as to analyze the connection between the refactoring techniques and the software quality attributes based on the selected empirical studies to understand the situation. The findings showed a lack of empirical research on the effect of the refactoring on software quality. Additionally, the relationship between the refactoring techniques and software quality attributes is unclear. Thus, several recommendations have been proposed to address these gaps.

Enabling Decision and Objective Space Exploration for Interactive Multi-Objective Refactoring

Due to the conflicting nature of quality measures, there are always multiple refactoring options to fix quality issues. Thus, interaction with developers is critical to inject their preferences. While several interactive techniques have been proposed, developers still need to examine large numbers of possible refactorings, which makes the interaction time-consuming. Furthermore, existing interactive tools are limited to the ”objective space” to show developers the impacts of refactorings on quality attributes. However, the “decision space” is also important since developers may want to focus on specific code locations. In this paper, we propose an interactive approach that enables developers to pinpoint their preference simultaneously in the objective (quality metrics) and decision (code location) spaces. Developers may be interested in looking at refactoring strategies that can improve a specific quality attribute, such as extendibility (objective space), but such strategies may be related to different code locations (decision space). A plethora of solutions is generated at first using multi-objective search that tries to find the possible trade-offs between quality objectives. Then, an unsupervised learning algorithm clusters the trade-off solutions based on their quality metrics, and another clustering algorithm is applied within each cluster of the objective space to identify solutions related to different code locations. The objective and decision spaces can now be explored more efficiently by the developer, who can give feedback on a smaller number of solutions. This feedback is then used to generate constraints for the optimization process, to focus on the developer's regions of interest in both the decision and objective spaces. A manual validation of selected refactoring solutions by developers confirms that our approach outperforms state of the art refactoring techniques.

An Interactive and Dynamic Search-Based Approach to Software Refactoring Recommendations

Successful software products evolve through a process of continual change. However, this process may weaken the design of the software and make it unnecessarily complex, leading to significantly reduced productivity and increased fault-proneness. Refactoring improves the software design while preserving overall functionality and behavior, and is an important technique in managing the growing complexity of software systems. Most of the existing work on software refactoring uses either an entirely manual or a fully automated approach. Manual refactoring is time-consuming, error-prone and unsuitable for large-scale, radical refactoring. On the other hand, fully automated refactoring yields a static list of refactorings which, when applied, leads to a new and often hard to comprehend design. Furthermore, it is difficult to merge these refactorings with other changes performed in parallel by developers. In this paper, we propose a refactoring recommendation approach that dynamically adapts and interactively suggests refactorings to developers and takes their feedback into consideration. Our approach uses NSGA-II to find a set of good refactoring solutions that improve software quality while minimizing the deviation from the initial design. These refactoring solutions are then analyzed to extract interesting common features between them such as the frequently occurring refactorings in the best non-dominated solutions. Based on this analysis, the refactorings are ranked and suggested to the developer in an interactive fashion as a sequence of transformations. The developer can approve, modify or reject each of the recommended refactorings, and this feedback is then used to update the proposed rankings of recommended refactorings. After a number of introduced code changes and interactions with the developer, the interactive NSGA-II algorithm is executed again on the new modified system to repair the set of refactoring solutions based on the new changes and the feedback received from the developer. We evaluated our approach on a set of eight open source systems and two industrial projects provided by an industrial partner. Statistical analysis of our experiments shows that our dynamic interactive refactoring approach performed significantly better than four existing search-based refactoring techniques and one fully-automated refactoring tool not based on heuristic search.

Assessment of optimum refactoring sequence to improve the software quality of object-oriented software

Software Maintenance is the most expensive phase of Software Development Lifecycle (SDLC) and therefore requires maximum effort and time. Any modification in the source code also introduces some bad smell which may be harmful for the design of the source code. These bad smells get accumulated with every phase of the SDLC if not corrected timely, therefore, they need to be removed as early as possible with the help of refactoring which improves the internal attributes of the software without affecting the external attributes. In order to complete the software under time and budget constraints, authors have attempted to determine the optimum sequence of refactoring technique (RT) in advance so that maintenance team can directly apply them in order to remove the bad smell which further enhances the quality of the software. Authors have applied different types of Hill- Climbing algorithms. Results shows that that the Steepest-Ascent Hill-Climbing algorithm is the most promising algorithm in finding the most optimum refactoring sequence with 20% improvement in the maintainability value.

Refactoring business process models with process fragments substitution

Since business processes are important assets of enterprises, thousands of business processes are modeled. After modeling business process models, a problem arises here is how to improve the efficiency of these models? In this paper, we propose a novel approach to refactor business process models with process fragments substitution for efficiency improvement. First, we propose a process model smell for identifying inefficient process fragments in business process models based on a sequence relation matrix and a data dependency matrix. Second, we propose a refactoring technique to replace inefficient process fragments in business process models with efficient process fragments. After refactoring, concurrent execution of business tasks in efficient process fragments can be maximized, so the efficiency of business process models can be improved. Experiments show our approach can improve efficiency of business process models effectively.

Engrossing Prosecution of Code Smells Type Identification and Rectification using Machine Learning AdaBoost Classifier

Software code smells are the structural features which reside in a software source code. Code smell detection is an established method to discover the problems in source code and reorganize the inner structure of object-oriented software for improving the quality of such software, particularly in terms of maintainability, reusability and cost minimization. The developer identified where the code smell is identified and rectified within a system is a major challenging issue. The various code smell detection technique has been designed but it failed to classify the code type and minimum rectification cost. In order to perform classification with minimum cost, an efficient technique called Machine Learning Ada-Boost Classifier (MLABC) technique is introduced. The MLABC technique improves the software quality by identifying and rectifying the different types of software code smell in source code. Initially, MLABC technique uses decision tree as base classifier to identify the code smell type. The decision tree is used to classify the code smell type based on the certain rule. After that, the base classifiers are combined to make a strong classifier using adaboost machine learning technique. The output of strong classifier is used to identify the code smell type. Finally, the code smell type rectification is performed by applying the refactoring technique where the code smell is identified with minimum cost and space complexity. Experimental results shows that the proposed MLABC technique improves the software code quality in terms of code smell type identification accuracy, false positive rate, code smell type rectification cost and space complexity with the source code.

Investigating optimum refactoring sequence using hill-climbing algorithm

The surface indication of a deeper problem in the source code is bad smells that required to be removed as soon as possible. Not all smells are harmful, but if ignored, they automatically become faults which will further deteriorate the quality of the software. Therefore, this damage can be prevented with the help of refactoring that changes the internal attributes without affecting its external behavior. Every class of the source code contains numerous types of bad smells; therefore, more than one refactoring technique needs to be applied to clean the code. In this paper, we have tried to figure out the most optimum refactoring sequence that should be applied in a critically affected class of an open-source software (OSS), jTDS, to maximize its maintainability value with minimal effort. The results indicate improvement in maintainability value by 14.06% after the application of refactoring techniques. This study would be beneficial for the software maintenance team as this will encourage them to complete their work with much ease and will make them more efficient.