Efectos colaterales de TDD

El uso de TDD (desarrollo guiado por la pruebas) tiene varios efectos colaterales, a mi criterio, la mayoría de ellos positivos. Algunos de ellos son evidentes y ampliamente conocidos, pero algunos otros suelen pasar desapercibidos.

Uno de estos efectos colaterales las pruebas y el código de prueba pasan a ser ciudadanos de primera categoría. Esto es así porque el desarrollo arranca con las pruebas y eso hace que el código de las pruebas sea una herramienta central para pensar nuestro diseño. Antes de escribir una funcionalidad la vamos a estar describiendo en una prueba, eso concretamente implica que en la prueba escribiremos invocaciones a métodos y objetos que aún no hemos creado. Esto no ocurre cuando escribimos las pruebas a posteriori. El hecho de que las pruebas sean un ciudadano de primera categoría implica que el código de prueba debe ser tratado con el mismo cuidado que el código de producción, esto es: debe ser mantenible, cumplir las convenciones y sobre todo ser claro y evitar duplicaciones. Ojo, no es que al escribir las pruebas a posterior no debamos cumplir con esto, pero al hacer TDD estas propiedades del código de prueba toman mayor relevancia porque el código tiene un protagonismo distinto.

Al mismo tiempo, como no escribiremos código de producto sin tener primero una prueba, es común que la cantidad de pruebas sea mayor que si escribimos pruebas a posteriori (no tengo evidencias formales de esto, es más bien una sensación basada en lo que visto tanto con mis alumnos como con mis clientes). Cuantas más pruebas tenemos, más importante es la claridad y mantenibilidad del código de prueba. Curiosamente y un poco a contramano de esto, suele ocurrir que al agregar nuevos casos de prueba sobre una funcionalidad existente, muchas veces comenzamos “copy&pasteando” el código de prueba del caso anterior. Esto en principio genera código duplicado y ahí la importancia de hacer refactoring sobre el código de prueba. Personalmente me pasa que a partir de cierto punto, siento que hago mucho más refactoring sobre el código de prueba que sobre el código de producción. Más aún, cuando la aplicación alcanza cierto tamaño o grado de complejidad los refactorings sobre código de prueba llevan a generar clases/métodos “de soporte” por ejemplo para generar objetos/datos de prueba. En línea con esto me parece que no es casualidad que el libro de Gerard Meszaros tenga como subtítulo “Refactoring Test Code“. También los libros de Tarlinder y Freeman tienen capítulos dedicados al cuidado del código de prueba.

A propósito de este tema, el próximo jueves 12 de noviembre voy a estar dando una charla en la conferencia dotnetconf 2020 en la que compartiré algunas técnicas para mejorar la legibilidad de tests en C#: Enhancing Test Readability with Extension Methods and Fluent Interfaces.

Sobre mi taller de Git en Nerdearla 2020

Ante todo: ¡Zarpado evento Nerdearla 2020!

En este año de pandemia he participado de varias conferencias online pero ninguna estuvo ni cerca de Nerdearla, ni a nivel contenido, ni a nivel producción, ni a nivel interacción (y eso que Nerdearla aún no terminó). Simplemente mis felicitaciones al equipo organizador.

Ahora sí, el taller. En la sala de zoom había unas 40 personas que era el límite establecido, pero en paralelo la sesión fue transmitida por YouTube y por la página de la conferencia. Según me comentó uno de los organizadores llegó a haber más de 250 personas viendo la transmisión.

Al iniciar el taller hice dos preguntas a la audicencia en parte para validar algunas “creencias mias” y en parte para entender mejor a la audiencia. Para esto utilicé la herramienta mentimeter. En primer lugar les pregunte si habían utilizando alguna otra herramienta de versionado más allá de Git. Resultó que aproximadamente la mitad de los que contestaron solo habían trabajado con Git, en un palabra los podríamos calificar como “nativos git”.

Luego pregunté sobre la forma habitual de utilizar Git en el sentido de que qué tipo de herramienta utilizan. Resultó ser que la gran mayoría (~70%) indicó utilizar la terminal. Esto me sorprendió pues pensé que por la forma en que estaba anunciado el taller, me encontraría con mucha menos gente utilizando la consola y mucha más gente utiliza el IDE.

Personalmente me quedé muy conformé con el taller y hubo varios de los participantes que me manifestaron los mismo. Agradezco a todos los que participaron y también a Aixa por haberme asistido en la logística del taller.

Comparto algunos recursos:

Colaboración Universidad Pública y Estado: un potencial círculo virtuoso

