On va pas faire de politique, mais…

Posted on 14/04/2011 by JP Gouigoux

… on va quand même faire notre devoir de citoyen en diffusant la loi, que chacun est censé connaitre. Ma mauvaise foi légendaire fait que je vais bien évidemment m’arrêter sur un texte de loi particulièrement étonnant (et le mot est faible). Jetez un oeil sur ceci :

http://www.legifrance.gouv.fr/affichTexte.do?cidTexte=JORFTEXT000023646013

Il s’agit d’un article de loi relatif à la Loi sur la Confiance dans l’Economie Numérique. Pour résumer, ce texte indique qu’un opérateur de services sur internet doit dans certains cas stocker les mots de passe des utilisateurs. Pas seulement les identifiants, les heures d’accès, etc. mais bien les mots de passe !

Je pensais naïvement que les lois étaient examinées par des experts avant d’être proposées aux votes pour ne pas contenir d’aussi grosses bourdes, mais ce n’est visiblement pas le cas. Tous mes étudiants, même en première année de BTS, savent qu’on ne stocke JAMAIS un mot de passe. On stocke UN HASH de mot de passe, et en plus pas avec un algorithme dépassé comme MD5, et surtout en utilisant un sel pour qu’il ne soit pas attaquable trop facilement par des dictionnaires de hash…

De plus, quelle utilité pour un gouvernement d’avoir accès à cette donnée ? Je peux comprendre l’utilité de garder l’IP, le nom de la personne et l’heure d’accès pour des raisons éventuelles de preuve de fraude, mais le mot de passe n’apporte rien de plus. Par contre, il rendra l’internet beaucoup moins sûr. Le hash, pratique non réversible, a précisément été mis en place sur les mots de passe car il garantit que personne, même un administrateur, ne peut connaitre votre mot de passe. Il pourra bien sûr le faire sauter, en mettre un autre, se connecter avec votre utilisateur, mais il n’a aucun moyen de connaitre le contenu de votre mot de passe si celui-ci est stocké de manière hashée.

Or, ceci est capital pour la “confiance dans l’économie numérique”, et cette loi va à l’encontre de ce principe de base. A tel point que Google et Facebook ont déposé une plainte contre (http://www.presse-citron.net/google-facebook-et-ebay-deposent-une-plainte-contre-la-loi-francaise-de-conservation-des-donnees-des-utilisateurs) et que nous sommes désormais la risée du monde de la sécurité (http://www.boingboing.net/2011/04/11/france-to-require-cl.html).

Après un accès de paranoïa récent (j’enseigne la sécurité à des étudiants, et leur principale activité en dehors de mon cours est évidemment de tenter de hacker tous les comptes qu’ils peuvent trouver à mon nom), j’ai modifié les mots de passe des sites sur lesquels je possédais un compte pour qu’ils soient tous différents. J’étais récemment en train de me dire que, plutôt que de lancer une procédure “mot de passe oublié” pour chaque site trop peu fréquenté, il serait plus simple de revenir au même mot de passe partout. Si c’est pour qu’il soit stocké en clair quelque part et que n’importe quel administrateur de forum puisse accéder à tous mes autres comptes, c’est évidemment hors de question.

En bon scientifique, je cherche des raisons. Je n’en trouve pour l’instant que deux :

1) Nos députés votent des lois sans comprendre leur impact, et sans s’entourer d’experts sur les sujets qu’ils ne comprennent pas (je mets exprès le mot “expert”, qui est quasiment devenu un gros mot aujourd’hui, grâce aux nombreuses personnes qui confondent à dessein leur ignorance avec du bon sens).

2) Les mêmes cherchent sciemment à baisser le niveau de confidentialité et de sécurité d’internet, malgré le nom de cette loi sur la “confiance dans l’économie numérique” (étrange nom d’ailleurs, qui suppose que la confiance peut être décrétée).

L’une comme l’autre de ces deux hypothèses me hérissent le poil…

Posted in Sécurité | Leave a comment

Utilité de IsAlive ?

Posted on 08/04/2011 by JP Gouigoux

Le bout de code ci-dessous montre une utilisation conceptuelle des WeakReference. L’idée des références faibles étant qu’elles n’empêchent pas la collection par le GC, mais que si jamais le GC n’est pas passé, elles permettent de retrouver une “vraie” référence sur l’objet.

Ceci est intéressant dans le cas d’objets lourds, utilisés peu fréquemment et qui ne sont pas trop compliqués à reconstruire. Ca permet de ne pas bloquer la mémoire, mais si jamais ça ne gêne pas, on évite de tout reconstruire, ce qui est appréciable.

using System;

