¿Qué son los DSL?

Los DSLs son lenguajes de programación especialmente diseñados para desarrollar software restringido a un dominio determinado. A diferencia de los lenguajes llamados de propósito general como Java, C++ o C#, los DSLs cuentan con un universo limitado de aplicación. No obstante, gracias precisamente a esta especialización, presentan facilidades y ventajas a la hora de abordar los problemas de software para los que fueron diseñados y desarrollados.

Java usa muchos DSL basados en xml, por ejemplo struts usa un dsl para definir el workflow de sus paginas, es mucho más fácil y flexible que hacerlo con java. Los archivos .properties tambien son un ejemplo dsl, con un universo muy limitado pero que resulta mucho más facil que hacerlo con XML o java.

Para definir e implementar lenguajes DSL es posible basarnos en un lenguaje de propósito general que sirva como contenedor, o bien partir de cero, requiriendo en este caso de específicos compiladores o intérpretes. Los DSLs del primer tipo citado suelen denominarse DSLs internos dejando la categoría de externos para los del segundo tipo.

Los Internal DSL: están escritos en el propio lenguaje padre. Son basicamente lo que siempre hemos conocido como “API” aunque utilizando “fluent interface” y atendiendo más a la semántica de los métodos. Un ejemplo en Java sería la generación de SQL por parte de Hibernate:

SQLQuery sql = new SQLQuery();
sql.Select("Id").Select("FirstName").Select("LastName").From("Person").Where("Id = 1").Where("FirstName = 'Chris'").OrderBy("LastName").OrderBy("FirstName");
string strSqlString = sql.ToString();

Los External DSL: No están escritos en el mismo Java. Se utiliza un lenguaje externo. En el caso de Java han triunfado especialmente los External DSL escritos en XML. Un caso sería el MVC de Struts, que se declara así:

<action-mappings >

<action path="/listar" type="org.springframework.web.struts.DelegatingActionProxy">

<forward name="listar" path="lista.aplicaciones"/>

</action>

<action path="/formularioNuevaAplicacion" type="org.springframework.web.struts.DelegatingActionProxy">

<forward name="mostrar" path="nueva.aplicacion"/>

</action>

<action path="/nuevaAyuda" attribute="aplicacionForm" name="aplicacionForm" type="org.springframework.web.struts.DelegatingActionProxy" scope="request" input="nueva.aplicacion">

<forward name="nueva" path="/listar.do"/>

</action>

</action-mappings>

Usamos DSL todo el tiempo y ni sabia :|

Groovy

Groovy es como el java del siglo XXI, es un lenguaje script basado en java que toma características de Python, Ruby, Perl y Smalltalk. La especificación JSR 241 se encarga de su estandarización para una futura inclusión como componente oficial de la plataforma Java.

Java no es el único que piede ejecutarse dentro de una JVM (máquina virtual Java). Resulta que Groovy es uno de esos lenguajes dinámicos ejecutables en una JVM, que a diferencia de los otros como lo son JRuby, Jython y Scala, posee un grado muy alto de cercanía con el lenguage Java y al mismo tiempo posee características únicas. Continúa leyendo para saber mas sobre este lenguage y lo que puede ofrecerte.

Groovy usa una sintaxis muy parecida a Java, comparte el mismo modelo de objetos, de hilos y de seguridad. Desde Groovy se puede acceder directamente a todas las API existentes en Java. El bytecode generado en el proceso de compilación es totalmente compatible con el generado por el lenguaje Java para la Java Virtual Machine (JVM), por tanto puede usarse directamente en cualquier aplicacion Java. Todo lo anterior unido a que la mayor parte de código escrito en Java es totalmente válido en Groovy hacen que este lenguaje sea de muy fácil adopción para programadores Java; la curva de aprendizaje se reduce mucho en comparación con otros lenguajes que generan bytecode para la JVM, tales como Jython o JRuby. Groovy puede usarse también de manera dinámica como un lenguaje de scripting.

Veamos unos ejemplos de la pagina oficial de groovy:

Simple "Hola mundo":

def name='World'; println "Hello $name!"

Un "hola mundo" más complicado:

import static org.apache.commons.lang.WordUtils.* 
class Greeter {
  Greeter(who) { name = capitalize(who) }
  def salute() { println "Hello $name!" }
}  
new Greeter('world').salute()

Los problemas evolucionan por lo tanto las soluciones también deben evolucionar. La evolución natural de java es Groovy!

jar with dependencies

Como hacer un jar con todas las dependencias listo para entregar el cliente y quedar como un duque y exitoso desarrollador?

