Programmez120

L e m a g a z i n e d u d é v e l o p p e m e n t

mensuel n°120 - juin 2009

PROwww.programmez.com

LangageF# : le nouveau visage de .Net

Cloud ComputingDéployer Java sur Amazon EC2

MéthodeCréer vos DSL sous Eclipse

ConcurrenceMaîtriser le Concurrency andCoordination Runtime

SGBDLINQ et MySQL : c’est possible ! 3:H

IKONB=^UZ^Z]:?a@b@m@k@a;

M 0

4319

- 12

0 - F

: 5,9

5 E

Printed in France - Imprimé en France - BELGIQUE 6,45 € - SUISSE 12 FS - LUXEMBOURG 6,45 € - DOM Surf 6,90 € - Canada 8,95 $ CAN - TOM 940 XPF - MAROC 50 DH

PROG

RAM

MEZ

!

grammez!Votre code fonctionne-t-il sur tous les systèmes ?Qt, compilation croisée, les outils, le problème des navigateurs web.

● Bien débuter avec Silverlight

● Tout savoir sur Expression 3.0

● Silverlight sur votre Desktop

● Silverlight pour Eclipse

Le développeur devient AGILE !

Programmation MULTICOEUR

Devenir un développeur parallèle Les enjeux des processeurs multicore

Web 2.0Spécial

SILVERLIGHTSpécial

SILVERLIGHT

Multi-plate-formeMulti-plate-forme

©is

tock

.com

/77D

ZIG

N

● Adopter une méthode agile.● Scrum + eXtreme Programming : le cocktail parfait● Les experts dévoilent leurs secrets agiles

Le développeur devient AGILE !

01/02-83/84-120 20/05/2009 10:27

Logi

ciel

pro

fess

ionn

el. D

ocum

ent n

on c

ontra

ctue

l. Su

ppor

t tec

hniq

ue g

ratu

it: 1

5 re

quêt

es s

ur la

ver

sion

en c

ours

de

com

mer

cialis

ation

.

*: W

IND

EV a

été

élu

«La

ngag

e le

plu

s pr

oduc

tif d

u m

arch

é» p

ar le

s le

cteu

rs d

e la

revu

e «P

rogr

amm

ez!»

, oct

obre

200

8Nouvelle version

Développez 10 fois plus vite

PLATEFORME PROFESSIONNELLE DE DÉVELOPPEMENT (AGL)

Windows, .Net, JavaWindows 98, 2000, NT, 2003, XP, Vista, 2008

WINDEV 14 est l’environnementde développement totalement intégré (IDE, ALM),intégralement en français, réputé pour sa puis-sance et sa facilité d’utilisation.

WINDEV 14 est livré complet: éditeur d’ana-lyses (UML,...), RAD, patterns, lien avec toutes lesbases de données (ODBC, OLE DB), Oracle, SQLServer, AS/400, Informix, DB2..., lien natif MySQL,PostgreSQL, base de données Client/ServeurHyperFileSQL gratuite incluse, Générateur d’étatsPDF, Codesbarres, Accès natif SAP R/3, LotusNotes, Gestion de planning, Gestion des Exigences,

L5G, SNMP, Bluetooth, TAPI, OPC, FTP, HTTP, Socket, Twain, API, DLL,domotique, liaisons série et USB, débogage à distance, profiler, refac-toring, génère d’applications JAVA, multilangue automatique,Gestionnaire de versions, Installateur 1-clic, etc...

Les applications créées fonctionnent avec toutes les versions deWindows: 98, 2000, NT, 2003, XP, Vista, sous TSE et Citrix, sur eeePC...

WINDEV 14 gère le cycle complet de développement, pour des équipesde 1 à 100 développeurs. Le support technique est gratuit*.

Vous aussi, développez 10 fois plus vite...avec WINDEV 14.

Fournisseur Officiel de la Préparation Olympique

www.pcsoft.fr

252 pages + DVD + Version Express incluse +112 Témoignages.

Tél: 04.67.032.032 ou [email protected]

gicie

l pro

fess

ionn

el DEMANDEZ LE DOSSIER GRATUIT

RÉUSSISSEZ TOUS VOS PROJETSAVEC L’OUTIL DE DÉVELOPPEMENTÉLU LE PLUS PRODUCTIF*

VOTRE CODE ESTMULTI-PLATEFORMES: Windows, .Net, Java,PHP, J2EE, XML,Internet, Ajax, PocketPC, SmartPhone,Client riche ...

VERSION EXPRESS GRATUITETéléchargez-la !

01/02-83/84-120 20/05/2009 9:41

http://www.programmez.com/include/pub_mag_redirection.php?id=404

som

mai

re\\ numéro 120 - juin 2009grammez!PRO L e m a g a z i n e d u d é v e l o p p e m e n t

CD

RO

M

Donnez votre avis sur ce numéro : www.programmez.com/magazine_satisfaction.php

12

27

NOUVEAU

Démarrez le développement parallèleavec la toute dernière boîte à outils Intel®Offert par Programmez! - Juin 2009 – Echantillon gratuit

\\ actusL’actualité en bref ..............................................................................8Agenda..............................................................................................8

\\ événementsPiloter l’ordinateur par la pensée..........................................................12

\\ gros planMulti-plate-formeMulti-plate-forme : où, quand, comment, pourquoi ? ..............................15Développer multi-plate-forme en.net avec Delphi PRISM ..........................16La compilation croisée entre Linux et Windows ......................................19Qmake, le système de build multi-plate-forme qu’il vous faut ....................22Le multi-navigateur : le guide de survie du développeur web ....................24

\\ dossier : Le développeur devient AGILELes méthodes agiles pour mieux développer ..........................................27eXtreme Programming : les fondamentaux pour le développeur agile ........32La journée d’un développeur agile ........................................................34Standardiser la résolution de problèmes dans une équipe agile ................36L’agilité, une révolution culturelle ..........................................................37Vendre Scrum à une équipe qui pratique V ............................................38Adopter le mode agile en début d’un projet ou en cours de route ............41

\\ développement webBien débuter en Silverlight ..................................44Microsoft Expression Studio 3..............................................................46Silverlight 3 envahit aussi le bureau ......................................................50

\\ techniqueCloud Computing : déploiement d’applications Java ................................56

Pourquoi passer à la programmation parallèle ..........58

Intel Parallel Studio débarque ..............................................................60

\\ codeComprendre les Design Pattern Fabrique ..............................................62CCR, une API de programmation concurrente pour .net ..........................66Introduction à la construction d’un DSL sous Eclipse ..............................70Eclipse Tools for Silverlight : Silverlight sur Eclipse, c’est possible ! ..........73Utilisation de Linq avec différentes bases de données ............................75F# : l’avenir de .net et du développement Windows ? w(1re partie) ..........78

\\ temps libreEn direct des labos (2e partie) ............................................................81Les livres du mois ..............................................................................82

46

60

70

15

Le CD du mois : Découvrez la version finale de Intel Parallel Studio

03-05 edito sommaire120 20/05/2009 10:28

FAITES EVOLUER VOTRE CODE.Réalisez des applications parallèles robustes, de l‘analyse à la compilation, du débogage

à l‘optimisation. Intel® Parallel Studio est la panoplie d‘outils ultime pour les applications

Disponible maintenant: www.intel.com/software/parallelstudio

© 2009-2010, Intel Corporation. Tous droits réservés. Intel et le logo Intel sont des marques d’Intel Corporation, déposées ou enregistrées aux États-Unis et dans d’autres pays. *Les autres noms et désignations peuvent être revendiqués comme marques par des tiers.

FrenchPub 21cmx28.5cm BoxShot.indd 1 5/7/09 4:29:28 PM

03-05 edito sommaire120 20/05/2009 10:28


Rédaction : [email protected] de la Rédaction : Jean KaminskyRédacteur en Chef :François Tonic - [email protected] collaboré : F. Mazué, J.B. Boisseau, G Vidal.Experts : B. Boucard, P. Guermonprez, O. Lance,A. Dupuis, J. Mezhrahid, F. Queudret, L. Laslaz,O. Juncu, H. Harrath, A. Peter, S. Boigelot, L. Bar, J. Bernard, D. Vojtisek, T. Jaskula, N. Biedermann, C. Durand, R. Pierquin, P. Blayo.Publicité : Régie publicitaire, K-Now sarlPour la publicité uniquement : Tél. : 01 41 77 16 03 - [email protected] : Go-02 sarl, 6 rue Bezout 75014 Paris - [email protected]épôt légal : à parution - Commissionparitaire : 0712K78366 ISSN : 1627-0908 Imprimeur : ETC - 76198 YvetotDirecteur de la publication : J-C VaudecraneCe numéro comporte 1 CD-Rom

Abonnement : Programmez 22, rue René Boulanger,75472 Paris Cedex 10 - Tél. : 01 55 56 70 55mail : [email protected] : 01 40 03 97 79 - du lundi au jeudi de 9h30 à12h30 et de 13h30 à 17h00, le vendredi de 9h00 à12h00 et de 14h00 à 16h30. Tarifs abonnement(magazine seul) : 1 an - 11 numéros France métropolitaine : 49 € - Etudiant : 39 € - CEE etSuisse : 55,82 € - Algérie, Maroc, Tunisie :59,89 € - Canada : 68,36 € - Tom : 83,65 €

Dom : 66,82 € - Autres pays : nous consulter.PDF : 30 € (Monde Entier) souscription exclusive-ment sur www.programmez.com

PROCHAINNUMÉRON°121 juillet-août 2009, parution 30 juin

✔ DéveloppementAttention le futur est déjà là !

✔ Préparez-vous cet été :- Windows 7, Android, iPhone,

Surface, Java 7- OpenVibe : l'informatique

pilotée par la pensée

✔ Enquête carrière :- Etes-vous satisfait

de votre job ?

L’INFOPERMANENTEWWW.PROGRAMMEZ.COM

PM

grammez!PRO L e m a g a z i n e d u d é v e l o p p e m e n t

Le développeur serait-il un chat ?3 %. C’est le pourcentage de développeurs ayant sur

ces derniers mois introduit une fonction parallèle dans uncode source. Une petite poignée! Voilà un chiffre bien intriguant, non ? Etpourtant, depuis plus de 18 mois, Programmez ! s’investit autour de laprogrammation multicore / parallèle pour vous sensibiliser sur un sujethautement stratégique et d’une complexité non négligeable.

Aujourd’hui, l’écrasante majorité des PC vendus possède au moins 2cœurs. Et cela monte très vite à 8, 16 cœurs. D’ici à 2010, les fondeursestiment à 100 % les nouvelles machines qui seront multicoeur, que sesoit dans le desktop, le serveur, le portable, et même les téléphones por-tables ! L’argument anti-parallèle est cependant non négligeable : la pluspart des PC actuellement en activité ne sont pas multicores. Mais d’ici 5 ans, le parc explosera. Et cinq ans ce n’est pas grand chose… C’est donc aujourd’hui qu’il faut comprendre la programmation parallèle.Car cette programmation est loin d’être " friendly " comme vous le verrezrapidement dans notre grand dossier à paraître sur plusieurs numéros.On change de philosophie de code. Il faut penser multi dimension du codeen quelque sorte : exécuter plusieurs tâches parallèlement. Avec toute lacomplexité de gestion, de concurrence, de mémoire, etc. Les risques debugs se multiplient et, en programmation multicore, ces erreurs ne par-donnent pas. Cependant, n’allons pas croire qu’il faille paralléliser soncode à outrance. Au contraire, un code trop parallèle peut s’avérer pluslent qu’un code " normal " ! Il faut donc définir les portions du code à paral-léliser. La priorité sera donnée aux fonctions très exigeantes en puissan-ce de calcul comme les traitements Audio / Vidéo, les requêtes de don-nées, la compression, la cryptographie, etc.

Demain, les outils, les langages vont offrir de puissantes fonctions paral-lèles directement dans la machine virtuelle (ex. : Java et .Net) et deslibrairies vont aider le gentil développeur à paralléliser en quelquesminutes un code. Mais, n’attendez pas non plus la solution miracle ! Leparallélisme nécessite une solide compétence technique et une rigueur decodage extrême. Cependant, le développeur parallèle est réellement l’ave-nir et là, il apporte une valeur, une compétence.

Autre sujet chaud du moment, lui aussi récurrent me direz-vous, l’agilité.Non pas que le développeur doive devenir aussi souple physiquementqu’un acrobate… mais il doit intégrer le merveilleux monde des méthodesagiles. Depuis quelques mois, le couple Scrum / eXtreme Programmingconnaît un succès fulgurant dans les équipes de développement. Et pourcause, Scrum offre un cadre organisationnel, et XP redonne joie et plai-sir aux développeurs. Et oui, fini le temps du programmeur à la chaîne,codant sans réellement réfléchir… ! Le développeur revient au centre duprojet, avec de nouvelles responsabilités. Où, quand, comment ? C’est ceque l’on verra dans notre grand dossier du mois.

Si nous avions prédit la survie, la mort puis la résurrection de notre amile développeur, aujourd’hui, nous lui prédisons sa réincarnation. Comme lechat, le développeur n’aurait-il que neuf vies ? Rendez-vous au numéro150 de Programmez ! pour le savoir. Le suspense sera insoutenable…

■ François TonicRédacteur en chef

édito\

\03-05 edito sommaire120 20/05/2009 10:28

MICR0902_7 DP Visual 420x285 VEC.indd 1 14/04/09 17:50:56

06-07 20/05/2009 9:49


actu \\ en bref

8 • PROgrammez ! \\ Juin 2009

D epuis un mois, les rachats se suc-cèdent ! Est-ce la crise qui accélèreles rapprochements et la nécessité

de croissance externe des éditeurs ? Quoiqu’il en soit en quelques semaines, deuxgrandes figures du développement ont étéabsorbées : Sun et Borland. Pour Sun, onattendait depuis des mois le rachat. Si IBMtenait la corde, c’est finalement Oracle quirafle une fois de plus la mise pour plus de 7milliards de dollars. Oracle avait déjà uneforte implication dans Java, cela ne fait querenforcer cette tendance. Mais au-delà,Oracle complète ses offres logicielles notam-ment avec Glassfish et les outils de sécuritéde Sun ou encore sur le matériel notam-ment les lignes de serveurs et de stockage,tout en mettant la main sur un système d’ex-ploitation fiable et robuste : Solaris. Et sur-tout, MySQL tombe sous la coupe d’Oracle.Ce rachat pose aussi des questions depérennité de certaines offres, notammentdans le logiciel car elles font doublon avecles gammes actuelles d’Oracle comme pourle serveur d’application, la base de données.De quelle manière, MySQL sera-t-il positionnépar rapport à Oracle Database ? L’autrequestion concerne l’implication des dévelop-peurs Sun dans les projets open source.L’effort sera-t-il poursuivi, par exemple dansOpenOffice ou encore Netbeans. Mais pourOracle, il s’agit aussi de mieux se positionnersur le cloud computing et la virtualisation,deux marchés qui étaient très mal adresséspar l’éditeur. L’autre surprise du mois est le rachat pur etsimple de Borland par Micro Focus. Borlandavait déjà cherché à se recentrer sur lecycle de vie, la modélisation et la gouvernan-

ce, en se délestant totalement des outils dedéveloppements, de CodeGear à Embarca-dero. La concurrence accrue des outils decycle de vie y est sans doute pour quelquechose, ainsi que la profusion d’outils demodélisation, marché sur lequel, BorlandTogether avait du mal à rester un acteursignificatif. Cette opération se monte à envi-ron 75 millions de dollars. Reste à savoir sil’ensemble des gammes actuelles serontpoursuivies. Micro Focus a aussi mis la mainsur une partie des outils de Compuware :gamme test et de qualité. Compuwarecherche là aussi à recentrer son activité surles performances et optimisation sur main-frame et la gestion du portefeuille applicatif. Ces rachats modifient le marché du dévelop-pement et il faut encore s’attendre à d’im-portants rachats dans les mois à venir, enparticulier, côté Microsoft…

■ Embarcadero sort une nouvelle offredédiée aux données et Java afin dedétecter et de corriger les problèmes deperformances, DB Optimizer 1.5 et Per-formance Center. Ces outils permettentde profiler et de régler finement lescodes Java et SQL depuis la coucheapplicative Java jusqu’à la base de don-nées, facilitant ainsi le développement decodes et la détection des problèmesavant qu’une requête applicative ou debase de données ne soit envoyée à laproduction.

■ JetBrains a dévoilé un IDE Ruby :RubyMine 1.0. L'un des avantages clésde RubyMine réside dans la compréhen-sion poussée des spécificités du langagede Ruby, sa nature dynamique, et lesconventions de code. Il a connu un beausuccès depuis sa disponibilité. RubyMineapporte une gamme de refactorisationefficace compatible avec Rails, simpli-fiant considérablement par là-même leprocessus de modification des codes.

■ Quest annonce l’intégration de vWork-place, gestionnaire de poste de travailvirtualisé, aux environnements Micro-soft. Cela signifie que cette solution estdésormais compatible avec System Cen-ter Virtual Machine Manager et App-V(virtualisation d’application).

■ Perforce a dévoilé un nouveau compo-sant : Perforce Server Log Analyser. Ilpermet aux administrateurs de téléchar-ger leurs fichiers de log pour une analyseinstantanée. Ils disposent pour cela d’unaccès sécurisé à leurs fichiers de log età leurs résultats d’analyses, qui peuventêtre stockés jusqu’à dix jours. Disponiblegratuitement sur la Base de Connaissan-ce du site Perforce :https://kb.perforce.com/psla.

■ En attendant la disponibilité de Flex 4et des nouveaux outils, dont Catalyst,Adobe annonce une vingtaine de socié-tés qui supportent Strobe. Strobe est unframework pour aider les éditeurs etconstructeurs à avoir un standard pourles media player. Les fonctions sont trèsintéressantes comme le streaming dyna-mique, la fonction pause dans du directlive, une gestion fine de la qualité de service,etc. Strobe devrait être disponible dansquelques mois. www.adobe.com/go/strobe

JUINLe 04 juin, Hôtel Castille, Paris1er, invitation au lancement d’IntelParallel Studio, la suite complètepour le développement parallèle.Programme détaillé sur :http://www.sosdevelopers.com/intel/form.html

Le 09 juin, Lille, Eura Technolo-gies, WYGDAY 2009, pour com-prendre comment les

technologies vont supporter votrefutur( Green IT, Cloud Platform,Microsoft Surface, Live Mesh,Virtual Earth/Google Maps, .NET4 ou encore Azure).http://wygday.wygwam.com/

Le tour découverte Flex 3 et Air àtravers la France. Ateliers gra-tuits de découverte des outilsAdobe.http://www.baao.com/Forma-tions/LE_TOUR_DE_FLEX_ET_AIR_.html

Du 17 au 18 juin 2009, ParisExpo - Porte de VersaillesSALON ONLINE 2009, l’événementdes solutions web et mobilehttp://www.online-expo.fr/

JUILLETDu 06 au 07 juillet 2009, Grandamphithéâtre de l’EPITA,les PHP Days "Industrialisez votrePHP!" vous permettront d'acqué-rir les compétences nécessairesà une utilisation professionnellede PHP.Organisé par Alterway etAnaska. www.phpdays.com

agenda \\

MarchéRachat de Sun, Borland, et d’une partie deCompuware : le nouveau visage du développement

08-09 20/05/2009 9:46

Perforce, le système de Gestion de Configuration Logicielle rapide

Tous droits réservés. Toutes les marques citées sont des marques ou des marques déposées de leurs propriétaires respectifs.

Téléchargez sans conditions une copie gratuite de Perforce surwww.perforce.com. Un service d’assistance technique gratuit estoffert pendant toute la période d’évaluation.

Nos équipes supports sont toujours disponibles afin de partager leurs

expertises en personne - pas de réponses automatiques, de

répondeurs ou de centres d'appel. Nos ingénieurs supports

hautement qualifiés se font une fierté de traiter rapidement vos

appels et de vous apporter des réponses précises.

Réaliser vos projets dans les délais nécessites des équipes supports

prêtes à vous aider quand vous en avez besoin. Vous pouvez compter

sur le système de GCL rapide Perforce et son support technique

réputé, pour vous donner un atout gagnant.

Le support technique PerforceDes traitements rapides, des réponses précises

08-09 20/05/2009 9:46


actu \\ en bref


■ Smartesting, spécialisé dans les outils detests, annonce Test Designer 3.4. L’outilpermet de générer automatiquement destests fonctionnels à partir d’un module.Cette version simplifie la création desmodèles de tests avec l’ajout de nouveauxassistants, l’éditeur est maintenant intégré àEclipse. D’autre part il sait s’intégrer auxgrosses solutions de tests du marchécomme HP Quality Center.

■ Oracle lance une nouvelle version de Beehi-ve. Celle-ci renforce le système de build unifiépour l’entreprise avec de nouveaux outils decollaboration (mail, calendrier, espace detravail en équipe, etc.). Plus que jamais l’outilcherche à aider l’entreprise à mieux collabo-rer et à améliorer la partie web pour le tra-vail en équipe.

■ Ubuntu lance un concurrent frontal àMicrosoft Live Mesh : Ubuntu One. Il s’agitd’un service stockage et de synchronisationdes données sur le cloud, comme Mesh.

Une fois inscrit, il faut installer un clientdesktop sur son Ubuntu. On dispose d’un " desktop " virtuel comme avec Mesh maisen moins ergonomique. Dommage que leclient desktop ne soit disponible que sousUbuntu. La version de base (2 Go de stocka-ge) est gratuite. La version 10 GB est payan-te (10 dollars par mois).

■ Eclipse 3.5 sera disponible fin juin. Cetteversion apporte pas mal de changements :support de Solaris 86x pour SWP, nouveaumodule d’installation de logiciels, changementd’éditeurs et de pages dans les éditeurs pardes raccourcis claviers, nouvelles optimisa-tions entre Eclipse et Cocoa (MacOS X),comparateur d’API (pratique en cas de chan-gement). Site : www.eclipse.org

■ SpringSource a rendu disponible Spring-Source tc Server, une version entreprise deTomcat. Elle se destine aux Datacenters, auxenvironnements virtuels et cloud computing.Il est prévu de livrer ce serveur sous formed’appliance virtuelle optimisée pour VMware.Site : www.springsource.com

C’est la grande

nouveauté du mois

de mai. Après une

pré-version lourde et

d’une lenteur

souvent horripilante,

Microsoft livre enfin

aux développeurs

une bêta du prochain

Visual Studio qui

annonce de

nombreuses

nouveautés.

L a version bêta, dispo-nible à l’écriture de

l’article, pèse 3,6 Go enenvironnement .Net (4,6Go avec C++). Bonne nou-velle dès l’installation : laprésence de F# (articledans ce numéro), de Dot-fuscator, des outi ls detests unitaires, du .Net 4,du framework Sync.

100% WPFCe qui frappe d’emblée,c’est une interface assezlargement modifiée. Elle seveut plus claire, moinscomplexe, dotée d’éditeursplus ergonomiques. Onconstate aussi la présenced’une nouvelle fonctionzoom surpuissante, preuveque Visual Studio s’appuiesur le framework WindowsPresentation Foundation(WPF). L’un des focus decette version concerne lecycle de vie des applica-tions que Microsoft veutdémocratiser auprès desdéveloppeurs. Team Sys-tem 2010 se dote en effet

de nouvel les fonct ions(fonction découverte descodes existants, nouveauxdiagrammes de modélisa-tion, outils améliorés pourla documentation…). Visual Studio 2010 sup-porte l’ensemble des der-nières évolutions de .Netet tout particulièrement.Net 4.0 que nous détaille-rons dans les prochainsnuméros. Retenons ici lesupport natif et en managé(.Net) de Windows 7,d’une mise à niveau desoutils de développementpour Office, du support deSharepoint, de Silverlight(uniquement 2.0 dans labêta testée). Autre grossenouveauté, la présence ducloud computing avec uneintégration transparentedes kits de développementAzure. Jusqu’à présent, ilétait parfois délicat de lesinstaller avec Visual Studio2008. Autre surprise bien-venue, l’arrivée du supportde DB2 et d’Oracle dansles bases de données, enplus du classique SQL Ser-ver ! Autre grosse nou-veauté : le support pardéfaut du développement

parallèle pour les proces-seurs multicoeurs (en C++et .net). Concernant lamodélisation, outre la ver-sion Architect de TeamSystem, le projet Oslo seraaussi sans doute présent.Oslo est la pierre angulairede l’approche transversaleet verticale de la modélisa-tion chez Microsoft.

Une version prometteuseA l’heure actuelle, il n’y apas de date officielle desortie. On évoque souventune disponibilité fin 2009,début 2010, sans plus deprécision. Il est probableque cette sortie se dérouleplusieurs semaines aprèsWindows 7. Nos premierstests montrent qu’il fauttout de même une machi-ne puissante avec unegrosse réserve de mémoi-re v ive. Les lenteursconstatées ici et là (notam-ment sur la toolbox) appa-raissent normales pourune bêta. Attendons lesévolut ions de per for-mances dans les pro-chaines versions pourmieux juger.

IDE

Visual Studio 2010 : enfin disponible en bêta !

10-11 OBJECT pub 20/05/2009 10:30

Juin 2009 \\ PROgrammez ! • 11

actu \\ sécurité

En 2002, après une série retentissante de vulnérabilités détectéesdans les logiciels Microsoft, Bill Gates siffle la fin de la récréation.Les failles d’Internet Explorer et celles du système d’exploitationinquiètent les entreprises utilisatrices, et certaines commencent àtester sérieusement les offres alternatives. Bien sûr, un simulateurde vol dissimulé dans Excel n’est pas la fin du monde. Sous le nom de Security Development Lifecycle (SDL), soit Cycle dedéveloppement sécurisé, l’initiative Microsoft a pour objectifs demettre la sécurité au cœur des développements de tous les produits,et de partager les résultats de cette politique avec ses partenaires. Ilne faut pas croire que le premier objectif soit si simple : en effet,pour des responsables de lignes de produits, la sécurité dans un pre-mier temps coûte cher. Il n’est donc pas surprenant de devoirattendre 2004 pour voir la démarche SDL généralisée à l’ensemblede Microsoft, et 2005 pour être rendue disponible au reste de l’éco-système. Où en somme-nous aujourd’hui, 7 ans après le lancementde ce processus ? Si vous vous rappelez le dossier dans Program-mez ! concernant les 25 erreurs de programmation les plus cou-rantes, il semblerait que nous soyons encore à l’âge de pierre en cedomaine ! D’après les statistiques citées par Microsoft, 70% des édi-teurs de logiciels font leurs tests de sécurité… après la mise envente de leur logiciel. On se heurte en fait à deux types de mentalité :le sempiternel " la sécurité coûte " et également " le système d’ex-ploitation devrait être là pour nous protéger ". Faux, et faux.

SécuritéMicrosoft relance SDL

Modelio : Nouvel outil de modélisation Modéliser sur toute la portée de l’entreprise pour un alignement SI/Métier

Modelio est disponible en trois éditions • Free : Un outil complet de modélisation gratuit !• Express Java : Un outil de développement Java guidé par le modèle de haute

performance pour seulement 100€ !• Enterprise : La solution de modélisation complète, supportant le travail de groupe,

extensible avec une riche palette de modules de modélisation et de générationdisponibles sur étagère

Modéliser n’a jamais été aussi abordable et productif• Ergonomie simple et productive• Support intégré de UML, BPMN, BPM, l’Architecture d’Entreprise,

L’analyse des besoins, … dans un seul référentiel• Travail de groupe distribué, intégré à SVN/Subversion• Des générations sur étagère adaptables pour toutes les cibles• Support MDA : transformation, extensibilité et adaptabilité

Modélisation du Système,

de l’Architecture& du Logiciel

Génération de Rapports &

DocumentationGénération BPEL, WSDL

Intégration aux outils tiers

Objectifs, Exigences,

Règles métier & Dictionnaire

www.modeliosoft.com

Modélisation de l’Architecture d’Entreprise,des Processus Métier

& de l’Architecture Orientée Services

Génération de CodeMulti cibles, pour Frameworks

[email protected]él. : 01 30 12 18 40

A la mi-mai, Microsoft a lancé un " nouveau SDK " comprenant :- Le guide SDL version 4.1.- Une intégration d’outils SDL dans Team System, l’environnementde développement intégré de Microsoft. (via un template)

- Un partenariat stratégique : SDL Pro Network avec SANS (25erreurs de programmation) et SAIC (une entreprise de cyber-sécu-rité travaillant pour le gouvernement US).

Elle répond donc aux trois objectifs : éduquer (les équipes), automati-ser (les processus) et assister (les projets). Les contraintes de sécu-rité s’intègrent donc désormais de façon transparente auxdéveloppements, et permettent enfin le suivi en temps réel des faillesde sécurité, tout en donnant une vue synthétique au moment de larevue finale du projet. Un exemple à suivre pour les autres éditeurs ?

■ Gilbert Vidal

10-11 OBJECT pub 20/05/2009 10:30


I l est rare que la présentation d’un logicielattire de nombreuses caméras de télévi-sion. C’était pourtant le cas, ce 13 mai,

au siège de l’Inserm (Institut National de laSanté et de la Recherche Médicale). Il est vraique la promesse attirait légitimement la curio-sité des médias et de la communauté scienti-fique. Nous étions là et n’avons pas été déçus.Aujourd’hui, l’équipement nécessaire est unsytème simple d’électrodes au niveau du cuirchevelu, permettant de capter l’activité élec-trique cérébrale, analogue au dispositif del’électro-encéphalogramme. Plusieurs expériences ont été présentées,dans des domaines de réalité virtuelle et desanté.

REALITE VIRTUELLEL’expérience a permis de montrer que l’appli-cation détectait que le sujet avait l’intention dedéplacer sa main gauche ou sa main droite. L’application passe par une phase d’apprentis-sage, correspondant à celui nécessaire pourun logiciel de reconnaissance de la parole.Après une série de traitements des signaux, ilest possible de savoir quelle était la main utili-sée pour le mouvement imaginé par exemple,l’onde cérébrale provoquée par l’imageriementale du sujet est détectée et commandeun déplacement sur l’écran. On reconstitue en3D, et en temps réel, l’activité cérébrale. Ladémonstration était dans le domaine du jeuvidéo. Les handicapés moteur pourront ainsiplus facilement accéder à l’univers virtuel.L’application peut également être un outil d’entraînement cérébral, souligne AnatoleLécuyer, responsable du projet à l’Inria

NEURO-FEEDBACKL’apport de l’Inserm a été notamment le repé-rage des " marqueurs électro-encéphalogra-phiques " : j’écoute avec l’oreille gauche oul’oreille droite. " Nous explorons actuellement

la possibilité de communiquer avec une per-sonne dans le coma, afin d’essayer de la sortirde son état végétatif ", explique Jean-PhilippeLachaux, un des responsables du projet, à l’Inserm. Le concept de neuro-feedback ouvrepar ailleurs des champs thérapeutiques infinis.La personne essaie de modifier le " signal " :les applications concernent la douleur, ou desgênes de type accouphènes. Ou encore destroubles de l’attention chez l’enfant hyperactifou encore la rééducation post-traumatique.

Le P300 speller : L’écriture par la pensée Grâce au logiciel OpenViBE, l’Inserm a dévelop-pé une interface simple et conviviale qui offrela possibilité d'écrire des phrases en sélection-nant, simplement par la pensée, des lettresprésentées sur un écran. L’expérience a mon-tré que, au cours de l’affichage successifde lignes et colonnes de lettres, surlignées, lapersonne focalise son attention sur une lettreà épeler. Lorsque la ligne ou la colonnecontient la lettre choisie, une réponse céré-brale particulière est générée. Cette réponse,connue des chercheurs, est déclenchéequand l’individu a détecté un stimulus attendu

qui apparaît de manière imprévisible. Elle sur-vient environ 300 ms après la stimulation,d’où son nom de P300. Il est de cette manière,possible de savoir sur quelle lettre la personnefocalisait son attention.

événements \\ interface


Neuf années-homme pour développer OpenVibe. L’équipe deRennes de l’INRIA était fière de présenter à Paris, le 13 mai,OpenVibe, le premier logiciel français permettant d’ " agir par lapensée ". Il est gratuit et open-source, vous trouverez le lien surprogrammez.com.

OpenVibe : 9 années/hommeYann Renard est l’ingénieur responsabledu développement d’OpenVibe, à L’Inria. Ila œuvré avec deux autres développeurspendant 3 ans. Il nous a livré quelquesdétai ls sur cette appl icat ion de 9 années/homme : " Le code est en C++.L’application comporte plus de 150 000lignes de code. Elle est très modulaire, àbase de composants connectés par uneinterface graphique drag&drop. L’architec-ture est planifiée pour le multi-coeur, etprête pour les clusters, permettantd’agencer les modules existants et ceuxqui seront ajoutés " Anatole Lécuyer, direc-teur du projet, l’a initié en 2005, dans lecadre d’une unité de l’Inria dédiée auxmondes virtuels, basée à Rennes. L’ouver-ture de la forge de OpenVibe représentaitpour lui et pour l’équipe le commencementdans la vie réelle d’un projet qui ira loin.

CONTRIBUEZ au Projet OpenVibe !Sur le site officiel, les développeurs dis-posent de plusieurs outils. Un Designerpermet de modéliser et de tester sonInterface Cerveau-Ordinateur. Acquisi-tion Server permet de communiquerentre le matériel d’acquisition (= casque)et l’application OpenVibe. Disponible en open source, OpenVibeévoluera et se complètera grâce à vous,

les développeurs. Programmez ! suivrarégulièrement les évolutions ! Le code source et les binaires (137 Mo) sont disponiblessur Linux et Windows. Le projet est sous licence LGPL 2. A vous de jouer. Site :http://openvibe.inria.fr. (Rendez-vous également sur www.programmez.com !)

Cré

dit

: P

rogr

amm

ez/J

. K

amin

sky

PILOTER L’ORDINATEUR PAR LA PENSEE !OpenVibe, la première ICO (Interface Cerveau-Ordinateur) est disponible, en Open Source !

12-13 20/05/2009 12:06

actu \\ en bref

■ Windows 7 est désormais disponible en version RC. La versionfinale devrait être disponible vers octobre ou novembre si tout vabien. Pour débuter dès maintenant les tests de compatibilité desapplications, Microsoft France a ouvert un site spécifique : Windows 7Applications et Compatibilité. Cette excellente initiative concerneaussi bien les développeurs, éditeurs que les utilisateurs. Site :http://www.microsoft.com/france/windows/windows7/compatibilite/default.aspx

■ Kapitec, distributeur exclusif de Web Performance Load Tester,annonce l’arrivée de la version 3.6. Cette version intègre de nom-breuses nouveautés : nouvelles analyses utilisateurs, nouveaumodule des cas de tests, reporting amélioré, nouvelles méthodespour les tests de charge.

■ Rasdaman 8 est désormais disponible. Il s’agit d’une extensiondestinée à PostgreSQL dédié au stockage maillé dans une base.Cela signifie qu’il traite des données de plusieurs dimensions entrès gros volumes comme peut le faire PostGIS pour les donnéesgéospatiales. Des API sont disponibles en C++ et Java.

■ Qt souhaite mieux fédérer lesdéveloppements de la commu-nauté autour de Qt et de sesprojets. Pour ce faire, l’éditeurvient d’ouvrir une plate-formecollaborative pour la communau-té : Gitorious. Une excellente ini-tiative ! site : http://gitorious.org/

■ ABBYY, fournisseur de technologies de reconnaissance dedocuments, d’extraction de données et de linguistique, annonce ladisponibilité de FlexiCapture Engine 8.0, son nouveau SDK pourl’intégration des technologies d’extraction de données et de docu-ments aux applications Windows.

■ Quest Software organise une Journée de la Performance IT, le10 juin au NCI Com-Square Paris-La Défense. Dédiée à l’améliora-tion de la performance des systèmes d’information, la journéecomprendra 3 salles et plus de 15 ateliers sur les thèmes favorisde Quest : gestion des environnements Windows, gestion desapplications, gestion de bases de données et gestion des environ-nements virtuels. Site : http://www.performanceit2009.com/

■ Après Sun, Oracle a annoncé le rachat de Virtual Iron Softwarespécialisé dans l’administration des serveurs virtualisés et l’alloca-tion dynamique des ressources. L’administration des environne-ments virtualisés devient l’élément stratégique de toute stratégiede virtualisation et la plus value des éditeurs alors que lescouches de virtualisation (hyperviseur, player…) deviennent descommodités pour l’utilisateur.

Alter Way, intégrateur Open Source de référence, couvre les besoins de l’ensemble du système

d’information avec ses quatre offres

CONSULTINGConseil en architecture

Choix d’outils IndustrialisationBest practices

Audits

SOLUTIONSSOLUTIONS APPLICATIVES

Applications Web, ECM, E-commerce, Intégration de données,Business intelligence, Développements spécifiques

SOLUTIONS D’INFRASTRUCTURE Supervision, Serveur de messagerie, Serveurs d’infrastructure,

Bases de données, Management IP, Filtrage et partage desconnexions Internet, Sécurité

FORMATIONUn catalogue de plus de 60 formations

Des programmes de certifications : PHP, MySQL, PostgreSQL, Java1200 personnes formées par an

Près d’une centaine d’intervenants sur tous les sujets dontquinze internes certifiés

Des partenariats forts : SUN, MySql, Talend, Ingres…

HOSTINGHébergement à haute disponibilité 24/7

Exploitation et infogéranceSolutions SaaS

Solutions de stockageSolutions d’e-commerce

Des solutions techniques performantes et stables

OPEN SOURCE

