Apache Abdera

Apache Abdera es una implementación open source de Atom. Aja, pero que es Atom?

El nombre Atom hace referencia a dos estándares relacionados.

• El Formato de Redifusión Atom es un fichero en formato XML usado para Redifusión web.
• mientras que el Protocolo de Publicación Atom (resumido en Inglés AtomPub o APP) es un protocolo simple basado en HTTP para crear o actualizar recursos en Web.

Las fuentes web permiten que los programas busquen actualizaciones del contenido publicado en un sitio Web. Para crear uno el propietario de un sitio Web puede usar software especializado, como un Sistema de gestión de contenido que publica una lista (o fuente web) de artículos recientes en un formato estándar, legible por máquinas. La fuente web puede ser descargada por sitios web que redifunden el contenido usando la fuente web, o por un agregador que permiten que los lectores en Internet se suscriban y vean los contenidos de la fuente web.

Una fuente web puede contener entradas, que pueden ser encabezados, artículos completos, resúmenes, y/o enlaces al contenido de un sitio web.

El formato Atom fue desarrollado como una alternativa a RSS. Ben Trott fue uno de los defensores del nuevo formato que llegó a llamarse Atom. Él notó la incompatibilidad entre algunas versiones del protocolo RSS, ya que pensaba que los protocolos de publicación basados en XML-RPC no eran lo suficientemente interoperables.

Los proponentes del nuevo formato organizaron el grupo de trabajo IETF Atom Publishing Format and Protocol. El formato de redifusión ATOM fue publicado como un "estándar propuesto" de la IETF en el RFC 4287, y el protocolo de cumunicación se publicó como RFC 5023.

Apache Abdera es un projecto para construir una implementación completa, performante de las especificaciones la IETF Atom Syndication Format (RFC 4287) y Atom Publishing Protocol (RFC 5023)

Apache Abdera esta todavia en la incubadora de apache.

Dejo un link a la wiki: http://cwiki.apache.org/confluence/display/ABDERA/Getting+Started

Netbeans y maven

La integración de maven con Netbeans fue por largo tiempo desarrollada por http://mevenide.codehaus.org ahora es desarrollada por netbeans.org y en Netbeans 7 es va a ser parte estándar de la distribución.

Si nosotros usamos eclipse por ejemplo debemos decirle a maven que genere los archivos para que eclipse entienda nuestro proyecto hecho con maven. Lo hacemos con mvn eclipse:eclipse, y si usamos jIdea idea:idea y si usamos netbeans no necesitamos hacer nada. Desde netbeans 6, Netbeans entiende los proyectos hechos en maven!!! Y no necesitamos un mvn netbeans:neatbeans.

Esto es un paso gigante hacia la estandarización de la estructura y archivos usados por las IDES.

Neatbeans hizo el primer paso...

Las demás IDES lo seguirán?

SQLite

SQLite es un sistema de gestión de bases de datos relacional compatible con ACID, y que está contenida en una relativamente pequeña (~225 kB¹ ) biblioteca en C. SQLite es un proyecto de dominio público creado por D. Richard Hipp.

A diferencia de los sistemas de gestión de base de datos cliente-servidor, el motor de SQLite no es un proceso independiente con el que el programa principal se comunica. En lugar de eso, la biblioteca SQLite se enlaza con el programa pasando a ser parte integral del mismo. El programa utiliza la funcionalidad de SQLite a través de llamadas simples a subrutinas y funciones. Esto reduce la latencia en el acceso a la base de datos, debido a que las llamadas a funciones son más eficientes que la comunicación entre procesos. El conjunto de la base de datos (definiciones, tablas, índices, y los propios datos), son guardados como un sólo fichero estándar en la máquina host. Este diseño simple se logra bloqueando todo el fichero de base de datos al principio de cada transacción.

En su versión 3, SQLite permite bases de datos de hasta 2 Terabytes de tamaño, y también permite la inclusión de campos tipo BLOB.

El autor de SQLite ofrece formación, contratos de soporte técnico y características adicionales como compresión y cifrado.

Si lo queremos usar en java solo tenemos que bajar la base del sitio oficial: http://www.sqlite.org

El primer paso para conectar java a sqlite es bajarse el driver JDBC del SQLite :

http://www.zentus.com/sqlitejdbc/

Luego nos podemos conectar con algo así:

Class.forName("org.sqlite.JDBC");

