Posts Tagged acceptance testing

BeCodeWeek : Día 4

Ayer sólo hice tres cosas: blog, taller de product backlog y coding dojo. La primera no merece la pena mencionarla salvo que empleé casi toda la mañana. Después me puse a avanzar (no mucho, la verdad) en la codekata que estamos preparando para la XGN. Cuando llegó Xavi de conseguir dinero (contratos para casi todos los colaboradores) era ya casi hora de comer. Sin embargo, asistí a un momento muy interesante. Miguel Angel levantó la mano (metafóricamente) para avisar de que estaba teniendo problemas para avanzar al ritmo esperado. Xavi le echó una bronca (muy amable y didáctica, eso sí). Le explicó que había que avanzar en base a certezas y dejarse de tratar de demostrar más de una cosa en cada paso. En este caso, la iteración consiste en hacer una prueba de concepto, una bala trazadora que demuestre que la arquitectura funciona y que se puede hacer lo que se pretende. Y Miguel Angel lo entendió perfectamente y, en vez de responder a la agresión, reaccionar de una manera sumisa o bloquearse y pedir la solución concreta, explicó cuáles iban a ser sus siguientes pasos: de qué iba a prescindir para poder avanzar y en qué se iba a enfocar para conseguir el objetivo de la iteración. Y todo eso, con el cliente delante y con total naturalidad. Chapó. Es evidente que ser un punk no está reñido con ser un gran profesional.

Después de comer tomando el sol en la plaza de la Catedral con @luislitze y , volvimos a para tomar un cafelito y, mientras llegaba un cliente para preparar una visita a una feria de inversores en San Francisco, conseguí sacar la media hora mínima para empezar a trabajar el taller de backlog que también tenemos que preparar para la XGN. Surgieron conversaciones muy interesantes y creo que va a quedar muy bien. Este taller me lo voy a tener que preparar especialmente bien porque Xavi quiere sacarme de mi zona de confort y que lo lidere yo. Me gusta, porque es uno de esos empujones que necesito para saltar al vacío y porque tiene mucho que ver con un terreno en el que me siento especialmente cómodo: los criterios de aceptación (que idealmente deberían estar automatizados).

Y al final de la tarde ya nos fuimos yo con mi camiseta de agilismo.es y Miguel Angel con la de BeCode al Coding Dojo que se celebraba en la Escuela de Informática (la ETSINF). Xavi, por supuesto, iba con sus pintas de siempre. Las mismas que había llevado para visitar a un cliente y conseguir varios contratos, por cierto.

En la ETSINF me buenas instalaciones, aunque para ser la Universidad, muy poca audiencia. Eso sí, al final tuvimos conversaciones muy interesantes con algunos de los asistentes. Durante el ejercicio dimos varias recomendaciones de libros: “Refactoring“, “Implementation Patterns“, “TDD by example“, “Desarrollo Agil con TDD“, “Clean Code” y, por supuesto, “The Pragmatic Programmer“. A los que quedaron al final, charlando con nosotros sobre lo poco que se aprende en el trabajo, también les recomendé “Apprenticeship Patterns“.

La codekata que propusieron Miguel Angel y Xavi era FizzBuzz. No me deja de sorprender esta kata por la cantidad de cosas que se pueden practicar y cómo, siendo tan simple, te permite hablar de tantas cosas: naming, refactor (no sólo los refactors “hacia adelante”, sino también los “hacia atrás”), duplicación, código limpio, baby steps… Tanto es así, que me he empezado a reproducir la kata en el portátil usado git y poniendo un comentario en cada commit. Cuando lo tenga lo subiré a github.

Y bueno, cena con una agradable conversación con Miguel Angel y a la cama.

Tags: , ,

Una de Concordion

Con esto del Agile Open Spain 2009 estoy dejando de mano muchas cosas, pero no quiero abandonar el blog, así que aunque sean casi “microblogs” voy a intentar no dejar de escribir.

Dicho esto, voy a aprovechar que para el próximo miércoles en el grupo de Agile Spain en Madrid me he comprometido a hacer una presentación de 5 minutos para defender el tema “Pruebas de Aceptación Automatizadas con Concordion” y voy a dejar un par de apuntes aquí.

En el estupendo blog “Dos Ideas” he visto hace poquísimo un artículo con un par de screencasts en español sobre cómo usar Concordion + Selenium. Muy útil.

Para los que utiliceis .NET y queráis usar Concordion.NET, éste es vuestro blog (en inglés).

Lo siento, no hay tiempo para más. :(

Tags: , ,

AAFT, GTAC y automatización de pruebas en España

Estaba viendo una entrevista grabada durante la conferencia Agile2008 a Elisabeth “testobsessed” Hendrikson acerca de una iniciativa bastante interesante llamada Agile Alliance Functional Testing Tools Group (AAFT para que nos entendamos). Hay una lista de correo en Yahoo a la que ya me he suscrito y a través de la cual me he enterado de que Google organiza la cuarta “Google Test Automation Conference” dedicada a las pruebas para la web. Si alguno de vosotros está interesado en asistir, que sepa que este año será en Zurich (Suiza) entre los días 21 y 22 de Octubre. Y si alguno es más valiente y se atreve a proponerse para dar una charla, el “call for proposals” ya está abierto y termina el 1 de Agosto.

Me pregunto qué foros similares hay en España. Me refiero tanto a conferencias dedicadas exclusivamente a la automatización de pruebas como a grupos donde discutir sobre herramientas orientadas a la automatización de pruebas. En el primer grupo yo conozco la conferencia QA&TEST, que se celebra anualmente en Bilbao y que por lo que tengo entendido se orienta sobre todo a las pruebas en entornos de software empotrado (perdón, embebido). Pero en el segundo es que ni eso. ¿Qué pasa en España que no nos organizamos en grupos para aprender? Bueno, al menos en Agile Spain estamos invirtiendo esa tendencia, demostrando que estas inversiones de tiempo empleadas en reunirnos con desconocidos para compartir experiencias y conocimientos (pongo el ejemplo del grupo de Madrid o el del grupo de Barcelona) son inversiones muy rentables.

Tags: , , ,

Salvando las distancias

Voy en metro, ilusionado, camino del segundo día del curso de Scrum de Medinilla. Y me he pillado el libro de Gojko Adzic “Bridging the Communication Gap” porque ayer surgió el tema de las especificaciones ejecutables y los roles dentro del equipo. Pero estoy un poco desentrenado porque hace mucho que no voy en metro con tiempo para leer, y el iPod lo tengo vacío de podcasts por escuchar, así que me he puesto la “música aleatoria” y mientras escucho de lo más variado (desde la deliciosa Joy Denalane hasta M-Clan, que no veas cómo me animan) he pensado en tomar notas para cumplir con una “cierta obligación”: explicar lo que me ha parecido el libro.

Gojko Adzic es un tipo que habla en inglés con un acento balcánico realmente difícil de seguir (al menos para mi), así que pensé que era buena idea comprar el libro para entender a qué se refiere cuando habla de talleres de especificaciones y de pruebas de aceptación ejecutables en entornos ágiles. Además, Gojko Adzic también imparte cursos sobre Domain-Driven Design y esa relación entre DDD y pruebas de aceptación es algo que me interesa bastante.

Voy a ser sincero, también compré el libro porque es el primero en el que se habla de Concordion, la herramienta open source en la que modestamente colaboro. Pero son apenas unas páginas y el valor del libro es mucho más que eso.

Adzic explica la importancia de que “la gente del negocio” hable el mismo idioma que “la gente técnica”. Esto muchos lo entienden como obligar a clientes y usuarios a que hablen en términos tecnológicos como “altas, bajas, modificaciones y listados (CRUD en inglés)”, o peor aún, de tablas, campos y relaciones.

En DDD hablamos de un lenguaje ubícuo, o único en todo el proyecto, y que es el que usan tanto técnicos como usuarios. Esto permite reducir los defectos producidos por malentendidos y tiende puentes entre ambos mundos, abriendo la posibilidad a una verdadera colaboración.

Un inciso melancólico. Voy ahora mismo montado (mientras escribo estas notas en mi moleskine) en el metro ligero y me he acordado de ese par de meses intensos que viví y trabajé (sobre todo lo primero) en Melbourne (Australia). Allí fui usuario del “tram” y he de decir que me parece un medio de transporte público de lo más interesante porque es a la vez rápido, cómodo y silencioso.

Pero sigamos con el libro. El grueso del mismo se basa en hablar del “agile acceptance testing” y de cómo buscamos ponernos de acuerdo en qué es lo que hay y lo que no hay que desarrollar. Para esto usamos ejemplos realistas en vez de requisitos abstractos. “Los ejemplos demuestran cómo debería actuar el sistema y cómo debería ayudar a los usuarios a hacer su trabajo”. Adzic propone que estos ejemplos sean creados por todo el equipo de implementación, no sólo por un “experto del dominio” (también conocido como “analista de negocio”) como en modelos de desarrollo más tradicionales. “Usamos los ejemplos para discutir el dominio y asegurarnos de que no hay malentendidos”.

Según Adzic, el uso de ejemplos realistas obliga a pensar más acerca de los problemas. De hecho, comenta cómo se producen muchas discusiones entre los expertos cuando se plantean ejemplos para casos extremos; discusiones que incluso les hacen a veces revisar sus propios procesos de negocio. ¡Vaya! Si resulta que podemos ayudar a nuestros clientes en vez de simplemente observar su comportamiento “desde fuera”, como si fueramos “supernanis con corbata”.

Damned! ¡Me he saltado una parada! Estaba tan concentrado… Menos mal que la frecuencia del metro ligero éste es alta y he podido llegar sólo un par de minutos tarde. Buff…

De vuelta del estupendo curso de Ángel Medinilla, sigo con el resumen del libro y me fijo en que no he explicado esto de los ejemplos. Vamos, que no he puesto ejemplos de ejemplos. :-) Adzic pone un ejemplo en la página 45 de una regla de negocio relacionada con el descuento que le podemos ofrecer a un cliente, pero a mi me gusta más el que explica David Peterson en la web de Concordion. Es bastante más completo porque nos lleva desde la historia de usuario (el requisito) hasta la prueba de aceptación automatizada (en forma de ejemplos). Es interesante cómo David hace mucho hincapié siempre en que debemos especificar con ejemplos que expliquen comportamientos muy elementales y dejar para otras especificaciones todo aquello que quedaría fuera. Son los “Further details” en el ejemplo. También Adzic habla de esto en su libro, pero menos; y yo creo que es importante esta anotación al margen para aquellos que queráis “tomar este camino” para hacer pruebas de aceptación.

