Mes TechDays 2010

Cela fait maintenant presque trois ans que je n’ai pas touché à mon blog… il serait peut-être temps de s’y remettre !

Aussi vais-je parler ici des 3 jours que j’ai passés à Paris du 8 au 10 février à l’occasion des TechDays 2010. Je ne détaillerai pas l’ensemble des sessions auxquelles j’ai assisté mais me concentrerai sur les sujets qui m’ont le plus intéressé.

F#

J’ai assisté à 2 sessions sur F# ; la première était un atelier nous permettant de prendre en main le langage. La seconde était destinée à montrer de réelles applications de F#. Ces deux sessions étaient présentées par Don Syme, l’inventeur de F#, rien de moins (qui nous a aussi donné les génériques de C# 2…)

Getting Started

Pour la première session, nous avons eu droit à un tutorial sur F# qui partait réellement des bases :

printfn "Hello, World!"

Rapidement cependant, les nouveautés dans la manière de coder et de penser apparaissent. En vrac :

• Initialisation de listes avec n’importe quelle expression énumérable,
• Pattern-matching : sorte de super switch/case
• Pipe : chaînage d’appels de fonctions avec l’opérateur |> : les “fluent interfaces” sont ainsi intégrées au langage.
• Parallélisation : Async.Start, agents (MailboxProcessor) permettant la programmation parallèle par passage de messages à des agents concurrents.

Bref, si vous avez aimé les extensions ajoutées à C# 3 (types anonymes, inférence, Linq, lambdas et extensions parallèles (à venir dans .NET 4) vous adorerez F#.

Real life usage

La seconde session s’est attachée à montrer que F# était plus qu’une curiosité de laboratoire et pouvait servir dans la vraie vie au travers de trois exemples :

Tout d’abord, et l’on pourra objecter que ceci intéresse surtout les scientifiques, dans le domaine de la simulation numérique :

Au delà de l’aspect graphique (le rendu est effectué par DirectX), cette démonstration montre les capacités en matière de parallélisation de F# : sur la capture ci-dessous, chaque anneau (les petits doughnuts blancs avec une flèche) est géré par un “agent” différent. Ce que la capture statique ci-dessus ne montre pas est que la surface est définie par une fonction de 3 paramètres dont le temps : elle est animée. Chaque anneau se déplace en suivant les contours de la surface !

Les deux autres exemples montraient d’une façon très différente comment cibler des architectures différentes lors de la compilation :

Premier exemple

Robert Pickering nous présente le jeu de la vie. Là encore, ce n’est pas tous les jours que nos clients nous demandent d’implémenter le jeu de la vie dans leur solution… Tout l’intérêt de la démonstration était ailleurs : nous avons vu tourner l’application une première fois compilée pour x64, classique et lent, puis pour la GPU ! Les cartes graphiques modernes disposent de processeurs particuliers que l’on peut qualifier d’aptes au traitement massivement parallèle : on atteint une dimension dans le parallélisme qui n’a plus grand chose à voir avec les applications classiques que l’on optimise pour 2, 4 ou 8 cœurs. Le revers de la médaille : le code a l’air tout bonnement incompréhensible (pour le peu que j’en ai vu). Cibler ce type d’architectures implique de repenser totalement les algorithmes : les objets que les GPU aiment traiter ne sont pas de bêtes variables mais des vecteurs et des matrices (et plus leurs dimensions sont élevées, plus la puissance du processeur s’exprime).

J’avoue qu’à part dans des cas spécifiques : traitement de données facilement représentable de manière matricielle, informatique scientifique, traitement d’image, je ne vois pas vraiment comment appliquer ces techniques demain dans mes projets.

Deuxième exemple

Là, on commence à toucher au monde professionnel. Adam Granicz est le fondateur de Intellifactory et il propose un outil mignon tout plein : WebSharper. En gros il s’agit d’un GWT (ou d’un Volta) à la sauce F# : du F# que du F#. Des attributs permettent de cibler le serveur ou le client et, en fonction, du code .NET classique ou du Javascript est généré.  Le layout HTML se déclare en imbriquant des listes F# : le code résultant est plutôt agréable et pas si différent de ce que de nombreux moteurs de templating MVC font. Il m’a semblé particulièrement intelligent de partir de F# pour générer du Javascript : en effet, les deux langages ont déjà beaucoup en commun (Javascript est déjà très fortement fonctionnel) et cela a du simplifier la traduction. Evidemment, les capacités parallèles de F# sont intraduisibles en Javascript (pas de multi-threading en Javascript).

Enfin, j’ai demandé à Adam Granicz quelle tête pouvaient bien avoir les pages générées : la page est-elle entièrement construite par du code Javascript dans le onLoad ou bien les balises HTML sont-elles émises ? Et bien oui et non : le rendu final en HTML est produit ce qui permet, entre autres, aux moteurs de recherche d’indexer correctement la page ; mais dès le chargement, le Javascript du onLoad supprime le DOM entier et le recrée… J’aurais peut-être préféré que le DOM reste à sa place et que le code Javascript remplisse les trous plutôt qu’il efface tout… Je suppose que de très bonnes raisons les ont poussé à faire ceci.

