sábado, 31 de mayo de 2014

Apache Spark


Se puede ser más rápido que Apache Hadoop? Y si se puede y Apache Spark esta para probarlo.

Hadoop es el framework por defecto si hablamos de Big Data. Spark fue diseñado para soportar en memoria algoritmos iterativos que se pudiesen desarrollar sin escribir un conjunto de resultados cada vez que se procesaba un dato. Esta habilidad para mantener todo en memoria es una técnica de computación de alto rendimiento aplicado al análisis avanzado, la cual permite que Spark tenga unas velocidades de procesamiento que sean 100 veces más rápidas que las conseguidas utilizando MapReduce.

Y además fue desarrollado en Scala, lo que permite facilidad de integración con Scala, Java y también python (eso es lo que se puede leer en su web)

Spark tiene un framework integrado para implementar análisis avanzados que incluye la librería MLlib, el motor gráfico GraphX, Spark Streaming, y la herramienta de consulta Shark. Esta plataforma asegura a los usuarios la consistencia en los resultados a través de distintos tipos de análisis.

Como conclusión podemos afirmar que spark es un framework big data, pero liviano y a la vez más rápido.

Dejo link:
http://spark.apache.org/
http://en.wikipedia.org/wiki/Apache_Spark

martes, 27 de mayo de 2014

School of Haskell



School of Haskell es una página en la cual podemos aprender Haskell por medio de tutoriales y vídeos.

Esta muy buena!!

Dejo link: https://www.fpcomplete.com/school

lunes, 26 de mayo de 2014

Prueba un lenguaje de forma online


El programador curioso por lo general se siente frustrado al ser encasillado en un lenguaje, siempre cree que puede haber otra forma de hacer las cosas, mejor o peor pero distinta.

Es sabido que cuando crees encontrar el lenguaje perfecto simplemente se está ignorando un montón de problemas los cuales no aplicaría muy bien ese lenguaje que parece perfecto.

Por suerte los programadores curiosos o inquietos tienen muchas herramientas que les permiten investigar nuevos horizontes. Entre ellas están las páginas que permiten probar un lenguaje de forma online. Sin tener que instalar nada le podemos dar una primera probada a ese lenguaje que nos interesa tanto.

Vamos a revisar las páginas que en mi humilde opinión son muy buenas para introducirnos en un lenguaje:

Groovy web console : Groovy es un lenguaje de tipado dinamico que corre sobre la plataforma Java. Es un lenguaje sumamente interesante. Groovy web console es una página sumamente simple que te permite ejecutar Groovy de forma rápida y sencilla.

Try Clojure: Clojure es un lenguaje para los amantes de Lisp. Clojure es un derivado de Lisp y corre sobre la plataforma Java. Try Clojure nos brinda la consola RELP de Clojure de forma web.

Try Ruby: Si no conocen Ruby, ésta es tu oportunidad. Try Ruby no solo permite ejecutar Ruby sino que nos brinda un conjunto de actividades para acrecentar nuestro conocimiento.

Scala Tutorials: Scala es un lenguaje multiparadigma (Funcional y Orientado a Objeto) que corre en la plataforma Java. Scala Tutorials es un tutorial básico de Scala que te permite jugar con el lenguaje y sobre todo aprender

Try Haskell: Haskell es un lenguaje funcional que es bueno que aprendas. Muy rico en conceptos, cambia tu forma de pensar un problema. Try Haskell es una página inspirada en try ruby que permite probar este maravilloso lenguaje.

Try Ceylon: Ceylon es el lenguaje de la empresa JBoss para la plataforma Java, en este lenguaje esta trabajando Gavin King (el creador de hibernate) entre otros. Try Ceylon tiene la misma esencia que try ruby o try haskell y a la vez nos permite probar ejemplos. Nobleza obliga, gracias Enrique Zamudio por recordarme. 

Compile online: Y por ultimo Compile online que es una página que no solo permite probar innumerables lenguajes también se puede probar frameworks javascript y distintas tecnologías web.

En conclusión para probar un lenguaje solo se necesita un browser y un poco de tiempo. Conocen otra pagina que debería estar en la lista? Cual les pareció más interesante?


Scala: The Simple Parts with Martin Odersky

Quiero recomendar este video presentado por Martin Odersky:


Dejo link:
http://new.livestream.com/accounts/8519806/events/3011572

