domingo, 31 de agosto de 2014

Primeros pasos en Qt: Layouts


Ahora vamos a hacer un ejemplo que nos permita utilizar en más profundidad las señales y vamos a introducirnos en el uso de layout.

La aplicación consiste en 3 widget un QSpinBox, un QSlider y un QWidget.  Qwidget va a ser la ventana de la aplicación. Como es de esperar QSpinBox y QSlider  se van a dibujar dentro de QWidget. Por lo tanto podemos afirmar que  QWidget es contenedor de  QSpinBox y QSlider. Veamos el código:

#include <QApplication>
#include <QHBoxLayout>
#include <QSlider>
#include <QSpinBox>

int main(int argc, char *argv[])
{
  QApplication app(argc, argv);
  QWidget *window = new QWidget;
  window->setWindowTitle("Enter Your Age");
  QSpinBox *spinBox = new QSpinBox;
  QSlider *slider = new QSlider(Qt::Horizontal);
  spinBox->setRange(0, 130);
  slider->setRange(0, 130);
 
  QObject::connect(spinBox, SIGNAL(valueChanged(int)), slider, SLOT(setValue(int)));
  QObject::connect(slider, SIGNAL(valueChanged(int)), spinBox, SLOT(setValue(int)));
 
  spinBox->setValue(35);
 
  QHBoxLayout *layout = new QHBoxLayout;
  layout->addWidget(spinBox);
  layout->addWidget(slider);
  window->setLayout(layout);

  window->show();
  return app.exec();
}

Luego de crear la ventana se puede ver que se puede establecer el texto de la barra de titulo. Después creamos los dos componentes QSpinBox y QSpinBox y configuramos el rango de 0 a 130. Además indicamos a Qt que si spinBox lanza la señal valueChanged (que indica que el valor del componente ha cambiado) ejecute la función setValue de slider.

QHBoxLayout es un layout, los layouts nos permiten configurar fácilmente la disposición de los componentes en una ventana. QHBoxLayout es un layout que organiza los componentes de forma horizontal. Agregamos  QSpinBox y QspinBox al layout y luego agregamos el layout a la ventana para que se muestre.

Qt nos brinda 3 grandes tipos de layouts:

  • QHBoxLayout que permite organizar los componentes de forma horizontal y de izquierda a derecha.
  • QVBoxLayout que permite organizar los componentes de forma vertical y de arriba a abajo.
  • QGridLayout organiza los componentes como una grilla. 


Con el método setLayout indicamos el layout a la ventana. Como se deben imaginar es posible indicar un árbol de componentes y de esta forma una ventana puede tener diferentes layouts.

Primeros pasos en Qt

Vamos a empezar con un programa de Qt muy simple. Primero estudiaremos línea por línea.

#include <QApplication>
#include <QLabel>

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QLabel *label = new QLabel("Hello Qt!");
label->show();
return app.exec();
}

En la linea 1 y 2 incluimos las clases QAplication y Qlabel. En QT todas las clases comienzan con la letra Q en mayúscula.   En la linea 5 creamos la aplicación qt y le pasamos como parámetro, los parámetros de main dado que la aplicación se puede ejecutar desde la linea de comandos con algún parámetro.

En la linea 6 se crea el widget QLabel el cual muestra “Hello Qt!”, los widget en la terminología Qt y unix son elementos visuales. Un botón, menú, scroll son ejemplos de widget. Además un widget puede contener a otro widget.

En la linea 7 se hace visible el componente, dado que todos los componentes nacen invisibles.

Línea 8 pasa el control de la aplicación a Qt. En este punto, el programa entra en el bucle de eventos. Esta es una especie de modo de espera, donde el programa espera de las acciones del usuario tales como clics del ratón y las pulsaciones de teclas. Las acciones del usuario generan eventos (también llamados "mensajes") a los que el programa puede responder, por lo general se ejecutan una o más funciones.

Si ejecutamos la aplicación, se vera un label con la fase “Hello Qt!". Podemos escribir HTML en el label para eso vamos a cambiar la linea 6 por:

QLabel *label = new QLabel("<h2><i>Hello</i><font color=red>Qt!</font></h2>");

El label tomara el estilo igual que html.

Vamos a agregar un botón para salir de la aplicación:

#include <QApplication>
#include <QPushButton>

int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QPushButton *button = new QPushButton("Quit");
QObject::connect(button, SIGNAL(clicked()),
&app, SLOT(quit()));
button->show();
return app.exec();
}

En este ejemplo agregamos un botón el cual emite la señal clicked cuando el usuario hace click en el componente.

Los widgets de Qt emiten señales para indicar que se ha producido una acción del usuario o de un cambio de estado. Por ejemplo, QPushButton emite una señal clicked() cuando el usuario hace clic en el botón. Una señal se puede conectar a una función (utilizando la función SLOT), de modo que cuando se emite la señal, la función se ejecuta automáticamente.


Es necesaria la inyección de dependencias en lenguajes de tipado dinámico?


Porque utilizamos la inyección de dependencias en lenguajes como java o C# pero no lo utilizamos en lenguajes como Ruby, Python o PHP?

He leído en varios lugares que la inyección de dependencia puede ser útil para los lenguajes dinámicos y en otros sitios que es una tontería:

DI frameworks are unnecessary. In more rigid environments, they have value. In agile environments like Ruby, not so much. The patterns themselves may still be applicable, but beware of falling into the trap of thinking you need a special tool for everything. Ruby is Play-Doh, remember! Let’s keep it that way.
– Jamis Buck

Veamos un ejemplo de no utilizar un framework de inyección de dependencia en Ruby, supongamos que tengo un DAO que necesita de la conexión a la base de datos, en java sería así:

class Repository {
    private Connection connection;
    public Repository(Connection connection) {
        this.connection = connection;
    }
    public Something find(Integer id) {
        return this.connection.execute("SELECT ...");
    }
}

En java si necesitamos el objeto connection en varios lugares lo vamos inyectando y a la vez si queremos testear el dao vamos a utilizar un mock, es decir que para los tests vamos a inyestar un objeto que simule la base de datos. Pero en Ruby existe otro modo de organizar este código y es por medio de módulos.

module ConnectionProvider
  def connection
    # open a database connection and return it
  end
end

Gracias a estos modulos podemos utilizar en varios lugares ConnectionProvider, reutilizando código. Y a la vez Ruby nos brinda la posibilidad de reabrir una clase por lo que podemos reabrirla y utilizar la base de datos real o una base de datos en memoria o mock para los test.

# connection_provider.rb

module ConnectionProvider
  def connection
    # open a database connection and return it
  end
end

# reopening the class to mix the module in
class Repository
  include ConnectionProvider
end

Esto provee una capacidad similar a la inyección de dependencia sin utilizar un framework.




jueves, 28 de agosto de 2014

Retrofit, haciendo fácil el acceso a servicios rest desde android.

Retrofit es un framework que nos hace fácil la vida cuando desarrollamos aplicaciones Android. Supongamos que mi aplicación tiene una API Rest y otra aplicación Android se conecta y consume datos de dicha API. Retrofit nos hace muy fácil el acceso a esta API usando Android.

Retrofit nos permite consumir servicios Rest por medio de anotaciones y de la misma forma que los desarrollamos, lo que hace que la curva de aprendizaje sea casi nula. A la vez popula nuestros objetos desde json o xml.

Veamos un ejemplo:

@Multipart
@PUT("/user/photo")
User updateUser(@Part("photo") TypedFile photo, @Part("description") TypedString description);

Además nos provee control de cabeceras:

@Headers("Cache-Control: max-age=640000")
@GET("/widget/list")
List<Widget> widgetList();

@Headers({
    "Accept: application/vnd.github.v3.full+json",
    "User-Agent: Retrofit-Sample-App"
})
@GET("/users/{username}")
User getUser(@Path("username") String username);

Si usamos maven la dependencia es:

<dependency>
  <groupId>com.squareup.retrofit</groupId>
  <artifactId>retrofit</artifactId>
  <version>1.6.1</version>
</dependency>

Dejo link:
http://square.github.io/retrofit/

domingo, 24 de agosto de 2014

Scala + Hadoop = Scalding


Scalding es una librería Scala que hace que sea fácil utilizar jobs de Hadoop MapReduce. Scalding es una librería que abstrae detalles de bajo nivel de Hadoop. Se podría comparar con Apache Ping, pero ofrece integración con Scala, trayendo ventajas de Scala a los jobs de MapReduce.

Scalding fue creado por la gente de twitter para facilitar el uso de Hadoop y fue publicado en github. Y además es totalmente libre dado que se distribuye con licencia Apache 2.

Dejo link:
https://github.com/twitter/scalding

Inyección de dependencias en Scala


