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

jueves, 4 de agosto de 2011

Programa de Agiles 2011 (y se acaba el descuento a fin de mes)

Ágiles 2011Como ya comenté antes, este año la conferencia latinoamericana de metodologías ágiles, Ágiles 2011 se realiza nuevamente en Buenos Aires, como en su primera edición del 2008.

Finalizada recientemente la llamada a ponencias, ya está disponible la primera versión del programa, donde pueden verse las sesiones aceptadas y distribuidas para los dos primeros días.

Pueden ver directamente las sesiones del día 11 de octubre y las del día 12 de octubre. El día 13 de octubre será dedicado exclusivamente al formato Open Space. El programa puede cambiar en cuanto a horarios, pero ya se pueden ver las propuestas aceptadas para los 7 tracks en paralelo, con contenidos en español, inglés y portugués.

El evento será del 11 al 13 de octubre en la Universidad de Palermo, Mario Bravo 1050 de la Ciudad de Buenos Aires. La registración está abierta desde hace tiempo y hasta el 31 de agosto hay un importante descuento.

Las figuras principales del evento serán los Keynote y Guest Speakers. Las keynotes (sesiones principales de los tres días) estarán a cargo de:

Jeff Patton
Jeff Patton
Agile Product Design

James Shore
James Shore
The Art of Agile Development

Juan Gabardini
Juan Gabardini
Agiles.orgIEEE CS

y los invitados especiales:

¡Espero encontrar muchos lectores de este blog en el evento!

viernes, 15 de julio de 2011

Agiles 2011 se acerca y atrae más actividades

Como ya vengo anunciando, del 11 al 13 de octubre llega Agiles 2011 a Buenos Aires. Esta será la cuarta edición de la conferencia latinoamericana, y la segunda en la capital argentina.

Juan Gabardini

Algunas novedades de la organización es que se ha confirmado a Juan Gabardini como otro de los keynote speakers, cumpliendo con una antigua deuda en la comunidad de dar este espacio a los representantes más destacados de la comunidad local.

Juan en uno de los fundadores de la comunidad regional, reconocido especialista en el área de control de calidad de software con mucha experiencia también como mentor en torno a dinámica de grupos y metodologías, sin alejarse tampoco del código mismo. También es presidente del capítulo argentino de la IEEE Computer Society y docente en la Facultad de Ingeniería de la UBA.

 

Talleres extra

Aprovechando también la presencia local de los demás oradores internacionales, Juan está organizando también un taller con James Shore, titulado "The Art of Agile Planning". James es otro de los keynote speakers de Agiles 2011 y es el autor del libro "The Art of Agile Development", casualmente.

En este taller que James dictará (en inglés) los días 6 y 7 de octubre, la semana previa a la conferencia, James cubre los siguientes temas:

 

  • Organizar las reuniones diarias o stand-up
  • Crear y priorizar historias de usuarios, tareas y características mínimas con valor de mercado
  • Realizar compromisos confiables para la iteración y predecir la velocidad
  • Personalizar el horizonte a largo plazo según las necesidades de la organización
  • Calcular entregas predecibles para coordinarse con terceros
  • Adaptar planes para crear y aprovechar oportunidades

Esta es una actividad arancelada, por tratarse de un taller intensivo de dos días completos, y se llevará a cabo en el auditorio del Grupo de Usuarios Microsoft ().

Más información y registro, en el sitio de Agilar.

 

viernes, 8 de julio de 2011

Video: Comunicación no violenta, con Ingrid Astiz

IngridAstiz

En la última reunión mensual de Ágiles @ Buenos Aires el tema central fue "Comunicación no violenta", coordinada por Ingrid Astiz de Fuerza Tres.

Ingrid tiene un background mixto entre sus estudios de filosofía en UBA y sus 16 años trabajando en desarrollo de software, que canalizó volcándose a las metodologías ágiles, poniendo fuerte foco en la dinámica de grupos y las relaciones humanas.

Pueden ver, además del video debajo, la presentación de Ingrid embebida en este post de su blog.

El video está dividido en 3 segmentos, y dura en total unos 50 minutos.

lunes, 4 de julio de 2011

Video: ¿Qué esperas de Agile? con Federico Zuppa

Federico Zuppa

Este video es de una de las reuniones mensuales de Agiles @ Buenos Aires, pero me había quedado en el tintero procesarlo y publicarlo, así que, con disculpas a Federico por la demora, acá va.

Federico es desarrollador y coach en metodologías ágiles en 10Pines, y anteriormente trabajó en EDS (hoy HP), Globant y otras empresas de software, involucrándose en proyectos muy interesantes.

Después de años utilizando metodologías ágiles y actuando como introductor en muchos equipos, se unió a 10Pines para dedicarle más tiempo a esta actividad de ayuda.

Mediante esta actividad encontró muchas veces una variedad de expectativas y objetivos respecto a la adopción de este paradigma, y de eso habla en esta sesión que presentó originalmente en Agiles 2010 en Lima y repitió en la reunión de Buenos Aires de marzo de este año.

Queda el video, entonces, dividido en 3 partes, que duran en total unos 50 minutos.