viernes, 23 de mayo de 2014

Inscríbete en el evento on-line de Red Hat: “Redefining the Enterprise OS”


Simplemente quiero hacerme eco de una noticia que leí en mcpro: Red Hat celebra un evento on-line gratuito bajo el título “Redefining the Enterprise OS”, o lo que es lo mismo, “Redefiniendo el sistema operativo empresarial”, que se celebrará el martes, 10 de junio, a las 17 horas (hora española).

Dejo el link:
http://www.muycomputerpro.com/2014/05/20/evento-on-line-red-hat

lunes, 19 de mayo de 2014

MongoDB for Java Developers on-demand




La gente de MongoDb University nos ofrecen un nuevo curso sobre su base de datos para programadores Java. Que novedad tiene este curso? Es que ahora son on demand. On demand significa que todos los capítulos y material se van a entregar a la vez. Al completar con éxito, los estudiantes recibirán un certificado de finalización. 

Los entrenadores van a estar disponibles para brindar ayuda a través de un chat en vivo. Los profesores son los ingenieros de MongoDB y los instructores del personal. 

Este curso va estar disponible desde 2 de Junio hasta el 1 de Agosto. 


MongoInc_Button_registernow.png
MongoInc_logosmall.pngMongoInc_Social_twitter.png MongoInc_Social_youtube.png MongoInc_Social_facebook.png MongoInc_Social_gplus.png MongoInc_Social_linkedin.png  

sábado, 17 de mayo de 2014

Métodos singleton

El comportamiento de una instancia viene determinado por su clase, pero hay veces que sabemos que una determinada instancia debe tener un comportamiento especial. En la mayoría de los lenguajes debemos meternos en la problemática de crear otra clase e instanciarla sólo una vez. En Ruby se puede asignar a cada objeto sus propios métodos. Veamos un ejemplo:

class Prueba
def imprimir_valor
print "Hola!!\n"
end
end

test1 = Prueba.new
test2 = Prueba.new

def test2.imprimir_valor
  print "Hola desde test2!!\n"
end

ruby> test1.imprimir_valor
Hola!!
nil
ruby> test2.imprimir_valor
Hola desde test2!!
nil

En este ejemplo, test1 y test2 pertenecen a la misma clase, pero a test2 se le ha redefinido el método imprimir_valor y por lo tanto se comportan de forma diferente. Un método que pertenece sólo a un objeto se conoce como método singleton.

Los métodos singleton no son únicos de Ruby, aparecen también en CLOS, Dylan, entre otros. Otros lenguajes como por ejemplo Self, Javascript, NewtonScript, Lua y Io sólo tienen métodos singleton. A estos se les conoce como lenguajes basados en prototipos, dado que implementan la orientación a objetos sin el concepto de clase, sino que por medio del prototipado.

En Dylan, los métodos no están intrínsecamente asociados a ninguna clase en particular; métodos se pueden considerar como existente fuera de las clases. Como CLOS, Dylan se basa en multimethods o Multiple dispatch.  Multimethods es una característica de algunos lenguajes orientados a objetos en los cuales los métodos o funciones, pueden ser dinámicamente seleccionados en tiempo de ejecución para ser ejecutados dependiendo por ejemplo del tipo de un parámetro o del contexto.

Métodos singleton es una característica muy interesante y algunos lenguajes lo implementan con prototipos y otros con  Multimethods.


Programming Language Popularity Chart


Me resulto muy interesante y quiero compartir una pagina sobre la popularidad de los lenguajes; les dejo el link:

http://langpop.corger.nl/

viernes, 16 de mayo de 2014

Videos de JavaZone

Como todos los años Javazone hace su conferencia y como es costumbre la publicita con los mejores vídeos:




jueves, 15 de mayo de 2014

Shaping up with Angular.js

La gente de codescholl a lanzado un nuevo curso gratuito, esta vez del framework javascript MVC Angular.js

La verdad, se ve muy bueno!!

Les dejo el mail que me enviaron:



Launched - Shaping up with Angular.js

Learn to use Angular.js by adding behavior to your HTML and speeding up your application's responsiveness. Get ready to dive into all the angles of Angular.js!
PLAY NOW

