Software Craftsmanship

Code Smells
Software Craftsmanship Manifesto

“Not only working software, but also well-

crafted software
Not only responding to change, but also steadily
adding value
Not only individuals and interactions, but also a
community of professionals
Not only customer collaboration, but also
productive partnerships”
 Technical Debt
Software Finance
Skipping (or deferring) design Borrowing money
Refactoring (i.e. behavior-preserving
Repaying principal
design improvements)
Slower development due to code
Paying interest
smells
 Code Smells

• Lost Intent
• Inefficient Name
• Duplicated Code
• Deodorant Comment
• Long Method
• Large Class
• Lazy Class
More…
 Lost Intent

Just as a traffic sign may be obscured by shrubs, Code that doesn't easily communicate
it's author's intention is hazardous: hard to understand, extend and modify.
 Lost Intent
Intention-Revealing Code Lost Intent
Low-level or complex logic obscures
The purpose of the code is clear.
the code's purpose.
The location of code makes little
You can easily find the code you seek.
sense.
Every step of an algorithm is clearly The steps of the algorithm are
defined. blended together.
Lost Intent
 Inefficient Name

Where The Streets Have No Name

 Inefficient Name
These are five lines chosen at random from a class.
Each is grabbing a fetch result and putting it in a variable of type Account.

tmp = finder.fetch("0182901");
Account theAccount = finder.fetch(transaction.getSource());
account = finder.fetch( new StateMatcher("VA") );
for(Account item : finder.fetchAll()) { … }

getDrctn()
getDir()
getDirection()
 Duplicated Code

If you see the same code structure in more than one place, you can be sure that your program
will be better if you find a way to unify them.
— Refactoring[page 76], Martin Fowler and Kent Beck
Duplicated Code
Deodorant Comment

Comments often are used as a deodorant.

— Refactoring [page 87], Martin Fowler and Kent Beck
Deodorant Comment
 Comment Guidelines

• Whenever possible make your code express

the intent of the comment and remove the
comment.
• Comments are to provide intent that
is not expressible in code.
• Any comment that duplicates what the code
says should be deleted.
 Long Method

A long method is too much to digest

Long Method
 Large Class

Take on too many responsibilities

 Large Class

WebServicesProviderContoller
• performValidationCB()
• executeBusinessProcessCB()
 Lazy Class

A lazy class isn't doing enough to justify its existence.

Lazy Class
 Lazy Class

Employee constructor
.

Passing Jobs in
Employee
constructor.
 Oddball Solution

When a problem is solved one way throughout a system and the same problem is
solved another way in the same system, one of the solutions is the oddball or
inconsistent solution.
Oddball Solution
 Primitive Obsession

Primitive Obsession exists when code solves a problem using a tool that's too simplistic.
Primitive Obsession
 Switch Statement

Most times you see a switch statement you should consider polymorphism.
— Refactoring, Martin Fowler and Kent Beck (page 82).
 Switch Statement

Move each leg of the conditional to an overriding method in a subclass. Make the original
method abstract.
 Switch Statement

• Not every occurrence of a switch statement

(or if...else if...else if... statements) should be
replaced with a polymorphic solution.
 Speculative Generality

You get this smell when people say "Oh, I think we will need the ability to do that someday"
and thus want all sorts of hooks and special cases to handle things that aren't required. —
Refactoring, Martin Fowler and Kent Beck (page 83).
Speculative Generality
 Long Parameter List

Methods that take too many parameters produce client code that is awkward and
difficult to work with.
 Long Parameter List

user = userManager.create(USER_NAME, group, USER_NAME, “test",

USER_NAME, LANGUAGE, false, false, new Date(), "blah", new Date());
 Conditional Complexity

Conditional logic is innocent in its infancy, when it is simple to understand and contained
within a few lines of code. Unfortunately, it rarely ages well.
— Joshua Kerievsky, Refactoring to Patterns, page 41.
Conditional Complexity
 Combinatorial Explosion

When new combinations of data or behavior further bloat an already bloated design, you've got
a Combinatorial Explosion smell.
Combinatorial Explosion
 Alternative Classes With Different
Interfaces

This subtle smell results when differences in the interfaces of similar classes leads to
duplicated code.
Alternative Classes With Different
Interfaces
 Inappropriate Intimacy

Sometimes classes become far too intimate and spend too much time delving in each others'
private parts.
— Refactoring [page 85], Fowler and Beck
Inappropriate Intimacy
Indecent Exposure

We don't normally expose wires inside a wall or ceiling.

Indecent Exposure
 Refused Bequest

Subclasses get to inherit the methods and data of their parents. But what if they don't
want or need what they are given? — Refactoring[page 87], Martin Fowler and Kent Beck
Refused Bequest
Black Sheep
Black Sheep
 Solution Sprawl

When code and/or data used to perform a responsibility becomes sprawled across numerous
classes, Solution Sprawl is in the air.
— Joshua Kerievsky, Refactoring to Patterns, page 43.
Solution Sprawl
Feature Envy
Feature Envy
 Temporary Field

An object's field (a.k.a. instance variable) should have meaning during the full lifetime
of the object.
Temporary Field
Side Effect
Side Effect
 References

• Refactoring: Improving the Design of Existing

Code by Martin Fowler
• Refactoring to Patterns by Joshua Kerievsky.
• https://elearning.industriallogic.com/gh/subm
it?Action=AlbumContentsAction&album=reco
gnizingSmells&devLanguage=Java