namespace TestWeakReferenceIsAlive
{
    class Program
    {
        static void Main(string[] args)
        {
            WeakReference ReferenceFaible = null;
            
            // Juste pour créer une portée à la sortie de laquelle
            // on perdra la référence forte sur l'objet instancié
            if (true)
            {
                var ReferenceForte = new { Nom = "Gouigoux" };
                ReferenceFaible = new WeakReference(ReferenceForte);
            }

            // ...

            // Pendant ce temps, le GC peut décider de collecter ou pas l'objet instancié,
            // rendant possible ou pas une récupération de l'objet par sa référence faible

            // ...

            if (ReferenceFaible.IsAlive)
            {
                // Dangereux, car la mémoire correspondant à l'objet pourrait très bien être
// recyclée entre le moment où on a fait le IsAlive et celui où on récupère
                // une référence forte ci-dessous
                dynamic ReferenceForte = ReferenceFaible.Target;
                
                if (ReferenceForte != null)
                {
                    // C'est pourquoi il faut tester ici la nullité 
                    // pour être sûr qu'on a bien récupérer l'objet
                    Console.WriteLine(ReferenceForte.Nom);
                }
            }
            else
            {
                Console.WriteLine("Trop tard, il faut réinstancier Personne");
            }
        }
    }
}

Ce que je ne comprends pas, c’est à quoi sert le IsAlive ? De toute façon, on n’a pas de garantie qu’entre le moment où on teste si l’objet est vivant et celui où on récupère une référence forte dessus, il ne disparaitra pas. Et donc, nous sommes obligés quoi qu’il arrive de vérifier que la référence retrouvée n’est pas nulle.

Alors quel est l’utilité de IsAlive ? Juste savoir si l’objet est encore disponible ? Oui, mais pourquoi donc aurait-on besoin de cette information pour autre chose que pour le récupérer après ???

Toutes les idées / commentaires sont les bienvenus…

[Edit]

Justement, un commentaire de JB Evain que je recopie tel quel (il n’apparait pas en commentaire, car je n’ai migré que le contenu depuis mon ancien hébergeur, désolé) :

En fait elle est uniquement utile dans le cas où elle retourne False. Donc dans un scénario où on dit:

if (!weakRef.IsAlive) {
  // repopulate cache.
}

L’intention du code est un peu plus claire qu’en écrivant:

if (weakRef.Target == null) {
  // repopulate cache
}

Dans le cas où on est intéressé par la valeur, le plus simple est de ne pas s’en soucier du tout, et d’utiliser directement sa .Target en validant qu’elle n’est pas null

Pour une fois la MSDN est précise là dessus d’ailleurs.

[Edit – Août 2012]

Dans la version 4.5 de .NET qui arrive avec Visual Studio 2012, il y a désormais une version fortement typée WeakReference<T>, qui ne présente plus la méthode IsAlive, mais seulement TryGetTarget.

Plus d’infos sur http://msdn.microsoft.com/en-us/library/gg712738(v=vs.110).

Posted in .NET, C# | Leave a comment

La couverture de code : pas aussi compliqué que NCover, mais quand même…

Posted on 07/03/2011 by JP Gouigoux

Bon, que je l’avoue tout de suite : je n’aime pas NCover. Je n’aime pas leur façon de planquer leur version gratuite sur leur site, je n’aime pas qu’ils m’aient appâté pendant un an avec un produit gratuit pour me dire ensuite qu’il fallait payer. Je n’aime pas quand NCover passe cinq minutes à exécuter une montagne de tests et me recrache un fichier de log de couverture absolument vide à la fin. Enfin, je n’aime pas leur intégration médiocre à Visual Studio.

Bref, il fallait autre chose, et ça commençait à urger. Il y avait bien PartCover, mais franchement, il n’est pas facile du tout à faire fonctionner, et il a aussi ses bugs. Bref, inutile de dire que je suis content que Visual Studio 2010 embarque la couverture de code. Mais bon, ce n’est pas si simple que ça à faire fonctionner, et je me disais que ça valait peut-être le coup de faire un petit post pour expliquer tout ce qu’il faut mettre en place pour que ça marche…

Version de Visual Studio

Il vous faut une version Premium ou Ultimate pour que ça marche. Ne passez pas comme moi un quart d’heure à vous demander si c’est un bug dans la Pro, c’est normal… Enfin, normal, c’est beaucoup dire : j’aurais un peu de mal à qualifier de “pro” un développeur qui ne calcule par sa couverture de code, mais bon, passons.

Créer un projet de test

