La qualità del codice che maneggiamo tutti i giorni è molto importante ma difficile da ottenere. Non si tratta di un traguardo da raggiungere ma di un processo di continuo miglioramento. Nel talk vedremo quali sono le più comuni debolezze del codice, vedremo come sia possibile manipolarlo senza paura e come approfittare di ogni occasione per migliorarlo seguendo alcuni principi di design. https://brewbox.community/ https://www.facebook.com/events/1673978505997779 https://www.youtube.com/watch?v=aQQWrQZYliU

2. Refactoring
Sempre, senza pietà!
BrewBox
29 gennaio 2018
Scaletta
1. Smells
2. Riscrittura vs refactoring
3. Codice, codice, codice

3. Roberto
Albertini
r.albertini@newgenesys.it
@robalbertini
www.linkedin.com/in/robertoalbertini
www.newgenesys.it

4. La presentazione contains
un uso discontinuo
of italiano and english
Attenzione

5. Fonti
Clean Code: A Handbook of Agile
Software Craftsmanship
Robert C. Martin (2008)
Extreme Programming Explained:
Embrace Change
Kent Beck (1999)
Refactoring: Improving
the Design of Existing Code
Martin Fowler (1999)
@milanoxpug
@milanoxpug

6. “
”
Any fool can write code
that a computer can understand.
Good programmers write
code that humans can understand
Refactoring: Improving the Design of Existing Code: Martin Fowler

7. “
”
Programming is the art of
telling another human being
what one wants the computer to do
Donald Knuth

8. Codice come comunicazione
Cosa comunica
Dominio
Design
Intenzioni
Come comunica
Attendibile
Verificabile

9. Contesti e stili
contesti diversi generano stili diversi
Linguaggi
Tecnologie
Framework
Community
Competenze
Personalità

10. Mi ispiro a OOP
Ma molti concetti sono applicabili a qualunque contesto
Attenzione

11. “
”
Problems with projects
can invariably be traced back to
somebody not talking to somebody else
about something important
Kent Beck, Extreme Programming Explained: Embrace Change

12. La comunicazione può essere problematica
Faticoso da leggere
10 a 1
Nasconde bachi
Comportamenti non evidenti aiutano a nascondersi
Difficile da modificare
Comprensione del design e delle intenzioni
Invita al degrado
Finestra rotta

13. “
”
is a surface indication
that usually corresponds to
a deeper problem in the system
Code smell

14. Duplicated code
Liar Names
Uncommunicative Name
Inconsistent Names
Comments
Mixing levels of abstraction
within a function
Data Clumps
Primitive Obsession
Long Method
Long Names
Long Parameter List
Large Class
Code Smells (catalogo completo?)
Feature Envy
Inappropriate Intimacy
Incomplete Library Class
Middle Man
Message Chains
Alternative Classes with
Different Interfaces
Refused Bequest
Switch Statements
Temporary Field
Divergent Change
Shotgun Surgery
Parallel Inheritance
Hierarchies
Dead Code
Data Class
Lazy Class
Speculative Generality
Incomplete Library Class
Message Chains
Middle Man
Conditional Complexity
Combinatorial Explosion
Type Embedded in Name
Oddball Solution
Indecent Exposure
Solution Sprawl
Excessive use of literals
Cyclomatic complexity
Downcasting
Orphan variable or constant
class
Excessively short identifiers
Excessively long identifiers
Excessive return of data

