Experiencias con la Kata del Juego de la Vida de Conway

screen-shot-2016-07-17-at-7-06-44-am

Conway’s Game of Life

He hecho la kata del Juego de la Vida de Conway de un par de maneras: inside-out y outside-in.

La primera forma ha sido TDD inside-out en Javascript con Karma, Mocha y Chai, y la segunda TDD outside-in con Groovy y Spock. Ahí dejo enlaces al Github donde se ve en cada commit qué decisiones he ido tomando siguiendo el ciclo:
ROJO -> VERDE -> REFACTOR.

Si te interesa, para ver una buena explicación de las diferencias de hacer TDD inside-out e outside-in, puedes leer este post: TDD: Outside-In vs Inside-Out en el fantástico blog de Adictos al Trabajo, o éste (en inglés): TDD – From the Inside Out or the Outside In?. de 8th Light.

Experiencia

Me ha sido mucho más sencillo programar el primer intento. Creo que al hacerlo inside-out y siendo que lo que hay que programar es un algoritmo, fue mucho más fácil ir separando la parte del cálculo de las reglas, de la de flujo del programa.

Empecé por las condiciones que hacían que una célula viviese o no en la siguiente iteración, y poco a poco fui yendo hacia fuera hacia la composición de la malla del universo en el que vivían las células y terminando con el bucle que recorría la malla.

La segunda iteración me resultó mucho más difícil. Elegí Groovy para probar también con un lenguaje Orientando a Objetos, y así las clases me ayudasen a delimitar mejor las responsabilidades de cada componente.

Tuve en la cabeza sobre todo el Principio de Responsabilidad Única, que cada clase gestionase sólo aquello que tenía sentido para ella.

Intenté no caer en la trampa de programar abstracciones muy genéricas, pensando el típico: “para que sea fácil cambiar esto por aquello”.

Pero sí que programaba desde el inicio respetando el Principio de Inversión de Depedencias, y al inyectar siempre los colaboradores a las clases, permite hacer TDD con Mocks de manera muy transparente y natural.

// Spock test helper to create GameOfLife class
 GameOfLife createGol() {
     def nextService = Stub(NextService)
     def nextGrid = createSeed()
     nextService.next(_) >> nextGrid
     createGol(nextService)
}

GameOfLife createGol(nextService) {
    new GameOfLife(nextService)
}

Digo ‘pero’ porque mockear todos los colaboradores antes de programarlos, para tener los tests en verde me llevó a un bug bastante difícil de cazar que explicaré más adelante.

En la revisión de código vimos que aunque los mocks ayudan a esa parte, tienes dos problemas:

  • UNO: que mockear todo puede tener el efecto que realmente no estás probando nada.
  • DOS: que al hacer un Stub, tienes que conocer la firma qué devuelven los colaboradores y eso produce un acoplamiento importante en fases muy tempranas.

También quiero destacar que tomé una decisión bastante interesante: el sistema no tenía por qué conocer en qué tipo de estructura de datos se almacenaba el grid en el que vivían las células y sólo se debían comunicar con el responsable a través de un API, que mostraba una topología de consenso.

Esto tiene mucho sentido, ¿verdad? Para ponerme a prueba, en vez de almacenar las células en un array bidimensional, decidí almacenarlas en un vector, en el que la matriz estaría almacenada por filas.

class Grid {
    int rows
    int columns
    def data = new ArrayList()
    ...
}

Para acceder a cada posición [row, column], había que hacer un cálculo de paginación, en el que las filas eran la página y las columnas el offset.

GridItem get(row, column) {
    if (row < 0 || row >= this.rows ||
        column < 0 || column >= this.columns) {
            throw new IndexOutOfBoundsException("Position requested out of grid")
     }
     return this.data[row * this.columns + column]
 }

No exponer las interioridades, hacía que el sistema más exterior que se encargaba de recorrer el grid, no pudiese hacer un bucle de manera normal.

Entonces se me ocurrió que podía imitar el comportamiento de un tipo iterable.
Esto es, para pedir la siguiente posición había que pedirla al objeto responsable. Esto me llevó a tener que mantener la posición de lectura en el propio objeto, y por tanto mantener estado.
Esto no me gustaba nada, pero como era una kata, seguí adelante para ver las implicaciones.

Y según avanzaba la programación encontré un bug bastante gordo relacionado con mockear todas las dependencias de los test unitarios. Si pedía el grid.next(), y al leer avanza el cursos una posición, y luego pedía los vecinos, estaba leyendo no los que yo pensaba, sino los de la posición siguiente.
Así que tuve que crear un método que se llamase getCurrent(), calcular los vecinos y al final usar el next(), ya en este caso solo para avanzar posición.

class NextServiceImpl implements NextService {
    ...
    Grid next(Grid seed) {
        GridItem item
 
        Grid nextGrid = new Grid(seed.rows, seed.columns)
 
        //  found a bug in calculating neighbours after next
        //   we should separate this in current() and next()
        while (item = seed.current()) {
            def numNeighbours = seed.countNeighbours()
            def nextItem = alg.calc(item, numNeighbours)
            nextGrid.push(nextItem)
            seed.next()
        }
        return nextGrid
    }
}

Mantener la decisión del iterable me costó bastante, la verdad.

A posteriori creo que no merece la pena en este problema abstraer cómo se almacena el sistema y después leyendo el libro, veo que expone al máximo nivel la estructura de datos, o por lo menos la topología.

Conclusión

La kata inside-out, fue mucho más satisfactoria, pues veía mucho mejor el problema que tenía que resolver y construía el sistema desde la base.

La kata outside-in me ha ayudado a ver el big-picture mucho mejor, y darme cuenta de dónde están las responsabilidades, sobre todo al hacer TDD. Como dato interesante, encontré más bugs y más difíciles de resolver.

En definitiva, ejercicio interesante. ¡Espero poder participar en el Global Day of Coderetreat el próximo 22 de octubre de 2016 desde Asturias!

Etiquetado , ,

Recorriendo poco a poco el libro “Understanding the 4 rules of simple design”

cover

 

Artículo publicado originalmente en el blog de Codesai

 

Kata del Juego de la Vida de Conway

En mis primeras semanas en Codesai he hecho la kata del Juego de la Vida de Conway como parte de mi formación para empaparme de la cultura y valores de la empresa.

La hice dos veces: la primera ha sido TDD inside-out en Javascript con Karma, Mocha y Chai, y la segunda TDD outside-in con Groovy y Spock. Dejo aquí mis enlaces al github donde se ve en cada commit qué decisiones he ido tomando siguiendo el ciclo: ROJO -> VERDE -> REFACTOR.

Para ver una buena explicación de las diferencias de hacer TDD inside-out e outside-in, podéis leer este post: TDD: Outside-In vs Inside-Out en el fantástico blog de Adictos al Trabajo.