En “Bridging the communication gap” también se explica cómo conducir estas reuniones (talleres de especificación) e incluso aconseja sobre algunas herramientas. Pero creo que es interesante explicar cómo pueden encajar estos talleres en nuestro calendario semanal (ágil).

Adzic sugiere lo siguiente:

Release es todo aquello que hacemos después de la demo para dejar bien cerrado el sprint. Etiquetamos en subversion, hacemos copias de seguridad, ponemos las versiones del nuevo sprint en los pom.xml (si usamos Maven y si es que tenemos que cambiar de versión), limpiamos las pizarras… y mientras esto lo pueden ir haciendo algunos desarrolladores (típicamente los becarios, je, je) pues el resto puede estar preparando el sprint primero revisando el backlog y luego, ya con los becarios incorporados, estimando las historias y decidiendo lo que se podrá hacer razonablemente en el sprint (las próximas dos semanas).

Ojo, es una manera de organizar el trabajo durante un sprint, pero lo importante de esto es que el dueño del producto (también conocido como jefe de proyecto, analista de negocio, o incluso tester, según vuestro “mapeo” preferido) se encarga de trabajar las historias de usuario (redacción y priorización) y de los ejemplos (criterios de aceptación) antes de los talleres de especificación, pero realmente es el equipo en su totalidad quien acuerda lo esencial de los criterios de aceptación mediante la discusión que se ofrece en esta reunión. Para los que ya estéis algo picados con esto del agilismo, me permito recordar “las tres Ces” (card, conversation, confirmation). Éste es el momento ideal para la conversación, aunque ya se haya tenido una conversación previa cuando se han estimado las historias de usuario en el Sprint Planning Meeting (usando terminología Scrum).

