Un vistazo a Node.js

Node.js es un entorno de ejecución para aplicaciones hechas con Javascript. Posee un ecosistema de paquetes (npm) que nos provee una manera más fácil para el desarrollo de nuestras aplicaciones.

Existen diversas maneras de instalar Node.js. Una de ellas es mediante nvm.

Para ello podemos teclear la siguiente orden en la terminal de comandos (si usas Linux, debo aclarar):

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.32.1/install.sh | bash

Para que surja efecto hay que teclear:

source ~/.bashrc

Listo, tenemos instalado nvm:

nvm --version

Para instalar node tecleamos: 

nvm install node

Para instalar el gestor de paquetes npm:

nvm install npm

Comprobamos su instalación:

node -v

npm -v 

Ahora a crear el primer ejemplo.
1. Creamos un archivo llamado hola.js
2. Ejecutamos el script mediante node


hola.js
console.log("Hola, Codemonkeys");


En terminal tecleamos:

node hola.js

Ya tenemos nuestro primer ejemplo en Node.js

Links
https://github.com/creationix/nvm
https://nodejs.org/es/

Ama el problema, no tu solución

Les dejo este vídeo de Coder Dog sobre los problemas a los que nos enfrentamos en el desarrollo de aplicaciones.

Instalar lenguajes JVM usando SDKMAN!

Existe una herramienta llamada SDKMAN! que nos sirve para instalar lenguajes como Ceylon, Groovy, Scala, además de otros entornos o sdks de desarrollo como Grails, SBT, etc.

Desde Linux podemos teclear en nuestra consola de comandos:
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

Obtener ayuda:  sdk help
Que versión tenemos: sdk version
Listar lo que podemos instalar: sdk list

Comencemos instalando Ceylon, Groovy, y Scala:
sdk install ceylon
sdk install groovy
sdk install scala

Comprobemos que se instalaron adecuadamente:
ceylon --version
groovy -version
scala -version
 
Con esto tenemos instalados los lenguajes y la herramienta SDKMAN!.

Links
http://sdkman.io/

Conociendo Java 8

Dicen que con los cambios vienen cosas mejores.  Esperemos que sea así. Java 8 nos trae nuevas características. Una de ellas son: las Lambdas. ¿Qué son las lambdas? ¿Para qué nos sirven?.  Las lambdas son un tipo de función. Es una función "anónima", es decir, que no está vinculada un nombre.

En lenguajes como Python tenemos algo como esto:

switch=[
    lambda n: 'Hola',
    lambda n: 'Que tengas un buen dia' if n == 1 else 'Tal vez no tengas un buen dia',
    lambda n: 'Hoy es un buen dia para empezar' if n == 2 else 'Tal vez otro dia puedas empezar',
]

opcion=raw_input('Introduce un numero ente 1 y 2:')
print switch[0](opcion)
print switch[1](opcion)

En Java 8 tenemos "las expresiones Lambda". Que se puede definir como un "nuevo estilo" o manera de programar usando Lambdas.

En el sitio oficial de Oracle tenemos esta explicación:
"They provide a clear and concise way to represent one method interface using an expression. Lambda expressions also improve the Collection libraries making it easier to iterate through, filter, and extract data from a Collection. In addition, new concurrency features improve performance in multicore environments."

Podemos escribir algo como esto:

Clase instancia = () -> hacerAlgo();

La función puede o no contener parámetros. Además no es necesario definir qué tipo de dato es (String, int, double, boolean, char).

Clase instancia = (String a) -> hacerAlgo(a);  

Ejercicio. Crearemos una interface "Servicio" que contenga un método llamado opera, elcual recibe dos parámetros a y b. Una clase principal con un método llamado "operacion"que recibirá tres parámetros,las variables a,b y una instancia de tipo Servicio. La operación a realizar es la suma.

import static java.lang.System.out;

public class Control{
    public static void main(String[] args) {
        Servicio s=(a,b) -> a-b;
         out.println("35 - 26 = " + new Control().operacion(35, 26, s));
    }

    private int operacion(int a,int b, Servicio servicio){
        return servicio.opera(a,b);
    }
}

interface Servicio{
    int opera(int a,int b);
}

El resultado será 35 - 26 = 9.


Links
http://viralpatel.net/blogs/lambda-expressions-java-tutorial/
http://stackoverflow.com/questions/16501/what-is-a-lambda-function

Programando en C# : Interfaces y clases abstractas

Para los programadores que vienen de Java puede parecerles raras algunas cosas del lenguaje C#. Recordemos que C# es un lenguaje "heredero" de Java ysigue la misma filosofía, pero con ciertas variantes y una evolución propia. C# nació como lenguaje competidor y ciertos aspectos permanecen igual.