A noter que WebSharper intègre de nombreuses bibliothèques Javascript connues (jQuery, Yahoo UI) et les expose à F#. Le développeur peut aussi intégrer lui-même des bibliothèques Javascript (c’est une sorte d’Interop Javascript <—> F#…).

Quelques liens

• F# samples (pour Visual Studio 2008 et 2010) : http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=fsharpsamples&DownloadId=7636
• F# February 2010 CTP (fonctionne dans Visual Studio 2008 ou en ligne de commande) : http://www.microsoft.com/downloads/details.aspx?FamilyID=ba52e650-4e77-4b0b-b987-9f9ecd3bab3b&displaylang=en
• Le blog de Don Syme : http://blogs.msdn.com/dsyme/archive/2010/02/09/f-tutorial-and-talk-today-at-techdays-paris-late-announcement.aspx
• Le blog de Robert Pickering : http://strangelights.com/blog/
• Intellifactory, éditeur de WebSharper : http://www.intellifactory.com/ 

System.Identity

Kim Cameron, Distinguished Engineer de la division sécurité et identité de Microsoft nous propose une session à l’intitulé alléchant ‘M’-Based System.Identity Model for Accessing Directory Services.

Il part du constat qu’Active Directory n’est pas adapté aux nouveaux besoins en matière d’identité : avec sa structure trop hiérarchique, il est difficile d’y représenter des liens entre personnes (comme le font les réseaux sociaux par exemple). Un autre point important est qu’Active Directory n’est pas abandonné, ni modifié : le nouveau modèle se place au dessus d’un AD existant : il l’étend.

Ce qui m’a le plus intéressé dans cette présentation n’est pas tant les liens avec Active Directory (d’ailleurs pas encore implémentés à l’heure actuelle) que le méta modèle sur lequel s’appuie la nouvelle architecture. Ce modèle est défini en utilisant les outils du projet Oslo (renommé récemment en SQL Server Modeling). Le langage M fait partie de ce projet est sert à décrire des modèles de niveau conceptuel. On a donc bien ici, non seulement un méta-modèle de représentation des identités numériques, mais un modèle logique. Bien que le schéma ci-dessous fasse penser à du pseudo UML, la technologie d’implémentation n’est pas définie :

Dans la pratique, et dans sa version actuelle, le modèle est effectivement implémenté au dessus de SQL Server. Cependant, comme le montre ce deuxième schéma, plusieurs “providers” sont prévus, dont évidemment Active Directoy. La partie de gauche du schéma montre l’état actuel classique d’interrogation d’un annuaire Active Directory. La partie de droite, quant à elle représente le futur. L’API System.Identity permet une unification des accès aux sources de données quel que soit le type de magasin sous-jacent :

Dans sa présentation, Kim Cameron a donné quelques exemples d’utilisation de l’API. Le code est clair est simple, le support Intellisense complet. Cette dernière remarque semble banale et pourtant : une des forces du modèle est qu’il est extensible (soit par simple paramétrage XML pour les “Kinds” par exemple, soit en modifiant directement le modèle logique avec les outils Oslo). Un modèle modifié ou étendu est ensuite passé dans une moulinette qui génère un assembly wrapper. On dispose ainsi d’aides au codage, même sur ses propres extensions.

En bref, une présentation très intéressante. Je n’ai été déçu que sur un seul point. Bien que le titre de la présentation cite M, nous n’avons pas vu une seule ligne de code et les outils d’Oslo (Quadrant, ipad…) n’ont même pas été cités.

Quelques liens

Le blog de Kim Cameron : http://www.identityblog.com/

Autres sessions, en vrac

• Le futur de XAML dans le framework .NET et Silverlight présenté par Mitsu Furuta de Microsoft France : System.Xaml est un nouvel assembly factorisant la sérialisation/désérialisation XAML pour toutes les technologies qui l’utilisent (WPF, Silverlight, WF…). Mitsu Furuta nous montre comment tirer partie de ces nouvelles classes pour sérialiser nos propres graphes d’objet.

• Deux sessions présentées par SOGETI : Visual Studio : comment l’adapter à vos besoins et Comment optimiser la qualité de son code par la mise en place de bonnes pratiques :

• La première session présente le nouveau modèle d’extensibilité de Visual Studio 2010 : déploiement simplifié et plus rapide (fichiers vsix) et plugins basés sur MEF.

• La seconde, après avoir rappelé quelques bonnes pratiques généralement acceptées, présente le framework Code Contracts qui propose des outils d’analyse à la compilation et au runtime garantissant un code robuste (pré et post conditions, invariants). A noter que Jonathan “Peli” de Halleux était dans la salle.

Les nouveautés de Workflow Foundations 4

Fuites mémoires en .NET : Détecter et corriger.

Développement embarqué : Windows Embedded 6

…

Liens

• Le blog de Mitsu Furuta : http://blogs.msdn.com/mitsu/
• Le blog de Peli : http://blog.dotnetwiki.org/ et sa page sur Microsoft Research : http://research.microsoft.com/en-us/people/jhalleux/