lunes, marzo 26, 2012

Migración completada


Finalmente he terminado la migración del blog. No es que fuera una gran tarea pero siempre me han surgido "mejores cosas" que hacer. Mantendré este blog activo durante unas semanas y posteriormente lo eliminaré por completo.

A partir de ahora el blog estará alojado en la siguiente dirección:

http://migue.github.com/

por lo que NO habrá más entradas en este blog.

Hasta pronto!

Migue

viernes, marzo 09, 2012

Migrando el blog

O al menos intentándolo . . .



Estos días no he escrito nada por aquí porque he estado barajando la posibilidad de migrar el blog a una plataforma que me permita una mayor versatilidad a la hora de escribir. Mi idea es que el nuevo blog esté aloajdo en mi cuenta de GitHub: migue.github.com.

Espero que la migración no sea demasiado complicada y que pueda tener el blog operativo cuanto antes.

Cuando el proceso de migración esté completado avisaré por aquí. Mientras tanto no creo que postee nada nuevo por aquí!

Espero tener noticias cuanto antes!

Migue

sábado, febrero 25, 2012

Mi visión del Spring I/O 2012


Dicen que más vale tarde que nunca así que, aunque con un poco de retraso, aquí va vi visión del Spring I/O de este año.

La semana pasada asistí a la tercera edición del evento Spring I/O que se celebra en Madrid. El año pasado estuve dando una charla acerca de Hadoop, Cloud y Spring pero este año simplemente he asistido como oyente (de momento el niño me deja poco tiempo libre . . . .).

Fueron dos días bastante intensos (estuvimos allí desde las ocho y media de la mañana hasta las siete de la tarde) que me dejaron un sabor agridulce. 

Por una parte la organización del evento ha sido magnífica: aplicación para el móvil con la agenda, algún regalillo, multitud de información, coffee breaks, algo de comida, etc. Sobre el papel venía gente de mucho renombre: Adrian Colyer (CTO SpringSource), Matt Raible, Rob Harrop, Graeme Rocher (Grails Team Leader), Peter Ledbrok (Grails Team Leader), James Ward (Heroku Evangelist), el CTO de ZeroTurnaround (ahora mismo no recuerdo su nombre) . . . . y sin embargo el nivel de las charlas ha sido un poquito, bajo mi punto de vista, decepcionante: pocos contenidos novedosos, cosas muy básicas, etc. Puede ser que a medida que me voy haciendo viejo me esté volviendo un poco cascarrabias o que mi listón para medir las cosas esté demasiado alto; no lo tengo claro.

No pretendo convertir esta entrada en un ladrillo así que dare alguna pincelada sobre alguna de las charlas a las que asistí.
  • Application Development in the Cloud Era. Esta charla fue impartida por Adrian Colyer y estuvo hablando, de manera muy genérica, sobre Rich clients, Cloud Computing, CQRS, Server Side. Lo mejor de la charla fue una frase en la que dijo "it is a good time to be a server side developer". No podría estar más de acuerdo :). Fue una de las charlas más entretenidas a las que asistí.
  • Running Spring Apps on the Cloud with Heroku. James Ward hizo una presentación de la plataforma PaaS Heroku. Durante el transcurso de la misma estuvo contando algunas generalidades sobre dicha plataforma y realizó una pequeña demo sobre como podemos desplegar nuestra aplicación en dicha plataforma. Ya conocía Heroku porque había hecho algunas cosillas para el doctorado aunque nunca está de más que una persona como James te lo cuente. Personalmente, me sigo quedando con Cloud Foundry, creo que está un escalón por encima. 
  • Polyglot Messaging with RabbitMQ. Presentación de RabittMQ en la que se habla sobre esta plataforma de mensajes y cómo, gracias a su agnosticismo, se pueden escribir programas en multitud de lenguajes. El ponente presentó ejemplos (hablo de memoria) en Java, Erlang, Haskell, Python, . . . y seguro que me dejo alguno. La primera parte de la charla estuvo más o menos entretenida puesto que contó de manera general el funcionamiento de RabbitMQ. Sin embargo, la segunda parte comenzó a escribir ejemplos en multitud de diferentes lenguajes, a cambiar de editor a una velocidad de vértigo, ahora me funciona, ahora no, esto no me compila, . . .
  • Comparing JVM Web Frameworks. Comparación de algunas de los frameworks de desarrollo web más populares. Establece diversos factores de comparación entre plataformas como Struts, Grails, Lift, Rails, Vaadim, Play!. Poco puedo decir de esta charla que no se haya dicho ya. La verdad que la comparativa está muy bien realizada y puede ayudar a una persona a decantarse en la elección de un framework de desarrollo web. 
  • NoRedeploys: Instant updates in dev and prod. Presentación de JRbel y LiveRebel. Durante mucho tiempo estuve utilizando JRebel tengo que decir que es un producto que me encanta. Fui a la charla con la expectativa de que iban a contar cosas técnicas de cómo hacen internamente las cosas y lo que me encontré fue una presentación con un cierto grado de tendencia comercial. Ojo, no estoy diciendo que eso este mal; sino que simplemente me esperaba otros contenidos en la charla.
  • Spring Data y JPA: Charla muy bien presentada, con ejemplos y mecanismos de como funciona. No me gusta mucho el enfoque que la ha dado la gente de Spring al proyecto (te tienes que acoplar muchísimo a sus clases) pero he de reconocer que fue una charla muy entretenida.
  • MongoDB en un proyecto real. Charla presentada por David Gomez, no hemos tenido la suerte de desvirtualizar, en la que presenta el uso de MongoDB en una aplicación que han desarrollado para la gestión de puertos. Para aquella gente que no conozca mucho el mundo de NoSQL y conceptos como CAP, BASE, . . . creo que la primera parte de la charla es un muy buen punto introductorio. Luego se le echó el tiempo encima y tuvo que ir bastante deprisa.