Bueno, y hasta aquí hemos llegado. Espero que os resulte útil. Y si alguien más se ha leido este libro y quiere contrastar aquí su opinión, estaré encantado de poder charlar con vosotros porque mi intención es preparar una presentación (o un taller, ya veré) sobre este tema y exponerla bajo el “paraguas” de Agile Spain.

Tags: , , , , , ,

Concordion: un ejemplo

Hace ya varios meses que estoy involucrado en el proyecto Concordion, un framework para construir y ejecutar pruebas de aceptación. Desde entonces hasta ahora el código base no ha cambiado significativamente, pero hasta ahora seguíamos sin tener un ejemplo de uso con el código fuente incluido más completo que el HolaMundo del proyecto concordion-samples. En el artículo de hoy voy a pagar esta deuda.

Concordion

Las principales características de Concordion son:

  • Las especificaciones se escriben en XHTML
  • libertad absoluta de formato, que favorece escribir las especificaciones orientadas a comprobar los comportamientos en vez de orientadas a “scripts”
  • no es necesario conocimiento técnico para poder escribir las especificaciones

  • Las especificaciones se instrumentan para ejecutar código Java sin restricciones, puesto que las fixtures son clases Java que heredan de una extensión de TestCase de JUnit (o anotada con @ConcordionRunner) y que se vinculan con las especificaciones por convenio (se llama igual que la especificación pero con el sufijo Test)
  • No hay ficheros de configuración
  • Está disponible en el Repositorio Central de Maven
  • groupId
    org.concordion

    artifactId
    concordion

    version
    1.3.0

  • Se ejecuta como cualquier test JUnit
    • el resultado de la ejecución son los mismos XHTML pero iluminando los textos instrumentados con verde si se cumple la condición, rojo si no se cumple o amarillo si se ha producido una excepción
    • también hay un plugin Maven que produce un resumen del resultado de la ejecución que recorre todos los XHTML resultantes y que mejora el que produce el plugin Surefire para los JUnit

    Proyecto de ejemplo

    He creado un proyecto en GoogleCode para, entre otras cosas, ir realizando todas estas pruebas. Anteriormente había escrito un artículo donde se trataba de ilustrar el uso de Spring y de JPA juntos. Ahora he incorporado un ejemplo que ilustra cómo pasar de una historia de usuario sobre el Mantenimiento de un Catálogo de Productos para una tienda. Esto es un poco CRUD, pero poco a poco iremos viendo cómo incluso en ese escenario podemos orientarnos al comportamiento.

    ¿Cómo descargar y probar este ejemplo?

    Para descargar este proyecto podéis seguir las instrucciones:

    svn co http://shopaas.googlecode.com/svn/trunk/shopaas shopaas

    Podéis revisar los siguientes detalles por si queréis cambiarlos.
    En shopaas/pom.xml

    …y a continuación podéis construirlo usando Maven. Para ello, ejecutad:

    cd shopaasmvn clean install cobertura:cobertura site

    Si todo ha ido bien, podréis comprobar que se ha generado un “site” del proyecto en la carpeta target/site.

    Desgraciadamente no he conseguido aún que queden correctamente enlazados los módulos, por lo que es necesario ir hasta la carpeta shopaas/services-acceptance-test/target/site y abrir el fichero index.html con nuestro navegador favorito para poder ver el resultado de las pruebas de aceptación (incluso el informe de cobertura de las mismas).

    Si ejecutáis la construcción del proyecto desde la linea de comandos, es posible también que tengáis un problema de falta de memoria (Error “Java Heap Space”), para evitarlo tendréis que ejecutar antes que nada “set MAVEN_OPTS=-Xmx128m”. A mi me ha dado este problema cuando lo he probado en Windows XP con un JDK 1.6.0_11, y sospecho que tiene que ver con los valores por defecto que elige la JVM en este entorno. Pero tampoco lo tengo 100% seguro.

    maven-concordion-plugin

    No sé si para el momento en el que probéis esto ya estará publicado en el Repositorio Central de Maven el plugin que permite obtener informes resumidos de Concordion. Si no fuera así, también deberéis descargar el código del maven-concordion-plugin y construirlo con mvn install.

    Cobertura

    El informe de cobertura del código (“code coverage”) ha sido algo que me ha costado especialmente puesto que el código a instrumentar no está en el mismo módulo que las pruebas, de modo que he usado una combinación de los plugins maven-antrun-plugin y build-helper-maven-plugin. Como podréis comprobar, así podemos conocer con bastante certeza si hay código que llevamos a producción para el que no tenemos ninguna prueba. Mmmm, sí que es interesante, ¿verdad?

    Automatización

    Pero lo más interesante es que está completamente automatizado. También están las pruebas de aceptación de la UI que os mostré en un artículo anterior. Por tanto, tenemos pruebas unitarias de los componentes internos, pruebas de aceptación de los servicios de aplicación (escritas en lenguaje de negocio) y pruebas de aceptación de la UI (independientes de la implementación de los servicios de aplicación, o no, esa es nuestra decisión). Con lo que sólo nos queda, en cada “release”, darnos un paseo por la aplicación por aquellos puntos críticos o para los que el coste de hacer una prueba automática sea excesivo. Pero el resultado neto es que hemos ganado en confianza y reducido el tiempo que tardamos en entregar un proyecto. En estos tiempos de crisis, eso es importante, ¿verdad?

    Recursos

    También hay disponible un tutorial de Concordion. Además, a continuación incluyo una lista de enlaces de interés:

    Feedback (o reacciones)

    Por favor, espero que me hagáis llegar vuestros comentarios cuando probéis esto. Me ayudarán mucho a mejorar este ejemplo. No tengo claro cómo organizar el código para que Maven me construya todo como es debido y eso le resta claridad al resultado final, que debería ser que el “Product Owner” o los “expertos del dominio” pudieran navegar hasta el resultado de las pruebas de aceptación y discutir tanto sobre su definición como sobre el resultado de la ejecución.

    También hay dos conjuntos de código diferentes: users y products. El primero corresponde a aquel ejemplo que hice hace ya unos meses y el segundo es el que he estado trabajando últimamente y que pretendo que me sirva como piedra de toque para ir encontrando patrones o plantillas.

    Tags: , , ,

    Diseño emergente

    Mientras preparaba una sesión del curso online de Lean Software Development que imparte Alan Shalloway tuve que leer un artículo de él mismo titulado algo así como “Guía para desarrolladores ágiles sobre Lean Software Development” (traducción libre). En este artículo se recopilan detalles interesantes como los principios fundamentales del desarrollo de software “lean” (Nota: demonios, necesito una traducción para este término), pero lo que quizás más me ha gustado ha sido la definición de Diseño Emergente.

    Shalloway explica que al abordar un diseño hay básicamente dos opciones: diseñar estríctamente para cubrir los requerimientos (con lo que el código resultante irá siendo progresivamente más difícil de mantener) o diseñar pensando en el futuro (con lo que frecuentemente introducimos más complejidad de lo necesario). Aquí introduce Shalloway una tercera opción que denominamos Diseño Emergente y que resulta de la combinación de tres disciplinas (ojo, dice disciplinas):

    • basar el diseño en patrones para crear arquitecturas resistentes y flexibles a la vez, abaratando así el coste de mantenimiento del código
    • limitar el diseño sólo a los requisitos actuales (no adelantarse a requisitos futuros), consiguiendo así reducir el tamaño y complejidad del código
    • escribir pruebas de aceptación y unitarias automatizadas antes de escribir el propio código, favoreciendo así la construcción de un mejor diseño y haciendo que sea más seguro aplicar cambios

    Shalloway también dice que el Diseño Emergente nos ayuda a añadir código nuevo desacoplado del viejo pero sin incorporar complejidades innecesarias. Esto, dicho así, puede resultar un poco difícil de entender, pero en el contexto de desarrollos iterativos tiene mucho sentido.

    Trabajar sin un diseño completo desde el principio es algo incómodo por el nivel de incertidumbre que se maneja, pero si lo pensamos fríamente, es muchor mejor postergar las decisiones de diseño mientras tengamos dudas sobre los requisitos. En cualquier caso, me gustaría añadir que trabajar con un Diseño Emergente NO significa trabajar SIN diseño o con un diseño IMPROVISADO. Me remito a las tres disciplinas que enumera Shalloway:

    Patrones de diseño

    Emplear patrones de diseño contribuye definitivamente a que tengamos un diseño fácil de transimitir (incluso fácil de documentar). (Nota para los arquitectos: es una buena práctica documentar con gran detalle los patrones empleados -aunque no sean del GoF y nos los hayamos “inventado”- y pedir a los desarrolladores que documenten en su código qué piezas de los patrones están implementando.)

    Por otro lado, los patrones de diseño nos permiten construir soluciones extensibles puesto que no resuelven nuestro problema sino un problema más general.

    Me gustaría añadir que también podemos añadir patrones de análisis (ver libro de Fowler “Analysis Patterns“, p.ej.) a nuestra caja de herramientas con el objetivo de ser capaces de plantear el diseño más adecuado a nuestro problema, pero con la “puerta abierta” a futuras necesidades.

    No adelantarse al futuro

    Nuestro pequeño gran ego de programador nos empuja indefectiblemente a demostrarle al mundo entero lo listos que somos al ser capaces de ver el futuro y adelantarnos a todos prediciendo las necesidades de los clientes. Para ello solemos diseñar soluciones tan virtuosas como inútiles para el 80% de las necesidades reales de los clientes. Frecuentemente nos encontramos con diseños que transforman datos entre capas una y otra vez hasta llevarlas a la base de datos, validando una y otra vez los datos (antes y después de persistirlos)… aunque esos datos en realidad el cliente nunca los ha necesitado guardar. Alguien decidió en algún momento que era mejor guardarlo todo “por si acaso” y la consecuencia es un código tremendamente difícil de explicar, con muchos defectos de desarrollo y un rendimiento muy mejorable. Muchas veces somos nosotros mismos los que diseñamos así: “por si acaso”.

    Pues bien, está demostrado que es mejor no diseñar “por si acaso”. En la mayoría de las ocasiones no estamos haciendo una inversión sino introduciendo complejidad que nunca se verá compensada. En términos económicos eso no es rentable.

    Propongo que hagáis el ejercicio de identificar algunas de esas “características avanzadas” que se incorporan “por un pequeño esfuerzo más” y que al final del proyecto nunca se han utilizado. Si además sois capaces de saber cuánto ha sido ese “pequeño esfuerzo más”, quizás lo podáis sumar a los defectos y retrasos provocados por esas “características avanzadas”. Claro, un diseño sin “características avanzadas” es menos “cool”. :-)

    Pruebas automatizadas

    Muchísimas veces me he encontrado con que teníamos tanto miedo de hacer cambios en el diseño que retorcíamos el diseño existente hasta límites insospechados. En ocasiones, cambiar aquí hacía que allí dejara de funcionar. Lo más terrible era cuando nos enterábamos de ese impacto cuando nos llamaba el cliente para decirnos que les había salido un mensaje muy extraño en la pantalla…. Ay, si hubieramos contado con un conjunto de pruebas automatizadas que cubrieran los requisitos de nuestros clientes…

    Hoy día, este problema está claramente superado, si no tenemos un motor de integración continua y desarrollamos nuestras pruebas unitarias y de aceptación es o porque no sabemos o porque no queremos, pero no nos podemos escudar en que no es posible o que es muy costoso.

    Instalar Hudson, Continuum o CruiseControl se hace en dos patadas y desarrollar pruebas unitarias con JUnit o TestNG está ampliamente documentado. Si tenéis un frontal web podéis usar Selenium, HttpUnit o algún otro framework similar. Si tenéis web services podéis usar SoapUI o haceros vuestro propio framework “ad hoc” basándolo en HttpUnit, por ejemplo. Y finalmente, para escribir las pruebas de aceptación tenéis desde el viejo Fit (o Fitnesse) hasta Concordion (lógicamente mi recomendación) o incluso easyb o jBehave. Para cada clavo seguro que tenéis vuestro martillo.

    Pero Shalloway va un poco más allá y pide escribir las pruebas ANTES que el código. Hay mucho escrito sobre TDD (test-driven development), ATDD (acceptance test-driven development) o BDD (behaviour-driven development), pero os puedo asegurar que practicar el “red-green-refactor” termina dando como resultado diseños y código de mucha mejor calidad, con el beneficio añadido de que tenemos una estupenda red de seguridad formada por las pruebas que hemos ido escribiendo para explicar qué queríamos que hiciera el software y no para explicar lo que ya hacía el software. Además, reducimos el número de defectos y, yo no sé a vosotros, pero a mi no me gusta nada estar resolviendo defectos… a mis jefes tampoco. :-)

    Proceso de descubrimiento

    Otra afirmación de Shalloway con la que estoy muy de acuerdo es que:

    El proceso de desarrollo de software es más un proceso de descubrimiento que de construcción.

    Podría dedicar un artículo entero a esta afirmación pero sólo quiero señalar que parte de lo que se va
    descubriendo durante este proceso es justamente el Diseño Emergente.

    Viendo el desarrollo de software dentro del proceso mayor que lo engloba, el desarrollo del producto, podemos decir (simplificando mucho) que hay 3 fases para desarrollar un producto:

    • descubrir las necesidades del cliente
    • imaginar cómo construir los artefactos que cubrirán esas necesidades
    • construir los artefactos

    Shalloway explica muy bien en su artículo cómo empleamos un gran esfuerzo en las dos primeras fases a pesar de que normalmente no somos casi ni conscientes (¿inconscientes?) de ello. Si de repente tuvieramos la oportunidad de reconstruir nuestro sistema tardaríamos digamos un 50%-80% menos del tiempo empleado la primera vez. Ese tiempo “perdido” es el correspondiente a las dos primeras fases: descubrir necesidades y diseñar los artefactos.

    El artículo de Shalloway del que he extraído las principales ideas que os he comentado es mucho más rico porque recorre los principios fundamentales de “Lean” y va mostrando qué prácticas ágiles surgen a partir de ellos. Esta muy bien porque así es posible tener un fundamento teórico para unas prácticas y, cuando en ocasiones no es posible aplicarlas, podemos sustituirlas por otras pero respetando los principios, es decir, buscando los mismos beneficios. También compara los procesos de producción JIT (just-in-time) con los procesos ágiles de desarrollo de software, pero esto casi merece otro artículo sólo para él.

    Estaría encantado de conocer vuestras opiniones.

    Tags: , , ,

    Editor para Concordion

    Papá Noel me ha traído esta Nochebuena un plugin Eclipse para facilitar el trabajo con Concordion. Si abro una especificación (un fichero html) con el editor Concordion, se abre una ventana de edición con dos pestañas: una con la especificación y otra con la fixture (el fichero java asociado). De la misma manera, si abro la fixture (un fichero java) con este editor, se abre una ventana de edición con las mismas dos pestañas y los mismos contenidos. Las fixtures se editan con el editor Java estándar y las especificaciones html con el editor web, que a su vez tiene dos pestañas: una con la vista de diseño y otra con la de previsualización. Además, la vista de diseño web está dividida y muestra arriba la página web para editar en formato WYSIWYG y abajo en puro HTML.

    He basado el desarrollo en el ejemplo de editor multipágina que viene con Eclipse y en el WicketBench, un editor para Wicket que hace muchas más cosas y del que he tomado prestadas algunas ideas también para el futuro. Sin embargo, aún tengo que trabajar mucho este plugin porque es la primera vez que hago algo útil con Eclipse RCP y tengo mucho que aprender. De momento, los siguientes pasos serán:

    1. hacer pruebas unitarias (para poder refactorizar)
    2. refactorizar (es mejor no mirar al código ahora mismo)
    3. crear automáticamente el desplegable en forma de site (ahora es un jar que construyo manualmente)

    Podéis descargar el jar y simplemente dejarlo en la carpeta “plugins” de vuestra instalación de Eclipse.

    Felices Fiestas a todos, por cierto.

    Tags: , ,

    La Gran Brecha de la Fatalidad

    Acabo de verme enterita una presentación de Dan North y Martin Fowler en la QCon 2007 de Londres titulada “The Yawning Crevasse of Doom” (La Gran Brecha de la Fatalidad) donde hablan (durante 1 hora) sobre la necesidad de construir puentes de comunicación entre el negocio y la técnica. Llegué a ella a partir del blog de Gojko Adzic (que está preparando un libro sobre pruebas de aceptación ágiles) y de ella es posible obtener muy buenos argumentos y técnicas agilistas. Insisto: muy recomendable.

    Durante 1 hora da para decir muchas cosas, pero yo me quedaría con lo siguiente:

    Construir puentes
    En vez de tener a los analistas yendo y viniendo entre los usuarios y los técnicos (la brecha), es mejor conseguir que la organización permita establecer puentes entre ambos mundos. Aquí insisten en la importancia vital de las conversaciones entre usuarios y técnicos porque ayudan a evitar trabajar en funcionalidades que no aportan valor de negocio y además permiten encontrar mejores soluciones que trabajando a través de intermediarios.

    Fatalidad
    Si creemos que no es posible construir esos puentes, estaremos de alguna manera influyendo en nuestro entorno para que la brecha se siga manteniendo e incluso se amplíe. Así se defienden unas partes de otras mediante contratos, documentos de requisitos, diagramas de arquitectura… En cambio, si la actitud es positiva, es posible colaborar en un entorno de confianza en la que incluso se pueda trabajar en construir un sistema sin conocer cómo será el “desplegable” final.

    Lenguaje ubicuo
    Para que todos dentro del equipo (gente de negocio y gente técnica) puedan entenderse es conveniente usar un lenguaje ubicuo (tal y como recomienda Eric Evans en su estupendo libro “Domain-Driven Design“).
    Sin embargo, el uso de un lenguaje común entre usuarios y técnicos que permita y/o facilite la comunicación entre ambas orillas no debe obligarnos a que este lenguaje sea “universal” para toda la empresa. Fowler dice explícitamente que es mejor un conjunto de “modelos locales” (más manejables y comprensibles y menos abstractos) y un mecanismo de mapeo entre ellos.

    Construir juntos
    Técnicas como construir juntos “Prototipos de baja fidelidad” (ya sabéis, “paper prototyping” con Post-Its, etc), “Storyboards” (como los que se usan para las películas de cine),… ayudan a construir esos puentes.

    Hecho
    Para especificar qué entienden los usuarios y los técnicos por “tarea completada” es conveniente utilizar ejemplos, idealmente que se puedan comprobar automáticamente. (Es lo que se conoce como pruebas de aceptación ejecutables).

    Suficiente
    Otro término muy relacionado con “hecho” es “suficiente”. Se trata de conocer lo suficiente para avanzar hasta el siguiente paso. Para ello es necesario asumir que las prioridades están en constante cambio durante la construcción del proyecto.

    Productividad
    Un detalle, ¿sabíais que sólo el 15% aprox del coste total del software corresponde a la programación?
    Es muy importante trabajar continuamente en encontrar todas las oportunidades posibles que nos permitan recoger reacciones (feedback) de todos los miembros del equipo y conocer aquellos factores puedan afectar al estado de ánimo del equipo puesto que éste es un aspecto psicológico que afecta significativamente a la comunicación y, por tanto, a la productividad.

    Tags: , ,