version PDF - Flash informatique

9
22.11.2011
FlashInformatique.epfl.ch
Concours étudiants
La solution
p/a EPFL - Domaine IT - Station 8 - CH 1015 Lausanne - tél. +41 21 69 322 11
Analyse
page 12
Feelin’ Groovy
Actualités
DIT-info
6
Maciej.Macowicz@epfl.ch, EPFL – Domaine IT - KIS, développeur Groovy
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
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.
Groovy, un langage de programmation pour la JVM (machine
virtuelle Java), permet la programmation agile sur la plateforme 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.
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
tout public
public averti
expert
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 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 plateforme 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 pre-
Feelin’ Groovy
mière place dans l’index TIOBE 1 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,
3
4
5
1
2
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 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 5.
Groovy
Groovy est un langage créé par les développeurs pour les développeurs en tant que langage agile et dynamique pour la plateforme 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).
www.tiobe.com/index.php/content/paperinfo/tpci/index.html
en.wikipedia.org/wiki/List_of_JVM_languages
groovy.codehaus.org
DUBOCHET, Gilles. Scala. Flash Informatique 9/2010. EPFL 2010. flashinformatique.epfl.ch/spip.php?article2221
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 partielle, n’est autorisée qu’avec l’accord de la
rédaction et des auteurs.
2 flash informatique
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ć
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: +41 21 69 32246 & 32247
Abonnement au FI par e-mail à:
fi[email protected]fl.ch
Feelin’ Groovy
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++ 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 cidessous 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:
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’intégration des frameworks Java (Struts2, Sitemesh);
z rapidité de compilation et d’exécution;
z possibilité de prototypage rapide et de programmation exploratoire;
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 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 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 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 original8.
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).
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).
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
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
22 NOVEMBRE 2011 - N° 9
3
Feelin’ Groovy
Personne p
... nom= (p != null) ? p.getNom(): null;
... nom= p?.nom
... nom = (p.getNom()!= null) ? p.getNom() : "unknown";
... nom = p.nom?: ’unknown’
... nom = (p!= null && p.getNom()!= null) ? p.getNom() : "unknown";
... nom = p?.nom?: ’unknown’
//
//
//
//
//
//
Java
Groovy
Java
Groovy
Java
Groovy
code 3 – opérateurs
Chaînes de caractères
Fermetures
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).
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).
String p=’Ugolin’
String n=’Soubeyran’
Collections
/* chaîne évaluée */
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).
String u= "$p - $n"
assert u == ’Ugolin - Soubeyran’
/* chaîne multiligne */
String sql= """
SELECT * FROM annuaire
WHERE age < 35
"""
Traitement d’exceptions
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).
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 (sousclasses des exceptions non traitées comme par exemple RunTimeException 9). Groovy lève ces contraintes, les exceptions non
traitées sont simplement passées à l’appelant.
def text = ’Groovy est bien’
def pattern= ~/(G|g)roovy/
assert ’Groovy est bien’ =~ /(G|g)roovy/
// =~
assert !(’Groovy est bien’ ==~ /(G|g)roovy/)
assert text ==~ /(G|g)roovy.*$/
assert "a b c".split(/\s/) == [’a’, ’b’, ’c’]
assert ("a b c" =~ /\S/).collect { it } == [’a’, ’b’, ’c’]
new File("pagnol.txt").eachLine{
line-> if (line =~ /[Jj]ean|[Ff]lorette/) println line
}
// syntaxe spéciale pour les e.r., chaînes entre ~/ et /
vrai si la chaîne contient un fragment conforme à l’e.r.
// ==~ vrai si toute la chaîne est conforme à l’e.r.
//
// chaine -> liste via split + e.r.
// chaine -> liste via e.r.
// imprimer toutes les lignes contenant ’jean’ ou ’florette’
/* 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 }
0.upto(9) { println it }
(0..<10).each { println it }
// { println it } : fermeture, paramètre de times
/* 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) {
long elapsed= System.currentTimeMillis()
c.call()
return System.currentTimeMillis()-elapsed
}
long elapsed= benchmark { sleep(1000) }
code 6 - fermetures
download.oracle.com/javase/tutorial/essential/exceptions/runtime.html
9
4 flash informatique
//
//
//
//
c = fermeture (code!) passée en paramètre à la fonction
on récupère la valeur de l’horloge
on appelle le code passé en paramètre (le code peut être long)
à la fin on calcule le temps d’exécution et on le retourne
// sleep (...) est le bloc de code passé en paramètre.
Feelin’ Groovy
/* Listes */
def l=[’jean’, ’paul’, ’jacques’]
assert l.class.name == ’java.util.ArrayList’
assert l.findAll{ it.startsWith(’j’) } == [’jean’, ’jacques’]
assert l.any { it.startsWith(’p’)}
assert l.findAll{ it.startsWith(’j’) }.every { it.startsWith(’j’)}
assert l*.toUpperCase() == [’JEAN’, ’PAUL’, ’JACQUES’]
assert l[0] == 'jean'
assert l[-1] == 'jacques'
l+= ’henri’
l-= ’paul’
assert l == [’jean’, ’jacques’, ’henri’]
l.each { println it }
l.eachWithIndex { it, idx -> printf "%3d: %s\n", idx, it }
assert l.sort () == [’henri’,’jacques’,’jean’]
assert l.sort {a,b-> b.compareTo(a)} == [’jean’,’jacques’,’henri’]
assert l.sort {it.size()} == [’jean’, ’henri’, ’jacques’]
assert l.sort {-it.size()} == [’jacques’, ’henri’, ’jean’]
//
//
//
//
//
//
//
//
//
liste de Groovy est une liste Java
sélection
prédicat: au moins un élément
prédicat: tous les éléments
application à tous les éléments
premier élément de la liste
dernier élément de la liste
ajout d’un élément
suppression d’un élément
//
//
//
//
//
//
itération simple
iteration avec index
tri ascendant, ordre lexicographique
tri descendant, ordre lexicographique
tri ascendant par longueur
tri descendant par longueur
/* Maps */
def age=[jean:28, paul:30, jacques:32]
assert age.jean== 28
code 7 – collections
Traitement de XML
Accès aux bases de données SQL
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.
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).
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
<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
22 NOVEMBRE 2011 - N° 9
5
Feelin’ Groovy
def bastides= [’César’: ’Soubeyran’,’Ugolin’: ’Soubeyran’, ’Manon’, ’Cadoret’ ]
def builder =new groovy.xml.MarkupBuilder()
builder.annuaire {
bastides.each { prenom, nom -> personne( prenom: prenom, nom: nom ) }
}
code 10 – génération de XML
def sql = groovy.sql.Sql.newInstance(’jdbc:mysql://localhost:3306/annuaire’, userid, password, ’com.
mysql.jdbc.Driver’)
sql.eachRow("SELECT nom,prenom FROM annuaire") {
// imprimer les entrées de l’annuaire
println "${it.prenom}, ${it.nom} "
}
def builder =new groovy.xml.MarkupBuilder()
// transformer tous les entrées en XML
builder.annuaire {
sql.eachRow(’SELECT * from annuaire’) {
personne(nom: it.nom, prenom: it.prenom )
}
code 11 – accès à la base de données
Easyb, Spock et Geb: environnements de tests
Gradle: outil de construction des logiciels (considéré comme successeur de maven).
tiques, 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é.
Conclusion
Références sur Groovy
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 sta-
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 groovy.codehaus.org; on y trouve également la documentation et de nombreux exemples. n
Actualités
DIT-info
Nouveau stagiaire au groupe Téléinformatique
Nous souhaitons une très cordiale bienvenue à
Philippe Gagnon qui a commencé son stage le
1er novembre. Changeant d’orientation, ce stage
lui permettra de compléter sa formation, à côté de
son brevet fédéral en informatique de gestion. En travaillant avec
l’équipe de techniciens DIT-TI pendant ces douze prochains mois,
il aura l’occasion de découvrir la cuisine du réseau. Nous espérons
qu’il profite au maximum des opportunités de ce stage pour sa
future carrière dans le domaine informatique.
Jacques.Virchaux@epfl.ch, Domaine IT
Nouvelles têtes au groupe Exploitation
Le groupe Exploitation accueille deux nouveaux collaborateurs.
Nils Schätti. Arrivé le 1er octobre dans l’équipe
HPC pour succéder à Pascal Jermini qui nous
a quitté début mai. Nils participera à l’administration du grid et des clusters de calcul.
Funda Cubuk. Arrivée le 1er novembre au sein de
l’équipe stockage pour y effectuer un stage
d’un an; elle succèdera à Fabien Borloz qui
nous quittera fin novembre. Funda reprendra
les développements du site Web de gestion des
salles serveurs.
Nous souhaitons à tous les deux la bienvenue et un plein succès
dans leur nouvelles fonctions.
Fabien.Figueras@epfl.ch, Domaine IT
6 flash informatique