alter user USERNAME identified by PASSWORD;

Luego de ello entré al Enterprise Manager… Y sorpresa, los passwords de sys y otros habían expirado.

De lo que pude leer, lo que pasa es que Oracle Database 11g pone por defecto la expiración del password como habilitada. Pero están de acuerdo que no es común cambiar los passwords en una base de datos. Si están en mi mismo caso, hay que quitar esa opción de expiración. Y como siempre, es más fácil a través del SQL Plus.

ALTER PROFILE DEFAULT LIMIT
FAILED_LOGIN_ATTEMPTS UNLIMITED
PASSWORD_LIFE_TIME UNLIMITED;

Algunos enlaces de interés (parte de la información fue obtenida de estas fuentes):

• http://www.odi.ch/weblog/posting.php?posting=520

Caused by: BINDING.JCA-11811
Stored procedure invocation error.
Error while trying to prepare and execute the SCHEMA01.PKG01.PLSQL01 API.
An error occurred while preparing and executing the SCHEMA01.PKG01.PLSQL01 API.
Cause: java.sql.SQLTimeoutException: ORA-01013: user requested cancel of current operation
ORA-06512: at "SCHEMA01.PKG01", line 1206
ORA-06512: at "SCHEMA01.PKG01", line 1176
ORA-06512: at line 1

Check to ensure that the API is defined in the database and that the parameters match the signature of the API.  This exception is considered retriable, likely due to a communication failure.  Because the global transaction is rolling back the invoke must be retried in a new transaction, restarting from the place of the last transaction commit.  To classify it as non-retriable instead add property nonRetriableErrorCodes with value "1013" to your deployment descriptor (i.e. weblogic-ra.xml).

    at oracle.tip.adapter.db.exceptions.DBResourceException.createXARetriableException(DBResourceException.java:670)
    at oracle.tip.adapter.db.exceptions.DBResourceException.createEISException(DBResourceException.java:642)
    at oracle.tip.adapter.db.sp.SPUtil.createResourceException(SPUtil.java:175)
    at oracle.tip.adapter.db.sp.AbstractStoredProcedure.execute(AbstractStoredProcedure.java:131)
    at oracle.tip.adapter.db.sp.SPInteraction.executeStoredProcedure(SPInteraction.java:141)
    at oracle.tip.adapter.db.DBInteraction.executeStoredProcedure(DBInteraction.java:1102)
    at oracle.tip.adapter.db.DBInteraction.execute(DBInteraction.java:247)
    at oracle.integration.platform.blocks.adapter.fw.jca.cci.JCAInteractionInvoker.executeJcaInteraction(JCAInteractionInvoker.java:311)
    ... 102 more

Para corregir este error de timeout obtuve cierta información que espero sea de utilidad para alguien más. Los pasos para cambiar los parámetros de timeout tanto en JTA como en BPEL son:

1. Configuración syncMaxWaitTime: Esta propiedad controla el tiempo máximo que se espera un resultado en un proceso sincronizado.

• Iniciar sesión en EM como administrador.
• Abrir SOA y click derecho sobre “soa-infra”.
• Seleccionar: SOA Administration -> BPEL Properties
• Dar click sobre “More BPEL Configuration Properties…”
• Localizar el atributo syncMaxWaitTime y cambiarlo.

2. Configuración del tiempo de transacción de EJB de BPEL: Permite modificar las propiedades de tiempo de espera (timeout) para la aplicación SOA, ignorando la configuración global especificada en los parámetros JTA.
• Acceda a la consola de administración de Oracle WebLogic.
• Haga clic Deployments.
• Ampliar soa-infra –> EJB.
• Los siguientes EJBs deben actualizarse:

BPELActivityManagerBean
BPELDeliveryBean
BPELDispatcherBean
BPELEngineBean
BPELFinderBean
BPELInstanceManagerBean
BPELProcessManagerBean
BPELSensorValuesBean
BPELServerManagerBean