Después de hacer estas dos katas, he leído el libro “Understanding the 4 rules of simple design” y he comparado mis decisiones.

Resumen y comentarios del libro “Understanding the 4 rules of simple design”

El libro empieza muy fuerte, con los prólogos de Kent Beck y J. B. Rainsberger de los que se sacan auténticas perlas:

Foreword from Kent Beck

Is wrong “Design for the future. Change is expensive. Make it cheap by anticipating it.”

This looked like a positive feedback loop to me: more speculation -> worse design -> more speculation.
The good news about disastrous positive feedback loops is that you can generally drive them backwards. I first experimented by ignoring any changes that seemed like they would happen longer than six month in the future. My designs were simpler, I started making progress sooner, and I stressed less about the unknowable future. I shortened the time horizon to three months. More better.
One month. More. A week. A day. Oh, hell, what happens if I don’t add any design elements

Es muy gráfico cómo relata una especie de evolución de su pensamiento sobre qué pasaría si no adelantamos nada de supuestos futuros.

Buceando un poco desde el enlace que da en el prólogo, llegué a un artículo de Martin Fowler sobre estas reglas de diseño donde pone la siguiente cita de Kent Beck:

At the time there was a lot of “design is subjective”, “design is a matter of taste” bullshit going around. I disagreed. There are better and worse designs. These criteria aren’t perfect, but they serve to sort out some of the obvious crap and (importantly) you can evaluate them right now.

The real criteria for quality of design, “minimizes cost (including the cost of delay) and maximizes benefit over the lifetime of the software,” can only be evaluated post hoc, and even then any evaluation will be subject to a large bag full of cognitive biases. The four rules are generally predictive.

— Kent Beck

Creo que define muy bien lo que significan las buenas prácticas: Estos criterios no son perfectos, pero sirven para detectar algo de la basura más obvia y (lo más importante) puedes evaluarlo inmediatamente.

En un entorno de trabajo donde cualquier decisión es cuestionable, tener reglas básicas para distinguir el ‘crap-code’ ayuda mucho a las conversaciones dentro del equipo

Foreword from J. B. Reinsberger

El siguiente prólogo está realmente bien. Pues ayuda a profundizar y hacerte una idea de las conversaciones que puede haber detrás de algo aparentemente tan sencillo como las cuatro reglas.

Destaco como antes, no textos del prólogo, sino de los posts relacionados de JB. Son mencionados en numerosas ocasiones por todos los autores vistos hasta ahora y se recomiendan incluso por Corey Haines en el propio libro.

The four elements of simple design

When I find fifteen lines of duplicate code, I start by extracting them to a new method, and since I probably don’t yet know what those lines of code do yet, I name the new method foo(). After around 15 minutes of working in the same area, I begin to understand what this method does, so I give it an accurate name, such as computeCost().
[…]
That leaves me with two key elements of simple design: remove duplication and fix bad names. When I remove duplication, I tend to see an appropriate structure emerge, and when I fix bad names, I tend to see responsibilities slide into appropriate parts of the design.
[…]
I claim that developing strong skills of detecting duplication, removing duplication, identifying naming problems, and fixing naming problems 
equates to learning everything ever written about object-oriented design.

Este post es oro puro, el primer párrafo me encanta, pues dar nombres a métodos o clases, es la tarea más difícil del desarrollo. Aquí da una pista muy buena.

El siguiente post relacionado de JB, es la continuación del anterior, e intenta cerrar la ‘guerra’ abierta sobre el orden de importancia de las cuatro reglas.

Putting an age old battle to rest

I don’t think it matters whether you focus first on removing duplication or on revealing intent/increasing clarity, because these two guidelines very quickly form a rapid, tight feedback cycle. By the time the guidelines guide you to any useful results, you’ll have probably used them both. Therefore, order the rules however you like, because you’ll get to the same place either way.

When we remove duplication, we create buckets; when we improve names, we create
more cohesive, more easily-abstracted buckets.

Now, I think of them as a
single guideline: remove duplication and improve names in small cycles. When I do this, I produce a higher proportion of  well-factored code compared to all the code I write.

Removing duplication and improving names helps me reduce the liability (cost) of the code that I write.
Together, they help me reduce both the total cost and the volatility of the cost of the features I deliver.

En estos tres párrafos habla de tres temas muy potentes:

  1. Cerrar la guerra sobre el orden
  2. Cohesión
  3. Coste

Introduction: This book

Me encanta esta introducción. Habla con más claridad de lo que hemos visto hasta ahora: cómo las cuatro reglas se retroalimentan, incidiendo en lo comentado por JB.

Recalca como Kent Beck que no ve que haya diseños buenos y malos, e incluso que puede haber varios buenos diseños. A partir de ahí, comparándolos se podría llegar a un consenso de las ideas fundamentales de por qué un diseño es “mejor” que otro.

If we can look at things from a comparison point of view, perhaps we can find some fundamental ideas about “better”.

Termina formulando las dos constantes en el desarrollo de software, acompañado de un tweet de Sandi Metz: “Habrá cambios pero no sabemos qué es lo que va a cambiar”

Examples

A continuación entramos en materia del libro con diferentes ejemplos divididos en capítulos (respeto los títulos en inglés), como si fuéramos construyendo desde cero el Juego de la Vida.

Test Names Should Influence Object’s API

// Test: Check world is empty
// NO
world.cell_alive_at(1,1)?
// YES
world.empty?

Hay que usar nombres de test de hablen de negocio, y construir un API apropiada. Si usamos nombres de test orientados a datos, corremos el riesgo de construir un código que expone información que no es responsabilidad de la clase.

Duplication of Knowledge about Topology

class LivingCell
    attr_reader :location
end class

Aquí, Corey Hanes propone poner la localización dentro de la celdas, para no duplicar el conocimiento acerca de la topología del sistema, como en el código visto antes.

Pensé en hacer esto, pero tal como estaba resolviendo el problema, no podía mover o quitar el conocimiento de la ubicación de las células fuera de la clase Grid, que está un nivel hacia afuera: lo necesitaba para recorrer la malla y calcular la siguiente iteración y para calcular el número de vecinos.

Como experimento para esta kata, la estructura de datos en la que almacené las células de la malla, una estructura de dos dimensiones, fue en un tipo List, unidimensional. Y para consumirlo, desarrollé una especie de Iterable y el acceso a un elemento concreto con paginación.

Así, el primero de los problemas que comento lo tenía resuelto, no se iba a recorrer la malla.

El segundo problema, el de calcular el número de vecinos es el que no supe cómo resolverlo. ¿Cómo podía acceder a los vecinos de un elemento, si la posición que ocupan la tiene solo los elementos? ¿Cómo accedo a un elemento concreto de la malla?

