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

24 junio 2015

Hackeando Agile - De vuelta a los principios ágiles

Acabo de llegar de la Agile Open Spain 2015 y, como siempre, me traigo ideas nuevas para trabajar.

En esta edición hemos discutido sobre relación con el cliente, equipos, eficiencia, hemos traído nuestros problemas y retos y los hemos presentado a los demás, pero también hemos hackeado Agile con el Dojo de #NoIfs y con las discusiones #NoProjects #NoEstimates #NoTeams #NoProductOwner.

De todas las AOS, en mi bolsa de ideas, siempre reservo la "caja del tesoro" para lo que más me ha llamado la atención. En esa caja me traje el año pasado el cómo aborda Diego Rojas el coaching, para mí el descubrimiento del año.

Este año han sido Joserra Díaz y Jorge Uriarte los que me han hecho pensar en qué estamos haciendo mal para que a tantas empresas les cueste tanto aplicar correctamente las prácticas ágiles.

https://twitter.com/aos2k15/status/612211994708606976

Jorge nos lanzó la pregunta de en qué punto creemos que se encuentra la adopción de los marcos ágiles de trabajo - en nuestro entorno laboral -. Hubo diversas opiniones, desde quienes piensan que estamos al inicio de la curva de adopción hasta los que opinan que estamos en la cima.

New Product Adoption

Pero un punto nos quedó claro: muchas empresas lo intentan más de una vez y desisten del intento, otras implantan prácticas ágiles de modo incorrecto no consiguiendo el objetivo de la práctica en sí y son muy pocas las que consiguen tener un marco de trabajo ágil correcto, con lo que he aquí la pregunta: ¿Debemos aceptar el fracaso ágil?

Como juego para hackear Agile, este título no es más que un reto para que nos preguntemos qué está pasando.

Con las opiniones de unos y otros y las muy valiosas de Xavier Gost, que es un exponente claro de la base sólida Agile, fuimos desgranando los motivos de por qué estamos donde estamos...

Intentamos aplicar las prácticas de Agile olvidándonos de que esas prácticas se basan en los principios Agile

Y es cierto.

¿Cuántas veces escuchamos hablar sobre Scrum, Lean, Kanban, TDD, Clean Code, Inceptions, Motivation, GTD, Pomodoro, Retrospectives y muchas otras prácticas para mejorar en eficiencia, comunicación, desarrollo, entregas y cuántas otras veces escuchamos a alguien mencionar los doce principios que promueve el Manifiesto Ágil?

La verdad es que no necesitamos hacer TDD, necesitamos ser capaces de hacer desarrollos simples que funcionen, "maximizar la cantidad de trabajo NO hecho".

No necesitamos Scrum, necesitamos entregar frecuentemente software que funcione.

De hecho, no necesitamos entregar por entregar, sino entregar software que tenga valor para el cliente porque nuestra máxima prioridad es satisfacerle.

