Software Freedom Day

Éste sábado 17 de setiembre de 2011 se estará realizando el Software Freedom Day, o Día de la Libertad del Software. Es una celebración anual a nivel mundial que se realiza desde hace 7 años para celebrar las virtudes del software libre y los beneficios de compartir.

Software Freedom Day es una celebración global del Software Libre y abierto (FLOSS).

En nuestros días donde nuestras vidas son cada vez más dependientes de la tecnología, es importante que tomemos el tiempo de considerar el impacto tecnológico que este tiene y la importancia de asegurarnos que la tecnología no esta siendo usada para limitarnos, pero para tomarnos más lejos en ruta de oportunidad, innovación y libertad para todas las personas.
Dejo links:

http://softwarefreedomday.org/
http://es.wikipedia.org/wiki/D%C3%ADa_de_la_Libertad_de_Software

CoffeeScript

CoffeeScript es un lenguaje que “compila” dentro de javascript dando mayor facilidad a la hora de escribir código. Es un lenguaje dentro de javascript para hacernos las cosas más fáciles.
Personalmente creo que javascript no es muy natural pero es un gran lenguaje. El principal problema al escribir código es nuestro desconocimiento sobre el lenguaje, nadie estudia a fondo como funciona javascript.

Después de la reflexión dominical veamos unos ejemplos como nos puede ayudar coffeeScript a escribir código:
En javascript es así

var cube, square;
square = function(x) {
  return x * x;
};
cube = function(x) {
  return square(x) * x;
};

En coffeescript así:

square = (x) -> x * x
cube   = (x) -> square(x) * x

En javascript es así

var fill;
fill = function(container, liquid) {
  if (liquid == null) liquid = "coffee";
  return "Filling the " + container + " with " + liquid + "...";
};

En coffeescript así:

fill = (container, liquid = "coffee") ->
  "Filling the #{container} with #{liquid}..."

Además de todas estas ventajas permite escribir clases:

class Animal
  constructor: (@name) ->

  move: (meters) ->
    alert @name + " moved #{meters}m."

class Snake extends Animal
  move: ->
    alert "Slithering..."
    super 5

class Horse extends Animal
  move: ->
    alert "Galloping..."
    super 45

sam = new Snake "Sammy the Python"
tom = new Horse "Tommy the Palomino"

sam.move()
tom.move()

Lambda en Java 8

Por fin se decidió la sintaxis del operador lambda en java 8. Luego de muchas discusiones se decidió por la sintaxis de scala que es igual a la que usa C#. Me parece muy bien, se habían disparados supuestos y ejemplo de otras sintaxis que para mi gusto no eran cómodas ni elegante.

Sin más veamos unos ejemplos:

x => x + 1
(x) => x + 1
(int x) => x + 1
(int x, int y) => x + y
(x, y) => x + y
(x, y) => { System.out.printf("%d + %d = %d%n", x, y, x+y); }
() => { System.out.println("Hola!"); }


Muy similar a Scala:

(x: Int) => x * x
(x: Int, y: Int) => x * y

Que les parece?

Mockito

El objetivo de una prueba unitaria es probar un solo objeto, pero en ciertas ocasiones las colaboraciones entre objetos tienen un acoplamiento alto por lo tanto no puedo probar un objeto sin llamar a otro. Es aquí donde los test se ensucian un poco, en especial si el objeto que deseamos testear depende de algún objeto “pesado” o que tenga interacción con algún otro sistema externo, servidor o base de datos. Por ejemplo testear un objeto que valide el nombre de usuario y la clave en un ldap.

Una estrategia de solución para este problema es usar objetos mocks, los objetos mocks son objetos “de mentira” que permiten simular otro objeto o entidad del sistema. Si vamos a la wikipedia podremos encontrar la siguiente definición:

En la programación orientada a objetos se llaman objetos simulados (pseudoobjetos, mock object, objetos de pega) a los objetos que imitan el comportamiento de objetos reales de una forma controlada. Se usan para probar a otros objetos en pruebas de unidad que esperan mensajes de una clase en particular para sus métodos, al igual que los diseñadores de autos usan un crash dummy cuando simulan un accidente.

En los test de unidad, los objetos simulados se usan para simular el comportamiento de objetos complejos cuando es imposible o impracticable usar al objeto real en la prueba. De paso resuelve el problema del caso de objetos interdependientes, que para probar el primero debe ser usado un objeto no probado aún, lo que invalida la prueba: los objetos simulados son muy simples de construir y devuelven un resultado determinado y de implementación directa, independientemente de los complejos procesos o interacciones que el objeto real pueda tener.
Existen diferentes frameworks en java para hacer mocks, easymock, mockito, etc. Vamos a utilizar mockito.

Mockito es un framework simple, fácil de usar para hacer objetos mocks en java. Tiene una interfaz simple  y natural.

Características:

• Se pueden crear mocks de interfaces y clases concretas.
• Verificación de invocaciones (cantidad exacta, al menos una vez, órden de invocación, etc.)
• El stack trace se mantiene limpio, ya que los errores ocurren en los assert que se hagan (y no dentro del método bajo prueba).
• Un API más clara para crear stubs y verificaciones.

Vamos a hacer un objeto mock con mockito:

//creamos el mock y el stub


ArrayList instance = mock(ArrayList.class);
doReturn("hola mundo").when(instance).get(0);
 
//ejecutamos la lógica a probar
instance.get(0);     
 
//verificamos que se hayan invocado los métodos
verify(instance).get(0)

Como se puede ver la api es clara y simula el lenguaje natural. En la primera linea creamos un objeto mock de la lista; luego indicamos que cuando se llame el método get con el parámetro 0 debe devolver “hola mundo”. Luego ejecutamos el método y luego se verifica si este método se corrió.

Para agregar este framework a nuestro proyecto maven es solo necesario agregar esta entrada en el pom:

    org.mockito
    mockito-all
    1.8.5

Libros Gratuitos

Dejo dos libros gratuitos, el primero de un framework llamado node.js (muy recomendado) el otro sobre TDD.

 http://www.nodebeginner.org/index-es.html 
 http://www.dirigidoportests.com/el-libro 

 Que los disfruten!!

JUnit 4

Junit 4 es un framework de test unitario basado en anotaciones. Nos permite realizar el mismo trabajo que JUnit 3 pero con anotaciones, proveyendo mayor flexibilidad y simplicidad a nuestro código.

JUnit provee elementos que nos facilitan probar entidades o clases de nuestro programa:

Permite cargar los test de forma transparente Provee anotaciones que facilitan el testing: @Before, @BeforeClass, @After, and @AfterClass Provee diferentes asserts Integración con IDEs (eclipse, netbeans) y herramientas como maven y ant.

Veamos un ejemplo de test con JUnit:

import static org.junit.Assert.*; 
import org.junit.Test; 
public class CalculatorTest { 
	@Test 
	public void testAdd() { 
		Calculator calculator = new Calculator(); 
		double result = calculator.add(10, 50); 
		assertEquals(60, result, 0); 
	} 
} 

En la primera linea se importan los métodos de la clase estática Assert, la cual cuenta con sin fin de asserts, que facilitan nuestros test. Con @Test indicamos que ese método es un Test. Además con el método assertEquals de la clase Assert verificamos si el resultado es igual a 60.

Test Case son casos de prueba, en JUnit 4 son los metodos que estan anotados con @Test

Test Suite son un conjunto de Test Case, JUnit 4 genera automáticamente un Test Suite cuando se corren todos los test de una clase. Veamos un ejemplo de Test Suite:

@RunWith(value=org.junit.runners.Suite.class) 
@SuiteClasses(value={FolderConfigurationTest.class, 
 	FileConfigurationTest.class}) 
	public class FileSystemConfigurationTestSuite { 
} 

Con @RunWith configuramos el Runner para correr los Test Suite. Runner es el motor que corre los test, JUnit proporciona uno por defecto que por medio de anotaciones se puede cambiar. Y con la anotación @SuiteClasses indicamos que clases correr.

JUnit

Existen diferentes frameworks para ayudarnos a realizar pruebas unitarias, como por ejemplo PHPUnit para PHP, NUnit para .net y JUnit para Java. En java JUnit es el framework más utilizado para hacer pruebas unitarias, pero no el único; existen otros como TestNG, JTiger.

TestNG y JTiger estan basados en anotaciones y nacieron principalmente para suplir algunas deficiencias que tenia JUnit 3.

JUnit es una herramienta simple, Open Source que se ha convertido en el estándar para probar clases java de forma unitaria. Fue creada por Erich Gamma y Kent Beck.

Es fácil de usar y configurar por lo que prácticamente no existe curva de aprendizaje, salvo el cambio de mentalidad que debe producir en las mentes de los programadores al usar técnicas que faciliten el uso de pruebas unitarias.

El propio framework incluye formas de ver los resultados (runners) que pueden ser en modo texto, gráfico (AWT o Swing) o como tarea en Ant.

En la actualidad las herramientas de desarrollo como Netbeans y Eclipse cuentan con plug-ins que permiten que la generación de las plantillas necesarias para la creación de las pruebas de una clase Java se realice de manera automática, facilitando al programador enfocarse en la prueba y el resultado esperado, y dejando a la herramienta la creación de las clases que permiten coordinar las pruebas.

Desde la versón 4 de JUnit hubo grandes cambios, con respecto a otras versiones dado que la versión 4 de JUnit esta orientada a anotaciones dando mayor potencial al framework y flexibilidad.

Arquitectura Orientada a Servicios

La Arquitectura de Empresa y Arquitectura orientada a servicios le ayudan a mantener el control sobre la complejidad en un mundo siempre cambiante.

Frente a los rápidos cambios - a partir de la creciente globalización, la consolidación de la industria y los mercados emergentes – las organizaciones necesitan ser ágiles en los negocios, así como en TI. Los cambios estratégicos en las actividades empresariales deben ser apoyados por sistemas flexibles y ágiles de TI. La información tiene que ser abierta en forma estandarizada y las transformaciones de negocio y de TI tienen que ser apoyadas por planes de trabajo alineados.

Según Gartner, en 2011 un ochenta por ciento de las organizaciones de todo el mundo se habrán cambiado a SOA, este porcentaje fue mucho menor sin embargo en inegable que las organizaciones se interesan por migrar a una arquitectura abierta orientada a Servicios. La razón: los modelos SOA hacen que sea mucho más fácil adaptar los procesos de negocio a los cambios del mercado que mediante las arquitecturas tradicionales de software. Como ha ocurrido muy a menudo en el pasado, las grandes compañías fueron las pioneras en este desarrollo. Gracias a soluciones inteligentes y modulares, este cambio de paradigma se ha hecho ahora atractivo y factible también para las compañías de tamaño mediano, por tanto se puede afirmar que el futuro pertenece a las arquitecturas orientadas a servicios (SOA).

En una empresa pueden coexistir varias aplicaciones. Esto lleva a una serie de inconvenientes que aumentan el esfuerzo y el tiempo en que se responde a un requerimiento determinado. Uno de los inconvenientes es, por ejemplo, ante aplicaciones diferentes probablemente desarrolladas en lenguajes diferentes, no poder acceder desde una de las aplicaciones hacia la otra para consultar algún dato.

Mediante la aplicación de la Arquitectura SOA se pretende solucionar los inconvenientes antes mencionados. Dentro de la arquitectura SOA la funcionalidad se implementa en pequeños componentes autónomos reutilizables denominados servicios.

SOA obtiene una integración de aplicaciones o componentes, uniendo la tecnología de información con las necesidades del negocio, logrando una respuesta rápida con un bajo acoplamiento, un ambiente operativo integrado que provee servicios para integrar personas, procesos e información.
El hecho de optar por este tipo de arquitectura requiere de una infraestructura de comunicación, en este caso la arquitectura orientada a servicios utiliza ESB (Enterprise Service Bus). Según Craggs es una plataforma basada en estándares que incluye funciones básicas como servicio de mensajería, servicios Web, enrutamiento inteligente y transformación de datos para conectar y coordinar la interacción de un número significativo de aplicaciones de empresas extendidas con integridad transaccional.

SOA es una arquitectura de Software orientada a servicios. Esta arquitectura surge de la continua y creciente evolución de la Tecnología de Información (IT), en conjunto con la evolución de los procesos de negocios.

SOA integra procesos, recursos humanos e información en un ambiente operativo más ágil y flexible. Para poder lograr esta integración hace uso del concepto de servicio, Orquestación y Coreografía de Servicios Web.