Después de terminar la kata, se me ocurrió una solución a esto. Podría haber usado métodos como .filter() sobre el List, para buscar elementos. No es muy eficiente, pero consigue lo que se quiere, abstraes la localización del Grid y se lo pasas a las células, lo probaré para la próxima.

Behavior Attractors

Whenever we have a new method — a new behavior — an important question is “where do we put it?” What type does this belong to?

Siempre que tenemos un nuevo comportamiento la pregunta es dónde lo ponemos.
En el libro recomienda ponerlo en cualquier sitio, no pararse a analizar el problema. Si nos encaja, perfecto; pero si no, tenemos que moverlo. Además moverlo cuanto antes para que luego con el uso no sea más difícil.

// Where do we put neighbors?
// Location seems perfect.
class Location
     attr_reader :x, :y
     def neighbors
         # calculate a list of locations
         # that are considered neighbors
      end
 end

Destaca que a través de eliminar la duplicación de conocimiento de manera agresiva es como conseguimos clases que atraen comportamientos. Y como corolario, si intentamos eliminar y no encontramos dónde colocarlo es que nos faltan algunas abstracciones.

En el ejemplo de código, me llamó mucho la atención poner los neighbors en Location. Porque eso significa que es un dato que se guarda, no un dato calculado al momento del tick. Interesante para explorar.

Testing State vs Testing Behavior

En este apartado habla que hay que testear el comportamiento y no el estado, y pone como ejemplo que lo primero que comprueba en la kata es:

world.empty?

Yo lo que pensé que era el primer comportamiento era algo como:

world.stable?

Es decir: “¿Es el sistema estable? ¿Hay que hacer una siguiente iteración? ¿Cuál es la condición de parada?”. Comentándolo con los compañeros, parece que afronté el problema desde demasiado afuera. Outside-in no quiere decir literalmente: “Desde la capa más exterior, hacia dentro”.

Don’t Have Tests Depend on Previous Tests

def test_an_empty_world_stays_empty_after_a_tick
     world = World.new
     next_world = world.tick
     assert_true next_world.empty?
 end

Rather new world is empty, let’s explicitly ask for an empty world.

def test_an_empty_world_stays_empty_after_a_tick
     world = World.empty
     next_world = world.tick
     assert_true next_world.empty?
 end

Si cambiamos el constructor base y devuelve otra cosa que un mundo vacío, el primer test continuará pasando. Para evitar esto, quien invoque al objeto no debería usar el constructor base con la confianza que vendrá con un estado específico, y menos en la preparación del test, debería usar un ‘constructor’, un ‘builder’, para crear un objeto con un estado concreto y válido.

Esto me parece simplemente genial. Dejar de confiar en los constructores y crear builders que te den el objeto en el estado deseado. Es un problema que me encuentro de manera recurrente, no confío en los datos que tengo al preparar un test.

Breaking Abstraction Level

def test_world_is_not_empty_after_adding_a_cell
     world = World.empty
     world.set_living_at(Location.new(1,1))
     assert_false world.empty?
end

Este tests está acoplado a una capa de abstracción que no es la suya, por lo que si se cambia el sistema de coordenadas a tres dimensiones, por ejemplo, fallarán tests que no tienen nada que ver.

El libro recomienda en este caso hacer un doble de test que abstraiga de ese detalle. Otra opción puede ser usar un helper que de cree ese objeto de coordenadas y así solo está definido en un sitio.

def test_world_is_not_empty_after_adding_a_cell
    world = World.empty
    world.set_living_at(Object.new)
    assert_false world.empty?
end

Este tipo de problemas nos hacen ver todos los puntos de contacto que tienen nuestros objetos con los demás.

Naive Duplication

Muy interesante esta sección en la que veremos las diferencias entre duplicidad de código y duplicidad de lógica de negocio.

Vamos a observar las condiciones para que una célula viva en la siguiente generación:

class Cell
    # ...
    def alive_in_next_generation?
        if alive
            number_of_neighbors == 2 ||
            number_of_neighbors == 3
        else
            number_of_neighbors == 3
        end
    end
end

Podríamos refactorizar este código:

// An optimization of is_alive condition
class Cell
    # ...
    def alive_in_next_generation?
        (alive && number_of_neighbors == 2) ||
            number_of_neighbors == 3
    end
end

Con este refactor de código recordamos una de las cuatro reglas: “El conocimiento se debe representar una y solamente una vez”.

Every piece of knowledge has one and only one representation.

Mirando otra vez al código original podemos ver que esos 3s no significan lo mismo.
Recomienda que una buena técnica para no caer en este error, sería nombrar de forma explícita los conceptos antes de refactorizar.

class Cell
    # ...
    def alive_in_next_generation?
        if alive
            stable_neighborhood?
        else
            genetically_fertile_neighborhood?
        end
    end
end

Así se ve mucho mejor y en caso de cambiar las condiciones de supervivencia, accedemos a reglas de negocio directamente.

En mi código no hice refactor porque me di cuenta que no era el mismo conocimiento, pero no extraje a un método cada comportamiento, interesante apunte para la próxima.

Procedural Polymorphism

El if en el código del apartado anterior diferencia los casos comprobando el valor del estado:

if state == ALIVE
...

En esta sección destaca que el uso de variables de estado es un indicio de que no se ha entendido el negocio. Interesante.

¿Cómo resolvemos esto? Nos presenta el Polimorfismo, como una técnica que nos da la posibilidad de llamar a un único método y tener más de un posible comportamiento. Si usamos ifs para hacer estas diferencias le llama Procedural Polymorphism.

Cuando vi esto me vino a la cabeza que una buena razón para no tener cuerpos ifs muy grandes o complejos es que se podría romper el Principio Open/Close porque este método tiene más de una razón para cambiar. Deberían ser super-sencillos.

Avanzando con el polimorfismo, la OO nos da su método preferido, el Polimorfismo basado en tipos.

Así en nuestro ejemplo podemos coger el estado y trasladarlo a un par de tipos:

class LivingCell
    def alive_in_next_generation?
        # neighbor_count == 2 || neighbor_count == 3
        stable_neighborhood?
    end
end

class DeadCell
    def alive_in_next_generation?
        # neighbor_count == 3
        genetically_fertile_neighborhood?
    end
end

¡Polimorfismo! ¡Me encanta! Me parece muy mágico y elegante.

Pero Haines no lo deja ahí, no nos deja tranquilos en nuestra satisfacción. A continuación rompe el polimorfismo de este ejemplo cambiando de nombre a los métodos. ¿Por qué?

La explicación que da, es que el polimorfimo hace abstracciones muy atractivas que podrían ocultar detalles del comportamiento real de cada subtipo, siendo incorrecto ese genérico que queremos atribuirle.

