Ale Vouilloz

Modelando la Capa de Acceso a Datos

2011-08-01T15:31:00.020-03:00

La finalidad de este pequeño tutorial es mostrar con un pequeño ejemplo, el uso de distintas tecnologías para modelar e implementar una Capa de Acceso a Datos en la plataforma Java. Los frameworks usados serán los siguientes:

- Spring (IoC): Usaremos la Inversión de Control de éste framework general para configurar por inyección de dependencias las clases a utilizar ganando así flexibidad. También usaremos de él, algunas clases de apoyo útiles para los test de JUnit.

- JPA (Java Persistence Api): Estándar para la persistencia de objetos en Java.

- EclipseLink: Motor ORM que usaremos como proveedor JPA. Gracias a Spring podemos reemplazar EclipseLink por otro ORM como Hibernate o OpenJPA fácilmente.

- JUnit: Framework para crear test unitarios.

- DBUnit: Librería de utilidades para escribir test con Base de Datos.

- HSQL-DB: Motor de Base de Datos en memoria, muy útil para los test.

El código fuente se encuentra en un proyecto de Netbeans pero es muy sencillo copiar todas nuestras clases y agregar todas las librerías dependientes del directorio lib en tu IDE favorito.

El Domino
Como modelaremos sólo la capa de acceso a datos no es necesario conocer demasiado del negocio, sólo necesitamos saber que clases del domino serán las persistentes como muestra el siguiente diagrama de clases. Un empleado trabaja para un departamento y puede tener asignadas algunas tareas.

De esta forma tendremos un modelo de datos con cuatro tablas. La tabla EMPLEADO, DEPARTAMENTO, TAREA y EMPLEADO_TAREA para la relación muchos a muchos entre Empleado y Tarea.

La clase Departamento:

@Entity
public class Departamento implements Serializable {

 @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
 private long id;

 private String nombre;

 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;
 }

 @Override
 public String toString() {
     return "Departamento{" + "nombre=" + nombre + '}';
 }

}

En éste caso el mapeo del nombre de la clase a la tabla se produce de forma implícita porque tienen el mismo nombre (no es case sensitive). Si la clase se llamaria con un nombre distinto al de la tabla, sería necesario hacer el mapeo del nombre explicito con la anotación @Table(name=”nombreTabla”).

Tambien podemos observar que la anotación @Id seguida de @GeneratedValue, especifica que el campo sera la clave primaria y el valor sera autogenerado por la base de datos con la estrategia IDENTITY.

La clase Tarea:

@Entity
public class Tarea implements Serializable {
    
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private long id;
    
    private String descripcion;

    public String getDescripcion() {
        return descripcion;
    }

    public void setDescripcion(String descripcion) {
        this.descripcion = descripcion;
    }

    public long getId() {
        return id;
    }

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

La clase Empleado:


@Entity
public class Empleado implements Serializable {
    
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private long id;
    
    private String nombre;
    
    private String apellido;
    
    @Temporal(javax.persistence.TemporalType.DATE)
    private Date fechaNac;
    
    private float sueldo;
    
    @ManyToMany
    @JoinTable(name="EMPLEADO_TAREA",
            joinColumns=@JoinColumn(name="EMPLEADO_ID"),
            inverseJoinColumns=@JoinColumn(name="TAREA_ID"))
    private Collection tareas;
    
    @ManyToOne
    @JoinColumn(name="DEPARTAMENTO_ID")
    private Departamento departamento;

    public String getApellido() {
        return apellido;
    }

    public void setApellido(String apellido) {
        this.apellido = apellido;
    }

    public Departamento getDepartamento() {
        return departamento;
    }

    public void setDepartamento(Departamento departamento) {
        this.departamento = departamento;
    }

    public Date getFechaNac() {
        return fechaNac;
    }

    public void setFechaNac(Date fechaNac) {
        this.fechaNac = fechaNac;
    }

    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 float getSueldo() {
        return sueldo;
    }

    public void setSueldo(float sueldo) {
        this.sueldo = sueldo;
    }

    public Collection getTareas() {
        return tareas;
    }

    public void setTareas(Collection tareas) {
        this.tareas = tareas;
    }

    @Override
    public String toString() {
        return "Empleado{" + "id=" + id + ", nombre=" + nombre + ", apellido="
                + apellido + ", departamento=" + departamento + '}';
    }
}

Nótese el mapeo de las colecciones, en especial la colección tareas que representa la relación muchos a muchos con la tabla TAREA mapeada con la tabla intermedia EMPLEADO_TAREA gracias a la anotación @ManyToMany y la anotación @JoinTable

Clases DAO
Este patrón de diseño es usado como Objeto de Acceso a Datos. En nuestro ejemplo definimos su interface para acceder a los datos de la entidad Empleado:


public interface EmpleadoDao {
    
    public Empleado buscarPorId(long id);
    
    public void guardar(Empleado empleado);
    
    public void borrar(Empleado empleado);
    
    public Empleado buscarPorNombre(String nombre);
    
    public Collection listarTodos();
    
    public Collection listarPorDepartamento(Departamento departamento);
}

Y su implementación para JPA:


@Repository
@Transactional
public class EmpleadoDaoJPA implements EmpleadoDao {
    
    @PersistenceContext
    private EntityManager em;

    @Override
    public Empleado buscarPorId(long id) {
        return em.find(Empleado.class, id);
    }

    @Override
    public void guardar(Empleado empleado) {
        em.persist(empleado);
        em.flush();
    }

    @Override
    public void borrar(Empleado empleado) {
        em.remove(empleado);
    }

    @Override
    public Empleado buscarPorNombre(String nombre) {
        Query query = em.createQuery(
                "SELECT e FROM Empleado e WHERE e.nombre=:nom")
                .setParameter("nom", nombre);
        
        return (Empleado) query.getSingleResult();
    }

    @Override
    public Collection listarTodos() {
        Query query = em.createQuery("SELECT e FROM Empleado e");
        
        return query.getResultList();
    }

    @Override
    public Collection listarPorDepartamento(Departamento departamento) {
        Query query = em.createQuery(
                "SELECT e FROM Empleado e WHERE e.departamento=:dpto")
                .setParameter("dpto", departamento);
        
        return query.getResultList();
    }
}

La anotación @Repository es una anotación Spring que indica que es una clase que deberá ser instanciada automáticamente como un Singleton.

La anotación @Transactional le indica a Spring que las operaciónes de datos realizadas por JPA en esa clase serán transaccionales.

La anotación @PersistenceContext inyecta un EntityManager a la variable de clase em para poder acceder a las operaciones que nos expone JPA en su api.

Obsérvese además, las querys creadas en el lenguaje de consultas de JPA JPQL que nos permite consultar manteniendo las características de la orientación a objeto, tales como la herencia.

El archivo persistence.xml




  
    org.eclipse.persistence.jpa.PersistenceProvider
    alevouilloz.entity.Empleado
    alevouilloz.entity.Departamento
    alevouilloz.entity.Tarea

Si buscamos dentro del paquete META-INF nos encontraremos con el archivo persistence.xml. Este archivo es la unidad de persistencia que configura JPA. Como podemos apreciar se indica el proveedor de persistencia que se usará, en nuestro caso EclipseLink. Además se enumeran las clases que deben ser mapeadas por el motor ORM. También es posible configurar aquí la fuente de conexión JDBC que se usará, pero en nuestro ejemplo lo haremos en el contexto de aplicación de Spring.

Importante: Al iniciarse la aplicación, la JVM por defecto buscará éste archivo dentro del paquete META-INF.

El archivo applicationContext.xml:



       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-3.0.xsd">
        
    
    
    
    
    

    
    
        
        
        
        
    
     
    
    
        
        
        
            
        
        
