Compte-rendu de la conférence SpringOne 2009(Amsterdam - 27 au 29 avril 2009)

Rod Johnson, le créateur de Spring et CEO de SpringSource, a commencé la conférence par une présentation intitulée "The future of Java innovation".

On peut "twitter" à propos de la conférence avec le mot-clé #SpringOne.

Il pose une question à 7.4 milliard de dollars (rires dans la salle) : "Oracle va bientôt acquérir Sun. Doit-on s'inquiéter pour l'avenir de Java ?"

Il semble défavorable à l'acquisition de Sun par Oracle. D'après lui, "innovation is not coming from Oracle".

Et toujours d'après lui, avec cette acquisition, on prend le risque de voir Oracle manager le musée Java ("Let Oracle run the Java museum"). Il a comparé Larry Ellison, le CEO d'Oracle à Genghis Khan, empereur mongol, avec cette question : "Que ferait Genghis Khan ?". Il avait déjà fait connaître son opinion sur ce rachat sur son blogquelques jours auparavant.

Il a ensuite évoqué Grails et Groovy. D'après lui, chaque développeur Java devrait connaître de loin ou de près Grails et Groovy.

Il a ensuite laissé la parole à Ben Alex pour nous présenter Spring Roo.

En fait Roo (Real Object Oriented) est pour l'instant un nom de code. On peut voter pour choisir son nom définitif ici : http://cloud.springsource.com/vote/.

J'ai retenu qu'il s'agit d'un shell qui permet de rapidement créer une structure de projet à la Maven, qui gère l'autocomplétion. Ce shell est aussi utilisable dans STS (SpringSource Tool Suite).

Ben Alex a commencé à écrire une série d'articles introductifs à Roo sur son blog et une version alpha est déjà disponible ici.

Comme l'a dit Rod Johnson, "the days of creating projects by hand are over".

Une des news annoncées par le CEO est la gratuité de SpringSource Tool Suite, outil de développement basé sur Eclipse. "STS will be free". Ce qui a entraîné des applaudissements du public. Le communiqué officiel est ici.

Il a aussi mentionné que STS intègrera des fonctionnalités Grails & Groovy dans les mois à venir.

Une autre news importante est la certification JEE de SpringSource tc Server.

Ce fût ensuite le tour de Jennifer Hickey de venir rapidement présenter SpringSource tc Server 6.0.19.A. Il s'agit en fait de la 1ère version de ce serveur. 6.0.19 étant la version du serveur Tomcat qu'il embarque.

Keith Donald est le co-lead de Spring Web Flow.

On a fait le tour des modules Web qui sont déjà disponibles aujourd'hui dans Spring 2.5 :

• Module Spring Web Flow 2.0.x :
  Les exemples étaient ceux du site de Spring : Welcome to Spring Travel. Ce module permet de contrôler la navigation en implémentant des stateful flows. Les wizards sont un bon exemple.

• Module Spring MVC :
  - Controller avec l'annotation @Controller, qui n'existait pas avant la version 2.5
  - Mapping de requêtes HTTP sur des méthodes : @RequestMapping("/hotels/list", method=GET)
  - convention over configuration : c'est-à-dire qu'on définit des paramètres par défaut qui peuvent être redéfinis si besoin. Par exemple, @RequestMapping sans paramètre mappe par défaut sur la classe + le nom de la méthode. Moins de choses à taper signifie moins d'erreurs possibles.
  - Data binding
  - Les hints Autowiring : @Autowired ...

• Module Spring JavaScript :
  Intègre le DojoToolkit et est inclus dans la distribution de Web Flow 2.
  Ce module simplifie l'utilisation de Dojo pour les cas les plus communs d'utilisation :
  - Ajax
  - Validation côté client
  La servlet ResourceServlet permet de fournir efficacement des ressources statiques (images).
  Pour utiliser Spring JavaScript, il suffit d'inclure les fichiers Spring.js, dojo.js et Spring-Dojo.js.
  La démo a été faite sur la page des résultats de la recherche des hôtels.

• Module Spring Faces :
  Fait de JSF une technologie côté vue dans Spring en rendant des vues JSF depuis Spring MVC, les Controllers et les web flows. Le cycle de vie JSF est piloté depuis l'environnement Spring. Il a souligné que les Facelets sont meilleurs que les JSPs.

Il a malheureusement manqué de temps pour approfondir les démos et les explications.

Juergen Hoeller est le co-fondateur du projet Spring Framework et le co-auteur du livre "Expert One-On-One J2ee Development Without Ejb" (2004).

Cette présentation était centrée sur la distribution core de Spring.

Revue rapide de Spring 2.5 : Juergen Hoeller a d'abord fait une revue rapide de Spring 2.5 :

• Support pour la configuration basée sur les annotations (@Autowired, @Transactionnal, @Service, @Controller, @Repository ...)
• Support des annotations Java EE également : @PostConstruct, @PreDestroy, @PersistenceContext, @PersistenceUnit, @Resource, @EJB, @WebServiceRed, @TransactionAttribute ...
• Fichiers XML de définition des beans les plus minimalistes possibles.

Thèmes de Spring 3.0 RC1 : Puis il a fait une revue des thèmes de Spring 3.0 RC1. En gros, Spring 3.0 est "la réalisation complète de ce que l'on a commencé dans Spring 2.5".

• l'interface BeanFactory retourne maintenant des types generiques (utilisation de l'API Java 5) : T getBean(String toto, Class<T>)
• l'interface TaskExecutor hérite maintenant de java.util.concurrent.Executor
• Spring 3.0 inclut une version révisée du module OXM (Object/XML mapping).
• Spring 3.0 inclut la fonctionnalité essentielle du projet Spring JavaConfig : des factory méthodes annotées.
• plus d'options pour les annotations personnalisées
• Une autre nouveauté est l'inclusion d'un parser d'expression language dans Spring 3.0 : on pourra l'utiliser dans les fichiers XML de définition des beans, dans les classes de définition des components (annotations). Exemples d'attributs de contexte faisant partie de l'EL : attributs implicites ("systemProperties", "systemEnvironment"), attributs implicites spécifiques au web ("contextParameters", "contextAttributes", "request", "session"), attributs implicites JSF ("param", "initParam", "facesContext").
• support de REST : Spring MVC supporte le style de mapping REST. L'alternative qu'est JAX-RS est possible (@PathVariable("id")). D'autres annotations apparaissent : @RequestHeader, @CookieValue
• support de Portlet 2.0 en tant que modèle de validation : @ActionMapping("delete"), @EventMapping("BookUpdate")
• support de la JSR-303 (Bean validation) : @NotNull, @Past
• sérialisation de bean avec portée : Spring 2.5 ne permettait pas de correctement sérialiser des objets de portée session/conversation. Spring 3.0 apporte une solution avec des proxies qui réobtiennent des références lors de la désérialisation, à partir de WebApplicationContext.
• révision du package de scheduling : @Async, @Scheduled, l'interface TaskScheduler avec des Triggers, un namespace pour le scheduling via la configuration XML (cron, executor services)
• support de l'API JAVA EE 6 (JSF 2.0, JPA 2.0 ...) : Spring 3.0 requiert au minimum Java 5. Cependant le web container requiert Servlet 2.4 au minimum, et la version J2EE 1.4 concernant tout ce qui est Java EE.
• complètement compatible avec OSGi (avec dm Server 2.0)
• certaines classes disparaissent, d'autres sont déclarées deprecated (elles restent mais ne sont donc plus supportées)
• des modules du framework ont été révisés : ils sont maintenant gérés dans un style Maven, il n'y a plus de jar Spring.jar mais des modules : spring-beans.jar ...

Spring 3.0 Roadmap :