Para darnos un ejemplo, se plantea la propia existencia de la clase DeadCell, pues no tendría mucho sentido si el tamaño del Grid fuera infinito.

Es muy fácil, sobre todo al principio, sacar abstracciones rápidamente y hacer una jerarquía de tipos. Pero si nos damos cuenta que es incorrecta deshacerla suele ser complicado.

Making Assumptions About Usage

La idea fundamental bajo la pregunta: “¿Necesitamos esta abstracción?” es: “El uso influencia la estructura”. Propone que hay que construir nuestra lógica de negocio y las abstracciones que usemos motivadas por el uso que hagamos.

Unwrapping an Object

Partiendo de este trozo de código que muestra una solución para contar los vecinos de una célula:

class Location
    attr_reader :x, :y
end

location1 = Location.new(1, 1)
location2 = Location.new(1, 2)

if location1.equals?(location2)
    # Do something interesting
end

Para hacer ese “algo interesante” tenemos que saber si las dos posiciones son iguales. Y generalmente haríamos algo como esto:

class Location
    attr_reader :x, :y
    def equals?(other_location)
        self.x == other_location.x &&
        self.y == other_location.y
    end
end

location1.equals?(location2)

¿Qué sucedería si aplicamos en la kata la restricción (muy potente) de “Nuestras funciones no pueden retornar valores”?
Tendríamos que transformar este código para que cumpla el ‘Tell, don’t ask’ y confiar en los objetos para que hagan un trabajo que generalmente haríamos nosotros.

Para ello propone una solución muy interesante, el uso de lambdas: le decimos al .equals? lo que queremos que ejecute si se cumple la condición.

count_of_locations = 0
location1.equals?(location2, -> { count_of_locations++ })

class Location
    attr_reader :x, :y
    def equals?(other_location, if_equal)
        other_location.equals_coordinate?(self.x, self.y, if_equal)
        nil
    end

    def equals_coordinate?(other_x, other_y, if_equal)
        if self.x == other_x && self.y == other_y
            if_equal.()
        end
            nil
    end
end

Es de destacar que como no podemos retornar nada, hay que invocar a other_location con la lambda, para que lo ejecute.

Me ha encantado encontrarme el uso de funciones anónimas en este ejemplo; creo que combinándolo con el apartado anterior de “Romper el nivel de abstracción” puede quedar un código con menos efectos laterales.

Inverted Composition as a Replacement for Inheritance

Volvemos al ejemplo anterior del polimorfismo:

// Let’s create mother class
class Cell
    attr_reader :location
end

class LivingCell < Cell
end

class DeadCell < Cell
end

Esta extracción al crear el padre no introduce un nuevo concepto de dominio. La herencia es a menudo utilizada como una forma de “reusar” más que para eliminar duplicidades.
Es un error común crear clases ‘base’ de este estilo, que pueden llegar a ser un contenedor de comportamientos muy poco relacionados.

Si la herencia no es un solución, ¿qué otras opciones tenemos?

En el ejemplo usa módulos de Ruby, y en otros lenguajes tendríamos Traits (Groovy) y en otros algo como los decoradores.

class LivingCell
    include HasLocation
end

class DeadCell
    include HasLocation
end

Llegados a este punto, con la duplicidad medio resuelta, vemos que tenemos dos clases apuntando al mismo tipo, (Living|Dead)Cell a Location.
Una técnica útil es Invertir la dependencia, que la localización apunte a las células.

class Location
    attr_reader :x, :y
    attr_reader :cell
end 

class LivingCell
    def stays_alive?(number_of_neighbors)
        number_of_neighbors == 2 ||
        number_of_neighbors == 3
    end 
end 

class DeadCell
    def comes_to_life?(number_of_neighbors)
        number_of_neighbors == 3
    end
end

De esta manera, las clases que representan células están únicamente centradas en la información que les atañe, como las reglas sobre cómo evolucionan.
También hemos extraído la topología de las reglas del juego, viendo que el tipo Location tiene un rol de estructura, que une la malla con la célula.

Comparándo con mi código, la composición invertida es muy similar a la solución que había propuesto yo inicialmente en la kata: Grid -> Position -> Info

Como ‘Rule of Thumb’ la dependencia de clases debe ir desde la que más cambia a la que menos cambia, desde la menos estable a la más estable, es decir, la dependencia la tiene que tener aquella que tiene más posibilidades de cambiar sus atributos.

Conclusión

Programar el Juego de la Vida de dos maneras diferentes y luego leerme este libro ha resultado ser un ejercicio muy intenso y productivo. ¡Y escribir este post, claro!
Me llevo un buen montón de herramientas.

A continuación voy a leerme el libro “Practical Object-Oriented Design in Ruby”, de Sandi Metz. Os iré contando!

Etiquetado ,

cover

In my first weeks in Codesai, I have to code the Conway’s Game of Life in a pair of ways.

First one was TDD inside-out in Javascript, and the second one was TDD outside-in with Groovy. I left there links to my Github.

If you want to know a little bit more about TDD styles, you can read this beautiful post: TDD – From the Inside Out or the Outside In?

After that I read the small book “Understanding the 4 Rules of Simple Design” and I leave a little review in GoodReads :

Very interesting thoughts about Four Rules of Simple Design based in Game of Life Kata.
I agree with most of the conclusions and the review of Simple Design Rules.
Little ‘but’ ahead… In my opinion, I see in the final examples, a little bit of ‘magic’ and some jumps in the flow we were following with the author.

It’s a good booklet, you can read it very quickly and you take very clear and useful information.

I’m writing right now a more extended post with detailed comments. Stay tuned!

 

Book review – Understanding the 4 Rules of Simple Design

Etiquetado

¡Gracias Madrid!

IMG_20160715_210223

¡Gracias!

Gracias a todo lo que he vivido en Madrid, a la gente que he conocido, a lo que he aprendido y crecido como profesional, …. puedo hoy decir que tengo la capacidad de cambiar mi vida, de cerrar un ciclo.

Por si llegas aquí de repente, puedes leer el post anterior sobre el Cierre de un Ciclo.

Gracias a Lupe, mi mujer, si no es por ella, por su apoyo, no habría podido asistir a múltiples eventos mientras se hacía cargo de las obligaciones que compartimos. En estos momentos está esperando pacientemente a que termine este post para irnos de paseo por Tenerife. Eso es amor.

Gracias a Eduardo Ferro, casi el primer compañero que tuve en Madrid y el que me ha descubierto el amor por el desarrollo. Un amigo con los destinos entrelazados.

Gracias a Madriagil, la comunidad de profesionales más grande, heterogénea y resucitada del mundo. Siempre me he sentido querido y muy seguro entre todos vosotros. Os seguiré ahora un poquito desde la distancia y siempre que pueda me acercaré a las reuniones.