Es fácil...

Con Maven, lo más grande que hay!!

Lo que tenemos que hacer es configurar un plugin como este:

<plugin>

<artifactId>maven-assembly-plugin</artifactId>

<configuration>

<archive>

<manifest>

<addClasspath>true</addClasspath>

<classpathPrefix>lib</classpathPrefix>

<mainClass>com.paquete.elNombreDeMiApp</mainClass>

</manifest>

</archive>

<descriptorRefs>

<descriptorRef>jar-with-dependencies</descriptorRef>

</descriptorRefs>

</configuration>

<executions>

<execution>

<id>make-assembly</id> <!-- this is used for inheritance merges -->

<phase>package</phase> <!-- append to the packaging phase. -->

<goals>

<goal>single</goal> <!-- goals == mojos -->

</goals>

</execution>

</executions>

</plugin>

Y listo!!

maven y netbeans segunda parte

Como dije en un post anterior netbeans permite importar proyectos maven como nativos.

Para ejecutar estos proyectos crea un archivo nbactions.xml donde podemos indicar a netbaans como ejecutar nuestro proyecto, miren este ejemplo:

<action>

<actionName>run</actionName>

<goals>

<goal>package</goal>

<goal>org.codehaus.mojo:exec-maven-plugin:1.1.1:exec</goal>

</goals>

<properties>

<exec.workingdir>${project.build.directory}</exec.workingdir>

<exec.args>-jar ${project.build.finalName}-jar-with-dependencies.jar</exec.args>

<exec.executable>java</exec.executable>

</properties>

</action>

<action>

Aca le indico a netbeans que ejecute la tarea exec de maven de un proyecto jar que es nombreDelProyecto-jar-with-dependencies.jar

Creo que es muy flexible. Maven con netbeans es una avión!!!

El disco más vendido de la Argentina

Escuche en la radio que el disco más vendido de rock nacional era "Alta suciedad" (un discaso) pero yo estaba seguro que era el amor despues del amor de fitito Paez y por suerte no estaba equivocado.

"Alta suciedad" de Andres Calamaro es el segundo. El disco superó las 500.000 copias vendidas en todo el mundo (el segundo disco más vendido del rock argentino justo después de El amor después del amor de Fito Páez que alcanzó las 750.000 copias vendidas) y llevó al músico a realizar gran cantidad de recitales, en los cuales compartió el escenario con músicos como en grande ,Fito Páez y Joaquín Sabina, entre otros.

Este regreso post-Rodríguez fue perfecto y diez años después (2007) Alta suciedad sería ubicado en el décimo puesto por 180 músicos y periodistas musicales en lo que serían Los 100 mejores álbumes del rock argentino según Rolling Stone.

Entonces el más vendido es "El amor despues del amor" me quedo tranquilo, en realidad me queda la duda si Calamarico supero a Fitito. Por eso si saben algo comenten!!

JetBrains libera IntelliJIdea!!!

JetBrains libera IntelliJIdea Community Edition con licencia Apache.

No es la IDE en totalidad sino una versión menor, pero esta bueno para probar y siempre a la larga los productos open source son mejores y más completos que los primitivos.

Dejo link para descargar: http://www.jetbrains.org/display/IJOS/Download

y algo de info: http://www.jetbrains.org/pages/viewpage.action?pageId=983211

Hadoop HBase

HBase es como el BigTable de google pero libre :D

Mas específicamente, HBase es una base de datos distribuida que permite escalar casi linealmente con simplemente agregar mas servidores al sistema. Para esto HBase puede utilizar opcionalmente una tecnología llamada HDFS (Hadoop Distributed File System) que básicamente es el análogo del GFS (Google File System), que no es mas que un fichero de archivos distribuidos.

Con esta arquitectura es posible lograr no solo altos niveles de rendimiento, sino que además altos niveles de redundancia en datos, ya que a cierto nivel los datos están distribuidos de manera redundante similar a como los datos son distribuidos en un sistema de discos duros con tecnología RAID 5 por ejemplo (aunque esta funcionalidad tengo que aun verificarla personalmente, pero sepan que es parte al menos del concepto original).

Algo importante a notar aquí es que si algo hemos aprendido del Internet, y en particular de Aplicaciones Web, es que en muchos casos la demanda de usuarios es impredecible, en donde una pequeña empresa con una gran idea puede de la noche a la mañana recibir millones de visitas, y para eso mejor estar preparado que perder esas visitas, y es ahí en donde se le verá la importancia a HBase.

Sin embargo, HBase no es solo una base de datos altamente escalable, sino que además es un nuevo paradigma que por fin quizás deje atrás las bases de datos relacionales en muchos casos típicos.

Por décadas hemos dependido de bases de datos relacionales, y estas han sobrevivido las bases de datos de objetos, de XML, y toda variedad bajo el sol, pero gracias a las lecciones que Google le ha dado al mercado con su infraestructura, se ha hecho evidente que esta nueva filosofía de diseñar bases de datos es quizás la mas adaptable para las necesidades de hoy en Internet.

Sin embargo, hay que entender que aunque HBase representa una amenaza a largo plazo tanto para las bases de datos comerciales como Oracle, DB2 o MS SQL Server, así como a las de Código Libre como Postgress o hasta a la misma MySQL, que sin embargo hay situaciones en donde es mejor aun tener una base de datos relacional. ¿Cómo decidir? Este documentote apuntará a los primeros pasos.

Técnicamente, HBase está implementado en Java, por lo que funciona en cualquier plataforma que tenga una máquina virtual de Java, lo que hace a HBase una tecnología fácil de adoptar en entornos de Unix, Linux, Windows y hasta OS X.

Pero quizás una de las mejores noticias sobre esta tecnología es que es Open Source (Código Libre), lo que significa que puede ser utilizado por cualquiera libre y gratuitamente, así como uno poder aportar a su desarrollo o aprender de su código fuente.

Si eres estudiante de informática, no pierdes nada en aprender estos conceptos ahora, y de paso estarás mejor preparado cuando en unos años este tipo de conocimientos se tornarán invaluables y altamente cotizados. Un tip: Puedes iniciar con HBase y Java en una sola PC, y cuando quieras experimentar en modo distribuido es cuando en realidad necesitarás a HDFS.

Nota a técnicos: Una aclaración: Aunque BigTable es relativamente reciente, los conceptos detrás de la técnica no lo son, y ya eran conocidos desde hace al menos unos 20 años atrás en otras formas.

Actualización: Algo importante que no mencioné en el artículo es que Yahoo es posiblemente el contribuidor mas grande a este proyecto, y lo utiliza en decenas de miles de servidores internamente.

Fuente: http://eliax.com/index.php?/archives/6651-Hadoop-HBase,-el-futuro-de-bases-de-datos-escalables.html

Que es Hadoop?

Apache Hadoop es un proyecto Java de software libre para brindar servicios de computación distribuida, escalable y confiable. Hadoop fue inspirado por los papers: Google's MapReduce y Google File System (GFS) . Hadoop incluye los siguientes subproyectos:

• Hadoop Common: Utilidades comunes.
• Avro: Un sistema de serialización de datos que provee integración con lenguajes scripts.
• Chukwa: Un sistema recolección de datos para manejo de grandes sistemas distribuidos.
• HBase: Una base de datos distribuida que soporta la estructura de data storage para grandes tablas.
• HDFS: File system distribuido.
• Hive: Una infraestructura de data warehouse que prove sumarización de datos y consultas ad hoc.
• MapReduce: Un framework para procesos distribidos de grandes conjuntos de datos en clusters
• Pig: Un lenguaje de alto nivel para flujo de datos y framework de ejecución de procesos en paralelo.
• ZooKeeper: Un coodinador de servicios de alta performance para aplicaciones distribuidas.

El equipo de Yahoo anunció que logró batir el record en el concurso anual GraySort, siendo ganador en 2 categorías. GraySort consiste en un conjunto de benchmarks, cada uno con sus propias reglas. Todos los benchmarks miden el tiempo para ordenar distinta cantidad de registros de 100 bytes cada uno (los primeros 10 bytes son la clave del registro, el resto el valor).

Para repartir la carga utilizaron un cluster gigante coordinado con Apache Hadoop. De esta manera, Apache Hadoop logró ordenar 1 Terabyte de datos en 62 segundos, y 1 Petabyte en 16.25 horas. Es la primera vez que un producto de software libre logra ganar esta competencia.

Apache Hadoop esta en el top level de los proyectos de Apache

Donde estas jar ?

No les paso que usaban un jar o una clase y no se acuerdan de donde salio o la entrada en el POM?

Bueno por suerte existe http://javacio.us/ que nos permite buscar clases y nos devuelve la entrada del pom. Lo pueden configurar como un plugin de google y cada vez que busquen en google, nos ayudara!!!

Otra herramiente más buena que el arroz con leche, es http://www.mvnrepository.com que nos permite buscar las dependencias para agregar a nuestro pom.

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.