• Puede consultar en la pestaña de configuración el timeout para los beans que coincidan con el filtro “EJB*BPEL” (podría haber más beans si su versión es diferente).
• Haga clic en Guardar.
• Reiniciar Oracle WebLogic Server.

3. Ajuste del timeout de transacción global a nivel de dominio WebLogic: Esta propiedad controla el tiempo de espera para las transacciones activas. Si la transacción está todavía en estado “activo” después de ese tiempo, automáticamente se revierte (rolled back).

• Acceda a la consola de administración de Oracle WebLogic.
• Haga clic en Servicios -> JTA.
• Cambie el valor de segundos del tiempo de espera (timeout, por defecto es 30).
• Haga clic en Guardar.
• Reinicie Oracle WebLogic Server.

En mi caso se modifiqué los valores de timeout JTA a:

• Timeout Seconds: 6000
• Completion Timeout: -1 (en opciones avanzadas)
• Maximum Duration of XA Calls: 6000000 (en opciones avanzadas)

Las transacciones se establecen a 6000 segundos que equivale a 1.6 horas.

Algunos enlaces de interés (parte de la información fue obtenida de estas fuentes):

• http://forums.oracle.com/forums/thread.jspa?threadID=2279364
• http://sudhakarsoa.blogspot.com/2011/03/how-do-you-configure-transaction.html

La computación en grid es una tecnología innovadora que permite utilizar de forma coordinada todo tipo de recursos (entre ellos cómputo, almacenamiento y aplicaciones específicas) que no están sujetos a un control centralizado.

En este sentido es una nueva forma de computación distribuida, en la cual los recursos pueden ser heterogéneos (diferentes arquitecturas, supercomputadores, clusters…) y se encuentran conectados mediante redes de área extensa (por ejemplo Internet). Desarrollado en ámbitos científicos a principios de los años 1990, su entrada al mercado comercial siguiendo la idea de la llamada Utility computing supone una revolución que dará mucho que hablar.

El término grid se refiere a una infraestructura que permite la integración y el uso colectivo de ordenadores de alto rendimiento, redes y bases de datos que son propiedad y están administrados por diferentes instituciones. Puesto que la colaboración entre instituciones envuelve un intercambio de datos, o de tiempo de computación, el propósito del grid es facilitar la integración de recursos computacionales. Universidades, laboratorios de investigación o empresas se asocian para formar grid para lo cual utilizan algún tipo de software que implemente este concepto.

Para no extendernos en los conceptos les recomiendo visitar los siguientes enlaces:

• Conceptos

  http://es.wikipedia.org/wiki/Computaci%C3%B3n_distribuida

  http://es.wikipedia.org/wiki/Computaci%C3%B3n_grid

• EhCache con Spring (Spring Framework se integra perfectamente con EhCache, tanto sea a través de clases utilitarias “oficiales” como usando librerías adicionales que brindan una mejor integración)

  http://www.dosideas.com/wiki/EhCache_Con_Spring

• Terracota

  http://www.dosideas.com/noticias/java/271-introduccion-a-terracotta.html

  http://www.terracotta.org/

• Infinispan
  http://unpocodejava.wordpress.com/2010/09/15/getting-started-with-infinispan/

Tenemos al menos dos formas de calcular la edad en Java:

1. La podemos calcular en milisegundos, entregando la cuenta exacta de milisegundos desde que la persona nació.
2. Otra forma un poco más orientada al negocio para el que se esté construyendo el sistema es simplemente entregar el número de años que tiene la persona (como entero), ya que en los procesos financieros muchas veces no cuenta la edad real sino la edad establecida por el uso de la sociedad (en este caso el número de años).

Para la mayoría de casos preferiremos usar el segundo método ya que es la forma común en que entendemos la edad. Veamos esto en detalle (y con código):

Forma 1
Obtendremos la diferencia en milisegundos. Esta cantidad la puedes pasar a segundos, minutos, días o años, de acuerdo a la necesidad específica.

public long calcularEdadEnMilis(Date fechaNacimiento, Date fechaActual) {
    long diferencia = ( fechaActual.getTime() - fechaNacimiento.getTime() )
    return diferencia;
}

Forma 2
Haremos una resta sencilla: Si ya cumplió años en el año en curso, la edad es la diferencia de años. Si aún no cumple años, la edad es la diferencia de años menos uno. Recordemos que este código podría no aplicar para sociedades con otras formas culturales de calcular la edad (o que usa un calendario distinto a los conocidos).

public int calcularEdad(Date fechaNacimiento, Date fechaActual){
    Calendar fechaAct = Calendar.getInstance();
    fechaAct.setTime(fechaActual);

    Calendar fechaNac = Calendar.getInstance();
    fechaNac.setTime(fechaNacimiento);

    int dif_anios = fechaAct.get(Calendar.YEAR) - fechaNac.get(Calendar.YEAR);
    int dif_meses = fechaAct.get(Calendar.MONTH) - fechaNac.get(Calendar.MONTH);
    int dif_dias = fechaAct.get(Calendar.DAY_OF_MONTH) - fechaNac.get(Calendar.DAY_OF_MONTH);

    //Si está en ese año pero todavía no los ha cumplido
    if(dif_meses<0 || (dif_meses==0 && dif_dias<0)){
        dif_anios--;
    }
    return dif_anios;
}

CREACION DE FECHAS

Sólo por curiosidad: ¿Cómo creas tus fechas?
Una forma correcta de hacerlo es:

public Date crearFechas(int anio, int mes, int dia){
	Calendar fecha = Calendar.getInstance();
	fecha.clear(); //establece valores a 0
	fecha.set(anio, mes-1, dia); //establece año, mes y dia
	return fecha.getTime();
}

AÑOS BISIESTOS

Para saber si un año es bisiesto se puede aplicar una simple formula: Un año es bisiesto si es divisible entre 4, excepto el último de cada siglo (aquel divisible por 100), salvo que este último sea divisible por 400.

if ((anio % 4 == 0) && ((anio % 100 != 0) || (anio % 400 == 0)))
	System.out.println("El año es bisiesto");
else
	System.out.println("El año no es bisiesto");

Pero la mejor forma es usar Java al máximo, así:

public boolean esBisiesto(int anio) {
	GregorianCalendar calendar = new GregorianCalendar();
	return calendar.isLeapYear(anio);
}

(Nótese que esto sólo aplica para calendarios gregorianos)

Algunos enlaces de interés:

• http://americati.com/blog/?p=79
• http://draxus.org/weblog/2008/04/15/calcular-edad-en-java/
• http://lineadecodigo.com/java/ano-bisiesto-en-java/
• http://es.wikipedia.org/wiki/A%C3%B1o_bisiesto

Una vez iniciado Eclipse y teniendo configurado los plugins necesarios para trabajar con GWT procedemos a crear un nuevo proyecto:

A continuación seleccionamos el tipo de proyecto: GWT Java Proyect:

Escogemos un nombre para el proyecto, en este caso “DemoGWT”:

Marcamos la creación del módulo GWT:

Con eso tenemos listo el proyecto, con el ejemplo “automágicamente” generado y listo para ser probado.

Para probar nuestra aplicación pre-fabricada sólo hay que seleccionar el archivo ImageViewer.java (el archivo módulo) y con el botón derecho del mouse abrimos el menú contextual. Podemos usar el “Run as” o “Debug as” según nuestra necesidad. Lo único importante es que se ejecute como Google Web Application:

A continuación en la consola aparecerá un mensaje especial. En la pestaña de “Development Mode” aparece la URL a la que debemos dirigirnos si queremos probar la aplicación:

Copiamos la URL en nuestro navegador y podremos ver la aplicación. Se nos solicita instalar un complemento especial para que nuestro navegador pueda estar en modo de depuración con el GWT. Cuando el sistema entra a producción ya no es solicitado este complemento para el navegador, para mi caso estoy usando Firefox:

Una vez instalado el complemento solicitado por el navegador podemos ver la aplicación:

Y listo, con eso un “Hola Mundo GWT” sin programar. ¿Es rápido y amigable, verdad?

Pero como en desarrollo de software no todo es tan fácil, a continuación probaremos la capacidad de hacer la edición visual de la interface en GWT. Para ello el archivo ImageViewer.java debe ser abierto (con doble click sobre el nombre del archivo en el “Package Explorer”) y luego debemos abrir la pestaña que dice “Design” con el archivo abierto en el editor. Tener paciencia que puede tardar un poco en abrir en modo de diseño:

A continuación veremos cuatro áreas importantes:

• Structure: La estructura o jerarquía de clases, fijarse que en nuestro ejemplo el rootPanel tiene objetos “dentro” de él.
• Properties: Las propiedades de cada objeto, donde incluso puede cambiarse el nombre de la variable con que identificas el objeto.
• Palette: La paleta de objetos.
• Área de trabajo: El área donde modificamos la posición, tamaño y otras propiedades visuales de los objetos. Además se pueden arrastrar nuevos objetos o suprimir los ya existentes.

Para el ejemplo, haremos que la aplicación reciba un nombre en una caja de texto, este nombre se mostrará en el “alert” que aparece al hacer click al botón y posteriormente este mismo nombre se envía a una nueva caja de texto de sólo lectura, a modo de “resultado”.

Para ello modificaremos las líneas 25 y 33 de ImageViewer.java (el número de línea puede variar en su máquina, revise que lo que modifique corresponde a las mismas líneas mostradas en la imagen). Y agregaremos/modificaremos el código en las líneas 47, 48 y 49. La modificación para las líneas 25 y 33 corresponde a hacer las variables finales, de tal forma que el código dentro del “onClick” pueda hacer uso de esas variables:

Para más detalle de las modificaciones, muestro capturas de las propiedades de cada objeto:

Finalmente podemos ver el resultado de la modificación de nuestro ejemplo:

Espero este tutorial haya sido de ayuda.
 
 
 

Google Web Toolkit
Framework creado por Google que permite ocultar la complejidad de varios aspectos de la tecnología AJAX. Es compatible con varios navegadores. El concepto de Google Web Toolkit es bastante sencillo, básicamente lo que se debe hacer es crear el código en Java usando cualquier entorno de desarrollo (IDE) de Java y el compilador lo traducirá a HTML y JavaScript.

Google Plugin for Eclipse
El complemento de Google para Eclipse (en Inglés “Google Plugin for Eclipse”) es una forma rápida de empezar a desarrollar aplicaciones de Google Web Toolkit y de App Engine, de la instalación directo a la implementación de una aplicación AJAX “Hello World” en cuestión de minutos.

Eclipse
Eclipse es un entorno de desarrollo integrado de código abierto multiplataforma para desarrollar lo que el proyecto llama “Aplicaciones de Cliente Enriquecido” (Rich Client Applications). Esta plataforma típicamente ha sido usada para desarrollar entornos de desarrollo integrados (del inglés IDE), como el IDE de Java llamado Java Development Toolkit (JDT) y el compilador (ECJ) que se entrega como parte de Eclipse (y que son usados también para desarrollar el mismo Eclipse). Sin embargo, también se puede usar para otros tipos de Aplicaciones de Cliente Enriquecido.

Procedimiento

Para nuestro caso descargamos Eclipse Helios (3.6) para Windows. Ustedes pueden usar la versión de Eclipse y sistema operativo de su preferencia. El mecanismo es similar para todos los casos, descargamos y descomprimimos:

Puede elegir la versión adecuada desde la siguiente URL: Eclipse Downloads.

El paso posterior es abrir un workspace existente o crear uno nuevo, para nuestro caso crearemos un workspace nuevo en “c:\temp\Java\wks\gwt-helios”:

A continuación debemos entrar al menú Help -> Install New Software

Y ya en esa ventana de configuración seleccionar “Add Repository”:

De acuerdo a la versión de Eclipse podemos agregar uno de los siguientes URL’s:

Eclipse 3.6 (Helios): http://dl.google.com/eclipse/plugin/3.6
Eclipse 3.5 (Galileo): http://dl.google.com/eclipse/plugin/3.5
Eclipse 3.4 (Ganymede): http://dl.google.com/eclipse/plugin/3.4

Después de agregar la URL se puede seleccionar los paquetes a instalar. En este caso seleccionamos el Plugin y el SDK para tenerlos integrados con Eclipse:

A continuación aparece la revisión del software a instalar y damos “Next”:

Aceptamos la licencia del software:

Aceptamos instalar software sin firmar:

Se inicia la instalación, puede tardar (ya que primero descarga los paquetes y luego los instala):

Una vez instalado todo, se nos solicita reiniciar eclipse (recomiendo usar la opción de “Restart Now”):

Una vez reiniciado volvemos a entrar a nuestro workspace de trabajo (“c:\temp\Java\wks\gwt-helios”) y volvemos a entrar a agregar nuevo software (Help -> Install New Software). Allí introducimos la URL para el plugin para diseño del GWT:

Como en el caso anterior, de acuerdo a tu versión de Eclipse, eliges la URL que corresponde:

Eclipse 3.6 (Helios): http://dl.google.com/eclipse/inst/d2gwt/latest/3.6
Eclipse 3.5 (Galileo): http://dl.google.com/eclipse/inst/d2gwt/latest/3.5
Eclipse 3.4 (Ganymede): http://dl.google.com/eclipse/inst/d2gwt/latest/3.4

A continuación seleccionamos el software a instalar (“GWT Designer” e “Infraestructure”) :

Revisamos el software a instalar y damos en “Next”:

Aceptamos las licencias:

Aceptamos la instalación de software sin firmar:

El software se instala:

Y si todo fue bien, se pedirá que se reinicie Eclipse:

Eso es todo, espero esta guía les haya servido de ayuda. Si quieren más información respecto a GWT, construí un tutorial para construcción con GWT y Eclipse, pueden revisar este tema aquí.

Traté de explicarle que el lenguaje Java como tal no es igual a gratis ni a Open Source (para ello vean el artículo La Trampa de Java). Creo que no me entendió.

Pero su pregunta principal fue: ¿Qué otras opciones tengo para evaluar además de Java? Recordemos que es primordial hacer una comparación antes de tomar una decisión de desarrollo. Así que, ¿dónde puedo encontrar esa lista de herramientas/lenguajes?

Le recomendé una lista de herramientas de desarrollo rápido: List of rapid application development tools

Es un buen inicio ver que tenemos a disposición.

Y para aquellos que gusten de comparar lenguajes, aquí un gráfico interesante en el que verán que a veces Lisp puede ser tan rápido o más que C++ para algunas tareas.

No sé si todos lo sepan pero .NET tiene un Common Language Runtime o CLR (Lenguaje común en tiempo de ejecución) que es el componente de máquina virtual de la plataforma .NET de Microsoft.

Mono es un proyecto Open Source iniciado por Ximian y actualmente impulsado por Novell (tras la adquisición de Ximian) para crear un grupo de herramientas libres, compatibles con .NET, según lo especificado por el ECMA (y proporciona un CLR, además de soporte a algunos lenguajes como C#, MonoBasic, GTK# etc).

Alguna vez escuché a los evangelizadores de .NET decir que su máquina virtual es una evolución natural de la Java Virtual Machine (JVM). ¿Por qué? Porque Java produce bytecodes que se interpretan en la JVM. Si los bytecodes son portables porque la implementación de la JVM es un estándar (independiente del Sistema Operativo o hardware) es lógico hacer lo mismo con cualquier lenguaje y esto haría que cualquier lenguaje pueda funcionar como Java, es decir independiente del Sistema Operativo y del hardware. Así nace CLR, una máquina virtual para múltiples lenguajes. Creado CLR lo único que faltaría es el compilador que genere código intermedio (llamado Common Intermediate Language – CIL) para el lenguaje que se desee ejecutar en el CLR.

[ Breve paréntesis: ¿Por qué no hacemos un compilador que nos permita programar con Logo o Basic y ejecutar lo programado en la JVM? No he visto ningún proyecto similar. Y la idea no deja de ser interesante y teóricamente posible.]

Bueno, buscando, era obvio que era cuestión de tiempo para que crearan eso que permitiese ejecutar Java dentro del CLR.
El proyecto es IKVM.NET:

IKVM.NET es una implementación de Java para Mono y Microsoft.NET Framework. Incluye los siguientes componentes:

• Una máquina virtual de Java implementada en. NET
• Implementación de las clases básicas de Java en .NET
• Herramientas que permiten la interoperabilidad entre Java y .NET

Lo bueno, es que funciona bien con aplicaciones de consola (habrá que ver el rendimiento, en MONO y en CLR .NET). Lo malo, es que no funcionan bien las interfaces gráficas (olvídate de usar Swing). Como alternativa creo que podrías crear un programa híbrido con clases Java, usando interfaces gráficas .NET.

Los links de interes:

Mono & Java
Interfaces gráficas Java en Mono… que decepción

JavaServer Faces (JSF) es una tecnología y framework para aplicaciones Java basadas en web que simplifica el desarrollo de interfaces de usuario en aplicaciones Java EE. JSF usa JavaServer Pages (JSP) como la tecnología que permite hacer el despliegue de las páginas, pero también se puede acomodar a otras tecnologías como XUL.

JSF incluye:

• Un conjunto de APIs para representar componentes de una interfaz de usuario y administrar su estado, manejar eventos, validar entrada, definir un esquema de navegación de las páginas y dar soporte para internacionalización y accesibilidad.
• Un conjunto por defecto de componentes para la interfaz de usuario.
• Dos bibliotecas de etiquetas personalizadas para JavaServer Pages que permiten expresar una interfaz JavaServer Faces dentro de una página JSP.
• Un modelo de eventos en el lado del servidor.
• Administración de estados.
• Beans administrados.

La especificación de JSF fue desarrollada por la Java Community Process como JSR 127, que definía JSF 1.0 y 1.1, JSR 252 que define JSF 1.2 y JSR 314 para JSF 2.0

A continuación agrego unos tutoriales de IBM que pueden aclarar un poco como desarrollar con JSF:

• JSF 2 fu: Ajax components
• JSF 2 fu: After-the-fact Ajax composite components
• JSF 2 fu: JSF wizards

La imagen siguiente corresponde al editor visual de JSF de MyEclipse. Pero es importante que sepan que se incluye un editor similar en Eclipse, así que ya ustedes decidan cual usar:

Este editor también puede ser usado para editar JSP’s. Para convertir el Web Page Editor en el editor por defecto de JSP’s, se debe hacer lo siguiente:

1. Vaya a “Window” -> “Preferences…” -> “General” -> “Editors” -> “File Associations”
2. En el “File Associations” seleccione “*. jsp”
3. En “Associated editors”, seleccione “Web Page Editor”
4. Seleccione el botón “Default”

Y listo.

Espero este breve vistazo a JSF les sirva de ayuda.

He escogido tres tecnologías interesantes que pueden ayudarnos en esta tarea, que permiten ejecutarse en múltiples sistemas operativos (y múltiples browsers):

• Yahoo! UI Library
• Microsoft Silverlight
• Google Web Toolkit

Yahoo! UI Library
Yahoo User Interface(YUI), una serie de bibliotecas escritas en JavaScript, para la construcción de aplicaciones interactivas (RIA). Liberadas bajo licencia BSD por parte de la compañía Yahoo. Dichas bibliotecas son utilizadas para el desarrollo web específicamente para ser usadas como la programación de aplicaciones de escritorio, con componentes vistosos y personalizables y con una amplia implementación con AJAX.

Para integrarlo con Java he visto dos páginas interesantes:

• Yahoo’s Rich Web UIs for Java Developers: Java developers who develop web applications with server-side frameworks often don’t have the JavaScript expertise to create rich user interfaces. Learn how Yahoo User Interface (YUI) can help bridge that gap.
• Putting a YUI Face on a Java Web Application: Learn how to use Yahoo User Interface (YUI) Web components to develop a real world application with just the right mix of JavaScript/AJAX.

Sin embargo en este punto no he encontrado una herramienta que me ayude a hacer un diseño fácil de estas interfaces gráficas.

Tres referencias importantes que nos acercan a un “editor” WYSIWYG para YUI:

• YUI CSS Grid Builder
• Dreamweaver CS4
• Aptana

Microsoft Silverlight
No se asusten, se puede integrar con Java y además es independiente del browser. Microsoft Silverlight es una estructura para aplicaciones web que agrega nuevas funciones multimedia como la reproducción de vídeos, gráficos vectoriales, animaciones e interactividad, en forma similar a lo que hace Adobe Flash. Silverlight compite con Adobe Flex, Nexaweb, OpenLaszlo y algunas presentaciones de componentes AJAX. Actualmente se distribuye de forma gratuita.

Para Silverlight hay herramientas comerciales y libres, incluso un plugin de Eclipse. Sin embargo las herramientas que permiten hacer más sencillo el diseño de las interfaces son de pago.

Como integrarlo con Java:

• Whitepaper: Using Silverlight for JEE applications

Google Web Toolkit
Framework creado por Google que permite ocultar la complejidad de varios aspectos de la tecnología AJAX. Es compatible con varios navegadores, lo cual es notorio ya que cada navegador suele necesitar código específico para lograr un front-end correcto en una aplicación web. El concepto de Google Web Toolkit es bastante sencillo, básicamente lo que se debe hacer es crear el código en Java usando cualquier entorno de desarrollo (IDE) de Java y el compilador lo traducirá a HTML y JavaScript. Se distribuye bajo la Apache License, v2.0.

La verdad es el framework del que encontré más información y lo que más me gustó fue facilidad de usar el GWT Designer que ofrece (que es robusto y libre). Justo lo que buscaba.

Página oficial: http://code.google.com/intl/es-ES/webtoolkit/

Y para integrarlo con aplicaciones Java:

• Cómo desarrollar aplicaciones corporativas con GWT/JEE
• Deploying GWT Applications in SpringSource dm Server: Part 1, Part 2, Part 3.
• Build an Ajax application using Google Web Toolkit, Apache Derby, and Eclipse: The fancy front end, The reliable back end, Communication, Deployment

Algo importante es que Google nos facilitó un designer, una herramienta para diseñar interfaces con GWT de forma visual, WYSIWYG. Vea la noticia aquí: Google publica plugins de Instantiations gratuitamente..

GWT Designer: Permite crear aplicaciones Ajax de forma gráfica usando Google Web Toolkit. Para muchos la verdadera razón de que Google compró a Instantiations. Sin duda se extrañaba una herramienta gratuita y soportada por el mismo Google para generar interfaces con GWT. Si bien GWT ha ganado bastantes usuarios en los últimos años, GWT Designer va a bajar la barrera para que aquellos que no lo usan se acerquen al framework y va a facilitar mucho la vida a los usuarios existentes.

He preparado una entrada dedicada al primer demo que desarrollé con GWT y Eclipse, aquí. Y si no conocen como configurar esos plugins en Eclipse pueden dirigirse a esta otra entrada.