15. Code Smells: Duplicated code
“Number one in the stink parade”
(Martin Fowler - Refactoring
“Root of all evil”
(Robert C. Martin - Clean Code)
“The bane of software development”
(Jeff Atwood - blog.codinghorror.com)

16. Code Smells: smells nei nomi
Liar names
Metodi con effetti collaterali, diversi da quel che ci si aspetta
Uncommunicative names
Descrivono efficacemente? Lasciano intendere quello che accadrà?
Inconsistent names
Terminologia, convenzioni.

17. Code Smells: Comments
public void printReport(Date now) {
printBanner();
// print details
System.out.println("name: " + name);
System.out.println("amount: " + getOutstanding());
// footer
int sdf = new SimpleDateFormat("dd MMM yyyy");
System.out.println("======================");
System.out.println(sdf.format(now));
System.out.println("======================");
}

18. Code Smells: Duplicated code
“Root of all evil”
(Robert C. Martin - Clean Code)

19. Code Smells: Mixing levels of abstraction within a function
public void printReport(User user, BigDecimal rate, Date now) {
printHeader(user);
printUserDetails(user);
BigDecimal points = getTotalPoints();
BigDecimal coins = points.divide(rate, 0, FLOOR);
BigDecimal gold = coins.divide(CHANGE, 0, FLOOR);
BigDecimal silver = coins.subtract(gold.multiply(CHANGE));
System.out.println(" ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~");
System.out.println("Points: " + points + " ");
System.out.println(" Value: " + gold + "gold " + silver + "silver");
System.out.println(" ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~");
printFooter(now);
}

20. Code Smells: Data Clumps
“Data items tend to be like children;
they enjoy hanging around in groups together”
void drawPoint(int xPos, int yPos);
double valueBetween(Date startDate, Date endDate);
void drawPoint(Point point);
double valueBetween(DateInterval interval);

21. Code Smells: Primitive Obsession
double computeValue(List<Invoice> invoices){ … }
List<Invoice> readAllInvoicesOfMonth(Date mese){ … }
List<Invoice> readAllInvoicesOfMonth(int anno, int mese){ … }
Packages findByTrackingCode(String bfTrackingCode){ … }
“Use small objects for small tasks”

22. Code Smells: Feature Envy
“a method that seems more interested
in a class other than the one it actually is in.”
public class Amount {
public void computeTotal(Item item) {
int amount1 = item.getAmountOne();
int amount2 = item.getAmountTwo();
int amount3 = item.getAmountThree();
int total = amount1 + amount2 + amount3;
item.setTotal(total);
}

23. Code Smells: Duplicated code
Duplicated code
Root of all evil

24. Uno alla volta
gli smells si accumulano
Demo!

25. Il codice peggiora nel tempo

26. Soluzione 1: Riscrittura

27. Organizzare la riscrittura
Tempo, Risorse e Organizzazione
Ma il valore è poco visibile
Sviluppo interrotto o parallelo?
Risorse suddivise o nuove?
Rilascio big bang o incrementale?
Quale valore si ottiene?

28. Cosa si riscrive?
Bisogna riportare TUTTE le features
Nascoste, dimenticate, bug
La verità sta solo nel codice
non nella memoria o nella documentazione

29. Sicuro che sapresti
fare meglio?
Ma soprattutto…

31. La riscrittura è la soluzione giusta
‣ Per adeguamento tecnologico
‣ Quando l’accesso al sorgente è difficile
‣ Per accedere a nuove tecnologie
‣ …
Non per fare le pulizie

32. Soluzione 2: Refactoring
Sempre, senza pietà!

33. “
”
Programmers restructure the system
without changing its behavior
to remove duplication,
improve communication,
simplify, or add flexibility
Refactoring
Kent Beck da “Extreme Programming Explained”

34. “
”
Refactoring is a disciplined technique
for restructuring an existing body of code,
altering its internal structure
without changing its external behavior
Refactoring
Martin Fowler dalla home page di www.refactoring.com

35. 1. Miglioramento del codice
2. Nessuna aggiunta o modifica
di funzionalità
3. Tecnica disciplinata
Refactoring

36. ‣ Dopo aver aggiunto una feature: per pulire
‣ Prima di aggiungere una feature: per fare spazio
‣ Per consolidare un livello di comprensione del
problema
“as I gain understanding about the program, I embed that understanding
into the code for later so I don't forget what I learned”
‣ Per comprendere codice ignoto che si sta
esplorando
‣ Per stanare un baco
‣ Ogni volta che puzza
Quando? Sempre!

37. Come? Senza pietà!
‣ Coraggio
‣ Costanza e disciplina
‣ Nessuna tolleranza per i difetti

38. 1. Two hats
2. Baby steps
3. Test automatici
4. Undo
In pratica: 4 punti fondamentali

39. In pratica: (1) Two hats
Make it work
Aggiungi le features
Punti a una soluzione semplice che funzioni
Make it clean
Non modifichi il comportamento del sistema
Approfitti della conoscenza acquisita

40. In pratica: (2) Baby steps
Modifiche semplici
La probabilità di sbagliare è bassa
Sistema rimane sempre funzionante
Ogni modifica non rompe il sistema

41. In pratica: (3) Test automatici
Evitare le regressioni
Rete di sicurezza
Evitare la paura
La confidenza è fondamentale
per affrontare le ristrutturazioni più audaci

42. In pratica (4) Undo
Deve essere facile ricominciare
commit, refactor, commit, refactor, REVERT
Quando ricominciare?
Quando sei insicuro a metà di un refactoring
Quando sei fuori controllo
Come si ricomincia
Con passi più piccoli e idee più chiare

43. Passi di refactoring: catalogo completo (?)
Add Parameter
Change Bidirectional
Association to Unidirectional
Change Reference to Value
Change Unidirectional
Association to Bidirectional
Change Value to Reference
Collapse Hierarchy
Consolidate Conditional
Expression
Consolidate Duplicate
Conditional Fragments
Decompose Conditional
Duplicate Observed Data
Dynamic Method Definition
Eagerly Initialized Attribute
Encapsulate Collection
Encapsulate Downcast
Encapsulate Field
Extract Class
Extract Interface
Extract Method
Extract Module
Extract Subclass
Extract Superclass
Extract Surrounding Method
Extract Variable
Form Template Method
Hide Delegate
Hide Method
Inline Class
Inline Method
Inline Module
Inline Temp
Introduce Assertion
Introduce Class Annotation
Introduce Expression Builder
Introduce Foreign Method
Introduce Gateway
Introduce Local Extension
Introduce Named Parameter
Introduce Null Object
Introduce Parameter Object
Isolate Dynamic Receptor
Lazily Initialized Attribute
Move Eval from Runtime to
Parse Time
Move Field
Move Method
Parameterize Method
Preserve Whole Object
Pull Up Constructor Body
Pull Up Field
Pull Up Method
Push Down Field
Push Down Method
Recompose Conditional
Remove Assignments to
Parameters
Remove Control Flag
Remove Middle Man
Remove Named Parameter
Remove Parameter
Remove Setting Method
Remove Unused Default
Parameter
Rename Method
Replace Abstract Superclass
with Module
Replace Array with Object
Replace Conditional with
Polymorphism
Replace Constructor with
Factory Method
Replace Data Value with
Object
Replace Delegation With
Hierarchy
Replace Delegation with
Inheritance
Replace Dynamic Receptor
with Dynamic Method
Definition
Replace Error Code with
Exception
Replace Exception with Test
Replace Hash with Object
Replace Inheritance with
Delegation
Replace Loop with Collection
Closure Method
Replace Magic Number with
Symbolic Constant
Replace Method with Method
Object
Replace Nested Conditional
with Guard Clauses
Replace Parameter with
Explicit Methods
Replace Parameter with
Method
Replace Record with Data
Class
Replace Subclass with Fields
Replace Temp with Chain
Replace Temp with Query
Replace Type Code with Class
Replace Type Code with
Module Extension
Replace Type Code With
Polymorphism
Replace Type Code with
State/Strategy
Replace Type Code with
Subclasses
Self Encapsulate Field
Separate Query from Modifier
Split Temporary Variable
Substitute Algorithm

44. Replace Nested Conditional with Guard Clauses
double getPayAmount() {
double result;
if (isDead){
result = deadAmount();
} else {
if (isSeparated) {
result = separatedAmount();
} else {
if (isRetired) {
result = retiredAmount();
} else {
result = normalPayAmount();
}
}
}
return result;
}
double getPayAmount() {
if (isDead) {
return deadAmount();
}
if (isSeparated) {
return separatedAmount();
}
if (isRetired) {
return retiredAmount();
}
return normalPayAmount();
}
Prima Dopo

45. Introduce Parameter Object (prima)
public int getValBetween(Date startDate, Date endDate) {
int result = 0;
for (Entry each : entries) {
if ((each.getDate().after(startDate)
&& each.getDate().before(endDate))
|| each.getDate().equals(startDate)
|| each.getDate().equals(endDate)) {
result += each.getValue();
}
}
return result;
}

46. Introduce Parameter Object (dopo)
public int getValBetween(DateInterval dateInterval) {
int result = 0;
for (Entry each : entries) {
if (dateInterval.include(each.getDate())) {
result += each.getValue();
}
}
return result;
}

47. Introduce Parameter Object (dopo)
public class DateInterval {
private final Date startDate;
private final Date endDate;
public DateInterval(Date startDate, Date endDate) {
this.startDate = startDate;
this.endDate = endDate;
}
public boolean include(Date date) {
if ((date.after(startDate) && date.before(endDate))) {
return true;
}
if (date.equals(startDate) || date.equals(endDate)) {
return true;
}
return false;
}
}

48. Da dove si comincia? In quale direzione? Chi guida?
Principi di design
Clean code, GRASP, SOLID
Soluzioni a problemi comuni
Design pattern
Provare più soluzioni possibili
Spike, refactor/revert

49. “
”
Talk is cheap.
Show me the code
Linus Torvalds

50. Domande?

51. Grazie per
l’attenzione
Fine
Roberto Albertini
r.albertini@newgenesys.it
@robalbertini
www.linkedin.com/in/robertoalbertini
www.newgenesys.it

52. Credits
‣ Presentation template: Gremio by Slidescarnival
http://www.slidescarnival.com/gremio-free-presentation-template/1593
‣ Base color: Marsala #964F4C by Pantone
http://www.pantone.com/color-of-the-year-2015
https://www.pantone.com/color-finder/18-1438-TCX
‣ Font: Roboto by Google (Christian Robertson)
https://fonts.google.com/specimen/Roboto
‣ Font: Great Vibes by TypeSETit
https://fonts.google.com/specimen/Great+Vibes
‣ Icons: Font Awesome Vector Icons/Glyphs
https://goo.gl/vdQGpu, http://fontawesome.io/