                         class="org.springframework.beans.factory.config.PropertiesFactoryBean">
                
                    
                        false

En el paquete resource del directorio test, se encuentra el archivo applicationContext.xml. Este archivo es el contexto de aplicación del framework Spring. En él indicaremos entre otras cosas, la fuente de conexión JDBC con la base de datos y las clases DAO que usaremos.

En nuestro ejemplo, el bean definido con id empleadoDao no es necesario, ya que como vimos anteriormente, nuestra implementación EmpleadoDaoJPA está anotada como @Repository y gracias al component-scan de Spring, ésta es cargada automáticamente y luego es inyectada cuando una clase necesita una instancia de su interface usando la anotación @Autowired. En el caso que la Interface EmpleadoDao tenga varias implementaciones, es útil definir el bean con un id en el contexto para que luego pueda indicarse que implementación DAO será la inyectada.

Preparando la Base de Datos para el Test

Por medio del script ddl.sql del paquete resource que ejecutamos, definimos la creacion de las tablas necesarias.


DROP TABLE EMPLEADO if exists;
DROP TABLE DEPARTAMENTO if exists;
DROP TABLE TAREA if exists;
DROP TABLE EMPLEADO_TAREA if exists;

CREATE TABLE EMPLEADO (
    id integer NOT NULL IDENTITY,
    nombre varchar(255) NOT NULL,
    apellido varchar(255),
    sueldo float,
    fechaNac Date,
    departamento_id integer 
);

CREATE TABLE DEPARTAMENTO (
    id integer NOT NULL IDENTITY,
    nombre varchar(255) NOT NULL
);

CREATE TABLE TAREA (
    id integer NOT NULL IDENTITY,
    descripcion varchar(255) NOT NULL
);

CREATE TABLE EMPLEADO_TAREA (
    id_empleado integer NOT NULL,
    id_tarea integer NOT NULL,
);

En el archivo initDataSet.xml definimos el DataSet para que el framework DBUnit cargue algunos datos de prueba en las tablas de la base de datos.

Escribiendo el Test para el DAO: EmpleadoDaoJPA


@ContextConfiguration(locations = {"classpath:resources/applicationContext.xml"})
@RunWith(SpringJUnit4ClassRunner.class)
@TransactionConfiguration(transactionManager = "transactionManager")
@Transactional
public class EmpleadoDaoJPATest {
    
    @Autowired
    private EmpleadoDao empleadoDao;
    
    @Autowired
    @Qualifier(value = "HSQLDataSource")
    private DataSource datasource;
    
    @Before
    public void setUp() throws Exception {
        //Creamos las tablas necesarias para el test antes de cargar los datos
        SimpleJdbcTemplate temp = new SimpleJdbcTemplate(datasource);
        SimpleJdbcTestUtils.executeSqlScript(
                temp, new ClassPathResource("resources/ddl.sql"), false);          
            
        //Cargamos la BD con los datos iniciales
        Connection conn = datasource.getConnection();
        IDatabaseConnection dbUnitCon = new DatabaseConnection(conn);
        FlatXmlDataSetBuilder dsBuilder = new FlatXmlDataSetBuilder();
        IDataSet dataSet = dsBuilder.build(new File("./test/resources/initDataSet.xml"));
        try {
            DatabaseOperation.CLEAN_INSERT.execute(dbUnitCon, dataSet);
        } finally {
            DataSourceUtils.releaseConnection(conn, datasource);
        }
    }

