FLASH INFORMATIQUE FI



Feelin’ Groovy


Groovy, un langage de programmation pour la JVM (machine virtuelle Java), permet la programmation agile sur la plate-forme Java. Dans l’article, nous introduisons le contexte des langages de la JVM, puis nous présentons le langage Groovy du point de vue d’un développeur Java et énumérons les bibliothèques/frameworks disponibles dans l’écosystème Groovy.



Yet another programming language for the JVM (Java Virtual Machine), allows for agile programming on the Java platform. In this article we first introduce the context of the JVM languages, then we present Groovy as it can be seen by Java developers. We conclude by sketching the libraries and frameworks available within the Groovy ecosystem.


Maciej MACOWICZ


Le langage Java fut conçu par la société Sun Microsystems dans les années 1990 en tant que langage de programmation par objets moderne offrant la robustesse, la gestion dynamique de la mémoire (ramasse-miettes) ainsi que les mécanismes internes de programmation concurrente (multi-threading).
Java est très portable (compiler une fois, exécuter partout = Compile Once, Run Everywhere) car il s’appuie sur la machine virtuelle Java (JVM=Java Virtual Machine), implémentée sur la plupart des architectures et systèmes d’exploitation. La première implémentation de Java (1.0) est apparue chez Sun Microsystems en janvier 1996, nous en sommes actuellement à la version 1.7.
Conçu dès le départ comme une plate-forme de programmation universelle plutôt qu’un simple langage de programmation, doté de riches bibliothèques standard de composants logiciels, Java a rapidement gagné du terrain. Il s’est décliné en plusieurs versions (profils), ciblant une vaste gamme de matériels allant des dispositifs mobiles (téléphones, smartphones) aux applications Web critiques.
Au fil du temps, le langage a subi plusieurs améliorations (généricité, annotations…) et les bibliothèques standard se sont considérablement enrichies en passant de 211 classes en version 1.0 de la plate-forme Java à 3777 classes en version 1.6. En 2011 la plate-forme Java accompagnée d’innombrables bibliothèques de composants logiciels s’avère très complète.
Au début des années 2000, Java était largement enseigné et utilisé ; il occupait la première place dans l’index TIOBE avec 30 % de popularité ; certains parlaient alors de la fin de l’histoire des langages de programmation.

Langages de programmation agile

Les années 2000 ont amené la programmation agile, très attirante pour les développeurs, ainsi que l’avènement de langages agiles Python ou Ruby, plus dynamiques que Java. Les langages agiles permettent de programmer naturellement et rapidement ce qu’on a dans la tête au lieu de réfléchir comment transposer ce qu’on a dans la tête pour que le compilateur comprenne enfin. Une telle facilité de programmation repose sur un système de types dynamique (on parle alors de duck typing, où toutes les propriétés d’un objet sont déterminées au moment de son utilisation... par analogie : si je vois un oiseau qui vole comme un canard, cancane comme un canard, et nage comme un canard, alors j’appelle cet oiseau un canard). À cela s’ajoutent les mécanismes de programmation fonctionnelle, permettant les manipulations de fonctions par les programmes (contrairement à la programmation impérative ou objet, où la fonction peut seulement être appelée). Notons que les langages de programmation agile sont souvent moins performants à l’exécution que les langages statiques, la dynamique et la liberté laissée au développeur nécessitent de multiples vérifications pendant l’exécution du programme ; dans le cas de langages statiques, la plupart des vérifications sont effectuées à la compilation.

Langages pour la plate-forme Java

La plate-forme Java présente un grand intérêt (on y trouve tout ce dont on peut avoir besoin), on a donc vu fleurir une panoplie de langages de la JVM, de plus haut niveau que Java, permettant les styles de programmation variés, et offrant l’accès aux composants logiciels de la plate-forme.

Parmi ces langages, citons :

  • Jython et JRuby, portages de Python et Ruby,
  • Scala, langage statique, mixte objet-fonctionnel et doté d’un système de types très puissant,
  • Groovy, extension dynamique et fonctionnelle de Java, et finalement
  • Clojure, un dialecte de Lisp.

