Mostrando entradas con la etiqueta agile. Mostrar todas las entradas
Mostrando entradas con la etiqueta agile. Mostrar todas las entradas

martes, 25 de julio de 2017

DevOps en Startups

Recientemente participé en la transición de una startup, que está yendo más allá de las pruebas de conceptos y de los pilotos hacia un negocio autosustentable. Comparto lo que aprendimos.
¿DevOps es distinto en Startups?
El movimiento DevOps busca derribar las paredes entre las áreas de las empresas, para lograr que las soluciones se construyan incluyendo el aporte de todos los involucrados. Esto permite disminuir el tiempo que toma pasar de la idea al producto, lo que a su vez permite aprender y ajustar el rumbo con mayor velocidad.
En las Startups,  por el contexto riesgoso y desconocido, es necesario aprender y ajustar el rumbo con velocidad. ¡Bingo! El objetivo de DevOps y las necesidades de las Startups coinciden.
Por otro lado, el foco inicial de las Startups es descubrir el producto y el mercado. Hay relativamente pocos usuarios y el mayor riesgo es hacer el producto incorrecto. Al inicio se pone menos atención a la operación.
Como reflejo de esto, en muchas Startups no hay un área de Operaciones separada. Y si la hay, hubo mucho menos tiempo de levantar muros entre esta y el área de Desarrollo.
Entonces, ¿cuál es el desafío?

El desafío de DevOps en Startups

Inicialmente validamos con pocos usarios que el producto genera valor. Luego la prioridad pasa a ser hacerlo disponible para muchas personas. Buscamos incorporar los atributos necesarios para seguir creciendo (por ejemplo: escabilidad, confiabilidad, que sea operable y tenga soporte) afectando poco en la velocidad del equipo. Queremos mantener al equipo en el centro de la acción, incorpore los conocimientos y responsabilidad de Operaciones.
Algunos de los análisis sobre DevOps (como The Phoenix Project o el Continuous Delivery Maturity Model) asumen que la organización ya tiene un área de Operaciones funcionado.
El desafío es encontrar un camino de evolución para que el equipo incorpore responsabilidades y actividades de Operaciones sin desatender la mejora del producto.
Estos son algunos de los riesgos en ese camino:
  • Que el esfuerzo de incorporar conocimientos y prácticas de operaciones le quite foco al equipo y no se pueda seguir con el ritmo de innovación.
  • Que el equipo vea las actividades de operaciones o soporte como aburridas. Esto bajaría la motivación del equipo.
  • Que no se incorporen buenas prácticas de operaciones. Esto bajaría la calidad de la experiencia del usuario.
¿Cómo lo hacemos?

¿Qué es Operación en IT?

Cuando hablamos de que el equipo incorpore responsabilidades y actividades de Operaciones, ¿lo tenemos que hacer como un todo o podemos dividirlo?
Intentaremos una posible división en roles, que nos permita incorporar el conocimiento incrementalmente al equipo o buscar soluciones alternativas:
  • Soporte de Operaración: Mantener la aplicación funcionando, lo que incluye entre otras cosas estar al tanto de los consumos de recursos para realizar escalamiento (según políticas preestablecidas), responder a incidentes como por ejemplo servicios caídos, realizar provisioning de ambientes, instalar versiones, realizar copias de resguardo.
  • Ingeniería de Operaciones: Anticiparse a los problemas relacionados con el software de base y infraestructura (red, almacenamiento, procesamiento), estando al tanto de las actualizaciones de seguridad, versiones de software que dejan de estar soportadas, manejo de licencias.
  • Arquitectura: Colaborar con el equipo en el diseño de la aplicación, incluyendo consideraciones sobre la forma de despliegue, radar de tecnologías, buenas prácticas para lograr los atributos de calidad buscados (como seguridad, escalabilidad, confiabilidad, etc.).
Conviene recordar que sobre esto hay mucho análisis, reflejado en ITIL. Hay mucho para reutilizar si mantenemos la visión de simplicidad que tiene la agilidad. Por ejemplo, en muchas Startups, es necesario implementar manejo de Incidentes y Resolución de problemas. Estos procesos pueden implementarse siguiendo las buenas prácticas de ITIL.

Alternativas

Pensamos algunas alternativas de solución, cada una con sus pros y contras:
  • Manejarlo con el equipo actual.
  • Incorporar personas en el equipo (permanente o temporal) con experiencia en Operaciones.
  • Aumentar temporalmente la capacidad del equipo.
  • Tercerizar el servicio
  • Delegar al usuario
  • Automatizar las actividades de operaciones.
Para decidir deberíamos analizar el caso concreto, y experimentar distintas alternativas para resolver los problemas en orden de prioridad.

Caso Ejemplo

El caso es una startup que tuvo éxito con un piloto y va a empezar a vender el servicio, lo que implica mantener un SLA (Service Level Agreement o Acuerdo de Nivel de Servicio) en cuanto a disponibilidad, resguardo de datos y escalabilidad ante la incorporación de nuevos clientes.
Con personas sumadas en forma temporal al equipo, se evaluó y decidió modificar la arquitectura de despliegue, para pasar de máquinas virtuales a servicios en la nube (Amazon Web Services). El estado del ejemplo al momento de este reporte, solo una foto dentro de la evolución:
  • Parte de la Soporte de Operación se mantuvo dentro del equipo, con herramientas de monitoreo provistas por la plataforma. Se mantuvo y extendió la automatización de la instalación.
  • Parte de los actividades de Soporte de Operación e Ingeniería de Operaciones fueron delegadas a la plataforma: Actualización de versiones y seguridad, parte de los mecanismos de alta disponibilidad y escalamiento.
  • Arquitectura: Se detectó una oportunidad de mejora, que se realizaría conjuntamente entre miembros del equipo y las personas sumadas al equipo en forma temporal.

Conclusión

En las empresas establecidas, el conocimiento sobre cómo Operar existe, pero está en áreas separadas. El desafío en la transición hacia DevOps es derribar las barreras internas entre áreas y compartir ese conocimiento. Además, las formas de desarrollo deben adaptarse, como por ejemplo automatizar builds y pruebas.
En las Startups la dificultad está en incorporar la Operación de manera incremental, profesional y sostenible a la empresa y al equipo (en una Startup son prácticamente lo mismo).

miércoles, 15 de abril de 2015

Arquitectura de la prueba automatizada



La automatización de la prueba de software es un tipo particular de sistema de software, a veces llamado framework de prueba o stack de prueba.
Como cualquier sistema de software, tiene una arquitectura que puede facilitar o no la extensión, reuso y modificación. 
Arquitectura del Sistema de pruebas automáticas

Una arquitectura compartida

Algunas familias de herramientas de prueba (como Mercury, Rational, Silk y TestComplete) están pensadas para resolver toda la problemática de la prueba y tienen la arquitectura definida por el fabricante.
En otros casos (como Selenium, FitNesse, Cucumber y RobotFramework) las herramientas resuelven sólo algunos de los aspectos de la prueba. Suelen usarse combinadas con otras herramientas.
Una discusión que dejo pendiente es la correlación entre los atributos de las arquitecturas (extensión, reuso y modificación) y el origen de las herramientas: propietarias o FLOSS.

Planteo entonces por mi cuenta una arquitectura que describe muchos de los stack de prueba que conozco. 
Esta arquitectura está en movimiento aún. Hace un año aproximadamente incorporé el componente Comparator por conversaciones con Nicolás Páez (él plantea un modelo ligeramente distinto parte 1/parte 2). En enero de este año, cuando estaba explicando la arquitectura, me surgió la necesidad de agregar el Editor.
Y aún tengo dudas sobre la utilidad de separar algunos componentes, como por ejemplo tener componentes separados para reflejar el mecanismo de extender el DSL, tanto del lado del Test Case como del Interpreter.

Para qué buscar una arquitectura compartida

