version PDF - Flash informatique

FlashInformatique.epfl.ch
p/a EPFL - Domaine IT - Station 8 - CH 1015 Lausanne - tél. [phone]
22.11.2011
9
tout public
public averti
expert
Actualités
DIT-info 6
z Nouveau stagiaire à la Téléinformatique
z Nouvelles têtes au groupe Exploitation
VMWorld Copenhagen Fabien Figueras
& Eric Krejci 7
FlashiPhone: MobileIT François Roulet 10
Gutenberg, Helvetica et Steve Jobs
Laurent Kling 14
Eunis 2011 à Dublin en Irlande, en plein
dans les nuages ! Christian Zufferey 18
Analyse
Feelin’ Groovy
Maciej Macowicz 1
Petite introduction à la gestion
électronique de documents
Patricia Plaza Gruber 9
Mot-croisé: HÉBERGEMENT Julia Paolini,
Frédéric Rauss & Esteban Rosales 20
Comment faire?
Solution du concours ou Ada, Alan
et la pomme Appoline Raposo 12
Prochaines parutions
No Délai de rédaction Parution
10 01.12.11 20.12.11
1 12.01.12 31.01.12
2 09.02.12 28.02.12
page 12
Concours étudiants
La solution
Feelin’ Groovy
Maciej.Macowicz@epfl.ch, EPFL – Domaine IT - KIS, développeur Groovy
Yet another programming lan-
guage for the JVM (Java Virtual
Machine) , allows for agile pro-
gramming on the Java platform.
In this article we first introduce
the context of the JVM lan-
guages , then we present Groovy
as it can be seen by Java devel-
opers. We conclude by sketch-
ing the libraries and frameworks
available within the Groovy eco-
system .
Groovy, un langage de program-
mation pour la JVM (machine
virtuelle Java) , permet la pro-
grammation 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 biblio-
thèques/ frameworks disponibles
dans l’écosystème Groovy.
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 (ra-
masse-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 architec-
tures et systèmes d’exploitation. La pre-
mière implémentation de Java (1.0) est
apparue chez Sun Microsystems en jan-
vier 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’innom-
brables bibliothèques de composants logi-
ciels s’avère très complète.
Au début des années 2000, Java était large-
ment enseigné et utilisé; il occupait la pre-
Analyse

2flash informatique 22 22 NOVEMBRE 2011 - N° 9
flash informatique
mière place dans l’index TIOBE 1 avec 30 % de popularité; certains
parlaient alors de la fin de l’histoire des langages de program-
mation.
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 program-
mation fonctionnelle, permettant les manipulations de fonctions
par les programmes (contrairement à la programmation impéra-
tive 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 dyna-
mique 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 sys-
tè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 2.
Groovy 3 et Scala
4 représentent des objectifs de conception très
différents, nous en détaillerons quelques points. Scala est un lan-
gage 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; statique-
ment typé, il est doté d’un système de types très évolué, permet-
tant 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 biblio-
thè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 5.
Groovy
Groovy est un langage créé par les développeurs pour les déve-
loppeurs 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 ty-
ping), 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).
Feelin’ Groovy
1 www.tiobe.com/index.php/content/paperinfo/tpci/index.html
2 en.wikipedia.org/wiki/List_of_JVM_languages
3 groovy.codehaus.org
4 DUBOCHET, Gilles. Scala. Flash Informatique 9/2010. EPFL 2010. flashinformatique.epfl.ch/spip.php?article2221
5 en octobre 2011 Java occupe toujours la première place dans l’index TIOBE, mais son taux d’utilisation est tombé à 18%
Impressum
Revue consacrée aux technologies de
l’information, éditée par le Domaine IT de
l’EPFL (DIT). 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 par-
tielle, n’est autorisée qu’avec l’accord de la
rédaction et des auteurs.
Rédacteur en chef:
Jacqueline Dousson, fi@epfl.ch
Mise en page & graphisme:
Appoline Raposo de Barbosa
Comité de rédaction:
Jean-Daniel Bonjour, Patrice Fumasoli,
Florence Hagen, Laurent Kling, Julia
Paolini, François Roulet, Christophe
Salzmann, Richard Timsit & Predrag Vicei´c
Impression: Atelier de Reprographie EPFL
Tirage: 4000 exemplaires
Adresse Web: flashInformatique.epfl.ch
Adresse: Domaine IT EPFL
Station 8, CH-1015 Lausanne
Téléphone: [phone] & 32247
Abonnement au FI par e-mail à:
fi[e-mail]fl.ch

