Developing Frogtek

El blog del Departamento de Tecnología

Categoría: integración continua (página 1 de 2)

Visualizar el servidor de integración continua

Monitor de monitorizaciónOs presento la última “frikada” que hemos añadido a nuestra colección de gadgets de oficina.

Con el viejo servidor, actualmente en desuso, una pantalla vieja y el plugin de Jenkins  eXtreme Feedback Panel Plugin. Hemos montado un visualizador del estado de nuestro servidor de integración continua (Jenkins).

El objetivo esta claro. Conseguir estar enterados en todo momento de la salud de nuestras construcciones. Ya no vale eso de “no vi el email”.

Además informa del culpable de la rotura si la hay. Y muestra el número de tests añadidos en la última construcción, entre otras virguerías.

 

 

 

Lanzar un Job de Jenkins desde Google App Engine

La semana pasada estuve dándole vueltas a este problema, después de varios intentos fallidos llegué, con la ayuda de Julio, a la solución que planteo en el título del post.

Para empezar tenemos que ir al job en Jenkins que queramos lanzar desde fuera y activar la opción de “Lanzar ejecuciones remotas”

Por motivos de seguridad, Jenkins nos obliga a usar un Token que será usado al llamar al Job desde fuera.

El código que usaremos en GAE (en Python) será el siguiente:

import urllib2, base64, httplib
from urllib2 import URLError, HTTPError
from django.http import HttpResponse

def call_mlp_generator(request):

    theurl = 'JENKINS_JOB_URL?token=TOKEN'
    username = 'USERNAME'
    password = 'PASSWORD'

    request = urllib2.Request(theurl, None)
    base64string = base64.encodestring('%s:%s' % (username, password)).replace('n', '')
    request.add_header("Authorization", "Basic %s" % base64string)
    try:
        urllib2.urlopen(request)
        response = str(httplib.OK)
    except HTTPError, e:
        response = str(e.code)
    except URLError, e:
        response = str(e.code)

    return HttpResponse(response)

Bastante simple, sólo había que saber tocar las teclas adecuadas.

¿Por qué usar Maven?

A raíz de mi grata visita a PocketWidget, en nuestro Desk-Surfing más reciente, he revisado la configuración de Maven que nos permite construir nuestros entregables.

Al volver sobre ella con Francho, repasarla y volver a aplicarla en otros proyectos, me he dado cuenta de lo potente que es y lo difícil que sería la vida sin ella.

Aparte de todas las bondades que su propia página web resalta, personalmente, me quedo con dos de ellas.

  • La herencia entre los archivos de configuración. Permitiendo eliminar duplicidades en las configuraciones y facilitando la configuración de multiples proyectos similares partiendo de una configuración padre-base.
  • Su extensibilidad mediante plugins. Los hay de todos los tipos y si no encuentras uno que se cuadre a tus necesidades, puedes desarrollarlo y usarlo fácilmente. Nosotros el que más usamos es el de Android. No ha estado siempre a la última, pero la comunidad que hay detrás es impresionante y en su última versión beta (2.9) ya soporta los Library Projects.

Solo usamos Maven en el entorno de integración continua, porque durante desarrollo con el plugin de Eclipse ADT para Android, no solemos tener problemas. Pero a la hora de automatizar, la elección ha sido clara: Maven sobre Ant.

Bloqueo de SVN en caso de build fallida

Hace poco tuvimos una agradable visita aquí en Frogtek. Una de las muchas aportaciones de Emma fue hacernos replantear nuestro sistema de lanzamiento de builds en Jenkins, pasando de uno más pesado en recursos a otro más eficiente. A raíz de dicho cambio hemos aprovechado y mejorado el procedimiento de bloqueo que tenemos configurado en Jenkins y la forma en la que lo realizamos. Vamos a explicarlo para que nos ayudéis a mejorarlo todavía mas.

