NDepend, la pleine maturité !

Il y a quelques bonnes années déjà, j’avais demandé à NDepend si je pouvais bénéficier d’une licence d’essai grâce à mon statut de MVP (beaucoup d’éditeurs le font) et Patrick, le responsable, avait bien voulu accéder à ma requête. Déjà, j’avais été impressionné et j’avais fait acheter une licence à une entreprise pour laquelle je travaillais à l’époque.

Il y a peu, j’ai eu envie de faire quelques tests de couplage d’une application par rapport à une autre, suite à une interop conçue il y a longtemps, dans une galaxie très lointaine où les développeurs ne connaissaient pas le concept de couplage lâche. Bon d’accord, je voulais savoir à quel point j’avais mal codé à l’époque, et si le travail que j’avais supervisé avec mon stagiaire était aujourd’hui regardable sans avoir honte. J’ai donc demandé à Patrick à nouveau s’il voulait me faire faire un test de son outil, et il a encore accepté, en me prévenant qu’il y avait du nouveau, en l’occurrence un graphe de dépendances réécrit. Pour être honnête, je pensais que ça allait surtout être du relookage, une ergonomie améliorée ou quelques efforts pour la performance… En fait, la refonte n’a pas usurpé son nom et le résultat est assez exceptionnel ! Je ne résiste pas au plaisir de renvoyer sur l’animation qui décrit ça dans le site NDepend :

Imaginez que vous puissiez d’un coup voir toutes les dépendances dans votre code, en zoomant à n’importe quel niveau et en revenant en arrière avec un simple scroll de souris. Ca paraît aussi magique que ces images dans lesquelles on zoome quasiment sans limite, sans que l’image serait dynamique en plus. Mais ça marche… et en plus avec des performances de dingue. De quoi voir votre code complètement différemment, car on peut sans arrêt jongler entre l’architecture de haut niveau et le pourquoi de la dépendance dans le code. La difficulté principale du logiciel, qui était liée à la difficulté de lire la matrice de dépendances, est donc complètement levée.

Retour sur un vieux projet

Il y a presque dix ans, le framework Bamboo permettait de faire de la prévalence (persistance de données en mémoire, y compris post-extinction du processus), ce qui était phénoménal en termes de performance et de capacité de développement rapide. Honnêtement, je n’ai jamais compris pourquoi cette approche n’a pas plus percée, mais je pense que le pas psychologique était trop grand. Trop en avance sur son temps, mais c’est comme toutes les technos, ça reviendra dans dix ans et on hurlera au génie et à l’innovation incroyable. Bref…

En son temps, je me disais que peut-être que rendre compatible Bamboo avec SQL permettrait de faciliter le passage à certains, et j’ai donc eu un stagiaire, excellent de surcroit, qui s’appelait Damien et qui a créé sous ma supervision un fournisseur ADO.NET pour Bamboo, comme j’en ai parlé ici. Le code est en open source et vous pourrez le trouver sur ce dépôt Github.

J’étais en train de chercher une solution pour du prototypage très rapide d’API métier avec des règles business et je me suis rappelé que la prévalence était le meilleur moyen de faire cela. Ayant besoin d’une compatibilité SQL, je me suis rappelé de ce projet, mais était-il vraiment au point ? Je me rappelais de l’avoir présenté au BreizhCamp avec Damien, mais était-ce encore à l’état de prototype ou bien terminé ? Gros blanc…

Comment savoir si ce code était à peu près correct ? En retournant dans le code source ? C’est certainement ce que j’ai fait de plus compliqué conceptuellement avec un stagiaire et je n’avais pas trop envie de me replonger dans le code. Quoi de mieux que NDepend pour reprendre la main.

Allô, Patrick ?

La même recette a encore fonctionné et le responsable de cet outil de merveille a été d’accord pour m’accorder encore une licence d’utilisation. Me voilà donc reparti à l’assaut du projet, mais bien équipé.

Il faut reconnaître que ce fameux graphe est assez incroyable :

icpglfhcaomnplnj

En un coup d’oeil, j’ai retrouvé le fonctionnement du provider, avec un analyseur de syntaxe Irony et un fournisseur complètement compatible avec ADO.NET.

Tiens, quand on zoome, on voit vite quelque chose d’intéressant : une
dépendance circulaire qui traine !

poomapmenohalmip

Je suis pourtant assez maniaque sur le sujet et le stagiaire était excellent, donc ça vaut le coup d’aller voir en faisant un clic droit et en envoyant dans la matrice de dépendances (un bête clic-droit sur la flèche, comme ça semble logique, tombe sous la main) :

fgodlmahidbpkngo

Oui, juste une petite dépendance mais l’exception aurait dû être dans un espace de nommage commun au client et à l’extracteur de code pour éviter ce problème…

Problème trouvé en… allez une minute top chrono, alors qu’une analyse de code sans l’outil ne m’aurais pas permis de le détecter. Et si je l’avais cherché avec les méthodes traditionnelles, j’aurais mis au moins un quart d’heure à faire le tour des classes concernées, sans parler des risques d’erreur, surtout que quand on se concentre sur les dépendances fonctionnelles, on a vite fait de passer complètement à côté de la partie non fonctionnelle et les exceptions en font partie.

Vision complète d’un codebase

Un autre graphique permet de voir en visite la structure globale du fonctionnement de l’application exemple, et donc de retrouver tout de suite comment fonctionne le test du provider ADO.NET :

phiaoojdgjnjniof

Evidemment, si on regarde tout au niveau méthodes et champs, on en bave, et ce même si on peut zoomer comme on veut !

nogcnaapjcandfei

Mais le miracle vient de la fonction de clustering, qui permet de trouver des ensembles intelligents de dépendances :

bcbnhbmpplgdpmlm

Ce qui est surtout très fort est que le graphe est très réactif. Tous les calculs sont faits en amont et même ça, ça ne prend qu’une dizaine de secondes pour un gros projet comme celui-ci.

L’outil de recherche nous permet de localiser en quelques secondes la classe à analyser dans tout ce plat de spaghettis :

poajehbgmjelkljf

C’est là qu’on se rend compte qu’on est bien de peu de chose avec nos petits projets à côte du framework .NET, sachant que là, on ne voit que System.Data !

jpnnpppefecfobjm

Eh oui, tout à gauche, le petit bout ridicule correspond au graphe
montré précédemment. Tout ce qui est à droite est en dépendance, et
on voit en bleu foncé les appels indirects. Là encore, on se rend
compte qu’un appel relativement simple pour nous mobilise en fait
toute une tringlerie dans le parser (Irony, dans le cas étudié) mais
aussi dans les dépendances de la BCL, en l’occurrence surtout
System.Data comme expliqué plus haut, le projet consistant à créer
un fournisseur de données ADO.NET pour le moteur de prévalence
Bamboo.

Une autre façon de voir ce ratio est sur les métriques en treemap :

nfpaieefpmllllfj

System.Data est énorme en termes d’instructions IL mais aussi en namespaces utilisés. Étonnamment, le framework Bamboo n’est pas si important qu’on pourrait le croire, et contient à peine deux fois plus d’instructions qu’Irony, lui-même correspondant en gros à la taille du provider, qui inclue toutefois la description de la grammaire à parser, en l’occurrence SQL, alors qu’elle vient elle-même d’Irony.

Gestion de la qualité du code

Le dashboard est ultra-complet :

njgmdhmlpkphmalh

Et encore, je n’avais pas activé la gestion de la couverture de code par les tests ni la comparaison par rapport à une baseline, vu que c’était la dernière version de code du provider et que je n’ai pas de version ancienne ou nouvelle à opposer à celle étudiée.

Je me suis toujours posé la question de la façon dont était étudiée la dette, donc c’est l’occasion de voir le mécanisme grâce à l’aide contextuelle (voir ci-dessus). Ce qui est bien est qu’on peut toujours revenir en arrière et changer facilement le contenu du projet d’analyse, ce qui dans mon cas était particulièrement important pour cette analyse de la dette technique, car je n’allais évidemment pas prendre en compte les 177 jours de résolution de System.Data et autres dépendances. En relançant pour la seule assembly correspondant au provider, on retombe sur quelque chose de plus logique… et rassurant :

lfehblnffbocbkjg

Encore deux règles critiques violées, je me demande ce que ça peut être. Là encore, l’ergonomie est top et un clic nous amène directement sur les deux problèmes :

ocoeckhofjmbbhmj

Encore une fois cette dépendance cyclique, et on sait maintenant qu’il y aura un peu de boulot, car il y a 20 occurrences. Un double-clic sur la règle, et nous voilà avec la liste tout prête des endroits où porter une correction :

gdcfbodhamghnlfl

On retrouve la dépendance en boucle vue plus haut et causée par le fait que l’exception n’a pas été externalisée.

Pour les autres, le problème est au niveau du namespace SampleApplication.Queries qui appelle SampleApplication. Pour voir ce qui se passe précisément, on peut copier les types dans la matrice :

nohaekaijkfagpoi

Un coup d’œil nous permet alors de trouver le point exact du problème :

jfobiobakpjhbdec

L’autre possibilité est de passer par l’ouverture du code piloté par NDepend :

fjhfhnfadojfcpeo

La fenêtre permet de choisir lequel des deux problèmes est à traiter :

belhepjoigjemilk

Et un clic nous renvoie alors directement sur le cœur du problème :

kgankpgkccmaimhj

L’exécution pourrait effectivement être plus propre si on n’avait pas à caster l’objet passé dans des types qui sont sur SampleApplication, à savoir le PersistenceSet et le PersistenceEngine.

Conclusion

Au final, je n’avais pas utilisé NDepend depuis quelques temps vu que je faisais plus d’architecture et d’urbanisation des SI que de code, mais je vois que l’outil a encore grandi et s’est renforcé. Sa puissance peut paraître difficile à maitriser au premier abord, mais l’interface fait intelligemment des liens multiples entre toutes les fonctions, ce qui fait qu’on s’y retrouve d’une façon ou d’une autre, et que finalement chacun aura peut-être une façon différente de naviguer entre les multiples outils, mais c’est sans importance.

La fonction de graphe, quant à elle, est proprement bluffante. La performance est même telle qu’on se demande s’il n’y aurait pas de l’accélération des traitements par la carte graphique, avec des approches vectorielles. La possibilité de zoomer quasi à l’infini fait penser à ces images à ultra-haute résolution, mais ce n’est visiblement pas cela qui est utilisé. Dans tous les cas, la méthode fait des miracles.

Bien sûr, si votre code est très complexe, il restera compliqué à lire et déboguer, même avec NDepend, mais vous aurez un pilote pour vous y retrouver. Et même dans le cas où le code est relativement bien connu, on peut retomber sur des choses à améliorer comme je l’ai constaté sur ce petit projet !

Je ne peux pas finir sans féliciter l’équipe NDepend, car cet outil est vraiment un bijou. Je ne sais pas si Patrick est tout seul derrière, mais j’ai du mal à imaginer ça, vue la puissance et l’utilisabilité du produit. Et encore, je n’ai pas parlé de toutes les règles et alertes, ainsi que les indicateurs sur la qualité du produit ! Bref, chapeau Smile.

En me baladant sur le site, je vois que NDepend est même intégré à Azure DevOps. Manque plus que le support de Visual Studio Code et on aura atteint l’absolue perfection !

Posted in .NET, Performance, Prevalence | Tagged | 2 Comments

De Windows 95 à Windows 10

image

Doit-on conclure que Windows 10 est 320 fois plus utile / performant / fonctionnel que Windows 95 ? Pour avoir connu les deux, clairement le nouveau est mieux, mais pas tellement plus rapide alors que ma machine est 100 fois plus puissante que l’ancienne…

Est-ce qu’à un moment, ça ne va pas valoir le coup d’abandonner trente ans de compatibilité ascendante et de repartir depuis les couches basses, de façon à avoir quelque chose d’un tant soit peu performant ?

Posted in Uncategorized | Leave a comment

Web2day Nantes !

J’aurais le plaisir de présenter un retour d’expérience à Nantes à la mi-juin, à l’occasion du Web2day “Digital Springbreak” (j’espère que ce sera moins bruyant qu’à Fort Lauderdale).

Le sujet :

Votre SI manque de souplesse ? Vous n’êtes pas le seul… La majorité des SI actuels utilisent 80% du budget pour la maintenance et seulement 20% pour évoluer. Il existe pourtant des solutions pour industrialiser l’informatique mais elles sont aujourd’hui peu diffusées. La solution est en partie technique (le trio MDM+BRMS+BPM, la Web Oriented Architecture) mais surtout fonctionnelle (alignement Business/IT, normalisation des échanges, DDD). Elle a été mise en œuvre par l’auteur sur plusieurs grands SI, et cette conférence vous expliquera comment.

Bannière-speaker-Jean-Philippe-Gouigoux

Posted in Uncategorized | Leave a comment

Teaser pour l’atelier BreizhCamp “Urbanisation du SI expliquée par les Lego”