Es más, implantar estas técnicas "desde las trincheras" como hemos hecho muchas veces, nos lleva a esta situación en la que podemos practicar, pero no conseguir un paso constante, seguro e interiorizado de las prácticas ágiles, porque para que funcionen las personas de negocio y las de desarrollo deben trabajar juntos y a diario en los proyectos (o en un #NoProject ;)

Quizá nos convendría poner en un mapa estos doce principios y asociar cada técnica que empleamos al principio en el que se basa, para que no olvidemos el por qué queremos usar esa técnica... ese "SO THAT" en que hacemos tanto hincapié.

Eso me he traído esta vez en mi caja del tesoro. Ahora que la he abierto estoy venga a jugar con esas ideas.
Jmmm...


20 agosto 2013

Caso de Éxito: Scrum en un proyecto de 3 meses

Me habían pedido muchas veces que publicara cómo hicimos para que este proyecto tuviera un principio y final felices y aquí va mi retrospectiva personal.

Proyecto: Proyecto de software para industria.

Cliente: Familiarizado con las tecnologías de software, había oído hablar de Scrum, pero nunca lo había usado como marco de trabajo.

Equipo: Tres personas. Dos de ellas habían trabajado con Scrum, otra no lo conocía. Las tres personas tenían una velocidad de trabajo diferente.

Mi empresa: Nos da la libertad de gestionar el proyecto siempre que se obtengan los resultados esperados, según mi opinión, en este orden:
  1. Calidad: la máxima posible, intentando no afectar las fechas planificadas
  2. Fechas: lo más cercano a las planificadas, intentando no afectar los requisitos
  3. Requisitos: los acordados con el cliente al principio del proyecto o los que se acuerden a lo largo del proyecto

Inicio del proyecto


Los requisitos, las fechas y el presupuesto ya estaban pactados con el Cliente, pero como hago siempre, reviso de nuevo los requisitos y vuelvo a realizar una estimación predictiva con al menos uno de los miembros del equipo que va a formar el proyecto para hacerme una idea de la presión que vamos a tener. En este caso, preveía una desviación de aproximadamente un 20%.

Decidimos – el Equipo de Desarrollo – hablar con el Cliente para volver a analizar en profundidad todos los requisitos y de paso construir el Product Backlog. Para ello, sin usar términos de Scrum, le comentamos que queríamos reunirnos con ellos para analizar todos los requisitos.

Mi idea era realizar parte de una Inception, que me permitiera dejar claro a todos las partes del proyecto qué es lo que íbamos a hacer y cómo lo haríamos.

¿Por qué no toda la Inception? Pues porque era la primera vez que iba a jugar con esta técnica y porque se supone que ya estábamos consumiendo horas del proyecto en la que no se había presupuestado tiempo para esto. De modo que seleccioné aquellas preguntas que creí me permitirían acotar mejor el proyecto:
  • Definir el proyecto en una explicación corta y concisa
  • Definir qué NO es este proyecto
  • Comentar qué podría quitarnos el sueño durante el desarrollo de este proyecto
  • Conocer a los vecinos – esa lista de implicados, sean personas o no, a los que afectará el proyecto

De estos puntos lo que más nos ayudó, sin ninguna duda, fue definir “Qué podría quitarnos el sueño”. Fue lo que más nos ayudó con diferencia. Y en orden, saber “qué no es este proyecto”, luego alguna vez recurrimos a la definición del proyecto y por último, para las Historias de Usuario y definición de la seguridad, a la lista de vecinos. El haber hecho estas preguntas fue decisivo para que el proyecto llegara a buen puerto.

Luego, en un par de jornadas duras escribimos las Historias de Usuario del Product Backlog, de modo que el cliente quedó contento porque reflejaban de forma clara qué se quería hacer, para quién y por qué, aunque no estaba reflejado el cómo. Cada vez que escribíamos una, comentábamos brevemente, junto con el equipo, sobre la dificultad de la historia de usuario y le asociábamos un valor que representaba ese esfuerzo. Habiendo explicado muy rápido cómo definíamos ese valor, por qué usábamos puntos y no horas y por qué mientras más esfuerzo más separación había entre un valor de esfuerzo y el siguiente, no hubo problemas.

Cabe decir que para escribir las Historias de Usuario leímos más de una vez la oferta formal que se hizo para la contratación del proyecto, pero salieron muchas cosas que no estaban escritas en la oferta, de modo que la satisfacción estaba asegurada para todos. Así llegamos a completar la lista inicial del producto y nos hicimos una idea de cuánto esfuerzo nos llevaría desarrollar todo lo que se quería.

Una vez conocido el esfuerzo total (recalco: inicial) – hicimos un cálculo muy sencillo:
  • Explicamos al cliente que el equipo tenía una velocidad de trabajo de N puntos diarios y que esos puntos reflejaban:
    • la cantidad de trabajo que el equipo era capaz de sacar adelante cada día, es decir, la capacidad diaria de trabajo
    • que esa capacidad diaria (N puntos) es equiparable a los puntos de esfuerzo asignado a las tareas
  • Luego, teniendo la fecha límite para la entrega del producto, contamos los días laborables y determinamos la capacidad de trabajo total - aproximada- hasta la fecha de entrega y vimos que no coincidían, como casi nunca coincidirán. Para desarrollar todas las historias de usuario se necesitaba más esfuerzo que capacidad tenía el equipo.
Viendo esto, le explicamos que eso sucede en la gran mayoría de los proyectos y es por eso que se entregan fuera de plazos, con poca calidad y muchos errores, y que para evitar eso, lo que nos aseguraba la calidad era la priorización de tareas por períodos de tiempo de 15 a 20 días y la entrega, demostración e instalación del producto al final de cada período.



Triángulo de hierro
Es en este punto donde se produce un problema de negociación importante. Es en este punto clave donde hay que explicar bien, si no cabe todo, por qué no cabe y qué consecuencias traería intentar desarrollar todo con los mismos recursos en el mismo tiempo. Es en este punto – el más importante de la negociación del tan famoso triángulo de compensación – donde se va a definir qué se mueve de los pilares del proyecto: Coste/Recursos, Tiempo/Fechas o Alcance/Funcionalidades. Nosotros conseguimos explicarnos bien y he de reconocer que teníamos un cliente que comprendía las consecuencias de una decisión incorrecta – decidimos que variarían las funcionalidades a desarrollar y que las menos importantes, quedarían fuera del desarrollo, se realizarían en fases posteriores.


Cuando hay funcionalidades que se quedan fuera de alcance la mayoría de las veces se recomienda – en este orden:
  • [Alcance] Dejar fuera aquellas funcionalidades menos importantes del proyecto, para futuras fases, después de probar, entregar y facturar lo que se ha desarrollado – Esto es sencillo si se prioriza bien al principio de cada Sprint.
  • [Coste] Ampliar el equipo hasta donde lo permita el proyecto y abordar más funcionalidades. Esto requiere una ampliación del presupuesto y requiere que la empresa cuente con personas capaces de integrarse en el equipo existente. – Dos opciones difíciles de conseguir.
  • [Tiempo] Como opción última y menos recomendable, mover la fecha de entrega final. Esta opción también requiere variar el presupuesto, porque a más tiempo de desarrollo, más costes para el proyecto – y este es un punto de muy difícil negociación una vez firmada la oferta.
    • Hay que intentar por todos los medios no mover la fecha de entrega final, porque será el comienzo de una fecha de entrega cambiante que alargará indefinidamente el tiempo de desarrollo y los costes del proyecto.
Nosotros decidimos optar por la primera opción (dejar fuera aquellas funcionalidades menos importantes) ya que ampliar el presupuesto para ampliar el equipo no estaba en los planes. Casi siempre es la opción escogida.

Y dicho esto, ¡comenzamos con el primer Sprint!

Inicio de cada Sprint


Ya en las reuniones de inicio del proyecto le explicamos al cliente que para obtener el producto que él necesitaba, nosotros, el equipo, necesitaríamos compromiso por su parte y que era imprescindible que estuviera al principio y al final de cada Sprint para validar que el trabajo que íbamos a hacer era el que él necesitaba.

De modo que habiendo llegado a un acuerdo, antes de iniciar cada Sprint hacíamos, junto con el cliente, una selección de Historias de Usuario.

¿Cómo las seleccionábamos?

La primera vez fue un poco duro porque nuestro Product Backlog no estaba priorizado, de modo que comenzamos por priorizarlo todo. Nuestra técnica para priorizar fue la siguiente:
  • Decidimos priorizar asignando valores de 1 a 100.
  • Aquellas Historias de Usuario con una prioridad de más de 75 puntos quedarían fuera del alcance de nuestro desarrollo y podrían abordarse en fases posteriores. Es importante matizar esto para evitar la idea de que esas funcionalidades nunca se van a hacer.
  • Comenzamos por la primera Historia y le asignamos una prioridad.
  • Pasamos a la segunda Historia y le asignamos una prioridad respecto a la primera Historia priorizada con una pregunta muy sencilla – “¿esta Historia es más o menos importante que esta otra?” – y luego, sabiendo si era más o menos importante, teníamos un valor de referencia para priorizarla.
  • Pasamos a la tercera historia y la priorizamos respecto a las dos Historias ya priorizadas, usando la misma pregunta.
  • A partir de la cuarta Historia teníamos varias referencias para priorizar y era mucho más sencillo decidir cuándo se debía hacer esa Historia, si antes o después de otra.
  • Si no teníamos claro el orden en que debíamos poner dos Historias de Usuario podíamos darles la misma prioridad o cambiar algún valor de prioridad que habíamos dado anteriormente a otra Historia.
  • Al Product BackLog podían entrar nuevas Historias de Usuario en cualquier momento. Al inicio del siguiente Sprint les asignábamos un esfuerzo y las priorizábamos.
Al saber cuánta capacidad de desarrollo teníamos hasta la fecha de entrega y tener priorizadas –ordenadas- las Historias, sabíamos qué se quedaba fuera cada vez que entraba una nueva historia. Eso permitía al cliente ver, en todo momento, las consecuencias de los nuevos requisitos y priorizar mejor, porque la prioridad indicaba qué entraba y qué no entraba en cada versión del producto final.

Y una vez priorizadas, seleccionamos las Historias de Usuario del Sprint por comenzar. Para seleccionarlas, en vez de decidir primero los días que iba a tener el Sprint, seleccionábamos un grupo de ellas que ocuparan de 15 a 20 días de desarrollo – las más importantes. Los pasos que hacíamos eran:
  • Seleccionar las Historias más importantes, según su prioridad, de modo que la suma del esfuerzo ocupara de 15 a 20 días de desarrollo, atendiendo a la velocidad del equipo de desarrollo.
    • Si ya el cliente había probado una versión anterior del producto:
      • Hablamos de los cambios que deseaba incluir o las incidencias que había encontrado.
      • Los cambios ya sabemos cómo los tratamos: incluimos y priorizamos antes de comenzar la selección.
      • Las incidencias son la mayoría de las veces responsabilidad nuestra y tenemos que resolverlas como primeras tareas del siguiente Sprint, suman tiempo al Sprint, tiempo que debe asumir el equipo y que no suele ser facturable.
    • Si se habían incluido Historias de Usuario – cambios – durante el desarrollo del Sprint anterior, se priorizaban antes de comenzar la selección.
  • Definíamos en presencia del cliente las Tareas a realizar por cada Historia de Usuario y le asignábamos el tiempo de desarrollo a las tareas, esta vez en horas. Comprobábamos que la suma horas de las tareas se correspondía con el esfuerzo que habíamos asignado a la Historia de Usuario contra la Velocidad de trabajo. Si no se correspondía, modificábamos el esfuerzo de la Historia, para ser realistas.
    • En cada tarea poníamos, junto con el cliente, lo mejor que sabíamos, los criterios de aceptación
    • Dentro de las tareas de cada Historia, como costumbre personal, incluimos la de actualizar la Guía de Usuario y la Guía de Instalación, de modo que con cada entrega tuviésemos actualizada la documentación a entregar – por cada tarea. Esto me ha demostrado un ahorro de tiempo considerable.
  • Por último, definíamos los días que ocuparía el Sprint y la fecha de la próxima reunión, donde realizaríamos la demo y entregaríamos al cliente el desarrollo realizado para que lo instalase en los servidores, junto con la documentación que le permitiría instalar y trabajar con el producto.
Me gustaría recalcar dos puntos que considero muy importantes:
  • En el primer Sprint incluimos todas las tareas necesarias para montar la arquitectura inicial del proyecto. Esas tareas las incluimos delante del cliente, de modo que viera que “eso” también lleva tiempo. No hubo problemas con la asignación de tiempo para ello.
  • En el primer y segundo Sprints decidimos incluir todas aquellas funcionalidades relacionadas con “aquello que nos quita el sueño” y que hablamos en la Inception. Esta decisión nos quitó muchísimas preocupaciones de encima a lo largo del proyecto, ya que todos los problemas que podían surgir se solucionaron en la primera mitad del proyecto, consiguiendo el final feliz que todos queríamos.

Reuniones de planificación, seguimiento, entrega y todas (y sólo) las que sean necesarias


Respetar el tiempo de los demás es primordial para que las reuniones sean efectivas y no se vean como innecesarias o como un retraso en el trabajo.

Para ello, es muy importante al realizar una convocatoria poner bien claro de qué se va a hablar en la reunión y poner una duración realista para que todos sepan de antemano a qué se va y cuánto tiempo se va a estar.
Por lo demás, hay mucha documentación que ayuda a mantener reuniones efectivas. De modo que no comentaré este punto.

Durante todo el proyecto intentamos, por todos los medios, mantener las reuniones que recomienda Scrum y lo conseguimos. Nos reuníamos tanto de forma presencial como en remoto.

No sólo nos juntábamos en el momento de la reunión, sino que cuando hizo falta, hicimos pair-programming aunque tenemos que mejorar en las técnicas a emplear y cualquier otra vez que lo necesitábamos, nos juntábamos para comentar cómo abordar un determinado detalle del proyecto. – Nunca nos pareció que nos juntásemos más de la cuenta, la verdad, y cuando pensábamos que nos estábamos enrollando mucho cualquiera de nosotros lo decía y decidíamos lo que fuese – o seguir o cambiar o arrancar a desarrollar de nuevo.

Es responsabilidad de todo el equipo – incluyendo al cliente, claro está – el no malgastar el tiempo. De cualquier modo, cuando tenemos las tareas ahí, frente a la cara, esperando para ser desarrolladas y un tiempo con el que nos hemos comprometido, sabemos que hay que trabajar porque es nuestra palabra el entregar en tiempo y forma lo que hemos dicho.

Y no sé qué más contaros… ah sí, una cosa, en el último Sprint decidimos “probar” a no actualizar las guías de usuario y de instalación en cada tarea, sino actualizarlas al final, como última tarea, antes de la demo con el cliente. Resultado? – Esa vez no pudimos entregarlos porque nos concentramos en terminar otras cosas más importantes.

Post-Proyecto


Una vez entregado el último paquete del producto nos cogimos un par de semanas por nuestra cuenta para probar bien el producto e ir solucionando aquello que no funcionase bien. Esto nos lo pudimos permitir por la carga de trabajo de ese momento. Por lo general ese tiempo debe estar planificado dentro del proyecto, desde el inicio, y casi nunca se hace para abaratarlo. No debería haber problemas si se desarrolla bien, pero eso es casi una quimera.

El cliente no nos reportó prácticamente ninguna incidencia y las que encontramos por nuestra cuenta las resolvimos e hicimos una última entrega.

Ya que el cliente planeaba continuar ampliando por su cuenta el producto, pero quería realizarnos consultas o solicitarnos pequeños desarrollos se le propuso una bolsa de horas en las que nos pudiera solicitar cualquier desarrollo sobre el mismo u otro producto y las consultas que necesitase y fue aceptada.

El cliente nos envió un mensaje contándonos lo cómodo que estuvo durante el tiempo de desarrollo y su satisfacción con el producto final.

Nosotros aprendimos a valorar – yo una vez más – la comodidad del trabajo con Scrum.

Hay muchos más detalles sobre el trabajo de desarrollo día a día, pero cada uno de ellos merece ser explicado con calma.

Espero que esta historia os sirva para algo y si hacéis otras cosas que nos permitan mejorar el trabajo y sentirnos más cómodos al abordar un proyecto, estaré encantado de que me lo contéis.

08 febrero 2010

Storypoints – y la eterna pregunta de “¿cuántos pongo?

[[ El ñaco me ha preguntado ]]

1- ¿Cómo determinas la capacidad de un sprint, especialmente del primer sprint (no tienes anteriores para basarte en ellos)?

2- ¿Como cuantificas el esfuerzo de una historia? Esto para mi tiene relación directa con la medida que se tomo para calcular el sprint.

Repasando apuntes de Scrum me encuentro con que:

1- Los equipos en el sprint planning meeting estiman "esfuerzo" o puntos de historia. ¿Y entonces quién da la duración de una historia? (Nosotros no estamos haciendo esto, creo que siempre tocábamos la duración)

2- El esfuerzo no esta relacionado directamente con el tiempo. Pero la mayoría de ejemplos que encuentro si calculan la capacidad en base al tiempo y dedicación (eficacia) de los recursos disponibles, por lo que, ¿el esfuerzo no queda inmediatamente asociado al tiempo?

[[ Y le he respondido ]]

(…) A mí me costó entenderlo también.

Te lo explico en breves pautas que suelo seguir, aunque el segundo punto que has encontrado sobre apuntes de Scrum lo resume bien:

- Los storypoints dan un valor al esfuerzo necesario para realizar una historia de usuario.

- La carga de trabajo de la historia, como bien dices, no queda asociada de forma directamente proporcional al tiempo real del que dispones.

- El esfuerzo estimado en puntos se asocia de forma relativa al tiempo. Esa relatividad la das tú.

- Si asumimos que una persona hábil, a capacidad normal, puede hacer dos puntos cada 8 horas (lo tengo demostrado), puedes hacer una estimación aproximada de cuánto va a tardar en realizarse esa historia.

- A partir de ahí, si sabes que esa persona tiene constantes interrupciones, entonces el esfuerzo en realizar 2 puntos, en vez de 8 horas, será de 10 o 12 horas.

- Lo mismo pasa si la persona no es muy hábil o no conoce el entorno de trabajo, que el tiempo que tarde en desarrollar esos dos puntos será mayor que el tiempo ideal.

- Finalmente las horas asignadas van a ir llenando el sprint, dependiendo de las horas que tengas configuradas como horas de jornada de trabajo (horas diarias) y los días que le tengas asignado al sprint, quitando los días festivos, de descanso u otras excepciones que pongas en el sistema con el que scrumices todo.

Hay algunos documentos que dicen que el desarrollo tope de un programador son dos puntos diarios, pero no lo creo. Un desarrollador ágil, dedicando 8 horas al día a programar, menos media hora de café y media de interrupciones, es decir, 7 horas al día, es capaz de hacer 2 puntos y medio de esfuerzo.

Estimar menos para programadores ágiles dedicados full time a un proyecto será estimar holgadamente. Obsérvalo tú mismo.

clip_image002 clip_image004

(…)

¿Estáis de acuerdo conmigo? Porque quizá soy yo el que anda estimando mal las historias…

Un saludo a tod@s.

27 octubre 2009

SCRUM, nuestra experiencia

> Nada

> Documento de tareas a partir de requerimientos en papel, estimado y con estado de las tareas. El equipo lo va actualizando.

RESULTADO:

- El equipo sabe qué tareas hacer y mejora en tranquilidad.

> Sprints en Excel planificados por el Jefe de Proyectos (JP), a partir de tareas en papel.

MÁS RESULTADOS:
- El equipo VE el progreso del desarrollo y lo que queda por terminar
- El JP puede estimar mejor las siguientes tareas
- Se sabe qué se va a entregar al terminar cada sprint

> ScrumDesk para gestión Scrum, historias de usuario (HU) a partir de requerimientos en papel, cálculo de capacidad de sprints, casi-daily sprint.

MÁS RESULTADOS:
- Equipo involucrado, mejora el ánimo y la cohesión
- Mejora en la visibilidad de tareas pendientes, comenzadas, terminadas y validadas.
- Control de la cantidad de tareas comenzadas a la vez
- Control de la velocidad del equipo, y la carga de trabajo en cada sprint
- Mejora en la planificación y seguimiento del sprint

> Análisis de fallos, planteamiento de próximas actuaciones

- Pasar los requerimientos en papel a un documento
- Convertir requerimientos en HU
- Escoger y priorizar con el cliente y el equipo las HU del siguiente sprint
- Convertir el casi-daily sprint en un daily sprint
- Hacer la retrospectiva (equipo) y la review (con el cliente) de los sprints
- Marcar como validados los requisitos implementados
- Repetir hasta release y entregar

RESULTADOS ESPERADOS:
- Equipo aún más involucrado
- Cliente contento y con la sensación de que se está haciendo lo que espera del producto
- Mejora en las estimaciones de horas de futuros proyectos
- El producto final llevará lo que es más importante para el cliente

Nos falta mucho, pero vamos venciendo etapas.

Se admiten sugerencias…

09 octubre 2009

“Eso” que rodea a SPRINTS y BACKLOGS

…o “¿dónde están todos los requisitos?”…

En nuestra poca experiencia en SCRUM hemos tenido un problema de “desorden” que donde se nota es al final de los proyectos, en las entregas, no de los sprints, sino de las releases.

En las entregas nos encontramos con que algunos requerimientos no los habíamos implementado. No por no haberlos recogido o analizado, sino porque los medios donde recogíamos los requerimientos eran “diversos”… correos-e, documentos de requisitos, notas de reuniones (actas). Y no es la diversidad de “artefactos” lo que hacía que se extraviaran algunos requisitos, sino la indisciplina de, una vez recogidos, no pasarlos, centralizarlos en un medio común.

Lo peor de todo es que algunos de esos requisitos no implementados (que finalmente encontramos), el cliente los consideraba importantes, y en ningún momento los incluimos en las planificaciones.

Achaco este desorden a no tener definida una herramienta donde recoger los requisitos, donde centralizarlos. Teníamos una, pero no la utilizábamos bien… la “vista” que utilizábamos era “guay” pero no “útil”. Una lista en grid, donde se puedan ordenar, priorizar, ponerles el estado, compartir, es la mejor opción.

Pero sólo utilizar una. La opción de pasarlos en Excel para enviarlos al cliente no es válida. La opción de pasarlos en Word temporalmente y luego ya los pasaré a la herramienta de requisitos tampoco. La opción es pasarlos a la herramienta y luego exportarlos a donde necesitemos.

Mi objetivo de los últimos días es disciplinarnos, centralizarnos, compartirnos y actualizarnos… y, claro, encontrar la herramienta. Es sabido que no existe la herramienta “mágica”. Que hasta con archivos de texto podríamos realizar este trabajo. Pero en el proceso de scrumización, la disciplina es importante y la herramienta ayuda mucho a mantener la disciplina, facilitando el trabajo a aquellas personas que tienen que mantener la información asociada al proyecto. Si una herramienta no facilita el trabajo, sino que lo entorpece, tendemos a no usar la herramienta, a dispersarnos y a usar cada uno la suya. Vaya… lo mismo que pasa con las aplicaciones que hacemos.

Ahora… que tengo un punto más sobre el que trabajar, mientras lo desarrollo, me pongo con el siguiente punto: los tests. En la charla de “Gestión Ágil con TFS, SCRUM y buenas prácticas” que nos dio Rodrigo Corral en las sesiones Microsoft ALM ‘09 de Madrid, comentó una cosa que hizo temblar una vez más… dijo una de aquellas frases que son como un golpe de puño en la mesa: de nada sirve la metodología sin tests unitarios, gestión del código fuente, builds automatizadas.

Voy a atacar a los tests, pero, ¿qué va primero: el huevo o la gallina? ¿Implementar un proceso de testeo o implementar una metodología que permita definir qué validan los tests? Esperemos haber decidido la metodología de antemano no haya sido del todo incorrecto… que las dos cosas tengan que ir a la par, y que incluir los tests en el proceso no sea un trabajo de titanes: aprender, concienciar e implementar.

Os iré contando.