Mapeo de relaciones en hibernate

Mapeo de relación uno a uno.

Para estas relaciones se puede utilizar una foreing key o algo menos común que las dos tablas tengan similar Id.

Con una relación many-to-one podremos mapear la relación uno a uno utilizando foreing key:

Cuando queremos tener similar primary key debemos utilizar una relación one-to-one:

Para que tome el mismo key no hay que especificar la propiedad “koreing-key”

Mapeo muchos a uno

En este caso puede haber dos situaciones que sea una relación unidireccional o una relación bidireccional.

En el caso de la relación unidireccional se mapea de la siguiente manera:

En el caso de la relación bidireccional se mapea de la siguiente manera:

Mapeos uno a muchos

En este caso también tenemos 2 situaciones unidireccional y bidireccional.

La unidireccional se mapea de la siguiente manera:

La relación bidireccional es similar a la que vimos en many-to-one bidireccional:

Mapeo muchos a muchos

EL mapeo muchos a muchos siempre es bidireccional y se mapea como dos colecciones indicandole el nombre de la tabla relación, la cual va a tener los ids de las diferentes entidades; el mapeo sera como el siguiente:

Mapeos de Herencia con Hibernate

Hibernate provee 3 estrategias para resolver el mapeo de herencias.

• La primera es utilizar una sola tabla lo que es recomendable cuando los objetos “hijos” o subclases no agregan gran cantidad de propiedades.
• La segunda es utilizar una tabla para la clase “Padre” y los atributos de las subclases en otras tablas.
• La tercera es utilizar una tabla por clase.

Si utilizamos una sola tabla deberíamos utilizar una columna que indique de que tipo es el registro que se esta guardando. Este registro se llama discriminator . Por ejemplo en el mapeo de nuestra clase padre deberíamos agregar la siguiente entrada para indicar el dicriminador:

Y además debemos indicar la subclase:

 
	 
	..... 
 

Con anotaciones podemos hacerlo como muestra el ejemplo:

@Entity 
@Inheritance(strategy=InheritanceType.SINGLE_TABLE) 
@DiscriminatorColumn( 
	name="planetype", 
	discriminatorType=DiscriminatorType.STRING 
) 
@DiscriminatorValue("Plane") 
public class Plane { ... } 

@Entity 
@DiscriminatorValue("A320") 
public class A320 extends Plane { ... } 

Si utilizamos una tabla con los datos genéricos y otras por subclase se debe mapear de la siguiente manera:

 
	
	 
	 
	..... 
 

El atributo key indica cual es el nombre de la columna que contiene el id de la clase padre. Veamos un ejemplo:

 
 
	 
		 
			 
				 
			 
			...
			 
				 
				 
			 
		 
 

Si utilizamos una tabla por clase se debe declarar de la siguiente manera:

 
 
..... 
 

En este caso no es necesario un discriminador ya que cada tabla tiene su clase.

MySQL cambia su estrategia de negocio a “open core”

Es una noticia que se venia venir; oracle anuncio que va a cambiar el modo en que hace dinero con mysql . Ahora va a tener un “core” libre y productos comerciales ni libres, ni gratuitos. Imagino que muchas empresas que optaron por el software libre van a pasarse a otros proyectos.
Me imagino que esto impulsara el proyecto MariaDB en el que esta trabajando Monty el creador de MySQL. Creo que también le dará un empujón a PostgreSQL que viene creciendo de una forma constante.
No estoy en desacuerdo que una empresa haga dinero, es su objetivo pero creo que por nada del mundo puede cambiar el modelo de negocio de uno de sus productos. No solo porque pierde credibilidad sino que porque tambien esta traicionando a sus clientes.
Que opinan de esta noticia?

Dejo el link de blog de oracle:
http://blogs.oracle.com/MySQL/entry/new_commercial_extensions_for_mysql

Una profesión clave para el desarrollo

Sigo leyendo clarin, me mantengo informado ahora una columna de opinion del Decano de la FRBA, Ing. Guillermo Oliveto en Ieco de Clarin: 

http://www.ieco.clarin.com/economia/profesion-clave-desarrollo_0_560944131.html

 Bueno ahora viene mi opinión, creo que nuestra profesión es fantástica, si te gusta estudiar todo el tiempo, evolucionar, actualizar constantemente.

 El conjunto de incumbencias de nuestra profesión nos posibilitan a dirigir proyectos como a programar y aquí el problema porque el programar nos deja en competencia con el programador de la esquina que sin desmerecer a los programadores de raza (o que aprendieron "de la vida") cobra mucha veces más barato o se olvida de la calidad en pos de un buen precio.