Après un weekend complet à préparer des Lego reflétant au mieux les complexités d’un SI, je commence à avoir quelque chose de propre :

Orchestration, chorégraphie, Entreprise Integration Patterns, couche d’intermédiation, API gateway, robustesse d’intégration, coupe-circuit, on va parler de tout ça et poser les bonnes méthodes pour urbaniser un SI avec des microservices, tout en se basant sur des Lego pour que même les débutants prennent les bonnes pratiques d’architecture.

Mon fiston m’a bien aidé pour préparer plein d’EIP, ça va être un chouette atelier je pense !

Posted in Uncategorized | Leave a comment

MLStudio : l’IA pour les nuls !

Imaginons que vous souhaitiez utiliser les capacités de l’Intelligence Artificielle mais que vous ne connaissiez rien aux réseaux neuronaux, régressions logiques, perceptrons et algorithmes bayésiens. C’est tentant ! Vous entendez parler d’IA et de Machine Learning dans tous les magazines et les promesses sont alléchantes : trouver des réponses dans des données disparates ou réaliser des programmes prenant des décisions sans avoir à coder, et donc sans avoir à comprendre dans le détail toutes les subtilités des causes et des conséquences métier. Or, comprendre tous ces modèles est affaire de spécialistes. Mais, comme pour le reste de la programmation, on aimerait que ces “couches basses” soient cachées et que nous puissions les utiliser sans trop nous poser de questions sur leur fonctionnement interne.

Il se trouve que le Microsoft Azure Machine Learning Studio réalise exactement ceci pour vous.

Prenons un exemple que j’ai déjà expliqué dans ce blog, à savoir la reconnaissance de lettres exprimées par les squelettes capturés par une Kinect. C’est un TP que je fais avec des étudiants depuis quelques années et qui fonctionne plutôt bien pour les amener à pratiquer le Test Driven Development, comme expliqué sur cette page.

L’algorithme que les étudiants doivent arriver à mettre en œuvre consiste à trouver les lettres représentées par le haut du corps lors de la chorégraphie “YMCA”. A partir de cinq points définis par une coordonnée X et une coordonnée Y (soit au total dix paramètres), la fonction étudiée doit renvoyer Y, M, C, A en fonction des positions des mains et coudes gauche et droit et du centre des épaules, ou bien un tiret si le squelette ne forme aucune lettre reconnue. Par exemple, ceci représente la lettre Y :

image

Certains étudiants créent des algorithmes basés sur les angles, d’autres sur les distances selon les deux coordonnées, d’autres enfin s’égarent quelque peu en pensant se baser directement sur des zones de coordonnées (ce qui supposerait que la personne soit toujours bien au centre de la vision du périphérique, bref limiterait fortement la pertinence de l’algorithme). Je me suis récemment demandé si des mécanismes simples d’IA pourraient leur être montrés à titre d’exemple. L’algorithme n’est en effet pas très complexe à trouver, mais il leur faut en général un peu d’aide du prof pour arriver à le réaliser en deux heures.

Serait-il plus rapide d’oublier toute notion d’algorithme et d’apprendre simplement à une intelligence artificielle à reconnaître les différentes postures ?

C’est la question à laquelle je vous propose de répondre en vous accompagnant sur cet exemple avec ML Studio. La première étape consiste à vous connecter à https://studio.azureml.net/. Si vous n’avez pas de compte Azure, le site vous propose de bénéficier des 150 € gratuits fournis par Microsoft.

image

Une fois connecté, ML Studio vous accueille avec le liste des “experiments” que vous avez déjà mises en place, et le bouton en bas à gauche vous permet d’en créer une nouvelle :

image

Le tutoriel est très bien fait (et je ne vais pas faire grand-chose de différent dans cet article) et les autres exemples sont d’excellentes façons de prendre en main les fonctionnalités, mais pour l’instant, nous allons simplement créer une “blank experiment” :

image

Comme vous le verrez sur l’interface qui apparaît, une “expérience” ML Studio est composé d’un graphe de modules qui sont liés les uns aux autres. Le tout premier, de type Import Data, a comme son nom l’indique pour but d’importer la donnée qui va servir à mettre en œuvre notre moteur d’IA :

image

Une fois le module posé dans le graphe, nous allons le paramétrer pour pointer sur le fichier d’apprentissage (exposé dans notre cas sur un simple serveur web pour y accéder par HTTP) :

image

Il est important de s’arrêter sur le contenu du fichier pour bien comprendre l’idée de cet article. Le fichier CSV contient des ensembles de points produits par la Kinect et qui ont systématiquement été créés pour produire des postures à reconnaître :

image

Pour créer ce fichier, des postures diverses ont été prises devant la Kinect pour “montrer” au système à venir ce qu’est une posture de type “Y” ainsi que toutes les autres postures et en particulier des postures neutres pour que l’algorithme apprenne aussi quand il doit renvoyer simplement un tiret, pour dire que le squelette ne forme pas une lettre reconnue. Le plus simple est alors de travailler avec deux personnes. Une pose avec des mouvements divers et la seconde enregistre les coordonnées avec la lettre (ou l’absence) qu’il considère correcte. Ce fichier montre ainsi de nombreuses positions, neutres ou “valides” – au total 249.

Sans rentrer dans le détail des algorithmes (c’est bien le but de montrer qu’on peut créer un moteur d’IA sans avoir à connaître le fonctionnement interne), il faut juste savoir qu’un “modèle” s’entraine à partir de ces données à les reconnaître, mais qu’il est important de se garder des données de côté pour pouvoir évaluer sa pertinence en le testant avec des situations qu’il rencontre pour la première fois. Pour cela, il est habituel de commencer par couper les données en deux, en ajoutant un module Split Data.

image

Dans notre cas, il est essentiel d’activer l’option “Randomized split”, sinon les situations correspondant aux différentes lettres ne seront pas mélangées et le modèle aurait alors très peu de chances de fonctionner car le fichier utilisé prend les lettres à apprendre dans l’ordre, avec des formats neutres entre les différents paquets d’échantillons équivalents. Le lien entre les modules se fait simplement par un glisser-déposer. Assez logiquement, le module d’import possède une sortie et celui de découpage en montre deux, que nous allons brancher pour la première sur le module d’apprentissage (Train Model) et la seconde sur celui d’évaluation (Score Model) :

image

L’interface utilise des codes de couleur verte ou rouge pour indiquer quelle entrée est compatible avec la sortie sélectionnée sur un autre module, ce qui facilite encore l’utilisation. Le premier paramètre attendu par le module Score Model est – logiquement – le modèle qui a été “entraîné”. Nous les relions donc comme suit, ce qui aboutit à la suppression de l’icône d’erreur sur Score Model :

image

Pour ne plus avoir d’erreur sur Train Model, il faut lui donner en paramètre un algorithme de Machine Learning, en l’occurrence un mécanisme de classification. C’est ce que nous allons faire dans notre cas : classer des ensembles de points dans des catégories différentes, auxquelles nous donnerons des noms (dans notre cas, de simples lettres). Des algorithmes d’IA sont spécialisés dans la classification à deux classes (déduire si une entrée va dans une entrée ou une autre), d’autres dans la classification multi-classes. Nous allons utiliser un d’entre eux, à savoir le Multiclass Decision Forest :

image

Le module Train Module est encore en erreur car nous n’avons pas spécifié quelle colonne le modèle devait s’entraîner à trouver. Pour cela, il faut sélectionner ce module pour afficher ses options (voire les dérouler si nécessaire) et cliquer sur Launch column selector :

Dans la fenêtre qui s’affiche, au lieu de sélectionner les colonnes par leur nom, nous allons les sélectionner par leur indice dans le fichier. En effet, le fichier CSV ne contenait pas d’entête ; mais nous aurions pu travailler autrement, et il aurait fallu dans ce cas indiquer au module Import Data que la première ligne contenait les noms de colonnes.

image

Ci-dessus, nous indiquons que la colonne contenant les lettres indiquées est la onzième du fichier (attention, l’index de début est à 1, contrairement aux habitudes des développeurs de commencer à 0, mais cela marque aussi le fait que ce type de “studio” est destiné à faciliter le travail à des personnes non techniques).

Arrivés à ce stade, nous allons simplement rajouter un dernier module – à savoir Evaluate Model – permettant l’analyse statistique du score du modèle. L’évaluation se fait en effet en obtenant un Score puis en l’évaluant, avec comme nous le verrons des sorties numériques et graphiques permettant de mieux comprendre ce score :

Le modèle est prêt à être lancé grâce au bouton Run. Après quelques minutes au maximum (notre modèle n’est pas très complexe), un clic droit sur le module d’évaluation du modèle fait apparaître le menu contextuel suivant, dans lequel nous allons choisir Evaluation results / Visualize :