La funcionalidad se encapsula en servicios independientes entre sí. Alta interoperabilidad entre los servicios. La aplicación final orquesta la ejecución de los servicios y añade la interfaz.
García, Gabriel Alejandro, SOA Architect, se refiere a la arquitectura diciendo que hace un tiempo era IBM quién buscaba a los posibles clientes para ofrecerles esta tecnología, mientras que hoy en día son los clientes los que se acercan a consultar, más que nada por las siglas, sin conocer muy bien como funciona y que implica. Gabriel, continúa diciendo que, si bien IBM es quien más tiempo tiene en el mercado, otras empresas como Oracle y Weblogic están ganando terreno. En cuanto a los proyectos en Argentina que utilizan esta tecnología, sostiene que las empresas de Telefonía son las que están avanzando en estos proyectos.

Por su parte otro especialista del área de soporte de productos, opina que a nivel País el tema de SOA está en sus comienzos, recién se están comenzando a encarar proyectos serios. Sin embargo, brinda soporte a toda América del Sur, y Países de habla hispana, y considera que a nivel región ya existen proyectos funcionando utilizando SOA y muchos proyectos más en proceso de desarrollo que serán puestos en marcha muy pronto.

Linux El emblema del software libre celebra sus 20 años de vida

Hoy leí el siguiente articulo en clarin:

http://www.ieco.clarin.com/tecnologia/Linux-emblema-software-libre-celebra_0_544745576.html

Me quedo con este párrafo:

En la actualidad, de aquella versión de garaje que nació en un ambiente de PC queda muy poco. Se apuntaló la estabilidad, la seguridad y el hecho de estar respaldado por algunos colosos de la tecnología, han convertido a Linux en una opción muy seria en las empresas . No es por casualidad que está instalado en el 92 % de las supercomputadoras, según el sitio especializado top500.org.

Feliz Cumpleaños al mejor Sistema Operativo por lejos!!!

Feliz Cumpleaños Linux!!!

IBM Linux Prodigio subtitulado por guivaloz

Profiles de Maven

Es posible redefinir prácticamente cualquier parte de un POM definiendo un perfil o profile para definir un profile es necesario modificar el pom agregando la siguiente entrada:

	 
	   
	    notest 
	     
	     
	       
		org.apache.maven.plugins 
		maven-surefire-plugin 
		2.9 
		 
		  true 
		 
	       
	     
	   
	   
	

En el siguiente profile le estamos diciendo a maven que no corra los test con la expresión true
Para correr este profile es necesario ejecutar el comando con el parametro -P notest, por ejemplo:

mvn clean install -P notest

Creación de Herencia entre projectos con Maven

Para realizar herencia entre pom es necesario generar un proyecto pom (padre) y luego generar cada proyecto (hijo)

Creamos el proyecto padre:

mvn archetype:create -DgroupId=com.ejemplo -DartifactId=EjemploPomPadre

Luego borramos la carpeta src y editamos el pom para que sea similar al siguiente:

 
  4.0.0 

  com.ejemplo 
  EjemploPomPadre 
  1.0-SNAPSHOT 
  pom 

 ...

Cambiamos el packaging a pom y agregamos las dependencias comunes para todos los proyectos hijos.

Ahora creamos 2 proyectos en el directorio EjemploPomPadre.

mvn archetype:create -DgroupId=com.ejemplo -DartifactId=EjemploHijo1
mvn archetype:create -DgroupId=com.ejemplo -DartifactId=EjemploHijo2

Si editamos el pom del proyecto EjemploPomPadre vemos que maven agrego la siguiente entrada:

 
    EjemploHijo1 
    EjemploHijo2 

Si editamos el pom de uno de los proyectos hijos veremos que se agrego la siguiente entrada indicando el proyecto padre:

 
    EjemploPomPadre 
    com.ejemplo 
    1.0-SNAPSHOT 
   

Si agregamos una dependencia en el pom padre se agregan a los proyectos hijos, para verificar las dependencias reales de un proyecto tenemos el comando:

mvn help:effective-pom

Detención de conflictos entre dependencias con Maven

Para detectar conflictos entre dependecias podemos usar los siguientes comandos:

Ver jerarquía de dependencias
$ mvn dependency:tree
Este comando muestra el arbol de dependencias.

Ver dependencias en orden alfabético
$ mvn dependency:resolve

Analizar uso de dependencias
$ mvn dependency:analyze

Crear un proyecto web con Maven

Siguiendo con post dedicados a maven vamos a ver como crear un proyecto web con maven y como  configurar jetty para poder ver nuestras paginas desde maven.
Para crear un proyecto web se debe posicionar en el directorio donde se quiere crear el proyecto y se debe ejecutar la siguiente comando:

mvn archetype:create -DgroupId=com.ejemplo -DartifactId=EjemploWeb -DarchetypeArtifactId=maven-archetype-webapp

Con este comando se creara un proyecto web, para poder verlo desde eclipse se debe agregar la siguiente entrada en el pom.

 
		 
			 
				maven-compiler-plugin 
				 
					1.6 
					1.6 
				 
			 
			 
				org.apache.maven.plugins 
				maven-eclipse-plugin 
				2.7 				 
				 
					2.0 
					true 
				 
			 
			 
				org.apache.maven.plugins		 
        	   		maven-javadoc-plugin 		 
       			 
			 
				org.apache.maven.plugins		 
        	    		maven-project-info-reports-plugin 		 
			 
		 
  

El wtpversion es la versión de Web Tools Project de eclipse, el cual es necesario setear para que eclipse, utilice esta herramienta.
Luego entrar a la carpeta del proyecto y ejecutar:

mvn install
mvn eclipse:eclipse

Luego de ejecutar estos comandos es posible importar este proyecto a eclipse.
Ahora vamos a configurar un plugin para ejecutar nuestro proyecto web con maven. Se agregara la configuración de un servidor web llamado jetty.
Para esto se debe agregar en el pom el siguiente plugin:

		 
		    org.mortbay.jetty 
		    maven-jetty-plugin 
		

Y ejecutar mvn jetty:run para luego abrir un browser y ir a http://localhost:8080/EjemploWeb/, en el cual podremos ver nuestro proyecto funcionando.

Libros en castello sobre agilismo

Dejo un interesante post sobre libros sobre agilismo en castellano: 

http://najaraba.blogspot.com/2011/08/libros-en-castello-original-sobre.html

Saludos!!

Iniciando con Maven Parte 3

Siguiendo con el post anterior, vamos a seguir posteando sobre maven:


Dependencias

Una dependencia es una referencia en el POM de la librería que se desea incluir en el proyecto. Por ejemplo si deseamos incluir la librería para el manejo de JUnit debemos declararlo de la siguiente manera:

  
     junit
     junit
     4.5
  

Como vimos, los objetos en el repositorio se identifican mediante 3 tags groupId:artifactId:version

Transitividad de dependencias

Con esto, nos referimos al hecho de que cada dependencia, incluye a su vez las dependencias que necesita. Por ejemplo, si agregamos la dependencia A, que a la vez depende de B, entonces B se incluirá sin la necesidad de explicitarlo.

Es muy importante tener siempre presente la transitividad, a la hora de detectar problemas de BUILD ERROR. Supongamos que agregamos la dependencia A, que a la vez depende de B, versión 1.0. Es muy probable que no seamos conscientes de esa transitividad, con lo cual, en algún momento podemos agregar en el pom, explícitamente, la dependencia B versión 2.0. Lo que ocurrirá, es que si en el código utilizamos features de la versión 2.0 que no están en la 1.0, entonces tendremos un BUILD ERROR. Esto es así, ya que maven le da prioridad a la transitividad.

Para estos casos, lo que tendremos que hacer cuando agregamos la dependencia A, es excluir la B, versión 1.0.

 	org.A
 	A
 	1.0
 	
 		
 			org.B
  	 		B
 		
 	


 	org.B
 	B
 	2.0
 

Scope de dependencia

Las dependencias tienen varios niveles o scopes, algunas hacen falta para compilar, otras solo para los test, algunas las va a incluir el contenedor.

Los scopes de las dependencias pueden ser utilizados para limitar o condicionar las dependencias transitivas. Existen seis tipos de scopes:

Compile: es el scope por defecto. Las dependencias están disponibles en el proyecto y en sus proyectos dependientes.
Provided: se espera que el JDK, la aplicación o el contenedor provean la dependencia.

Runtime: la dependencia no es requerida en tiempo de compilación pero sí para la ejecución.
Test: son dependencias que son requeridas solo cuando se compila y ejecuta los test.

System: similar a provided pero se le debe indicar el jar que contiene la dependencia.

Import: (a partir a la version 2.0.9) solo es usado en una dependencia del tipo POM en la sección . Indica que el POM utilizado debe ser remplazado con las dependencias que éste tenga en su sección.