En sí, el procedimiento consiste en no permitir commits al servidor SVN si hay una build rota. Excepto al usuario que haya provocado dicha rotura. De esta forma nos aseguramos de varias cosas:

  • No se avanza en el desarrollo si el código subido no es de una calidad mínima, pasa los test y se construye correctamente.
  • Los desarrolladores se hacen responsables de los problemas que ellos han generado y los arreglan.
  • Cuando existe un problema en una parte del proyecto, y dicho problema tarda en resolverse, todo el equipo se preocupa por saber qué pasa y ayudar a resolverlo para poder seguir avanzando.

Seguir leyendo

VirtualEnv para Google App Engine en local

Por defecto en Google App Engine , hasta hace bien poco, solo se podía usar hasta la versión 1.1 de Django. Esto generaba problemas si tenías alguna otra aplicación web que requería una versión más reciente de Django, como por ejemplo nuestra herramienta de revisión de código. Obtenías una serie de conflictos que eran una molestia para el desarrollo y uso en local del servidor, impidiendo un desarrollo fluido y una configuración estable.

La solución por la que optamos fue usar virtualenv. Con esta herramienta podríamos separar el entorno de ejecución de Google App Engine, del resto de aplicaciones instaladas, tanto en el servidor de integración continua como en los equipos de los desarrolladores.

Después de consultar varios sitios web al respecto, el proceso de configuración quedo algo así:


aptitude install python-virtualenv python-pip

Para instalar tanto el propio virtualenv como pip, una herramienta para instalar paquetes en dicho entorno.


virtualenv --no-site-packages --python=python2.5 ENV

Para configurar en ENV el entorno. –no-site-packages indica que no herede ningún package de la instalación de la cual se toma python y le indicamos que queremos la versión 2.5 pues GAE se ejecuta en con la 2.5 en los servidores de Google.

pip install -E ENV Django==1.1

Añadimos la versión de Django que utilizar con pip.

Para finalizar ya solo falta copiar la carpeta de Google App Engine dentro de ENV. Activar el entorno utilizando un par de scripts que hay en ENV/bin/ y lanzar el servidor de desarrollo.

Ahora mismo toda esta parafernalia tiene algo menos de sentido pues en la última versión del SDK del GAE han añadido la versión 1.2 de Django. Pero aún así puede ser útil para conseguir un entorno controlado y separado del resto de la máquina. Ya sea un servidor de integración continua o nuestra propia máquina de trabajo.

Herramientas: Resource filtering en Maven

Nuestro querido servidor de desarrollo es el encargado de generar las versiones de nuestros productos, los publica en la web, nos avisa por e-mail de que se han generado nuevas versiones, etc. Además se encarga de que desde el mismo código salgan dos versiones diferentes de la aplicación. La versión de producción, sólo para clientes finales, y la de pre-producción donde se prueban todas las funcionalidades antes de ser pasadas a producción.

Las diferencias entre ambas versiones son mínimas pero delicadas, así que hace tiempo programamos una serie de bash scripts que hacían los cambios automáticamente en Hudson. Nada elegante pero muy útil para evitar errores al subir archivos de configuración a nuestro sistema de control de versiones.

Hace unos días, a raíz de este post de Francho, Pedro pensó que igual podíamos mejorar dichos scripts para incluir ese proceso de definición en la propia aplicación. Nosotros no usamos Ant a nivel del servidor de integración continua, sino Maven. Me tocó desempolvar el recomendable libro que me dio a conocer Maven y me puse manos a la obra.

Así descubrí el Resource filtering, plugin de Maven que permite filtrar archivos y sustituir variables definidas en el pom.xml (archivo de configuración de Maven). A continuación os muestro lo sencillo que fue deshacerme de tres o cuatro scripts y pasar a definir dicho proceso desde el propio archivo de configuración de Maven.

Para ello en primer lugar se definen las variables.

...

   false
   UA-********
   http://*******/tiendatek/prebuilds/latest.apk
   frogtek

...

Seguir leyendo

Frogtek Kanban Boards

En Frogtek tenemos dos tablas de kanban distintas en paralelo, una para los Product Owners y otra para el equipo de Tecnología. Primero nació la de Tecnología, como una manera fácil y visual de controlar el trabajo, lo que queda pendiente, lo que está ya acabado o lo que está siendo programado en este momento. El proceso de desarrollo es lo suficientemente “complicado” (tampoco mucho) como para que sean necesarias varias columnas, pero ¿por qué necesitamos también una tabla de kanban para el proceso de diseño de una user story por parte de los Product Owners?. Principalmente, y esto es lo único que voy a contar al respecto antes de centrarme en la tabla de Tecnología, porque el proceso de definición de user stories se ha ido complicando conforme añadíamos técnicas como el Usability Testing y demás y ahora requiere de varias iteraciones antes de que una user story quede archivada y por lo tanto disponible para ir al Backlog de Tecnología, es decir, a la fase de producción.

La tabla virtual de los Product Owners.

Moraleja: las tablas de Kanban son muy útiles incluso si lo que quieres organizar son las tareas del hogar, no es algo reservado a programadores o ingenieros.

La tabla virtual de tecnología.

Nuestra tabla real de tecnología (ver foto abajo) tiene una fila por proyecto y 6 columnas de las cuales forman parte del proceso estrictamente 4, las dos de los extremos no son más que los recipientes de donde salen las user stories y en donde acaban al final.

La tabla real de Tecnología

Son las siguientes:

  1. Backlog: aquí el Product Owner almacena las user stories que ya han pasado por todo el proceso de diseño (en la otra tabla) y están listas para ser empezadas cuando lo considere necesario, es una especie de almacén (los programadores no miran mucho dentro). También almacenamos bugs que cualquiera detecta y que no son muy urgentes, de esta forma el Product Owner puede evaluarlos, descartarlos o priorizarlos según su criterio.
  2. Development – User Interface: de alimentar esta columna se encargan tanto el Product Owner como la diseñadora gráfica. La idea es la siguiente, cuando una user story del backlog está lista (es decir, tiene una descripción exhaustiva y una lista de tests de aceptación) si requiere antes de su programación de la creación de recursos gráficos (iconos, imágenes…) entonces es la diseñadora gráfica la que la arrastra a esta columna (a la parte izquierda) y no la coloca en la derecha (que indica que la user story está lista para pasar a la siguiente fase) hasta que no ha creado todos los recursos y los ha adjuntado para que los usen los programadores. Si la user story, por el contrario, no necesita nada gráfico el Product Owner la mueve directamente a la parte derecha de la columna en espera de que un desarrollador la escoja. Sea como fuere, en este punto todas las user stories tendrán una descripción detallada, una lista de test de aceptación y si lo requiere ciertos archivos adjuntos con los recursos gráficos necesarios. En esta columna también aparecen de vez en cuando bugs urgentes (aquellos que alguien detecta y que hay que resolver enseguida).
  3. Development – Code: Esta columna es responsabilidad de los programadores, cuando uno de ellos se libera acude a la columna Development – User Interface y toma la user story que esté más arriba de entre las de la parte de la derecha. La user story (el post-it en realidad) se mueve a la parte izquierda de esta tercera columna y quedará allí hasta que el programador considere que ha terminado su trabajo. ¿Y eso que quiere decir?. Pues hasta que ha probado, en un entorno lo más real posible, que lo que ha programado cumple todos y cada uno de los test de aceptación diseñados por el Product Owner (amén de los tests unitarios propios y ajenos entre otras cosas). Entonces hace “commit” (o comitea en castellano antiguo) y cruza los dedos para que todo funcione y no haya “momento cerdito” (en ese momento la build se compila en el servidor y los test unitarios se ejecutan, así como los funcionales y los aleatorios… así que es como para echarse a temblar, lo del cerdito lo explicaremos en otro post dentro de poco). Si todo va bien es momento de mover la user story a la parte derecha de la columna donde esperará a que otro desarrollador inicie el proceso de revisión. Por cierto, IMPORTANTE,  esta columna es la única a la que aplicamos WIP (limitación del Work In Progress) y normalmente lo limitamos al número de programadores en el proyecto menos uno. De esta forma no podemos tener dentro de la columna más user stories que programadores en el proyecto menos uno. Lo que hace que, a veces, cuando alguien acaba su tarea se vea obligado a revisar alguna de las user stories que otros hayan acabado para vaciar la columna o a hacer pair programming.
  4. Quality – Review: el proceso de revisión es doble, primero por parte de un desarrollador, que no haya participado en la programación de la user story, y luego por parte de nuestro responsable de QA, Julio. Consiste en utilizando la herramienta Review Board revisar que todo el código y ver que el código es consistente en estilo y con un diseño eficiente. Si hay algún tipo de comentario, el programador original deberá modificar el código y volver a pasar pruebas manuales y automáticas. Al final del proceso y si todo va bien la user story acaba en la parte derecha de la columna esperando a que el responsable de calidad la testee.
  5. Quality – Test: ya estamos llegando al final del proceso. Aquí es donde las cosas se ponen más interesantes ya que Julio se dedica a comprobar que todos y cada uno de los test de aceptación definidos por los Product Owners se han satisfecho. Si encuentra algún error, la user story vuelve directamente a la columna 3 (Development – Code) y el momento cerdito es acogido con regocijo por toda la oficina (menos aquel a quien se le aplica). Esto es un poco como esas casillas del juego de la oca que te mandaban 20 casillas atrás… hay que volver a empezar y arreglar lo que no funciona. Cuando los tests se pasan correctamente la user story se deja en la parte derecha de la columna esperando a que el Product Owner que es quien debe dar al final el visto bueno la archive definitivamente.
  6. Archive: cuando una user story está en la parte derecha de la columna Quality Test es señal de que el trabajo está listo para que el Product Owner lo pruebe. Si comprueba que todos los tests de aceptación se pasan directamente puede mover la tarea a esta sexta columna donde quedará para siempre. Si hay algún error entonces la tarea vuelve a la tercera columna, todo vuelve a comenzar y el “momento cerdito” planea sobre nuestro querido Tester.