À titre d’anecdote, mentionnons les implémentations d’Ada, de Cobol, et même de Pascal pour la JVM.
Groovy et Scala [1] représentent des objectifs de conception très différents, nous en détaillerons quelques points. Scala est un langage académique (conçu à l’EPFL par l’équipe du Prof. Odersky), mais très pragmatique. Conçu en tant que langage extensible (scalable), Scala est censé couvrir un maximum de domaines d’application et garantir de hautes performances à l’exécution. Scala permet la programmation objet et fonctionnelle ; statiquement typé, il est doté d’un système de types très évolué, permettant de réduire et simplifier le code source (moteur d’inférence sur les types) et permet la surcharge des opérateurs. Sa syntaxe est très épurée et élégante, mais très différente de Java ; Scala est interopérable avec Java, on peut aisément utiliser les classes Java depuis Scala, mais l’utilisation dans l’autre sens est parfois plus délicate. La bibliothèque standard de Scala étend la bibliothèque standard de Java et fournit les abstractions d’acteurs pour la programmation concurrente. Finalement, Scala peut être utilisé en tant que langage de programmation ou en tant que script, et depuis quelques années gagne en popularité, dans l’index TIOBE il arrive à la 50e place parmi tous les langages utilisés [2].

Groovy

Groovy est un langage créé par les développeurs pour les développeurs en tant que langage agile et dynamique pour la plate-forme Java, doté de fonctionnalités inspirées par Python, Ruby et Smalltalk, destiné aux développeurs Java avec la syntaxe très proche de Java. Groovy, langage dynamiquement typé (duck typing), offre des mécanismes de programmation fonctionnelle à travers les fermetures (closures) et permet la surcharge des opérateurs. L’interopérabilité avec Java est parfaite dans les deux sens (Java > Groovy et Groovy > Java). Tout comme Scala, Groovy peut être utilisé en tant que langage de programmation ou en tant que script. La popularité de Groovy est pour le moment similaire à Scala (dans l’index TIOBE il est placé entre la 51e et la 100e place) ; dans la catégorie de langages agiles, Groovy est devancé de loin par Python (8e) et Ruby (11e).
Groovy est apparu pour la première fois en 2004, en tant langage dynamique pour la JVM, défini par la spécification JSR-241. Son développement n’a vraiment commencé qu’en 2006, la version 1.0 du compilateur est sortie en 2007 ; actuellement (automne 2011) le système Groovy est arrivé à la version 1.8.2 et bénéficie toujours de l’enthousiasme de son équipe de développeurs et du soutien de l’entreprise VMWare. Notons enfin que, afin de palier aux problèmes de performances de Groovy, une version plus statiquement typée du langage est en cours de développement chez Google sous le nom de Groovy++.
Dans la suite de l’article, nous nous intéresserons aux avantages de Groovy pour un programmeur Java (j’ai derrière moi plus de treize ans de développement Java). Les observations présentées ci-dessous sont tirées d’un exemple grandeur nature concret : je suis actuellement en train de préparer une nouvelle version du moteur de recherche de l’EPFL. Search.epfl.ch d’aujourd’hui est une application Java/J2EE utilisant plusieurs frameworks Java (dont Struts). Avant de commencer le développement de la nouvelle version du moteur de recherche, j’ai voulu vérifier si une technologie plus moderne pourrait convenir pour le développement. Je me suis fixé les critères suivants :

  • support du langage par l’IDE Intellij IDEA. J’utilise cet IDE depuis 2003 et je trouve qu’il mérite pleinement son slogan : développer avec plaisir ;
  • interfaçage bidirectionnel avec le code Java, permettant l’intégration des frameworks Java (Struts2, Sitemesh) ;
  • rapidité de compilation et d’exécution ;
  • possibilité de prototypage rapide et de programmation exploratoire ;
  • traitement de XML rapide et flexible ;
  • accès aux bases de données SQL rapide et flexible.

Mon choix s’est initialement porté sur Scala et Groovy, Scala fut rapidement écarté, car :

  1. le support par l’IDE est très moyen et parfois instable,
  2. la compilation est lente,
  3. l’intégration avec Java est unidirectionnelle (Java depuis Scala) ; l’intégration dans l’autre sens (Scala depuis Java) est plus délicate et nécessite des conversions explicites.