    @Test
    public void testBuscarPorId() {
        Empleado result = empleadoDao.buscarPorId(1L);
        assertNotNull(result);
        
        System.out.println("Empleado encontrado: " + result);
    }

...

Es posible cargar el archivo de contexto de Spring por medio de la API, pero en el ejemplo lo hacemos por medio de la anotación @ContextConfiguration donde le indicamos además su ubicación. Si no se indica la ubicación Spring asume que el archivo contexto de aplicación se encuentra en el mismo paquete de la clase de inicio y su nombre es el de la clase concatenando “-config.xml”.

La anotación @RunWith(SpringJUnit4ClassRunner.class) nos da soporte de Spring para JUnit 4.

Podemos ver que la variable de clase empleadoDao al estar anotada como @Autowired será inyectada con la implementación de EmpleadoDao que sea encontrada en el contexto.

De forma similar también será inyectado el DataSource declarado en la variable datasource, pero esta vez indicamos explícitamente con la anotación @Qualifier que sea con el bean llamado “HSQLDataSource”. En el caso de que existan varios beans del mismo tipo y si no usamos @Qualifier, Spring no sabrá que implementación inyectar y nos arrojará una excepción informando éste inconveniente. En nuestro ejemplo no es necesario especificar el DataSource a inyectar ya que en el contexto existe un solo bean declarado, pero queda a modo ilustrativo.

El método setUp() anotado con @Before de JUnit4 se ejecuta al comienzo de cada test y prepara la Base de Datos con la ayuda de algunas clases de utilidades de DBUnit, cargando el dataset con los datos iniciales para las pruebas.

Esto es todo. Espero que les haya sido útil, y ya saben: cualquier duda, comenten.

Las 10 webs de lectura imprescindibles para el Arquitecto de Software

2011-05-10T11:36:00.019-03:00

Hacia tiempo que tenía ganas de redactar una entrada con las webs que me vienen ayudando en el día a día laboral. De esta forma, confeccioné un ranking con lo que para mi son los 10 sitios webs imprescindibles para un Arquitecto de Software.

InfoQ es el más completo sitio con artículos y conferencias del mundo del software, dividido en comunidades: Java, .NET, SOA, Arquitecturas, Agile.

Subscripción para recibir tarjetas-artículos sobre nuevas tecnologías de software.

Comunidad con artículos de la plataforma JEE.

Extensa recopilación de articulos sobre la plataforma Java continuamente actualizada.

Web con artículos sobre metodologías ágiles y liderazgo de proyectos.

El clásico de clásicos de Java en el lenguaje de Cervantes con noticias y una gran comunidad comprometida a brindar ayuda en los foros.

Comunidad de Linux en español con novedades sobre tecnologías de desarrollo para éste sistema operativo.

Excelente web con todo los patrones de diseño, anti-patrones y técnicas de refactoring explicados gráficamente y con ejemplos en los lenguajes más usados.

Se autodefine como: "El corazón de la comunidad de desarrolladores Java".

Sitio principal sobre el desarrollo de las apis de Java, implementaciones de JSRs y librerias en incubación.

Scala - Parte 1: Introducción

2010-08-13T11:48:00.006-03:00

Luego de mucho tiempo de no escribir una entrada nueva al blog, me comprometo a redactar una serie de entradas para introducirlos en este lenguaje que me tiene fascinado: Scala

Existen dos motivos que me llevó a tomar ésta desición: 1-No existen muchos artículos en castellano sobre el tema. 2-Lo escribo más para mi que para los lectores a modo de repaso de lo estudiado.

Bien, comencemos.

¿Por donde empezar?
Lo primero que debemos hacer es visitar el sitio oficial de Scala y bajarnos su última versión.

Mientras descargamos les cuento que Scala es un lenguaje multiparadigma que convina la Orientación a Objetos con la Programación Funcional. Si bien se lo puede catalogar como de tipado fuerte, permite la inferencia de tipos. Como lenguaje Orientado a Objetos es tan puro como lo es Smalltalk. Es decir, todo en Scala es un objeto, no existen los tipos nativos. Si escibimos un valor literal como podría ser un entero veremos que éste tiene métodos.
Scala compila a bytecode para la JVM. Aunque existe una versión para .NET. Los astutos ya se habrán imaginado que entonces es requisito tener instalado un JRE para ejecutar una aplicación Scala.
Además de ésto tenemos el potencial de poder reutilizar todas las Apis y librerias de Java importandolas en nuestro código Scala de manera muy sencilla. Importante es aclarar que el paquete java.lang esta implícitamente importado en el lenguaje.

Existen plugins tanto para los ide's Netbeans como para Eclipse con caracteristicas poderosas que van más allá del simple coloreado de sintaxis. Como si fuera poco la distribución de Scala nos trae una propia herramienta REPL que no es otra cosa que un iterprete Scala. Para invocarla y tirar nuestro primer "hola mundo" sólo hace falta ejecutar la orden scala desde el shell de nuestra terminal del S.O. Previamente y una vez descargada la distribución deberemos descomprimirla en algun directorio y establecer el directorio /bin de Scala para que sea accedido desde cualquier path. Para ésto desde Windows editamos la variable de entorno path agregando el directorio /bin de nuestra instalación Scala. Los linuxeros ya sabrán como hacerlo, ni me gasto :P

Hola Mundo Scala!
Para nuestro primer hola mundo accedemos al interprete de scala ejecutando scala.bat desde el directorio /bin de la instalación o simplemente ejecutando scala si tenemos configurado el path en la variable de entorno.

scala> println("Hola Mundo Scala!")
Hola Mundo Scala!

Declarando variables
Si declaramos las variables con la palabra reservada val, la variable puede ser asignada con un valor una sola vez, similar a cuando declaramos con el modificador final de Java.

scala> val msg = "Hola Mundo Scala!"
msg: java.lang.String = Hola Mundo Scala!
scala> println(msg)

Cuando queramos asignarle un nuevo valor el error producido es el siguiente:

scala> msg = "Hola de nuevo"
:5 error: assignment to non-variable
val unnamed4 = {msg = "Hola de nuevo";msg}

Por el contrario si declaramos la variable con la palabra reservada var, ésta podrá reasignarsele valores todas las veces que queramos.

scala> val msg2 = "Hola cambiante"
msg2: java.lang.String = Hola cambiante
scala> msg2 = "Hola de nuevo"
msg2: java.lang.String = Hola de nuevo
scala> println(msg2)
Hola de nuevo

Definiendo métodos
Ahora veamos algunas definiciones de métodos en Scala:

scala> def max(x: Int, y: Int): Int = if (x < y) y else x max: (Int,Int)Int

Éste método calcula el máximo de los dos valores enteros argumentados. En la definición está indicado explícitamente el tipo de retorno del método. Algunas veces el compilador requiere que especifiquemos el tipo. Si el método es recursivo, por ejemplo, es necesario explicitar el tipo del resultado del método. Pero en el ejemplo anterior es posible obviar el tipo del retorno en la definición porque el compilador es capaz de darse cuenta por inferencia:

scala> def max2(x: Int, y: Int)= if (x < y) y else x max2: (Int,Int)Int

Podemos observar como Scala sabe por inferencia que el retorno es un objeto Int.

En los ejemplos anteriores el cuerpo del método está definido en una sola sentencia. Pero si el método fuera más complejo el cuerpo debería estar enmarcado dentro de un bloque. Al igual que Java y C, Scala usa las llaves { } para limitar los bloques de código:

scala> def max3(x: Int, y: Int) = { if (x < y) y else x } max3: (Int,Int)Int

Podemos comprobar el resultado del método con:

scala> println(max(5,2))
5

Cuando el método no necesita argumentos es posible definirlo de la siguiente manera:

scala> def saludo = println("Hola, soy un metodo sin argumentos")
saludo: Unit

Además podemos notar que ahora el retorno del compilador indica que el método saludo no tiene parametros y que retorna un Unit. Un Unit viene a representar lo que es un void en Java. Para usarlo podemos escribir:

scala> saludo
Hola, soy un metodo sin argumentos

Bueno, por ahora dejo sólo esto pero espero volver con más en un par de días. Mientras vale seguir experimentando, sobre todo para los que vienen de Java. No sean flojos! :)

LiveCD de Ágil

2009-06-05T13:45:00.008-03:00

Un alto porcentaje de la gente que crítica a Ágil no conoce de que va el tema y se resisten a comprender sus ventajas por una multitud de motivos sin sentido y presentando excusas tontas como: “ahh, pero en mis proyectos no se podría aplicar, mis proyectos son especiales”. Pfff…Ahora somos todos especiales!! Otros reconocen ciertas ventajas pero no se animan al cambio debido a que algunas prácticas propuestas exigen cierta destreza.

Sin embargo, podemos realizar pequeños pasos para introducirnos en ágil y asomarnos levemente a ver más o menos de que se trata.

Una forma de asomarse al agilismo puede llegar a ser éste desafío que lo tomé prestado de ésta web chilena y permite que los conservadores y cautelosos puedan experimentar sin “dañar nada de su sistema”, similar a un liveCD :) como se calcula la velocidad de un equipo de desarrollo usando Kanban o mejor dicho algo de Kanban.

1. Listar en post-its las tareas de cada uno para las próximas dos semanas

2. Escribir en cada post-it el tiempo que demoraría en hacerse en condiciones óptimas (sin interrupciones)

3. Frente al escritorio de trabajo, crear un panel (que llamaremos Panel Kanban) con 3 columnas: Ítemes que no han partido, ítemes comenzados e Ítemes finalizados

4. En las dos semanas, mover los post-its de una columna a otra a medida que se progresa

5. Al final de las 2 semanas, sumar los numeros de aquellas tareas que estén en la columna “finalizados”

Al dividir la suma de horas “ideales” logradas sobre el total de horas de trabajo de las 2 semanas, habrán medido su velocidad. Ahora tienen una medida de cuanto son capaces de realizar cada 2 semanas, y por ende tienen una guía cerca de cuanto pueden comprometerse para la próxima.

¿Que les parece esta experiencia?

Resultado de la encuesta sobre RIA's

2009-04-30T01:23:00.002-03:00

