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

miércoles, 18 de enero de 2017

Desarrollo ágil de Software - stack Python

Soy uno de los facilitadores del curso Desarrollo Ágil de Software (DAS) de Kleer.
Lo solemos hacer con Ruby (alguna vez lo hemos dado en Java y C#).

Afortunadamente, hace poco lo hicimos en Telefonica I+D Chile y nos pidieron hacerlo con Python ¡Gracias!

Le comento mi experiencia y les dejo la referencia del ambiente https://github.com/jgabardini/csdpy, lo pueden reproducir en Linux (o la virtual de DAS con Mint)

Resumen de Stacks

En el ambiente Ruby, las herramientas son: bundle, rspec, cucumber, webrat/capybara, sinatra con erb.

En el ambiente Python: virtualenv y pip, behave, splinter, flask con jinja2. Además, usé un plugin de Jenkins: ShinningPanda.

Python

No hubo problemas porque la mayoría ya programaba en Python (había dos o tres personas sin conocimiento, pero que se sumaron rápido).
Algunos prefirieron usar sus ambientes, por los editores (sin usar la virtual). La virtual tiene Gedit, ellos usaban Visual Studio Code, vim, ....
Usé Python 3.4 (en vez de 2.7 que es el default en la virtual de DAS).
Para manejar versiones y ambientes use virtualenv y pip.

Unittests

Usé nosetests como test runner. Extrañé la sintaxis BDD (de rspec), pero ellos no 😉
Para el próximo (que por suerte es la semana que viene), daré instrucciones concretas sobre la estructura de directorios. Los desarrolladores Python NO tienen el mantra Convention over configuration, cada uno lo hace distinto si los dejas libres 🙌. Y explicaré las reglas de descubrimiento de pruebas de nosetests, eso hubiera ayudado (tests/xxx_test.py).

Flask

El código mínimo es un poco más largo que el de Sinatra y, como yo no tengo tanta práctica, no lo escribí de cero. Usé el código del repo csdpy desde el inicio.
Cuando falla el routing u otro error, no es tan amistoso como Sinatra, no muestra una página 500 con información de que falta.
Usar annotation para definir el routing, obliga a tener funciones por cada mapeo, y es natural que la misma función cubra varios métodos HTTP. Cometí muchos errores de nombre método duplicado, acostumbrado a los bloques de Ruby.
Los asistentes no tuvieron mucho problemas (o los resolvieron).
Nuevamente, Flask es menos prescriptivo que Sinatra. Yo propuse una estructura de directorios. 
El motor de templates, Jinja2, lo usé simplificado. Sin layout, bloques ni herencia. Es el motor usado en  Django.

Behave

Sigue bastante la idea de Cucumber, excepto que los pasos son distintos para cada palabra clave (Given/When/Then). En Cucumber, un paso está definido solo por el texto. En Behave los pasos se definen por la combinación palabra clave + texto. Tuve el mismo problemas con nombres de métodos repetidos que en routing de Flask.
No propone pasos con regex  "automáticas". Uno debe agregar los parámetros a mano.

Splinter

Usé Splinter que equivale a webrat/capybara. Pinta muy bien. Tiene una API muy parecida a WebDriver y puede usar los driver de WebDriver, o flask (me parece que inprocess, pero no lo encontré la documentación).


Configuración de Jenkins

Para correr tareas que requieren virtualenv, use un plugin ShinningPanda. Todas las tareas configuradas como shell.
Para que corra el behave tuve que agregar un package: behave-jenkins.

Conclusiones

Hacer la migración de Ruby a Python me llevó un día neto de trabajo. Bien sencillo.
Luego de 3 años de programar principalmente con Ruby, me sentí raro en Python. Me falta práctica. Por suerte, la semana que viene volvieron a pedirme, esta vez en Córdoba, que hagamos el curso en Python 😎


martes, 15 de abril de 2014

Reporte de defectos (bugs) en Scrum

Una pregunta muy frecuente en los equipos que están implementando Scrum es si tienen que seguir usando una herramienta de seguimiento de defectos, y si lo uso que deberían registrar en la misma.

Veamos primero la respuesta revolucionaria y después una respuesta evolutiva. 
Y luego el análisis en cuanto al momento en que se detecta.

Nota: en todos los casos que comentamos, la importancia o prioridad de los bugs se debe acordar en el Scrum Team (Dev Team + Product Owner + Scrum Master), teniendo la última palabra el PO basado en el impacto en el negocio.

Revolución: Hay una sola lista de pendientes

El backlog contiene todo lo que hay que construir. No hacemos diferencia entre bug y funcionalidad nueva.
Un bug que provoca que las pruebas automáticas estén en rojo (falla alguna de las pruebas) debe corregirse en el momento o esa funcionalidad debe quitarse (o desactivarse).
Si encontramos un bug durante la prueba exploratoria que es crítico, agregamos una prueba automática que lo evidencie. 
Todo otro bug se considera un cambio a una funcionalidad existente y se prioriza junto con otras funcionalidades.

Evolución (orgánico): Lista de bugs

El Product Owner dispone de varias fuentes: pedidos de los clientes, ideas propias de nueva funcionalidad, y un lista de los bugs que persisten en el producto. Cuando se planifica el sprint, se consideran los bugs más complejos como nuevos requerimientos, y los chicos se agrupan en paquetes de corrección. En ocasiones se define un tiempo fijo que se dedicará a corrección de todos los bugs que se puedan.

Caso bug detectado en una historia que se está desarrollando

  • Primera opción, corregirlo dentro del sprint como parte del desarrollo de la historia
  • ¿Y qué pasa si no llegamos con todo lo comprometido? 
    • Recortar la funcionalidad para que ese bug no sea relevante y agregar una historia con esa funcionalidad recortada. 
    • Si es muy grave, quitar la funcionalidad correspondiente y la historia queda sin hacer. Quizás pueda resolverse e el próximo sprint.
    • El bug es poco importante como para hacer alguna de las anteriores: si no es importante ahora, ¿cuándo lo será? Podemos registrarlo en una herramienta o tiralo a la basura, si aparece alguien a quien le importe, lo pedirá. Esta última es la forma más realista en el largo plazo. Las listas interminables acumuladas de bugs son un consumo de tiempo y esfuerzo de todo el equipo.

Caso bug detectado luego de liberada una historia

Hay varias alternativas:
  • Se maneja como una historia de usuario (si es grande)
  • Se agrega a las lista de ideas a revisar en el refinamiento de backlog, tanto para estimar como para evaluar la prioridad. Luego del análisis, se carga en el backlog / lista de bug si se quiere corregir en los próximos sprints, o se descarta.
  • Se corrige a medida que aparecen. El equipo debe manejar el impacto en cuanto a cambio de alcance. Por ejemplo: tener un tiempo fijo dedicado en el sprint para corrección de bugs. O poner un límite de bugs abiertos (por ejemplo 10) y se debe detener el desarrollo de nueva funcionalidad hasta tanto se corrijan los bugs que hay en exceso. 

¡Espero este breve recorrido te ayude!

jueves, 7 de noviembre de 2013

¿Automatizamos las pruebas de regresión?

Trabajo en una aplicación en la que cada vez que mis usuarios piden un cambio, el costo de hacer el cambio es mucho menor que el costo de probar. La aplicación no tiene automatizada la prueba y no es modular.

Esta situación la he escuchado y vivido muchas veces en mi carrera. Ante esa situación, hay varias acciones posibles:

  1. Tenemos que hacer de nuevo el sistema, y esta vez lo haremos bien.
  2. Redefinamos el sistema para que sea más fácil probar.
  3. Automaticemos la prueba.
  4. Contratemos más testers.
  5. Sigamos sin cambiar durante algún tiempo.

No puedo en este post analizar todas las alternativas, pero voy a seguir una linea de razonamiento posible, asumiendo algunas creencias, básicamente que las prácticas de desarrollo ágil me pueden ayudar en este caso (Más información sobre estrategias en Working Effectively with Legacy Code). 

Entonces, la secuencia de pensamientos sería:
  • Me gustaría hacerlo bien, pero no puedo tirarlo y empezar de nuevo, el negocio debe seguir operando y la aplicación se debe seguir adaptando. Entonces, trabajaremos en hacerlo bien, pero en forma incremental
  • Para redefinir el sistema sin romperlo, y dado que trabajaremos incrementalmente (muchos pequeños cambios) necesitamos pruebas automatizadas, al menos de nivel funcional. Esto permitirá que probemos a bajo costo cada versión del sistema con un nivel aceptable de calidad. No reemplazamos las pruebas manuales, pero al menos distribuimos las pruebas entre dos ciclos: uno automatizado, rápido y frecuente, otro manual, costoso y que corremos antes de liberar versiones.
  • Hacer bien la aplicación implica modularizar, tener pruebas automatizadas unitarias y calidad interna. Estas importantes ideas y prácticas no las estoy tratando en este post, pero suelen tener como precondición las pruebas funcionales automatizadas a las que me refierno en este post.
Vemos muchas equipos y empresas que siguen esta linea de pensamiento. Entonces el problema se puede reeplantear.

Quiero automatizar las pruebas de regresión, ¿cómo lo hago?

Quiero automatizar las pruebas de regresión, ¿cómo lo hago? ¿Qué herramientas uso? ¿lo hago con personas del equipo o contrato fuera? ¿cómo cambian los roles, que tenemos que aprender? ¿qué y cuánto tengo que probar para lograr confianza?

La respuesta a estas preguntas: Depende. 
Bien, pero ¿de qué depende?

El equipo ¿tiene cultura de calidad?

Algunos miembros del equipo se ocupan de la calidad, dedican tiempo a pensar como probar y manejar los riesgos. Ya se hacen pruebas, y el problema es como automatizarlas.

¿Cómo es la estructura y cuales son los conocimiento del equipo?

La prueba manual la realiza un grupo externo, o los testers del equipo (hay personas cuyo puesto o posición es Tester), o las pruebas las realizan varias personas que cubren el rol de tester, pero también otros roles (analistas, programadores, diseñadores gráficos).
Los que cumplen rol de tester, ¿tienen conocimientos sobre programación o les interesa adquirirlos?
Funciona el equipo como un Whole Team en el que todos toman responsabilidad sobre el resultado conjunto y no sobre un subconjunto ("yo pruebo, no programo" o viceversa)

¿Cómo es la tecnológicamente la aplicación?

Para disminuir la curva de aprendizaje y mejorar la aceptación de las nuevas herramientas, es conveniente que la tecnología de la prueba automática sea cercana a la utilizada para la aplicación. ¿El equipo trabaja con .Net, Java, Ruby, Python?

Nuestra respuesta

Cada equipo debe explorar qué organización, herramientas y conocimientos les servirán para su caso.
Lo que encontramos desde Kleer (en este caso Nicolás Páez, Juan Gabardini, Carlos Peix), es que solemos repetir, al inicio de las consultoría de estos temas, una mínima nivelación de conocimientos y del abanico de posibilidades en cuanto a prácticas y herramientas, para facilitar a los equipos tomar decisiones. Pensamos que sería útil extraer esto en una serie de talleres cortos (medio día cada uno):


domingo, 11 de noviembre de 2012

Herramientas de Desarrollo en PHP

En los últimos tiempos estoy trabajando con varios clientes que utilizan PHP para sus desarrollos.
Hemos hablado entre varios de los involucrados, tanto de Kleer (Martín Salias, Nicolás Paez, Ignacio 'Code' Raguet) como de los clientes y nos parece que, por razones históricas, la comunidad de PHP  tiene poco incorporadas prácticas que ya están muy difundidas en las comunidades de otros lenguajes. Prácticas como análisis estático de código, criterios de calidad de código, prueba automatizada, frameworks web sencillos y potentes, y varios más. Está característica de la comunidad se reflejaba en la falta o inmadurez de las herramientas que soportan esas prácticas. Parece que esto está cambiando. 
Mi anterior post sobre PHP es viejo y  mucho a cambiado desde entonces.

Van entonces algunas herramientas y comentarios, principalmente tomado de Martín Salias, Nicolás Paez, Ignacio 'Code' Raguet y Pablo Morales. Verán que algunas cosas se repiten desde 2008, otras son nuevas.

Análisis de código 

¡Gracias Martín por la data!
  • Source Code Search Engine te permite hacer queries sobre bases de código muy grandes, con más inteligencia que un grep común, entendiendo el lenguaje (soporta PHP entre muchos otros). Esto puede servir para encontrar usos de ciertos elementos, y es más un complemento que otra cosa.
    http://www.semanticdesigns.com/Products/SearchEngine/

Pruebas automatizadas 

Frameworks


viernes, 12 de octubre de 2012

Scrum en Asunción - Paraguay

Hace uno mes (31 de Agosto) hice mi primera visita laboral a Paraguay. 
El Centro de Calidad de Software organizó un curso de "Gestión ágil de proyectos de software", de 16hs, que dimos en dos días (viernes y sábado).
Aprovechando la visita también organizamos, junto con AgilePy lo que creo fue el primer Coding Dojo de Paraguay.

Paso a contar cada actividad, no sin antes agradecer al Centro de Calidad, y en particular a Marcelo De Filippis, por la organización, el empuje y soporte en todo momento y a Cristhian Cardozo que además de dar soporte durante el curso, sacó fotos y se quedó al Dojo para recibir a los asistentes.

Gestión ágil de proyectos de software

En lo que entiendo fue el primer curso abierto de Scrum en Paraguay, asistieron 18 personas, haciendo un gran esfuerzo, ya que lo hicimos un viernes a partir del mediodía, y el sábado. Hacer 16hs de curso en esas condiciones fue cansador, pero terminamos contentos.

Sigo con mi intensión de dar los cursos con soportes visuales en afiches, y ejercitando mi capacidad de transmitir ideas visualmente. Esto fue muy valorado por los asistentes, y genera un efecto ¡WOW!, ya que es muy distinto a lo que están acostumbrados. 


También el uso de técnicas de Training from the Back of the room (ver resumen) hacen el aprendizaje es más divertido y profundo. 




 La asistencia fue variada, lo que enriqueció las discuciones. Había profesores universitarios, personas que trabajan en empresas grandes y chicas, emprendedores, programadores y personas de testing y calidad.
¡Muchas gracias a todos, y espero que volvamos a vernos!

Yoseki Coding Dojo


Este dojo fue claramente inmoral, y hasta diría inhumano. Lo organizamos el sábado, de 19 a 21hs. ¡Había que tener muchas ganas para estar! Doble puntaje para los asistentes :D
Hicimos el kata del Juego de la Vida, con Python. Los asistentes eran programadores de Action Script y PHP, no tenían conocimiento previo de Python, pero no fue un problema. Comentamos TDD, Integración Continua, algunos de los principios de SOLID y mocking.



Pasamos un buen rato, para la próxima, ¡vale traer cerveza!





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?

lunes, 14 de junio de 2010

Referencias del curso de Scrum

En los últimos tiempos fui disminuyendo la cantidad de transparencias en los cursos, para dar más lugar a las actividades interactivas y a la adaptación del nivel de detalle según el interés de los asistentes.

En el último curso, me basé completamente en la dinámica que no requiere proyector. En lineas generales me pareció que la dinámica fue buena, pero una pérdida fue que las referencias a libros, sitios y eventos quedaron repartidos a todo lo largo de los dos días de curso.

Trataré de cubrir aquí esa falencia. Si quieren pueden ver la presentación previa del curso.

Grupos y sitios

Foro ágiles: lista de correo de intercambio de ideas y experiencias, preguntas y anuncios de la comunidad hispanoparlante (Latam y España)
Ágiles: uno de los sitios comunitarios de metodologías ágiles en español.
Ágiles Argentina: lista de correo de la comunidad argentina para anuncios locales, organización de eventos
Blog de Juan Gabardini: ¡Este blog! Desarrollo ágil de software, con cierta inclinación hacia el testing
Scrum Development: lista de mails 'oficial' de Scrum.
Scrum Alliance: sitio 'oficial' de Scrum. Por ejemplo tiene la lista de capacitaciones de CSM.
Agile Alliance: sitio 'oficial' sobre el desarrollo ágil. Son los organizadores del mayor evento anual, Agile 20xx.

Eventos

Ágiles 2010 – Oct – Lima: Evento anual de la comunidad latinoamericana sobre metodologías ágiles.
Agile Open Tour: Serie de eventos argentinos realizados con el formato Open Space. Se han hecho 6 durante 2009 y hay planeados 8 eventos en el 2010.

Libros y otro material

Ken Schwaber: Agile Project Management with Scrum / The Enterprise and Scrum
Libros de referencia. El primero con foco en scrum dentro de un equipo, el segundo con la implementación en toda la organización. Ver mis comentarios previos.

Rob Austin y Lee Davin: Artful Making
Una visión novedosa sobre el desarrollo de software y otras actividades (teatro, planificación estratégica), que explica la secuencia desde el trabajo hecho artezanalmente, la producción industrial y la artística, con las motivaciones económicas y implicancias en cuanto a las condiciones necesarias y la forma de trabajo resultante. Ver mis comentarios previos.

Henrik Kniberg: Scrum and XP from the Trenches
Conjunto de experiencias en todos los temas enfrentados al usar Scrum, con referencias a libros y material adicional. Disponible en forma electrónica gratuita y en español.
Mike Cohn: User Stories Applied / Agile Estimating and Planning
Libros de referencia obligada para temas los temas del título. Además Mike tiene muchos recursos disponibles gratuitamente.

Craig Larman: Agile & Iterative Development: A Managers Guide
Buena introdoción a la idea general y sumario de los distintas 'metodologías'. Tiene varios libros interesantes y algunos documentos gratuitos muy interesantes, como Lean Primer

Kent Beck: Extreme Programming Explained: Embrace Change
Uno de los primeros libros sobre Desarrollo Ágil, con contenido relacionado con las pácticas técnicas, que no están cubiertas en los libros mensionados anteriormente.

Mary & Tom Poppendieck: Implementing Lean Software Development
Los conceptos de Lean están atrás de muchas de las buenas prácticas Ágiles. Uno de los tres libros de los Poppendieck (todos recomendables).

David Anderson: Agile Management for Software Engineering: Applying the Theory of Constraints for Business Results / KANBAN, Successful Evolutionary Change For Your Technology Business
En el primer caso, David toma los conceptos de TOC aplicados al Software. El segundo es un libro de próxima publicación (con traducción a español) con la aplicación de Lean que el inició y nombró.