Identificar una arquitectura común de las herramientas de prueba permitiría simplificar las interfaces y que cada producto tenga foco en su especialidad, sabiendo que otros productos se ocuparán de las restantes áreas. Esperaba que el programa de la Agile Alliance "Agile Alliance Functional Testing Tools" lograra este consenso. No encuentro que se haya publicado ese análisis, aunque hay otros temas interesantes (20082012).

Es también útil tener un lenguaje común para poder discutir stacks alternativos cuando se está diseñando una solución de prueba.  

Los componentes

Por cada componente, describo brevemente el alcance del mismo y algunos ejemplos de su instanciación en herramientas existentes.
  • Editor: cómo creo y edito mis casos de prueba. En ocasiones una herramienta ad hoc, en otros casos una herramienta genérica.
    Selenium: Selenium IDE, permite grabar acciones desde la aplicación o editar los TC.
    WebDriver: editor/IDE del lenguaje de programación usado. 

    RobotFramework: RIDE, permite editar TC en forma 'inteligente', o editores de HTML. 
    FIT: Word, Excel y editores de HTML. 
    FitNesse: wiki. 
    Cucumber: cualquier editor de texto.
  • Test Case (TC): Repositorio de mis casos de prueba, con o sin estructura y con un lenguaje con el que escribo mis casos de prueba. Puede incorporar la posibilidad de definir términos nuevos que abstraigan complejidad.
    Selenium IDE: Los casos de prueba se escriben con Selenese, básicamente un HTML con una tabla de tres columnas. La estructura de casos está dada por las suite, que es una tabla HTML con los casos.
    WebDriver: No tiene forma nativa de representar los casos de prueba o la estructura. Debe usarse un Runner de otra herramienta y sintaxis de lenguaje de programación usado. Extensión usando el lenguaje de programación.
    RobotFramework: HTML (tablas), TSV, reST. Permiten extender el DSL de prueba con user keywords.

    FitNesse: wiki markup languaje (tablas). Permiten extender el DSL de prueba con Scenario.
    Cucumber: Gherkin y permiten extender el DSL de prueba con Scenario Outlines.
  • Interpreter: interprete del lenguaje de TC, incluyendo mecanismos para definir o extender un DSL.
    Selenium: plugin de Firefox, y se extiende con plugins adicionales.
    WebDriver: la parte correspondiente a WebDriver es interpretada o compilada por el lenguaje en el que se escribieron los TC (Java, Ruby, Python, etc), y resuelto con la API provista por la biblioteca de Selenium.
    RobotFramework: interprete del lenguaje propio (test data syntax), se extiende con  
    library keywords.
    FitNesse: interprete de HTML (modo compatibilidad con FIT) a través de una conversión interna entre wiki text y HTML, o directamente wiki text en el caso de SLIM. Extensión usando Fixture.
    Cucumber: interprete de Gherkin más los steps creados.
  • Adapter: cero, uno o más capas de adaptación entre los TC interpretados y el sistema bajo prueba (System Under Test o SUT). La forma de conexión depende del tipo de prueba que se quiere hacer, por ejemplo conexión con: interfaz usuario, API REST, u objetos de la aplicación.
    SUT Web: un ejemplo sería WebDriver usado para automatizar la aplicación a través de la interfaz web, más PhantonJs para simular un browser.
    SUT Desktop: un ejempo es Abbot para pruebas de Java Swing o White para pruebas GUI sobre Windows usando UIAutomation.
  • Comparator: el mecanismo de comparación entre resultados esperados y los resultados reales. El comparador puede tener conocimiento semántico y sintáctico sobre el resultado (Output) del SUT, para poder hacer comparaciones más significativas y concisas. En este sentido puede estar ligado a los adapters. En otras casos está implementado en el Interpreter. Y también puede ser extendido.
    Cucumber: la base de los comparadores corresponde a las expectations de RSpec, pero se enriquecer, por ejemplo con los Capybara Matchers.
    Fitnesse: una de las diferencias entre el Interprete FIT y SLIM es los comparadores adicionales (rangos, aproximados, mayor o menor). Adicionalmente, en SLIM se pueden enriquecer con Custom Comparators.
  • Runner: permite correr los TC. Pueden permitir ejecutar TC secuencialmente o en paralelo; todos los TC, o algún subconjunto (los que tienen cierta marca o tag, los que han fallado, etc), o uno solo TC; indicar dependencias entre TC.
    Los Runner también tiene mecanismos para indicar cuando un TC ejecutado ha sido exitoso o no y  mecanismos de preparación y limpieza de las pruebas. Invocan a la generación de reportes.
    Cucumber: se invoca por linea de comando y puede usarse el runner de JUnit (con cucumber-JVM)
    FitNesse: se puede ejecutar las pruebas desde la wiki, por linea de comandos, por servicios REST y puede usarse el runner de JUnit.
  • Reporter: crea los reportes de seguimiento de los resultados de la prueba. Distintos usuarios del sistema de pruebas requieren distintos reportes: resumen al momento, evolución temporal, detalle de casos ejecutados, etc. Es este área el formato XML de JUnit es el standard de facto. Aunque varias herramientas tienen alternativas: sólo texto o HMTL. Además, se incorporan a otras herramientas para brindar visibilidad, como Jenkins o SonarQube.

Conclusiones

Los equipos de desarrollo de software pueden diseñar su sistema de pruebas automáticas en forma iterativa e incremental, de igual manera a como se desarrolla el producto. Se empieza por la forma más sencilla y se mejora cuando es necesario.

Espero que este modelo te ayude a evaluar alternativas y decidir que cambiar en cada ciclo de mejora.

miércoles, 5 de marzo de 2014

Reunión Agile Peru en Lima el 27 de Febrero

Aprovechando mi estadía en Lima, el jueves pasado fui a la reunión mensual de Agile Perú. Nos reunimos en Avantica, que prestaron la sala y proporcionaron bebida.

Se presentaron temas y luego se votó, en un estilo Open Space. Iniciamos unas 15 personas y hubo unas 25 personas en total. Había un par de personas nuevas en agilidad, y personas con mucha experiencia. Se planteó hacer dos tracks, uno introductorio, pero finalmente se unificó en una sola ronda


Hubo tiempo para 4 temas, y podes ver todas las fotos en el album. Además, facilité gráficamente las charlas.

Mejores prácticas de Estimación

¡Sería mejor hablar de buenas prácticas, no de mejores!
Se partió de la pregunta frecuente del tipo: "como hago para estimar agile mejor que como lo hago ahora". Esto lleva a entender que si hacemos lo mismo que antes no podemos mejorar la estimación, y de ahí pasamos a entrega incremental, formatos alternativos de contratos, confianza, negociación win-win,  y alternativas para estimar al inicio de un proyecto con un equipo nuevo.
   

¿Cómo manejar proyectos llave en mano?

Casualmente (o no tanto :D) la conversación derivó naturalmente en el siguiente tema. ¿Cómo manejamos proyectos llave en mano?
A su vez, la pregunta fue cambiando a "cómo convencemos a nuestros clientes que entrega incremental y colaboración es mejor él? 

¡El rol de Product Owner es una gran mentira!

Esta fue una sesión propuesta por mí. Plantee una discusión, en cuanto a la utilidad y aplicabilidad del rol de Product Owner, usando 3 casos en los que creo que no aplica (Organización de conferencias, Pproducto masivo, Open source), y tres hipótesis que no siempre son ciertas (Product Owner como priorizador de necesidades, Capacidad fija del equipo, Software funcionando como medida del éxito).


Técnicas Retrospectivas (Motivar participación)

Un par de personas expusieron la situación del proyecto en el que estaban (distribuido, largo) y nos dieron una excelente oportunidad para hablar sobre las características de las retrospectivas efectivas, como identificarlas y fomentarlas.



Cierre
Por lo que comentaban, fue una buena reunión. La comunidad limeña viene de un año en el que las reuniones giraban en torno a organización de eventos (sobre todo Ágiles 2014, que exigió mucho trabajo). Y ahora disfrutan de las reuniones de intercambio de ideas y experiencias. La organización es super liviana: El lugar y las bebidas ofrecidos por una empresa, las charlas se definen en el momento. 

Les dejo el link al albúm de fotos

lunes, 21 de mayo de 2012

Sobre Retrospectivas

Les paso una lista de recursos sobre retrospectivas, que por supuesto no leí, salvo un par.

Video

Libros

via Michael James
via Pierre Fauvel
via Bas Vodde
via Jean-Charles Meyrignac

via Hubert Smits
via Diane Larsen
via Josef Scherer 

via Ilja Preuss

miércoles, 28 de marzo de 2012

Intro al desarrollo ágil

Hace un tiempo armamos con Ricardo Colusso una introducción breve al desarrollo ágil de software. 
El objetivo es tener material de lectura suplementario a un curso, ya que nuestros cursos tienden cada vez más ppt-less, siguiendo las ideas de Training from the back of the room. La intensión es ser un primer paso, con links para seguir el aprendizaje. No una enciclopedia.
Dudamos entre hacerlo en formato de pequeño libro con copyright, luego decidimos hacerlo con CreativeCommons, y lo implementamos en knol.
Knol fue el intento de Google de contrarestar Wikipedia, permitiendo que queden indicados los autores de los artículos vs editores anónimos. No funcionó. Siguiendo la política de fail fast, lo discontinuaron, ofreciendo la posibilidad de mudar los knol a mano (pueden ver el mío de testing aquí), o a Wordpress, donde pueden acceder a Desarrollo ágil de Software.
A los que les sirva este pequeño texto, comenten para que lo mejoremos.

miércoles, 15 de febrero de 2012

Prueba de Software

Introducción a la prueba del software, sus objetivos, técnicas y relación con otras actividades del desarrollo de software.

¿Dónde estamos?

Antes de tratar la prueba de software, me parece necesario que acordemos que entendemos por software, como se construye, que entendemos por calidad del mismo y cual es nuestro contexto organizativo.

¿Qué es el software y cómo lo desarrollamos?

Software es el conjunto de instrucciones que controlan el funcionamiento de computadoras con programa almacenado. Antes, la funcionalidad estaba definida por engranajes o conexiones eléctricas. A partir del desarrollo de las computadoras con programas almacenados en la década de 1940 se pudo cambiar comportamiento de las mismas con sólo modificar el contenido de las memorias. Inicialmente el desarrollo de software se consideraba parte del desarrollo de la computadora, que correspondia a matemáticos, físicos, ingenieros eléctricos y electrónicos.
Con el pasar del tiempo, la complejidad del software creció hasta que empezó a ser complejo y costoso de desarrollar. Siendo una actividad joven, para entenderla y analizarla se intenta asimilar a otras actividades más maduras. A fines de la década de 1960 se empieza a llamar Ingeniería de Software a la disciplina. Se intentaba tomar, a partir de la analogía con las ingenierías, ideas para mejorar el desarrollo de software. Esta no es la única analogía que se ha utilizado para entender el desarrollo de software.

Analogías

Se han propuesto varias analogías, según las cuales el software es parecido a: la publicación de investigación académica, el resultado de un trabajo en equipo (música, teatro, cirugía, deportes, SWAT), un proceso de producción (línea de montaje), una creación artística (literatura). Las analogías pueden ser útiles, ya que nos permiten reusar el conocimiento e ideas de otras áreas, pero por otro lado nos pueden engañar, ya que nos enfocamos a las características comunes, minimizando las diferencias.
Planteo un muy breve resumen de las analogías, sólo para que luego lo usemos al discutir la visión de la calidad en el software.
  • Publicación de investigación académica: este es el modelo que origina el movimiento de software libre, según lo descripto por Richard Stallman [GNU]. En la investigación, todo resultado publicado es utilizable por otros, siempre que se cite la fuente. Esta analogía lleva a visión de la construcción del software como una continua mejora y extensión del trabajo de otros, y expuesto al escrutinio de cualquiera que le interese.
  • Música y teatro: el producto es una construcción colectiva y, aunque se base en un texto (partitura, obra de teatro), la interpretación produce un producto nuevo, cada función de teatro o cada recital es distinto. Se puede pensar que el equipo es en si mismo un producto del proceso de desarrollo [AustinLevin]. Esta analogía hace foco en la innovación, el espacio para la experimentación sin miedo al 'error'.
  • Deportes: la dinámica de los equipos deportivos y la motivación, en algunos aspectos similares a los de música y teatro, se asimila a los equipos de desarrollo de software. Aparecen la noción de entrenador (coach). Tiene en contra que la mayoría de los deportes son juegos competitivos, y el desarrollo de software no suele serlo [Cockburn].
  • S.W.A.T. / Cirugía: equipos con mucho entrenamiento, roles en general definidos, y objetivos claros y urgentes [Brooks], en el caso del equipo de cirugía, hay un rol de liderazgo muy fuerte. Se asemejan a los equipos de operaciones y mantenimiento de IT, aunque en el libro se utiliza como metáfora del desarrollo de software.
  • Proceso Manufactura: en la búsqueda de modelos exitosos, se toma la línea de montaje (tanto tradicional o taylorista como Lean Manufacturing[LarmanVodde]). ¿Cómo lograr que el desarrollo de software hacerse de esa manera? Tenemos que separar la parte creativa y novedosa, para que podamos optimizar la construcción.
  • Literatura: el software como una forma de comunicarse entre personas [Knulth] o las similitudes entre el proceso creativo de la escritura y el desarrollo de software.[Nachmanovitch]
  • Diseño de nuevos productos: el software diseñando como producto de consumo masivo, con la particularidad que tiene costo de duplicación prácticamente nulo (no tiene producción en el sentido de los bienen físicos) [TakeuchiNonaka].

Características y producto completo

El software se suele describir como intangible y maleable. Tiene costo de duplicación y distribución cercano a cero.
Sin embargo, el software es normalmente parte de un producto o servicio que incluye otras cosas.
Los casos obvios son los productos con software embebido, como celulares, lavarropas, aviones, etc.
Pero aún los productos que parecen ser exclusivamente software, para el usuario incluyen manuales, soporte posventa, capacitaciones , comunidad y otras aplicaciones que se relacionan, todo lo que llamamos el producto completo (Whole product [Moore]).
Si consideramos el producto completo, puede tener diferentes características. Por ejemplo, los cambios de VisualBasic 6 a VisualBasic.Net, de Python 2 a Python 3, o de IP4 a IP6 fueron mejoras en el software que tardaron en reflejarse en el producto completo: comunidad, desarrollo de terceros.

La calidad del software

Dependiendo de como entendamos el desarrollo de software (ver Analogías), se proponen distintas definiciones de la calidad, por ejemplo:
  • Cumplimiento de requerimientos: Se consideran los requerimientos implícitos y explícitos. Aplicado cuando se ve el desarrollo de software como un proceso de manufactura.
  • Apropiado al uso: ¿puede el usuario utilizar el producto en su entorno habitual? No cumplir con los requerimientos sin considerar la realidad. Los requerimientos en si mismos son vistos como parte del proceso de desarrollo, por lo que deberán ajustares si comprobamos que el producto por alguna razón no puede ser usado en el entorno del usuario.
  • Satisfacción del usuario: aunque es aplicable en cualquier caso, es muy usado la visión 'artística' del desarrollo del software (Literatura, Música y Teatro).

Los contextos de la prueba

La prueba está afectada por el contexto [Gabardini]. Las perspectivas que podemos utilizar para evaluar el contexto:
  • Impacto de los errores en el usuario final: afectamos muchas vidas humanas (ej. aviación), una vida (ej. radioterapia), grandes montos de dinero (ej. homebanking), montos de dinero menores, inconvenientes (ej. sistema de seguimiento de incidentes), diversión (ej. juegos).
  • Cultura de la organización: hay varias clasificaciones de cultura, por ejemplo [Schneider] Colaboración, Control, Competencia, Cultivo.
  • Objetivos: ¿cuándo se considera exitosa la prueba?. Métricas de algunos objetivos posibles son detectar defectos para corregirlos y mejorar la calidad, o sólo medir la calidad.
  • Metodología de desarrollo: Cascada, Iterativa Incremental, Ágil [ColussoGabardini].