Algunos comentarios:

No diferenciamos entre user stories y bugs, salvo por el color del post-its, eso es importante. Los tratamos igual. Un bug normalmente no tendrá test de aceptación, archivos gráficos adjuntos pero si una descripción detallada. Cuando los errores se identifican durante la fase de testeo, no se genera un bug, sino que se rechaza la user story. Si se detectan después, sí y, en ese caso, su destino será: el backlog si no son urgentes, la parte derecha de la columna de Dev – User Interface si lo son o la parte izquierda de la columna de Dev – Code si son críticos. El triaje lo realiza normalmente o el responsable de QA, el Kanban Master o el Product Owner si está disponible (nótese la diferencia horaria, 6-7 horas, entre POs y programadores).

¿Cómo es posible que el tester pueda testear “instantáneamente” cada una de las user stories tras el commit?. Gracias al sistema de integración continua del que ya hemos hablado en varios posts. Cada commit genera una nueva versión de pre-producción que nos sirve para testear lo último que se ha terminado. No hay más que seleccionar buscar actualizaciones en nuestra aplicación y el “upgrade” es automático.

En los pantallazos correspondientes a nuestra tabla virtual (que en el fondo es la oficial, porque es la única que compartimos toda la empresa) no hay lado derecho o izquierdo de las columnas. Simplemente cuando una user story está lista le ponemos un reborde verde.

Si os fijáis en las imágenes que hemos adjuntado la tabla real no tiene columna “Archive” esto es así porque realmente hemos encontrado una utilidad mucho mejor para las user stories (los post-its) terminadas que coger polvo o ir a la caja de reciclar. Lo contaremos en nuestro próximo capítulo junto con lo del “momento cerdito”.

Waterfall vs SCRUM vs Kanban (III)

[Leer Waterfall vs SCRUM vs Kanban (II)]