Les métriques affichées montrent une bonne précision moyenne du modèle, de plus de 95% :

Comme nous sommes dans un algorithme de multiclassification, nous avons également la précision sous forme de matrice :

image

La lecture en est assez simple. Par exemple, lorsque la classe est effectivement un M, il y a 86,7% de chance que la prédiction soit un M et 13,3% de chance que la prédiction ne reconnaisse pas le signe M (symbole tiret renvoyé).

En ajoutant quelques lignes de données, il serait assez simple d’amener ce modèle vers des taux de prédiction encore meilleurs, et – comme promis – nous n’avons pas écrit une seule ligne de code pour obtenir cet algorithme, mais nous n’avons pas non plus eu à plonger dans des calculs mathématiques complexes.

Et cerise sur le gâteau, le modèle est extraordinairement facile à exploiter une fois créé. Il suffit de cliquer sur l’icône Set up web service pour que ML Studio crée un modèle de prédiction en ligne :

image

Le modèle créé peut alors être exposé en ligne grâce à l’icône Deploy web service (après l’avoir toutefois lancé avec Run, comme il s’agit d’une nouvelle “expérience”) :

image

Le résultat est une API qui va vous permettre de consommer cet algorithme de prédiction par IA depuis n’importe quelle application ou périphérique intelligent, avec en plus un mode batch, et une sécurisation par clé d’API :

image

En suivant le lien Request / Response, vous arrivez sur une page de documentation extrêmement complète, avec l’adresse à utiliser pour déclencher une prédiction, les headers HTTP supportés, des exemples de corps de requête, etc. :

image

Il y a même les squelettes de code C#, Python ou R nécessaires pour appeler l’API !

image

Bref, en une demi-heure maximum (c’est-à-dire moins que ce qu’il m’a fallu pour écrire ce post), vous avez un modèle de prédiction IA disponible en ligne, avec des machines derrière pour obtenir des performances intéressantes, et ce pour un investissement en connaissance de l’IA quasiment nul et un coût d’exposition très réduit. Je me demande quand je vais avoir mon premier étudiant qui réalise mon TP en remplaçant l’algorithme codé par une version basée sur une IA. Il y a quelque temps à peine, je pensais que ça prendrait plus de temps que de juste réfléchir au meilleur moyen d’implémenter un algorithme en code, mais quand je vois la vitesse à laquelle on peut réaliser un moteur de prédiction, le plus dur sera juste de capturer les postures d’apprentissage…

Posted in Uncategorized | Leave a comment

Un nouveau WebBrowser embarqué dans WinForms

L’intégration d’un navigateur embarqué dans une application native Windows est un excellent moyen de faire de la migration progressive d’interface, en implémentant progressivement des écrans en web tout en les rendant utilisables dans une application Windows. Moyennant quelques efforts de programmation finalement assez légers, une authentification correcte peut être gérée, des évènements du DOM peuvent être récupérés et on arrive à un bon niveau d’interop.

Seulement, voila, le contrôle WinForms WebBrowser est assez vieux et on était loin d’avoir toute la puissance des navigateurs modernes… jusqu’à ce que Microsoft nous fasse la surprise d’intégrer Awesomium dans les contrôles WinForms de Visual Studio 2017 ! Et ça change tout ; pour preuve, un petit benchmark très simple en appelant http://lemonde.fr sur le WebBrowser (à gauche) et sur le navigateur embarqué Awesomium (à droite). Dans les deux cas, il n’y a qu’une ligne de code pour naviguer sur le contenu dans le code derrière le bouton respectif…

image001

A gauche, donc, 100 Mo de mémoire consommés pour arriver à un affichage lent et inutilisable, avec des erreurs de script à n’en plus finir. Bref, un résultat pourri. A droite, seulement 30 Mo de mémoire consommés et le résultat saute aux yeux comme bien meilleur.

Je dois avouer que je n’avais pas vu ce contrôle arriver dans ma veille ni sur aucun blog ni sur les annonces de Microsoft. C’était donc une surprise de tomber là-dessus en faisant un test de WinForms dans Visual Studio 2017, mais pour le coup, c’est vraiment une excellente surprise !

Posted in Uncategorized | Tagged | 2 Comments

Retours sur l’atelier Architecture évolutive des SI expliquée avec des Lego™