Pour quelqu’un qui vient du monde NUnit, ce n’est pas évident, mais dans Visual Studio, un projet de test n’est pas bêtement un projet qui contient des tests. Ca ne suffit pas… Il faut que le projet ait été créé en tant que projet de test dans l’interface.

image

Et sinon, vous pouvez le faire reconnaitre après coup en ajoutant la ligne suivante dans le fichier.csproj :

<?xml version=”1.0″ encoding=”utf-8″?>
<Project ToolsVersion=”4.0″ DefaultTargets=”Build” xmlns=”http://schemas.microsoft.com/developer/msbuild/2003“>
  <PropertyGroup>
    <Configuration Condition=” ‘$(Configuration)’ == ” “>Debug</Configuration>
    <Platform Condition=” ‘$(Platform)’ == ” “>AnyCPU</Platform>
    <ProductVersion>
    </ProductVersion>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>8099f91a-f07e-4450-9506-a46f5d41e627</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>TestProject1</RootNamespace>
    <AssemblyName>TestProject1</AssemblyName>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
  </PropertyGroup>

Par contre, il vous manquera alors le répertoire Solution Items avec les paramètres nécessaires pour les tests, mais là encore, vous pouvez vous débrouiller pour les rajouter après coup, en utilisant la commande “Ajouter un nouvel élément”, et en sélectionnant la bonne entrée comme ci-dessous :

image

Activer la couverture de code dans les paramètres de test

Vous pouvez alors voir dans le menu les paramètres de test, et choisir le second mode, qui est là pour prendre en charge toute l’instrumentation additionnelle.

image

En sélectionnant le menu juste en dessous, nommé “Modifier les paramètres de test”, et en entrant dans la section correspondant au mode choisi plus haut, vous allez pouvoir mettre à jour finement ce qui doit être instrumenté dans ce mode, et en l’occurrence activer l’enregistrement de la couverture de code, dans la catégorie “Données et diagnostics” :

image

Il faudra ensuite cliquer sur Configurer ou double-cliquer sur la ligne pour donner les assemblages qui doivent être traités. Pas très très intuitif, surtout qu’on ne voit pas bien que Configurer est un menu. Enfin, on était peut-être un peu fatigués, mais ni mon collègue ni moi n’avons fait tilt, et surtout, par défaut, il n’y a rien de sélectionné.

Je trouve ça un peu dommage : ça serait bien que Visual Studio mette un avertissement “Vous avez activé la couverture de code, mais aucun projet n’est sélectionné”. Ou au moins qu’il le dise lorsqu’on rejoue les tests. Pour l’instant, on se retrouve juste avec un message expliquant qu’il n’y a pas de données de couverture de code.

Bien choisir les projets

Attention, ce ne sont pas les projets de tests que vous devez choisir dans cette interface de gestion, mais bien les projets à instrumenter.

image

Et autre détail : vous ne verrez pas les projets qui ne sont pas compilés.

Resharper, lecteur réseau, etc.

Si vous utilisez Resharper, il faudra le désactiver, ou en tout cas ne pas lancer les tests par les commandes qu’ils proposent, car elles ne sont pas compatibles avec la couverture de code.

Autre souci potentiel : Visual Studio acceptera de lancer les tests, mais le fichier de couverture ne sera pas écrit si votre projet se trouve sur un lecteur réseau. Mettez donc votre workspace en local. De toute façon, c’est une bonne pratique, ne serait-ce que pour les performances d’accès aux fichiers, et donc d’édition et de compilation.

Soyez patients

Il faut ensuite lancer les tests unitaires, et ne pas se précipiter immédiatement sur l’icône permettant de consulter les résultats de la couverture de code, sous peine de voir le message ci-dessous :

image

Et voila : arrivés ici, vous pourrez enfin voir vos informations de couverture de code. Je n’ai pas eu les problèmes supplémentaires exposés sur http://www.lgmorand.com/blog/post/2010/06/08/Mettre-en-place-du-code-coverage-avec-Visual-Studio-2010.aspx bien que j’utilise également TFS, mais à la place j’ai eu quelques autres effets de bord sans gravité…

Posted in .NET, ALM, Tests | Tagged | Leave a comment

De la difficulté de faire un bon test

Posted on 26/02/2011 by JP Gouigoux

Comment tester qu’un tri a bien été réalisé ? Imaginez que vous deviez tester unitairement la fonction Sort générique de .NET. Comment réaliser le code le plus concis possible, sans redondance mais sans laisser passer de cas particulier, et qui valide que cette fonction réalisera correctement le travail.

Un bon test est toujours plus complexe à réaliser qu’une bonne fonction. Pour cet exemple du tri, voici ce que je propose, suite à une longue discussion avec plusieurs collègues lors d’une formation.