• Spring 3.0 M3 : disponible dans les jours à venir. C'est le dernier milestone avant la version RC1.
• Spring 3.0 RC1 : prévu pour fin mai 2009, la version GA suivra peu après.
• Spring 3.1 : Q4 2009.

Jennifer Hickey est senior software engineer chez SpringSource.

Elle a présenté le SpringSource tc Server en déployant l'application "Spring Travel". La phrase "The Tomcat you know, the enterprise capabilities you need" résume bien la philosophie de ce serveur. C'est un serveur pour les utilisateurs de serveurs Java EE qui cherchent à réduire les coûts et la complexité, ainsi que pour les utilisateurs de Tomcat qui veulent ajouter les fonctionnalités des serveurs Java EE.

On peut donc dire qu'il s'agit d'une version entreprise d'Apache Tomcat, le serveur d'application Java le plus largement utilisé.

La version actuelle 6.0 est en fait la toute première, elle correspond à la version de Tomcat 6.0.19 (Servlet 2.5, JSP 2.1) sur laquelle le tc server est codé.

Plusieurs serveurs peuvent tourner dans une seule box. Plusieurs instances peuvent tourner avec une seule installation. Un instance peut tourner par installation.

Un de ses slides montrait le schéma suivant, il décrit bien le principe du tc server :

Elle a ensuite décrit certains aspects du serveur.

• Opérations distribuées :
  - reporting généré avec JasperReports
  - accès finement contrôlé suivant le rôle
  - opérations classiques réalisables via le dashboard : deploy / undeploy / start / stop / configuration de la JVM / configuration d'une instance / vues opérationnelles consolidées ...
  - Le serveur ne gère pas encore les accès concurrents de plusieurs administrateurs, par exemple.
  - Pas encore de gestion du load-balancing.

• Scripting :
  Elle a fait une démo de certaines commandes, entre autres les suivantes :
  - >tcsadmin
  - >tcsadmin list-servers
  - >tcsadmin list-jvm-options --serverid 10432
  - >tcsadmin list-groups
  - >tcsadmin set-jvm-options
  - >tcsadmin get-file
  - >tcsadmin put-file
  - >tcsadmin list-applications

• Métriques :
  - diagnostique de deadlocks dans Tomcat
  - Mémoire disponible, consommation CPU, configuration des alertes

En résumé, le tc Server est recommandé quand :

• on veut déployer des web apps critiques
• on cherche à déployer plus que quelques instances de serveur.

Une version d'évaluation (valable 90 jours) est téléchargeable ici.

Adrian Colyer est le CTO de SpringSource. C'est aussi le leader du projet AspectJ. Il nous a expliqué les principes du Lean Software Development.

C'est manifestement un habitué des conférences, il était très à l'aise avec sa marionnette et a reçu de longs applaudissements en fin de session. De plus j'ai vu beaucoup de feuilles vertes dans la corbeille.

• Les principes du Lean Software Development :
  - Eliminer les gaspillages
  - Créer de la connaissance
  - Faire de la qualité
  - Ne pas se baser sur des spécifications figées
  - Livrer rapidement
  - Respecter les individus
  - Améliorer le système

• Puis il a rapidement fait une série de démos :
  - Demo 1 : "Using STS and Groovy to build and deploy an application in GAE" (Groovy tournant dans le Google App Engine). La demo faisait utilisation de Google Maps.
  - Demo 2 : "Using Grails to build and deploy an application to GAE" : ce fût l'occasion pour la marionnette de dire hello à Guillaume Laforge ;-)
  - Demo 3 : "Using STS to launch a cluster of dm Servers instances in Amazon EC2 and deploy an app"
  - Demo 4 : "Virtual QA Environment with tc Server"
  - Demo 5 : "Using Cloud Foundry to create a cluster specification and deploy a Spring app". Il a configuré et lancé un cluster depuis le site http://www.cloudfoundry.com/