Connection conn = DriverManager.getConnection(”jdbc:sqlite:test.db”);

Para los curiosos dejo links:

* http://ifconfig.com.ar/programacion/sqlite-y-java/
* http://www.zentus.com/sqlitejdbc/
* http://sqlite-latino.blogspot.com/search/label/SQLite%20y%20Java
* http://nestedvm.ibex.org/
* http://es.wikipedia.org/wiki/SQLite

¿Cuáles son las principales diferencias entre un programador junior, un semi senior y un senior?

Que pregunta!!!
Tal ve la respuesta este aquí.

Se viene Spring fase 3.0

La gente de Spring Framework acaba de liberar Spring 3.0 release candidate. Esta versión tiene todas las características claves que formarán parte de Spring 3.0 final. Spring 3.0 RC1 trae muchísimos agregados y mejoras que vale la pena empezar a investigar. Veamos de qué estamos hablando...

Lo que se viene en Spring 3.0

* Completamente basado en Java 5. Esta la primer versión de Spring que necesita Java 5 o superior para funcionar, y que utiliza la sintáxis de Java 5 en todo el API de Spring, y también en su implementación. Por ejemplo, el API del BeanFactory retorna instancias tipadas con generics cuando es posible, y un ApplicationListener puede declarar tipos de eventos específicos con generics. En comparación, Spring 2.5 (la versión actual de Spring) todavía es compatible con el JDK 1.4, aunque mucha funcionalidad de alto nivel se construía en Java 5.

* Lenguaje de expresiones de Spring (SpEL - Spring Expression Language). Un parser de expresiones para usar en la definición de los beans, que permite referenciar a estructuras anidadas (por ejemplo, propiedades de otros beans), y también a estructuras del sistema (por ejemplo, variables de entorno) usando la sintáxis común #{...} en el valor de las propiedaes de un bean. Esto también sirve como base para otras características basadas en expresiones en otros proyectos de Spring.

* Soporte extendido para componentes basados en anotaciones. Se incluye el concepto de clases de configuración y métodos de factory anotados - ¡las características fundamentales del proyecto Spring JavaConfig finalmente están disponibles en Spring!. Sprint también permite inyectar valores de configuración a través de expresiones @Value, y referirse a valores de la configuración usando expresiones dinámicas #{...} o estáticas ${...}.

* Modelo de estereotipos. Permite crear anotaciones "de atajo" a través del uso de meta-anotaciones. Por ejemplo, para determinar scopes predeterminados o características de transacción predeterminadas en estereotipos propios. Imaginen una anotación propia @MiServicio que indica @Service, @Scope("request") y @Transactional(readOnly=true) usando una única anotación. Este es el principio de No Repetirse aplicado al uso de anotaciones de componentes.

* Anotaciones de inyección de dependencias estándar. Spring 3.0 provee un soporte inicial para el JSR-330 specification for Dependency Injection in Java- inyección a través de anotaciones usando javax.inject.Inject y sus calificadores asociados y modelo de proveedores, como una forma alternativa a la anotación @Autowired propia de Spring. Tengan en cuenta que el JSR-330 todavía no está terminado; el soporte para javax.inject en Spring se irá completando a medida que madure la especificación.

* Modelo de validaciones declarativo basado en anotaciones de restricciones. Configuración al estilo de Spring de un proveedor de JSR-303 Bean Validation (como ser, Hibernate Validator 4.0). Spring 3.0 viene con una opción para hacer validaciones basadas en anotaciones en Spring MVC, exponiendo una vista unificada cuando no se cumplen las restricciones. Tengan en cuenta que el JSR-303 está próximo a terminarse, aunque todavía puede tener modificaciones.

* Soporte para REST extendido. Soporte nativo para REST en Spring MVC, como ser mapeos de peticiones REST, extracción de variables URI a través de parámetros @PathVariable, y resolución de vistas guiadas por la negociación del contenido. Imaginen Spring MVC 2.5 con soporte de primera clase para REST - y manteniendo en enfoque de MVC. Hay soporte para el lado del cliente de REST a través de la clase RestTemplate.

* Mapeo Objeto/XML (OXM). Tal como se usaba en Spring Web Services, ahora dentro del núcleo de Spring Framework. Abstracciones para el marshalling y unmarshalling con soporte directo para JAXB 2, Castor, etc. Se provee opciones de integración para soporte de contenidos XML en Spring MVC y Spring JMS.