using System;
using System.Collections.Generic;
using System.Text;
 
using NUnit.Framework;
 
namespace Tests
{
    [TestFixture]
    public class Class1
    {
        private List<Personne> Liste = new List<Personne>();
 
        [SetUp]
        public void Initialisation()
        {
            Liste.Clear();
            Liste.Add(new Personne("Gouigoux", "JP", 35));
            Liste.Add(new Personne("Lagaffe", "Gaston", 39));
            // etc...
        }
 
        [Test]
        public void TestTri()
        {
            List<Personne> Copie = new List<Personne>(Liste);
 
            Liste.Sort(ComparateurAgeDescendant);
 
            // PHASE I
            Assert.AreEqual(Liste.Count, Copie.Count);
 
            // PHASE II
            Assert.IsTrue(Copie.TrueForAll(delegate(Personne p)
            {
                return Liste.Contains(p);
            }));
 
            // PHASE III
            for (int Index = 0; Index < Liste.Count - 1; Index++)
                      Assert.IsTrue(Liste[Index].Age >= Liste[Index + 1].Age);
 
            // PHASE IV
            for (int Index = 0; Index < Liste.Count - 1; Index++)
                if (Liste[Index].Age == Liste[Index + 1].Age)
                {
                    int PosA = Copie.IndexOf(Liste[Index]);
                    int PosB = Copie.IndexOf(Liste[Index + 1]);
                    Assert.Less(PosA, PosB);
                }
        }
 
        private int ComparateurAgeDescendant(Personne a, Personne b)
        {
            return b.Age.CompareTo(a.Age);
        }
    }
}

La première assertion doit consister en une vérification que la longueur de la liste après le tri doit être la même qu’avant le tri.

La seconde doit valider que chaque entité contenue dans la liste avant traitement doit être retrouvée dans la nouvelle liste.

La troisième (celle que tout le monde fera, sans parfois réaliser que c’est loin d’être suffisant) valide que l’ordre est bien celui qu’on souhaitait, en vérifiant que chaque entité est bien dans l’ordre correspondant à sa position par rapport à celle qui suit.

Enfin, la quatrième est celle que tout le monde ou presque oublie : pour qu’un tri soit réputé stable (mais il est vrai que je n’avais pas précisé cette exigence au début du post), il faut que deux objets qui sont égaux pour la comparaison, mais pourtant bien distinct, restent dans le même ordre. Dans notre exemple, si j’avais eu le même âge que Gaston Lagaffe (en plus d’avoir le même pull et le même tact), le tri devrait laisser la liste triée avec nos deux entités dans leur ordre initial.

[Edit]

Je reprends ci-dessous un commentaire de Guillaume Collic et ma réponse (désolé, je ne migre que les commentaires les plus importants en migrant ce blog depuis l’ancienne adresse) :

Le commentaire initiale de Guillaume :

J’approuve ce que tu tests (le fond), mais par contre la structure m’étonnes (la forme). Ce serait plus clair à mon avis de séparer chaque phase dans son propre test avec un nom plus parlant que “Phase II”. Cela impliquerait aussi que le test sur l’ordre devrait pouvoir passer même si le compte n’est pas bon par exemple. J’ai l’impression que la source d’une anomalie serait identifiée plus rapidement, en plus d’une meilleure lisibilité.

Ma réponse :

C’est vrai que si on veut rester dans l’esprit test unitaire, on devrait avoir une fonction par phase.

Je fais avec une seule fonction, parce que les Assert n’ont de sens que les uns avec les autres. Par exemple, la phase IV pourrait très bien renvoyer un faux positif si la phase I n’était pas vérifiée. Du coup, j’ai plus tendance à voir le tout comme un seul test unitaire “fonctionnement du tri”, avec plusieurs phases d’Assert, plutôt que plusieurs tests unitaires, car ils ne seraient alors pas indépendants.

Posted in .NET, ALM, C#, Tests | Tagged | Leave a comment

[TechDays2011] Bilan

Posted on 10/02/2011 by JP Gouigoux

Tout d’abord, il faut reconnaître qu’il y avait beaucoup moins de nouveautés à présenter cette année. Les TechDays 2010, c’était une nouvelle version de Visual Studio .NET, une version majeure de .NET, TFS qui arrivait, le Cloud qui apparaissait. Cette année, rien de tout cela, mais une année de consolidation, on va dire.

