Archive

Archives pour 03/2010

Alpes JUG : Maven – Construire vos applications d’entreprise

Lundi soir (29 mars) c’est la 2ème soirée de l’Alpes JUG.
Arnaud Héritier, membre de la communauté Apache Maven et auteur d’un bouquin sur le sujet, vient présenter les nouveautés de Maven 3 ainsi que des retours d’expérience sur son utilisation dans une forge logicielle.
Si ça vous intéresse, n’hésitez pas à vous inscrire sur le site de l’Alpes JUG.
Rdv à 18H30 (début de conf à 19H) à l’amphi E de l’ENSIMAG.

PS : ne le répétez pas, mais  Objet Direct est désormais sponsor de l’Alpes JUG. Plus de détail bientôt ;-)

Categories: Actualités Tags: ,

Les tweets de la semaine !

Categories: Divers Tags: ,

The Sun and Intel Road show

Sun Microsystems et Intel animerons un séminaire autour de la virtualisation et l’impact du choix de celle-ci sur une éventuelle solution de « Cloud Computing » adoptée par une entreprise.

Le séminaire aura lieu le 8 avril à Paris. L’inscription au séminaire est gratuite et disponible à l’adresse suivante http://www.beyond-the-buzzwords.com/register.php.

Un autre séminaire traitant le même sujet aura lieu le 5 mai à Lyon.

Pour avoir plus d’informations, suivez ce lien.

Categories: Cloud, Divers Tags:

QCon London 2010 – Udi Dahan – Avoid a Failed SOA

“Business & Autonomous Components to the Rescue”

image Malgré un sujet pas très original, avec peu d’idées réellement neuves, probablement la meilleure présentation à laquelle j’ai assisté aux QCon 2010 de Londres. J’y ai été particulièrement sensible, du fait que j’ai moi-même réalisé et animé des séminaires sur des sujets similaires. Et j’ai pris une leçon, sur la forme comme sur le fond.

Sur le fond, finalement, un seul message simple est véhiculé par Udi Dahan : une condition nécessaire à la réussite d’une SOA c’est l’émergence de composants très faiblement couplés. Pas vraiment une surprise. Mais c’est grâce à une forme étudiée que son discours (simple mais pas simpliste) amène à se poser des questions profondes.

Sur la forme donc, un discours extrêmement clair sans utilisation d’aucun buzz, et un enchaînement logique des idées qui mène inexorablement l’auditoire à ses conclusions inéluctables. Quand la vidéo de cette présentation sera en ligne sur InfoQ (malheureusement, ils les distillent pendant six mois), ne la ratez pas.image

Je vais tenter de résumer.

Le sujet c’est le projet d’intégration. Pourquoi ça rate souvent, et comment faire que ça rate moins :-) On a le droit de se tromper plusieurs fois, mais à chaque fois différemment !

La présentation oscille autour de l’architecture entre la vision métier et la vision technologique.

SOA et couplage faible

Un des objectifs de la SOA est d’atteindre un couplage faible entre composants métiers autonomes. Tout le monde est d’accord là-dessus. Mais ce couplage faible doit être une exigence à la fois métier et technique qu’il faut prendre en compte à la conception comme à l’exécution.

imageUdi part d’un SI théorique plutôt bien aligné sur le métier (avec une véritable architecture fonctionnelle explicite) dont on pourrait se dire qu’il est facilement “SOAisable”.

Il montre qu’une intégration des applications par des services (une SOA) peut, en fait, mener facilement à des applications très fortement couplées qui amènent, en production, leur lot de contentions (mémoire, threads, locks base de données…) .

So what ? Qu’est-ce qu’on a loupé ?

On a oublié que pour obtenir le découplage à l’exécution il faut des communications asynchrones (d’un point de vue fonctionnel et pas seulement technique). Et il y a de fortes conséquences sur… la conception.

Il faut donc basculer du requête/réponse à la publication/abonnement (d’une architecture orientée services vers une architecture orientée événements). C’est la succession d’émission d’événements qui matérialise le processus et non l’orchestration d’appel de services. Et c’est l’émetteur qui définit le contrat de service et non le receveur. On parle d’Event Driven Architecture (EDA).

Mon avis