* Soporte para Portlet 2.0. Spring MVC soporta completamente los entorno de Portlet 2.0 y el nuevo modelo de recursos y eventos de Portlet 2.0. Se incluyen facilidades de mapeo para peticiones de portlet típicas: @ActionMapping, @RenderMapping, @ResourceMapping, @EventMapping.
* Nuevo sistema de scheduling. Nuevos mecanismos de TaskScheduler y Trigger con soporte estilo cron, alineados con el mecanismo de Spring TaskExecutor. Spring 3.0 provee un namespace que soporta anotaciones @Async y @Scheduled. Esto se puede ejecutar sobre pooles nativos de hilos o en pooles manejados por Servidores de Aplicaciones, incluyendo soporte para los servidores de aplicaciones Java EE más populares.

* Y por último, soporte inicial para Java EE 6. Spring 3.0 soporte el uso de JSF 2.0 y JPA 2.0 dentro de Spring, junto al soporte de JSR-303 y JSR-330. Se irá incluyendo soporte para otras tecnologías de Java EE 6 (como Servlet 3.0) a medida que se vayan concretando los productos.

Para seguir investigando Spring 3.0 RC1 pueden leer la sección sobre configuración basada en anotaciones, y el nuevo capítulo de validaciones declarativas. También les puede interesar las nuevas características de formateo en formateo de campos basado en anotaciones.

db4o

DB4O es un novedoso motor de base de datos orientada a objetos. Sus siglas se corresponden con la expresión "DataBase 4 (for) Objects", que a su vez es el nombre de la compañía que lo desarrolla: db4objects, Inc.

DB4O es:

• Nativa a Java y .NET

• 100% orientada a objetos, sin mapeo objeto-relacional

• Diseñada para uso embebido

• De código abierto y libre bajo la GPL

Las claves innovadoras de este producto es su alto rendimiento (sobre todo en modo embebido) y el modelo de desarrollo que proporciona a las aplicaciones para su capa de acceso a datos, el cual propugna un abandono completo del paradigma relacional de las bases de datos tradicionales.

De este modo, tenemos las siguientes consecuencias directas resultantes de este nuevo paradigma:

• Deja de existir un lenguaje SQL de consultas/modificaciones para pasar a crearse sistemas de consulta por métodos delegados y actualización/creación/borrado automático de entidades mediante código compilable.

• Se elimina la necesidad de representar el modelo de datos de la aplicación en dos tipos de esquemas: modelo de objetos y modelo relacional. Ahora el esquema de datos del dominio viene representado por la implementación que se realice del diagrama de clases.

• Se consigue evitar el problema del Object-Relational Impedance Mismatch sin sacrificar el rendimiento que los mapeadores objeto-relacionales sufren actualmente para llevar a cabo el mismo objetivo.

La mayor clave del éxito que está teniendo este motor de base de datos frente a otros competidores que han desarrollado tecnologías similares, es que se ha optado por un modelo de licenciamiento idéntico al utilizado por empresas como MySQL: licencia dual GPL/comercial. Es decir, si se quiere desarrollar software libre con esta librería, su uso no conlleva ningún coste por licencia; sin embargo si se desea aplicar a un software privativo, se aplica otro modelo de licenciamiento concreto.

Actualmente este producto funciona como una librería para dos tipos de plataformas de desarrollo: Java y.NET (tanto la implementación de Microsoft como la de Mono).

Dejo unos links que contienen todo lo que hay que saber de este producto:

http://javahispano.org/contenidos/es/db4o/;jsessionid=E73763B425065DA17545394C602338EA

http://www.programacion.com/java/articulo/jap_persis_db4o/

http://developer.db4o.com/forums/storage/15/33746/50-54%20code34%20Architecture.pdf

Y para todos los araganes que no quieren buscar o leer, dejo un ejemplito:

La clase Player

public class Player {         

    protected String name;    

    protected int squadNumber;

    protected float battingAverage;

    protected Team team;

   

    public Player(String name, int squadNumber, float battingAverage){

         this.name = name;

         this.squadNumber = squadNumber;

         this.battingAverage = battingAverage;    

    }         



    //Geters and seters

        

    public String toString() {

         return name + ":" + battingAverage;    

    }

}

La clase Pitcher

public class Pitcher extends Player {

     private int wins;

  

    public Pitcher(String name, int squadNumber, float battingAverage, int wins) {

           super(name,squadNumber,battingAverage);

           this.wins = wins;

    }      