Otra vez una encuesta con tan pocos votantes no es indicador de mucho.
Pero creyendo en una tendencia de 29 votos se destacan las herramientas Flash/Flex, Ajax con librerias Javascript y GWT sobre JavaFX, Silverlight y OpenLaszlo.
No hay mucho para decir. Es lo que esperaba.

Lean en la producción de Software

2009-03-27T12:39:00.005-03:00

Considerado por los expertos como el sistema de fabricación del siglo XXI, Lean Manufacturing es un sistema de gestion de proceso de producción impulsado por Toyota. Su objetivo primordial es implantar la eficacia en todos los procesos del negocio, eliminando las actividades que no aportan valor añadido (denominadas waste), con el fin de generar beneficios tangibles para el cliente final.

Veamos los cinco principios del Lean:

"Understanding Consumer Value" o comprensión de lo que es valor para el cliente; el foco se externaliza desplazándose hasta el consumidor final, que es quien decide lo que es importante y le aporta valor.
"Value Stream Analysis" o estudio de todas las fases del proceso de producción, para determinar las que añaden valor y las que se deben cambiar o eliminar.
"Flow" o unificación de las fases de trabajo en un espacio único.
"Pull" o fase final, en la que el producto no se termina hasta que los clientes no hacen el pedido.
"Perfection" u objetivo final. En la medida en que se eliminan los pasos innecesarios y los flujos de trabajo se adaptan a los pedidos de los clientes, se comprueban las reducciones de costes, esfuerzo y tiempos de trabajo en todas las áreas de la empresa. continuas.

Mejoras Continuas.

El soporte a los principios del Lean Manufacturing, se realiza en tres áreas funcionales básicas: gestión, planificación y ejecución, y reducción de actividades sin valor añadido.

En el área de gestión, esta metodología analiza todos los procesos y prácticas respecto a una serie de indicadores clave, y establece unos criterios fundamentales que sirven de punto de partida para medir las mejoras y progresos durante el proceso de implementación del Lean Manufacturing.

En el área de planificación y ejecución, la fabricación comienza cuando el cliente hace el pedido. Mediante el sistema Kanban de planificación y ejecución, se establece un flujo ordenado y automático de materiales, tanto en lo que se refiere a peticiones y aprovisionamientos como a cantidades, proveedores y lugares de destino, basándose en la demanda actual.

Los proveedores también pueden formar parte del sistema gracias al desarrollo de portales web en los que pueden verificar los niveles de existencias y reponer ellos mismos el material en función de los niveles acordados.

La posibilidad de replicar actividades repetitivas sin necesidad de emitir órdenes de trabajo para cada una de ellas o de establecer líneas de producción independientes para cada trabajo, son otras de las ventajas de este sistema que reduce los tiempos muertos entre cada etapa.

Por último, el sistema Lean incide con especial interés en la reducción de actividades que no aportan valor añadido ”waste”. Básicamente, esta metodología identifica siete tipos de waste:

Exceso de producción o producción temprana: producir más de lo que el cliente demanda o hacerlo antes de tiempo. Ocupa trabajo y recursos valiosos que se podrían utilizar en responder a la demanda del cliente.
Retrasos: por falta de planificación, de comunicación o de tardanza en el suministro de materiales, herramientas, información…
Transportes desde o hacia el lugar del proceso: los materiales se deberían entregar y almacenar en el punto de fabricación, para evitar traslados innecesarios.
Inventarios: se deben reducir al mínimo ya que suponen un coste financiero y de almacenamiento.
Procesos: dedicar más esfuerzos de los necesarios en revisiones y actualizaciones; la calidad se debe insertar en todas las fases del proceso de forma que cada una de ellas sea correcta desde el principio.
Defectos: multiplican los costes y el tiempo de trabajo y consumen una parte importante de los recursos para su solución.
Desplazamientos: los empleados deben tener a su disposición todas las herramientas y recursos que vayan a necesitar para evitar desplazamientos innecesarios.

Mejoras Operativas

90% reducción de tiempos en el ciclo de trabajo

50% incremento de la productividad

80% reducción del inventario

80% mejora de la calidad final

75% reducción del espacio utilizado

Para eliminar o reducir el waste, existen una serie de técnicas que abarcan todas las áreas funcionales como: análisis de producción de la empresa, análisis de las actividades de valor, sistema de gestión de calidad total, mantenimiento totalmente productivo, análisis Kaizen de costes y fijación de precios, ingeniería y gestión del cambio y gestión de la documentación.

Como se ha visto, la implantación de la metodología Lean implica el compromiso de toda las áreas funcionales de la empresa y supone un cambio de mentalidad basado en la calidad total. Además ayuda a generar una dinámica propia de mejora, por lo que la adaptación a las caracteristicas de cada caso es indispensable. Por todo ello las ideas centrales del pensamiento Lean no incluyen explicitamente una implementación.

Fuente: Principios Lean para una fabricación eficaz. de IFS España

Ahora bien, En el caso puntual de la industria del software la respuesta rápida al cambio es un requisito indispensable. Cuantas veces hemos oido la frase: "¿Pero como, ahora es tan dificil agregar un botón en el formulario?" Haciendo una analogía apresurada con la ingeniería de puentes, ¿cuántos habitantes de una región(clientes) han pedido modificar el puente ya construido para que en vez de que sea de tipo colgante sea en arco. El cliente ve un proyecto de software como algo blando, fácilmente modificable, y sabemos que no siempre es asi. Pero entonces, ¿qué hacemos? Tratamos de persuadir al cliente que la Ingeniería del Software es tan rígida como la Ingenería Civil o buscamos adaptarnos a la flexibidad requerida.

Teniendo en cuenta lo anterior, la industria del software es el contexto ideal para implementar Lean. Toyota y muchas empresas ajenas a la industria del software tuvieron éxito y mejoraron su productivad con su implementación. Si el software se identifica tanto con los principios del Lean, ¿porqué no implementarlo?

El mismo RUP propone cierta flexibidad al cambio. Eso si, exige abundante documentación para poder llevarla a cabo. En un ciclo productivo Lean se analizaria que documentación es útil en la producción y que documentación es pérdida de tiempo y recursos. Aquí es donde entran las metologías ágiles. Si, es verdad, al igual que las religiones, todas se parecen. Pero cada una busca su implementación de la filosofía Lean para maximizar la producción. Noten que ahora hice referencia a Lean como una filosofía y no como una metología. Si se quiere se puede ver a Lean como una especificación de principios y a cada metodología agil como una implementación de Lean que intenta conducir un proyecto por el camino del éxito.

Sin dejar la objetividad de un ideal de fábrica de software productiva y metodológica, quiero abrir el debate y leer sus opiniones.

FileDrop: Drag & Drop de archivos fácil en Java

2009-03-19T12:25:00.022-03:00

Así es como se presenta éste api, sencillo, de dominio público y muy, pero muy útil.

FileDrop no tiene licencia, es de dominio público y tal como se aclara en su web, podemos hacer lo que se nos antoje con el. El zip de descarga contiene además del jar, el archivo FileDrop.java con toda la funcionalidad embebida para que podamos incluírlo en la ruta de paquetes de alguna aplicación propia sin tener dependencias de jar externos.

