ES KAsi UN blog

Blog de Unkasoft, donde hablamos de programación de juegos para móviles, advergaming, marketing móvil, la industria de los videojuegos, metodologías ágiles y todos aquellos temas que nos preocupan en nuestro día a día

30 marzo 2009

Unkasoft presenta su implementación agile-CMMI


El próximo jueves día 2 de Abril, Unkasoft presentará su experiencia en la implementación de su proceso CMMI2, basado en la metodología ágil SCRUM.

Si estás interesado en temas de metodologías, agilidad o procesos, y tienes curiosidad por saber cómo hemos mezclado temas tan dispares como SCRUM, CMMI o programación de juegos, puedes inscribirte de forma gratuita en la página del evento.

Etiquetas: , ,


14 julio 2008

El mundo de las catedrales

Siempre me ha fascinado el mundo de las catedrales medievales: su estilo, sus leyendas, sus personajes, sus intrigas, pero sobre todo: su construcción.
Hoy, viéndolo desde la perspectiva, nos parecen obran maestras, de ejecución perfecta y resultado inmejorable. Sin embargo, me gustaría poder preguntarle a los maestros (como Tom Builder de Los Pilares de la Tierra) su opinión sobre el resultado de su trabajo. Estoy seguro de que no sería tan positiva. Y es que las catedrales no son perfectas: sufrían retrasos de lustros (incluso siglos), durante su construcción se iba cambiando constantemente el estilo y las técnicas constructivas (a menudo se comenzaba los muros inferiores en estilo gótico y se terminaban las bóvedas y cúpulas en estilo renacentistas), los arquitectos morían y eran remplazados por otros según pasaban los años... sin embargo, ahí están viendo pasar los siglos, y provocando admiración a todos los que las contemplamos.

Yo tengo la suerte de disfrutar de las vistas de la catedral de Salamanca (las que véis a la izquierda) en mi viaje diario de las oficinas hasta mi casa, y como es lógico, en ese viaje se entremezclan mis pensamientos sobre el día con mi especial admiración por esta catedral. Y es que nuestro trabajo diario tampoco es tan distinto del de aquellos siglos. Como ellos, los que vivimos la informática en nuestros días estamos inventando el oficio. La arquitectura lleva miles de años de evolución, la informática tal y como la conocemos no llega a un siglo, y eso se nota. Como ellos, en el desarrollo de un proyecto a largo plazo, cambiamos muchas veces nuestro estilo y técnicas constructivas, y aunque eso pueda parecer "falta de coherencia" para los puristas, para mi no es más que pura evolución positiva. Y como ellos, tenemos que priorizar el avance y el llegar a la meta, a ser fieles e inflexibles con ideas originales que posiblemente no fuesen acertadas (o que ya están obsoletas).
Me imagino a Tom Builder hablando con unos y otros, intentando convencer al maestro cantero de que no se puede tirar media catedral para ser fieles al estilo original, hablando con otros arquitectos para inventar la forma de que los contrafuertes sostengan esa nueva bóbeda que no estaba prevista, intentando conseguir más obreros para reducir el retraso, hablando con el cardenal para pedirle más fondos...

En definitiva, cuando viene Carlos y dice que hay que rehacer los scripts de build y test porque son inmantenibles, cuando Félix se queja de que la arquitectura no es buena y que hay que cambiarla, cuando Javi dice que Java es una mierda y que el lenguaje nos limita, cuando Antonio nos avisa de que la cosa está complicada para llegar a fechas... no hago más que acordarme de esa catedral que ha visto pasar tantos siglos, que me acompaña en mi camino de vuelta a casa, y de cómo los maestros de aquella época fueros unos auténticos magos de la arquitectura (y sin saberlo, de la gestión de proyectos). Si Tom Builder estuviera aquí... ¡cuántas cosas le preguntaría!

Por cierto, no dejéis de echar un vistazo a todas estas fotos.

Etiquetas: , ,


26 abril 2007

Ramas en subversion

Cuando se va a implementar una nueva caracterísitca en Unkasoft Platform, bueno, cualquier software en realidad, corres el peligro de esa nueva característica deje el software inestable o peor, sin nisiquiera compilar.

Para evitar que la inclusión de algo nuevo impida a los demás continuar su desarrollo usamos el mecanismo de ramas que aporta subversion. Básicamente el sistema se basa en hacer una "copia" del código actual y llevarlo a un presente paralelo en el que si haces cambios no afectan al código principal (también llamado trunk). Una vez se ha terminado de modificar el código en ese "universo paralelo" hay que volver a la realidad, esto es, mezclar los cambios de la rama con trunk.



Dicho esto ya se pueden enumerar varias pegas:
1.- si tardas mucho en mezclar una rama al final el mezclado con trunk es un infierno
2.- se hace difícil de gestionar y de mantener, sobretodo si no tienes "acoplado" subversion con el tracker de ramas.

En un principio planteamos usar este sistema para cualquier bug o mejora que tuvieramos que implementar, sin embargo los dos puntos anteriores nos echaron hacia atrás, dejándo solo la creación de ramas para cambios que pudiesen desestabilizar el sistema. Es lo que denominan "The Branch-When-Needed system".

El sistema usado tiene sus ventajas:
- aisla un cambio de otros, con lo cual si dejas el código a la mitad no afecta a nadie
- se pueden probar las caracterísitcas por separado con la ventaja de si salen bugs se pueden corregir sobre la misma rama sin llegar a la principal