Même si ce qui vient d’être dit est parfaitement logique en terme d’affectation de responsabilités, la plupart des démarches de conception travaillent dans l’autre sens : le contrat de service est défini à partir du besoin du client du service (c’est ce qu’on fait quand on fait de la conception d’application : c’est le scénario d’utilisation qui définit les services publiés par le serveur métier). Il faut donc changer radicalement son mode dimagee conception lorsqu’on fait de la SOA/EDA : les contrats de service doivent être définis uniquement par les changements d’état des objets métier et non par les “clients” de ces changements d’état.

Autre réflexion que m’inspire cette vision (originale) de ce qu’est un processus SI : un enchainement infini d’événements. On ne peut plus définir un Processus avec un début (l’Evénement déclencheur) et une fin (un Produit de sortie) créant de la valeur pour son Client. C’est une révolution conceptuelle (on remet en cause la définition d’un processus selon l’ISO !) et surtout, ça pose un gros problème. Comment appliquer la doctrine millénaire du consultant en processus : “centrer les processus de l’entreprise sur le client”, si le client de l’entreprise n’est plus le client du processus ? Je n’ai pas de réponse pour le moment :-)

Composants métier autonomes

Udi Dahan évoque ensuite une autre question délicate. Comment partitionner les services en composants autonomes ? A nouveau, une réponse évidente est : aligner les composants sur le métier. Un composant métier par bloc fonctionnel. Un rêve d’urbaniste !

Il montre qu’en fait, ce partitionnement “idéal” ne répond pas toujours au besoin et  imageparticulièrement aux exigences non fonctionnelles. Il donne l’exemple des SLA différents en fonction du type de client et propose donc des composants métier autonomes techniquement (potentiellement très différents dans l’implémentation), définissant les mêmes contrats de service mais implémentés différemment.

Mais à nouveau, comment éviter un couplage si, finalement le routage des événement doit se faire en fonction de leur contenu (l’événement contenant un “petit client” doit être routé vers le composant dédié petit client, l’événement “gros client” vers le composant dédié gros client).

Le fonctionnement EDA précédent permet, à nouveau, à chaque composant d’être autonome dans la prise de décision : tous les composants d’un même métier sont abonnés aux mêmes événements et chacun décide de manière autonome de traiter ou non un événement particulier en fonction de son contenu.

A bientôt pour d’autres conférences QCon.

Categories: Web Services - SOA Tags: , , , ,

Presentation d’Entity Framework

Voici un premier billet présentant de manière générale l’outil de mapping objet relationnel proposé par Microsoft : Entity Framework. Je proposerai par la suite d’autres billets sur des points spécifiques au mapping objet relationnel tels que :

  • les identifiants
  • les associations entre entités
  • l’héritage
  • les stratégies de chargement

Afin de lever toute ambiguïté, je tiens à préciser que j’arrive du monde Hibernate, un outil de mapping objet relationnel open source reconnu et aujourd’hui normalisé avec JPA (Java Persistence API). C’est pourquoi je ferai régulièrement référence à cet outil que j’apprécie particulièrement. Ceux qui connaissent (N)Hibernate ne seront pas trop dépaysés car certains mécanismes ont été repris.

La première version d’Entity Framework ne m’a pas vraiment convaincu.

  • L’idée fondamentale qui est de séparer le modèle conceptuel (CSDL : Conceptual Schema Definition Language), du modèle logique de bases de données (SSDL : Store Schema Definition Language) en détaillant le mapping dans un schéma de liaison (MSL : Mapping Specification Language) est théoriquement très intéressant mais se révèle assez lourd dans la pratique : le designer proposé dans Visual Studio étant limité, il faut très rapidement éditer LE fichier XML manuellement qui est encore plus verbeux qu’un fichier de mapping Hibernate !
  • Par ailleurs, les objets entités étaient nécessairement très liés au framework : héritage d’implémentation, utilisation de collections propres à EF…
  • L’approche outillée était une approche relationnelle : à partir d’un modèle relationnel et EF génère des classes persistantes.

Avec la nouvelle version (Entity Framework 4), et notamment avec Entity Framework Feature CTP 3, également connu sous le nom de code-first, je commence à trouver l’outil très intéressant.

Comme son nom l’indique, code-first permet d’écrire des classes en premier, puis de générer un modèle relationnel issu de ces classes. C’est cette approche que je vous propose d’aborder dans ces billets avec la modélisation d’un système d’information (très simplifié) d’une banque. Dans une banque le client est roi, nous commencerons donc par la classe Client:

public class Client{
   public int Id { get; set;}
   public string Nom { get; set;}
   public string Prenom { get; set;}
}

Pour fournir à Entity Framework les informations de mapping, nous utiliserons le mode fluent. Pour cela, on définit généralement une classe de configuration par entité qui étend de EntityConfiguration<T>.

public class ClientConfiguration : EntityConfiguration<Client>{
   public ClientConfiguration(){

   // la propriété Id est l'identifiant de base de données
   this.Property( client => client.Id)
        .IsIdentity();

   // la propriété Nom ne peut pas être null
   // elle a une taille max de 200
   this.Property( client => client.Nom)
        .IsRequired()
        .HasMaxLength(200);
   }
}

Cette manière d’utiliser les lambdas expressions est de plus en plus fréquente en C#. On la retrouve notamment dans Fluent Nhibernate. Les fichiers de mapping XML sont contraignants à éditer et à maintenir. Les annotations sont plus simples d’utilisation mais leur présence dans nos classes POCO impliquent une forme d’adhérence vers le framework : une dépendance de compilation. Dans une application RIA avec Silverlight , il est fréquent de référencer l’assembly contenant le modèle du domaine. Mais une dépendance de compilation des classes du domaine vers un framework de mapping objet relationnel rend caduque ce référencement. Le mode fluent permet de décrire le mapping dans une assembly tierce, sans la lourdeur du XML avec en prime une vérification au moment de la compilation, de la complétion et du refactoring !

Je détaillerai dans mon prochain billet la configuration du ContextBuilder à partir de nos classes de configuration. C’est l’équivalent de la SessionFactory. Une fois configurée, cette fabrique va permettre  à EF de générer notre schéma de bases de données. Par défaut, il va créer une table Clients avec 3 colonnes :

  1. Id : la clé primaire de la table auto incrémentée
  2. Nom : un nvarchar de 200 non null
  3. Prenom

Nous avons vu dans ce premier billet la mise en place d’un mapping simple entre un POCO vers une base de données relationnelle, les éléments de mapping étant fournis dans une classe C# en mode fluent.

Categories: .NET Tags: , ,

Présentation Android

Ce billet présente mon retour sur la demi journée de séminaire que j’ai pu suivre mardi chez nos confrères de Valtech Training animé par Olivier Penhoat.

Le marché du smartphone.

Android arrive sur un marché difficile étant donné la place prépondérante des OS historiques. Là où l’iPhone a percé avec insolence, révolutionnant les standards, Android peine à démarrer.

Dans un premier temps, n’oublions pas que l’on parle de deux sujets différents : d’un côté il y a toute une stratégie marketing avec un OS destiné à un objet unique, et de l’autre un OS disponible sur de multiples plateformes intégrant chacune des périphériques différents qu’il faut pouvoir orchestrer de façon identique.

De plus, cet OS n’est pas destiné spécifiquement aux smartphones comme on aurait tendance à le penser en premier lieu mais à une multitude d’appareils mobiles (tablettes, GPS, ordinateur de bord automobile, …).

Contrairement à ce que l’on peut penser à première vue, il semblerait que le marché à venir concerne ces divers appareils encore plus que les smartphones !

Google nous propose donc ici un système qui se veut ouvert :

  • Applications (internes et tierces) toutes logées à la même enseigne (accès à toutes les ressources)
  • Personnalisation poussée du bureau
  • Applications modérées à postériori
  • Pas d’IDE/OS imposé pour les développements
  • Développement sur des standards du marché (Java/XML)

Comment cela se présente-t-il ?

Le système

L’architecture est basée sur un noyau Linux récent, agrémenté des divers drivers fournis par les constructeurs. Ensuite il y a une couche de libraires dont le « runtime Android » contenant une VM optimisée (Dalvik), puis une couche identifiée comme le SDK Android permettant un accès via le langage Java aux développeurs.

Attention néanmoins, la VM Dalvik est assez spécifique :

  • Bytecode propriétaire
  • Fonctionne sur un registre et non une pile pour optimiser la mémoire.
  • Une instance de VM par processus.

L’outillage

Il est plutôt complet, on note entre autres :

  • Android Debug Bridge : envoi de commandes sur l’appareil (ou son émulation).
  • Un émulateur (permettant de simuler les différentes versions, matériels) avec déploiement à chaud.
  • Dalvik Debug Monitor Service : affiche notamment les logs de la VM.
  • Android Development Tools : plugin pour IDE au choix permettant de gérer une structure de projet Android et de mettre en place les IHM visuellement.