jueves, 30 de junio de 2011

Webinar gratuito: Especificaciones por medio de ejemplos usando FitNesse

Juan Gabardini

El próximo 21 de julio (de 18:30 - 20:00; GMT -3; horario de Buenos Aires) el amigo Juan Gabardini, viejo compañero de aventuras, estará presentando un Webinar (un seminario via web) patrocinado por la buena gente de Kleer.

El tema es el uso de casos de prueba basados en ejemplos utilizando FitNesse, la plataforma de pruebas de aceptación basada en wikis creada por el tío Bob Martin y amigos en base al FIT original de Ward Cunningham (ambas herramientas de código abierto y gratuito).

El evento es en línea y gratuita, pero los interesados deben registrarse porque hay una cantidad máxima de asistentes (aunque no se bien cuál).

La sesión se presentará utilizando GoToMeeting, un servicio de conferencias en línea de Citrix que soporta Windows y Mac OS y utiliza un cliente que se descarga al momento de la conexión, por lo que recomiendo conectarse unos 10 minutos antes para estar seguros de que todo funciona correctamente.

 

El temario, según la invitación, es el siguiente:

FitNesse

¿Cómo logramos que los requerimientos sean claros tanto para los usuarios como para los desarrolladores?


¿Cómo lograr validar continuamente y con bajo costo que el producto cumpla con los requerimientos?


Veremos las especificaciones por medio de ejemplos, una técnica utilizada para lograr estos objetivos, y Fitnesse, una herramienta libre que soporta la técnica.


Fitnesse permite escribir los ejemplos (requerimientos) como tablas o historias, y ejecutar automáticamente estos ejemplos contra la aplicación, informando si la aplicación cumple con los resultados esperados.

 

lunes, 27 de junio de 2011

Video: Programando de a pares con Diogenes Moreira

Diogenes Moreira

En esa sesión mi par es Diogenes Moreira, amante de la Orientación a Objetos que a pasado por múltiples tecnologías desde Cobol y PowerBuilder hasta Java y C#, siempre con su corazón cerca de Smalltalk.

Diogenes trabaja actualmente para Ilon SA y aunque tiene múltiples responsabilidades no deja de programar junto a su equipo. Participó en varios proyectos de código abierto, incluyendo colaboraciones para Pharo.

Nos conocemos por amigos comunes y por el grupo Agiles de Buenos Aires, y casualmente durante una de las reuniones mensuales de éste nos escapamos un rato a grabar este video en que hacemos algunos ejemplos con Seaside, un framework web para Smalltalk.

Como acompañamiento del video, dejo esta presentación de Esteban Lorenzano, en la que se recorren varias de las características que Diogenes comenta mientras escribimos los ejemplos:

Sin más preámbulos, el video, que dura aproximadamente 35 minutos. Estoy usando un servicio que brinda mucho mejor calidad de video (sobre todo para el código), pero tengan paciencia porque el reproductor puede tardar varios segundos (a veces casi un minuto) en empezar.

 

martes, 21 de junio de 2011

Se aproxima otro Alt.NET Buenos Aires (y video de una VAN)

Alt.NET Hispano

Cada tanto la comunidad Alt.NET se pone de acuerdo para realizar un Open Space en Buenos Aires, como en muchas otras partes del mundo. Ya he cubierto ediciones anteriores en este blog, y ahora me toca informar sobre la organización de una nueva reunión.

Como suele ocurrir, hay mucha gente que está interesada pero aún no se ha acordado la fecha definitiva, aunque hay consenso en hacerla durante el mes de julio. Para votar por la fecha que prefieran los interesados, estamos utilizando este mecanismo:

http://whenisgood.net/p5734be

¡No sean tímidos! Todo el que esté realmente interesado en participar puede elegir qué sábado le queda mejor. Tengan en cuenta que usualmente s desde las 9 de la mañana hasta las 6 de la tarde, con la interrupción del almuerzo que se hace in-situ. Es probable que el lugar sea Microsoft de Argentina, en Bouchard 710, 4to piso, Ciudad de Buenos Aires.

Para quienes nunca estuvieron en un Open Space, dejo esta descripción en castellano del grupo Agile Spain.

Y como siempre, aprovecho para recordar que además de estas reuniones presenciales que se organizan esporádicamente en distintas ciudades, el grupo Alt.NET Hispano organiza reuniones virtuales en forma semanal (a veces más de una por semana), que se anuncian en la lista de distribución y en el calendario de reuniones del sitio.

Estas reuniones quedan grabadas y pueden verse a demanda una semana o dos después de su ejecución, y el grupo ya lleva (a hoy) 73 reuniones que pueden verse en línea o descargarse desde el histórico de reuniones.

Como muestra, dejo el video de la reciente sesión sobre REST Services y WCF Web Api, presentada por Pablo Cibraro, Gustavo Machado y José Romaniello, de Tellago.

Unable to display content. Adobe Flash is required.

 

lunes, 23 de mayo de 2011

Video: Programando de a pares con Martín Alaimo

Martín Alaimo

En este segundo video de la serie de sesiones de programación de a pares le toca el turno a Martín Alaimo, de Kleer.