Clairement, le message mis en avant par Microsoft est celui de la simplicité. Il faut faire voir que toutes ces nouvelles technologies sont puissantes, oui, mais qu’elles ne sont pas trop compliquées à mettre en oeuvre. OK pour certaines, mais le message était parfois un peu trop martelé, et plusieurs orateurs utilisaient tellement de fois les mots “simplement”, “juste”, etc. que ça virait au “Yakafokon”… Avec des dérives parfois, en s’émerveillant parfois que déployer un site web ou changer une fonte soit si simple dans SharePoint. Ben oui, en même temps, je ne vois pas pourquoi il faudrait pomper trois fois ou manipuler du XML pour ça…

Tant que je suis dans la critique, ça serait bien que les orateurs préparent encore mieux leurs environnements. OK, ce n’est pas toujours facile. J’en sais quelque chose, j’ai fait pas mal de démos dans des conférences, et il y a toujours un petit message qui fait suer… Mais bon : qui mieux que Microsoft peut savoir comment configurer les droits pour ne pas avoir un avertissement de la sécurité d’IE par exemple. Or, ça arrive toujours souvent de voir les démos réalisées avec un utilisateur ADMIN, ou en cliquant sur OK à fond la caisse pour éviter le message de sécurité.

De même, quand il y a un problème de lenteur, arrêtez par pitié de nous expliquer que c’est parce qu’ASP.NET se lance pour la première fois : on le sait tous qu’il y a une phase de génération, sauf que nous, quand on démontre à des clients, on fait l’effort d’avoir réalisé un premier essai à blanc pour ne pas avoir d’attente. Et blâmer la lenteur des machines virtuelles alors qu’une session autre part démontre que la différence avec l’équivalent physique n’est que de quelques pourcents est également une excuse pourrie. Pourquoi ne pas avouer tout simplement que c’est lent pour l’instant, mais que ça marche ? La prochaine version optimisera, voila…

Allez, je me lâche, et je finis avec deux critiques : un orateur doit parler correctement. Je sais que notre domaine est bourré de mots anglais, mais les prononcer proprement serait bien. Ou s’ils sont traduits, pitié : pas de francisation à la hâte. “Adresser un problème” ne veut rien dire en français, pas plus que “lancer une requête contre un serveur”. Franchement, je regrette Eric Mittelette et Mitsuru Furuta, qui s’expriment bien mieux que ça. Ils ont souvent laissé la place à des gens certainement tout aussi compétents, mais manquants cruellement de dons pour la présentation. On ne demande pas un show à la Steve Jobs, mais un minimum de préparation.

Dernier truc, mais je pense que c’est plutôt extérieur à Microsoft : jusqu’où va aller la sécurité ? Impossible de rejoindre une personne sur les stands parce que la session générale est en route ! Impossible de descendre manger ses sandwiches à l’extérieur ! Badge lus et relus à chaque escalier, avec les agents qui bloquent avec leur bras pour ne laisser monter que vingt personnes à la fois… On va où, là ? Cette infantilisation commence à sérieusement me gonfler, et il ne faudra pas s’étonner si quelqu’un pète un plomb un jour : la chaleur, la densité humaine, le fait de toujours courir pour arriver vingt minutes en avance aux sessions intéressantes en ayant une chance de pouvoir entrer sont déjà suffisamment pénibles. Si les mesures de sécurité deviennent aussi chiantes, bien joué les terroristes, non seulement vous aurez tué 5000 personnes il y a dix ans, mais en plus vous aurez réussi le tour de force d’en faire chier des millions depuis 2001…

Voilà, c’est fini pour l’opération râlerie 🙂

Mais il y a beaucoup de positif : la maturité de F#, celle de Mono qui devient de plus en plus impressionnant, l’impression globale de maîtrise technologique et surtout stratégique de Microsoft : les produits sont bons, mais Microsoft devient vraiment meilleur dans la façon de les justifier par des études sérieuses. TFS est justifié du point de vue de la gestion de projet, et non pas comme build ou gestionnaire de code source, ce qui n’aurait aucune valeur. Le Cloud est argumenté d’un point de vue financier, avec des chiffres à l’appui, et des arguments qui font mouche.

Bref, on ressort comme d’habitude avec la ferme intention de tout mettre en pratique et des rêves plein la tête. Encore faudra-t-il que Microsoft fasse un effort de clarté sur les licences et les modes de mise en oeuvre, car c’est souvent un gros frein à l’adoption : même les employés de Microsoft sur les stands étaient peu clairs sur les licences et les prix. J’ai personnellement l’expérience d’un projet sur PowerPivot abandonné pour cause de manque total de clarté sur le coût. Je n’ai pas l’impression que ça aille en s’améliorant, et c’est un avis apparemment très partagé, d’après de nombreuses discussions sur les TechDays et auparavant. Malheureusement, je pense que Microsoft n’est pas encore conscient de la perte de projets due à leurs licences absconses. Je sais que des institutionnels penchent vers l’open source moins pour la gratuité que pour la simplicité des licences. S’il faut mettre une personne à mi-temps pour gérer les licences, ça finit par représenter un sacré surcoût…

