Catalogue Search | MBRL
Are you sure you want to remove the book from the shelf?
{{itemTitle}}
189
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
This book presents 25 structural design smells (indicators of common design problems), their role in identifying design issues, and potential refactoring solutions. Organized across common areas of software design, each smell is presented with diagrams and examples illustrating the poor design practices and the problems that result, creating a catalog of nuggets of readily usable information that developers or engineers can apply in their projects. This resource presents a unique naming scheme for smells that helps understand the cause of a smell as well as points toward its potential refactoring; covers pragmatic techniques for refactoring design smells to manage technical debt and to create and maintain high-quality software in practice; and presents insightful anecdotes and case studies drawn from the trenches of real-world projects. --
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
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
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
Harnessing deep learning algorithms to predict software refactoring
All experimental results show how refactoring has a direct influence on improving software quality. [...]predicting refactoring promptly should be investigating, and building an accurate model becomes mandatory. Software developers still face a real challenge to pick the right time and software code for refactoring purposes as the operation needs time and budget [11]. [...]developers should be sure about which piece of code should be evolved before starting the process of refactoring to adopt the new requirements. Different methodologies are designed and built to help developers in the refactoring process such as code smells detection strategies [12], logic meta-programming [13], invariant mining [14] and search-based [15, 16]. [...]machine learning is harnessed in the area of prediction and shows noticeable performance in terms of prediction in various fields as computer vision, defect prediction, natural language processing, code comprehension, bioinformatics, speech recognition, and finance [17-24 ]. [...]is to control the information that flows out of memory known as reset gate unlike long short-term memory (LSTM), GRU hasn't had separate memory cell, instead of that gating unit that controls the flow of information inside the unit [36].
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