Ejemplo. Calcular el área y el perímetro de tres figuras geométricas: Circulo, Rectángulo, y Triángulo.

Crearemos una clase abstracta (la cual no podrá ser instanciada) que nos servirá como Padre de las demás clases que la extienden.

• Clase abstracta:  Figura
• Clases hijas: Triangulo, Rectangulo, y Circulo

Además una interface, una clase también abstracta que nos permitirá definir métodos comunes entre las tres clases creadas.

//tenemos la clase abstracta (y Padre)
abstract class Figura{ ... }

//la interface
interface Funciones { ... }

//las clases hijas y que además implementan la interface Funciones
class Triangulo : Figura , Funciones{ ... }
class Circulo: Figura, Funciones{ ... }
class Rectangulo: Figura, Funciones{ ... }


Código completo:
using System;

public class Codemonkey{
    public static void Main(string[] args){
        Triangulo t;
        Rectangulo r;
        Circulo c;
        try{
            t=new Triangulo();
            c=new Circulo();
            r=new Rectangulo();

            t.setLados(new int[]{3,3,3});
            t.Bases=26;
            t.Altura=23;

            c.Radio=2.4;
            c.Diametro=4.9;

            r.Bases=6;
            r.Altura=4;

            Console.WriteLine("Triangulo\nPerimetro: {0}  , Area: {1}",t.getPerimetro(),t.getArea());
            Console.WriteLine("Circulo\nPerimetro: {0}  , Area: {1}",c.getPerimetro(),c.getArea());
            Console.WriteLine("Rectangulo\nPerimetro: {0}  , Area: {1}",r.getPerimetro(),r.getArea());

        }catch(Exception ex){
            Console.Error.WriteLine("Error {0}",ex.Message);
            Environment.Exit(0);
        }finally{
            t=null;r=null;c=null;
        }
    }
}

abstract class Figura{
    private int[] lados;
    private int altura;
    private int bases;

    public void setLados(int[] lados){
        this.lados=lados;
    }

    public int[] getLados(){
        return lados;
    }

    public int Bases{get;set;}
    public int Altura{get;set;}
}

interface Funciones{
    int getArea();
    int getPerimetro();
}

class Triangulo : Figura , Funciones{

    public  int getPerimetro(){
        return (int)this.getLados()[0] * 3;
    }

    public int getArea(){
        return (this.Bases*this.Altura) / 2;
    }

}

class Rectangulo : Figura, Funciones{

    public  int getPerimetro(){
        return 2*(this.Bases*this.Altura) + (2* this.Bases);
    }

    public  int getArea(){
        return this.Bases*this.Altura;
    }

}

class Circulo : Figura, Funciones{
    private double radio;
    private double diametro;


    public double Radio{get;set;}
    public double Diametro{get;set;}


    public  int getPerimetro(){
        return (int)(3.14159*this.Diametro);
    }

    public  int getArea(){
        return (int)(3.14159*(this.Radio*2));
    }
   
}

Compilar: gmcs Codemonkey.cs
Ejecutar: mono Codemonkey.exe

JDBI como alternativa a JDBC

En el post anterior hablábamos de una librería que nos permite realizar operaciones con bases de datos de una manera más sencilla y similar a lo que se hace con JDBC.

JDBI promete, al menos en teoría, hacer que el manejo de información en bases de datos no sea tan complicada. Haremos un ejemplo práctico para ver si es tan fácil o no.

Supongamos que tenemos una base de datos llamada "test" y una tabla llamada "persona". Obtendremos la información contenida en la tabla persona creando los siguientes archivos (clases):

• ModeloPersona.java  que servirá como "entidad" en nuestra aplicación.
• ModeloPersonaMapper. java que servirá como "mapeador" de la entidad.
• PersonaDAO.java donde definiremos las operaciones de consulta.
• TestPersona.java que servirá como clase principal.

Nuestra tabla "persona" contiene los siguientes campos: id, nombre, apellidoP, apellidoM, edad,peso, talla. Por lo tanto, nuestra entidad ModeloPersona.java también debe cubrir esos campos.

ModeloPersona.java

public class  ModeloPersona implements java.io.Serializable{
 
private static final long serialVersionUID=1L;

private String id;
private String nombre;
private String apellidoP;
private String apellidoM;
private String edad;
private String peso;
private String talla;

public ModeloPersona(String id, String nombre,String apellidoP,String apellidoM,String edad,String peso,String talla){
    super();
    this.id=id;
    this.nombre=nombre;
    this.apellidoP=apellidoP;
    this.apellidoM=apellidoM;
    this.edad=edad;
    this.peso=peso;
    this.talla=talla;
}

//setters y getters
}


