Tdd y clean code SG campus

www.sgcampus.com.mx
Por Jorge Jiménez y Fernando Arana
@sgcampus
TDD y Clean Code
www.sgcampus.com.mx @sgcampus

BAD CODE
¿Quién se identifica con esto?
xkcd.com

BAD CODE
O peor… ¿A quién le ha pasado?

BAD CODE
Y entonces…

¿Existe alguna solución?
¿Extensos estándares?
¿Documentación?
¿Poner extremo cuidado?
¿Análisis estático de código?
¿Inspecciones?
¿Pedir la bendición para el código productivo?

Test Drive Development

“No soy un gran programador. Sólo
soy un buen programador con
grandes hábitos”
―Kent Beck
Inventor de TDD

TDD es una técnica de desarrollo que nació con
XP (eXtreme Programming)
Se hace diseño y codificación guiado por las
pruebas unitarias
Con TDD podemos lograr que el diseño “emerja”
del código

Pero antes…
1. Has una lista de las posibles pruebas que se
harán al requerimiento
2. Comienza con las pruebas más sencillas
3. Aquellas que rodean el requerimiento
4. DETÉN el impulso de programar todas las
reglas de negocio en una sola vez

Consta de 3 pasos:
1. Escribes una prueba que falla
2. Escribes el MÍNIMO código productivo que
hace que la prueba pase
3. Haces Refactor usando Clean Code

Clean Code
“Sabes que estás trabajando con Código Limpio
cuando cada rutina que lees resulta ser
exactamente lo que esperabas de ella”
-Ward Cunningan
“Sabes que ves un Código Limpio cuando:
• Corren todas las pruebas
• No tiene código duplicado
• Expresa todas las ideas que tiene el sistema
• Minimiza el número de entidades como clases,
métodos, y funciones”
-Ron Jeffries
www.sgcampus.com.mx Fuente: libro “Clean Code” por Bob Martin
@sgcampus

Clean Code

Clean Code
Mapa Mental por
Gustavo García en
base a los videos de
cleancoders.com

Clean Code
Nombres:
Los nombres deben reflejar su intención
Deben poder pronunciarse
Usar nombres de acuerdo a las reglas de negocio
Evitar encodings (prefijos, tipos de datos)
Algunas reglas de nombrado:
Clases = Sustantivos
Variables = Nombres
Métodos = Verbos
Booleanos = “is” o “has”

Clean Code
Nombres
VS
@sgcampus

Clean Code
Funciones:
Deben de ser pequeñas
Y más pequeñas aún: 4 a 6 líneas
Una función larga puede tener algunas clases
escondidas
No pasar más de 2 argumentos
Extraer hasta no poder extraer más, así
aseguramos un nivel de abstracción
“FUNCTIONS SHOULD DO ONE THING. THEY
SHOULD DO IT WELL. THEY SHOULD DO IT ONLY”
@sgcampus

Clean Code
Formato:
Comentarios: El mejor comentario es el que no se
escribe
Tamaño de archivos: entre más pequeños, mejor
Formato Vertical: uniformidad en interlineado,
sangría, ciclos, etc.
Step Down Rule: Organizar métodos del más
abstracto al más específico.
El código debe entenderse en secuencia de arriba
hacia abajo
@sgcampus

Clean Code
@sgcampus

¿Qué es una Kata?
Una Kata es una manera de poner en práctica y
aprender de manera segura
En una Kata, el aprendizaje es más importante
que el resultado (es decir, no importa si el
programa “no jala” o se queda incompleto)
Por eso, las Katas se tienen que hacer más de
una vez

Kata Factores Primos
Prime Factors
+ generate(n : int)
Escribe un clase llamada “PrimeFactors” que tiene
un método estático: generate
El método generate toma un argumento entero y
regresa una lista de enteros “List<Integer>” Esta
lista contiene los factores primos en secuencia
numérica.

Junit
@Test
public void dadoUno_regresaVacio() throws Exception {
FactoresPrimos factorador = new FactoresPrimos();
List<Integer> factores = factorador.buscarFactoresPrimos(1);
assertEquals(0, factores.size());
Productivo
}
public class FactoresPrimos {
public List<Integer>buscarFactoresPrimos(int i) {
return null;
}
}

Junit
@Test
FactoresPrimos factorador = new FactoresPrimos();
}
Productivo
public List<Integer>buscarFactoresPrimos(int i) {
return new ArrayList<Integer>();
}
}

Junit
private FactoresPrimos factorador;
@Test
public void setUp() throws Exception {
this.factorador = new FactoresPrimos();
}
@Test
}

Junit
public void dadoDos_regresaListaConSoloDos() throws Exception {
assertEquals(2, factores.get(0).intValue());
Productivo
@Test
}
public List<Integer> buscarFactoresPrimos(int numero) {
ArrayList<Integer> listaDeFactores = new ArrayList<Integer>();
if (numero > 1) {
listaDeFactores.add(2);
}
return listaDeFactores;
}

Junit
public void dadoTres_regresaListaConSoloTres() throws Exception {
Productivo
@Test
List<Integer> factores =
factorador.buscarFactoresPrimos(3);
}
if (numero % 2 == 0) {
} else if (numero % 3 == 0) {
}
}

Junit
private void assertFactoresPrimos(int numeroAEvaluar) {
List<Integer> factores =
factorador.buscarFactoresPrimos(numeroAEvaluar);
assertEquals(numeroAEvaluar, factores.get(0).intValue());
}
@Test
assertFactoresPrimos(2);
}
@Test
}

for (int primo = 2; primo <= numero; primo++) {
añadirPrimo(listaDeFactores, primo, numero);
}
}
private void añadirPrimo(ArrayList<Integer> listaDeFactores, int primo, int numero) {
if (numero % primo == 0) {
listaDeFactores.add(primo);
}
}
Productivo

Junit
Productivo
@Test
public void dadoCuatro_regresaDosYDos() throws Exception {
}
int aEvaluar = numero;
final ArrayList<Integer> listaDeFactores = new ArrayList<Integer>();
for (int primo = 2; primo <= aEvaluar;) {
aEvaluar = aEvaluar / primo;
} else {
primo++;
}
}
}
}

private static final int PRIMER_FACTOR_PRIMO = 2;
public List<Integer> buscarFactoresPrimos(final int numero) {
siguientesFatoresPrimos(listaDeFactores, PRIMER_FACTOR_PRIMO, numero);
}
private void siguientesFatoresPrimos(final ArrayList<Integer> listaDeFactores, final int primo,
final int numero) {
if (primo <= numero) {
evaluaFactorPrimo(listaDeFactores, primo, numero);
}
}
private void evaluaFactorPrimo(final ArrayList<Integer> listaDeFactores, final int primo, final
int numero) {
siguientesFatoresPrimos(listaDeFactores, primo, numero /
primo);
} else {
siguientesFatoresPrimos(listaDeFactores, primo + 1, numero);
}
}
}
Productivo

Productivo
private static final int PRIMER_FACTOR_PRIMO = 2;
public List<Integer> buscarFactoresPrimos(final int numero) {
siguientesFatoresPrimos(listaDeFactores, PRIMER_FACTOR_PRIMO, numero);
}
private void siguientesFatoresPrimos(final ArrayList<Integer> listaDeFactores, final int primo, final
int numero) {
if (primo <= numero) {
evaluaFactorPrimo(listaDeFactores, primo, numero);
}
}
private void evaluaFactorPrimo(final ArrayList<Integer> listaDeFactores, final int primo, final int
numero) {
siguientesFatoresPrimos(listaDeFactores, primo, numero / primo);
} else {
siguientesFatoresPrimos(listaDeFactores, primo + 1, numero);
}
}
}

Junit
private void assertFactoresPrimos(final int numeroAEvaluar, final int... valores) {
final List<Integer> factores = factorador.buscarFactoresPrimos(numeroAEvaluar);
assertEquals(valores.length, factores.size());
for (int i = 0; i < valores.length; i++) {
assertEquals(valores[i], factores.get(i).intValue());
}
}
@Test
}
@Test
assertFactoresPrimos(2, 2);
}
@Test
}
@Test
assertFactoresPrimos(4, 2, 2);
}

Junit
public void dadoCinco_regresaCinco() throws Exception {
Productivo
@Test
}
Pasa

Junit
private void assertFactoresPrimos(final int numeroAEvaluar, final int... valores)
private void assertNumeroGeneraFactoresPrimos(final int numeroAEvaluar,
final int... valores)
@Test
}
@Test
}
@Test
}
@Test
assertFactoresPrimos(4, 2, 2);
}
@Test
public void dadoCinco_regresaCinco() throws Exception {
}
public void dadoNumero_regresaSusFacotresPrimos() throws Exception {
assertNumeroGeneraFactoresPrimos(1);
assertNumeroGeneraFactoresPrimos(2, 2);
assertNumeroGeneraFactoresPrimos(4, 2, 2);
}

Junit
assertNumeroGeneraFactoresPrimos(8, 2, 2, 2);
assertNumeroGeneraFactoresPrimos(2 * 3 * 5 * 7 * 11 * 13 * 17, 2, 3, 5, 7, 11, 13, 17);
Productivo
assertNumeroGeneraFactoresPrimos(6, 2, 3);
Pasan

Conclusiones
Utilizando TDD y Clean Code tendremos los siguientes
beneficios:
Seguridad al modificar código (red de protección de
pruebas unitarias)
Código mantenible para poder arreglar bugs o
implementar nuevos features
Mejor trabajo en equipo (¡por fin nos entendemos!)
Clientes satisfechos
Estimaciones más certeras
Enfocarnos en cosas más interesantes: nuevos
frameworks, Clean Architecture, Patrones, Sistemas
resistentes a fallos, Escalabilidad…
@sgcampus

Clean Code
“Deja el código mejor de cómo lo encontraste”

Bibliografía
 Clean code: A Handbook of Agile Software Craftsmanship
@sgcampus
(Robert C. Martin)
 Test Driven Development: By Example (Kent Beck)
 Refactoring: Improving the Design of Existing Code (Martin
Fowler)
 Working Effectively with Legacy Code (Michael Feathers)
 The Clean Coder: A Code of Conduct for Professional
Programmers (Robert C. Martin)
 The Coding Dojo Handbook (Emily Bache)
 CleanCoders.com

Tdd y clean code SG campus

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Tdd y clean code SG campus

Similar a Tdd y clean code SG campus (20)

Más de Software Guru

Más de Software Guru (20)

Último

Último (20)

Tdd y clean code SG campus