Un día de Enero de 2010 recibí un correo de David titulado “Hacia Scrum-ban” con un archivo adjunto muy interesante. Se trataba del libro “Kanban and SCRUM: how to make the most of both” un libro muy ameno y fácil de leer que explica las principales características del sistema Kanban. Se trata de un sistema muy poco restrictivo que apenas impone obligaciones y que se puede usar en combinación con algunas de las cosas más interesantes de SCRUM. No me voy a parar a explicar Kanban, el libro lo hace mucho mejor por si solo y no cuesta leerlo más de hora o así. Pero sí me gustaría contar en qué cambió nuestra forma de trabajar.

Para empezar eliminamos las reuniones de planificación, dichas reuniones (que nosotros hacíamos por skype) se habían convertido en eternas conversaciones en las que explicábamos una a una las US incluidas en el Sprint y tratábamos de estimarlas. Estimar se nos daba realmente mal, apenas conseguíamos sacar adelante la mitad de lo previsto cada dos semanas (el optimismo del developer es un tema que tarde o temprano habrá que tocar en este blog), aunque seguramente poco a poco podríamos haber ido mejorando. La idea con Kanban es que no hay Sprints y el flujo de users stories entre Product Owner y programador es continuo. ¡Mucho mejor!, así nos podemos centrar en intentar aumentar nuestra velocidad, es decir reducir el tiempo que nos cuesta desarrollar una user story (el lead time). La idea del flujo continuo hace Kanban muy apropiado para sistemas de mantenimiento en los que los bugs llegan de manera inopinada, sin seguir un patrón fijo y el primer programador que se libera de trabajo se hace cargo de ellos. Nuestro caso no era exactamente ése (aunque los bugs iban llegando) pero el hecho de tener, para nuestra aplicación de contabilidad en el móvil, un cliente tan informal como “los comerciantes más humildes de países emergentes” hacía que el goteo de requerimientos y cambios fuera constante y difícilmente encorsetable en forma de Sprints.

Lo siguiente fue crear nuestras propias tablas de Kanban (la real, en la oficina y la virtual en la web ya los POs están en las Américas), una experiencia entretenida (post-its, gomets, cinta aislante, tijeras, una pared grande…) que además al final nos permitió en la parte virtual abandonar AgileBuddy (demasiado complejo y cuyas métricas no acabábamos de entender) y usar en cambio una herramienta mucho más visual, sencilla e intuitiva, como AgileZen. Lo malo es que hay que asegurarse de mantener sincronizadas las dos tablas, pero nos encargamos de ello todos los días justo antes del stand-up meeting. Este tipo de tablas también se pueden usar para SCRUM, nada lo impide, pero en Kanban son imprescindibles porque permiten que todo el mundo sepa lo que está haciendo el resto a la vez que es fácil chequear/limitar el Work In Progress (WIP) que es la clave de todo sistema Kanban.

A todo esto, nada de este cambio hubiera sido posible si a la vez no hubiéramos implementado un sistema de integración continua con el que obtener una nueva versión suficientemente fiable de nuestro producto con cada commit de una nueva user story. Pasamos de un sistema en el que cada dos semanas había que hacer un complicado paso a producción (pero que aún se podía hacer manualmente) a un flujo continuo de nuevas versiones creadas automáticamente en pre-producción y que al final tenían la misma calidad que las de producción del sistema anterior. Julio puede dar más detalles de cómo funciona todo eso y cómo usamos HUDSON & company para este tipo de cosas, pero podemos decir que tenemos la parte de pre-producción totalmente automatizada y ahora hacemos los pasos a producción tanto en teléfono o en la web bajo demanda y con mucha más seguridad de que las cosas van a ir bien.

