Todas las entradas de: mmacias

try-with-resources en Kotlin

Una de las grandes novedades que nos trajo Java 7 fue el soporte para try-with-resources, que nos permitía definir bloques que, utilizando un recurso que implementara la interfaz “AutoCloseable“, cerraban éste implícitamente sin tener que preocuparnos de llamar a su método “close()“. Por ejemplo:

try (BufferedReader br = new BufferedReader(new FileReader(path))) {
   return br.readLine();
}

Kotlin provee una solución equivalente para los objetos del tipo “Closeable“, que es la función “use“:

BufferedReader(FileReader("dsf")).use {
    it.readLine()
}

Sin embargo, parece que los creadores de Kotlin se han olvidado de las clases AutoCloseable, tales como los PreparedStatement de JDBC. Para solucionarlo, he creado una función trywr, fácilmente integrable en cualquier código

package info.macias.kotlin
inline fun <T:AutoCloseable,R> trywr(closeable: T, block: (T) -> R): R {
    try {
        return block(closeable);
    } finally {
        closeable.close()
    }
}

Un ejemplo de uso sencillo:

import info.macias.kotlin.trywr
fun countEvents(): Long {
    return trywr(connection.prepareStatement("SELECT COUNT(*) FROM event")) {
        var rs = it.executeQuery()
        rs.next()
        rs.getLong(1)
    }
}

No obstante, me comentan en Stackoverflow que aunque la solución es sencilla y hará su función, no reproducirá exactamente el comportamiento estándar de Java.

Integrando Kotlin en aplicaciones web

Java, pese a las impresionantes mejoras que trae en su versión 8, siempre me ha parecido un lenguaje un poco verboso y con algunas incomodidades con respecto a C#.

Lenguajes como Python, Ruby o ECMAScript son cómodos y ágiles, pero no me gustan para proyectos de cierta envergadura puesto que, siendo tan despistado como soy, prefiero lenguajes con tipado estático que me muestren los errores en tiempo de compilación y ahorrarme tener que buscarlos con el depurador.

Groovy es un gran lenguaje, aunque un tanto lento. A la filosofía Scala no me he acabado de acostumbrar, y siempre acabo haciendo programas con la misma estructura que si de un programa Java se tratara. Además, he tenido algunos problemas tratando de integrar Scala con librerías Java.

A pesar de las críticas que programadores “new age” lanzan por una cuestión de moda, me gusta la Máquina Virtual de Java y el impresionante número de librerías y frameworks maduros que posee. No cambiaría para irme a Rails o Node, a pesar de sus muchas otras ventajas. Quizás la cambiaría para irme a .NET si éste finalmente llega a ser completamente multiplataforma (otro sacrilegio, no solo para programadores “new age”  si no también para aquellos que asocian automáticamente Microsoft con malvado y malo).

