Veille technologique semaine 3

Pour le bulletin de cette semaine, je vous propose les sujet suivants :

• la fin de SUN confirmé par le père de Java : James Gosling,
• l'histoire d'un projet : toute ressemblance est fortuite ...,
• une présentation des Solid State Drive : SSD. Il y a un garbage collecteur !,
• suite sur le model driven et la programmation par aspect :
• Le HTML 5 et la video : l'offensive de YouTube, Vimeo, ...,
• 2010 : l'année de la modularité : dm Server, OSGi, ...,
• Le framework DataNucleus passe en version 2 : intègre les standards de persistance JDO, JPA sur plusieurs base de données. C'est le framework retenu par Google pour Google App Engine,
• Le deuxième article sur l'injection de dépendance du standard JEE 6,
• La sortie du JDK 6 update 18 : correction de bugs et performance améliorée (le garbage collector G1 (Garbage first) en particulier).

Bonne lecture.


So long, old friend...


C'est l'histoire d'un projet…
C'est l'histoire d'un projet, pas plus complexe que d'autres, pas plus simple non plus : une
application qui s'interface avec une base de données et 2 systèmes tiers. Du classique du point
de vue technique et architecture, du standard également du point de vue management : il faut
tout faire pour hier et il y a beaucoup à faire…bref, « ca va être chaud! » comme disent souvent
les développeurs mais personne ne le crie trop fort.

Alors on « staffe », on monte à 40 personnes, on spécialise les gens, on contractualise entre les
équipes. Les équipes s'organisent en pools, répondant à certaines demandes puis redispatchant d'autres demandes à d'autres pools. Un flux de demandes s'organise, certains pools chauffent et deviennent le « goulot d'étranglement », un stock se crée en amont alors que les équipes en aval attendent…Dès lors et pour ces pools en surchauffe, l'important devient l'urgent, il faut choisir parmi l'urgent pour répondre à l'immédiat, switcher de tâches en permanence et au final, la chaine globale ralentit.

En complément, les reportings commencent à virer au rouge dans les premiers niveaux de management. Mais au fur et à mesure de l'escalade de ces mêmes reportings dans la hiérarchie, ces derniers virent au vert tant et si bien qu'en « haut » : tout va bien. Absence de priorisation ou le « il faut tout faire » Pression du management ou la culture de la peur. A quelques semaines de la mise en production et alors que l'organisation en place chauffe, décision est prise de rajouter de la main d'oeuvre « everything fails all the time ». Pourquoi ne pas jouer avec et arrêter de l'ignorer ?


Comprendre les Solid State Drive
Depuis quelques années, les SSD font beaucoup parler d'eux. En effet, ces supports de stockage a base de mémoire flash sont très prometteurs, car ils permettent en théorie de se débarrasser de l'un des plus gros défauts des disques durs : les latences induites par le déplacement des têtes de lecture et la rotation du disque, qui sont de l'ordre de la dizaine de ms. A notre échelle, cela peut paraitre peu, mais à l'échelle d'un ordinateur dont le processeur fonctionne à plusieurs GHz, une attente de 10ms représente plusieurs millions de cycles d'horloge.

• La mémoire flash
• MLC, SLC
• Secteurs, pages, blocs...
• Wear-leveling
• TRIM
• Garbage collector
• Contrôleurs: les forces en présence
• Contrôleurs: qui utilise quoi ?
• Conseils d'utilisation
• Éviter les écritures inutiles
• Ne pas défragmenter
• Que faire du fichier swap ?
• Surveillez les évolutions des systèmes d'exploitation
• Journal ou pas?
• Utiliser un système de fichier pour flash ?
• Conclusion

The Role of Aspect-Oriented Programming in OMG's Model-Driven Architecture
A fundamental challenge of software development is bridging the vision of an application
to its realization. In practical terms, if we capture the vision in use cases and
requirements, without the distractions of implementation details, how then do we
generate conforming implementations on real platforms, while accounting for platform
idiosyncrasies, limitations, and other constraints? Despite years of research, this
generation process remains difficult. Fortunately, there are emerging technologies that
bring software generation closer to reality.

Model-Driven Development is one approach to this challenge, where the problem domain
is modeled at a high level of abstraction and the implementation is derived from these
models. The Object Management Group (OMG) has articulated a particular vision of
MDD called Model-Driven Architecture. MDA will include standards for modeling
problem domain specifications and mapping techniques for generating implementations
from them.

However, the challenge for MDA and other MDD variants is to define all these standards
and to make them work on real projects. This article describes how a new methodology,
Aspect-Oriented programming (AOP), helps make this possible.
What Is MDA?

• The Challenge for MDA
• Aspect-Oriented Programming (AOP)
• How AOP Helps MDA
• Aspect-Oriented MDA
• Conclusions

YouTube se lance dans le HTML 5

YouTube vient de lancer la version beta de son service en HTML 5. Concrètement, il suffit d'activer l'option sur cette page pour voir le format Flash disparaître de votre navigateur. Le format choisi par YouTube est le H.264, ce qui limite la chose aux navigateurs tels que Chrome et Safari (quoi qu'il soit également possible d'y accéder avec Internet Explorer pour peu que ses utilisateurs aient choisi d'installer le plugin Chrome Frame).

La nouvelle est de taille car elle apporte un soutien de poids au codec H.264, alors que le W3C est perclus de querelles intestines quant au standard à adopter. Dailymotion pour sa part propose une version HTML 5 qui propose tant le H.264 que l'Ogg Theora, préféré par Mozilla Firefox.

Une fois la fonction activée dans YouTube, toutes les vidéos s'afficheront sans Flash, du moins celles qui sont disponibles au format H.264, sans avoir à modifier l'adresse URL, la bascule est donc transparente (à noter cependant que l'option peut ne pas être disponible suivant les autres options que vous avez pu activer dans le "testtube"). Sur Dailymotion en revanche il faut précéder l'adresse d'une vidéo du TLD "openvideo" pour avoir sa version HTML 5.

Cependant, cette version HTML 5 n'est pas exempte de défauts : il est impossible de basculer la lecture en plein écran, les annotations ne sont plus visibles, pas plus d'ailleurs que les publicités (ce que vous considérerez comme un avantage ou un inconvénient selon que vous êtes simple visiteur ou que vous cherchez à monétiser vos vidéos).

D'autre part, à l'inverse de Flash, le HTML 5 ne permet pas d'empêcher d'intégrer une vidéo dans un autre lecteur que celui de YouTube, un problème que la plupart des diffuseurs ont soulevé auprès du groupe de travail dédié au futur standard du web. Ainsi, il est possible à un concurrent de YouTube de diffuser les vidéos hébergées sur ses serveurs et de les afficher dans son interface maison comme si de rien n'était…

Bref, il reste encore beaucoup à faire pour que le HTML 5 soit une alternative viable pour tous les acteurs, mais on peut malgré tout commencer à en profiter dès maintenant.


Vimeo se lance (aussi) dans le HTML 5

C'est la fête à Flash depuis 24h, après YouTube c'est au tour de Vimeo, l'un de ses concurrents, d'annoncer également un accès à ses vidéos selon la norme HTML 5. Vimeo n'a pas la surface du service de Google (et il est en partie payant pour l'hébergement) mais il a su gagner ses galons au fil du temps par la qualité de ses encodages, il fut l'un des premiers par exemple à se mettre à la HD. 90% des films uploadés en 2009 sont lisibles en HTML 5. Sur la totalité du fond, 35% nécessite encore Flash.

La bascule d'une vidéo Flash vers son équivalent HTML 5 se fait par un lien en bas à droite de chaque clip. Pour le moment ça ne fonctionne que sur le site de Vimeo, et pas encore pour les vidéos intégrées dans des pages externes. Pas de lecture plein écran non plus.

Pour les avantages, on retrouve les même que chez YouTube : temps de chargement plus rapide, possibilité d'avancer dans la vidéo sans attendre que la section désirée soit déjà en cache et normalement une meilleure fluidité de lecture avec une pression relâchée sur les processeurs. Il faut toutefois souligner que cette prestation est encore en bêta.


Google fights Flash, adds HTML5 support for YouTube videos
Google this week added support for HTML5 playback of videos in its own Chrome browser as well as Safari from Apple. The new feature allows users to watch video without the longstanding Internet standard: Adobe Flash.

YouTube's HTML5 support is offered through a beta opt-in program and is currently only available with browsers that support both HTML5 and H.264 video encoding.

This limits the beta to Google's Chrome and Apple's Safari browsers. Microsoft's Internet Explorer is also supported if Google's Chrome Frame is installed.

The HTML5 player fully replaces the Flash player for most videos on the site, but some limitations do exist. Videos with advertisements are currently not supported, and will play instead in the Flash player. Fullscreen playback is also not yet supported.

YouTube refers to the opt-in as "an experiment" and welcomes feedback from the community on its HTML5 integration.

HTML5 allows video to be rendered natively inside the browser, as opposed to Flash which requires a browser plug-in to be installed.

Flash is still not supported on Apple's iPhone. Major sites that use Flash for video on the web, including YouTube, CBS Mobile, and the BBC, now push standard H.264 video to the iPhone directly.

Beginning Thursday, video site Vimeo also will begin to support HTML5 playback. Playback using the HTML 5 standard is available on the same browsers that YouTube supports: Chrome, Safari, and IE with Chrome Frame.


YouTube announces HTML5 demo, but not for FireFox 3.6
YouTube have announced a beta of HTML5 support. These are broadcasting videos in H.264 format for browsers that understand HTML5's tag. The choice of H.264 is perhaps unsurprising, since that's what Apple's iPhone supports natively (and indeed, is how the YouTube mobile application is rendered). This means that other browsers that don't support H.264 won't be able to render content. The initial supported list includes Safari 4+, Google Chrome and the Chrome Frame plugin for Internet Explorer. Although FireFox 3.6 was released today with HTML5 support, it only supports the open-source OGG video format.


Bundle.update: The Year of Modularity
A lot seems to have happened since the last Bundle.udpate, despite the usual vacation slowdown that happens at this time of year.


DataNucleus AccessPlatform 2.0 Released
DataNucleus AccessPlatform 2.0.0 has just been released. AccessPlatform provides access to a range of datastores for Java applications using JDO/JPA API's. It is fully compliant with JDO1, JDO2, JDO2.1, JDO2.2, JPA1, as well as providing complete JDO2.3 support, and the majority of JPA2. It currently supports persistence to RDBMS, db4o, NeoDatis, LDAP, XML, Excel, ODF, JSON, Amazon S3, HBase (HADOOP), as well as Google AppEngine BigTable.

AccessPlatform additionally allows configuration of classes to be persisted using JDO annotations/XML/API or JPA annotations/XML providing access to both JDO and JPA persistence APIs regardless of which configuration method was chosen, offering flexibility not seen in any other persistence tool. Querying of the supported datastores can be performed using JDOQL, JPQL or SQL (dependent on the datastore). By making use of standardised APIs, the process of swapping persistence from one datastore to another is a simple URL change when specifying the datastore. AccessPlatform is made up of a series of OSGi compliant jars, and can be utilised in J2SE, J2EE, or OSGi container environments. By using OSGi together with Eclipse extension-points, DataNucleus is highly extensible so if you wanted to provide support for your own datastore then this would be a relatively simple procedure. DataNucleus Access Platform is licensed under the flexible Apache 2 license.

DataNucleus Access Platform 2.0 provides the following over and above what DataNucleus 1.x provides :-

• Significantly reworked internal API's to aid easier support for other datastores, and datastore features in the future
• Support for persistence to Amazon S3
• Support for persistence to HBase (HADOOP)
• Support for persistence to Oracle Timesten
• Support for persistence of JodaTime fields
• Support for auto-generation of primary key classes during enhancement
• Change default for non-transactional read/write to true for JDO
• Support atomic non-transactional write persist/delete operations
• Level 2 Cache is now enabled by default (soft)
• Split query cache into 3 components : generic compilation, datastore compilation and query results. Added API for managing caching of query results (using JDO or JPA).
• Cache : Support for pinning/unpinning of query results with Memcache/javax.cache
• Support for JDO 2.3 Query cancel, and datastore read/write timeout
• Support for explicit JPA extended persistence context
• Support for JPA2 metamodel API
• Support for bean validation with JPA2
• Support for various new JPA2 JPQL keywords
• Support for JPA2 1-N FK bidirectional relations
• Support for JPA2 1-N collection/map of non-persistable objects.
• Support for JPA2 TypedQuery
• Support for update/delete-by-query for RDBMS (JPQL)
• Rewritten RDBMS JPQL implementation building on generic query compiler. This is now the default JPQL implementation for RDBMS, and can be used with the query caching mechanism.
• Rewritten RDBMS JDOQL implementation building on generic query compiler. This is not currently the default JDOQL implementation but is available to be used, and can be used with the query caching mechanism.
• LDAP : Support for persistence of recursive object graph to hierarchical structure
• Add support for PMF/EMF singleton pattern, via persistence property
• Spatial : Many fixes to handling of JTS types.

Many bug fixes, and minor feature additions.

Documentation is available to view online (HTML) or available to download (HTML/PDF).
Limited free support for AccessPlatform is provided by way of our forum. Commercial support and consulting is also provided.


This is the second part of a multi-article series.
Dependency Injection in Java EE 6 - Part 2

This series of articles introduces Contexts and Dependency Injection for Java EE (CDI), a key part of the Java EE 6 platform. Standardized via JSR 299, CDI is the de-facto API for comprehensive nextgeneration type-safe dependency injection as well as robust context management for Java EE. Led by Gavin King, JSR 299 aims to synthesize the best-of-breed features from solutions like Seam, Guice and Spring while adding many useful innovations of its own.


Sun Releases Java 6 Update 18 With Significant Performance Improvements and Windows 7 Support
Sun have released Java 6 update 18 with a strong emphasis on performance improvements, including a new version of Hotspot (16.0), start-up improvements and run-time improvements for UI applications. The release also includes support for Ubuntu 8.04, Red Hat Enterprise Linux 5.3 and Windows 7, along with an impressive 357 bug fixes.


Performance Improvements
• Java Hotspot VM 16.0
6u18 includes version 16.0 of the Java HotSpot Virtual Machine.
Contributing to increased performance in this release are several
enhancements in Java HotSpot VM 16.0. These include:

• Improved NUMA-aware allocation
• Extensions to compressed object pointers

• Garbage collection improvements
• Updated Client JVM heap configuration

In the Client JVM, the default Java heap configuration has been modified to improve the performance of today's rich client applications. Initial and maximum heap sizes are larger and settings related to generational garbage collection are better tuned.

• The default maximum heap size is half of the physical memory up to a physical memory size of 192 megabytes and otherwise one fourth of the physical memory up to a physical memory size of 1 gigabyte.

For example, if your machine has 128 megabytes of physical memory, then the maximum heap size is 64 megabytes, and greater than or equal to 1 gigabyte of physical memory results in a maximum heap size of 256 megabytes.

• The maximum heap size is not actually used by the JVM unless your program creates enough objects to require it. A much smaller amount, termed the initial heap size, is allocated during JVM initialization. This amount is at least 8 megabytes and otherwise 1/64 of physical memory up to a physical memory size of 1 gigabyte.

• The maximum amount of space allocated to the young generation is one third of the total heap size.
• The updated heap configuration ergonomics apply to all collectors except Concurrent Mark-Sweep (CMS). CMS heap configuration ergonomics remain the same.
• Server JVM heap configuration ergonomics are now the same as the Client, except that the default maximum heap size for 32-bit JVMs is 1 gigabyte, corresponding to a physical memory size of 4 gigabytes, and for 64-bit JVMs is 32 gigabytes, corresponding to a physical memory size of 128 gigabytes.

• Work stealing termination
• Work queue overflow processing
• Bit set processing on 64-bit Linux
• Class loading optimizations for faster startup (see Bug Fixes section)

• Code generation improvements
• New intrinsics using SSE 4.2
• New intrinsics for Integer/Long bit operations - leading/trailing zeros, bit count
• Unsigned byte and integer loads
• Integer load shortening
• Elision of needless conversions between integer primitive types
• Optimization of common string concatenation patterns

• Garbage First (G1) garbage collector
• Improved reliability and performance
• Available as "early access" software. Usage of G1 in production settings without a Java SE for Business support contract is not recommended.

For more information about G1, see the G1 technology page.

In addition to performance enhancements, HotSpot VM 16.0 offers improved reliability and serviceability.

• Serviceability enhancements
• New options to request a heap dump or class histogram before or after a full GC
• New tool to decode LogCompilation output

• Extensive reliability improvements (see Bug Fixes section)

Note that Escape analysis-based optimization (-XX:+DoEscapeAnalysis) is disabled in 6u18. This option will be restored in a future Java SE 6 update.

Veille technologique semaine 2

Pour le bulletin de cette semaine, je vous propose les articles suivants :

• les langages les plus populaires en 2009,
• sortie du JDK 6 update 18 avec une liste importante de correction de bugs et des améliorations de l'outil VisualVM,

• la colocalisation et l'efficacité des équipes,
• le livre "Le mythe de l'homme mois" : un "best of" de 35 ans,
• programmer, c'est aussi communiquer,

• la conception par contrat : Bertrand Meyer nous rappel les bonnes pratiques pour la définition des interfaces,
  Avez vous des interfaces de services avec des pré et post conditions bien définies et documentés ?
• Les bonnes raison de mettre les closures dans le JDK 7,
• Les websocket du HTML 5 : le push devient accessible,

• Les performances des applications distribuées,
• Les moteurs de règles : Drools ?
• SUN propose un composeur visuel pour JavaFX,
• JavaFX : cela intéresse-t-il le marché ?,
• Le projet Lombock : réduction du code par les annotations,
• IntelliJ IDEA est proposé avec une version community (gratuite).

bonne lecture.

Popular Languages of 2009
The TIOBE index for 2009 says that Google's new Go programming language experienced more growth in popularity than any other language in 2009. The growth is quite remarkable given that the language became available late in the year. Is it all just hype? The Google brand certainly carries a lot of power and marketing capability with it. Based on TIOBE's system, Go and Objective-C had the biggest gains in 2009 with Java taking a slight hit, but remaining at the top. TIOBE calculates its index based on search engine hits.

Object-Oriented Languages still have the majority of the index share with 54.6% while Procedural Languages (41.5%) made a 1.4% jump thanks to Go. Statically Typed Languages and Dynamically Typed Languages are about a 60/40 split in favor of Statically Typed.


Java 6 Update 18: Now With Windows 7 Support
Java 6 Update 18 is now available for download. One of the main features of this release is the inclusion of support for Windows 7. Along with an impressive list of bug fixes, the update includes performance improvements, an update to JavaDB and the inclusion of the latest version of the Java profiling tool, VisualVM. This update is bound to be popular, while we wait for the final milestone of JDK 7, expected this September.


Ce que la science nous dit de la colocalisation
Les méthodes agiles recommandent la colocalisation des acteurs (i.e. une localisation physique dans un même bureau) pour une meilleure communication, une meilleure collaboration et globalement une équipe ou un processus projet plus performants.

Même dans le cas d'équipes « colocalisables » dans les faits, on mesure la distance de la coupe aux lèvres lorsque les organisations doivent faire le pas et que les obstacles se dressent, notamment :

• une remise en cause délicates des frontières organisationnelles dès lors que des acteurs de différents silos sont amenés à partager au quotidien un même espace de travail (ex : MOA/MOE/marketing/intégration/exploitation…);
• des demandes d'aide pour le moins fastidieuses vis-à-vis des tout puissants « services généraux » ;
• un impact sur l'ensemble des acteurs projet, au-delà de la population des développeurs, seule astreinte aux nouvelles disciplines comme le pair programming, TDD ou l'intégration continue.

Les multiples réticences à la mise en place d'équipe colocalisées ou le débat au sein de la communauté agile doivent nous inciter à étayer notre discours plus solidement que « c'est une bonne pratique agile qui est indispensable/facultative » ou « la colocalisation/non-colocalisation a bien/mal marché dans nos projets précédents ».


Présentation du livre "The Mythical Man Month"
Pourquoi lire ce livre ?
Premièrement, si vous ne connaissez pas ce livre, même de nom, vous connaissez peut-être la célèbre expression : "ajouter des hommes à un projet en retard, ne fait que le retarder encore plus". Cette idée a donné son titre à cet ouvrage. Et si cette expression ne vous a rien dit, peut-être que celle-ci vous parlera : "Malgré les nouveaux outils, il n'y a pas eu de gain significatif de productivité depuis les années 90.

Dois-je conseiller ce livre à mon chef de projet/manager ?
Oui, ce livre est intéressant pour les chefs de projet et les managers. Certains chapitres ont plus d'intérêts que d'autres. Parmi ceux-ci, les parties documentation, planification et communication fournissent des thèmes récurrents dans les projets. Cet ouvrage permet également d'ouvrir les yeux sur certains sujets.

Par exemple :
En cas de retard sur votre projet, est-ce qu'ajouter une personne me permettra de rattraper ce retard ; Est-ce que je gère un planning qui me permet de gérer les priorités en cas de retard ; Comment je gère ma documentation, comment je la maintiens et comment la partager entre ceux qui l'écrivent et ceux qui la lisent.


Programming is also teaching tour team
Programming has two goals.

• One goal is to do something, of course: calculate an amortization table, present a list of updated feeds, snipe someone on Ebay, or perhaps smash a human player's army. This goal is focused at a computing environment.
• The other goal is - or should be - to transfer knowledge between programmers.

Design by Contract
Bertand Meyer, the designer of the Eiffel programming language, was one of the early proponents of the importance of contracts. In "A Conversation with Bertrand Meyer, Part II - Design by Contract" (http://www.artima.com/intv/contracts.html), he puts it this way, "The main purpose of contracts is to help us build better software by organizing the communication between software components through specifying, as precisely as possible, the mutual obligations and benefits that are involved in those communications."

Taking it somewhat deeper, an effective contract specification provides an unambiguous description of the interface syntax and semantics - what it looks like and how it behaves. The contract defines the operations offered by the interface, the inputs, the outputs, and the effects.

Contracts should exhibit well-known design quality attributes such as
separation of concerns, high-cohesion, loose-coupling, granularity and
degree of element interactions and others.

For today, let's just emphasize one: the separation of concerns which engenders the ability to organize the development effort around the architecture. Effective contract definition allows individuals or teams to be assigned responsibility for delivery of specific subsystems or components, understanding how that functionality is integrated to the overall system. In other words, contracts help us to divide and conquer.

What's a Contract?
Bertrand Meyer talks with Bill Venners about Design by Contract and the limits of formal languages for expressing contracts.

The main purpose of contracts is to help us build better software by organizing the communication between software components through specifying, as precisely as possible, the mutual obligations and benefits that are involved in those communications. The specifications are called contracts.


Mark Reinhold justifie l'introduction des closures

C'était l'Annonce de cette édition de Devoxx, l'apparition des closures en Java 7. Mark Reinhold revient, sur son blog, sur les raisons à l'origine de cette petite bombe.
Il justifie cette évolution majeure du langage par la nécessité pour Java de tirer partie des nouvelles générations de processeurs, multi-cœurs.
Jusqu'ici, pour exploiter cette puissance, il fallait utiliser des Parallel Array et tout le code inutile nécessaire à leur fonctionnement. Les closures permettent de supprimer ce code, et il est temps de les introduire en Java.
Java doit se concentrer sur deux fonctionnalités clés : la syntaxe littérale, et les fonctions typées. L'arrivée des closures requiert deux autres évolutions de Java : les conversions, et l'extensibilité des méthodes.
Il est temps pour Mark Reinhold d'oublier les querelles. Sun spécifiera et implémentera un premier jet des closures pour le JDK 7. Cela permettra une expérimentation à grande échelle, et si tout se passe bien, cela conduira à une JSR de modification du langage, qui pourra être incluse dans Java SE 7.
La tâche est immense et Mark Reinhold appelle bien évidement toutes les bonnes volontés à contribuer.

Bien au-delà de la manipulation du multi-threading, les closures pourraient permettre une simplification des APIs courantes. Cette perspective semble essentielle à Mark Reinhold qui ne pouvait attendre le JDK 8 pour une nouvelle tentative, dans 3 à 4 ans…

HTML 5: les WebSockets sont là !
HTML 5 arrive peu à peu dans nos navigateurs et cherche à standardiser certains aspects du Web : vidéo, offline, ….et push serveur.
Les WebSocket standardisent les API JavaScript mises à disposition par le navigateur pour rendre disponible le push.


Performance Considerations in Distributed Applications
Distribution and Communication between applications and services is a central concept in modern application architectures. In order to profit from distribution you have to keep some basic principles in mind – otherwise you can easily run into performance and scalability problems. During development these problems often do not surface. Then suddenly in load testing or production you might then realize that your chosen software architecture does not support the required performance and scalability requirements. In this post we will look at major points to keep in mind when building distributed applications.


Drools et les moteurs de règles
Lorsque l'on entend parler de moteur de règles, on a souvent tendance à y associer le mot « Drools ».
Pourquoi ce réflexe : Par habitude ? Parce que Drools est l'unique solution du marché Open Source ?

Mais avant j'aimerais répondre à plusieurs questions :

• Qu'est ce qu'un moteur de règles ?
• Quand en a-t-on besoin ?
• Pourquoi en a-t-on besoin ?

Ensuite on pourra présenter Drools !

Qu'est ce qu'un moteur de règles, et pourquoi ?


Sun Releases Early Access Version of RAD Tool for JavaFX
Sun is working on two RAD tools for JavaFX - one targeted at web developers and page content authors, and the other aimed more at Java
developers. A preview version of the latter tool, tentatively called "JavaFX Composer" is now available for download from the NetBeans 6.8 update centre.
"We're not even calling this a beta - we're calling it an 'early access' or preview", said Sun's director of Developer Tools Engineering, David Folk, during a conference call. "What this tool is really about is enabling you to develop form-based applications with JavaFX."

The basic idea behind the new JavaFX tool is similar to Project Matisse for Swing, which simplified Swing development by providing a visual editor much like those found in Visual Basic or Delphi. As with Matisse, which became the NetBeans GUI builder when NetBeans 5 shipped, JavaFX Composer generates code as you work and, whilst you can view the generated source code, it frustratingly cannot be modified.


When Will JavaFX Get Real Community Acceptance?
Even though we're two years on from the 1.0 release of JavaFX, 2010 could be the defining year for the technology. With the mobile device space really taking off, JavaFX has to prove that it deserves to be up there with competing technologies. While some say that it is all too little, too late, I think that JavaFX has one key feature that gives it a fighting chance - an application you write for JavaFX mobile can also work on the web or desktop.

Earlier this week, I asked JavaLobby readers what they would develop their mobile applications with. So far, the overwhelming majority, at about 70% say they would use Android. JavaFX comes in second at just 16%. Despite the low number, I don't think all is lost but I wonder what JavaFX has to do to get buy in from the Java community.


Reducing Boilerplate Code with Project Lombok
Introduction
"Boilerplate" is a term used to describe code that is repeated in many parts of an application with little alteration. One of the most frequently voiced criticisms of the Java language is the volume of this type of code that is found in most projects. This problem is frequently a result of design decisions in various libraries, but is exacerbated by limitations in the language itself. Project Lombok aims to reduce the prevalence of some of the worst offenders by replacing them with a simple set of annotations.


IntelliJ IDEA Open Sourced
Starting with the upcoming version 9.0, IntelliJ IDEA will be offered in two editions: Community Edition and Ultimate Edition. The Community Edition focuses on Java SE technologies, Groovy and Scala development. It's free of charge and open-sourced under the Apache 2.0 license. The Ultimate edition with full Java EE technology stack remains our standard commercial offering. See the feature comparison matrix for the differences.


IntelliJ IDEA Editions Comparison

Veille technologique semaine 1

Pour le bulletin de cette première semaine de l'année, je vous propose les sujets suivants :

• un premier article ironique qui fait une analogie entre le développement logiciel et un hôpital. Cela doit être du vécu ?
• un projet ambitieux de processeur conçu en Chine, pour des raisons d'indépendances.

• La présentation faite par DCNS à la conférence Model Driven Day 2009 proposait d'utiliser les principes de programmation par aspects (AOP) pour aider la mise en oeuvre du Model Driven Architecture. Cet article propose la même conclusion.

• Les 7 principes du KISS : Keep It Simple and Stupid.
  C'est un principe philosophique qui désigne le fait que la simplicité dans la conception devrait être le but recherché et que toute complexité non-nécessaire devrait être évitée. Ce principe très utile est appliqué dans grand nombre de disciplines telles que le développement logiciel, l'animation, le journalisme, la photographie, l'ingénierie, l'aviation et la planification stratégique.
  
  Ce principe est à rapprocher au principe du Rasoir d'Occam aussi appelé « principe de simplicité », « principe de parcimonie », ou encore « principe d'économie », il exclut la multiplication des raisons et des démonstrations à l'intérieur d'une construction logique.

• Le pattern builder en Java avec des interfaces génériques.
• Le service provider du JDK 6 : article en français (j'avait déjà envoyé une version anglaise).

• Un article sur les tuples proposé par le leader de Mono comme évolution du langage C#.

• Les simplifications de la verbosité du langage Java prévue pour le JDK 7.
• Un article très technique sur les optimisations de la JVM pour les "Tail Call" : une méthode qui fait un return en appelant une autre méthode. Optimisation classique des compilateurs.

Bonne lecture.


L'informatique, ou l'art de l'opération au couteau à beurre
Vous êtes à l'hôpital, et vous êtes sur le point de vous faire opérer. Une infirmière a roulé votre lit depuis votre chambre jusqu'à la salle d'opération, traversant un labyrinthe de coulours froids aux murs décrépits dans un grincement de roues lancinant. Puis elle s'est retirée, vous laissant seul.


People's Processor: Embrace China's Homegrown Computer Chips
Imagine that your nation is entirely dependent on a belligerent and economically unstable foreign country for a precious commodity. Imagine that without that commodity, your entire society would grind to a halt. Got it? OK, now imagine that your nation is China, the belligerent nation is the US, and the commodity is CPUs.

Chinese government sponsored an ambitious initiative to create a sort of national processor. Work on the Loongson, or Dragon Chip, began in 2001 at the Institute of Computing Technology in Beijing. The goal was to create a chip that would be versatile enough to drive anything from an industrial robot to a supercomputer.


Explore Model Driven Architecture and Aspect-oriented Programming

In recent years, two new trends in software engineering have been established — Aspect oriented Programming (AOP) was developed to extend and ease programming, and the Model Driven Architecture (MDA) was introduced to take full advantage of the power of modeling. Many people are confused when confronted with both AOP and MDA. This article provides a crash-course on both topics and explains the differences and similarities between the two.

Although AOP and MDA were developed from very different viewpoints: programming vs. modeling; weaving many inputs into one output vs. creating many outputs from one input, there is a great deal of common ground between them and both techniques are used for identical purposes. There is no need to choose between them. They complement each other and can be used together successfully.


The 7 characteristics of simple code (KISS)
I used to believe that the most important quality of code is its extensibility. The code had to be prepared for future changes so I would code lots of things not necessary now. But after realizing that I never was right upfront guessing what the future changes will be, and after having quite a few maintenance and handover nightmares, a few a years ago I decided that I will take the opposite approach to what good
code is. Ever since I did that, I am every day more convinced that the key characteristic of good code is simplicity. Simple code is easy to read and easy to change. And because it is simple, it is less prone to have bugs (the more complex the algorithm you are creating the more changes to make a mistake). Whenever you are coding, I recommend you to check every time if your code is still simple, and remember: "there are no hard problems, only hard solutions".


Des interfaces extensibles avec les Self-Bounded Generics
Certains objets complexes nécessitent d'être construits ou paramétrés en plusieurs étapes, comme les composants d'une interface graphique (définition de leur taille, position, couleur...) ou les requêtes SQL (génération des clauses select, from, order by...), Ces étapes sont matérialisées par un ensemble de méthodes, que le développeur doit appeler dans un ordre précis pour réaliser le processus de construction, au terme duquel l'objet finalisé lui est retourné. Ces méthodes peuvent appartenir à l'objet lui-même, ou à un objet externe implémentant le design pattern Builder.

Afin de simplifier la vie du développeur et de rendre le code plus lisible, il est intéressant de coder ces méthodes de manière à pouvoir chaîner leurs appels : l'objet possède alors une interface dite "fluide" (fluent en anglais).

Il suffit pour cela que chaque méthode renvoie l'instance courante de l'objet auquel elle appartient :
public class Foo {
public Foo method() {
(...)
return this;
}
}

Cet article expose la principale limitation de cette approche et propose une méthode simple pour la contourner, grâce à la technique des Self-Bounded Generics.


Java : présentation du Service Provider API
La spécification JAR (http://java.sun.com/javase/6/docs/technotes/guides/jar/jar.html) propose depuis Java 6 une fonctionnalité fort pratique mais relativement méconnue : la Service Provider Interface (SPI). Derrière ce nom peu engageant se cache un mécanisme de découverte et de chargement dynamique de classes répondant à une interface donnée. Son utilisation est heureusement fort simple, et nous verrons ici qu'il est possible de s'en servir comme d'un système de plugins rudimentaire.


C# Support for Tuples
More Mono proof of concept extensions to C#.
As part of the list of things I would like to see in C# is support for tuples in the language. They would show up in a few places, for example, to return multiple values from a function and assign the results to multiple values at once.



JDK7 Tackles Java Verbosity
The Java Language changes accepted for inclusion in JDK7 have been announced by Joseph Darcy. We already knew that closures were off the menu. So too, unfortunately, is language support for arbitrary-precision arithmetic. The final list is pretty non-controversial and includes a number of changes that will reduce the verbosity of Java programs (one of the main criticisms of Java from proponents of other languages). Java will never be as terse as Perl or Haskell, but that's no bad thing. One of the strengths of Java is its readability. There are however some areas where the language is needlessly verbose and that's what these changes are addressing.


Tail call anyone ?
Last June, Arnold Schwaighofer push a patch to mlvm repository that allow to transform tail call invocation of a method to a jump. Even if this transformation is classical in language like Lisp, Scheme or Caml, the JVM was not offering any help to optimize this kind of call until this patch.

Recently, Tom Davies has refreshed the patch in order to be used with a more recent jdk7 beta VM. Really cool, indeed.

Veille technologique semaine 51

Pour le bulletin de cette semaine, je vous propose les sujets suivants :

• la sortie de NetBeans 6.8 synchrone de l'implémentation de référence JEE 6 GlassFish V3. A noter le support de JavaFX 1.2.1.
• le principe de l'inversion de dépendance : principe souvent mal compris et donc non utilisé. On entend parler de modularité et de re-use mais on oubli très souvent que du code fonctionnel qui dépend du socle technique (et donc du modèle de programmation du socle technique) est très peut réutilisable en dehors de ce socle technique. La meilleure traduction française trouvée est : "il ne faut pas construire le fonctionnel sur le socle technique [comme c'est le cas traditionnellement], mais il faut construire le socle technique sur le code fonctionnel". Question ; pouvez vous construire votre système et le faire tourner sans le socle technique ? Si la réponse est non, votre architecture n'est pas indépendante du socle technique, il n'y a pas d'inversion de dépendance : la probabilité de re-use s'effondre.

• deux articles au sujet de la dette technique : c'est un sujet du bulletin de la semaine dernière, qui a intéressé quelques personnes. Je vous propose donc un complément.
• un autre article au sujet du développement du logiciel.
• un article sur la mesure de la productivité : c'est une question qui revient souvent.

• la présentation d'Emmanuel Bernard faite au JUG de Paris au sujet des standards.

• les nouvelles API de HTML 5 : le push
• le projet Lambda intégré à OpenJDK : sur le chemin des closures pour le JDK 7
• enfin les dernières mesures de perf des implémentation des langages les plus utilisés : le plus rapide est le C/C++ avec la valeur 1,
  Java est à 1.68 (1. 68 fois plus lent que le C/C++), Ada à 1.99, scala est à 2,8, C# mono à 3.3, l'interpréteur Java à 23, JRuby à 89 et Ruby à 94.

Bonne lecture.


Sun has released NetBeans 6.8, its open source IDE for Java. C++. PHP, and Ruby.
New features in this version include:

• EJB 3.1 support
• RESTful web services (JAX-RS 1.1), GlassFish Metro 2.0 web services (JAX-WS 2.2), JAXB 2.2
• Java Persistence JPA 2.0, deployment, debugging and profiling with GlassFish v3 application server
• Code completion, error hints, namespace completion, documentation popups, and tag auto-import for Facelets
• Editor support for Facelets libraries, composite components, expression language, including generators for JSF and HTML forms
• Customizable JSF components palette generates JSF forms and JSF data tables from entities
• JavaFX SDK 1.2.1
• Editor Hints: Fix Imports, Surround With, Implements Abstract Methods, and more
• Improved navigation: Hyperlinks, Go to Type, Find Usages
• Full JIRA support
• Project dashboard with more member and project details, improved search and navigation, easier project sharing
• Improved instant messenger integration
• Improved issue tracker integration
• PHP 5.3
• Symfony Framework support
• PHPUnit, Code Coverage, FTP/SFTP integration improvements, exclude PHP project folders from scanning/indexing
• New Project from Maven archetype catalog and improved support for Java EE 6, Groovy, Scala projects
• Support for Rails 2.3.2 apps with dispatchers, JRuby 1.3.1, Ruby 1.9 debugging, and RSpec 1.2.7
• C++ Profiling: New Microstate Accounting indicator, Thread Map view, Thread Analyzer, Hot Spots view, Memory Leaks view, Sync Problems view
• C++ Parallelization Adviser
• Support for gdbserver attach and easier attaching to already running processes


Principe d'inversion des dépendances

Dependency Inversion Principle - DIP :
A. Les modules de haut niveau ne doivent pas dépendre de modules de bas niveau.
Tous deux doivent dépendre d'abstractions.
B. Les abstractions ne doivent pas dépendre de détails.
Les détails doivent dépendre d'abstractions.


LES ARCHITECTURES CLASSIQUES NE PERMETTENT PAS LA RÉUTILISATION DES MODULES "MÉTIER"
Dans la plupart des applications, les modules de haut niveau (ceux qui portent la logique fonctionnelle de l'application ou les aspects "métier") sont construits directement sur les modules de bas niveau (par exemple les librairies graphiques ou de communication) :

Cela paraît naturel au premier abord mais pose en réalité deux problèmes essentiels :
• Les modules de haut niveau doivent être modifiés lorsque les modules de bas niveau sont modifiés.
• Il n'est pas possible de réutiliser les modules de haut niveau indépendamment de ceux de bas niveau. En d'autres termes, il n'est pas possible de réutiliser la logique d'une application en dehors du contexte technique dans lequel elle a été développée.


Il faut construire les parties "techniques" de l'application sur les parties "fonctionnelles",
et non l'inverse.

VERS DES FRAMEWORKS MÉTIER ?
Ce principe conduit à des applications dans lesquelles la logique "métier" est parfaitement réutilisable. Cette partie métier forme une sorte de "framework", qui permet de développer une même application dans des contextes techniques différents.


Technical Debt
The term "technical debt" was coined by Ward Cunningham to describe the obligation that a software organization incurs when it chooses a design or construction approach that's expedient in the short term but that increases complexity and is more costly in the long term. Ward didn't develop the metaphor in very much depth. The few other people who have discussed technical debt seem to use the metaphor mainly to communicate the concept to technical staff. I agree that it's a useful metaphor for communicating with technical staff, but I'm more interested in the metaphor's incredibly rich ability to explain a critical technical concept to non-technical project stakeholders.


Dette technique - Technical Debt
C'est bien connu, une chose n'existe pas tant qu'elle n'a pas de nom.

L'informatique, discipline pas si jeune que ça, n'échappe pas à la règle même si certains ont tendance à oublier certains noms pour en faire apparaître de nouveaux.

Voici un terme qui a l'avantage de mettre en avant un fléau difficile à cerner de notre discipline : la dette technique. Il s'agit de mettre un nom sur une pratique généralisée dans le métier et qui constitue le principal problème de maintenance des systèmes informatique. Une traduction de l'entrée wikipedia sur le sujet pourrait être résumée ainsi :

La dette technique est un terme inventé par Ward Cunningham pour décrire une situation où l'architecture d'un système logiciel est conçue et développée trop précipitamment. L'analogie avec une dette financière vise à montrer que du code écrit médiocrement requiert le "paiement d'intérêts" par un effort de maintenance, qui serait plus petit ou inexistant si le code fut développé plus soigneusement et avec une planification à plus long terme.

Rearchitecturer et réécrire le code pour être plus maintenable est analogue au paiement de cette dette.

L'objectif d'une telle métaphore est bien de communiquer à des personnes qui n'ont pas de bagage technique mais qui sont pourtant en charge de l'allocation des budgets informatique, un problème essentiellement visible du développeur / architecte. La communauté des développeurs / architectes a tout intérêt à faire ressortir ces coûts dans l'objectif d'améliorer la qualité des logiciels et de rendre plus intéressant et utile la profession d'informaticien.

Mais un frein à la diffusion de cette information est le flou autour de ces coûts car la dette technique est à la base de la forte rentabilité des société de service en ingénierie informatique. Une SSII a tout intérêt a construire une application peu chère mais avec une forte dette technique pour qu'elle puisse continuer à faire de la marge sur la maintenance du système.


Développement logiciel : Doit on continuer à ignorer l'évidence ?
Nous l'avons constaté encore une fois, une fois de trop sans doute. L'un de nos clients s'est mis tout seul (car les responsables d'une telle situation travaillent bien dans la même entreprise que celle où officie notre interlocuteur) dans une situation perdant / perdant avec son intégrateur dans le cadre d'un projet développé au forfait. Quels sont les faits ? Nous pourrions, sans même lui laisser la parole, nommer une à une toutes les difficultés qu'il rencontre, les yeux fermés, à la manière d'un chapelet qu'on égrène.


Comment mesurer la productivité ?
Depuis toujours, dans le monde du logiciel, on entend « Il faut augmenter la productivité des développements ». Il ne suffit pas d'en parler pour améliorer la productivité. Comment passer d'un slogan très abstrait à des actions concrètes et des résultats tangibles ?

On ne peut améliorer que ce que l'on mesure. Il est donc impératif de trouver un indicateur permettant de vérifier l'amélioration recherchée. Les mesures comme le nombre de lignes de code ou le nombre de points de fonctions, encore utilisées aujourd'hui, sont trop éloignées de la valeur produite pour être intéressantes. Un indicateur beaucoup plus proche de la satisfaction client, et donc plus pertinent, est « le nombre de fonctionnalités sans erreur ajoutées à un logiciel durant un période donnée », ce que l'on pourrait appeler le débit de fonctionnalités.

• Nombre de fonctionnalités ajoutées à un logiciel
• Sans erreur
• Durant une période donnée

Présentation sur les Standards par Emmanuel Benard au JUG de Paris
L'objet de la présentation d'Emmanuel Bernard est limpide : « Les Standards : caca ou pas caca ?" .
Avec un sujet décalé, exercice imposé par Antonio, il s'en est très bien sorti. Emmanuel pour ceux qui auraient été dans une grotte ces derniers mois, travaille chez JBoss RedHat, s'occupe du Podcast « Les CastCodeurs« , blog de temps en temps et trouve aussi le temps d'être membre du Java Community Process en participant à la spécification JPA 2.0 et en étant Spec Lead de la JSR-303 (Bean Validation). Avec tout cela, il trouve le temps de venir au Paris JUG, c'était bien sympa.

La légende veut que les spécifications désignées par des comités d'experts
soient lourdes et inadaptées au marché. A l'opposé, le monde de l'open-source est un univers merveilleux où tout se passe bien, les gens s'éclatent et s'entendent super bien pour faire de magnifiques logiciels.

En conclusion
Pour terminer, Emmanuel explique qu'un bon standard doit être stable, extensible, ouvert sur le futur et surtout adopté par la communauté. L'objectif de Java EE 6 est de proposer un socle normalisé, afin que maintenant la communauté mette son énergie sur de nouveaux problèmes. Et là, mesdames et messieurs, il a raison. Bon sang quel temps perdu pendant 3 ans, nous devons maintenant passer à autre chose, et commencer à réfléchir à des serveurs de 4ème génération.


Le point sur les nouvelles API HTML 5

• Le point sur les technologies actuelles
• WebSockets
• Server-sent events
• XmlHttpRequest v.2
• Cross-document messaging
• Conclusion

Le projet Lambda apparaît au sein d'OpenJDK
Mark Reinhold annonce la création d'un nouveau sous-projet au sein d'OpenJDK : le Projet Lambda. Son but est d'apporter une implémentation des closures pour le JDK 7. Dans la mesure où il est prévu que cette fonctionnalité soit implémentée dans un premier temps pour être spécifiée par la suite, il sera particulièrement intéressant de suivre l'évolution de ce projet dans les prochains mois afin de découvrir à quoi pourraient ressembler les closures dans la prochaine version de Java.

Un premier document de travail a été mis à disposition. Il présente de manière non formelle la proposition pour l'implémentation des closures qui est retenue pour le moment. Cette proposition se base sur les trois principales bases de travail qui s'étaient dégagées lors des débats précédents, à savoir la BGGA, la CICE et la FCM. Elle met en avant principalement :

• La syntaxe retenue pour la définition de fonctions anonymes qui se base sur le caractère #, ainsi #()(42) définit une fonction retournant toujours 42.
• La définition d'un type Java pour ces fonctions. Ainsi la fonction #()(42) prise en exemple précédemment a pour type#int().
• Les fonctions anonymes peuvent être converties automatiquement lorsqu'elle sont passées en argument d'une méthode attendant une instance d'une classe anonyme. En clair, il sera possible de créer une nouvelle thread avec new Thread(#() { ...some code... } ) plutôt que de fournir au constructeur une classe anonyme implémentantRunnable pour définir la méthode run(). Cette possibilité permettra donc aux closures d'être utilisées directement dans les APIs existantes !
• Dans certaines conditions, les closures sont à même d'utiliser les variables accessibles dans le contexte dans lequel elles sont définies.
• Le mot clé this peut être utilisé si la closure est déclarée depuis une méthode d'instance, il référence alors l'instance à laquelle est attachée la méthode concernée.

Enfin, pour faciliter les évolutions des APIs existantes que pourraient justifier ces nouvelles possibilités du langage, la notion de méthodes d'extensions est introduite. Il s'agit de permettre la définition de méthodes au sein des interfaces dont l'implémentation par défaut serait une méthode statique indiquée en argument.

Pour plus de détails sur cette proposition, n'hésitez pas à lire le document de travail, volontairement très didactique, du projet Lambda.


Project Lambda: Straw-Man Proposal
This is a straw-man proposal to add first-class functions, function types, and lambda expressions (informally, "closures") to Java.
1. Lambda expressions
2. Function types
3. Function conversion
4. Variable capture
5. Instance capture
8. Extension methods


Les expressions lambda (closures) se dotent de méthodes d'extension !
C'est fait, le projet Lambda est né de la volonté d'intégrer un système de closures, que l'on nommera désormais "expressions lambda".

On y retrouve donc une liste de diffusion mais surtout un prémice de la proposition : Project Lambda : Straw-Man Proposal.


Computer Language Benchmarks Game

Veille technologique semaine 50

Je vous propose, pour le bulletin de cette semaine, les articles suivants :

• un article au sujet de la dette logiciel des projets,
• la sortie de JEE 6 signé le 10 décembre : avec une implémentation de référence GlassFish,
• première partie au sujet de JEE 6 (les deux autres seront envoyés dans les prochains bulletins),
• le multi-core et la programmation concurrente,
• la sortie de Google Web Toolkit (GWT) en version 2 : c'est une version très attendue,
• la sortie de l'IDE IntelliJ en version 9 avec une version community gratuite : il est donné comme le meilleur IDE pour Java (et autre langage),
• deux articles sur le projet Lombok : réduire le code technique,
• Scala et la programmation fonctionnelle,
• JUnit 4.8 et les @Category
• Java et les performances,
• la pratique du Service Oriented Architecture,
• le NoSQL data base,
• l'integration continue,

bonne lecture.


Votre logiciel est-il en bonne santé financière ?
La santé financière est une métaphore utile pour nous aider à comprendre la relation entre la qualité d'un logiciel et sa valeur réelle. Utiliser la notion de dette financière nous aide notamment à réfléchir aux conséquences de livrer un logiciel plus rapidement au détriment de sa qualité (externe ou interne).
Ward Cunnigham a introduit le terme de dette technique pour faire référence aux raccourcis techniques qu'une équipe fait afin de livrer plus tôt, par exemple pour satisfaire des contraintes de temps ou de budget. Comme l'analogie le laisse supposer, s'endetter c'est accepter de rembourser plus tard et de payer les intérêts en attendant. Et il faut bien comprendre quel est le taux d'intérêt qui s'applique !


Java EE 6, Glassfish 3 and NetBeans 6.8 Released:
Q&A with EE 6 Specification Lead Roberto Chinnici
Following the final approval vote for Java EE 6 last week, Sun has today announced the official release of the Java EE 6 SDK, along with GlassFish version 3, the first application server with full support for the platform, and NetBeans 6.8.

When the Java EE 6 specification was first made public the three central themes could be summarised as improving extensibility, adding profiles and pruning redundant APIs. EE 6 has delivered something on each of those areas. For extensibility the CDI portable extension SPI in particular offers substantially easier integration of additional technologies into the Java EE environment. For profiles the specification provides a general definition and introduces the Web Profile, defining a smaller container comprising a subset of key components such as servlets, JPA, JTA, JSF, CDI and EJB Lite.

The pruning work has seen largely underused features like EJB Entity beans, JAX-RPC, JAXR and Java EE Deployment marked as future optional components. At the same time, EE 6 has overhauled key parts of the platform and continued to push on the ease of development work which started with Java EE 5. As the platform is officially launched I talked to Sun Microsystems' Roberto Chinnici, one of the two leads for the EE 6 specification, beginning by looking at the significance of these themes from a developer's perspective.


Introducing the Java EE 6 Platform: Part 1
Java Platform, Enterprise Edition (Java EE) is the industry-standard platform for building enterprise-class applications coded in the Java programming language. Based on the solid foundation of Java Platform, Standard Edition (Java SE), Java EE adds libraries and system services that support the scalability, accessibility, security, integrity, and other requirements of enterprise-class applications.

Progress continues. The next release of the platform, Java EE 6, adds significant new
technologies, some of which have been inspired by the vibrant Java EE community. It
also further simplifies the platform, extending the usability improvements made in
previous Java EE releases.

This article highlights some of the significant enhancements in Java EE 6.
- Java EE 6 Goals
- Powerful New Technologies
- Enhanced Web Tier Capabilities
- EJB Technology, Even Easier to Use
- A More Complete Java Persistence API
- Further Ease of Development
- Profiles and Pruning
- Summary
- For More Information
- Comments


do you speack concurrency ?
Nous sommes toute une génération de développeur qui a été bercée par la course au Méga-Hertz, et si nous constatons un plafond les vieux réflexes perdurent. Face à un programme trop lent, la solution reste le "plus gros" processeur.

Seulement, l'offre des fondeurs de puces est explicite : n'espérez plus de GHz supplémentaire – à la place, on vous propose des cœurs en plus.

La conférence de Doug Lea à Devoxx ainsi que son livre "Programmation Java Concurrente" sont basés sur ce constat. Fini le Free Lunch sur la puissance CPU. Pour faire plus rapide il va falloir apprendre à penser et à parler parallélisme, concurrence et synchronisation, des sujets particulièrement pointus et mal connus.

Pas encore convaincu ? Intel annonce avoir dans ses labs un processeur à 48 coeurs ! Vers 2012, un serveur haut de gamme se basera sur ce type de puce, et votre PC portable entrée de gamme en 2020 aussi. Croyez-vous vraiment que vos logiciels sauront en profiter ? Votre super batch d'import de données tire t-il profit d'une architecture à 48 coeurs, ou ressemble t-il plus à un bête programme séquentiel, comme décrit dans votre document de spécification ?

Les traitements lourds comme les encodeurs vidéo, traitement d'image et autres manipulations massive de données ont déjà franchi le pas, mais que penser des milliers d'autres softs, … à commencer par ceux que nous développons nous même !


Google Releases GWT 2.0
Google's open-source Web Toolkit (GWT) has become a popular Web
development framework in recent years. GWT allowing developers to
write Java code, using familiar Java development tools, and generates
highly optimized JavaScript from the Java code base. The GWT compiler
takes into account the idiosyncrasies of various browser environments
when optimizing its JavaScript output. Google released this week
version 2.0 of GWT.

The most visible feature in the latest release is Speed Tracer, a
performance profiler that works with the Chrome Web browser. Speed
Tracer is not tied to GWT applications: It can be used to profile and
analyze the performance of any Web applications. Speed Tracer is a
result of performance profiling instrumentation added to the version
of WebKit used by Chrome and, therefore, works only in Chrome.

Separating user interface and program logic is a key feature of almost
every Web and UI toolkit. However, as UIs become increasing
sophisticated, graphic artists and UI specialists often need to work
side-by-side with more code-centric developers. Since graphic
designers and developers often use different tools and have different
working styles, modern UI toolkits need to facilitate easy interaction
between developers and designers. Adobe's Flex framework has provided
such features for a long time with an XML-based declarative UI
language, and GWT 2.0 adds a similar capability with UiBinder:

To construct your UI, simply mix HTML and widget elements
declaratively in a UiBinder XML template — a .ui.xml file. You can
then place application logic in an associated .java file... UiBinder
makes it much easier to involve web designers more directly into the
development workflow. For example, developers can copy/paste from HTML
mocks provided by a web designer... Incorporating your own custom
widgets into a UiBinder template is exactly the same as using any of
the built-in widgets...

An equally important aspect of Web application UIs is their fidelity
to design when rendering in various browser environments. To that
effect, GWT 2.0 introduces layout panels, an abstraction over CSS
layout:

Prior to GWT 2.0, even GWT's widgets were not able to fully abstract
away some of the layout headaches that can occur. However, GWT 2.0
introduces layout panels that actually do make it possible to reliably
create the layout you want... Layout panels create a predictable
constraint-based layout system on top of standard CSS. Because it
works with CSS, rather than in spite of it, layout panels continue to
work predictably in the presence of custom CSS styles that you might
need to include.

Since GWT applications run mostly in the browser, minimizing
application download time is an important usability concern. GWT 2.0
introduces code splitting, allowing a GWT application to incrementally
download to a browser:

Just find a spot in your project where you'd like to chop out some
code and use the magic new GWT.runAsync() method to create a split
point. By continuing to add split points wherever it makes sense, you
can easily and safely slice and dice your application to ensure that
the initial download includes only the bare minimum of code necessary
to start. The compiler automatically arranges for additional code
fragments to be downloaded later. And, unlike manually splitting
JavaScript... the GWT compiler does the hard work of ensuring that all
necessary dependencies are downloaded in the correct order
automatically.

GWT 2.0 also includes numerous compiler improvements, leading to
further optimization in the generated JavaScript:

With each new release of GWT, we add compiler optimizations to make
compiled JavaScript smaller and faster. That's a big benefit if you
have existing GWT projects, because you can simply upgrade, recompile,
and — poof — your applications start and run more quickly. Indeed, GWT
2.0 includes some high-impact new optimizations, and we have already
seen size reductions in compressed JavaScript ranging from 3% up to
over 20%.


IntelliJ IDEA 9.0
The Most Intelligent Java IDE


What's New in Version 9
This release delivers many major updates to IntelliJ IDEA including better performance, support for Java EE 6 and other new frameworks, lots of productivity improvements in the editor, a more streamlined user interface and much more.


Lombok Reduces Your Boilerplate Code
In this article, I show you the power of the product I stumbled upon this week: Project Lombok enables you to modify bytecode at compile code. First, I will detail what features Lombok brings you out-of-the-box. In the second part of this article, I will describe how to extend it to generate you own code.

Lombok's driving feature is to create code you need from annotations in order to reduce the amount of boilerplate code you have to write. It provides you with the following annotations that will change your code (if not your life) forever:

@Getter and @Setter: create getters and setters for your fields
@EqualsAndHashCode: implements equals() and hashCode()
@ToString: implements toString()
@Data: uses the four previous features
@Cleanup: closes your stream
@Synchronized: synchronize on objects
@SneakyThrows: throws exceptions


Interview: Reinier & Roel on Lombok
Project Lombok removes the need for you to code a lot of the standard boilerplate, such as "getters" and "setters", that have helped cause developers to leave Java, in favor of other languages. Using annotations provided by Lombok, your application's bytecode can be modified at runtime, as explained below in an interview with
Reinier Zwitserloot and Roel Spilker, the two developers behind Lombok.


A Taste of Scala
A (Brief) History of Object-Functional Programming
Once upon a time, there was a language, it was called Scala.
People came to look at the language, and they announced that it was "pretty impressive", but they thought that the feature set was changing too fast, and that nobody was using it yet outside of hobby projects. It sure did look good, but nobody wanted to risk their career on it, it was too young, it might not last.

Then something happened; Scala grew up. Twitter announced that they used it to replace some of their Ruby back-end, and SAP were using it, and EDF. The news spread and new developers also came to see that Scala was "pretty impressive", whilst the early pilgrims began to look at it with renewed interest and a glint in their eye. What they saw was a language that is now mature and ready to be used in anger. With the approach of version 2.8, Scala is coming of age, and it is indeed "pretty impressive"!


About JUnit and the 4.8 Release
JUnit has been an important framework in the evolution of test-driven development (TDD). The open source unit testing framework has been ported to numerous languages (e.g. PHP (PHPUnit), C# (NUnit), and JVM languages) and can now be found natively in many popular IDEs. DZone recently talked with David Saff, a JUnit committer and Software Engineer in Test currently working on Google Books, about the newest version [1] of JUnit and the current state of the project.

Devoxx – Jour 4 – Java Performance Tuning
A Devoxx, deux sessions étaient dédiées au thème du tuning de performance en Java : Performance for the performance-shy par Holly Cummins et The not so dark art of performance tunning par Kirk Pepperdine et Dan Hardiker. Nous nous attardons ici sur cette dernière. Kirk Pepperdine (photo ci-contre) est Java Champion et
possède une expertise reconnue dans le domaine des performances des applications Java. On se souvient également de sa présentation en avril 2008 au ParisJUG où il avait fournit un aperçu des problématiques liées à ce sujet. Dan Hardiker est pour sa part le fondateur d'une entreprise spécialisée dans l'hosting de solutions basées sur Confluence.


Devoxx – Jour 2 – SOA en pratique
Les sessions dédiées à SOA étaient présentes cette année encore à Devoxx. Nicolai Josuttis a animé une présentation intitulée « SOA in practice » à l'image du titre du livre dont il est l'auteur, publié chez O'Reilly. Passage obligé de toute présentation sur SOA, Nicolai Josuttis commence par introduire l'ensemble des concepts gravitant autour de l'architecture orientée services. Nous passerons sur ces rappels ici, car malgré quelques divergences dans les définitions, on retrouve les idées décrites dans les différents articles portant sur SOA que nous avons pu publier jusqu'alors.


Devoxx – Jour 1 – NoSQL avec HBase
Durant la première journée de Devoxx, deux sessions étaient dédiées au NoSQL : une présentation (trop) courte de 30 minutes durant la journée suivie d'un BOF sous forme de discussion d'une heure le soir. Ce sera l'unique incursion de cette technologie durant la semaine. On peut d'ailleurs regretter que ce sujet qui monte en puissance actuellement n'y ait pas été plus présent.


Continuous integration, going beyond continuous compilation.
Continuous integration is in my opinion the most important practice to successfully deliver good software. Continuous integration should go beyond a simple set of practices and tools to build your source code every now and then; doing so is continuous compilation, not continuous integration. Continuous integration goes beyond that, it should drive the way the software gets build and how the different actors from the project interact with each other. The five main characteristics of continuous integration