Level 1 BadgeLevel 1 - Flatlander's Gem Store: Get comfortable with expressions by beginning to build a gem store.
Level 2 BadgeLevel 2 - Built-in Directives: Use directives to add a gallery and tabs to the gem store.
Level 3 BadgeLevel 3 - Forms: Give the gem store review functionality by using Angular.js forms.
Level 4 BadgeLevel 4 - Custom Directives: Create custom directives for more organized and maintainable Angular.js code.
Level 5 BadgeLevel 5 - Services: Create a new module and learn to use the $http service to get real data into the gem store.

domingo, 11 de mayo de 2014

La ventaja de ser perezoso


Si buscamos en la wikipedia “lazy evaluation”, podemos encontrar este concepto como lazy evaluation o call-by-need. Los dos nombres le quedan muy bien pero personalmente opino que call-by-need explica mejor lo que sucede. Lazy evaluation permite que un bloque de código sea evaluado luego o mejor dicho sólo cuando se lo necesite, esto nos permite realizar código que tiene un rendimiento superior en ciertas situaciones.

Veamos un ejemplo, supongamos que tengo la función multiplicación

mult(a, b) = a * a

Si llamara a esta función con los parámetros 8 y 5+2 de forma tradicional o eager sucedería lo siguiente :
mult(8, 5+2)
mult(8,7)
8*8
64

Pero si ejecutamos el código de forma perezosa:
mult(8, 5+2)
8 * 8
64

En este caso la ejecución perezosa fue más eficiente que la forma tradicional o eager.

Para poner otro ejemplo si tengo la función loop

loop(x) = loop(x)

Esta función nunca termina, veamos que pasa si ejecutamos mult(2, loop(2))

mult(2, loop(2))
mult(2, loop(2))
mult(2, loop(2))
mult(2, loop(2))
... hasta el infinito y más allá...

Pero si ejecutamos de forma perezosa

mult(2, loop(2))
2 * 2
4

Termina y nos da el resultado.

Si piensan bien, los programadores c (y sus derivados) utilizamos dos funciones que son lazy por cuestiones de rendimiento. Te acordas?

Vamos no es tan difícil...

Pensa...

mmm...

Si, si lo operadores and y or.

Estas funciones son diferentes pero trabajan similar. Vamos a analizar el and. El and es una función que si un parámetro es falso, retorna falso y si los dos son verdaderos devolverá verdadero. Como ustedes ya saben no necesita analizar los dos parámetros, si el primero es falso. De esta forma podemos hacer lo siguiente:

(a != null && a.nombre == “Peperino”)

Si a es nulo nunca ejecutara la expresión: a.nombre == “Peperino”

Scala es un lenguaje que se puede indicar que un parámetro sea manejado de forma perezosa, para esto se debe utilizar “=>” cuando se declara el parámetro. Vamos a hacer una función “and” en Scala:

def and(x:Boolean, y: => Boolean) = if (x) y else x

De esta forma si “x” es verdadero devolvemos “y” y si “x” es falso, ni siquiera ejecutamos “y”.

Podemos probarla con la función loop:

def loop : Boolean = loop   //> loop: => Boolean

and(false, loop)    //> res1: Boolean = false

La evaluación perezosa proviene del paradigma funcional, es una característica de Haskell y otros lenguajes funcionales, pero también podemos usarla en lenguajes multiparadigma como Scala.

sábado, 10 de mayo de 2014

miércoles, 7 de mayo de 2014

Más libros gratis!!

Querías leer? Te voy a dejar un link que vale oro, muchos libros gratis de informática, pero muchos...

Dejo el link:
http://bookdl.com

lunes, 5 de mayo de 2014

Libros Gratis



Como si uno no tuviera cosas para estudiar o leer!!

Quiero compartir este link en el que se pueden descargar libros de forma gratuita. Entre los temas de los libros esta Android, AngularJs, Windows Phone 8, Html 5, etc.

Dejo link:
http://theneodesign.com/latest-free-ebooks-for-developers/

sábado, 3 de mayo de 2014

Linux apesta

Me resulto muy interesante este vídeo que les quiero compartir. Les pido un favor no piensen que soy enemigo de Linux porque publico esto; ya maduramos un poco de autocritica no viene mal.


 

viernes, 2 de mayo de 2014

Elixir



José Valim decidió crear un lenguaje para aumentar la productividad en la plataforma Erlang y lo consiguió. El nombre de este lenguaje es Elixir