Creo que el mercado es amplio hoy en día todos tenemos oportunidad es necesario saber "venderse" para dejar sentado nuestra calidad. Calidad que se ve reflejada por el precio, los tiempos y el código. Estoy convencido que este es el camino para crecer como profesión.

Mapeos en Hibernate

Hibernate nos permite definir las relaciones de nuestros objetos con las tablas de la base de datos por medio de un archivo xml y por medio de anotaciones en la clase.

Veamos con mayor detalle las partes de este mapeo.

Primero se define la clase y la tabla:

< class name="event" table="events">
...
 

Cuando usamos anotaciones llamamos a @Entity que indica que la clase es una entidad manejada por hibernate y se va a persistir. Además con @Table indicamos el nombre de la tabla.

Luego se puede definir el id, de la siguiente forma:

 
            node="element-name|@attribute-name|element/@attribute|." 

 

 

Donde:

• name: Indica el nombre de la propiedad. type: indica el tipo. 
• column: la columna en la base de datos. 
• unsaved-value: Valor que toma cuando el objeto no esta guardado. 
• access: como va aceder hibernate a esta propiedad.

Esto es similar a utilizar la anotación @Id en Jpa.

El generator es el motor que indica como hibernate se va a manegar para obtener los números de las claves nuevas.

Hibernate ofrece varias estrategias:

• IDENTITY: soporta id autoincrementales en DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL . 
• SEQUENCE : Usa secuencias de la base. 
• TABLE: Toma el nombre de la tabla y la columna como fuente y genera una un identificador a partir de estas. 
• AUTO: Toma el más conveniente según el motor de base de datos.

Cuando son claves compuestas las cuales se encuentran en una clase embebida se puede definir de la siguiente manera:

 
 
 
...... 
 

Cuando tenemos claves compuestas que no se encuentren en una clase envevida podremos definirla de la siguiente manera:

Version

Cuando queremos que hibernate detecte los conflictos podemos agregar un campo versión, que indica la versión del registro. De esta forma hibernate incrementara este registro cada vez que guarde.

También se puede utilizar un timestamp para mantener la versión de los registros.

Con anotaciones podemos usar el @Version.

Property

Con Property declaramos una propiedad de nuestro objeto:

Componentes o objetos embebidos

Se pueden definir estructuras de objetos contenidos en el archivo contenedor, de esta forma nos ahorramos hacer un archivo de mapeo. Cuando la clase contenida es utilizada en 2 o más clases no es conveniente utilizar componentes.

 
	 
	 
	........ 
 

La rotación amenaza a la industria del software

Estuve leyendo este articulo de clarin y lo quisiera compartir:

http://www.ieco.clarin.com/economia/rotacion-amenaza-industria-software_0_560944133.html

Es una visión de las empresas de software, habría que hacer un articulo pero desde la visión de los programadores.

En mi opinión creo que unas de las razones del recambio es que las empresas de software no comparten sus ganancias. Todo es dinero y me parece genial que empresas ganen bien; pero esas ganancias se deben reflejar también en el sueldo de sus empleados.

Y ustedes que opinan?

Scala School!

La gente de twitter nos invita a capacitarnos en scala por medio de esta pagina:

http://twitter.github.com/scala_school/

Recordemos que hace tiempo el front end de twitter fue migrado de ruby a scala. Por lo visto le dio buenos resultados.

Que lo disfruten!

Crear proyecto Maven + Hibernate

Vamos a crear un proyecto Hibernate con Maven.

 Crear proyecto con maven 2 :

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

Generar los archivos necesarios para importar el proyecto a eclipse:

mvn eclipse:eclipse

Importar el proyecto desde eclipse : File –> Import –> General

Crear una carpeta resurces en src/main de tal forma que el path quede así: src/main/resources

Abrir el pom y agregar las dependencias de hibernate y mysql y además plugins para que compile con java 1.6, plugin de java doc y plugin de reportes.

El pom debería quedar así:

	4.0.0

	com.ejemplo
	hibernate
	1.0-SNAPSHOT
	jar

	hibernate
	http://maven.apache.org

	
		UTF-8
	

	
		
			
				maven-compiler-plugin
				
					1.6
					1.6
				
			
			
				org.apache.maven.plugins
				maven-javadoc-plugin
			
			
				org.apache.maven.plugins
				maven-project-info-reports-plugin
			
		
	

	

		
			junit
			junit
			4.8.2
			test
		

		
		
			mysql
			mysql-connector-java
			5.1.9
		

		
		
			org.hibernate
			hibernate-core
			3.6.3.Final
		
 
		
			javassist
			javassist
			3.12.1.GA
		

	

