Developing Android Apps

Udacity lanzo un curso gratuito muy interesante de Android. Aun que cuesta 150 dolares tener correcciones personalizadas y "trato" especial, el curso es gratuito.

Les dejo un vídeo:

Dejo link:
https://www.udacity.com/course/ud853

Debian AIO: todos los sabores de Debian en un solo disco

Robe este post, es de http://lamiradadelreplicante.com/

Quiero hacerme eco de esta super version de Debian que permite probar todos los sabores del sistema operativo. Debian Live AIO DVD es un proyecto no oficial de Debian que incluye todas las ISOs de los principales entornos presentes en esta distribución GNU/Linux, como son KDE, GNOME, Xfce y LXDE, en un único archivo.

Dejo el link, del post original:
http://lamiradadelreplicante.com/2014/07/14/debian-aio-todos-los-sabores-de-debian-en-un-solo-disco/

Un orgullo enorme!! Gracias Campeones!!

Entendiendo el principio HATEOAS

HATEOAS es la abreviación de Hypermedia as the Engine of Application State (hipermedia como motor del estado de la aplicación). Es una restricción de la arquitectura de la aplicación REST que lo distingue de la mayoría de otras arquitecturas. El principio es que un cliente interactúa con una aplicación de red completamente a través de hipermedia proporcionadas dinámicamente por los servidores de aplicaciones. Es como que el cliente REST debe ir navegando por la información y no necesita ningún conocimiento previo acerca de la forma de interactuar con cualquier aplicación o servidor más allá de una comprensión genérica de hipermedia.

En otras palabras cuando el servidor nos devuelva la representación de un recurso parte de la información devuelta serán identificadores únicos en forma de hipervínculos a otros recursos asociados.

Lo vamos a entender mejor con un ejemplo, supongamos que tenemos una API REST, con cliente y sus diferentes pedidos. El modelo podría ser un cliente que tenga una lista de pedidos.

Lo que podríamos hacer es cuando el cliente REST solicite un cliente por la URI:

myURL/cliente/:id

Devolvemos los datos del cliente con su lista de pedidos. Pero el problema yace en que tal vez tenga muchos pedidos y a la vez el cliente REST necesita datos del cliente no de los pedidos. Por lo tanto, estoy mostrando más información de lo que debiera.

Una solución sería tener otro servicio REST que me devuelva los pedidos, por ejemplo:

myURI/cliente/2

Esta URI me devolverá los datos del cliente 2 que podría ser:

{ id:2, nombre:”Pepe”, apellido:”Gomez” }

Y podríamos hacer otro servicio que nos devuelva los pedidos por medio de la URI:

myURI/cliente/2/pedidos

Supongamos que por algún problema debemos cambiar la URI de pedidos, para hacer esto  debemos avisar a todos los clientes y ellos deberán consumir la nueva URI.

HATEOAS nos dice que debemos mostrar las URIs de forma que el cliente este menos acoplado al servidor y no sea necesario hacer cambios en estos casos.

Por ejemplo el servicio de consulta de clientes puede devolver la URI del pedido de la siguiente manera:

{ id:2, nombre:”Pepe”, apellido:”Gomez” , pedidos:”myURL/cliente/2/pedidos ”}

A la vez si no mostramos la URI de los pedidos el cliente REST tiene que ir a la documentación de la API por cada servicio que desee utilizar. Con HATEOAS los servicios descubren nuevos servicios lo que permite navegar por la información y un cliente que una URI principal puede ir descubriendo los demás servicios.  

La restricción HATEOAS desacopla cliente y el servidor de una manera que permite la funcionalidad del servidor para evolucionar de forma independiente.

Dejo link: http://en.wikipedia.org/wiki/HATEOAS

Mint Xfce

Todos sabrán mi adoración por el sistema operativo Mint, me parece que hace las cosas muy bien y me gusta mucho la interfaces mate y cinammon. Pero ahora les quiero mostrar Mint xfce. Para el que no conoce xfce es una interfaces de escritorio muy liviana y potente, la que la gente de Mint la volvió muy elegante.

