Primeros pasos en Haskell

Haskell es un lenguaje funcional que les aconsejo que aprendan. Antes que nada vamos a instalar el compilador GHC o Hugs. Yo voy a usar GHC, si usamos una distro basada en Debian, podemos hacer lo  siguiente:

apt-get install ghc6 libghc6-mtl-dev

y si tenemos un RHEL podemos hacer:

yum install ghc6 libghc6-mtl-dev

GHC puede tomar un script Haskell y compilar pero también puede trabajar de modo interactivo; lo que se conoce como RELP. Luego de instalar estos paquete ejecutamos ghci en una consola:

[emanuel@localhost ~]$ ghci
GHCi, version 7.4.1: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> 2 +2
4
Prelude> 5 + 5
10
Prelude> 2 * 2
4
Prelude> 5 / 2
2.5
Prelude> True  && False
False
Prelude> 5 == 5
True
Prelude> 5 /= 4
True
Prelude> 5 + "hola"

<interactive>:9:3:
    No instance for (Num [Char])
      arising from a use of `+'
    Possible fix: add an instance declaration for (Num [Char])
    In the expression: 5 + "hola"
    In an equation for `it': it = 5 + "hola"
Prelude>

Como podemos ver podemos utilizar Haskell como calculadora, pero en la ultima linea, que sucedió? El error que fue lanzado fue porque quise sumar 5 de tipo numero con una palabra o String "hola" y como Haskell es de tipado estático, no puede sumar estas cosas. 

También podemos llamar funciones de la siguiente forma:

Prelude> min 3 5

3

Prelude> max 100 100

100

Prelude> max 3000 3 

3000

Como pueden ver el llamado de funciones no necesita los paréntesis como java o C++ o C. 

Por este post hemos avanzado bastante, en próximos post vamos a seguir aprendiendo Haskell!

Clojure - Functional Programming for the JVM

Quiero compartir un link muy interesante, sobre Clojure muy completo y útil.

Dejo link: http://java.ociweb.com/mark/clojure/article.html

Que proyectos Open Source están hechos con Clojure?

Este post es a raíz de una pregunta en stackoverflow que publico el amigo Ivan Pierre en google+, pufff cuanta comunicación.

La pregunta es sencilla, conocen algún proyecto open source que este escrito en Clojure, bueno para aprender más sobre Clojure, y la respuesta fue una buena lista:

• Clojure: Clojure esta escrito en Clojure por lo tanto cuenta.
• Compojure: Un Framework web para desarrollo en Clojure.
• Ring: Es una librería web inspirada en Python's WSGI y Ruby's Rack. 
• Enlive: Selector basado en CSS.
• Incanter: Es una plataforma de computación estadística y graficación similar a R. 

Y más!!! 

Developers Bus

Encontré una pagina del Developer Bus, si no tienen idea que es esto les dejo un extracto:

"Bienvenido al Developer Bus!
El Developer Bus es el primer reality para desarrolladores en Latinoamérica, podrás seguir todas las novedades de una forma social y en vivo. ¿Estás listo para demostrar tu talento, diseñar y contribuir al ecosistema de tus PyMES regionales?"

Dejo el link
http://developerbus.withgoogle.com/

Shibboleth un single-sign in basado en el estándar SAML 2

Vamos por partes, que es un single-sign in? Un single-sign in es un sistema que permite que te autentique una sola vez en todos los sistemas de tu empresa o organización. De esta forma no es necesario logearse cada vez que abrimos un sistema.

Shibbolethes un  single-sign in open source que se apoya en el estándar SAML 2. Pero que es SAML 2? primero que todo es un estándar realizado por la organización OASIS que quiso tomar las mejores características de los mensajes de comunicación de single-sign in y formar uno que englobe a todos. Por lo tanto SAML no es más que XML estandarizado.

Porque esta bueno que un single-sign in use estándares? Porque se tiene que integrar con infinidad de sistemas, por lo tanto si existe un estándar todos los sistemas implementan este estándar solo una vez y pueden comunicarse con cualquier single-sign in.