Hacer mvn clean install y mvn eclipse:eclipse. Refrescar el proyecto en eclipse para que tome los cambios.

Generar clase y su mapeo:

Creeamos una clase persona:

package com.ejemplo;

/**
 * @author emanuel
 *
 */
public class Persona {
	
	private Long id;
	
	private String nombre;
	
	private String apellido;

	public Persona(String nombre, String apellido) {
		super();
		this.nombre = nombre;
		this.apellido = apellido;
	}

	public Long getId() {
		return id;
	}

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

	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public String getApellido() {
		return apellido;
	}

	public void setApellido(String apellido) {
		this.apellido = apellido;
	}
	
	//Constructor usado por hibernate
	protected Persona() {	}

}

Ahora creamos el archivo de mapeo, el cual es un archivo .xml el cual es deseable (no obligatorio) que se llame igual que la clase que mapea y se encuentre en la carpeta resources con la estructura de paquete que tiene la clase, por lo tanto el path sería:

main/resources/com/ejemplo/persona.hbm.xml y el archivo sería como el siguiente:

Configurar hibernate:

Para configurar hibernate es necesario generar un archivo hibernate.cfg.xml y guardarlo en la carpeta resources. Este archivo contendra la siguiente información:

 
  com.mysql.jdbc.Driver
  jdbc:mysql://localhost:3306/prueba
  root
  
  update
  org.hibernate.dialect.MySQLDialect
  true
  

Crear HibernateUtil:

Ahora vamos a crear una clase util, la cual sera encargada de generar las sessiones de Hibernate:

package com.ejemplo.util;
 
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
public class HibernateUtil {
 
	private static final SessionFactory sessionFactory = buildSessionFactory();
 
	private static SessionFactory buildSessionFactory() {
		try {
			// Create the SessionFactory from hibernate.cfg.xml
			return new Configuration().configure().buildSessionFactory();
		} catch (Throwable ex) {
			// Make sure you log the exception, as it might be swallowed
			System.err.println("Initial SessionFactory creation failed." + ex);
			throw new ExceptionInInitializerError(ex);
		}
	}
 
	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}
 
	public static void shutdown() {
		// Close caches and connection pools
		getSessionFactory().close();
	}
}

Crear un test:

Vamos a generar un test para probar como todo funciona:

package com.ejemplo;

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

import org.hibernate.classic.Session;
import org.junit.Test;

import com.ejemplo.util.HibernateUtil;

public class HibernateTest {

	@Test
	public void test() {
		Persona persona = new Persona("Juan","Rodriguez");
		Session session = HibernateUtil.getSessionFactory().openSession();
		session.beginTransaction();
		session.save(persona);
		session.flush();
		
		List personas = session.createQuery("from Persona").list();
		assertFalse(personas.isEmpty());
		
		Persona personaGuarda = (Persona) session.get(Persona.class, persona.getId());
		assertEquals(persona, personaGuarda);
	}

}

Crear esquema en la base de datos:


Es necesario escribir un esquema llamado prueba en la base de datos Mysql.

Ahora a correr el Test y todo debería a andar!

Google Dart

Google planea matar a javascript con un dardo. Google Dart es el nuevo lenguale de google que pretende suplantar a javascript. Dart se ha descrito como “un nuevo lenguaje de programación orientado hacia la programación web estructurada”. También hay rumores que va a ser un lenguaje orientado a objetos similar a SmallTalk. Me imagino que google quiere revertir la historia que tuvo con Go su lenguaje de programación, el cual no fue muy exitoso por su parecido con C y también tenia una mezcla con python.

Este lenguaje va a ser presentado en el GoTo que se celebra en Dinamarca en el mes de octubre. Los responsables del lenguaje son Lars Bak y Gilad Bracha, dos ingenieros de software de Google con experiencia en diseño de lenguajes.

Bracha es el creador del lenguaje de programación Newspeak y antes de estar en Google fue vicepresidente en SAP Labs, además de reputado ingeniero en Sun Microsystems; entre otras cosas es co-autor de Java Language Specification e investigador en el área de lenguajes de programación orientado a objetos. En cuanto a Lars Bak, es conocido como un veterano de las máquinas virtuales. Diseñó e implementó máquinas virtuales orientadas a objetivos  y trabajó en proyectos como Beta, Self, Strongtalk, Sun HotSpot, OOVM Smalltalk y el motor V8 de Google para el navegador Chrome.

Dejo la fuente:
http://www.itespresso.es/dart-el-nuevo-lenguaje-de-programacion-web-de-google-52856.html