Como ustedes sabrán, cualquier aplicación no trivial está formada por dos o más clases que colaboran entre sí para realizar alguna lógica. Tradicionalmente cada objeto se hacía cargo de obtener sus propias referencias a los objetos a los cuales colaboraba (sus dependencias). Esto lleva a código acoplado y difícil de probar. Cuando se aplica inyección de dependencia le decimos a una entidad externa que provea las dependencias a los objetos. Esto nos resuelve el problema del acoplamiento.

Que framework utilizar en Scala? Existen numerosos framework que podemos utilizar que proveen la implementación de la inyección de dependencia. Pero no creen que vamos muy rápido? Ya estamos pensando en un framework? Si la inyección de dependencias es tan buena, porque el lenguaje no nos brinda una forma de implementarla? Existen lenguajes que proveen la inyección de dependencia en el mismo lenguaje un ejemplo era Noop.

Scala brinda dos formas de implementar inyección de dependencias sin utilizar framework. La primera es por medio de cake patterns y la segunda es utilizando reader monad.

Probablemente cake patterns es la técnica más popular para implementar inyección de dependencia sin utilizar un framework. En esta técnica se basa en la técnica de mixing. Veamos un ejemplo:

object idExample {

  class User(var id: Int, var firstName: String, var lastName: String, var email: String, var supervisorId: Int) {}

  trait UserRepositoryComponent {

    def userRepository: UserRepository

    trait UserRepository {
      def get(id: Int): User
      def find(username: String): User
    }
  }

  trait Users {
    this: UserRepositoryComponent =>

    def getUser(id: Int): User = {
      userRepository.get(id)
    }

    def findUser(username: String): User = {
      userRepository.find(username)
    }
  }

  trait UserInfo extends Users {
    this: UserRepositoryComponent =>

    def userEmail(id: Int): String = {
      getUser(id).email
    }

    def userInfo(username: String): Map[String, String] = {
      val user = findUser(username)
      val boss = getUser(user.supervisorId)
      Map(
        "fullName" -> s"${user.firstName} ${user.lastName}",
        "email" -> s"${user.email}",
        "boss" -> s"${boss.firstName} ${boss.lastName}")
    }
  }

  trait UserRepositoryComponentImpl extends UserRepositoryComponent {

    def userRepository = new UserRepositoryImpl

    class UserRepositoryImpl extends UserRepository {

      var db: Map[Int, User] = Map()
      var dbUserName: Map[String, User] = Map()

      def save(user: User) = {
        db += (user.id -> user)
        dbUserName += (user.email -> user)
      }

      def get(id: Int) = db(id)

      def find(username: String) = dbUserName(username)

    }
  }
 
  object UserInfoImpl extends
  UserInfo with
  UserRepositoryComponentImpl

}

Como podemos ver UserInfoImpl hereda de UserInfo pero utiliza los métodos de UserRepositoryComponentImpl usando mixing.

La otra técnica es utilizar reader monad para explicarla es necesario entender monad, para luego centrarnos en el monad reader.

Básicamente una función con un solo parámetro es un objeto de tipo Function1, por ejemplo la función triple es de tipo Int => Int

val triple = (i: Int) => i * 3
triple(3) // => 9

Pero Int => Int  es sólo una forma elegante de decir Function1[Int, Int] y Function1 nos permite crear nuevas funciones usando andThen.

val thricePlus2 = triple andThen (i => i + 2)
thricePlus2(3) // => 11

El método andThen combina dos función de un parámetro, generando una tercera función la cual aplica la primera función y luego la segunda. A la vez andThen puede cambiar los tipos de salida, por ejemplo:

val f = thricePlus2 andThen (i => i.toString)
f(3) // => "11"

El tipo de f es Int => String.

Reader Monad es un monad definido para funciones unarias, que utiliza andthen como la operación map veamos un ejemplo:

val triple = Reader((i: Int) => i * 3)
triple(3) // => 9

val thricePlus2 = triple map (i => i + 2)
thricePlus2(3) // => 11

Todo muy lindo pero y esto como me puede ayudar a implementar la inyección de dependencia?
Podemos utilizar Reader Monad para implementar inyección de dependencia, nosotros solo necesitamos definir las funciones con UserRepository como parámetro y podemos envolver cada una de estas funciones en un scalaz.Reader:

trait Users {
  import scalaz.Reader
  def getUser(id: Int) = Reader((userRepository: UserRepository) => userRepository.get(id) )
  def findUser(username: String) = Reader((userRepository: UserRepository) => userRepository.find(username) )
}