    //Geter y seter para wins



    public String toString() {

            return name + ":" + battingAverage + ", " + wins;

    }

}

La clase Team

import java.util.List;

import java.util.ArrayList; 



public class Team {         



    private String name;    

    private String city;    

    private int won;    

    private int lost;

    private List players;         



    public Team(String name, String city, int won, int lost){

        this.name = name;

        this.city = city;

        this.won = won;

        this.lost = lost;

        this.players = new ArrayList();

    }        



   public void addPlayer(Player p) {        

       players.add(p);    

   }  



   // Geters y seters



   public String toString() {

       return name;

    } 

}

Primero, creamos algunos datos de prueba con los que trabajar:

// Create Players

Player p1 = new Player("Barry Bonds", 25, 0.362f);

Player p2 = new Player("Marquis Grissom", 9, 0.279f);

Player p3 = new Player("Ray Durham", 5, 0.282f);

Player p4 = new Player("Adrian Beltre", 29, 0.334f);

Player p5 = new Player("Cesar Izturis", 3, 0.288f);

Player p6 = new Player("Shawn Green", 15, 0.266f);         



// Create Pitchers



Player p7 = new Pitcher("Kirk Rueter",46, 0.131f, 9);

Player p8 = new Pitcher("Kazuhisa Ishii",17, 0.127f, 13);         



// Create Teams



Team t1 = new Team("Giants", "San Francisco", 91, 71);

Team t2 = new Team("Dodgers", "Los Angeles", 93, 69);         



// Add Players to Teams



t1.addPlayer(p1);

p1.setTeam(t1);

t1.addPlayer(p2);

p2.setTeam(t1);

t1.addPlayer(p3);

p3.setTeam(t1);

t2.addPlayer(p4);

p4.setTeam(t2);

t2.addPlayer(p5);

p5.setTeam(t2);

t2.addPlayer(p6);

p6.setTeam(t2);         



// Add Pitchers to Teams



t1.addPlayer(p7);

p7.setTeam(t1);

t2.addPlayer(p8);

p8.setTeam(t2);

Un objeto Team se puede almacenar con una sóla línea de código:

db.set(t1);

db.set(t2);

db.commit();

Donde db es una referencia a un objeto ObjectContainer, que se haya creado abriendo un fichero de base de datos, de esta forma:

ObjectContainer db = Db4o.openFile(filename);

Una base de datos db4o es un único fichero con una extensión .yap, y se utiliza su método set para almacenar objetos.

Observe que está linea almacena el objeto Team y su colección de objetos Player. Se puede probar esto recuperando uno de esos objetos Player. La forma más simple de hacer esto es utilizando QBE.

Player examplePlayer = new Player("Barry Bonds",0,0f);

ObjectSet result=db.get(examplePlayer);         

System.out.println(result.size());



while(result.hasNext()) {    

    System.out.println(result.next());

}

Neo4j

Neo4j es una graph database. Es un motor de persistencia transaccional que guarda las estructuras de datos en graph. Graph en la jerga de red es una estructura flexible que permite más agilidad y flexibilidad al desarrollador.

Podemos pensar en neo4j como un motor de persistencia de alta performance con todas las características de una base de datos robusta. Al ser más flexible que las tablas permite a los desarrolladores más libertad a la hora de diseñar sus objetos con la tranquilidad de ser soportado por una motor de persistencia con las características de una dase de datos.

Neo4j es un producto open source aun que cuenta con una licencia comercial.

Entre las características de neo4j podemos citar: transacciones ACID, control de concurrencia y todo lo que una base de datos empresarial.

Veamos un ejemplo que nos proporciona el sitio oficial:

package org.neo4j.example.helloworld;

import org.neo4j.api.core.*;

/**
* Example class that constructs a simple node space with message attributes and then prints them.
*/
public class NeoTest {

public enum MyRelationshipTypes implements RelationshipType {
KNOWS
}

public static void main(String[] args) {
NeoService neo = new EmbeddedNeo("var/base");


Transaction tx = neo.beginTx();
try {
Node firstNode = neo.createNode();
Node secondNode = neo.createNode();
Relationship relationship = firstNode.createRelationshipTo(secondNode, MyRelationshipTypes.KNOWS);

firstNode.setProperty("message", "Hello, ");
secondNode.setProperty("message", "world!");
relationship.setProperty("message", "brave Neo ");
tx.success();

System.out.print(firstNode.getProperty("message"));
System.out.print(relationship.getProperty("message"));
System.out.print(secondNode.getProperty("message"));
}
finally {
tx.finish();
neo.shutdown();
}
}
}

NoSql

Una reunión en San Francisco fue la inauguración de la comunidad de NoSQL, un grupo de personas que comparten la idea de destronar la tiranía de las bases de datos relaciones, costosas y lentas, en favor de una alternativa mucho más eficiente y barata para manipular datos.

Los miembros de esta comunidad comparten una visión común en cuanto a que los sistemas de bases de datos relacionales (RDBMS) clásicos son lentos, complejos, caros e ineficientes para muchos de los problemas existentes en las aplicaciones de Internet actuales, especialmente en el ámbito de la Web 2.0 y las redes sociales. Frente a estos sistemas clásicos, proponen la utilización de sistemas más eficientes y baratos para gestionar la información, como los almacenes de datos basados en clave-valor como BigTable (Google) o Cassandra (Facebook), o incluso almacenes en memoria como Memcached, la utilización de shardings sobre estos almacenes para ofrecer almacenamiento distribuido, y sistemas como Hadoop que permitan el trabajo sobre estos almacenes distribuidos.

"Las bases de datos relaciones nos ofrecen demasiado. Nos fuerzan a adaptar nuestros objetos para adaptarlos a una RDBMS (sistema de gestión de bases de datos relacional)", dice Jon Travis, uno de los principales ingenieros en SpringSource, y uno de los 10 presentadores en la reunión de NoSQL.

Las alternativas basadas en NoSQL "te ofrecen sólo lo que necesitás", dice Travis.

Surge el código abierto

Los primeros precursores son desarrolladores Web y Java, muchos de los cuales aprendieron a llevar adelante sus iniciativas (ajustadas en presupuesto) sin usar Oracle. Para esto construyeron sus propias soluciones para almacenar datos (emulando lo que hicieron Google y Amazon), y luego las publicaron como código abierto.

Hoy estas soluciones gestionan terabytes e incluso petabytes de datos para la Web 2.0, y ya no es factible volver atrás, por motivos técnicos, económicos e incluso ideológicos.

"Las empresas Web 2.0 pueden tomar riesgos y necesitan escalabilidad", dice Johan Oskarsson, el organizador de la reunión NoSQL y, como la mayoría de los participantes, un desarrollador Web (del sitio Last.fm). "Cuando se combinan estas dos cosas, hace que NoSQL sea una muy buena alternativa".

Muchos, dice Oskarsson, dejaron de usar la base de datos MySQL, una favorita de la Web 2.0 por mucho tiempo, en favor de una alternativa NoSQL porque las ventajas eran demasiado grandes para ignorar.

Por ejemplo, Facebok creó su almacen de datos Cassandra para soportar una nueva búsqueda en su sitio web, en vez de usar su base de datos MySQL existente. De acuerdo a la presentación del ingeniero de Facebook Avinash Lakshman, Casandra puede escribir hasta 50GB de datos en disco en tan sólo 0.12 milisegundos, más de 2500 veces más rápido que MySQL.

¿Y qué es NoSQL? (técnicamente hablando)

Los nombres de los proyectos son tan diversos como extraños: Hadoop, Voldemort, Dynomite, y otros. Pero suelen estar unificados por algunos puntos en común, incluyendo:

No llamarlos "bases de datos". Werner Vogels, CTO de Amazon, se refiere a su sistema Dynamocomo "un almacenamiento de clave-valor de alta disponibilidad". Google llama a su BigTable, otro de los modelos para muchos simpatizantes de NoSQL, "un sistema de almacenamiento distribuido para gestionar datos estructurados".

Pueden manejar enormes cantidades de datos. Hypertable, una implementación de código abierto basada en BigTable, se usa dentro del motor de búsqueda Zvents para escribir 1000 millones de celdas de datos por día, según cuenta el ingeniero Doug Judd en su presentación.

A su vez, BigTable, en conjunto con su tecnología hermana MapReduce, procesa hasta 20 petabytes de datos por día.

"Definitivamente la cantidad de datos es tan grande que las personas están buscando otras tecnologías", dice Travis de SpringSource, que con su tecnología VPork ayuda a los usuarios de NoSQL a realizar benchmarks de rendimiento de sus bases de datos alternativas.