El resultado de este cambio fue altamente satisfactorio ya que esta nueva manera de trabajar se adaptaba mucho mejor a nuestras necesidades. Esto no quiere decir que SCRUM no valiera, ya que incluso tenemos que reconocer que aún estábamos al principio de la curva de aprendizaje de SCRUM y hacíamos cosas mal. Ahora también… nos pasamos del WIP de vez en cuando, no hacemos todas las retrospectivas que deberíamos, definimos user stories un poco desiguales (de vez en cuando se nos escapa alguna interminable “looser story”) pero bueno… nadie dijo que esto fuera a ser fácil y, de hecho, si echamos la vista atrás, creo que podemos estar satisfechos de nuestro recorrido. Además no descartamos recuperar los Sprints de SCRUM para según que proyectos y clientes más apropiados, ni evolucionar a cualquier otra cosa que nos parezca mejor o más apropiada en cualquier momento.

Automatización

Gracias a la costumbre en Frogtek de fomentar la formación a través de la compra libros, he podido leer “The Pragmatic Programmer” magnífico libro recomendable para cualquier programdor con ganas de mejorar.

En el mismo dan un par de consejos que me han parecido muy interesantes y que aparte de estar muy ligados, creo que seguimos bastante aquí en Frogtek. El primero:

Use the power of command shells

Indica que debemos usar los comandos shell como herramientas para facilitar nuestro trabajo. Por ejemplo en mi caso utilizo scripts shell para eliminar nuestro software del emulador y cargar la última versión de nuestro servidor, consiguiendo con un solo comando algo que si hiciera a través de la interfaz me llevaría el doble o el triple de tiempo. El segundo:

Don’t use manual procedures

Nos dice que no hagamos de forma manual nada que pueda hacer un script o programa. Será más propenso a errores y dará más quebraderos de cabeza a la hora de ser repetido en diferentes entornos. En este caso el ejemplo es nuestro proceso de paso a producción a través de Hudson, la compilación de todos los proyectos y paso de test, etc.

En resumidas cuentas automatización, todo lo que sea susceptible de ser automático debería serlo. Será más rápido, más confiable y menos propenso a errores. No tengas miedo al coste de configuración, si lo vas ha hacer más de dos veces, vale la pena automatizar. Vamos o eso nos dice la experiencia en Frogtek …

Waterfall vs SCRUM vs Kanban (II)

[Leer Waterfall vs SCRUM vs Kanban (I)]

Fue así como descubrimos SCRUM, una metodología ágil que implementa de una u otra manera los 4 principios fundamentales del Agile Manifesto, a saber:

  1. Que aunque los procesos y las herramientas son importantes, lo son más los individuos y sus interacciones.
  2. Que aunque la documentación exhaustiva está muy bien, es mucho mejor tener prototipos que funcionan.
  3. Que aunque negociar un contrato con el cliente es vital, es mejor aún que el cliente se involucre contigo en el proyecto.
  4. Y que aunque saber seguir un plan es una estupenda habilidad, más importante es saber cambiar dicho plan a tiempo.

SCRUM define distintos roles para las distintas personas que participan en un proyecto, no voy a entrar en detalles ya que existe multitud de literatura al respecto. Simplemente saber que existe el rol de Product Owner (en adelante PO) que es la persona que, en estrecho contacto con el cliente, define las pequeñas piezas de funcionalidad que se le van añadiendo poco a poco al producto. También se define el rol del Team (equipo de desarrolladores) que son los programadores de la cosa y el del SCRUM Master, que viene a ser el encargado de que todo el proceso que define SCRUM, el ritual periódico por el que hay que pasar inexorablemente, se lleve a la práctica como Dios manda. ¿Ritual?, ¿qué ritual?. Pues principalmente uno muy sencillo, el que sigue:

  • Como nos resulta imposible saber con antelación qué es lo que quiere el cliente dividimos el tiempo en pequeños periodos (Sprints, típicamente de entre 2 y 4 semanas) sobre los que creemos tener suficiente visibilidad. Es decir, “no tengo ni idea de cómo va a evolucionar mi producto dentro de 6 meses pero sí creo saber que mi cliente quiere ver tales características funcionando dentro de 2 semanas”… Esto tiene que ver con los puntos 3 y 4 del Manifiesto Ágil (involucrar al cliente y gestionar el cambio).
  • El PO, por lo tanto, estudia con el cliente la funcionalidad que les gustaría tener disponible en la próxima versión de la aplicación. Y luego participa en la reunión de planificación de principio de Sprint en la que, junto con el Equipo de Desarrollo, se clarifica qué hay que hacer y se decide quién hará qué y cuánto tiempo costará. Punto 1, sobre las personas y las interacciones.
  • Durante todo el Sprint el Equipo de Desarrollo lleva a cabo reuniones diarias para intercambiar información. De nuevo reforzando el punto 1 del Manifiesto.
  • Cuando se acaba el Sprint se hace una reunión de Revisión y Demo en la que el PO muestra al cliente, o los desarrolladores al PO (depende) la nueva versión del producto con las mejoras de las últimas dos semanas ya listas. Punto 2, mejor un prototipo que un infumable tocho de documentación obsoleta.
  • El ritual termina con la reunión de Retrospectiva, donde el Equipo de Desarrollo junto con SCRUM Master y POs revisan el proceso y proponen mejoras para el siguiente Sprint.

Y vuelta a empezar. Hay normas extras, peculiaridades, cosas divertidas y complicaciones sobre las que se podría profundizar mucho, pero básicamente esto es SCRUM.

En nuestro caso la cosa empezó bastante “de andar por casa”. El PO era PO y SCRUM Master a la vez, los programadores no hacían Stand-ups… Cowboy-SCRUM como bien dice Pablo. Pero bueno, la intención es lo que cuenta, durante un tiempo al menos.

Con la nueva oficina la cosa mejoró, al menos el equipo técnico ya se veía las caras. Stand-ups, Sprint Plannings, Sprint Reviews, Sprint Retrospectives… toda una plétora de reuniones salpicaba nuestro calendario. Mucha diversión mientras a la vez tratábamos de montar un entorno de desarrollo decente con pre-producción, producción, repositorios de código, branches… la juerga padre vamos. El típico momento en el que a los novatos emprendedores les empiezan a crecer los enanos y se dan cuenta de que ser profesional es difícil, muy difícil y complejo, muy complejo.

Lo que veis más arriba era nuestro día a día por aquellos tiempos. Habíamos conseguido ya tener un proceso automático que compilaba todos los días a las 15:00 CET (a primera hora de la mañana de nuestros POs en USA y Colombia) una versión de preproducción. Al final del Sprint sacábamos dos versiones de producción, una el viernes después del Review del jueves y otra el domingo con las US (User Stories, pequeños fragmentos de funcionalidad) que nuestro programador exiliado en Santiago de Compostela hacía los fines de semana. Resultado: habíamos dado nuestro primer paso hacia un concepto que desconocíamos, la Integración Continua… y nos salían bugs por todos lados. Fue por eso que empezamos también a interesarnos por cosas como el TDD y las pruebas unitarias automáticas y nos empezáramos a preocupar de que la frase “pues en mi emulador funciona” se oyera cada vez menos.

En lo que respecta a SCRUM dimos un paso de adelante contratando el servicio AgileBuddy una página web que te permite gestionar distintos proyectos con sus respectivos Backlogs (el conjunto de funcionalidades a programar), los Sprint Backlogs (cosas a programar durante el Sprint), etc, etc. Se trata de una útil herramienta para gestionar tus proyectos usando esta metodología. Lo mejor, que te dota de un marco de trabajo donde tienes todo mucho más controlado y que te calcula automáticamente las métricas de tus proyectos (Burndown chart y demás). Lo peor, que a veces no es fácil entender la forma que tienen estas herramientas de calcular sus métricas y también que quizá entraba en demasiado detalle y era necesario desglosar tareas, imputar horas de forma no siempre tan fácil o intuitiva como nos gustaría.

No fue AgileBuddy, no obstante, la razón por la apenas 4 meses después decidimos cambiar al Kanban. ¿Cambiamos por las razones adecuadas?, ¿fue un cambio precipitado?, ¿estábamos haciendo suficientemente bien SCRUM?… Todo eso y mucho más, en el próximo capítulo.

Antiguas entradas