Scribd
Upload
4 views15 pages

Code Refactoring

Refactoring is a disciplined technique for restructuring existing code without altering its external behavior, essential in agile software development. It aims to improve code quality, maintainability, and productivity, while being implemented through a test-refactor-test process. Although it incurs costs and requires expertise, its benefits often outweigh the drawbacks when applied judiciously.

Uploaded by

20zerocool2021
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
4 views15 pages

Code Refactoring

Refactoring is a disciplined technique for restructuring existing code without altering its external behavior, essential in agile software development. It aims to improve code quality, maintainability, and productivity, while being implemented through a test-refactor-test process. Although it incurs costs and requires expertise, its benefits often outweigh the drawbacks when applied judiciously.

Uploaded by

20zerocool2021
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 15

Agile Software Development

Process (OE3C41)

Code Refactoring

Dr. Ashish Singh


Parihar
Refactoring: what is it?
• Definition: Refactoring is a disciplined technique for
restructuring an existing body of code, altering its
internal structure without changing its external
behavior.

• Refactoring does not fix bugs, but it may help find bugs
by scrutinizing code. It may also reduce the further
introduction of bugs by cleaning-up code.

• Refactoring does not add new functionality to the


system, but it will ease the further adding of new
functionality.

• It is an essential part of agile software development


such as Extreme Programming or incremental
development.
Refactoring: when?
• Refactoring ought to be done continuously as “bad
smells” are encountered during programming.

• “Bad smells” or “anti-patterns” are portions of design


or code that are characterized as potentially confusing
and identifies as refactoring targets.

• More importantly, when using iterative development, a


major refactoring stage should precede the beginning
of the development of a new build. This will remove
slight design problems and ease the addition of further
functionality.

• In this case, refactoring counterbalances the


productivity-driven software development practices
implied by agile incremental software development.
Refactoring: why?
• Refactoring is usually done to:
• Improve quality
• improve design quality
• improve maintainability
• improve extensibility
• Improve sustainability of development
• requires proper testing, so improves testability
• helps to find bugs
• Improve productivity
• improve code readability & comprehensibility
• simplify code structure
Refactoring: how?
• Each refactoring is implemented as a small behavior-
preserving transformation.

• Behavior-preservation is achieved through pre- and


post-transformation testing.

• Refactoring process: test-refactor-test


Refactoring: drawbacks
• Cost Overhead: Refactoring is an add-on activity
and therefore will incur extra cost in form of time,
effort, and resource allocation, especially if
elaborated design and code documentation is
maintained. However, when done sparingly and only
on key issues, its benefits are greater than its
overhead. Automated documentation tools, code
browsing tools, refactoring tools and testing tools will
also diminish the refactoring overhead.

• Requires Expertise: Refactoring requires some


expertise and experience and considerable effort in
going through the process, especially if proper testing
is involved. However, this overhead can be minimized
by using refactoring tools and automated testing
such as with a unit testing framework.
Refactoring patterns
Reractoring: examples
• Encapsulate Downcast: A method returns an
object that needs to be downcasted by its callers.
Refactor by moving the downcast to within the
method.
Object lastReading() {
return readings.lastElement();
}

Reading lastReading() {
return (Reading) readings.lastElement();
}
Refactoring: examples
• Consolidate Conditional Expression: You have a
sequence of conditional tests with the same result.
Refactor by combining them into a single conditional
expression and extract it.

double disabilityAmount() {
if (_seniority < 2) return 0;
if (_monthsDisabled > 12) return 0;
if (_isPartTime) return 0;
// compute the disability amount

double disabilityAmount() {
if (isNotEligibleForDisability()) return 0;
// compute the disability amount
Refactoring: examples
• Consolidate Duplicate Conditional Fragments:
The same fragment of code is in all branches of a
conditional expression. Refactor by moving it outside
of the expression.
if (isSpecialDeal()) {
total = price * 0.95;
send();
} else {
total = price * 0.98;
send();
}

if (isSpecialDeal())
total = price * 0.95;
else
total = price * 0.98;
send();
Refactoring: examples
• Rename Method: The name of a method does not
reveal its purpose. Refactor it by changing the name
of the method.
int getInvCdtLmt(){
…
}

int getInvoiceableCreditLimit(){
…
}
Refactoring: examples
• Pull Up Field: Two subclasses have the same field.
Refactor it by moving the field to the superclass.
Refactoring: examples
• Push Down Method: Behavior on a superclass is
relevant only for some of its subclasses. Refactor it
by moving it to those subclasses.
Refactoring: practice
• Some refactorings are controversial.
• Some refactorings are arguably not improving code
quality.
• Some refactorings can in fact be counter-productive
when applied blindly, especially in iterative
development, where design is evolving.
• Have your team adopt a set of refactorings to be
applied, and make sure that refactorings are applied
in a productive manner.
• Apply in combination with the application of design
patterns.
• Use refactoring tools to automate changes, e.g.
Eclipse refactoring, and JUnit testing framework.
References
• Source Making. Refactoring.
http://sourcemaking.com/refactoring
• Martin Fowler, Kent Beck, John Brant, William Opdyke, Don
Roberts. Refactoring: Improving the Design of Existing Code.
Addison-Wesley Professional, 1999. ISBN-13: 978-0201485677.
• Martin Fowler. Refactoring.com.

You might also like