J’ai donc choisi Groovy pour le développement. Par rapport aux critères ci-dessus : le support de Groovy par l’IDE est très bon pour développer dans un langage dynamique (surtout accompagné d’analyseur CodeNarc) ; Groovy s’interface avec Java dans les deux sens, il est donc possible d’utiliser les frameworks Java et d’y ajouter des classes Groovy et/ou Java sans aucune difficulté. Rien à signaler non plus pour la rapidité de compilation, quant aux performances du code généré dans Groovy : pour le moment je n’ai trouvé aucun problème, les premiers tests de charge ont démontré la tenue à la charge de 200 requêtes/s alors que la charge réelle ne dépassera pas 50 requêtes/s, Groovy reste donc suffisamment performant et satisfait aux besoins.
Les possibilités de prototypage rapide et de programmation exploratoire méritent plus d’attention, la première impression générale que donne Groovy est qu’on peut programmer et arriver très vite aux résultats concrets ; de plus, le passage depuis Java est agréable, on peut commencer par coder pratiquement en Java, ensuite on utilise dans le code de plus en plus de fonctionnalités spécifiques à Groovy. Afin de donner un avant-goût de Groovy, voici le code de tri rapide (code 1), très proche de l’algorithme original [3].

code 1 - tri rapide en Groovy

Nous allons maintenant présenter quelques fonctionnalités représentatives de Groovy.

GroovyBeans

Les composants JavaBeans largement utilisés dans Java sont inutilement compliqués : on impose l’implémentation de méthodes getX et setX pour chaque attribut exposé. En Groovy ces méthodes sont implicites, il est néanmoins possible de les redéfinir si on veut effectuer un traitement avant l’accès à l’attribut. Les constructeurs sont optionnels, on peut instancier un objet en passant une map de paramètres d’instance nommés (code 2).

code 2 - GroovyBean

Opérateurs

Groovy fournit une panoplie d’opérateurs, dont  ?., qui permet la navigation dans la hiérarchie d’objets sans avoir à vérifier si l’objet est nul, et  ? : (elvis), qui simplifie l’expression conditionnelle (code 3).

code 3 - opérateurs

Chaînes de caractères

Groovy propose trois types de chaînes : les chaînes à la Java, les chaînes évaluées (GString), qui peuvent comporter les expressions et les chaînes multiligne (code 4).

code 4 - chaînes de caractères

Expressions régulières

Les expressions régulières en Java sont lourdes à utiliser, l’essentiel est noyé dans la syntaxe trop complexe (échappement pour plusieurs caractères, la classe Matcher à sémantique compliquée). En Groovy, les expressions régulières sont plus simples à utiliser, le résultat est assez convaincant (sans toutefois égaler Perl) (code 5).


code 5 - expressions régulières

Fermetures

Une fermeture (closure) est une fonction anonyme qui peut être appelée, stockée dans une variable, passée en paramètre ou bien composée avec d’autres fermetures. Voici quelques exemples (code 6).

code 6 - fermetures

Collections

Groovy fournit trois types de collections : les intervalles (ranges), listes et maps. Les manipulations de collections sont simples grâce aux nombreuses méthodes et opérateurs (code 7).


code 7 - collections

Traitement d’exceptions

Java impose le traitement d’exceptions (blocs try ... catch) pour tous les fragments de code censés lever une exception et en effectue les contrôles à la compilation. Dans la pratique cela résulte en plusieurs blocs catch vides, à moins d’utiliser les astuces (sous-classes des exceptions non traitées comme par exemple RunTimeException). Groovy lève ces contraintes, les exceptions non traitées sont simplement passées à l’appelant.

Traitement de XML

Le traitement des données XML est très fréquent dans les applications Web. L’analyse et la transformation de XML en objets du domaine d’application (la désérialisation) est très lourde en Java ; au fait, même si le développeur a le choix entre plusieurs parsers XML (DOM, SAX et JDOM), voire des bibliothèques de plus haut niveau (Apache Digester), il ne peut que rarement échapper à la création d’une hiérarchie de classes correspondante à la structure du document XML.
En Groovy la situation est différente, les parsers XML créent un objet qui permet de manipuler l’information en utilisant les mêmes noms dans le code et dans les balises XML. Le développeur n’a pas à connaître les détails, l’objet en question est pourvu de tous les mécanismes nécessaires. Regardons de près la désérialisation de XML sur un document XML (code 8 et 9). La sérialisation de XML est également très concise grâce aux builders, par exemple le document XML peut être généré par le code 10.