En conclusion : bien joué les techniciens chez Microsoft, mais pour les commerciaux, rappelez-vous le message de Steve Ballmer qui avait martelé 17 “Thank you” hurlants aux partenaires Microsoft : votre valeur est dans ce que vos partenaires font de vos produits. Les produits sont techniquement et stratégiquement excellents. Il ne tient qu’à vous d’aller au bout de la logique et de rendre leur adoption tellement simples que vous deviendrez au logiciel ce qu’Apple est aux portables et aux mobiles : non seulement bon, mais visionnaire.

Mais tout ceci n’est que mon ressenti…

Posted in Retours | Leave a comment

Tech Days 2011 : Mono et son écosystème

Posted on 10/02/2011 by JP Gouigoux

Jean-Baptiste Evain (jbevain.at.novell.com) présente.

Mono 2.10 prévue pour les semaines à venir. WCF est annoncé comme supporté, mais uniquement le subset supporté par Silverlight. C’est ce qui est le plus demandé en ce moment, donc il y a beaucoup de travail en ce moment dessus.

Pour WPF, il n’y a pas de plan d’implémentation. WF serait intéressant, mais ne sera pas commencé s’il n’y a pas un intérêt et une participation de la communauté.

MEF et DLR sont supportés, ainsi que PFX et PLinq. Pas encore d’EF car il n’y a que peu de demande, par contre, et seulement partiellement Code Contracts.

Mono.Addins est un équivalent de MEF. Mono.csharp permet de faire des fonctions de type eval dans C# (un peu comme le RuleParser de WF), en incluant un compilateur C# dans le langage lui-même.

iOS empêche d’avoir des pages mémoires écrivables et exécutables en même temps. Du coup, pas de JIT compiling, pas de code emit, pas de remoting, etc. MonoTouch compile tout en code natif. Vu qu’on est obligé d’avoir les références fixes, il a fallu mettre en place plusieurs outils pour enlever ce qui ne sert pas dans Mono. Par contre, chaque application a du coup son propre Mono, ce qui répresente entre 2 et 6 Mo en fonction des besoins, à enlever des 20 Mo autorisés pour un téléchargement d’appli iOS.

MonoDroid permet par contre de faire du JIT. C’est un plugin MonoDevelop, mais aussi pour Visual Studio 2010. On peut avoir le runtime embarqué ou partagé, et donc à n’installer qu’une seule fois.

WP7 permet de coder directement en C#, bien sûr, sans passer par Mono. Du coup, les trois plateformes principales sont déployables. WP7 est basé sur le Compact Framework, alors que dans le cas de Mono, il y a un framework complet, et on choisit au déploiement de stripper les références.

La dernière demo montre justement la possibilité de faire du Queryable<T>, les hashsets et JSON sur WP7 en ajoutant simplement la référence à la librairie Mono pour ça.

Beaucoup de questions pour cette session, mais malheureusement il va falloir que je parte vite pour ne pas louper mon train de retour. Juste ce que j’ai écouté :

– Pas de portage de Moonlight sur les mobiles pour l’instant

– Apple a clarifié sa licence et MonoTouch peut bien être utilisé

– AttachMate est en phase de rachat de Mono

– Nouveau garbage collector en 2.8 : amélioration des performances des serveurs, et il y a aussi des efforts de fait sur la génération de code, sur ASP.NET MVC, etc.

En conclusion, session très rassurante sur le futur de Mono : il y a beaucoup de talents à l’oeuvre, et Microsoft aurait limite du souci à se faire 🙂

Posted in .NET, Retours | Tagged | Leave a comment

Tech Days 2011 : CodeContrats

Posted on 10/02/2011 by JP Gouigoux

[ContractClass] et [ContractClassFor] permettent, par injection, de placer des contrats de code sur des interfaces, et qu’on retrouvera sur les classes d’implémentation.

[ContractInvariantMethod] et Contract.Invariant() pour les invariances de valeurs.