Especialmente malas fueron la de Graeme Rocher hablando sobre Grails 2.0 (por cierto, como el reloading de las clases funcione igual de mal que durante su presentación . . . .) y la de novedades de Spring 3.1 a Spring 3.2 por Sam Brannen, básicamente porque de Spring 3.2 contó bien poco, por no decir nada.

Como decía al principio, me he quedado con un sabor de boca agridulce. 

Ya para terminar, me gustaría agradecer a toda la gente que hace que este evento sea posible: organizadores, ayudantes, patrocinadores, . . . 

Hasta pronto!

martes, febrero 21, 2012

Scala Implicits: simple examples

Durante la entrada anterior analizábamos los conceptos básicos de los implicits en Scala desde un punto de vista "teórico", dejando a un lado los ejemplos de código con el objetivo de no convertir el post en algo completamente inmanejable e incomprensible. A lo largo de la entrada que nos ocupa analizaremos diversos ejemplos de aplicación, describiendo con la mayor exactitud posible el mecanismo de funcionamiento de los implicits aquí descritos.

Como punto de partida realizaremos un sencillo ejemplo en el que veremos como realizar conversiones automáticas a un tipo determinado (el compilador las realizará por nosotros). Supongamos que disponemos de la siguiente definición de clase

class User (private val username:String)

y que deseamos obtener instancias de la clase anterior sin la necesidad de realizar llamadas del tipo 

val user:User = new User("migue")

El primer paso que debemos dar será llevar a cabo la definición del implicit correspondiente. En este caso la conversión deberá realizarse desde String hacia User. Para ello definimos algo como lo que sigue:

object UserImplicits {
    implicit def stringToUsername(user: String) = new User(user)
}

Nuestra siguiente tarea será hacer que el implicit anterior esté disponible en el ámbito donde lo queramos utilizar (una buena práctica suele ser realizar la definición de todos nuestros implicits en un singleton object llamado Preamble e importar dicho objeto al comienzo de nuestras clases):


import UserImplicits.stringToUsername
val user:User = "migue"

¿De verdad el código anterior compila? ¿Que está pasando? El proceso es "muy sencillo", el compilador detecta que hay un error de tipos puesto que no puede asignar una cadena a una variable de tipo User. Antes de declarar que existe un error ocasionado por una asignación de tipos incorrecta, el compilador busca si existe una conversión implicita disponible que le permita resolver el error encontrado. En este caso, el compilador buscará si existe un implicit que nos permita convertir una cadena de texto en un objeto de la clase User. Si revisamos la definición de nuestro primer implicit veremos que disponemos de una función que cumple los requisitos que el compilador está intentando satisfacer, por lo que este último, de manera interna, realizará algo similar a


val user:User = stringToUsername("migue")

El segundo ejemplo de uso de los implicits que vamos a tratar son las conversiones de objetos sobre los que se realiza la llamada de un método. Nuestro objetivo será añadir nuevos métodos a una clase externa que podría estar definida en una librería third-party sobre la que no tenemos ningún tipo de control.

Imaginemos la siguiente definición de clase en una librería externa (por sencillez esta clase estará definida en el propio archivo de código fuente junto al resto de ejemplos)


class ExternalClass {
def f1() = {
"f1"
}


def f2() = {
"f2"
}
}

en la que nos gustaría incluir el método def f3() = {"f3"}. Para llevar a cabo nuestra tarea construiremos una clase auxiliar en la que definiremos el método que deseamos incluir:



class MethodHelper {
def f3(): String = {
"f3"
}
}

e incorporamos un nuevo implicit


implicit def newMethodsToExternalClass(externalClass:ExternalClass) : MethodHelper = {new MethodHelper }



A continuación podremos escribir un código similar al que sigue:


import UserImplictis.newMethodsToExternalClass


println("Method f3() is added via an implicit conversion: " + externalClass.f3())


¿Qué está ocurriendo en esta ocasión? Durante el proceso de compilación, Scala detectará que existe un error puesto que el método f3() no forma parte de la definición de la clase ExternalClass. Antes de emitir un error, el compilador buscará una conversión implícita en la que se convierta el objecto receptor de la llamada del método f3() en un objeto que realmente posea dicho método. En nuestro ejemplo newMethodsToExternalClass es el elemento que nos permite que el código anterior compile correctamente. ¿Que está ocurriendo internamente? El compilador estará emitiendo un código similar al siguiente:

newMethodsToExternallClass(externalClass).f3()

Como último ejemplo para esta entrada, revisaremos cómo podemos hacer uso de parámetros implícitos en las llamadas a funciones. Incorporemos el siguiente método a la definición de la clase User

def encodePassword(password:String)(implicit encoder: Encoder) : String = {

encoder.encode(password)
}

Fijémonos que hemos marcado el segundo argumento de la función como implicit por lo que el compilador intentará completar las llamadas a la función añadiendo los parámetros necesarios. Definamos un encoder de ejemplo (que no realiza ningún tipo de operación útil) y utilizemos


implicit object IdentityEncoder extends Encoder {
  override def encode(password:String): String = password
}



import UserImplictis.IdentityEncoder


user2.encodePassword("foo")

Como podemos observar en el fragmento del código anterior en ningún momento estamos indicando el segundo parámetro de la función encodePassword sino que es el propio compilador el que está intentado incluir en la lista de parámetros alguno de los implictis disponibles de manera que la llamada de la función sea correcta.

Ha sido una entrada un poco larga pero he considerado que todos los ejemplos encajarían mucho mejor en una misma entrada de manera que pudieramos realizar un comparativa de los diferentes puntos de utilización de este poderoso mecanismo.

Importante: los snippets de código que aparecen a lo largo de esta entrada no están listos para ejecutarse en el REPL por lo que os aconsejo que, si quereis jugar con el código fuente, utilicéis aquel que está disponible aquí (realizaré el merge de esta rama sobre master tan pronto como me sea posible).

Hasta pronto!

Migue


lunes, febrero 20, 2012

Scala implicits (I)

Durante numerosas entradas hemos estado hablando del lenguaje de programación Scala, analizando algunas de sus principales características y/o la interacción con otros lenguajes: conceptos básicos, traits, parser combinators, combinando AspectJ y Scala, . . . Podéis encontrar todas las entradas relacionadas en el siguiente enlace: http://miguelinlas3.blogspot.com/search/label/Scala y un pequeño documento en el que se realiza una somera introducción al lenguaje: https://github.com/migue/blog-examples/tree/master/scala-intro

Durante las siguientes entradas me gustaría ahondar en algunas características más "avanzadas" del lenguaje como "type parametrization", "abstract members" o "implicitis" (estás últimas las abordaremos durante la entrada que nos ocupa).

El principal problema que se nos presenta cuando trabaja mos con una librería de terceros es la dificultad de extender y/o modificar el comportamiento de la misma. A lo largo de los diferentes lenguajes existentes podemos encontrar numerosas alternativas, cada una con sus ventajas e inconvenientes, como las open classes de Ruby o el ExpandoMetaclass de Groovy.

La respuesta de Scala al problema que nos ocupa son los implicits. El compilador intentará incluir en nuestro código fuente aquellos implicits que se encuentren disponibles con el objetivo de solventar cualquier "problema de tipos". De manera general, se rigen por las siguientes reglas:

  • Sólo estarán disponibles para el compilador aquellas definiciones que nosotros marquemos de manera explícita como implicit.
  • Los implicits deben estar disponibles en el ámbito de uso.
  • El compilador solamente intentará incluir un implicit de cada vez
  • El compilador no reemplazará código correcto.
  • ¿Dónde se utilizan los implicits?
    • Conversiones a un tipo determinado
    • Conversiones del objeto que recibe la llamada a un método
    • Parámetros de funciones
Hemos visto una pequeña introducción sobre la teoría de los implicits en Scala, las reglas que rigen el funcionamiento de los mismo y las aproximaciones que otros lenguajes utilizan. Puede que con este contenido la entrada se quede un poquito escueta pero he preferido dividirlo en dos entradas independientes por lo que en el próximo post realizaremos un ejemplo práctico y veremos las aplicaciones reales de esta potente (y a veces compleja) funcionalidad que el lenguaje nos brinda.

Hasta pronto!

Migue

lunes, enero 02, 2012

Algunos libros para comenzar el año

Unos cuantos libros para comenzar el año de la mejor manera posible: aprendiendo cosas nuevas.

The Garbage Collection Handbook. Este libro ofrece una visión actualizada del estado del arte de los sistemas de recolección de basura y la gestión automática de memoria. He leido varias críticas de Gil Tene (CTO de Azul Systems) y en todas ellas pone al libro por las nubes.

No he tenido ocasión de leerlo, todavía, pero está en las primeras posiciones de la lista de libros que me gustaría leer este comienzo de año.




Para aquellos que estéis interesados en los sistemas distribuidos y/o trabajeis con ellos aquí podréis encontrar una magnífica y extensa referencia sobre este tipo de sistemas: fundamentos, algoritmos , etc.

No estoy seguro si ya he hablado de este libro con anterioridad pero la verdad es que se trata de una magnífica y reconfortante lectura en la que se pueden aprender infinidad de cosas.



Excelente lectura si os gusta conocer los "internals" del sistema operativo Linux y cómo funcionan la mayoría de sus principales subsistemas: gestión de procesos, gestión de memoria, etc. Posiblemente nunca escribamos ni una línea de código relacionada con el núcleo de este sistema operativo pero estoy convencido de que esta lectura puede ayudarnos como desarrolladores a escribir mejores programas.









Hasta pronto!

Propósitos para 2012

Un año nuevo que comienza cargado de ilusiones, apasionantes retos personales y profesionales y grandísimas noticias. Al igual que el año anterior me gustaría escribir esta pequeña entrada en la que plasmar todas las buenas intenciones para este nuevo año que acaba de comenzar. Sobra decir que, tal y como ha ocurrido con las intenciones de hace doce meses, algunas se cumplirán y algunas no; esperemos que con tesón, perseverancia y muchas muchas ganas muchas de ellas sean algo más que meras intenciones. 

Algunas de las cosas que tengo en mente:
  • Pasar el máximo tiempo posible con mi hijo y mi novia. Como tod@s ya sabéis el pasado mes de noviembre hemos sido padres por primera vez y quiero disfrutar al máximo del niño y de todo lo que lo rodea.
  • Casarme. La única duda que tengo respecto a este tema es el tipo de celebración que vayamos a realizar aunque todo indica que no llevaremos a cabo una "boda tradicional" cientos de invitados sino que será algo extremadamente simple.
  • Retomar el tema del doctorado. Acontecimientos de diversa índole como la parálisis facial, la operación de corazón de mi suegra, el nacimiento de Sergio y algunas cosas más hicieron que durante el segundo semestre del año pasado me costara mucho más poner orden y determinación. Esperemos que en este año que comienza sea capaz de organizarme de manera mucho más eficaz y pueda retomar las diferentes cosas del doctorado que ahora mismo tengo en un estado de abandono absoluto.
  • Ponerme en forma Practicar algo de deporte. Creo que practicar algo de deporte es algo muchto más realista. Soy consciente de que recuperar el estado de forma que tenía cuando jugaba al fútbol y practicaba surf es una utopía con lo que me conformaré con salir a correr de vez en cuando y perder unos cuantos kilillos que he cogido durante el último viaje a EEUU y estas navidades (que todavía no han tocado a su fin y tengo unas cuantas citas pendientes) .
No podía terminar este post sin hacer mención a las cosas ligadas al mundo de la tecnología que me gustaría hacer durante este año:

  • Asistir a alguna conferencia más que el año anterior. El año pasado estuve hablando en Spring I/O sobre Hadoop y este año tenía medio preparada una presentación sobre los internals de Cloud Foundry aunque finalmente no tuve tiempo de enviarla por lo que este año, en caso de que pueda asistir, será unicamente como oyente. 
De momento ya tengo la entrada para los Scala Days 2012 (todavía tengo que gestionar el hotel y el viaje)
  • Aprender nuevas cosas y mejorar muchas de las que yo conozco. Mejorar mis habilidades con  Scala, participar más activamente en algunos proyectos en los que he hecho algunas cosillas, dar "pasos mucho más serios" en otros lenguajes como Go y Haskell, profundizar mis conocimientos de sistemas distribuidos, . . . .
Tenía algunas cosas más en mente pero tengo que cortar aquí porque está el niño llorando y tengo que ocuparme de el.

Feliz año 2012 a tod@s y esperemos que no sea tan malo como lo pintan!

Hasta pronto!