I'm in the process of learning scales, modes and chords for the guitar, but these aren't easy to remember. Being a developer, I thought I could write a small program to help me understand how they are built, and where I can find the related notes on the guitar neck.
So I spent a couple of hours on it tonight (mainly to find documentation on music theory) and here it is : a small companion program that can calculate and display any chord in any mode and key.

The API is very compact and ultra-easy to understand :
(A "Scale" is basically a collection of Notes. It is used to contain notes for whole Scales, Chords, etc.)

Scale scale = Scale.of(Note.C);
System.out.println("Scale of C : " + scale);
 
Scale mode = Mode.IONIAN.of(scale);
System.out.println("Scale of C in "+Mode.IONIAN+" mode : " + mode);
 
Scale chord = Chord.major(mode);
System.out.println("Major chord : " + chord);
 
Guitar.display(chord, Guitar.STANDART_TUNING, 12); // 12 frets

And here is the result :

Scale of C : [C, C#, D, D#, E, F, F#, G, G#, A, A#, B]
Scale of C in IONIAN mode : [C, D, E, F, G, A, B]
Major chord : [C, E, G]
                        3             5             7             9                    12  
--E --||------|------|--G --|------|------|------|------|--C --|------|------|------|--E --|
------||--C --|------|------|------|--E --|------|------|--G --|------|------|------|------|
--G --||------|------|------|------|--C --|------|------|------|--E --|------|------|--G --|
------||------|--E --|------|------|--G --|------|------|------|------|--C --|------|------|
------||------|------|--C --|------|------|------|--E --|------|------|--G --|------|------|
--E --||------|------|--G --|------|------|------|------|--C --|------|------|------|--E --|

The source code is available for download just below.
This ain't rocket science but hey, I thought It might be cool to share it with you :)
Comments and suggestions welcome !

Il y a deux mois, avant de partir en vacances, j'ai été contacté par Packt Publishing pour faire la revue de leur tout nouveau livre GlassFish Security, écrit par Masoud Kalali.

Vous allez voir, le hasard fait bien les choses : ils ne pouvaient pas mieux tomber.

• D'une part, je venais de terminer le livre d'Antonio (j'en reparlerai), dans lequel GlassFish laissait entrevoir sa puissance ;
• D'autre part, je sortais d'une courte mission de conseil sur la mise en place d'une architecture SSO sur une plateforme Java, pour laquelle j'avais eu beaucoup de mal à trouver la moindre documentation correcte (et compréhensible) - d'autant plus qu'Oracle était en plein sabotage d'OpenSSO...

Bref, le temps que la Poste fasse son office, me voilà donc avec ce fameux GlassFish Security entre les mains.

Mardi dernier, j'ai animé chez Zenika une conférence sur les Annotations.

Et le sujet est plus complexe qu'il n'y paraît. Outre les subtilités de leur syntaxe, les annotations disposent d'un outillage puissant à la compilation et au runtime, dont la maîtrise ouvre de nouvelles perspectives en termes de méta-programmation.
En particulier, j'ai démontré l'utilisation des Annotation Processors, qui permettent d'interagir avec le compilateur Javac, et de la Réflexion pour lire et injecter des annotations dynamiquement au runtime.

Apparemment, la conférence a remporté un franc succès :

• "Très intéressant. Niveau technique avancé" A. F.
• "Vivement le prochain projet pour qu'on mette cela en place" JP. L.
• "Excellente présentation avec démo hardcore à la fin ;)" C. M.
• "Très bon intervenant" S. F.

Je remercie de leur présence tous les participants qui ont pu venir.
Pour les parisiens qui n'ont pas pu avoir de place, rassurez-vous, il est possible qu'une nouvelle session soit programmée. Et pour mes lecteurs de province, mon passage est prévu dans certains JUGs d'ici la fin de l'année. Renseignez-vous et faites pression ! :)

Pour finir, j'ai le plaisir de vous offrir, en annexe de ce billet, les slides et les sources de la conférence.
Tous les commentaires sont les bienvenus !

Il y a deux semaines, j'étais en Crète en compagnie des meilleurs experts Java (Michael Hunger d'Allemagne, Larry Presswood des USA, Herman Lintvelt pour l'Afrique du Sud, David Gomez pour l'Espagne, et David Hallett pour la Nouvelle-Zélande), pour suivre le séminaire de certification des formateurs du Java Specialist Master Course, sous la houlette du Champion Java Heinz Kabutz.

Nous en avons profité pour enregistrer un webinar intitulé "Why I Don't Read Your Code Comments", dans lequel nous confrontons nos avis quant aux bonnes et mauvaises pratiques relatives aux commentaires de code (et pas de blagues sur mon accent anglais :). Heinz avait déjà défriché le terrain dans sa newsletter n°39, mais il était intéressant d'avoir des avis supplémentaires.

Je me tourne donc vers vous à mon tour, pour recueillir vos témoignages :

• Quelles sont vos bonnes pratiques personnelles ?
• Quelles sont les meilleurs et pires commentaires que vous ayez vus / écrits ?
• Que faut-il commenter ? Est-ce une perte de temps ?
• Quels conseils donneriez-vous à un développeur débutant ?

Cadeau bonus : gagnez au choix Pragmatic Programmer ou Clean Code.
Pour participer au tirage au sort qui aura lieu ce week-end, il suffit de laisser un commentaire intelligent sur ce billet et d'habiter la France métropolitaine. Le gagnant sera contacté par l'email associé à son commentaire.

Le framework web Wicket fournit un composant ModalWindow permettant de gérer des fenêtres modales.
Dans cet article, nous verrons comment le mettre en oeuvre, au travers de cas d'utilisation de plus en plus complexes.

Google a récemment (et sans prévenir) changé son API permettant d'intégrer des Waves sur des sites.
Rien de méchant, car cela concerne surtout les options graphiques, mais cela a suffi pour empêcher mes compte-rendus de conférence de s'afficher correctement : à la place, il n'y avait plus que du blanc... J'ai donc fouillé un peu pour trouver d'où cela pouvait venir.
Vous trouverez ci-dessous les nouvelles instructions détaillées.

Et puis, j'en profite pour vous annoncer la bonne nouvelle : il est maintenant possible de consulter les Waves intégrées sans posséder de compte Wave !
C'était la principale critique remontée à Google, et elle a visiblement été écoutée. Par contre, la modification de la Wave est toujours réservée aux utilisateurs authentifiés.

Une classe injustement méconnue du JDK est Scanner (java.util.Scanner).
Elle offre pourtant des fonctionnalités très intéressantes pour parser des chaînes de caractères, et en extraire et convertir les composants.

Un Scanner peut se brancher sur à peu près n'importe quelle source : InputStream, Readable (et donc Reader), File... et bien sûr une simple String. Ensuite, deux options s'offrent à vous : utiliser les méthodes de type hasNext...() / next...(), ou alors les méthodes de type find...() / match() / group().

Dans ce billet, nous verrons comment utiliser ces deux jeux d'instructions.

Dans un récent article intitulé "Terracotta, un an après", je vous décrivais la volonté de Terracotta de simplifier la mise en oeuvre du framework sur ses principaux cas d'utilisation : clustering de sessions HTTP, clustering de cache EHCache ou Hibernate, intégration avec Spring et Quartz...
Peu à peu apparaissent donc des solutions packagées et pré-configurées, reconnaissables à leur suffixe "Express".

Si vous suivez ce blog, vous savez déjà clusteriser des sessions HTTP avec Terracotta et TCServer, en configurant manuellement la plateforme ; aujourd'hui, je vous parlerai du module "HTTP Session Clustering Express", introduit avec Terracotta 3.2.1-beta, qui simplifie nettement le processus.

Google Wave provides an "Embedded API" that can be leveraged to insert a single Wave into any HTML page.
Unfortunately, the official documentation is somewhat old and gives the procedure only for the sandbox waves, not the regular ones. As a result, I had to struggle more than an hour long and browse the API's source code to get all the parameters right, and eventually successfully display a wave in a blog post (see my summary of the last Paris JUG's meeting, in French).

Here is a very short tutorial to help you integrate waves in your own websites/blogs in minutes !

Je me suis un peu amusé avec la nouvelle balise HTML5 Canvas et l'API Javascript associée...
Si vous avez un navigateur récent, vous devriez pouvoir voir et contrôler les flammes :

Je vous invite à regarder le code source de la page pour plus de détails !