Y agradecer sobre todo a Kaleidos, mi casa durante los pasados ocho años , 8 años? Si Kaleidos acaba de cumplir 5! , sí yo soy de Kaleidos desde el 1 de febrero de 2008, cuando con mucha fortuna, después de terminar un proyecto en cliente, mi relocalización dentro de Entelgy fue a FOSS, del que nació Kaleidos en 2011.

Poco a poco, como para que nos lo creyésemos nosotros mismos, fuimos construyendo otra forma de hacer las cosas, otra forma de hacer empresa.

Durante este tiempo he aprendido, disfrutado, sufrido, reído muchísimo, frustrado, reflexionado, crecido, y aprendido otra vez.

Reconozco que he pasado momentos de mucha frustración , a veces la comunicación con el equipo y con los jefes no era la mejor, no estábamos alineados. Sufrí mucho.
Recuerdo especialmente el verano de hace dos años en el que hablé con muchos amigos, como Vanesa, Juanma o Isra, para saber qué hacer.  Pero fueron las conversaciones con Diego Rojas, que me vio tan perdido que me ofreció tener unas sesiones de coaching personal, con el que examiné en profundidad todo lo que me pasaba.

Gracias a él, me di cuenta que creo en este proyecto, creo que se puede hacer una empresa diferente. Desde ahí si esa empresa es resultado de una jerarquía muy plana, donde realmente no hay nadie a quien echarle la culpa, porque si estamos aquí es porque todos hemos querido…
solo queda que te mires a ti mismo y decidas qué hacer con esto.

Y decides crecer.

Crecer para poder convertirme en un gran profesional que ahora puede elegir el destino que quiere tener, que no todo el mundo puede, os lo aseguro.

Este balance positivo está coronado por un último año magnífico. El cambio a front es algo que realmente necesitaba y no lo sabía.
Y además con un último proyecto fantástico. Que me quedase solo en el proyecto al inicio, fue la tormenta perfecta que permitió coger las riendas de un proyecto, que iba a crecer con cuatro personas más con mucho más conocimiento que yo en javascript. La experiencia adquirida en los equipos de back en Kaleidos, con un nivel fuera de escala, me sirvió y muy bien.

Pero de esto no me di cuenta yo solo, tuvieron que ser las after-work cervezas de un viernes y una buena charla la que me animó. Que iba a costar mucho trabajo, pero me hicieron darme cuenta que era la única manera de ascender ese nivel que necesitaba.
Y una vez decidido a enfrentarme al reto, no monté solo el proyecto, fue con la ayuda de personas con paciencia y corazón infinito.

Este crecimiento personal y seguridad conseguidas son necesarias para poder tener la  humildad en reconocer mis propias carencias. Desde ahí crecer y sobre todo crecer dentro de un equipo es mucho más fácil.

¡Gracias equipo por todos estos años! :-*

Próximo destino?
<censurado hasta anuncio oficial>

Dejo muchísimo amor en Madrid, así que estad seguros que nos veremos a menudo: en cafés mano a mano, en eventos y por qué no, en desksurfings!

Para terminar quiero compartir con vosotros un correo que mandé a mis compañeros de Kaleidos con la única misión que me quedó sin completar.

 

---------- Mensaje reenviado ----------
 De: Antonio de la Torre
 Fecha: 22 de julio de 2016, 12:28
 Asunto: Y ya está...
 Para: Kaleidos Team

Acabo de firmar la baja. :_-)

Esta semana ha sido preciosa recordando un viernes que quedará grabado en mi memoria.

(recuerda Toño, siempre un Call to Action)

Los últimos años han visto la estabilización de proyectos y por tanto de equipos, que hace que cada vez estemos trabajando más con nuestro equipo y menos con todos los demás de manera diaria.

Con esto en la mente, si me quedaba una tarea inacabada en Kaleidos que hubiese querido ver, es que las Comunidades de Práctica dentro de Kaleidos (de back, de front, de JS, de diseño, …) sean un espacio seguro y una fuente recurrente de intercambio de ideas y conocimiento, consulta y mentoring activo.

Fue un gran apoyo para poder afrontar mi último proyecto con absoluta garantía y creo que pueden ser de ayuda para otras ocasiones parecidas.

Os animo a impulsarlas!🙂

</call-to-action>

Nos vamos a ver mucho, os lo aseguro. Hay muchos nexos en marcha: Baoqu o Habitica, eventos varios: CAS, Codemotion, y además de eso las visitas cuando me pase por Madrid.

Gracias a todos!

Toño

 

Etiquetado

Cierre de ciclo

y23

Un poco de historia

En el verano de 2004 estaba viviendo en Oviedo, mi ciudad natal. Me quedaba solamente el proyecto para terminar Ingeniería de Informática.

Tras unas vacaciones que salieron bastante regular decidí buscar un trabajo serio. Estaba harto ya de becas y prórrogas de becas, y eso mezclado con que no tenía un duro, me impedía avanzar en mi vida.

Así que el 2 de agosto me di de alta en Infojobs  y la vez empecé a llamar a todas las puertas que conocía en Asturias. Sabía que no era un buen momento, el mundo se para en agosto, pero qué opciones había, en algún momento había que empezar.

A los dos días me llamaron de una empresa de Madrid para hacer una entrevista. No me lo podía creer. Miré cómo se iba a Madrid en bus, no tenía ni idea. Busqué dónde estaba la Estación Sur de Autobuses y oí por primera vez el nombre de Méndez Alvaro. Llamé a unos primos para preguntarles si me podía quedar con ellos y para allá que fui.

Todavía me acuerdo la sensación de satisfacción infinita al salir de aquella reunión. En media hora ya estaba hecho y hasta salía con una oferta. Era otro mundo totalmente.

Fue un mes de agosto muy intenso, hice hasta doce entrevistas en Madrid, e incluso una en Bilbao, para diferentes empresas, consultoras, clientes, terceros, terceros de terceros… Viajé todas las semanas y hasta llegué a quedarme en Madrid sin nada que hacer esperando a que me llamasen para no tener que darme más viajes arriba y abajo.

Mientras aprendía a marchas forzadas lo chungo de las consultoras bodyshopping, ¿sabes cuántas llamadas recibí de empresas de Asturias? CERO. Esa diferencia de realidades merecía por lo menos una oportunidad, ¿no?

Así que el 1 de septiembre de 2004 empecé a trabajar en una empresa de Madrid.

Decisiones vitales

Hace 12 años de esto y la vida todo este tiempo ha sido muy buena, pero había que tomar decisiones.

En Madrid estamos muy a gusto. La vida es fácil y bonita. Tenemos dos niños pequeños, una casa acogedora y todos los servicios que puedas necesitar muy cerca. En estos años hemos hecho muy buenos amigos con los que hemos pasado momentos e incluso viajes inolvidables.
Hasta soy voluntario de Samur-Protección Civil. Lo que he aprendido en sus formaciones me ha dado un tranquilidad con la que puedo salvar vidas. Si me quedo con una actuación sería la del accidente del Spanair en Barajas. Eso son lecciones de vida.

Pero inconscientemente no estábamos tomando decisiones como si fuera nuestra ciudad para siempre. Ni hablar de comprar casa, por ejemplo.

Descubrí durante el programa de Enmagiate que hice con Hana Kanjaa el año pasado, que dónde yo quería vivir era en mi tierra natal, en Asturias.

Así que inicié la conversación en casa. Lupe, mi mujer, alucinó bastante, porque ya habíamos hablado alguna vez de esto y veíamos que era muy difícil volver.
Pero dónde no había opciones, cuando pasas a ‘querer’ realmente volver, hace que se muestren las oportunidades. Siempre estuvieron ahí, pero ahora las valoras.

Y una de esas oportunidades se concretó. Cuando Lupe volvió de Oviedo de una entrevista muy contenta y a los pocos días la llamaron para decirle que sí, que contaban con ella, era la señal que estábamos esperando.

Ese día fijamos la fecha de nuestra mudanza, sería el sábado 16 de agosto de 2016.

Tres meses y medio para crear una nueva vida

Tres meses y medio para crear la nueva vida en Oviedo. No teníamos ni casa, ni yo tenía trabajo, ni empresa de mudanzas, ni colegios para los niños para el curso siguiente, …

Pero como te puedes imaginar todo esto se fue resolviendo. Mi trabajo fue lo único que costó un poco más.

Pego aquí debajo un extracto del correo que mandé a los compañeros de Kaleidos

---------- Forwarded message ----------
From: Antonio de la Torre 
Date: 2016-06-27 13:59 GMT+02:00
Subject: Nueva vida! Me mudo a Asturias el 16 de Julio
To: Kaleidos Team 

¡Hola!

New life is coming!

Como sabréis todos (me he asegurado) me mudo a Asturias el 16 de Julio, sábado. Un día después de la PiWeek y la fiesta Kaleider, por supuesto.

Tres semanas y una de ellas de piweek…  :_-)

Mi intención era seguir en remoto con Kaleidos, pero no ha sido posible. Tenemos más experiencia y dos retrospectivas más sobre el remoto y el teletrabajo.

Fair enough, Kaleidos busca recentralizar en lo posible o por lo menos no descentralizar más y yo busco nuevos horizontes. Al final os cuento más de esto último.

Desde aquí, lo que hemos hablado con el equipo hace ya un par de meses es que estaré en remoto trabajando en Kaleidos los tres próximos meses, hasta octubre.
Con dos objetivos win-win: El proyecto actual tenga buen recorrido hasta el MVP (aunque viendo el equipazo de front, estoy seguro de que no haría falta) y yo pueda tener un aterrizaje suave en mi nueva/vieja tierra.  ¡Gracias!🙂

Durante este tiempo, la idea es venir según necesidad y estar un par de días.

Después de este tiempo buscaré nuevas aventuras! Por ahora la pinta es muy buena. Solo comentando el tema en persona en eventos y meetups, tengo propuestas muy interesantes ‘encima de la mesa’.😀

Estoy super contento, porque cuando tomamos la decisión no tenía nada, ni casa, ni trabajo. Y ahora ya encontramos piso bonito y si todo sale bien empezaremos esta nueva etapa con muy buena base.

Quedan todavía tres semanas, pero no está de más adelantar que gracias a vosotros, gracias a todo lo que este equipo me ha ayudado a crecer, he tenido la confianza de dar este paso, a ojos de muchos arriesgado y viendo las evidencias seguro.

¡Gracias por estos OCHO años en FOSS->KALEIDOS!

Y que tanta paz lleve como descanso deje.🙂

¡Besitos!

Toño

 

Tres semanas después todo se aceleró bastante y no hicieron falta esos tres meses. La nueva vida estaba montada.

Ahora toca dar las gracias, pero como este post a quedado un poco largo, os lo escribo en el siguiente.

Update: Aquí tienes el post de ¡Gracias Madrid!

En breve conocerás mi próximo destino.🙂

ultimodia

graciaskal

mudanza

 

Foto: Salida con el Grupo de Montaña de la Universidad de Oviedo a Villamanín, León. Autor desconocido.

Etiquetado , ,

Decisiones: ¿Tecnológicas o Estratégicas?

the garden of forking paths

Estamos actualmente en el desarrollo en un momento que yo comparo a veces con la adolescencia. No sabemos qué somos, ni a qué queremos dedicarnos.

Solo importa la tecnología.

La vorágine de frameworks que está asolando el panorama del Frontend actual es para plantearse si las decisiones de cambio de lenguaje a lo último de lo último, ¿son como  resultado de una buena pensada de pros y contras, o más bien porque sabemos alzar la voz por encima de todos los demás?

Parece que lo que buscamos es que nos dejen elegir la tecnología en la que queramos trabajar sin tener que justificarnos, sin tener que compartir nuestra decisión, …

Entonces sufre el equipo, el compañerismo, preocuparse por el otro, aprender juntos, enseñar, mentorizar, …

Estamos de acuerdo que la tecnología es un medio… ahora bien, ¿al servicio de un fin para qué o para quién? Porque puede ser que sea sólo al servicio de uno mismo.

¿No debería estar al servicio de la estrategia que queremos como empresa? O por lo menos al servicio de lo que queremos como equipo.

Debería estar alineada con la estrategia de la empresa.

Creo que nunca debería estar al servicio personal, sería como disparar con la pólvora del Rey.

En un proyecto que acabamos de empezar, la elección del framework fue Angular 1.5. Más popular y quizás menos moderno (aka “tiene más de seis meses”) que otros en el mercado. Lo inesperado fue que ha provocado estos efectos muy positivos:

  1. Fue una decisión tomada por la Comunidad de Práctica de JS interna de la empresa con el refuerzo consiguiente para todos.
  2. Angular 1.5 a pesar de ser antiguo tiene una orientación a componentes muy moderna, por lo que no hubo nada de rechazo.
  3. Al ser un framework popular , tiene muy buena documentación y ha permitido que compañeros de back se vean con ganas de hacerse un tutorial “por si hay que echar una mano algún día”. Algo impensable.
  4. Al haber mucha experiencia previa en proyectos, se han podido establecer nuevas relaciones de mentoring entre compañeros con diferentes niveles de conocimiento.

Creo que está siendo una gran decisión y nos está haciendo madurar como empresa y como equipo.

¿Te has encontrado con estos problemas alguna vez?
¿Cómo decidís la tecnología de vuestros proyectos?

Photo by Craig Cloutier

 

Etiquetado , ,

¿Cómo se ve la comunidad de Madriagil a sí misma?

