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!

lunes, noviembre 28, 2011

Algunos libros sobre Java y JVM

Durante estas últimas semanas he tenido la ocasión de terminar varios de los libros que tenía pendientes así como de realizar alguna nueva adquisición que, de momento, está encolada en mi lista de lectura.

Me gustaría aprovechar esta entrada para compartir con vosotros algunos de los libros anteriores que, bajo mi punto de vista, podrían resultar interesantes para tod@s aquell@s que os dediquéis, de algún modo, a trabajar con la plataforma Java (lenguaje y/o máquina virtual).

El primero de ellos es Java Performance from The Java Series. Escrito por Charlie Hunt, JVM performance lead engineer en Oracle, y  Binu John, senior performance engineer en Ning. Ha sido mi última adquisición y únicamente he podido leer los dos primeros capítulos pero creo que estamos ante uno de las lecturas obligatorias para tod@s aquell@s que se dedican y/o les gusta el mundo del rendimiento de aplicaciones sobre la JVM.

JVM Tuning, profiling, mediciones, herramientas, escritura de benchmarks, internals de la JVM, algoritmos de recolección de basura y tuneo de los mismos, gestión de la memoria,  . . .  son sólo algunas de las temáticas tratadas en este magnífico manuscrito.


Otro magnífica referencia  relativa al mundo Java: The well-grounded Java developer. Se trata de un early access por lo que sólo he podido leer los capítulos disponibles hasta el momento. Pensado para desarrolladores con unos sólidos conocimientos de Java el libro abarca un amplio espectro de temáticas como pueden ser:
  • Algunas de las novedades de Java 7
  • Nuevo mecanismo de IO y concurrencia
  • Classfiles y bytecode
  • Inyección de dependencias
  • Lenguajes alternativos en la JVM: Clojure, Groovy y Scala
  • Integración continua
  • . . .
En lineas generales creo que se trata de una lectura recomendada (a la espera de que se publique la segunda mitad del libro). Los capítulos pueden ser leidos de manera independiente, saltándose aquellos en los que ya se conoce de manera profunda la temática tratada en el mismo.

Un libro que había leido hace tiempo y que he vuelto a leer hace  unas semanas ha sido Java Concurrency in Practice. Poco puedo decir de este libro que no se haya dicho ya. Otra de las lecturas obligatorias para todos aquellos desarrolladores que trabajen con el lenguaje Java.

Ofrece una visión práctica de cómo se deben escribir programas escalables y seguros aprovechando la capacidad de las nuevas arquitecturas hardware.









Functional Programming for Java Developers. Escrito por Dean Wampler. Es un libro en el que se introducen los conceptos básicos de la programación funcional (que está "renaciendo" gracias a lenguajes como Scala o Clojure, además de sus beneficios a la hora de escribir programas concurrentes entre otras muchas cosas).

Es un libro muy cortito aunque personalmente no me ha entusiasmado demasiado. Si no tenéis ninguna experiencia en programación funcional puede ser un buen punto de partida. No se cubren mónadas, laziness ni combinators.

jueves, octubre 06, 2011

Escalabilidad, disponibilidad y estabilidad

En algunas ocasiones hemos hablado de temas de escalabilidad y disponibilidad de sistemas aunque siempre desde un punto de vista muy práctico, haciendo referencia a los problemas que ocupan nuestro día a día. Me gustaría recopilar, a lo largo de una serie de posts, algunos de los patrones y/o tecnologías más populares relacionados con la escalabilidad, la concurrencia o la alta disponibilidad.

Me gustaría dejar claro desde un principio que lo aquí expuesto son simplemente mis ideas, adquiridas a lo largo del tiempo gracias a la experiencia acumulada en la construcción de diversos sistemas software, mis estudios de doctorado, leer y practicar mucho, aprender de los maestros y pasarme muchas, pero muchas muchas,  horas aporreando el teclado. Por tanto, las cosas que aquí aparecen podrían ser erróneas y/o incompletas.

Me gustaría comenzar con una tecnología relacionada con la concurrencia: la memoria transaccional (STM en adelante).

Escribir programas concurrentes es una tarea sumamente complicada y, habitualmente, no determinista; ¿cuantas veces habremos probado un programa multihilo en nuestros sistemas de integración continua y , tras poner el sistema en producción, nos hemos encontrado con nuevos errores? Tan real como la vida misma.

Habitualmente las inmutabilidad (hablaremos de ella en el futuro) es un gran aliado a la hora de escribir programas concurrentes dado que resulta mucho más sencillo razonar sobre información cuyo estado permanece estable. Sin embargo, como en la mayoría de las situaciones, la inmutabilidad no es una bala de plata que soluciona todos los problemas por lo que tendremos que lidiar con información cuyo estado puede variar y con toda la problemática asociada a la misma. Llegados a esta situación, y siguiendo con el enfoque con el que estamos más familiarizados, estaríamos peleándonos con bloqueos, granularidad de los mismos, etc.

Un vistazo a la STM

La STM puede ayudarnos a resolver el problema anterior de manera mucho más sencilla visualizando la memoria (heap + pila) como si de un dataset transaccional se tratara. Algunas de las características más relevantes:

  • Concepto muy similar al de una base de datos tradicional. Se llevan a cabo operaciones como begin, commit o abort/rollback
  • En caso de que se produzca una colisión la transacción será relanzada de manera automática
  • Se realiza un proceso de rollback sobre la memoria cuando se produce una operación de abort.
  • Las transacciones se pueden componer y anidar

Un aspecto sumamente importante que debemos tener en cuenta a la hora de utilizar la memoria transaccional es que todas las operaciones englobadas en el ámbito de una transacción deberán ser idempotentes (anteriormente hablábamos del relanzamiento automático en caso de que se produjera una colisión).

Existen numerosas implementaciones disponibles para la máquina virtual de Java (JVM) entre las que destacan:

En la siguiente entrada realizaremos varios ejemplos prácticos de uso de la memoria transaccional y analizaremos cuales son los escenarios más propicios para la utilización de esta solución.

Hasta pronto!

Migue

miércoles, octubre 05, 2011

[Off-Topic] Poniéndome al día y buenas noticias

Hola a tod@s,

Hace más de un mes y medio de la última entrada en el blog pero es que me está costando mucho más de lo esperado retomar todas las cosas pendientes y/o atrasadas por lo que últimamente me estoy agobiando un poquito. De todos modos el objetivo de la entrada no era aburriros con mis "problemas" sino comentaros una buena noticia, al menos para mi :), aunque seguro que muchos de los que os pasáis por aquí ya lo sabréis: ¡vamos a ser papás!

Así es; si todo sigue como hasta ahora, dentro de cuatro semanas aproximadamente tendremos  a nuestro hijo Sergio entre nuestros brazos.


Estos últimos meses han sido, sin lugar a dudas, los mejores meses de mi vida. Meses de cambio, de preparar la casa, de descubrir cosas que ni siquiera sabía que existían o de convertirme en un "manitas".



Con toda seguridad los cambios serán mucho más notables cuando el pequeño nazca pero de momento prefiero no adelantar acontecimientos y centrarnos en disfrutar del "poquito" tiempo de embarazo que nos queda.


Dentro de poco tendré que repartir mimos y cuidados entre mis dos amores aunque mi gordita dice que nada de dividir, que como mínimo duplicar así que . . . difícil tarea me espera.

Hasta pronto!

Migue

viernes, agosto 26, 2011

De regreso

Ya estoy de vuelta.

Por suerte ya me he recuperado por completo de mi parálisis facial (finalmente "solo" me duró once días aproximadamente) con lo que de nuevo estoy online.

La entrada no será muy larga :) , simplemente quería que supierais que me encuentro perfectamente.

Espero retomar el blog durante los próximos días aunque con lo que tenemos en camino tengo una agenda en la que el tiempo libre brill a por su ausencia.

Hasta pronto!

Migue

PD: he escrito la entrada desde el iPad y la verdad que se escribe mucho más rápido de lo que uno podría esperar en un principio.

martes, agosto 02, 2011

Offline

Durante los próximos días estaré "offline" por completo. Nada de ordenador, IPad, Internet y similares :). Voy a ver si consigo desconectar por completo durante estos días y termino de recuperarme de mi parálisis facial.

Hasta pronto!

Migue