Y dejo links:
http://www.extremetech.com/computing/95417-google-announces-dart-programming-language
http://siliconangle.com/blog/2011/09/15/google-dart-details-leaked-new-programming-language-seeks-to-replace-javascript/

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.

Iniciando con Maven Parte 2

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




Pom
En el directorio de nuestro proyecto encontraremos un archivo con el nombre pom.xml el cual contienen toda la información de nuestro proyecto:

4.0.0

com.ejemplos
EjemploMaven
1.0-SNAPSHOT
jar

EjemploMaven
http://maven.apache.org


UTF-8




junit
junit
3.8.1
test

En el pom se registra el groupId, artifactId, versión, etc. Entre las diferentes propiedades se encuentra las dependencias; las dependencias son los artefactos que el proyecto necesita para poder ejecutarse.

Cada dependencia contiene un groupId, artifactId y versión; especificando esta información se le indica a maven la dependencia; la cual el bajara de internet y la guardara en nuestro repositorio. Para obtener datos de dependencias se puede utilizar paginas como http://www.mvnrepository.com/

Integración con los IDE

Si deseamos usar una IDE, como eclipse, IntelliJ IDEA, netbeans o otra. Maven es capaz de generar un proyecto de eclipse, de idea y creo que de netbeans. Basta ejecutar esto

mvn eclipse:eclipse
mvn idea:idea

Luego, desde nuestro IDE, creamos un proyecto importando o leyendo el fichero de proyecto que ha generado maven.

Para eclipse, hay que hacer algo más. Debemos definir dentro de eclipse la variable M2_REPO apuntando a nuestro repositorio local de maven.

También hay plugins en nuestros IDEs que hacen más fácil el trabajo con maven, de forma que desde nuestro IDE podamos ejecutar las tareas maven. En codehaus tienes los plugins para los cuatro IDEs más conocidos: eclipse, netbeans, IntelliJ y JBuilder.

Seguiremos posteando sobre esta gran herramienta!

Iniciando con Maven

Maven es una herramienta para la construcción de proyectos en java, ya explicamos que es en este post http://emanuelpeg.blogspot.com/2011/02/maven.html ahora veamos como utilizarlo.


Instalar Maven:

1. Bajar Maven de: http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-2.2.1-bin.zip, por ejemplo
2. Copiarlo en un directorio en disco por ejemplo: c:\maven
3. Agregar la carpeta bin de maven a la variable PATH. Para meter el subdirectorio bin en el path de ejecutables, le doy con el botón derecho del ratón sobre el icono de "Mi PC" y elijo "Propiedades", "Avanzado" y "Variables de Entorno". Busco "Path" y le doy a "Editar". Añado al final ";C:\maven\bin" (con punto y coma delante, para separlo de lo que ya haya escrito)
4. Abrir una consola en windows ir a ejecutar y escribir “cmd”, en linux abrir cualquier consola y escribir:

> mvn --version

Y obtendrá la siguiente salida:

Apache Maven 2.2.1 (r801777; 2009-08-06 16:16:01-0300)
Java version: 1.6.0_25
Java home: /java/sdk/jdk1.6.0_25/jre
Default locale: es_AR, platform encoding: UTF-8
OS name: "linux" version: "2.6.35-22-generic" arch: "amd64" Family: "unix"

Configurar maven para que funcione utilizando una red con un proxy:

Es común el uso de proxies en empresas para brindar mayor velocidad en el uso de internet, en otros casos también es usado para restringir el uso de internet para algunos empleados. Es posible configurar maven para que funcione atra vez de un proxy.

Si la conexión a internet es a través de un proxy, necesitamos configurar maven para que sepa cómo acceder a través de él. El proxy puede además requerir un usuario y password para el acceso.
Vamos al directorio conf donde tenemos instalado maven, en mi caso c:\maven-2.0.4\conf y editamos el fichero settings.xml. Es un fichero xml y en el sitio que pone proxies, justo debajo, ponemos esto

optional
true
http
mi_nombre_usuario
mi_passowrd
ip_de_mi_proxy
80
ordenadores_de_mi_red_local_separados_por_comas

...

El id optional es un nombre que queramos darle para identificar el proxy. En vez de optional podemos poner cualquier nombre. especifica una lista separada por pipes (|) con los servidores o direcciones IP excentas de proxy.
Por ejemplo:

ConfigProxy
true
http
proxyuser
proxypass
10.10.10.1
8080
10.10.10.2|10.10.20.1

Creación de proyecto con Maven

Para crear un proyecto con maven hay que abrir la consola, y pocicionarse en la carpeta donde es necesario crear el proyecto y luego escribir en consola los siguiente:

mvn archetype:create -DgroupId=com.ejemplos -DartifactId=EjemploMaven

Veamos los parámetros

• archetype:create es el comando/plugin, o como quieras llamarlo, de maven para crear un proyecto. Por defecto crea un proyecto de java plano.
• -DgroupId es el conjunto de proyectos al que pertenece nuestro proyecto. Por ejemplo, yo puedo meter todos mis programas de ejemplo en un grupo que llamaré "com.ejemplos". Este nombre que pongamos aquí va a servir de paquete inicial para todas las clases del proyecto. Todos los proyectos maven deben pertenecer a un grupo, aunque sea único para él, que se denominará groupId.
• -DartifactId es el nombre que queramos dar al proyecto. Maven creará un directorio con este nombre y el jar que genere para el proyecto tendrá también este nombre. Todos los proyectos maven tienen un nombre para identificarlos, que se denomirá artifactId

Al ejecutar este comando maven crea el proyecto y baja de internet los jar necesarios. Si todo salio bien vera el siguiente cartel:

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 30 seconds
[INFO] Finished at: Sat Aug 20 19:26:27 ART 2011
[INFO] Final Memory: 11M/490M
[INFO] ------------------------------------------------------------------------

La estructura del proyecto creado es la siguiente:

EjemploMaven
+---src
¦ +---main
¦ ¦ +---java //Para nuestros fuentes
¦ ¦ +---com
¦ ¦ +---ejemplos
¦ ¦ +---App.java
¦ +---test
¦ +---java //Para test de Junit
¦ +---com
¦ +---ejemplos
¦ +---AppTest.java
+---pom.xml

Dentro un fichero pom.xml que es un fichero que contiene datos de configuración de nuestro proyecto, como dependencias con otros jar, tipos de informes que queremos en la página web de nuestro proyecto, etc.. Inicialmente contiene una serie de cosas por defecto que podremos cambiar si lo deseamos.

Crea dos subdirectorios, uno src y otro test. Dentro de src debemos meter todo lo que sean fuentes y ficheros de configuración o datos propios del proyecto. En la parte de test debemos meter todos nuestros fuentes de prueba, clases de test de JUnit, ficheros de datos o de configuración de pruebas, etc. Es decir, en src va lo que es del proyecto y en test lo que nos ayude a probar el proyecto, pero no sea propio del proyecto.

En ambos casos, crea un directorio java. Ahí debajo es donde van los fuentes java. En paralelo a estos directorios java y si lo necesitamos, debemos crear nosotros a mano otros directorios. El nombre de estos nuevos directorios es standard en maven.

Para compilar la aplicación, por consola entramos al directorio EjemploMaven
y escribimos:

mvn compile

Si queremos correr los test 

mvn test 

Si queremos generar el empaquetado (jar, war, ear)

mvn package 

Si queremos correr los test + compilar + generar el empaquetado

mvn install

Al correr estos comandos generara una carpeta target, la cual contendra los archivos compilados y el jar generado. Si se quiere borrar esta carpeta y limpiar el proyecto se debe ejecutar:

mvn clean

Se pueden convinar los comandos por ejemplo borrar target y limpiar el proyecto para luego generar un paquete:

mvn clean install

Repositorios Maven

Una de las grandes ventajas de maven son los repositorios (almacenes) de ficheros jar que se crea.
Si miras en http://www.ibiblio.org/maven2/ tienes el repositorio oficial de jars de maven. Ahí están los groupId de casi todos los jar de libre distribución que puedas encontrar en internet. Tienes el log4j, commons-logging, JFreeChart, mysql-connector, etc, etc. Maven es capaz de bajarse cualquiera de estos jar si tu proyecto lo necesita.

Todo lo que se baje maven de internet lo mete en un repositorio (almacen) local en tu pc, de forma que si lo necesita una segunda vez, no necesita descargárselo nuevamente de internet. Este directorio, habitualmente está en

$HOME/.m2 en unix/linux
C:\Documents and Settings\usuario\.m2 en windows

Adicionalmente podemos configurar maven para que use más repositorios, tanto de internet como otros que montemos internamente en nuestra red local si la tenemos. Por ejemplo, en internet tienes otro repositorio con jars independiente de maven en http://java.freehep.org/maven2/

El repositorio interno en la red local es particularmente útil si trabajamos en una empresa y hacemos proyectos que son dependientes unos de otros o tenemos nuestras propias librerías de jars. Poniendo jars en ese repositorio de empresa, todos los programadores podrán acceder o subir jars a ese repositorio y compartirlos.