Conocí a Martín en los comienzos de la comunidad Agiles.org en Argentina, cuando él todavía trabajaba en Accenture, y seguimos en contacto desde entonces, compartiendo varios eventos, viajes y peripecias del mundo del desarrollo.

Martín tiene algunas certificaciones más tradicionale como PMP (Project Management Professional) o Certified Java Developer, y varias dentro del campo ágil, como Certified Scrum Master Practitioner (la variante más concreta de esa certificación algo cuestionada) y más complejo aún, es uno de los pocos entrenadores certificados del curso de Scrum Development en América Latina (el único en Argentina y alrededores, hasta donde yo se).

Pero lo más importante no son los títulos sino la larga experiencia que demuestra desarrollando o enseñando, y la buena disposición para compartir esos temas con la comunidad, que lo han llevado a organizar los Yoseki Coding Dojo (de los que hablé en otro post) y asumir la responsabilidad de co-dirigir la organzación de Agiles 2011.

En esta sesión lo que tratamos de recorrer con Martín es el camino del diseño basado en dos prácticas complementarias pero que a veces parecen solaparse: TDD (Test-Driven Development) y ATDD (Acceptance Test-Driven Development).

Para el ejemplo, que codificamos en Ruby, usamos Cucumber para las pruebas de aceptación (ATDD) y RSpec para las unitarias (TDD).

Espero que les resulte interesante, y como siempre, esperamos feedback para saber por dónde continuar o qué temas tratar en más profundidad.

 

viernes, 13 de mayo de 2011

Video: Programando de a pares con Carlos Peix

Carlos Peix
Con este post comienzo una serie de entrevistas que tenía en mente desde el comienzo de este blog el año pasado, pero a la que no le encontraba el formato definitivo, hasta hace poco.
En realidad, me di cuenta que no quería hacer entrevistas convencionales, y me parece que lo mejor para nosotros desarrolladores es ver a otros en la práctica, así que estoy comenzando a grabar sesiones de programación de a pares.
La idea es aprovechar la excusa para darme el gusto de programar con amigos y conocidos de la industria regional. Algunos, como este primer caso con Carlos, serán sentados a la misma mesa, y algunos serán remotos, a distancias diversas según la ocasión. Como es tradición de este blog, tengo en mi backlog sentarme a programar en diferentes lenguajes, tecnologías, y en algunos casos tal vez no sea código sino diagramas en un pizarrón, o alguna charla más tradicional, pero siempre que pueda, será a código limpio.

Para iniciar la serie entonces, recurrí a varios amigos, y la primer víctima fue Carlos Peix. Nos conocemos desde hace más años de los que puedo recordar, a través de la comunidad Microsoft. Carlos es un desarrollador independiente con muchos años de experiencia y una actitud abierta a nuevas ideas, pero que no se deslumbra fácilmente con las nuevas modas y prefiere centrar su atención en las técnicas de diseño e implementación más perdurables. Es reconocido sobre todo como especialista en desarrollo web y el mundo .NET, pero siempre está mirando y practicando un poco de Java, Ruby o Smalltalk.
Carlos también participa activamente en la comunidad Agiles.org localmente y en la organización de Agiles 2011. Tiene un blog con varios videos muy interesantes que graba por iniciativa propia y al participar en otras comunidades, como Alt.Net Hispano, donde es presentador habitual.
En el video que grabamos (unos 20 minutos en total), Carlos trajo un ejemplo extraído de un caso real que le tocó, sencillo pero ya algo avanzado y con unas pruebas unitarias, y entre ambos hicimos una sesión de refactorización. El ejemplo es en C#, y usamos Visual Studio 2010 con ReSharper. Para quienes quieran ver el código con más detenimiento, dejo la solución al inicio del ejercicio, y la solución al final.

viernes, 6 de mayo de 2011

Paper: Desarrollo ágil de software

Rick y Juan

Los amigos Juan Gabardini y Ricardo Colusso han publicado de manera abierta este extenso y detallado trabajo que presenta "Una introducción a las metodologías ágiles de desarrollo de software".

Creo que este es uno de los documentos introductorios más completos sobre métodos ágiles en español, y además generado por dos personas que no sólo son divulgadores constantes sino practicantes intensivos, lo que aporta una alta dósis de realidad al trabajo, además de la base conceptual.

Veamos el contenido general:

Desarrollo del Software

Plantea la problemática general del desarrollo y anticipa la posición del Manifiesto Ágil.

Desarrollo “tradicional” de software

Vuelve a revisar el proceso tradicional, usualmente en cascada, con sus problemas usuales.

Características del Desarrollo Ágil

Comenta las características principales (en la práctica) de este estilo, enfocándose en el empowerment de los equipos y los mecanismos de feedback permanente.

Por qué y cuándo conviene usar Desarrollo Ágil de Software

Es uno de los puntos más interesantes, y ataca algunas de las dudas más frecuentes de la gente acercándose al modelo ágil. Hablan del Cono de Incertidumbre, y cómo se trata de ir reduciéndolo en los distintos estilos de administración de proyectos, y su impacto en el desarrollo de Productos.

