Software Libre

Una explicación simple del software libre:

Resource-oriented architecture

Resource-oriented architecture (ROA) es un estilo arquitectónico basado en Rest, como sabrán SOA es un estilo arquitectónico que indica que funcionalidades del negocio deben estar colgadas es servicios web (normalmente) lo cual permite desacoplamiento de funcionalidad de negocio y reutilización. ROA en cambio no se basa en exponer funcionalidad sino recursos. Lo cual marca una diferencia importante con SOA, SOA se centra en verbos "realizar movimiento bancario" mientra que ROA se basa en los sustantivos "movimientos bancarios".

ROA se basa en REST para exponer los recursos, es decir usa todas las características de REST por lo tanto expone los recursos con URL RestFul. Es decir el movimiento bancario va estar en /movimiento-bancario y se lo va a poder crear con el método PUT, listar con el GET, modificar con POST y borrar con DELETE.

ROA propone exponer los recursos, de forma tal que sea muy similar a la forma que accedemos a base de datos; select - GET, delete - DELETE, update - POST, insert - PUT. Dando una forma clara de acceder, borrar y modificar cada uno de los recursos.

También al basarse en REST se crean arquitecturas livianas flexibles.

Personalmente creo que la gran desventaja es que no contamos con todo el estándar ws-* y el conjunto de herramientas que permiten la orquestación,interacción, seguridad, etc. que si nos brinda SOA.

Creo que el tiempo va a coronar un ganador por ahora a utilizar la mejor herramienta para los problemas particulares y hacer camino al andar!

Dejo Links:

http://en.wikipedia.org/wiki/Resource-oriented_architecture
http://www.infoq.com/articles/RESTSOAFuture

SOAP vs REST: ¿Cual usar en cada caso?

Desde que REST salió a la luz, siempre ha habido un debate en torno a su comparación con SOAP. La arquitectura REST es sencilla, precisamente ese es su atractivo principal.

REST fue rápidamente catalogado como alternativa a SOAP. Aún así, actualmente SOAP todavía posee el monopolio en el mundo de los Servicios Web. Ambos difieren en muchos aspectos comenzando por que REST fue concebido en el ámbito académico y SOAP es un estándar de la industria, creado por un consorcio del cual Microsoft formaba parte.

Las principales diferencias en el funcionamiento de ambos son:

• SOAP es un estilo de arquitectura orientado a RPC (Remote Procedure Call), es decir, un estilo basado en llamadas a procedimientos remotos, mientras que para REST solamente existen los métodos de HTTP y está orientado a recursos.
• REST no permite el uso estricto de “sesión” puesto que por definición es sin estado, mientras que para SOAP, al ser orientado a RPC, los servicios Web crean sesiones para invocar a los métodos remotos.
• SOAP utiliza HTTP como un túnel por el que pasa sus mensajes, se vale de XML para encapsular datos y funciones en los mensajes. Si dibujásemos una pila de protocolos, SOAP iría justo encima de HTTP, mientras que REST propone HTTP como nivel de aplicación.

En el debate de comparación entre REST y SOAP, la mayoría de los desarrolladores de aplicaciones Web toman posiciones muy extremas a favor de uno u otro. Los afines a SOAP, suelen pronunciarse diciendo que SOAP es más flexible que REST a la hora de implementar servicios Web y muestran como un defecto de REST la restricción “sin estado”, mientras que los adeptos de REST (también llamados Restafarians), critican la escasa transparencia de SOAP y opinan que hace las cosas más difíciles de lo que de verdad son, dicen que SOAP da “un paso hacia delante y dos hacia atrás”. Además opinan que SOAP puede suponer un problema porque puede dar lugar a la creación de agujeros de seguridad en las implementaciones HTTP.

Yo personalmente creo que los dos son utiles y se debe buscar la mejor herramienta para cada caso, dejo un link sobre este tema:

http://www.estebanetayo.es/?p=438

The Git Community Book

Todo indica que SVN es bueno pero GIT es mejor, por lo tanto ha estudiar GIT!

Dejo un link sobre el libro de la comunidad:

http://book.git-scm.com/

Y mientras leen el libro dejo una canción de GIT:

Porque tu mama no debe ser tu amigo en facebook

Un poco de humor no viene mal...

Spring data + mongoDB

Bueno vamos a hacer otro ejemplo con Spring data y mongoDB. La idea seria que tengo un usuario y debo guardarlo en una base NoSQL como MongoDB.

Antes de empezar es necesario instalar mongoDB y levantar la base como lo indica el siguiente tutorial:

http://emanuelpeg.blogspot.com/2012/02/instalar-mongodb-en-linux.html

Vamos hacer el proyecto con maven:

mvn archetype:generate

Creamos el proyecto comunacho de maven, con los nombres de paquetes que deseen. Vamos a agregar al pom las dependencias necesarias:

		
			org.springframework.data
			spring-data-mongodb
			1.0.1.RELEASE
		
		
		
			org.springframework
			spring-core
			${spring.version}
		

		
			org.springframework
			spring-context
			${spring.version}
		

		
			org.springframework
			spring-aop
			${spring.version}
		

		
			org.springframework
			spring-aspects
			${spring.version}
		

		
			org.springframework
			spring-tx
			${spring.version}
		

		
			junit
			junit
			4.10
			test
		

		
			org.springframework
			spring-test
			${spring.version}
			test
		

donde:

	3.1.0.RELEASE

Además agregamos el repositorio:

	
		
			spring-release
			Spring Maven Release Repository
			http://repo.springsource.org/libs-release
		
	

Hacemos maven para agregar las dependencias:

mvn clean install
mvn eclipse:eclipse

Ahora importamos el proyecto a eclipse o su IDE favorita, la mía es eclipse.

Creamos la clase User, vamos a hacer antes una clase padre que contenga las particularidades generales de las clases del modelo que van a hacer persistidas:

public abstract class PersistentEntity {
	@Id
	private Long id;

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}


}

Ahora hacemos la clase User:

@Document
public class User extends PersistentEntity {

	private String userName;
	
	private String password;
	
	private List emails = new ArrayList();
	
	public User() {
	}
	
	public User(String userName, String password) {
		super();
		this.userName = userName;
		this.password = password;
	}

	public User(String userName, String password, List emails) {
		this(userName, password);
		this.emails = emails;
	}

	//getters and setters

} 

Vamos a escribir un DAO para ello vamos hacer lo siguiente vamos a generar una clase genérica que contenga métodos genéricos de acceso a datos y vamos a heredar de esta clase; a la vez cada clase va a tener su interfaz que la describa.

La interfaz del genericDAO:

package org.assembly.edda.repository;

import java.io.Serializable;
import java.util.List;

import org.assembly.edda.model.PersistentEntity;

public interface GenericDAO {
	
	T get(ID id);
	
	T save(T object);
	
	void delete(T object);
	
	List findAll();
} 

Su implementación:

package org.assembly.edda.dao;

import java.io.Serializable;
import java.util.List;

import org.assembly.edda.model.PersistentEntity;
import org.assembly.edda.model.User.User;
import org.assembly.edda.repository.GenericDAO;
import org.springframework.data.mongodb.core.MongoTemplate;

/**
 * @author emanuel
 *
 */
public abstract class GenericDAOImpl implements GenericDAO {

	private MongoTemplate mongoTemplate;
	
	public void setMongoTemplate(MongoTemplate mongoTemplate) {
		this.mongoTemplate = mongoTemplate;
	}
	
	protected abstract Class getEntityClass();
	
	public T get(ID id) {
		return (T) mongoTemplate.findById(id, getEntityClass());
	}

	public T save(T objectToSave) {
		mongoTemplate.save(objectToSave);
		return objectToSave;
	}

	public void delete(T objectToDelete) {
		mongoTemplate.remove(objectToDelete);
	}
	
	public List findAll() {
		return mongoTemplate.findAll(getEntityClass());
	}

}

Ahora la interfaz de UserDAO:

package org.assembly.edda.repository.user;

import org.assembly.edda.model.User.User;
import org.assembly.edda.repository.GenericDAO;

public interface UserDAO extends GenericDAO{

}

y su implementación:

package org.assembly.edda.dao.user;

import org.assembly.edda.dao.GenericDAOImpl;
import org.assembly.edda.model.User.User;
import org.assembly.edda.repository.user.UserDAO;

/**
 * @author emanuel
 *
 */
public class UserDAOImpl extends GenericDAOImpl implements UserDAO{

	
	@Override
	protected Class getEntityClass() {
		return User.class;
	}

}

Ahora vamos a escribir el ApplicationContext.xml de spring:

Bueno con esto estamos, solo debemos testar para ver si funciona. Creamos un test; ojo tener levantada la base cuando se lo corre. Para testear esto lo voy hacer más difícil voy a generar una clase padre generica y luego el test concreto (solo para ver como queda)