Al hacer mvn install maven agrega nuestor jar al repositorio local de nuestra PC. Es decir que lo agrega a .m2

En próximos post seguiremos esta inicialización con Maven.

JavaCC

Una de las capacidades de la tecnología Java es que no solo puede correr e lenguaje Java sino innumerables lenguajes más. Pensemos si pudiéramos hacer un lenguaje a nuestro gusto, para eso existe JavaCC

JavaCC (Java Compile) es un generador de lenguajes que funcionen sobre la plataforma java y además es open source. Es similar a Yacc pero para java.

JavaCC es una herramienta para transformar y generar un parser con código Java (similar a las expresiones regulares) para chequear la sintaxis del código fuente desde reglas definida como gramática. La gramática de JavaCC es similar a la de java por suerte.

Dejo algunos tutoriales:

http://www.codeproject.com/KB/cross-platform/CreateProgrammingLanguage.aspx
http://www.uhu.es/470004004/practicas/practica04.htm

Rails for Zombies: Resurrection Announcement

Muy interesantes son los cursos dictados por codeschool entre los más cursados se encuentra el de Ruby for zombies. La verdad lo recomiendo porque es muy fácil de seguir y además es gratuito.

Ahora van a dictar la segunda parte titulada: Resurrection Announcement. No solo que son muy divertidos sino que muy interesantes.

Dejo links:

http://www.codeschool.com/courses/rails-for-zombies

http://www.codeschool.com/courses/rails-for-zombies-2

Java SE 7 Released

Me llego un mail hace instantes que nos dice lo siguiente:

After nearly five years of collaboration within the worldwide Java community, Java Platform, Standard Edition 7 is ready for download! The major features of Java SE 7 are Project Coin, the Fork/Join framework, the New File System API, and InvokeDynamic. It's an important step in Java’s evolution. Learn more:

Download Java SE 7
Read the Press Release: Oracle Announces Availability of Java SE 7
Watch the technical presentations from Oracle's global event on July 7
View Moving Java Forward: A Video Discussion about Java 7
Find a JUG meeting covering Java 7 near you
Access Java 7 Training
Get Involved in Open JDK

-The Oracle Technology Network Team (The Java Source Blog)

Clojure

Clojure es Lisp sobre JVM. Clojure es un dialecto de Lisp por lo tanto si entendemos Lisp entendemos Clojure. Lisp es un lenguaje funcional no puro. Lisp tiene algunas características interesantes:

Lisp es un lenguaje de listas. Una llamada a una función utiliza el elemento de la primera lista como la función y el resto como los argumentos.
Lisp utiliza sus propias estructuras de datos para expresar código

Si mezclamos estas dos ideas obtendremos un lenguaje ideal para metaprogramacion. Podemos organizar nuestro código en un árbol teniendo una base de modelo de objetos, también podemos crear un código basado en prototipos. Dándonos gran flexibilidad.

Los primeros dialectos de Lisp son Common Lisp y Scheme. Scheme y Clojure son de la familia de dialectos llamado lisp-1 y Common Lisp es de la familia llamada lisp-2.

Una de las cosas más importantes de Clojure es que funciona sobre la JVM lo que permite usar todas las librerías y frameworks ya escritos en java.

Clojure es funcional y es dinámicamente tipado, lo que hace que el código sea más fácil de leer y más divertido de escribir.

Esto es solo una introducción en proximos post seguiremos escribiendo de este lenguaje.

Dejo Link:
http://clojure.org/

Cuanto gana un programador en Valley?

UnQL

CouchDB y SQLite han creado un nuevo lenguaje de consulta de datos, aunque es similar a SQL, esta diseñado para trabajar con bases documentales, NoSQL.

El lenguaje incluye select, update, delete y inserts pero no como SQL ya que no trabaja con tablas sino con colecciones desordenadas de documentos. En UnQL un documento es un objeto que puede ser descripto con JSON, un float, un string, puede ser visto como un documento.

Al leer que todos los documentos se pueden representar con JSON, se nos viene a la mente BSON el lenguaje de MongoDB otra base de datos documental, NoSQL. Tomando caminos diferentes confluimos en casi iguales estructuras y lenguajes. Sera hora de estandarizar un lenguaje NoSQL?

Ceylon