Beneficios de usar Desarrollo Ágil

Cubren en detalle el Desarrollo guiado por valor, mejor manejo de riesgos y mejoras de productividad.

Aplicabilidad del Desarrollo Ágil

Revisa en líneas generales casos diversos y también la relación entre agilidad y procesos como CMMI.

Experiencias directas

Plantea un caso en detalle, planteando la solución, la realización, resultados y comparación entre la visión de Producto y Proyecto.

Métodos, Prácticas y Herramientas

Describe rápidamente Scrum, Programación Extrema (XP), Desarrollo de Software Lean, Kanban y prácticas como programación de a pares, TDD, proceso continuo, transparencia y visibilidad.

Finalmente el trabajo deja punteros a cómo continuar profundizando, incluyendo comunidad, bibliografía, material gratuito y otras.

lunes, 25 de abril de 2011

Más videos desde el pasado: Agiles 2008

Agiles

Como comenté la semana pasada, Google Video decidió no mantener más el contenido que se había subido en su momento a ese servicio (previo a la compra de YouTube por parte de Google), pero en estos días mejoraron la manera de manejar el proceso, permitiendo mover de manera más directa el contenido hacia YouTube (cosa que no podía hacerse antes aun manualmente en el caso de videos de más de 15 minutos, que YouTube no soporta).

El resultado es que -afortunadamente- pude pasar todo el contenido que tenía hacia YouTube, y hoy sigo compartiendo un poco desde este arcón de los recuerdos. En este caso, dejo una serie de videos de Agiles 2008, y aprovecho para mencionar algo importante sobre la edición de este año del evento:

Ya está abierta la Convocatoria a Ponencias para Agiles 2011, en Buenos Aires.

Todos aquellos interesados en proponer sesiones o talleres, o en ver las propuestas hechas por otros y votar por ellas (lo que ayuda a la organización en la definición del programa final) puede visitar la página correspondiente en la sección de programa del sitio.

Volviendo a los videos, aquí en primer lugar uno de una sesión en español:

En ISO 9000 Ágil, Diego Gonzalez, de Lagash (a quienes felicitamos por sus flamantes 10 años), contaba cómo hicieron para certificar bajo normas ISO su proceso de desarrollo, basado en métodos ágiles.

Los siguientes videos son mayormente en inglés, con alguna acotación en español. Dejo en primer lugar el Panel de Cierre de Agiles 2008, que contó con la participación de varias de las figuras importantes que vinieron a visitarnos, y donde además podrán notar que se generó un debate algo tenso. Sobre el final, pueden saltear la parte en que aparezco balbuceando en el cierre del evento.

También dejo la sesión de Micah Martin sobre pruebas de aceptación con Fitnesse:

Y finalmente la sesión de mis amigos Matt Gelbwaks y Emilio Gutter sobre cómo mantener prácticas ágiles con equipos distribuidos.

miércoles, 6 de abril de 2011

Agiles 2011 en Buenos Aires - ¡tres días imperdibles en octubre!

agiles

Como todos los años desde 2008, se viene la conferencia latinoamericana de metodologías Ágiles.

Para quienes no están al tanto de la historia, todo empezó en Buenos Aires, Argentina en 2008 con un grupo de entusiastas que nos embarcamos en la locura de organizar un evento internacional, con gente viniendo desde muchos países de la región, y varios invitados especiales llegados desde USA y Europa.

La primer conferencia fue un éxito y al año siguiente se hizo en Florianopolis, Brasil, y el año pasado en Lima, Perú.

En su regreso a Buenos Aires, y con la experiencia de los últimos años, el equipo organizador ha logrado mejorar el proceso completo y hoy estamos orgullosos de poder abrir la registración con meses de anticipación, y teniendo ya confirmada la sede, los oradores principales y los primeros patrocinadores.

La conferencia este año durará tres días, del 11 al 13 de octubre, dentro de los que habrá una combinación de sesiones, talleres y open spaces.

La conferencia será en la Universidad de Palermo, en la Facultad de Ingeniería y Diseño, en Mario Bravo 1050 de la Capital Federal.

Tendremos el lujo de contar con dos oradores principales reconocidos internacionalmente (y hay más figuras intesadas que esperamos ir confirmando en las próximas semanas):

Jeff Patton

Jeff Patton es consultor independiente, docente y mentor ágil. En su sitio http://www.agileproductdesign.com/ hace foco en diseño centrado en el usuario y en la concepción del producto.

Colaboró con Alistair Cockburn en el clásico libro Crystal Clear y es fundador y moderador del foro agile-usability en Yahoo, y ganó el premio Gordon Pask por su contribución al agilismo en 2007.

James Shore

James Shore es co-autor del libro The Art of Agile Development editado por O'Reilly en 2007, y mantiene el blog del mismo nombre.

Fue el primer ganador del premio Gordon Pask en 2005 y es uno de los entrenadores y presentadores ágiles más reconocidos por su visión que abarca el lado técnico tanto como el humano, de proyecto y negocios.

Ya está abierta la registración y los precios finales de la conferencia son muy económicos, más aún si se paga antes del 31 de agosto, que tienen aproximadamente un 20% de descuento.