package org.assembly.edda.dao;

import static org.junit.Assert.*;
import java.util.List;

import org.assembly.edda.model.PersistentEntity;
import org.assembly.edda.repository.GenericDAO;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;


/**
 * @author emanuel
 *
 */
@ContextConfiguration(locations = "classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
@Transactional
public abstract class GenericDAOTest> {
	
	protected abstract DAO getDAO();
	protected abstract T createObject();
	protected abstract T createOtherObject();
	protected abstract void assertEqualsObject(T object, T objectSaved);
	
	@Test
	public void find() {
		T object = createObject();
		getDAO().save(object);
		
		T objectSaved = getDAO().get(object.getId());
		assertEqualsObject(object, objectSaved);
	}

	
	@Test
	public void findAll() {
		T object = createObject();
		getDAO().save(object);
		
		T otherObject = createOtherObject();
		getDAO().save(otherObject);
		
		List all = getDAO().findAll();
		
		assertEquals(2, all.size());
	}

}

Y la implementación del test:

package org.assembly.edda.dao.user;

import static org.junit.Assert.*;

import javax.annotation.Resource;

import org.assembly.edda.dao.GenericDAOTest;
import org.assembly.edda.model.User.User;



public class UserDAOTest extends GenericDAOTest {

	@Resource
	private UserDAOImpl dao;
	
	public void setDao(UserDAOImpl dao) {
		this.dao = dao;
	}
	
	@Override
	protected UserDAOImpl getDAO() {
		return dao;
	}

	@Override
	protected User createObject() {
		User user = new User("Pepe", "0303456yalalala");
		user.setId(4l);
		return user;
	}

	@Override
	protected User createOtherObject() {
		User user = new User("Pepe", "0303456yalalala");
		user.setId(5l);
		return user;
	}
	
	@Override
	protected void assertEqualsObject(User object, User objectSaved) {
		assertEquals(object.getId(), objectSaved.getId());
		assertEquals(object.getUserName(), objectSaved.getUserName());
		assertEquals(object.getEmails(), objectSaved.getEmails());
		assertEquals(object.getPassword(), objectSaved.getPassword());
	}


}

Eso es todo amigos!!

Udacity, la primea universidad online gratuita para todo el mundo

El renombrado profesor de Stanford, Sebastian Thrun, ha dejado la docencia en el centro y ha anunciado un proyecto revolucionario: Udacity, una “universidad” online gratuita e interactiva para cualquier persona en el mundo. El primer curso: cómo construir un motor de búsqueda.

En la pagina web dice:
Creemos que la enseñanza universitaria puede ser a la vez alta calidad y bajo costo.

La verdad es que estoy totalmente de acuerdo con esta premisa, y voy a aprovechar haciendo estos cursos.

Dejo el link:
http://www.udacity.com/

Agile Open Paraná 2012

En el contexto de los exitosos eventos del Agile Open Tour, se organizará un nuevo Agile Open Paraná 2012 "Compartiendo Metodologías Ágiles" el Viernes 30 de Marzo.


No tengo ni una sola palabra para agregar. En realidad 2... 

Ha inscribirse!!

Dejo el link:

http://www.agiles.org/agile-open-tour/agile-open-parana-2012

Hyperpolyglot

Cuando alguien hace un buen trabajo no queda otra que sacarse el sombrero y si es licito compartir ese trabajo a la comunidad. Por esta razón quiero compartir una pagina que encontré que tiene diferentes comparaciones de lenguajes de programación. Estas comparaciones son muy completas y tienen una buena calidad.

Las comparativas son:

Interpreted Languages:	PHP, Perl, Python, Ruby
Interpreted Languages:	Tcl, Lua, JavaScript, Io
Operating System Automation:	POSIX Shell, AppleScript, PowerShell
C++ Style Languages:	C++, Objective C, Java, C#
Pascal Style Languages:	Pascal, Ada, PL/pgSQL, MySQL
Lisp Dialects:	Common Lisp, Scheme, Clojure, Emacs Lisp
Type Inference Languages:	Standard ML, OCaml, Scala, Haskell
Untyped Declarative Languages:	Prolog, Erlang, Oz
Concatenative Languages:	Forth, PostScript, Factor
Tabular Data Selection:	SQL, Awk, Pig
Computer Algebra Software:	Maxima, Mathematica
Numerical Analysis Software:	Fortran, MATLAB, R, NumPy

Dejo el link:
http://hyperpolyglot.org/

Code Hero

"Code Hero" es el video juego que fue diseñado para aprender a programar en javascript. Es un juego en primera persona y usa la api Unity3D.
Lo realmente malo es que se descarga para windows o mac solamente; pruebo si mi wine lo tira!

Dejo el video:



Dejo link:
http://primerlabs.com/codehero

LungoJS

Quiero compartir un screencast sobre LongoJS un framework que aprovecha las caracteristicas de HTML 5, CSS 3 y javascript para desarrollar aplicaciones moviles.

LungoJS - RESTful + Templating + Cache (Spanish) from LungoJS on Vimeo.


Dejo la fuente y links:
http://www.genbetadev.com/desarrollo-aplicaciones-moviles/lungojs-usando-restful-templating-cache-screencast
http://vimeo.com/37014134
http://www.lungojs.com/

Apache celebra su 17 aniversario con un release de su servidor

Leo en infoq que el servidor Apache cumple 17 añitos y para festejarlo libera su versión 2.4 de su servidor http.


Dejo mis felicitaciones!!


Y dejo links:
http://httpd.apache.org/
http://www.infoq.com/news/2012/02/Apache-HTTP-Server-2-4

Infografía sobre HTML 5

Comparto una Infografía sobre HTML 5 y sus nuevos tags y propiedades:

Ejemplos de MongoDb y spring data

Dejo el repositorio de ejemplos de mongoDb y spring data:

https://github.com/SpringSource/spring-data-document-examples

Spring data y mongodb parte 2

Spring data nos brinda muchos beneficios para poder utilizar MongoDB entre los cuales ya nombramos en este post:

http://emanuelpeg.blogspot.com/2012/02/mongodb-spring-data.html

Pero vamos a empezar?

Spring MongoDB requiere MongoDB 1.4 o superior y JDK 1.5 o superior. Obiamente que lo ideal seria utilizar Spring MongoDB en un proyecto que use Spring.

Antes que nada debemos iniciar MongoDB como lo explica el siguiente post:

Podemos hacer un proyecto Spring con maven y agregar las siguientes dependencias:

    org.springframework.data
    spring-data-mongodb
    1.0.0.M5
  

y el siguiente repositorio:

  
    spring-milestone
    Spring Maven MILESTONE Repository
    http://maven.springframework.org/milestone
  

Debemos agregar un archivo log4j.properties si necesitamos ver el log. El archivo va a contener lo siguiente:

http://emanuelpeg.blogspot.com/2012/02/instalar-mongodb-en-linux.html

log4j.category.org.springframework.data.document.mongodb=DEBUG
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %40.40c:%4L - %m%n


Para el siguiente ejemplo vamos hacer una clase persona:

package org.spring.mongodb.example;

public class Person {

  private String id;
  private String name;
  private int age;
   
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  
  //Getters and setters
  
  @Override
  public String toString() {
    return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
  }
  
}

Buenisimo, ahora hacemos un main para probar:

package org.spring.mongodb.example;

import static org.springframework.data.mongodb.core.query.Criteria.where;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;

import com.mongodb.Mongo;

public class MongoApp {

  private static final Log log = LogFactory.getLog(MongoApp.class);

  public static void main(String[] args) throws Exception {

    MongoOperations mongoOps = new MongoTemplate(new Mongo(), "database");

    mongoOps.insert(new Person("Joe", 34));

    log.info(mongoOps.findOne(new Query(where("name").is("Joe")), Person.class));

    mongoOps.dropCollection("person");
  }
}

Es magia.

En 4 lineas de código se guarda en la base de datos NoSQL MongoDB y se consulta con una consulta con where y se logea el resultado y al terminar la prueba se borra los datos; en 4 lineas.

En este pequeño ejemplo se pueden ver 4 cosas:

• Se puede instanciar MongoTemplate con el objeto estandar de MongoDB com.mongodb.Mongo y el nombre de la base.
• Se puede guardar un POJO así de simple sin metadata, ni herencia, ni nada raro.
• MongoDB sabe el ObjectID por convensión, se maneja el campo id por convesión
• La clase Persona puede tener solo getters, dado que asigna los datos por convensión. Si los nombres de los parametros del contructor coinciden con los datos usa estos datos para construir el objeto.

Para la proxima un ejemplo más copado. Continuara...