Trois semaines ou presque passées depuis le 23/11, jour de l’atelier organisé par Agile Rennes à la French Tech, où j’ai eu le plaisir d’expliquer l’urbanisation des SI par des métaphores utilisant les Lego, accompagné de Benoît Chanclou (merci Benoît d’être venu malgré un rhume carabiné !).

WP_20171123_19_43_28_Pro

J’ai désormais un peu de feedback, donc après un résumé pour ceux qui étaient absents et me l’ont demandé, je détaillerai ce qui va être amélioré pour la prochaine fois où je jouerai cet atelier.

Objectif

Ce qu’on cherche à montrer dans cet atelier est qu’il existe des méthodes permettant en informatique de mettre en œuvre une industrialisation telle qu’elle existe dans les autres métiers plus vieux, comme l’industrie traditionnelle, l’automobile, la construction d’ouvrages, etc.

Aujourd’hui, en informatique, la tendance est à tout le temps tout réécrire, tout simplement parce qu’on n’a que récemment trouvé la définition de ce que pouvait être une brique renouvelable. Après les routines, les librairies, les composants, les composants distribués, COM, COM+, DCOM, DNA et tout le bazar, on sait maintenant que la brique doit être fonctionnelle (approche SOA). Mais comme il a fallu quelques dizaines d’années pour standardiser le filtre à huile de nos voitures, il va falloir du temps pour réaliser la même chose en informatique. Heureusement, les normes sont présentes et la techno est désormais prête (REST, microservices, EIP, diagramme 4 strates pour l’urbanisation, etc.).

Pour rappel, les critères d’industrialisation sont :

  • prédictibilité
  • normalisation
  • capacité à mesurer la performance

Atelier 1

Le premier atelier consiste à trouver un moyen de rendre “interfaçable” une tour et un corps de château. L’ensemble doit correspondre au modèle ci-dessous, le but étant de pouvoir facilement changer la tour pour une plus grande.

image

Il s’agit de la première approche vers une interface contractuelle. Un retour important pour un prochain atelier est de mélanger les personnes connaissant déjà le Lego et celles n’ayant que peu touché aux briques magiques dans leur enfance. Les constructions, sinon, manquent parfois un peu de solidité. Or, le but est de ne pas sacrifier complètement celle-ci au caractère interchangeable.

Atelier 2

On passe à quelque chose de légèrement plus complexe, avec une modélisation des messages véhiculés dans un Système d’Informations sous forme de plaque contenant quatre “pistes”. La présence ou l’absence de crémaillère permet de spécifier des qualités d’une personne tandis qu’une piste avec des briques de couleur symbolise son identité, en permettant de nombreuses combinaisons. Mine de rien, avec seize couleurs différentes sur 4 emplacements, on obtient déjà 65000 et quelques codages !

La porte réalisée pour le passage de cette plaque correspond à l’interface, bref au contrat à respecter pour pouvoir laisser entrer et sortir des plaques standard. Le sens est essentiel car la porte n’est pas symétrique (vu pendant l’atelier… et corrigé aussitôt).

image

Ainsi, un module de traitement va être composé de deux portes, une pour l’entrée et l’autre pour la sortie. Comme les faces opposées des portes peuvent se clipser, on obtient bien la capacité de réaliser ce qu’on veut à l’intérieur des modules sans présupposer de l’ordre dans lequel ils vont être utilisés :

WP_20171122_11_57_43_Pro

La créativité de tous a donné lieu à de joyeux délires (le passage de la plaque qui bat les œufs en neige, etc.), et deux perles que j’ai eu le temps de prendre en photo, à savoir le siège qui se penche pour les employés et qui éjecte les cadres :

WP_20171123_20_32_02_Pro

et aussi le système de modulation du son et des lumières en fonction des privilèges associés à la personne (belle utilisation du gros engrenage, en prise directe sur la sirène tournante) :

WP_20171123_20_35_15_Pro

Atelier 3

Le temps manquant sur une soirée (l’atelier dure plutôt une journée), les deux derniers ateliers ont été réalisés sous forme de démo. Le premier montrait comment on pouvait modéliser en Lego une activité d’orchestration. Les plaques à crémaillères contenaient ainsi la “recette” des opérations à lancer, et elle était exécuté par un moteur qui lançait des rotations des axes standards de sortie en fonction, ces derniers étant reliés vers des “effecteurs”, métaphore des services logiciels (non montrés ci-dessous) :

image

Le lien était ensuite fait sur de véritables processus d’orchestration de Systèmes d’Information :

image

Atelier 4

Enfin, le dernier atelier, également réalisé sous forme de démo, montrait une approche légèrement différente de l’intégration de services, à savoir une étape entrée / sortie correspondant à une portion d’un ensemble en mode “chorégraphie” :

image

La limite dans la métaphore (remontée en feedback par Benoît) était que l’entrée manuelle ne modélise pas suffisamment clairement le fait que cette entrée peut également provenir d’un évènement déclenché dans un autre module. J’ai acheté quelques plaques supplémentaires pour pouvoir modéliser ces évènements par la suite. Idéalement, une rotation de l’axe pourrait enclencher un interrupteur. Pour terminer le traitement, il serait également possible de fermer l’interrupteur lorsqu’une plaque de commandes (comme celle utilisée ci-dessus) serait utilisée.

Bref, il va falloir faire quelque chose de plus sophistiqué pour mieux montrer la réalité d’un SI. Ce sera d’ailleurs l’occasion de mettre plus en avant les EIP, qui ont été montrés en métaphore Lego, mais pas manipulés par manque de temps. En préparant un système complet et en rendant les blocs “EIP” plus robustes, il devrait être possible de demander aux participants de créer leur propre médiation complexe.

image

Au final, le but est de montrer qu’il est (relativement) simple, pourvu que les messages soient correctement normalisés, de rendre facile pour les utilisateurs de gérer une chorégraphie simple (une commande pour un évènement), un peu à la mode de ce que font les applications grand public de type IFTTT ou Microsoft Flow.

image

Derniers feedbacks

Un autre point à régler est que les métaphores ne sont pas les mêmes entre les deux derniers ateliers, ce qui rend plus complexes la compréhension. D’où l’idée de les rejoindre tous les deux dans un seul ensemble, quitte à ce qu’il soit plus gros… Le message resterait toujours la plaque de base, et les EIP pourraient être utilisés pour modifier le fonctionnement des axes en sortie avec des EIP. Les effectueurs pourraient eux-mêmes déclencher d’autres moteurs qui effectueraient des actions complémentaires.

Bref, on peut encore largement améliorer cet atelier, mais l’essentiel a été rempli lors de cette session Agile Rennes : les participants étaient contents, ils ont déclaré que la métaphore les avaient aidés à comprendre les principes exposés et, magie de la manipulation par rapport à l’image, 70% de ce qui a été compris est désormais acquis (au lieu de 10% avec des diapos de présentation) !

Posted in Retours | Tagged , , | Leave a comment

Automatisation des attaques

Ca devient vraiment n’importe quoi… Pour les besoins de l’écriture de mon prochain bouquin, j’ai ouvert un cluster Docker Swarm sur un port 2375, donc sans passer par toute la tambouille des certificats, vu que ce n’est pas pour de la production mais pour des exercices sur quelques heures à peine.

A peine revenu de manger le midi, qu’est-ce que je trouve sur mon cluster ? Un processus pirate de minage de monnaie virtuelle :

image

Et impossible de se débarrasser de ce pou, à chaque fois que je kill le conteneur, un autre apparaît quelques minutes après au mieux.

Je jette un œil aux logs d’une application Node.js que j’ai exposée sur le 8080, et là, même chose : une série complète d’appels “de reconnaissance” sur des URL standards de PhpMyAdmin et Struts2 !

Comme je n’ai besoin du cluster que pour quelques heures, je ne vais pas me taper toute la procédure de sécurisation, mais quand même… ouvrir un port connu sur internet, c’est devenu une activité équivalente à se balader au milieu de hyènes avec un steak accroché au pantalon : il vaut mieux foncer si on n’est pas en 4×4 blindé.

Posted in Sécurité | Tagged | Leave a comment

L’ergonomie, la vraie !

Pour moi, c’est ça la vraie ergonomie : commencer à travailler sans connaître une fonctionnalité du logiciel, que celui-ci la fasse apparaître en reconnaissant le travail que vous cherchez à accomplir et que le résultat soit immédiatement celui voulu.

Excel dans ses fonctionnalités d’aide à la transformation de données

Trop fort, Excel (copyright Thomas G. :-))

Posted in Data | Leave a comment

MVP 2016 !

C’est reparti pour un an Sourire

Résultat de recherche d'images pour "logo mvp microsoft"

Fier d’avoir été désigné MVP pour la 6ème année consécutive !

Posted in Uncategorized | Tagged | Leave a comment