Kata de números romanos y TPP

Slides usadas para un coding dojo en la Coruña. En concreto se trata de la kata Roman Numerals aplicando la Transformation Priority Premise (TPP).

Transcript

1. Coding dojo: Kata de números romanos y TPP A Coruña, 3 de abril de 2018 Borja Fdez Pillado (@BorjaL) Isidro López (@islomar)
2. Ego slide Desarrollador de software (de sabático) @islomar islomar@gmail.com Desarrollador de software (Charplanet) @borjal https://borjafernandezpillado.com
3. ¿Para qué estamos aquí? • Para divertirnos, aprender y compartir • Practicar TDD (Test-Driven Development) • Aprender qué es TPP (Transformation Priority Premise) • Trabajar en parejas y con pomodoros
4. ¿Qué es un Coding Dojo? • Lugar donde aprender, mejorar y divertirse programando • Lugar donde experimentar • Lugar seguro para practicar: diseño, testing, refactoring, herramientas, etc. • En parejas: humildad, generosidad, agradecimiento • Práctica deliberada • NO es un curso ni una formación ni una “clase maestra”: facilitadores
5. Disclaimer
6. http://luizricardo.org/wordpress/wp-content/upload-files/2014/05/tdd_flow.gif
7. La regla dorada de TDD Nunca escribas nueva funcionalidad sin un test que falle
8. Recordemos: ¿qué aporta (y qué no) TDD? ¿Qué puede aportar? • Foco • Feedback rápido • Simplicidad • Cadencia • Documentación ¿Qué no aporta necesariamente? • Un buen diseño • “Buenos” tests • Buena documentación
9. Hands-on time!! Pair programming Pomodoros: ~25 min. Kata Roman Numerals http://cdn2.hubspot.net/hub/213381/file-367603473-jpg/images/kata.jpg
10. Kata de números romanos https://github.com/CraftersEntrePercebes/RomanNumerals http://cyber-dojo.org Write a function to convert from normal numbers to Roman Numerals. (there is no need to be able to convert numbers larger than about 3000) Ayuda: • http://www.novaroma.org/via_romana/numbers.html : no más de tres símbolos similares seguidos • https://www.rapidtables.com/convert/number/roman-numerals-converter.html
11. Round 1… code!!
12. Baby steps y el problema del impás Baby steps • RED -> GREEN: escribir el mínimo código necesario para pasar el test. • Feedback rápido • Baja complejidad en cada iteración El problema del impás • Mala elección en el orden de creación de los tests: bloqueo y “explosión”. • No hacer el código cada vez más genérico con cada test.
13. Transformation Priority Premise • Transformation -> Modifica el comportamiento del código • Cada transformación tiene una prioridad o un orden • Cuanta más alta es la prioridad, más simple es la transformación • Ayuda al programador a crear el paso más simple posible (Baby step) • El código va de específico a genérico
14. The transformations
15. TDD and TPP • When passing a test, prefer higher priority transformations. • When posing a test choose one that can be passed with higher priority transformations. • When an implementation seems to require a low priority transformation, backtrack to see if there is a simpler test to pass
16. Example - Word Wrap Kata ({}–>nil) - Red @Test public void WrapNullReturnsEmptyString() throws Exception { assertThat(wrap(null, 10), is("")); }
17. Example - Word Wrap Kata ({}–>nil) - Red public static String wrap(String s, int length) { return null; } (nil->constant) - Green public static String wrap(String s, int length) { return ""; }
18. Example - Word Wrap Kata (nil–>constant) - Green @Test public void WrapEmptyStringReturnsEmptyString() throws Exception { assertThat(wrap("", 10), is("")); }
19. Example - Word Wrap Kata (constant->constant+) - Red @Test public void OneShortWordDoesNotWrap() throws Exception { assertThat(wrap("word", 5), is("word")); }
20. Example - Word Wrap Kata (unconditional->if) & (constant->scalar) - Green public static String wrap(String s, int length) { if (s == null) return ""; return s; } Ignoramos la premisa con mayor prioridad
21. Example - Word Wrap Kata (constant->constant+) - Red @Test public void TwoWordsLongerThanLimitShouldWrap() throws Exception { assertThat(wrap("word word", 6), is("word\nword")); }
22. Example - Word Wrap Kata (expression->function) - Green (Too low in the list) public static String wrap(String s, int length) { if (s == null) return ""; return s.replaceAll(" ", "\n"); }
23. Example - Word Wrap Kata (constant->constant+) - Red @Test public void ThreeWordsJustOverTheLimitShouldWrapAtSecondWord() throws Exception { assertThat(wrap("word word word", 9), is("word word\nword")); } ¡Atención Impás!
25. Example - Word Wrap Kata (constant->constant+) - Red @Test public void OneShortWordDoesNotWrap() throws Exception { assertThat(wrap("word", 5), is("word")); }
26. Example - Word Wrap Kata (constant->constant+) - Green public static String wrap(String s, int length) { if (s == null) return ""; return "word"; }
27. Example - Word Wrap Kata (constant->constant+) - Red @Test public void OneShortWordDoesNotWrap() throws Exception { assertThat(wrap("otherword", 10), is("otherword")); }
28. Example - Word Wrap Kata (constant->scalar) - Green public static String wrap(String s, int length) { if (s == null) return ""; return s; }
29. Example - Word Wrap Kata (constant->constant+) - Red @Test public void TwoWordsLongerThanLimitShouldWrap() throws Exception { assertThat(wrap("word word", 6), is("word\nword")); }
30. Example - Word Wrap Kata (constant->constant+) - Red @Test public void WordLongerThanLengthBreaksAtLength() throws Exception { assertThat(wrap("longword", 4), is("long\nword")); }
31. Example - Word Wrap Kata (unconditional->if) - Green public static String wrap(String s, int length) { if (s == null) return ""; if (s.length() <= length) return s; else { return "long\nword"; } }
32. Example - Word Wrap Kata (statement->statements) - Red @Test public void WordLongerThanLengthBreaksAtLength() throws Exception { assertThat(wrap("longword", 4), is("long\nword")); assertThat(wrap("longerword", 6), is("longer\nword")); }
33. Example - Word Wrap Kata (expression->function) - Green public static String wrap(String s, int length) { if (s == null) return ""; if (s.length() <= length) return s; else { return s.substring(0, length) + "\n" + s.substring(length); } }
34. Example - Word Wrap Kata (constant>constant+) - Red @Test public void WordLongerThanTwiceLengthShouldBreakTwice() throws Exception { assertThat(wrap("verylongword", 4), is("very\nlong\nword")); }
35. Example - Word Wrap Kata (statement->recursion) - Green public static String wrap(String s, int length) { if (s == null) return ""; if (s.length() <= length) return s; else { return s.substring(0, length) + "\n" + wrap (s.substring(length), length); } }
36. Round 2… code!!
37. Algunas reflexiones • ¿Existen otras transformaciones? (seguramente) • ¿Son éstas las transformaciones correctas? (probablemente no) • ¿Existen mejores nombres para las transformaciones? (casi sseguro) • ¿Existe realmente una prioridad?
38. Resumiendo, que es gerundio • It appears that the green phase can be achieved by employing a fixed set of behavior changing transformations to the code. • These changes move the code from a specific form to a more generic form. • It also appears that these transformations have a preferred order based on complexity. This ordering can be used in both the red and green phases of TDD. • TDD impasses will be reduced or eliminated.
39. https://goo.gl/AitF9H
40. Posibles “soluciones” http://codingdojo.org/record/GothPy081007/ http://www.solveet.com/exercises/Kata-Roman-Numerals/9
41. Sobre la kata de números romanos y TPP • Blog post: ◦ https://codurance.com/2015/05/18/applying-transformation-priority-premise-to-roman-n umerals-kata/ ◦ https://8thlight.com/blog/micah-martin/2012/11/17/transformation-priority-premise-appli ed.html (it includes screencast with TPP for another kata) • Screencasts: ◦ http://blog.coreyhaines.com/2012/12/roman-numerals-kata-with-commentary.html ◦ https://www.infoq.com/presentations/TDD-Managers-Nicolette-Scotland ◦ https://vimeo.com/15104374 • Uncle Bob - Advanced TDD, the Transformation Priority Premise [min 34:00]: https://vimeo.com/97516288
42. Bibliografía • TDD by example (Kent Beck) • Growing Object-Oriented guided by tests (Steve Freeman, Nat Pryce) • Diseño ágil con TDD (Carlos Blé) • Specification by example (Gojko Adzic) • Refactoring (Martin Fowler) • Clean Code (Uncle Bob) • XP Explained (Kent Beck)
43. Blogs http://blog.adrianbolboaca.ro/ http://blog.jbrains.ca/ https://codurance.com/publications/ https://www.codesai.com/publications/
44. Screencasts • Screencasts de Sandro Mancuso: ◦ Algorithms: https://www.youtube.com/watch?v=iZjgj1S0FCY ◦ Outside-In TDD: ▪ https://www.youtube.com/watch?v=XHnuMjah6ps ▪ https://www.youtube.com/watch?v=24vzFAvOzo0 • Carlos Blé ◦ Implementando algoritmos con TDD ◦ Kata sobre juego de cartas
45. Charlas • Joaquín Engelmo (@kinisoftware) ◦ Adicto al verde ◦ Dando amor a los tests • The limited red society • The three laws of TDD • Test-Bridle Development (@flipper83), SCPNA
46. Artículos y webs de interés • https://martinfowler.com/bliki/IntegrationTest.html • https://martinfowler.com/articles/microservice-testing/ • http://www.agiledata.org/essays/tdd.html • https://medium.com/@ramtop/what-im-talking-about-when-i-talk-about-t dd-546a383468be • https://martinfowler.com/articles/practical-test-pyramid.html • Ideas para katas: https://github.com/12meses12katas
47. Cursos http://www.codium.team/curso-tdd.html : Vigo, 11 y 12 de junio https://www.codesai.com/curso-de-tdd/ http://www.jbrains.ca/training/the-worlds-best-introduction-to-test-driven-dev elopment/ http://www.codemanship.co.uk/tdd.html Pluralsight: https://www.pluralsight.com/search?q=TDD
48. http://3.bp.blogspot.com/-N6byEO21I0w/VoTzspUt8xI/AAAAAAAAC7M/oDukuU0kVdU/s1600/THANK-YOU-FOR-YOUR-TIME-1.png Graciñas!!
49. ¡¡Gracias por el feedback!! https://islomar.typeform.com/to/HchXmN