El próximo sábado 20 de abril, tengo el placer de dar una charla en la Commit Conf 2024. La charla será «La nueva forma de expresar ‘Data’ en Java 21» y tratará sobre como con el nuevo soporte de los tipos algebraicos que se ha dado en Java 21 se ofrece de facto la nueva forma de expresar Data en Java desde JavaBeans una especificación que se puede decir sin miedo que es del siglo pasado.
Será el sábado después del descanso de la comida.
El pasado 24 de octubre dí una charla sobre el soporte completo que se ha dado en Java 21 a los tipos algebraicos. Estuvo muy bien, sobre todo por el debate que se estableció durante la charla y en el networking posterior.
Diapositivas presentación: Tipos algebraicos en Java 21
El repositorio de código:
https://github.com/logicaalternativa/algebraictypes
y también el video del directo de la charla
El pasado 21 de abril di una charla sobre programación reactiva y como tener conocimiento de los patrones funcionales pueden ayudar a entender mejor este tipo de programación.
En la charla también introduzco el concepto de DSL (Domain Specific Language) que permiten de una manera real abstraer nuestro código de la tecnología escogida.
En otro orden de cosas, para mí fue un honor que la organización del Commit Conf confiara en mí para ser ponente.
Aquí están las diapositivas de la presentación
Diapositivas presentación: Programación reactiva y patrones funcionales
y el vídeo de la charla
El objetivo de este post es servir de introducción a una de las ramas del machine learning o, en español, aprendizaje computacional como son los modelos de aprendizaje por refuerzo. Los sistemas de aprendizaje computacional se pueden modelar como una función que dependiendo del valor de unas entradas se obtiene una salida que permite predecir o clasificar.
# Modelización de un sistema de aprendizaje computacional como una función Entrada_1 --> ,-------. Entrada_2 --> | Modelo| --> Predicción o clasificación (Salida) ... --> `-------' Entrada_n ---- predicción = modelo( entrada_1, entrada_2, ..., entrada_n )
Si nos atenemos al conocimiento a priori de cuan buena puede ser la predicción, podemos clasificar los sistemas en tres grupos:
En los sistemas supervisados se tiene un conocimiento completo. Un ejemplo puede ser un clasificador que es capaz de distinguir entre un muffin o un chiguagua, ya que se puede saber (o puede que no sea tan sencillo 😀 ) si el clasificador lo ha hecho bien o se ha equivocado. Por el contrario, los sistemas no supervisados, no existe ese conocimiento previo y sirven para descubrir patrones y agrupaciones desconocidos dentro de un conjunto de datos.
El el punto medio están los sistemas de aprendizaje por refuerzo, donde sólo podemos saber si el sistema esta respondiendo mejor o peor con respecto a una entrada. Esto se materializa obteniendo una recompensa o una penalización del resultado de la salida, y así, «saber» si la solución plateada actual, va por el buen camino.
Un ejemplo en la vida real es un cachorro al que le estamos enseñando a sentarse, si lo hace bien, recibe su recompensa y si no, no recibe nada. Sin entender al principio lo que pasa, al cabo de unas cuantas veces pensará «Si en esta situación, me comporto de esta manera, recibiré una recompensa porque en el pasado ya me ha ocurrido».
Dentro sistemas de aprendizaje por refuerzo están los algoritmos genéticos utilizados en sistemas difusos. Cuando se habla de un sistema difuso se está hablando de un sistema del que no se tiene «incertidumbre» en la percepción del entorno. Hay que tener en cuenta que este tipo de conocimiento incompleto es muy común en el mundo real («velocidad en torno los 100 km/h», «temperatura mayor de 25ª») y nosotros los humanos somos muy capaces de tomar decisiones a partir de esta información imprecisa.
Con respecto a los algoritmos genéticos son aquellos que se van variando sus parámetros de modelo de una manera parecida a como funciona en la naturaleza. En esta, aquellas familias de genes que mejor se adaptan al entorno son las que prevalecen y siguen evolucionado y en los algoritmos genéticos son las familias de parámetros que más se acercan a la solución óptima son los que prevalecen y a partir de los más exitosos se sigue evolucionando.
Los agentes reactivos también pueden encajar dentro de los sistemas basados en aprendizaje por refuerzo. Un agente tiene un sistema autónomo que está puede obtener información y comunicarse con el mundo real
Reactivo significa que el agente no tiene una idea clara, ni una representación simbólica de entorno con el que se comunica. Es un sistema sencillo que simplemente se relaciona y reacciona con su entorno. La inteligencia emerge de las iteraciones de varios de estos agentes.
Una hormiga se limita a reaccionar a su entorno comunicándose con otras a través del olor( feromonas), físicamente o mediante sonido o vibraciones. La suma de estas interacciones hacen que el hormiguero sea un sistema altamente adaptativo e inteligente sin un sistema de control centralizado, con organizaciones complejas como la separación de tareas dentro de los individuos.
En próximas entradas quiero centrarme en este tipo de sistemas multiagente, que es un agente y su relación con los modelos de aprendizaje por refuerzo.
M.E.
Los días 23 y 24 de noviembre ha tenido lugar en Madrid la primera edición del Commit Conf, uno de los eventos más importantes que se tiene en lengua castellana.
En su momento presente mi charla sobre Akka Sharding y su relación con DDD al “call for papers” con ilusión pero sin grandes esperanzas de que fuera aceptada. Hay que tener en cuenta que hasta ese momento no tenía experiencia presentando charlas en eventos públicos aunque afortunadamente si que tengo cierto callo en exponer ideas en público ya que mi trabajo me lo exige.
Así que cuando me aceptaron la presentación me lleve una enorme alegría porque consideraron el tema de mi charla interesante. Alegría, pero también responsabilidad por toda la confianza depositada.
Recuerdo con una sonrisa la primera presentación que hice a a tres compañeros de trabajo que me hicieron de beta testers. Para mi alivio les resultó interesante y fue curioso, porque cada uno tenía una visión diferente de lo que le había gustado de la presentación. Uno se decantó más por las posibilidades que ofrecía este paradigma, otro puso más interés como se implementaba y el otro las implicaciones operacionales que tenía el despliegue de un sistema distribuido. El problema fue el tiempo: se fue más de hora y media.
Luego he tenido la increíble oportunidad de presentar la charla en otros foros como puede ser en el ScalaMAD (el 31 de octubre) a los que estoy agradecido y que me permitió pulir la charla.
Al final creo que la presentación en el Commit fue bastante bien, aunque recortada estuvo un poco justa de tiempo, … me faltaron unos minutos, un problema endémico por intentar tener en cuenta todos los conceptos, pero si que la gente se mostró participativa en la tanda de preguntas lo cual es muy bueno.
En resumen la sensación fue muy positiva, una experiencia intensa pero muy bonita de la que guardaré un buen recuerdo. Para terminar, lo prometido, estos son el vídeo y los enlaces de la charla y el repositorio del github de los notebook de Jupiter con la demo.
Presentación: Akka Sharind y su relación con DDD
Código: Repo GitHub
«Los modelos NIO no bloqueantes y la programación asíncrona y reactiva son paradigmas que poco a poco van adoptándose y utilizando más.»
Los modelos NIO no bloqueantes y la programación asíncrona y reactiva son paradigmas que poco a poco van adoptándose y utilizando más. No creo que diga una tontería al afirmar que muy probablemente serán la norma en un futuro cercano. La razón es clara: aunque no se obtiene un rendimiento mejor que los modelos tradicionales sincrónicos, si son modelos mucho más eficientes. Obtienen el mismo rendimiento con menos recursos al tener un mejor control de los hilos, uno de los recursos más preciados en un sistema operativo.
Futuros y promesas
Para poder articular una programación asíncrona y reactiva es necesario utilizar patrones adaptados a este tipo de programación. Puedes utilizar el patrón observable o las señales, pero casi podríamos decir que tu camino te llevará irremisiblemente al patrón futuro en cuando tienes que integrar varios resultados asíncronos. Si además nuestra implementación del patrón futuros-promesas cumple con las propiedades de las monadas se nos abre un mudo de posibilidades. Con la programación funcional, la composición de futuros se podrá hacer de una manera elegante obteniendo un código más legible.
Esto permite realizar DSL’s (Domain Specific Language) y separar la lógica de negocio de los efectos de lado. Por ahora “… ahí lo dejo”; prefiero no perder foco en el objetivo de este artículo, pero en mi mente esta tratar todo esto en una nueva reseña. En este artículo entraré a desarrollar todos estos nuevos conceptos intentando desmitificarlos, porque al principio todo lo de “Futuros”, “Promesas” y “Mónadas” puede que suene “muy místico”. Lo haré apoyado en mi propia implementación del patrón Futuros y promesas que está disponible en mi GitHub.
La implementación está basada “fuertemente” en el Api de Scala de futuros y sólo recordar que Akka en su versión de Java la exporta directamente y que además los futuros de Scala son también monadas. Cuando digo que me apoyo en el Api de Scala me refiero a seguir la definición de su contrato, de hecho, no me interesaba el código fuente y si hacer el ejercicio de, a partir de su interfaz, realizar mi propia implementación en Java. El código que podéis ver y utilizar es todo mio. Hecha esta aclaración es el momento de empezar a entrar en faena.
Intentaré hacer un acercamiento de dentro a fuera. Primero pondré el foco en las ideas principales para ir después abriendo el zoom y conseguir tener la imagen completa.
«¿Qué es un futuro?» Pongámonos en contexto. Imaginemos dos procesos: uno será el principal que llamará a un método que devuelve un futuro de un valor. El otro será el que calcule realmente el valor de manera asíncrona ejecutado en un segundo plano con respecto al principal. Voy a poner un ejemplo para hacerlo más didáctico. Ana (el hilo A, el principal) le dice a Bartolo (el hilo B) que haga la colada (llamada al método)
1. Llamada asíncrona
El proceso principal obtiene un futuro como resultado de llamar a un método que se lanzará en segundo plano gracias al hilo B. En el ejemplo Bartolo manda una nota (representa el futuro) a Ana que le permitirá apuntar lo que se quiere que se haga con la colada cuando haya terminado Bartolo. El hilo A no queda a la espera del resultado de la acción ejecutada por el hilo B y queda liberado para realizar otras operaciones. En el ejemplo Ana no espera a que Bartolo termine y puede seguir haciendo otras tareas.
2. Se devuelve un futuro
Este futuro es en realidad un artefacto que permite asignar, desde el proceso principal una función callback. En el siguiente paso, Ana decidirá que es lo que quiere hacer cuando termine la colada, es decir, asignará la función callback que se ejecutará cuando se obtenga el resultado del segundo proceso ejecutado por Bartolo.
3. Asignar callback
Cuando, gracias al segundo proceso, se haya calculado finalmente el valor, se ejecutará la función de regreso al que se le pasará como argumento el valor final obtenido. En el ejemplo tenemos la función «planchar la ropa» y el resultado del proceso: «la ropa lavada».
4. Resultado del futuro
La ejecución de las funciones callback con el valor final como argumento se hará dentro de lo que se llama un contexto de ejecución. Este no es más que un pool de hilos que permite independizar la ejecución de la función con el valor final tanto del hilo principal como del segundo proceso, es decir, se ejecutarán en un tercer hilo “reutilizable”. En el ejemplo que estamos siguiendo es Carlos (el hilo C) el que plancha la ropa.
Ejecución de la función callback con el valor del futuro
En la implementación del patrón que he propuesto a cada una de las funciones callback y de orden superior definidas en el interfaz futuro se le puede pasar un contexto de ejecución.
A grandes rasgos, esta es la esencia: el futuro permite configurar desde la ejecución principal que hacer cuando finalmente exista el valor. Y se hace sin tener que bloquear hilos porque sino arruinamos la asincronía.
Teniendo esto en mente y sin perder de vista lo simple de este concepto, base de todo, voy a ir añadiendo nuevos conceptos e ideas que nos permitirá ir completando la visión general del patrón.
Añadiendo una nueva capa a las funciones callback. El resultado de la ejecución de cualquier método puede ser, o bien su valor, o bien que su ejecución se haya saldado con un error, luego el resultado final que contiene un futuro puede ser:
¿Por qué no contemplar esta circunstancia con dos caminos? Un camino para cuando el valor sea correcto con su correspondiente función callback (el método onSuccess) y otro que nos permita definir otra función de regreso cuando se produzca un error (el método onFailure)
void onSuccesful( final Consumer<T> function, final Executor executor );
El argumento function es una función cuyo argumento es de tipo T (es el tipo del valor final del futuro) y resultado void.
function: T => void
Esta será la función que se ejecutaría cuando de resultado final del futuro ha ido bien.
void onFailure ( final Consumer<Throwable> function, final Executor executor );
En este caso el argumento function es una función cuyo argumento es un Throwable (la excepción que se reportaría si se produciría un error) y resultado void.
function: Throwable => void
Está será la función que se ejecutará cuando el futuro se haya solventado con un error.
Para dar respuesta a esta pregunta nos debemos fijar en que existan las dos cosas necesarias para la ejecución de la función: que exista la función y que exista el valor. Hay entonces dos posibilidades:
Es importante tener en mente que un futuro (“barra” promesa, esto lo explicaré más adelante), sólo se le puede asignar el valor una vez, además otra característica es que una función callback sólo se ejecutará una vez. Sin embargo se puede asignar al futuro, a lo largo del tiempo, todas las funciones callback que se deseen.
Si has llegado hasta aquí probablemente ya te habrá asaltado la duda: ¿Cómo se da valor al futuro? ¿Cómo se le asigna un valor? La respuesta: a través de la promesa.
Podemos decir que la promesa y el futuro son las dos caras de la misma moneda y que una promesa está relacionada con un futuro. La idea básica que debemos tener en mente es la siguiente:
Si volvemos al ejemplo anterior, será más sencillo de entender. Si recordamos el proceso principal llamaba a un método que permite en un segundo proceso calcular un valor de manera asíncrona en un tiempo indeterminado (puede ser antes o después). Mientras que el proceso principal tiene como herramienta al interfaz futuro que le permite indicar que es lo que se debe de hacer una vez se haya calculado el valor, el interfaz de la promesa será el instrumento que poseé el segundo proceso encargado de calcular el valor para asignar el valor a ese futuro. En síntesis Ana usaría el futuro y Bartolo la promesa.
Diagrama de flujo Promesa-Futuro
Diagrama de secuencia Promesa-Futuro
Si echáis un vistazo al código, podéis observar que sólo existe una implementación que implementa las dos interfaces: la promesa y el futuro.
La clase AlternativePromiseImp tiene un atributo que permite almacenar el valor del futuro. Este se asignará gracias a los métodos que expone el interfaz promesa AlternativePromise.
Existen dos atributos más en AlternativePromiseImp que son del tipo de cola FIFO (el primero que entra será el primero que sale). Permiten almacenar las funciones callback gracias a los métodos expuestos por el interfaz AlternativeFuture.
Una de las colas guardará las funciones que se van a ejecutar cuando mediante la promesa relacionada se asigne un valor correcto al futuro. Las funciones se van añadiendo a esta cola utilizando el método ‘onSuccesful‘ del interfaz AlternativeFuture.
La otra cola FIFO almacenará las funciones callback que se ejecutarán cuando la promesa relacionada se resuelva con un error. De la misma manera, se van añadiendo estas las funciones gracias al método ‘onFailure‘ del interfaz AlternativeFuture.
Bien cuando se asigna un valor a la promesa o bien cuando se añade una función callback al futuro se comprueba que existan los requisitos necesarios (la función y el valor del futuro). Si es así se ejecutará las funciones callback incluidas en la cola de callbacks con el valor final. Según se vayan ejecutando las funciones se eliminarán de la cola.
Se puede dar una vuelta de tuerca más y seguir añadiendo capas a la cebolla. El patrón Futuro/promesa permite adoptar un nuevo patrón funcional: la monada. Este artículo ya es lo suficientemente extenso, quizás con ya demasiados conceptos así que dejo pospuesto introducir la composición mónadica con AlternativeFuture y os emplazo a un siguiente post continuación de este.
«Tercer y último artículo sobre Akka explicado mediante ejemplos.
En los dos anteriores se basó en como funcionan la cola de mensajes de un actor, que es un router, como se envían mensajes entre actores. Después se trató temas como la supervisión y el bus de eventos.
Ahora me centraré en los actores tipados.«
Entrada anterior: Akka por ejemplos. Sobre supervisión, bus de eventos, …
Todo el código fuente relacionado con esta serie de posts está disponible en mi repositorio de GitHub
Los actores tipados son una funcionalidad que ofrece Akka recubriendo un actor no tipado en un interfaz java. Con un actor tipado el programador realiza llamadas a un método de una clase normal ‘sin preocuparse‘ (y pongo esto entre comillas por lo que veremos más adelante) de lo que está detrás es un actor de Akka.
![[Actor tipado]](/wp-content/uploads/2015/10/typedActor-peque.png)
[Actor tipado]
Permite unir los dos mundos, código java estándar con el mundo de los actores. En la documentación de Akka puedes leer que tienen su nicho, pero hay que ‘usarlos con moderación‘. Recomiendan que si lo que buscas es una arquitectura de alta escalabilidad utilizar estos actores no es la solución más sencilla. Por ejemplo en este caso, aunque se puede, no es tan natural la supervisión y la monitorización padre-hijo.
Para los actores tipados, Akka utiliza el patrón de Objetos Activos y proxys de Java. Para levantar un actor tipado es necesario una interfaz y una implementación. Simplificando, en los actores tipados no existe el método ‘onReceive()‘ y se utilizan como un clase más de Java haciendo llamadas a los métodos que exporta la interfaz.
En realidad lo que hay detrás es un actor no tipado. Akka monta un proxy en el que el interfaz será la fachada y el ‘contrato público‘ que podrá utilizar el resto del código java. Los atributos de los métodos de ese interfaz serán los mensajes que se enviarán al actor y la implementación será la que dicte el comportamiento. Por lo demás se cumple con el modelo de actores que asegurá que no habrá más de un hilo ejecutando el actor.
Todo esto, que haya un actor detrás de este interfaz, hace que tenga un comportamiento diferente al esperado en una clase java, y hay que tenerlo en mente cuando se utilizan actores tipados.
Para los ejemplos se ha utilizado una clase TypedActorDummyImp que implementa el interfaz TypedActorDummy con una serie de métodos sencillos que permitirán ver con facilidad el funcionamiento de los actores tipados.
He creado dos test, uno TypedActorDummyImpTest.java que comprueba el comportamiento en una llamada normal a un método con diferentes tipos de retorno y otro TypedActorDummyImpExceptionsTest.java para ver cual será su comportamiento si se produce una excepción.
Un método puede devolver tres tipos de respuesta: o bien es un método que no devuelve nada (void), o devuelve un objeto, o bien devuelve un futuro de objeto.
Cuando un actor tipado el tipo de respuesta es ‘void‘, lo que está ocurriendo es que se está mandando un mensaje del tipo dispara y olvida (‘fire-forget‘). En realidad se está enviado un mensaje ‘tell‘ al actor que hay por detrás, y no se espera respuesta.
Esto hace que tenga un comportamiento un poco ‘diferente‘ del esperado y es algo que se puede comprobar en los dos ejemplos.
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.typed.TypedActorDummyImpTest#testReturnVoidWithSleep test
Se comprueba que no se espera a la ejecución del método, sino que se continua inmediatamente con la siguiente orden. El mensaje se ha encolado al actor y este ejecutará la implementación en segundo plano, sin ningún tipo de espera en el hilo principal.
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.typed.TypedActorDummyImpExceptionsTest#testRuntimeExceptionVoid test
El test anterior permite hacer esta comprobación y es bastante didáctico.
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.typed.TypedActorDummyImpTest#testFutureEcho test
Por lo tanto la respuesta se recogerá cuando se resuelve el futuro y no desde la llamada al método. El hilo principal continuaría su ejecución sin esperar.
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.typed.TypedActorDummyImpExceptionsTest#testRuntimeExceptionFuture test
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.typed.TypedActorDummyImpTest#testEcho test
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.typed.TypedActorDummyImpExceptionsTest#testRuntimeExceptionString test
Por lo tanto desde la llamada al método de un actor tipado hace que hilo de ejecución principal espere la respuesta (aunque por detrás se esté enviando un mensaje ejecutándose en otro ‘hilo’). Por lo tanto el comportamiento es ‘el mismo’ al acostumbrado (ver el ejemplo 1). En este caso si se produce una excepción si será recogida en la llamada al método (Ver test 2)
Como conclusión final de esta serie de posts decir que aunque el modelo de actores y Akka presentan nuevos conceptos, estos una vez aprendidos son sencillos de asimilar.
A cambio ofrece un modo elegante y sencillo de codificar aplicaciones que soporten programación paralela que sean escalables, robustas y de alta disponibilidad.
Espero que os sirva.
Esta es la segunda entrega de Akka por ejemplos. La primera trató sobre cual es el funcionamiento de la cola de mensajes de un actor, que es un router y como se envían mensajes entre actores.
Ahora se tratarán temas como el control de fallos y la supervisión de actores, el bus de eventos de Akka y sobre los ‘Dead Letters’
Entrada anterior: Akka por ejemplos
Sin más vamos con los ejemplos.
Todo el código fuente relacionado con esta serie de posts está disponible en mi repositorio de GitHub
![[Supervisión padre-hijo en Akka]](/wp-content/uploads/2015/10/supervision-peque.png)
[Supervisión padre-hijo en Akka]
Se crea así una jerarquía en forma de árbol en la que la que los actores padres supervisan a los actores hijos. El actor ‘user‘ de Akka será el padre de primera generación de actores que hayamos creado.
Esto es realmente lo que te da la robustez (‘resilence‘) que un sistema reactivo necesita. Esta robustez se pierde cuando se intenta en vez de tener esta jerarquía, ir a un esquema con una mentalidad más tradicional de inyección de dependencias y se cae en la tentación de inyectar actores a otros actores.
Cuando un actor falla y se produce una excepción, su supervisor puede hacer, o bien reiniciar el actor, parar el actor, escalar la excepción o absorber la excepción y continuar con la ejecución.
El sistema de supervisión de Akka permite tener la posibilidad de diferente respuesta del supervisor dependiendo del tipo de excepción y si esta afecta a todos los actores supervisados o sólo al que ha fallado. Esto junto con lo anterior permite implementar fácilmente patrones, por ejemplo de tipo ‘circuit breaker‘, si uno de los actores falla.
Akka tiene la posibilidad de establecer eventos o disparadores en el ciclo de vida de un actor. Por ejemplo antes de crearlo, antes y después de reiniciarlo y cuando se para.
Ademas del concepto de supervisión, en Akka existe el de monitorización. Cualquier actor, puede ‘monitorizar‘ a cualquier otro, lo haya creado o no. El primero obtiene un mensaje ‘Terminated‘ cuando el monitorizado ha terminado. Esto permite modificar su comportamiento o cambiar su estado. En los ejemplos siguientes el actor supervisor también hace de ‘monitor‘ de sus hijos.
Para poder mostrar con ejemplos como es el comportamiento de las diferentes estrategias a seguir, he creado en el proyecto dos actores: ActorNoTypedDummyCheckLifeCycle y ActorNoTypedLetItCrash.
ActorNoTypedDummyCheckLifeCycle se utiliza para comprobar los eventos que se disparan y por los ‘estados‘ que pasa un actor cuando es supervisado con diferentes estrategias. Concatena en un atributo ‘state‘ los diferentes pasos por los ‘hooks‘ del ciclo de vida de un actor:
El actor ActorNoTypedLetItCrash es el que creará y hará de supervisor de ActorNoTypedDummyCheckLifeCycle. En su constructor, permite definir por parámetro la estrategia de supervisión. Su comportamiento será en de hacer de proxy en el envío de mensajes a ActorNoTypedDummyCheckLifeCycle hasta que este el actor hijo se pare o cuando el mismo se haya reiniciado.
Para mostrar el comportamiento de las diferentes estrategias y cual es el ciclo de vida especifico de los actores (cuando se llama a los diferentes ‘hooks‘) he codificado en el proyecto los siguientes ejemplos.
Test: ActorLetItCrashTestDefault.java
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.supervisorstrategy.ActorLetItCrashTestDefault test
Esta estrategia cobra sentido cuando se quiere mantener un sistema estable. La idea subyacente es que cuando se produce un error el sistema debería volver a un estado consistente y esto se consigue reiniciando el estado del actor.
En este ejemplo, los pasos son:
El ejemplo permite comprobar el flujo completo del paso de los diferentes eventos a lo largo de la vida del actor hijo. En este caso con la estrategia de supervisión por defecto, es este:
Se llama al constructor
=> Llamada a aroundPreStart
=> Llamada a preStart
=> [[exception]] Se provoca una excepción
=> Llamada a aroundPreRestart
=> Llamada a preRestart
=> Llamada a postStop
=> Llamada al constructor (Se vuelve a crear el actor)
=> Llamada a aroundPostRestart
=> Llamada a postRestart
=> Llamada a preStart
=> Llamada a aroundPostStop
=> Llamada a postStop
Test: ActorLetItCrashTestEscalate.java
Commando maven mvn -Dtest=com.logicaalternativa.examples.akka.supervisorstrategy.ActorLetItCrashTestEscalate test
El ejemplo puede ayudar a verlo más claro. En este caso se configura el supervisor (ActorNoTypedLetItCrash) para que la estrategia de supervisión sea la de escalar la excepción. Cuando se provoca una excepción en el actor supervisado, el resultado es el mismo que si se hubiera producido en el supervisor.
El este caso el supervisor tiene la estrategia de supervisión por defecto, que lo reinicia, volviéndose a crear el actor hijo.
En el test se comprueba este hecho cuando se valida todo el ciclo de vida del actor hijo. Se arranca y después de la excepción, se para, para después volver a arrancar sin reinicio. Esto último provocado porque al reiniciarse actor supervisor, el hijo se para y se vuelve a crear:
Llamada a constructor
=> Llamada a aroundPreStart
=> Llamada a preStart
=> [[exception]] Se provoca una excepción
=> Llamada a aroundPostStop
=> Llamada a postStop
=> Llamada al constructor (Se vuelve a crear el actor)
=> Llamada a aroundPreStart
=> Llamada a preStart
=> Llamada a aroundPostStop
=> Llamada a postStop
Test: ActorLetItCrashTestResume.java
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.supervisorstrategy.ActorLetItCrashTestResume test
El test ayuda a comprender este tipo de supervisión. Se comprueba que cuando se produce una excepción al procesar un mensaje, no se hace ninguna llamada a los métodos del ciclo de vida, ni tampoco se escala la excepción. El siguiente mensaje lo procesa correctamente.
El ciclo de vida del actor supervisado con este tipo de supervisión será:
Llamada a constructor
=> Llamada a aroundPreStart
=> Llamada a preStart
=> [[exception]] Se provoca una excepción
=> Llamada a aroundPostStop
=> Llamada a postStop
Test: ActorLetItCrashTestStop.java
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.supervisorstrategy.ActorLetItCrashTestStop test
En el ejemplo se fuerza esta situación. Si se provoca una excepción en el actor supervisado se comprueba que el actor no se vuelve a reiniciar. De hecho si se le vuelve a enviar un mensaje de estado, este se envía a la cola de ‘Dead Letters‘ porque la referencia al actor ya no apunta a un actor válido.
El ciclo de vida del actor es el siguiente:
Llamada a constructor
=> Llamada a aroundPreStart
=> Llamada a preStart
=> [[exception]] Se provoca una excepción
=> Llamada a aroundPostStop
=> Llamada a postStopTest: PublishSimpleSuscribeTest.java
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.bus.PublishSimpleSubcribeTest test
![[Bus de eventos de Akka]](/wp-content/uploads/2015/10/busEvent-peque2.png)
El paradigma cambia. En vez de enviar un mensaje a un actor concreto, es decir, “(Por favor) haz esto”, cuando se publica un mensaje en el bus se está diciendo “(A quien pueda interesar) ha ocurrido esto”
En este caso el ejemplo muestra un uso sencillo del bus de Akka para mostrar este patrón.
Se levantan dos actores suscriptores (del tipo ActorNoTypedLogEvent) que se suscribirán a mensajes de tipo Integer. La implementación de este actor es sencilla: registra los mensajes del tipo a los que está suscrito y si se le envía un mensaje ‘lastMessage‘ devolverá el último mensaje que ha registrado.
En el test después de levantar a los dos suscriptores se envía un mensaje al bus de Akka. Después se comprueba que el mensaje le ha llegado a ambos.
Test: DeadLettersTest.java
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.bus.DeadLettersTest test
Por defecto Akka informa en el log de la aplicación los dead letters que se producen (esto es configurable). También pública esta información a través del bus de eventos de Akka, lo que permite que una aplicación tenga la posibilidad de una gestión específica de estos mensajes perdidos.
En el ejemplo para poder provocar un dead letter se crea un actor del tipo ActorNoTypedDummy pararlo para a continuación enviarle un mensaje. Este mensaje ‘se pierde‘ y es recogido como ‘dead letter‘.
Por otra parte en el ejemplo se está utilizando un actor del tipo ActorNoTypedLogEvent configurado para que suscriba en el bus de eventos de Akka los mensajes del tipo DeadLetter.
Cuando se manda un mensaje de ‘lastMessage‘ al actor ActorNoTypedLogEvent este devolverá la información del mensaje perdido en forma de DeadLetter.
Como comprobación final del test se validará la información contenida en el objeto DeadLetter: el mensaje y la referencia al actor receptor.
Hasta aquí este segundo artículo de Akka por ejemplos. El próximo y último artículo de esta serie será sobre actores tipados.
Espero que os sirva.
«Akka representa muchos conceptos nuevos que al principio cuesta asimilar. Para poder entenderlo mejor, he ido creando, poco a poco, una serie de ejemplos que me han permitido comprender mejor el paradigma que conlleva.
![[Akkapor ejemplos]](/wp-content/uploads/2015/10/akkaExample.png)
Este artículo trata sobre esto, intentar tener una prueba de código de cada nuevo concepto que permita ver cual es su comportamiento y función.»
Entrada siguiente: Akka por ejemplos. Sobre supervisión, bus de eventos, …
Akka es un framework basado en el modelo de actores que permite dar solución al problema de la programación concurrente. Además de formar parte de Scala de manera nativa existe como librería en Java.
Permite diseñar aplicaciones que sean escalables horizontalmente de manera transparente, con alta toleracia a fallos y basada en eventos que permite cumplir el ‘manifiesto reactivo‘.
Este será el primer de una seríe de artículos explicando conceptos clave que se utilizan en Akka mediante ejemplos. En esta primera parte trataré como funciona las colas de mensajes de un actor, que es un router y las diferentes maneras de como se pueden enviar mensajes entre actores.
En próximas entregas trataré sobre el sistema de supervisión de los actores en Akka, como funciona el bus de eventos y que son los actores tipados.
Esta entrada es eminentemente práctica, te invito a descargarte el proyecto y a que eches un vistazo y ejecutes los ejemplos. Se entenderá mejor lo que quiero explicar en este artículo. Todo el código fuente relacionado con esta serie de post está disponible en mi repositorio de GitHub
La idea fundamental a la hora de realizar los test ha sido la de realizar implementaciones dummy y ‘ad hoc‘ y, gracias a ellas, montar test que permitieran ver con facilidad cual es el funcionamiento de la pieza que interesa.
Por otra parte, he buscado que el código incluido en los test puedan servir de ejemplo uando se quiera implementar ese mismo concepto en una aplicación real.
Es por esto por lo que he evitado utilizar el framework de Akka de test ‘akka-testkit’ y en algunos momentos puede parecer que me he complicado la vida realizando las validaciones cuando se completan los futuros y utilizando agentes de Akka para compartir estados entre actores.
Mucha de la funcionalidad común a todos los actores, como crear el sistema de actores y métodos de utilidad se ha llevado a test base (TestBase y TestBaseTypedActor ) de los que heredan todos los test.
Ya que en los test utilizo agentes, antes de entrar a explicar los test, intentaré hacer una breve introdución de lo que es un agente en Akka.
Un agente de Akka permite almacenar un valor y actualizarlo sin problemas de concurrencia. Tienen la particularidad que la actualización se realiza de manera asíncrona, pero se puede leer el valor de manera síncrona.
Su funcionamiento es similar a un mailbox de un actor. Se basa en encolar los nuevos valores de tal manera que el valor interno se va actualizando en orden de llegada. No existe concurrencia y por eso su actualización es asíncrona.
Hay que tener en cuenta que cuando se pide su valor de manera síncrona devuelve el valor ‘actual‘ no el valor ‘futuro‘ que tendrá cuando se procesen todos los valores encolados hasta ese momento.
Vamos entonces con los test.
Test: ActorQueueTest.java
Commando maven: mvn −Dtest=com.logicaalternativa.examples.akka.queue.ActorQueueTest test
![[Un actor, un mailbox]](/wp-content/uploads/2015/10/maibox-e1444336153949.png)
Un actor, un mailbox
En este ejemplo se está levantando dentro del sistema de actores, un actor del tipo ActorNoTypedDummy. Este tiene una lógica muy sencilla: si se envía un mensaje tipo Long la ejecución se espera los milisegundos indicados en el valor del mensaje. Si el mensaje es de tipo String devuelve un eco del mensaje.
En el test ActorQueueTest se envía un primer mensaje tipo Long para que se realice una espera y después 10 mensajes de tipo String.
En en la ejecución del test, se puede observar de que aunque se envían todos los mensajes sin esperar la ejecución del actor, en realidad estos se encolan. El actor no procesa el siguiente mensaje hasta que no ha terminado la ejecución anterior.
El resultado es que los mensajes son procesados por orden de llegada ya que este actor tiene la implementación por defecto de ‘mailbox‘ (existen otras implementaciones que permiten prioridades de mensajes). Con lo que realiza la espera del primero de ellos y después el eco del resto.
En este test para comprobar el orden de los mensajes que se están ejecutando en el actor se está utilizando un agente de Akka para guardar el estado de manera asíncrona. El agente almacena la concatenación de los mensajes tipo cadena que se envían al actor.
Para verificar que el orden de los mensajes enviados es el mismo orden de los mensajes que se han procesado se comprueba que estas dos cadenas son iguales.
Test: ActorQueueRouteRoundRobinTest.java
Commando maven mvn −Dtest=com.logicaalternativa.examples.akka.queue.ActorQueueRouteRoundRobinTest test
Se basa en el mismo concepto que tenemos todos en mente de que es un Router: un frontal al que se envían los mensajes y que se encarga de reenviarlos a sus ‘routees‘ para que estos los procesen y devolver la respuesta.
Permite un procesamiento en paralelo mayor, al existir más instancias de un actor, pero con la comodidad de tener una referencia única a la que enviar los mensajes.
![[Concepto de router]](/wp-content/uploads/2015/10/router-peque.png)
Router
El ejemplo levanta un sistema de actores. Se crea un router de 5 actores del tipo ActorNoTypedWhoIam. Este actor tiene una implementación muy sencilla. Se limita a responder en un Map con el mismo mensaje que le envían y su nombre de actor.
Al router se le envían 10 mensajes. En la resolución de cada futuro de respuesta se comprueba que el mensaje es el mismo que se ha enviado. Por otra parte, gracias a la nombre del routee, se guarda la información de que routee ha procesado el mensaje.
Por último se comprueba que a cada actor del grupo del router le ha llegado el mismo número de mensajes (estrategía de envío RoundRobinPool). En este caso son 2 ya que el router lo forman 5 actores y se mandan 10 mensajes.
En las trazas se puede comprobar que el actor con el nombre ‘a‘ le llegan los mensajes ‘0‘ y ‘5‘, al ‘b‘ el ‘1‘ y el ‘6‘ y así sucesivamente.
Test: ActorProxyTest.java
Comando maven mvn -Dtest=com.logicaalternativa.examples.akka.message.ActorProxyTest test
Por otra parte un actor puede crear otros actores a los que necesita enviar mensajes. Es muy común que existan actores cuya tarea sea la de orquestar o supervisar el trabajo de los actores que ha creado (‘actores hijos’), y que una parte de esta tarea sea la de reenviar a sus hijos los mensajes que les llegan. Para estos cosos es muy útil utilizar la función ‘forward‘
El ejemplo se crea un actor ActorNoTypedProxy que crea un actor hijo del tipo ActorNoTypedDummy. Recordemos que este último devuelve un echo de los mensajes que se le envían.
ActorNoTypedProxy hará de proxy para mostrar las diferentes formas de enviar y reenviar mensajes entre actores. Recibe los siguientes mensajes tipo cadena:
Commando maven test 'forward' mvn -Dtest=com.logicaalternativa.examples.akka.message.ActorProxyTest#testForward test
Comando maven test redirect mvn -Dtest=com.logicaalternativa.examples.akka.message.ActorProxyTest#testRedirectMessageToChild test
![[forward o 'redirect']](/wp-content/uploads/2015/10/forward-peque.png)
forward o ‘redirect’
Comando maven test 'future' mvn -Dtest=com.logicaalternativa.examples.akka.message.ActorProxyTest#testFutur test
Al ser este un futuro, si fuera necesario, se puede desde el actor que hace de proxy, operar con él o realizar cualquier tipo de transformación. Por ejemplo se puede registrar un callback, realizar alguna transformación operando con el de manera funcional, etc…
Para simplificar en el test se espera el resultado de la respuesta y como esta también es un futuro, se espera también a este para obtener el resultado.
Comando maven test 'await' mvn -Dtest=com.logicaalternativa.examples.akka.message.ActorProxyTest#testAwaitFutur test
En el actor proxy realiza la misma llamada ‘ask‘ y a continuación se utiliza la función ‘Await‘ que espera la resolución del futuro. Se obtiene así un comportamiento bloqueante y síncrono de petición-respuesta.
Hasta aquí llega esta primera parte de esta serie de artículos centrados en explicar como funciona Akka con ejemplos. Conceptos como la supervisión entre actores, el bus de eventos y que son los actores tipados serán material de futuras entregas.
Espero que os sirva.
Entrada siguiente: Akka por ejemplos. Sobre supervisión, bus de eventos, …
“Este artículo trata sobre la importancia de las pruebas de robustez y de rendimiento y su relación directa con la calidad del software, y lo importante que es medir y representar los datos en una gráfica.
Un caso práctico, un sistema de cache PHP simpe basado en almacenamiento en ficheros. En teoría lento ¿verdad? ¿pero lo has comprobado?”
Cachear no es que sea nuevo, pero si está de rabiosa actualidad. El cacheo es una técnica fundamental dentro de los paradigmas de escalabilidad y rendimiento que se están implementando en la actualidad. Sus ventajas son claras a la hora de evitar tráfico en los cuellos de botella de una arquitectura, típicamente la base de datos. Las arquitecturas con cache compartida (con sistemas como Memcached o a otro nivel Redis) y colas de mensajes pasan a ser “la nueva forma” de hacer las cosas.
Está presente también en las tendencias actuales de arquitecturas basadas en microservicios. Algunas siguen la máxima “cache everything” (“Cachea todo lo que se mueva..” 🙂 )
Y a otro nivel, también hay un debate abierto con la movilidad y en el que ha entrado de lleno Linus Torvalds (1). Defiende que añadir más procesamiento en paralelo (más cores a los procesadores de los móviles) no es la solución y que las caches grandes son eficientes.
El cache también tiene sus problemas intrínsecos complejos. Por ejemplo, la invalidez de los valores cacheados. Si no se hace correctamente se puede trabajar con datos ‘antiguos’ y perder información. Problema antiguo… Martin Fowler (2), ha hecho famosa la cita de Phil Karlton
“There are only two hard things in Computer Science: cache invalidation and naming things.”
El objetivo de este post no es tan ambicioso como para meterse de lleno en este problema. En su tiempo para el post “Dar valor a los tweets: Interés, difusión, audiencia,… trasteando con el API de Twitter” necesitaba una librería para cachear los resultados del api de Twitter. Me decanté la librería php-cache de Emilio Cobos, me pareció sencilla, fácil de utilizar y configurar y suficiente para lo que necesitaba. Desde entonces llevo usándola también en otros proyectos.
El almacenamiento en memoria es lo más rápido para una cache. Esto, que en Java es sencillo de implementar, basta con almacenar el valor en un atributo estático de una clase para que este accesible en todos los hilos de ejecución, en PHP es necesario usar extensiones externas al core de PHP o utilizar memoria compartida. Esto último honestamente no creo que sea lo más se adecue dentro de este contexto en donde lo que busqué es la máxima sencillez.
![[Cache]](/wp-content/uploads/2015/01/cache.png)
La finalidad de la librería es tener un sistema de cache sencillo sin necesidad de instalación de extensiones como apc ni ni servicios como memcache. Tan sólo es necesario que el usuario del apache tenga permisos de escritura, cosa que es lo más común. Por esto es ideal para “alojamientos compartidos” de páginas web.
Su funcionamiento similar a otras librerías de este tipo. Está basada en la serialización de las variables, y su almacenaje en ficheros de texto. El código fuente es sencillo, ordenado y muy fácil de seguir.
Después de decirme a usarla y ver como funcionaba, me surgieron dos dudas. En su momento, en anteriores proyectos, tuve problemas de concurrencia en PHP cuando más de un proceso leía/escribía en el mismo fichero a la vez. Además que el acceso a cache tuviera acceso a disco «¿cuánto estaba penalizada la velocidad este motivo?»
Estas dos preguntas fueron la excusa para adentrarme en el mundo de las pruebas de rendimiento y de robustez. Otra pata importante dentro del desarrollo que aporta valor a la calidad del software. El resultado de todo esto está reflejado en lo que viene a continuación.
Adelanto que propuse unos cambios en el código y Emilio Cobos a tenido a bien aceptar mi ‘pull request‘, por lo tanto he pasado a ser un humilde, pero a la vez orgulloso contribuidor de php-cache.
php-cache utiliza para cada clave de la cache un fichero donde almacena el valor «serializado«. Para probar la concurrencia cuando varios procesos leen/escriben en una misma clave de la cache diseñe dos test.
El primero de ellos, robustness-rw.test.php, lanza 10 procesos concurrentes, simulando 10 clientes ejecutando las mismas operaciones a la vez. Cada uno de ellos graba un valor en una clave de la cache y a continuación obtiene el valor de la misma clave de la cache. Estas dos operaciones las realiza cada proceso 50 veces (un total de 500 operaciones de escritura/lectura en total) cambiando cada vez el valor grabado de 3 posibles.
El valor obtenido de la cache tiene que ser igual a alguno de los tres valores posibles. Si es diferente o es nulo el valor se considera como invalido.
El segundo de los test de robustez, robustness-rw2.test.php es similar al anterior. En este caso además de guardar y obtener el valor se realiza una tercera operación de borrado de la clave de la cache. En este caso, el valor obtenido de la cache tiene que ser igual a alguno de los tres valores posibles o nulo. En cualquier otro caso se considera como inválido.
Los dos test están el directorio test repositorio principal de la librería ya que estaban incluidos en el ‘pull request‘ aceptado. En el README.md del directorio test está explicado más en profundidad lo que hacen y como se lanzan.
¿Cómo simular los clientes/peticiones concurrentes? Hay que tener en cuenta que el soporte multihilo no viene habilitado en una instalación tipo de PHP. El esquema que he seguido para simular la concurrencia he seguido en el paradigma de “modelo de actores”.
El script principal (actor principal) se encarga de lanzar los demás actores (procesos secundarios). En este caso son procesos PHP, en realidad una copia del mismo test que tiene un comportamiento diferente si “actúa” como actor secundario. Los secundarios se encargan cada uno de de hacer las 50 peticiones de escritura/lectura o escritura/lectura/borrado en una misma clave común.
Una vez lanzado los actores secundarios, el principal espera a que todos terminen para recoger los resultados y calcular la información estadística de los errores que se hayan podido producir.
Los mensajes entre el actor principal (el proceso) y el resto de actores (los procesos secundarios) los he montado utilizando también la librería php-cache.
Este es el flujo seguido:
![[Concurrencia utlinzando modelo de actores]](/wp-content/uploads/2015/01/actores.png)
Los mensajes son inmutables, los actores secundarios sólo escriben en la clave asignada y el principal sólo lee las claves que ha asignado.
Al lanzar los test de robustez comprobé que en estos casos extremos de concurrencia la librería podía devolver la lectura de datos corruptos.
Hice una pequeña modificación en el código. Ahora siempre que se almacena un valor de una clave se escribe en un archivo temporal. Si la escritura es correcta, el fichero temporal se renombrará al definitivo utilizando la función rename de PHP. Esta función, es atómica si se realiza en el mismo sistema de ficheros. Este es el caso ya que se trabaja en el mismo directorio.
Volviendo a lanzar los test con este cambio ya no se obtienen datos corruptos y tanto la lectura se ejecutan sin errores.
Después de hacer un ‘fork‘ del repositorio y propuse los cambios lanzado un ‘pull request‘. Esta petición ha sido aceptada y los esta modificación está ya en el repositorio oficial de php-cache en GitHub
php-cache es una librería basada en lectura/escritura de ficheros, así que su velocidad depende de lo rápido que sea el acceso a disco y su velocidad de lectura.
En el repositorio de GitHub he subido un pequeño script (benchmark.test.php) que permite realizar medidas del acceso a un valor de la cache y cual sería el tiempo medio por respuesta.
Además como referencia se calcula el valor medio que se tarda en recuperar el objeto de su representación en cadena cuando sus datos están en memoria sin acceder a disco. Es decir, el valor teórico ideal que se alcanzaría si el coste de tiempo de acceso a disco fuera cero.
La información que devuelve el test es tanto el coste real como el teórico, número de peticiones realizadas, tiempo total y las estadísticas con datos sobre la media de milisegundos que ha tardado en hacer una petición y el cálculo de las peticiones por segundo.
Las conclusiones se pueden pueden ver de las siguientes gráficas:
En la primera (Gráfica 1) se muestra la información de los datos de las peticiones por segundo de los dos procesos, el real y el teórico. Si se observa con atención, para objetos de poco peso el valor del número de peticiones es muy dispar entre las dos gráficas. Sin embargo, según va aumentando el peso del objeto guardado en cache, los dos valores se acercan hasta que casi el valor real es igual al ideal … Pero « ¿por qué puede pasar esto?»
Para poder poner un poco de luz en el asunto he creado la Gráfica 2. Se muestra la velocidad en MB por segundo en obtener el objeto. Una de las líneas es la velocidad de las peticiones reales, otra es como sería el calculo ideal y la línea amarilla es la velocidad que tarda en leer de fichero, es decir el tamaño del objeto dividido por la diferencia de los dos tiempos (real menos teórico).
Se puede observar, que mientras las velocidades de los procesos teórico y real tienden a ser constantes, la velocidad de lectura crece. En proporción, cuanto más grande es el objeto menos tarda en leerlo.
Con los objetos más grandes, al ser el proceso de lectura mucho más rápido que el proceso de «des-serialización«, el peso del primero pasa a ser despreciable en comparación con el segundo. Es la velocidad del proceso más lento (la «des-serialización«) la que marca la velocidad al obtener un valor de la cache.
La librería php-cache también tiene la posibilidad de guardar los datos en «crudo» sin serializar para almacenar cadenas, por ejemplo, para cachear la salida html directamente. Las siguientes gráficas (Gráficas 3 y 4) son los datos obteniendo un valor de la cache en «crudo«. Muestran mejor a la conclusión que quiero llegar.
En este caso la velocidad de lectura aumenta según lo hace el tamaño del objeto a leer y tiende a un máximo.
Y vuelvo a repetir «¿Por qué pasa esto?» Sorprendente, …o no tanto. La respuesta es que el sistema operativo viene al rescate y entra en acción el buffer cache del disco (3).
El acceso a disco es mucho más lento que el acceso a memoria. El buffer cache del disco del sistema operativo sirve de colchón amortiguador de esta diferencia de velocidades de acceso. Mantiene en memoria (cache, …su cache) aquellos datos que leen la misma parte del disco varias veces durante periodos relativamente cortos de tiempo. Con respecto a este punto también he hecho pruebas realizando un sleep de dos segundos entre peticiones y la velocidad era la misma por lo que el los datos se conservaban en el buffer.
Recordar que este buffer no realiza cache de archivos, pero sí de bloques. Cuantos más bloques del fichero están en cache más rápido será la lectura y también añadir que el buffer de lectura de disco es transparente y lo gestiona el sistema operativo.
Resumiendo, cuanto mayor sea el tamaño del objeto a cachear y mayor sea el número de lecturas, php-cache pasa de ser un sistema cache basado en disco, «a priori» lento, para convertirse de «facto» en un sistema de cache basado en memoria y pasar a ser rápido. Y recordemos que estas circunstancias, objetos grandes y costosos de calcular con cierta carga de lectura, son precisamente una de las razones por las que se valora adoptar un sistema de cache.
Siempre que se evite la optimización prematura evitando complicar innecesariamente el software (optimizar es un vicio, cuando se empieza no se sabe como parar), las pruebas de robustez y de rendimiento pueden ser unas herramientas muy útiles.
Permiten valorar como se comportará el producto que estás desarrollando o como lo hará el que estás pensando en adoptar… Sabemos que en muy pocas ocasiones los errores que surgen en un entorno de producción son reproducibles, pero que duda cabe que estas pruebas dan un plus de confianza en el software desarrollado. Y puede, como en este caso concreto, que te lleves una sorpresa para bien y se comporte mucho mejor de lo que en un principio podías esperar.
Otra conclusión, siempre que se mide se debe dibujar. Es importante reflejar los datos en un gráfico. Esto ayuda a vislumbrar una tendencia en los datos y obtener respuestas.
Y por último romper una lanza en favor de PHP. En algún sitio he leído que si «PHP fuera un arma se podía comparar con la manguera que pones al escape del coche para intentar suicidarte«…
No pienso así, PHP es un lenguaje al que tengo especial cariño y su simplicidad y potencia está demostrada con esta clase php-cache. Con unas pocas líneas tienes un sistema de cache muy competente y fiable que puedes usar sin problemas en proyectos sencillos y en el que puedes almacenar un montón de valores en la cache… tantos como espacio tengas en el disco duro.
Espero que os sirva.
… segunda Parte de TDD is dead? … o yo y el TDD
![[Mock y test]](/wp-content/uploads/2014/10/mockAndTest_p.png)
Este es el segundo y último artículo de la serie que completa el anterior post TDD is dead? … o yo y el TDD.
Trataré de explicar como defino y codifico mis propios objetos ‘mock‘, y de como los uso tanto para pruebas unitarias, como también en pruebas de integración entre clases.
Y siendo más especifico mostrar como se pueden codificar tres tipos de mock utilizados habitualmente:
Y como dijo el maestro:
“… hablar es barato, vamos a ver un poco de código…”
Para ilustrar el ejemplo utilizaré una aplicación web que mediante un formulario html sencillo llamará con ajax a un servicio REST. Consiste en dar de alta códigos de promoción de una web.
![[Pantallazo de la Demo Ejemplo Mock]](/wp-content/uploads/2014/10/pantallazoEjemploMock.png)
[Pantallado de la demo]
La demo es completamente operativa y se puede usar. Se puede descargar el código aquí:
![[Logo GitHub]](/wp-content/uploads/2013/09/GitHub-Mark-32px.png){kind=small}
MoksExample en GitHub
Los detalles de como funciona y como se puede probar están en el archivo README.md
La parte de servicios REST es Java, montada sobre Spring. En el ecosistema de Spring, Spring-Data es el mediador con la capa de persistencia de datos. En el ejemplo se usará como interfaz con la base de datos. Como framework de tests unitarios usaré Junit. Maven será la herramienta de compilación, ejecución de test y construcción del proyecto. Como es una demo para estos fines se usa Hsqldb, base de datos en memoria.
En la demo existen dos entidades PROMOTION y PROMOTION_CODE. La primera es el maestro de promociones y en la segunda se almacenarán todos los códigos de promoción relacionados con las primeras. Los objetos de negocio que las definen son los beans: Promotion y PromotionCode
Spring-Data se basa en el patrón repositorio. A grandes rasgos y simplificando, Spring-Data implementa la interfaz de las operaciones CRUD y el resto de consultas que se pueden realizar para cada entidad de la capa de persistencia (usualmente una tabla de una base de datos).
Existen por tanto dos interfaces definidos en el pakage com.logicaalternativa.ejemplomock.repository cuya misión es definir las operaciones CRUD de las entidades
En este caso los dos extienden del interfaz de Spring-Data JpaRepository.
Con Spring-Data sólo tienes que definir la interfaz con las diferentes operaciones de consulta, inserción y modificación que se van a realizar de la entidad y este se encarga de implementar la interfaz. Esto hace que resulte muy fácil codificar tus propios mocks. Después para los test se inyectarán por inversión de control al objeto de negocio.
Para los test he implementado los dos mock de cada uno de los interfaces. Están en el package com.logicaalternativa.ejemplomock.repository.mock .
Las dos clases son muy similares y siguen la misma línea. Sólo se ha implementado las operaciones necesarias para realizar los test. La idea es esa codificar sólo lo estrictamente necesario. Se añadirá o se modificará código cuando toque, si para un futuro test es necesario implementar algún otro método más.
Centrándome por ejemplo en el mock PromotionCodeRepositoryMock, el ‘quid de la cuestión‘ está en que he definido un atributo lista de tipo PromotionCode.
1 2 3 4 }
Este es accesible mediante los métodos públicos:
1 2 3 4 5 6 7 }
He codificado los métodos CRUD para que operen con esta lista. Por ejemplo, así he codificado el método que sirve para obtener un código de promoción a través de su clave primaria.
01 02 03 04 05 06 07 }08 09 }10 11 }
Que lo que hace es encontrar el índice de la lista de códigos de promoción con el mismo email. Si lo encuentra devuelve una copia de ese objeto. Para entrar más en detalle te invito a revisar los métodos findIndex, clone y el resto de métodos que he implementado de PromotionCodeRepositoryMock
Otro ejemplo es el método saveAndFlush:
01 02 03 04 05 06 07 08 }09 10 11 12 13 14 15 }16 17 }18 19 }
Que busca en la lista el objeto con el mismo email. Si lo encuentra actualiza el objeto de la lista y sino, lo añade a la lista.
El test AddCodeBusinessImpTest prueba el objeto de negocio AddCodeBusinessImp.
La clase de negocio (AddCodeBusinessImp) comprueba que existe el código de promoción en la BBDD y utiliza para ello PromotionRepository. En el método setUp() del test se inicializa un objeto PromotionRepositoryMock con el objeto Promotion deseado y este mock se inserta por inversión de control a la instancia de AddCodeBussinessImp.
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 }21 22 }
promotion, promotionRepositoryMock, addCodeBusinessImp son atributos privados de AddCodeBusinessImpTest.
Internamente AddCodeBusinessImp llama al método findOne de PromotionRepository con el identificador de la promoción (el del maestro de promociones) del nuevo código que se quiere insertar.
Si queremos testear que ocurre si no encuentra la promoción en la BBDD, simplemente se hace lo que en el método testPromotionNotBbDd de AddCodeBusinessImpTest:
01 02 03 04 05 06 07 08 09 }10 11 }
Si la lista de promociones en PromotionRepositoryMock es nula no se podrá encontrar la promoción (El método findOne devolverá nulo).
En este mismo test también se utiliza PromotionCodeRepositoryMock. Inyectado también por inversión de control a la instancia de AddCodeBusinessImp, en este caso, sirve para comprobar que se ha insertado el código de promoción. Se hace en el test testOk
01 02 03 04 05 06 07 08 09 10 11 ;12 13 }14 15 }
Para tener una visión más clara de cual es la idea, lo mejor es revisar cada uno de los test Junit de AddCodeBusinessImpTest Creo que puede ser de gran ayuda para tener una visión global de lo que quiero plantear . He intentado que sean claros y autoexplicativos.
Lo que interesa en este caso es comprobar que un objeto de negocio hace la llamada a un interfaz con los datos correctos. Lo que se hace es ‘mockear‘ esa interfaz capturando los datos de la llamada para comprobar después de que estos son correctos.
En la demo existe un objeto de negocio, SendMailCodePromotionImp, que a partir de una dirección de correo manda el código de promoción por email. Este objeto de negocio realiza internamente una llamada a la interfaz JavaMailSender que implementa Spring (JavaMailSenderImpl) para enviar el correo electrónico.
JavaMailServerMock, que implementa también el interfaz JavaMailServer, es el mock que va a recoger los datos de la llamada. En este caso sólo me interesaba saber la dirección de correo a la que se envía el correo electrónico. Para ello he implementado el método send:
01 02 03 04 05 06 07 08 09 10 11 12 13 }14 15 }16 17 18 19 }20 21 22 }23 }
Se recoge del argumento de entrada la cabecera “To” para almacenarla en un atributo de la clase.
En el test SendMailCodePromotionImpTest se utiliza este Mock. En el método setUp(), se instancia y se inserta por inversión de control al objeto SendMailCodePromotionImp.
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 }17 18 }
El test testOk de SendMailCodePromotionImpTest sirve como ejemplo para comprobar si se ha realizado correctamente la llamada:
01 02 03 04 05 06 07 08 09 10 }11 12 }
Donde después de hacer la llamada al método sendMailCodePromotion del objeto de negocio se obtiene el atributo de sendTo del mock para comprobar que se envía a la misma dirección de correo electrónico.
En este mock sólo se comprueba la cabecera ‘To‘. También se podría comprobar el texto del mensaje o cualquier otro dato enviado desde el objeto de negocio.
En la demo he codificado MessageSourceMock que implementa el interfaz MessageSource, utilidad que tiene Spring para la internacionalización. Este mock sólo me interesa para poder probar otras funcionalidades. Ha sido necesario codificado porque el objeto de negocio lo necesitaba, pero, en este caso, el resultado de su llamada era irrelevante. Solamente se ha codificado el método getMessage :
1 2 3 4 5 6 }7 8 }
Que como puedes comprobar, devuelve directamente la entrada.
En el test SendMailCodePromotionImpTest se utiliza este Mock. En el método setUp()Se instancia y se inserta por inversión de control al objeto
SendMailCodePromotionImp.
01 02 03 04 05 06 07 08 09 10 11 12 13 14 }15 16 }
Ya ahora al hacer la llamada getSendTo del objeto de negocio no aparece la tan temida NullPointerException 😉
Como se puede ver, con un poco de ingenio es relativamente sencillo crearte tus propios objetos mock sin tener que recurrir a Frameworks. La creación de los mock me ayudan a comprender mejor como funciona la aplicación y ver las clases involucradas como verdaderas cajas negras. Esta es la gracia del paradigma de la orientación a objetos.
No necesariamente tiene que llevar demasiado tiempo el codificarlos. Sólo se debería ‘picar’ lo que necesitas cuando lo necesitas y mucho es reaprobechable. Al final del proyecto seguro que tienes un buen juego de objetos mock para pruebas.
Otra ventaja, es que no hay reflexión, no existe bbdd en memoria para los test, ni ha sido necesario levantar un entorno para pruebas… el resultado es que los test van ‘volaos‘.
P.D.: Para esta demo, de esto que te vas liando y liando… y poco a poco me ‘currado’ un framework MVC hecho en JavaScript. Cuando lo organice un poco será material para próximos post.
Antes de vacaciones escribí el siguiente artículo en el blog de Civitana.org
[Firma electrónica fácil de usar] ( http://blog.civitana.org/2014/08/11/firma-electronica-facil-de-usar/)![[Firma digital fácil de usar]](/wp-content/uploads/2014/09/baner.png)
“Test-driven development (TDD)”, en la lengua de Cervantes “Desarrollo guiado por pruebas”… Palabras malditas para algunos… Últimamente se dice que está muerto… “TDD is dead?”.
Actualización:
La segunda parte de este artículo es «Mocks… o el TDD y yo»
A grandes rasgos, consiste en primero diseñar y realizar los test de una determinada funcionalidad (lo usual es una clase de negocio). En este punto los test no pasan => Test ‘en rojo‘.
![[Esquema TDD]](/wp-content/uploads/2014/07/tdd.png)
A continuación se codifica, centrándonos en que pasen todos los test. Una vez que todos están ‘ok’ (Test en ‘verde‘) se refactoriza el código. Se da un repaso final para que quede todo correcto y pulir los flecos que quedan.
Estos test serán siempre independientes. No debe importar el orden en que se lancen. Se añaden a la herramienta de integración continua para que se pasen en cada compilación/build y asegurarse así que no ha habido ‘efectos colaterales’ en cada modificación de código fuente.
Si partimos de este enfoque ¿es todo ‘testeable‘? ¿Se ve condicionado tu diseño del software poder hacer este tipo de pruebas? ¿Cuanto tardan tus test? ¿Es asumible este tiempo?
Todo esto y más argumentos se han puesto encima de la mesa. Hay quien opina que que en el TDD puro sólo es para entornos académicos y blogs y que en el mundo real no se puede llevar al extremo. Hay pruebas que no se pueden replicar tan fácilmente y que dependen de un entorno desplegado (terceros sistemas).
Tampoco es recomendable que se condicione el diseño y la arquitectura para poder realizar los test. Debe ser al contrario los test se deben adaptar al diseño.
El TDD se basa en pasar continuamente los test, por lo tanto deben ser lo más rápidos posible. En algunos casos el tiempo de lanzar toda la batería de test no es despreciable. En este punto los Frameworks de ‘mock‘ basados en generación de clases por reflexión están en el punto de mira.
Y a pesar de todo esto, esta forma de desarrollar me ha hecho la vida más sencilla. Lo intento explicar:
He llegado a esta metodología tarde. No fue hasta que empezando con un proyecto desde cero, que me puse en serio a seguir este paradigma. Mi conversión ha sido tal, que confieso que ahora ya casi no sé prescindir de los test al enfrentarme a tirar código. Primero me planteo los tests y después implemento. Aunque esto no es siempre así, tengo bastante flexibilidad.
Si tengo claro ‘lo que hay que hacer‘ hago todos del tirón. Repaso todos los casos de uso, las posibles entradas, salidas y los errores y cada caso lo reflejo en un test. En estos casos lo más normal es que tarde más en diseñar los test que en codificar. El proceso es, de manera iterativa, terminar una parte de la codificación e ir pasando los test, hasta que no quede ninguno con error y la funcionalidad esté terminada.
En los casos que no tengo tan claro lo que tiene que hacer la clase, quizás porque, por ejemplo, tenga que ‘repartir’ la responsabilidad en otra clase, empiezo realizando los test que si tengo claro, validando entradas y resultados parciales. Codifico y logró que se pasen los test. Me replanteo o no la estructura y vuelvo a codificar los nuevos test y terminar de implementar la parte que queda. Todo también de manera iterativa.
En cualquier caso siempre habrá uno o varios test con las entradas y la salida correctas. Los pongo al principio de la clase de test y me sirve de documentación. De un vistazo se puede saber el comportamiento y el control de errores realizado.
Para poder realizar los test ‘mokeo’ las clases que necesito para probar la funcionalidad. Empecé realizando mis propios objetos Mock porque no quería que mi foco se perdiera en el aprendizaje de un nuevo Framework de ‘mokeo‘.
En la arquitectura en la que suelo trabajar Spring y Spring-Data para acceso a base de datos, en lo que todo es un interfaz, es supersencillo crear el Mock que genere la salida que necesitas. Estos objetos son reaprovechables, ya que en un proyecto normalmente las clases están relacionadas, y utilizas el mismo Mock para varios test.
Esto en realidad no va en contra de ‘la máxima‘ de que los test no puede ser un desarrollo en sí, ya que ‘sólo codifico la parte que necesito‘. Si en un segundo test necesito más funcionalidad completo el comportamiento del Mock.
Resulta que después, leyendo post como este («When to mock«) en el Blog de Uncle Bob Martin me di cuenta que no iba tan mal encaminado.
Estoy preparando un segundo artículo donde intentaré explicar con ejemplos como hago los ‘mock‘.
Sobre todo una nueva visión de enfrentarme al desarrollo, para mi más enriquecedora. Ahora lo primero que pienso son los parámetros que voy a pasar a la clase y que salida quiero obtener. Valoro que entradas podrían causar error y como quiero realizar este control de errores. Esto hace que tenga una idea mucho más clara de lo que va hacer la clase y de que parte de la funcionalidad va a ser responsable.
Para simular la base de datos utilizo mis propios ‘mock‘ implementando los interfaces de Spring-Data y no uso una BBDD en memoria. Esto también me ha ayudado a entender mejor que datos necesito y tener mucho más claro el modelo.
He ganado en seguridad. Casi consigo que el 100% del código sea testeable. Gracias a los test estoy seguro de que se ha pasado por cada uno de los ‘if’ del código.
Es significativo que ahora uso mucho menos el ‘debug‘ para saber que está fallando y corregir errores. Puede resultar paradójico pero en muchos casos, con los test consigo comportamientos que es difícil de obtener para obtener el mismo resultado en una prueba de integración. Normalmente hago pocos ajustes en el código cuando lo pruebo desplegado en un servidor de aplicaciones, contra una base de datos de verdad, …
Tengo menos bug y más control de la interrelaciones que tiene el código. Si hay alguna modificación de uan parte del código que afecta a otra, los ‘test’ pueden evitar muchos de estos problemas de interrelación. Problemas que suelen surgir, ‘como siempre pasa’ (ley de Murphy), en producción.
Como contrapartida se tarda más en el desarrollo y el proceso de generación de los test no es ‘tan divertido‘ como puede parecer. De todas maneras las ventajas que he obtenido me salen a cuenta y doy el tiempo por bien invertido.
Realmente en mis proyectos, y a pesar de integrarse con más de un sistema de terceros no he tenido muchos problemas en generar los test. No he sentido que el diseño del software se haya visto condicionado.
Al hilo de esto, estoy acostumbrado a trabajar con Spring y su inversión de control. Hay quienes le ‘chirría’ tener que definir un interfaz aunque sólo haya una implementación. A mí definirlo me parece más limpio indicando así el api pública de la clase.
Esto para los test viene muy bien. En muchos casos por cada interfaz existirá la implementación de la funcionalidad y otra ‘mock‘ para simular el comportamiento para los test de otra clase. Insisto no lo veo como un condicionante de diseño para facilitar los test. Hubiera definido el interfaz de todas maneras incluso en el caso de que no hubiera hecho los test. Sobre esto me parece interesante este post («How tdd affect my designs«)
El hecho de implementar mis propios ‘mock‘ y que estos no sean creados utilizando reflexión y sólo haya que instanciarlos, hace que la lentitud no sea un problema.
Así que, en la práctica, no me he encontrado muchos problemas técnico/filosóficos a la hora de utilizar el TDD. Queda pendiente la segunda parte de este artículo de ejemplos de ‘mock’ que estoy utilizado.
Espero que os sirva.
Actualización octubre del 2014:
» Después de un verano intenso que nos ha dado tiempo a desarrollar un protocolo de voto electrónico en el que por mis tareas me he tocado definir y desarrollar en gran parte, a partir de octubre de 2014, las circunstancias hacen que me desligue de Civitana.org, .
Aunque tengo una pequeñisima parte del ella desde ese momento paso de ser ‘cerdo’ a convertirme en ‘pollo’. Quizás más adelante, cuando las circunstancias cambien en un futuro se pueda retomar la relación laboral.»
M.E.
Han sido unos meses muy intensos y cuando por fin Civitana.org está en producción siento la necesidad de escribir esta entrada. Mucho trabajo y no pocos retos los que hemos tenido que superar.
Fue a ![[Civitana]](/wp-content/uploads/2014/06/logoCivitana.png)
principios de verano pasado cuando Iván contacto conmigo para presentarme su proyecto.
Lo que me encontré fue una declaración de intenciones de proyecto ambicioso, del que todavía no somos conscientes del calado que puede llegar a tener.
Me presentó un proyecto donde la palabra “Firma” dejaría de estar desvirtuada. Pasaría a tener un valor probatorio real, tanto de integridad, como de veracidad de la misma y de verificación de cuando se realizó. Un proyecto donde la “participación ciudadana” se vería respaldada por un documento firmado electrónicamente, cuya firma estuviera basada en estándares, para que pudiera ser fácilmente validada y que solamente con él se pudiera defender el cambio. El reto de como presentaba el concepto de identidad en Internet era algo que se adelantaba a lo que probablemente tengamos en un par de años.
Todo estaba por hacer, se partía desde cero. Me uniría al proyecto en calidad de consultor en firma electrónica gracias a la experiencia anterior en el Ministerio de Cultura. En realidad a los que formamos el equipo técnico de Civitana con Tania, Jesús y yo mismo, nos ha tocado hacer de todo y estar en todos los frentes.
Mientras todo se definía y entre unas cosas y otras todo se retrasó hasta medidos de octubre. La propia naturaleza y lo innovador del proyecto me hizo ser consciente que podría tener un futuro incierto.
He de reconocer que los principios fueron duros pero a la vez apasionantes. Aunque para ser sincero, esto ha sido así en todo el proceso y no sólo al principio. Cada paso ha sido un reto que hemos tenido que superar y del que por ahora siempre hemos salido airosos.
Primero había que definir la arquitectura y la tecnología. Civitana tenía que ser escalable y montada con alta disponibilidad y además muy interactiva y usable. Creo que se eligió un stack tecnológico que cumple con todo ello. Con Frontend y Backend diferenciados y escalables, solución mixta de bases de datos relacionales y NoSql, sistema de ficheros distribuido,..etc.. Perdonarme que no pueda ser más específico pero en Civitana.org hay mucho más de lo que se ve.
Y fue cuando estuvimos en el quizás hasta ahora ha sido el momento más crítico del proyecto.
La firma no iba como nosotros queríamos que fuera. Nos obligó a realizar una nueva implementación de la parte de firma y generación de claves desde cero con otra tecnología, y lo que fue nuestra debilidad, se ha convertido en nuestra fortaleza. Ahora tenemos firma con cualquier dispositivo que tenga un navegador moderno, sin necesidad de instalar java, plugins, drivers, aplicaciones nativas….
Sin poder entrar en detalles, de un plumazo pasamos a tener firma en PC, firma en “movilidad”, etc… Y lo mejor de una manera usable, universal, basada en estándares, y como debe ser generando las claves y la firma en el cliente, es decir, en el navegador.
Y todo con, a mi modesto entender, a años luz en facilidad de uso y universalidad de la “firma electrónica” a la que está todo el mundo acostumbrado. Como chascarrillo, siempre digo que esto nunca será valorado suficientemente,… si no es alguien que ha tenido que dar soporte de firma electrónica en una Sede Electrónica (un “pequeño” infierno y lo digo por lo he sufrido en mis propias carnes 🙂 ).
¡Ah! y todo es tecnología “by Civitana”.
Nos tocaba ponernos “el gorro” de sistemas y montarlo todo en la nube, que es toda una aventura en si,… auditoria de seguridad, terminando la maquetación del diseño … en fin ultimando todo para por fin salir a producción el 15 de Mayo.
¿Y ahora? El futuro sigue incierto, ..’¿la gente tomará como suya Civitana?, ¿realmente lo verá como la herramienta que puede ser?’…. De lo que no tengo duda es todo el equipo técnico de Civitana disparamos siempre nuestro ‘mejor tiro‘.
![[Grunt logo]](/wp-content/uploads/2014/05/grunt.png)
En un proyecto me tocó realizar una ‘builtool‘. Era una herramienta común que utilizarían todos los demás proyectos no importando su tecnología, PHP,.Net, Java, etc. Obtenía el código del sistema de control de versiones compilaba, paquetizaba y subía la build compilada a otra rama del control de versiones. En realidad era un pre-Maven porque obligaba a una cierta estructura de directorios en los proyectos pero no tenía ni su control de dependencias, ni sus arquetipos para nuevos proyectos. La herramienta estaba hecha en Ant.
Realmente nunca me llegó a apasionar ese proyecto, siempre me ha gustado más programar. Pero me ayudó a tener conciencia de la importancia de saber montar el ‘Control de la configuración‘ de un proyecto y también, como podéis imaginar, a tener bastante soltura con Ant.
Para el Front del nuevo proyecto, con mucha carga de JavaScript, teníamos que generar la build y realizar el despliegue. Para hacer menos pesada y más rápida la descarga necesitamos comprimir html, jasvascript y css y en el caso de estos dos últimos unificarlos en un sólo fichero. Este proceso también lo utilizaríamos para hacer despliegue continuo en nuestro entorno de preproducción, utilizando Jenkins.
Grunt se ajustaba perfectamente a nuestras necesidades y además se unificaba las tecnologías. La elección de Grunt en vez de Gulp, otra herramienta similar, fue porque el primero está incluido en Yeoman, que viene a ser en Javascript lo que Maven es a Java. Una herramienta de gestión de dependencias, arquetipos, generación de buidls, test, etc.., que al igual que Maven permite gestionar todo el ciclo de vida de las builds. Elegí Grunt como un primer paso del camino que muy probablemente nos lleve a Yeoman.
Me enfrente al reto aprendiendo algo nuevo desde la perspectiva de algo conocido. Utilizando como punto de apoyo, sin que lo conocido conllevara a perjuicios iniciales. Estas son las semejanzas, las diferencias y las conclusiones a las que he llegado.
Ant tiene ya mucho recorrido, o dicho de otra manera ya es bastante ‘viejuno‘. En cierta forma fue la respuesta de Java al Make de C. Surgió de la necesidad de crear una herramienta que pudiera compilar, generar ejecutables y que no dependiera del sistema operativo donde se ejecutara. Permite también la generación de test, despliegue, generación de documentación, etc.
Grunt está dentro del ecosistema Javascript, es un ‘ejecutor de tareas‘ y se usa fundamentalmente para realización de builds, su testeo y su despliegue.
Para utilizar Ant es necesario primero tener instalado Java y después la distribución de Ant. Algo similar ocurre con Grunt para poder usarlo es requisito tener instalado node.js y el cliente de Grunt.
Tanto en Ant como en Grunt la configuración de la build del proyecto se hace a través de un archivo. Su nombre por defecto en ‘build.xml‘ en Ant y ‘Gruntfile.js‘ en Grunt
En esencia tanto en Ant como en Grunt se utilizan las tareas disponibles (‘tasks‘) para definir objetivos (‘target‘). Los objetivos contienen la configuración de nuestro proyecto utilizando estas tareas… ‘Copia estos ficheros‘, ‘borra los ficheros de este tipo‘, etc..
En Ant un target pueden depender de otros. Se ejecutarán los targets de los que depende antes que él y lo harán en el orden indicado. Esto permite crear un flujo de ejecución de tareas.
1 <project name="Ejemplo de build" default="ejecutar">2 3 <target name="ejecutar" depends="clean,crearDistro,crearWar"/>4 5 </project>
En este caso ‘ejecutar‘ sería el target por defecto.
En Grunt se definen ‘alias‘ para el mismo resultado.
1 2 3
Eso no significa que no puedas ejecutar targets individuales. Por ejemplo en Ant para lanzar el target clean sería, ejecutando en el directorio donde está el ‘build.xml‘
1
o en Grunt, ejecutado en el directorio donde está el ‘Gruntfile.js‘
1
Tanto en Ant como en Grunt se pueden pasar variables al archivo de configuración desde línea de comandos, lo que resulta muy útil a la hora de configurar varios entornos del mismo proyecto en el Jenkins.
En Ant
1 $ ant −DdirEntorno=prepro
Usando así la variable en el buid.xml
1 <target name="clean">2 <delete dir="${dirEntorno}"/>3 </target>
En Grunt:
1 $ grunt −−dirEntorno=prepro
Y el Gruntfile.js
1 2 3 4 }5 }
Ant utiliza xml para definir la configuración. Esto hace que, sobre todo al principio, y con archivos de build complejos, que sea bastante rígido y engorroso.
Grunt en este aspecto utiliza json, un formato mucho más liviano. Además está embebido en un archivo javascript permitiendo utilizar este lenguaje con toda su potencia. Este aspecto le da mucho más flexibilidad que Ant. Aquí es donde se le notan los años a Ant y como muestra Gant,una alternativa en el mundo Groovy que ‘pasa’ del xml
La filosofía de las dependencias de las tareas es completamente diferente. Ant ,de serie, trae diferentes tareas que ya se pueden usar. Esto no significa que se puedan utilizar otras tareas de terceros. Para esto se usa la tarea ‘typedef‘.
La gestión de dependencias de las librerías que son necesarias para ejecutar estar tareas es completamente ‘a mano’. No te queda otra que bajarte la librería he incluirla, o bien en tu distribución de ant (en el directorio ‘lib’) o bien dentro de tu home (en el directorio ‘.ant/lib‘)
En esto Grunt si que gana por goleada. Por defecto no viene con ninguna tarea predefinida, por lo que eres el que elige cual vas a utilizar, seleccionandola de su página de plugins. Probablemente existan varias posibilidades a la tarea que estás buscando. Después, para poder utilizarla, Grunt utiliza la potencia del gestor de paquetes de node.js, npm.
Por ejemplo, para instalar la tarea ‘uglify‘ que se utiliza para comprimir archivos js, se ejecuta el siguiente comando en el directorio donde este el Grutfile.js
1 $ npm install grunt−contrib−uglify −−save−dev
Esto incluye las dependencias en el ‘package.json‘ (Este fichero se crea al iniciar el proyecto ejecutando ‘npm init’)
Y para pode usar la tarea hay que añadir al Gruntfile.js:
1 2 3
Fácil y cómodo, aunque tampoco falto de problemas. Por ejemplo la tarea clean de repente dejo de funcionar en Windows, mientras que el Linux no había problema. El problema, una de las dependencias subió de versión… y dejo de funcionar. La solución fue añadir la dependencia a la versión que funcionaba directamente en el archivo ‘package.json‘. Espero tener tiempo para explicarlo mejor en otro post.
Si eres de Back ,tienes algo de experiencia en Ant y quieres montar tu control de configuración para el Front que está basado en Javascript, trabajar con ‘Grunt’ te va a resultar muy familiar.
Son tecnologías diferentes, algunas tareas serán similares y otras más específicas no encontrarás en Ant, pero la esencia es la misma, así que sin miedo.
Espero que os sirva.
Hace unos par de meses, por fin tuve tiempo para realizar la integración del plugin de twitter que hice en 747mx.com. Para mi desgracia el servidor compartido no estaba muy actualizado y para que me funcionara tuve que añadir como parámetro, en las propiedades de la función cURL, el certificado de la Autoridad Certificadora. En este caso la CA de VeriSign.
Y este ejemplo me viene al pelo para intentar explicar brevemente como funciona los certificados digitales y es que, como en la vida misma, todo está basado en relaciones de confianza.
La firma y la encriptación utilizando los certificados digitales se fundamentan en cifrado asimétrico en el que se utilizan dos claves. Una clave es pública y puede navegar sin problemas, bien por la red, en un correo electrónico, o embebida en un documento firmado por el usuario. La otra clave es privada y es la que sólo está en posesión del dueño. Por esa última razón las dos claves se deberían generar en el dispositivo del usuario, y no por ejemplo en el servidor en una aplicación web.
Con las dos parejas de claves se pueden hacer:
1) Firmar un “mensaje” con la clave privada y comprobar esa firma con la clave pública. Se calcula un resumen criptográfico (hash) del mensaje y el emisor con su clave privada firma este hash. El receptor vuelve a calcular el hash del mensaje y lo compara con el valor obtenido de firma con la clave pública del emisor.
Así, con la firma se comprueban dos cosas:
– La “integridad” ya que el mensaje no ha sido modificado desde que se ha enviado (no coincidirían los hash).
– El “no repudio” ya que sólo ha podido emitir la firma el poseedor de la clave privada que corresponde a la clave pública.
2) Cifrar un “mensaje” con la clave pública y descifrarlo con la clave privada. Solamente el poseedor de la clave privada es capaz de leer el mensaje en claro.
Hasta aquí la situación es esta: dos usuarios generan sus parejas de claves y para mantener mensajes autentificados y cifrados se intercambian sus respectivas claves públicas, pero … ¿ cómo comprueban su “identidad”? ¿cómo saben que el ha generado la clave pública que tienen es quien dice ser?… Puedes caer en el peligro de lo que se llama el “ataque del hombre el medio”. Una tercera persona ‘puentea’ la comunicación entre otras dos, generado dos parejas de claves y hace de ‘proxy‘ simulando ser la primera persona para la segunda, y ser la segunda para la primera y permitiéndolo ‘escuchar’ toda la conversación.
Y es aquí donde retomo el título del post y entran en juego las relaciones de confianza… Tiene que existir algún mecanismo, que sin conocer al poseedor de la clave pública, permita «confiar» en que es quien dice ser.
Esa confianza se puede establecer de varias maneras. O bien por anillo de confianza, o bien delegándola en una Autoridad Certificadora (y porque no, dando una vuelta de tuerca más, descasándola en una solución mixta).
Las dos se basan en firmar la clave pública de un usuario que se conoce su autenticidad. El el caso del anillo de confianza, es el usuario que conoce a la persona el que realiza la firma de la clave. En el caso de la Autoridad Certificadora es esta la que establece los medios necesarios para certificar la autenticidad del usuario y después firma la clave publica del usuario con su clave privada. Un ejemplo de Autoridad Certificadora es la Policía Española con el DNI electrónico.
Así un tercero sólo necesita dar “confianza” y establecer como auténticas a sólo unas pocas claves públicas del anillo o en la clave de la autoridad certificadora.
Así en el caso de claves públicas de terceros, sólo serán “confiables” aquellas que estén firmadas por las que “confío”, o en todo caso por las que estén firmadas por claves que a su vez estén firmadas por claves en las que confío (disculpadme lo de “…la parte contratante de la primera parte…” 🙂 ). Se establece entonces una “cadena de confianza” en forma de árbol. Creo que el chascarrillo que lo resume es: “…los amigos de mis amigos son mis amigos…”
Y es que un certificado digital, lo que viaja por la red, y que por ejemplo podemos ver en un navegador cuando comprobamos el certificado de un página https, no es más que un contenedor que contiene la clave pública, metadatos y la firma de ambos por parte de la Autoridad Certificadora. Estos metadatos incluyen los datos de la persona o la empresa para para quien ha sido emitido, las fechas de validez, la dirección donde consultar si el certificado ha sido revocado por la entidad emisora (OSCP o CRL), los datos de la entidad emisora, un número de serie, etc.
![[Certificado digital de google.com]](/wp-content/uploads/2014/04/datos_certificado_google_p1.png)
Certificado de google.com donde se puede ver la cadena de certificados (jerarquía) y sus metadatos
Por el hecho de venir con la instalación del programa de turno, implícitamente le das confianza a estas autoridades certificadas. Lo que no significa que las puedas dejar de dar confianza eliminado sus certificados manualmente. O que puedas dar la misma confianza a otras autoridades incluyéndolas manualmente y que a todos los efectos los certificados emitidos por esta Autoridad Certificadora tengan la misma validez.
Esto es justo lo que me ha pasado en el ejemplo con el que empezaba el post. Para poder establecer la comunicación ssl con el api de twitter tuve que “darle confianza” a la CA e incluir su certificado en las opciones de la función cURL.
Y es que como ya he dicho antes, como en la vida misma, todo es cuestión de confianza…
Espero que os sirva.
![[Vert.x Logo]](/wp-content/uploads/2014/03/logo-white-big.png){kind=logo}
La primera vez que oí hablar de Vert.x fue en la charla sobre el nuevo lenguaje Ceylon basado en la JVM que dio Gavin King (la mente pensante detrás de Hibernate) el pasado febrero en MadridJUG. Comentó que para la web estaban enfocando sus esfuerzos en un framework asíncrono basado en Vert.x.
«¿Asíncrono…?» Ya se me levantó la ceja a lo ‘Sobera’ .. y lo que me dio ya la puntilla es cuando se puso a picar en directo un servidor web (puro live coding :-)) me olía todo tenía un aire a como se trabaja con node.js,.. Así que me dije…»esto de Vert.x me lo tengo que mirar«.
He de reconocer que con el título del post me he pasado… He estado dándole vueltas a uno que tuviera ‘punch‘… y me parece que he tirado por lo fácil. En realidad Vert.x es mucho más que un servidor web… Su ‘misión‘, ‘visión‘ y ‘valores‘ es soportar millones de conexiones concurrentes usando un número mínimo de hilos del sistema operativo (¿¿?? así lo asegura en su documentación), imposibles en un esquema multihilo típico.
Vert.x es un framework basado en eventos que corre en la máquina virtual de Java. Hecho para que sea fácil de escalar y soporte a tolerancia a fallos. Pensado para que existan de una manera sencilla varios cores en diferentes JVM y que se intercomuniquen entre ellos. Vert.x resuelve la concurrencia siguiendo el modelo de actores y además asegura que no existirán bloqueos entre hilos. Otra de sus características es su ‘bus de eventos‘ que permite desacoplar tu aplicación en módulos y comunicarse entre ellos a través de mensajes. Y todo de manera asíncrona.
Vert.x es ‘Políglota‘, soporta JavaScript, Ruby, Groovy, Java o Python y con vista a soportar Scala, Clojure e incluso PHP. Ejecuta código fuente por lo que, por ejemplo, existe la posibilidad de arrancarlo con ficheros ‘.java’ sin necesidad de compilarlos.
Llegaréis a la conclusión y la compartiré de que con el título lo he simplificando demasiado ¿Pero porque he hecho esta comparación? Porqué Node.js y Vert.x tienen funcionamientos similares.
En JavaScript no existe la concurrencia. Aunque esta afirmación pueda ser no del todo cierto, porque en html5 y en el cliente existe los workers, en JavaScript sólo existe un hilo y las operaciones que bloquean se ejecutan con llamadas asíncronas.
Y quizás esto, lo que parece su debilidad, es su virtud es esto lo que hace que node.js este valorado como un servidor con poca latencia cuando existe mucha carga .
La diferencia fundamental entre node.js (o Vert.x) y un sistema tradicional multihilo es que la máquina virtual de node utiliza un sólo hilo para atender todas las peticiones. El hilo se limita a recibir la petición y realizar llamadas asíncronas. No espera el resultado de la petición y continua con la siguiente. Más tarde recogerá el resultado para devolverlo al cliente.
Por el contrario en un sistema multihilo, por ejemplo en un despliegue tradicional de Java, existe un hilo para cada petición. Este se queda bloqueado mientras espera el resultado de una operación. Esto hace que bajo mucha carga existan muchos hilos y parte de ellos esperando, lo que repercute en la latencia.
Vert.x trabaja de igual manera, en este caso utilizando el modelo de actores en el que cada uno de los actores será un ‘verticle‘. En la documentación lo definen con una partícula de Vert.x y en la práctica es la manera de definir el código desplegado. Los ‘verticles‘ se pueden agrupar en módulos (lo más usual cuando la aplicación deja de ser trivial) y estos se pueden reutilizar.
Con Vert.x es muy sencillo crear servidores y clientes socket, ssl, http y websocket.
Necesitaba poder familiarizarme con la herramienta y tenía que hacer algo. Es entonces cuando recordé la presentación y demo muy, muy chula que hizo Iván López en MadridGUG utilizando una cuenta de Gtalk como boot. Así que basándome en esa idea he creado una prueba de concepto realizando un Gateway con WebSockets y Gtalk utilizando Vert.x. El proyecto es un proyecto Java.
Se utiliza una cuenta de Gtalk para poder crear una sala de chat entre usuarios que se conectan por Gtalk y usuarios que se conectan con un navegador mediante websockets.
Este ejemplo no explota todas las posibilidades de Vert.x como el escalado y el bus de eventos pero si que despliega servidores web y de websocket. Me ha permitido conocer como se genera, se configura y se ejecuta un módulo. En definitiva, ha conseguido mi objetivo que como he dicho más arriba era familiarizarme con el framework
El proyecto lo he subido a GitHub y que es lo que hace y como está explicado en el README.md .
Prueba de concepto: Gateway WebSockets y Gtalk utilizando Vert.x
Espero que os sirva.
Actualmente estoy involucrado en un proyecto en el que la arquitectura es un Backend de servicios web Rest (Java) y como Frontend una aplicación de una sola página (SPA Single-page application) hecha en AngularJs, utilizando el patrón MVC en el navegador.
Siempre he tenido ganas en saber algo más de como funciona este framework y no podía perder la oportunidad de echar una mano en el Front.
Para poneros en antecedentes, vaya por delante que en mi anterior trabajo apenas se utilizaba JavaScript en la vista. Así que ahí estaba yo, leyendo un manual de AngularJs con muchas ganas, intentando asimilar todos los nuevos conceptos de la herramienta y del lenguaje.
Aquí van mis primeras conclusiones sobre Angularjs de un ‘newbie’ que todavía tiene mucho que aprender.
La primera y quizás más importante es que me ha encantado el concepto. Te plantea una aplicación web de una manera diferente. Ya no piensas en peticiones web, formularios, etc, sino que piensas en eventos.
Al ser una aplicación de una sola página pasas de pensar en una aplicación web al uso a una que se parece más a .NET. La página se carga una vez (index.html) y es Angular quien se encarga según la url (en realidad ficticia con un ancla #) la que carga las diferentes ‘plantillas’ (vista, código html parcial) y los diferentes ‘controladores’ (funciones javaScript) que hace que se convierta en diferentes ‘páginas’.
No se carga una página por petición por lo que no es necesario guardar variables ‘volátiles’ en sesión, simplemente la almacenas en memoria. De hecho nosotros solamente almacenamos en cookies las credenciales de acceso.
A nivel de controlador defines las funciones que responderán a los diferentes eventos. El apretar un botón, un enlace, el cambio de foco de un campo de formulario,etc… Te centras en programar la lógica del evento, sin preocuparte como propagar el cambio para dibujar el resultado al usuario. De eso se ocupa Angular…
Dos cosas me han llamado la atención para bien. Primero, la conexión entre la vista y el controlador.
Es directa. Si desde el controlador se cambia una variable esta se propaga directamente en la vista y se produce un cambio en lo que está viendo en usuario. También en el otro sentido, se puede saber cuando se ha modificado una entidad por el usuario y procesar este cambio en el controlador.
Si tenemos en cuenta que los campos de un formulario pueden constituir una entidad en su conjunto, es fácil imaginar lo sencillo que es propagar los cambios también al backend. No se si se puede llamar ‘Programación Reactiva‘ pero se le parece mucho… Un cambio realizado por el usuario se puede propagar al backend y un cambio en el backend se puede propagar y que lo vea el usuario.
La segunda es la inyección de dependencias que implementa Angular. Una aplicación se divide en módulos y en estos hay controladores, directivas (estas enfocadas más a la vista y a sus validaciones) y servicios. Todas las dependencias, por ejemplo, de un servicio que necesita un controlador, se definen a nivel de módulo de aplicación.
Siguiendo el ejemplo, para poder utilizar el servicio en tu controlador es tan sencillo como tener como argumento en la definición de tu función controlador un objeto servicio. Angular se encarga de instanciar correctamente el servicio que necesita el controlador resolviendo a su vez todas las dependencias.
A nivel de modulo se pueden definir, factorías, servicios y proveedores… Seguro que quien se han pegado en Java con Spring esto les suena algo…
Angular es un framework muy completo. En el core viene con directivas, filtros, y servicios predefinidos (como su propia implementación del patrón ‘promise‘ [$q]) que te hace la vida más fácil para un novatillo en el lenguaje y en el concepto como yo.
Tiene ‘interceptadores‘ que son parecidos a los filtros de Java que te permiten capturar la petición al servidor y por ejemplo enviar las credenciales de conexión sin tener que hacerlo en cada petición.
Angular está orientado a TDD. Es sencillo tanto hacer test unitarios como test de integración.
En esta fase de aprendizaje Angular me lo ha puesto sencillo. Me ha definido un marco estándar de trabajo y me ha ayudado a no tener la sensación de estar haciendo las cosas no también como debería.
Además me he encontrado con que la documentación es buena y en este momento ya hay mucha gente trabajando con él por lo que puedes encontrar solución a casi cualquier problema en Stackoverflow.
Otra de las ventajas es su rapidez de ejecución. Las peticiones al servidor son sólo llamadas ajax y plantillas parciales html. Realmente es destacable la rapidez con que se muestran todos los cambios.
Este tipo de arquitectura es fácilmente cacheable al ser todo archivos estáticos por lo que la escalabilidad del Front casi deja de ser un problema.
Por lo que escrito más arriba. El dinamismo que le da a la web es difícil de superar en otra arquitectura.
La dudas que me surgen es que cuando la aplicación empiece a crecer en ficheros js cuanto va a ser de pesada en la primera carga. A lo mejor cuando llegue habrá que plantearse una librería como RequireJs. Por rendimiento realmente no es necesaria, ya que Angular sólo carga en memoria lo que necesita.
Otra de las pegas es de usabilidad. Es muy común que en un mismo controlador manejes, por ejemplo, dos formularios y que juegues con su visibilidad para mostrar uno u otro. Si en el proceso el usuario aprieta el botón de ‘Atrás’ del navegador lo más probable es que le lleve a una sección de la web que no se corresponde con el anterior paso. Estas cosas hay que tenerlas en cuenta en el diseño de la aplicación.
Otro punto a tener en cuenta es a indexación por parte de los buscadores. Al ser todo javaScript y dinámico probablemente Google no podrá indexar la web.
El problema de IE8. Es el único navegador que no soporta HTML5 y que actualmente aún lo usa mucha gente, aunque afortunadamente cada vez menos. Para que Angular soporte IE8 hay que hacer ‘unas movidas’, que hace que es mejor plantearse indicar al usuario que utilice otro navegador.
Y por último es un cambio de concepto en el diseño de una página web. Por las inercias de las empresas, esto lleva a no pocas reticencias para que alguna se atreva a realizar su proyecto en Angular.
Para una web que siempre requiera un registro, y muy dinámica tipo red social, para mi las ventajas supera con mucho a los inconvenientes.
Espero que os sirva.
Con la aparición de Node.js y la posibilidad de programar JavaScript en servidor se palpa entre los “javeros” cierta, no se encontrar la palabra, …¿preocupación?. La sensación es de “…nos están cambiando el agua…” y el comentario más oído es “… parece que es lo que se lleva ahora, no me gusta, pero habrá que aprenderlo…”
A este desasosiego no ayudan post como los de PayPal (enlace ) en el que en resumen dicen que se pasan a JavaScript entre otras cosas porque es más rápido, necesitan menos gente y además se tira menos código. En respuesta a este post ha habido otros que han salido en defensa de Java y para poner coherencia en el tema (enlace)… y es que es lo que tienen casi todos los benchmark que pecan de partidistas.
En todas las ingenierías, pero mucho más en informática, tienes que estar en continua formación y estar al tanto de lo que se está haciendo. Es cierto que no podemos negar que también va todo un poco por modas y que es todo es cíclico. Parece que más tarde o más temprano siempre volvemos al mismo sitio que nos estamos moviendo en un circulo cerrado. Yo prefiero verlo más como una espiral… si la ves verticalmente parece que estás en el mismo punto,… pero que si la ves horizontalmente te das cuenta que estás en un nivel superior. Un ejemplo de esto son las nuevas bases de datos NOsql. Puede parecer que vuelven a las bases de datos pre-relacionales pero en realidad aportan muchas más cosas (escalabilidad, rapidez, big data y su explotación).
Pasa lo mismo con JavaScript hace mucho mucho tiempo que ha dejado de ser un lenguaje que sirve para poco más que hacer validaciones y hacer las “cosas bonitas” en la capa de presentación.
El gran problema de los “javeros” que dan sus primeros pasos en JavaScript, entre los que me incluyo, es que a la hora de enfrentarse al nuevo lenguaje piensan “… al final será algo como Java, con tipado dinámico y bueno con callbacks... ” y nada más lejos de la realidad, JavaScript es otra filosofía y en realidad casi casi comparte con Java poco más que el nombre y algunas palabras reservadas.
Creo que en el aprendizaje hay que enfrentarse con una actitud diferente y positiva. Me parece muy interesante el trabajo que ha realizado Micael Gallego en su blog (enlace), en el que explica su viaje en el aprendizaje del lenguaje desde el punto de vista de un programador Java y como a lo largo de los diferentes artículos va entendiendo la filosofía de JavaScript. A mi me ha ayudado mucho su lectura, así que no puedo más que recomendarla.
Reconozco que no soy experto en JavaScript y no puedo opinar en profundidad. Pero desde fuera creo que lo bueno y lo malo de JavaScript es que debido a su dinamismo, se pueden hacer las cosas de varias maneras. En Java por el contrario que es todo más cuadriculado.
De todas maneras creo que lo mejor es ser práctico, intentar conocer las debilidades y las fortalezas de cada lenguaje… Por ejemplo no me platearía hacer una aplicación de escritorio para Widonws en Java, para eso creo que es mucho mejor .NET. Por la misma razón me encontraría más a gusto, en aplicaciones de Backend en un proyecto con un equipo de trabajo numeroso, en un arquitectura Java que en una JavaScript, ya que al ser Java más “estricto” el código tendería ser más uniforme.
Lo que es cierto es que JavaScript permite hacer nuevas arquitecturas muy escalables y derivando gran parte de la responsabilidades al cliente. Angular.js es un framework que sigo muy de cerca. Sé que en algunos aspectos puede ser limitado pero prefiero la seguridad de basarme en algo estándar para montar una arquitectura MVC en el cliente.
Además JavaScript, junto con HTML5 se está convirtiendo en la única opción en la parte de navegador. Debido a las restricciones de seguridad que se están poniendo a los applets de java y a las extensiones y plugins. Son un autentico quebradero de cabeza por los agujeros de seguridad encontrados. Un ejemplo, Firefox a partir de su versión 26 no vienen habilitados por defecto los plugins excepto el de Flash.
Por eso en cosas “especiales” en la capa de cliente que por inercia antes te planteabas hacerlas con un applet o una extensión ahora enfocas tus esfuerzos en hacerlas en JavaScript… y se pueden hacer cosas muy, muy chulas.
Espero que os sirva.
En general cuando desarrollas una aplicación de cualquier tipo te enfrentas al reto de:
La configuración tiene que ser cómoda de modificar y tiene que estar centralizada (evitando que este desperdigada en multitud de ficheros de configuración las rutas, parámetros de conexión etc…)
Evitar tener que hacer un build para diferentes entornos (Además probablemente en un entorno corporativo no tengas acceso a las contraseñas y a las rutas de los recursos, etc.. de producción) A esto es a lo que me refiero con externalizable.
Spring es una poderosa y elegante herramienta que permite configurar una aplicación y establecer las dependencias entre sus clases a través de anotaciones o mediante archivos xml.
Pero esta potencia también puede llevar al peligro de que si no somos cuidadosos tengamos los parámetros de conexión, contraseñas, URL y rutas desperdigadas en varios archivos.
Para esto Spring ofrece herramientas que permiten cargar propiedades y valores de archivos ‘.properties‘ y además estos archivos pueden encontrase fuera del jar o del war e incluso pueden estar cifrados. Con esto se soluciona la centralización y la externalización.
Hecha la introducción paso a explicar el problema: Había que configurar una aplicación web en Spring en diferentes entornos en una misma máquina (un entorno en un Jetty y otro en un Tomcat), por lo que había que externalizar la configuración y además al estar en la misma máquina no servía que la ruta al fichero de configuración fuera fija (de estilo ‘/home/usuario/aplicacion.properties‘)
Ha sido utilizar el bean ‘PropertyPlaceholderConfigurer‘ de Spring y utilizar SpEL (Spring Expression Language) de esta forma:
01 <?xml version="1.0" encoding="UTF-8"?>02 <beans xmlns="http://www.springframework.org/schema/beans"03 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"04 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"05 >06 07 <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">08 <property name="locations" value="#{systemProperties['aplicacion.config'] != null ? 'file:' + systemProperties['aplicacion.config'] :'classpath:'}application.properties"/>09 </bean>10 11 </beans>
Código 01. Configuración xml de ‘propertyConfigurer’
La clave está en la línea 8. Si está definida la propiedad del sistema ‘aplicacion.config‘ buscará en el sistema de ficheros, el archivo de configuración ‘aplicacion.properties‘ en la dirección que indica su valor. Si no, busca el ‘aplication.properties‘ en el classpath (es decir dentro del war), por lo que este sería el archivo de configuración de la aplicación por defecto.
Un ejemplo del contenido de ‘aplicacion.properties‘ podría ser
1 2 3
Código 02. Ejemplo de contenido de aplicacion.properties
Y la manera de usarlo dentro de la configuración xml de Spring sería:
01 <?xml version="1.0" encoding="UTF-8"?>02 <beans xmlns="http://www.springframework.org/schema/beans"03 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"04 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"05 >06 07 <bean id="utilFichero" class="com.logicaalternativa.ejemplo.UtilFicheroImp">08 <property name="directorio" value="${aplicacion.config.pathfiles}"/>09 </bean>10 11 </beans>
Código 03. Ejemplo de como se utilizan los valores definidos en el archivo de configuración
Ya sólo me queda indicar como se define esa propiedad. En el Tomcat un buen sitio es el ‘catalina.properties‘ de su directorio ‘config‘. Se definiría así:
1 2 3
Código 04. Configurando el Tomcat
O directamente definiendo la propiedad al arrancar la máquina virtual. Por ejemplo si tu proyecto tiene configurado el plugin, arrancando el jetty embebido de mvn de la siguiente manera:
1
Código 05. Ejemplo al arrancar el jetty de mvn
En los ejemplos en los dos directorios ‘/home/miguel/config−aplicacion−jetty/‘ y ‘/home/miguel/config−aplicacion−tomcat/‘ se encontrarían sendos archivos ‘aplicacion.properties‘ cada uno configurados con los valores para cada entorno.
Espero que os sirva.
Están surgiendo nuevos conceptos como el despliegue continuo y la responsabilidad personal que están cambiando la forma de desplegar en un entorno de producción.
Digamos que la “manera tradicional” es decidir que funcionalidades van a ir en cada versión codificarlas, probar esa versión y por fin el despliegue en producción. Quién se haya enfrentado a esto sabe el estrés que produce el despliegue de una nueva versión sobre todo si conlleva bastantes cambios, …si ya sabemos que todo está probado, que no va a pasar nada, pero el mal trago del despliegue no te lo quita nadie … “¿irá todo bien? ¿no irá?”
¿Cómo están haciendo las cosas empresas como Facebook? … pues simplemente no hay versiones. Sigue leyendo
No se puede decir que sea un ‘social media‘, pero de un tiempo a esta parte Twitter se ha convertido para mi en una fuente de información esencial y casi imprescindible. Tiene un pero, a veces te pierdes entre toda la información que te llega… Pensando siempre ‘alternativamente‘ me surgieron estas preguntas:
¿Sé puede hacer un poco más social una red social como Twitter?… ¿Por qué no mostrar de una manera sencilla como han valorado los demás usuarios el tweet que estás leyendo?…¿cuánto se ha difundido?…. ¿Sé puede estimar a cuanta gente a llegado?
Lo que me dio pie fue que, para 747mx.com, un proyecto hermano de Lógica Alternativa, quería incorporar la información de los tweets pero el widget oficial me fastidiaba el diseño, no sabía como encajarlo. La solución pasaba en estudiar el API REST de Twitter. Puesto manos a la obra me di cuenta del mundo de posibilidades que permitía,… apareció en mi el físico que llevo dentro, ese el que le gusta lo de los coeficientes y esas cosas, la cosa se lío y el resultado fue el siguiente. Sigue leyendo
Usabilidad, Experiencia de Usuario, Diseño Centrado en el Usuario, … son palabras que se nos han hecho familiares a raíz de la evolución de la web y sobre todo con la aparición de los nuevos dispositivos móviles.
Esto ha hecho que el técnico experto en estas materias sean uno de los perfiles más valorados en el mercado. Existen otros conceptos relacionados, unos a nivel teórico y otros unidos a la práctica profesional, que son elementos claves y que engloban lo que se llama interacción persona-ordenador (IPO).
En mi vida profesional he utilizado estas técnicas y conceptos. Últimamente me he enfrentado a ellos desde la visión académica. Para poder fijar ideas y tener una visión clara y concisa de esta apasionante disciplina me obligado a escribir este artículo.
Me centraré más en el Diseño Centrado en el Usuario, en que consiste, cuales son sus ventajas, sus etapas, que herramientas se usan y su integración con la metodologías ágiles. Pero antes y para enmarcarlo en su contexto doy unas pequeñas pinceladas sobre conceptos como Interacción persona-ordenador, Experiencia de usuario y Usabilidad. Sigue leyendo
![[Logo de tizen]](/wp-content/uploads/2013/07/tizen_p.png)
Tizen es un nuevo sistema operativo, que pretende ser global. Su principal objetivo son los Smartphone pero exitirán versiones para PC, para tablets, TV inteligentes e incluso para coches (por cierto este último con muy buena pinta, ver vídeo)
Tizen esta patrocinado y promovido por la Linux Foundation. El proyecto es una “join venture” de varias empresas que van desde operadores móviles como Vodafone y Orange, a fabricantes de dispositivos como Samsung e Intel. Se ha elegido una forma de gobierno democrático en el que ninguna de las empresas que la forma lleva el peso de las decisiones, aunque eso no significa que cada una de ellas pueda crear sus propios módulos.
Tizen se fundamenta en estándares y es una plataforma de código abierto basada en Linux. Para el desarrollo de aplicaciones se ha elegido HTML 5 como entorno de desarrollo de sus aplicaciones.
Gracias al Taller de Tizen organizado por MadridJS y impartido por Intel he podido saber las líneas maestras de su plataforma de desarrollo, API y SDK. Sigue leyendo
Realmente no te das cuenta de la dependencia que tienes de los servicios de Google. Piensas que puedes disponer de ellos porque además de ser potentes son gratis… hasta que dejan de serlo.
![[Mapa OpenLayers]](/wp-content/uploads/2013/07/mapa.png)
Me ha ocurrido en el pasado, en un proyecto personal (747mx.com) que utilizaba el traductor de Google. Era gratis hasta un número de peticiones, suficientes para la pretensiones de esa página y pasó a ser de pago desde la primera petición. Algo que no me podía permitir en ese portal.
Así que cuando en una entrevista a Javier De La Torre uno de los fundadores de Vizzuality señalaba a OpenStreetMap como alternativa seria a Google Maps me dije ‘… esto me lo tengo que mirar‘ .
Para saber como funciona de verdad, lo que me propuse fue migrar un código que tenía con el API de Google Maps en 747mx.com. Basarme en él y hacer lo mismo en OpenStreetMap utilizando lal librería OpenLayers y el servicio de geolocalización de OpenRouteService.org. Sigue leyendo
“Si lees esto significa que Lógica Alternativa está ya en la nube”… Lo siento no he podido resistir la tentación de empezar esta entrada como los epílogos de las pelis 🙂
![[OpenShift]](/wp-content/uploads/2013/06/openshift_mod_p.png)
OpenShift es un servicio de Red Hat encuadrado en la capa PaaS (Plataforma como Servicio), enfocado por lo tanto al desarrollador. Permite desplegar un montón de tipos de aplicaciones, J2EE (jbossas-7, jenkins-1.4, Tomcat 6, Tomcat 7, ..) PHP, Perl, Pyton, Ruby, JavaScript (node.js) contra base de datos como MySql, PostgreSQL, ¡MongoDb!. Y realizar integración continua con Jenkins (se más de uno que al llegar aquí ya se le está haciendo la boca agua).
Tiene una mecánica ‘alternativa’, aquí que no hay un ftp al uso. Se utiliza Git y el cliente por linea de comandos rhc. Sigue leyendo
Para mi son tiempos de cambios, algunos “forzados” y otros “provocados”. Ahora tengo la necesidad de saber que es lo que está pasando en este mundillo de la programación y la informática. Siempre me ha interesado las metodologías ágiles, así que el pasado miércoles asistí a un seminario/taller organizado por Agile Madrid y dirigido por Ángel Diaz Maroto.
En este seminario presentó el Framework de Competencias de Agile Coach ideado por Lyssa Adkins. La idea de fondo de este marco de trabajo es intentar conseguir transformar a un grupo de personas en un grupo de alto rendimiento. Sigue leyendo
Una nota rápida de un problema con el que me he pegado hace poco.
Necesitaba lanzar una función de BBDD (Oracle) desde Hibernate manteniendo la transacción. Para lanzar la función desde jdbc, en las versiones anteriores de Hibernate era muy intuitivo obtener el objeto Connection relacionado con la sesión pero en Hibernate 4 ha cambiado el interface Session. Sigue leyendo
Hace mucho tiempo que en casa hay un ordenador, casi casi está ahí desde siempre. Es un Intel Celeron a 2.66 Mhz con 256 Mb de RAM. Lo utilizamos todos y se usa para navegar, ver el correo, de servidor de impresión…
Ha salido bueno, porque ha sobrevivido a todo lo que estaba en la mesa del escritorio. Se ha mantenido, ahí sempiterno, mientras todo (ratones, teclados, monitores, altavoces, etc) ha ido muriendo y se ha tenido que ir cambiando.
El caso es que el Windows XP que tiene instalado se ha ido degradando. El pobre tampoco podía con las nuevas versiones de antivirus. Era un suplicio por el tiempo que tardaba en arrancar y en abrir las aplicaciones.
Buscaba una solución sin tener que quemar todas mis naves y manteniendo todo lo que tenía instalado y la encontré en una distribución linux, Puppy. Me gusto su lógica alternativa… Sigue leyendo
La duración de manga de motocross se mide en minutos + 2 vueltas. A nivel regional son 20 minutos + 2 vueltas, a nivel nacional 30 minutos + 2 vueltas, etc… Entrenando lo normal es hacer mangas de la misma duración, o de menos tiempo (mejorando la rapidez) o de más (mejorando el fondo). Las motos de cross no tienen instrumentación y obliga a que una persona desde fuera indique al piloto cuanto le queda de manga.
¿Qué por qué cuento esto? Desde hace bastante tiempo mi hermano y yo corremos motocross a nivel regional. Bueno en realidad mi hermano es el “quemao” y siempre andaba quejándose de que sus entrenos no podían ser de calidad porque no sabía el tiempo que llevaba, no sabía cuando apretar, cuando regular, bla, bla, bla…
Ahí salió el “hermano informático”, surgió el problema de cambiar el color a una barra de progreso y echarme a la cara el peor ‘stakeholder‘ que he tenido en mi vida … Sigue leyendo