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!!

Breaking the Code: Biografía de Alan Turing

Seguramente conocen a Alan Turing y sino en resumen, fue el matemático que concibió, una maquina programable y probo que se podía construir. Por lo que le debemos el trabajo. Breaking the Code es la biografía de Alan Turing y esta libre y gratuita en youtube:

Dejo link:
http://es.wikipedia.org/wiki/Alan_Turing

Dba PostgreSQL desde básico a avanzado

Quiero compartir esta excelente info sobre la base de datos Postgres:

Dba PostgreSQL desde básico a avanzado parte1 from EQ SOFT Consultoría y Soporte EIRL

Dba PostgreSQL desde básico a avanzado parte2 from EQ SOFT Consultoría y Soporte EIRL

The Arnold Schwarzenegger Programming Language

ArnoldC es un lenguaje de programación basado en frases de ... y de quien? de Arnold Schwarzenegger. Si señores parece un chiste y lo es, pero un chiste que se puede utilizar para hacer programas.

Entre las instrucciones más graciosas tenemos:

False I LIED

True NO PROBLEMO

If BECAUSE I'M GOING TO SAY PLEASE

Else BULLSHIT

EndIf YOU HAVE NO RESPECT FOR LOGIC

While STICK AROUND

EndWhile CHILL

PlusOperator GET UP

MinusOperator GET DOWN

MultiplicationOperator YOU'RE FIRED

DivisionOperator HE HAD TO SPLIT

ModuloOperator I LET HIM GO

EqualTo YOU ARE NOT YOU YOU ARE ME

GreaterThan LET OFF SOME STEAM BENNET

Or CONSIDER THAT A DIVORCE

And KNOCK KNOCK

DeclareMethod LISTEN TO ME VERY CAREFULLY

NonVoidMethod GIVE THESE PEOPLE AIR

MethodArguments I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE

Return I'LL BE BACK

EndMethodDeclaration HASTA LA VISTA, BABY

CallMethod DO IT NOW

AssignVariableFromMethodCall GET YOUR ASS TO MARS

DeclareInt HEY CHRISTMAS TREE

SetInitialValue YOU SET US UP

BeginMain IT'S SHOWTIME

EndMain YOU HAVE BEEN TERMINATED

Print TALK TO THE HAND

ReadInteger I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY

AssignVariable GET TO THE CHOPPER

SetValue HERE IS MY INVITATION

EndAssignVariable ENOUGH TALK

ParseError WHAT THE FUCK DID I DO WRONG

Entre otras características ArnoldC corre sobre la plataforma Java, veamos un "hola mundo" con este lenguaje:

IT'S SHOWTIME
TALK TO THE HAND "hello world"
YOU HAVE BEEN TERMINATED

Veamos un ejemplo de un condicional:

if(a) print "a is true"
else print "a is not true"

BECAUSE I'M GOING TO SAY PLEASE a
TALK TO THE HAND "a is true"
BULLSHIT
TALK TO THE HAND "a is not true"
YOU HAVE NO RESPECT FOR LOGIC

La verdad muy gracioso,

Dejo links:
https://github.com/lhartikk/ArnoldC
https://github.com/lhartikk/ArnoldC/wiki/ArnoldC

Se busca Sponsors!!!

Si queres invertir en este humilde blog ahora lo podes hacer. Como viene la mano?  Se trata de Coobis. Un producto el cual permite invertir en blogs.

Coobis es un plataforma que ofrece a los blogs dos vías principales para acceder a nuevos sponsors:

• Widgets: Los blogs pueden instalar diferentes tipos de widgets ofrecidos por Coobis para mostrar las campañas de los sponsors de forma automática, como si de una red de afiliación se tratará, pero con una capa de sencillez añadida respecto a las dificultades habituales de este tipo de redes.
• Marketplace: Los sponsors pueden comprar patrocinios exclusivos a los blogs desde el marketplace de Coobis, así como post patrocinados o menciones en Twitter.

Como me gusta predicar con el ejemplo, ya estoy usando Coobis. Aquí pueden ver la ficha:
http://coobis.com/blog/emanuelpeg.blogspot.com.ar

La pregunta obvia, quiere invertir en el blog?

Collections.js

Quien no soñó tener todas las colecciones más comunes en Javascript? Collections.js cumple ese sueño. Con esta librería podes tener todas las estructuras de datos más comunes en Javascript.

Estas colecciones ofrecen alternativas especializadas de arrays y objetos planos. Incluye la capacidad de observar todos los cambios además todas las colecciones tienen un interfaz común y se puede utilizar tanto para aplicaciones Node.js o aplicaciones que se ejecutan en el navegador.

Algunas estructuras de datos son más adecuados para problemas específicos por lo tanto podemos armar la librería como mejor nos convenga y descargarla.

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

Además les dejo una referencia a los objetos de esta la librería:

ListObjectMapFastMapLruMapLfuMapSortedMapSortedArrayMapDictMultiMapWeakMap

DequeArraySetFastSetLruSetLfuSetSortedSetSortedArraySetSortedArrayHeapIterator

La historia de Lisp

Para conocer un lenguaje es necesario conocer su historia y más que eso conocer porque se tomaron tal o cual decisión. Lisp es un lenguaje muy particular que nos provee muchos dolores de cabeza con sus paréntesis. Pero antes de leventarse en armas contra este lenguaje, es bueno conoser su historia y porque fue pensado de esta manera.

Dejo link de la historia de Lisp:
http://www-formal.stanford.edu/jmc/history/lisp/lisp.html

75 libros de #Python

Solo quiero hacerme eco de un post sobre libros de python: http://blog.segu-info.com.ar/2014/06/75-libros-de-python.html

Python se ha transformado sin dudas en el lenguaje base de cualquier profesional de seguridad debido a su formato sencillo, potente y totalmente extensible. Python, un lenguaje multiplataforma, 

permite que trabajas rápidamente y eficientemente, permitiéndo concentrarse en el objetivo a lograr en lugar del lenguaje en sí mismo.

A continuación una lista de más de 70 libros sobre diferentes formas de aprovecharlo al máximo

• 51 libros gratuitos sobre cómo programar en este lenguaje.
• 21 libros gratuitos hosteados en Google Docs
• Hacking Secret Ciphers with Python
• BlackHat Library
• The Hacker's Guide to Python

Hacer un proyecto con cxf, rest o soap con maven

Si recuerdan el post anterior, sabrán que ahora vamos a hacer un proyecto rest con cxf, pero vamos a usar m2e y jetty con el plugin "run jetty run".

Esto va a ser muy facil, vamos a nuestra queriada IDE eclipse, con los plugines m2e y run jetty run instalados. Y vamos a crear un nuevo proyecto maven:

Y luego clean install:

Y luego a correr el servicio:

Y ahora si ponemos en el browser http://localhost:8080/rest/hello/echo/HolaBlog veremos lo siguiente:

HolaBlog

Y Listo!!

Hacer un proyecto con cxf, rest o soap con maven

Hace muy poco tuve que hacer un proyecto rest con maven y decidí utilizar Apache CXF y la verdad es que quede sorprendido por la facilidad. Y para que vean que no miento, les dejo la receta:

Ingredientes:

• Abundante maven
• IDE a gusto (yo voy a utilizar eclipse) 
• Servidor web Jetty o tomcat, pueden utilizar el plugin de eclipse “run jetty run” si usa jetty. 

Para hacerlo más divertido vamos a hacer el proyecto soap con maven solamente y luego para el proyecto rest vamos a utilizar el plugin m2e de eclipse.

Vamos a hacer un proyecto soap con Apache CXF, para esto nos posicionamos en la carpeta que queremos crear el proyecto y luego ejecutamos:

 $ mvn archetype:generate
[INFO] Scanning for projects...
[INFO]                                                                        
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:2.2:generate (default-cli) @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.2:generate (default-cli) @ standalone-pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.2:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Interactive mode
[INFO] No archetype defined. Using maven-archetype-quickstart (org.apache.maven.archetypes:maven-archetype-quickstart:1.0)
Choose archetype:
 …

Ahora debemos elegir el archetype en nuestro caso es :
368: remote -> org.apache.cxf.archetype:cxf-jaxws-javafirst (Creates a project for developing a Web service starting from Java code)

Y luego elegimos la versión (hacer enter si quieren la ultima)
Y luego ingresar el nombre del proyecto, paquete y número de versión:

Define value for property 'groupId': : com.prueba
Define value for property 'artifactId': : soap
Define value for property 'version':  1.0-SNAPSHOT: :
Define value for property 'package':  com.prueba: :
Confirm properties configuration:
groupId: com.prueba
artifactId: soap
version: 1.0-SNAPSHOT
package: com.prueba
Confirm properties configuration:
groupId: com.prueba
artifactId: soap
version: 1.0-SNAPSHOT
package: com.prueba
 Y: : y
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Archetype: cxf-jaxws-javafirst:3.0.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: com.prueba
[INFO] Parameter: artifactId, Value: soap
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: com.prueba
[INFO] Parameter: packageInPathFormat, Value: com/prueba
[INFO] Parameter: package, Value: com.prueba
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: groupId, Value: com.prueba
[INFO] Parameter: artifactId, Value: soap
[INFO] project created from Archetype in dir: /home/emanuel/Projects/restVsSoap/soap
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 5:05:03.940s
[INFO] Finished at: Sun Jun 15 18:17:02 ART 2014
[INFO] Final Memory: 14M/207M
[INFO] ------------------------------------------------------------------------
$ cd soap
$ mvn clean install
Al finalizar puedes importarlo a eclipse o cualquier IDE es recomendable utilizar m2e.
Ahora bien el reto era no utilizar IDE, por lo tanto vamos a levantar el tomcat desde maven:
$ mvn tomcat:run

Y Listo!!
Vamos a un browser e ingresamos a http://localhost:8080/soap
Y verán lo siguiente:

Available SOAP services:

HelloWorld sayHi

Endpoint address: http://localhost:8080/soap/HelloWorld WSDL : {http://prueba.com/}HelloWorldImplService Target namespace: http://prueba.com/

Available RESTful services:


En el próximo post vamos con REST.

Manejando Funciones como Objetos en Scala

En Scala las funciones también son objetos por tanto es posible pasar funciones como argumentos, guardarlas en variables y devolverlas como respuesta de otras funciones. Esta habilidad para manipular funciones como valores es una de las piedras angulares de la programación funcional.

Como ejemplo muy simple de porqué puede resultar útil el uso de funciones como valores, consideremos una función temporizador cuyo propósito sea realizar alguna acción una vez por segundo. ¿Cómo le pasamos la acción a realizar? lógicamente, como una función.

En el siguiente programa, la función temporizador se llama unaVezPorSegundo, y toma una función como argumento. El tipo de esta función se escribe () => unit y es el tipo de todas las funciones que no tienen parámetros de entrada y que no devuelven nada (el tipo unit es similar a void en C/C++). El método main de este programa simplemente llama a la función temporizador para que repita cada segundo la impresión por pantalla de la frase “el tiempo pasa volando”.

object Temporizador {
      def unaVezPorSegundo(repite : () => unit) {
            while (true) { repite(); Thread sleep 1000 }
      }

      def elTiempoVuela() {
            println("el tiempo pasa volando...")
      }

      def main(args: Array[String]) {
            unaVezPorSegundo(elTiempoVuela)
      }
}

Aunque este programa es fácil de entender, se puede refinar un poco. Antes de nada, se ve que la función elTiempoVuela solo se ha creado para ser pasada posteriormente como argumento al método unaVezPorSegundo . Tener que dar nombre a esa función, que sólo se usa una vez, parece innecesario, y de hecho estaría bien poder construirla justo cuando se le pasa a unaVezPorSegundo. En Scala esto es posible usando funciones anónimas, que son exactamente eso: funciones sin nombre. La versión revisada de nuestro programa temporizador utilizando una función anónima en vez de elTiempoVuela queda así:

object Temporizador {

      def unaVezPorSegundo(repite: () => unit) {
            while (true) { repite(); Thread sleep 1000 }
      }

      def main(args: Array[String]) {
            unaVezPorSegundo(() =>
                  println("el tiempo pasa volando..."))
      }
}

La presencia de una función anónima en este ejemplo, se revela por la flecha ‘ => ’ que separa a la lista de argumentos de la función, del cuerpo de la misma. En este ejemplo la lista de argumentos es vacía, como indican los paréntesis vacíos a la izquierda de la flecha. El cuerpo de la función es el mismo que el de elTiempoVuela antes.

Otra característica es que una función puede ser devuelta como resultado de otra función. Esto es sumamente útil y nos permite currificar funciones. Pero que es currificar? En resumen "Si ajustas algunos argumentos, tendrás una función de los argumentos restantes".

Veamos un ejemplo:

object CurryingTest {
 
      def multiplicar (nro1: Int) : (Int)=> Int = (nro2: Int) => nro1 * nro2
                                                 
      def doble(nro: Int) = multiplicar(2)(nro)    
 
      doble(3)         //> res0: Int = 6
}

Pero podemos utilizar el azúcar sintáctico:

object CurryingTest {
      def multiplicar (nro1: Int)(nro2: Int) = nro1 * nro2
     
      def doble(nro: Int) = multiplicar(2)(nro)    
 
      doble(3)       //> res0: Int = 6
}

Para los curiosos el nombre "currificar", acuñado por Christopher Strachey en 1967, es una referencia al lógico Haskell Curry.

Las funciones son muy importantes y modelarlas como objetos nos hace la vida más fácil.

Unos cuantos libros!!

Quiero compartir unos cuantos links con libros:

https://github.com/vhf/free-programming-books/blob/master/free-programming-books.md
https://github.com/vhf/free-programming-books/blob/master/free-programming-books-es.md
http://resrc.io/