code 8 - exemple de données XML


code 9 - lecture de données XML


code 10 - génération de XML

Accès aux bases de données SQL

Groovy fournit les mécanismes de haut niveau également pour accéder aux bases de données SQL, dans l’esprit similaire au traitement de XML ; pas besoin de créer les hiérarchies de classes dans la couche de persistance. Les fermetures permettent l’accès aisé aux résultats, et les composants de la bibliothèque standard de Groovy prennent soin de la bonne gestion de connexions, d’instructions et d’ensembles de résultats (code 11).

code 11 - accès à la base de données

Ecosystème Groovy

Groovy est un langage de programmation qui suscite un grand intérêt de développeurs, par conséquent on a vu apparaître plusieurs frameworks et bibliothèques Groovy :

  • Grails : développement d’applications Web inspiré de Rails
  • Griffon : développement de clients riches
  • Gaelyk : environnement de programmation d’applications Web sur le Google App Engine
  • Easyb, Spock et Geb : environnements de tests
  • Gradle : outil de construction des logiciels (considéré comme successeur de maven).

Conclusion

Nous avons présenté le langage de programmation agile Groovy que nous utilisons pour le développement depuis plusieurs mois. Force est de constater que Groovy tient la plupart des promesses et permet de passer très rapidement des idées au code, et cela malgré quelques particularités, parfois difficiles à comprendre. Il est important de dire que, dans notre contexte d’utilisation, Groovy ne remplace pas Java, c’est son complément de valeur ; dans une application Java restera valable pour les parties statiques, critiques, ou tout simplement écrites il y a longtemps qui fonctionnent bien et qui n’ont pas besoin d’être réécrites. Quant à Groovy, il sera utilisé pour les parties nécessitant plus d’agilité.

Références sur Groovy

Il existe une multitude de ressources traitant de Groovy, un bon point de départ est le livre de Venkat Subramaniam, intitulé Programming Groovy édité dans la série Pragmatic Programmer en 2008 (ISBN 1-934356-09-3). Le livre de référence sur Groovy c’est Groovy in Action de Dierk König, édité chez Manning en 2007 (ISBN 1-932394-84-2, deuxième édition revue et corrigée prévue pour 2012). Finalement le compilateur de Groovy peut être téléchargé sur le site Web ; on y trouve également la documentation et de nombreux exemples.

[1] DUBOCHET, Gilles. Scala. Flash Informatique 9/2010. EPFL 2010.

[2] en octobre 2011 Java occupe toujours la première place dans l’index TIOBE, mais son taux d’utilisation est tombé à 18%

[3] Groovy définit plusieurs conventions, par exemple la variable it représente la valeur courante de l’itération courante



Cherchez ...

- dans tous les Flash informatique
(entre 1986 et 2001: seulement sur les titres et auteurs)
- par mot-clé

Avertissement

Cette page est un article d'une publication de l'EPFL.
Le contenu et certains liens ne sont peut-être plus d'actualité.

Responsabilité

Les articles n'engagent que leurs auteurs, sauf ceux qui concernent de façon évidente des prestations officielles (sous la responsabilité du DIT ou d'autres entités). Toute reproduction, même partielle, n'est autorisée qu'avec l'accord de la rédaction et des auteurs.


Archives sur clé USB

Le Flash informatique ne paraîtra plus. Le dernier numéro est daté de décembre 2013.

Taguage des articles

Depuis 2010, pour aider le lecteur, les articles sont taggués:
  •   tout public
    que vous soyiez utilisateur occasionnel du PC familial, ou bien simplement propriétaire d'un iPhone, lisez l'article marqué tout public, vous y apprendrez plein de choses qui vous permettront de mieux appréhender ces technologies qui envahissent votre quotidien
  •   public averti
    l'article parle de concepts techniques, mais à la portée de toute personne intéressée par les dessous des nouvelles technologies
  •   expert
    le sujet abordé n'intéresse que peu de lecteurs, mais ceux-là seront ravis d'approfondir un thème, d'en savoir plus sur un nouveau langage.