Se ejecutan en clusters de servidores de PC baratas. Los clusters de PC se pueden expandir de forma facil y barata sin la complejidad y el costo del "data sharding", que involucra recortar una base de datos en múltiples tablas para ejecutarse en grandes clusters o grillas.

Google cuenta que uno de sus clusters de BigTable más grande gestiona 6 petabytes de datos sobre miles de servidores.

"Oracle te va a decir que con el hardware y la configuración adecuada de Oracle RAC (Real Application Clusters) y algún otro software mágico pueden lograr la misma escalabilidad. ¿Pero a qué costo?", pregunta Javier Soltero, CTO de SpringSource.

Superan los cuellos de botella de rendimiento. Al no tener que realizar la traducción de datos hacia un formato amigable para SQL, las arquitecturas NoSQL son mucho más rápidas.

"SQL es un enfoque extraño para el código procedural, y casi todo el código es procedural", dice Curt Monash, un analista independiente de bases de datos y blogger. "El costo de mapear los datos a SQL puede valer la pena para los casos en que estos datos tengan que manipularse extensivamente... pero cuando la estructura de la base de datos es muy simple, SQL no parece ayudar".

Raffaele Sena, de Adobe Systems, dice que Adobe relanzó su servicio colaborativo ConnectNow Web hace un año y medio, y decidió no usar una base de datos por los motivos explicados por Monash.

Adobe usa Terracotta, un software Java para clustering, para gestionar los datos en formato Java. Sena explica que este enfoque es la clave por la cual el rendimiento de ConnectNow es dos a tres veces superior a la versión anterior. "El sistema hubiera sido mucho más complejo y dificil de desarrollar con una base de datos", dice.

Otro proyecto, MongoDB, se llama a si mismo "base de datos orientada a documentos" por su almacenamiento nativo de datos de tipo objeto.

Sólo lo necesario. Quienes impulsan NoSQL admiten que las bases de datos tienen características únicas y una reputación sólida para la integridad de datos, pero explican que todo esto puede resultar demasiado para sus necesidades.

Tomemos por ejemplo a ConnectNow que, incluso sin una base de datos, hace tres copias de los datos de la sesión del usuario mientras está online - datos que luego son borrados cuando el usuario se desconecta, dice Sena. "No necesitamos una base de datos, ya que la mejor representación de los datos ya están en memoria", dice.

Soporte de la comunidad

Por ser de código abierto, las alternativas de NoSQL no suelen tener el mismo soporte que otros proveedores tradicionales. Para la mayoría de los entusiastas de NoSQL esto no es un problema, ya que están acostumbrados a trabajar con enfoques alternativos.

Pero algunos admiten que puede causar miedo trabajar sin "un cuello para ahorcar" cuando las cosas salen mal, especialmente para los gerentes.

"Tuvimos que salir a vender la propuesta", admite Sena de Adobe. "Pero básicamente, después de ver que nuestro primer prototipo funcionaba, pudimos convencer a la alta gerencia que este era el camino correcto".

A pesar de todo el potencial, la mayoría de las organizaciones todavía no necesitan preocuparse por lo que se pierden, dice Monash.

"La mayoría de las organizaciones grandes ya tienen una forma de hacer OLTP (procesamiento de transacciones online), probablemente a través de sistemas de bases de datos. ¿Por qué cambiar?", dice. MapReduce y otros proyectos "puede ayudar a las organizaciones. Pero probablemente debería integrarse a una DBMS analítica".

Incluso Orkarsson, el organizador de NoSQL, admite que su compania, Last.fm, todavía no migró a una alternativa NoSQL, y en cambio usa bases de datos de código abierto. Por ahora, la revolución está esperando.

"Es verdad que hoy NoSQL no es muy relevante para la mayoría de las organizaciones", dice Orkarsson. "Pero esto podría cambiar en los próximos dos años".

Noop

Noop es un nuevo lenguaje java que corre sobre JVM y además es de google. Este lenguaje tiene sintaxis similar a Java pero agrega algunas ventajas. Como por ejemplo la inyección de dependencias nativa en el lenguaje.

Su enfoque a la inyección de dependencias se basa en que una clase se puede crear de dos formas: a partir de objetos que el inyector puede proveer o a partir de a creación de dichos objetos en tiempo de ejecución ( usando new ), pero nunca a partir de una mezcla de ambos. Puedes leer los detalles de como piensan implementar esta funcionalidad en el wiki del proyecto.