Pour hériter des contraintes depuis une interface, on implémente une classe sur cette interface et qui va porter les contraintes d’invariance, de pré- ou de post-condition, et on la marque avec [ContractClassFor], et on va mettre l’attribut [ContractClass(typeof(laClasseHeritantLInterface)] sur l’interface.

Vérification des contrats à la compilation dans la version Premium ou Ultimate, ou avec l’utilitaire cccheck. Contrat.Assume permet d’informer le vérificateur qu’une valeur a été validée par un autre moyen que le code (exemple : le contrôle WPF l’envoyant), et que c’est normal que le code ne prouve pas lui-même le respect de la contrainte dans cet enchaînement particulier de fonctions.

Contract.EndContractBlock() permet de délimiter la fin d’un code directement écrit en C# juste après la déclaration de fonction, et qui du coup sera pris en compte comme si c’était du CodeContract, y compris en terme d’héritage, etc.

Un outil permet d’avoir une assembly sans les règles, et une assembly séparée avec les contracs. Typiquement à utiliser après le staging, et pour avoir les performances maxi en production, par suppression des règles.

C’est le Code Contract Rewriter qui injecte les règles dans la dll intégrateur. Call-site requires checking est l’option des propriétés CodeContract qui permet d’activer ce comportement. Avant d’utiliser, il faudra bien vérifier que le problème de signature par nom fort a bien été pris en compte.

Common Compiler Infrastructure = l’API de base utilisée par FXCop, SandCastle, etc. pour parcourir le code compilé.

Posted in .NET, C#, Retours | Tagged | Leave a comment

Tech Days 2011 : BPM : Automatisez vos processus sur un socle applicatif intégré

Posted on 10/02/2011 by JP Gouigoux

C’est dommage que le livret avec les sessions ne montrait pas le mot clé BPM : seules les personnes ayant vu sur internet le descriptif complet pouvait se faire une idée du contenu de cette session.

La session commence par de la pub sur les sociétés extérieures qui intervenaient sur cette conférence. Un peu dommage qu’on prenne cinq minutes pour ça, ça fait beaucoup.

De même, l’introduction opposant les grosses solutions massives pour l’ERP et la CRM avec les besoins d’adaptation de plus en plus réactive au marché est, je pense, bien connue des gens qui participent à cette session qui est quand même orientée experts.

Formalisation de la prédictibilité : si quelqu’un est en vacances, est-ce qu’une demande de support adressée à l’entreprise va tout de même être traitée en temps et en heure ? Du coup, lien théorique entre l’application DRH et l’application gestion des bugs.

Pour synchroniser les gros modules applicatifs, on peut utiliser des messages ou bien un serveur centralisé de mise en commun. Le message est le plus commun, vu que c’est ce qu’il est le plus facile à automatiser. Du coup, ce qui reste en tâches humaines est surtout de l’exécution sans communication.

Windows Server AppFabric se positionne au niveaux des processus d’entreprise, tandis que BizTalk, Azure AppFabric Service Bus et SQLServer sont plutôt au niveau de l’intégration des applications, qu’elles soient dans le Cloud ou On Premise.

Le suivi fonctionnel est fait avec le BAM de BizTalk. Pour ce qui est du suivi des tâches humaines, on ferait plutôt du SharePoint.

Workflow Foundation est présent dans la plupart des niveaux, mais il prend tout son sens dans Windows Server AppFabric, dont les buts sont d’héberger IIS et WF, de façon à fournir des services web stateful grâce au WF, de gérer du cache et de faire du monitoring et du hosting (gestion de la non-affinité des instances de workflow, y compris en cas de panne).

On fait un workflow hébergé WCF, mais dommage, la session ne fait pas voir un vrai exemple, avec la mise en oeuvre de quelque chose créé sur place. Mais c’est certainement parce que j’ai une approche trop développeur.

Le workflow WCF peut ensuite être exécuté dans Windows Server AppFabric. La démo montre un découpage intéressant des fonctionnalités : on utilise un sharepoint pour envoyer des messages de demande de validation d’une étape du workflow, puis, et ce de manière complètement séparée, l’utilisateur abonné va pouvoir demander à recevoir des mails sur les entrées nouvelles dans cette bibliothèque SharePoint. Du coup, la fonctionnalité abonnement n’a aucun rapport avec le workflow, ce qui atteint un bonne Separation Of Concerns.

La démo part ensuite sur Rok, qui est un produit commercial non Microsoft, basé sur Silverlight. Il montre une excellente ergonomie visuelle, avec beaucoup de gestion par des diagrammes, et pas de menu ou presque. Une cartographie des procédures est également très intéressantes pour voir les impacts des instances de workflow en cours sur les différents acteurs.

La démo utilise le client de test WCF pour faire voir que l’interface fait avancer les couleurs du workflow en fonction de l’étape atteinte effectivement par l’instance.

Il y a un addon Biztalk pour générer un BAM à partir des indicateurs dans Excel. Les conférenciers n’ont pas donné le nom de ce plugin, mais il doit être possible de le retrouver sur internet, ou au besoin en retrouvant le contact sur cette session dans le site TechDays.

[Edit]

Je rajoute les commentaires après migration du contenu depuis mon ancien blog.

Jérémy Jeanson :

Alors là, je suis dégouté… J’ai raté la session qui m’aurait le plus interrrrrrrrrrrrressé Frown

Merci pour ce resumé!

GROSPELIER David :

Bonjour,
J’ai eu le plaisir de co-animer cette session et je vous remercie de consacrer un billet à ce sujet.

Je viens de publier un billet sur mon blog pour donner plus de détails sur la partie ‘BAM’ de la session. Ce billet devrait donc répondre à votre question concernant les outils utilisés pour le BAM.

Pour accéder au billet de mon blog, c’est ici : http://wp.me/p3NhP-2Q

Posted in Retours | Leave a comment

[TechDays2011] Booster votre productivité avec Visual Studio .NET 2010

Posted on 09/02/2011 by JP Gouigoux

Conférence sous la forme de démo d’outils de productivité de VS.NET. Les orateurs commencent par remarquer que VB6 et VS 2003 sont toujours en vente sur Amazon, et qu’il serait temps de faire voir les avantages de VS 2010.

L’ouverture d’un bug fait voir tous les détails du test qui montre le problème, en particulier la version exacte de test. Il y a aussi une vidéo, mais ça ne marche pas super sur cette démo.

L’exécution du test enregistre un log complet de type IntelliTrace. Très intéressant, mais on se pose aussitôt la question de la possibilité d’enregistrer ceci chez un client…

Génération de diagramme de séquence : très sympa, mais est-ce que c’est bien une fonction de la version Pro, ou est-ce que ce n’est que du Ultimate ?

La démo fait ensuite voir les tests automatisés avec enregistrement, les tests impactés, les tests générés par PEX, etc.

Posted in .NET, Retours | Tagged | Leave a comment

Tech Days 2011 : Top 10 des fonctionnalités SharePoint 2010

Posted on 09/02/2011 by JP Gouigoux

Allez, une petite session de débutant, sur une technologie que je ne connais pas suffisamment. Après une introduction à ce qu’est SharePoint, et qui est vraiment TRES générale, on passe aux dix points proprement dits, à savoir :

Les modèles de site

Il y a des modèles orientés CMS, d’autres orientés collaboratifs, etc. et on peut bien sûr créer d’autres templates. Ensuite, l’administrateur peut les instancier sous forme d’un nouveau site.

Le ribbon (GUI)

Bon, on ne va pas passer 10 minutes à expliquer la contextualisation d’un menu…

Les bibliothèques de documents / listes

Ce sont les conteneurs pour stocker de l’information. On parle de listes si ce sont des informations sous format non documentaire.

Pareil pour la simplicité des fonctions : c’est effectivement simple de traduire les commandes dans le site à la volée en changeant de langage, mais en même temps, c’est une fonctionnalité qui est intrinsèquement simple et qui existe depuis 15 ans sur n’importe quel site. C’est un peu dommage du coup de passer du temps là-dessus.

Les groupes et autorisations

Sur le versioning, on peut limiter le nombre de versions stockées, vu qu’il n’y a pas de delta sur les binaires.

Les circuits d’approbation

L’approbation de contenu simple peut être remplacée par des workflows plus complexes. C’est quand on publie une version majeure que ça déclenche le circuit d’approbation. Les workflows sont plus complexes, avec la possibilité de mettre des gens dans l’ordre ou pas, avec des temps limites, etc. Et si ça ne suffit pas, on peut passer à Visual Studio .NET pour paramétrer vraiment en détails.

Le workflow peut être visualisé de manière ergonomique avec du Visio autogénéré.

La gestion de contenus

On peut créer des templates d’entrée de contenu, de façon à contraindre les auteurs à entrer dans un format très précis.

Le référentiel de métadonnées

On peut créer une taxonomie. On parle de mots-clés d’entreprise, et la suggestion automatique va utiliser la liste de mots-clés. Le référentiel hiérarchique ainsi créé peut être sécurisé à un niveau donné, pour affecter la responsabilité de la mise à jour des termes à tel ou tel groupe.

Les fonctionnalités sociales

MySite est le site perso d’un utilisateur. Folksonomy = taxonomy enrichi par les utilisateurs, au lieu d’être fixée de manière administrative centralisée.

Un composant Silverlight affiche un diagramme de hiérarchie en fonction des utilisateurs dans l’ActiveDirectory.

Le moteur de recherche

Intégration FAST possible. La recherche par facettes est mise en place.

Les Office Web Apps

Intégration de bouts d’office dans SharePoint

Posted in Retours | Tagged | Leave a comment