La República Democrática Socialista de Sri Lanka (cingalés:ශ්‍රී ලංකා ප්‍රජාතාන්ත්‍රික සමාජවාදී ජනරජය, Sri Lankā Prajathanthrika Samajavadi Janarajaya, tamil: இலங்கை சனநாயக சோஷலிசக் குடியரசு, Ilaṅkai caṉanāyaka cōṣalisak Kuṭiyarasu) es un país insular ubicado al sureste de India en Asia. Hasta 1972 era llamado Ceilán. Originalmente conocido como Heladiva, está habitada por más de veinte millones de personas.
La isla fue conocida en la Antigüedad como Lanka, Lankadvīpa, Simoundou, Taprobane, Serendib y Selan, llegando a ser denominada popularmente como la «Isla de los mil nombres». Durante su colonización, la isla tomó el nombre, en inglés, de Ceylon, que se siguió utilizando posteriormente. Su particular forma y su cercanía a la India hicieron que se la llame la «Lágrima de la India».

Además Ceylon es el nombre del nuevo lenguaje de Jboss para la JVM.

Ya escribí sobre este nuevo lenguaje de Jboss que corre sobre la JVM. Gavin escribe en su blog que el Lenguaje Java a quedado un poco viejo; por lo tanto el diseño un lenguaje llamado Ceylon que tiene como principal objetivo actualizar el lenguaje Java.

Los objetivos de Ceylon incluyen: Ser fácil de aprender tanto para desarrolladores Java como C#

• Eliminar la verbosidad de Java pero manteniendo la legibilidad
• Mejorar el tipado estático de Java
• Proveer una expresión declarativa para eliminar dependencias con xml
• Apoyar y fomentar un estilo de programación más funcional.
• Proveer soporte para meta-programación
• Proveer construcción modular.

Veamos el clasico “Hola Mundo”:

void hello() {   writeLine("Hola Mundo!");
}

Este método imprime “Hola Mundo!” por consola. Un método TopLevel como este es similar a una función C, esta es manejada directamente por el paquete que la contiene. Y esta no es parte de ningún tipo, por lo tanto no es necesario llamar a un objeto para llamar a un método TopLevel y a la vez no es necesario tener funciones estáticas.Para documentar el codigo provee una anotaciones que nos permiten hacer una documentación más natural por ejemplo:

doc "The classic Hello World program"
by "Gavin"
see (goodbye)
throws (IOException)
void hello() {
writeLine("Hello, World!");
}

Ceylon provee también mejora en el manejo de string, veamos un ejemplo:

doc "The Hello World program
 ... version 1.1!"
void hello() {
writeLine("Hello, this is Ceylon " process.languageVersion
          " running on Java " process.javaVersion "!");
}

Para el manejo de objetos nulos provee un operador ?, veamos un ejemplo:

doc "Print a personalized greeting"
void hello() {
String? name = process.arguments.first;
String greeting;
if (exists name) {
    greeting = "Hello, " name "!";
}
else {
    greeting = "Hello, World!";
}
writeLine(greeting);
}

Name es declarado como String? Lo que significa que acepta valores nulos. También podemos usar el operador ? Para no devolver valores nulos:

shared String greeting = "Hello, " + name?"World";

El operador ? Devolverá name si no es nulo, sino devolvera “World”

Celyon provee parámetros por defecto, secuencias y diferentes tipos de parametros:

void hello(String name="World") {
writeLine("Hello, " name "!");
}


//sequenced parameter
void print(String... strings) {
for (String string in strings) {
    writeLine(string);
}
}


//union type
void print(String|Named printable) {
String string;
switch (printable)
case (is String) {
    string = printable;
}
case (is Named) {
    string = printable.name;
}
writeLine(string);
}

Veamos la declaración de una clase:

doc "A personalized greeting"
class Hello(String? name) {

doc "The greeting"
shared String greeting;
if (exists name) {
    greeting = "Hello, " name "!";
}
else {
    greeting = "Hello, World!";
}

doc "Print the greeting"
shared void say(OutputStream stream) {
    stream.writeLine(greeting);
}

}

Como se puede ver no es necesario un método constructor dado que el código se ejecuta en el cuerpo de la clase.

Ahora veamos como se usa nuestra clase:

doc "Print a personalized greeting"
void hello() {
Hello(process.args.first).say(process.output);
}

La palabra new no se usa simplemente porque no es necesaria.
Las interfaces pueden tener definiciones de metodos pero no se pueden instanciar veamos un ejemplo:

shared interface Writer {

shared formal Formatter formatter;

shared formal void write(String string);

shared void writeLine(String string) {
    write(string);
    write(process.newLine);
}

shared void writeFormattedLine(String formatString, Object... args) {
    writeLine( formatter.format(formatString, args) );
}

}

shared class ConsoleWriter()
    satisfies Writer {

formatter = StringFormatter();

shared actual void write(String string) {
    writeLine(string);
}

}

Hasta aquí una pasada por este nuevo lenguaje para JVM. En mi opinión, cumple sus objetivos; pero deja mucho que desear si se lo compara con groovy o scala. Que piensan? Les gusta este nuevo lenguaje?

Dejo Link:

http://in.relation.to/Bloggers/Gavin

http://in.relation.to/Tutorials/IntroductionToCeylon

Microsoft and Linux, un vídeo de cumpleaños

Increíble este vídeo, nunca pensé que microsoft quisiera hacer las pases con Linux. Por el cumpleaños de Linux la gente de Redmond ha hecho el siguiente vídeo:



Me da desconfianza, es muy raro... Que opinan?

Blog sobre Erlang

Estoy leyendo aprendiendo-erlang.blogspot y me parece muy buena información, claro y conciso.

Una buena forma de ir aprendiendo erlang.

JetBrains crea un nuevo lenguaje para la JVM

Kotlin es el nombre del nuevo lenguaje de la empresa jetbrains. Recordemos que jetbrains es la creadora de la exitosa ide IntelliJ.

Kotlin es un lenguaje que intenta solucionar incombenientes al escribir codigo Java. Entre otras características podemos nombrar:

El sistema toma control de las referencias nulas, no es necesario null pointer.
Soporta Clojures

Es interoperable con Java; Java puede llamar a Kotlin y Kotlin puede llamar a Java.

Veamos un ejemplo de un Hola Mundo:

class Greeter(name : String) {
fun greet() {
println("Hello, ${name}");
}
}

fun main(args : Array) {
Greeter(args[0]).greet()
}


Dejo links:

http://en.wikipedia.org/wiki/Kotlin_(programming_language)

http://confluence.jetbrains.net/display/Kotlin/Welcome

http://www.infoq.com/news/2011/07/kotlin

JQuery EasyUI

JQuery EasyUI es una colección de plugins para diseñar interfaces de usuario con JQuery. Entre los componentes que ofrece podemos nombrar form, validatebox, combo, combobox, combotree, calendar.

Con Easyui se pueden desarrollar interfaces profesionales de forma rapida. A la vez soporta theme como Jquery UI.

Dejo links:

http://www.jeasyui.com/
http://www.jeasyui.com/demo/

Sindicato Unión Informática

Siempre que estamos bien, no pensamos en el futuro. Es hora de ver y trabajar por nuestro futuro. Me llego este mail y quiero compartirlo:

Seguramente muchos no saben pero el 28-JUL hay convocado un paro en IBM.
Es raro escuchar esto, dado que nuestra profesión no está acostumbrada a estar sindicalizada.

Pero analizando los sueldos que pagan y la estructura que se conoce en empresas grandes como IBM, plantean que los profesionales comienzen a "unirse" por mejores condiciones laborales y salariales. Más datos en http://www.union-informatica.com.ar/.

Como podrán observar un sueldo en IBM evaluación 2, está por debajo de los 6000$AR (unos 1450 USD), que es el básico de muchos asalariados sin especialización (obreros, camioneros, etc).

Es decir, las lineas bajas están mejor representados y unidos, generando mejores negociaciones para todos ellos. Hace rato que había leído acerca de la próxima "rebelión" de las lineas medias (profesionales). Es decir, los que mayormente integramos esta lista :).

Se que el problema pasa mayormente en las grandes compañías que tienen las famosas software factories. Si bien, muchos trabajamos en empresas más pequeñas donde nos permiten usar hasta nuestras herramientas, no siempre es el caso. Hay grandes empresas donde usan Smalltalk también y estamos inmersos en el mismo dilema.

¿Que opinan, será favorable?

InvokeDynamic en Java 7

Ya hemos hablado en post anteriores sobre el proyecto Da Vinchi:

da-vinci-machine-project.html

InvokeDynamic es el primer fruto de este proyecto, básicamente que permite hacer InvokeDynamic, invocar métodos al vuelo; si si va ser usado para closures. Si bien no se puede usar desde java es una mejora importante para jvm preparando todo para el uso de closures en la versión 8 de java.

La pregunta es cantada, para que hacen esta mejora en java 7 si la vamos a ver en java 8. Es para los lenguajes script que actualmente corren en java.
Poder ejecutar al vuelo métodos le da la posibilidad a lenguajes script a correr mucho más rápido. Anteriormente se veían obligados a un uso de reflexión.
En conclusión en java 7 los lenguajes scripts son mucho más rápidos y la pregunta es: el futuro de la plataforma esta en otros lenguajes?

Dejo links:

http://java.sun.com/developer/technicalArticles/DynTypeLang/index.html