Todos aquellos que tengan interés en proponer actividades, estén atentos porque en los próximos días se abrirá también la recepción de propuestas para las diferentes categorías.

Quienes tengan interés en colaborar patrocinando el evento, pueden descargar el documento de patrocinio que contiene las condiciones y datos de contacto.

jueves, 31 de marzo de 2011

Yoseki Coding Dojo en Kleer

Siguiendo con la buena costumbre de los Coding Dojo, mis amigos de Kleer vienen organizando algunas de estas sesiones abiertas para escribir código entre muchos, como un ejercicio de trabajo en grupo, programación y entretenimiento. Ellos ya tienen un formato bastante definido para estas sesiones, llamadas Yoseki Coding Dojo en las que se van variando el lenguaje y el entorno.

Kleer Dojo

El martes de esta semana me sumé a esta actividad, me encontré con otro amigo asistiendo, Carlos Peix, y me di el gusto de compartir con él la primera ronda de pair programming.

Esta vez trabajamos con Java/Eclipse. Parece que el próximo Yoseki será en Ruby, y si me dejan haremos uno en Javascript.

El problema que planteó el facilitador de turno, Pablito "Pablitux" Tortorella: escribir un contador de puntos de tenis. A continuación dejo las premisas generales para quien quiera practicar este Code Kata. Recuerden que la idea es realizar el ejercicio utilizando TDD, y puede hacerse como una Kata individual, o en un Dojo con varias personas.

La idea es hacer un contador de puntos de tenis. No soy experto en tenis y no me quedaron a mano los detalles que Pablo iba mostrando como historias de usuarios, pero creo que todos sabemos un poco cómo se cuenta: "15 - 0", "30 - 0", "40 - 0"; después los sets; detalles de convención como "30 iguales", etc.

Les dejo debajo los primeros tests (a propósito no dejo todos por si alguno quiere intentar por su lado). Quienes quieran pueden ver los fuentes completos de los tests y de la implementación.

Primeros tests:

package la.kleer.yoseki.tenis.tests;

import junit.framework.Assert;
import la.kleer.yoseki.tenis.Tablero;

import org.junit.Test;

public class TenisFixture {
   
   @Test
   public void tableroTituloConDosJugadores()
   {
      Tablero t = new Tablero("Martin", "Carlos");
      Assert.assertEquals("Martin vs Carlos", t.getTitulo());
   }

   @Test
   public void tableroTituloConDosJugadoresAlReves()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      Assert.assertEquals("Carlos vs Martin", t.getTitulo());
   }
   
   @Test
   public void tableroPuntajeInicial()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      Assert.assertEquals("0 - 0", t.getPuntaje());
   }
   
   @Test
   public void puntosJ1()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      t.puntoJugador1();
      Assert.assertEquals("15 - 0", t.getPuntaje());
   }
   
   @Test
   public void puntosJ2()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      t.puntoJugador2();
      Assert.assertEquals("0 - 15", t.getPuntaje());
   }

   @Test
   public void puntosJ1_J1()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      t.puntoJugador1();
      t.puntoJugador1();
      Assert.assertEquals("30 - 0", t.getPuntaje());
   }

   @Test
   public void puntosJ1_J2()
   {
      Tablero t = new Tablero("Carlos", "Martin");
      t.puntoJugador1();
      t.puntoJugador2();
      Assert.assertEquals("15 iguales", t.getPuntaje());
   }
   // Aquí van más tests
}

Finalmente, les dejo una foto del grupo en acción:

Yoseki Coding Dojo

 

miércoles, 2 de marzo de 2011

Agile Open Buenos Aires - Calidad y Arquitectura

Agiles

El grupo Agiles.org de Argentina estará realizando el sábado 12 de marzo de este mes, en la sede Centro Cultural Borges de la Universidad Nacional de Tres de Febrero (Viamonte y San Martín, Capital Federal), un nuevo Agile Open sobre Calidad y Arquitectura.

De la página del evento en el sitio de Agiles:

Luego de los exitosos eventos Ágiles 2008, Ágiles 2009 y de los Agile Open Buenos Aires, Córdoba, Tandil, La Plata y Mar del Plata 2009, se organizará el evento Agile Open Buenos Aires 2011, enfocado en el tema de la Calidad y la Arquitectura en el desarrollo de software Agil.

Este evento servirá para la capacitación el intercambio de experiencias relacionadas con las técnicas y prácticas relacionadas a asegurar la calidad en el desarrollo de Software Ágil en organizaciones.

El evento como siempre es gratuito, pero requiere registración y las vacantes son limitadas (unas 70 personas).

El formato del evento es el de Open Space, por lo que no hay un temario predeterminado, sino que se construye al inicio con la postulación y votación de temas por parte de los asistentes, incluyendo la posibilidad de presentaciones, debates, actividades y otros formatos.

Dejo algunas fotos de otro Agile Open (en Córdoba), cortesía de mi amigo Pablo Rodríguez Facal.

Agile Open

Programa

¡Y no se olviden que en octubre se viene la conferencia anual Agiles 2011! (muy pronto más información).