Elixir es lenguaje de programación de propósito general, concurrente; este lenguaje es funcional. Además esta construido sobre la máquina virtual de Erlang. Se trata de un lenguaje dinámico con una sintaxis flexible y apoyado en macros; que aprovecha las capacidades de Erlang para construir aplicaciones concurrentes y distribuidas, tolerables a fallos, con actualizaciones de código en caliente.

Elixir también soporta pattern matching, el polimorfismo a través de protocolos (similar a Clojure), alias y estructuras de datos asociativos (generalmente conocido como hashes en otros lenguajes de programación).

Por útimo, Elixir y Erlang comparten el mismo byte code. Esto significa que puede invocar código Erlang de Elixir (y viceversa) sin ningún tipo de transformación o impacto en el rendimiento. Esto permite a los desarrolladores mezclar la expresividad de Elixir con la robustez y el rendimiento de Erlang.

Veamos un ejemplo, es bueno comenzar con un "hola mundo" pero para hacerlo más interesante vamos a hacerlo dentro de un modulo:

defmodule Hello do
  IO.puts "Defining the function world"

  def world do
    IO.puts "Hello World"
  end

  IO.puts "Function world defined"
end


Hello.world


Los módulos son simplemente una forma lógica de organizar el código, no se debe confundir con una clase, ya que no tiene propiedades.


Este código retorna:


Defining the function world
Function world define

Hello World

Si queremos probar el ejemplo solo debemos guardar el ejemplo como Hello.ex y luego debemos compilar, para eso ejecutamos el relp de Elixir y compilamos de la siguiente manera:


Interactive Elixir
iex> c("Hello.ex")
[Hello]
iex> Hello.hello
Defining the function world
Function world define
Hello World
:ok

Elixir tiene varias características que lo hacen un muy buen lenguaje para programar, como por ejemplo tiene pattern matching, veamos un ejemplo:


def serve_drinks({ User, name, age }) when age < 21 do
  raise "No way #{name}!"
end

def serve_drinks({ User, name, age }) do
  # Code that serves drinks!
end

serve_drinks User.get("John")
#=> Raises "No way John!" if John is under 21

Otra característica interesante es que la documentación es muy importante para elixir. Por lo que provee mecanismos que facilitan documentar nuestro código, veamos un ejemplo:

defmodule MyModule do
  @moduledoc """
  Documentation for my module. With **formatting**.
  """

  @doc "Hello"
  def world do
    "World"
  end
end

Y como es de esperar, Elixir provee herramientas que facilitan el acceso a la documentación.


iex> h MyModule
# MyModule

Documentation for my module. With **formatting**.

Elixir es un lenguaje que nació para facilitar el desarrollo en la plataforma Erlang y vaya que lo logro!

Dejo link:
http://elixir-lang.org/


jueves, 1 de mayo de 2014

Manejar la concurrencia con Actores.


El modelo de actores que fue propuesto por primera vez por Carl Hewitt en 1973; es un modelo de concurrencia computacional que al igual que los hilos, trata de solucionar el problema de la concurrencia.

En el modelo de actores, cada objeto es un actor. Esta es una entidad que tiene una cola de mensajes o buzón y un comportamiento. Los mensajes pueden ser intercambiados entre los actores y se almacenan en el buzón. Al recibir un mensaje, el comportamiento del actor se ejecuta. El actor puede : enviar una serie de mensajes a otros actores, crear una serie de actores y asumir un nuevo comportamiento para el próximo mensaje.

La importancia en este modelo es que todas las comunicaciones se llevan a cabo de forma asincrónica. Esto implica que el remitente no espera a que un mensaje sea recibido en el momento que lo envío, solo sigue su ejecución.

Una segunda característica importante es que todas las comunicaciones se producen por medio de mensajes: no hay un estado compartido entre los actores. Si un actor desea obtener información sobre el estado interno de otro actor, se tendrá que utilizar mensajes para solicitar esta información. Esto permite a los actores controlar el acceso a su estado, evitando problemas.

Erlang es un lenguaje de programación concurrente y un sistema de ejecución que incluye una máquina virtual y bibliotecas. Fue diseñado en la compañía Ericsson para realizar aplicaciones distribuidas, tolerantes a fallos y de funcionamiento ininterrumpido. Originalmente, Erlang era un lenguaje propietario de Ericsson, pero fue cedido como software de código abierto en 1998. La implementación de Ericsson es, principalmente interpretada pero también incluye un compilador HiPE (sólo soportado en algunas plataformas).