Reflexión Madriagil

¿Por qué venimos a los eventos de Madriagil?

 

Esta foto es el resultado de un ejercicio que hicimos buscando el por qué venimos a los eventos y por qué creemos que vienen los demás. Fue en el  Madriagil: Inicio de temporada + Dojo de CNV, celebrado el pasado 8 de octubre de 2015,

Al final sacamos esta Lista ordenada de razones por las que asistimos a los eventos de Madriagil:

  1. Compartir
  2. Formación gratis
  3. Experiencias
  4. Ver a la gente
  5. Aprender
  6. El tema es importante para asistir
  7. Vivir mejor (aprender a)
  8. Uniqueness (Ocasiones únicas, como visitas de algún miembro de otra comunidad)
  9. Energía (recargar)
  10. La idea feliz
  11. Incluir a más gente
  12. Persona (Ponente) conocida
  13. Promocionar mi curso

 

¿Qué te parece? ¿La compartes?

Mi opinión

En mi opinión esta lista es bastante genérica y no refleja ni la conversación que tuvimos allí, ni la sensación que tengo de la actividad que tiene Madriagil como tal.
Lo primero no creo que cumplamos las condiciones para definirnos como Comunidad. Quizás tenemos intereses y valores comunes, pero nos falta algo más importante como la identidad o el sentido de pertenencia.

Y a continuación en modo lista los problemas que veo:

  • No creo que seamos un grupo equilibrado.
  • Muy pocos son los que proponen temas para hacer las reuniones.
  • La acogida de cada charla y la atención que genera es muy irregular, dependiendo en gran medida de cada una de las razones expuestas más arriba.
  • La asistencia final respecto a la confirmación suele ser del 50-60%.
  • El nivel de los asistentes es irregular, puede haber gente con mucha experiencia y con poca.

Analizando un poco más un par de temas…

Cómo se convocan las reuniones.

Las últimas convocatorias han sido siempre fruto de una iniciativa individual. Aunque es genial, que la primera noticia de un evento llegue por un correo de la plataforma meetup,  nos resta identidad.

La asistencia es del 50-60%

JMBeas señaló el año pasado de la falta de compromiso de las personas que no iban a los eventos de meetup tras confirmar asistencia. Se habló bastante sobre el tema e incluso como respuesta, Bonilla le dedicó la Bonilista de esa semana: “Una silla vacía”.
Creo que el fondo de la cuestión, es que el compromiso con el evento hay que construirlo, y es el resultado de construir una comunidad, con una identidad, formada por un conjunto de personas que se conocen. Si no tenemos esa comunidad, no nos extrañe que el nivel de compromiso de un “Me apunto” en una página de un Meetup sea bajo.

El nivel de los asistentes.

Obviamente no vamos a hacer una comunidad exclusiva para novatos o para expertos. Tiene que haber de todo. Lo que creo que está pasando es que no lo estamos gestionando adecuadamente. Uno de los signos más obvios es que de las personas que yo considero ‘experimentadas’ de la comunidad es MUY raro que coincidan más de dos en un mismo evento.
¿Por qué no vienen? Para mi está claro. La ratio beneficio/esfuerzo resultado de asistir a estas reuniones en muchas ocasiones no está clara y en otras muchas es inferior a uno. Ni siquiera sirve como networking, pues la falta de relación personal entre las personas que van últimamente no dan ni para una caña después del evento.

Y sorprendentemente…

el número de personas que asisten por primera vez a un evento de Madriagil es muy alto en cada ocasión. A ojo quizás sea del 20-25%. ¿Qué hacemos con estas personas? ¿Les damos una calurosa bienvenida a la comunidad? #nope

 

¿Qué podemos hacer?

Algunas ideas

Convocatorias

Sería bueno realizar un par de mejoras a esta manera de reunirnos. Primero fijar una frecuencia para hacer las reuniones y segundo mandar un correo a la lista previo, buscando una pequeña tormenta de ideas. Igual que hace MadridGUG.

Nivel de los asistentes

Crear eventos específicos más horizontales, donde el nivel y motivo de las sesiones sea más claro.
Aquí cabe la idea de ampliar la idea de Comunidad de Práctica que propusimos a unos cuantos Juanma y yo viniendo del AOS de Asturias. Esto se va a hacer en febrero, pendiente de fecha.

Construir más comunidad

Sinceramente, ni idea cómo hacer esto. Imagino que es un resultado de todo lo anterior.m

 

A partir de aquí igual todo es importante y no hago más que relacionarlo con el tema abierto en Agile Spain, relativo a que todavía no ha salido nadie para organizar la siguiente CAS.

O no lo es en absoluto, y solo hay que respirar, ser más indulgentes con nosotros mismos y seguir adelante preocupándonos únicamente de conectar con aquellos que realmente nos aportan energía.

Un abrazo a todos y ¡Feliz Año 2016!

Etiquetado , , ,

Mi primer Agile Taste y el Sushi Kanban

IMG_20151127_210207

¡Gracias por la invitación!

Así empezó mi participación en mi primer Agile Taste, con la invitación de un buen amigo, Diego Rojas de Thinking With You.

Para que este comentario sea valioso voy a intentar ser breve e ir a lo que más me llamó la atención. (da igual, espero lo disfrutéis)🙂

La bienvenida

Nos recibieron Diego Rojas y Pepe Vazquez con un cafetín para calentar, mientras íbamos conociendo a los integrantes del taller y nos familiarizamos con el entorno. El lugar era Sueños de Cocina, una escuela que parecía con un buen espacio para hacer la actividad.

De paso nos presentan al cocinero y responsable del local: Nacho Garbayo. Será nuestro maestro y como veremos luego nuestro chef y jefe del restaurante.

El taller que dimos estaba basado en éste, aunque más corto y adaptado para solo cuatro horas largas.

Introducción

Lo primero nos dan una pequeña charla sobre en qué va a consistir el curso y luego pasamos a que Nacho, el cocinero, nos enseñe cómo preparar las variedades de sushi que vamos a tener que realizar durante la tarde.

La dinámica consiste en ser el equipo de cocina de un restaurante japonés y tenemos que satisfacer a nuestros insaciables clientes, Pepe y Diego, y con la vigilancia muy de cerca de Nacho, el jefe de cocina, que cuidaba que sobre todo las medidas de higiene y contra la contaminación de alimentos se cumplían.

Comienzan las hostilidades, primera iteración.

Nos dividen por equipos, en nuestro caso dos de cinco personas, nos dan solo cinco minutos para organizarnos y a continuación tenemos que preparar en veinte minutos todo un repertorio de comandas que van a ir pidiendo prácticamente sin parar nuestros dos hambrientos clientes.

En esta primera iteración no hay kanban, autoorganización directa.

