Catalogue Search | MBRL
Are you sure you want to remove the book from the shelf?
{{itemTitle}}
200
result(s) for
"Software refactoring."
Sort by:
Refactoring JavaScript : turning bad code into good code
If your JavaScript is a mess, frameworks can only do so much to help. No matter what framework, \"compiles-to-JS\" language, or library you use, bugs and performance concerns will always be an issue if the underlying quality of your JavaScript is poor. With this hands-on guide, you'll learn how to test and refactor your existing code to help reduce complexity, improve readability, and gain confidence in the codebase.
Book
Refactoring for Software Design Smells
Awareness of design smells - indicators of common design problems - helps developers or software engineers understand mistakes made while designing, what design principles were overlooked or misapplied, and what principles need to be applied properly to address those smells through refactoring.
eBook
Refactoring Techniques for Improving Software Quality: Practitioners’ Perspectives
Refactoring is a critical task in software maintenance and is commonly applied to improve system design or to cope with design defects. There are 68 different types of refactoring techniques and each technique has a particular purpose and effect. However, most prior studies have selected refactoring techniques based on their common use in academic research without obtaining evidence from the software industry. This is a shortcoming that points to the existence of a clear gap between academic research and the corresponding industry practices. Therefore, to bridge this gap, this study identified the most frequently used refactoring techniques, the commonly used programming language, and methods of applying refactoring techniques in the current practices of software refactoring among software practitioners in the industry, by using an online survey. The findings from the survey revealed the most used refactoring techniques, programming language, and the methods of applying the refactoring techniques. This study contributes toward the improvement of software development practices by adding empirical evidence on software refactoring used by software developers. The findings would be beneficial for researchers to develop reference models and software tools to guide the practitioners in using these refactoring techniques based on their effect on software quality attributes to improve the quality of the software systems as a whole.
Journal Article
Schedule of Bad Smell Detection and Resolution: A New Way to Save Effort
Bad smells are signs of potential problems in code. Detecting and resolving bad smells, however, remain time-consuming for software engineers despite proposals on bad smell detection and refactoring tools. Numerous bad smells have been recognized, yet the sequences in which the detection and resolution of different kinds of bad smells are performed are rarely discussed because software engineers do not know how to optimize sequences or determine the benefits of an optimal sequence. To this end, we propose a detection and resolution sequence for different kinds of bad smells to simplify their detection and resolution. We highlight the necessity of managing bad smell resolution sequences with a motivating example, and recommend a suitable sequence for commonly occurring bad smells. We evaluate this recommendation on two nontrivial open source applications, and the evaluation results suggest that a significant reduction in effort ranging from 17.64 to 20 percent can be achieved when bad smells are detected and resolved using the proposed sequence.
Journal Article
Deep Active Learning for Label-Efficient Refactoring Prediction
Software refactoring improves the maintainability of code and reduces technical debt, but making the construction of a labeled refactoring dataset is a costly and labor-intensive process. To make refactoring prediction more deployable under limited annotation budgets, this paper introduces a Deep Active Learning (DAL) pipeline that iteratively trains a deep neural classifier on software-metric representations and selectively queries labels for the most informative unlabeled entities. Our proposed approach is evaluated in a pool-based setting across class-, method-, and variable-level refactoring datasets (multiple refactoring types) using a consistent training protocol and a broad set of query strategies. Results show that DAL can recover near full-data effectiveness with substantially fewer labels: on average, reaching the target performance requires 11.4% labeled data for class-level, 25.0% for method-level, and 20.0% for variable-level refactorings—corresponding to roughly 75–89% labeling savings, demonstrating improved data efficiency for refactoring prediction. Moreover, uncertainty-based and dropout-enhanced strategies were the most consistently effective query strategies across refactoring types and labeling budgets.
Journal Article
Design Level Class Decomposition using the Threshold-based Hierarchical Agglomerative Clustering
Refactoring activity is essential to maintain the quality of a software’s internal structure. It decays as the impact of software changes and evolution. Class decomposition is one of the refactoring processes in maintaining internal quality. Mostly, the refactoring process is done at the level of source code. Shifting from source code level to design level is necessary as a quick step to refactoring and close to the requirement. The design artifact has a higher abstraction level than the source code and has limited information. The challenge is to define new metrics needed in class decomposition using the design artifact's information. Syntactic and semantic information from the design artifact provides valuable data for the decomposition process. Class decomposition can be done at the level of design artifact (class diagram) using syntactic and semantic information. The dynamic threshold-based Hierarchical Agglomerative Clustering produces a more specific cluster that is considered to produce a single responsibility class.
Journal Article
Feature requests-based recommendation of software refactorings
Software requirements are ever-changing which often leads to software evolution. Consequently, throughout software lifetime, developers receive new requirements often expressed as feature requests. To implement the requested features, developers sometimes apply refactorings to make their systems adapt to the new requirements. However, deciding what refactorings to apply is often challenging and there is still lack of automated support to recommend refactorings given a feature request. To this end, we propose a learning-based approach that recommends refactorings based on the history of the previously requested features, applied refactorings, and code smells information. First, the state-of-the-art refactoring detection tools are leveraged to identify the previous refactorings applied to implement the past feature requests. Second, a machine classifier is trained with the history data of the feature requests, code smells, and refactorings applied on the respective commits. Consequently, the machine classifier is used to predict refactorings for new feature requests. The proposed approach is evaluated on the dataset of 55 open source Java projects and the results suggest that it can accurately recommend refactorings (accuracy is up to 83.19%).
Journal Article
Software Refactoring Prediction Using SVM and Optimization Algorithms
Test suite code coverage is often used as an indicator for test suite capability in detecting faults. However, earlier studies that have explored the correlation between code coverage and test suite effectiveness have not addressed this correlation evolutionally. Moreover, some of these works have only addressed small sized systems, or systems from the same domain, which makes the result generalization process unclear for other domain systems. Software refactoring promotes a positive consequence in terms of software maintainability and understandability. It aims to enhance the software quality by modifying the internal structure of systems without affecting their external behavior. However, identifying the refactoring needs and which level should be executed is still a big challenge to software developers. In this paper, the authors explore the effectiveness of employing a support vector machine along with two optimization algorithms to predict software refactoring at the class level. In particular, the SVM was trained in genetic and whale algorithms. A well-known dataset belonging to open-source software systems (i.e., ANTLR4, JUnit, MapDB, and McMMO) was used in this study. All experiments achieved a promising accuracy rate range of between 84% for the SVM–Junit system and 93% for McMMO − GA + Whale + SVM. It was clear that added value was gained from merging the SVM with two optimization algorithms. All experiments achieved a promising F-measure range between the SVM–Antlr4 system’s result of 86% and that of the McMMO − GA + Whale + SVM system at 96%. Moreover, the results of the proposed approach were compared with the results from four well known ML algorithms (NB-Naïve, IBK-Instance, RT-Random Tree, and RF-Random Forest). The results from the proposed approach outperformed the prediction performances of the studied MLs.
Journal Article