Noten que las funciones devuelven un objeto de tipo Reader[UserRepository, User] y no un usuario. Luego el Reader devolverá un usuario cuando se le asigne un repositorio. La inyección de dependencia se difiere.

Pero en algún momento debemos indicar a la aplicación que utilice una implementación. Esto se puede hacer en una capa superior por ejemplo un controler:

object Application extends Application(UserRepositoryImpl)

class Application(userRepository: UserRepository) extends Controller with Users {
}

Otras formas de implementar inyección de dependencia es utilizar algún framework. Por supuesto podemos utilizar los frameworks de java, que entre los más utilizados esta Spring y Guice.

Pero también tenemos frameworks en Scala entre los que podemos nombrar:

  • Subcut: provee tanto inyección de dependencias como servicio de búsqueda.  
  • Scaldi: Similar a Subcut.
Scala nos provee la inyección de dependencia tanto con técnicas del lenguaje como con frameworks de java y Scala. 

sábado, 23 de agosto de 2014

C++14 trae novedades


Se viene la versión 14 de C++ y lo más impresionante, a mi entender, es que en esta versión va  agregar mejoras a las expresiones  lambda.

Las mejoras del lenguaje se pueden dividir en 3 grupos, funciones lambda, constexpr y deducción tipos.

En la versión 14 vamos a poder utilizar lamdbas de la siguiente manera:

auto lambda = [](auto x, auto y) {return x + y;};


Dejo link: http://www.infoq.com/news/2014/08/cpp14-here-features

viernes, 22 de agosto de 2014

Por que no funciono Noop?

Noop era un proyecto de google, un lenguaje que corria en la maquina virtual Java. Lo novedoso de este lenguaje era que el mismo lenguaje provee inyección de dependencias. Es decir el mecanismo de inyección de dependencias era soportado por el lenguaje. Por lo tanto un hola mundo sería:

import noop.Application;
import noop.Console;

class HelloWorld(Console console) implements Application {

  Int main(List args) {
    String s = "Hello World!";

    console.println(s);
    return 0;
  }
}

Donde console, sera inyectado por el contenedor.

Hasta ahora todo bien salvo que noop esta muerto. Pero como no estoy conforme con esa realidad, escribo este post. Noop me parece un buen lenguaje, fundado en una gran idea.

Normalmente pensamos que la buena y nueva funcionalidad va a venir de la mano de un framework, pero si es tan buena porque no lo provee el lenguaje o la plataforma?

Dejo link: http://code.google.com/p/noop/

domingo, 17 de agosto de 2014

Sale una orden de Pattern Matching para C# y VB.net

No me canso de repetirlo la programación funcional cada vez esta ganando más espacio. Hoy quiero compartir la noticia que leí en infoQ.

Al parecer la versión 6 de C# y la 12 de VB.net van a incorporar pattern matching. Personalmente me parece bastante fea la implementación pero es mi opinión.

Veamos un ejemplo:

switch (e) {
  case X(): return Const(1);
  case Const(*): return Const(0);
  case Add(var Left, var Right): return Add(Deriv(Left), Deriv(Right));
  case Mult(var Left, var Right): return Add(Mult(Deriv(Left), Right), Mult(Left, Deriv(Right)));
  case Neg(var Value): return Neg(Deriv(Value));
}

Dejo link: http://www.infoq.com/news/2014/08/Pattern-Matching

Haciendo interfaces multi-touch con Kivy




Kivy es un framework para hacer interfaces multi-touch, multiplataforma en Python. Es decir que es un framework increíble.

Este framework nos permite usar la plataforma Python para hacer interfaces de nuestras aplicaciones. Además estas aplicaciones pueden correr en Linux, Windows, OS X, Android y iOS.

A la vez es muy fácil probar aplicaciones hechas en Kivy para celulares dado que no es necesario ningún emulador, simplemente debemos correrla. Como las aplicaciones son multiplataforma se pueden probar desde nuestra pc y luego instalarlas en nuestro dispositivo móvil.

Kivy esta orientado a Widgets y ofrece un sin numero de widgets y layouts entre los que se puede nombrar:  popup, video, slider, spinner, splitter, canvas. Además provee una API para acceder a la cámara y el micrófono. También provee una serie de efectos y la capacidad de transiciones de pantallas.

Veamos un “Hola mundo” hecho en Kivy:

from kivy.app import App
from kivy.uix.button import Button

class TestApp(App):
    def build(self):
        return Button(text='Hello World')

TestApp().run()

Y como si fuera poco Kivy provee un lenguaje declarativo para definir interfaces, similar a QML de Qt. Con este lenguaje se puede definir estilos en las interfaces, similar a css. Veamos un ejemplo:

#:kivy 1.0
Button:
    text: 'Hello world'

Kivy se puede usar libremente para proyectos comerciales y también para proyectos de software libre, dado que fue publicado con licencia MIT.  

Dejo link:
http://kivy.org/



miércoles, 13 de agosto de 2014

Porque Ceylon?



Quiero compartir un articulo muy bueno que indica porque debemos utilizar Ceylon.

Dejo link:
http://ldegruchy.blogspot.com.ar/2014/07/why-ceylon.html

martes, 12 de agosto de 2014

Oracle Service Bus: SOA Reference Architecture Design Patterns

Quiero compartir el siguiente curso de oracle:

To ensure delivery directly to your inbox, please add reply@oracle-mail.com to your address book today.
If you are having trouble viewing this newsletter, please click here.
Free Oracle Learning Streams Live Webinar!
Oracle Service Bus: SOA Reference Architecture Design Patterns

Free Live Web Seminar
Oracle Service Bus: SOA Reference Architecture Design Patterns
Wednesday, August 20
11:00am to 12:00pm PT
(2:00pm to 3:00pm ET)
 
Sign up Now!


About the Instructor

David Mills
David Mills is a Senior Principal Instructor for Oracle University. He has been an instructor for over 14 years, teaching Fusion Middleware and Service-Oriented Architecture (SOA) training classes. David has presented numerous times at workshops and conferences such as Oracle OpenWorld, and continues to be sought out among his peers as the “go to” expert for a large number of Oracle Middleware products, technologies, and best practices.

Free Oracle Learning Streams Live Webinar!
Oracle Service Bus: SOA Reference
Architecture Design Patterns
SOA Reference Architecture Design Patterns

Oracle University is pleased to invite you to experience part of the new Oracle Middleware Learning Stream when you attend this free one-hour webinar delivered by one of our senior instructors, David Mills. In this webinar, David will discuss the primary use cases and patterns that should be considered when leveraging an Enterprise Service Bus within an SOA Infrastructure. He will also provide an overview of some of the specific capabilities of the Oracle Service Bus 12c and 11g, primarily focusing on the proxy service and connectivity service design patterns.This Live Webinar Includes:
  • Oracle Service Bus Overview
  • SOA Reference Architecture Overview
  • Inbound & Outbound Proxy Use Cases
  • Connectivity Services Use Case Patterns
  • ESB V-E-T-O Pattern
  • Previewing the Oracle Middleware Learning Stream
Why You Should Attend:
By attending this live seminar, you will be able to explain the capabilities of Oracle Access Manager and identify business areas where the product can be useful.
Sign Up Now.

Discover Oracle Learning StreamsSubscribe to Oracle Learning Streams to receive one year of unlimited access to:
  • Hundreds of fresh videos and webinars by Oracle experts
  • Live connections with Oracle's top instructors
  • Robust video search capability to find exactly what you are looking for
  • Tools to build your own custom learning queue and request new content
For a limited time save 50% when you purchase an Oracle Learning Stream subscription together with any Oracle University Classroom, Live Virtual Class or Training On Demand training.*

Learn More
Hardware and Software, Engineered to Work TogetherOracle University
Copyright © 2014, Oracle and/or its affiliates.
All rights reserved.
Contact Us | Legal Notices | Privacy

lunes, 11 de agosto de 2014

The Haskell Platform

The Haskell Platform es un conjunto de librerías, herramientas y paquetes de software. Es una plataforma común para el desarrollo de aplicaciones en Hashkell.

La plataforma provee diferentes herramientas para el desarrollo, entre las que podemos nombrar:


  • GHC, el compilador de Haskell
  • GHC-Profiler, herramienta para perfilar las aplicaciones.
  • GHCi, GHCs interprete de bytecode
  • GHCi-Debugger 
  • Alex, un generador similas a lex
  • etc...

Dejo link:
http://en.wikipedia.org/wiki/Haskell_Platform
http://www.haskell.org/platform/

sábado, 9 de agosto de 2014

Scala es el nuevo Ruby?