sábado, 12 de febrero de 2011

[Video y Ejercicio] Agiles @ Buenos Aires: Coding Dojo

Agiles.org

La semana pasada se realizó la reunión mensual de Agiles @ Buenos Aires, como anuncié en un post anterior.

No voy a repetir todo el detalle, sino a dejar el video de la introducción de Adrián Eidelman, y el arranque del ejercicio con el primer par frente a la computadora.

El resto se los ahorro porque son dos horas en las que no se llega a leer claramente el código y la conversación entre los pares no llega a distinguirse claramente. Es un tipo de actividad que requiere presencia directa para disfrutarla, y recomiendo que estén atentos si les interesa porque ya hay en marcha una iniciativa de Katayunos (desayunos entre tres o cuatro personas para practicar Code Katas), y cualquiera puede organizar algo así con sus compañeros de trabajo o de estudio.

Pero para que no se pierdan el total (aunque la gracia es el camino recorrido más que el punto final), dejo el ejercicio tal cuál como quedó resuelto durante la reunión (sin edición ni retoque), cortesía de Adrián. La plataforma y lenguajes son anecdóticos, pero en este caso se realizó en C# utilizando Visual Studio 2010 y NUnit como framework de testing.

Van primero los tests (un primer ejercicio puede ser tomar los tests y tratar de escribir el código sobre ellos):

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Moq;
using NUnit.Framework;
using NumerosRomanos;

namespace NumerosRomanos.Tests
{
    [TestFixture]
    public class Tests
    {
        Conversor conversor;

        Dictionary<int, string> valores;

        [TestFixtureSetUp]
        public void setUp()
        {
            conversor = new Conversor();
            valores = new Dictionary<int, string>();
            valores.Add(1, "I");
            valores.Add(5, "V");
            valores.Add(10, "X");
            valores.Add(50, "L");
            valores.Add(100, "C");
            valores.Add(500, "D");
            valores.Add(1000, "M");
        }

        [Test]
        [ExpectedException(typeof(ArgumentException))]
        public void El0ArrojaExcepcion()
        {
            int numeroArabigo = 0;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);
        }

        [Test]
        [ExpectedException(typeof(ArgumentException))]
        public void NumeroNegativoArrojaExcepcion()
        {
            int numeroArabigo = -1;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);
        }

        [Test]
        [ExpectedException(typeof(ArgumentException))]
        public void El4000ArrojaExcepcion()
        {
            int numeroArabigo = 4000;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);
        }

        [Test]
        public void El1DeberiaDevolverI()
        {
            int numeroArabigo = 1;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("I", numeroRomano);
        }

        [Test]
        public void El5DeberiaDevolverV()
        {
            int numeroArabigo = 5;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("V", numeroRomano);
        }

        [Test]
        public void El10DeberiaDevolverX()
        {
            int numeroArabigo =10;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("X", numeroRomano);
        }

        [Test]
        public void El2DeberiaDevolverII()
        {
            int numeroArabigo = 2;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("II", numeroRomano);
        }

        [Test]
        public void El3DeberiaDevolverIII()
        {
            int numeroArabigo = 3;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("III", numeroRomano);
        }

        [Test]
        public void El15DeberiaDevolverXV()
        {
            int numeroArabigo = 15;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("XV", numeroRomano);
        }

        [Test]
        public void El4DeberiaDevolverIV()
        {
            int numeroArabigo = 4;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("IV", numeroRomano);
        }
        [Test]
        public void El48DeberiaDevolverXLVIII()
        {
            int numeroArabigo = 48;

            string numeroRomano = conversor.ANumerosRomanos(numeroArabigo);

            Assert.AreEqual("XLVIII", numeroRomano);
        }

        [Test]
        public void RetornaValoreConocidos()
        {
        
            foreach(var i in valores.Keys)
                Assert.AreEqual(valores[i], conversor.ANumerosRomanos(i));

        }
    }
}

Y aquí está finalmente la implementación misma (para quienes quieran hacer trampa):

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NumerosRomanos
{
    public class Conversor
    {
        List<int> valoresArabigos = new List<int> 
            {1,4,5,9,10,40,50,90,100,400,500,900,1000};
        List<string> valoresRomanos = new List<string> 
            {"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};
    
        public Conversor()
        {
            valoresArabigos.Reverse();
            valoresRomanos.Reverse();
        }

        public string ANumerosRomanos(int numeroArabigo)
        {
            if (numeroArabigo<=0 || numeroArabigo>3999)
                throw new ArgumentException();


            string resultado="";

            while (numeroArabigo > 0)
            {
                foreach (var i in valoresArabigos)
                {
                    if (i <= numeroArabigo)
                    {
                        resultado += valoresRomanos[valoresArabigos.IndexOf(i)];
                        numeroArabigo -= i;
                    }
                }
            }

            return resultado;
       }
    }
}

jueves, 10 de febrero de 2011

Video: Kata con Números Romanos (Ruby, 15 minutos)

http://www.flickr.com/photos/mightyohm/3986677172/

Como comenté el viernes, ayer tuvimos la reunión mensual del grupo Agiles.org en Buenos Aires, dedicada a un Coding Dojo en el que practicamos un ejercicio entre la docena de asistentes, rotando de a pares y avanzando con TDD para resolverlo.

El ejercicio en si consiste en pasar de números arábigos (los que usamos todos los días) a números romanos. Esta antigua forma de numeración tiene la particularidad de ser un poco irregular con sus dígitos que restan antes de llegar a los múltiplos de 5 y 10, como en el caso del 4 (IV) y el 9 (IX).

Lo bueno de este ejercicio en particular es que es bastante corto y las reglas son conocidas por casi todo el mundo. En el Dojo de ayer (del que pronto espero publicar un video con al menos la introducción y algunos momentos) llevó bastante tiempo porque ibamos rotando entre gente con diferente grado de conocimiento de la plataforma y lenguaje elegido (Visual Studio y C#), el teclado era raro para todos (menos para el dueño), y para muchos era la primera vez con ejercicios de este estilo y/o TDD.

Mientras rotábamos practiqué el ejercicio varias veces por mi lado y sobre el final hice una versión bastante parecida a lo que obtuvimos entre todos.

Dejo el video para quien le pueda interesar, con las siguientes aclaraciones:

  • La respuesta no es la única correcta. De las que obtuve, es una de las más concisas.
  • Lo que grabé es lo que se considera un Kata: hice el ejercicio muchas veces y al final fluyó bastante. Dura 15 minutos incluyendo tiempo de escribir algunos comentarios que representan lo que iba pensando. Probé relatarlo pero el tiempo era más largo porque no puedo escribir el códido tan derecho.
  • Como siempre, la elección del entorno es arbitraria. Esta vez lo hice en Ruby usando unit/test que es lo más básico. Hice un uno con Ruby/RSpec pero me parece que va a llamar más la atención el framework de BDD que el ejercicio. Si hay interés puedo publicar otras variantes.
  • En un Randori Dojo, aunque el ejercicio es el mismo, la dinámica es totalmente diferente. Lleva mucho más tiempo pero el foco está más en la práctica de las interacciones y el juego de pares que en la técnica misma. Recomiendo mucho hacer las dos cosas. Los katas son ejercicios más individuales, los dojos como ensayos con una banda.
  • Espero que les guste la música. Si no, pueden dejar el video mudo. Todo lo demás está en el código.

viernes, 4 de febrero de 2011

Agiles @ Buenos Aires: Coding Dojo

Coding DojoEl grupo Agiles.org organiza actividades de varios tipos en muchos puntos de América Latina.

Esta comunidad surgió fuertemente tras la primera edición de la conferencia latinoamericana Agiles 2008, y a partir de ahí el grupo en Argentina quedó consolidado, realizando muchas actividades por todo el país (anunciadas en la página Agiles Argentina).

Específicamente en Buenos Aires, se efectúan reuniones todos los meses, que se anuncian en la página Agiles@BsAs.

La próxima reunión es el martes que viene, 8 de febrero, en las oficinas de Southworks (Perú 375, 1er piso).  [disclaimer: es donde yo trabajo]

Lo interesante de esta próxima reunión en particular es que va a ser un Coding Dojo (estilo Randori), facilitado por Adrián Eidelman.

En palabras del propio Adrián:

"Un coding dojo es una sesión de codificación centrada alrededor de un desafío de programación. El desafío es sumamente pequeño en alcance y -en la versión Randori de un coding dojo- la totalidad de la audiencia participa para completarlo. Básicamente la solución se construye utilizando una única computadora y un proyector, en donde los desarrolladores van rotando de a pares cada una cantidad fija y acotada de tiempo, dejando lugar a que otras personas de la audiencia continúen. El objetivo es aprender, enseñar y mejorar nuestras habilidades de programación compartiendo con otros desarrolladores de software en un ambiente relajado."

La actividad como siempre es totalmente abierta y gratuita pero requiere inscripción previa, y vale la pena decidirse rápido porque el espacio no es infinito.

Espero ver a muchos de ustedes la semana que viene, codeando, y espero poder capturar en video todo lo que se pueda de la actividad, para compartir con quienes no puedan asistir.

 

viernes, 14 de enero de 2011

Video: ¿Existe la mejor forma de probar?

Agiles

El martes pasado se realizó la reunión mensual de Agiles @ Buenos Aires, organizada por la comunidad local Agiles.org. Para estar al tanto de estas actividades conviene suscribirse a la lista de correo Agiles Argentina.

La mecánica de estas reuniones es que tradicionalmente al cierre de cada una se proponen y votan los temas para la próxima, teniendo en cuenta temas que estaban pendientes en una especie de backlog informal.

Esta vez el tema central fue el testing desde un punto de vista ágil, iniciando con la presentación de Juan Gabardini titulada "¿Existe la mejor forma de probar?". En la sesión Juan recorre su experiencia personal como desarrollador volcado a tareas más ligadas a control de calidad (QA), recorriendo el espectro desde las pruebas manuales hasta las técnicas de automatización más sofisticadas, y reflexionando sobre el valor de cada variante y sus combinaciones.

La segunda mitad del evento fue una serie de preguntas, respuestas y debate a raíz de la presentación, que fue muy interesante pero es difícil de compartir en video.

Afortunadamente, si tenemos grabada la presentación de Juan, y para todos aquellos que tengan dudas o temas a debatir, creo que lo mejor puede ser plantearlos en la lista, donde tanto Juan como otros agilistas pueden aportar sus opiniones.

 

 

 

miércoles, 12 de enero de 2011

Curso Certified ScrumDeveloper (CSD) Track - Verano 2011

Kleer

Hoy dedico el post a un pequeño aviso, porque se que hay mucha gente interesada en capacitación sobre Scrum, y en particular estos cursos tienen que ver con un área que me parece muy importante y no siempre bien cubierta, que es la parte técnica o de ingeniería que se requiere para poder mantener la calidad iteración tras iteración.

Esta serie de cursos que organiza Kleer (la única empresa en Argentina certificada por la Scrum Alliance para dar estos cursos), tiene el siguiente temario:

* Los conceptos básicos, valores y principios de la agilidad y Scrum 
* Técnicas de análisis de procesos e identificación de historias de usuario 
* Técnicas de estimación y planificación con Scrum 
* La creación de historias de usuario que den lugar a desarrollos evolutivos 
* La identificación y automatización de sus pruebas de aceptación 
* La comunicación con el equipo mediante integración continua 
* Técnicas de diseño y desarrollo dirigido por pruebas (TDD) 
* La utilización de taskboards y métricas ágiles 

El track está orientado a: 



CSD en acción

* Gerentes de Proyecto con formación en gestión 
* Gerentes de Proyecto con background técnico 
* Gerentes de Desarrollo 
* Líderes Técnico 
* Arquitectos de Sistemas 
* Desarrollador de Software

 

El programa completo incluye tres cursos independientes:

Curso de Introducción a Scrum

Duración: 8hs.

Fecha de Dictado: 21 de Febrero de 9 a 18hs

Lugar: Microcentro, Buenos Aires

Curso de Estimación y Planificación con Scrum

Duración: 8hs.

Fecha de Dictado: 22 de Febrero de 9 a 18hs

Lugar: Microcentro, Buenos Aires

Curso de Desarrollo Ágil de Software en Scrum

Duración: 24hs.

Fecha de Dictado: Del 23 al 25 de Febrero de 9 a 18hs

Lugar: Microcentro, Buenos Aires

Para consultas: entrenamos@kleer.la

También se puede ver  el calendario completo de Kleer o ver las fotos de los cursos anteriores en su página de Facebook.

 

lunes, 27 de diciembre de 2010

La campaña Anti-IF

 

I have joined Anti-IF Campaign

Francesco Cirillo, de Italia, conocido por muchos como el creador de la Técnica Pomodoro para manejar el tiempo personal, inició tiempo atrás una campaña más específicamente orientada a los programadores:

El objetivo de esta campaña iniciada en 2007 es captar la atención en la comunidad de desarrollo sobre el abuso de técnicas procedurales en detrimento de las capacidades de orientación a objetos que los lenguajes que en general utilizamos tienen. El apuntar específicamente en contra del IF (y por extensión su derivado extremista, SWITCH/CASE) implica hacer foco en el valor del polimorfismo en lugar del abuso de condiciones que pueden expresarse en forma más clara y mantenible de otra manera.

El ejemplo canónico que presenta el sitio de la campaña es:


// Bond class
double calculateValue() {
   if(_type == BTP) { 
       return calculateBTPValue();
      } else if(_type == BOT) { 
       return calculateBOTValue();    
      } else {
       return calculateEUBValue();
      }
   }

 

¿Cuántas veces vemos código como éste? Peor aún, es probable que nosotros mismos seamos los culpables, tiempo atrás, o no tanto...

Entre otros problema, este código viola el principio Abierto/Cerrado (Open/Close) popularizado por el tío Bob Martin, ya que cada vez que un nuevo tipo de bono aparezca tendremos que "abrir" nuevamente esta clase para ampliar el tipo de cálculo. La solución es obvia, aunque no la vemos aplicada tan frecuentemente: utilizar polimorfismo basándonos herencia (aunque pronto puede que la herencia no se tan conveniente y cambiemos a composición). Veamos la respuesta propuesta en el sitio:


// Bond class
double calculateValue() {
_bondProfile.calculate();
}
// AbstractBondProfile class
abstract double calculate()

// BTPBondProfile class >> AbstractBondProfile
double calculate() {
...
}
// BOTBondProfile class >> AbstractBondProfile
double calculate() {
...
}
// EUBondProfile class >> AbstractBondProfile
double calculate() {
...
}

 

A partir de crear una clase base con un método abstracto, respetamos el principio Abierto/Cerrado porque podemos agregar más tipos de bono simplemente agregando nuevas subclases, sin tener que tocar (necesariamente) la base.

Es interesante ver la lista de gente que apoya la campaña, entre los que se encuentran nombres conocidos como David Laribee (conocido miembro de la comunidad Alt.NET), Kent Beck (el "padre" de Extreme Programming y JNunit), Dave Nicolette (otro reconocido agilista), y muchos otros.