El estado invierte en la universidad pública. Por su parte la universidad educa a los ciudadanos, hace investigación y genera conocimiento que ayuda a mejorar la sociedad. Esta mejora se traduce (indirectamente) en una mejora del estado y así se cierra un circulo virtuoso.

En el área de informática/computación/sistemas creo que se da una situación en la que este circulo virtuoso no resulta tan virtuoso, o al menos no todo lo virtuoso que podría resultar.

Más allá de mi trabajo en la universidad, llevo casi 20 años trabajando en la industria del software, he sido empleado de distintas empresas privadas y en los últimos años he trabajado de manera independiente. Nunca fui empleado de un organismo estatal (más allá de mi trabajo en la universidad) pero como empleado de una empresa privada he trabajado en proyectos de consultoría y capacitación para organismos estatales. Proyectos que perfectamente podría haber realizado una universidad. Al mismo tiempo tengo muchos colegas en situaciones análogas. Esto me ha disparado una pregunta recurrente: ¿porque está una empresa privada haciendo este proyecto y no una universidad pública?

Es aquí donde veo que el círculo virtuoso Estado-Universidad no es todo lo virtuoso que podría ser. Si los organismos estatales contrataran a universidades públicas, estas podrían tener más presupuesto, una cuestión siempre escasa en las universidades Argentinas. Al tener más presupuesto podrían hacer más investigación, o mejorar diversos aspectos de su operatoria y en un última instancia aportar más valor a la sociedad.

Intentando dar respuesta a la pregunta planteada comparto aquí algunas posibles respuestas que se cruzaron por mi cabeza:

  • La universidad no tiene el conocimiento para dar servicios a terceros. No lo creo. Si efectivamente fuera así, entonces tendríamos un problema muy grave. Pero sinceramente no lo creo. Muchos docentes universitarios del área de informática trabajan en la industria y enseñan en la universidad justamente lo que ponen en práctica en la industria (es mi propio caso y el de todo mi equipo docente).
  • La función de la universidad no es dar servicios a terceros. Falso, la universidad (al menos en Argentina) tiene 3 funciones: docencia, investigación y extensión. El prestar servicios a terceros es una actividad de transferencia que puede enmarcarse perfectamente dentro de actividades de investigación y/o extensión.
  • Las personas de la universidad que podrían brindar servicios a terceros prefieren hacerlo en forma privada que por medio de la universidad. Este sí puede ser un tema. Las diferencias salariales en el área de informática entre la universidad y lo que paga el sector privado pueden ser muy relevantes. Sin embargo, según he estado averiguando, hay alternativas que podrían habilitar que los docentes que trabajen en brindar servicios a terceros puedan recibir una remuneración equiparable a lo que podrían ganar desde el sector privado.

Ojo, con esto no estoy diciendo que la universidad tenga que convertirse en una software factory o en un proveedor de servicios de manpower vendiendo “programador por kilo”. Sino que los tipos de trabajos en los que imagino a la universidad, son trabajos de capacitación, consultoría o proyectos de desarrollo con un alto componente investigación/innovación.

Me consta que en algunos casos de algunas universidades y algunos organismos, esta colaboración fluye exitosamente, pero no es el caso común.

Creo que revertir esta situación requiere de un acuerdo de las 3 partes: las universidades, los organismo estatales y los docentes/profesionales.

Estoy bastante convencido de esta idea del círculo virtuoso de colaboración Estado-Universidad y es por ello que ya estoy gestionando para participar de un proyecto de colaboración entre la universidad y un organismo estatal durante el año próximo. Continuará…

#HistoriaDeTrinchera: Planning de una User Story

Recurrentemente hablo con gente que me comenta de sus dificultades para completar el trabajo planificado en la iteración. En muchos de esos casos mi sensación es que el equipo incluye funcionalidades en su iteración sin tener suficientemente en claro su implicancia. Creo que muchos se han ido del extremo de especificar cada detalle de la funcionalidad en un documento tipo especificación de casos de uso, a directamente pasar al otro extremo y escribir un título y nada más. Es por esto que quiero compartir en este artículo el ejercicio que intentamos hacer en mi proyecto actual a la hora de armar nuestro backlog de iteración determinando las funcionalidades que trabajaremos.

Una de las particularidades de nuestro proyecto es que como parte del equipo tenemos una especialista en diseño de experiencia usuario (digo particularidad pero me parece que esto es cada vez más común). A su vez esa especialista es en simultáneo parte de otro equipo que trabaja en forma transversal en el diseño de la experiencia de varios productos de la organización. Es así que las funcionalidades (que usualmente llamamos user stories) se piensan desde un momento muy temprano teniendo presente la experiencia que se quiere ofrecer al usuario. De esta forma, cuando hablamos sobre una funcionalidad en una reunión de planificación generalmente ya contamos con un diseño de pantalla (o tal vez varias) que acompañan la conversación.