Les cuento tal cual fue mi encuentro con esta versión, andaba buscando un escritorio liviano para una pc vieja que tengo y siendo sincero quede maravillado, tanto que lo voy a usar en mi actual pc.

Les dejo screenshots:

Dejo link:
http://www.linuxmint.com/

Bootstrap 3, el manual oficial

Bootstrap 3 es un framework front-end para desarrollo web, enfocado en responsive design. Si no lo conoces deberías hacerlo ya que es de gran utilidad.

Me encontré este manual que me pareció bien compartirlo:

http://librosweb.es/bootstrap_3/

A estudiar!!!

Hacer una Api Rest con haskell es posible gracias a rest

Parece un juego de palabras pero no lo es rest es un framework (en la documentación dice conjunto de paquetes) que permiten hacer una Api Rest con Haskell.

A la vez se puede ejecutar estas librerías en varios frameworks web, como Happstack o Snap. También puede generar automáticamente la documentación de la API Rest, lo que garantiza que siempre coincide con el código. Del mismo modo, puede generar cliente para diferentes lenguajes como Javascript o Haskell.

Algo muy bueno es que la Api queda escrita como en un DSL muy fácil de mantener, veamos un ejemplo:

module Api.Post (resource) where

import Rest
import qualified Rest.Resource as R

type Title = String

resource :: Resource IO (ReaderT Title IO) Title () Void
resource = mkResourceReader
  { R.name   = "post"
  , R.schema = withListing () $ named [("title", singleBy id)]
  , R.list   = const list
  , R.get    = Just get
  }

Dejo link:
http://silkapp.github.io/rest/
https://github.com/silkapp/rest/archive/master.zip

The Eclipse Memory Analyze, una excelente herramienta para buscar memory leak

Si no sabes que es un memory leak siéntete un afortunado, dado que estos nos hacen la vida imposible cuando suceden. Como sabrán java tiene un Garbage collector o recolector de basura que se encarga de eliminar los objetos que no utilizamos y liberar la memoria.

Pero cómo sabe cuándo no usamos más un objeto? Una posibilidad es cuando nadie lo referencia. En el heap de la Máquina Virtual Java (JVM) guarda todos los objetos creados por la aplicación Java, por ejemplo, utilizando el operador "new". El recolector de basura de Java puede separar lógicamente el heap en diferentes áreas, por lo que el garbage collector puede rápidamente identificar los objetos que pueden quedar eliminados.

La memoria para los nuevos objetos se asigna en el heap en tiempo de ejecución. Las variables de instancia viven en el interior del objeto en el que se han declarado. Por lo tanto, si referenciamos siempre a un objeto por más que no lo usemos el garbage collector no lo va a poder eliminar. Si creamos objetos y no los liberamos nunca vamos a consumir cada vez más memoria y este es un recurso limitado por lo que tarde o temprano vamos a tener un OutOfMemoryError. Es decir nos, quedamos sin memoria.

Algo horrendo en la vida de un programador, es buscar este tipo de errores. Son muy difíciles de rastrear y muchas veces ocurren cuando la aplicación tiene tiempo corriendo.

Para ayudarnos a luchar contra los memory leak, eclipse creo MAT o The Eclipse Memory Analyze que es un rápido y seguro analizador de memoria java. Que necesitamos para utilizarlo? Solamente un dump de memoria cuando ocurra el error. Si, si claro y como obtengo esto?

Es muy fácil, para obtener un dump de memoria cuando ocurre un OutOfMemoryError debemos configurar la jvm con unos parámetros como lo indica la documentación de oracle:

-XX:-HeapDumpOnOutOfMemoryError que indica a la Jvm que haga un dump cuando ocurra un OutOfMemoryError

-XX:HeapDumpPath=./java_pid<pid>.hprof que indica donde va a guardarse el dump, no es obligatorio pero es aconsejable configurar el path para estar seguros donde se va a guardar.

Por ejemplo con:

Java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/home/emanuelpeg/logs/

Le estoy diciendo a la jvm que guarde el dump de memoria en /home/emanuelpeg/logs/ cuando ocurra un OutOfMemoryError.

Luego de esto es todo muy fácil, solo tenemos que importar el dump a MAT y esta herramienta nos preguntará si queremos hacer un reporte con los memory leaks y simplemente tenemos que presionar finish para obtener un completo reporte interactivo de la memoria de la jvm.

A la vez nos brinda gráficos con los posibles errores, y contiene un histograma el cual muestra el número de instancias de una clase en particular y la cantidad de memoria que cada uno utiliza. Además, se puede agrupar por cargador de clase o paquete. Esto le permitirá centrarnos en nuestros objetos.

Como conclusión podemos asegurar que MAT es una herramienta indispensable para la búsqueda de memory leaks.

 Dejo link: http://www.eclipse.org/mat/

Los 5 framework más populares en PHP

Efecto de PHP en las empresas

Scala.js

Scala.js es un compilador scala a javascript. Con este compilador podemos escribir nuestras paginas en Scala y ejecutarlas en nuestro browser preferido. Entre las características más importantes podemos nombrar:

• Soporte total de scala (hasta macros)
• Muy buena interoperabilidad con javascript. 
• Integración con Sbt
• Puede utilizar la IDE que prefiera para programar en Scala

Dejo link:

http://www.scala-js.org/

Flume, Kafka, Spark y Storm, ¿un nuevo ejército Apache?

Quiero compartir un excelente articulo sobre Flume, Kafka, Spark y Storm que encontré gracias a javahispano.

Dejo el link:
http://blog.gfi.es/flume-kafka-spark-y-storm-un-nuevo-ejercito-apache/
http://www.javahispano.org/portada/2014/6/28/articulo-en-espaol-explicando-los-framework-flume-kafka-spar.html

Pliegues

Es muy común que trabajemos con listas y también es muy común que tengamos que recorrerlas para obtener un valor. Por ejemplo si queremos el promedio de una lista de números, debemos sumar todos los números para luego dividirlos por la cantidad.

Este es un patrón muy común y por lo tanto en Haskell nos brinda unas cuantas funciones muy útiles para encapsular este comportamiento. Estas funciones son llamadas pliegues (o folds en ingles).

Un pliegue toma una función binaria, un valor inicial (llamémoslo acumulador) y una lista que plegar. La función binaria toma dos parámetros por si misma. La función binaria es llamada con el acumulador y el primer (o último) elemento y produce un nuevo acumulador. Luego, la función binaria se vuelve a llamar junto al nuevo acumulador y al nuevo primer (o último) elemento de la lista, y así sucesivamente. Cuando se ha recorrido la lista completa, solo permanece un acumulador, que es el valor al que se ha reducido la lista.

La función foldl, también llamada pliegue por la izquierda. Esta pliega la lista empezando desde la izquierda. La función binaria es aplicada junto a el valor inicial y la cabeza de la lista. Esto produce un nuevo acumulador y la función binaria es vuelta a llamar con ese nuevo valor y el siguiente elemento, etc.

Vamos a implementar una función “sumarLista”:

sumaLista :: (Num a) => [a] -> a
sumaLista xs = foldl (\acc x -> acc + x) 0 xs

Probamos:
ghci> sumaLista [1,2,3,4]
10

Vamos a analizar un poco este pliegue. \acc x -> acc + x es la función binaria donde suma sus parámetros. 0 es el valor inicial y xs es la lista que debe ser plegada. Al inicio acc es igual a 0 (dado que esto lo indicamos en el segundo parámetro) y x toma el primer elemento de la lista 1, el resultado de la suma es 1 y va a ser el valor del acumulador para la segunda iteración.

Si tenemos en cuenta que las funciones están currificadas, podemos escribir esta implementación de forma más bonita como:

sumaLista :: (Num a) => [a] -> a
sumaLista = foldl (+) 0

La función lambda (\acc x -> acc + x) es lo mismo que (+). Podemos omitir el parámetro xs ya que al llamar a foldl (+) 0 nos devuelve una función que toma una lista. Generalmente, si tienes una función del tipo foo a = bar b a la puedes escribir como foo = bar b gracias a la currificación.

Ahora los pliegues por la derecha funcionan igual que los pliegues por la izquierda, solo que el acumulador consume elemento por la derecha. La función binaria de los pliegues por la izquierda como primer parámetro el acumulador y el valor actual como segundo parámetro, la función binaria de los pliegues por la derecha tiene el valor actual como primer parámetro y el acumulador después. Tiene sentido ya que el pliegue por la derecha tiene el acumulador a la derecha.

Las funciones foldl1 y foldr1 son muy parecidas a foldl y foldr, solo que en lugar que no necesitas indicar un valor de inicio. Asumen que el primer (o el último) elemento de la lista es valor de inicio, luego empiezan a plegar la lista por el elemento siguiente. Por lo tanto la función sumaLista puede ser implementada como: sumaLista = foldl1 (+)

Los pliegues no son una característica únicamente de Haskell, están presentes en varios lenguajes como Ruby, Java 8, Scala, Swift, Python, C#, Clojure, Erlang, Groovy, javascript, PHP, Smalltalk, etc.

Veamos nuestro ejemplo de sumaLista en otros lenguajes:

Ruby
> (1..4).inject(&:+)
=> 10
>(1..4).reduce(&:+)
=> 10

Groovy 
[1, 2, 3, 4].inject(0, { sum, value -> sum + value })

Javascript
[1, 2, 3,4].reduce(function(x,y){return x+y})
10
[1, 2, 3,4].reduceRight(function(x,y){return x+y})
10

Clojure
(reduce + [1 2 3 4])
10

Scala
List(1,2,3,4).foldLeft(0)((x, sum) => sum + x)  //> res0: Int = 10


Erlang
lists:foldl(fun(X, Sum) -> X + Sum end, 0, [1, 2, 3, 4]).
10

Los pliegues nos permiten recorrer listas escribiendo muy poco código, ayudando a la legibilidad y a que los programadores perezosos escribamos menos.

Dejo links:
http://en.wikipedia.org/wiki/Fold_(higher-order_function)
http://aprendehaskell.es/content/OrdenSuperior.html#pliegues

Documetando APIs Rest con Swagger

Te imaginas un javadoc de tus servicios REST? Swagger es eso y mucho más dado que es una herramienta extremadamente útil para describir, producir, consumir y visualizar APIs RESTful. El principal objetivo de este framework es enganchar el sistema de documentación con el código del servidor para que esté sincronizado a cada cambio. Casi documentamos al mismo tiempo que creamos la implementación.

Swagger está desarrollado de tal modo que podemos usar Scala, Java, Javascript, Ruby, PHP o ActionScript para generar toda la documentación y su sandbox correspondiente. Además, existen distintos módulos para enganchar a nuestros proyecto Node.js, Grails, Scala Play, Spring MVC, Symfony o Ruby, entre otros muchos.

Los usuarios de las APIS también son beneficiados ya que proporciona una interfaz visual a modo de sandbox donde podemos testear la llamadas del API, además de consultar su documentación. Podéis echar un vistazo a un ejemplo de la web que genera Swagger a partir del código de nuestra API con los métodos, parámetros y modelos de JSON que devuelve.

Swagger es perfecto para tener la documentación de nuestras APIs a punto y brindarle un servicio más a los clientes con ejemplos.

The Swagger™ Specification: https://github.com/wordnik/swagger-spec
Swagger™ Demo: http://petstore.swagger.wordnik.com/
Downloads: https://github.com/wordnik/swagger-core/wiki/Downloads

Scala Movie 2.11 Official Trailer

Es muy Gracioso!!