QA, QC y Testing

Quality Assurance (Aseguramiento de la Calidad): ¿Cumplimos con los procesos que tenemos definidos? Los procesos definidos es la mejor manera que tenemos de hoy de hacer las cosas. Si no los seguimos, ¿por qué es?
Rol de QA: Dependiendo del estilo de las personas que lo realizan y de la forma en que se definen los procesos (por el equipo o desde fuera del equipo), puede ser visto como un rol policial o como un soporte al equipo. Está muy arraigado en el mercado como la cumbre del plan de carrera de alguien que trabaja en calidad de software. Es un rol que no es muy importante en los entornos de desarrollo ágil, ya que los procesos son definidos por los equipos, y son los equipos los principales interesados en cumplirlos. En estos entornos puede mantenerse la sigla (QA) debido al arraigo en el mercado, aunque con un sentido cambiado (Quality Assistant - Asistente de la Calidad) para enfatizar que los responsables de calidad son todos los miembros del equipo.
Quality Control (Control de Calidad): pruebas realizadas sobre el producto para determinar si cumple con los criterios definidos de aceptación. Aplicable en principio al producto terminado, aunque se extiende a productos intermedios.
Testing (Prueba): cualquier actividad de prueba del producto, en cualquier momento de su desarrollo. Por ejemplo se puede hacer las pruebas antes de construir el producto (TDD), haciendo que la calidad esté en el producto por construcción, algo que no es QC.
La diferencia entre QA y QC/Testing es que QA es sobre los procesos y QC/Testing sobre el producto.

Conceptos y terminología

Diseño y organización

  • Condiciones de prueba (Test condition): un atributo, característica o área de riesgo que se quiere probar. Se pueden encontrar como listas (checklist) de problemas comunes, o partiendo de los requerimientos. Por ejemplo: probar valores límites, en enteros uno antes del límite, el límite y uno después del límite, en el caso de dinero, diferencias de un centavo.
  • Casos de prueba (Test case): una descripción de una prueba particular (ejemplo). Contiene las pre-condiciones, los pasos a seguir y datos de entrada utilizados, y el resultado esperado (y postcondiciones). Varios casos de prueba pueden corresponder a una condición de prueba.
  • Grupo de pruebas (Ciclo de prueba o Test suite): agrupamiento de los casos de prueba según cierta característica que me permite organizar el diseño, la ejecución y reporte. Un caso de prueba puede estar en varios Grupos de Prueba. Por ejemplo, la prueba  de límites en la extracción de cuenta puede estar en el Grupo de pruebas de caja de ahorro, y en el Grupo de pruebas de regresión general.
  • Regresión: es la aparición de defectos en funcionalidad que ya había sido probada y estaba libre de errores. En el sentido más estricto se refiere a la reaparición de defectos que habían sido corregidos, pero se usa también, en un sentido más laxo, a la aparición de nuevos defectos en código ya probado.
  • Pruebas de regresión (Regression test): es la prueba orientada a encontrar regresiones. Las pruebas de regresión difieren de otras pruebas en que no esperan encontrar defectos, su tamaño se relaciona con el tamaño y complejidad total del producto (no del tamaño del último cambio hecho) por lo que son contínuamente crecientes (ver Código legado).
  • Particiones y clases de equivalencia: considerando la cobertura de entradas o de salidas, dado que las variables (parámetros o resultados) pueden tener gran cantidad de valores posibles, se acota la prueba identificando conjuntos de valores para los que el programa se comporta de la misma manera. Estos conjuntos se llaman clases de equivalencia, y se definen de manera de tener el espacio de valores de entrada y salida particionado. Se llama partición a una división que es completa (no queda nada sin probar) y sin superposiciones (no se prueba nada dos veces).

Resultados de la prueba

  • Bugs: algo anduvo mal en un software. No es un termino muy preciso, y puede tener alguno de los siguientes tres sentidos.
  • Falla: una situación en la que la aplicación exhibe un comportamiento no deseado. Ejemplo: al ingresar un par de valores, la aplicación termina con un mensaje de división por cero.
  • Defecto: comportamiento no deseado en la aplicación. Es la descripción de una clase de fallos. Ejemplo: en el caso anterior, luego de analizar los fallos descubrimos que la aplicación falla siempre que el par de valores que ingresamos sean iguales, ya que usa la diferencia entre los valores como denominador.
  • Error: la causa por la cual la aplicación tiene un comportamiento no deseado. Ejemplo: en el caso anterior no se está detectando que al tener el mismo valor habrá una división por cero. 

Calidad de la prueba

  • Cobertura: es una métrica sobre el grado de prueba que ha tenido el producto. Por ejemplo, una cobertura de lineas de código del 80% indica que un 20% de las líneas de código no han sido ejecutadas nunca durante la ejecución de los casos de prueba. Hay varios tipos de cobertura: de requerimientos, de código (que a su vez pueden ser de lineas, expresiones, camino y otros), de entradas, de salidas, de riesgos.
  • Código heredado o legado (Legacy code): código que es difícil de mantener y evolucionar. Desde el punto de vista de la prueba, una razón que define un código como legado es que las pruebas de regresión no estén automatizadas. Esto hace que las pruebas de regresión sean muy costosas (manuales) y esto lleva a que se desee minimizar los cambios, para realizar pocas pruebas y/o que las pruebas se realicen espaciadas en el tiempo, con lo que las regresiones quedan sin detectar durante mucho tiempo.
  • Eficiencia de la prueba: resultados obtenidos del esfuerzo dedicado a la prueba el producto, por ejemplo cuantas horas de prueba son necesarias para detectar y reportar un defecto.
  • Eficacia de la prueba: ¿se cumple el objetivo de la prueba?. Por ejemplo, porcentaje de defectos detectados vs defectos existentes.
  • Criterios de calidad de la prueba: ¿la prueba que estamos haciendo es buena? Algunas métricas que miden la calidad de la prueba son: porcentaje de detección de defectos (mutation testing), porcentajes de cobertura, tiempo de prueba para la detección de un defecto (esta métrica por sí sola no discrimina entre la eficiencia y efectividad de la prueba), cantidad de defectos detectados en producción (mide la calidad del proceso completo de desarrollo, indirectamente la calidad de las pruebas).

Modelos