Shibbolethes es tecnología open source, que provee muchas formas de autenticarse. Se basa en autenticación web.

Dejo el link:
http://shibboleth.net

Living in a Post-Functional World

Les quiero recomendar este vídeo sobre programación Funcional, es muy bueno:

http://www.infoq.com/presentations/post-functional-scala-clojure-haskell

Y les dejo un video:

Toad World

Si no conocen "El Toad" es porque no han trabajado mucho con Oracle... Esta misma empresa quiere hacer comunidad, y nos presenta  un sitio muy recomendable, Toad World. En el cual podemos descargarnos un montón freeware muy útil,la joyita es la ide para Big data (Toad for Cloud Database), que nos permite conectarnos con Hadoop, tanto a la base Hive como a HBase.

Dejo link: www.toadworld.com

Buscar documentación en Clojure

Similar que la función help de python, en clojure existe doc, con esta función podemos ver documentación de otra función, como por ejemplo:

=> (doc str)
-------------------------
clojure.core/str
([] [x] [x & ys])
  With no args, returns the empty string. With one arg x, returns
  x.toString().  (str nil) returns the empty string. With more than
  one arg, returns the concatenation of the str values of the args.
nil

Por supuesto que doc muestra lo que esta documentado de la función, no hace magia, si no documentamos nuestras funciones doc no puede mostrar nada.

Otras veces no sabemos que función utilizar y para esos casos esta find-doc que pasandole una expresión regular busca las funciones que se le parecen:

=> (find-doc "reduce")
-------------------------
clojure.core/areduce
([a idx ret init expr])
Macro
  Reduces an expression across an array a, using an index named idx,
  and return value named ret, initialized to init, setting ret to the
  evaluation of expr at each step, returning ret.
-------------------------
clojure.core/reduce
([f coll] [f val coll])
  f should be a function of 2 arguments. If val is not supplied,
  returns the result of applying f to the first 2 items in coll, then
  applying f to that result and the 3rd item, etc. If coll contains no
  items, f must accept no arguments as well, and reduce returns the
  result of calling f with no arguments.  If coll has only 1 item, it
  is returned and f is not called.  If val is supplied, returns the
  result of applying f to val and the first item in coll, then
  applying f to that result and the 2nd item, etc. If coll contains no
  items, returns val and f is not called.
-------------------------
...
nil

Importar librerias en clojure

Clojure se organiza en namespaces que son similares a los paquetes de java.

Tenemos diferentes formas de importar librerías o paquetes:

• Require, de esta forma le indicamos a Clojure que necesitamos una librería  Clojure va a verificar que esta este en el classpath, se usa de la siguiente manera: 