Les slides de sa présentation sont ici.

Jeremy Grelle est le leader de Spring Faces, Spring JavaScript, Spring BlazeDS Integration.
C'est aussi un membre de l'Expert Group JSF 2.0.

Il a d'abord fait une petite intro très rapide sur JSF et il a distingué 2 approches : l'approche centrée JSF et l'approche centrée Spring.

Dans l'approche centrée Spring, Spring et Spring WebFlow sont utilisés :

• en tant que fournisseur de beans managés
• en tant que request dispatcher
• en tant que navigation handler
• en tant que state manager

Spring WebFlow permet d'introduire la conversation dans JSF (implémentation de web flows pour des stateful conversations).

Les bénéfices d'une approche centrée Spring :

• contrôle total des URLs : RESTful MVC
• une logique de contrôle UI plus concise et plus puissante
• une gestion de l'état plus fine (FlowScope, ViewScope, FlashScope)
• un seul modèle à apprendre

Puis il nous a donné un aperçu très bref de ce qu'on peut faire avec Spring Faces. Il a donné des exemples de Spring Faces components :

• decoration d'un text field avec un tool-tip : <sf:clientTextValidator ...>
• <sf: commandButton ...>
• <sf: clientDateValidator ...>

Les choses que Spring Faces permet de résoudre :

• la prolifération d'un fichier XML de configuration verbeux (grâce aux annotations)
• faible performance / surconsommation de mémoire
• POST seulement / manque de contrôle des URLs
• problèmes d'utilisation du bouton BACK dans le browser

Ensuite il a fait une demo d'une intégration centrée sur Spring avec l'application Travel, pour montrer comment WebFlow s'intègre à JSF (web.xml, webflow-config.xml, main-flow.xml).
Extrait de main-flow.xml :

<view-state id="enterSearchCriteria">
<on-render>...</on-render>
<transition on="cancelBooking">...</transition>
...
</view-state>

Si JavaScript est désactivé, la page fonctionnera toujours, le rendu sera juste différent. Contrairement à JSF.

Spring Faces 3.0 roadmap :

• Avan la fin de l'année. Sera basée sur JSF 2.0

De nombreux slides de la présentation ont été repris d'une ancienne présentation de Keith Donald.

Arjen Poutsma est Principal Software Engineer chez SpringSource et le development lead de Spring WebServices.

Le sous-titre de sa présentation était : "RESTful web applications with Spring 3.0"

Il a d'abord rapidement présenté REST et ensuite décrit une par une les implémentations RESTful dans Spring 3.0 :

• RESTful URIs :
  Avec des URLs, des paths, des Query Variables ...
• URI templates :
  Ces chaînes peuvent contenir 1 ou plusieurs variables.
  - @PathVariable : permet d'utiliser des URI templates dans MVC
  Exemple :

@Controller
@RequestMapping("hotels/{hotels}")
public class HotelsController {
        @RequestMapping
        public void handleHotel(@PathVariable("hotel") String hotel) {
                ...
        }
        ...
}

• Content negotiation :
  C'est l'accès à des ressources via des représentations
  Views : MarshallingView, AtomFeedView, RssFeedView (vient dans Spring 3.0)
  Il a fait une démo de content negotiation dans l'application Pet Clinic.
• HTTP method conversion :
  Les URLs doivent pouvoir supporter les 4 méthodes HTTP : GET, POST (non idempotent), PUT, DELETE (idempotent). C'est géré dans Spring 3.0
• RestTemplate :
  Une nouvelle classe RestTemplate pour les accès HTTP côté client. Suivi d'une démo (affichage dans une JFrame de photos venant de Flickr).
• ETag support :
  Pour résumer, Spring 3.0 facilitera la création d'applications web RESTful.

Les slides de la présentation sont là.

Le blog de l'auteur apporte des éclaircissements.