Composition d’une application

Le fichier manifest

Il sert de contrat pour l’application. Toutes les ressources que l’application va utiliser doivent y être déclarées : géolocalisation précise ou non, accéléromètre, appels, …

Une orchestration via des « intentions »

Les intentions sont très similaire à REST, il s’agit d’une ressource identifiée par son URI liée à une action simple (MAIN retourne à l’accueil, PICK sélectionne la ressource, EDIT …).

4 composants proposés comme cadre :

  • Les activités : le cœur de l’application, en général une activité est fortement liée à un écran.
  • Les fournisseurs de contenu : le nom est plutôt explicite, il va géré les accès aux différents contenus pour  donner un accès simplifié à l’application.
  • Les services : ce sont les processus lancés en tâche de fond, tournant même quand l’application n’a plus la main.
  • Les récepteurs d’intention : prennent en compte des évènements extérieurs (appel entrant).

Limites

La fragmentation

La première limitation vient de l’objectif même d’Android : la multiplication des appareils sur lesquels il est amené à fonctionner et donc des configurations différentes à gérer par le développeur, notamment les tailles d’écran, présence d’accéléromètre, …

On appelle cela la fragmentation et elle se multiplie encore avec les différentes versions d’Android proposées par les constructeurs : v1.5 : 30%, v1.6 : 54%, v2.0.1 : 15% …

Il faudra donc composer avec toutes ces configurations !

Android Market

La place de marché pour les applications Android, mis en place par Google souffre de nombreuses lacunes mettant un frein à son développement :

  • Mauvaise gestion des commentaires
  • Achat uniquement via le système de paiement Google (Checkout)

Conclusion

Olivier nous a fait une démonstration rapide et efficace de la mise en place d’une application Android. Le résultat est flagrant, il parvient très rapidement à afficher une carte Google Maps avec notre dernière position géographique donnée par le GPS …

Pendant la session, il nous a confirmé plusieurs fois que le développement était très simple malgré la fragmentation, qui est plutôt bien gérée par le SDK, pour faire des choses simples. Le pendant de ce système ouvert reste sa complexité quant on veut faire des choses qui sortent du cadre.

De plus, il ne faut pas oublier que l’on déploie une application sur un mobile et non un serveur d’application ! Il faudra donc, même si l’on travaille en Java, repenser notre façon de développer afin d’optimiser certaines structures de code.

Categories: Actualités, Mobile Tags: ,

Les tweets de la semaine !

Categories: Divers Tags: ,

Un SDK pour consommer des services de données REST OData

J’avais publié il y a quelques temps déjà un article sur comment publier des données dans un format REST en .NET. Initialement Astoria, ce projet a été renommé en ADO.NET Data Services. On parle aujourd’hui de WCF Data Services.

Le format REST utilisé est formalisé dans l’OData (Open Data Protocol), ce qui en théorie permet de consommer des services de données .NET depuis d’autres environnements. Un scénario de déploiement serait de publier ces services dans le Cloud sur une plateforme Azure afin que des clients IPhone ou Java par exemple puissent consommer les données. Dans la pratique, il faut implémenter la brique logicielle qui va permettre de dialoguer avec du OData, ce qui limite considérablement l’utilisation extensive de ce format.

Afin de pallier à ce problème, l’équipe Astoria a annoncé la sortie d’un SDK comprenant notamment une librairie IPhone, une librairie Javascript et une librairie Java. Le SDK embarque par ailleurs des outils comme un « Explorateur de données ».

QCon, Modèles et Intégrisme

This post is available in english on my personal blog.

QConJe rentre juste de trois jours aux QCon de Londres. C’est comme toujours un grand moment permettant une véritable prise de recul. Je peux respirer, ouvrir les yeux sur ce que font les autres et comment ils travaillent, sentir quelles sont les tendances et surtout, tenter d’appréhender ce que sera mon job dans un an, voire, plus loin.

Promis, je vous ferai, dans les jours qui viennent, une compilation des meilleurs moments de la conférence et des points les plus marquants. Mais avant tout, je voulais vous faire une réaction à chaud sur quelque chose qui me semble important.

Je reviens aujourd’hui avec un goût désagréable dans la bouche (non ce n’était pas la bière qui était, comme toujours, excellente). Un goût amer et un peu de colère aussi.