A mi me tocó ser camarero y responsable del flujo de trabajo y fue una auténtica locura, me tuvieron para arriba y para abajo todo el tiempo. Fue bastante agotador y casi no tuve capacidad de comprobar nada del flujo. Así y todo salvamos muy bien el tipo, siendo, según nos contaron luego, el equipo que más producto había sacado nunca en su primera intentona. La organización previa había salido muy bien.

Segunda iteración, kanban style.

Hacemos una introducción a kanban y cómo lo podemos aplicar directamente a nuestro trabajo en la cocina.

Tras una pequeña preparación para que se adapte la cocina a nuestro nuevo proceso de trabajo, empezamos. La productividad no fue tan alta, pero la sensación de calidad, desahogo y capacidad para ayudar al compañero y poder optimizar el flujo subió exponencialmente.

Conclusiones

Es un taller con una sensación de mundo real muy bien conseguida. Está muy centrado en el proceso y realmente el cocinar no es importante. Todo el tiempo mi sensación no era de no tener capacidades para cocinar o hacer la tarea encomendada, el problema siempre venía de la coordinación.

La formación muy clara y sencilla, en píldoras de información directamente aplicables.

Sobre la iteración 1, me sentí en todo momento muy agobiado y con una falta de visión de lo que estaba pasando total.

En la iteración 2, como decía antes, sensación de mucha más holgura, de que podía ayudar a mis compañeros, que podía preguntar a los demás, e incluso al cocinero si no entendía el pedido (nos hicieron un pedido que no había explicado Nacho :P).
Y sobre todo, con la ayuda de políticas explícitas, tenía la confianza en mi equipo de parar la cadena entera si lo veía necesario. Como de hecho pasó, cuando estábamos montando un pedido mal y hubo que rehacerlo.

Conseguimos un equilibrio que enseguida vimos que se podía optimizar. Por ejemplo en el puesto de preparar el relleno y colocarlo que podíamos aumentar el WIP limit a 2, metiendo otra persona para trabajar en paralelo.

Hasta entró un pedidos urgente que entró por un carril prioritario y !salió a tiempo!

Finalizando el taller

Para terminar Diego y Pepe se extendieron en los valores de Kanban y aquí hago una selección de los que más relevantes me parecieron para esta dinámica.

Valores

Transparencia – en lo que desconozco
Colaboración
Acuerdo y compromiso
Respeto, refuerzo positivo

Principios

Empieza por donde estás
Entender expectativas del cliente BIEN!!
Cambio incremental y evolutivo
Alentar liderazgo

Prácticas

Feedback
Políticas explícitas
Gestionar el flujo
Limitar el wip
Visualizar el flujo

Cierre

Aquí os dejo unas fotos por si queréis ver cómo fue el taller:
https://goo.gl/photos/xCTekDGwK8KiAnYM9

En definitiva, un taller muy bonito e intenso que recomiendo sin dudarlo.

Etiquetado

Deberíamos darnos la vuelta más a menudo. Primer comentario de la CAS 2015.

CAS teatro

Primer comentario en alto después de la CAS 2015.

Copio aquí el comentario que hice en el post de Carlos Ble: Reflexiones tras una emotiva CAS2015.

Hola Carlos!

Como followup a este tuit.

El pensamiento sobre aprender de todos viene de ésto.

Me imaginaba que todos en la sala podemos identificar a nuestros padres y madres en el agile. Y seguramente estén sentados a escasos metros de nosotros.
Y luego nosotros somos los iniciadores para otros.

Eso hace que parezca que hay diferencias de experiencia y de nivel… y lo digo porque se nota un regustillo a diferentes niveles de ‘profi’ en la aplicación del agile en tu vida durante la conferencia.
Comentarios de que las charlas son básicas, o que luego nos juntamos siempre entre los mismos conocidos, no nos abrimos a gente nueva.

Tendríamos que darnos más la vuelta y volver a hablar con esos ‘padawans’, y tratarlos como iguales y hacer un esfuerzo por aprender también nosotros de ellos. Me sorprendo continuamente los retos a los que se enfrentan cada uno de ellos en su día a día y que dan mil vueltas a lo que yo les pude mostrar alguna vez.

Mi No-charla en la CAS 2015 : Necesidades vs Soluciones: una vista diferente al Crossing the Chasm

Este año presenté un par de charlas[1][2] para la CAS 2015.
El nivel es realmente extraordinario, así que no me extraña demasiado que al final no se aceptase ninguna. La parte buena es que podré ir mucho más relajado.

Presenté charlas más como un ejercicio de colaboración con la comunidad que por un objetivo personal. Este año me lo había tomado como de descanso, después de haber ido como ponente a un montón de sitios en el 2014.

Pero lo que me trae a escribir este post rápido es compartir con vosotros el abstract de la charla que creo es muy interesante, así que me encantaría prepararlo y contarlo en un @madriagil.

Necesidades vs Soluciones: una vista diferente al Crossing the Chasm

En mi entorno existe una gran inquietud tecnológica. Llega a ser un ansia feroz por buscar el siguiente best-framework-ever, por no conformarse con soluciones bien probadas.

El pasado agosto estuve en Sofía asistiendo a la ALE y conocí al genial Chris Matts que hizo la keynote inaugural. Hizo una aproximación al clásico Crossing the Chasm, mapeándolo por encima con otros modelos como el Cynevin, Meme Lifecycle o Real Options.

Fue realmente revelador. ¿Por qué algunos se conforman con una solución suficientemente buena y otros buscan continuamente la excelencia? ¿Por qué las buenas prácticas no son tan buenas? ¿Por qué reinventar continuamente la rueda? ¿Qué motivaciones existen en unos y otros?

En esta charla veremos las diferentes comunidades que tenemos a nuestro alrededor y trataremos de alinear todas estas motivaciones dándoles un objetivo común.

Articulos relacionados de Chris Matts Communities of Need & Community of Solutions y Agile – The Broken Learning Machine

Un pequeño sketch que hice ayer para explicarlo en una sesión que tuvimos en Kaleidos:

needs02

La idea clave que puse ayer es que las Necesidades se mantienen, mientras que las Soluciones cambian con el tiempo.

Aquí salió la pregunta “¿No hay un gran desperdicio de tiempo y esfuerzo en estos experimentos constantes?”

Mi respuesta es conseguir el equilibrio entre “Rentabilidad vs Atraer Talento” , “Aburrimiento vs Investigación”, “Estrategia empresarial vs Motivaciones personales”

Más diferencias, foto de Alexis Monville

needs01

Espero que os resulte tan interesante este tema como lo es para mi.

[1] Tarjeta trello de la CAS2015 para la charla de Necesidades vs Soluciones
[2] Tarjeta trello de la CAS2015 para la charla de Discusiones y Decisiones

Etiquetado ,