Cette présentation a été faite conjointement par Enrique Duvos (Group Manager chez Adobe) et Jeremy Grelle (cette fois-ci en tant que leader de Spring BlazeDS Integration).

Flex semble être le choix le plus évident quand un développeur Spring souhaite faire des Rich Internet Applications (RIA).

Enrique Duvos a commencé par présenter le projet open source Flex, basé sur ActionScript et MXML.

Il a eu l'occasion de nous faire une démo en live avec sa webcam à partir du site http://ge.ecomagination.com/smartgrid/#/augmented_reality

BlazeDS (open source) est un fichier war à déployer et qui intercepte les appels qui proviennent du player Flash.

Jeremy Grelle a ensuite brièvement expliqué que l'intégration de Flex dans Spring est pour le moment complexe. Mais un nouveau sous-projet dans le portfolio web vise à faciliter cette intégration : Spring BlazeDS Integration.

Il a fait une démo en modifiant les fichiers web.xml, web-application-config.xml, services-config.xml, remoting-config.xml.

La version 1.0 est prévu pour le 15 mai 2009.

Enfin il nous a invité à jeter un coup d'oeil à Spring ActionScript.

Le sous-titre de la présentation était "A glimpse into the future".

Juergen Hoeller a commencé la session en précisant que les specs Java EE 6 ne sont pas encore définitives.

Spring reste encore majoritairement utilisé sur des projet autour de Java 1.4. Il a bien précisé que Spring 2.5 s'est aligné sur Java EE 5 et que Spring 3.0 s'alignera sur Java EE 6.
Puis il a fait une overview des nouveautés de Java EE 6, en analysant l'impact sur la prochaine version de Spring (3.0), point par point :

• Java EE 6 Web Profile :
  Servlet, JSP, JSTL, JSF, JTA, JPA, EJB 3.1 Lite ==> n'impacte pas vraiment Spring en tant que framework.
• Servlet 3.0 :
  - support de l'auto-déploiement dans le framework (minimalise le fichier web.xml, support de l'auto-déploiement du Spring web context)
  - support pour les Comet endpoints (gestion des requêtes HTTP asynchrones)
  - Spring MVC supportera les requêtes Comet en tant que type spécial de request/response.
  Prévu dans Spring 3.2 (début 2010).
• JSR-236 Concurrency Utilities for JavaTM EE:
  Un scheduling adapter basé sur l'API de la JSR-236 mais c'est encore incertain car ce n'est pas sûr que ce soit dans Java EE 6.
• JSF 2.0 :
  Les annotations @ManagedBean, @ManagedProperty sont similaires aux annotations @Component and @Value. Spring continuera de supporter JSF.
• JPA 2.0 :
  JPA 2.0 appporte des améliorations dans le mapping, des locks modes, des query timeouts ...
  Spring 3.0 prendra en compte ces nouveautés.
• JSR-303 Bean validation :

public class Reward {
    @NotNull
    @Past
    private Date transactionDate;
}

Dans la view : <form:input path ="transactionDate">

C'est supporté dans JSF 2.0 et JPA 2.0

Ce sera également supporté dans Spring 3.0

• JAX-RS :
  JAX-RS ressemble à Spring MVC. Spring 3.0 fournit du support REST dans Spring MVC. JAX-RS sert en tant que modèle alternatif.
• EJB 3.1 :
  - ajout de beans singletons
  - invocation de méthode de façon asynchrone
  - convention de nommage JNDI par défaut des EJBs
  - EJB 3.1 Lite

@Singleton @Startup
@DependsOn({OtherBean1", "OtherBean2"})
public class SharedService {
    private Data sharedData;

    @PostConstruct
    public void init(){
     this.sharedData=...;
    }

    @Lock(READ)
    public String returnSharedDataValue(){
      return this.sharedData;
    }
}

Bien évidemment Spring n'a pas vocation à devenir un container d'EJB.

• JSR-299 Web Beans, renommée JCDI (Java Contexts and Dependency Injection) :
  @ConversationScoped, @Initializer, @Selected
  La mission originelle ce cette JSR était de fournir une nouvelle version des managed beans JSF, pour faciliter l'intégration avec les EJBs.
  Comme la JSR n'est pas finalisée, le support dans Spring 3.0 n'est pas sûr.

Guillaume Laforge est le responsable du développement Groovy. Il est le co-auteur de Groovy in Action et le Spec Lead de la JSR 241.

Les exemples de la présentation sont basés sur un article qu'il a écrit : http://www.infoq.com/articles/groovy-1-6.

Le sous-titre de la présentation était : "An introduction to Groovy and the new features in 1.6".

Il nous a présenté Groovy, un langage dynamique pour la JVM et projet Open source Apache.

Un développeur Java est aussi un développeur Groovy. Nous avons eu droit au classique exemple Hello World : il est parti d'un programme Java (20 lignes environ) qu'il a petit à petit dépouillé pour le transformer en programme Groovy (5 lignes environ).

La Groovy web console permet de faire du Groovy sans l'installer.

C'est orienté-objet, peut compiler des programmes Java et Groovy en même temps, gère les closures (des blocs réutilisables de code), utilise des properties à la place des getters/setters, gère les expressions régulières etc.

Des Groovy builders existent, tel que le Markup builder, une façon facile de créer du contenu XML ou HTML.

Les nouveautés dans Groovy 1.6 :

• Amélioration de la performance (à l'exécution et à la compilation) grâce à une classe intelligente qui fait un lookup du cache. Le compilateur Groovyc est 3 à 5 fois plus rapide. Groovy 1.6 est donc plus rapide que Groovy 1.5.
• nouvelles syntaxes :
  - possibilité d'assigner plusieurs variables en une fois : def (a,b) = [1,2]
  - possibilité d'utiliser / définir des annotations
• meta-programming, c'est-à-dire la possibilité pour un langage de se modifier. Groovy 1.6 introduit les transformations AST (Abstract Syntax Tree).
  Par exemple, pour définir une classe singleton, il suffit de l'annoter @Singleton. De même pour définir une classe immutable, on utilisera l'annotation @Immutable. D'autres annotations : @Lazy, @Delegate ...
• Le GrapeModuleSystem qui est le moteur avancé de Groovy pour le packaging (@Grab)
• améliorations pour Swing :@Vetoable, @Bindable ... Ensuite il a fait un peu de pub pour Griffon, le framework Swing MVC : http://griffon.codehaus.org/
• des additions dans le runtime metaprogramming
• JSR-223 : dans Groovy 1.6, le moteur de script javax.script.* (JSR-223) est intégré dans Groovy.
• JMX Builder

La présentation est déjà disponible sur slideshare.

Ben Alex est le créateur de de Spring Security (Acegi).

Cette présentation a surtout été une introduction à Spring Security 2.5 (en fait un rappel pour la plupart des personnes qui ont assistés à la session), avec des démos pour l'utiliser dans des web apps.

Les domaines couverts sont :

• l'authentication
• l'authorization
• l'authorization d'invocation de méthodes
• ACLs (sécurité suivant des instances de domaines)
• détection d'un utilisateur humain

Spring Security fonctionne bien avec Jcaptcha, AspectJ, OpenID, JAAS ...

C'est utilisé dans des web apps, mais également dans des jobs de batchs, des clients riches (Swing, SWT, Flex, GWT ...), des tests d'intégrations ...

Tout le code des démos est dans le tutoriel en ligne.

• Demo 1: easily securing an unprotected web app
• Demo 2: using a custon login page
• Demo 3: basic authentication
• Demo 4: LDAP authentication
• Demo 5: cross site request forgery
• Demo 6: declarative web authorization
• Demo 7: EL method authorization
  C'est une nouveauté : l'utilisation des EL.
  Exemple :

@PreAuthorize('hasRole('ROLE_X') or (hasRole('ROLE_Y') and (#account.balance < 1000))')

Guillaume Laforge a commencé par faire une rapide présentation de Groovy.

Il a ensuite donné des exemples concrets de DSLs : expressions régulières, SQL, notation des mouvements des pièces aux échecs, notation Rubik's cube, les notes de musique …

Dans Groovy, les caractéristiques d'un DSL sont présentes. Par exemple les parenthèses et point-virgules sont optionnels, le type BigDecimal par défaut pour les nombres décimaux, l'utilisation de closures …

Puis il a rapidement parlé du MOP (MetaObject Protocol), de l'interface GroovyObject, du Builder pattern avec le Groovy MetaBuilder et enfin de GroovyShell.

Enfin il a fait un peu de pub pour la GR8 Conference, qui se tient à Copenhague, au Danemark, les 18 et 19 mai 2009 et qui est consacrée principalement à Groovy, Grails et Griffon .

La présentation est déjà disponible sur slideshare.

Spring JavaScript supporte le Dojo Toolkit.

Jeremy Grelle a d'abord fait un survol rapide d'Ajax en évoquant les technologies DOM, CSS, XMLHttpRequest (fait partie de l'API JavaScript pour les requêtes asynchrones), JSON (JavaScript Object Notation).

• Introduction à Spring JavaScript :
  - framework JavaScript
  - implémentation d'API publique. Pour le moment c'est DoJo 1.2 mais ils pensent prochainement à également implémenter jQuery.
  - une approche pragmatique
  - ajout d'Ajax de façon transparente
  - rendu partiel de page
  - la servlet générique ResourceServlet pour retourner des ressources statiques (gif, js, css, jpeg, etc) - les fichiers à inclure sont : dojo.js, Spring.js, Spring-Dojo.js, tundra.css
• Spring JavaScript decorations :
  - utilisé pour améliorer un node DOM - la méthode Spring.ElementDecoration transforme un champ HTML en un riche widget, requiert "elementId" et "widgetType"
  - la méthode Spring.addDecoration permet d'ajouter une infobulle
• L'Ajax event decoration :
  - requiert "elementId" et "event"
  - ValidateAllDecoration empêche la soumission d'un formulaire si un champ est invalide
• Les forms Ajax :
  - soumettre une form dans un appel Ajax
• Rendu de fragment :
  - fait des updates partiels
  - un appel Ajax rafraîchit des fragments d'une page (paramètre "fragments")
• Une preview de Spring JavaScript 3.0 :
  - but : une intégration claire avec Dojo
  - JSON view (rendre une représentation JSON de ressources RESTful)
  - binding JSON
  - support de JSON-RPC 2.0
  - référencement JSON

Il a fait des démos avec la classique application "Spring Travel".

Dylan Schiemann est le co-fondateur du framework Javascript Dojo Toolkit et le CEO de sitepen.

Fin de conférence oblige, il restait très peu de personnes pour assister à cette dernière session.

Malgré la qualité et la bonne humeur de l'orateur (une bière à la main pendant toute la session, il était visiblement prêt pour attaquer le lendemain le Koninginnedag's day), j'ai été un peu déçu par cette présentation. Pas de détails quant à l'intégration avec Spring 3.0 d'une part et d'autre part pas de description détaillée de Dojo.

De plus, sa démo n'a pas marché.

J'ai néanmoins appris que Dojo compte environ 60 committers, que la librairie Dojo fait 26 KB seulement, et qu'il travaille aussi sur le projet ComedD qui permet de réduire la latence, c'est-à-dire le temps qu'il faut pour envoyer une requête au client depuis le serveur.

Et qu'il fait énormément de conférences ces temps-ci à travers le monde !

Dylan Schiemann animera un workshop Dojo payant, à Paris le 10 juin 2009. Pour s'inscrire à la formation : http://dojoparisworkshop.eventbrite.com/