Bonjour,
Voici deux semaines se tenaient les Microsoft Tech Days à Paris, et OCTO y était. Voilà un comtpe rendu des séances auxquelles nous avons assisté, garanti sans langue de bois. Merci à Sofian, Maxence et Vincent pour leurs retours.
Session intéressante sur l'utilisation du framework Rx par Mitsuru Furuta et 2 personnes de chez Thalès. Pour rappel, Rx est une librairie développée par Microsoft (non comprise en natif dans .NET) permettant de faire de la programmation asynchrone sur des listes d'objets suivant le pattern Observer/Observable.
Rx a été poussé puisqu'il n'y avait pas d'uniformité sur les outils/frameworks de développement asynchrone.
Le principe est de pouvoir utiliser les mêmes outils dispo pour les IEnumerable (Linq query) sur des listes observables. On passe d'un modèle "push" (je fais un foreach sur une liste et pour chaque élément j'envoie une action) à un modèle "pull" (je prépare mes conditions pour observer des évènements sur une liste et dès qu'ils apparaissent, je lance un event asynchrone et mes clients font leur traitement associé).
Un exemple : j'ai une liste de clients. Lorsqu'un texte saisi change je veux pouvoir effectuer une action. En Rx ça donnerait :
var input = (from event in Observable.FromEvent<EventArgs>(text, "TextChanged")
select ((TextBox)event.Sender).Text)
On peut ajouter des conditions puisqu'on est en Linq (je veux envoyer une notification seulement si le texte est égal à "toto", etc...).
Pour en revenir à la session, la première partie était une intro assez générique sur la nécessité de faire de la programmation parallèle (arguments classiques du type : faut pas freezer les UI !) et une introduction à Rx.
Le reste de la présentation était axé autour de code Rx (développement d'un Timer puis d'un comportement de drag & drop d'une forme géométrique). On a vu durant cette démonstration un large panel d'opérateurs utilisables sur les listes d'observables (on peut ajouter plein de filtres/conditions/comportements sur notre requête Linq).
Des exemples de requêtes effectuées : on drag uniquement si on bouge la souris autour d'une certaine zone autour de la forme, on notifie le changement d'un texte au bout de x millisecondes seulement s'il n'a pas changé... Mon retour : présentation intéressante mais trop focalisée sur les exemples (j'ai trouvé qu'on passait trop de temps à faire un drag & drop au lieu de parler par exemple du IScheduler ou d'autres points de Rx). Bonne présentation globalement.
Cette présentation de Don Syme (lead Microsoft sur F#) avait pour but de présenter l'avancée du langage fonctionnel de Microsoft.
Petit rappel : F# est un langage fonctionnel basé sur le framework .NET. La syntaxe est quasi identique à celle du OCAML (let rec x = ... match ...) en reprenant également les principales features (pattern matching, type inference...). F# garde donc également des caractéristiques des langages orientés objet en plus de l'utilisation du framework .NET (ex : linq).
La première partie de la session était une présentation de F# et des bénéfices de l'utilisation d'un langage fonctionnel. Don Syme a cité les banques d'investissements comme principaux consommateurs du langage. Effectivement, les caractéristiques de F# en font un langage adapté au milieu de la programmation parallèle (typage safe et immutable, closures, asynchronisme sans gestion de threads par le développeur, currying permettant l'exécution parallèle de fonctions...). On peut retrouver du F# dans des moteurs de calcul de risque financier. Don Syme a avancé un nombre de 120 développeurs chez Crédit Suisse faisant du F# pour du code "analytique".
F# est testable unitairement (pas de démo sur ce point).
Revenons à la session. Suite à la présentation "F# as of today" de Don Syme, démonstration de l'utilisation de F# via un proto sur Windows Phone. Très peu de code a été montré, on a surtout vu un mec bouger son WP7 pour tester l'accéléromètre et faire afficher des graphiques. Il semblait vouloir nous montrer la possibilité de gérer des évènements (accéléromètre) en F#. Peu de code, très brouillon... cette partie n'a pas été utile à mon goût.
La 3e partie de la session était orientée sur WebSharper pour F#. WebSharper est un framework de développement web pour .NET. Sur la version F#, les développeurs ont la possibilité d'écrire du code F# qui sera mappé sur du JS par le framework (via un attribut [JavaScript]). Il y a quand même la possibilité d'utiliser du JS directement avec la compatibilité vers notamment jQuery et Yahoo UI.
Sur le F#, WebSharper ajoute la notion de "Formlet". Un formlet est un type de page proposant des fonctionnalités de formulaire (controles UI, gestion de la validation client/server). On a également eu la présentation des "sitelets" qui sont des conteneurs de pages selon le pattern MVC "bijectif" (une requête déclenche une action mais une action côté serveur peut également lancer une requête avec le même code).
Dernière partie de la présentation par Don Syme sur le futur de F#. Grosse déception pour ma part sur cette partie. Don Syme n'a parlé que d'une "factory" sur le cloud Azure offrant des types de données. Concrètement, on a un DataProvider sur le cloud qui permet de manipuler des structures de données définies (objet "Baseball" utilisable en Baseball.Joueur.Caracteristique...). Il y a un Marketplace sur ces données où les développeurs ont la possibilité de réutiliser des modèles de données pour une interopérabilité totale dans un monde idéal. Le seul rapport avec F# est que le langage est capable de faire de l'inférence de type.
Mon retour : assez déçu de cette présentation. Etant moins documenté/intéressé par les langages fonctionnels je pense que je n'aurais pas été convaincu par "F# c'est trop bien en finance". Peu d'exemples, des arguments flous (ex : on peut faire du TU. Point.) et quasiment pas de code montré avec une petite interlude publicitaire pour WebSharper.
Présentation de 3 personnes de la boîte So@t sur les pratiques d'architecture en Silverlight et WPF.
La présentation a commencé par une explication du pattern IoC et de deux conteneurs : Unity et MEF (Managed Extensibility Framework). Les deux conteneurs ont été opposés et la conclusion est qu'Unity est en mode centralisé (il faut connaître toutes les classes/interfaces) alors que MEF est en mode décentralisé (mode plugin, on charge des assemblies et c'est parti).
Ensuite, une explication du pattern MVVM avec un mini-débat sur "view first" vs "view-model first".
La présentation s'est poursuivie avec une très brève introduction à Prism pour enchaîner sur un produit de leur boîte : SoPrism. SoPrism est une librairie de templates pour Visual Studio générant des projets sur le pattern MVVM et Prism. Ce qui est généré : une arborescence de projet, des références vers des DLL dans tous les sens.
Mon retour : j'étais vraiment déçu par cette présentation qui n'a absolument pas parlé d'anti-patterns (bonnes pratiques par rapport à quoi ?!) et qui a surtout servi à présenter leur outil "SoPrism". De plus, la présentation était brouillon et par moment fausse (ex : je préfère le view-model first puisqu'on ne peut pas mocker de données dans une vue). De mon point de vue la session n'était absolument pas alignée avec son titre (qui était pourtant alléchant).
ALM = Application Live Management
N'ayant jamais travaillé avec TFS j'avais envie de découvrir ce que c'était. Du coup il y a surement plusieurs choses évidentes que j'ai tout de même noté.
Donc, une présentation globalement pas passionnante mais au moins les intervenants n'étaient pas nuls : ils venaient d'une boite de Toulouse nommée Bewise. Sur les 50 personnes dans la salle il y avait environ 7 personnes qui utilisait TFS sur leur projet. TFS Basic est une plateforme plus légère et facile à installer que la version de TFS classique. Différentes méthodologies sont implémentées dedans (Agile, CMMI, Scrum,...) et la personnalisation des Work Items permet de les adapter au besoin. Un plugin existe pour permettre aux managers de gérer les projets depuis Excel. Le controleur de code source présente 2 fonctionnalités notamment mises en avant durant la présentation :
Il a voulu d'ailleurs bien faire noter la différence entre Version Control et Visual SourceSafe... Qui n'a pas très bonne réputation apparament (c'est du ressenti : car je ne l'ai jamais utilisé).
Le build TFS peut lancer les Tests Unitaires sur le poste de travail avant de valider l'archivage (ça doit éviter pas mal de commit pourri). On peut "personnaliser" le build grâce au Workflow foundation (ce qui est plus "sexy" pour l'intervenant). Enfin on a eu droit à une démo ratée à la fin ou le mec n'arrivait plus à faire ce qu'il voulait (un import de projet vers TFS si je me souviens bien...).
Présentation inutile pour une personne non intéressé par le sujet comme moi.... J'avoue que je suis allé la voir uniquement parce que j'ai rencontré un ancien octo et nouveau consultant MS (Nicolas Mangin) et manqué la présentation sur PowerShell (grrrrrrrrrrr : quelqu'un est allé la voir ?). Mais bon en gros c'est un système plus poussé que le XP Mode de Windows Seven. L'autre chose que j'ai apprise est que 14h30 était le créneau le plus complet pour les présentations... Sur 5 présentations qui avaient l'air intéressantes on s'est fait recaler à 5.
Bon, j'y allais essentiellement pour voir les nouveautés dans WCF, c'est reglé, y'en a pas. Donc présentation de WCF, de Open Data, de WCF Data Services et WCF RIA Services. Un gros focus sur le dernier, qui est le petit chouchou de Microsoft en ce moment, mais avec un GROS bémol : hors Silverlight, point de salut. RIA services, ça ne fonctionne pas en client lourd, avec d'autres technos, bref, faut du Silverlight comme client, point barre.
La présentation était intéressante, avec un juste milieu entre le coté découverte et le technique. Un bon survol pour les novices, une bonne piqure de rappel pour les autres, le seul regret est le peu de perspectives offertes.
Attention, session pour barbus. En même temps, niveau 400, on était prévenu. Ma préférée du lot, en fait, même si l'intro était un peu légère. Passer 10 minutes sur MinWin, c'était trop, alors que ça se résume vite. Mais une fois ça passé... Vous vouliez savoir comment marche l'allocation de mémoire au niveau du silicone ? Pourquoi, après 3 exécutions, votre programme cesse subitement de planter ? Les principes du core parking et du timer coalescing ? Fallait venir.
-> Allocation de mémoire
Saviez vous que quand vous demandez 1 octet, vous obteniez 64k (dont 63999 inutiles et bloqués) ? Qu'on peut donc avoir un out of memory avec un programme qui, finalement, consomme peu ? Que ce n'est pas parce qu'il y a 2 Mo de libre qu'on peut les allouer, encore faut-il qu'ils soit contigus sur le silicone ? Qu'il n'y a qu'une seule fonction pour allouer la mémoire (VirtualAlloc) ? Et que du coup, la différence entre le tas et la pile, c'est que le tas préalloue de la mémoire pour vous la donner par petit bout (permettant ainsi des allocations inférieures à 64k), alors que la pile tape directement sur la RAM ?
-> Fault tolerant Heap
Des fois, les programmeurs font des bétises. Souvent, même. Du coup, ça plante, et l'utilisateur se dit "chez Microsoft ils sont tout naze", même si ça vient du dernier shareware pour dialoguer (culture et cinéma) avec des suédoises nues. Or, chez Microsoft, faut croire qu'ils n'aiment pas être accusés pour les plantages des autres. Du coup, quand un programme plante trop souvent, il passe sous la surveillance de la Fault Tolerance Heap. Kezako ? Simplement un outil de gestion mémoire qui permet, par exemple, de libérer deux fois la même zone mémoire sans faire planter le programme. Ou qui, quand on lui demande 1 octet, en réserve silencieusement 2000 pour éviter les buffer overrun. Alors oui, le programme est plus lent. Mais il ne plante plus.
-> Core parking & timer coalescing
C'était mis en avant dans les présentation de W7, celui-ci endort les coeurs du processeur qui ne servent à rien. Mieux, il va regrouper le boulot sur un nombre le plus faible possible de coeurs, avec comme maxime "mieux vaut un coeur à 100% et un qui dort que 2 à 50%". Pourquoi ? 1/ ça utilise moins d'électricité, et ça, dans un datacenter, ça aide et 2/ sur les processeurs modernes, quand on endort des coeurs, les autres vont plus vite. Donc ça permet de gagner en efficacté sur les programme monothreadés (et il y en a encore beaucoup).
Le timer coalescong, ça part d'une idée bête. Quand vous mettez un timer à 100 ms sur un programme, dans 95% des cas, vous voulez juste faire du polling. Du coup, qu'on soit pile à 100 ms, ben finalement, ça importe peu. Ca pourrait être 150 une fois, 78 la fois d'après, etc. sans changer la vie de votre programme. Sauf que pour la conso de la machine, ça change. Si tous les timers sont exacts, on passe son temps à reveiller des coeurs pour leur faire exécuter le handle de votre timer. Et c'est là qu'intervient le timer coalescing. En effet, W7 va regrouper les timers histoire d'exécuter les handlers peu ou prou en même temps, permettant ainsi d'augmenter le temps pendant lequel les coeurs sont endormis.
C'est ma grosse déception des tech days. Niveau 300, qu'ils disaient. Plongée profonde,qu'ils disaient. Bon, je vous résume la session :
- RemoteFx est un nouveau codec vidéo pour RDP
- RemoteFx permet de connecter des équipements USB locaux sur une VM distante.
Voilà. Comment ça marche ? On en saura rien. Par contre, on a bien compris qu'un nouveau codec, ça permet d'être plus fluide et d'aller plus vite, vu qu'on nous l'a répeté toutes les 10 secondes pendant 45 minutes. On a bien compris aussi qu'il y aurait des puces dédiées pour ce nouveau codec (quand ? dans quels produit ? ben ça, on en sait rien). Ca doit être la seule session ou j'ai sorti le téléphone pour jouer, c'est dire.
C'étaient mes petites séances récréation. Des perspectives sur l'avenir du jeu vidéo dans l'environnement W7/Windows phone7/XBox, un peu de kinect (avec la phase toujours drôle ou on voit les photos du démonstrateur prises par le kinect), un peu de technique, cela donne des sessions un peu plus légères, un peu plus visuelles, avec quelques point intéressants à retenir :
- XBox live / Windows Phone 7 : mêmes outils, même langage, mêmes frameworks (Silverlight et XNA). Bref, quand vous avez fait pour l'un, vous êtes prêts pour l'autre. Microsoft fait tout pour abattre les barrières entre les deux mondes, et ça, c'est bien (et le PC alors ? gromelle le vieux en moi).
- Le marché décolle sur Windows Phone 7. C'est pas encore l'app store et ses succès monumentaux à la Angry Birds, mais c'est déjà mieux qu'il y a un an. 2 millions de téléphones vendu, une progression en nombre d'applis sur le marketplace fulgurante (supérieure à celle de l'App store au même niveau)
- Kinect, ça déchire. Franchement. Même s'il y a des cas où la manette paraît plus appropriée, le système Kinect est génial. Et réservé pour les jeux ? Non, monsieur, ça c'est fini. Y'a eu amnistie générale sur les vilains pirates, lâchez-vous ! Paraîtrait même (confirmé depuis) qu'un SDK sortira bientôt pour le PC.
- On peut coder un jeu en moins d'une heure. Certes pas un grand jeu, certes pas en MVVM avec tests unitaires et d'intégration complets, mais bon, on peut.
Cette session a présenté de manière très dynamique et plaisante les manières d'accéder aux services Azure à partir d'une application Windows Phone.
Après une description générale de la plateforme Azure et de ses différentes composants, les speakers ont pris l'exemple d'une application connectée permettant la saisie de feedbacks des sessions pour présenter les pratiques suivantes:
- création et paramétrage d'une base de données (Azure)
- déclaration et sécurisation de Web Services métiers (Azure)
- utilisation de Microsoft Push Notification Service (http://msdn.microsoft.com/en-us/library/ff402558(VS.92).aspx) pour les notifications temps réel
- consommation de services "Cloud" et souscription au service de notification dans une application Silverlight pour Windows Phone
(la session où tout le monde a dormi y compris les speakers)
Cette session assez lente a abordé les problèmes de portabilité des développements .Net pour les environnements bureautique (WPF, WinForms), Web (Silverlight) et Windows Phone (Silverlight, XNA) .
Trois grands axes ont été vus: la portabilité des binaires, la portabilité de sources et le pattern MVVM pour l'écriture de services métier génériques.
En résumé, la portabilité des binaires est très faible sauf peut-être pour les couches métier pur qui n'auraient aucune dépendance avec des classes spécifiques à un environnement (ex: Microsoft.Phone.Controls rend l'assembly qui l'utilise non portable). Microsoft est en train de finaliser (CTP) l'initiative Portable Library Tools qui permettrait entre autres de faciliter la création de librairies réutilisables sur les différents environnements d'exécution .Net.
Concernant les sources, la portabilité est meilleure mais est dûe à 2 astuces basiques et évidentes : l'ajout de sources communes en passant par des liens (Add as link) et l'utilisation de abondantes de #define et #ifdef permettant de conditionner certaines lignes de codes en fonction de la plateforme cible.
Le pattern MVVM (voir l'article en anglais https://blog.octo.com/en/behavior-driven-development-using-mvvm-pattern-and-greenpepper-tests/) permet un découpage de l'application en couches successives (Modèle de données, Vue et Modèle orienté Vue). Ce découpage permet de réduire l’adhérence de la couche métier (Modèle) vis-à-vis de l'IHM et ainsi permettre théoriquement de partager la couche métier à travers plusieurs IHM.
Voici une session très technique où les speakers ont donné un certain nombre de conseils pour garantir l'efficacité des applications mobiles.
Il y a tout d'abord eu une présentation de l'architecture matériel des Windows Phone (CPU, GPU, écran, Bus de données...) et de la répartition des traitements entre le CPU et le GPU (thread UI par le CPU et thread Composition par le GPU).
Ensuite plongée dans les différentes fonctions graphiques et consommatrices de ressources :
- le GPU calculera les animations simples sur les types double (dont la rotation et l'opacité mais pas les gradients de couleur), certaines déformations, le clipping et l'application de textures
- le CPU fera tout le reste: gestion des évènements tactiles, layout général, conversion et les transitions complexes
Des exemples assez parlant ont été utilisés pour démontrer comment le choix d'un type de donnée (int au lieu de double) ou de certaines options pouvaient affecter la performance et donc l'utilisabilité d'une application.
Quelques informations ont été données sur les hautes performances de l'émulateur (qui utilise les CPU/GPU du PC hôte) par rapport à celles d'un téléphone réel.
La session a vite tourné à l'orgie technique en abordant en vrac :la fréquence d'appel du Garbage Collector, les spécificités du JIT pour WP7, le décodage logiciel des PNG par rapport au décodage matériel des JPG, l'optimisation de contrôles, le lazzy-loading, des options de monitoring avancé des threads graphiques, l'impact négatif de l'utilisation de Linq et de foreach.
On ressort de cette session avec beaucoup d'informations et l'envie de mettre en application immédiatement ces judicieux conseils.
De manière générale, il y eu une certaine insatisfaction sur le manque scoop des sessions Windows Phone 7. Il était palpable que les speakers faisaient preuve de réticences (par manque d'informations ou volontairement) à parler de l'avenir de Windows Phone 7 et de ses nouveautés à venir. Et cela s'est expliqué logiquement lorsque sept jours plus tard Steve Ballmer a présenté un keynote au World Mobile Congress (http://www.microsoft.com/presspass/exec/steve/2009/02-17mwckeynote.mspx) et a annoncé lui-même ce que les petits français ne pouvaient dire aux TechDays. Les "scoops" étaient les suivants: