Software Refactoring:
How to Improve
Source Code
Software Reengineering
What is Refactoring?
Refactoring is a process focused on improving the functionality of
source code by reducing and correcting the accumulation of inefficient
structures (bugs), all without adding new features to the code.
Every code refactoring process is guided by two main principles:
1. Transformations are implemented to simplify and make the code
easier to understand.
2. These changes do not add new features or alter the observable
behavior of the code.
• The result is the transformation of the source code into a more
stable, compatible, and readable system through iterative processes
without having to rewrite the code from scratch.
• Thus, refactoring is considered one of the best practices in software
development, contributing to the virtuous cycle of software quality.
When is Refactoring Recommended?
1. To fix errors (unnecessary or duplicate code, long
parameter lists, etc.)
2. In cases of “spaghetti code,” where the code is
disorganized, confusing, and difficult to read, hindering its
functionality. This kind of code often contains elements
that complicate its structure (jump statements, loops, if
statements, etc.), leading to issues known as code
smells or code rot, which can degrade the code to the point
that updates become nearly impossible.
Refactoring addresses these problems, improving the code and
making it more efficient, allowing new elements to be
integrated more easily, even by developers accessing the code
for the first time.
Advantages of Refactoring
• It creates more efficient and less redundant code.
• It facilitates code maintenance and improvements, as
well as testing processes.
• It does not alter the code’s functionality.
• It allows the incorporation of additional developers.
Disadvantages of Refactoring
However, it's important to recognize that refactoring
isn’t always appropriate.
• For instance, if functional changes are being made to
the code, refactoring is not recommended.
• Additionally, care must be taken to avoid introducing
new bugs during the process.
• If you have a large team, refactoring can cause delays
due to the difficulty in reaching consensus on how to
implement changes.
Refactoring Techniques
1. Branching/Refactoring by abstraction:
• This technique is mostly used by developers when
there is a need to do a large amount of refactoring.
• Mainly we use this technique to reduce the
redundancy (duplication) in our code.
• This involves class inheritances, hierarchy,
creating new classes and interfaces, extraction,
replacing inheritance with the delegation, and
vice versa.
Refactoring Techniques
2. Red-Green Refactoring:
Red-Green is the most popular and widely used
code refactoring technique in the Agile software
development process.
This technique follows the “test-first” approach to
design and implementation, this lays the foundation
for all forms of refactoring.
Developers take initiative for the refactoring into the
test-driven development cycle and it is performed
into the three district steps.
[Link]-Green Refactoring:
[Link]-Green Refactoring:
• RED: The first step starts with writing the
failing “red-test”. You stop and check what
needs to be developed.
• Green: In the second step, you write the
simplest enough code and get the development
pass “green” testing.
• Refactor: In the final and third steps, you
focus on improving and enhancing your code
keeping your test green.
2. Red-Green Refactoring:
So basically this technique has two distinct parts: The
first part involves writing code that adds a new function
to your system and the second part is all about
refactoring the code that does this function. Keep in
mind that you’re not supposed to do both at the same
time during the workflow.
3. Composing Method
• During the development phase of an application a lot of
times we write long methods in our program. These
long methods make your code extremely hard to
understand and hard to change. The composing method
is mostly used in these cases.
• In this approach, we use streamline methods to reduce
duplication in our code.
• Some examples are: extract method, extract a variable,
inline Temp, replace Temp with Query, inline method,
split temporary variable, remove assignments to
parameters, etc.
3. Composing Method
• Extraction: We break the code into smaller chunks
to find and extract fragmentation. After that, we
create separate methods for these chunks, and then it
is replaced with a call to this new method. Extraction
involves class, interface, and local variables.
• Inline: This approach removes the number of
unnecessary methods in our program. We find all
calls to the methods, and then we replace all of them
with the content of the method. After that, we delete
the method from our program.
4. Simplifying Methods
There are two techniques involved in this approach…let’s discuss
both of them.
• Simplifying Conditional Expressions Refactoring
• Simplifying Method Calls Refactoring
Simplifying Conditional Expressions Refactoring
• Conditional statement in programming becomes more logical
and complicated over time. You need to simplify the logic in
your code to understand the whole program.
• There are so many ways to refactor the code and simplify the
logic. Some of them are: consolidate conditional expression
and duplicate conditional fragments, decompose conditional,
replace conditional with polymorphism, remove control
flag, replace nested conditional with guard clauses, etc.
Simplifying Method Calls Refactoring
• In this approach, we make method calls simpler and easier to
understand. We work on the interaction between classes, and
we simplify the interfaces for them.
• Examples are: adding, removing, and introducing new
parameters, replacing the parameter with the explicit method
and method call, parameterize method, making a separate
query from modifier, preserve the whole object, remove
setting method, etc.
5. Moving Features Between
Objects
• In this technique, we create new classes, and we move the
functionality safely between old and new classes. We hide the
implementation details from public access.
• Now the question is… when to move the functionality between
classes or how to identify that it’s time to move the features
between classes?
• When you find that a class has so many responsibilities and too
much thing is going on or when you find that a class is unnecessary
and doing nothing in an application, you can move the code from
this class to another class and delete it altogether.
• Examples are: move a field, extract class, move method, inline class,
hide delegate, introduce a foreign method, remove middle
man, introduce local extension, etc.
6. User Interface Refactoring
• You can make simple changes in UI and refactor the
code. For example: align entry field, apply font,
reword in active voice indicate the format, apply
common button size, and increase color contrast, etc.
7. Preparatory Refactoring
• This approach is best to use when you notice the need for
refactoring while adding some new features in an application.
So basically it’s a part of a software update with a separate
refactoring process. You save yourself with future technical
debt if you notice that the code needs to be updated during the
earlier phases of feature development.
• The end-user can not see such efforts of the engineering team
eye to eye but the developers working on the application will
find the value of refactoring the code when they are building
the application. They can save their time, money, and other
resources if they just spend some time updating the code
earlier.
7. Preparatory Refactoring
Example of Preparatory Refactoring
• “It’s like I want to go 100 miles east but instead of
just traipsing through the woods, I’m going to drive
20 miles north to the highway and then I’m going to
go 100 miles east at three times the speed I could
have if I just went straight there. When people are
pushing you to just go straight there, sometimes you
need to say, ‘Wait, I need to check the map and find
the quickest route.’ The preparatory refactoring does
that for me.”
[Link] properties between classes
• In this refactoring technique, attributes are moved
between classes using methods like moving methods,
moving attributes, extracting classes, or converting
classes to inline, among others.
Conclusion
• You need to consider the code refactoring process as
cleaning up the orderly house. Unnecessary clutter in
a home can create a chaotic and stressful
environment. The same goes for written code. A
clean and well-organized code is always easy to
change, easy to understand, and easy to maintain.
You won’t be facing difficulty later if you pay
attention to the code refactoring process earlier.
Tools and Beyond: Refactoring in the
Age of Simplification
• Refactoring is part of a larger trend in software development
that aims to simplify all stages of programming. The goal is to
generate high-quality customized software with greater
efficiency and reduced development times.
• Tools like icaria Lean Factory, an MDA platform for
designing and creating business software without coding, are
leading the way in this effort. This simplification initiative
reduces costs and speeds up implementation and maintenance
by generating code from abstractions.