En deux mots : la modélisation n’est plus simplement absente (comme c’était pratiquement le cas lors des deux dernières éditions), c’est devenu un gros mot.

Que le code soit à l’honneur, c’est bien naturel dans une conférence consacrée au développement. Que l’on fustige les erreurs commises par le passé (en particulier la “sur modélisation” symptomatique d’un déficit de confiance dans les processus de développement) me semble aussi plutôt sain.

Mais que l’on entende des sentences définitives du genre “comme chacun le sait, les modèles ne servent absolument à rien” dans la bouche de stars comme Robert C. Martin, alias Uncle Bob (qui a pourtant écrit en 2003 un remarqué “UML for Java Programmers” !), qu’un Dan North (par ailleurs excellent, je vous en reparlerai) considère l’usage d’un modeleur comme une inutile “complification”, relève de l’hypocrisie, de la démagogie ou de l’intégrisme (voire de la simple bêtise, indissociable du dernier).

La seule conférence à laquelle j’ai assisté qui faisait encore la part belle aux modèles était celle d’Eric Evans qui parlait de conception agile. Encore avait-il rayé le mot Modèle du titre, pour celui de Design plus consensuel. C’est lui qui a, d’ailleurs, eu le mot juste : en abandonnant la modélisation, la communauté du développement a, un peu trop rapidement “jeté le bébé avec l’eau du bain” (sic).

En fait, j’ai eu l’impression d’être dans le domaine du religieux et d’assister à des professions de foi.

Il y a, d’un côté, les fondamentalistes du code, pure monothéistes, nostalgiques d’un âge d’or mythique où le développeur était le seul maître de sa production, en relation directe avec Dieu (le Product Owner), dépositaires d’un savoir millénaire (le Software Craftsmanship) qui se transmet de bouche de gourou à oreille de disciple.

Et il y a la secte des UMListes, vus comme de dangereux illuminés schismatiques, dont les délires auraient corrompus le monde parfait des précédents et qu’il faut exterminer par tous les moyens. J’ai eu l’impression d’être soumis à une fatwa.

Comme toujours lorsqu’il y a des problèmes, il faut trouver des boucs émissaires. Les modèles (et ceux qui les font) semblent jouer ce rôle aujourd’hui : symboles du “Big Upfront Design”, c’est eux qui portent la responsabilité des échecs des grands projets. Les modèles sont vus comme des artefacts de pure documentation : modéliser serait une activité chronophage et inutile (voire perverse), en particulier dans un monde agile.

Dans un tel environnement, impossible de sortir ma carte de visite : sous mon nom, il y a marqué “MDA business line manager”. Comme une maladie honteuse.

Pourtant, il me semble que modéliser, au contraire de développer, permet :

  • d’analyser un problème,
  • de compresser sa complexité,
  • d’appréhender sa globalité,
  • de s’abstraire de contingences techniques,
  • de communiquer.

Mon cerveau n’est pas suffisant pour faire tout ça sans assistance. J’ai besoin d’UML (ou de tout autre formalisme), à la fois comme d’une béquille, d’un tableau blanc, d’une extension de mémoire et d’un formulaire de maths.

Modéliser n’est pas antagoniste de développer (sans parler de MDA qui combine les deux activités) : modéliser permet simplement de mieux développer.

Et d’ailleurs, le code EST un modèle (“système d’abstractions qui décrit des aspects sélectionnés d’un domaine”), au même titre qu’un diagramme UML. Juste un peu plus verbeux (et un peu plus facilement exécutable).

Pour conclure, il me semble que ce hiatus est, avant tout, très représentatif de modes de pensées différents : une pensée analytique “à la française” (après tout, Descartes et Merise sont des créations bien de chez nous) face à une pensée pragmatique anglo-saxonne.

J’aime à penser qu’il y a du bon dans les deux mondes et que les deux se complètent agréablement. C’est même ce qui, à mon avis, constitue l’intérêt principal de notre métier : analyser des problèmes pour informatiser leur résolution. C’est ce qui quotidiennement renouvelle ma motivation : comment faire rentrer dans un (bon) programme la complexité du monde réel.

TechDays 2010 : les WebCasts en ligne

Si vous n’avez pas pu suivre toutes les sessions qui vous intéressaient aux TechDays 2010, les WebCasts ainsi que les présentations sont disponibles en ligne.

Categories: Divers Tags: