Ignorer la casse, les diacritiques, et les ligatures dans un autocompléteur GWT

Autant, en Java, supprimer les diacritiques et ligatures est un jeu d'enfant, il suffit de ces quelques ligne (voir ci-dessous), autant, dans une application Web avec GWT, ce n'est pas aussi immédiat.
Nous allons voir comment réaliser cela dans un autocompléteur grâce auquel l'utilisateur peut sélectionner le nom d'un pays sans se soucier de commencer à l'écrire : avec ou sans accents, en majuscules ou minuscules.

Je Suis Charlie

Les sinistres auteurs de cette horrible tuerie se sont écartés eux-même du genre humain. Ils viennent de démontrer qu'ils ne sont pas des êtres humains, étant totalement dépourvus de la faculté de penser.

Mais je sais que de talentueux dessinateurs prendront la relève chez Charlie Hebdo, car Charlie Hebdo est désormais immortel.

Je tiens à exprimer de la manière qui est la mienne mon admiration aux 12 victimes assassinées et mon soutien à leur famille, par le projet JeSuisCharlie que j'ai déposé dans GitHub.

Voici la trace d'exécution des tests :

[TestNG] Running:
  /private/var/folders/1h/T/testng-eclipse-1337986361/testng-customsuite.xml

JE SUIS
CHARLIE
PASSED: charlieHebdoEstImmortel
PASSED: unTerroristeEstToujoursUnCretin

===============================================
Default suite
Total tests run: 2, Failures: 0, Skips: 0
===============================================

Je suis horrifié.
Je suis triste.

Je Suis Charlie.

Tester avec Maven un processeur d'annotation

Générer du code est une pratique courante en Java qui permet d'éviter de se répéter : il faut reconnaître que c'est une pratique bien pratique.

Mais lorsqu'il s'agit de créer un projet sous Maven avec un générateur de code (et de ressources) basé sur des annotations et qu'on envisage de tester le code généré (et les ressources), c'est une toute autre paire de manche : j'ai suffisamment lutté avec Maven pour trouver la configuration simple mais qui marche, que j'ai la joie de partager avec toi, ami lecteur.

Nous allons voir pas à pas dans cet article comment configurer notre POM pour que notre processeur d'annotation que nous développons puisse être testé sans heurts.

10 trucs à éviter en Java

Rangez votre crème solaire et vos tongues : c'est la fin de l'été !
Après une pause estivale, il est normal de tout oublier, aussi, une piqûre de rappel sur quelques mauvaises pratiques en Java ne peut pas faire de mal. Et puis c'est moins désagréable qu'une piqûre de moustique.

Je livre ici 10 trucs à éviter en vrac ; il n'y a pas de classement du pire truc à faire, ni du plus dangereux, ni du plus important, il s'agit juste un choix arbitraire de pratiques à éviter ou carrément à proscrire. Evidemment, au delà de ces 10 là, il y en a des dizaines d'autres...

Lazy Stream Generation with Java 8

Avant, pour produire les items à consommer dans une boucle for-each en Java, on pouvait utiliser un itérateur. Mais ça, c'était avant...

Depuis Java 8, le tant attendu, il y a les lambdas et l'API stream : Java rattrape enfin son retard sur nombre de langages qui offrent déjà depuis bien longtemps des mécanismes de programmation fonctionnelle. Il était temps.

Alors, comme tout Javaman qui se respecte, je me suis attelé à la tâche : essayer de domestiquer ces nouveaux compagnons. Il y a tout un tas de fonctionnalités géniales prêtes à l'emploi : on peut générer des streams à partir de tout et n'importe quoi, on peut obtenir des stream bornés ou infinis, séquentiels ou parallélisables, et on les consomme dans un mode "lazy", c'est à dire que chaque étape dans un pipeline demande à l'étape précédente la donnée à traiter qui lui-même fournira à l'étape suivante la donnée utile, ni plus ni moins : c'est du pur pull-pipeline bourrin, économe et efficace.

Mais comment produire des données dans un mode "lazy" ? Pratiquement dès le début, je me suis retrouvé comme une poule devant un violon face à cette épineuse question.

Voyons de quoi il s'agit dans un exemple concret.

Produire juste ce qu'il faut : un enjeu de chaque instant

Jouons à cache-cache avec Java (seconde partie)

Mettre en cache un objet signifie qu'on espère le réutiliser à court ou moyen terme en s'épargnant le coût de sa reconstruction. Cet article est le second d'une série (de deux articles) dédié à la mise en œuvre d'une mauvaise stratégie de cache.

Dans le précédent article, nous avons vu comment mettre en oeuvre une telle stratégie apparemment viable.
Dans celui-ci nous verrons d'abord comment notre cache se comporte, puis si les adaptations apportées améliorent les résultats. Pour finir, nous aborderons un cas d'utilisation dans lequel une petite modification des conditions de départ peuvent rendre ce cache enfin utilisable (ce serait dommage de rester sur un échec !).

Association de malfaiteurs dans GWT

...ou comment gérer une structure composite multiple dans les cellules d'un tableau.

A la façon d'un tutoriel, je vous propose étape par étape comment réaliser un tableau sophistiqué avec GWT et Sencha GXT, les problèmes rencontrés et les solutions adoptées. Un prérequis raisonnable pour la lecture de cet article est une connaissance de GWT, même de niveau débutant ; quant à Sencha GXT ce n'est pas nécessaire : on va découvrir cette librairie ensemble.

Effet souhaité

Plutôt qu'un long discours, l'idée est d'obtenir ceci :

Un casse réussi, c'est un casse bien préparé !

Ce tableau permet d'ajouter plusieurs items (de la liste de gauche) dans une cellule de grille (partie à droite), avec plusieurs mécanismes d'ajouts dont le Drag N Drop.