Además del tema de Testability y la DI, Noop busca simplificar la programación para la JVM atacando casos comunes desde el core como la gestión de Nulls e impulsando las buenas prácticas de programación como favorecer la composición sobre la herencia. Características que a mi parecer lo hacen una opción interesante para mejorar la calidad de los desarrollos.

El proyecto esa en su fase inicial, pero ya puedes descargar la versión 0.1 para empezar a probarla. Algo interesante del lenguaje, es que además de proporcionar un intérprete para ejecución del lenguaje y un compilador a Byte Code (como lo hacen otros lenguajes de la JVM), también incluyen un "Traductor" cuyo propósito es generar código java a partir de Noop para permitir codificar en este lenguaje aunque tus proyectos sean 100% Java.

Las novedades del JDK 7

Las novedades del JDK 7 serán:

• Switch con objetos de tipo String
• Gestión automática de recursos
• Mejoras en la inferencia de tipos para la creación de Generics
• Invocación de métodos con varargs simplificada
• Mejoras en los literales numéricos
• Soporte en el lenguaje para Collections
• Soporte en el lenguaje para JSR 292

Tiene un Plan!!

Oracle publico el siguiente aviso en el cual no habla de java, y reta a IBM! Saquen sus propias conclusiones.

Hitler se entera que Oracle Compro Sun Microsystems

Lenguajes Scripts en Spring.

La desventaja de los lenguajes compilados, es que si quisiéramos hacer un cambio, para que se aplique este cambio hay que volver a compilar. No estoy diciendo nada nuevo, en java por ejemplo se usan archivos xml para hacer dinámicamente cambios. Hay situaciones en las cuales necesitamos hacer cambios dinámicos en nuestra aplicación pero no podemos recompilar. La solución es cantada usar algún lenguaje script.

Imaginemos que tengo toda mi arquitectura en java, y se nos presenta el problema anterior. Bueno spring nos permite ejecutar beans escritos en lenguaje script.

Vamos a desarrollar un ejemplo. Vamos a programar el famoso saludador:

package com.emanuel.prueba;

public class Saludador {

public void saludar {

this.saludo.decirHola();

}

private Saludo saludo;

public void setSaludo(Saludo saludo) {

this.saludo = saludo;

}

}

El Saludador tiene un Saludo el cual se inyecta con spring.

package com.emanuel.prueba;

public interfaz Saludo {

void decirHola();

}

Ahora inyectémosle al Saludador el Saludo.

<bean id=”elSaludador” class=”com.emanuel.prueba.Saludador” >

<property name=”saludo” ref=”saludo” />

< /bean>

Hasta ahora no hemos hecho nada nuevo, lo único que nos falta es implementar la interfaz Saludo, y lo vamos a hacer en JRuby.

Para programar beans scripts spring nos permite elegir entra JRuby, Groovy , BenShell y Jython. Para el ejemplo voy a usar JRuby:

class Saludo

def decirHola

puts “Holasssss amigos”

end

end

Saludo.new

Una cosa muy importante es la ultima línea ya que es lo que nos va a dar una instancia de Saludo. Ahora a decirle a spring que tenemos nuestro bean implementado con otro JRuby.

< beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:lang="http://www.springframework.org/schema/lang"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

http://www.springframework.org/schema/lang

http://www.springframework.org/schema/lang/spring-lang-2.0.xsd">

< lang:jruby id="saludo"

script-source="classpath:dondeDejeElarchivo/saludo.rb "

script-interfaces=” com.emanuel.prueba.Saludo”

refresh-check-delay=”5000” />

< /beans>

Y listo!!

Existe un tag para cada lenguaje: lang:jruby, lang:groovy, lang:bsh, etc.

El atributo refresh-check-delay indica cada cuantos mili segundos se va a actualizar el codigo, lo que permitira que nuestros cambios se vean reflejados.

Todo esto lo podemos hacer gracias a la magia de spring!!!

Inciclopedia

Navegando sin rumbo me encontré con la inciclopedia es un lugar donde la gente escribe definiciones graciosas y artículos con humor.

El grado de delirio de la página la hace muy interesante, dejo el link: http://inciclopedia.wikia.com/wiki/Portada y para aquellos que quieran escribir pueden leer los consejos de cómo escribir aquí: http://inciclopedia.wikia.com/wiki/CSDYNE