In software development, code refactoring refers to the manual or automated structural improvement of source code while maintaining observable program behavior. The aim is to improve readability, comprehensibility, maintainability and extensibility, with the aim of significantly reducing the respective effort for error analysis and functional enhancements. Code refactoring is a central part of Agile software development. There is usually talk of continuous refactoring. Refactoring is an integral part of the software development process in agile software development such as coding or module testing and is not limited to specific times or phases.
Refactoring is mainly applied to unsightly places in the code. The source code of a computer program is redesigned, whereby the actual program function is to remain unchanged. The refactoring of the source code is usually done according to the following points of view:
- Readability
- Clarity
- Comprehensibility
- Extensibility
- Avoidance of redundancy
- Testability
The aspects of refactoring are closely related to the resulting advantages. Refactoring has an analogy in mathematics in what is called algebraic forming, in which the aim of forming is also better readability, comprehensibility and, if necessary, extensibility (of the equation system). For this reason, functional languages (Lisp, Haskell, OCaml, Erlang and so on) are much better suited to refactoring, as they are based on a mathematical paradigm of programming. Refactoring is facilitated and supported by:
---
- Unit tests that can prove as regression tests that the behavior of the program has not changed under the same conditions and that refactoring did not inadvertently introduce errors,
- Tools, in particular integrated development environments, that provide support in the execution of refactorings,
- Functional programming languages (among other things, because code can be checked for correctness in functional languages using mathematical methods),
- A programming language with a strict type system which excludes many errors in advance (at compilation time) because it ensures that the interface remains the same, even if the structure (implementation) changes. This saves many unit tests in advance (because it excludes many sources of error).
The following measures or work are carried out particularly frequently during refactoring:
- Changing a symbol name
- Moving a symbol to another module
- Divide a module
- In the broadest sense also the reformatting a source code,
- In the case of changed business processes when displayed using the Unified Modeling Language UML, the program code can be changed by means of “refactoring”. This creates a robust and stable system architecture because confusing changes do not need to be initiated in code.
- Apply higher-order functions in functional programming languages
- Outsource the common abstract logic of several modules into the gates.
- Combine (abstract) two or more generically very similar functionalities
into a universal functionality (reduction of multi-duplicate code) - Assign practical memorable names for variables, constants, methods, etc.
- Eliminate dead or redundant code
Advantages of Code Refactoring
Refactoring is designed to improve the maintainability of the design in such a way that it becomes easier for the programmer to functionally extend the existing code or reuse it elsewhere. This is attempted by improving the code, in particular with regard to the following criteria:
- Readability : so that as many programmers as possible understand what the code actually does
- Modularity and redundancy : so that concrete problem solutions can be used from elsewhere and are not implemented multiple times
- Coupling and cohesion : so that future changes will only have local impact
- Testability : to ensure the correct functioning of the code for the future through regression testing
In the usual software development cycle, a continuous cycle of specification, design, implementation and testing is provided. After each run, the software product can repeatedly enter this cycle. With the classical techniques, however, this meant that after a change of specification or a redesign, parts or even the whole program often had to be completely rewritten. Refactoring allows the developer to run this cycle permanently on a small scale, thus continuously improving his product.
Disadvantages of Code Refactoring
On the other hand, however, there are some drawbacks or complications, especially for the company and its environment:
- Possible time consumption without any real benefit for the customer, which also distracts from the “important tasks”.
- Refactoring can cause new, unexpected errors.
- Interpretation and testing effort may be wastage of time.
- Taste question of what the program structure looks like.
- Tuning effort between programmers varies which results in possible errors that affect time.
These disadvantages may vary and are not part of refactoring.
Tagged With Code Refactoring