A Study of Quality Improvements By Refactoring
Bart Du Bois
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
AI
AI
This study investigates the impact of refactoring on software quality by analyzing transformations that maintain behavior while potentially altering non-functional properties. It explores the application of refactorings, specifically a variant of the Move Method, to enhance coupling and cohesion metrics. Results indicate that while refactoring can improve quality in specific contexts, further research is necessary to establish comprehensive guidelines for effective application.
Related papers
Optimizing Non-functional Properties of Software Product Lines by means of Refactorings
Today, software product line engineering concentrates on tailoring the functionality of programs. However, we and others observed an increasing interest in non-functional properties of products. For example, performance, power awareness, maintainability, and resource consumption are important nonfunctional properties in software development. Current product line techniques have the potential to flexibly optimize nonfunctional properties. In this paper, we present our vision of optimizing non-functional properties in software product lines. We show how such an optimization can be achieved using refactorings and present first results of a case study.
Information-Theoretic Remodularization of Object-Oriented Software Systems
Information Systems Frontiers, 2019
Software remodularization consists in reorganizing software entities into modules such that pairs of entities belonging to the same modules are more similar than those belonging to different modules. In recent years, Search-Based Software Engineering (SBSE) approach has gained unprecedented growth for solving software remodularization problem. Most of the previous studies remodularize the software system by optimizing the structural coupling and cohesion metrics as objective functions. These metrics are defined in terms of the number of structural relationships counts, rather than taking patterns of relationships. It has been observed that the computation of coupling and cohesion based on patterns of relationships (i.e., information-theory based) are more accurate than the number of relationships. This paper proposes an information-theoretic software remodularization where an entropy-based similarity measure is introduced as an objective function along with other objective functions i.e., intermodule class change coupling, intra-module class change coupling, module size index (MSI), and module count index (MCI) and is further optimized using many-objective meta-heuristic algorithm. To evaluate the effectiveness of the proposed approach, seven object-oriented software systems have been remodularized using NSGA-III, MOEA/D, IBEA, and TAA algorithms. The results are compared with existing multi-objective formulation of remodularization problem in terms of authoritative software remodularization, non-extreme distribution, and stability. The experimentation results suggest that the proposed approach can be a good alternative to improve the quality of software systems. The findings suggest that the approach is more suitable for generating remodularization solution good from both quality metrics and developers perspective.
Balancing Competing Needs of Machine and Human in Software Refactoring
2016
research towards reformulating traditional software engineering challenges as optimization problems and consequently deploying search heuristics to solve them. From the search-based perspective, any SE problem can be defined by a set of conflicting objectives, accompanied multiples constraints and other factors. Instead of targeting an optimal solution, the metaheuristic search has the capability of generating multiple near-optimal solutions that eventually In both categories, cohesion and coupling are the main metrics used to improve the quality of existing packages (e.g. modules) by determining which classes need to be grouped in a package. Research Problem 1: The majority of existing contributions have formulated the restructuring problem as a single-objective problem where the goal is to improve the cohesion and coupling of packages. Even though most of the existing approaches are powerful enough to provide remodularization solutions, some issues still need to be addressed. Research Problem 2: One of the most important issues is the semantic coherence of the design. The restructured program could improve structural metrics but become semantically incoherent. In this case, the design will become difficult to understand since classes are placed in wrong packages to improve the structure in terms of cohesion and coupling. Also, the number of code changes is not considered when suggesting remodularization solutions; the only aim is to improve the structure of packages independently of the cost of code changes. However, in realworld scenarios, developers prefer, in general, remodularization solutions that improve the structure with a minimum number of changes. It is important to minimize code changes to help developers in understanding the design after applying suggested changes. Research Problem 3: Existing remodularization studies are also limited to few types of changes mainly move class and split packages [18] [19]. However, refactoring at the class and method levels can improve remodularization solutions such as by moving methods between classes located in different packages. The use of development history can be an efficient aid when proposing remodularization solutions. For example, packages that were extensively modified in the past may have a high probability of being also changed in the future. Moreover, the packages to modify can be similar to some patterns that can be found in the development history, thus, developers can easily recognize and adapt them. 1.2.3 Software Refactoring: Software Refactoring is defined as the process of improving code after it has been written by changing its internal structure without changing its external behavior [15]. The idea is to reorganize variables, classes and methods to facilitate future adaptations and extensions and Proposed Research Contributions Our primary goal was to explore a higher dimensionality of different SE problems. Problems belonging to different domains, such as model transformation, software refactoring and remodularization, have eventually different formulations (objectives, constraints etc.). The following figure will cluster our contributions according to their application domains.
Refactoring: Current research and future trends
Electronic Notes in …, 2003
In this paper we provide an extensive overview of existing research in the field of software restructuring and refactoring, from a formal as well as a practical point of view. Next, we propose an extensive list of open questions that indicate future research directions, and we provide some partial answers to these questions.
Quality-driven object-oriented code restructuring
"Second Workshop on Software Quality" W13S Workshop - 26th International Conference on Software Engineering, 2004
The technique of refactoring, restructuring the source code of an object-oriented program without changing it external behavior, has been embraced by many objectoriented software developers as a way to accommodate changing requirements. It is expected that such refactoring operations or software transformations improve the maintainability of software. Unfortunately, it in unclear how specific quality factors are affected by applying such refactorings operations or software transformations. This position paper addresses the issue of developing a restructuring methodology and its associated architecture for migrating an object-oriented legacy system to a new target system. The methodology allows for specific design and quality requirements of the target migrant system to be considered during the restructuring process that is applied on iterative and incremental steps.
Refactoring Functional Programs (GR/R75052/01) Final Report
2008
Refactorings are source-to-source program transformations that change program structure and organisation, but not program functionality. Documented in catalogues and supported by tools, refactoring provides the means to adapt and improve the design of existing code, and has thus helped to address long-standing problems in software maintenance while also enabling the trend towards modern agile software development processes.
Code Restructuring: As the Most Common Type of Reegineering and Its Application
It is not uncommon to find that many of the data processing systems of today have been in operation for as many as 10 – 30 years back. Legacy systems are older software systems that remain vital to an organization. Many software systems that are still in use were developed many years using technology that are now obsolete. Re-engineering is the systematic transformation of an existing system into a new form to realize quantity improvements in operation, system capability, functionality, performance or evolveability at a lower cost. This publication explores data restructuring as the common type of reengineering and its application.
Optimized Refactoring Mechanisms to Improve Quality Characteristics in Object-Oriented Systems
IEEE Access
Refactoring has emerged as a predominant approach to augmenting software product quality. However, empirical evidence suggests that not all dimensions of software quality experience unending enhancements through refactoring. Current scholarly explorations reveal significant variances in the impacts of diverse refactoring methods, with potential adverse effects and contradictions surfacing concerning software quality. Consequently, such disparities render the advantages of refactoring contentious, culminating in challenges for software developers in the selection of optimal refactoring methods to ameliorate software quality. Existing literature lacks an in-depth exploration of the reasons behind the contrasting impacts of refactoring methods on quality enhancement or the development of refined protocols for employing these techniques. Therefore, this research aims to explore, identify, and fine-tune the utilization mechanisms of refactoring methods, empowering software developers to make informed choices for the enhancement of object-oriented systems' quality attributes. Ten commonly employed refactoring methods were singled out for this investigation, each executed independently across five case studies varying in scale (small, medium, and large). The Quality Model for Object-Oriented Design (QMOOD) was employed as the evaluation tool to ascertain the influence of refactoring techniques on quality attributes. The research outcomes denote that the multifarious impacts of refactoring methods on quality attributes are attributed to distinct usage mechanisms of the techniques. These insights assist software practitioners in discerning the optimal utilization of refactoring methods to ameliorate software quality, taking their mechanisms into account. Moreover, these outcomes furnish industry experts with prescriptive guidelines for employing refactoring methods to elevate the quality of object-oriented systems, predicated on the suitable mechanism.
The Need of Re-engineering in Software Engineering
In this paper we will discuss the importance of software re-engineering and the reasons behind this importance followed by a discussion on each of these reasons with examples to prove that the re-engineering process is a useful tool to convert old, obsolete systems to more efficient, streamlined systems. And the re-engineering is used to increase maintainability, interoperability, performance and testability. Also re-engineering is used to decrease personal dependency.
Refactoring: improving coupling and cohesion of existing code
2004
Refactorings are widely recognised as ways to improve the internal structure of object-oriented software while maintaining its external behaviour. Unfortunately, refactorings concentrate on the treatment of symptoms (the so called code-smells), thus improvements depend a lot on the skills of the maintainer. Coupling and cohesion on the other hand are quality attributes which are generally recognized as being among the most likely quantifiable indicators for software maintainability. Therefore, this paper analyzes how refactorings manipulate coupling/cohesion characteristics, and how to identify refactoring opportunities that improve these characteristics. As such we provide practical guidelines for the optimal usage of refactoring in a software maintenance process.
TrueRefactor : An Automated Refactoring Tool to Improve Legacy System and Application Comprehensibility
2011
Manual refactoring is a complicated process requiring intimate knowledge of the software design and underlying intended behavior of a system. This knowledge is not always available. Fully automated refactoring, using a meta-heuristic based search that is dependent on software quality metrics and code smells as a guide, eliminates the need for the developer to be intimately connected to the software under modification. Computer applications in industry and engineering benefit significantly from new approaches to self-correcting refactoring software. TrueRefactor is an automated refactoring tool that significantly improves the comprehensibility of legacy systems. The goal of TrueRefactor is to modify legacy object-oriented systems in order to increase the understandability, maintainability and reusability aspects of legacy software, and to simultaneously generate new UML documentation in order to help developers understand the changes being made. This paper presents the research behin...
Graph transformations for object-oriented refinement
Formal Aspects of Computing, 2009
UNU-IIST is jointly funded by the government of Macao and the governments of the People's Republic of China and Portugal through a contribution to the UNU Endowment Fund. As well as providing twothirds of the endowment fund, the Macao authorities also supply UNU-IIST with its office premises and furniture and subsidise fellow accommodation.
A Refactoring Classification Framework for Efficient Software Maintenance
IEEE Access
The expenses associated with software maintenance and evolution constitute a significant portion, surpassing more than 80% of the overall costs involved in software development. Refactoring, a widely embraced technique, plays a crucial role in streamlining and minimizing maintenance activities and expenses. However, the effect of refactoring techniques on quality attributes presents inconsistent and conflicting findings, making it challenging for software developers to enhance software quality effectively. Additionally, the absence of a comprehensive framework further complicates the decision-making process for developers when selecting appropriate refactoring techniques aligned with specific design objectives. In light of these considerations, this research aims to introduce a novel framework for classifying refactoring techniques based on their measurable influence on internal quality attributes. Initially, an exploratory study was conducted to identify commonly employed refactoring techniques, followed by an experimental analysis involving five case studies to evaluate the effects of these techniques on internal quality attributes. Subsequently, the framework was constructed based on the outcomes of the exploratory and experimental studies, further reinforced by a multi-case analysis. Comprising three key components, namely the methodology for applying refactoring techniques, the Quality Model for Object-Oriented Design (QMOOD), and the classification scheme for refactoring techniques, this proposed framework serves as a valuable guideline for developers. By comprehending the effect of each refactoring technique on internal quality attributes, developers can make informed decisions and select suitable techniques to enhance specific aspects of their software. Consequently, this framework optimizes developers' time and effort by minimizing the need to weigh the pros and cons of different refactoring techniques, potentially leading to a reduction in maintenance activities and associated costs.
Class Refinement and Interface Refinement in Object-Oriented Programs
FME '97: Industrial Applications and Strengthened Foundations of Formal Methods, 1997
Constructing new classes from existing ones by inheritance or subclassing is a characteristic feature of object-oriented development. Imposing semantic constraints on subclassing allows us to ensure that the behaviour of superclasses is preserved or refined in their subclasses. This paper defines a class refinement relation which captures these semantic constraints. The class refinement relation is based on algorithmic and data refinement supported by Refinement Calculus. Class refinement is generalized to interface refinement, which takes place when a change in user requirements causes interface changes of classes designed as refinements of other classes. We formalize the interface refinement relation and present rules for refinement of clients of the classes involved in this relation.
EFFECT OF REFACTORING ON SOFTWARE QUALITY
Software quality is an important issue in the development of successful software application. Many methods have been applied to improve the software quality. Refactoring is one of those methods. But, the effect of refactoring in general on all the software quality attributes is ambiguous. The goal of this paper is to find out the effect of various refactoring methods on quality attributes and to classify them based on their measurable effect on particular software quality attribute. The paper focuses on studying the Reusability, Complexity, Maintainability, Testability, Adaptability, Understandability, Fault Proneness, Stability and Completeness attribute of a software .This, in turn, will assist the developer in determining that whether to apply a certain refactoring method to improve a desirable quality attribute.
Restructuring Object-Oriented Software Systems Using Various Aspects of Class Information
Arabian journal for science and engineering, 2020
Frequent modifications in a software system generally deteriorate the design of the source code and consequently increase the complexity of the system. In object-oriented software, one of the symptoms of design degradation is that the package structure of the source code drifts away from design principles. To improve the deteriorated design, systems are generally restructured by reorganizing the classes into packages based on good design principles. Coupling and cohesion are the two important package design principles widely used to assess software design quality. Most of the existing package restructuring approaches use either structural, lexical, or change history class information to compute coupling and cohesion of software system. Moreover, these approaches compute coupling and cohesion without considering multiple dimensions of structural, lexical, and change history information. In this article, we utilize different types of structural, lexical and change history class information and integrate them as per their relative importance to compute coupling and cohesion. To automate the restructuring process, we formulate the restructuring problem as a multi-objective optimization problem and solve it by using non-dominated sorting genetic algorithm (NSGA-II). The proposed approach is applied to five object-oriented software applications. The obtained restructuring is compared with authoritative restructuring and restructuring suggested by external developers. The obtained restructuring is also compared with some existing multi-objective software restructuring approaches. Overall, findings indicate that the proposed approach can be a good approach to improve the design of software systems whose quality is under suspicion.
Related topics
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.