ModeloPersonaMapper.java

 public class ModeloPersonaMapper implements ResultSetMapper<ModeloPersona> {

    @Override
    public ModeloPersona map(int arg0, ResultSet r, StatementContext arg2) throws SQLException {
        ModeloPersona mpersona=new ModeloPersona();
        mpersona.setClave(r.getString("clave"));
        mpersona.setNombre(r.getString("nombre"));
        mpersona.setApellidoP(r.getString("apellidoP"));
        mpersona.setApellidoM(r.getString("apellidoM"));
        mpersona.setEdad(r.getString("edad"));
        mpersona.setPeso(r.getString("peso"));
        mpersona.setTalla(r.getString("talla"));
        return null;
    }

}

PersonaDAO.java
import org.codemonkey.model.ModeloPersona;
import org.skife.jdbi.v2.sqlobject.Bind;
import org.skife.jdbi.v2.sqlobject.SqlQuery;
import org.skife.jdbi.v2.sqlobject.customizers.RegisterMapper;

@RegisterMapper(ModeloPersonaMapper.class)
public interface PersonaDAO {
    @SqlQuery("SELECT test.persona.clave, test.persona.nombre, test.persona.apellidoP, test.persona.apellidoM, test.persona.edad, test.persona.peso, test.persona.talla FROM test.persona WHERE test.persona.clave = :id")
    ModeloPersona findById(@Bind("id") long id);
    @SqlQuery("SELECT test.persona.clave, test.persona.nombre, test.persona.apellidoP, test.persona.apellidoM, test.persona.edad, test.persona.peso, test.persona.talla FROM test.persona")
    List<ModeloPersona> verTodo();
    void close();
}

Finalmente la clase TestPersona.java

package org.codemonkey.test1;

import org.codemonkey.dao.PersonaDAO;
import org.codemonkey.model.ModeloPersona;
import org.skife.jdbi.v2.DBI;
import org.skife.jdbi.v2.Handle;
import static java.lang.System.out;

public class TestPersona {

    public static void main(String[] args) {
        DBI dbi = new DBI("jdbc:mysql://localhost:3306/test",
                "root",
                "5432");
        Handle h = dbi.open();
        if(!dbi.open().isInTransaction()){
            out.println("No esta realizando alguna transaccion");
        }
       
        PersonaDAO pers=null;
        try{
            pers=dbi.open(PersonaDAO.class);
            if(pers.verTodo().size() > 0){
                out.println("Lista de persona llena!!:"+pers.verTodo().size());
                out.println(""+pers.verTodo().toString());
                for(int i=0 ; i < pers.verTodo().size(); i++){
                    out.println("id:"+pers.verTodo().get(i).getClave());
                    out.println("nombre:"+pers.verTodo().get(i).getNombre());
                    out.println("apellido paterno:"+pers.verTodo().get(i).getApellidoP());
                    out.println("apellido materno:"+pers.verTodo().get(i).getApellidoM());
                    out.println("edad:"+pers.verTodo().get(i).getEdad());
                    out.println("peso:"+pers.verTodo().get(i).getPeso());
                    out.println("talla:"+pers.verTodo().get(i).getTalla());   
                   
                }
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }finally{
            pers.close();
        }
       
        h.close();
    }

}

Conociendo JDBI

Usar JDBC implica el uso de clases y algunas configuraciones que nos permiten establecer conexión con bases de datos. Además tan solo necesitamos algún driver para cada tipo de bases (MySQL, Oracle, Sqlite, Firebird,etc.).

Sin embargo, hay cierta complejidad cuando necesitamos manejar gran cantidad de información. Los que han programado en Java saben lo molesto que puede ser el acceso a base de datos mediante los mecanismos que nos proporciona el JDBC (Java DataBase Connectivy).  No es que sean malos, pero cuando se trata de administrar la información de un  proyecto más o menos grande si causa algunos problemas.  

JDBI nace gracias a la necesidad de los programadores por acceder y administrar bases de datos de una manera más sencilla. Es una librería Java que promete ser una alternativa más adecuada al uso de JDBC.

JDBI nos ofrece dos estilos:

1. Estilo fluido: Donde se hace uso de Datasource similares a JDBC, pero de una manera mucho más sencilla.
2. Estilo Objetos SQL: Similar a lo que hacemos usando Hibernate o JPA nativo. donde tenemos nuestras "Entities" y las manipulamos mediante DAOs. 

 Más adelante haremos algunos ejemplos.

Links
http://jdbi.org/