Para ver cuan fácil es usar el Drag & Drop de archivos en Java con FileDrop, vamos a ir más alla del ejemplo de su web y vamos a hacer un componente que muestre imágenes y acepte archivos de imagenes "dragueados" desde el sistema. Algo similiar se podría hacer con visores PDF, reproductores multimedia, o cualquier funcionalidad relacionada al drag & drop de archivos integrada a una aplicación Java standalone. En éste link puse el código fuente del ejemplo.

Primero implementmos el visor de imágenes como un componente. También es posible implementar el visor de imagenes extendiendo de JPanel, Canvas o un JLabel en lugar de un JComponent.
Luego es necesario definir una clase que maneje la transferencia del objeto a draguear. Para nuestro propositito sólo se soportará transferencia de objetos java.awt.Image.

Y Finalmente, hacemos uso de FileDrop en el método que instancia nuestro visor de imágenes.

Como se aprecia en el ejemplo, en el método FileDroped del listener se espera un array de objetos File, ésto permite manejar múltiples "dropeos" de archivos. Una aplicación útil podría ser la típica lista de reproducción que al dropear múltiples archivos .mp3 en el contenedor Swing reproduzca el elemento [0] y encole el resto en la lista.

Espero que les sirva y cualquier duda, comenten.

FEST Swing: Testing de GUIs

2009-03-13T16:13:00.009-02:00

FEST Swing no es un festival sobre el estilo musical que hace mover las caderas :D

FEST es el acrónimo de Fixtures for Easy Software Testing y esta compuesto por cuatro módulos, uno de éstos modulos se llama FEST-Swing y su función es la de proporcionar una ayuda para la dificil y tediosa tarea de escribir test para las interfaces gráficas de usuario programadas con el api de java Swing.

FEST Swing se integra perfectamente con TestNG y con JUnit. Además desde una tarea ant es posible generar screenshots de las pantallas que fallaron, util para reportar.

Sin más parafernalia veamos un ejemplo:

dialog.comboBox("domain").select("Users");
dialog.textBox("username").enterText("leia.organa");
dialog.button("login").click();
dialog.optionPane().requireErrorMessage()
            .requireMessage("Please enter your password");

El ejemplo ilustra como testear un dialogo de login y la validación cuando el usuario olvida llenar el campo de texto password.

Aunque su sintaxis es muy intuitiva, en su wiki podrán encontrar una completa documentación de uso.

Exprimiendo a Hudson - Parte 4 (Métricas de calidad)

2009-03-11T11:58:00.005-02:00

Me he encontrado con la grata sopresa de que una persona no sólo comparte el mismo ambiente de desarrollo e integración que el mio, si no que también ha decidido escribir sobre Integración Continua en su blog.

Iván, ya ha explicado en su blog como montar un ambiente de desarrollo para TDD con Netbeans, Ant, SVN y Hudson. Ambiente idéntico al que vengo describiendo en una serie de post.
Dejo la continuación de los temas que tenía pensado escribir, en éste par de artículos redactados de manera excelente:

TDD mejora la calidad sin perder productividad

2009-03-03T11:29:00.005-02:00

Un estudio publicado por Empirical Software Engineering demuestra que TDD mejora la calidad del software producido sin decrementar la productividad.

Este estudio se basó en observar el desarrollo de un proyecto de IBM y tres de Microsoft. Cada uno de estos casos de estudio comparan dos proyectos que trabajan en el mismo producto, usando los mismos lenguajes de programación y tecnologías, bajo la misma gerencia y dirección, y sólo uno de los equipos usaba Test-Driven Development (TDD). Ningún equipo sabía que estaba siendo parte de un estudio. El caso de estudio de IBM siguió a un equipo que desarrollaba un controlador de dispositivos. Los casos de Microsoft siguieron a equipos que trabajaron en Windows, MSN y Visual Studio.

Los resultados arrojados mostraron que la densidad de defectos en las pre-entregas de los cuatro productos, medida como defectos cada mil líneas de código, disminuyó entre un 40% y un 90% relativo a los proyectos que no usaron TDD. Las gerencias de los equipos informaron un incremento subjetivo del 15-35% en el tiempo de desarrollo inicial para los equipos que usaron TDD, pero todos estuvieron de acuerdo que esto se cubría por los menores costos de mantenimiento.

Fuente: http://www.dosideas.com/metodologias/445-esta-demostrado-tdd-mejora-la-calidad-del-software.html

JavaFX alcanzo los 100 millones de descargas

2009-02-20T11:41:00.004-02:00

Continuando con las noticias, ésta vez relacionadas a Java, el CEO de Sun Jonathan Schwartz anunció que JavaFX ha llegado a los 100 millones de descargas. En su blog alaba las características de éste recién nacido lenguaje multiplataformas y augura un futuro muy prometedor.

Jonathan Schwartz fue la persona de Sun que más ha promocionado Java y colaborado para liberar la plataforma completamente, convirtiendo a la compañía en un icono más del Open Source.

¿Que opinas de JavaFX?

Links:

Encuesta: ¿Que S.O. prefieres para desarrollar en Java?

2009-02-10T15:56:00.007-02:00

Finalizada la encuesta, podemos observar que de un total de 26 votos gana Linux con 13 votos, siendo Ubuntu la distro preferida. Le sigue Windows con 11 y bueno... Solaris y MacOs con un solo voto.

Si bien la muestra de 26 votos es muy chica, me alcanza para confirmar lo siguiente:

Con las facilidades de usabilidad que alcanzaron al día de hoy las distribuciones Linux como Ubuntu, los desarrolladores Java que desean ser productivos y no liarse con asuntos exclusivamentes del sistema operativo ya no lo ven de forma negativa. Más aún están comenzando a notar ventajas sobre Windows en cuando a estabilidad, seguridad y usabilidad.

Desde que migre mi ambiente de desarrollo desde Windows a Ubuntu no me canso de recomendar y enumerar las ventajas que vengo obteniendo.

Personalmente opino que muchos de los que aún siguen prefiriendo Windows a Linux, toman su desición debido a prejuicios basados en conceptos fantasmas y relacionados a la falsa creencia de la dificultad de configuración y usabilidad. En fin, quiero recomendar a todos ellos que prueben el live-cd de ubuntu y despues me cuentan.

Escucho sus opiniones.

Exprimiendo a Hudson - Parte 3 (Creando un Job)

2009-02-09T13:02:00.032-02:00

Por fin vamos a crear nuestro primer job. En ésta ocasión vamos a suponer que contamos en nuestra Software Factory con un proyecto Java que se construye (compila, distribuye, genera javadoc, etc) desde un script ant. Si usamos un IDE como NetBeans este script es generado automáticamente segun las propiedades del proyecto, no es la finalidad de este tutorial explicar como modificar estos script desde Netbeans, solo comentar que podemos modificar/agregar task ant facilmente sin tocar lo generado por el ide en el archivo build.xml del directorio raiz del proyecto. Aquí un pequeño tutorial que explica como hacer esto.

Retornando a Hudson, podemos definir un Job como una tarea con acciones y triggers a realizar sobre un proyecto de software. Normalmente tendremos definido un job por cada proyecto que tengamos que integrar, pero no hay un límite sobre la cantidad de jobs que podamos definir sobre un proyecto particular, todo depende de las acciones que quisieramos ejecutar en el job.