Durante estas vacaciones he tenido tiempo de probar por encima Kotlin, y la verdad es que las primeras impresiones han sido buenas. Principalmente, me ha gustado, entre otras:

  • Es estáticamente tipado
  • Le quita verbosidad a Java
  • Getters y setters directamente definidos en los atributos, y no como métodos (al estilo de C# o Groovy)
  • Null safety
  • Sobrecarga de operadores al estilo de C++
  • Data classes
  • Lo extremadamente bien que se integra con las librerías existentes de Java
  • El soporte de Jetbrains le da en su IDE, incluida la funcionalidad de traducir automáticamente código Java a Kotlin

Como demostración (y para mi utilidad propia en aplicaciones futuras), he creado este pequeño proyecto web que integra Kotlin con algunas librerías para el desarrollo web, tales como Struts 2 y Tiles para la gestión del Modelo Vista Controlador, Shiro para la gestión de la seguridad, y Jersey para la implementación de servicios REST.

El enlace en cuestión, con sus respectivas instrucciones de puesta en marcha: https://github.com/mariomac/kwebbt

 

Libro: Introducción a Apache Spark

Recientemente tuve el placer de escribir y editar este libro junto con otros tres autores:

INTRODUCCIÓN A APACHE SPARK para empezar a programar el Big Data
Mario Macías, Mauro Gómez, Rubèn Tous y Jordi Torres
Editorial UOC, Noviembre 2015
ISBN: 978-84-9116-037-3

Hay mucha excitación en relación con el análisis del big data, pero también mucha confusión en decidir por dónde empezar para aquellos que quieren iniciarse en la programación en este apasionante mundo. Este libro proporciona al lector una oportunidad para empezar a programar y manejar datos a través del ecosistema Apache Spark. Spark es actualmente uno de los paquetes de código abierto más importantes en el espacio del big data y por el que importantes empresas, como IBM, SAP, Oracle o Amazon, han apostado, al tiempo que son también grandes contribuidoras. Este libro, que puede utilizarse como texto de autoestudio o de soporte a cursos que requieran una introducción a Apache Spark, contiene una excelente visión introductoria de Apache Spark, una descripción de su ecosistema y de sus características básicas e incluye ejemplos de código para que el lector los pueda probar en su propio PC si lo desea y así tener una comprensión de primera mano de algunas de sus posibilidades.

El libro ya está a la venta en las principales librerías. También se puede adquirir en los portales:

La Casa del Libro

Portal Amazon

Portal editorial UOC

El edición del libro en papel también se podrá adquirir a través de cualquier librería española, así como también a través en cualquier librería Hispanoamérica (México, Argentina, Colómbia, Chile, Perú, etc.) por medio de la red de distribuidores de la que dispone la editorial UOC en estos paises.

La distribución digital del libro, a nuestro pesar, se retrasará un tiempo de acuerdo con las políticas de distribución de la editorial UOC. Cuando esté disponible se podrá adquirir a través de las principals plataformes digitales: Amazon, Apple, Bluebottle, Casa del Libro – Tagus, Casalini, Dawsonera, Digitalia, Digital Books, e-Libro, El Corte Inglés, Google Play, Kobo, Liberdrac, Odilo, así como también en la web de la editorial UOC.

EasyRPC: crea fácilmente servicios RPC en puro Java

Acabo de publicar una versión inicial de EasyRPC en GitHub.  EasyRPC es una librería que automáticamente crea servicios y clientes web en tiempo de ejecución para Java.

Las características que destaco son:

  • Fácil de adoptar y usar. Descarga las librerías y úsalas directamente en el código para crear servicios web como cualquier otra clase Java, sin necesidad de lidiar con las complejidades de la serialización y el envío de datos.
  • Comunicación a través de HTTP y AMQP 1.0. Extensible a otros protocolos de comunicación.
  • Serialización a través de JSON-RPC 2.0. Extensible a otras especificaciones (SOAP, ProtoBuf…)

Todo ello, insistiendo, programando simples clases Java de la misma manera en que se programarían para ser ejecutadas en local.

A continuación se muestra un ejemplo de uso:

Programación del servidor

Paso 1: crea una interfaz con los métodos de tu servicio.

public interface IFace {
    int add(int a, int b);
    String concat(String s1, String s2);
    int[] doubleArray(int[] arr);
}

Paso 2: implementa la el servicio como una clase Java corriente que se fuera a ejecutar en local.

public class Implementation implements IFace {
    @Override
    public int add(int a, int b) {
        return a+b;
    }
    @Override
    public String concat(String s1, String s2) {
        return s1+s2;
    }
    @Override
    public int[] doubleArray(int[] arr) {
        for(int i = 0 ; i < arr.length ; i++) {
            arr[i] = arr[i] * 2;
        }
        return arr;
    }
}

Paso 3: instancia el servidor, especificando el protocolo de comunicación y el tipo de serialización.

Ejemplo 1: JSON-RPC 2.0 a través de HTTP

RpcServer server = new RpcServer(
            new HttpService(8080,"/rpc"),
            new JSONCallee());

Ejemplo 2: JSON-RPC 2.0 a través de AMQP 1.0:

RpcServer server= new RpcServer(
      new AmqpService(
              new URI("amqp://localhost:5672"),
              "rpcQueue"),
      new JSONCallee());

Paso 4: registra  el servicio a través de la clase que lo implementa, e inicia el servidor.

server.addEndpoint(new Implementation());
server.start();

Uso del cliente

Paso 1: obtén la interfaz IFace que describe el servicio a ejecutar. Ésta debe ser proporcionada por el proveedor, compartiendo, por ejemplo, el código fuente o un archivo JAR.

Paso 2: instancia el generador de clientes. En el ejemplo, habilita la comunicación a través de HTTP y la serialización a través de JSON-RPC 2.0.

ClientFactory clFact =
     new ClientFactory(
             new HttpClient(
                     "server.address.com",
                     8080, "/rpc"),
     new JSONCaller());

Paso 3: instancia el cliente.

IFace ws = (IFace) clFact.instantiate(IFace.class);

Paso 4: usa el servicio:

int result = ws.add(2,3);
String completo = ws.concat("Hola", " mundo!");

MongoAL: MongoDB Aggregation Language

Hace unas semanas comentaba cómo agregar datos para una serie temporal con MongoDB.

Hoy veremos cómo sería el léxico de dicha agregación mediante MongoAL, un lenguaje de agregación para MongoDB que un servidor acaba de publicar en su versión previa y, si bien de momento no aporta ninguna funcionalidad nueva sobre lo existente,  provee un léxico más amigable para un ser humano. El objetivo de dicho lenguaje es exponer el framework de agregación a clientes y usuarios genéricos que no tienen por qué conocer la estructura JSON del pipeline de agregación de MongoDB.

Recordemos el léxico de una consulta para crear una serie temporal:

[{ "$match":{ "proceso": "1234" }},
{"$group" : {
    "_id" : {
       "$subtract" : ["$timestamp" ,
                    {"$mod" : [ "$timestamp",
                                300000 ] }]},
    "cpu" : {"$avg": "$cpu" }
 }},
{"$sort":{"_id":1}}]

El equivalente en MongoAL sería (suponiendo que, por ejemplo, los elementos están en una colección llamada monitor):

FROM monitor MATCH proceso = 1234
GROUP BY timestamp - timestamp % 3000
      avg(cpu) as cpu
SORT BY _id ASCENDING

Docker como alternativa a la (ya clásica) virtualización

Hace menos de una década asistimos al estallido de la Infraestructura como Servicio (IaaS, Infrastructure as a Service en inglés) por las evidentes ventajas económicas de la llamada Nube: gracias a la virtualización, ese mecanismo mediante el cual un grupo Máquinas Virtuales ejecutan a la vez varios sistemas operativos sobre un mismo hardware, los usuarios de la Nube son capaces de dimensionar dinámicamente sus recursos contratados, adaptándolos a las necesidades puntuales de cada momento del día, y obteniendo total acceso a la configuración software, como si se tratara de su propio servidor físico.

Si bien la utilidad del modelo IaaS sigue siendo incuestionable, dicho modelo puede ser técnicamente pesado e ineficiente cuando se usa como base para modelos de Plataforma como Servicio Software como Servicio (PaaS y SaaS, respectivamente). Muchas veces se usan máquinas virtuales como soporte para aplicaciones relativamente ligeras, lo que implica empaquetar sistemas operativos completos más sus librerías genéricas. Además, arrancar una aplicación puede llegar a ser un proceso lento, puesto que implica arrancar el sistema operativo completo y sus servicios asociados.

Captura de pantalla 2014-10-20 a las 17.30.47

Docker nace en parte como alternativa a las máquinas virtuales, substituyendo éstas por contenedores mucho más ligeros que tan sólo empaquetan las aplicaciones a distribuir y las librerías que necesitan. El papel del hipervisor, la capa que gestiona cómo y cuando acceden las máquinas virtuales al hardware, se substituye por el motor de Docker.

Captura de pantalla 2014-10-20 a las 17.30.57

¿El resultado? Pasamos de máquinas virtuales que podían llegar a ocupar varios GigaBytes en disco a contenedores que en la mayoría de casos ocupan unas decenas de MegaBytes (con las consiguientes ventajas a la hora de ser transferidos por Internet). Por otra parte, al eliminar pesadas capas software, con Docker obtenemos más ligereza, lo cual es de agradecer cuando requerimos alta responsividad y escalabilidad. Y por último, el proceso de elasticidad mediante el cual obtenemos o dejamos recursos a medida que los necesitamos es todavía más dinámico, puesto que arrancar nuevos contenedores es siempre más rápido que cargar una máquina virtual completa.

Agregar datos para una serie temporal con MongoDB

Supongamos una colección de datos en MongoDB que contiene documentos con una estructura similar a la siguiente, pertenecientes a un sistema de monitorización que guarda qué porcentaje de CPU consume cada proceso:

{ "proceso" : "1234",
  "timestamp" : 14567888841,
  "cpu" : 31.3 }

{ "proceso" : "33212",
 "timestamp" : 14567888941,
 "cpu" : 104 }

{ "proceso" : "1234",
 "timestamp" : 14567898381,
 "cpu" : 28.5 }

// etc...

Siendo “timestamp” una marca de tiempo. Por ejemplo, el número de milisegundos desde el 1/1/1970 00:00 UTF (System.currentTimeMillis en Java).

Si quisiéramos crear una serie temporal con, por ejemplo, el consumo medio de CPU del proceso ‘1234’ en bloques de 5 minutos (300.000 milisegundos), podríamos usar el framework de agregación de MongoDB enviando la siguiente petición (función aggregate):

[{ "$match":{
   "proceso": "1234"
 }},
 {"$group" : {
   "_id" : {
      "$subtract" : ["$timestamp" ,
                    {"$mod" : [ "$timestamp",
                                 300000 ]
                    }]
   },
   "cpu" : {"$avg": "$cpu" }
 }}]

Esta orden nos devolvería un array con todos los elementos de la serie de tiempo, similar al siguiente:

[{ "_id" : 14742000000, "cpu" : 22.33 },
 { "_id" : 14742300000, "cpu" : 12.30 },
 { "_id" : 14742600000, "cpu" : 33.75 },
 { "_id" : 14742900000, "cpu" : 10.69 },
 { etc... }}

Del bit a la Nube

Oferta, por tiempo limitado: ¡Del Bit a la Nube disponible gratuitamente en Google PlayApple iBooks, y  Amazon Kindle!

Portada Del Bit a la nube

Si te gusta mi blog, quizás también te guste “Del bit a la Nube“, mi e-Book de divulgación sobre la ciencia detrás de las computadoras.

¿Quién no se ha preguntado alguna vez qué tiene una computadora en su interior, y cómo funciona para poder hacer tan diversas tareas? Explicar esto de una manera concisa y sencilla es el propósito de este libro, haciéndolo a través de diversos capítulos que intentan cubrir todo el abanico de conocimientos en la ciencia de las computadoras: desde las simples corrientes eléctricas hasta la llamada “Nube” y la actual revolución del “Big Data”.

Por 2,99€ (¡Gratis en Apple iBooks, Google Play, y Amazon Kindle por tiempo limitado!) en las principales tiendas online:

 

Tu blog gratis en la nube con OpenShift

OpenShift es una Plataforma como Servicio (Platform as a Service, PaaS) muy chula que provee la empresa Red Hat, que además proporciona tres “small gears” gratuitos al cualquier usuario (un “gear” es la unidad de capacidad de OpenShift).

Quien quiera un blog personal que reciba pocas visitas puede aprovecharse de este servicio para tener en cuestión de minutos un blog en WordPress totalmente operativo y configurable, sin las limitaciones de los blogs gratuitos que ofrece wordpress.com, sin publicidad de terceros y sin que le cueste ni un céntimo.

En este tutorial, aprenderás a:

  • Crear un blog en WordPress con OpenShift
  • Instalar el paquete de idioma español para WordPress en Openshift
  • Configurar WordPress, OpenShift y tu gestor de dominios para usar tu propio dominio

Seguir leyendo Tu blog gratis en la nube con OpenShift