Modelo V (V-Model): es la visualización del proceso de desarrollo de software entendido como una serie de traducciones desde el concepto hasta el código en la línea descendiente de la V, y la serie de pruebas correspondientes hasta la aceptación del producto por el usuario en la rama ascendente. Se puede interpretar como una secuencia temporal, y estaríamos en un proceso en cascada (waterfall, o como una clasificación de las actividades, que pueden ser hechas en diferentes momento del proyecto. La actividades son:
  • Requerimientos: obtener los requerimientos de los usuarios y otros involucrados, modelizar conceptualmente el negocio
  • Arquitectura: diseño de alto nivel, incluyendo decisiones de estructura, comportamiento, modularización y estilos.
  • Diseño detallado: diseño de componentes, sus interfaces y semántica.
  • Programación: programar cada uno de los componentes de la aplicación.
  • Prueba unitaria: validar que los componentes cumplan con los diseños detallados
  • Prueba de Integración: validar que los componentes se integren correctamente y presenten las características arquitecturales deseadas.
  • Prueba de Sistema: validar que el sistema cumpla con los requerimientos.
  • Prueba de Aceptación: validar que el producto sea aceptado por el usuario.
Matriz de la Prueba Ágil (Agile Testing Matrix o Cuadrantes de Brian Marick): esta matriz tiene dos dimensiones, cada una con dos valores, lo que da lugar a 4 clases de prueba. Esta clasificación es útil para planificar las pruebas y se usa en equipos de desarrollo ágil [CrispinGregory]. Las dimensiones son lenguaje (Tecnología, Negocio) y beneficiado (equipo, producto). No implica orden de importancia ni temporal:
  • Primer cuadrante (tecnogía y soporte al equipo): pruebas unitarias y de componentes, usualmente escritos en el mismo lenguaje que el programa. Tienen por objetivo servir de red de seguridad para el equipo, permiten desarrollar con la confianza que el programa cumple con el diseño, para ver si hacemos bien el producto. El diseño está descripto por las pruebas.
  • Segundo cuadrante (negocio y soporte al equipo): ejemplos, pruebas funcionales, story test (pruebas de la historias de usuario), prototipos y simulaciones. Están escritos en el lenguaje de negocio, deben ser entendidos (y a veces hechos) por los usuarios. Es una red de seguridad para ver que estamos haciendo el producto correcto.
  • Tercer cuadrante (negocio y mejora al producto): pruebas exploratorias, escenarios, pruebas de usabilidad, pruebas de aceptación, procesos de pruebas Alpha y Beta. Permite detectar mejoras al producto, y tomar la decisión sobre si el producto está listo para pasar a producción.
  • Cuarto cuadrante (tecnología y mejora al producto): pruebas de rendimiento, carga, estrés, seguridad (pruebas ...ility). Permite detectar mejoras para el producto, requieren herramientas y profundo conocimiento técnico de todas las tecnologías involucradas y las formas de uso del producto.

¿Cuándo probamos?

La detección de defectos en forma tardía tiene varios efectos negativos: se pierde la oportunidad de aprender del error y por lo tanto se repite; se desarrolla alrededor de los errores, por lo que luego se hace más difícil corregir; y la acumulación de defectos dificulta poner foco en lo importante.

¿Cómo probamos?

Actividades

El testing se puede dividir en distintas actividades. Estas actividades pueden ser hechas secuencialmente o en paralelo, por roles específicos o distribuidas en todo el equipo.
  • Plan: decidir qué se va a probar (alcance), quién prueba, cuándo se prueba, cómo se prueba (técnicas, herramientas, estrategias), cuánto se prueba (criterio de calidad de la prueba), a quien reportamos el estado del producto, y en qué formato. Se toman los objetivos del negocio, se identifican los riesgos que los afectan y las características de arquitactura que se deben medir.
  • Diseño: partiendo del lo planeado, se diseñan las herramientas y pruebas que se usarán, por ejemplo se definen cuantas pruebas se necesitan analizando las condiciones de prueba.
  • Construcción: escribir los casos de prueba, documentos para prueba manual o programas para prueba automática.
  • Ejecución: ejecución de los casos de prueba en los ambientes definidos. Se ejecutan conjuntos de casos de pruebapor ejemplo, las pruebas de regresión.
  • Reporte: registrar el resultado de la ejecución: casos ejecutados, casos bloqueados (no pudieron ejecutarse), defectos encontrados, sugerencias de nuevas pruebas. Resumir los resultados para ser informados a los interesados en el producto.
  • Administración: seguimiento de requerimiento, casos de pruebas y defectos. Hacer seguimiento significa que se mantienen actualizados (agregar, actualizar y quitar) y relacionados unos con otros, se prioriza el trabajo sobre los mismos y decide cuando y cuales deben ejecutarse.
  • Métricas y Mejora: medir el resultado del trabajo (producto) y la forma de trabajo (proceso), para identificar oportunidades de mejora. Algunos ejemplos de métricas son: cantidad de defectos detectados en producción, tiempo que lleva detectar defectos, porcentaje de build a los que se les detectan defectos por medio de las pruebas automáticas, cuanto tarda la prueba de regresión.

Tipos y estrategias de prueba

  • Exploratorio: prueba no guionada, ni repetitiva. Suele ser realizada con una misión definida (por ejemplo, probar la usabilidad o reproducir un defecto), con tiempo limitado (timeboxed), y se realiza de modo simultáneo la planificación, diseño y ejecución de las pruebas, en ciclos cortos (minutos) que permiten adaptar el nuevo ciclo a los resultados obtenidos en el anterior, en un proceso de aprendizaje. Puede tener soporte de herramientas, pero no puede ser automatizado. Finaliza con un reporte de la prueba en el que se describe las hipótesis, las pruebas realizadas, los resultados de las mismas, y los posibles pasos a seguir.
  • Test-Driven Development (TDD): una forma de diseño y programación, que se basa en declarar el diseño en la forma de ejemplos ejecutables (pruebas) del uso del componente, antes de programar el componente. El ciclo de TDD consiste en: escribir las pruebas, ver que fallen (no está el código correspondiente), escribir el código mínimo para lograr que la prueba pase, ver ver que las pruebas pasen, y luego revisar el código (del componente y de las pruebas) para mejorarlo (también llamado refactoring). Esta técnica se origina en Extreme Programming, y tiene mucha relación con otras como Pair Programming, Simple Design, Coding Standard. No es una técnica de prueba en sí misma, pero genera como subproducto un conjunto de pruebas automatizadas con alta cobertura de código, lo que implica que el software desarrollado de esta manera suele tener niveles de calidad muy buenos.
  • Prueba Automatizada: estas pruebas son construidas completamente antes de la ejecución de las mismas, por lo que no se requiere intervención humana durante la ejecución. Esto permite que se realicen frecuente y rápidamente.
  • Aceptación: pruebas realizada por el usuario (o cliente o sus representantes) que definen si el producto se ajusta a las necesidades y puede ser aceptado. Según la relación entre el usuario y el equipo de desarrollo puede ser que la aceptación se refiera sólo al cumplimiento de las necesidades explicitadas o sea más amplio.
  • Funcional: pruebas desde el punto de vista de la funcionalidad, y no sobre temas como confiabilidad, mantenibilidad, usabilidad, seguridad. Dado que la definición de funcionalidad puede ser ambigua (por ejemplo se pude considerar que no tiene sentido distinguir entre requerimientos funcionales y no funcionales), en ocaciones se usa este término con el mismo sentido que prueba de sistema.
  • Integración: pruebas orientadas a las interacciones entre los distintos componentes que componen el producto. Se buscan que se comuníquen correctamente tanto desde el punto de vista sintáctico como semántico.
  • Sistemas: pruebas de punta a punta, considerando no sólo el producto que el equipo está desarrollando, sino también otras productos (de software o no), procesos y personas involucradas en la solución a las necesidades del usuario.
  • Otros tipos o estrategias: fuzzing, combinatoria, guiada por riesgos, Behavior-driven development (DBB), caja negra, caja blanca, pruebas de regresión, pruebas formales.

Bibliografía

[AustinLevin] Artful Making, Rob Austin y Lee Davin.
[Brooks] The Mythical Man-Month, Fred Brooks.
[Cockburn] Alistair Cockburn, obtenido 2011-05-16 http://alistair.cockburn.us/Software+development+as+a+cooperative+game
[ColussoGabardini] Desarrollo Ágil de Software, Ricardo Colusso & Juan Gabardini. http://knol.google.com/k/desarrollo-ágil-de-software
[CrispinGregory] Agile Testing, Lisa Crispin & Janet Gregory.
[Gabardini] ¿Exite la mejor forma de probar?, Juan Gabardini. blog, video, presentación: http://softwareagil.blogspot.com/2011/01/la-mejor-manera-de-probar-en-agilesbsas.html
[GNU] "The GNU Project (essay)". obtenido 2011-05-16 http://www.gnu.org/gnu/the-gnu-project.html
[Knulth] Literate Programming, Donald Knuth.
[Moore] Crossing the chasm, Geoffrey Moore.
[Nachmanovitch] Free Play, Stephen Nachmanovitch (comentado en http://bit.ly/mdnKOe)
[LarmanVodde] Lean Primer; Larman & Vodde. http://www.leanprimer.com/downloads/lean_primer.pdf
[Schneider] The Reengineering Alternative, William E. Schneider.
[TakeuchiNonaka] The new new product development game, Takeuchi & Nonaka, HBR.


Que falta en este documento

  • ¿Quienes probamos?
  • ¿Por qué probamos?
  • Referencia al checklist de TestObsessed
  • Cambiar referencias al formato knol
  • Gráficos: contexto de la prueba, pirámide de la prueba
  • Cuadro comparativo QA/QC/Testing
  • Definiciones de Validación y Verificación, smoke test (build validation test), caja blanca y negra.

viernes, 12 de agosto de 2011

Relación entre la frecuencia de entrega y los procesos

Recientemente vi un video de Kent Beck, Software G Forces: The Effects of Acceleration, comentado por Mary Poppendieck en How Cadence Predicts Process.

Kent analiza como cambian los procesos y buenas prácticas según aumenta la frecuencia de entregas (Anual, Trimestral, Mensual, Semanal, Diaria, Horas). Comenta como algunas prácticas son buenas con cierta frecuencia de entrega y son malas en otras.
Plantea la relevancia de este análisis debido a que, según su percepción, la frecuencia de entrega de los equipos de software tiene a acelerarse.

Mi intensión es hacer un resumen, pero recomiendo ver el video que, aunque dura 90 min, es mucho más rico que este post.

Entregas anuales → trimestrales

Prácticas que se agregan: Test de aceptación automatizados, refactoring, Integración continua
Justificación: No se puede solo reducir los tiempos, hay que cambiar los procesos. No puedo tener un mes de integración y corrección de bug, con una o dos semanas de pruebas manuales para hacer regresiones. Entonces aparece Integración continua, y Pruebas de Aceptación Automatizada. No puedo tener uno o dos meses de diseño, aparece la necesidad de avanzar aún sin tener todo el diseño hecho o cerrado. Estoy seguro que tendré que cambiar el diseño, por lo tanto, tengo la necesidad de refactoring.

Cambios en el negocio: Suscripción.
Justificación: No se pueden vender 4 versiones por año. Necesito bajar el costo de transacción (tanto para la empresa como para los clientes).

Entregas trimestrales → mensuales

Prácticas que se agregan: prueba por parte de los desarrolladores, reuniones diarias, tarjetas en las paredes.
Prácticas que se quitan: Departamente de QA, soporte a múltiples versiones, Documento de diseño, Control de cabios, equipo de análisis, equipo de build.
Justificación: no hay tiempo para el ida y vuelta con un grupo separado de QA. La mayoría del testing y la reducción del defectos deben ser hechos por el mismo grupo, y probablemente por la misma personas (testers en el equipo y pruebas por los programadores), en el plazo de horas, no de días. La comunicación debe ser mucho más rápida, no podemos sincronizarnos y detectar problemas una vez por semana o mensualmente. Tenemos que estar al tanto cada día, solo tenemos 20 días para entregar (reuniones diarias), tenemos que planificar y re-planificar en forma barata y rápida (tarjetas en las paredes, dejar de usar control de cambios formales). No podemos dedicar mucho tiempo para escribir las decisiones detalladas de diseño antes de usarlas (Documentos de diseño).
Al aumenta la cantidad de entregas, el costo de soporte de muchas versiones se vuelve prohibitivo, y debemos mantener una o pocas versiones del producto (soporte de múltiples versiones). Necesitamos iniciar el diseño y el desarrollo, no podemos esperar una fase de análisis o el ida y vuelta en paralelo con un grupo de análisis (mismo problema que con QA).

Cambios en el negocio: Pagar por el uso.
Justificación: la suscripción no nos da suficiente feedback. Con pagar por el uso, sabemos realmente que funcionalidad que estamos desarrollando les interesa a los clientes.

Entregas mensual → semanales

Prácticas que se agregan: migración de datos en vivo, cero defecto, ramas temporarias, dovela clave (keystoning), kanban.
Prácticas que se quitan: equipos de test, migración en un sólo sentido, ramas de release, parches, diseño de usabilidad al inicio, venture capitals
Justificación: para poder cambiar las estructuras de datos en sitios con grandes volúmenes de datos y cantidad de usuarios, se debe hacer procesos de migración en dos o tres fases, de manera de cambiar la estructura sin nunca dejar de dar el servicio (migración de datos en vivo).
Como los tiempos son cortos, algunas funcionalidades se comienzan a agregar sin hacerlas visibles. Solo cuando está todo dispobible, se agrega la última parte (como la dovela clave de un arco de medio punto), y queda dispobible para los usuarios. Siendo que las entregas son tan rápidas, cualquier cambio, por más urgente que sea, puede incluirse en la próxima entrega. Se elimina la necesidad de procesos de emergencia (parches).

Cambios en el negocio: Bootstrap financing.
Justificación: La financiación de Venture Capitals necesita mayor predecibilidad en los planes, e impone restricciones a desarrollo de productos (a esta velocidad).

Entregas semanal → diarias

Prácticas que se agregan: inmunización, A/B testing
Prácticas que se quitan: staging, equipo de operaciones, reuniones diarias.
Justificación: algunos de los releases van a ser malos. Tenemos que tener formas muy sencillas de volver atrás o formas muy rápidas de corregir y continuar. No hay mucho tiempo para discusciones sobre diseño de interfase, se pude simplemente dar las alternativas y ver como lo usan los usuarios (A/B testing). Para hacer entregas rápidas, no podemos pasar por tantos pasos (ambientes) intermedios. Simplemente no hay tiempo para usarlos (staging), lo que se puede hacer es hacer instalaciones en distintos servidores de producción, que se va midiendo y obteniendo feedback. Todo esto lleva a que la operación debe ser parte de la responsabilidad del equipo (equipo de operaciones). La comunicación en el grupo tiene que ser tan continua y rápida, que no tiene mucho sentido para las reuniones diarias.

Mis conclusiones

Esta visión me hizo repensar mis ideas sobre La mejor manera de probar, reinterpretando parte de mis observaciones desde esta nueva perspectiva. La corelación entre ambas visiones es muy fuerte, pero no completa. Es interesante que la visión de Kent está muy asociada a situaciones en las que el software es el componente principal de los productos.

lunes, 1 de noviembre de 2010

¿Existe la “mejor” forma de probar?

¿La prueba manual de software es necesaria? ¿Es suficiente? ¿Y la prueba automatizada?
Es tentador pensar que si estudiamos el problema (prueba de software) lo suficiente y somos buenos profesionales, podremos encontrar “la mejor manera” de hacerlo. Si conocemos “la mejor manera”, los que realizan la prueba de otra manera están equivocados.
Alguna vez pensé conocer cual era “la mejor manera”. Luego, aprendí o cambié de contexto, y “la mejor manera” cambió.
A partir de estas experiencias soy algo escéptico cada vez que escucho (de otros, o de mí!) afirmaciones en este sentido. Esta nueva “mejor manera”, ¿que problemas viejos resuelve? ¿que problemas nuevos crea? ¿en que contexto está siendo usada?
Voy a comentar mi experiencia personal con diferentes formas y contextos de prueba. En cada contexto, analizaré los problemas comunes y cultura, y también si ese contexto es un estado final o sólo un paso hacia otro estado. Este texto se basa en la presentación que realicé en Ágiles 2010 – Lima.
No trato el problema más general de la calidad de software, sino solamente sobre la prueba.
El modelo

La comparación de los contextos está organizada utilizando el modelo de prueba comentado en el libro “Agile testing”, de Lisa Crispin y Janet Gregory, a su vez basado en las propuestas Mike Cohn y Brian Marick. En este modelo, tenemos 4 tipos de prueba (de arriba hacia abajo):
  • Pruebas Manuales
  • Pruebas de Interfase Usuaria (automatizada)
  • Pruebas de Aceptación o API (automatizada)
  • Pruebas técnicas o unitarias y de componentes (automatizada)
El costo de ejecución es menor en las Pruebas técnicas y va creciendo hasta el máximo costo, que es la ejecución de pruebas manuales. El costo de mantenimiento de las pruebas automáticas también es creciente, desde el mínimo en las pruebas técnicas, hasta el máximo en las pruebas de Interfase Usuaria. El mantenimiento de las pruebas manuales es equivalente o menor que el caso de pruebas técnicas automatizadas. En todos los casos, el costo y mantenimiento de las pruebas automatizadas requiere una inversión importante en experiencia e infraestructura. Pero esa inversión se puede llevar en muchos casos de un proyecto a otro. Los costos consideran esa inversión amortizada o distribuida en gran cantidad de pruebas.
La relación entre los costos lleva a sugerir que la forma más eficiente de dedicar esfuerzo tiene la forma de una pirámide, con las pruebas técnicas (unitarias y de componentes) en la base, las de aceptación (o API) luego, y finalmente las pruebas de UI en el vértice de la pirámide.
Contexto: Prueba Ad hoc
Durante los primeros 10 años de mi carrera, trabajé en grupos de 5 personas o menos, trabajando en desarrollo de software en áreas tan variadas como aplicaciones administrativas (ERP), adquisición y procesamiento de imágenes médicas (de medicina nuclear), y sitios de Internet que brindan información bursátil en tiempo real.
En estos equipos, no había separación de roles, todos hacíamos un poco de todo. En particular, las pruebas las hacíamos entre todos, intercambiábamos roles, probando la funcionalidad realizada por otro. La prueba final la hacían los jefes, usuarios o, si existían, las personas de servicio a cliente.
Al no haber responsables definidos la prueba solía quedar huérfana, sin mejora. En este contexto es un problema realizar pruebas de regresión, una tarea poco atractiva y compleja.
La evolución de este contexto suele ser incorporar un tester o área de testing para Prueba Manual (camino tradicional) o que los programadores empiecen a desarrollar Pruebas Técnicas o incluso TDD (camino del desarrollo ágil).
Cualquier camino de evolución pasar por un cambio cultural, ya que en estos grupos la prueba no suele ser valorada lo suficiente. Se suele escuchar “si los programadores hacen bien su trabajo, ¿por qué senecesitaría probar?”
Los problemas se hacen más notorios cuando el grupo debe crecer, tiene mucha rotación o debe mantener muchos productos.
Caso: en una importante compañía de fondos de pensión y seguros de retiro pidieron presupuesto para mantenimiento de muchas aplicaciones existentes (legacy: sin pruebas automatizadas). El cliente no aceptó una propuesta de equipo con cuatro personas, en la que una cumplía el rol de tester; sin embargo, aceptó un equipo de 4 personas con 3 programadores. Internamente el equipo se manejó con uno de los 'programadores' actuando como tester, con buenos resultados.
Motto: ¡No vale la pena probar!
Problemas: baja calidad, baja previsibilidad, regresiones
Cobertura: no hay métricas.

Responsable: todos y ninguno. Pruebas por el usuario.
Organización: generalmente chicas y con poca estructura
Contexto: Prueba Manual
En mi siguiente reencarnación, estuve 8 años en una compañía que trataba de convencer y ayudar a empresas de contexto Ad hoc a que la prueba es algo útil y necesario.
Este cambio cultural es difícil, y con riesgo de involuciones. Por eso se busca separar en un grupo autónomo a los responsables de probar. La separación y la función de probar, que a veces se desvirtúa como prueba de la persona en vez de prueba del producto, provoca enfrentamientos y fricciones con los programadores.
El diseño de las pruebas es divertido, pero ejecutarlas una y otra vez es terriblemente aburrido, lo que lleva a que pocas personas quieran quedarse mucho tiempo haciendo esto. Resultado: muchas personas capaces se van a otras áreas, más divertidas (como desarrollo), y por el recambio hay mayoría de novatos en los roles de prueba. Los que se mantienen en el rol suelen ser personas con poca inclinación a lo técnico. Para crecer profesionalmente, los testers se dedican a tareas de QA (procesos) o de Analistas de negocio, que son más valoradas en el mercado.
En este contexto, los problemas son que la prueba de regresión de productos medianos y grandes se hace muy costosa, lo que lleva a ciclos de desarrollo muy largos (para ejecutar pocas veces las pruebas de regresión) o disminución de las pruebas realizadas durante la regresión (lo que lleva a baja calidad).
La salida parece ser la automatización, pero lamentablemente no es una salida fácil, ya que las personas que están en el grupo de prueba no tienen conocimientos técnicos, y la relación con el grupo de programación, que puede aportar el conocimiento técnico, no es la mejor.
En algunos casos se pasa a Prueba Manual Optimizada.
Motto: ¡No vale la pena automatizar las pruebas!
Problemas: costo de ejecución, que a su vez lleva a seleccionar las pruebas, que baja la confianza y lleva a pocos releases
Cobertura: requerimientos, casos de uso
Responsable: Testers / QA.

Organización: testing separado
Prácticas: casos de prueba manuales, checklist
Contexto: Prueba Manual Optimizada
Luego de 6 años en Prueba Manual, reencarné en Prueba Manual Optimizada. Algo bueno habré hecho en mi vida anterior, porque un cliente exigió en un proyecto que automaticemos.
¿Por qué automatizar? Por criticidad del negocio o cuando se logra volumen suficiente en el área de prueba como para justificar la inversión.
¿Cómo hacerlo? Se suele incorporando programadores al grupo de prueba con el rol de Automatizadores de la Prueba.
Con gran esfuerzo se mantiene un conjunto de pruebas automatizadas, que permiten hacer pruebas de regresión en forma rápida, lo que permite mejorar la calidad, confianza y tiempo de respuesta. Pero por otro lado, debido a la separación entre los grupos de programación y los de prueba, es frecuente que cambios realizados en forma inconsulta en el producto rompan las pruebas automatizadas. Ysi sumamos el hecho que estas pruebas suelen ser de caja negra a través de la UI, el costo de mantenimiento de las pruebas automatizadas es alto.
Es una situación extraña, ya que en muchos casos nos damos cuenta que podríamos ser mucho más eficiente si algunas pruebas fueran de caja blanca y las hicieran los programadores, o si los testers pudieran participar en la toma de decisiones sobre cambios al producto. Pero no podemos influir en la forma en que se programa, es otro grupo.
Esta tensión puede resolverse cuando los grupos de programación y prueba empiezan a trabajar juntos y se pasa al contexto Técnico++ o al Nirvana.
Motto: No podemos mejorar la producción del código.
Problemas: mantenimiento de las pruebas
Cobertura: requerimientos, riesgos
Responsable: Testers, Testers automatizadores, QA.
Organización: organizaciones grandes, grupos de homologación separado
Prácticas: pruebas automatizadas de interfase de usuario
Contexto: Prueba Técnicas
Algunos equipos en los que trabajé (entre 2 y 40 desarrolladores) tenían la cultura de calidad incorporada con fuerte influencia de XP, por ejemplo con prácticas de Integración Continua, TDD y Pair programming incorporadas.
En estos equipos la calidad es alta comparada con los contextos de Prueba Manual. Se suele utilizar cobertura de código como métrica relevante. Los problemas que suelen presentarse son: mantener el tiempo total de ejecución de las pruebas bajo (<10 min)
La evolución natural es hacia Pruebas Técnicas++, ya que en este contexto ante los problemas la primera solución que se piensa es agregar pruebas automatizadas.
Caso: en un proyecto Ruby on Rails comenzamos con una funcionalidad de CMS sencillo para seguir luego con funcionalidad más compleja. Se trabajaba con coberturas de código por arriba del 80%. A los dos meses del proyecto, el usuario vuelve a utilizar la funcionalidad de CMS sólo para encontrarla rota, debido a un cambio en las vistas que pasó desapercibida por mucho tiempo. El análisis del problema llevó al equipo a agregar pruebas automatizadas con Cucumber y Selenium (API y UI).
Motto: Sólo vale la pena las pruebas automatizadas
Problemas: usabilidad, cumplimiento de requerimientos y regresiones en cuanto a requerimientos
Cobertura: líneas de código
Responsable: programador
Organización: equipo de programadores
Prácticas: TDD, CI
Contexto: Prueba Técnicas++
Los equipos en este contexto vienen de la Prueba Técnica, agregando prueba de APIs y quizás de UI, o de la Prueba Manual Optimizada, agregando prueba unitaria y quizás de API. En ambos casos, tienen des-balanceada la pirámide de prueba. En el caso de los que vienen desde Prueba Manual Optimizada, puede ocurrir que pierdan la prueba manual o la prueba de UI automatizada, dado que el esfuerzo por incorporar pruebas unitarias es grande, y se detecta duplicación de esfuerzo entre las pruebas existentes (manuales o automáticas a nivel UI).
Luego de lograr el balance en la pruebas automatizadas, el problema remanente son las pruebas de difícil automatización (¡ningún programador las quiere hacer!) y la falta de prueba exploratoria. Esto último puede llevar a productos que son correctos desde el punto de vista funcional y de robustez, pero que no son sobresalientes, ya que no se detectaron puntos a mejorar en forma temprana.
Motto: Sólo vale la pena las pruebas en automatizadas
Problemas: usabilidad, cumplimiento de requerimientos
Cobertura: líneas de código y requerimientos
Responsable: usuario y programador
Organización: equipo de programadores
Prácticas: ATDD, BDD, TDD, CI
Contexto: Nirvana
Aunque no he llegado aún al Nirvana. Pero estoy atento a los reporte de gente que estuvo, como Lisa Crispin.
Estos equipos han incorporado todas las prácticas de XP. Están en continuo aprendizaje sobre como complementar los distintos tipos de pruebas, la automatización a diferentes niveles y la exploración, para lograr la combinación óptima. Están en un equilibrio dinámico, siempre cambiante, atentos a cambios en el negocio, la organización, el producto y nuevos desarrollos de prácticas en el equipo y la comunidad. Se preocupan por la cadena de valor completa.
Motto: Optimizamos el todo
Problemas: buscar el balance óptimo
Cobertura: líneas de código y requerimientos, riesgos
Responsable: equipo completo (whole team)
Organización: Lean
Prácticas: ATDD, BDD, TDD, CI
Re-visitando
Las descripciones dadas en cada contexto plantean la visión que tenía de lo 'correcto' cuando estuve en ellos, aunque algunas cosas me hacían ruido. Mirando ahora hacia atrás, tengo una visión distinta, que comento a continuación.
Re-visitando: Nirvana
Hay quienes quieren ir más allá de las prácticas de XP.
Los usuarios se equivocan tanto como los desarrolladores, ¿podemos hacer algo para ayudarlos? Hace 5 años Sebastián Elbaum nos comentaba sobre las pruebas para los usuarios finales. Actualmente Excel indica (subraya) las fórmulas que considera “raras” y co posibles errores del usuario, como el caso de una columna con fórmulas que totalizan filas, excepto en una celda que tiene un valor (no una fórmula).
Soporte a la prueba exploratoria: Brian Marick nos comentaba el año pasado sobre experimentos que estaba haciendo para potenciar el mecanismo de UNDO de una aplicación, de manera de poder volver atrás en una prueba para tomar otro camino en la exploración de la misma.
Re-visitando: Ad hoc
¿Qué pasa cuando la solución implica poco o nada de programación en el sentido estricto, sino más bien configurar soluciones existentes o crear contenido?
Caso: hace un año, poniendo en marcha nuestro primer evento usando Open Space (Agile Open Bs As 2009), teníamos que decidir como hacer la registración de los participantes. Luego de evaluar un par de alternativas, incluyendo desarrollar, decidimos realizar la registración utilizando la funcionalidad de Formularios que brinda Google Docs. Una de las personas se quejó del formulario de registración, la pregunta “¿Le interesaría un evento de dos días?”, tenía sólo alternativas de dos días (dos días de semana, viernes y sábado, sábado y domingo) y era obligatoria. Hasta ahí, entendible. Pero la sugerencia que nos hacia era que deberíamos tener pruebas automatizadas. Probablemente esta persona se imaginaba que eramos un equipo de desarrollo en el contexto de Prueba Manual o Ad hoc, y nos sugería que deberíamos estar en Prueba Manual Optimizada o Técnica. ¡Pero la realidad fue que una sola persona configuró el formulario en media hora! Y el problema no tenía que ver con funcionalidad implementada, sino con la semántica del texto y la consistencia del mismo con el tipo de control utilizando. Este problema semántico pasó desapercibido por los revisores. Automatizar la prueba del formulario no hubiera encontrado el problema, y hubiera sido más costosa que el 'desarrollo'.
En algunas situaciones, la prueba Ad hoc podría ser lo mejor: desarrollo de sitios sencillos usando CMS, creando contenido y configuración.

Re-visitando: Prueba Manual
¿Podemos siempre tener un equipo integrado? ¿Podemos siempre confiar en el equipo?
Homologación de plataformas: cuando debemos proteger una plataforma, como en el caso de Microsoft, Apple o el entorno de producción de un banco, nos interesa validar algunos puntos mínimos, y simplemente no podemos confiar en que el equipo que realizó el producto (en muchos casos un tercero), haya realizado bien su trabajo. Pero por otro lado, aunque automaticemos algunas partes de la prueba (preparación de ambientes, comparaciones de antes y después), hay una buena parte de la prueba que es exploratoria, y que no tiene mucho sentido automatizar, ya que es de única vez.
Alto riesgo: aunque podamos ser un sólo equipo, cuando hay en juego mucho dinero o vidas, queremos redundancia. Podemos pagar pruebas manuales para lograr independencia (dos grupos, con dos técnicas distintas)
Productos que no controlamos, open source o no: cuando construimos sobre otros productos, la ecuación que justifica las pruebas automáticas nos juega una trampa, si el dueño del producto decide cambiar la aplicación, él solo evalúa sus costos, pero puede romper nuestras pruebas automáticas. (ej. en los que trabajé: Outlook y Liferay)
En algunas situaciones, la Prueba Manual podría ser lo mejor, buscando el mejor punto en el continuo que hay entre prueba manual totalmente definida y la prueba exploratoria. También debe considerarse tener ayudas automatizadas.
Re-visitando: Prueba Manual Optimizada
Cuando el producto no es sólo software, puede ser factible automatizar parte de la prueba (correspondiente al software) y realizar el resto en forma manual.
Algunos casos de esta situación podrían ser
  • CMS complejos, en los que no sólo se desarrolla contenido, sino también extensiones o aplicaciones.
  • Productos en los que el software acompaña al texto, y probablemente el texto sea lo más importante, como tutoriales
  • Soluciones que incluyan procesos: probar que los procesos se realicen correctamente (por ejemplo que las personas estén entrenadas y sepan qué hacer) es algo que debe probarse con las mismas personas.

Re-visitando: Prueba Técnica/ Técnica++
No encontré situaciones en las que convenga quedarse en estos contextos, siempre me parecieron pasos hacia el Nirvana. ¡Pero creo que es sólo cuestión de tiempo!
Conclusiones
Las metodologías ágiles han logrado una mejora muy importante en la calidad lograda en los desarrollos. Es tentador aplicar siempre las técnicas y prácticas que han permitido estas mejoras, y es tentador pensar que nuestros problemas se resuelven con más y mejor aplicación de las mismas.
Por otro lado, he escrito críticas a algunas prácticas (como el (ab)uso de métricas de cobertura de código), para luego encontrar que personas a las que respeto encuentran estas críticas inconvenientes, ya que se interpretan como un ataque a las técnicas de automatización de la prueba.
Estos contextos me han ayudado a aclarar las discusiones sobre la conveniencia de la utilización o no de las distintas prácticas. Espero que pueda ayudar a otros. ¿Tu que opinas?