Quiero compartir con ustedes el siguiente articulo : https://medium.com/@Jarlakxen/is-scala-the-new-ruby-a-deeper-view-2b724666e595 en el cual es una comparativa de Ruby y Scala.

La verdad que coincido con la idea que Scala es o va a ser el nuevo Ruby. Pero no a nivel sintáctico o semántico, sino en lo que paso con el lenguaje. En mi humilde opinión Ruby es y fue un lenguaje exitoso dado que influyo a muchos lenguajes y muchos lenguajes se crearon a partir de él por nombrar algunos Groovy o Scala. Es decir existían muchas necesidades y el supo satisfacerlas.

Algunas personas dirán que no fue o es exitoso porque no hay tantos proyectos nuevos en Ruby o no hay tantas lineas de código escritas en él. Pero esto no es así. Ruby fue y es una gran influencia para los lenguajes y la programación. Tal vez no triunfo porque no usa la sintaxis de C o no sé.

Scala en mi humilde opinión no crecerá tanto como tecnología sino que influirá a otros lenguajes y sera el padre de otros lenguajes. Scala introdujo el concepto de que la programación funcional y la orientada a objetos pueden convivir. Además que los mejores conceptos de programación pueden convivir.

Que opinan?

miércoles, 6 de agosto de 2014

OpenLibra, la Biblioteca Libre


Que buena idea! Era hora que exista una pagina para compartir libros. En esta pagina podemos encontrar muchos libros sobre programación.

Dejo link: http://www.etnassoft.com/biblioteca/

martes, 5 de agosto de 2014

Curso de Django


Quiero compartir estos vídeo tutoriales sobre django el framework más popular para desarrollo de aplicaciones web para python.

Dejo link: https://www.youtube.com/playlist?list=PLEtcGQaT56cg3A3r-TNoc-PyVeOuAMB4x

sábado, 2 de agosto de 2014

Comet fácil con Atmosphere Framework


Seguramente has sentido nombrar la técnica de comet o técnica de Push que permite que el servidor envié peticiones sin que el browser o cliente lo solicite. Voy a dar un ejemplo, si debemos implementar un chat, en el modelo tradicional el cliente debe preguntar cada cierto tiempo si hay un nuevo mensaje para él porque el servidor no puede notificar al cliente sin un pedido de éste.

El enfoque comet difiere del modelo original de la web, en el que un navegador solicita una página web completa o trozos de datos para actualizar una página web. En cambio, el servidor puede notificar al cliente sin que él haya hecho un pedido, pero esto es solo en teoría porque en la práctica hay diferentes formas de implementar comet, una muy extendida es que el cliente haga pedidos largos y el servidor solo conteste cuando tenga algo que notificar, otro modo es utilizar WebSocket si utilizamos HTML 5.

Atmosphere es un framework java/javascript para la construcción de aplicaciones Web asincrónicas usando Groovy, Scala y Java. El objetivo del framework es permitir a los desarrolladores escribir una aplicación y dejar que éste descubra el mejor canal de comunicación entre el cliente y el servidor, de forma transparente. Por ejemplo, con atmophere una aplicación puede utilizar webSockets cuando el servidor y el browser lo permitan pero éste framework usara otra técnica si esto no esta soportado.

Algo muy bueno de atmophere es que soporta todos los principales navegadores y servidores y además tiene integración con los más populares framework java y javascript. Y como si fuera poco soporta diferentes tecnologías para implementar comet, como WebSockets, Server Side Events (SSE), Long-Polling, HTTP Streaming y JSONP.

Del lado del servidor atmophere soporta Tomcat, Jboss, Jetty, Resin, GlassFish, Undertow, WebSphere, WebLogic etc. pero si no corres tu aplicación sobre un servlet container tienes soporte para Netty, Play! Framework o Vert.x. Además tiene extensiones para los frameworks más usados PrimeFaces, Wicket, Vaadin, Grails, richfaces, Spring, etc. Puedes buscar la extensión que necesites aquí.

Si utilizas maven puedes utilizarlo agregando la siguiente dependencia:

<dependency>
         <groupId>org.atmosphere</groupId>
         <artifactId>atmosphere-{atmosphere-module}</artifactId>
         <version>2.2.0</version>
</dependency>

Atmosphere es una excelente opción para implementar la técnica de comet en Java por su flexibilidad, integración y facilidad de uso.

Dejo links:
https://github.com/Atmosphere/atmosphere
http://async-io.org/