y sus pegas:
- es un infierno hacer merge de ramas antiguas. Hemos puesto como límite de vida de una rama una semana para evitarnos males mayores.
- con los renombrados, copias y demás se hace un poco lioso (aún más) el proceso de mezcla.
- es difícil de mantener si no hay alguien que controle las ramas activas, aunque sean pocas. Durante una semana se puede olvidar actualizar el tracker y al cabo de un tiempo no sabes si mezclaste o no.

Por ahora nos vamos acostumbrando al proceso, estamos buscando el mejor sistema para que las mezclas no sean tan traumáticas y para automatizar algunos procesos como por ejemplo la creación de ramas, la numeración de las ramas para QA, etc, etc (siempre hay algo que automatizar). Menos mal que está ant de por medio, aunque muchas veces se echa de menos la potencia de python :(. La teoría es buena pero la práctica no lo es tanto.

¿y tú? ¿te vas por las ramas o prefieres tener los pies sobre trunk?

Etiquetas: ,


04 abril 2007

Test unitarios en grupos de trabajo

No es la primera vez que en este blog se habla de test unitarios y seguramente esta no será la última, pero en este caso voy a dejar un poco al lado la teoría y hablaré de la práctica, del uso diario que se le puede dar a los test unitarios y que tratamos de aplicar en Unkasoft.

Una de los desarrollos actuales de Unkasoft es Unkasoft Platform, una herramienta para atajar el problema de la fragmentación en el mundo de los móviles y que permite, de una forma cómoda, crear todos los contenidos para desarrollar un juego en una amplia gama de móviles. Aunque estemos acostumbrados a ver multitud de herramientas gráficas para todo (grabar un CD con Nero, crear imágenes con photoshop), muchas veces es difícil darse cuenta de la complejidad que hay por debajo.

En el desarrollo de Unkasoft Platform trabajamos un grupo de personas, cada cual hace y deshace parte del código, corrige bugs, incluye nuevas características, pero es imposible que en un proyecto con cierta complejidad, como es UP, una sola persona esté al tanto de todos los posibles efectos colaterales del cambio de una clase o un método. Por ello la existencia de unos test unitarios impide (bueno, hace más difícil :) que un error cometido en una parte de código se propague a las demás. Si alguien hace un cambio que afecta al código de un miembro del equipo (que puede ser él mismo) ,cuando pase los test unitarios verá con facilidad que y donde la está liando.

La cosa no termina ahí. Las aplicaciones con un entorno gráfico suelen tener una curiosa inercia hacia el caos. Es habitual ver como el modelo vista controlador se convierte en un modelo de "controlo desde la vista", donde, por ejemplo, se ve como la gestión de los datos se implementa en un callback de un botón o similar. El uso de test unitarios te obliga a tener que separar lo más posible la parte controlador del resto ya que solo de esa forma es posible programarlos.

Como conclusión es fácil ver que "gastar" un poco de tiempo en realizar las pruebas unitarias te puede ahorrar horas de debug corrigiendo problemas que han incluído los demás o peor, tú mismo, o intentando refactorizar código distribuido por callbacks de botones.

Etiquetas: , ,


26 febrero 2007

Seminario de SCRUM en la UPSA

La semana pasada empezamos un curso sobre programación de videojuegos para móviles en la Universidad Pontificia de Salamanca.
Este curso se encuadra dentro de una de las becas de Fundación Caja Duero para estudiantes universitarios y pretende ayudar a un grupo de aventureros a que desarrollen su propio videojuego móvil. Y digo aventureros porque si no partes de base sólida y de las herramientas adecuadas, no es fácil acabar esta empresa con éxito, ¿verdad chicos?

La primera parte del curso trató sobre cómo enfocar el desarrollo, y se habló fundamentalmente sobre metodologías ágiles: SCRUM y eXtreme Programming.
Es divertido ver la cara de poker que pone alguien que acaba de estudiar "Ingeniería de Software II", cuando escuchan que las metodologías ágiles echan por tierra todas esas viejas ideas...

Pero recordad lo más importante: no os dejéis engañar, ni por los "clásicos", ni por los "ágiles". Cada proyecto debe buscar su propio equilibrio entre metodologías ágiles y clásicas (o formales). Habrá proyectos exitosos ágiles, y proyectos formales igual de exitosos, y eso no significa que unos sean unos inconscientes y otros unos carcas.
Buscad vuestro propio equilibrio, experimentad, sed críticos con lo que se dice en clase y fuera de ella... y entonces estaréis en disposición de poder elegir en cada momento lo que os convenga.

Hasta ahora sólo conocíamos una forma de desarrollar software... a partir de ahora ya sabéis que existe la alternativa.

Nuestra experiencia nos dice que las metodologías ágiles funcionan, tanto para hacer juegos móviles como para "software empaquetado", como nuestra plataforma.


A continuación podéis descargaros la presentación sobre metodologías ágiles y SCRUM que utilizamos en el curso.

Etiquetas: , , ,


13 septiembre 2006

SCRUM en Unkasoft: eXtreme Programming (XP)

Desde que empezamos nuestra serie sobre SCRUM, nos han llegados algunos correos vuestros preguntando sobre eXtreme Programming. ¿Seguís usando XP? ¿Se pueden usar XP junto con SCRUM? ¿En qué lugar quedan las prácticas de XP dentro de SCRUM?

Lo primero que hay que tener claro es qué es cada cosa:O sea: cada cosa para lo suyo.
Gracias a SCRUM conseguimos hacer un seguimiento continuo del proyecto, adelantando las sorpresas desagradables, para que nos de tiempo a reaccionar ante ellas. Conseguimos crear un buen ambiente de trabajo, dando a cada uno sus responsabilidades, e intentando no crear tensiones entre el equipo (aunque algunas son inevitables).

Sin embargo, si sólo usásemos SCRUM para gestionar el proyecto,no tendríamos sin ningún control en toda la parte de programación. ¿Cómo debemos escribir el código? ¿Qué tareas debemos hacer antes de codificar? ¿Y después? Aquí es donde entra en juego XP. Con eXtreme Programming tenemos una metodología ágil para programar, que encaja perfectamente con la filosofía que propone SCRUM. Quizá por esto último, el tandem SCRUM + XP se ha empezado a aplicar en varios proyectos de Microsoft e incluso en alguna empresa de videojuegos.

Así que todo lo que hemos contado de SCRUM lo intentamos combinar con las siguientes prácticas de XP:Pero hay algunas que hemos tenido que dejar a un lado:En definitiva: SCRUM por si solo se puede quedar cojo, ya que no da pautas específicas sobre cómo abordar la programación, así que combinándolo con eXtreme Programming conseguimos una metodología ágil mucho más completa.

Etiquetas: ,


30 agosto 2006

SCRUM en Unkasoft: el sprint backlog

Ya hemos hablado en un par de ocasiones del sprint backlog.
Por un lado, durante la planificación del sprint, tenemos que confeccionar el sprint backlog, y por otro lado, durante el daily scrum, hay que ir actualizando su contenido.

La teoría la sabemos, pero... ¿cómo confeccionamos y actualizamos en Unkasoft este sprint backlog?

Nosotros nos basamos en la plantilla para sprints de SCRUM que publicó hace tiempo Juan Palacio (con algún retoque nuestro).
Estuvimos evaluando otras plantillas, pero no nos han convencido por ser demasiado complejas (y porque apostamos por los productos nacionales :)

En esencia, la plantilla de sprint que usamos nos hace las funciones de tablón virtual donde vamos dejando tarjetas de las tareas a completar y las vamos moviendo de sitio cuando están terminadas.
Durante el daily scrum, actualizamos cada tarea, apuntando las horas que quedan para completarla, y la propia plantilla nos saca gráficas de esfuerzo (que los ingleses llaman burndown charts).

Basicamente, la plantilla tiene tres secciones:

Configuración:
Damos varios datos del sprint que vamos a realizar, como el número de días que dedicaremos, número de horas de trabajo al día, tipos de tareas a realizar (codificación, reunión, pruebas, documentación, etc.), estados de cada tarea, integrantes del equipo o días festivos que tendremos durante el sprint.

Datos:
Aquí apuntamos las tareas que hemos ido extrayendo durante la planificación del sprint, apuntando la estimación en horas, el tipo de tarea.
Por cada tarea, a la derecha tenemos las horas que faltan para completarse en cada uno de los días del sprint. Así, si no se avanza en una tarea, veremos como sus horas no disminuyen, lo cual es una cosa mala.
Basándonos en ese total de horas y en la velocidad de desarrollo (un factor entre 0 y 1 que hemos añadido), podemos calcular la fecha estimada de cierre, distinta para cada día del sprint, para así ver si vamos a buen ritmo o llevamos retraso.
Otra cosa que hemos añadido es una columna con las horas reales dedicadas a cada tarea, que rellenamos cuando la tarea se termina. Aunque SCRUM no habla nada del control horas estimadas-reales (sólo controla las reales), nosotros lo necesitamos por temas de presupuestos, costes, etc.

Gráficos:
Por último, basándonos en los datos de esfuerzo de cada tarea, podemos sacar el famoso gráfico de esfuerzo (burndown chart) y otros gráficos para ver la evolución de las tareas, cómo fluctúa la fecha de cierre, o la carga de trabajo asignada a cada programador.

Sobre cómo interpretar estos gráficos, hay mucho que hablar. Aquí cuenta mucho la experiencia y la intuición (como en todo gráfico que se precie), aunque os recomiendo que leáis este post sobre los cinco signos de problemas durante una iteración. Nosotros creo que ya los hemos sufrido todos (:
También existen gráficos más complejos para gestionar de forma correcta las tareas introducidas a mitad del sprint.

Bien, esto poco a poco va llegando a su fin.
El próximo día hablaremos un poco sobre cómo combinamos eXtreme Programming con SCRUM.

Etiquetas: ,


22 agosto 2006

SCRUM en Unkasoft: el daily meeting

El otro día estuvimos hablando de cómo podemos organizar los sprints de SCRUM, dejando en el aire el tema de las reuniones diarias (llamadas daily meeting)

Antes de entrar en harina, tenemos que presentar a la figura del Scrum Master.
SCRUM propone los roles de "product owner", "equipo de desarrollo" y "Scrum Master".
El Scrum Master es la persona que conoce la filosofía y el modo de aplicar SCRUM en una empresa. No se trata del clásico "jefe de proyecto", sino que es uno más del equipo, al mismo nivel que los demás, aunque con tareas distintas.
Como ya hemos dicho, en los proyectos típicos de SCRUM se trata de una persona que compagina esta actividad con otras (puede ser habitual que el Scrum Master sea también el "product owner", o un programador más), aunque en proyectos grandes quizá pueda haber un Scrum Master a tiempo completo.
Es importante que el Scrum Master sea una persona con cierta capacidad de decisión en la empresa, más que nada porque quizá tenga que tomar algunas decisiones difíciles para que el proyecto llegue a buen puerto.

Bien, hechas las presentaciones, podemos decir que el corazón de SCRUM es la reunión diaria, (también llamada "scrum" en referencia al movimiento típico de rugby). La reunión es un momento en que todo el equipo de desarrollo pone en común sus avances, sus dudas, pide ayuda, etc. Con una reunión diaria nos evitamos las desagradables sorpresas a punto de cerrar la versión, ya que se va viendo el avance (o el "no-avance") día a día.

En varios equipos de desarrollo que conozco desde dentro, el jefe de proyecto va mesa por mesa preguntando el típico "¿cómo vas?", o el programador avisa al jefe cuando ha terminado una tarea.
Recordemos que en SCRUM, no existe ese concepto de "el jefe revisa", sino que, como estamos hablando de equipos autogestionados, es el equipo al completo (programadores como tú y como yo) los que van revisando el trabajo de los demás.
Además es importante que el equipo vaya viendo los avances del proyecto al completo, y no sólo de su parte. Esto crea un sentimiento de pertenencia e identificación, y este sentimiento podemos decir que es la gasolina de la metodología SCRUM. Sin sentirse identificado, el proyecto SCRUM al final se parará igual que un coche se para sin gasolina.
Todo esto me lleva a recordaros una vez más la regla de oro: no intentes aplicar SCRUM en cualquier empresa y en cualquier equipo. Elige muy bien la gente y el ambiente de trabajo.

La reunión diaria no debe durar más de 10-15 minutos, para evitar las típicas reuniones interminables, donde nunca se saca nada en claro. En nuestro caso la reunión es muy informal y dura 2 minutos (: ya que sólo estamos dos programadores en el proyecto.
Así que no hay excusas del estilo: "no tengo tiempo para reunirme", porque seguro que estás perdiendo más tiempo leyendo esta página.

SCRUM define un modus-operandi más o menos establecido. Durante la reunión, cada integrante tiene que contestar tres cuestiones:
  1. ¿Que hiciste ayer?
  2. ¿Que vas a hacer hoy?
  3. ¿Que necesitas para seguir?
En el blog del Jeff Sutherland (uno de los creadores de SCRUM), explica con detalle el porqué de estas preguntas:

¿Qué hiciste ayer?
Con esta pregunta se pretenden dos cosas:
  1. Que todo el mundo este trabajando en las tareas que él mismo se asignó. Como ya hemos dicho, SCRUM no funciona del modo tradicional en que el jefe de proyecto dice: "Fulanito, para la semana que viene tienes que tener terminada la tarea X", sino que cada desarrollador se asigna las tareas que cree que puede hacer mejor. Es posible que alguien "se invente" lo que ha estado haciendo. Sinceramente: es su problema. Cuando llegue el fin del sprint quedará en evidencia al verse que sus tareas no están terminadas y se verá que ha estado mitiendo durante todas las reuniones.
  2. Que todo el equipo vea como avanza el proyecto. Siempre viene bien para la moral ver como tus compañeros avanzan a buen ritmo en sus tareas, y el equipo se mueve a un ritmo constante hacia un objetivo común. Esto ayuda a que los rezagados se den más prisa y que los desmotivados se auto-motiven. Ojo, hay que distinguir cuando un programador está por debajo de su capacidad, tiene algún tipo de problema personal o cuando no le apetece trabajar más. Cada caso requiere de acciones distintas del Scrum Master.
    Hay veces en que los retrasos se deben a que el programador no es consciente de las consecuencias que acarrea un retraso en su código, y por eso se toma las cosas con más calma. Es natural y no suele ser culpa del programador: nadie se lo ha explicado y él no tiene porqué saberlo (típico en empresas con poca o nula comunicación). Con esta reunión se elimina este problema: todo el mundo es muy consciente cuando hay que correr porque se está esperando a que termine, o cuando las cosas se pueden tomar de una forma más relajada.
En este momento el programador actualiza el "sprint backlog" para reflejar el tiempo que queda para terminar la tarea con la que estaba (más adelante explicaremos cómo está organizado y cómo trabajar con el sprint backlog).

¿Que vas a hacer hoy?
En esta pregunta, cada integrante se asigna las tareas que más le gusten, dentro del sprint backlog. Ni el equipo, ni el Scrum Master deben obligar a nadie a hacer una tarea, sino que tiene que ser el propio programador el que elija la que quiere hacer. ¿Por qué? pues sencillamente porque nadie sabrá mejor que el programador las tareas que puede hacer mejor y más rápido. Por lógica, todo el mundo elegirá las tareas que le vayan mejor a sus habilidades y conocimientos, así que poco a poco las tareas se irán asignando de la forma más óptima sin intervención externa (teoría del caos en estado puro :)
Según avanza el sprint, van quedando pendientes las tareas que nadie ha elegido. En ese punto el Scrum Master pude sugerir, pero no obligar.
Hay metodologías que sugieren que las tareas con mayor riesgo deben hacerse antes que las de menor riesgo. Eso tiene su lógica, así que en caso de duda, deberíamos elegir siempre las tareas con mayor riesgo.

¿Que necesitas para avanzar?
Muchas veces, en las empresas tradicionales, las personas que están en puestos de responsabilidad olvidan su principal función: organizar y gestionar el entorno para que sus subordinados pueden trabajar en las mejores condiciones posibles (al fin y al cabo, se trata de maximizar el rendimiento del sueldo que se les paga). Sin embargo, muchos los jefes se quedan con la parte bonita, "organizar y gestionar", olvidándose de para qué se les ha dado ese "poder".

En esta pregunta, el programador lanza un aviso al equipo (y especialmente sobre los que más responsabilidad tienen en el equipo) sobre qué aspectos le tienen bloqueado o deben ser mejorados. El Scrum Master debe hacer lo posible por solucionar esos puntos críticos, aunque si algún otro programador tiene la solución al alcance de la mano, debería decirlo (siempre que haya un buen clima lo hará, pero si hay problemas entre miembros del equipo, no cuentes con que la ayuda surja espontáneamente).

Algunos problemas típicos son:
Algunos problemas puede que se resuelvan facilmente (por ejemplo, añadiendo nuevas tareas al sprint backlog), sin embargo, a veces las cosas se complican.

Si el proyecto está en apuros, lo habitual es que la lista de problemas sea cuando menos generosa. En ese momento, el Scrum Master debe ir recopilando esa lista en un "impediments backlog", o la "pila de problemas". A partir de ese momento, la prioridad del equipo no es avanzar en el "sprint backlog", sino hacer que ese "impediments backlog" desaparezca lo antes posible. Para ello se asignarán los distintos impedimentos a personas del equipo de desarrollo, o incluso a personas fuera del equipo (el administrador de red, el responsable de compras, etc.). Al día siguiente, se revisará tanto el "sprint backlog" como el "impediments backlog", eliminando aquellos impedimentos que se han solucionado, y pudiendose retomar las tareas del sprint que estaban bloqueadas.

Bien, y para terminar, pondremos un ejemplo más o menos gráfico de lo que sería una típica reunión diaria:

- Toñete: Bueno, que sepáis que ya he terminado con la refactorización de los renderizadores.
- Juancito: Perfecto, al final has tardado menos de que esperabas ¿no?
- Toñete: Sí, estaba inspirado y me ha salido de un tirón (:
- Perico (el Scrum Master): Genial, guardaremos esas horas sobrantes para el final del sprint, que nos harán falta.
- Toñete: Hoy voy a empezar a aplicar la aceleración por hardware, aunque la verdad es que no sé ni por donde cogerlo
- Juancito: Yo recuerdo haber leído algo en internet sobre el tema... dame un rato y esta tarde te envío algún código de ejemplo de la clase VolatileImage.
- Toñete: vale tío, muchas gracias. Cuando tenga tu código espero avanzar sin problemas.
- Juancito: Pues yo estoy atascado con el deshacer/rehacer. Está afectando a un montón de módulos y la verdad es que estoy un poco perdido entre tanta clase, herencia y métodos.
- Toñete: quizá te ayudaría usar alguna herramienta de modelado UML, más que nada para que veas las dependencias entre clases y cómo afectará tu cambio.
- Juancito: Sí, quizá sea buena idea... pero no sé cual usar ¿Rational Rose? ¿Together?
- Perico: Creo que en el otro departamento ya están usando alguna. Voy a preguntarles, y si vemos que nos viene bien, gestiono la compra de la licencia para nuestro departamento.
- Juancito: vale... pues entonces mientras consigues eso voy a intentar automatizar las pruebas en los teléfonos móviles.
- Perico: de acuerdo, voy a conseguirte unos cuantos teléfonos para que lo puedas probar en distintas marcas y modelos.
- Juancito: ok, entonces mañana os cuento a ver cómo me ha ido.

El próximo día trataremos el uso de la hoja de cálculo para gestionar el sprint backlog

Etiquetas: ,


19 agosto 2006

SCRUM en Unkasoft: el sprint

Continuemos con nuestra serie sobre SCRUM… tratando el tema de los sprints.

Para ponernos en situación, diremos que el sprint de SCRUM es más o menos lo mismo que la iteración en XP, aunque salvando ciertas distancias.

Podemos definir al sprint como el periodo de tiempo que tiene el equipo de desarrollo para implementar, documentar y probar un conjunto de nuevas funcionalidades (a este conjunto se le suele llamar “incremento”). Al finalizar el sprint, debemos tener una versión lista, empaquetada y con un bonito lazo rojo para entregar a cualquier cliente.

El sprint se divide en tres fases más o menos típicas:

1. - Planificación: una reunión del product owner junto con el equipo de desarrollo para:
2.- Implementación: una vez que tenemos el “sprint backlog” completado, podemos empezar el desarrollo. Se acuerda por ambas partes (product owner y equipo) que hasta que no se termine este sprint no se podrán “colar” nuevas funcionalidades. Si surge una nueva necesidad, se apuntará en el product backlog y en la planificación del próximo sprint se tendrá en cuenta.
Todos los días del sprint se hará una reunión (llamada “daily meeting”) del equipo para ir revisando cómo va el trabajo y actualizar el sprint backlog. El próximo día trataremos este tema.

3.- Revisión: una vez terminado el sprint, se reúnen el product owner, el equipo y cualquier persona interesada (por ejemplo gente de marketing, clientes, etc.) y se hace una demo informal de la nueva funcionalidad (llamada “incremento”). En esta revisión pueden surgir nuevas funcionalidades que serán apuntadas en el product backlog.

Por otro lado, se reúne el equipo de desarrollo consigo mismo, y saca dos conclusiones:
  1. ¿Que nos ha ido bien y debemos repetir?
  2. ¿Qué nos ha ido fatal y debemos mejorar?
Por ejemplo:
- Toñete: me da la sensación que en este sprint la hemos cagao con el tema de las pruebas de los nuevos renderizadores
- Juanín: sí, ha sido un infierno, pensé que no se acababa nunca.
- Toñete: en cuanto podamos deberíamos investigar cómo automatizarlo. Habrá cosas que no se puedan, pero seguro que hay alguna forma de automatizar aunque sólo sea una parte.
- Juanín: sí, lo apunto para colarlo en el próximo sprint.
- Toñete: por cierto, lo que sí que ha ido muy bien es el prototipo para probar lo de deshacer/rehacer
- Juanín: sí, menos mal que lo hicimos, porque yo no tenía ni idea como combinar los patrones Command y Memento. Una vez que tuve el prototipo, no fue más que aplicarlo al resto de casos.
- Toñete: pues para la próxima ya sabemos…

Bien, el próximo día hablaremos sobre cómo es el día a día de la implementación de un sprint y el "daily meeting".

Etiquetas: ,


16 agosto 2006

SCRUM en Unkasoft: el product owner

Ayer hablamos del product backlog, o en castellano: pila de producto. Bien, la persona encargada de llevar a buen puerto este documento es el que SCRUM llama product owner, o para nosotros el propietario del producto. En realidad no se trata de una persona tal cual, sino que estamos hablando de un rol, que en nuestro caso lo adoptamos dos personas a tiempo parcial (Jaime y yo mismo), aunque podría ser una persona a tiempo parcial (lo más habitual) o en proyectos muy grandes, una o varias personas a tiempo completo (ojo, SCRUM no encaja en proyectos grandes, así que si estás en este caso piénsatelo dos veces antes de empezar).

Bueno, pues el(los) propietario(s) del producto deben tener una visión clara del producto a construir (Jaime la tiene, y yo lo intento :), debe(n) saber bien qué se debe implementar, y sobre todo lo que NO se debe implementar.
Por cierto, suele ser más difícil de distinguir lo que NO se debe implementar, ya que parece ser que el 45% de las funcionalidades implementadas nunca llega a usarse. Por otro lado está la teoría del 80/20, donde dice más o menos (traducción libre de las mías):
A muchos desarrolladores les seduce la idea de la teoría del 80/20. Parece que tiene mucho sentido: el 80% de la gente usa el 20% de la funcionalidad. Así que te convences a ti mismo de que sólo necesitas implementar ese 20% de funcionalidad para seguir vendiendo el 80% de las copias. Por desgracia, no siempre es el mismo 20%. Cada usuario usa un conjunto de funcionalidades distinto. [...]
Pero esto es otra historia y debe ser contada en otra ocasión...

Bien, como decíamos, el product owner debe tener una idea clara de la dirección del proyecto, manteniéndo al día y priorizada la pila del producto. No se trata de pasarse meses analizando las necesidades reales y sacar la cojo-pila (también llamdo mega-análisis o super-especificación), sino trabajar unos días para sacar la cantidad de funcionalidad suficiente para cubrir la primera versión (algo que pueda funcionar), y a partir de ahí, añadir cosas.
Lo de siempre: el movimiento se demuestra andando.

Esta figura se parece más o menos al "cliente" que pregonaba eXtreme Programming, donde era la persona que colaboraba con el equipo en redactar las famosas historias de usuario, y que decidía lo que se iba a implementar en cada iteración de desarrollo.

Una vez que la versión está implementada, el propietario de producto la revisará para ver si ha cumplido con las expectativas que él tenía sobre ella... es decir: ver si las funcionalidades que él propuso como útiles y necesarias, realmente lo son (que a veces no lo son).

Cuando el propietario del producto tiene su pila más o menos preparada, colaborará con el equipo de desarrollo para definir la pila del sprint... así que ya tenemos carrete para el próximo día, donde hablaremos de los sprints (:

Etiquetas: ,


14 agosto 2006

SCRUM en Unkasoft: el product backlog

Bien, una vez hecha la introducción, vamos a tratar los distintos aspectos de SCRUM, siempre explicando cómo los hemos abordado en Unkasoft y qué problemas hemos tenido (y seguimos teniendo) a la hora de usarlos.

El primer elemento que tratamos de implantar fue el Product Backlog, o pila de producto: se trata de una lista de funcionalidades que debe llegar a tener el producto que estamos desarrollando. En teoría, cuando implementemos todas esas funcionalidades, el producto estará acabado (ya, a ver cuando llega eso, porque yo no lo tengo claro).

Este paso a sido fácil para nosotros, porque hace tiempo que usábamos un documento (que llamábamos "problemas a resolver") donde íbamos apuntando todas las cosas que nos gustaría que tuviera Battlewizard. Este documento lo íbamos ampliando con nuestra propia experiencia, peticiones del departamento de QA, o de empresas que están usando Battlewizard (como nuestros early adopters GPM-e y Karonte).
Adaptarnos a SCRUM a sido tan sencillo como convertir el documento en una hola de cálculo, incluyendo los títulos de las nuevas funcionalidades y con una explicación breve en forma de comentarios. En la propia hoja de cálculo hemos organizando las características en cuatro categorías conforme a la urgencia de implementarlas: muy alta, alta, media y baja.

¿Y para qué nos está sirviendo esto? Pues sencillamente para no olvidarnos de nada y para tener un sitio de consulta cuando queramos saber qué hay que hacer y qué es más urgente. Además, este documento es el punto de partida a la hora de planificar una versión.
Una vez que hemos implementado una característica, la borramos de la pila de producto, y así poco a poco va decreciendo (bueno, en realidad no ha parado de crecer desde que la hemos creado, añadimos más funcionalidades de las que nos da tiempo a implementar, pero con el tiempo y una caña... :)

La persona encargada de mantener este documento es el llamado "propietario del producto" ("product owner") y su función es... bueno, creo que ya está bien por hoy, así que el próximo día hablaremos del propietario del producto...

Etiquetas: ,


11 agosto 2006

SCRUM llega a Unkasoft!

Este verano está siendo movidito.
Estamos restructurando el equipo (alguno ya han llegado, y otros están por venir), salida a la calle de dos juegos más (todavía no podemos decir nada sobre ellos pero pronto publicaremos algo aquí sobre ellos) y probar una nueva metodología de gestión de proyectos: SCRUM.

Hace ya tiempo veníamos usando eXtreme Programming como metodología de desarrollo, sobre todo en el equipo de Battlewizard, pero la parte de planificación, gestión y seguimiento de los proyectos la teníamos un poco descuidada. Así que con la ayuda de Juan Palacio nos hemos puesto en marcha y ya vamos por nuestro sexto sprint (:

¿En qué consisten SCRUM? Pues es una metodología de autogestión de equipos, es decir: no hay un jefe que ordene y los demás obedezcan, sino que el propio equipo es el que tiene que auto organizarse.
Bueno, esto de promulgar la autogestión está muy bien, pero tienes sus problemas. No intentes aplicar esta metodología en cualquier sitio, porque yo conozco algunas empresas y algunas personas con las que esto sería un fracaso asegurado.

Justo hace un par de días Joel Spolsky ha publicado unos artículos sobre gestión de equipos, y en ellos cataloga los tipos de gestión típicos las empresas en tres: (como siempre, te recomiendo que lo leas porque no tiene desperdicio):
Así que el primer consejo: no intentes aplicar SCRUM en cualquier sitio. Primero haz que se respire un clima adecuado y cuando tengas el caldo de cultivo, todo será más fácil.

A continuación tenéis nuestra experiencia sobre algunos elementos de SCRUM que estamos usando en nuestro trabajo diario:

Etiquetas: ,


25 mayo 2006

TDD y Eclipse

En nuestro trabajo diario intentamos desarrollar siguiendo las prácticas de eXtreme Programming, y entre ellas en especial el desarrollo guiado por pruebas o TDD. Y digo "intentamos" porque a veces no es fácil aplicar TDD para corregir bugs o trabajar con código que ya está escrito. Sin embargo, TDD funciona extraordinariamente bien para desarrollar nuevas clases, sobretodo si trabajas con Eclipse.

Vamos a poner un ejemplo tonto: tenemos que desarrollar la clase "Device", que entre otras cosas, tiene un identificador, una descripción, un constructor de copia y un método que nos dice si el dispositivo soporta un formato específico de audio (basándonos en una base de datos en UAProf o WURLF).
Podemos abordar este problema de tres formas distintas:Bien, el caso que nos ocupa es que Eclipse nos ofrece una serie de herramientas que nos ayudarán a usar el TDD de forma poco traumática.


Empezamos codificando el esqueleto típico de la clase de pruebas con JUnit, y vemos como Eclipse nos marca una serie de errores de compilación. Como vemos en la imagen de la derecha, nos dice que la clase "Device" no se ha encontrado (logicamente, porque todavía no existe :). Haciendo clic sobre la marca de error del margen izquierdo, nos aparece una lista con posibles soluciones al error, y entre ellas: crear la clase. Así que dejamos que Eclipse cree el esqueleto de la clase "Device", y seguimos con nuestras pruebas.


Después de codificar dos métodos de pruebas estamos en las mismas: tenemos varios errores de compilación, ya que estamos llamando a métodos que todavía no existen.
Por ejemplo, en el test que prueba el constructor de copia, estamos llamando a un constructor que todavía no existe (además de un par de los getter), así que hacemos clic sobre la marca de error, y seleccionamos la opción "Create constructor Device(Device)". Con el resto de errores de compilación podemos hacer lo mismo, aunque habrá casos en que tendremos que completar o cambiar el tipo a ciertos parámetros que Eclipse no es capaz de deducir.

De este modo, casi podemos hacer que Eclipse nos vaya generando el esqueleto de nuestra clase de lógica basándose en las llamadas que hacemos desde la clase de pruebas.

Esto nos puede ahorrar bastante tiempo que dedicamos sólo a tareas de códificación zombie (la que se hace sin pensar, sólo para que los compiladores nos dejen vivir en paz).

Una vez que tenemos la prueba completa y el esqueleto de la lógica, podemos seguir codificando la lógica de la clase, hasta que todos los test pasen correctamente (aunque creo que Eclipse no puede ayudarnos demasiado en esto).

Etiquetas: , , ,


05 abril 2006

Integración continua y gestión de la configuración

Como decíamos "ayer", una de las tareas propias de las metodologías ágiles es la llamada "integración continua".
Esta práctica consiste en llevar al límite el proceso de construcción automática y diaria. Si conseguimos automatizar este proceso ¿porqué no lanzarlo cada vez que hagamos algún cambio, por pequeño que sea?
Pues precisamente esa es la clave de la integración continua, pero como es lógico, no todo es tan fácil como puede parecer a simple vista.

El primer paso para la integración continua es, como ya hemos dicho, automatizar el proceso de construcción. Para ello nos basamos en herramientas como Ant, Maven, el antiguo MAKE, Jam, etc., que nos permiten ir lanzando distintas tareas de forma secuencial y sin nuestra intervención.
Una vez que hemos logrado ejecutar todos los pasos necesarios, tenemos que conseguir que ese proceso se lance automaticamente, cada vez que algún cambio de código se integra en el repositorio. Lo podemos conseguir facilmente gracias a un montón de herramientas para ello, que nos ayudan a programar las construcciones, aunque también podríamos habilitar una máquina dedicada y conseguir que todo el equipo se comprometa a lanzar una compilación después registrar cada cambio. Ummmm, creo que va a ser mejor instalarse alguna herramienta ¿no?
Empresas que manejan proyectos muy grandes dan a este aspecto una importancia vital. Por ejemplo: Microsoft, en su equipo de desarrollo de Windows, tiene todo un laboratorio de construcciones diarias: un montón de servidores y personas responsables de que la compilación y las pruebas se ejecuten correctamente todos los días.

Bien, el modelo de integración continua, si no se hace con cabeza, puede traernos más problemas que ventajas.
Pongamos el caso en que tenemos un repositorio con nuestro código fuente. Nosotros usamos Subversion, pero valdrían otros como CVS, Source Safe, Perforce, etc. Cada vez que integramos un cambio en el repositorio, existe alguna posibilidad de que el programa deje de compilar (por ejemplo si hemos olvidado subir un archivo nuevo), o que hayamos generado algún bug, así que podemos decir que en ese momento, y hasta que se valide de nuevo, el repositorio está en estado inestable. Si hacemos que se lance una construcción cada vez que integramos algo en el repositorio, muchas de esas construcciones fallarán. Por ejemplo: todas las tardes, antes de irnos a casa, registramos nuestro trabajo, aunque no esté terminado, y muchas veces la construcción resultante no es válida. Pensad que esto lo hacemos todos los desarrolladores, así que a la mañana siguiente tenemos el repositorio lleno de bugs y en un estado caótico, y si ese mismo día necesitásemos entregar una versión, estaremos en apuros.

A continuación podéis ver el diagrama que representa esta situación:


Cada flecha es un cambio hecho en el repositorio, y como véis, algunos cambios desestabilizan el producto, bien introduciendo bugs o errores de compilación.

Para conseguir que la integración continua tenga su efecto beneficioso, tenemos que organizar el desarrollo en distintas ramas, o branches.
Para este modelo de gestión de la configuración tenemos varias opciones, aunque las más habituales son las siguientes:

Cada desarrollador tiene su propia rama de código, donde trabaja a diario, hace sus cambios, registra código, etc. Esa rama es privada, y podrá hacer lo que quiera con ella y mantenerla en cualquier estado. Lo habitual es que esa rama esté muy inestable al comenzar con una nueva tarea, y vaya ganando estabilidad conforme avance en el desarrollo.
En el momento en que el desarrollador termina con su trabajo, se compila una versión de esa rama y se pasa a pruebas. El departamente de pruebas validará la funcionalidad sobre la que ha estado trabajando el desarrollador, se reportarán los bugs oportunos, y cuando se de por correcta, se etiquetará esa rama y se integrará en el repositorio principal. En ese momento se lanza una construcción del producto de la rama principal, y se vuelve a pasar a QA el producto ya integrado, para validar que la integración ha sido correcta.
En este caso, hemos pasado a tener una funcionalidad más, reduciendo al máximo los tiempos de inestabilidad de la rama principal. Una vez que la rama principal se da por buena desde el departamento de QA, se etiqueta y se continua con la siguiente funcionalidad.
Podemos verlo representado aquí, y fijaros que la rama principal tiene muchas menos zonas en rojo:


Existe todavía otro modelo, muy parecido al anterior, y que consiste en tener una rama de desarrollo para cada nueva funcionalidad. El esquema es el mismo que hemos visto, donde los desarrolladores que trabajan en una misma funcionalidad lo hacen sobre una rama separada. La diferencia es que cuando la funcionalidad se da por terminada, se integra en la rama principal y esa rama queda muerta, teniendo que crear otra nueva para la siguientes funcionalidad.

Bien, como véis, es tema no es sencillo de gestionar, y requiere algo de infraestructura de por medio.
Yo os recomendaría que, al igual que se automatiza el proceso de construcción, intentéis hacer lo más automático posible la gestión de la configuración, teniendo scripts para la creación de ramas para desarrolladores, para funcionalidades, de integración en el principal etc.

Pero... ¿donde queda la integración continua en este jaleo de ramas? Pues en la rama principal, que es donde se registrarán los cambios definitivos y estables. No tiene sentido que intentemos compilar el producto cada vez que se cambie algo en una rama secundaria, ya que habrá muchos momento de inestabilidad. Así que cada vez que una tarea es dada por buena, se integrará en el repositorio principal y se construirá el producto final.

Y ya para poner la guinda al pastel, puedes poner un "ambient orb" en la oficina, para que todo el mundo vea el estado de la rama principal.

Automated Continuous Integration and the Ambient Orb
Using an Ambient Orb to show continuous integration build status
The Build Indicator Lamp

Nosotros no llegamos tan lejos, ¿y tú?

Etiquetas: ,


This page is powered by Blogger. Isn't yours?