Para crear un job nuevo hacemos click sobre New Job. Como dijimos que la construcción del proyecto esta basada en un script ant, entonces de las distintas posibilidad que disponemos, seleccionamos la opción Build a free-style software project y dejamos la opción de maven2 para otra ocación. Ya que estamos aquí, Copy existing job será muy útil para copiar una configuración de un job ya existente al job nuevo ( que deducción! XD ) y ahorrarnos trabajo repetitivo. Le asignamos un nombre al job y le damos al ok.

La configuración del job se divide en 5 secciones donde Hudson nos pide lo siguiente:

Dame información básica.
¿De donde obtengo el proyecto?
¿En que momento construyo el proyecto?
Dame una herramienta para la construya.
¿Que quieres que haga después de construir el proyecto?

Vamos a repasar cada una de las secciones:

Si nos concentramos en la sección superior, observamos que podemos llenar un campo de comentario con una descripción de la finalidad del job. Tambien existe un checkbox para indicar si queremos que los builds antiguos se vayan descartando, podemos definir esto por cantidad de días y/o por cantidad de builds. Esta última opción es la que siempre uso, manteniendo los últimos 10 builds. También disponemos de otro checkbox que deshabilita la ejecucion del job.

En la próxima sección Source Code Management, básicamente debemos elegir el sistema gestor de código fuente que posee nuestro repositorio de proyectos y definir la conexión al servidor. En principio solamente veremos las opciones CVS y Subversion ya que Hudson por defecto trae instalado y listo para usar plugins para conexión a estos dos servidores. Aunque además disponemos de plugins para Mercurial entre otros.

En la sección Build Triggers debemos definir el momento en que Hudson realizará el build. Por defecto existen tres formas distintas de realizar hasta acción (cuatro si incluimos el build now manual).
Una de las posibilidades es definir que se haga luego de finalizar otros build de proyectos, indicando el nombre de estos. Esto es muy útil si estamos definiendo un job para correr una completa bateria de tests pero siempre despues de que otro job complete la construcción de todo el proyecto. La segunda forma es encuestar el repositorio definido en la sección anterior cada cierto intervalo de tiempo, si se detectan cambios, se realizará el build. Por último se puede indicar que el build se haga periodicamente.
Para las últimas dos opciones la forma de indicar el tiempo es mediante cinco valores separados por espacios, siendo estos valores en orden: minuto, hora, dia del mes, mes, dia de la semana. Podemos usar el caracter comodín * para indicar "todos". Por ejemplo si queremos realizar builds nocturnos pasada media hora de la media noche todos los dias del mes, los valores a llenar en el campo Schedule podrían ser 29 23 * * * (los valores para minutos y dias, etc comienzan de 0).

Continuando con la próxima sección build, es aquí donde definimos la herramienta de construcción, en nuestro caso Ant. Especificando el target que queremos que corra o dejando el campo vacío para que corra el target por defecto. Además tenemos la potencia de ejecutar ordenes de un shell script o de batch script de Windows. Por ejemplo, podríamos invocar por shell script a la orden make makefile para construir un proyecto c/c+.

En la última sección podemos pedirle a Hudson que realize varias acciones luego de que finalize el build. Como muestra la imagen es posible retener artefactos indicando cuales son. Como por ejemplo archivos .exe .war . jar .zip o lo que fuese resultado del build. Además podemos hacer que se publique el javadoc (obviamente si es un proyecto Java) indicandole también donde se encuentra. Si lo deseamos, Hudson nos generará un reporte con el resultado de los test JUnit. Todas estas últimas acciones estan basadas en resultados ya generados en la etapa de build, en nuestro ejemplo con el script ant. Otra acción pos-build sencilla de activar es la de notificación por e-mail. Para esta sección disponemos de varios plugins extras sobre todo para reportes.

Con lo visto hasta aquí ya podemos hacer uso de Hudson de forma básica. En el próximo post comenzaremos a exprimir a Hudson. Ya saben... espero sus comentarios.

Exprimiendo a Hudson - Parte 2 (Administración)

2009-02-03T17:57:00.016-02:00

De retorno de mis vacaciones donde procure no interactuar con ningun tipo de tecnología más que la de una piedra/martillo para poder clavar las estacas de una carpa, intentare continuar con Hudson.

Ya hice publicidad de las bondades de Hudson a la hora de administrar y configurar el servidor, asi que este post será muy sencillo. Como si no fuera suficientemente fácil, veremos que la UI de Hudson nos proporciona ayuda continuamente.

Vemos que en la pantalla de administración entre otras operaciones se nos permite configurar el servidor y manejar los plugins de extenciones. Veamos como configurar el servidor:

Hudson permite la ejecución concurrente de builds. Se denomina "executor" a un hilo del servidor que puede realizar builds. Por eso se nos recomienda llenar el campo # of executors con la cantidad de procesadores que cuenta el equipo donde se esta corriendo Hudson.

Tenemos la posibilidad de marcar un checkbox para habilitar la seguridad. Esto permitira configurar o correr un nuevo build sólo a los que se logueen con un usuario con rol "admin". Si Hudson esta desplegado sobre Tomcat, los usuarios y roles estan definidos en el archivo $TOMCAT_HOME/conf/tomcat-users.xml . Podemos ver como editar éste archivo en la parte 1 de este tutorial.

Además de la concurrencia, tenemos la posibilidad de definir agentes "esclavos" del master. Esto nos permitira la ejecución de los builds de forma distribuida.

Cuando un esclavo se registra al master, el master comienza la distribución de las cargas a los esclavos. La carga será balanceada dependiendo de la configuración particular de cada Job. Algunos proyectos pueden optar a "pegarse" a una máquina en particular para hacer el build, mientras que otros podrán optar por balancear su carga libremente entre los esclavos definidos. En algún futuro post publicaré como configurar Hudson para realizar builds de forma distribuida, por ahora, aqui un tutorial para ir aprendendiendo esta técnica.

Tambien podemos definir los path y conexiones a distintas herramientas que Hudson eventualmente pueda utilizar. Los campos a llenar son las instalaciones del JDK, Ant, Maven, y definir las conexiones a un servidor CVS y a un servidor SMTP para notificaciones por e-mail.

Obviamente si usamos Subversion como repositorio de código fuente, no llenaremos los campos de CVS. De forma similar, si no nos gusta Maven y solo usamos Ant para programar nuestros script de builds, no es necesario definir una instalación de Maven.

Como vemos completar una configuración estándar del servidor es totalmente visual y sencilla.

Para la próxima aprenderemos a crear Jobs para realizar buids de proyectos. A no desesperar, el tunning avanzado para exprimir Hudson vendrá más adelante, cuando ya dominemos "de taquito una integración continua base con Hudson.

Exprimiendo a Hudson - Parte 1 (Instalación)

2009-01-23T20:21:00.024-02:00

Hudson es un CI Server o servidor de integración continua open source. Existen varios productos similares tales como Cruise Control o Continuum de Apache.
Lo que diferencia a Hudson del resto es su potencia mediante la extension por plugins y su facilidad de instalación, configuración y mantenimiento.