(require 'com.mi.libreria)

• Refer, con refer hacemos es que no tengamos que escribir todo el nombre de la librería. Solo usamos las funciones que fueron importadas. Lo que hacemos con refer es referenciar un namespace, creando mapeos para todos los nombres al actual namespace:

(refer 'com.mi.libreria)

• Use, es la aplicación de los 2 anteriores, Clojure se fija que la librería este en el classpath y también no es necesario escribir el nombre librería al llamar una función. Use tiene una bandera llamada reload, con la que le decimos que si importo ya una librería  que la recargue si esta librería tuvo un cambio, se actualizara.

(use 'com.mi.libreria)

Veamos un ejemplo:

(use 'examples.introduction)

->nil

(take 10 fibs)

->(0 1 1 2 3 5 8 13 21 34)

Firefox OS

El mercado de los moviles esta que arde, todos se quieren quedar con algo de la torta, un producto que esta ganando adeptos es Firefox OS. Que nos ofrece mira esta infografia:

Jtype, dando tipos a javascript

Tal vez se acuerdan de TypeScript, era un framework javascript para dar tipos a Javascript,  este framework esta impulsado por microsoft. Jtype tiene la misma idea, llevar javascript al mundo de las clases, con herencia y todo lo que ya conocemos.




Basta de chacharas y veamos un ejemplo:

// get the precompiled person class
var cachedPerson = localStorage.getItem('Person');

// compile the person class
var Person = $$(cachedPerson ? cachedPerson : '', function($fName, $lName, $age)
{
    // set the readonly fields (cast the string arguments)
    this.firstName = $$.asString($fName);
    this.lastName  = $$.asString($lName);

    // set the protected field (cast the number arguments)
    this._age = $$.asInt($age);
},
{
    'public readonly firstName': '',
    'public readonly lastName': '',

    'protected _age': 0,

    'public getFullName': function()
    {
        // return the concatenated full name
        return this.firstName + ' ' + this.lastName;
    },

    'public virtual triggerOneYearOlder': function()
    {
        // increment the protected field
        this._age++;
    },

    'public age':
    {
        'get': function()
        {
            // return the protected field
            return this._age;
        },
        'set': function($v)
        {
            // if the incoming property value is valid, set the protected field
            if ($v > 0)
                this._age = $v;
        }
    }
});

// if the person class was not cached, store a local copy of the precompiled export string
if (!cachedPerson)
    localStorage.setItem('Person', $$.export(Person));

// get the precompiled employee class
var cachedEmployee = cachedPerson && localStorage.getItem('Employee');

// compile the employee class
var Employee = $$(cachedEmployee ? cachedEmployee : '', Person, function($fName, $lName, $age, $salary)
{
    // call the base constructor
    this.__base($fName, $lName, $age);

    // set the protected salary field
    this._salary = $salary;
},
{
    'protected _salary': 0,

    'public override triggerOneYearOlder': function()
    {
        // increment the protected age field (by calling the base method)
        this.__base.triggerOneYearOlder();

        // increase the salary by three percent
        this._salary *= 1.03;
    },

    'public salary':
    {
        'get': function()
        {
            // return the salary
            return this._salary;
        }
    }
});

// if the employee class was not cached, store a local copy of the precompiled export string
if (!cachedEmployee)
    localStorage.setItem('Employee', $$.export(Employee));

// instantiate a person object
var p = new Person('John', 'Doe', 30);

// check that the values were set
console.log(p.firstName);// John
console.log(p.lastName);// Doe
console.log(p.age);// 30

// get a protected field
console.log(p._age);// undefined

// set a readonly field (throws an exception in debug mode)
//p.firstName = 'Jane'; (uncomment to try it out)

// set an invalid property value
p.age = -40;

// check that the field and property didn't change
console.log(p.firstName);// John
console.log(p.age);// 30

// set a valid property value
p.age = 40;

// check that the property did change
console.log(p.age);// 40

// invoke a method
console.log(p.getFullName());// John Doe

// invoke a virtual method
p.triggerOneYearOlder();

// check that the age was incremented (by the virtual method)
console.log(p.age);// 41

// instantiate an employee object
var e = new Employee(p.firstName, p.lastName, p.age, 75000);

// check that the inherited values were set
console.log(e.firstName);// John
console.log(e.lastName);// Doe
console.log(e.age);// 41

// get an inherited protected field
console.log(e._age);// undefined

// set an inherited readonly field (throws an exception in debug mode)
//e.firstName = 'Jane'; (uncomment to try it out)

// check that the field didn't change
console.log(e.firstName);// John

// get a declared field (not inherited)
console.log(e.salary);// 75000

// cast the employee object as a person object
e = e.as(Person);

// check the types of both person objects
console.log(p instanceof Person);// true
console.log(p instanceof Employee);// false
console.log(e instanceof Person);// true
console.log(e instanceof Employee);// true

// check that both person objects don't have the derived property
console.log(p.salary);// undefined
console.log(e.salary);// undefined

// invoke an overridden method
e.triggerOneYearOlder();

// cast the person object as an employee object
e = e.as(Employee);

// check that the age was incremented (by the base method)
console.log(e.age);// 42

// check that the salary increased 3% (by the overridden method)
console.log(e.salary);// 77250

Dejo link
:https://github.com/gaulinsoft/jTypes
https://www.facebook.com/JTypes
https://github.com/gaulinsoft/jTypes

Download Free ebook

He recibido de una empresa llamada Attune el siguiente mail y lo comparto:

Download Free Download FREE Open Source Intelligence monitoring eBook ActiveMQ Startup Guide Control over Mule Administration Creating User and Accessing Roles to them Accessing Work Flow From MMC Understanding Application deployment using Mule Management Console Creating Clusters and Deploying Application over them Creating Alert and Email Alerts on Cluster/Server Specific behavior Learning Load Balancing Over Cluster/Server ​ How to Dividing up Work with Queue in ActiveMQ How to create connection with ActiveMQ JMS broker How to Start ActiveMQ Server How to create Consumer and Producer How to send and receive message through Producer and Consumer JMS ActiveMQ in MULE How to Configure JMS component in Mule Creating Global ActiveMQ connector Monitoring queue Message using ActiveMQ admin Complete Integration with Simple example

Si te gusta un libro, a bajar!

SugarJ, endulzando Java...

SugarJ el objetivo de SugaJ es hacer más natural escribir código en los lenguajes. Pongamos un ejemplo, si te toca escribir un XML en java, te vas a encontrar que java no fue hecho para eso; pero existen librerías que utilizan mecanismos que hacen más fácil, por ejemplo escribir un XML en java. Lo que pretende hacer SugarJ es agregar azúcar sintético por medio de librarías.

Las librerías que contienen azúcar sintáctico conservan la compatibilidad y auto-aplicabilidad de las librerías convencionales: azúcar sintáctico puede estar compuesta mediante la importación de múltiples librerías,   azúcar sintáctico puede ser utilizado en el desarrollo de una librerías que exporta en sí azúcar sintáctico. De esta forma podremos generar DSL con librerías.

Este framework o libreía no solo existe para Java, también existe SugarHaskell.

Dejo link:
http://www.informatik.uni-marburg.de/~seba/projects/sugarj/

Rest con PHP, más fácil imposible!!

Me toco diseñar una API REST con PHP y la verdad me da vergüenza decir que trabaje, porque es sumamente fácil,lo primero hacemos nuestra función PHP, para el ejemplo un listado de paises:

    $db = new DB(); //Con este objeto me conecto a la base
    $db->conectar();
    $sql = 'SELECT * FROM `paises` ORDER BY `nombre`'; //Listo los paises por ejemplo
    $consulta = $db->query($sql);

    while ($fila = mysql_fetch_array($consulta)) {
        $paises[] = $fila;  
    }
    $data["paises"] = $paises;
    echo json_encode($data); // lo imprimo formato json.

Y listo, claro que no es rest puro pero es util para publicar una función. Si quieren usar Rest puro pueden usar el metodo $_SERVER['REQUEST_METHOD'] y de esta forma saber el metodo, y si tenemos un controlador podemos hacer:

$method = $_SERVER['REQUEST_METHOD'];

// Dependiendo del método de la petición ejecutaremos la acción correspondiente.

switch ($method) {
    case 'GET':
        // código para método GET
        break;
    case 'POST':
        $arguments = $_POST;
        // código para método POST
        break;
    case 'PUT':
         // código para método PUT
        break;
    case 'DELETE':
        // código para método DELETE
        break;
}

Y esto lo podemos consumir con javascript y si usamos jquery es una papa:

           $.ajax({

                       type: "GET",

                       dataType: "JSON",

                       url: "listar_paises",                                        

                       success: function(data)                                 

                       { //hacer algo

                       },

                       error: function() 

                       {       alert("Error recuperando la lista de Paises");

                       }                

                });

Y listo!!

GNU: 30 años de libertad

La noticia es un poco vieja pero no quiero dejar pasar la oportunidad de unirme al festejo de los 30 años de la organización GNU!

Y en los 30 años quiero recordar las palabras de Richard Stallman:  '¡Unix Libre! A partir del próximo Día de Acción de Gracias comenzaré a escribir un sistema de software completo compatible con Unix llamado GNU (que significa 'Gnu No es Unix'), y lo distribuiré libremente para que todos puedan usarlo. Son muy necesarias las contribuciones de dinero, programas y equipos'.