De la conversación sobre la user story buscamos esclarecer los siguientes puntos para poder agregarla al backlog de la iteración:

  • El escenario principal de uso y alguno de los escenarios alternativos más importantes. De ser posible, y si la complejidad lo amerita, ahi mismo expresamos estos escenarios en sintaxis Gherkin.
  • Las tareas necesarias para completar la story como ser: codear la pantalla, codear un nuevo servicio, codear componente para conectar con otro sistema, generar los datos de prueba, automatizar la prueba end-2-end, etc, etc
  • La dependencias de otras aplicaciones/apis y estados de las mismas (esa API que debemos consumir ¿ya está disponible en producción? ¿la está consumiendo algún otro equipo?)
  • La necesidad (o no) de hacer que la funcionalidad sea “apagable” o “segmentable”. Hay funcionalidades que son simples y de baja criticidad que apenas las terminamos pueden ser liberadas al público en general, pero hay otras que, ya sea por su complejidad o criticidad, se prefiere liberarlas gradualmente a distintos grupos de usuarios. En términos técnicos pretendemos identificar si la funcionalidad debe ser “toogleable”.

A medida que vamos viendo cada una estas cuestiones vamos tomando conciencia del tamaño y la complejidad de la funcionalidad y puede que en base a ello decidamos partir la funcionalidad en varios cortes (lo que comúnmente se conoce como slicing).

En algunos casos parte de estas cuestiones se hablan en una reunión de refinamiento que ocure previamente a la planning. A su vez dicha reunión nos permite identificar potenciales blockers para el desarrollo de alguna funcionalidad pedida. En algunos casos también ocurre que la funcionalidad pedida depende de funcionalidades provistas por alguna API desarrollada por otro equipo y que no se encuentra disponible aún o tal vez no provee todo lo que necesitamos. En estos casos en lugar agregar la funcionalidad en cuestión a nuestra iteración, agregamos una tarea de gestión para darle seguimiento a al desarrollo de esa API e incluso hacer algún prueba de concepto como para ir familiarizándonos.

Dos datos adicionales de contexto:

  • En las reuniones de refinamiento no participa necesariamente todo el equipo. Seguro están los especialistas de negocio, la especialista en UX, el facilitador y algunos devs. En general esta reunión dura 1 hora.
  • Las reuniones de planificación tiene 2 partes: una estratégica donde participa todo el equipo y una táctica donde solo participan los técnicos (devs & testers). Entre ambas se van entre 2 y 3 horas.

A partir de lo anterior resulta que para planificar una iteración de 2 semanas este el equipo requiere en total de unas 4 horas de trabajo conjunto.

Algunas de estas cuestiones puede que no coincidan exactamente con lo que recomiendan algunos libros y posiblemente a algunos lectores puede que le resulten impracticables en su propio contexto y lo entiendo. No es mi intención convencer a nadie de trabajar de esta de esta forma, simplemente pretendo compartir lo que a nosotros nos viene funcionando y nos permite entregar software todas las semanas.

Sobre nuestra dinámica de aula invertida

En las dos materias que dicto (UBA y UNTreF) utilizamos la misma dinámica de clases. la cual está basada en una estrategia de aula invertida con técnicas de educación centrada en el alumno y evaluación constante. Más allá de las definiciones formales, y en términos concretos, esto implica que cada tema que estudiamos en la materia consta de tres instancias: estudio, aplicación y evaluación.

Aclaración: en las siguiente secciones cuando digo aula me refiero al tiempo/espacio compartido sincrónicamente entre alumno y docente en forma semanal

1. Estudio

Ocurre fuera del aula, el alumno debe sentarse a estudiar, típicamente viendo uno o varios videos o leyendo un texto. Esto reemplaza la típica clase magistral donde el docente expone pasando diapositivas. Es justamente este tipo de clases las que convertimos en videos y que los alumnos consumen fuera del aula.

2. Aplicación

Esto ocurre dentro del aula y puede tomar distintas formas dependiendo del tema en particular, pero siempre intentamos que sea una actividad interactiva. Puede que sea una sesión de mob-progamming o alguna actividad de simulación (como el Pizza Game) utilizando alguna herramienta de soporte como Miro, Mentimeter, Kahoot o similares.

3. Evaluación

La evaluación ocurre también fuera del aula y dependiendo del tema puede ser un ejercicio de programación y/o un cuestionario.

De esta forma cada tema es estudiado y evaluado individualmente. Luego complementariamente tenemos dos trabajos integradores donde los alumnos trabajan en equipos y ponen en práctica todos los temas ya estudiados de forma integrada.