En esta primera entrega de una serie voy a explicar como desplegar Hudson en un Servidor Tomcat instalado en Ubuntu Intrepid Ibex, de todas formas en cualquier otra distro de Linux u otro S.O esto no debería ser muy diferente. En las próximas entradas veremos como integrar varias herramientas con los plugins de hudson para reporte de test, cobertura y análisis de código estático para métricas de QA.

Instalación:

Paso 1: Descargamos hudson.war desde el sitio oficial o desde este link. Podemos probar hudson iniciándolo con el servidor embebido que trae simplemente con la orden java -jar hudson.war
Paso 2: Para poder hacer uso de Hudson de forma profesional necesitamos desplegar el war en un contenedor de servlets/jsp como Tomcat. Necesitamos descargar los paquetes tomcat6 y tomcat6-admin. Esto podemos hacerlo desde el gestor de paquetes Synaptic o escribiendo en una terminal:

sudo apt-get install tomcat6 tomcat6-admin

Paso 3: Probamos si tomcat esta funcionando escribiendo en un browser: http://localhost:8080 . Si todo anda bien deberemos crear un usuario administrador con un rol. Para eso editamos el archivo tomcat-users.xml y luego reiniciamos el servidor:

sudo nano /var/lib/tomcat6/conf/tomcat-users.xml



<!--
<role rolename="tomcat"/>
<role rolename="role1"/>
<user username="tomcat" password="tomcat" roles="tomcat"/>
<user username="both" password="tomcat" roles="tomcat,role1"/>
<user username="role1" password="tomcat" roles="role1"/>
-->
<role rolename="manager"/>
<role rolename="admin"/>
<user username="user" password="secreto" roles="manager"/>
<user username="hudson-admin" password="secreto" roles="admin"/>
</tomcat-users>

Paso 4: Abrimos el administrador de Tomcat, aquí nos pedira el usuario y contraseña que recien agregamos en tomcat-users.xml. Para esto escribimos la siguiente direccion en el browser: http://localhost:8080/manager/html. En la sección apropiada agregamos el archivo hudson.war para poder desplegarlo en el contenedor.

Paso 5: Creamos el directorio de trabajo de Hudson y le otorgamos permisos:

sudo mkdir /home/hudson
sudo chmod 777 /home/hudson

Paso 6: En el archivo /etc/init.d/tomcat6 agregamos a la variable JAVA_OPTS la variable -DHUDSON_HOME con el valor del directorio de trabajo de hudson que definimos en el paso 5.

sudo gedit /etc/init.d/tomcat6

JAVA_OPTS="$JAVA_OPTS -Djava.endorsed.dirs=$CATALINA_HOME/endorsed -Dcatalina.base=$CATALINA_BASE -Dcatalina.home=$CATALINA_HOME -Djava.io.tmpdir=$CATALINA_BASE/temp -DHUDSON_HOME=/home/hudson"

Bueno...ahora el ultimo paso es probar si hudson esta andando escribiendo en el browser la dirección: http://localhost:8080/hudson

Espero que les sirva y ante algún problemita ya saben, escribanme preguntando que por ahí a mi ya me paso. Hasta la próxima entrega.

Subversion en Linux

2009-01-21T04:51:00.006-02:00

Para poder mantener controladas las versiones de los proyectos que estamos desarrollando existen los servidores de control de versiones. Uno de los mas populares es Subversion o svn.

Voy a explicar paso a paso como consumi un par de horas de mis vacaciones para instalar svn en mi Ubuntu 8.10. Abrimos una terminal y...

Instalamos los paquetes de subversion:

sudo apt-get install subversion subversion-tools

Si queremos "browsear" el repositorio necesitamos tener instalado y configurado un servidor Apache con el modulo dav y dav_svn, si no lo tenemos:

sudo apt-get install apache2 libapache_svn

Para poder otorgar permisos creamos un grupo llamado subversion:

sudo groupadd subversion

Agregamos un usuario:

sudo usermod -Gsubversion nombreusuario

Creamos un archivo con el usuario, luego nos pedira una contraseña

sudo htpasswd -c /etc/apache2/dav_svn.passwd nombreusuario

Creamos un directorio, indicamos el repositorio, y otorgamos permisos de grupo y de escritura:

sudo mkdir /home/svn/
sudo svnadmin create /home/svn/
sudo chown -R www-data:subversion /home/svn/
sudo chmod -R 770 /home/svn/

Editamos el archivo de configuración de Apache para svn:

sudo nano /etc/apache2/mods-available/dav_svn.conf

##
# SVN
#

DAV svn
SVNPath /home/svn
AuthType Basic
AuthName “Repositorio Subversion del proyecto”
AuthUserFile /etc/apache2/dav_svn.passwd

Require valid-user

Ahora solo nos queda reiniciar al sevidor Apache y verificar en un browser la dirección http://localhost/svn

sudo /etc/init.d/apache2 restart

Espero que este mini-tutorial les sea útil. Cualquier duda escriban comentarios.

Chatbots

2009-01-14T15:33:00.008-02:00

Continuando con la linea de IA retro me puse a investigar sobre la vida y logros de Joseph Weizenbaum, considerado el padre de la cibernetica. En 1966 Joseph Weizenbaum creo en el MIT un programita simple que lo llamo ELIZA, este programa intentaba mantener una conversación de texto coherente con un usuario. El usuario realizaba preguntas y ELIZA en rol de psicologa contestaba.

Luego ELIZA fue repudiado por su autor aclarando que sólo se trataba de una simulación de IA.

Pasemos al diván de ELIZA con este applet y dejemos que ella nos analize:

Eliza: Hi. I'm Eliza. Tell me your problems!
You : I am afraid
Eliza: How long are you afraid?
You : since last year
Eliza: Perhaps you would like to talk about a problem?
You : are you stupid?
Eliza: Why are you so interested wether I am stupid or not?
You : you are mother fucker
Eliza: Why do you think that I am mother fucker?
You : Fuck you!
Eliza: What does this mean for you, saying " Fuck me "?

El paciente se enojo por la corriente rogeriana de ELIZA :D y la mando a lavar los platos. Más alla de las palabras agresivas del paciente, podemos ver que cuando ELIZA encuentra una palabra en su diccionario responde con una pregunta preparada para esa palabra, como por ejemplo la tupla (afraid, How long are you afraid?). Cuando no encuentra alguna palabra clave, sólo responde con una pregunta lo suficientemente ambigua (a veces irritante) como para esconder su desconocimiento, concatenando además la frase del paciente.

Si te gusta Python aquí tienes otra implementación de ELIZA en éste lenguaje.

Aunque ELIZA no posee IA, dio inicio a una revolución en este campo. Les dejo algunos chatbots más modernos para que se diviertan un rato, algunos de ellos preparados para intentar pasar el Test de Turing:

Google y su Inteligencia Artificial

2009-01-13T21:51:00.011-02:00

Alan Turing en 1950 confecciono un test para medir la inteligencia de una máquina. La prueba consistía en que un jurado debía interactuar con una máquina y una persona, ambos ubicados en habitaciones distintas a la del juez. En la comunicación la máquina podía valerse de "trucos" para persuadir al juez que era una persona respondiendo preguntas. Si el juez no descubría quien era la persona y quien la máquina, la máquina superaba el test y se la podía considerar inteligente, hasta el momento ninguna ha podido superar este test con el rigor científico que Turing exigía.

Ahora bien. ¿Es suficiente definir la inteligencia artificial simplemente cuando esta no se diferencia de la Inteligencia humana?

Google indexa sus exabytes de información para sus búsquedas en base a mucha retroalimentación de los usuarios. Esta bien, además posee unos cuantos algoritmos. Pero lo que hace poderoso al superbuscador es esa enorme cantidad de información que entrena a lo que imagino seran perceptrones multicapa.

Consideremos lo siguiente: Si fuera posible anular el factor cansancio en un humano, este podría indexar toda esta información de forma similar a como lo hace Google sin mucha diferencia en el resultado final.

Entonces, un usuario del buscador no podría diferenciar si su búsqueda fue ordenada previamente por un ser humano o una máquina ¿Google pasaría el test de Turing? ¿El sistema de ordenado y disposición de la información de google es inteligente? Imagino que Turing diria que si.

PD: Si lo se, la imagen del Terminator es de lo mas amarillo :D

JNA: Invocando código nativo desde Java

2009-01-12T23:49:00.015-02:00

Para los que no lo conozcan, JNA (Java Native Access) es un proyecto del JDK-Incubator que nos proporciona un api para poder acceder a código nativo desde java. JNA Nos facilita y acelera el desarrollo al poder invocar funciones de librerías compartidas (.dll en Windows y .so en Linux) sin tener que usar JNI, ya que solamente debemos codificar en java implementando las interfaces y reglas que la api nos expone. La licencia de JNA es LGPL.

Veamos un ejemplo hola mundo escrito en consola por la función printf de la librería msvcrt si la plataforma es windows o la librería c en caso contrario:



import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Platform;

public class HelloWorld {

   public interface CLibrary extends Library {
       CLibrary INSTANCE = (CLibrary)Native.loadLibrary(
          (Platform.isWindows() ? "msvcrt" : "c"), 
          CLibrary.class);
  
       void printf(String format, Object... args);
   }

   public static void main(String[] args) {
       CLibrary.INSTANCE.printf("Hola mundo!\n");
       for (int i=0;i < args.length;i++) {
           CLibrary.INSTANCE.printf(
              "Argumento %d: %s\n", i, args[i]);
       }     
   } 
}

Pueden apreciar la simpleza con la que se "wrappea" la funcion printf de c. Noten que además de imprimir el clásico "hola mundo" se imprimen todos los argumentos pasados al metodo main utilizando el formateo que nos ofrece la funcion printf de c.

Esto es solo un ejemplo ilustrativo de uso, pero imaginen el potencial de facilidad que nos permite JNA al utilizar funciones de c en java comparando con el arduo trabajo que nos llevaría con JNI.

Llevo un tiempo utilizando JNA y aunque me he encontrado con un par de inconvenientes, pude dar resolución feliz a todo lo que quise "wrappear" a java desde librerías nativas. Hablo de invocar funciones pasando como parametros estructuras complejas, y parámetros por referencia para poder obtener retornos. Hasta ahora todo lo pude hacer y de forma simple. :)

Para finalizar, algunos proyectos que utilizan JNA:

JRuby (Charles Nutter)
Rococoa Java bindings to the Mac OS X Cocoa framework.
Freedom for Media in Java (FMJ) (Ken Larson/Dieter Krachtus)
gstreamer for Java (Wayne Meissner)
Videolan JVLC Java Multimedia Library
SVNKit pure Java Subversion client library.
OmegaT Computer-Aided Translation, which makes use of the hunspell spell checker.
IntelliJ IDEA (JetBrains)
NetBeans IDE
Drive Lego Mindstorm NXT (Emmanuel Pirsch)
Miscellaneous contributed mappings and utilities (including Windows NT Service, Registry, and User Account libraries).
A JavaFX Clock (Augusto Sellhorn)
Detect User Inactivity (Olivier Chafik)
Athena Backup (Doug Patriarche)
USB for Java (Mario Boikov)

Soporte mejorado de C/C++ en Netbeans 6.5

2009-01-12T01:43:00.012-02:00

- Mejoras del editor de código: Esto es lo mejorcito. Mejora el autocomplementado, mejora el resaltado de semántica y errores, identación y formateo automático, búsqueda de uso de variables locales y globales, funciones, clases, directivas de #includes, etc, refactoring de renombrado de variables y funciones.

- Mejor soporte a nivel de proyecto: Unos pocos cambios en las propiedades y configuración del proyecto, para linkear librerías dinámicas y estáticas.

- Grafo de llamados de funciones: Nos muestra una ventana con todas las llamadas a la función seleccionada.

- Ventana de Memoria: Nos muestra el contenido de las direcciones que están actualmente en uso.

- Desarrollo remoto: Esto no le he probado aún, pero promete definir host remotos y y poder realizar builds o correr proyectos desde el cliente.

-Empaquetado : Nos permite empaquetar las aplicaciones para distribuirlas en archivos tar, archivos zip, o paquetes SVR4.

Bueno, éstas son sólo las novedades en la versión 6.5, faltaron enunciar los features que se mantienen de las versiones anteriores.

Para la próxima entrada relacionada a C, estoy preparando un pequeño tutorial para explicar como preparar y configurar un ambiente de desarrollo de C/C++ con Netbeans y las tools GNU sobre Windows.

Python para todos!

2009-01-09T20:46:00.011-02:00

Estoy comenzando con Python y tengo que decirles que es el lenguaje de programación más parecido al lenguaje natural que he visto. Un código escrito en python es muy fácil de leer ya que se asemeja bastante al pseudocódigo. Además es muy entretenido y ameno aprenderlo. Como ejemplo de esto miren el siguiente código python:

edad = 0
while edad < 18

print "Tienes " + edad + " años."
edad = edad + 1

print "Ya eres mayor de edad."

Podemos además apreciar que los bloques estan limitados por la identación y no por las llaves { } como en C o Java o por palabras reservadas como begin end de Pascal.

Quiero recomendarles el siguiente libro pdf en castellano: Python para todos.

Para escribir los ejemplos estoy utilizando el interprete Jython y el plugin para netbeans 6.5 que pueden bajar del mismo Ide en Tool->Plugins. Aunque todavia este plugin es beta (al parecer tendra una liberación final junto con NB 7.0) alcanza para poder aprender y ejecutar ejemplos.

Cuando tenga mas novedades y aprenda más cosas sobre Python escribire una entrada con más recomendaciones.

Apertura del blog

2009-01-09T13:36:00.004-02:00

Antes que nada, bienvenidos a mi blog!

En este lugar encontraran información sobre tecnologia y programación. Publicare experiencias vividas en mi carrera que espero sirvan de ayuda a los demás.

Este blog va ser una forma de devolver el conocimiento de todo lo que he aprendido.

Espero que les sea grato y nuevamente bienvenidos!!!