Entre los mayores logros de la plataforma podemos destacar que el chat de facebook y la base documental CouchDB.

Sin dudas una cosa que hace muy especial de Erlang es como maneja la concurrencia. Erlang no maneja la concurrencia con hilos como nos tiene acostumbrado C, C++ o Java. Erlang soluciona la programación concurrente mediante el modelo de actores.

En Erlang los procesos o actores:

  • Son rápidos de crear y destruir.
  • El envío de mensajes entre procesos es muy rápido.
  • Es fácil mantener un gran número de procesos.
  • Son ligeros.
  • Son independientes y no comparten memoria.
  • Sólo un proceso tratará un mensaje pasado, en ningún caso pasará por otro proceso.


Parece complicado, pero no lo es. Con un ejemplo vamos a aclarar el tema. Supongamos que queremos hacer un actor saludador, pero no muy simpático; que salude solo a los conocidos; en erlang sería así:

-module(saludador).
-export([loop/0]).
loop() ->
receive
% Saluda a un conocido
"conocido" ->
io:format("Hola!! " ),
loop();
% Un desconocido, no lo saluda
_ ->
io:format(" ... " ),
loop()
end.

En la primera línea declaramos el modulo; luego importamos la función loop, con la cual definimos una función vacía e iteramos para siempre. Con receive recibimos un mensaje, es similar al swich, espera a recibir un mensaje y al recibir un mensaje ejecuta la estructura de código que corresponde al mensaje enviado y el “_” es como el default del swich en c, c++ o java.

Primero compilamos, para esto vamos a guardar nuestro saludador en el fichero saludador.erl y luego en la consola de Erlang escribimos:

1> c(saludador).
{ok,saludador}

Con spawn se puede generar un proceso, spawn nos devolverá el PID del proceso, que nos servirá para enviarle mensajes.

2> Pid = spawn(fun saludador:loop/0).
<0.38.0>

Ahora le vamos a mandar un mensaje:

4> Pid ! "conocido".
Hola!! "conocido"

5> Pid ! "Pepe".
... "Pepe"

Como era de esperar solo dice hola a los conocidos. Con el operador ! enviamos mensajes a un actor a partir de su Pid.

Éste es un pequeño ejemplo de manejo de concurrencia en erlang. La forma en que maneja la concurrencia Scala fue inspirada en Erlang.

Scala implementa el modelo de actores similar a Erlang, veamos un poco de código:

import scala.actors.Actor

class Saludador extends Actor  {
  
  def act() = {
        while (true) {
            receive {
                case "conocido" =>
                    println("Hola!")
                case _ =>
                    println("...")
            }
        }
    }

}

object ActorsTest extends App {

  val saludador = new Saludador
  saludador.start()
  
  saludador ! "otro"
  saludador ! "conocido"
}

Akka es un framework java que nos brinda este modelo en el lenguaje java. Permitiéndonos manejar la concurrencia de forma más simple como lo hace scala o erlang.

Veamos un ejemplo:

import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.actor.ActorRef;

public class HelloWorld extends UntypedActor {

  @Override
  public void preStart() {
    // create the greeter actor
    final ActorRef greeter = getContext().actorOf(Props.create(Greeter.class), "greeter");
    // tell it to perform the greeting
    greeter.tell(Greeter.Msg.GREET, getSelf());
  }

  @Override
  public void onReceive(Object msg) {
    if (msg == Greeter.Msg.DONE) {
      // when the greeter is done, stop this actor and with it the application
      getContext().stop(getSelf());
    } else
      unhandled(msg);
  }
}

Como podemos ver en ejemplo podemos hacer un manejo de actores de forma remota. Akka es tolerable a fallos dado que fue concedido con tecnología Let it crash/Embrace failure. Akka es de código abierto y está disponible bajo la licencia Apache 2. A la vez está basado en scala y provee una Api para este lenguaje.

Akka tiene integración con Spring, soporta OSGI, se integra con Apache Camel y la última versión soporta Java 8. ¡Solo falta que cocine y lave la ropa!

Desarrollar aplicaciones concurrentes puede ser un dolor de cabeza. Por este motivo nació el modelo de actores, para simplificar el desarrollo concurrente.