TECHNOLOGIESPHP / Python / Java / ECM

JasperSoft / Talend / Bases de données Open-Xchange…

Le libre, autrement

www.alterway.fr

12-13 20/05/2009 12:06


Aujourd’hui, la programmation est de moins en moins mono plate-forme (= monapplication fonctionne sur un seul système) mais de plus en plusmulti-plate-forme. Le site web en est le meilleur exemple.L’arrivée du cloud computing et des services en ligne (leSaaS) transforme radicalement la manière de concevoir etd’utiliser les logiciels. Demain, le développeur se souciera demoins en moins du système cible (sur quoi tourne monapplication) pour se concentrer sur l’interface, les fonctions.

Dans ce dossier nous allons aborder différents thèmes carsous le vague terme multi-plate-forme, se cachent denombreuses réalités. La cross compilation, ou compilationcroisée, est un de ces aspects, peut être le plus intéressant àconnaître et surtout à maîtriser. Il facilite grandement lacréation d’applications exécutables pour différents systèmes.Cette compilation multiple peut prendre différentes formes,comme nous le verrons. Elle peut être directement intégrée àl’environnement de développement ou alors passer par desoutils tiers. Des environnements de développement sont conçuspour être multi-plates-formes et réaliser des logiciels pouvantfonctionner sur plusieurs systèmes.Java est le langage le plusconnu même si deslimitations, des problèmessurgissent souvent. Deslangages comme C++, leslangages dynamiques et certainsbasic le peuvent aussi.

Avec l’interopérabilité omniprésente, lefait d’avoir un langage portable partout oupresque est devenu un réel enjeu. SiWindows demeure le système le plus utilisé,le paysage change rapidement et MacOS X etLinux prennent tous les ans des parts demarché.

Le multi-plate-forme apparaît crucial quand on parlede web, de web 2.0, de RIA. Et il est aussi source decauchemars pour le développeur web. Nous verrons que cetteproblématique reste complexe dans une approche multi navigateur.

Dans les prochains numéros, nous continuerons à aborder cetteépineuse question que l’on oublie trop souvent !

■ François Tonic

gros plan \\ multi-plate-forme


Le casse-tête du multi-plate-forme

©is

tock

.com

/77D

ZIG

N

14-25 complil croisée 20/05/2009 10:54



C omme dans tout développement,le multi-plate-forme ne s’improvi-se pas ! Il faut déjà connaître le

contexte de l’application à développer, lestechnologies, langages envisagés, le typed’utilisateur, et le ou les systèmes ciblespossibles.

Les langages et le problème du RIAQui dit multi-plate-forme, dit aussi langagede programmation. Dans un contexteweb, privilégiez les standards reconnus :HTML, xHTML, CSS, REST, Atom, Javas-cript, Ajax. Cependant attention, surHTML, évitez de trop vous focaliser surHTML 5 tant que les navigateurs ne lesupporteront pas entièrement et de façonoptimale. Sur Ajax, le choix du frameworkne sera pas non plus anodin. Dans tousles cas, une grosse phase de test seranécessaire (voir plus loin dans ce dossier).Par contre on peut rencontrer des soucissur un développement RIA (Rich InternetApplication). Le plus universel resteAdobe Flash / Flex fonctionnant aussi surWindows, MacOS X et Linux. Sa déclinai-son desktop, AIR, fonctionne aussi sur lestrois systèmes. Donc peu de souci à sefaire. Par contre avec Silverlight, si Win-dows et MacOS X sont bien supportés,Linux reste en retard malgré l’arrivée duprojet Moonlight. Et sur l’utilisation deJavaFX, le projet demeure trop immatureet peu reconnu. XUL sera aussi unebonne solution mais limitée aux universMozilla. Sur le RIA, il n’existe pas deréponse universelle.C++ (ANSI) est le langage le plus portablemême s’il demande de la rigueur et unebonne compétence. Cependant, aujour-d’hui, C++ est LE langage référence dumulti-plate-forme (voir article sur Qmake).C# commence lui aussi à se faire une

belle place, notamment grâce à la pileopen source Mono qui permet de dévelop-per un peu partout avec le même langage(voir article Delphi Prism). Nous n’oublie-rons pas Java qui fonctionne partout. Si laportabilité s’améliore constamment,attention tout de même aux disparités desJVM et aux différences de comportementselon les systèmes. Notamment sur toutce qui est interface native et appels natifs. Reste l’incontournable basic. Et oui ildemeure bien vivant ! Plusieurs environne-ments permettent de faire de la compila-tion multi cible à partir du même codebasic. Le plus connu dans ce domaine estReal Basic de Real Software. Ensuite vousavez un grand nombre de langages, delangages dynamiques et de scripts faisantparfaitement du multi-plate-forme, souventdans le domaine web et non desktop :PHP, Python, Ruby, Rails, etc.

Et les outils ?L’outillage pour le multi-plate-forme estvaste. Encore une fois, tout va dépendredu projet envisagé. Aujourd’hui de nom-breux outils, notamment open source,sont disponibles sur plusieurs plates-formes. Si on prend les classiques Eclipseet Netbeans par exemple mais aussi dansles outils Qt, Adobe, etc. En dehors del’éditeur, de l’IDE, il ne faut pas omettre lesoutils de tests, l’intégration continue, etc.Et les choix sont nombreux : Maven, Ant,JUnit (ou autres), etc. On peut aussi opterpour des environnements totalement inté-grés et multi-plates-formes, orientés don-nées ou non tels que 4D, Omnis.

Tester, tester, tester, tester !Pour réellement vérifier que son codefonctionne de la manière attendue sur lesenvironnements cibles, i l faut doncconstamment réaliser des build et tester

sur toutes les cibles. Il ne faut surtout pasattendre la fin du développement pour lefaire. Car en cas de bugs importants, lacorrection sera plus longue et plus diffici-le, surtout si la structure de l’applicationn’est pas réalisée en couches strictementdistinctes, au moins séparer l’interface ducode fonctionnel. Et plus un code serastructuré, modulaire, plus il sera aisé decorriger les imperfections de portage. Les environnements de virtualisationapportent aujourd’hui une souplesseinégalée pour le développeur. Il peut facili-ter créer des machines virtuelles spéci-fiques à chaque scénario d’utilisation.

■ François Tonic

Multi-plate-forme : où, quand, comment, pourquoi ?Le multi-plate-forme n’a jamais été un modèle très prisé des développeurs. Par contrele développeur web se trouve tous les jours, en principe, confronté à la variété desnavigateurs et des technologies à supporter pour être le plus universel possible. Maisrien n’est jamais simple en informatique et vous verrez dans ce dossier que le multi-plate-forme demande rigueur et structure.

Bonnes pratiques dès le départSogeti met en avant 3 clés :- ne pas se jeter directement sur lecode, regarder les besoins, l’envi-ronnement sur lequel tournera l’ap-plication.

- Avoir un code lisible, modulaire,facile à maintenir

- Quand la compilation est terminée,le travail n’est pas terminé !

- A cela se rajoute bien entendu laséparation des couches (interface,code fonctionnel).

Pour les aider, Sogeti utilise unmodèle de type MDA pour modéliserles couches et réaliser le découpagedes applications. Les développeursutilisent des langages et spécifica-tions matures du web.

14-25 complil croisée 20/05/2009 10:54

P etit problème cependant : offrez àun utilisateur Mac une applicationau look GTK ou WinForms, et voyez

ses réactions ! L’effort d’intégration gra-phique à l’OS ne doit surtout pas être négligé.C’est à ce stade que Delphi PRISM entre enjeu. Grâce à Mono et Cocoa#, vous pouvezutiliser PRISM pour développer des applica-tions Delphi.NET se comportant en toutpoint comme une application Cocoa (le fra-mework fourni par MacOS). Cet article vousmettra sur les rails de tels développements,en vous présentant les bases de la coopéra-tion entre Delphi PRISM et MacOS X.

PrérequisMacOS X 10.4 (ou supérieur)• Les Apple Developer Tools : http://develo-

per.apple.com permettent de disposer d’Inter-face Builder, l’éditeur d’interface graphiquede MacOS X.• Mono 1.2.6 ou plus récent :http://www.mono-project.com

Windows XP (minimum)• Delphi PRISM• Mono 1.2.6 ou plus récentPour des questions pratiques, il est préfé-rable que MacOS et Windows puissentcommuniquer en réseau, afin de partagerun répertoire de travail. Bien sûr, vous pou-vez utiliser une solution de virtualisationcomme VMWare ou Parallels pour exécuterWindows sur votre Mac, par exemple.

Vous rencontrerez peut-être des pro-blèmes de permissions entre MacOS

et Windows, suivant la configuration devotre partage de fichiers. Assurez-vous quevotre dossier de travail est accessible enécriture à votre compte Mac et au compteutilisé par Windows par le réseau (ou inver-sement). Si l’application MacOS générée(f ichier .app, dans " bin/Debug " ou " bin/Release ") se termine immédiatementaprès son lancement, ajoutez-lui les droitsd’écriture et d’exécution : sudo chmod –Ra+wx monapplication.app. Vous devrez alorsrefaire cette opération à chaque généra-

tion. Si lors de la génération vous obtenezune erreur de la tâche MacPack disant que" le répertoire n’est pas vide ", supprimez àla main le contenu du répertoire " bin " devotre solution et recommencez.

Premier projet PRISMVous êtes maintenant prêt à créer votre pre-mière application MacOS X avec Delphi PRISM.Créez un nouveau projet Mono (Fichier > Nou-veau > Projet) de type " Application Cocoa (Leo-pard) " ou " Application Cocoa (Tiger) ", suivantvotre version de MacOS. Créez le répertoire dela solution dans votre répertoire de travail par-tagé entre Windows et MacOS. Plusieursfichiers sont générés. Seuls deux d’entre euxretiendront ici notre intérêt :• Interface.nib : il apparaît comme un réper-

toire contenant, entre autres, le fichier " designable.nib " dans l’explorateur de solu-tion de Visual Studio. Il apparaîtra commeun fichier sous MacOS. Il s’agit du fichierque vous éditerez avec Interface Builderpour créer votre interface utilisateur.

• ApplicationController.pas : il s’agit ducontrôleur de votre application, que vousimplémenterez avec Delphi PRISM et qui

dialoguera avec l’interface graphique parle biais d’actions —définies comme desméthodes et correspondant aux événe-ments utilisateur— et d’outlets, pointsd’accès aux composants de votre interfa-ce, définis comme des champs de votreclasse. Nous y reviendrons.

Design de l’interface graphiqueLaissez de côté Delphi PRISM et, sousMacOS, rendez vous dans le répertoire devotre projet nouvellement créé. Ouvrez lefichier Interface.nib avec Interface Builder.Si vous ne connaissez pas encore le logiciel,vous serez peut-être dérouté au premierabord par ses nombreuses fenêtres. Voiciune rapide présentation : [Fig.1]Dans l’idée, cette fenêtre montre ce quecontient votre fichier NIB. Pour faire unparallèle avec Delphi, les objets qui appa-raissent ici pourraient être comparés auxcomposants non visibles que vous placeriezdans un DataModule. Cette comparaisonn’est qu’approximative, puisqu’apparaît éga-lement un objet pour chaque fenêtre devotre NIB. Le dernier objet, nommé " Appli-



Développer multi-plate-formeen .Net avec Delphi PRISMIl n’y a pas si longtemps, lorsqu’il était question de développement cross-platform, onpensait surtout au couple Windows/Linux. Aujourd’hui MacOS X —qui est un systèmeUNIX— devient de plus en plus une cible de prédilection.

Fig.1

Fig.2

Fig.3 Fig.4

Figure 1 - Contenu du fichier NIB

Figure 3 - Inspecteur d'objets Figure 4 - Bibliothèque decontrôlesFigure 2 - Fenêtre par défaut

Pub14-25 complil croisée 20/05/2009 10:54

Montez en gamme à tarif réduit !

Vous possédez un outil de développement de la gamme Microsoft Visual Studio ?

jusqu’à

30%de remise

4 promotions exceptionnellesSi vous possédez Visual Studio Professionnel, Visual Studio avec MSDN ou encore Visual Studio TeamSystem, vous avez la possibilité d’accéder au produit supérieur de la gamme à un prix préférentiel.

Visual Studio Visual Studio Visual Studio Visual Studio Professional avec MSDN Team System Team Suite

Vous profitez ainsi à prix réduit (selon votre produit) :• Des serveurs Microsoft

• Des systèmes d’exploitation Microsoft

• De logiciels de productivité : Microsoft Office, Project, Visio…

• D’outils de test : Montée en charge, fonctionnels, manuel…

• Logiciels de modélisation : diagrammes d’applications, de développement…

• Jusqu’à 4 incidents de support technique,

• Ressources techniques

• Toutes les mises à jour pendant votre abonnement : Visual Studio 10 et Windows 7 dès leur disponibilité

Exemple : Visual Studio 2008 avec MSDN Premium : 1137 €HT / an / par dev**au lieu de 1395€HT*Valable jusqu’au 26 juin 2009 - Tous les détails des promotions sur notre site internet.

**(abonnement 2 ans obligatoire - licence Open Business)

1er revendeur en France en outils de développement Microsoft.

Contactez nos spécialistes MSDN au 04 97 21 58 [email protected] – www.sosdevelopers.com/msdn3.htm

Pub VStudio:Mise en page 1 20/05/09 09:47 Page114-25 complil croisée 20/05/2009 10:54




cationController ", est un pont vers le fichier" ApplicationController.pas ". Nous y défini-rons les actions et outlets nécessaires aufonctionnement de notre interface. [Fig.2]Cette fenêtre est tout simplement celle surlaquelle vous travaillerez, à l’instar des outilsprésents dans Delphi ou Visual Studio. Pardéfaut, elle comporte une simple barre d’ou-tils contenant quelques boutons. Nous lamodifierons sous peu en y déposant descontrôles depuis la bibliothèque.Les deux fenêtres suivantes sont, respecti-vement, la bibliothèque de contrôles (visuelsou non) et de médias disponibles pour votreinterface, et ce qui se rapproche de l’inspec-teur d’objets. Cet inspecteur propose plu-s ieurs vues permettant d ’éditer lespropriétés de l’objet sélectionné dans l’unedes deux fenêtres précédentes. [Fig.3]Pour notre exemple, nous allons modifier lafenêtre pour obtenir ceci : [Fig.5]• Cliquez sur la barre d’outils incluse pardéfaut dans la fenêtre et supprimez-la.• Redimensionnez la fenêtre à la taille voulue• Dans la bibliothèque, trouvez le label. Ils’agit du premier composant dans Cocoa >Views & Cells > Inputs & Values. Déposez unlabel dans votre fenêtre grâce à undrag&drop et double-cliquez dessus pour enchanger l’intitulé. Validez par " Entrée ". Vousremarquerez que des guides vous aident àplacer correctement le composant dans sonconteneur lorsque vous le déplacez.• Ajoutez un TextField en dessous du label.• Enfin, ajoutez un bouton. Tous les types deboutons se trouvent dans Views & Cells >Buttons. Les différents types de boutonssont parfois destinés à des utilisations diffé-

rentes, parfois seulement à des design dif-férents. Ici il s’agit d’un simple Push Button.Le but de l’application sera très basique :afficher une boîte de dialogue avec un mes-sage incluant le nom entré dans le TextFieldlorsque l’utilisateur clique sur le bouton.Le comportement de votre application estimplémenté dans votre objet Application-Controller, défini dans le fichier " Applica-tionController.pas ". Afin d’interagir avecvotre interface, la classe est en réalitédéclarée de manière partielle dans unfichier " designable.pas ", lui-même inclusdans le fichier " designable.nib " contenudans " interface.nib ". Ainsi, toute modifica-tion apportée dans Interface Builder à l’objet" ApplicationController " sera répercutéedans cette classe partielle, et vous pourrezcoder en toute tranquillité dans " Applica-tionController.pas " en profitant de ce pontvers votre interface.Continuons justement notre chemin versl’implémentation. Pour que la classe Appli-cationController puisse agir comme nous lesouhaitons, il faut lui indiquer deux choses :• Un outlet vers le TextField, grâce auquelnous pourrons récupérer le texte entré parl’utilisateur.• Une action, nommant la méthode à exécu-ter lorsque le bouton est cliqué.Sélectionnez l’objet " ApplicationController "et, dans l’inspecteur, affichez l’onglet " iden-tity " (l’avant-dernier onglet). Vous pouvezvoir une section " Class Actions " et une sec-tion " Class Outlets ". Dans la première,ajoutez une action onClick: dont vous laisse-rez le type à id.Dans la seconde, ajoutez un outlet que vousnommerez edName et qui doit avoir pourtype NSTextField. Pour connaître le type d’unobjet, sélectionnez-le et vérifiez le champ " Class " dans l’onglet " identity " de l’inspec-teur. Reste maintenant à indiquer à la clas-se à qui (ou quoi) correspondent ceséléments dans l’interface. Pour cela, il fautcréer des connexions entre les objets grâceà un drag&drop effectué avec un clic droit.Cliquez droit sur l’objet " ApplicationControl-ler " et en maintenant le bouton pressé, glis-sez le l ien bleu qui s’aff iche jusqu’auTextField. Lâchez alors le bouton : s’afficheune liste des outlets disponibles et de typecompatible avec l’objet visé. Ici, seul edNa-me devrait s’afficher ; cliquez dessus.Effectuez la même opération en partant dubouton vers l’objet " ApplicationController ".Cette fois, une liste des actions disponibless’affiche. Choisissez onClick: que vous venez

de créer. Le selector du bouton, qui est l’ac-tion exécutée lorsqu’il est cliqué, est mainte-nant dirigé vers la méthode onClick: quevous allez implémenter dans votre Applica-tionController. [Fig.6]Vous pouvez vérifier toutes ces connexionsen examinant l’onglet " connections " del’inspecteur (cinquième onglet) et en sélec-tionnant les différents objets affectés.

Implémentation de l’applicationTout est maintenant prêt pour implémenterl’application. Sauvegardez le fichier NIB etrevenez à Delphi PRISM sous Windows. Afinde s’assurer que tout est bien synchronisé,effectuez un clic droit sur le fichier " desi-gnable.nib " (enfant de " Interface.nib ") dansl’explorateur de solution, et cliquez sur " Exécuter un outil personnalisé ". Cela regé-nère le fichier " designable.pas " avec lesdernières modifications apportées au fichierNIB. Dans " ApplicationController.pas " ajou-tez la déclaration de la méthode onClick enpublic de la classe ApplicationController :

public

method onClick(sender: Object); partial;

end;

Puis implémentez la méthode :

method ApplicationController.onClick

(sender: Object);

begin

Alert.AlertWithMessage('Bonjour !', 'OK',

nil, nil, 'Bonjour à vous, ' + edName.

Value + ' !').RunModal;

end;

Sauvegardez et générez l’application. Si toutse passe correctement, vous devriez avoirdans le dossier " b in/Debug " ou " bin/Release " un fichier " CocoaApplica-tion1.app " (suivant le nom de votre projetbien sûr). Lancez l’application depuis MacOS :vous avez alors sous les yeux une véritableapplication MacOS X, s’intégrant parfaite-ment à l’OS. Vous avez maintenant entre lesmains un outil qui vous permettra de ciblerun OS en vogue tel que MacOS X de manièretout à fait sérieuse, tout en conservant lapossibilité d’un portage vers d’autres plates-formes grâce au framework .NET.

■ Olivier LanceEtudiant ingénieur SIwww.codegearfrance.com

Fig.5

Fig.6

Figure 5 - Fenêtre finale

Figure 6 - Création d'un lien entre deux composants

14-25 complil croisée 20/05/2009 10:54



C ompiler depuis un système A pour produire un exécutable,ou une librairie, pour un système B est souvent bien pra-tique. Supposons que l'on développe une application en C++

avec Qt ou wxWidgets en guise de toolkit graphique. Supposons quel'on travaille seulement avec les plates-formes Linux et Windows,mais le raisonnement est bien sûr valable avec un autre choix deplates-formes. C++ permet d'écrire du code source portable. Trèsbien. Qt ou wxWidgets, ou même d'autres toolkits permettent d'écri-re du code portable. Toujours très bien. Mais compiler un projet surchacune des plates-formes risque fort d'obliger à travailler avec desoutils de développement différents, éventuellement chacun avecleurs spécificités et gérer de multiples projets. La compilation croi-sée est une réponse à ce problème. On écrit le code et on le compilesur une plate-forme seulement, en produisant des exécutables pourchaque plate-forme cible. Voyons comment pratiquer cela de Linuxvers Windows et réciproquement, et déjouer quelques pièges.

1DE LINUX VERS WINDOWS, LES OUTILS

Un compilateur croisé "qui va bien" est par exemple mingw32, géné-ralement connu comme compilateur libre sous Windows, mais ilexiste aussi sous Linux. Vous pouvez l'obtenir à http://www.libsdl.org/ lesite de la librairie SDL, une librairie pour écrire des jeux portablesentre Linux et Windows. La présence d'un compilateur croisée n'yest dont pas surprenante. En théorie on télécharge les sources ducompilateur, puis on construit celui-ci "à sa main" à partir de script.Notre but d'aujourd'hui étant simplement la compilation croisée,nous téléchargerons plutôt des binaires tout prêts sur le même site,à http://www.libsdl.org/extras/win32/cross/. Téléchargez l'archive dont lenom contient linux-x86. Désarchivez dans le répertoire de votrechoix. Par exemple sur ma machine: /home/fred/cross-tools.Notre compilateur croisé est un environnement complet dont leséléments sont répartis dans une arborescence. Un sous-répertoirebin pour les exécutables. Les noms de ceux-ci sont tous préfixéspour éviter des conflits avec les outils classiques. Ainsi g++ devienti386-mingw32-g++. Un sous-répertoire lib, un sous-répertoire inclu-de bien évidemment et aussi les sous-répertoires info et man quicontiennent les fichiers de documentations des mêmes noms. Pourune utilisation confortable, le mieux est d'intégrer le tout à votreenvironnement, en ajoutant quelques lignes à votre fichier .bashrc

export PATH=/home/fred/cross-tools/bin:$PATH

export MANPATH=/home/fred/cross-tools/man:$MANPATH

export INFOPATH=/home/fred/cross-tools/man:$INFOPATH

2CONSTRUIRE UN EXÉCUTABLEVoici un code d'une originalité folle :// fichier hello.cpp

#include <iostream>

La compilation croisée entre Linux et WindowsLa compilation croisée est une opération de compilation qui, effectuée sur un systèmeproduit un exécutable ou une librairie pour un autre système. Voyons comment cela peutse passer entre Linux et Windows.

using namespace std;

int main(){

cout << "Programmez!" << endl;

return 0;

}

Sa compilation est non moins simple

i386-mingw32-g++ -o hello.exe hello.cpp

et produit un exécutable Windows. Nous ne devons pas omettre dementionner l'extension .exe au fichier produit. Celui-ci est plutôt volu-mineux. La raison est que l'édition de liens avec le runtime a étéeffectuée statiquement par défaut, le but étant de produire un exé-cutable totalement autonome sur la plate-forme cible.

3CONSTRUIRE ET UTILISER UNE LIBRAIRIE

Une grosse application est rarement monolithique, mais utilise deslibrairies. Librairies dont les formats sont différents selon les plates-formes. En outre nous voulons :1) écrire un code qui compile aussi bien avec le compilateur de laplate-forme hôte qu'avec le compilateur croisé.2) être capable de faire une édition de liens statique avec la librairiepour produire une application autonome sur la plate-forme cible.Le premier point se règle simplement en traitant les particularitésdes librairies partagées ou dll sous Windows. Celles-ci doivent com-porter un point d'entrée bien défini et toutes les autres fonctions doi-vent être exportées explicitement. On obtient cela avec une directivede compilation conditionnelle :

// fichier madll.cpp

#ifdef __WIN32__

#include <windows.h>

#define EXPORT extern "C" __declspec (dllexport)

// Point d'entrée dll Windows.

int WINAPI DllMain(HINSTANCE hInstance, DWORD fdwReason, PVOID

pvReserved) {

return TRUE;

}

#else

#define EXPORT

#define CALLBACK

#endif

// Une fonction de notre librairie

EXPORT int CALLBACK fois2(int valeur) {

return valeur*2;

}

Pour Linux on compile simplement par

g++ -c madll.cpp

14-25 complil croisée 20/05/2009 10:54

0800 667 307



Et pour Windows

i386-mingw32-g++ -D__WIN32__ -c madll.cpp

4EDITION DE LIENS STATIQUEAbordons maintenant le deuxième point. Soit un code qui utilisenotre librairie :

#include <iostream>


extern "C" int CALLBACK fois2(int valeur);


int main() {

cout << fois2(3) << endl;

return 0;

}

Nous voulons à partir de ce code produire une application autono-me. Pour cela nous devons travailler un peu notre librairie qui pourl'instant n'est qu'un fichier objet à l'issue de la compilation faite plushaut. Commençons par en faire une archive :

ar -rs libmadll.a madll.o

A ce point, si nous tentions une édition de liens pour générer lalibrairie nous aurions un message d'erreur :

.//libmadll.a: could not read symbols: Archive has no index;

run ranlib to add one

Nous devons donc utiliser ranlib comme nous dit le message, maisattention ici, piège classique ce n'est pas le ranlib du système hôteque nous devons utiliser mais celui du compilateur croisé. Nous fai-sons donc :

i386-mingw32-ranlib libmadll.a

et maintenant nous pouvons faire l'édition de liens de la librairie pro-prement dite :

i386-mingw32-ld -dll -kill-at -o madll.dll madll.o

La directive -dll parle d'elle-même. Quant à -kill-at nous y reviendronsplus loin. Il est .maintenant possible de construire notre applicationautonome en compilant use-madll.cpp :

i386-mingw32-g++ -L./ -o use-madll.exe use-madll.cpp -lmingw32 -lmadll

Il y a ci-dessus une petite subtilité. Pourquoi ajoutons-nous la librairiemingw32 qui est liée automatiquement de toute façon ? Ici nousn'avons pas du tout besoin de le faire en fait. Mais c'est une bonnehabitude à prendre que de forcer la lecture de cette librairie en pre-mier. Sans trop entrer dans les détails dans ce court article, disonsqu'il est possible, dans de grosses applications, que vous rencon-triez un message d'erreur agaçant disant que pour une applicationGUI, la fonction WinMain n'est pas définie, alors qu'elle l'est pour-tant bel et bien dans votre code. Casse-tête courant qui en a énervéplus d'un :) Une particularité de l'éditeur de liens ld est de chercherun symbole requis par une librairie dans les librairies qui la suiventdans l'ordre d'inclusion. Or il se trouve que mingw32 a besoin de

WinMain, et que par défaut mingw32 est incluse automatiquementen dernier et ne peut profiter de votre définition de WinMain. Voilàpourquoi nous recommandons, avec la ligne de compilation ci-des-sus, de toujours forcer le bon ordre d'inclusion des librairies.

5 EDITION DE LIENS DYNAMIQUESous Windows une librairie peut être chargée à la demande et il enva de même pour les adresses des fonctions exportées. Voici uncode, écrit et compilé sous Windows qui fait cela :

#include <iostream>



const LPWSTR la_librairie = L"madll.dll";

int main(int argc, char* argv[]) {

HMODULE hmodule = ::LoadLibrary(la_librairie);

if(!hmodule) {

cout << "Impossible charger librairie" << endl;

exit(1);

}

typedef int (CALLBACK *type_pf)(int);

// sans -kill-at

// type_pf pf = (type_pf)::GetProcAddress(hmodule, "fois2@4");

type_pf pf = (type_pf)::GetProcAddress(hmodule, "fois2");

if(!pf) {

cout << "Impossible charger fonction" << endl;

exit(1);

}

cout << pf(3) << endl;

FreeLibrary(hmodule);

return 0;

}

Avec l'API Windows GetProcAddress nous obtenons un pointeur surla fonction à partir du nom de celle-ci. C'est le moment de constaterl'effet pernicieux de l'omission de la directive -kill-at dont nous avonsparlé plus haut. Sans cette directive le nom de notre fonction estdécoré et devient "fois2@4" comme on le voit dans la capture ci-contre, obtenue avec l'utilitaire Dependency Walker de Microsoft.Bien sûr si nous utilisons ce nom (cf. la ligne de code en commentai-re ci-dessus) cela fonctionne, mais ce n'est pas l'esprit de la pro-grammation Windows. La bonne manière est d'employer -kill-at quicomme son nom l'indique supprime le symbole at (@)

6DE WINDOWS VERS LINUXLe plus simple est d ' instal ler un environnement Cygwin(http://www.cygwin.com/) sous Windows, puis d'installer le compilateurcroisé mingw32, encore lu i : ) Vous le trouverez àhttp://sourceforge.net/project/showfiles.php?group_id=135860&package_id=15

3563. Son utilisation ne pose aucune difficulté.

■ Frédéric Mazué[email protected]

14-25 complil croisée 20/05/2009 10:54

Four Platforms. One Package.

Des composants interface utilisateurs supérieurs pour Windows Forms,

WPF, ASP.NET et Silverlight

Pour de plus amples infos : infragistics.com

0800 667 307

grids tree menus navigation charts & more!

Copyright 1996-2009 Infragistics, Inc. All rights reserved. Infragistics, the Infragistics logo and NetAdvantage are registered trademarks of Infragistics, Inc. All other trademarks or registered trademarks are the respective property of their owners.

14-25 complil croisée 20/05/2009 10:54


Q make n'est pas, à proprement parler un système de build.C'est un outil qui permet de simplifier considérablement leprocessus de création des fichiers de build. Typiquement,

Qmake va être utilisé pour générer les fichiers Makefile nécessairesà la construction d'un projet. Actuellement, Qmake permet de géné-rer des Makefiles pour toutes les plates-formes supportées par Qt.Il est aussi capable de générer les fichiers projet pour MicrosoftVisual studio ou Xcode permettant ainsi d'utiliser les outils propres àcertaines plates-formes. L'intérêt de cet outil réside dans son utili-sation pour des projets écrits ou non en Qt. Pour les projets Qt,Qmake génère automatiquement les cibles pour Moc (Meta ObjectCompiler) et Uic (User Interface Compiler).

Les bases...Commençons par les bases, Qmake se repose sur un fichier texte(UTF8 pour bien faire) dit “fichier projet”. Ce fichier est une suite devariables ou de directives qui seront utilisées pour générer les ins-tructions de compilation. La façon la plus simple d'obtenir un sque-lette de fichier projet est de faire appel à Qmake dans le répertoireracine de votre projet :

qmake -project

Prenons un premier exemple simpliste. Créez un répertoireexemple1. Dans celui-ci, créez un répertoire src.

mkdir -p exemple1/src

Créez dans le répertoire src, un fichier main.cpp contenant le " pro-gramme " suivant :

#include <iostream>

int main(){

std::cout << "HelloWorld\n" ;

return 0;

}

Maintenant, dans le répertoire exemple1, lancez " qmake -project ".Celui-ci va créer un fichier appelé exemple1.pro contenant ceci :

TEMPLATE = app

TARGET =

DEPENDPATH += . src

INCLUDEPATH += .

# Input

SOURCES += src/main.cpp

Nous reviendrons sur ce fichier, pour le moment transformez-le enfichier de build en tapant " qmake exemple1.pro ". Cela aura pour



Qmake, le système de build multi-plate-forme qu'il vous faut.Qmake est l'outil de build fourni avec le framework Qt. La puissance de ce dernierrepose, entre autres, sur la grande portabilité du code Qt. Cette portabilité nécessiteabsolument un système de construction totalement multi-plate-forme, c'est le rôle deQmake. Voyons ce qui en fait un outil attrayant.

effet de générer le Makefile, lancez-le en tapant " make ", vous ver-rez alors votre programme se construire.Vous constaterez aussi que votre programme se retrouve lié à Qt(et à toutes ses dépendances)... cela fait beaucoup pour notre " Hel-loworld "... D'autant plus que nous n'utilisons pas Qt ! C'est donc lemoment d'expliquer à Qmake que nous ne voulons pas qu'il lie notreapplication à Qt. Revenons donc sur le fichier projet. Nous consta-tons d'abord qu'il ressemble énormément à un fichier de configura-tion et que chaque ligne présente un schéma identique :

VARIABLE = VALEUR

D'autres types d'instructions existent mais la majeure partie d'unfichier projet est constituée de déclarations de variables. La premiè-re disponible est la variable TEMPLATE, celle-ci contient le templatequi sera utilisé pour générer le projet et peut prendre les valeurs sui-vantes :• app : crée un Makefile pour générer une application ;• lib : crée un Makefile pour générer une librairie ;• subdirs : crée un Makefile par répertoire déclaré dans la variable

SUBDIRS ;• vcapp : spécifique à Windows, crée un fichier de projet Visual stu-

dio pour une application ;• vclib : spécifique à Windows, crée un fichier de projet Visual studio

pour une librairie.Dans notre cas nous utilisons le template app. La variable suivanteest TARGET, qui est, par défaut, vide (la cible générée prend alors lenom du répertoire). Viennent ensuite : • DEPENDPATH : la liste des répertoires qui vont être scrutés pour

résoudre les dépendances ;• INCLUDEPATH : la liste des répertoires contenant les fichiers d'en-têtes ;• SOURCES : la liste des fichiers sources du projet ;• si nous avions des fichiers d'en-têtes, ils seraient listés dans la

variable HEADERS.Lors de la construction précédente du binaire vous avez pu constaterque celui-ci était compilé et lié contre Qt alors que nous ne l'utilisonspas. Ceci n'est pas anodin et un " ldd exemple1 " vous fera constaterl'étendue des dégâts ! Pour remédier à ce problème rien de plussimple : il suffit d'ajouter la définition suivante à notre fichier projet :

CONFIG -= qt

Relancez la compilation. Le Makefile est automatiquement regénéré(Qmake prend soin de mettre en place la règle adéquate). Constatezaussi que, cette fois, aucune librairie superflue n'est incluse, et lddvous dit merci ! Qu'avons-nous fait avec la variable CONFIG ? Nousavons simplement demandé à Qmake de ne pas générer les règlesqui lient Qt à notre application.

14-25 complil croisée 20/05/2009 10:54



...pour s'amuser !Attelons-nous maintenant à construire un projet multi-plate-formeavec du code dit " plateform specific ". Nous allons, pour cela,construire une librairie partagée d'utilitaires systèmes. Cette librai-rie contient un ensemble de fonctions telles que forceRemoveDirec-tory(const QString &), par exemple, qui font appel aux utilitairespropres à chaque système (del ou rm dans le cas présent).Notre librairie va compiler contre QtCore car nous souhaitons béné-ficier des types de Qt (entre autres), mais nous ne souhaitons pascompiler contre la partie GUI, nous verrons comment faire. Les

librairies partagées sont évide-ment spécifiques à une plate-forme : share object (.so) sousGNU/Linux, DLLs sous Windowset dynlib sous Mac OS. Il va falloirrégler ce problème qui pourraitêtre épineux si nous ne dispo-

sions pas de Qmake. Dans un premier temps voici l'arborescence de notre projet figureci-contre. Tout d'abord, générez le squelette de base du fichier pro-jet en tapant :

qmake -project -t lib

Dans un premier temps, voyons comment gérer la compilation dessources spécifiques à chaque OS. Qmake met à notre disposition unsystème de " scopes " très pratique. Les scopes sont des condi-tions qui permettent de prendre en compte les spécificités dechaque situation. Une des utilisations vraiment intéressante desscopes est la configuration du build en fonction de l'OS. Ainsi il suffit,pour ne compiler que le fichier source relatif à un OS, d'ajouter lesdéfinitions suivantes au fichier projet :

win32 {

SOURCES += src/sysutils_windows.cpp

}

macx {

SOURCES += src/sysutils_macos.cpp

}

unix{

SOURCES += src/sysutils_linux.cpp

}

Ce squelette nous permet aussi d'ajouter, pour chaque systèmed'exploitation, l'option adaptée aux librairies partagées. Il suffira derajouter : CONFIG += shared pour les Linux/Unices, CONFIG += dllpour Windows et CONFIG += dylib lib_bundle pour Mac OS X. Dans ledernier cas, l'option supplémentaire permet de créer le bundle parti-culier aux librairies de Mac OS X.Pour utiliser les types de Qt, nous devons utiliser QtCore. Enrevanche, comme nous désirons nous passer de QtGui, il faut le pré-ciser à Qmake (ces 2 modules étant inclus par défaut) :

QT -= gui

La variable QT permet de configurer les modules de Qt utilisés parnotre projet. La déclaration par défaut (lorsque rien n'est spécifié) est :

QT = core gui

Donc quand nous écrivons :

QT -= gui

C'est équivalent à :

QT = core

Les opérateurs += et -= se comportant comme nous l'attendons enconcaténant et en supprimant une valeur de la liste. Le signe =représentant, bien sûr, l'affectation.Les scopes de Qmake deviennent indispensables une fois couplésaux possibilités des objets qui peuvent être déclarés dans le fichierprojet. Un objet est une variable qui contient plusieurs membres.Certaines variables prédéfinies du fichier projet font une bonne utili-sation de ces objets si les membres requis sont remplis. Prenonsl'exemple de la variable prédéfinie INSTALLS. Celle-ci prend en argu-ment une liste d'objets contenant au minimum le chemin d'installa-tion. La forme la plus simple est donc la suivante :

target.path = /usr/lib

INSTALLS = target

Ici, nous spécifions que les cibles produites lors de la constructiondoivent être installées dans le répertoire /usr/lib. Il peut arriverque nous ayons plus que les cibles de construction à installer. Dansle cas présent nous voulons installer aussi le fichier d'en-tête. Pourcela, un nouvel objet est nécessaire :

# Les fichiers concernés par cet objet sont les .h du répertoire

include/

includes.files = include/*.h

# ceux-ci seront installés dans le répertoire /usr/include

includes.path = /usr/include

Une fois ceci fait, il est nécessaire d'ajouter l'objet includes

à la variable INSTALLS :

INSTALLS += includes

Les objets de la variable INSTALLS peuvent posséder un autremembre : extra. Celui-ci permet d'exécuter un certains nombre decommandes lors du build. Par exemple, si nous désirons installer lessources compressées de notre librairie :

sources.files = src/sysutils_linux.cpp.gz

sources.path = /usr/src/example2

sources.extra = gzip -c src/sysutils_linux.cpp > src/sysutils

_linux.cpp.gz

INSTALLS += sources

Ces possibilités sont, bien entendu, à mettre en relation avec lesscopes conditionnels concernant les systèmes d'exploitation. Pourterminer ce rapide tour d'horizon des possibilités de Qmake, ajou-tons qu'il est possible de déclarer des liaisons avec d'autres librairiessi celles-ci supportent pkgconfig, en utilisant la syntaxe suivante :

CONFIG += link_pkgconfig

PKGCONFIG += ogg dbus-1

Nous n'utilisons pas cette possibilité dans notre exemple.J'espère que cet article d'introduction vous aura convaincu que laconstruction multi-plate-forme n'est pas l'enfer fréquemment décrit,du moment que l'on choisit les bons outils...

■ Arnaud DupuisUperto/Devoteam

14-25 complil croisée 20/05/2009 10:54

M unissez-vous d'abord d’un bonéditeur HTML : vous éviterezainsi quelques erreurs silen-

cieuses sous certains navigateurs et trèsgênantes ailleurs. Pour bien visualiser ceque vous codez, Firefox et son extensionFirebug s'avèrent indispensables. Les fonctions d'inspection et d'édition enligne de Firebug vous permettront de mieuxcomprendre ce qui se passe dans votrepage et faciliteront considérablement votretravail de débogage – y compris en dehorsde Firefox. Il vous faut aussi de quoi tester régulière-ment vos pages web sur les trois navigateursles plus utilisés par les internautes : IE 7,Firefox 3 et IE 6. C'est là que cela se complique : si vous netravaillez qu'avec un seul poste de travail, ilvous faudra mettre en place une ou plu-sieurs machines virtuelles pour faire vostests à la fois sur les versions 6 et 7 d'IE quine peuvent fonctionner sur le même systè-me. Une autre option est l'utilisation de ver-sions émulées d'Internet Explorer, mais elleest loin d'être parfaite. Notons enfin qu'IE 8permet de se passer d'IE 7 grâce à sonmode de compatibilité très pratique etapporte aussi quelques bons outils de débo-gage. La bonne nouvelle, c'est que lesautres navigateurs vous poseront relative-ment peu de problèmes une fois la compati-bilité IE6/IE7/Firefox assurée. Rappelez-vous tout de même que quelquestests sur Safari (7% des visiteurs) doiventêtre effectués, au moins en fin de projet.

Avoir la bonne méthodeMême si un code conforme aux standardset propre ne garantit pas en soi la compati-bilité entre navigateurs, vous imposer cetterigueur vous facilitera les choses. Commen-cez donc par réaliser votre squeletteXHTML, sans style ni javascript, mettant enplace la structure logique et sémantique dela page. Positionnez ensuite vos blocs à l'ai-de des différentes propriétés CSS en sépa-rant scrupuleusement les responsabilités :toute la mise en forme doit se trouver dansdes fichiers CSS (pas de style " inline " direc-tement dans le HTML). C'est à cette étapeque l'essentiel des problèmes va se poser, lepositionnement sous IE suivant des règlesassez différentes de la norme (voir lesastuces plus bas à ce sujet) : contrôlezintensément les différences IE6/IE7/Fire-fox à cette étape.Occupez-vous ensuite de la décoration et dujavascript. Un site qui utilise beaucoup dejavascript peut poser de gros problèmes decompatibilité, mais l'utilisation adéquated'une bibliothèque JS de référence (Prototy-pe, Jquery, Dojo, Mootools) vous en éviteral'essentiel.

Les astuces à connaîtreUn bon doctypeMettez toujours un doctype valide au débutde vos pages et n'écrivez surtout rien avant(même pas le prologue xml pourtant autori-sé par XHTML), dans le cas contraire IEpasse en mode de rendu " quirks " qui rendl'affichage tout simplement absurde.

Redéfinir le style des balises par défautLes balises ne sont pas interprétées pardéfaut avec le même style suivant le naviga-teur. Forcer le style de toutes les balises (enparticulier border, margin et padding) vouséconomisera quelques migraines.Utiliser les commentaires conditionnelspour les styles spécifiques à IEIl y a de très fortes chances que vous deviez uti-liser les styles spécifiques à telle ou telle ver-sion d'IE pour fixer votre mise en page. Lescommentaires conditionnels sont faits pour ça :



La transparence des PNGLa transparence des PNG n'est pas géréenativement par IE6, mais plusieurs hackspermettent de contourner cette limitation.Par exemple : www.twinhelix.com/css/iepngfix

Les bugs de positionnement IE6IE6 comporte de nombreux petits bugs (oudifférences avec les standards) dans l'inter-prétation du positionnement des blocs, enparticulier avec les flottants. Un excellentsite en fait le recensement et fournit lessolutions adéquates : www.positionisevery-

thing.net/explorer.html

Et pour finir, rappelez-vous les trois com-mandements de l'intégrateur web : tester,tester, tester ! ■ Jean-Baptiste BoisseauEutech SSII

Le multi navigateur : le guide de survie du développeur webAutant le dire tout de suite : il n'existe aucuneméthode miracle pour faire fonctionner un site ou uneapplication web sur les principaux navigateurs dumarché. La quantité de problèmes engendrés par leseul Internet Explorer 6 est d'ailleurs effrayante...mais elle est aussi incontournable quand on sait quece navigateur représente encore 18% des utilisateurs(et plus encore en contexte d'entreprise). Ladémarche et les quelques astuces qui suivent vouspermettront donc d'être mieux armés face à cespetites galères quotidiennes. La fonction d'inspection de Firebug en action

14-25 complil croisée 20/05/2009 10:55

14-25 complil croisée 20/05/2009 10:55


dossier \\ méthode agile

Les méthodes agiles sont des méthodologies detravail et d’organisation aidant à être plus effica-ce dans le développement et l’organisation d’unprojet informatique. Aujourd’hui, l’agilité n’est pasun mot en l’air, tout particulièrement dans lesSSII, et chez les équipes de développement. Deuxméthodes, complémentaires, se détachentassez nettement : Scrum et le eXtreme Pro-gramming. L’une concerne plutôt l’organisationdes équipes et la manière de mener un projet,l’autre se concentre sur le développement desfonctionnalités. Combinées, cela donne un cock-tail détonnant ! De nombreuses équipes, de

petites tai l les, adoptent et adaptent cesméthodes et clairement, cela redonne l’envie dedévelopper car le développeur retrouve une placede choix dans l’organisation. Il n’est plus unsimple exécutant, un " pisseur de code " commeon a souvent cherché à le limiter. Mais cela s’ac-compagne aussi d’un développement moins soli-taire et avec de nouvelles responsabilités. Pourun développeur habitué à coder dans son coin, àavoir entre les mains des spécifications, uncahier des charges figés dans le marbre, lecouple Scrum / XP déroute. Car la visibilité sur leprojet est à court terme, avec des itérationscourtes et des développements de petites tâchesoù savoir communiquer, travailler, échanger avecle reste de l’équipe est nécessaire. Le dévelop-peur doit aussi s’habituer à l’art délicat de l’esti-mation. C’est-à-dire que c’est à lui d’évaluer ladifficulté de la fonction à développer et surtout dedonner un temps de développement. Cescontraintes et libertés obligent à avoir deséquipes relativement homogènes et à encadrerles nouveaux venus. Une bonne maîtrise destechnologies est également indispensable. Le développeur agile est une réalité même si celase limite essentiellement aux développements enéquipe car pour le développeur indépendant ouoccasionnel, l’agilité aura peu d’influence, saufpeut être sur son organisation et la manière dedécouper un développement. Dans ce dossier nous al lons explorer lesméandres de Scrum, de XP et voir comment sedéroule une journée type d’un développeur agile,sans oublier les meilleurs conseils pour biendémarrer dans l’agilité.

■ François Tonic

©i-

stoc

kpho

to.c

om/S

tep

hani

e H

orro

cks

DéveloppeurAGILEPour retrouver

le goût du développement


26-43 20/05/2009 11:10



A lors…implication des utilisa-teurs, soutien de la direction,exigences clairement défi-

nies, planning bien adapté, jalons plusfins, compétences des équipes et leurengagement, vision et objectifs clairs,sont des facteurs clés de succèsconnus et partagés d’un projet infor-matique et pourtant… Aujourd’hui, ilsne peuvent appliqués qu’en prenanten compte le meilleur des méthodes " Agiles " pour appréhender toutes lesdimensions d’un projet de développe-ment. [Fig.1]

Comment choisir la bonneméthodologie et lesimpacts / conséquencesde celle-ciLa dimension organisationnelle estcelle qui est très, trop ?, souventmise en avant pour aborder lesméthodes agiles dans le développe-ment. Parlons tout d’abord process,je sais c’est iconoclaste, mais le choixet la bonne utilisation d’un langage demodélisation et de spécifications basésur UML et centré sur l’architecturepermettent une définition et une ges-tion rigoureuse des cas d’utilisation etexigences. Le critère de la force estalors illustré.Poursuivons par la dimension collabo-ration, la méthode Scrum devientincontournable en focalisant l’en-semble des équipes MOA/MOE sur lapoursuite des objectifs, avec en pre-mier le respect du délai pour les fonc-

tions prioritaires et essentielles pourl’utilisateur final. Elle incarne lesdimensions coordination et puissance ;la référence au rugby n’est pas inno-cente... Enfin, la mise en oeuvre despratiques d’eXtreme Programmingadresse complètement les notions dedéveloppement piloté par les tests,intégrat ion cont inue, règles etnormes de codage avec mesure de laqualité en continu. Elle symbolise lesréflexes à acquérir …Quelles sont donc leur condition demise en œuvre ? L’organisation " Unité de temps, unité de lieu et unitéd’action " chère aux écrivains clas-siques est elle l’unique solution ? Lacaractéristique d’une équipe (d’unebonne…) au delà de la valeur indivi-duelle de chacun se traduit par lesvaleurs essentielles partagées parses membres : la communication, leretour d'information, la simplicité et lerespect. Ces valeurs ont toutes pourobjectifs d'améliorer l'équipe et dedévelopper le bon produit.L’espace partagé est un facteurimportant, il peut être physique ou vir-tuel suivant la répartition des activitésentre différentes localisations, laplate-forme collaborative prend toutson sens en termes de référentielstechniques, données, normes…Dans ces conditions, le mode de pro-duction distribué et/ou centraliséest alors complètement pris en comp-te et organisé ; la réalisation d’un pro-duit sur des lieux géographiques

différents n’est plus un obstacle. Lesimpacts sur le mode de développe-ment du produit sont par ailleurs mul-tiples. [Fig.2]La relation MOA/MOE est modifiéepour produire la plus grande valeurmétier au plus tôt. Les choix et arbi-trages sont partagés au début et toutau long du projet pour absorber lesperturbations extérieures (difficultéstechniques, évolutions du besoin….)

et apporter ainsi aux utilisateurs lagarantie de disposer des fonctionnali-tés indispensables. [Fig.3]Pour l’équipe de développement, cha-cun, même si il n’est pas directementimpliqué, doit être à tout momentinformé des activités en cours. De ce

Les méthodes agilespour mieux développerLe " Chaos Report " du Standish Group publié en 1994 meten évidence que 31% des projets informatiques sontarrêtés en cours de route, 52% n’aboutissent qu’au prixd’un important dépassement des délais et du budget (189%)et en offrant moins de fonctionnalités qu’il n’en était demandé. Seuls 16% des projets peuvent être considérés comme des succès. Depuis 1994 etmalgré une volonté farouche de progresser dans ces domaines, force est de constaterque nous (développeurs) sommes toujours confrontés aux mêmes enjeux et challenges.

Fig.2

Fig.3

Figure 1 : Equilibre et

méthodes agiles

Figure 2 : Valeur ajoutée du produit

Figure 3 : la communicationet la transparence

26-43 20/05/2009 11:10

fait, tout intervenant peut contribuerà la résolution d’un problème naissantet bénéficie d’une vision d’ensemble.Le Chef de projet joue un rôle essen-tiel. Il doit adapter son management àl'esprit et aux pratiques de l'équipeafin de constituer un environnementpropice à la " fusion " des dévelop-peurs et à la libre expression de leursavoir-faire. Il s’agit alors plus de lea-dership que de relation hiérarchiquec’est à dire plus d’animation, de facili-tation et de coordination que decontrôle. Cependant, ce n’est pasnon plus la porte ouverte à l’auto ges-tion des équipes de développement



mais bien le maintien dans la bonnedirection de tous les intervenants etcette mission là est éminementimportante.Pour assurer la visibilité du projet : unerègle simple : " ce qui est importantpour le projet est et reste visible ".L'objectif est d'être en mesure de pré-senter son avancement à toutmoment en se basant sur des infor-mations, pertinentes et à jour, que cesoit pour le produit, le processus dedéveloppement, l’architecture, les dif-ficutés, les bonnes idées, les axesd’amélioration ou les tâches à réali-ser. [Fig.4]Pour ce dernier point, trois horizonssont définis: la journée, la semaine, lemois. Chaque matin, une courteréunion de l’équipe fixe les objectifs dujour, le reste à faire (en heures) d’unsprint, d’une livraison, est réévaluétous les soirs au vu des travaux effec-tués, et partagé par tous. Les déve-loppements sont testés au fil de l’eaupar une équipe distincte dite d’assem-blage sur la production de la semaine. La correction de toutes les anomaliesdétectées est inscrite dans le plan dedéveloppement général pour la planifi-cation mensuelle.

Comment ensuite l'utiliserdans son développement,les outils à mettre enoeuvreL’outillage doit faire l’objet d’une atten-tion particulière. A chaque phase ducycle de vie du projet correspond unoutil ou une suite d’outils spécifique. Pour appréhender la dimension colla-borative, le partage des informationsau sein de l’équipe de développementpeut être réalisé manuellement.Cependant, la complexite toujoursplus grande des projets implique lamise en œuvre d’un portail qui permetde couvrir les quatre fonctions sui-vantes : échanger , partager, formali-ser et piloter. [Fig.5]Pour la conception, il s’agit alors des’appuyer sur des outils de modélisa-tion et de traçabilité des exigences.Les scénarios de tests techniques etutilisateurs sont spécifiés et viennentenrichir un référentiel de manièreautomatique et réutilisable.

Enfin il convient de normaliser etcontrôler la production technique, aufil de l’eau et prévenir les erreurs.[Fig.6]Une forge logicielle est nécessairepour instrumenter les normes dedéveloppement internes et/ouclients. Des ateliers de développe-ment intégré facilitent la générationet le contrôle du code. Ces atelierssont interfacés avec des outils degestion de configuration au sens ITILdu terme et d’un outillage de qualimé-trie. Une démarche " performances "basée sur des outils de tests, d’analy-se et de traçabilité, ainsi qu’une plate-forme de développement et de testspermettent de reproduire le plus fidè-lement possible l’environnement ciblemême, si l’échelle n’est pas identiqueen termes de volumétrie de données.

Les problèmes de formation, de compétencesPour maîtriser concepts, outillages etorganisation, la courbe d'apprentissa-ge des équipes doit être prise encompte. Le vocabulaire utilisé, la gestion des priorités, l’équilibre per-manent entre la dimension technolo-gique et les livraisons de produits nes’acquièrent pas immédiatement.L’initialisation du projet, coaching etaccompagnement dans la montée encharge sont les maîtres mots decette courbe d’apprentissage. Cesthèmes concernent autant leséquipes de développement que, pourcertains, les équipes MOA. En effet,pour bien se comprendre il faut parta-ger les " mots ". [Fig.7]Le coaching des développeurs estréalisé lors des séances de " pair-pro-gramming ", le développeur est auclavier et à la souris. Il s'occupe prin-cipalement de la syntaxe du code, dela compilation et du rejeu des tests.Le coach, quant à lui, s’intéresse à ceque le code doit faire, la conception etla revue associée. L’élaboration de lasolution technique ou sa mise aupoint émerge du travail mis en com-mun des deux équipiers. Cette pratique facilite le partage desconnaissances et garantit l’homogé-néité des développements et la réso-

Fig.4

Fig.5

Fig.6

Figure 4 : ce qui est important est et reste visible

Figure 5 : Plate-forme collaborative en support

Figure 6 : Outillage pour la production (ex environnement Java)

26-43 20/05/2009 11:11

26-43 20/05/2009 11:11


lution des bugs (si si, il y en a !! ).Même si cette organisation du travailsemble gourmande en énergie, le ROIest, croyez le, rapide.La montée en charge de l’équipe pourla fabrication du produit doit faire l’ob-jet d’une planification relative auxcadences des itérations. L’intégrationd’un développeur par mois pour uneéquipe de moins de neuf personnesest un bon rythme. Abordons maintenant les aspectsgains et axes d’amélioration… Lesretours d'expérience peuvent êtreillustrés par deux exemples de projetsqui ont privilégié des axes différentslors de la mise en œuvre desméthodes agiles. Les schémas ci-des-sous présentent pour chaque projetle point d’équilibre. [Fig.8]Les choix réalisés apparaissent claire-ment lors du développement de cesprojets. Les avantages et pointsd’amélioration qui en découlent sontprésentés dans le tableau ci-dessous.A partir de ces analyses, les équipespositionnent le point de départ et défi-



nissent les actions pour conduirel’équipe, l’organisation et les futursdéveloppements au barycentre de cetriangle.

Les recommandations.Ainsi trois erreurs sont couramentcommises. 1 Se jeter dans la mêlée : la propen-sion à penser que plus vite les déve-loppements sont lancés, plus vite lesobjectifs de délais sont atteints, estun élément de perturbation dont onne perçoit les impacts que lors despremières livraisons. Il est alors sou-vent très tard pour corriger.2 La complexité des architecturesest la plupart du temps due au phéno-mène bien connu des développeurs,l’aspiration technologique. Cette aspiration fait alors oublier leprincipe fondamental d’adéquation del’architecture au problème à résoudreet non le satisfecit à développer unesuperbe technologie qui ne servirapas.

3 L’outillage insuffisant ou peu utiliséconduit à des débauches d’énergietant dans le cadre du suivi du projetque dans l’élaboration du produit lui-même par l’impact des régressions àchaque livraison.

Afin de ressortir les bonnes pra-tiques, retenons quatre élémentsclés :La rigueur. Si les méthodes agilessont génératrices de créativité dansla production des produits aussi bienque dans l’organisation des dévelop-pements, il importe que la rigueurd’exécution sous-tende toutes les opé-rations.La simplicité. Elle agit comme corol-laire à la mise en œuvre d’architec-tures et de solutions technologiquespour la qualité du produit à dévelop-per. La transparence. Par tager etatteindre des objectifs communs auxéquipes MOA/MOE, nécessite unetransparence totale des difficultés etdes arbitrages à réaliser aussi bienque de la bonne estimation des fonc-tions dites " essentielles ".L’accompagnement. Cet accompa-gnement doit être orienté dévelop-peurs, comme nous l’avons expriméprécédemment car rien n’est inné,mais également vers les autresmembres de l’équipe qui concourrentà la réussite du projet.

Arrêtons-nous quelques instants surces éléments clés… Ces points sontuniversels et régissent notre activitéde développement depuis toujours.Les méthodes agiles sont un levier,maintenant accessible et opération-nel, pour les mettre en œuvre au ser-vice du métier de nos utilisateurs.

■ Jacques MezhrahidResponsable National du développement des applications et des services managés chez Sogeti

Projet 1 Projet 2Avantages • Process : La démarche évite l’effet tunnel propre au • Process : Tenue du planning initial

développement en " nouvelle technologie " : Points de visibilités régulierscela améliore la qualité du reporting et rassure ainsi Qualité des livraisonsle client qui " voit "le logiciel se monter sous ses yeux Prise en compte au fil de l’eau de nouvellesau fil des semaines demandes et sans remise en cause

de la date de fin de projet.• Humain : C’est un élément de motivation et de responsabilisation de l’équipe de développement. • Outillage : mesure permanenteLa productivité de l’équipe est allée en de la qualité techniques’améliorant de sprint en sprint. Evolutivité de l’application : référentiel de tests

fonctionnels, scénarios de tests techniques, couverture de tests unitaires, point d’améliorationdu code

Points d’amélioration • Outillage : Outiller la méthode de gestion des exigences • Process : Mobilisation importante des équipesConnecter la méthode à la plate-forme d’intégration pour les testscontinue de manière à gagner en productivité sur l’automatisation des tests en environnement Microsoft• Humain : Suivi de la courbe d’apprentissage de la méthode

Retours d’expériences projets

Fig.7

Figure 7 : Vocabulaire méthodes Agiles

Figure 8 :Position du pointd’équilibre sur 2

projets

Projet 1 : Projet 2 : Fig.8

26-43 20/05/2009 11:11

26-43 20/05/2009 11:11




Les experts de Scrum l'affirment :les prat iques d' ingénier iedécrites dans l'eXtreme Pro-

gramming sont indispensables pourréussir de manière durable un projetde développement incrémental, envoici quelques-unes :Tests automatisés : comment s'assu-rer que le logiciel livré à chaque find'itération fonctionne correctement ?Il n'est pas question de tester à lamain toutes les fonctions du logiciel àchaque fin d'itération : cela finirait parprendre plus de temps de tester quede développer, jusqu'à un moment oùla totalité du temps de l'itération nesuffirait plus pour tester suffisam-ment l'application. La solution préconi-sée par l'eXtreme Programming estd'automatiser autant de tests quepossible, et pour tous les types detests. Pour chaque type, il existe desoutils en facilitant l'automatisation,par exemple : les tests unitaires (Xunit:: junit, nunit...); les tests d'interfaceweb (Selenium, webdriver...), ou enco-re les spécifications exécutables (fit-nesse, greenpepper). Ainsi, ledéveloppement et le paramétrage duharnais de test deviennent partie inté-grante du travail de développement.Intégration continue : le système encours de construction est intégré enpermanence. En prat ique, lessources sont compilées, les testsdéroulés automatiquement, aussi fré-quemment que possible. Ainsi, l'équi-pe est informée très rapidement dèsqu'une erreur s’introduit dans lecode, et les corrections rendues plusfaciles puisque les modifications sontencore " fraîches ". On peut s'appuyersur des outils comme Hudson, Conti-nuum ou Bamboo pour mettre enplace un tel mécanisme.

loppeur; Orange Business Services -Online Multimedia) : on se place enpremier lieu comme utilisateur desAPI en cours de développement, et ledesign n'est plus une phase préalableau développement : il émerge en per-manence pendant le développement.Au début, on a l'impression de perdrebeaucoup de temps C'est difficile dedéfinir la suite de tests qui permettrade coder ce qu'on a en tête, et mêmenommer un test semble fastidieux.Puis on perçoit graduellement lesbénéfices, on modifie sa tournure dedéveloppement, et on comprend quepasser plus de la moitié du temps decodage sur les tests est efficace pourle projet. " Si on arrête le TDD, je quit-te l ’entreprise ! " (Jean-Phil ippeCaruana, développeur, Orange).

Remaniement ou refactoringRemanier le code, c'est le modifiersans en changer les fonctionnalités,dans l'objectif de le rendre plus facileà comprendre et à faire évoluer. L'eX-

eXtreme Programming : les fondamentaux du développeur agileL'eXtreme Programming est la première méthode de développement agile appliquéeen France. Contrairement à Scrum, elle prescrit des pratiques d'ingénierie logicielle.Nous allons présenter ici les plus marquantes.

Développement Piloté parles Tests (ou TDD) Pour chaque fonctionnalité que jeveux ajouter dans le code :1) je code le test (automatisé) qui

montrera que j'ai réussi,2) je fais le développement le plus

simple possible pour que ce testpasse,

3) je remanie (refactoring) le codepour réduire la duplication.

Appliquer systématiquement et rigou-reusement ce principe permet deproduire du code couvert par destests automatisés. Mais les dévelop-peurs témoignent que les bénéficesvont au delà - " le TDD pousse à biencoder " (Laurent Cobos, développeurchez Pyxis Technologies France) : desprincipes tels que le découplage, lacohérence forte, où la responsabilitéunique sont encouragés, les APIdéveloppées sont faciles à utiliser, lecode et les tests sont expressifs,faciles à lire et à comprendre, auto-documentés. " l'approche du designest inversée " (Bruno Thomas, déve-

© E

mm

anue

l Che

nu

26-43 20/05/2009 11:11



treme Programming encourage desact iv i tés de remaniements fré-quentes, à plusieurs échelles (métho-de, objet, composant, systèmecomplet), y compris dans le harnaisde test lui-même. C'est une hygiène àrespecter pour lutter contre l'entro-pie dans le code.Sans remaniement, le même cycle sereproduit toujours. Au fur et à mesu-re que le logiciel évolue, il devient sigros et si complexe qu'il s'écroulesous son propre poids : il est extrê-mement long pour tout nouvel arri-vant d'en comprendre la structure; ettrès coûteux de le faire évoluer pourrépondre aux nouvelles demandes deses utilisateurs. A ce stade, on décidede lancer une refonte " from scratch ",ou bien le logiciel finit par être oubliéau profit d'un concurrent plus jeune etplus performant.Grâce à un refactoring régulier et sys-tématique, on peut enfin faire la pro-messe que le logiciel pourra vivrependant 10 ou 20 ans. Ce sont les tests automatisés et l'in-tégration continue qui le rendent pos-sible : on n'a plus peur de " casser " lecode quand on y touche. Si cela arri-ve, un test automatique échoue,l'alerte est levée immédiatement, et ilest encore facile de revenir en arriè-re. Le remaniement est l'activité laplus complexe du développement,mais c'est aussi la plus gratifiante. " Le refactoring, c'est la récompense "(Antoine Contal, coach xp, Orange).

Le binômage ou pair programmingLe binômage, c'est la plupart dutemps, un clavier, un écran, et 2développeurs derrière! Le travail dedéveloppement devient un dialoguepermanent. Le bénéfice immédiat estla qualité du code produit, et la diffu-sion des compétences dans l'équipe.Les développeurs qui ont adoptécette pratique ne tarissent pasd'éloges : " Chaque fois que je binô-me, j'apprends " (Radhouane Gour-chene; développeur, Orange), " Celam'a permis de m'intégrer rapidementau projet " (Laurent Cobos), " Tunivelles la compétence de l'équipe parle haut " (Bruno Thomas), " Tu n'es

plus tout seul face au problèmedevant la machine " (Jean-PhilippeCaruana), " quand on code, on peuts'égarer, l'autre, c'est ta boussole "(Thomas Dufourd), " coder à 2, c'estdiviser le nombre d'erreurs par 5 "(Radhouane Gourchene).Quelques conseils pratiques : fairecirculer fréquemment les individusdans les binômes, jouer au ping pong(" j'écris un test, tu le fais passer, tuécris un test, je le fais passer, j'écrisun test... "), ne pas hésiter à se sépa-rer quand être en face à face n'estpas efficace (pour les activités explo-ratoires par exemple, explorer enparallèle et faire le point régulière-ment). Pour certains, binômer, c'estagréable et plutôt naturel, cela per-met de faire connaissance, et mêmeles tâches les plus ingrates devien-nent motivantes. Mais ce n'est pastoujours facile, surtout quand on neconnait pas son binôme : au début,c'est un bras de fer, on veut démon-trer sa compétence et cacher seslacunes, on a peur de ralentir l'autre.Puis on apprend à se faire confiance,à exposer ses faiblesses et à s'ap-puyer sur les forces de l'autre, et letravail devient un enrichissementmutuel.Binômer rend l'activité de développe-ment très intense : face à un problè-me dif f ici le, pas d'échappatoirepossible, pas question de l'éviter, nide faire des compromis sur la qualité.Quand on est deux, on est plus disci-pliné, et le regard de l'autre pousse àdonner le meilleur de soi-même, enpermanence. A la fin de la journée, onest épuisé. Heureusement, l'eXtremeProgramming engage par ailleurs àtravailler à un rythme soutenableindéfiniment : les heures supplémen-taires doivent rester exceptionnelles.

Pour quel projet ?L'eXtreme Programming est un modede développement demandantrigueur et discipline. Il est recomman-dé pour les développements logicielsréalisés en équipes colocalisées, où laqualité du code (en particulier sonévolutivité à long terme) est la préoc-cupation première. C'est cette qualitéqui permet de s'assurer que le logiciel

pourra évoluer longtemps, tout enapportant régulièrement de la valeurà ses utilisateurs.

Un art martial du développement ?L'eXtreme programming est uneméthode agile complète, applicablesans référence à Scrum. Elle prescriten tout 13 pratiques et s'appuie surle respect de 4 valeurs. Pour chaqueindividu, comme pour l'équipe dansson ensemble, les adopter demandecourage et persévérance.Au tout début, cela peut être un choc,les habitudes sont bousculées, lesautomatismes remis en question. Lespremières semaines peuvent être dif-ficiles, avec l'impression que le projetpiétine. Après le premier apprentissa-ge, les résultats apparaissent. Enfin,l'investissement s'avère payant, demanière durable : le logiciel développécontinue à évoluer à un rythme quasiconstant que l'équipe peut soutenirindéfiniment; les développeurs pren-nent plaisir à travailler ensemble etsont fiers du code qu'ils produisent.Pour chaque individu, ça passe ou çacasse : des développeurs rejettent enbloc certaines pratiques. Notam-ment, le binômage ne convient pas àcertains tempéraments. En revanche,ceux qui ont adopté l'eXtreme Pro-gramming ne jurent que par lui : " J'ail'impression d'avoir changé de métier" (Thomas Dufourd) " XP m'a redonnéle goût du développement" (Jean-Phi-lippe Caruana), " c'est l'avenir dudéveloppement " (Bruno Thomas).

RessourcesTest Driven Development: By ExampleKent BeckRefactoringMartin FowlerL'Extreme Programming - Avec deuxétudes de cas, 2002Jean-Louis Bénard, Laurent Bossavit,Régis Médina et Dominic Williams

■ Raphaël Pierquincoach d'équipes dedéveloppement chezPyxis TechnologiesFrance [email protected]

26-43 20/05/2009 11:11



Les méthodes agiles sont des pratiques itératives de développement logiciel quirépondent à des besoins de changement pouvant être fréquents, et qui privilégientl’interaction humaine en visant la satisfaction réelle du client. Au travers de cet article,nous racontons la journée type de Martin, devenu développeur agile, et les grandschangements que cela a engendré dans son travail. Si vous êtes développeurprofessionnel, vous comprendrez vite les bénéfices à utiliser de telles méthodes !

9H00Nightly Build et rapportsjournaliersMartin arrive au bureau. Il travaillecomme développeur sur différentsprojets et, aujourd’hui, il est plusmotivé que les autres jours. Il repen-se au jour où sa société a décidé degérer les projets à l ’a ide desméthodes Agiles. Depuis, il a retrou-vé un intérêt pour son travail qu’iln’avait plus eu depuis quelquesannées. Le temps de poser sesaffaires, il jette un rapide coup d’œil àson mail : le rapport de générationde build automatique, qui s’exécute à2:00 du matin, lui indique que touts’est bien passé et que la build a étélivrée aux testeurs sur un partageréseau.

9H15Les individus et les interactionsMartin rejoint l’équipe à la machine àcafé. Leur chef de projet arrive unpeu après et en profite pour donnerun feedback rapide sur les testsmenés la veille : tout est au vert, lestesteurs sont très satisfaits desajouts remontés hier. Les priorités

de la journée sont rapidementbalayées pour que toute l’équipe soitalignée sur les mêmes objectifs.Comme d’habitude le point se conclutpar un petit tour de table : Qu’est cequi se passe bien ? Moins bien ? Quepeut-on améliorer ? Frédéric fait partau reste de l’équipe d’une optimisa-tion qu’il a trouvée pour accéder auxdonnées SQL. Il partagera l’info sur lewiki interne de l’équipe.

9H30Collaboration entre lemétier et la techniqueDe retour à l’open space, Martinlance son Visual Studio, met à jour sasolution en récupérant les dernièresversions des codes sources depuis labranche principale du projet sousTeam Foundation Server (TFS). Ilreprend les documents décrivant lesfonctionnalités à implémenter. Cesdocuments ne sont pas exhaustifs etse présentent sous la forme de " usecase " : le besoin métier et les solu-tions techniques y ont été élaboréesen collaboration entre les fonction-nels et les membres de l’équipe. Cedocument de travail évolue tout aulong du projet grâce à l’effort de cha-cun pour contribuer à son écriture.Martin a justement prévu de voirSacha à 11h00 pour discuter d’unefonctionnalité. Les réunions entre lefonctionnel et la technique ont per-mis d’améliorer la cohérence globaledu projet mais aussi de mieux fairecomprendre et revaloriser le rôle dechacun.

9H45Check-in réguliers et intégration continueMartin récupère ses tâches depuis

TFS (Work Items) et démarre sesdéveloppements dans l’ordre despriorités. C’est véritablement dans lamanière de développer que Martin achangé ses habitudes afin de secaler au rythme des itérations : l’ob-jectif est de faire simple, pragma-tique et évolutif pour apporter de lavaleur fonctionnelle le plus rapide-ment possible. Martin vient de finir les évolutionsqu’il avait prévues la semaine derniè-re. Il fait une dernière mise à jour deses codes sources en local, compileet intègre ses modifications dans leréférentiel. Une build de validationest automatiquement mise en filed’attente sur le serveur de build quiexécutera par ailleurs les tests uni-taires. Martin recevra ensuite unrapport lui permettant de s’assurerque tout s’est bien passé.

11H00Les changements, même de derniermoment, sont les bienvenus !Sacha vient retrouver Martin à sonposte de développement et lui tendun document de demande d’évolu-tion. Il faut revoir 25% d’une fonction-nal i té développée la semainedernière et faire des modifications

La journée d’un développeur agile

26-43 20/05/2009 11:11



plus ou moins mineures. Pas de pro-blème pour Martin, ce sera un déve-loppement de quelques heures. Letout se faisant dans un flux continu,les changements arrivant au fur-et-à-mesure que les tests sont faits, lesmodifications sont finalement relati-vement mineures. En fait, c’est devenu très simple pourMartin : il développe rapidement deschoses testables sur la base des usecases émis par les fonctionnels.Plus il met rapidement à dispositiondes testeurs quelque chose d’utili-sable, plus vite les testeurs revien-nent vers lui pour demander deschangements en adéquation avec lemétier.

14H00Réunion hebdomadaire etmesures de progressionAprès le déjeuner, comme tous lesmercredis, l’équipe se retrouve dansl’open space pour faire le point surl’avancement du projet. L’élément demesure principal est la complétudedes fonctions livrées et testées. Cesréunions hebdomadaires sont aussil’occasion d’inviter d’autres membresdes équipes de test ou des fonction-nels. Le chef de projet donne unretour sur la progression, mais aussila satisfaction remontée. On en profite aussi pour passer enrevue les bugs les plus importants,ceux qui sont en priorité 1 (à faire leplus rapidement possible) et sévérité1 ou 2 (bug critique ou bug majeur).Grâce aux différents indicateursremontés par TFS et le cube associéau projet, le chef de projet a pumettre en place une feuille Excel per-mettant de piloter le rythme desdéveloppements, la qual ité deslivrables et la progression du travail

réalisé, tout cela dans le souci degérer la bonne prior ité au bonmoment.

14H30Tests unitaires et couverture de codeRetour au développement, Martinimplémente les tests unitaires desdéveloppements réalisés le matinmême. Il trouve intéressant la pra-tique du développement piloté par lestests (TDD) mais son équipe n’a paschoisi de suivre cette pratique. Néanmoins, les tests unitaires per-mettent de vérifier qu’il n’y a pas derégression engendrée par les nou-veaux développements, et la couver-ture de code associée aux testsunitaires permet de vérifier l’exhausti-vité des tests et ainsi la qualité qui endécoule. Cette méthode a permis àMartin de s’améliorer comme déve-loppeur professionnel : du code plusfacile à maintenir, plus lisible et sur-tout plus fiable. Au final, c’est toute l’équipe qui abénéficié de cette pratique et lescompétences s’en sont trouvées net-tement améliorées, pour le plusgrand bien de tous. Tirer l’équipevers l’excellence technique est l’undes principes des méthodes Agiles.

18H30ConclusionMartin a fini sa journée et est satis-fait de son travail : il obtient du feed-back des testeurs et aide lesfonctionnels à formal iser leursbesoins lors de leurs réunions de tra-vail. L’ambiance au sein de l’équipen’a jamais été aussi bonne etconstructive : tout le monde s’entre-aide et la communication est effica-ce. Il sait que grâce au choix desméthodes Agiles, sa carrière dedéveloppeur professionnel reprendde l’intérêt, qu’il est valorisé par lefeedback des utilisateurs finaux quiobtiennent des réponses concrètes àleurs besoins, et que son avis estrespecté car l’autonomie dont ilbénéficie dans la conception tech-nique prouve que ses idées sontbonnes. Pour rien au monde, il nevoudrait revenir aux méthodes précé-

dentes dans lesquelles le chef de pro-jet lui demandait de lire des spécifica-t ions techniques détai l lées quin’étaient jamais exhaustives et qui nelaissaient aucune place à sa créativi-té de développeur.

RéférencesManifesto for Agile Software Develop-ment : http://www.agilemanifesto.org/

Guidelines for Test-Driven Develop-ment : http://msdn.microsoft.com/en-

us/library/aa730844.aspx

Continuous Integration : http://martinfow-

ler.com/articles/continuousIntegration.html

■ FrédéricQUEUDRET

MVP Client Application &CTO de la sociétéMpoware, accélérateur

d’innovation. Société fran-çaise d’édition de logiciels et de prestationsde services sur les technologies .NET.Mpoware est signataire du manifeste Agileet accompagne ses clients dans la mise enplace des méthodes Agiles au sein de leurséquipes.

http://www.mpoware.com/

Mpoware lance l’AgileTraining CenterPour les développeurs, testeurs, chefs de projet,architectes ou MOA, le workshop d’une journée,que propose Mpoware au travers de l’Agile Trai-ning Center, permettra aux équipes projets decomprendre et pratiquer les valeurs et principesdes méthodologies Agiles appliquées à la plate-forme Microsoft Visual Studio Team System2008. La plupart du temps, les équipes projetdéploient VSTS mais utilisent seulement la plate-forme pour versionner leurs codes sources, pas-sant ainsi à côté des avantages et du retour surinvestissement qu’ils gagneraient à suivre un pro-cessus Agile. Ce n’est pas la plate-forme qui rendles équipes agiles, c’est la méthodologie et sesvaleurs appliquées à la plate-forme. Mpoware pro-pose un workshop d’une journée avec mises ensituation projet pour vos équipes : participez àtoutes les étapes d’un projet Agile et pratiquez lesméthodologies Agiles alliées à la plate-forme VSTSpour améliorer concrètement la performance etla productivité de vos équipes projets.Contactez nous vite pour réserver votre journéevia [email protected].

26-43 20/05/2009 11:11



D ans l'équipe eXtreme Program-ming / Scrum où je travaille,

lorsqu'un problème survient, nous uti-lisons depuis quelques mois un for-mat standardisé issu du Lean : leQRQC (Quick Qual i ty ResponseCheck). De quoi s'agit-il ? En présenced'une situation insatisfaisante, unmembre de l'équipe prend une feuillede papier et nomme le problème enhaut à gauche. Par exemple : nousavons mis 5h pour ajouter deuxoptions au lieu de 1h30 estimée initia-lement. On indique ensuite l'impactpour le client : risque de non-respectde l'engagement du sprint en cours.Vient ensuite l'impact pour l'équipe dedéveloppement : mon binôme écrit"maux de tête". Puis on passe à ladescription du problème (que s'est-ilpassé ?) : • Première difficulté : nous avons tenté

pendant une heure d'écrire un testpour soutenir l'ajout d'une optiondans le fichier de configuration.

• Deuxième difficulté : pour l'une desoptions, nous avons passé dutemps à trouver le lien entre l'inter-face homme-machine et sa repré-sentation dans le code.

On note ensuite les causes probables : • 1/ Méconnaissance de l'utilisation

combinée de JNDI et Spring. • 2/ Utilisation inutile de JNDI dans

ce contexte • 3/ Nom de variable décorrélé du

terme employé dans l'interface gra-phique

Pour chacune des causes, on regar-de s'il existe un standard explicite ets'il a été respecté. Dans le cas de cetexemple, nous n'avons aucun stan-dard. Ensuite, pour chacune des trois

causes, nous énumérons des actionspossibles : • 1/ Faire un how to sur comment

écrire des tests conjuguant Spring,JNDI et l'ajout d'option.

• 2/ Remplacer JNDI par un fichierde properties.

• 3/ Choisir des noms de variablesplus cohérents.

Enfin, on indique la date et le tempspassé (un chronomètre avait étédéclenché en prenant la feuille). Nousy avons consacré trop de temps : 20minutes au lieu des 10 minutes duQRQC précédent. Avec mon binôme,nous concluons qu'il vaut mieux fairede plus petits QRQC au fur et à mesu-re que les problèmes sont rencontrésplutôt que d'attendre la fin de latâche. Le lendemain, cette stratégiese révélera payante.

Un écart par rapport à unstandard existantPour notre problème de dépasse-ment de temps, nous n'avions aucunstandard, mais ce n'est pas toujoursle cas. Dans une équipe agile, desstandards explicites existent dontnous n'avons pas conscience, commela définition de done (aussi appeléefini-fini). Au lendemain d'une démonstration defin d'itération difficile, un QRQC a lieupendant la rétrospective. L'une descauses est le non respect de la défini-tion de done. Enoncer en équipe cetécart par rapport au standard per-met alors à un des développeurs deprendre conscience qu'il ne respec-tait plus cette définition de done. Ildécide de se montrer plus rigoureuxet un autre développeur se propose

pour vérifier les critères du fini-finichaque matin.

Un standard à améliorerUne autre cause de la démo difficiledont je viens de parler était que deuxinstances de Tomcat tournaient sur lamachine de recette. C'est la mauvai-se instance de Tomcat qui répondaitlors de la démo. Nous nous posons alors la questiondes standards : • Un standard existe-t-il ? Oui : un

script centralise l'accès aux ser-veurs d'application.

• Le standard a-t-il été respecté ?Oui. On a bien invoqué application_server stop, mais seule l'optionforce-stop tue Tomcat à coup sûr.

• Solution possible : changer le stan-dard en câblant l'option stop surl'option force-stop

Se poser plus systématiquement laquestion des standards au sein d'unQRQC permet donc d'en prendreconscience, aide à les vérifier et sur-tout à les améliorer. Le QRQC étantlui-même un standard, sans douteest-il possible de l'améliorer !

■ Philippe Blayo, DéveloppeurOrange Business Services

Jeff Sutherland a créé la première équipe Scrum en mettant enoeuvre un article écrit par deux japonais. Des démarches Leanvenues du Japon, nous pouvons tirer des outils pour aider à améliorerla qualité dans une équipe agile. Voyons comment une équipeXP/Scrum utilise un de ces outils pour la résolution de problèmes.

Standardiser la résolution de problèmes dans une équipe agile

Avis d’expert

26-43 20/05/2009 11:12


Entretien avec Claude Puppatti, directeur général de Valtech France, spécialiste des Méthodes Agiles.

Programmez : Les équipes techniquesacceptent davantage ces méthodes ?

Claude Puppatti : Le fonctionnement est diffé-rent, les équipes du client et du prestataire sontétroitement mêlées, ce qui demande à ré-inventerles contrats : la logique maître d’ouvrage/maîtrised’ouvrage est dépassée, on est dans une relation deco-responsabilité. Le mode de communicationdevient très direct, les équipes opérationnelles ontdavantage de responsabilités. Les reporting doiventêtre organisés autrement afin de ne pas peser,comme c’est souvent le cas, sur le cycle.

P : Le concept de " méthodes agiles " est-ilaujourd’hui bien compris des entreprises ?CP : Le terme est galvaudé, mais surtout, la dif-ficulté réside dans le fait qu’il s’agit d’un rudechangement de mentalités, d’une révolution cul-turelle ! Cela demande un effort, alors quedemeurer dans le classique " effet tunnel " desprojets est si confortable ! Nous sommes dansdes cycles courts, de 4 à 6 semaines, et il faut

disposer très vite des composants. Lesméthodes agiles induisent une conduite du chan-gement au sein de l’entreprise. Les cycles dedéveloppement ne suivent pas les cycles de déci-sion de l’entreprise. On avait 3 ans pour un pro-jet, aujourd’hui, on a 15 mois. Les prioritéschangent : installer un ERP ne suffit plus forcé-ment à donner un avantage stratégique.

P : Etre spécialiste des Méthodes agiles est unatout ?CP : Finalement, notre mission est de plus en plussouvent de modifier la culture de l’entreprise.Nous allons constituer au niveau de Valtech unetask-force capable de vendre une offre globale,incluant la conduite du changement, au sein de LaDirection Informatique, et dans le fonctionnementdes services. Notre maîtrise des méthodes agilesnous confère une avance au niveau des SSII. Unefenêtre d’avance de 15 à 24 mois ? Les chosesvont vite !

Propos recueillis par Jean Kaminsky

Claude Puppatti dirigeValtech pour la France. Le groupeintègre 4 entités,dont ValtechTechnology, conseil etintégration de projets,spécialiste desméthodes agiles. Il est installé dans 7 pays, dont lesEtats-Unis et l’Inde. Il compte 1130employés, dont 266 en France. 39% duCA de 100,6 M€ estréalisé par la France (chiffres 2008).

SOFTEAM FormationCalendrier complet et inscriptions en ligne

www.softeam.fr

Soyez prêtspour les nouvelles architectures

SOA et Web 2.0 !

SOA est devenu en peu de temps le mot-clé des développementslogiciels. SOA est une nouvelle façon de faire qui s’appuie sur un

ensemble de technologies existantes : UML, J2EE, .Net, XML, etc.Maîtriser SOA implique de maîtriser ces technologies pour les associer

efficacement au sein d’une nouvelle approche.SOFTEAM Formation, forte de son expérience en Méthodologie, Architecture et

Développement, a construit un cursus complet de formation SOA qui vous permet de débuter dès les phases amont, de poursuivre en architecture, et d’aller jusqu’à

la réalisation dans le langage de votre choix.

SOA

SOA

SOA

SOA

Tél. : 01 53 96 84 30 - Fax : 01 53 96 84 01Paris : 21 avenue Victor Hugo - 75016

Rennes - Nantes - Sophia Antipolis

Web 2.0

Nouveau catalogue Formation 2009 :UML pour la maîtrise d’ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 jAnalyse et conception avec UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 jAlignement Métier du Système d’Information. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 jArchitecture d’Entreprise (EA) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 jMéthodologie pour SOA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 jArchitecture technique SOA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 jDéveloppement de Web Services en Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 jDéveloppement de Web Services en C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 jArchitecture distribuée : la synthèse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 jProgrammation orientée objet avec Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 jDéveloppement d’applications JEE 5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 jDéveloppement d’applications JEE 5 Front End . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 jDéveloppement d’applications JEE 5 Back End avec EJB 3. . . . . . . . . . . . . . . . . . . . . . . 3 jMaîtrise du framework (Struts / JSF / Spring / Hibernate) . . . . . . . . . . . . . . . . . . . . . . . . . 3 jDéveloppement d’applications .NET / C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 jDéveloppement d’applications RIA avec. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 j (Ajax / Dojo / GWT / FLEX3). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 j

Convergence SOA, UML2, BPMN, EA Modélisation EA, BPMN, SOA avec Objecteering SOA Solution. . . . . . . . . . . . . . . . . 2 jAnalyse et Conception UML2 avec Objecteering Modeler . . . . . . . . . . . . . . . . . . . . . . 5 jExpression de besoins en UML2 avec Objecteering Scope Manager. . . . . . . . . . . . . 1 jArchitecture MDA avec Objecteering MDA Modeler . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 jGénération de code Java, .NET C#, C++ avec Objecteering Developer. . . . . . . . . . 1 j

SOA

UML 2Ajax

Java

J2EE

Web 2.0

.NET

Urbanisation Méthodologie

Patterns

Frameworks Web services

EAI

ESB

BPM EA

MDA

XML

Architecture

SOA

SOA

“L’agilité, une révolution culturelle”

26-43 20/05/2009 11:12




P our rappel, la méthode detravail doit être adaptée à laréalisation d’un nouveau pro-

duit complexe pour lequel il n'est paspossible de faire des spécificationsfonctionnelles et techniques détailléeset exhaustives. Les tâches sontdécouvertes progressivement, leschangements sont la norme et doi-vent être considérés comme uneopportunité: un besoin, une solutiontechnique qui n’ont pas été identifiéslors du lancement du projet, mais quisont pertinents, doivent être pris encompte. A l’inverse, un choix nonadapté doit être remis en question etretiré si nécessaire.Ainsi, il importe que la méthode detravail permette à l’équipe de s’adap-ter aux changements et imprévus,qu’ils soient techniques, fonctionnelsou organisationnels (par exemple unchangement de la constitution del’équipe). Il est donc nécessaire d’utili-ser des outils et une organisation quipermettent :

Vendre SCRUMà une équipe en cycle VPasser à la méthode SCRUM pour une équipe de développement delogiciel appliquant une méthode classique (de type cycle en V) est unchallenge en vue d'une bien meilleure efficacité, mais nécessite de grandschangements organisationnels et une remise en question des pratiques del'équipe. Nous présentons dans cet article un bref résumé de la méthode,ses avantages, ses difficultés, et quelques recettes simples pour aider àfranchir le pas.

• D’optimiser le travail du groupe:faire ce qui est nécessaire et suffi-sant pour l’utilisateur, favoriser lepartage des savoirs et des compé-tences et mettre en avant les com-pétences de chacun.

• D’établir un dialogue de qualité avecl’utilisateur: comprendre ce qu’il dit,parler un langage qu’il comprend etl’impliquer dans la réussite du projet

• De s’organiser en s’appuyant surdes estimations fiables: un plan pré-cis, mais faux, est plus qu’inutile: ilest dangereux! Il est important d’es-timer la qualité de l’information donton dispose.

Les méthodes de travail qui respec-tent ce besoin de grande réactivitésont appelées les méthodes agiles.Le " manifeste agile " formalise lanotion d’agilité en la déclinant sous laforme de 4 valeurs et de 12 prin-cipes. Il est intéressant de présenteret parcourir avec les membres del’équipe ces valeurs et principes afin

de les sensibiliser sur les enjeux etréalités pratiques auxquels il estnécessaire de faire face dans lecadre du développement de logiciel.

Quels sont les principesde scrum ?lls sont simples.• Les personnes qui interviennent sur

le projet sont réparties en seule-ment 3 rôles :- Le Product Owner / directeur deproduit : il représente les utilisa-teurs, déf in it et pr ior ise lesdemandes produit.- L’équipe SCRUM: avec moins de 7personnes regroupant tous lesrôles traditionnels (architecte, déve-loppeur, testeur, administrateur).Cette équipe développe le produit etse gère en toute autonomie.- Le Scrum master, qui n’est pas lechef de projet mais qui a un rôle decoach: sa mission est de toutmettre en oeuvre pour que l'équipetravaille dans de bonnes conditionset se concentre sur l'objectif duprojet.

• Le Product BackLog (cf figure 1)liste les besoins produits. Il est gérépar le Product Owner mais est par-tagé avec l’ensemble du groupe. Lesbesoins sont priorisés et l’accentest mis sur les besoins les plus prio-ritaires et devant être adressés àcourt terme. Ils sont associés à descritères d’acceptance qui permet-tent de définir, sans ambiguité, lescritères qui permettront de considé-rer que le besoin est couvert.

Fig.1

Gestion desbesoins et des

tâches.

26-43 20/05/2009 11:12



• Le Sprint BackLog contient lestâches à réaliser durant une itéra-tion appelée Sprint.

• Les Burndown Charts sont des gra-phiques permettant de suivre visuel-lement l’avancement du sprint et dela release (composée de plusieurssprints).

• Les sprints ont une durée fixe et sedéroulent de la façon suivante: (cffigure 2)- Chaque sprint commence par uneréunion de planification appeléeSprint planning. A l’issue de cetteréunion, l’ensemble de l’équipeconnaît et comprend l’objectif dusprint et chaque besoin, qui doitêtre adressé dans le sprint, estdécomposé en tâches.- Durant le sprint, chaque membrede l’équipe prend une et une seuletâche dans le pool de tâches lesplus prioritaires et effectue celle-ci.- A heure fixe, un daily scrum(mêlée quotidienne) est effectuédebout. Chaque membre prend laparole à tour de rôle pour indiquerce qu’il a fait, ce qu’il va faire et lesproblèmes qu’il a rencontrés. L’ob-jet de ce meeting est de faire unstatut mais pas de résoudre lesproblèmes.- En fin de sprint, les besoins réali-sés durant le sprint sont montrés àtravers l’utilisation du logiciel.- La réunion de rétrospective estfaite après la démonstration. Cetteréunion a pour objet de lister lespoints qui ont bien fonctionné, ceuxqui peuvent être améliorés et deconvenir d’un ou 2 axes d’améliora-tion pour le prochain sprint.

Qu'est ce qui différenciescrum des autresméthodes agiles ?A la différence des méthodes UP ouXP, SCRUM met l'accent sur l'implica-tion de chaque membre de l'équipepour atteindre un objectif et non passur des pratiques de développementde logiciel. Le product owner est fortement impli-qué : il revoit les priorités et besoins àchaque sprint et se focalise sur leursvaleurs business. L’équipe Scrum travaille de façon

incrémentale avec des itérations timeboxées. Ainsi, SCRUM permet desatisfaire le client en livrant tôt etrégulièrement des logiciels utiles etde qualité (puisque composés defonctionnalités terminées).On retrouve dans SCRUM l'importan-ce de la cohésion du groupe pourfaire face aux difficultés qui vont êtrerencontrées tout au long de la vie duprojet. Dans l 'équipe Scrum, chaquemembre est impliqué et a sa placedans le projet : les compétences,connaissances et avis de chacun sontimportants et complémentaires.Cette organisation permet à chaquemembre non seulement de remonterdes besoins qui n’ont pas forcémentété identifiés, mais également demieux comprendre les besoins et diffi-cultés des autres membres de l’équi-pe : par exemple, l’implication d’unepersonne en charge de l’exploitationde l’application permet de mieux com-prendre et appréhender les besoinsde monitoring ou de déploiement de l’application. La responsabilité n'incombe plus àune seule et même personne maisest partagée entre le product owner,l'équipe scrum et le scrum master.

Quel est l'interêt de cetteapproche ?L'équipe est très efficace :• Les membres de l'équipe sont impli-

qués donc amenés à collaborer

ensemble, ce qui permet de parta-ger la connaissance et d'éviter ainsique le groupe ne devienne tropdépendant d'une seule personne.Plusieurs personnes sont en mesu-re de prendre une tâche hautementprioritaire et sont ainsi capables determiner une fonctionnalité.

• Les livraisons régulières motiventles membres et les impliquent dansla réussite du projet.

• L'équipe travaille dans de bonnesconditions puisque le scrum masterfait en sorte qu'elle ne soit pas per-turbée par des éléments extérieursau projet.

L'équipe livre régulièrement desfonctionnalités terminées, ce quipermet :• D'utiliser le logiciel en l'état.• De mesurer la capacité de production

(appelée vélocité) du groupe et ainsid'ajuster la planification des fonction-nalités qu'il reste à implémenter.

Comment passer en mode scrum ?• Former l'équipe à SCRUM.• Rassembler l'équipe projet dans

une seule et même pièce.• Mettre en place des outils et pra-

tiques pour travailler efficacementen mode incrémental. SCRUM neprécise pas les techniques d'ingé-nierie du logiciel à utiliser. Unebonne pratique consiste à utilisercelles préconisées par XP notam-ment l'utilisation d'une plate-forme

Déroulementd'un sprint

Fig.2

26-43 20/05/2009 11:12



la nouveauté. Elles ne travaillent pasexclusivement sur leur domaine decompétence ou selon leurs aspira-tions: par exemple, un développeurva être amené à contribuer auxtests pour atteindre l'objectif dusprint. Son rôle ne se limite doncplus simplement à produire du code.

• Chaque membre n'a pas une listede tâches affectées mais prend destâches parmi les plus prioritairestout au long du sprint. Toutefois, ilexiste des limites puisque certainestâches sont liées à un corps demétier et ne peuvent être réaliséespar n’importe quel membre del’équipe. C’est le cas, par exemple,de certaines tâches de déploiementen production.

• Les membres de l'équipe qui avaientun rôle décisionnel (notamment lechef de projet) ou qui avaient obtenuun " titre " convoité depuis long-temps peuvent ressentir un senti-ment de frustration.

• A l'inverse, les personnes qui ne sontpas habituées à se prononcer aurontbesoin d'une phase d'adaptation.

De ce fait, du temps et de l'adaptationà plusieurs niveaux peuvent êtrenécessaires pour obtenir une cohé-sion optimale de l'équipe.Pour passer outre ces difficultés, lerôle du scrum master est essentiel. Ildoit pour cela :• Etre à l'écoute de l'équipe et attentif

aux obstacles rencontrés qui peu-vent être de nature très variée(conflits internes, problèmes d'infra-structure, administratifs...),

• Faire appliquer les valeurs et lespratiques de SCRUM,

• Superviser l’activité des membres,• Communiquer au client l'avance-

ment et les problèmes,• Protéger l’équipe de tous les élé-

ments perturbateurs externes,• Encourager la coopération entre les

personnes,• Aider le product owner à sélection-

ner les fonctionnalités qui ont laplus-value maximale.

Quelles solutions peuventêtre mises en place ?Il peut être nécessaire de procéderpar étapes, notamment lorsque l'équi-

pe a un historique de cycle en V. Parexemple, la non affectation de tâcheslors du sprint planning est sujet à dis-cussion. Si, malgré une explication, lamajorité n'est pas convaincue de l'in-térêt de cette approche, il est pos-s ib le dans un premier tempsd'affecter les tâches lors du sprintplanning. On démontre ainsi à l'équi-pe qu'en se focalisant sur les objectifsdu sprint, le turn over des tâches esttel qu'il n'y a pas d'intérêt à les assi-gner. Après quelques sprints, il estplus facile de les convaincre d'es-sayer (et d'adopter :-) ) le fait de nepas affecter les tâches.Il est important d’essayer de nou-velles pratiques et de se faire un juge-ment après les avoir testées:l'utilisation du tableau scrum (quicontient l'objectif du sprint, les tâchesà faire, en cours et terminées) et duplanning poker pour faire des estima-tions font partie des pratiques lesplus courantes pour appliquer rapide-ment les valeurs et règles deSCRUM.Pour conclure, bien que la méthodeSCRUM réponde à des règles relati-vement précises, il est important debien garder à l’esprit que chaqueéquipe, chaque projet et chaquecontexte sont différents. La solutionretenue sur un projet n’est pas forcé-ment celle qui doit être appliquée surtout autre projet. Le cadre deSCRUM est suffisamment large pourpermettre à chaque équipe de trou-ver l'organisation et les solutions adé-quates.

■ Laurent LaslazScrum MasterObjet Direct

A propos de Objet DirectObjet Direct (filiale de Homsys Group) déve-loppe depuis plus de 10 ans son expertisedans la modélisation, les architectures objet(Java, .NET, RIA) et les Méthodes Agiles,pour accompagner ses clients dans le pilo-tage de leurs projets, depuis la conceptionjusqu’au déploiement des applications, etoptimiser leurs systèmes d’information,leurs méthodes de développement logiciel etleurs processus métiers.

www.objetdirect.com

d'intégration continue et le Test Dri-ven Development (TDD)

• Initialiser un product backlog en seconcentrant sur les besoins haute-ment prioritaires. Mettre l'accentsur les critères d'acceptance dechaque besoin. Le découpage estun exercice difficile et pour lequel ilest important de consacrer dutemps puisque c'est à partir de cedécoupage que l'équipe va travailler.

• Se poser la question de la nécessitéd'opérations faites habituellementen mode cycle en V tant d'un pointde vue technique qu'organisationnel(nécessité d'un rapport, d'un docu-ment...).

• Si le projet est en cours et a com-mencé en mode cycle en V, arrêtertoutes les nouvelles tâches de déve-loppement et de spécifications etterminer en testant et intégrant lesfonctionnalités commencées.

Les difficultés qui peuvent être rencontrées lors de la mise en place de scrumSCRUM remet en question :La façon de travailler de l’équipe :• Les fonctionnalités doivent être

exprimées sous forme de besoinsqui ont de la valeur pour l’utilisateuret qui sont adressables en unsprint: trouver le bon niveau de gra-nular ité et le bon découpagedemande de la pratique.

• L'équipe doit être capable de déli-vrer des fonctionnalités avec uncoût de tests, de packaging et dedéploiement acceptables. La miseen place de l'outillage peut nécessi-ter un effort important pour desprojets existants ayant peu ou pasde tests automatisés ou des procé-dures de déploiement manuelles etfastidieuses.

• Des critères d'acceptance doiventêtre définis avant d'adresser lebesoin. L'équipe doit s'habituer àterminer (en accord avec les cri-tères d'acceptance définis) les fonc-tionnalités adressées avant d'encommencer d'autres.

L'organisation de l'équipe :• Il faut faire accepter aux personnes

26-43 20/05/2009 11:12



P our démarrer un projet agileou pour " rendre agile ” unprojet en cours de dévelop-

pement, il faut agir sur les mêmesaxes : organisation spécifique del’équipe, mise en place de l’usine dedéveloppement nécessaire pour lestests, gestion de la configuration detravail itératif, avec comme objectifl’amélioration continue. Définir uneorganisation en début de projet pré-sente bien des avantages: si l’équipechoisie connaît les principes de l’Agili-té elle fonctionnera facilement enmode agile (SCRUM, XP, Lean ouautre mixage opportun de méthodes).Si elle n’est pas encore à l’aise avecles pratiques agiles, elle sera motivéed’explorer des nouvelles voies qui–selon les règles de l’art de l’agilité-devraient valoriser son travail.De la même façon, l’adoption desméthodes agiles en cours de route,est globalement perçue par leséquipes de développement commeune aide à l’amélioration. Sur l’axeorganisationnel, la difficulté la plusfréquente en cas de mise en place del’Agilité sur un projet déjà démarré,est l’intégration des profils préféranttravailler en solitaire.

De la " MOA " au " Product Owner " et des spécifications fonctionnelles au backlogUn acteur majeur dans la dynamiqueAgile est le représentant des utilisa-teurs (Product Owner). C’est lui quiest mandaté pour définir les prioritésmétier et remplir la " feuille de route "

Adopter le mode agile en début d’un projet ou en cours de routeFaire fonctionner un projet informatique en mode agile reflète la volonté decréer une dynamique de travail à la fois efficace et valorisante pour leséquipes impliquées. Quel que soit le moment de la vie d’un projet oùl’Agilité est adoptée, cette décision est un acte novateur, porteur dechangements dans les habitudes des développeurs, des managers, desutilisateurs.

de l’équipe de développement pourchaque nouvelle itération. Il est bienplus facile d’intégrer la nécessité detrouver le profil adéquat comme pré-requis pour un démarrage, qued’identifier ce profil dans un dispositifavec des habitudes de travail instal-lées. Un mauvais casting du ProductOwner peut compromettre un projetAgile. Ce risque est d’autant plusimportant dans le cas de l’agilisationd’un projet existant.Le Product Owner est le responsableet le principal contributeur du conte-nu du backlog. Ce terme SCRUM estune liste non hiérarchisée des fonc-tionnalités simples (" stories "). L’équi-pe de développement, qui interprèteet décline techniquement les fonc-tionnalités, alimente aussi le backlog.Sa constitution est consentie commeun élément d’entrée pour le démarra-ge d’un projet agile, et peut être per-çue comme une surcharge de travailbureaucratique sans bénéfice immé-diat dans le cas de l’adoption de l’agili-té en cours de route. Dans ce 2ecas, le backlog risque de ne pas avoirassez de profondeur et de ne pasdonner assez de visibilité sur l’avance-ment du projet. De leur côté, leséquipes de développement peuventperdre en motivation et confiance,car elles ne peuvent pas se projetersuffisamment dans l’avenir.

Le rythme itératifC’est la pierre angulaire des projetsagiles. Le respect de ce rythme etdes bonnes pratiques énoncées parles méthodes agiles (la stand-up mee-

ting, le TDD, le " Kanban ", etc.) estessentiel. Adopter ces nouvelles pratiques pourun nouveau projet est " naturel ". Eneffet, il est plus facile de définir desrègles du jeu sur " une feuille blanche "que de changer les habitudes et leprocessus de gestion d’un projet encours. Plus le projet est important etle processus mature, plus il sera diffi-cile de changer. A ce moment, unequestion s’impose: pourquoi adopterle mode de fonctionnement agile pourun projet déjà démarré ? Souvent laréponse est liée au dysfonctionne-ment du groupe, un manque de visibi-lité sur l’avancement, une motivationfaible des équipes de développement.Ces dernières subissent une pressionselon des urgences qu’elles ne com-prennent pas. Si le mode urgence estinstauré, la communication entre lesdivers acteurs du projet censés tra-vailler ensemble est faible, voir inexis-tante.

Le Planning Game : unoutil de responsabilisationIl s’agit d’un instrument de régularisa-tion du rythme de réalisation. I lconsiste à définir la liste des fonction-nalités à développer pendant la pro-chaine itération (le " sprint backlog ").Elle est évaluée sur la base d’unecharge de travail soutenable, définiepar l’ensemble de l’équipe, et mesu-rée en " complexité ". Le système deplanification collaborative responsabi-lise l’équipe de développement et lamotive davantage à tenir un engage-ment qu’elle a pris elle-même. Au

26-43 20/05/2009 11:12



contraire, le planning estimé et impo-sé par le management est souventsubi par l’équipe de développement,qui se désolidarise des objectifs qu’el-le estime loin de la réalité du terrain.Adoptée en début de projet ou inté-grée dans un projet en cours, cettepratique est appréciée par les déve-loppeurs, qui ont l’opportunité nouvel-le de remonter régulièrement lesretours " du terrain ". La mécaniquemet en évidence la capacité réelle deproduction.

L’usine de développement,les tests et la qualité logicielleLes principes de l’Agilité s’appuientsur des pratiques (le TDD, l’intégra-tion continue, etc.) à outiller. Pourcela, l’installation de l’usine de déve-loppement est une action clé dudémarrage d’un projet.Qu’est ce que la " Software Factory "doit inclure ? Tout d’abord il faut défi-nir la solution d’intégration continuepour automatiser le build. Le mondeUnix le fait depuis très longtemps, lacommunauté Java a développé Ant etcelle .net, Nant et MSBuild. L’automa-tisation permet d’implémenter deuxpratiques de l’eXtreme Programming :le " commit" quotidien et la construc-tion d’un build " auto-testable ". L’es-sor du TDD (test driven development)a permis de créer des techniquesd’intégration des tests unitaires dansle code. Les serveurs d’intégrationpeuvent gérer les tests automatisésdu monde Java (JUnunit) et .net(NUnit), la construction du build com-prend l’exécution de ces tests. Parmiles plates-formes d’intégration conti-nue les plus utilisées, citons Hudson,Cruise Control, Continuum. Dans ladémarche agile, le contrôle de la qua-lité logicielle passe aussi par l’automa-t isat ion des tests fonct ionnels(recette). La " XU family " met à dis-

position divers outils open source àcet effet : FitNesse, Selenium, Sahi,Greenpepper, etc. Les serveurs d’in-tégration continue peuvent aujour-d ’hui intégrer des out i lsd’automatisation de la recette, maispour cela il faut tenir compte que lamachine de tests automatisés peutêtre utilisée seulement si l’architectu-re de l’application est compatibleavec le codage des tests unitaires. Pour un projet à concevoir, il est pro-bable qu’ i l y a peu ou pas decontraintes d’architecture. Pour unprojet en déroulement, la revue ducode, l’ajout des tests unitaires, etl’installation d’une nouvelle configura-tion de développement, peuvents’avérer complexes. Selon le contexteréel du projet, les réponses aux ques-tions suivantes sont déterminantes :l’application a-t-elle été conçue pourêtre testable ? Le " product owner " a-t-il la possibilité d’assumer la définitiondes tests fonctionnels automatiques ?L’avancement du projet permet-t-ild’absorber l’investissement nécessai-re pour le développement de tests detout type ? Plus le projet est avancé,plus l’effort de " refactoring " du codeexistant - le remboursement de la " dette technique "- risque d’êtregrand. Parfois l’écart entre l’existantet la cible est tellement important quele " refactoring " devient plus coûteuxque la refonte de l’application. Dans cecas extrême, devant un logiciel vrai-semblablement non maintenable, unerevue des objectifs s’impose.

Le travail collaboratif et l’amélioration continueLa mise en œuvre des pratiques liéesà l’amélioration continue est uneautre action clé d’un projet Agile.L’Agilité s’appuie massivement sur " l’intelligence du groupe ". La " pro-grammation en binôme " (coder àdeux), la " programmation par l’équipe "

(toute l’équipe se met autour de latable pour programmer), les testscroisés (les membres de l’équipe tes-tent réciproquement le code) sontdes pratiques qui s’appuient sur laprogression par le retour des pairs. Autres pratiques importantes qui faci-litent l’échange : les points d’analysecommune comme le " Stand-up Mee-ting ", mise au point quotidienne d’unedurée de 10 minutes environ, et la " rétrospective ", réunion régulière(par exemple en fin de chaque itéra-tion) qui permet d’analyser le travaild’équipe et d’identifier les axes d’amé-lioration. Bien sûr, ces activitésdemandent un investissement detemps que parfois ni l’équipe ni lesmanagers ne sont prêts à faire, maisdont à l ’usage, l ’ensemble desacteurs reconnaît les bénéfices. Dansle cas d’un projet qui démarre, définirce type de fonctionnement fait partiedu " plan d’assurance qualité " du pro-jet et il sera accepté, même si la réti-cence sur le " temps passé enréunion " par l’équipe de développe-ment reste présente. A l’opposé, lechangement d’un fonctionnementconnu, impliquant la participation àdes " nouvelles réunions ", est plus dif-ficile à assumer. L’équipe et les lea-ders ne sont pas prêts à renoncer aumode de travail habituel, il a un côtérassurant, car connu, même si unaccord existe sur le besoin d’ac-croître son efficacité. Pour ces rai-sons, il semble judicieux de rendreagile un projet en mode " échantillon "plutôt qu’en mode " Big-bang ". Autre-ment, un phénomène de rejet peuts’installer et mettre en péril la bascu-le Agile.

■ Oana JuncuDirection de Projets - SFEIRwww.sfeir.com

Abonnez-vous à e-2,7 € seulement par numéro au format PDF (pour le monde entier)

et pour0,84 € de plus par mois : abonnement illimité aux archives(numéros du magazine, et articles, en PDF)

Abonnez-vous sur www.programmez.com

26-43 20/05/2009 11:12

26-43 20/05/2009 11:12


S a simplicité et son intégration avec la plate-forme .Netreprésentent les principales raisons de son adoption par ungrand nombre de développeurs à travers le monde. De

plus, on ne manque pas d’outils, il y a des environnements adaptésaux besoins spécifiques des développeurs et des designers, et desmécanismes de collaboration fluides.Silverlight 2.0 partage la technologie de WPF en se basant sur lelangage XAML " Extensive Application Markup Language ". Le langa-ge XAML est un dialecte XML qui peut être utilisé pour spécifier demanière déclarative l'interface utilisateur d'une application Silverlightou WPF. XAML peut également servir plus largement pour repré-senter des objets .NET.Silverlight reprend aussi le modèle ASP.Net en intégrant les fichiersde classe " Code-behind " pour gérer la séparation du code et la pré-sentation. Ces fichiers peuvent être écrits en plusieurs langagesdont C#, VB.NET, Python et Ruby.

Préparez l’environnement de développement1- Visual Studio 2008 SP1 ou Visual Web Developer Express with

SP1 (gratuit).2- Silverlight Tools for Visual Studio 2008 SP1 : extension pour

Visual Studio 2008 SP1 ou Visual Web Developer Express withSP1 qui va mettre à jour Visual Studio.Ajouter le support des projets Silverlight, les runtime de développe-ment, et le SDK.

3- Microsoft Expression Blend 2. Et son Service Pack 2 : Un nouvelenvironnement de développement orienté designers qui permet decréer des interfaces graphiques pour les applications Silverlight 2.

4- Deep Zoom Composer : outil permettant de préparer vos imagespour les utiliser avec la fonctionnalité Deep Zoom.

5- Silverlight Toolkit : projet open source Microsoft project conte-nant des contrôles et des composants Silverlight pour créer desapplications.

Créez votre premier projet SilverlightNous allons utiliser Visual Studio pour créer notre première applica-tion et commencer à explorer Silverlight : [Fig.1]Par défaut, un projet d'application Silverlight nouvellement créécontient un fichier Page.xaml et App.xaml, ainsi que les fichiers declasse code-behind (qui peuvent être écrits en VB, c#, Ruby ouPython) qui y sont associés : [Fig.2]

développement web \\ silverlight


Bien débuter en Silverlight Silverlight gagne du terrain dans le domaine de la création d’applications internet richeset devient une technologie incontournable.

Le fichier App.xaml est généralement utilisé pour déclarer des res-sources, comme les pinceaux (Brush) et les styles qui sont partagésentre les composantes de l'application. La classe code-behind dufichier App.xaml peut être utilisée pour gérer les événements deniveau application - comme Application_Startup, Application_Exit etApplication_UnhandledException.Après compilation, le projet est transformé en fichiers " .xap " asso-ciés à des assemblies .Net standard. Les fichiers " .xap " utilisentl’algorithme de compression zip standard pour réduire la taille detéléchargement de client.Pour héberger et exécuter une application Silverlight 2, vous pouvezajouter une balise <object> dans toute page de HTML standard quipointe vers le fichier .xap. Ce fichier sera alors automatiquementtéléchargé et instancié par le plugin Silverlight du navigateur :

Ajoutez des contrôles utilisateur avec BlendVous pouvez charger le projet créé avec Visual studio avec Expres-sion Blend : [Fig.3]Silverlight offre trois possibilités pour l’agencement des élémentsd’interface : • Le Canvas : Permet le positionnement explicite des contrôles en

utilisant des coordonnées.• Le StackPanel : Permet le positionnement horizontal ou vertical

d’un groupe de contrôles.• Grid : Similaire aux tables Html. Permet le positionnement en

multi-lignes et multi- colonnes.Nous allons utiliser Blend pour créer une grille avec trois lignes ettrois colonnes. Pour cela il suffit de la zone d’édition graphique duconcepteur. L’étape suivante sera de glisser-déposer des contrôlesutilisateurs sous Blend. Et le code XAML associé généré par Blend :(voir listing A)Retournons dans Visual Studio pour ajouter un peu de logique C# ànotre application. Ajoutons un gestionnaire d’évènement click aubouton btnSearch : (voir listing B)

Fig.1 Fig.2 Fig.3

[ ]

44-55 20/05/2009 11:59



Et le code de la méthode btnSearch_Click :

Le Code C# utilisé est des plus simples, mais l’objectif est de monterl’accessibilité des contrôles Silverlight à partir du code et la facilitéde leur manipulation (exactement identique à un développementWinForms ou ASP.NET).

Utilisez les stylesSilverlight offre des fonctionnalités de style similaires aux feuilles CSSpermettant d’encapsuler les valeurs de propriétés de contrôlescomme une ressource réutilisable. Ces styles peuvent être stockésdans des fichiers séparés et seront utilisés dans l’intégralité de notreapplication. Ajoutons un style au fichier App.xaml : (voir listing C)La définition de ce style " Label " peut être référencée dans le restede notre application en utilisant la propriété style : (voir listing D)

Et le résultat :

Changez l’apparence des contrôlesAvec Silverlight la personnalisation de l'apparence standard descontrôles est un jeu d’enfant. L’une des approches est d’utiliser lesstyles pour redéfinir la propriété " Template " qui définit l’apparencestandard d’un contrôle (le bouton par exemple) :

Ajoutons la référence de ce style à notre bouton :

Et le tour est joué :

ConclusionLe précédent exemple nous a permis de faire une rapide introduc-tion au développement Silverlight et à ses outils. Vous pourrez trou-ver des ressources complémentaires sur le site de Silverlighthttp://silverlight.net/ et d’autres contrôles utilisateur plus avancés dansle Silverlight Toolkit : http://www.codeplex.com/silverlight

■ Hassen HARRATHSpécialiste .NET chez IP-Tech, SSII Tunisienne spécialisée dans les développementsinformatiques pour le marché Français (www.iptech-offshore.com).

[ ]

(listing A) (listing C)

(listing D)

(listing B)

44-55 20/05/2009 12:00

avez installé une version plus récented’Internet Explorer sur votre machine-puisque celle-ci fonctionne commeune mise à jour Windows-, vous avezdésormais la possibilité avec ce nou-vel outil d’avoir un aperçu de votresite Internet depuis Super Previewsous le moteur de rendu d’InternetExplorer 6. Bien sûr pour l’accompagner, vouspouvez intégrer d’autres navigateursWeb dans Super Preview [Fig.2]. Dansun premier temps, vous avez à dispo-sition les navigateurs installés survotre ordinateur (Internet Explorer 7ou 8, Firefox et Safari). Mais il estégalement possible de pouvoir relierSuper Preview avec des navigateursprésents sur d’autres machines -comme un Mac- pour bénéficier deleur aperçu dans celui-ci. La naviga-tion entre ces prévisualisations se faitd’une manière instantanée après lechargement de la page du site Inter-net. Il est possible aussi de faire unecomparaison avec une image de votresite Internet, pour correspondre aumieux avec votre maquette gra-phique.

Quelques outils en plusSuper Preview met également à votredisposition quelques éléments dedébogage. Pas de quoi le comparer

Expression Web 3Mix 09 ne nous aura pas beaucoupplus éclairés sur les nouveautés quiseront intégrées dans la prochainemouture d’Expression Web. On peutnéanmoins s’attendre à des améliora-tions sur le support des CSS dans lafenêtre de Design. Silverlight 2 etMVC devraient venir aussi s’ajouter àla liste des technologies supportéespar Expression Web. Il a égalementété dit que le support de systèmes degestion de versions comme MicrosoftVisual SourceSafe, ou plutôt TeamFoundation Server, n’était pas prévu àl’heure actuelle dans la version 3 d’Ex-pression Web. L’une des raisons étantque la priorité a été donnée au sup-port des technologies citées plus haut.Mais rien n’empêche Microsoft derevenir sur certains éléments avant sasortie en version finale. Contre touteattente et malgré le fait qu’ils aient étéfortement sous-entendus lors des ses-sions, ce n’est pas ce genre de nou-veautés qui ont été dévoilées lors del’évènement de Las Vegas. Outre le faitde revenir sur des possibilités déjàexistantes (affichage simplifié desCSS, utilisation de Seadragon Ajaxdans votre site Web, etc.), Microsofta plutôt insisté sur un nouvel outil quifera son apparition dans ExpressionWeb 3 : SuperPreview.



Microsoft Expression Studio 3Dans cet article, nous allons passer en revue les principales nouveautés annoncéespar Microsoft durant le MIX09 qui s’est tenu du 18 au 20 Mars dernier à Las Vegas.Lors de cet évènement, le focus avait été mis notamment sur Expression Web 3 etExpression Blend 3. Pour plus d’informations sur les éléments vus ou cités, je vousinvite à vous reporter aux liens disponibles à la fin de cet article.

Super Preview : un afficheur multi-navigateurL’une des principales nouveautésmise en avant par Microsoft sur laprochaine version d’Expression Webest sans aucun doute Super Preview.Pour expliquer rapidement cette nou-velle fonctionnalité incluse dansExpression Web 3, on pourrait diregrossièrement qu’il s’agit d’un affi-cheur multi-navigateur de site Inter-net, accompagné de fonctions dedébogage très utiles. Super Previewne vient pas remplacer la fenêtre deDesign d’Expression Web, mais c’estune fonctionnalité qui peut être utili-sée en parallèle avec celle-ci. Exami-nons donc plus précisément ce quenous pourrons faire avec [Fig.1].

Aperçus sous divers navi-gateurs locaux ou distantsTout d’abord, comme dit plus haut,celui-ci permet d’avoir un affichagedes pages d’un site Internet sous dif-férents moteurs de navigateur Web.Une des principales qualités de SuperPreview est d’embarquer avec lui uneversion portable d’Internet Explorer 6.En effet, cela permet de bénéficierdes éléments de débogage que pro-pose Super Preview pour les appli-quer sur un site Internet sousInternet Explorer 6. Donc, si vous

Fig.1 Fig.3Fig.2

44-55 20/05/2009 12:00

44-55 20/05/2009 12:00




équitablement avec Firebug ou ledébogueur intégré dans InternetExplorer 8, mais il reprend néan-moins les bases de ces derniers. Lasélection d’éléments, pour les compa-rer entre eux, peut se faire directe-ment depuis les prévisualisations ouencore depuis un arbre DOM du siteInternet visualisé [Fig.3].En effet, Super Preview ne fait pasqu’afficher une prévisualisation, il enreprend aussi les informations géné-rales HTML. En sélectionnant un élé-ment sur la prévisualisation, onretrouve des informations comme :son type de balise, sa position, sesdimensions, sa classe CSS ou son IDdirectement depuis la barre d’état.Parmi ces outils, on peut noter la pos-sibilité d’ajouter une règle autour desvisualisations ou encore d’ajouter desrepères de la même façon que surPhotoshop ou Expression Design.SuperPreview nous donne la possibili-té de visualiser notre site Internetsous différentes méthodes. Cela peutse faire côte à côte, l’une en-dessousde l’autre ou via une superpositiondes prévisualisations.

Quelques limitations égalementDans cette version bêta de SuperPreview, on sent tout de même qu’ilreste encore beaucoup à faire pour laversion finale.Comme indiqué précédemment, seulsFirefox et Safari sont pris en comptepar Super Preview. Qu’en est-il alorsd’Opera ou encore de Chrome ?Microsoft promet néanmoins qu’ilsseront intégrés prochainement danscette fonctionnalité.Un autre point gênant reste que lesfiltres et transitions ne sont pas dispo-nibles sur le moteur d’Internet Explo-

rer 6 présent dans Super Preview.Par exemple, cela ne permet pas detraiter les PNG transparents avecDXImageTransform. On peut égale-ment noter que certains élémentsHTML, comme les balises object,embed et applet, peuvent ne pas êtreaffichés avec les bonnes dimensionssi IE8 n'est pas installé. Une autre uti-lisation de Super Preview, qui auraitpu être d’une très grande utilité,aurait été le support de moteurs derendu de messagerie mail commeOutlook 2007. En effet, Microsoft n’utilise plus lemoteur d’Internet Explorer pour affi-cher les mails HTML dans Outlook2007, ce qui peut générer quelquessoucis d’affichage avec une structureHTML/CSS classique. Il faut cepen-dant souligner que cette version estune Bêta et que des modificationssont encore à venir. Il s’agit là dequelques limitations, mais qui nedevraient pas empêcher Super Pre-view de devenir un outil aussi incon-tournable que Firebug ou encore ledébogueur d’Internet Explorer 8.

Expression Blend 3Les nouveautés annoncées pourBlend sont, quant à elles, beaucoupplus nombreuses que pour Expres-sion Web 3. Outre une interface légè-rement revue mais qui ne changeraen rien vos habitudes, on peut souli-gner la présence d’éléments commele support de Visual Studio TeamFoundation Server ou encore l’ajoutde nouveaux éditeurs XAML, C# etVB, avec notamment la présence oul’amélioration de l’IntelliSense pources langages. Ceci évite désormaisl’emploi de Visual Studio pour profiterde ces fonctionnalités avec ces lan-gages-là.

SketchFlow : Donner vie à vos concepts et vos prototypesSketchFlow vous permet avec uneseule et même application intégrée àExpression Blend 3 de réaliser vosmaquettages ou prototypages. Eneffet, ce nouvel outil permet aux desi-gners de dessiner des esquisses, lesmettre en forme, les simuler, leurdonner vie pour enfin les déployer, etcela d’une façon beaucoup plus inter-active que via PowerPoint ou d’autresméthodes.Avec SketchFlow vous avez la possibili-té de donner de l’interactivité à voscroquis de prototypes car celui-ci per-met à tout moment d’y ajouter descontrôles WPF. Pour faire simple, ilpermet la même chose que ce quevous pouvez faire dans un projet WPFnormal. Et afin de rester dans l’espritde prototype et de maquettage, cescontrôles ont droit à une apparencespécifique se rapprochant d’uneesquisse [Fig.4]. Cela permet de sefocaliser principalement sur le fonc-tionnement de votre application plutôtque de s’attarder sur des détails gra-phiques. Néanmoins, il vous est àtout moment possible de basculerd’apparence depuis les propriétés devos contrôles.Vos esquisses peuvent être lancéescomme une application WPF depuisle SketchFlow Player [Fig.5]. Ce lecteur,inclus automatiquement dans votreprojet de maquettage, donne la possi-bilité à d’autres personnes de navi-guer facilement entre vos différentsécrans. Si vous le souhaitez, des ani-mations peuvent être jouées depuisce lecteur. Cela permet de se faireune idée sur la façon dont les élé-ments interagissent entre eux. Sket-chFlow Player permet aussi à ses

Fig.4 Fig.5 Fig.6

44-55 20/05/2009 12:00



utilisateurs d’ajouter des commen-taires ou des annotations sur les cro-quis de vos écrans. Une foisenregistrés sous forme de fichier,vous pouvez ouvrir ces commentaireset annotations dans votre projetExpression Blend 3.SketchFlow permet d’associer facile-ment des données à vos maquettespour leur fournir plus de contenu. Cesdonnées et leur modèle d’affichagesont éditables de la même manièrequ’un projet WPF de base. Il est inté-ressant de noter que votre projetSketchFlow est exportable sousforme de fichier Word. Durant l’opé-ration d’export, Expression Blend 3vous crée un document complet com-prenant une table de contenu, desimages de vos écrans, les annota-tions associées à ceux-ci, etc.

Créer des comportementset des composants sanscodeExpression Blend 3 introduit désor-mais une bibliothèque de comporte-ments de base pour vos contrôles.Cela permet notamment au graphistede ne pas avoir besoin d’un dévelop-peur pour créer des interactions utili-sateurs. Néanmoins, un développeuraura toujours la possibilité de créerdes comportements supplémentairespour que le graphiste puisse les utili-ser de son côté depuis sa biblio-thèque.Cette nouvelle version d’ExpressionBlend permet aussi une création decomposants beaucoup plus aisée. Eneffet d’un simple clic, vous avez désor-mais la possibilité de créer des com-posants à par t ir d ’é lémentsgraphiques existants. Il introduit parla même occasion la not ion deControlParts : Vous pouvez attribuezun élément graphique comme unepartie de contrôle. Si on prendcomme exemple le Slider, vous pouvezfacilement définir un élément gra-phique existant comme curseur.De ce fait, une nouvelle fenêtre faitson apparition pour vous permettrede choisir simplement un élémentcomme étant une partie du compo-sant. Cette fenêtre vous donne accèsà une liste prédéfinie du composantque vous souhaitez créer. L’élément

choisi adoptera de cette manière uncomportement logique associé à lapartie du composant sélectionnée.

Importer un fichier Adobe Photoshop ou IllustratorUne autre nouveauté qui a déjà pufaire son apparition en partie dans laversion 2 d’Expression Web est l’im-port d’un fichier de type Adobe Photo-shop ou Illustrator. A la différencequ’ici, son utilisation est beaucoupplus poussée et surtout beaucoupplus utile. Dans ce qui suit, je décriraiprincipalement l’import de fichier Pho-toshop car le fonctionnement de l’im-por t de f ichier I l lustrator estglobalement le même que l’import defichier d’Expression Design.Lorsque l’on importe un fichier Photo-shop, Expression Blend 3 permet desélectionner les calques à incluredans les données que l’on désire ajou-ter à son projet [Fig.6]. Il est égalementpossible de créer de nouveauxgroupes d’éléments depuis l’arbores-cence de sélection des calques àimporter. Pour ce qui est du respectdes éléments Photoshop, ExpressionBlend 3 est assez généreux pourcette nouvelle fonctionnalité. En effet,il respecte les calques, leur arbores-cence, leur position, les bitmap, lesformes vectorielles, les textes, lesmasques et les formes ayant un rem-plissage solide ou dégradé. Expres-sion Blend 3 s’occupe aussi degénérer le XAML qui correspond à ceque vous lui avez importé. Pour ce quiest des masques et des formes vec-torielles, dès qu’ils sont importésdans votre projet, ils sont tout à faitmodifiables à votre guise. La manipulation des éléments Photo-shop importés ne diffère pas des élé-ments déjà présents et il vous seraégalement possible de créer descomposants directement depuis unélément ou un groupe d’éléments.Pour pallier au problème de la taillede pixels sous Adobe Photoshop (72DPI) et Expression Blend (96 DPI),celui-ci vous propose de les redimen-sionner si nécessaire. Dans le cas oùdes problèmes de compatibilité seprésentent, il est possible de sélec-tionner un calque qui fusionne l’en-

semble des éléments Photoshop soussa bonne version. Ceci étant dû aufait que certains éléments ne sontpas encore supportés, comme parexemple l’opacité d’un élément ou leseffets de Photoshop. Le but de Micro-soft étant que le support des élé-ments d’un fichier Photoshop soittotal.

Une version Bêta disponiblePour couronner le tout et pour unpoids de plus ou moins 289.4 MB,vous avez désormais la possibilité devous faire une idée de ces nouveautésavec la version Preview d’ExpressionWeb 3 dont le lien est disponible à lafin de cet article. Néanmoins, veuilleznoter quelques petites remarquesavant de vous ruer sur cette versionPreview !Tout d’abord et le plus important àmon sens, si vous ouvrez un projet Sil-verlight 2 dans Expression Blend 3Preview, celui-ci vous demandera àêtre converti en projet Silverlight 3.Une fois ceci fait, vous ne pourrezplus revenir en arrière.Prenez en compte aussi le fait queSketchFlow n’est pas disponible danscette version Preview. Donc, si vouscomptiez voir d’un peu plus près cettefonctionnalité, il vous faudra prendrevotre mal en patience !

Ressources - Internet Explorer 8 : http://www.microsoft.com/ie8/

- Seadragon Ajax : http://livelabs.com/seadragon-ajax/

- Silverlight 3 Bêta : - http://silverlight.net/getstarted/silver-

light3/default.aspx

- Expression Blend 3 Bêta : http://www.microsoft.com/expression/try-

it/blendpreview.aspx

- Expression Studio 2 (Evaluations dis-ponibles) : http://www.microsoft.com/expression/

- Sessions du MIX09 sur Expression :http://videos.visitmix.com/MIX09/Tags/Expr

ession

■ Axel PeterIntégrateur .NET & Web Designerhttp://www.wygwam.comhttp://blogs.codes-sources.com/chronos

44-55 20/05/2009 12:00

Dans cet article nous allons apprendre à :• Rendre une application Silverlight 3 téléchargeable• Détecter si l’application est :

- Installée sur le bureau ou sous navigateur- Online ou offline.

• Récupérer des données à partir du site hôte de l’applicationAvant de commencer, notez que les pré-requis pour cet article sont :• Connaître les bases de la plate-forme .Net• Installer Visual Studio 2008 (dont la version express est gratuite) Attention, installez la version anglaise, les Tools et SDK existent seu-lement en anglais pour l’instant !• Installer les Silverlight 3 Tools et SDK ainsi que les .Net RIA ser-

vices (http://www.silverlight.net/GetStarted/silverlight3)

Bases de l’application• Démarrez Visual Studio 2008• Ouvrez le menu File -> New Project …• Dans la boîte de dialogue " New Project " qui apparaît, choisissez

" .Net Framework 3.5 " et sous le type de projet " Silverlight " : " Silverlight Application " [Fig.1].

• N’oubliez pas de lui donner un nom, dans ce cas-ci : " OutOfBrowser "• Cliquez sur Ok.• Une nouvelle boîte de dialogue apparaît : " New Silverlight Appli-

cation ". Prenez soin de cocher l’option " Link to ASP.Net serverproject ". Cette option activera le lien .Net RIA Services entre l’ap-plication Silverlight et son site ASP.NET host [Fig.2].

• Cliquez sur Ok.• Visual Studio va générer automatiquement toute la structure de la solution.• Dans le fichier MainPage.xaml du projet Silverlight, ajoutez un

texte " Hello World ".

<Grid x:Name="LayoutRoot" Background="White">

<TextBlock>HelloWorld</TextBlock>

</Grid>

Voici le résultat obtenu lors d’un débogage de la solution créée ci-dessus : [Fig.3]



Silverlight 3 envahit aussi le Bureau !Alors que Silverlight 2 ne fonctionnait qu’en mode connecté (en ligne) et à l’intérieur d’unnavigateur, la version 3 de la plate-forme ne respecte plus ces limitations et débarque(enfin) sur le bureau, à l’instar d’un Adobe AIR.

Rendre cette application téléchargeableGrâce au bouton fourni par la plate-formePermettre à vos utilisateurs d’installer votre application sur leursmachines se fait dans son fichier manifeste. Ce fichier se trouvedans le dossier " Properties " de votre application. [Fig.4]. Pour pro-céder, décommentez le nœud " Deployement. ApplicationIdentity ".

<Deployment xmlns="http://schemas.microsoft.com/client/2007/

deployment"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

>

<Deployment.Parts>

</Deployment.Parts>



<Deployment.ApplicationIdentity>

<ApplicationIdentity

ShortName="Out of Browser Silverlight Application"

Title="Window Title of Your Silverlight Application">

<ApplicationIdentity.Blurb>Description of your

Silverlight application</ApplicationIdentity.Blurb>

</ApplicationIdentity>

</Deployment.ApplicationIdentity>

</Deployment>

Ce nœud contient 3 paramètres d’origine :• ShortName : est le nom de l’application, c’est ce nom qui sera uti-

lisé pour les icônes du bureau, les raccourcis, etc.• Title : est le titre de l’application, ce titre sera utilisé en en-tête de

fenêtre par exemple.• ApplicationIdentity.Blurb : est la présentation de votre application.Cependant, un autre nœud est intéressant à ajouter : le nœud " ApplicationIdentity.Icons"

<ApplicationIdentity.Icons>

<Icon Size="16x16">Icons/icon_16.png</Icon>


Fig.1 Fig.2 Fig.3

DÉVELOPPER VOS APPLICATIONSPOUR POCKET PC, SMARTPHONE& TERMINAL MOBILE : FACILE !

Logi

ciel

pro

fess

ionn

el. D

ocum

ent n

on c

ontra

ctue

l. Sup

port

tech

niqu

e gr

atui

t: 15

requ

êtes

sur l

a ve

rsion

en

cour

s de

com

mer

cialis

ation

. . W

INDE

V, W

EBDE

V et

WIN

DEV

Mob

ile so

nt c

ompa

tibles

.

DEMANDEZ LE DOSSIER GRATUIT

44-55 20/05/2009 12:00

WINDEV Mobile 14 est l’environnement dedéveloppement professionnel qui permet de développerjusqu’à 10 fois plus vite les applications sur mobile dontvotre entreprise et vos clients ont besoin: gestion de stock,force commerciale, géolocalisation, saisies médicales, ex-pertises, relevés de terrain, prise de commande temps réel,réglage de chaîne de production, etc...

La puissance et la facilité de développement deWINDEV Mobile 14 permettent un développe-ment complet en quelques journées.

L’environnement est livré complet, le déploie-ment des applications réalisées est gratuitsans redevances (base de données incluse).

Toutes les fonctionnalités d’un AGL profes-sionnel sont offertes. Tousles aspects de la mobi-

lité sont gérés: base de données, accèsdirect, réplication, WiFi, Bluetooth, 3G, Internet,socket, ActiveSync, réseau, J2EE, SMS, RFID, lien avecvotre S.I., codes-barres automatiques...

Vous aussi réalisez vos applications mobiles10 fois plus vite... avec WINDEV Mobile 14.(Logiciel professionnel, Support Technique gratuit*)

Développez 10 fois plus vite

PLATEFORME PROFESSIONNELLE DE DÉVELOPPEMENT (AGL)

Pocket PC, Smartphone, TerminalWindows CE, Windows Mobile

DÉVELOPPER VOS APPLICATIONSPOUR POCKET PC, SMARTPHONE& TERMINAL MOBILE : FACILE !

www.pcsoft.fr

Logi

ciel

pro

fess

ionn

el. D

ocum

ent n

on c

ontra

ctue

l. Sup

port

tech

niqu

e gr

atui

t: 15

requ

êtes

sur l

a ve

rsion

en

cour

s de

com

mer

cialis

ation

. . W

INDE

V, W

EBDE

V et

WIN

DEV

Mob

ile so

nt c

ompa

tibles

.

VERSION EXPRESS GRATUITETéléchargez-la !

Un tableau debord en

temps réel surson téléphone?

Facile !

Nouvelle version

252 pages + DVD + Version Express incluse+ 112 Témoignages.

Tél: 04.67.032.032 ou [email protected]

gicie

l pro

fess

ionn

el

Fournisseur Officiel de la Préparation Olympique

DEMANDEZ LE DOSSIER GRATUITVOTRE CODE ESTMULTI-PLATEFORMES:Windows, .Net, Java,PHP, J2EE, XML,Internet, Ajax, PocketPC, SmartPhone, Client riche ...

44-55 20/05/2009 12:00






</ApplicationIdentity.Icons>

Ces icônes doivent faire partie de la solution Silverlight 3 pour êtreintégrées au fichier .xap qui sera téléchargé par le client [Fig.5]. Unnouveau menu est maintenant disponible sur le clic droit de l’applica-tion : " Install ‘ShortName’ … onto this computer "[Fig.6].

Rendre cette application téléchargeableGrâce à un bouton personnelBien que la plate-forme Silverlight offre un bouton de base pour pro-poser le téléchargement et l’installation d’une application au client,cette interface n’est pas très instinctive pour l’utilisateur lambda.Pour pallier ce problème, il est possible de créer votre propre bou-ton (ou autre action) " télécharger cette application ".• Ouvrez MainPage.xaml dans le projet Silverlight.• Ajoutez-y un bouton.


<StackPanel>

<Button

Name="DownAndInstallBtt"

Content="Télécharger et installer cette application

sur mon pc"

Margin="5"

Click="Button_Click"/>

<TextBlock

Margin="5"

Text="HelloWorld"/>

</StackPanel>

</Grid>

• Ouvrez MainPage.xaml.cs• Ajoutez la fonction " Button_Click " :

public MainPage()

{

InitializeComponent();

}

private void Button_Click(object sender, RoutedEventArgs e)

{

bool allowed = App.Current.Detach();

if (!allowed)

{

MessageBox.Show("L'application n'a pas été téléchargée

sur le bureau.");

}

}

Attention, la fonction App.Current.Detach(); générera une exceptionsi l’application à déjà été installée sur l’ordinateur.

Détecter si l’application est installée sur lebureau ou sous navigateurPour adapter le comportement de l’application à son environnementil est bon de savoir si elle s’exécute dans un navigateur ou si l’utilisa-teur vient de lancer la version qu’il a préalablement installée.• Ouvrez MainPage.xaml dans le projet Silverlight.• Ajoutez une nouvelle zone de texte et nommez-la " WebOrDesk-

TextBox "


<StackPanel>

(…)

<TextBlock

Name="WebOrDeskTextBlock"

Margin="5"

Text="HelloWorld"/>

</StackPanel>

</Grid>

• Ouvrez MainPage.xaml.cs• Dans le constructeur de la page, juste après l’initialisation descomposants, ajoutez ce code :

public MainPage()

{


if (App.Current.RunningOffline)

{

WebOrDeskTextBlock.Text = "Bureau";

}

else

{

WebOrDeskTextBlock.Text = "Navigateur";

}

}

Le booléen App.Current.RunningOffline vous donne cette informa-tion. [Fig.8]. Accessoirement, il est aussi possible de rendre le bouton" télécharger et installer cette application sur mon pc " invisiblelorsque c’est déjà le cas.

public MainPage()

{


if (App.Current.RunningOffline)

{

WebOrDeskTextBlock.Text = "Bureau";

DownAndInstallBtt.Visibility = Visibility.Collapsed;

}

else

Fig.4 Fig.6

Fig.5

44-55 20/05/2009 12:00

Bureau Navigateur

{

WebOrDeskTextBlock.Text = "Navigateur";

DownAndInstallBtt.Visibility = Visibility.Visible;

}

}

Détecter si le pc est online ou offlineDans le même état d’esprit, il est utile de connaître l’état de laconnexion internet de la machine sur laquelle tourne l’applica-tion.Mais dans ce cas-ci, le travail est un peu plus complexe. En effet,cette connexion n’a pas un état statique, il est possible que sonétat change durant l’exécution de l’application. Un évènementest envoyé à l’application par la plate-forme lorsque cela arrive. Ilsuffit donc de s’y abonner et de revérifier l’état de la connexionquand il est lancé.• Ouvrez MainPage.xaml dans le projet Silverlight.• Ajoutez une nouvelle zone de texte et nommez-la " OnOrOff-

TextBlock"• Ouvrez MainPage.xaml.cs• Dans le constructeur de la page, juste après l’initialisation des

composants, ajoutez ce code :

public MainPage()

{


(…)

OnOrOff();

NetworkChange.NetworkAddressChanged +=

new NetworkAddressChangedEventHandler(NetworkChange_

NetworkAddressChanged);

}

void NetworkChange_NetworkAddressChanged(object sender, Event

Args e)

{

OnOrOff();

}

void OnOrOff()

{

if (NetworkInterface.GetIsNetworkAvailable())

{

OnOrOffTextBlock.Text = "Online";

OnOrOffTextBlock.Foreground = new SolidColorBrush

(Colors.Green);

Fig.8

44-55 20/05/2009 12:00




}

else

{

OnOrOffTextBlock.Text = "Offline";

OnOrOffTextBlock.Foreground = new SolidColorBrush

(Colors.Red);

}

}

Lorsque l’ordinateur client perd la connexion internet, l’application leremarque en quelques secondes.

Récupérer des données à partir du site hôte de l’applicationSilverlight 3 et les .Net RIA Services simplifient grandement la viefastidieuse des développeurs. Auparavant, pour consommer desdonnées d’un serveur dans une application Silverlight, la méthode laplus couramment utilisée était de connecter cette application Silver-light à un service WCF (Windows communication foundation) lui-même correctement configuré pour que sa sécurité lui permette dedialoguer avec l’application. *gasp* Rien que de l’écrire, ça fait mal !Aujourd’hui, le paradis nous ouvre ses portes. En effet, il est possiblede créer une communication entre un site ASP.NET et une applica-tion Silverlight 3 qu’il héberge, et ce, en quelque clics, mais tout engardant une grande liberté de configuration. Ainsi, la plate-formenous offre de la simplicité, sans nous faire payer en généricité.• Pour les besoin de la démo, créons rapidement une petite base de

données des employés de Heode dont voici la structure : [Fig.9]• Retournez dans Visual Studio• Cliquez avec le bouton droit de la souris sur le projet " OutOfBrow-

ser.Web " (le site web ASP.NET) • Sélectionnez le menu Add new -> new Item …• Dans la boîte de dialogue " New Item ", sélectionnez le template" LINQ to SQL Classes " et donnez lui le nom : SuperHeroDB.Les classes LINQ to SQL sont un moyen simple et rapide de vousconnecter à une base de données.

• Ouvrez le fichier SuperHeroDB.dbml• Naviguez dans l’explorateur de serveur de Visual Studio jusqu’àtrouver la table SuperHero et glissez-là sur la surface de dessin desclasses LINQ to SQL.• Compilez le projet ASP.NET• Sélectionnez une fois de plus le menu Add new -> new Item …• Dans la boîte de dialogue " New Item ", sélectionnez le template" Domain Service " et donnez lui le nom : SuperHeroService.Un Domain Service est un service de données et d’opérations quisera accessible au site web et à tous ses composants internes.C’est à travers ce service que le site web et l’application Silverlightvont communiquer.• Cliquez sur Ok.• La boîte de dialogue suivante vous demande de sélectionner à quelaccès aux données vous voulez lier le Domain Service. ChoisissezSuperHeroDB, ensuite cochez l’option devant la table SuperHero.[Fig.10]• Cliquez sur Ok. • Compilez la solution au complet.Vos données sont maintenant exposées par le site web aux clientsSilverlight.• Ajoutez la référence System.Windows.Controls.Data à votre pro-jet Silverlight• Ouvrez MainPage.xaml dans le projet Silverlight.• Ajoutez une nouvelle grille de données et nommez-la " MaDataGrid"

<UserControl x:Class="OutOfBrowser.MainPage"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:data="clr-namespace:System.Windows.Controls;assembly

=System.Windows.Controls.Data"

Width="400" Height="300">


<StackPanel>

<data:DataGrid Name="MyDataGrid" Margin="5"/>

(…)

</StackPanel>

</Grid>

</UserControl>

• Ouvrez MainPage.xaml.cs• Dans le constructeur de la page, juste après l’initialisation descomposants, ajoutez ce code :

public MainPage()

{


(…)

SuperHeroContext context = new SuperHeroContext();

MyDataGrid.ItemsSource = context.SuperHeros;

context.LoadSuperHero();

}

Cette méthode passionnante d’accès aux données est bien pluscomplète que le peu que je viens de vous montrer. Pour les lecteursintéressés, je conseille grandement une lecture du document relatifaux .Net RIA Services disponible sur http://www.silverlight.net/GetStar-

ted/silverlight3.

■ Simon Boigelot & Loic Bar - HEODE.com

Fig.9

Fig.10

Les autres options vouspermettent de demander

à la plate-forme degénérer automatiquementtoute l’opération d’édition,

d’insertion et de résolutionde conflits, mais nous n’en

aurons pas besoin danscet exercice.

44-55 20/05/2009 12:01

44-55 20/05/2009 12:01


C ette série d’articles a pour but d’expliquer comment effec-tuer un déploiement d’applications Java sur la plate-formeAmazon EC2. La première étape consiste à préparer votre

compte Amazon pour disposer d’un environnement exploitable. Pourcela, connectez-vous à votre compte et inscrivez vous à EC2 si celan’est déjà fait (http://aws.amazon.com/ec2).Sur le site, cliquez sur l’onglet " Your Account ", puis le lien " AccessIdentifiers ". Notez bien votre " Access Key ID " et votre " SecretAccess Key " car vous en aurez besoin plus tard. Dans la section " X.509 Certificate ", cliquez sur le bouton " Create New " et sauvezsur votre poste les 2 fichiers qui seront générés (cert-XXXXX.pemet pk-XXXXX.pem) dans un répertoire nommé " .ec2 " (attention àbien garder le caractère ‘.’) à la racine de votre compte. Sous Win-dows le plus simple consiste à exécuter les commandes suivantes :

cd %USERPROFILE%mkdir .ec2

Une fois ces fichiers récupérés, installez les outils proposés parAmazon dans le répertoire " .ec2 " précédemment créé : http://develo-

per.amazonwebservices.com/connect/entry.jspa?externalID=351&categoryID=88

Les outils Amazon nécessitent que plusieurs variables d’environne-ment soient initialisées :

set EC2_HOME=%USERPROFILE%/.ec2

set PATH=%PATH%:%EC2_HOME%/bin

set EC2_PRIVATE_KEY=%EC2_HOME%/pk-XXXXX.pem

set EC2_CERT=%EC2_HOME%/cert-XXXXX.pem

Attention à bien remplacer les " XXXXX " par les noms de fichiersque vous aurez récupérés précédemment.Pour vérifier le bon fonctionnement de votre compte EC2, vous pou-vez lancer la commande suivante :

ec2-describe-images –o amazon

Cette instruction liste toutes les images système préparées parAmazon (AMI). Vous allez utiliser l’image Fedora Core 8 proposéepar Amazon (" ami-5647a33f " au moment de la rédaction de cetarticle). Pour vous connecter à la machine, vous devez disposerd’une " keypair " qui véhicule vos accès aux serveurs afin de vouspermettre de vous connecter. Pour cela, lancez la commande :

ec2-add-keypair ma-keypair

Cette commande génère une clé privée de type RSA. Vous devezcopier le résultat affiché (en incluant les lignes -- BEGIN RSA PRIVA-TE KEY - - et - - END RSA PRIVATE KEY-- ) dans le f ichier%EC2_HOME%/ma-keypair. Vous allez maintenant démarrer un ser-veur sur l’infrastructure EC2 (n’oubliez pas que ce faisant, Amazonvous facturera 0.10 $ par heure).

technique \\ cloud


Cloud Computing : déploiement d’applications Java

ec2-run-instances ami-5647a33f –k ma-keypair

Cette commande lance un serveur de type SMALL. Il vous est pos-sible de lancer plusieurs serveurs en même temps ou de spécifier letype de machine à démarrer. Le démarrage d’une machine EC2prend un peu de temps (jusqu’à quelques minutes). Vous pouvezconsulter le statut de la machine via la commande suivante :

ec2-describe-instances

Quand le statut de votre machine indique " running ", elle est prête àl’emploi. Notez l’adresse de la machine (ec2-xx-xxx-xx-xx.compute-1.amazonaws.com) et son identifiant (i-XXXXXXXX).Afin de pouvoir se connecter à ce serveur, vous devez autoriser lesconnections SSH (port 22) et Web (port 80) :

ec2-authorize default –p 22

ec2-authorize default –p 80

Cette commande n’est à faire qu’une seule fois car elle modifie lesrègles du pare-feu nommées " default " en ouvrant les ports 22 et80. Si vous utilisez Putty pour vous connecter via SSH, vous devezconvertir le fichier ma-keypair en un fichier exploitable par Putty.Pour cela, uti l isez l ’outi l " PUTTYgen ". Ouvrez le f ichier%EC2_HOME%/ma-keypair via cet outil et sauvez la nouvelle clé pri-vée. Vous devez en suite définir correctement la clé à utiliser lors dela connexion au serveur (cf http://docs.amazonwebservices.com/Amazo-

nEC2/gsg/2006-06-26/putty.html). SSH vous demandera si vous souhai-tez vous connecter. Tapez " yes " et ce sera chose faite.Maintenant installez le serveur Apache. Puis, démarrez-le :

Vous pouvez maintenant vous connecter via votre navigateur au sitehttp://ec2-xx-xxx-xx-xx.compute-1.amazonaws.com (en remplaçant bien sûrles ‘xxx’ par ceux qui correspondent à l’instance de votre machinetels qu’affichés par la commande ec2-describe-instances). Pensez àbien éteindre votre serveur une fois que vous n’en avez plus besoinvia la commande lancée sur votre machine :

ec2-terminate-instances i-XXXXXXXX

Les articles à suivre expliqueront comment construire sa propreimage Amazon EC2 (AMI) ainsi que comment mettre à jour desapplications sur EC2. Enfin, une fois les premiers déploiements surEC2 effectués, vous verrez comment le projet Open Source ElasticGrid vous permettra de maintenir une application en productionselon des critères de qualité de service (QoS) que vous spécifierez.

■ Jerôme Bernard - Director, EMEA Operations, Elastic Grid, LLC.Site: http://www.elastic-grid.com - Blog: http://blog.elastic-grid.com

1re partie

NE MANQUEZ PAS LE PROCHAIN NUMÉRON°121 juillet-août 2009, parution 30 juin

✔ Développement : Attention le futur est déjà là !

56-57 20/05/2009 11:31

Les outils de la Direction Informatique

Vous avez besoin d’info sur des sujets d’administration,

de sécurité, de progiciel,de projets ?

Accédez directement à l’information ciblée.

L’INFORMATION SUR MESUREActu triée par secteur Cas clients Avis d’Experts

Actus Evénements Newsletter

Infos des SSII

Vidéos

Etudes &

Statistiques

L’INFORMATION EN CONTINU

www.solutions-logiciels.com

56-57 20/05/2009 11:31


E n 1965, Gordon Moore (co-fondateur d’Intel) observaitque le nombre de transis-

tors contenus dans un semi-conduc-teur disponible sur le marché,doublait tous les 18 à 24 mois. C'estde ce constat empirique qu'est née laloi de Moore. En d’autres termes, lescapacités techniques des ordinateurss’amélioraient régulièrement, permet-tant aux programmes informatiques

d'en tirer parti sur leplan de la rapidité d’exé-cution sans grandesmodifications (souventaucune). Ce constat afait le bonheur de plu-sieurs générations d'in-formaticiens, au pointque certains appelaient

ce phénomène le " freelunch ". A cette époque, les fondeursbasaient le plus gros de leur discoursmarketing sur une course au Giga-Hertz, chacun se vantant d’aller plusvite que l’autreDepuis quelque temps, vous avezsans doute remarqué l'apparition deprocesseurs multi-cœurs allant dedeux à quatre cœurs dans les offresconstructeurs grand public. Cepen-dant, vos applications ne tournentsans doute pas plus vite sur ce typede matériel. En effet les systèmesd'exploitation, les applications d'au-jourd'hui ne sont pas adaptés pourtirer parti efficacement d'une archi-

technique \\ multicore


Pourquoi passer à la programmation parallèleA l’occasion de la sortie d’Intel Parallel Studio et des nombreuses avancées que leséditeurs préparent pour 2009 et 2010, Programmez ! vous propose de mieux comprendrela programmation adaptée aux processeurs à plusieurs cœurs. C’est ce que l’on appellela programmation parallèle. C’est- à-dire capable d’exécuter plusieurs opérations,instructions, parallèlement sur plusieurs processeurs ou plusieurs cœurs. Complexe àmaîtriser, le parallélisme est le mont Everest du développement. Nous vous proposons del’aborder méthodiquement en posant les fondamentaux pour bien l’assimiler et éviter leserreurs les plus classiques. Vous verrez alors que l’on peut faire exploser lesperformances de certaines portions de son code ! Bonne découverte !

■ François Tonic

tecture multi-cœur. Autrement dit,cette évolution matérielle n'est pasforcément vécue comme un gainimportant par les utilisateurs.

Pourquoi les fondeurs ont-ils changé de paradigme ?Depuis quelques années les construc-teurs ont été confrontés à descontraintes physiques fortes (chaleur& consommation) qui ne permet-taient plus d'améliorer leurs offres enrestant sur les mêmes bases tech-niques. Par exemple, Intel avait préditdès 2006 que la température de sespuces reposant sur la microarchitec-ture Netburst (Pentium IV) atteindraitenviron 6000 degrés en 2015, soitenviron la température à la surfacedu soleil. Ne pouvant plus croître surle plan des Hertz, les constructeursont choisi de répartir la puissance surplusieurs cœurs au sein d'un mêmeprocesseur (architecture multi-cœur).La course aux Hertz est donc termi-née, place à la course au nombre decœurs ! Dès aujourd'hui, lesconstructeurs de microprocesseursdisposent de nouvelles plates-formessachant grandir faci lement ennombre de cœurs tout en améliorantles performances de l'infrastructureinterne du processeur lui-même. Letout dernier processeur Intel Core i7(Nehalem) rencontre déjà un francsuccès auprès de constructeurs d'or-

1re partie

dinateurs. Les ordinateurs de demainseront donc massivement multi-cœurs (supérieur à 8 cœurs), lesaméricains parlent du passage duMulti-core au Many-core, ce qui peutsembler une bonne nouvelle.

Les systèmes d'exploitation sont déjà en cours d'adaptationDe leur côté, les éditeurs de sys-tèmes d'exploitation sont conscientsque leurs produits ne sont plus adap-tés pour exploiter correctement cesnouvelles architectures matérielles. Les prochains systèmes profiterontde ces nouvelles offres qui aujourd'huipeuvent sembler exagérées au regarddes besoins actuels, mais n'oublionspas que le monde change et que lesprogrès techniques ont toujours étéporteurs d'innovations qui aujourd'huinous apparaissent normales. A titred’exemple, dans sa version 64 bits, leprochain système Windows seracapable de gérer pleinement 256cœurs. Nous comprenons mieux aveccet exemple la nouvelle appellationMany-core pour qualifier des maté-riels regorgeant de cœurs.

The free lunch is overDès 2005, Herb Sutter, célèbrearchitecte C++ de Microsoft, annon-çait "The free lunch is over". Autre-ment dit, les gains de performancesde vos applications constatés sur les

Windows 7 en 64bits sera pleinementcapable de gérer256 cœurs.

12-14 outils 20/05/2009 11:37



{

get

{

return ++_status;

}

}

}

Si de nombreux threads appellentsimultanément cette propriété, l'exé-cution se déroulera souvent correcte-ment mais parfois l'incrémentationsera fausse lorsque les threads sechevaucheront sur l'instruction d'in-crémentation. De nombreux dévelop-peurs imaginent que l 'opérateurd'incrémentation est atomique alorsqu'il n’en est rien comme le montre lecode assembleur.

MOVE EAX, [_status]

INC EAX

MOVE [_status], EAX

Le danger est que cette erreur estsilencieuse et il est possible que per-sonne ne la relève avant longtemps.Imaginez le cas où notre valeur repré-sente le prix d'un produit financier, lesconséquences pourraient êtregraves. La race condition, est sansdoute l'erreur la plus populaire dansla programmation parallèle.Pour corriger notre code il nous suffitde remplacer notre opérateur d'incré-mentation par une méthode InterLoc-ked.Increment(ref _status) qui nousassure une exécution atomique.Cependant, les ressources à proté-ger ne sont pas toujours des entiers,mais sont souvent des types com-plexes. Dans ce cas, nous feronsappel à un outillage de synchronisa-tion plus polyvalent. En contrepartie,ces outils peuvent occasionner denombreux problèmes qui aboutissentparfois à des codes parallèles pluslents que leurs équivalents séquen-tiels. Voici d'autres exemples souventrencontrés dans le cadre la program-mation parallèle.La suite le mois prochain.

■ Bruno Boucard [email protected] Spécialisé dans les technologies Microsoft,il anime avec d'autres spécialistes le blogDéveloppement parallèle de Microsofthttp://blogs.msdn.com/devpara/default.aspx

nouveaux matériels sont terminés.C'est donc aux développeurs de révi-ser leurs codes pour retrouver de lapuissance. Dans ce contexte, pou-vons-nous affirmer que le " free lunch "est définitivement révolu ? Pourenrayer cette catastrophe, devons-nous engager une révision radicaledans nos pratiques de développement ?

Conséquences pour les développeursPourquoi peu de développeursconnaissent la programmationparallèle ? Pour les développeurs, laprise en compte effective de ce chan-gement technologique peut se révélertrès compliquée. Rappelons qu'il y adéjà une petite vingtaine d’années queles techniques de multithreading sesont intégrées dans un écosystèmefortement séquentiel. Néanmoins, les détracteurs du paral-lélisme peuvent trouver de nom-breuses raisons pour ne pass'adapter à cette nouvelle donne. Laculture séquentielle à l’origine de l’in-formatique peut être considéréecomme la plus légit ime. Noussommes aussi certains que le cer-veau humain éprouve des difficultés àraisonner en multitâche ce qui peutêtre vu comme un frein pour le passa-ge en mode parallèle. Aujourd’hui, nous pouvons recon-naître que les environnements deprogrammation comme les outils, leslibrairies, offrent peu d’adhérenceavec ces concepts. Alors, comments’assurer que la mise en parallèle decertaines parties du système est à lafois fiable et pertinente vis-à-vis dulangage de programmation et de l’in-frastructure matérielle ? Définir aveccertitude que les notions d’isolation,d’immuabilité ou de synchronisationsont correctement exprimées vis-à-visdu problème posé au regard des envi-ronnements, des langages, desoutils, sont des préoccupationsessentielles que nous abordons diffici-lement, faute d’un outillage adapté.Dans le cas des langages C et C++ oùl’héritage d’une culture séquentiellese comprend facilement (le langage Cest issu d’une philosophie très systè-me inspirée par la plate-forme UNIX

AT&T originelle où la notion de multi-threads n’existait pas) mais dontl’adaptation au multithreading estvenue se superposer à un existantséquentiel donnant lieu à un jeu d’APIrudimentaires difficilement compré-hensibles pour le développeur nonsystème. Initialement, la notion dethread à été introduite pour offrir auxdéveloppeurs un moyen de paralléli-ser du code sans avoir à créer plu-sieurs processus systèmes (trèscoûteux sur le plan des ressources dusystème d'exploitation). On constateavec le recul que de nombreux envi-ronnements se sont inspirés desinterfaces vétustes originelles, pla-çant le multithreading au rang destechnologies réservées aux experts.

Les principaux écueils de la programmationparallèle ?Après 20 ans de multithreading,nous pouvons reconnaître que lesmodèles parallèles sont à la fois peurépandus, peu connus, et difficiles àimplémenter. Pour un novice en déve-loppement parallèle, Il est très facilede provoquer de nombreux pro-blèmes potentiels sans forcément lesconstater. En effet, l'exécution parallè-le ne nous offre pas de certitude surl'ordre d'exécution des instructionsassociées aux threads courants : leprincipe d'incertitude énoncé par Hei-senberg défini en physique quantiqueà été renommé Heisenbug pour quali-fier ce principe en informatique. End'autres termes, toute ressource par-tagée par plusieurs threads doit fairel'objet d'une protection, sinon gareaux incohérences des résultats. Pourillustrer la dimension des difficultésrencontrées, nous pouvons citer leserreurs les plus courantes en pro-grammation parallèle :Race conditionLe code C# ci-dessous, pourtant trèssimple est tout de même faux dans lecas où la propriété Status est plongéedans plusieurs threads parallèles.

public class StatusManager

{

private int _status;

internal int Status

12-14 outils 20/05/2009 11:37

Le parallélisme se conçoit à plu-sieurs niveaux, mais celui quinous intéresse ici est le " thread ".

Intel Parallel Studio est un ensemble delogiciels pour vous aider à introduire dumulti-threadisme dans votre logiciel,corriger les éventuels bugs parallèleset enfin améliorer la performance. Enpratique, Parallel Studio se présentecomme un ajout à Microsoft Visual Stu-dio avec lequel il est fortement intégré.

Introduire du multi-threadismeLa première étape est l’ajout de sec-tions parallèles dans votre code. Choixcornélien tant les technologies propo-sées sont variées. Intel recommandeet fournit une très bonne implémenta-tion d’OpenMP et de la librairie Threa-ding Building Block. Le standardOpenMP est le bon choix pour les pro-grammeurs orientés C qui préfèrentgarder un style sériel et minimiser leschangements de code. La librairie TBBest, elle, destinée aux adeptes du C++qui ne sont pas contre une incursiondans la programmation fonctionnelle.Avec ces deux solutions vous devriezpouvoir résoudre une grande partie devos besoins. Une fois la méthode choi-sie, paralléliser une partie simple devotre code est étonnamment rapide.Mais il ne s’agit que d’un début.



rez aussi savoir quel temps est prisdans la synchronisation d’une variablepartagée.

Compilateur et IPPIntel Parallel Studio a beau mettre enavant ses logiciels de parallélisation, ilfournit aussi tout ce qui est nécessai-re pour obtenir la meilleure perfor-mance en sériel avant même deparalléliser. L’outil clé est le compila-teur Intel. Bien intégré dans VisualStudio il est le fruit d’une intense colla-boration avec les architectes proces-seurs. Nul autre compilateur ne saitmieux tirer parti des derniers jeuxd’instructions. Apprenez la significa-tion des principaux flags et vousgagnerez à coup sûr, sur le tempsd’exécution. Le compilateur Intel nerespecte pas seulement le standard,il le devance. Ainsi vous trouverez lesupport pour les fonctions lambda etautres innovations syntaxiques dansla dernière version. Il serait triste deconsacrer du temps à l’optimisationde votre code et d’utiliser par ailleursdes librairies peu performantes.Aussi Parallel Studio est fourni avec lalibrairie Intel Performance Primitives.Derrière ce nom se cachent en faitdes codecs audio ou vidéo ultra opti-misés, des fonctions d’imagerie parpipeline, de cryptographie, mathéma-tiques … et bien d’autres.

ConclusionLes concepteurs de Parallel Studioavaient pour ambition de démystifier etsimplifier la programmation parallèle.Je pense qu’ils ont réussi. Jugez enpar vous-même avec la version d’essai.

■ Paul GuermonprezIngénieur logiciel - Intel

Chasser les bugsAvec la programmation parallèleapparaissent des bugs spécifique-ment parallèles. Ils sont sournois etcomplexes à tracer. Il est alors trèsutile d’avoir un outil comme ParallelInspector. Cet outil instrumente etanalyse de manière extrêmementavancée l’exécution de votre logicielpour trouver des bugs, et ce mêmes’ils ne s’exécutent pas dans lesconditions particulières du test. Lerésultat est un simple tableau trèscomplet pointant vers les bugs dansvotre code. Il faut cependant com-prendre quelles sont les classes debugs parallèles pour pouvoir com-prendre les indications et corriger.Les bugs parallèles sont certes sour-nois mais ils ont souvent le mêmemécanisme et des causes similaires.Les corriger est donc souvent simpleune fois que l’outil les a pointés.

La touche finaleVous avez un logiciel parallèle, bravo,mais en pratique encore faut-il qu’ilutilise correctement tous ces mer-veilleux cœurs. Dans une équipe,ajouter des développeurs ne sert quesi la méthode de travail permet unpartage efficace du travail. Pour vousaider à comprendre comment fonc-tionne votre logiciel en parallèle, Intelpropose Parallel Amplifier.Cet outil mesure comment chaqueinstruction de votre logiciel interagitavec le processeur à une échelle infi-me lors de l’exécution, puis agglomè-re les données pour en faire unrésumé simple. Vous pouvez alorstrouver les régions chronophages enallant jusqu'à l’échelle de la ligne decode, et les régions qui n’utilisentqu’une partie des cœurs. Vous pour-

Version finale

La programmation est l’art de schématiser et simplifier un processus pourl’automatiser. Nous aboutissons donc le plus souvent à un code sériel. Avec l’arrivée depuces multi-core, et bientôt massivement multi-core cette approche atteint ses limites :Il vous faut passer à la programmation parallèle. N’ayez crainte, Intel est là pour vousaider avec un ensemble logiciel aussi convivial que complet : Intel Parallel Studio.

Sur le CD du numéro !

Intel Parallel Studio débarque

12-14 outils 20/05/2009 11:37

■■ M. ■■ Mme ■■ Mlle Entreprise : ........................................................................................ Fonction : ...................................................

Nom : ........................................................................................ Prénom :....................................................................................................................................

Adresse : .........................................................................................................................................................................................................................................

Code postal : ............................................... Ville : ...................................................................................................................................................................

Tél : ........................................................................................ E-mail : ....................................................................................................................................

■■ Je joins mon règlement par chèque à l’ordre de Programmez ! ■■ Je souhaite régler à réception de facture

A remplir et retourner sous enveloppe affranchie à :Programmez ! - Service Abonnements - 22 rue René Boulanger - 75472 Paris Cedex 10.

[email protected]

3:HIKONB=ÛZ^Z]:?k@b@l@b@a;M 04319 - 111 - F: 5,95 E

grammez!PRO

Spécial

PHP■ Les nouveautés PHP 5.3

■ Créer son moteur de template en PHP 5

■ UML et PHP : le duo d'enfer

■ PHP et la programmation parcomposants

L e m a g a z i n e d u d é v e l o p p e m e n tmensuel n°111 - septembre 2008

www. programmez.com

Comment ça marche ? Les outils, les technologies disponibles Coder pour l'iPhone 2.0 Au coeur du e-lab de Bouygues

Les Jeux Olympiques du développement !ImagineCup révèle les nouveaux talents

GoogleIntégrer Google Maps et JSF

MozillaCréer votre extension XULpour Firefox !

Multicœur■ Programmer vos cœurs

avec OpenMP■ La charge processeur

avec WMI

300 licencesÀ GAGNER

L’équipe The Shads,

de l’Epita ABC Project

ENFIN DISPONIBLE !

La Révolution du

MULTI-TOUCHMULTI-TOUCH

Nouvelle Formule

EXCLUSIFLes révélationsdu livre chocgrammez!


mensuel n°112 - octobre 2008

tech

niqu

e SQL Server2008Découvrez le ResourceGovernor

iPhone / .netPiloter votre Windows Media Centeravec iPhone

FlashMaîtriser le bitmap avecActionScript 3

Et aussi :Linux : Développer des extensions Nautilus

Numéro Spécial 10 ans !Nouvelle Formule

Le matchEclipse - NetbeansChoisir l’outil idéal !Les dernières versions comparéesTout savoir sur Eclipse 4.0

Exclusif ! Vers Microsoft 3.0

Les projets secretsde Microsoft

EnquêteVos langagesfavoris

Chrome et les développeursLe Google Developer Day !

JavaAspectJ :La programmation par aspect facile !

JavaSpaces : Créer votre grid computing

Jeux :Développer des jeux en Java

3:HIKONB=ÛZ^Z]:?k@l@b@c@a;M 04319 - 112 - F: 5,95 E


PROwww. programmez.com


mensuel n°118 - avril 2009

PROwww.programmez.com

ServeurTerracotta : simplifiez-vous le cluster

+GPUMaîtriser la puissance de Cuda

Coding4funFaites parler vos applications avec MS Speech !

Open SourceLes fondamentaux de PHP 3:HIKONB=ÛZ^Z]:?a@l@l@i@a;

M 04319 - 118 - F: 5,95 E


PROG

RAM

MEZ

!

grammez!Plongée au cœur des MozillaLabs

Tout ce qu’il faut savoir pour

DéveloppersurLinux• Maîtriser les standards :

LSB, AppChecker

• Développer vos premières applications

• Les développeursen parlent

• Faire carrière dansl’Open Source

• Mon code sourceest-il légal ?

Web 2.0Comment choisir

son framework Ajax ?

UMLLe futur de la modélisationCe que prépare Microsoft avec OSLO

OutilWinDev : l’atelier

de développement à tout faire

© John Schreiner/illustrationOnLine.com

OUI, je m’abonne

11 numéros par an : 49 €*

Economisez 16,45 €*

Vous pouvez vous abonner en ligne et trouver tous les tarifs www.programmez.com

PROGRAMMEZ avec Accès 10 jours à la Bibliothèque Numérique des Éditions ENI ! (offre limitée)■■ Abonnement 1 an au magazine : 49 € (au lieu de 65,45 € tarif au numéro) Tarif France métropolitaine

■■ Abonnement Intégral : 1 an au magazine + archives sur Internet et PDF : 59 € Tarif France métropolitaine

■■ Abonnement Etudiant : 1 an au magazine : 39 € (joindre copie carte étudiant) Offre France métropolitaine

Choisissez votre Bouquet de la Bibliothèque Numérique : ■■ Développement ■■ Microsoft ■■ Open Source

PR

OG

12

0

Offre limitée, valable jusqu’au 30 juin 2009

Le renvoi du présent bulletin impliquepour le souscripteur l'acceptationpleine et entière de toutes lesconditions de vente de cette offre.

Conformément à la loi Informatique etLibertés du 05/01/78, vous disposezd'un droit d'accès et de rectificationaux données vous concernant. Par notre intermédiaire, vous pouvezêtre amené à recevoir des propositionsd'autres sociétés ou associations.Si vous ne le souhaitez pas, il voussuffit de nous écrire en nous précisanttoutes vos coordonnées.

✁

ACCÈS ILLIMITÉ aux ARCHIVES du MAGAZINE pour 0,84€ par mois !Cette option est réservée aux abonnés pour 1 an au magazine, quel que soit le type d’abonnement (Standard, Numérique, Etudiant). Le prix de leur abonnement normal est majoré de 10 € (prix identique

pour toutes zones géographiques). Pendant la durée de leur abonnement,ils ont ainsi accès, en supplément, à tous les anciens numéros et articles/dossiers parus.

+ Abonnement INTÉGRAL

* au lieu de 65,45€ prix de vente au numéro, Tarif France métropolitaine

grammez!PRO L e m a g a z i n e d u d é v e l o p p e m e n t

EN CADEAUAccès illimité de 10 jours à la Bibliothèque Numérique des Editions ENIA choisir parmi les Bouquets : Consultez : www.eni-bibliotheque.fr• Développement : Plus de 30 livres numériques disponibles, de ADO.Net 3.5 à Flex• Microsoft : Plus de 30 livres numériques disponibles, de Windows Server 2008 à Silverlight• Open Source : Plus de 20 livres numériques disponibles, de Nagios à Java EE

Pour tout abonnement au magazine Programmez un accès de 10 jours à laBibliothèque Numérique de votre choix vous est offert. Offre limitée aux 1000 premiers souscripteurs.

■ Abonnement 1 an au magazine : 49 €(au lieu de 65,45 € tarif au numéro) Tarif France métropolitaine

■ Abonnement Intégral : 1 an au magazine + archives sur Internet et PDF : 59 € Tarif France métropolitaine

■ Abonnement PDF / 1 an : 30 € - Tarif uniqueInscription et paiement exclusivement en lignewww.programmez.com

■ Abonnement Etudiant : 1 an au magazine : 39 €(au lieu de 65,45 € tarif au numéro) Offre France métropolitaine

Choisissez votre formule Inclus : accès à la Bibliothèque Numérique !

OFFRE LIMITÉE

SAVOIR c’est POUVOIR !

61 abo 20/05/2009 11:38

code \\ patron


Comme nous le savons, lesDesign Pattern, ou modèlede conception, sont desl ignes directr ices, desbonnes pratiques destinées

à rendre plus simple et plussûre la programmation objet. Ces bonnes pratiques ont été définiespar des programmeurs expérimentés en POO et qui se sont aperçusque fondamentalement le programmeur objet doit sans cesserésoudre les mêmes problèmes. Les Design Pattern sont répartisen catégories : comportement, structuration et création d'objets.Nous abordons aujourd'hui un modèle classé dans la catégorie créa-tion d'objets en nous appuyant sur le langage Java. Il est indéniableque le programmeur objet est en permanence en situation de créerdes objets. Mais en quoi est-ce un problème ? Nous disposons pourcela de l'opérateur new (ou équivalent selon le langage). Nous utili-sons cet opérateur, les objets sont créés et le tour est joué! En théo-rie oui c'est aussi simple que cela. Et dans les cas très simplesl'approche convient très bien. Mais dès qu'une application devient neserait-ce qu'un peu compliquée, l'utilisation de l'opérateur new au"coup par coup" conduit à un code spaghetti, difficile à maintenir, ceque théoriquement le paradigme objet devrait éviter et non générer.Tel est le but des Pattern Fabrique et Fabrique Abstraite: rationali-ser la création d'objets et donc l'emploi de l'opérateur new.

1 SIMULONS UN WARGAME Pour apprécier les atouts du Pattern Factory, nous reprenons l'idéedu wargame fictif qui nous a déjà servi pour les Pattern Observateuret Stratégie dans Programmez! 93 et 94 respectivement. Par war-game nous voulons parler de ce type de jeux en temps réel où lejoueur clique sur des unités combattantes pour leur assigner uneaction. Toutes les interfaces de ce type de jeux présentent une zonesur laquelle on clique pour déclencher la création d'unités combat-tantes en fonctions des ressources dont on dispose. Vous l'avezcompris, créer des unités combattantes, c'est du point de vue de laPOO, instancier des classes, ou si l'on préfère, fabriquer des objets.Une occasion toute trouvée de mettre en oeuvre notre Pattern

2 UN PREMIER JETMais avant cela, faisons comme si nous ne connaissions pas l'exis-tence des Design Pattern et codons à l'instinct, sans trop deréflexion préalable. Nous avons des unités combattantes avec desfonctionnalités communes, nous faisons donc dériver celles-ci d'uneclasse commune baptisée Entité. (Et encore, déjà il faut se méfier de

Comprendre les Design Pattern Fabriqueet Fabrique AbstraiteTous les langages à objet disposent d'un opérateur new, ou équivalent, pour créer desobjets. Fort pratique en apparence, cet opérateur recèle des problèmes dont les PatternFabrique et Fabrique Abstraite permettent de s'affranchir.

cette approche comme vous le savez. Ou si vous l'avez oublié, peutêtre apprécierez vous de relire Programmez! n° 94 :) Nous décla-rons seulement deux classes, Soldat et Tank, c'est amplement suffi-sant pour notre propos. Ensuite nous avons un panneau de jeu, surlequel se déroule la bataille qui présente l'interface de générationdes unités. Faisons simple et admettons que lorsque le joueur cliquesur cette interface, la méthode creerEntite du panneau est invo-quée. Enfin nous avons la classe JeuBasic, qui représente le jeu lui-même. Voici l'implémentation de notre mini cahier des charges. Unwargame totalement fonctionnel :)

package sanspattern;

import java.util.Vector;

enum TypeEntite {

TYPESOLDAT,

TYPETANK,

}

class Entite {

protected String categorie;

protected int pv; // Points de vie

Entite() {

init();

}

public void init() {

categorie = "Entite";

pv = 0;

}

public void display() {

System.out.println(categorie + ", pv: " + pv);

}

public void action() {}

}

class Soldat extends Entite {

//voir sources sur notre site

}

class Tank extend Entite {

//voir sources sur notre site

}

APPLICATION : PATRON

LANGAGE : JAVA

SOURCE : OUIDIFFICULTEMOYENNE

FORUM dialogue et assistance www.programmez.com

62-65 Code Design Pattern 20/05/2009 11:40


code \\ patron

class PanneauJeu {

Vector<Entite> pieces = new Vector<Entite>();

public void creerEntite(TypeEntite type) {

switch(type) {

case TYPESOLDAT:

pieces.add(new Soldat());

break;

case TYPETANK:

pieces.add(new Tank());

break;

default:

break;

}

}

public void jouer() {

for(Entite e : pieces) {

e.display();

e.action();

}

}

}

public class JeuBasic {

public static void main(String[] args) {

PanneauJeu pj = new PanneauJeu();

// Ici le joueur clique sur l'interface

// et crée des entités

pj.creerEntite(TypeEntite.TYPESOLDAT);

pj.creerEntite(TypeEntite.TYPETANK);

// puis le jeu se déroule

pj.jouer();

// et ainsi de suite

}

}

3ANALYSE DU CODE ET INVENTAIREDES PROBLÈMES

Commentons notre code, qui s'il est écrit d'une manière naturelle,est très mauvais :) Commençons par les classes des unités combat-tantes. Chacune comporte trois méthodes en plus du constructeur.La méthode init comme son nom l'indique initialise les membres dela classe, la méthode display s'occupe de l'affiche de l'unité et laméthode action s'occupe de l'action de l'unité au plus fort de labataille. Déjà nous remarquons du code redondant. Le corps de laméthode display est trois fois le même. Ne riez pas, pareille horreurs'est déjà vue en situation réelle. Et si ceci ne concerne pas directe-ment notre Pattern Fabrique, nous constaterons que la mise enoeuvre de celui-ci contribue à éradiquer ce défaut. Ensuite, laméthode init. A chaque fois son corps contient ce qui est nécessaireà l'initialisation de l'objet. C'est logique, direz-vous, qu'un objet saches'initialiser. Oui, c'est logique. Mais c'est une logique. Il n'est pas obli-gatoirement requis qu'il en soit ainsi. Enfin la méthode action, dansla classe Entité, n'est qu'une coquille vide. C'est peu élégant. Regar-dons maintenant la classe PanneauJeu. Sa méthode jouer n'appellepas de commentaire. Sa méthode creerEntite est une suite de tests

sur le type de l'unité à créer. Lorsque le type est trouvé, l'unité estcréée via l'opérateur new.Ce code semble tout à fait convenable, et pour notre exemple trèssimple il l'est. D'ailleurs pour les cas très simples à peu près toutconvient. Mais les choses se gâtent sérieusement pour les situationsnon triviales, ce qui en informatique pratique sont les seules situa-tions que l'on rencontre. Ensuite il y a les deux ennemis jurés dudéveloppeur: le chef de projet et le client :) Ennemis parce qu'à coupsûr ils vont demander une modification du code. De mémoire decodeur le contraire ne s'est jamais vu. "Le jeu serait enrichi si onavait des entités camion" dit le chef de projet. Pour faire face à cettemodification il suffit d'ajouter un test sur le type. On s'en tire encorefacilement. Mais voilà que le client dit : " je voudrais avoir deux zones,sur lesquelles cliquer pour créer des unités soit terrestres soit mari-times et je voudrais avoir aussi trois niveau de jeux, des panneaux dejeu différent autrement dit, utilisant a priori leur ensemble propred'unités ". Ca y est, cette fois nous sommes fichus ! Nous nousretrouvons potentiellement avec 6 méthodes creerUnite à gérer. Etle chef de projet revient: "Nous avons oublié les sous-marins!". Modi-fier le code de 6 méthodes qui font sur le fond la même chose,créer des entités, est pénalisant. Beaucoup de travail, du tempsperdu, sans doute du code à la fois redondant et difficile à maintenir,et une forte probabilité de bugs sont les ennuis qui nous guettent.Tout cela, fondamentalement, parce que la classe PanneauJeu n'estpas découplée des classes Entité. Il est maintenant clair que nousdevons rationaliser nos créations d'entités, et nous le faisons aumoyen du Pattern Fabrique simple.

4 LE PATTERN FABRIQUE Son but est de déléguer la création d'objet à une ou plusieursclasses dont ce sera le seul rôle. Lorsqu'il y a plusieurs classescelles-ci seront utilisées selon le contexte ainsi que nous le verronsplus loin. Voyons d'abord le bien fondé d'une classe unique, ce quicorrespond au Pattern Fabrique Simple. Nous commençons parassainir les unités qui dériveront d'une classe abstraite, et danscette classe nous factorisons le code redondant de notre premierexemple. Ensuite nous créons notre fabrique qui dans l'exemple ci-dessous est la classe... SimpleFabrique.

package demofactorypattern;

import java.util.Vector;

enum TypeEntite {

TYPESOLDAT,

TYPETANK,

}

abstract class Entite {

protected String categorie;

protected int pv; // Points de vie

public void init(String categorie, int pv) {

this.categorie = categorie;

this.pv = pv;

}

public void display() {


code \\ patron


System.out.println(categorie + ", pv: " + pv)

}

abstract public void action();

}

class Soldat extends Entite {

@Override

public void action() {

System.out.println("Action soldatesque");

}

}

class Tank extends Entite {

// voir sources sur notre site

}

class SimpleFabrique {

Entite creerEntite(TypeEntite type) {

Entite e;

switch (type) {

case TYPESOLDAT:

default:

e = new Soldat();

e.init("Soldat", 10);

break;

case TYPETANK:

e = new Tank();

e.init("Tank", 500);

break;

}

return e;

}

}

class PanneauJeu {


SimpleFabrique fabrique = new SimpleFabrique();


pieces.add(fabrique.creerEntite(type));

}



e.display();

e.action();

}

}

}

public class JeuSimpleFabrique {


System.out.println("Demo Simple Factory");

PanneauJeu pj = new PanneauJeu();

// Ici le joueur clique sur l'interface


pj.creerEntite(TypeEntite.TYPESOLDAT);

pj.creerEntite(TypeEntite.TYPETANK);


pj.jouer();


}

}

Maintenant le panneau de jeu et les entités sont découplés. Unmême panneau instanciera aussi bien une horde de barbares quedes soldats du futur, selon la fabrique à laquelle il déléguera les ins-tanciations, fabrique qui peut très bien être passée en argument auconstructeur du panneau. Un autre atout de cette création centrali-sée apparaît maintenant avec la méthode init. En effet si celle-cin'avait pas grand sens dans le premier exemple, on voit maintenantque les classes entités elles-mêmes n'ont plus besoin de connaîtreles attributs. Notre fabrique pourrait bien à son initialisation lire uneseule fois un fichier de configuration contenant toutes les données,ce qui est plus rationnel que de voir le constructeur de chaque clas-se Entite faire ce travail, à chaque instanciation. Enfin si nousdevons ajouter un type d'entité, le seul code à modifier est celui de laméthode creerEntite de notre fabrique.

5UNE VARIANTE AU PATTERNFABRIQUE

Dans notre exemple nous utilisons une seule fabrique, alors plutôtque d'instancier celle-ci, pourquoi ne pas déclarer statique sa métho-de creerEntite ? Cela existe. Les Pattern sont une ligne directricequ'il faut savoir adapter au cas particulier. La classe BorderFactoryde la JDK est un exemple de fabrique à méthode statique. Le reversde la médaille est que le polymorphisme est cassé. C'est un choix.

6LE PATTERN FABRIQUE ABSTRAITENous arrivons à la définition complète du Pattern qui est: offrir uneinterface pour la création d'objets, mais en laissant aux sous-classes le choix des classes à instancier. Revenons à notre warga-me. Notre chef de projet soucieux de donner du réalisme à notrejeu, s'écrie tout à coup: "personne ne fait la guerre sans res-sources. Notre jeu doit comporter un panneau civil dont les acteursproduiront les ressources nécessaire à la guerre!". Et il ajoute: "Enoutre, les interfaces utilisateur des panneaux civils et militaire sontsimilaires, nous devrions nous en tirer sans rien coder de plus à ceniveau". En effet, nous le pouvons... parce que notre code est basésur la Pattern Fabrique. Le rôle de celui-ci est d'offrir une interface.Le terme est à prendre au sens de la programmation objet. Dansnotre exemple cette interface se réduit à une méthode: creerEntite.Les classes fabriques implémenteront cette interface ou selon l'usa-ge habituel dériveront d'une classe abstraite comportant cetteméthode. Le diagramme ci-dessous est notre Pattern Fabrique Abs-traite vu par UML. Pour ce qui est de notre jeu, c'est tout simple.Nous créons des unités civiles, une fabrique d'unité civile et... c'esttout :) Voici ce que cela donne (code complet sur notre site) :

abstract class JeuFabrique {

abstract Entite creerEntite(TypeEntite type);

}



code \\ patron

class FabriqueMilitaire extends JeuFabrique{

//etc

}

class FabriqueCivile extends JeuFabrique{

Entite creerEntite(TypeEntite type) {

Entite e;

switch (type) {

case TYPEBOULANGER:

default:

e = new Boulanger();

e.init("Boulanger", 30);

break;

case TYPEMECANICIEN:

e = new Mecanicien();

e.init("mecanicien", 40);

break;

}

return e;

}

}

class PanneauJeu {


JeuFabrique fabrique;

PanneauJeu(JeuFabrique fabrique) {

this.fabrique = fabrique;

}


pieces.add(fabrique.creerEntite(type));

}



e.display();

e.action();

}

}

}

public class JeuFabriqueAbstraite {


System.out.println("Demo Simple Factory");

PanneauJeu militaire = new PanneauJeu(new FabriqueMilitaire

()); PanneauJeu civil = new PanneauJeu(new FabriqueCivile());

// Ici le joueur clique sur les interfaceq


militaire.creerEntite(TypeEntite.TYPESOLDAT);

militaire.creerEntite(TypeEntite.TYPETANK);

civil.creerEntite(TypeEntite.TYPEBOULANGER);

civil.creerEntite(TypeEntite.TYPEMECANICIEN);


militaire.jouer();

civil.jouer();


}

}

Ce qui est remarquable avec cet exemple c'est que la classe Pan-neauJeu est unique. Nous l'instancions deux fois et nous lui passonsla fabrique en adéquation avec son contexte d'utilisation. Le code estunique tout simplement parce qu'il ne travaille avec aucune classe,mais seulement avec une interface. Le boulanger et le mécaniciensont des citadins. Voulons-nous un panneau de jeu pour des entitéscampagnardes ? La classe PanneauJeu restera la même. Simple-ment nous lui passerons une autre fabrique, adaptée à ce contexte.On peut se poser la question de savoir si, pour une application plusréelle, on pourrait vraiment utiliser un même code de panneau.Après tout le code l'affichage serait différent dans chaque cas et ilfaudrait bien s'en occuper. La réponse est pourtant oui. On régleraitce problème avec le Pattern Stratégie vu dans Programmez! 94 :)Les Pattern collaborent volontiers ensemble. Simple à comprendre,simple à mettre en oeuvre, le Pattern Fabrique Abstraite est trèspuissant. Dans les applications complexes il est impossible de s'enpasser. Attention! Voici notre chef de projet qui revient avec unenouvelle idée géniale en tête. Heureusement nous avons quelquesPattern en réserve... pour une prochaine fois :)

■ Frédéric Mazué - [email protected]

Tous les jours : l’actu et le téléchargementwww.programmez.com


code \\ concurrence


Tout programmeur quis'est essayé à écrire unpetit peu de code concur-rent a subi les turpitudesde l'ennemi public n°1 en la

matière: le deadlock. Cettecondition de verrou mortel se produit quand deux flux d'exécutionattendent chacun que l'autre libère une ressource telle que verrou,section critique, sémaphore ou autre. Et s'il était possible de faire dela programmation concurrente sans verrou ? Tout serait beaucoupplus simple. C'est l'idée qui a présidé au développement de l'API CCR,qui fournit un modèle de programmation minimisant notablement lesrisques et facilitant la conception des applications. Si CCR n'éradiquepas le deadlock définitivement (est-ce seulement possible ?), il est unoutil à découvrir absolument. CCR est la fondation de MicrosoftRobotics Developer Studio, mais elle peut parfaitement être utiliséeseule, avec n'importe quel langage .Net, car ce n'est concrètementqu'un jeu d'assemblies. CCR est d'ailleurs également à la base deDSS, une API pour le développement d'applications concurrentesdistribuées. Nous allons quant à nous découvrir CCR en écrivant unpetit peu de code concurrent classique. CCR n'existe pas en distri-bution autonome gratuite, mais il est au coeur de Robotics Develo-per Studio en Express Edition, donc gratuite.

1VUE D'ENSEMBLEFondamentalement CCR est un mécanisme à passage de messages.Il en existe de nombreux pour la programmation concurrente. Lesimplémentations de MPI par exemple. Ou bien les applicationsErlang. Dans ces deux cas, c'est le programmeur qui expédie explici-tement les messages, depuis des threads ou des processus respec-tivement. L'originalité de CCR réside dans une plus grande subtilité.Des classes de haut niveau surveillent des changements de condi-tions dans des ports et y réagissent en démarrant des threads.Avec ce mécanisme, le programmeur ne manipule pas les mes-sages directement. Une application CCR met en oeuvre 5 classesau minimum. La première est le port dont nous venons de parler etautour duquel tout s'articule. Concrètement, un port peut être vucomme une pile FIFO de données typées. Vient ensuite le Dispatcherqui détient des files de tâches potentielles et qui, comme son noml'indique, diffusera les messages et démarrera les tâches. Ces filesde tâches sont encapsulées dans une classe du nom de Dispatcher-Queue. Vient ensuite le Receiver, qui encapsule la notion de fonctionde rappel (ou callback). Cette classe implémente une interfaceITask, et, dans les instances de ces classes, un port est associéavec du code à exécuter en parallèle. Vient enfin l'Arbiter dont unepartie des méthodes statiques sont invoquées pour obtenir l'asso-

CCR, une API de programmationconcurrente pour .Net

ciation dont nous venons de parler, et dont la méthode Activateassocie des objets implémentant l'interface ITask (tel un Receiver)avec une DispatcherQueue. Tout ceci peut sembler assez complexe,et dans un sens ça l'est. D'autant plus que nous n'avons pas décritles classes dans le détail. Mais avec un peu de pratique, tout s'éclai-re et devient, finalement, plutôt facile.

2PREMIER EXEMPLE RUDIMENTAIRENous ne pouvons pas faire plus simple, c'est le "Hello World!" de laprogrammation concurrente à la sauce CCR. Nous créons un portdestiné à recevoir des entiers. Les entiers postés dans ce port sontimprimés en écho sur la console par du code parallélisé :

using System;

using Microsoft.Ccr.Core;

namespace SimplePort

{

class Program

{

Port<int> lePort;

Dispatcher leDispatcher;

DispatcherQueue leDispatcherQueue;

Receiver<int> leReceiver;

Program()

{

lePort = new Port<int>();

leDispatcher = new Dispatcher(1, "Mon Dispatcher");

leDispatcherQueue = new DispatcherQueue(

"Mon DispatcherQueue", leDispatcher);

}

void Go()

{

leReceiver = Arbiter.Receive<int>(

true,

lePort,

Rappel);

Arbiter.Activate(leDispatcherQueue, leReceiver);

for (int i = 0; i < 10; i++)

{

lePort.Post(i);

}

APPLICATION : CONCURRENCE

LANGAGE : C#

SOURCE : OUIDIFFICULTEAVANCÉ

La programmation concurrente et le cortège de deadlocks qui l'accompagne sont plusque jamais d'actualité. CCR est une API concurrente proposée par Microsoft pour .Net,dont l’originalité est de ne pas utiliser de verrous. Partons à sa découverte.

66-69 Code CCR API 20/05/2009 11:41


code \\ concurrence

Console.ReadLine();

}

void Rappel(int valeur)

{

Console.WriteLine(valeur);

}

static void Main(string[] args)

{

Program p = new Program();

p.Go();

}

}

}

Il y a plusieurs façons de passer le code parallélisé à Arbiter.Recei-ve. Si l'on préfère, on peut passer une fonction anonyme :


true,

lePort,

delegate(int valeur) { Console.WriteLine(valeur); });

Et même saupoudrer le tout d'un peu de sucre syntaxique :)


true,

lePort,

valeur => Console.WriteLine(valeur));

Dans tous les cas, bien remarquer le booléen positionné à true. Cebooléen assure la persistance de la connexion entre le port et lecode parallélisé. Avec le booléen à false, seul le premier entier seraitaffiché. Ce code est finalement fort simple pour de la programma-tion parallèle. Une fois que tout est initialisé, on poste 10 entiersdans le port, sans se préoccuper de rien. Si vous essayez ce codevous verrez que le callback, du nom de Rappel, est bien invoqué parle runtime, comme on s'y attend, et les 10 entiers sont affichés surla console, dans l'ordre dans lequel ils ont été postés.

3ASYNCHRONE OU CONCURRENT ?Les nombres affichés dans l'ordre dans lequel ils ont été postés ?Voilà qui est surprenant. On dirait avoir plus affaire à une API de pro-grammation asynchrone que concurrente. Notre exemple est effec-tivement asynchrone et ressemble au mécanisme des messages defenêtre en programmation Win32. L'explication se cache dans l'ins-tanciation du Dispatcher :

leDispatcher = new Dispatcher(1, "Mon Dispatcher");

La valeur 1 représente, nous dit la documentation de CCR, lenombre de threads systèmes que peut utiliser le runtime CCR pourtraiter les tâches en attente dans la ou les queues qu'il gère. Avecun seul thread permis, nous avons un comportement asynchrone àla Win32. Remplacez 1 par 10 et là vous verrez que les 10 entiersne s'affichent plus dans l'ordre. Cette fois le runtime a bien démarréplusieurs threads simultanément, et nous avons le comportementcaractéristique des applications concurrentes: les résultats dans ledésordre, de façon imprévisible, ou du moins non garantie par l'API.

4NOMBRE DE THREADS ET COEURSDE PROCESSEUR

Il est important de bien noter que les threads lancés par CCR sontdes threads systèmes. Ils ne sont pas gérés et planifiés par le runti-me comme c'est le cas par exemple en Erlang. Que l'on ait desthreads systèmes implique une limitation: Windows ne supportequ'un maximum de 64 threads pour une application. Lancer ungrand nombre de threads ne présente d'ailleurs que peu d'intérêt engénéral. Il est plus intéressant de répartir le code parallélisé sur lescoeurs d'un processeur. Voici un code qui demande explicitement àexploiter de la machine hôte. Le code parallélisé n'a pour rôle que dedévorer du temps d'exécution gloutonnement :

using System;

using System.Threading;

using Microsoft.Ccr.Core;

namespace PostCore

{

class Program

{

Port<int> lePort;

Dispatcher leDispatcher;

DispatcherQueue leDispatcherQueue;

Receiver<int> leReceiver;

Program()

{

lePort = new Port<int>();

leDispatcher = new Dispatcher(

10, ThreadPriority.Normal,

DispatcherOptions.UseProcessorAffinity,

"Mon Dispatcher");

leDispatcherQueue = new DispatcherQueue(

"Mon DispatcherQueue", leDispatcher);

}

void Go()

{


true,

lePort,

Rappel);

Arbiter.Activate(leDispatcherQueue, leReceiver);

for (int i = 0; i < 10; i++)

{

lePort.Post(i);

}

Console.ReadLine();

}

void Rappel(int valeur)

{

Les TUTORIELS sur www.programmez.com

66-69 Code CCR API 20/05/2009 11:41

code \\ concurrence


Console.WriteLine(

"Entrée dans le thread {0}", valeur);

int n = 250;

for (int i = 0; i < n; i++)

for (int j = 0; j < n; j++)

for (int k = 0; k < n; k++)

{

DateTime t = DateTime.Now;

}

Console.WriteLine("Sortie du thread {0}", valeur);

}

static void Main(string[] args)

{

Program p = new Program();

p.Go();

}

}

}

Examinons attentivement comment le Dispatcher est instancié cette fois :

leDispatcher = new Dispatcher(10,

ThreadPriority.Normal,

DispatcherOptions.UseProcessorAffinity,

"Mon Dispatcher");

Nous lui demandons de gérer les threads par paquets de 10. Nousdonnons aux threads une priorité normale. Cette notion de prioritéétant à prendre au sens "programmation Win32" du terme. Enfinnous demandons explicitement au runtime de répartir les threadssur les coeurs du processeur de la machine. Quoique selon lesobservations faites pas votre serviteur, ce comportement est detoute façon le comportement par défaut. Essayons notre code surun Dual-Core. La capture ci-dessous montre nettement le pic decharge: les deux coeurs travaillent au maximum. Le programmeémet cette sortie sur la console

Entrée dans le thread 0









Sortie du thread 1


Sortie du thread 8

Sortie du thread 5

Sortie du thread 2

Sortie du thread 6

Sortie du thread 7

Sortie du thread 9

Sortie du thread 0

Sortie du thread 3

Sortie du thread 4

Pour autant que cette sortie sur console décrive fidèlement les opé-rations, ce qui n'est pas forcément certain en environnementconcurrent, le résultat des courses est assez surprenant et donne àréfléchir. D'abord les threads sont lancés dans un beau désordre.Mais après tout comme rien n'est garanti à ce niveau, pourquoi pas ?Preuve est faite que l'ordre des postages dans un port n'influencepar l'ordre de lancement des threads. Quand même... cet ordre estétonnant :) L'ordre de fin d'exécution, sans rapport avec celui de lan-cement ne l'est pas moins, mais bon, concurrence oblige.... Mais lavraie surprise, si on considère que chaque thread a un temps d'exé-cution très long, c'est de voir que le dernier est lancé après qu'un sesoit déjà terminé. Tout semble se passer comme si en interne,c'était un thread qui se charge de lancer les autres. Dans notreexemple, les coeurs des CPU étant vampirisés, le supposé thread delancement doit attendre qu'un peu de ressource soit libérée pourfaire son travail. On est tenté de conclure qu'avec CCR il convientd'éviter les situations avec un système très chargé sous peine d'ob-tenir un fonctionnement très besogneux, problème qui ne se ren-contre pas avec Erlang que nous avons déjà cité plus haut. Il est vraique notre exemple est un cas extrême de mauvais usage de codeparallélisé :)

5DES PORTS MULTI-TYPESCCR recèle encore beaucoup de choses à découvrir. Ainsi le PortSetqui est une classe de port pouvant recevoir plusieurs types diffé-rents, jusqu'à dix neuf. Pour chaque type, on établit une connexiondu port avec le code parallélisé adapté au cas. Cette connexion estétablie via l'Arbiter, comme dans le premier exemple. Ceci installé,c'est tel ou tel thread qui sera lancé, selon le type de la valeur pos-tée dans le port. Une fonctionnalité fort intéressante, agrémentée,là aussi, d'une petite surprise. Vous trouverez sur notre site le codeDemoPortSet qui est un exemple mettant en oeuvre un port suppor-tant trois types : entier, double et String.Remarquons que l'instanciation du Dispatcher ne permet qu'unthread actif à la fois, comme dans le tout premier exemple de cetarticle. Dans le port nous postons successivement un entier, unCCR répartit bien la charge de travail sur les coeurs de notre processeur

Dual-Core

66-69 Code CCR API 20/05/2009 11:41

code \\ concurrence

double, une chaîne et un flottant (Tiens le flottant est traité commeun double. C# n'est pas Haskell en ce qui concerne la rigueur sur lestypes :). Puisque nous ne pouvons avoir qu'un seul thread à la fois,nous nous attendons à obtenir une sortie dans le même ordre. Lasurprise est que nous obtenons :

Reçu entier: 1

Reçu double: 1

Reçu double: 2

Reçu chaine: Programmez!

Nous avons obtenu ce comportement sur toutes nos machines,aussi bien Dual-Core que Quad-Core. Ce qui vient immédiatement àl'esprit est que la constitution de la chaîne demande plus de tempset que son thread est doublé, c'est le cas de le dire, par le dernierthread traitant un double. Mais en fait, cela n'est pas normalementpossible puisque nous ne pouvons avoir qu'un thread actif à la fois.Alors que se passe-t-il ? Il semble, sous toutes réserves, que le run-time vide les piles FIFO attachées à chaque type l'un après l'autre,dans l'ordre de leur déclaration et/ou dans l'ordre des gestion-naires spécifié dans l'appel à Arbiter.Activate.

6DE LA PROGRAMMATION CONCURRENTE SÉQUENTIELLE

Comment ? Le code est soit parallèle soit concurrent! Non, plusavec CCR :) Celui-ci propose un usage original des itérateurs C#. Aulieu d'avoir une fonction de code parallélisé ne retournant rien, onretourne un itérateur de tâches par une instruction yield return.Voici une fonction parallélisée extraite de l'exemple DemoIteratorque vous trouvez complet sur notre site :

IEnumerator<ITask> Rappel(int valeur)

{

while (lePort.ItemCount != 0)

{

yield return lePort.Receive();

result += lePort;

Console.WriteLine(result);

}

Console.WriteLine("Résultat final {0}", result);

}

Une sortie de console dans un ordre inattendu...

Abonnez-vous : EN CADEAU

Accès illimité de 10 jours à la Bibliothèque NumériqueA choisir parmi les Bouquets de la Bibliothèque Numérique des Editions ENI : Développement, Microsoft, Open SourcePour tout abonnement au magazine Programmez un accès de 10 jours à la Bibliothèque Numérique de votre choix vous est offert. Offre Limitée aux 1000 premiers souscripteurs. (voir page 61 Abonnements)

La tâche est retournée au planificateur du runtime, qui peut alorsl'activer. L'instruction yield return devient une sorte de point de syn-chronisation. Dans notre exemple la partie de code qui poste dansle port ne fait pas partie de la section parallèle. La documentationde CCR va plus loin et propose un exemple où c'est le code paralléli-sé lui-même qui poste dans le port. Voici ce code extrait de DemoI-teratorSequential.

IEnumerator<ITask> Rappel(int valeur)

{

for (int i = 1; i < 10; i++)

{

lePort.Post(i);

yield return lePort.Receive();

result += lePort; // <- sucre syntaxique

Console.WriteLine(result);

}

Console.WriteLine("Résultat final {0}", result);

}

Et nous arrivons à un code parallélisé à l'exécution parfaitementséquentielle :)

7UNE GESTION DES ERREURS ORIGINALE

Gérer les erreurs en environnement concurrent n'est pas une minceaffaire. Pour traiter le problème, CCR dispose d'un système qui cap-ture les exceptions éventuellement levées par les sections paralléli-sées, capture qui aboutit à l'exécution d'une section paralléliséedédiée. Nous avons en fait une sorte d'extension du mécanismed'exception classique, implémenté pour les threads. Ce mécanismeassez complexe, qui permet d’avoir des gestionnaires d'erreursimbriqués, ne sera pas décrit ici. Le lecteur trouvera toutefois unexemple rudimentaire sur notre site, du nom de DemoCausualty.

8CONCLUSIONNous sommes très loin d'avoir fait le tour de CCR. Ainsi n'avons-nous, par exemple, pas parlé des fonctionnalités de synchronisationde threads (autre que le mécanisme de l'itérateur) Mais nous avonsvu qu'il s'agit d'une API originale. Son comportement réserve son lotde surprises, mais c'est un peu la loi du genre. Nous pensons que CCR, s'il obtient la popularité qu'il mérite, est detaille à révolutionner l'approche de la programmation concurrentesous .Net. Pour preuve de son potentiel, il est à la base de DSS(Decentralized Software Services), une API pour l'écriture d'applica-tions concurrentes, distribuées et tolérantes aux fautes, ce qui n'estpas rien. Dans des articles à venir, nous approfondirons notreconnaissance du maniement de CCR et nous découvrirons DDS,autre univers passionnant.

■ Frédéric Mazué[email protected]

66-69 Code CCR API 20/05/2009 11:41

code \\ eclipse


Avec les outils disponiblesaujourd'hui dans Eclipse, ilest possible de choisir entreréutiliser et adapter un lan-

gage existant génériquecomme UML, ou bien directe-

ment créer un langage dédié (ou Domain Specific Language). En choi-sissant cette seconde solution, l'un des avantages sera pourl'utilisateur final d’être naturellement guidé dans l'utilisation de sesmodèles. Pour construire un DSL, nous vous proposons de suivre unprocessus qui permet une boucle de prototypage entre chaque étapede construction. Cela permet donc d'expérimenter facilement le langa-ge avant de l'outiller complètement. Suivant notre expérience, celaassure une meilleure progression et permet d'en améliorer la fiabilité.

PRÉSENTATION DE L'EXEMPLEPour illustrer nos propos, nous nous appuierons sur l'exemple du lan-gage de la tortue Logo (que certains d'entre nous ont peut-être déjàconnu sur leur MO5). Logo est un petit langage permettant de diri-ger une tortue équipée d'un crayon pour lui faire dessiner une figurelà où elle est passée. Ce langage a d’abord été destiné à initier lesenfants aux concepts de la programmation. Nous allons décrirecomment l’IDM va nous aider à construire un environnement de pro-grammation pour Logo, et au final l'appliquer concrètement poureffectivement piloter un petit robot construit en Lego Mindstorm.

UN PEU DE THÉORIE Traditionnellement, quand on pense à concevoir un langage, on esttenté de réfléchir d'abord à la syntaxe concrète qu'on va donner àcelui-ci, et donc en terme de grammaire et de parser. En IDM, lasyntaxe concrète n'est qu’un aspect secondaire. C'est d’abord sur

Introduction à la construction d'un DSL sous EclipseCréer un langage spécifique à un domaine permet de proposer à vos utilisateurs unenvironnement de travail adapté à ce domaine, c'est-à-dire manipulant directement lesconcepts de celui-ci. Nous verrons aujourd'hui comment l'Ingénierie Dirigée par lesModèles (IDM) va nous aider à construire un tel langage et son environnement.

les concepts du cœur du langage que l'on se base (la syntaxe abs-traite). Ces concepts de base servent de fondations sur lesquellesnous allons bâtir autant de vues que nécessaire. Nous allons profiter ici des facilités offertes par un outil Eclipsecomme Kermeta. Tout d'abord parce qu'étant un Langage OrientéModèle, Kermeta offre nativement des fonctions qui en facilitent lamanipulation, mais surtout parce qu'il nous permet de tisser et d'as-sembler les éléments nécessaires sans modifier le cœur du langageque l'on souhaite construire. Nous verrons par la suite que cettefonctionnalité est intéressante car elle nous permet de viser plu-sieurs usages et outils autour du langage. Cela nous permettraitmême d'envisager plusieurs variantes de sémantiques si le cœurnous en disait !

DÉFINITION DES CONCEPTS DU LANGAGEAinsi, dans le monde IDM, les DSL sont communément représentésavec ce que l'on appelle un méta-modèle. En fait, c'est un diagram-me de classe qui définit les concepts de notre langage : dans Eclip-se, cela se fait avec un modèle Ecore. Avec notre exemple Logo, les concepts seront typiquement les ins-tructions que l'on voudra faire exécuter à notre tortue. Par exemple,lever le crayon, avancer d’un certain nombre (entier) de pas ou tour-ner d’un certain angle (exprimé, pour simplifier, comme un nombreentier de degrés). Nous allons donc créer et relier les concepts cor-respondants : une classe PenUp, une classe Forward, et une classeRight. Les instances de ces classes représenteront les instructionsdu programme Logo de l ’ut i l isateur, par exemple " FORWARD 10 " ou " RIGHT 3*30 ". Les classes Forward, et Rightétant paramétrées par une expression arithmétique, elles sontreliées à une classe " Expression ", qui peut être par exemple soit

APPLICATION : TOUTES

LANGAGE : DSL


Figure 1. Version minimaliste du méta-modèle du langage Logo Figure 2. Machine Virtuelle pour le simulateur Logo

70-72code DSL Eclipse 20/05/2009 11:42


code \\ eclipse

une expression binaire (ie. qui compose deux expressions par unopérateur de type +, *, etc.), soit une constante entière, ce qui estreprésenté par de l’héritage. L'éditeur arborescent de base fourniavec Ecore est certes fonctionnel, mais n'hésitez pas à lui adjoindreun diagramme de classe (fichier avec l'extension ecorediag) grâce àl'éditeur fourni par le projet Eclipse Ecore Tools.Afin de profiter des avantages de génération des outils basés surEMF, il faut penser à ajouter une notion de conteneur sur certainsliens pour créer une hiérarchie. En effet, même si les concepts denotre langage sont bien là et forment un modèle valide, la plupartdes générateurs s'appuient sur cette notion pour automatiser l'affi-chage de certaines vues. C'est le cas par exemple de la vue "outline".Pour rendre la tortue plus intéressante à piloter, nous compléteronsces instructions avec quelques structures de contrôle telles queBlock, If ou Repeat… [Figure 4] Celles-ci permettent de structurer etd'ordonner les séquences d'instructions. De même, l'instructionProcCall donnera la possibilité d'appeler des blocks définis dansProcDeclaration avec des paramètres.

CRÉATION DES PREMIERS MODÈLESLOGO AVEC L'ÉDITEUR RÉFLEXIF Pour débuter avec votre nouveau langage, le plus simple maintenantest d'utiliser l'éditeur arborescent réflexif. Depuis votre méta-modèlelogo.ecore, il vous suffit de sélectionner l'élément racine de votre lan-gage et de créer une nouvelle instance. Vous pouvez maintenantajouter des instructions pour créer vos premiers programmes Logo.

TISSER DES CONTRAINTES COMPLÉMENTAIRESEn expérimentant un peu votre langage, vous vous apercevrezqu'Ecore ne vous permet pas d'exprimer certaines contraintes, parexemple que les paramètres formels d’une procédure doivent avoirdes noms différents. C'est normal puisqu'il n'en définit que la struc-ture. Comme l'objectif d'un DSL est d'aider les utilisateurs du futurlangage, nous allons ajouter des contraintes qui vont les aider à nepas faire ces erreurs. Le langage Kermeta nous donne ici la possibi-

lité de rouvrir les définitions Ecore pour ajouter des éléments néces-saires au besoin courant. Par exemple, pour vérifier que les argu-ments des procédures Logo ont des noms uniques, il suffit d'ajouterl'invariant suivant :

package kmLogo::ASM;

require kermeta

// importe les définitions du fichier logo.ecore

require "http://www.kermeta.org/kmLogo"

// réouvre la classe ProcDeclaration du méta-modèle Logo pour

lui ajouter un invariant

aspect class ProcDeclaration{

inv unique_names_for_formal_arguments is do

args.forAll{ a1 | args.forAll{ a2 |

a1.name.equals(a2.name).implies(a1.equals(a2))}}

end

}

Obtenir un vérificateur de modèle revient alors à charger un modèleLogo et appeler la méthode checkAllInvariants sur les éléments à laracine du modèle. Cet invariant aurait aussi pu être écrit en OCL, (lelangage officiel de l'OMG) et importé de la même manière, d'ailleursKermeta en reprend les facilités de navigation dans les modèles exis-tant en OCL. Néanmoins, Kermeta nous sert surtout de systèmed'assemblage et lui ajoute d'autres fonctions qui seront utiles pourles besoins des autres activités d'ingénierie des méta-modèles.

EXTENSION DES CONCEPTS POUR FOURNIRUNE SIMULATION (SÉMANTIQUE OPÉRATIONNELLE)Maintenant nous souhaitons rendre ce modèle plus "vivant" et voirnotre tortue bouger. Pour en définir le comportement, le plus simpleet le plus rapide est de fournir un simulateur. La première étapeconsiste à définir une représentation du domaine d'application (unesorte de Machine Virtuelle) sur laquelle le langage va s'appliquer.Pour notre exemple, ce sera tout simplement une ... tortue et les

traits qu'elle trace sur son terrain de jeu.Cela peut ici encore être représenté avecun diagramme Ecore. Ensuite, nous allonsdonner un peu de comportement à notretortue en lui fournissant des primitivestelles que move ou rotate qui sont spéci-fiques à cette représentation. Pour cela, ilsuf f i t d ' indiquer que l 'on a besoind'étendre les classes du domaine d'appli-

cation et de leur ajouter directement lesFigure 5 : Tortue robot en Lego

Figure 3. Exemple d'exécution d’un programme Logo avec le simulateur Figure 4. Exemple de modeleur généré avec Topcased

70-72code DSL Eclipse 20/05/2009 11:42

code \\ eclipse


actions que l'on souhaite sous forme d'opérations. Enfin, créer lesimulateur pour le langage Logo revient donc à ajouter desméthodes evaluate(context : Context) sur chacune des instructionsdu langage. Cette méthode fait appel au contexte pour avoir desinteractions avec le domaine d'application et enchaîner sur l'évalua-tion des instructions suivantes. En fait, c'est tout simplement unevariation du patron de conception "Visiteur" qui a été simplifiéegrâce à l'utilisation du tissage d'aspect de Kermeta.

package kmLogo::ASM;

require kermeta

require "../1.MetaModel/ASMLogo.ecore"

require "../4.VirtualMachine/LogoVMSemantics.kmt"

...

aspect class Block

{

method eval(context : Context) : Integer is do

instructions.each{instruction | result := instruction.

eval(context)}

end

}

aspect class Forward

{

method eval(context : Context) : Integer is do

context.turtle.forward(steps.eval(context))

result := void

end

}

...

Pour lancer une simulation, il suffit de charger un modèle Logo et delancer l'évaluation de la première instruction.

AMÉLIORATION DU SIMULATEUR Le langage Kermeta étant principalement dédié à la manipulation demodèles, il ne propose pas par défaut de fonctions graphiques quiseraient trop spécifiques à un domaine et nuiraient à sa compacité.Néanmoins, il offre la possibilité d'accéder à du code java. C'est ainsique nous pouvons réaliser une petite interface par exemple en AWTpour compléter les sorties textes du simulateur logo.Parfois, vous pouvez vouloir augmenter les performances de votresimulateur. Dans ce cas, plutôt que d'utiliser la version dynamiquede Kermeta (qui interprète le code Kermeta), vous pouvez utiliserson compilateur pour obtenir le code java EMF de votre simulateur. Ilpourra ainsi être déployé directement sans Kermeta lui-même dansl'environnement de l'utilisateur final.A ce stade de la mise au point de la sémantique du langage, le coûtdes évolutions reste raisonnable. Ceci ne sera probablement plusvrai une fois que vous aurez avancé dans les étapes suivantes et enparticulier si vous avez construit un compilateur car leur coût demaintenance est généralement plus élevé.

VOUS AVEZ DIT SYNTAXE CONCRÈTE ?Maintenant que les concepts de notre langage sont stables, nouspouvons commencer à capitaliser sur son usage. En particulier pourle rendre plus agréable à utiliser, nous souhaitons en améliorerl'IHM, rien de mieux alors que d'en définir une syntaxe dédiée parexemple textuelle ou graphique.

Gérer des syntaxes implique d'utiliser une ou plusieurs techniques,chacune d'entre elles pouvant nécessiter de longues explications.Nous nous contenterons ici d'évoquer les pistes utilisant des outilsde l'IDM visant à vous faciliter cette tâche :- Générer et customiser l'éditeur arborescent par défaut. Cela sefait grâce au genmodel d'EMF. En général, on commence par là,cela permet très facilement d'avoir une extension de fichier qui estpropre à notre modèle, d'utiliser des libellés et des icônes plus par-lantes. C'est d'autant plus intéressant que ces informations serontreprises par d'autres éditeurs plus évolués (typiquement dans lavue "outline" qui leur sera associée)

- Générer un éditeur graphique. Cela se fait grâce à un modèle permettant de faire le lien entre le langage et l’éditeur graphique.L'outil, (GMF ou Topcased) génèrera alors la plupart du code pourfonctionner dans Eclipse.

- Obtenir un éditeur textuel. Traditionnellement cela consiste à fournirun parser et un pretty printer pour notre langage (typiquement avecdes outils comme sableCC ou antlr).Plus récemment, des outils suivant la même philosophie que pour les éditeurs graphiques ontcommencé à apparaître pour obtenir des éditeurs plus intelligents àmoindre coût, mais ceci est hors du spectre de cet article.

CONNECTONS-LE AU MONDE RÉELNous avons choisi un robot construit avec Lego Mindstrom. Il estéquipé de trois moteurs indépendants : deux pour piloter les roues,un pour actionner le stylo. Il faudra que nous transformions nosmodèles de programme Logo en du code compréhensible par lamachine. Pour cette tâche, il existe de nombreuses techniques etlangages de transformations de modèle qui ont leurs avantages etinconvénients. Le choix dépend généralement de la complexité et duniveau de maintenabilité voulus pour la transformation à développer.Notre robot peut être programmé en NXC (Not eXactly C). Cettefois encore, nous utilisons ici les capacités de tissage pour complé-ter notre méta-modèle de langage avec un compilateur. En effet,pour une compilation simple comme celle dont nous avons besoinici, il suffit de traverser ce modèle pour générer directement le codeNXC correspondant. Si la transformation avait été plus complexenous serions passés par un modèle intermédiaire spécifique au NXCavant de générer le code. Dans tous les cas, la structure de base dulangage nous sert de trame directrice.A notre avis, la construction d'un compilateur doit être faite aprèsavoir fait un simulateur. Il y a bien évidement des exceptions mais lamise au point et la maintenance d'un compilateur est sensiblementplus coûteuse que celle d'un simulateur et doit donc être faite seule-ment quand le langage est suffisamment stable. De plus, votresimulateur vous servira de version de référence pour tester les dif-férentes implémentations concrètes. Dans notre exemple, nousvisons une plate-forme Lego Mindstorm, mais déjà sans même par-ler d'un autre robot, nous pouvons envisager plusieurs dialectes etbibliothèques de programmation pour celui-ci ! Ainsi il est possible de mettre au point des programmes dans notrenouveau langage tortue Logo sans avoir à dépendre de la lenteur durobot réel ou de la santé des batteries qui le meuvent. On voit ici

vraiment tout l'intérêt des modèles qui donnentune abstraction de la réalité.

■ Didier Vojtisek - Ingénieur de recherche INRIAwww.irisa.fr/triskell - www.kermeta.org

70-72code DSL Eclipse 20/05/2009 11:42


code \\ ria

Soyatec est unesociété françaiseexperte dans ledéveloppementde plugins pour

Eclipse. Parmi sesproduits on remarquera particulière-ment eFace, un plugin compatibleavec le langage déclaratif XAML pourdécrire des interfaces graphiquesJava. Cette particularité, StèveSfartz (architecte Microsoft France)va la repérer. La suite logique, on laconnaît : un partenariat est crééentre Microsoft et Soyatec, et le toutpremier plugin Silverlight pour Eclipseest né : eclipse4SL. 6 mois aprèsson lancement, faisons un état deslieux.

LES FONCTIONSVisual Studio est certes un environ-nement très complet, le plugin eclip-se4SL est néanmoins très bienéquipé et en osmose avec les outilsMicrosoft. Les projets créés avececlipse4SL sont complètement com-patibles MSBUILD et donc avec

Visual Studio 2008 ou encoreExpression Blend 2. Les projets eclip-se4SL sont éditables aussi bien parVisual Studio 2008 que par la suiteExpression Studio 2 et vice versa ![Fig.2]

De ce fait, eclipse4SL peut importerdes projets Silverlight dans l’environ-nement Eclipse. Il vous est proposéde créer une application Silverlightavec ou sans projet Web attaché, lesprojets sont exécutés dans un envi-ronnement Web via Chiron, un mini-serveur web embarqué dans le SDKde Silverlight. [Fig.3]

L’expérience de l’éditeur XAML esttrès intéressante puisqu’on est aidépar l’auto-complétion à la façon " IntelliSense ", on note la présenced’une palette qui permet des glisser-déposer des composants Silverlight(près d’une cinquantaine). On pourragénérer aisément le corps desméthodes dès lors qu’on s’abonne àdes évènements côté XAML.L’éditeur de code C# est quant à lui

bien loin d’être complet, outre la colo-ration syntaxique et quelques snip-pets, il ne bénéficie pas d’assistantd’auto-complétion de code.Les erreurs sont remontées dans laconsole et dans la vue Problems.[Fig.4] [Fig.5]

Autre point ergonomique, l’explora-teur de projet est similaire à celui deVisual Studio 2008, on retrouvedonc la notion de " code-behind ", lesdifférentes assemblies du projet sontconcaténées dans un onglet Refe-rences. On a la possibilité d’ajouterd’autres assemblies, de nouvellesclasses C#, des User Controls, du

Eclipse Tools for Silverlight : Silverlight sur Eclipse, c’est possible !Silverlight est un plugin gratuit s’exécutant sur diverses plates-formes et dans différentsnavigateurs Web. Avec eclipse4SL, il devient désormais " multi-developmentenvironment ” ! Eclipse4SL permet en effet de développer des applications Silverlight 2directement dans l’environnement Eclipse. La communauté peut alors profiter de toute larichesse de Silverlight 2. [Fig.1]

Fig.2Fig.1

Fig.3

APPLICATION : RIA

LANGAGE : DIVERS

SOURCE : NONDIFFICULTEMOYENNE

73-74 ecilpse tools 20/05/2009 11:45

code \\ ria


JavaScript, etc. L’éditeur XAML sedote d’un rendu instantané. Commeje vous le disais précédemment, lasolution est compatible avec VisualStudio 2008 et la suite ExpressionStudio 2, il est même possible d’édi-ter le projet dans l’un de ces 2 envi-ronnements à l ’a ide du menucontextuel (si toutefois, ils sont instal-lés sur votre machine).[Fig.6]Le débogage est une feature prévuepour plus tard. Le projet peut êtrecompilé et exécuté en s’appuyant surMSBUILD et Chiron, la compilationpackagera l’application pour pouvoirêtre utilisée dans n’importe quel pro-jet Web.

L’INTEROPÉRABILITÉNon content d’avoir intégré Silverlightdans un environnement Java, l’équiped’eclipse4SL pousse l’interopérabilitéen proposant des scénarios en modeSOAP ou REST entre du métier Javaet une couche d’exposition Silverlight.Celui-ci supporte en effet SOAP V1.1et embarque un client HTTP qui luipermet d’interroger un service REST.La mise en place de ces différentsscénarios est disponible sur leur site.Dans l’ensemble, le plugin possèdede bonnes bases pour démarrer desprojets Silverlight. Le point pénalisantà mon sens est le support limité del’édition de code C# et aucun débugde code possible, il reste néanmoinstrès intuitif dans son utilisation et se

rapproche beaucoup de l’environne-ment Visual Studio. Un point impor-tant à souligner : le plugin est OpenSource sous licence EPL et disponiblesur SourceForge :http://sourceforge.net/projects/eclipse4sl/

SILVERLIGHT : UN PLUGIN " cross-browser, cross-platform, cross… "L’histoire ne s’arrête pas là, lors duMix 09 qui a eu lieu à Las Vegas,Vijay Rajagopalan, architecte dans ladivision Stratégie Interopérabilité deMicrosoft, faisait la démonstrationdu plugin, mais cette fois-ci sur MacOS X ! Le développement d’applica-tions Silverlight est désormais rendupossible sur plusieurs OS. On parlevraiment là d’un plugin Cross-Plat-form, voire Cross-Development Envi-ronment. [Fig.7]Lors de cette même session, Vijay R.faisait la démonstration d’un POC(proof of concept) permettant dedévelopper des applications PHPpour Windows Azure et tout celadans Eclipse ! En bonus, on trouvemême un Azure Storage Explorer.Aucune annonce officielle de la sortiede ce plugin n’a été communiquée.

CONCLUSIONSix mois après son lancement, eclip-se4SL est déjà classé parmi les plu-g ins les mieux notés de la

communauté. Beaucoup de cheminreste à parcourir avant de faire del’ombre au mastodonte Visual Studio,ce n’est certainement pas l’objectifde ce plugin. Intégrer le développe-ment d’applications Silverlight dansEclipse c’est pouvoir profiter de larichesse de la plate-forme et de toutela communauté autour. Finalement,avec eclipse4SL et ce fameux POCsur Azure, Microsoft montre la volon-té de s’ouvrir à d’autres univers etd’être de plus en plus interopérable.Affaire à suivre…Ressources :• Eclipse4SL : http://www.eclipse4sl.org

• Session de Vijay Rajagopalan auMix 09 :http://videos.visitmix.com/MIX09/T58F

■ Ronny KwonEtudiant CSII3 à l’EPSI de Montpellierhttp://blogs.developpeur.org/ronnyk

Fig.4

Fig.5

Fig.6

Fig.7

73-74 ecilpse tools 20/05/2009 11:45


code \\ mysql

Ces providers, implémen-tent un moteur de traite-ment des requêtespermettant de convertir lesdonnées dans un format dif-

férent afin de les exécuter surdivers stockages de données. Différents providers natifs pour LINQsont disponibles mais deux technologies rivales de Microsoft vouspermettent aujourd’hui de réaliser un développement de bases dedonnées orientées objet. Ces technologies sont LinqToSql etADO.NET Entity Framework.

LINQTOSQLCe provider a pour cible les bases SQL Server et SQL Server Com-pact uniquement. Puisque les données SQL Server se trouvent surun serveur distant qui possède son propre moteur de requêtes, Lin-qToSql ne fait pas appel au moteur de requêtes de LINQ mais secontente de convertir la requête LINQ en requête SQL qui est ensui-te envoyée à SQL Server pour être traitée. SQL Server stocke lesdonnées au format relationnel alors que LINQ interroge les donnéesencapsulées dans des objets. Ces deux représentations doivent être" mappées " l’une à l’autre.

ADO.NET ENTITY FRAMEWORKADO.NET Entity Framework est un ORM (object-relational mapper)qui est inclus dans le Framwork.NET 3.5 Service Pack depuis août2008. Il permet également d’exécuter les requêtes LINQ par rap-port aux entités du framework ADO.NET Entity Framwork. Il est des-tiné à être ouvert à d’autres moteurs de bases de données commel’annonce Microsoft.

ADO.NET ENTITY FRAMEWORK OU LINQTOSQLAu premier coup d’œil ces deux technologies proposent des fonc-tionnalités similaires. Les aspects suivants vous permettront dechoisir une des ces technologies pour votre développement :Les avantages de LinqToSql :- La prise en main est plus facile, et mieux adaptée pour un dévelop-pement RAD.

- Possède une meilleure intégration des fonctionnalités orientéesserveur, comme par exemple le type BLOB.

- Est moins compliqué qu’ADO.NET Entity Framweork.

Utilisation de LINQ avec différentes bases de donnéesLINQ (Language Integrated Query) est un composant du framework.NET 3.5 qui permetd’interroger des données. Bien qu’on puisse effectuer des requêtes sur n’importe sourcede données, il exige que les données soient encapsulées dans des objets. Les requêtesLINQ sont soit exécutées directement par le moteur de traitement de LINQ, soit par unmécanisme d’extension géré par les providers LINQ.

- performances supérieures à celles d’ADO.NET Entity Framework.- Aucune restriction n’est à appliquer à vos objets afin qu’ils soientcompatibles avec LinqToSql. Vous devez uniquement implémenterquelques interfaces.

Les avantages d’ADO.NET Entity Framework :- Entity Framework est une approche conceptuelle du développe-ment avec les bases de données. Cependant il nécessite plus deconnaissances pour la prise en main et le maintien les développe-ments.

- Est davantage portable sur différents serveur de bases de donnéescar sa conception est plus abstraire que celle de LinqToSql.

- Intégration avec WCF (Windows Communication Foundation).- Intégration avec ADO.NET Data Services.- Intégration avec quelques services de Microsoft comme parexemple Reporting et Analysis Services.

Cependant aucune des deux solutions ne propose en natif le déve-loppement avec d’autres bases de données que SQL Server. Laquestion suivante se pose alors :

Peut-on utiliser LINQ avec d’autres bases dedonnées que SQL Server ?Si vous utilisez une autre base de données que SQL Server, il estpréférable de savoir si vous pouvez avoir recours à ADO.NET EntityFramwork ou LinqToSql. Le tableau ci-dessous, répertorie les provi-ders disponibles (la liste est non exhaustive) :

LinqToSql LinqToSql Entity Framework Entity Framework(natif) (tiers) (natif) (tiers)

SQL Server Oui - Oui -

Oracle Non DBLinq, Oui dotConnect,

LinqToOracle, EFOracle

LightSpeed,

dotConnect

DB2 Non - Oui -

MySQL Non DBLinq, Non dotConnect

LightSpeed

PostgreSQL Non NpgSql, DBLinq, Non NpgSql, dotConnect

LightSpeed,

dotConnect

Dans le cadre de notre article, nous allons réaliser une applicationC# qui n’a pas une réelle utilité, à part la démonstration de l’utilisa-tion de LINQ avec la base de données MySQL (version 5.1.30). Afin

APPLICATION : DONNÉES

LANGAGE : LINQ

SOURCE : NONDIFFICULTEMOYENNE

Recevez la Newsletter www.programmez.com/inscription.php

75-77 code linq 20/05/2009 11:45

code \\ mysql


de simplifier la démarche, nous allons créer une application de typeconsole (sans le code GUI) qui permet de nous concentrer sur uncas concret d’utilisation. Première question à se poser : quel provi-der choisir pour réaliser le développement avec la base MySQL ?Dans le cas de MySQL, ni LinqToSql ni Entity Framework ne fournis-sent aucun provider en natif. MySQL AB est en train de développerson provider " Connector/NET 6.0 " pour Entity Framework (actuel-lement il est disponible en version alpha), mais aucune date de sor-tie officielle n’est donnée au moment de l’écriture de cet article. Ilest donc difficile de tester MySQL sur ADO.NET Entity Framworkpour le moment, à moins d’avoir recours aux providers commer-ciaux tels que par exemple dotConect de Devart ou LightSpeed deMindscape.Quant à LinqToSql nous pouvons également nous tourner vers lesproviders commerciaux (voir le tableau) ou utiliser une solution alter-native telle que DBLinq qui aujourd’hui gère MySQL, Oracle et Post-greSql en s’appuyant sur LinqToSql. Ce projet OpenSource a débutéen 2007, donc est relativement jeune, mais permet de faire les pre-miers tests avec MySQL. Dans le cadre de notre application, nousallons utiliser DBLinq v.0.18.

EXEMPLE : " GESTION COMMERCIALE ".Dans notre exemple, nous allons développer une simple applicationappelée " Gestion Commerciale ". Pour pouvoir commencer notreprojet nous allons avoir besoin des pré- requis suivants :- Le serveur MySQL que vous pourrez télécharger à l’adresse sui-vante http://dev.mysql.com/downloads/mysql/5.1.htm.

- La bibliothèque DbLinq v.0.18 http://code.google.com/p/dblinq2007/.

Modèle métierAvant de nous lancer dans le développement de notre application,nous allons créer notre modèle métier que nous pouvons illustrer demanière suivante : [Fig.1]Ce modèle est juste une partie simplifié d’un système de prise decommandes. Il n’est pas complet mais cela est bien suffisant pourillustrer l’utilisation de LINQ avec une base de données MySQL.

DBMetalUn fois notre base de données créée, nous devons générer nosclasses. Il n’y a malheureusement pas de support graphique pourles modèles, à l’instar de LinqToSql. Le DataContext doit donc êtregénéré via une adaptation de SQLMetal appelé DBMetal, commeaux premières heures de LINQ. DBMetal est un projet permettantde générer du code source en s’appuyant sur des schémas de bases de données. Vous trouverez le générateur DBMetal.exedans l’archive zip de la bibliothèque DbLinq que vous avez téléchar-gée. Nous allons donc générer pour le besoin de notre application le DataContext appelé GestComm, il sera contenu dans le fichier du même nom avec l’extension .cs (C#). Afin de générer notrefichier nous devons taper la commande suivante dans la consoleWindows :

bin\DbMetal.exe -provider=MySql -database:GestComm -server

:localhost -user:LinqUser -password:linq2 -namespace:GestComm

-code:GestComm.cs -sprocs

La ligne d’exécution est assez facile à comprendre et ne nécessitepas d’explications supplémentaires. Afin que la génération réussis-se, faites bien attention que l’utilisateur " LinqUser " ait les droits ensélection à la table système mysql.proc qui est nécessaire pour lagénération du code source. A la fin de la génération vous devriezavoir un message similaire à celui sur l’image : [Fig.2]Ce fichier contient le mapping entre la base de données MySQL et lecode source. Une fois le fichier généré, nous pouvons le joindre ànotre application.

Code source de l’application.Nous pouvons à présent passer à l’écriture de notre application. Ilfaut commencer d’abord par ajouter les bonnes références.

RéférencesAfin de pouvoir compiler votre application vous devez ajouter lesréférences à votre projet vers les bibliothèques suivantes :- DbLinq.dll- DbLinq.MySql.dll- MySql.Data.dll- System.Data.Linq.dllEnsuite en en-tête de votre code, ajoutez les références vers lesespaces de noms suivants :

using System.Linq;

using DbLinq.Factory;

using DbLinq.Logging;

using MySql.Data.MySqlClient;

Fig.2

Fig.1

75-77 code linq 20/05/2009 11:45


code \\ mysql

var q6 = from c in db.Commande from l in c.Lignes where l.Article.ArtLiBelle == "XBOX360" select new { c, a = l.Article, l };

Procédures stockéesQuand vous générez votre fichier de mapping GestComm.cs (Data-Context), les procédures stockées sont implémentées en forme desméthodes. [Fig.3]Vous pouvez facilement les invoquer afin de les exécuter. Dans notreexemple, nous avons créé une procédure stockée " Commande-PourTiers(idTiers int) " qui prend en paramètre l’identifiant d’untiers et retourne toutes ses commandes. Le résultat retourné estdu type DataSet. L’extrait du code ci-dessous illustre son utilisation :

System.Data.DataSet result = db.CommandesPourTier(1);

InsertionsIl est également très simple d’insérer des données. Dans l’exempleci-dessous nous allons insérer un tiers dans la base MySQL. Voici lecode qui permet de le réaliser :

db.Tiers.InsertOnSubmit(new Tiers { TRSID = 4, TRSNoM = "Martin" });

db.SubmitChanges();

SuppressionsDe même, nous pouvons aussi facilement supprimer le dernier tiersajouté dans l’exemple ci-dessus. Voici l’extrait du code qui permet deréaliser cette opération :

db.Tiers.DeleteOnSubmit(db.Tiers.Last());

db.SubmitChanges();

CONCLUSIONDans cet article, nous avons pris comme exemple la base de don-nées MySQL. Cependant le projet DbLinq étant compatible avecd’autres plates-formes, nous pouvions choisir un autre serveur dedonnées tel que par exemple Oracle, PosgreSql, Ingres, SQLite,Firebird ou même SQL Server. Comme vous pouvez le constaternous avons réussi à réaliser notre petite application d’essai bien queDbLinq comporte encore des lacunes fonctionnelles. D’après ce quenous pouvons lire sur le site web officiel du projet, les fonctionnalitésmajeures manquantes sont :- Manque de la gestion des transactions.- Non support des sous-requêtes.- Non intégration de LinqToEntities.Nous pouvons également constater que le développeur ne disposepas d’une interface d’intégration graphique comme LinqToEntities.De plus, un manque quasi total de documentation est un point han-dicapant. Il faut également se poser la question de la pérennitéd’une telle solution. Cependant, si vous ne voulez pas investir dansdes composants tiers souvent onéreux, vous pouvez vous tournervers DbLinq, car son utilisation ainsi que sa prise en main est trèsfacile, comme vous avez pu le constater à la lecture de cet article.

RéférencesDevart dotConnect : http://www.devart.com/dotconnect/linq.html

DBLinq : http://code2code.net/DB_Linq/

LightSpeed: http://www.mindscape.co.nz/products/lightspeed/

■ Thomas JASKULA - Chef de Projet .NET

Se connecter à la base MySqlLa connexion à la base de données s’effectue par le biais de notreDataContext (mapping de données) généré dans le fichier Gest-Comm.cs. Il suffit d’instancier le DataContext en lui passant en para-mètre la chaîne de connexion. Le code suivant illustre cette étape :

string dbServer = Environment.GetEnvironmentVariable("DbLinq

Server") ?? "nodevovmware";

string connStr = String.Format("server={0};user id={1}; password

={2}; database={3}", dbServer, "LinqUser", "linq2", "GestComm");

GestComm db = new GestComm(new MySqlConnection(connStr));

Pour faciliter le déboguage de l’application, vous pouvez avoir recoursau logger se trouvant dans l’espace de nom DbLinq.Factory. Vouspouvez le récupérer avec la ligne de code suivante :

var logger = ObjectFactory.Get<ILogger>();

Ensuite, son utilisation reste très simple. Il suffit de lui passer enparamètre la requête linq que vous voulez déboguer :

logger.Write(Level.Debug, "from p in db.article orderby p.ART

_PRIXBASEHT select p;");

SélectionsDans un premier temps à titre d’exemple nous pouvons afficher laliste d’articles triée par le prix :

var q2 = from p in db.Article orderby p.ArtPRiXBaseHT select p;

foreach (var v in q2)

Console.WriteLine(v.ArtID + " - " + v.ArtLiBelle + " : " + v.Art

PRiXBaseHT);

Vous pouvez le constater, l’opération est très simple, comme s’ils’agissait de LinqToSql avec la base SQL Server.Nous pouvons aussi effectuer une récupération partielle des pro-priétés en utilisant une projection simple comme celle-ci :

var articlePartiel = from c in db.Article select new Article

{ ArtID = c.ArtID, ArtLiBelle = c.ArtLiBelle };

Cela permet de réduire le trafic réseau car vous sélectionnez etmettez à jour les propriétés dont vous avez vraiment besoin. Si vousessayez de faire la même chose dans LinqToSql vous obtiendrez l’er-reur suivante "Explicit construction of entity type 'Article' in queryis not allowed.".Les requêtes un peu plus compliquées s’exécutent également sansproblèmes. La requête Linq ci-dessous affiche la liste des com-mandes dont l’article est la console " XBOX360 " :

Fig.3

75-77 code linq 20/05/2009 11:45

Les langages fonctionnelssont particulièrement bienadaptés pour l’écriture d’ap-plications scientifiques oud’intelligence artificielle. A

ce jour, Microsoft n'édite pasun tel langage pour la plate-forme .net, F# vient donc combler cemanque. F# est un langage .net, cela signifie que comme C#, VB.net,Boo ou d’autres langages, il repose sur un socle commun : la CLS(Common Language Specification). Ainsi, F# a accès à l’ensemble deslibrairies .net, c'est-à-dire qu’il est utilisable pour écrire une applica-tion WPF ou ASP.net, ou simplement une assembly utilisée par uneapplication C#. Concrètement, cela veut dire que le compilateur génè-re une assembly .net classique qui sera exécutée par la machine vir-tuelle .net ; F# a donc plus ou moins les mêmes performances queC#. F# et OCaml partagent les mêmes syntaxes et fonctions de base,certaines libraires faites en OCaml peuvent être compilées directementvia F#, sans changement ou seulement quelques modificationsmineures. Contrairement à C#, F# ne définit pas seulement une gram-maire, il apporte également un ensemble de fonctions prédéfinies.

LES DIFFÉRENTS PARADIGMESIl existe plusieurs catégories de langages répartis selon desconcepts différents ; on parle de paradigme pour désigner unensemble de concepts particuliers. Les langages de programmationimpératifs représentent le premier paradigme de programmation: lelangage C en est probablement le meilleur représentant. Le paradigmeorienté objet a connu le succès avec le C++ et, au début du XXIèmesiècle grâce aux langages Java puis C#. Les autres paradigmes,comme la programmation fonctionnelle, sont moins utilisés, ce der-nier comprend LISP, Scheme et F# entre autres. Arrêtons-nous surla programmation fonctionnelle, ce paradigme consiste à voir unprogramme comme un ensemble de fonctions mathématiques. Cesdifférentes fonctions peuvent s'emboîter, on les voit en fin de comptecomme des boîtes noires qui prennent des paramètres en entrée etles transforment en une sortie. A l'inverse de la programmationimpérative, la programmation fonctionnelle rejette le changementd'état ainsi que la mutation des données ; par défaut, toute opéra-tion d'assignation est interdite. [Fig.1]

LE LANGAGE F#Avant de commencer avec une série d'exemples, il est nécessaire demaîtriser quelques concepts de base. Tout d’abord, il existe en F# unmot-clé permettant la déclaration de liste, variable et fonction ; c’estle mot-clé let. Ensuite, F# est un langage fortement typé, pour cela ilutilise massivement ce qui est appelé l'inférence de type (type infe-rence). Ce concept permet de ne pas spécifier explicitement le type

code \\ fonctionnel


F# : l’avenir de .Netet du développement Windows ?F# est un langage fonctionnel qui possède un noyau compatible avec OCaml, il s'inspireégalement de C# et Haskell. Aujourd'hui, F# est un projet du laboratoire MicrosoftResearch. Il pourrait être intégré au prochain Visual Studio (VS 2010) qui devrait voir lejour fin 2009, début 2010.

de l’élément déclaré. Le compilateur va analyser le contexte actuelpuis va déduire le type automatiquement. Le reste du dossier présente quelques fonctionnalités et conceptsqu’il nous a semblé intéressant d'aborder.

FONCTIONNALITÉS ET CONCEPTSLes bouts de codes ci-dessous ont été réalisés et compilés avecVisual Studio 2008 en utilisant la CTP de septembre 2008(1.9.6.2) de F#.

Hello WorldLe classique Hello World ci-dessous présente une manière d'afficherune chaîne de caractères sur la console. Nous utilisons ici la métho-de F# printfn mais la méthode System.Console.WriteLine du frame-work .net aurait également pu faire l’affaire.

#light

(* Hello World

Une fonction sayHello qui prend en paramètre hello *)

let sayHello hello = printfn "Hello %s" hello

printfn sayHello "World" // Appelle sayHello avec World comme paramètre

En exécutant ce code, le résultat suivant est obtenu :

> Hello World

Etant donné que nous travaillons en F#, il est plus logique d'utiliser lafonction printfn car elle se combine parfaitement avec le système detypes de F#. Actuellement, tout code doit commencer avec l’instruc-tion #light ou #light "off". Dans les futures releases, #light devraitêtre ajouté par défaut si rien n’est spécifié. #light a pour but de sim-plifier le code en rendant les espaces significatifs. De cette manière,certains mot-clés tels que in, begin et end peuvent être omis. Ladeuxième variante est à utiliser pour conserver une compatibilitéavec le langage OCaml. Ce premier exemple montre également l’uti-lisation des commentaires. Deux barres obliques (slash) permettentde faire un commentaire sur une seule ligne alors que (* et *) per-mettent d’ouvrir, respectivement fermer, un bloc de commentaire.

APPLICATION : --

LANGAGE : FONCTIONNEL


1re partie

Fig.1

[ ]

78-80 code sharp 20/05/2009 11:47


code \\ fonctionnel

Les fonctions d'ordre supérieur Une fonction d'ordre supérieur est une fonction qui prend ou retour-ne une autre fonction en argument. Cela permet d'augmenter radi-calement la généricité du code. Ce concept n'est aucunement lié àla programmation fonctionnelle, mais son implémentation est, unefois de plus, plus concise que dans d'autres langages de program-mation comme nous allons le voir avec un exemple. Supposons que nous souhaitons faire des fonctions de comparaisonqui s'appliquent sur une liste. Nous aimerions pouvoir trier cetteliste par ordre croissant, décroissant, par ordre de valeur absolue,ou n’importe quel autre ordre. Une possibilité serait de définir uneméthode pour chacune des fonctions dont nous avons besoin. Cetteapproche n'est évidemment pas générique et nous aurions besoinde beaucoup de code similaire.Avec les fonctions d'ordre supérieur, nous définissons une fonction(disons f) qui va prendre en argument notre fonction (disons t) ainsiqu'une liste d'éléments à trier (disons e). De cette manière, nouspouvons envoyer n'importe quelle fonction de tri t à f pour ordonnere. Voici la manière de procéder en F# pour faire une fonction qui trieles éléments par ordre de valeur absolue. Pour commencer, on défi-nit t, notre fonction de tri. Cette fonction prend en paramètre deuxentiers à comparer (appelés ici x et y) et renvoie 1, 0 ou -1 selon lerésultat de cette comparaison.

let t x y =

if abs x > abs y then -1

elif abs x = abs y then 0

else 1

Maintenant que notre fonction t est définie, il nous faut une fonctionf qui prend une fonction de tri en paramètre et une liste à trier.Cette fonction est déjà présente au sein de F#, List.sort, nous ne laredéfinissons donc pas. L'appel se fait comme ceci

let l = List.sort t [-2; 5; -10; 7; 3]

printf "%A" l

> [-10; 7; 5; 3; -2]

Nous pouvons créer cette fonction d'ordre supérieur f. Par exemple,pour en faire une qui retourne la valeur absolue la plus élevée entredeux entiers, nous faisons :

let f t x y =

if t x y < 0 then x

else y

La fonction f est donc une fonction d'ordre supérieur car elle prendt, une autre fonction, qui retourne une valeur de 1, 0 ou -1 selonque le premier argument est soit plus petit, égal, ou plus grand quele deuxième. L'appel se fait donc comme ceci :

let a = f t 4 -5

printf "%A" a

Et la fonction nous retourne -5 car c'est la valeur absolue la plusgrande entre 4 et -5. Cette notion de passage de fonction n'est passpécifique à F# ni même aux langages de programmation fonction-nels, comme nous l'avons déjà dit ci-dessus. A titre de comparaison, voici un code similaire fait en C# qui, lui,n'est pas un langage fonctionnel (mais objet uniquement). Première-ment, une fonction qui compare deux entiers comme dans le codeF# et qui retourne le plus grand en valeur absolue

var t = new Comparison<int>((x, y) =>

{

if (Math.Abs(x) > Math.Abs(y)) return -1;

else if (Math.Abs(x) < Math.Abs(y)) return 1;

else return 0;

});

Pour trier la liste, nous appliquons notre fonction sur la classe List,comme en F#, et les éléments sont triés :

List<int> l = new List<int> { -2, 5, -10, 7, 3 };

l.Sort(t);

> [-10; 7; 5; 3; -2]

Tout comme en F#, nous pouvons créer une fonction d'ordre supé-rieur f, qui va donc prendre une fonction de tri t en paramètre. Voicicomment procéder :

int f(Comparison<int> t, int x, int y)

{

return t(x, y) < 0 ? x : y;

}

En testant avec :

f(t, 4, -5);

Nous obtenons comme dans le code F#, la valeur -5. Grâce à cetexemple, nous constatons que le passage de fonction n'est pasréservé aux langages fonctionnels (d'autres langages, comme C++,possèdent également les pointeurs sur fonctions). L'implémentationen F# a cependant l'avantage d'être plus concise.

Les listesLes listes dans un langage fonctionnel sont omniprésentes et F# nedéroge pas à cette règle. Afin de créer une liste, le plus simple estd’utiliser les crochets et séparer les valeurs par des points-virgules :

let listA = [ 1; 2; 3 ]

Il est également possible d’utiliser la méthode create de l’objetArray. L’exemple ci-dessous est équivalent à l’exemple précédent :

let arr = Array.create 3 1

arr.[1] <- 2

arr.[2] <- 3

F# donne aussi la possibilité de définir une liste à partir de cesbornes inférieures et supérieures : on parle alors de " range list "

let listB = [1..10]

Mieux encore, on peut faire des listes générées (generated list),c'est-à-dire que la liste sera créée à partir d’une fonction. L’exempleci-dessous crée une liste contenant le carré des nombres 1 à 10 :

let listC = [ for x in 1..10 -> x*x ]

On peut obtenir une liste en extrayant une sous-liste d’une autre liste :

let listD = listC.[0..2]

Enfin, on peut concaténer 2 listes via l’opérateur @ :

let listE = listA @ listB

Donnez votre avis sur ce numéro www.programmez.com/magazine_satisfaction.php

78-80 code sharp 20/05/2009 11:47

Fonction map Puisque les langages fonctionnels utilisent très souvent des listes, ilest donc intéressant de présenter la méthode map. Cette dernièreapplique une certaine fonction sur tous les éléments d'une liste. Pre-nons comme exemple le code ci-dessous

let l = List.map (fun x -> x * x) [1 .. 10]

printf "%A" l

La méthode map prend deux paramètres : la fonction à appliquer surchaque élément de la liste d’une part ainsi que la liste en questiond’autre part. Dans notre cas, on passe une fonction qui élève lavaleur passée en paramètre au carré (premier paramètre) et uneliste allant de 1 à 10 (deuxième paramètre). La méthode map nousretourne une liste contenant les éléments de la liste passés endeuxième paramètre élevé au carré. Le premier argument qui secharge d’élever un élément au carré ne porte pas de nom et est doncappelé fonction anonyme. La fonction anonyme est construite grâceau mot-clé fun. Le résultat obtenu après exécution est le suivant

> [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

Les tuples Une des fonctionnalités pratique mais pas implémentée à ce jour enC# est la possibilité de faire retourner plusieurs variables à uneméthode. F# le permet grâce à l’utilisation des tuples, une fonctionpeut ainsi retourner plusieurs résultats. Par exemple

let rec f = fun x -> x, x*x

let a, b = f 2

printf "a = %i\nb = %i" a b

> a = 2

> b = 4

Le mot-clé mutableEn F#, lorsque nous assignons une valeur à une variable à l'aide del’opérateur d’assignation, il n'est plus possible d’en modifier lavaleur. Cependant, dans certains cas, nous aimerions passer outrece comportement. C'est à ce moment qu’entre en jeu le mot-clémutable qui permet de surpasser cette restriction.

let mutable mut = "First value"

printfn "Current value '%s'" mut

(* Sans le mot-clé mutable lors de la définition,

cette affectation va créer une erreur de compilation *)

mut <- "Second value" // On utilise pas = mais <-

printfn "Current value '%s'" mut

> Current value 'First value'

> Current value 'Second value'

Puisque notre variable a été déclarée avec le mot-clé mutable, nouspouvons lui assigner une valeur après l’initialisation, mais en utilisantle signe <- au lieu du traditionnel =.

Les références Une autre solution pour modifier la valeur d'une variable consiste àutiliser les références. Ce procédé peut être comparé aux pointeurs :nous stockons l'adresse d'une valeur dans une variable et en chan-geant l'adresse de celle-ci, nous la faisons pointer sur une autre

code \\ fonctionnel


valeur. Pour déclarer une variable en tant que pointeur, il faut utiliserle mot-clé ref ; le compilateur s'occupera automatiquement de trou-ver de quel type il s'agit et ce type ne pourra plus être modifié par lasuite. Par exemple, en déclarant une référence sur une valeur detype int, il faudra toujours lui passer des adresses qui pointent surdes valeurs du même type sinon une erreur sera levée.

// Définition de la référence sur une valeur de type integer

let i = ref 1

printfn "i: %d" !i // Affiche 1

// Déréférencement avec l'opérateur !

i := !i + 1

printfn "i: %d" !i // Affiche 2

> i: 1

> i: 2

Le code ci-dessus nous montre que l’assignation d’une nouvelle valeurà une variable de type référence se fait avec l’opérateur :=. Le déréfé-rencement de la variable se fait quant à lui avec l’opérateur unaire !

PipelineF# permet l’utilisation de pipeline grâce à l’opérateur |>. Un pipelinepermet d’envoyer le résultat d’une expression dans l’entrée de l’ex-pression suivante. L’exemple utilisé dans le paragraphe sur la fonc-tion map peut alors s’écrire comme suit

let l = [1..10]

|> List.map (fun x -> x*x)

printf "%A" l

> [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

Cette fonctionnalité permet de facilement chaîner les méthodes etrend la lecture du code plus aisée. Voici un autre exemple illustrantdavantage l’utilité des pipelines

let l = [1..10]

|> List.filter (fun x -> x % 2 = 0)

|> List.map (fun x -> x*x)

|> List.rev

printf "%A" l

> [100; 64; 36; 16; 4]

Sans les pipelines, nous aurions dû écrire :

let l =

List.rev (

List.map(fun x -> x*x) (

List.filter (fun x -> x % 2 = 0) [1..10]

)

)

Nous poursuivrons la découverte de F# le mois prochain.Merci à Damien DOLIGEZ de l’INRIA pour sa relecture et ses conseils

■ Nicolas Biedermann - MVP C#http://www.nicolasbiedermann.ch

■ Cyril Durand - MVP ASP.netConsultant indépendant

http://blogs.developpeur.org/Cyril

78-80 code sharp 20/05/2009 11:47


ludique \\ applications

Pondus(www.ephys.de/software/pondus)

Voici un gestionnaire personnel de poids(personal weight manager), écrit en Pythonet Gtk+2, placé sous la licence GPL. Sonusage est très simple, et il est de surcroîtléger et rapide. On peut y tracer la courbe des données pourobtenir un aperçu rapide de l’historique deson poids, les données étant stockées sousforme de fichiers XML pour un accès instan-tané et une modification avec d’autres pro-grammes. I l est s imple, en ef fet, etl’installation n’est pas non plus trop com-plexe. Pondus vous permet de suivre pas-à-pas votre poids sur une longue période et ilaffiche vos progrès à l’aide d’un graphe. Ilpeut également basculer entre des mesuresmétriques (" en mètres ") et des mesuresimpériales (" Système Impérial Britanniquede mesure de poids ").

Installation. En termes de dépendances, ilvous faudra disposer de l’installation dequelques librairies Python avant de com-mencer. A chaque fois que vous compilezquelque chose, l’installateur exigera systé-matiquement les fichiers de développement.Alors, assurez-vous que vous installez lesfichiers python-dev en premier. Si vous ren-contrez toujours des problèmes, unerecherche sur Google permettra de trouvercertains packages dont dépend Pondus :• python 2.4.4-6• python-gobject 2.14.1-1• python-gtk2 2.12.1-1• python-matplotlib 0.90.1-2• python-support 0.7.6

Une fois le problème des dépendances réso-lu, téléchargez le code source du site webdu projet, extrayez-en le contenu et ouvrezun terminal dans le nouveau répertoire.Comme racine, entrez la commande :

# python setup.py install

Usage : Pondus est très minimaliste, maisce n’est pas forcément une mauvaisechose. En tapant Pondus, vous verrez unepetite fenêtre munie de cinq boutons. Lepremier ajoute une ligne de données – celuide votre poids et la date d’entrée. Le second efface une ligne et le troisièmeaffiche une ligne de données. Une fois quevous avez entré des poids et des dates,vous pouvez alors les afficher sous la formed’un graphe en cliquant sur le quatrièmebouton. Si vous voulez passer de l ivres (" pounds ") à kilogrammes, le cinquièmebouton ouvre la fenêtre des " settings " etvous permet de changer cela (c’est l’unedes deux seules options, l’autre permet dese rappeler de la taille de la fenêtre).Garder trace de vos progrès est centraldans Pondus. Nous arrivons maintenant àla section graphique – le quatrième bouton,ou dessiner les données, Plot data. Cliquezsur ce bouton, et une fenêtre intitulée PlotWeight apparaît avec un graphique à lignenette représentant votre poids au coursd’une période. Si vous regardez tout en basà droite, il y a une boîte " glisser-déplacer "(drop-down box) avec All Time écrit à l’inté-rieur. Ceci vous permet de filtrer le restedes informations par rapport à vos résultatsde l’année précédente, ou juste le mois der-nier. Si vous voulez filtrer votre période parrapport à quelque chose de plus spécifique,il y a deux champs tout en bas à gaucheappelé Select Date Range.Tapez la date de début que vous voulez voirapparaître dans le premier champ et la datede fin dans le second champ, cliquez surUpdate à l’extrême droite, et le graphiquefera la mise à jour avec les informationssélectionnées. Pour ceux d’entre vous qui veulent enregis-trer une copie de leurs progrès, en cliquant

sur le bouton Save Plot tout en bas, vouspourrez sauvegarder votre graphique dansun fichier .png.

FoxyTag(www.foxytag.com)

Voici un projet dont j’ai hâte de voir le résultat :un système gratuit d’avertissement anti-radar conçu pour fonctionner sur une grandevariété de téléphones portables et de GPS.FoxyTag est un système collaboratif conçupour inciter les utilisateurs à partager desdonnées radar – plus il y a d’utilisateurs et defeedback, plus le système devient fiable.

FoxyTag, un système populaire anti-radar

Le système ne suppose pas simplementqu’un radar se trouve à un endroit particu-lier. Les utilisateurs ont la possibilité designaler la présence permanente d’unradar, de son installation ou de sa suppres-sion. Tout téléphone portable JAVA équipéde MIDP 2.0, CLDC 1.1 et Bluetoothdevrait être compatible. Pour les systèmesGPS, tout GPS Bluetooth devrait être com-patible (y compris les modules GPS de cer-tains systèmes de navigation),

■ Dr. Rodrigue Sabin MompelatEnseignant-ChercheurIngénieur Logiciel - Copenhague - Danemark

En direct des labos !Dans les laboratoires, écoles, centres de recherche, on découvre parfois de petitesmerveilles. Voici quelques exemples que nous avons retenus ! Bonne découverte.

2e partie

L’adorable minimalisme de Pondus et un exemplede diagramme pondéral.

81 20/05/2009 11:47

livres \\ par François Tonic


PARALLÉLISMEProgrammation concurrente en Java

Difficulté : ****

Editeur : Pearson

Auteur : Brian Goetz

Prix : 39 €

La programmationconcurrente est un

des défis majeurs des développeurs pourparalléliser leurs codes. Plus que jamais, ledéveloppeur doit connaître et maîtriser l’en-semble des contraintes du parallélisme et laconcurrence fait partie de ces problèmes. Ils’agira tout d’abord de définir le sujet et lescontours de la concurrence. Puis on rentre-ra dans le vif avec les éléments basiques àmaîtriser absolument : thread safety, parta-ge des objets, la composition de ceux-ci…Ensuite, on attaque la concurrence : exécu-tion des tâches, leurs annulations et arrêts,le pool de thread… Au-delà de cela, se posela difficulté de stabilité de la concurrencedans le code et la nécessité d’avoir un codeoptimisé et robuste, d’où l’importance destests. Et pour ceux qui poursuivront leur lec-ture jusqu’au bout, l ’auteur proposequelques morceaux de choix : verrous expli-cites, synchronisation non bloquante. Par-fois ardu, ce livre nécessite une bonneconnaissance de Java mais les principes dela concurrence peuvent s’appliquer àd’autres langages. De nombreux codes, desconseils émaillent les pages ! Incontour-nable !

WEBHTML, le guide complet 3e édition

Difficulté : **

Editeur :

Micro Application

Auteur :

Fabrice Lemainque

Prix : 22 €

HTML et cie nesont pas morts.La preuve, avec la3e édition de ce

guide complet. Le but ici est d’expliquer lelangage et de rapidement pouvoir program-mer ses propres sites. L’auteur y présenteles bases à connaître : les fonctions, lesbalises, le fonctionnement de HTML,xHTML, etc., la sécurité, les données, etc.

Mais dynamisme oblige, les CSS et scriptsne sont pas oubliés. On regrettera tout demême l’absence de HTML 5.

WEBDu web 2.0 au web 3.0

Difficulté : *

Editeur : Eni éditions

Auteur :

Jean-Noël Anderruthy

Prix : 20,95 €

Eh oui, sans le savoir nous sommes déjàpassés au web 3.0, et on parle déjà du web4.0 (100 % cloud). Le titre est trompeurcar en réalité, l’ouvrage aborde ce qui estdéjà là, tout un ensemble de services, plusou moins " nouveaux " mais qui sont dans lamouvance du web 2. On parle de flux RSS, de widgets, de mobilitédu web. Quelques éléments pourraient êtrereliés au " web 3 " même si dès maintenant,on peut les mettre en œuvre, par exemple la nouvel le génération de moteur derecherche (tourné vers le côté sémantique)ou encore HTML 5, les web slices… Unegrosse partie est aussi consacrée aux appli-cations et documents en ligne, à la collabo-ration, la cartographie. Le développeur web ou toute personne voulant se tenir au courant, trouvera là un condensé despossibilités actuelles du web.

SGBDSQL Server 2008

Difficulté : **

Editeur : Microsoft Press

Auteur : Mike Hotek

Prix : 39 €

Apprenez pas à pasSQL Server 2008avec un guide pra-t ique qui vous

explique comment mettre en œuvre desbases de données pour répondre à desbesoins professionnels réels. Tout y passe :installation, configuration, création de table,cluster, sécurisation, optimisation et perfor-mance. Une centaine de pages complémen-taires sur la Business Intelligence et denombreux exemples de code sont dispo-nibles dans la rubrique Suppléments enligne associée à cet ouvrage sur le sitedunod.com.

ORGANISATIONCobiT

Difficulté : ** / ***

Editeur : Eyrolles

Auteur : collectif

Prix : 39 €

Référence incontour-nable au sein de lacommunauté desauditeurs informa-

tiques depuis plus de dix ans, CobiT (ControlOBjectives for Information and related Techno-logy) est devenu un standard de la gouvernan-ce des systèmes d'information. Les auteurss’appuient sur la version 4.1 de la méthode.La première partie dresse un panorama desdifférents référentiels existants, en décrivantleurs champs d'action et leur positionnementvis-à-vis de CobiT. Dans la deuxième partiesont détaillés les 34 processus de CobiTselon un plan standard, avec mise en lumièrede leurs forces et faiblesses. Enfin, la troisiè-me partie expose des cas pratiques d'utilisa-tion et de déploiement, correspondant à unvéritable mode d'emploi du référentiel.

LIVRE DU MOISHello,AndroidDifficulté : ** / ***Editeur : O’ReillyAuteur : Ed BurnettePrix : 26 €

Vous rêvez dedévelopper pourAndroid, le nou-veau système envogue pour téléphone ? Pourquoi ne passe lancer dans sa découverte avec Hello,Android. L’auteur plonge au cœur du kitde développement et des API. On démar-re par l’installation des outils et du SDK,puis on fait le tour du propriétaire etnotamment de l’émulateur. L’auteur abor-de ensuite les briques fondamentales dusystème avec des fonctions basiquescomme l’interface (et le design à adopter,le multimédia, les données locales, etc.).Bien entendu, pour le développeur quivoudrait aller plus loin, il existe de nom-breuses fonctions avancées que l’onretrouve dans ce livre telles que OpenGL,la localisation. Détail intéressant, onretrouve les sous-ensembles du langage.Plaisant à lire et instructif, un ouvrageincontournable sur Android. En anglais.

82-120 20/05/2009 11:47

DEMANDEZ LE DOSSIER GRATUIT

RÉUSSISSEZ TOUS VOS PROJETSAVEC L’OUTIL DE DÉVELOPPEMENTÉLU LE PLUS PRODUCTIF

01/02-83/84-120 20/05/2009 9:42 Page 3


01/02-83/84-120 20/05/2009 9:42 Page 4


Programmez120

Documents

Transcript of Programmez120