Translate

domingo, 18 de diciembre de 2011

Fantom


Fantom es un lenguaje el cual corre sobre la JVM de java; sobre CLR de .net y además sobre javascript. Es similar a java o c# pero con una sintaxis más evolucionada. Soporta mixin y concurrencia con el modelo de actores.

Totalmente orientado a objetos pero soporta el paradigma funcional y tiene closures. Soporta tipado estático o dinámico. Además de todos los características dichas agrega unos chiches como serialización a json, una api elegante y URIs basadas en REST.

Veamos un ejemplo:


// Hello from Fantom!
class HelloWorld
{
  static Void main()
  {
    echo("Hello, World!")
  }
}

Un ejemplo de clase:


public class Person
{
  public String name() { return name; }
  public void name(String x) { name = x; }

  public int age() { return age; }
  public void age(int x) { age = x; }

  private String name;
  private int age;
}

Prometo seguir escribiendo sobre este lenguaje que pinta lindo.

Dejo links:
http://fantom.org/doc/docIntro/StartHere.html
http://fantom.org/

jueves, 15 de diciembre de 2011

Anuncio de play! 2.0 en español


El anuncio de play 2.0 esta traducido en su totalidad al español y lo pueden leer del siguiente link: http://playdoces.appspot.com/2.0


Como principal novedad, el core del mismo estará escrito en scala, integrándose al stack de typesafe (scala + akka + sbt + play!), y tendrá soporte completo y APIs nativas tanto para scala como para java.

También hay otras novedades, como un nuevo sistema de builds (sbt), mayores validaciones en tiempo de compilación (los templates e incluso los archivos de rutas son estáticamente compilados), más soporte para operaciones asincrónicas, soporte para diversos tipos de fuentes de datos (bases relaciones y nosql) y más cambios.

martes, 13 de diciembre de 2011

@EJB


En un post anterior hicimos un proyecto con maven y JEE 

Pero en ese caso hicimos un lookup pero podríamos haber usado @EJB de la siguiente manera:


@EJB(mappedName="HolaMundoImpl/remote")
private HolaMundo holaMundo = null;

Y con esto nos ahorrábamos el lookup.

Cuales son los atributos de @EJB y para que se usan?

@EJB indica la dependencia de un ejb tanto local como remoto. Esta anotación tiene diferentes atributos los cuales analizaremos luego de revisar el concepto de ENC. Todos los EJB tienen un ENC (Enterprise Naming Context ) es como un registro interno donde fue deployeada esta aplicación.

Por ejemplo:

@Stateless(name="MyEJB")
public class MyEJBBean implements MyEJBRemoteBusiness, MyEJBLocalBusiness
{
...
}

Si nosotros asumimos que este EJB esta en myejb.jar y dentro de myapp.ear se puede tener una referencia a este bean de la siguiente manera:

javax.naming.Context jndiContext = new InitialContext(); // Assume we have this
// Define the contracted value
final String jndiName = "java:global/myapp/myejb/MyEJB!" +
MyEJBRemoteBusiness.class.getName();
MyEJBRemoteBusiness bean = (MyEJBRemoteBusiness)jndiContext.lookup(jndiName);

Cada bean contiene su JNDI ENC. La registración a JNDI ENC puede ser registrado bajo el contexto java:comp/env comp es porque es un componente. Cuando hacemos el lookup se resuelve la dependencia de diferentes contextos.

@EJB tiene los siguientes atributos:

name: atributo el cual indica conque nombre acedemos a una referencia EJB en JNDI ENC.

BeanName: este es el nombre de una referencia.

MappedName : es especifico del vendor; es una key dentro de la registración global. Es una forma de acceder a la referencia en el JNDI global. Por medio de mappedName varios vendors introducen características particulares. 

Esto fue una reseña general de @EJB. 

sábado, 10 de diciembre de 2011

Spring Data





Spring Data hace fácil la construcción de aplicaciones que usan nuevas formas de almacenar datos como por ejemplo base de datos no relacionales, servicios de datos en la nube, bases clave-valor, etc. 


La idea es introducir una capa de abstracción que permita generalizar el acceso a dato a almacenes de datos tan dispares. Este proyecto fue desarrollado gracias al trabajo conjunto con un conjunto de compañías y desarrolladores. 


Spring data esta dividido en diferentes subproyectos dependiendo los almacenes de datos que tenga que interactuar:



Categoría
Sub-proyecto
Relational Databases JPA

JDBC Extensions


Big Data Hadoop


Data-Grid Gemfire


Key Value Stores Redis

Riak


Document Stores MongoDB

CouchDB (planned)


Graph Databases Neo4j


Column Stores HBase (planned)

Cassandra (planned)


Blob-Stores Blob


Common Infrastructure Commons

Grails Mapping





IKVM.NET 7.0 Released




Fue liberada al versión 7 de IKVM. IKVM es una implementación de Java para Mono y .net. Este proyecto permite correr aplicaciones Java sobre .net adndonos mayor interoperabilidad entre estas plataformas. Esta compuesto por:


  • Una Maquina virtual Java implemantada en .net
  • Una implementación .net de librerías Java.
  • Herramientas que permiten la interoperabilidad entre Java y .net

Y es de licencia GNU 2.

Dejo links:

http://www.infoq.com/news/2011/12/IKVM_v7_released
http://www.ikvm.net/
http://www.ikvm.net/userguide/tutorial.html

martes, 6 de diciembre de 2011

APIs Explorer de Google

Quería compartir el explorador de Apis de google, no lo conocía tiene varias funcionalidades de varios productos de google.

Dejo el link:

https://code.google.com/apis/explorer/

lunes, 5 de diciembre de 2011

Play 1.2.4

Salio la nueva versión del framework play, copie la release note:


Soporte para Java 7

Play ahora trae soporte para Java 7, de manera que puede escribir el siguiente código sin ningún problema.
Map<String, List<String>> map = new HashMap();
String version = "1.2.4";
switch(version) {
  case "1.2.4":
     //code
     break;
   case "1.2.3":
     //code
     break;
   case "1.2.2":
     //code
   default:
     //code
     break;
}
 

Nueva implementación del binder de datos

La nueva implementación del binder es más flexible y le permite vincular datos fácilmente entre jQuery y Play. También es posible vincular objetos más complejos usando esta nueva implementación.

Soporte para la última especificación de WebSockets

Play ahora soporta la última versión de la especificación de WebSockets, más precisamente de la versión hybi-00 a la hybi-10. Consulte la Especificación de WebSocket para más información.

Soporte para IDs compuestos

Los fixtures ahora soportan IDs compuestos. También puede utilizar las siguientes anotaciones tanto desde los modelos como desde los fixtures: @IdClass@EmbeddedId. Consulte la Documentación de Hibernate para más información.

Mejor soporte para IntelliJ

El comando play idealize ahora crea un proyecto de IntelliJ completo. Puede abrir directamente los proyectos de Play desde IntelliJ.

Otras mejoras

Esta versión trae una cantidad importante de pequeñas mejoras, así como 86 bugs resueltos.

Having fun with Play framework!

Les quiero recomendar este nuevo blog, sobre play, scala, java, etc...

http://playlatam.wordpress.com/

domingo, 4 de diciembre de 2011

Cursos en Stanford University


La gente de Stanford University va a publicar unos cursos gratuitos, por lo visto estan buenos.

Dejo los links:
http://www.algo-class.org/
http://www.cs101-class.org/
http://jan2012.ml-class.org/
http://www.saas-class.org/
http://www.hci-class.org/
http://www.nlp-class.org/
http://www.game-theory-class.org/
http://www.pgm-class.org/
http://www.crypto-class.org/
http://www.security-class.org/

Date4j vs Joda Time


En infoQ publicaron una articulo muy interesante sobre la librería Date4j y lo comparan con Joda Time (librería facilitar el uso de fechas en java) quede sorprendido, joda time es mucho más pesado aunque soporta más cosas (hay que ver si se usan). Paso a copiar la tabla comparativa:


Joda Time
Date4j
Numero de clases140+
Numero de clases < 10
Clases mutables e inmutables
Clases inmutables
Foco en la velocidad y características
Se centran en la sencillez y la precisión
Soporta calendarios Gregorian, Coptic, Islamic, Buddhist ...
Solo soporta Gregorian calenda
Puede remplazar totalmente el Date de la JDK
Trabaja con Date de la JDK
Soporta milisegundos
Soporta nanosegundos
El dia "overflow"no es configurable
El dia "overflow" es configurable
Orientado a la manipulación total de fechas
Orientado a la manipulación de fechas por base de datos
Licencia Apache 2.0
Licencia BSD




Es interesante que existan estas librerías denota que en java no es bueno el manejo de fechas de forma nativa. Por lo visto para poblemas simples es mejor usar Date4j que Joda Time aunque me gustaría que lo traiga la jdk.

Dejo links:
http://www.infoq.com/news/2011/12/date4j-vs-joda-time
http://www.date4j.net/

lunes, 28 de noviembre de 2011

Cual es la diferencia entre Apache Click y otros frameworks web java?

Cual es la diferencia entre apache click y otros frameworks web java? y porque deberíamos aprender este framework web?

La diferencia tecnológica más importante es que apache Click no mantiene estados en el servidor (es stateless) esto lo hace ideal para usarlo en proyectos los cuales podrían tener muchos usuarios. Dado que si mantenemos estados en el servidor y vamos guardando cosas en estas sesiones cuando tengamos millones de usuarios; el servidor va a necesitar mucha memoria para trabajar.

Apache click no mantiene estados en el servidor (aunque se lo puede configurar para que si) lo que permite mayor escalabilidad. En click las paginas y los componentes son recreados por cada request. La visión de apache click es una creación de paginas web de forma más tradicional.

Apache click tiene más ventajas pero sin duda esta es la razón más importante por la que yo elegiría este framework.

Apache click esta en constante desarrollo y es un proyecto top-level de Apache foundation.

Dejo links:

http://click.apache.org/
http://click.apache.org/docs/user-guide/htmlsingle/click-book.html

sábado, 26 de noviembre de 2011

NuoDB

NuoDB es una base de datos newSQL. Se ve y se comporta como una base de datos relacional pero internamente nos permite tener una base distribuida. Si vamos a su pagina, como premisas afirma 100% ACID, 100% SQL y 100% escalable. Este conjunto de características combinadas hacen NuoDB el líder en el mercado NewSQL. Lo que diferencia a NuoDB además de otros NewSQL y soluciones NoSQL es cómo organizar y garantizar las transacciones ACID en un entorno distribuido.

El sistema está diseñado para ofrecer una visión coherente de datos, alta disponibilidad y la capacidad de detectar y gestionar las particiones de una manera predecible y consistente.

Dejo links:

http://nuodb.com/
http://nuodb.com/how_it_works.html

NoSQL, NewSQL y Data grid/cache

NewSql es una forma abreviada de dirigirnos a las bases de datos realcionales las cuales están preparadas para escalar, tienen en común el desarrollo de nuevos productos de base de datos relacional y servicios diseñados para llevar los beneficios del modelo relacional de las arquitecturas distribuidas, o para mejorar el rendimiento de bases de datos relacionales en la medida en que la escalabilidad horizontal es un la necesidad.

Podemos nombrar los siguientes productos como newSQL Clustrix, GenieDB, ScalArc, Schooner, VoltDB, RethinkDB, ScaleDB, Akiban, CodeFutures, ScaleBase, Translattice, and NuoDB, Drizzle, MySQL Cluster con NDB y MySQL con HandlerSocket. El ultimo grupo incluye Tokutek y JustOne DB. Podemos habler de NewSQL como servicio en el que podemos incluir Amazon Relational Database Service, Microsoft SQL Azure, Xeround, Database.com and FathomDB.

Como vemos ha cambiado bastante el ámbito de las bases de datos, las cuales se fueron adaptando para poder ofrecer mejor escalabilidad. Podemos agrupar las bases de datos escalables en 3 tipos: NoSQL, NewSQL y Data grid/cache.

InfoQ nos muestra la siguiente imagen donde muestra como se agrupan los productos según su clasificación:


domingo, 20 de noviembre de 2011

EJB 3 + Maven 2 + JBoss 6 + Eclipse

Vamos a crear un proyecto Jee con maven y que use como servidor Jboss con la siguiente estructura:

pom parent _
                     |__ ejb
                     |__ war

Bueno creamos el proyecto parent:

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

Y modificamos el pom para que quede de la siguiente manera:


  4.0.0

  org.assembly
  ExampleJEE
  1.0-SNAPSHOT
  pom

  ExampleJEE
  http://maven.apache.org

  
    UTF-8
  

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

  
        
            jboss-repository
            JBoss Repository
            https://repository.jboss.org/nexus/content/groups/public/
            default
        
    


  
     
    
      jboss
      jboss-ejb-api
      4.2.0.GA
      provided
    

    
      junit
      junit
      4.10
      test
    

  





Creamos el proyecto ejb:

cd ExampleJEE
mvn archetype:create -DgroupId=org.assembly -DartifactId=ExampleEJB

Y cambiamos el pom de la siguiente manera:



  4.0.0

  
    ExampleJEE
    org.assembly
    1.0-SNAPSHOT
  

  org.assembly

  ExampleEJB

  1.0-SNAPSHOT

  ejb

  ExampleEAR

  http://maven.apache.org

  
   
       
            javax.persistence
            persistence-api
            1.0
            provided
           
        
  
  
  
    UTF-8
  

 
    
    
      
        org.apache.maven.plugins
        maven-ejb-plugin
        2.1
        
          3.0
        
      

    
  





Ahora vamos a generar el proyecto war siempre dentro de ExampleJEE:

mvn archetype:create -DarchetypeArtifactId=maven-archetype-webapp -DgroupId=org.assembly -DartifactId=ExampleWAR

Y cambiamos el pom de la siguiente manera:


  
  4.0.0
  
  
    ExampleJEE
    org.assembly
    1.0-SNAPSHOT
  
  
  org.assembly
  
  ExampleWAR

  1.0-SNAPSHOT

  war

  ExampleWAR Maven Webapp

  http://maven.apache.org

  
    ExampleWAR
  

  
 
   
            org.assembly
            ExampleEJB
            1.0-SNAPSHOT
            provided
        
 
     
            javax.servlet
            servlet-api
            2.5
            provided
        

  





Pongo la dependencia a ExampleEJB como provided dado que no quiero que maven agregue el jar dentro del war después hago deploy del proyecto EJB y del WAR.

Ahora mvn clean install parados en el proyecto parent (ExampleJEE) y mvn eclipse:eclipse (si usan eclipse).

Bueno ahora importamos el proyecto a eclipse: file-> import-> Existing Projects into Workspace … Elegimos el path donde se encuentra el proyecto ExampleJEE y importamos.

Vamos a crear las siguientes clases en ExampleEJB:

La interfaz del servicio:

package org.assembly.service.api;

import javax.ejb.Remote;

@Remote
public interface HolaMundo {
 
 String decirHola();

}



La implementación :

package org.assembly.service.impl;

import javax.ejb.Stateless;

import org.assembly.service.api.HolaMundo;

@Stateless
public class HolaMundoImpl implements HolaMundo {

 /* (non-Javadoc)
  * @see org.assembly.service.api.HolaMundo#decirHola()
  */
 @Override
 public String decirHola() {
  return "Hola";

 }

}




Además agregamos este archivo en src/main/resources (si no existe la carpeta la crean) y lo nombramos jndi.properties

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
java.naming.provider.url=localhost:1099



Y en el Proyecto web agregamos este servlet:

package org.assembly.web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.assembly.service.api.HolaMundo;

public class HolaMundoServlet extends HttpServlet {

 private static final long serialVersionUID = 7819040755879233852L;

 private HolaMundo holaMundo = null;

 
 public HolaMundoServlet() {
  final Context context;
  try {
   context = new InitialContext();
   holaMundo = (HolaMundo) context.lookup("HolaMundoImpl/remote");

  } catch (NamingException e) {
   e.printStackTrace();
  }
 }


 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp)
   throws ServletException, IOException {
  final PrintWriter out = resp.getWriter();

  try {
   out.println(holaMundo.decirHola());
  } catch (Exception e) {
   out.println(e.getStackTrace().toString());
  }

 }

}



Por ultimo modificamos el web.xml para que escuche el servlet:


  Archetype Created Web Application
  
  
    
        hola
        org.assembly.web.HolaMundoServlet
    

    
        hola
        /hola.html
    
  
  





Ahora lo que hacemos es instalar el plugin Jboss Tools en eclipse lo podemos hacer desde el Marketplace de eclipse.



Ahora bajar Jboss 6 desde http://download.jboss.org/jbossas/6.1/jboss-as-distribution-6.1.0.Final.zip

Instalar el Jboss desde el panel de Servers menú contextual new. Luego importamos nuestros proyectos. Si todo fue bien debería verse el entorno así:



Corremos Jboss y en http://localhost:8080/ExampleWAR/hola.html deberíamos ver un “hola”

jueves, 17 de noviembre de 2011

Typesafe incluye a play en su Stack


Typesafe le empresa formada a raíz de Scala anuncio que agregara a play 2.0 a su stack.  Stack de typesafe es una plataforma que permite desarrollar software con scala teniendo a Akka como midleware. Bueno este stack va a tener a play como plataforma para desarrollo web. Recordemos que play es un framework para desarrollo ágil en Java y Scala (a partir de la versión 2.0).

El framework play va podes ser usado tanto en Java como en scala.

 Dejo links:

http://typesafe.com/stack
http://typesafe.com/company/news/15856
http://blog.typesafe.com/typesafe-stack-adds-play-framework
http://typesafe.com/technology/play