33
22 NOVEMBRE 2011 - N° 9
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 sta-
tiquement typée du langage est en cours de développement chez
Google sous le nom de Groovy++ 6.
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 appli-
cation 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:
z 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;
z interfaçage bidirectionnel avec le code Java, permettant l’in-
tégration des frameworks Java (Struts2, Sitemesh);
z rapidité de compilation et d’exécution;
z possibilité de prototypage rapide et de programmation explo-
ratoire;
z traitement de XML rapide et flexible;
z 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 Sca-
la); 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
7); 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 explo-
ratoire 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 original8.
Nous allons maintenant présenter quelques fonctionnalités re-
présentatives de Groovy.
GroovyBeans
Les composants JavaBeans largement utilisés dans Java sont inu-
tilement 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 construc-
teurs sont optionnels, on peut instancier un objet en passant une
map de paramètres d’instance nommés (code 2).
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).
Feelin’ Groovy
6 code.google.com/p/groovypptest/
7 codenarc.sourceforge.net
8 Groovy définit plusieurs conventions, par exemple la variable it représente la valeur courante de l’itération courante
def quickSort(list) {
if (list.size() < 2) return list
def pivot = list[list.size().intdiv(2)]
return (quickSort( list.findAll{ it < pivot}) +list.findAll { it == pivot } +quickSort(list.findAll { it > pivot }))
}
assert quickSort([’paul’, ’henri’, ’jacques’]) == [’henri’, ’jacques’, ’paul’]
code 1 – tri rapide en Groovy
class Personne {
String nom
String prenom
int age
}
Personne papet= new Personne (nom: ’Soubeyran’, prenom: ’César’, age: 59)
assert papet.name == ’Soubeyran’
assert papet.getName() == ’Soubeyran’
code 2 – GroovyBean

4flash informatique 44 22 NOVEMBRE 2011 - N° 9
flash informatique
Personne p
... nom= (p != null) ? p.getNom(): null; // Java
... nom= p?.nom // Groovy
... nom = (p.getNom()!= null) ? p.getNom() : "unknown"; // Java
... nom = p.nom?: ’unknown’ // Groovy
... nom = (p!= null && p.getNom()!= null) ? p.getNom() : "unknown"; // Java
... nom = p?.nom?: ’unknown’ // Groovy
code 3 – opérateurs
9 download.oracle.com/javase/tutorial/essential/exceptions/runtime.html
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).
String p=’Ugolin’
String n=’Soubeyran’
/* chaîne évaluée */
String u= "$p - $n"
assert u == ’Ugolin - Soubeyran’
/* chaîne multiligne */
String sql= """
SELECT * FROM annuaire
WHERE age < 35
"""
code 4 – chaînes de caractères
Expressions régulières
Les expressions régulières en Java sont lourdes à utiliser, l’essen-
tiel 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).
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).
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).
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 effec-
tue 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 RunTi-
meException 9). Groovy lève ces contraintes, les exceptions non
traitées sont simplement passées à l’appelant.
Feelin’ Groovy
def text = ’Groovy est bien’
def pattern= ~/(G|g)roovy/ // syntaxe spéciale pour les e.r., chaînes entre ~/ et /
assert ’Groovy est bien’ =~ /(G|g)roovy/ // =~ vrai si la chaîne contient un fragment conforme à l’e.r.
assert !(’Groovy est bien’ ==~ /(G|g)roovy/) // ==~ vrai si toute la chaîne est conforme à l’e.r.
assert text ==~ /(G|g)roovy.*$/ //
assert "a b c".split(/\s/) == [’a’, ’b’, ’c’] // chaine -> liste via split + e.r.
assert ("a b c" =~ /\S/).collect { it } == [’a’, ’b’, ’c’] // chaine -> liste via e.r.
new File("pagnol.txt").eachLine{ // imprimer toutes les lignes contenant ’jean’ ou ’florette’
line-> if (line =~ /[Jj]ean|[Ff]lorette/) println line
}
/* on sélectionne seulement le premier et le troisième mot dans une séquence de trois mots */
assert "eau des collines".replaceAll(~/(\w+) (\w+) (\w+)/, ’$1 - $3’) == ’eau - collines’
code 5 – expressions régulières
for (int i=0; i< 10; i++) { System.out.println(i); } // boucle Java
/* boucles Groovy avec fermetures prédéfinies */
times(10) { println it } // { println it } : fermeture, paramètre de times
0.upto(9) { println it }
(0..<10).each { println it }
/* juste nombres impairs */
(0..10).findAll{ it%2 }.each { println it } // fermeture {it%2}= prédicat passé à findAll, {println it} = param. de each
/* fermeture définie par le développeur */
def benchmark(Closure c) { // c = fermeture (code!) passée en paramètre à la fonction
long elapsed= System.currentTimeMillis() // on récupère la valeur de l’horloge
c.call() // on appelle le code passé en paramètre (le code peut être long)
return System.currentTimeMillis()-elapsed // à la fin on calcule le temps d’exécution et on le retourne
}
long elapsed= benchmark { sleep(1000) } // sleep (...) est le bloc de code passé en paramètre.
code 6 - fermetures

55
22 NOVEMBRE 2011 - N° 9
Traitement de XML
Le traitement des données XML est très fréquent dans les appli-
cations 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ériali-
sation de XML sur un document XML (code 8 et 9). La sérialisa-
tion 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.
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 traite-
ment 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).
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 plu-
sieurs 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
Feelin’ Groovy
<annuaire>
<personne prenom="Ugolin" nom="Soubeyran">
<age>30</age>
<adresse rue="rue des Romarins" numero="12" localite="Bastides Blanches"/>
</personne>
<personne prenom="César" nom="Soubeyran"> ... </personne>
<personne prenom="Florette" nom="Cadoret"> ... </personne>
<personne prenom="Jean" nom="Cadoret"> ... </personne>
</annuaire>
code 8 – exemple de données XML
def xml= new XmlSlurper().parse("data/eau_des_colinnes.xml") // lecture et analyse du fichier
xml.personne.each { // afficher toutes les personnes
println "${[email protected]()}, ${[email protected]()}, ${it.age} ans"
}
def comparerPersonnes = { a, b -> // comparer deux personnes, ordre décroissant
[email protected]().compareTo([email protected]())?: [email protected]().compareTo([email protected]())
}
xml.personne.findAll().sort { a,b -> comparerPersonnes(a,b) }.each { // trier la liste de personnes et l’afficher
print "${[email protected]()}, ${[email protected]()}, ${it.age}"
println " -- ${it.adresse.@numero}, ${it.adresse.@rue}, ${it.adresse.@localite}"
}
println (xml.personne.collect{Integer.valueOf(it.age.text())}.sum()/xml.personne.size()) // calculer la moyenne d’âge
code 9 – lecture de données XML
/* Listes */
def l=[’jean’, ’paul’, ’jacques’]
assert l.class.name == ’java.util.ArrayList’ // liste de Groovy est une liste Java
assert l.findAll{ it.startsWith(’j’) } == [’jean’, ’jacques’] // sélection
assert l.any { it.startsWith(’p’)} // prédicat: au moins un élément
assert l.findAll{ it.startsWith(’j’) }.every { it.startsWith(’j’)} // prédicat: tous les éléments
assert l*.toUpperCase() == [’JEAN’, ’PAUL’, ’JACQUES’] // application à tous les éléments
assert l[0] == 'jean' // premier élément de la liste
assert l[-1] == 'jacques' // dernier élément de la liste
l+= ’henri’ // ajout d’un élément
l-= ’paul’ // suppression d’un élément
assert l == [’jean’, ’jacques’, ’henri’]
l.each { println it } // itération simple
l.eachWithIndex { it, idx -> printf "%3d: %s\n", idx, it } // iteration avec index
assert l.sort () == [’henri’,’jacques’,’jean’] // tri ascendant, ordre lexicographique
assert l.sort {a,b-> b.compareTo(a)} == [’jean’,’jacques’,’henri’] // tri descendant, ordre lexicographique
assert l.sort {it.size()} == [’jean’, ’henri’, ’jacques’] // tri ascendant par longueur
assert l.sort {-it.size()} == [’jacques’, ’henri’, ’jean’] // tri descendant par longueur
/* Maps */
def age=[jean:28, paul:30, jacques:32]
assert age.jean== 28
code 7 – collections