Le contexte du stage - Institut de Recherche en … · Web viewC'est un langage de script interprété du côté du serveur (les scripts CGI, PHP, JSP, etc, sont aussi exécutés

STAGE EFFECTUÉ DU 14 AVRIL AU 20 JUIN 2003À SELLIGENT (CHARLEROI BELGIQUE)

MEMOIRE DE STAGE

Intégration d’un outil de surveillance à un logiciel existant

Maître de stage Michel Wrzesien - Team Leader Web Development

Selligent Corporate

EtudiantRémy Liscia - Informatique 2ème année

Institut Universitaire de Technologie de Rodez (représenté par Mr Barrios)

RemerciementsJe tiens particulièrement à remercier l’équipe “Recherche et Développement” de Selligent qui m’a accueilli dans ses locaux de Charleroi, à commencer par le directeur technique : Monsieur Thierry Téchy, le directeur du département R&D : Monsieur Michel Wrzesien, ainsi que Jenny Migliore, Pascal Evrard et Walter Tricknot qui ont suivi mes travaux et qui m’ont apporté toute l’aide dont j’avais besoin.Un grand merci aussi à Monsieur Barrios, professeur à l’IUT, qui a suivi mon stage depuis Rodez et qui n’a jamais été avare de conseils.

SOMMAIRE

1-LE CONTEXTE DU STAGE..........................................................51.1-Le pays : la Belgique.............................................................................51.2-L’entreprise : Selligent..........................................................................51.3-L’activité : la CRM..................................................................................71.4-Les logiciels édités................................................................................7

1.4.1-Philosophie de Selligent..................................................................71.4.2-Logiciels édités par Selligent...........................................................8

2-LOGICIEL SELLIGENT XI FOR WEB.............................................92.1-Présentation..........................................................................................92.2-Fonctionnalités CRM..............................................................................92.3-Technologies utilisées...........................................................................9

2.3.1-Architecture DNA et COM................................................................92.3.2-Architecture .NET..........................................................................102.3.3-Programmation avec C#...............................................................122.3.4-Interfaçage avec ASP et ASP.NET..................................................132.3.5-Architecture Selligent .NET...........................................................13

2.4-Conclusion...........................................................................................173-DESCRIPTION DU PROJET.......................................................183.1-Contrat................................................................................................183.2-Présentation........................................................................................183.3-Fonctionnalités....................................................................................183.4-Utilisateurs..........................................................................................183.5-Fonctionnement détaillé......................................................................194-ETAPES DU PROJET................................................................204.1-Documentation....................................................................................204.2-Analyse................................................................................................214.3-Développement...................................................................................234.4-Tests....................................................................................................294.5-Récapitulatif........................................................................................305-LE BILAN DU STAGE...............................................................315.1-Bilan du projet.....................................................................................315.2-Un stage à l’étranger..........................................................................315.3-Un stage en entreprise........................................................................325.4-Un stage de fin d’études.....................................................................33ANNEXES.................................................................................34Glossaire...................................................................................................34Bibliographie.............................................................................................36Chronologie du stage................................................................................37Documents produits lors de l’analyse du projet........................................38Brochure de publicité................................................................................38

Intégration d’un outil de surveillance à un logiciel existant - Le contexte du stage

1-Le contexte du stage

1.1-Le pays : la BelgiqueGuère plus étendue que la région Midi-Pyrénées mais peuplée d'environ dix millions d’habitants, la Belgique est une monarchie parlementaire qui est composée de plusieurs communautés linguistiques, source de nombreux conflits locaux et de nationalismes exacerbés : les Flamands néerlandophones, les Wallons francophones et une minorité germanophone.Treizième puissance mondiale, la Belgique a connu une industrialisation lourde (sidérurgie, exploitation minière). Ces activités aujourd'hui sinistrées sont peu à peu remplacées par des industries de pointe (biomédecine, télécommunications, aviation, etc) et des activités tertiaires.C'est à Gosselies, près de Charleroi, dans une région où cette reconversion est aussi difficile à mettre en oeuvre qu'urgente, que se situe le siège social de Selligent, l'entreprise dans laquelle j’ai effectué mon stage.

1.2-L’entreprise : SelligentSelligent est un éditeur de logiciels destinés aux moyennes entreprises. Cette société Wallonne créée en 1990 compte aujourd’hui des filiales en Allemagne, au Canada et en France. Ses partenaires de distribution couvrent toute la planète : Europe, Asie, Amérique du Nord, Golfe et Afrique du Nord. Les logiciels qu’elle édite sont des logiciels de CRM (Customer Relationship Management, en français GRC : Gestion de la Relation Clientèle).Les 45 employés du siège à Charleroi sont en charge de la R&D (recherche et développement), des contrôles qualité (tests), du help desk (assistance clientèle), du marketing et de l’administration.Employant 90 personnes dans tout le groupe (principalement des commerciaux et des intégrateurs, qui vendent, personnalisent et installent les logiciels pour les sociétés clientes), Selligent revendique 35000 utilisateurs à travers le monde.

Rémy Liscia 5


Très présente sur le marché français (la moitié des ventes est effectuée en France), quelques uns de ces clients sont : Club Med, Lexmark, Gaz de France, France Telecom, Axa, Siemens, etc.D’un point de vue économique, Selligent se porte bien : son chiffre d’affaires était de 2.9 millions d’euros en 1998, il a atteint 9 millions d’euros en 2002. Depuis la crise des nouvelles technologies, l’entreprise a vécu des moments délicats et a dû procéder à des restructurations organisationnelles. Le retour au bénéfice est prévu pour cette année.Au niveau de la concurrence, le marché de la CRM est très vaste. Des sociétés comme Siebel ou SAP occupent le marché des très grandes entreprises. Les petites entreprises sont clientes d’éditeurs comme Act ou encore Archie. Selligent se situe entre les deux, avec des transactions variant entre 50 et 500 licences. Dans ce secteur, des concurrents existent (PeopleSoft, Onyx) mais le marché est en constante augmentation. L’annonce de l’arrivée prochaine d’un produit Microsoft de CRM sur le marché européen ne menace en rien Selligent : en effet, Microsoft s’adresse plus aux entreprises de petite taille et Selligent a pour avantages le multilinguisme et une approche européenne.

Marché européen de la CRM


1.3-L’activité : la CRMAussi appelée Gestion de la Relation Clientèle (GRC), la CRM permet aux entreprises de mettre en avant les relations qu’elles ont avec leurs clients, relations axées sur le cycle prospection, vente, maintenance et relance.

Prenons des exemples : un logiciel qui permet de sauvegarder les coordonnées des clients et d’effectuer du publipostage est un logiciel de CRM. De même qu’une application disponible sur assistant personnel (PDA) qui permet à des représentants de recueillir à tout endroit des informations sur leurs clients. Bien évidemment, et comme évoqué plus haut, les besoins sont différents selon les entreprises et Selligent propose une solution logicielle de CRM beaucoup plus élaborée.

1.4-Les logiciels édités

1.4.1-Philosophie de SelligentLes logiciels proposés par Selligent répondent à une philosophie global and local. Ceci signifie que les développeurs de Selligent fournissent une application de base très complète mais entièrement personnalisable (fonctionnel et design) et à laquelle peuvent s’ajouter des composants programmés supplémentaires, adaptés à l’activité de l’utilisateur. La personnalisation de l’application et l’ajout de nouvelles fonctionnalités sont effectués soit par l’entreprise utilisatrice (administrateurs, services informatiques, etc), soit par des intégrateurs et consultants partenaires ou employés de Selligent.


1.4.2-Logiciels édités par SelligentSelligent édite deux logiciels qui ont les mêmes fonctionnalités mais dont l’architecture diffère afin de répondre aux différents modes d’utilisations possibles.Ces deux logiciels appartiennent à la gamme Selligent Xi (eXtended Integration) :-“Selligent Xi for Windows” qui a un principe de fonctionnement client-serveur. Il s’agit d’un client lourd, c’est-à-dire qu’il y a un logiciel installé côté client.-“Selligent Xi for Web” qui fonctionne avec la technologie Selligent.NET Server et dont l’architecture est nettement plus complexe (détaillée plus bas).Aujourd’hui, tous les efforts de la R&D se portent sur la version Web car la version Windows ne répond plus aux besoins majeurs du marché de la CRM qui sont la mobilité, le coût total de propriété (TCO) réduit et le retour rapide sur investissement (ROI).La gamme Selligent Xi constitue actuellement la solution GRC la plus riche du marché mondial en termes de fonctionnalités et de flexibilité.Une licence Selligent vaut en moyenne entre 1000 et 1500 euros en fonction du nombre de licences achetées, de la durée de la maintenance, des fonctionnalités installées, etc.

Intégration d’un outil de surveillance à un logiciel existant - Logiciel Selligent Xi for Web

2-Logiciel Selligent Xi for Web

2.1-PrésentationSelligent Xi for Web est un logiciel multi utilisateurs, très convivial, utilisable par un navigateur Web, entièrement sécurisé, ce qui permet une utilisation à distance.Ce logiciel est très complet mais il est possible d’ajouter de nombreuses fonctionnalités en fonction des besoins de chaque entreprise utilisatrice.

2.2-Fonctionnalités CRMVoici les fonctionnalités CRM offertes par le logiciel :-informatisation des forces de ventes (itinérantes et/ou sédentaires) : gestion des processus commerciaux (plannings, publipostage, outils de prévisions).-informations marketing :gestion de campagnes de publicité, identification de profils de consommateurs, télémarketing, outils d’analyse pour déterminer les retombées des opérations précédentes.-gestion des services aux clients :gestion des garanties et des contrats, du service après-vente, de la maintenance, des réclamations.

2.3-Technologies utilisées

2.3.1-Architecture DNA et COMJusqu'en 2002, la programmation des logiciels Selligent se faisait sous une architecture de type DNA. Windows DNA (Distributed interNet Applications Architecture) est un modèle Microsoft de développement d'applications trois-tiers (présentation-application-données) pour la plate-forme Windows. DNA spécifie comment développer des applications distribuées, robustes et évolutives utilisant des composants COM.COM (Component Object Model) est un modèle de Microsoft qui simplifie l'intégration de logiciels. Ce standard spécifie comment créer des composants logiciels indépendants et réutilisables. Tirant parti d'une orientation objet, COM permet l’encapsulation, le polymorphisme et la

Rémy Liscia 9


réutilisabilité des composants logiciels dont l'intégration binaire, non fondée sur le code source, permet de ne pas remettre en cause un logiciel tout en augmentant les services et fonctionnalités offertes aux applications. Cette intégration binaire permet aussi d'écrire une application avec différents langages de programmation. Il s’agissait ici de C++.Dans la couche présentation de l'architecture DNA, on trouve les technologies ASP, JavaScript et XML qui sont chargées de l'interfaçage avec l'utilisateur.

2.3.2-Architecture .NETSuite à l’abandon des technologies COM, .NET a été adopté par Selligent.L’appellation .NET est imprécise car il s’agit en réalité d’un label que Microsoft attache à plusieurs de ses technologies. Evoquons les principales :

2.3.2.1-Framework .NET

Avec le framework .NET, Microsoft a bien l’intention d’ouvrir l’ère de la programmation non plus par assemblage de composants ou d’objets (COM), mais par réutilisation de services.Editée en janvier 2002, cette plate-forme est fournie gratuitement par Microsoft.Selon Microsoft, le framework .NET est “la nouvelle plate-forme révolutionnaire, construite sur des protocoles Internet ouverts et des standards, incluant des outils et des services qui donnent un nouvel aspect à l'informatique et aux communications”.Une définition plus compréhensible serait celle-ci : le framework .NET est un nouvel environnement pour développer et exécuter des applications informatiques, fournissant une grande facilité de développement de services, un ensemble de services pour l'exécution de composants écrits


en une variété de langages de programmation, et une interopérabilité inter langages et inter machines.Le framework .NET contient deux composants principaux : la Common Language Runtime (CLR) et la bibliothèque de classes.La CLR est un environnement d’exécution (runtime) qui gère le code au moment de l'exécution, fournit des services essentiels comme la gestion de la mémoire, la gestion des threads, et l'accès distant. Il applique également une stricte sécurité des types et d'autres formes d'exactitude du code qui garantissent un code sécurisé et robuste. En fait, le concept de gestion de code est un principe fondamental du runtime. Le code qui cible le runtime porte le nom de code managé.La bibliothèque de classes est une collection complète orientée objet de types réutilisables que l’on peut utiliser pour développer des applications allant des traditionnelles applications à ligne de commande ou à interface graphique utilisateur jusqu'à des applications qui exploitent les dernières innovations fournies par ASP.NET, comme les services Web XML et Web Forms.Il existe un grand nombre de langages de programmation qui ont été (re)définis pour fonctionner sur le framework .NET (VB.NET, C#, J# mais aussi Cobol, Perl, Python, SmallTalk, etc). Tous ces langages sont compilés sous la forme d’un code binaire intermédiaire, indépendant du matériel et du système d’exploitation. Ce langage est ensuite exécuté dans la CLR. Les applications compilées sous la forme de code intermédiaire se présentent sous la forme de binaires exécutables portables.Une conséquence directe du fait que tous les langages du framework .NET sont compilés sous la forme d’un même code intermédiaire est qu’une classe écrite dans un langage peut être dérivée dans un autre langage, et que l’on peut instancier dans un langage un objet d’une classe écrite dans un autre langage.Avec .NET, tous les langages offrent en théorie les mêmes possibilités et fournissent sensiblement les mêmes performances (dans la pratique, tous les langages ne remplissent pas exactement toutes les spécifications du framework .NET), le choix entre les langages est donc effectué en fonction des goûts et habitudes du développeur, et non plus imposé par des contraintes d’implémentation.


2.3.2.2-Visual Studio .NET

Visual Studio .NET est un EDI (Environnement de Développement Intégré) dont le prix varie entre 1000 et 2500 € selon l'édition. Il inclut toute une gamme de fonctionnalités puissantes et sophistiquées qui permettent de concevoir, développer, déboguer et déployer des applications robustes, conviviales et sécurisées.

2.3.2.3-SDK .NET (Software Development Kit)

Il s’agit d’un ensemble de services destinés aux développeurs et fournis gratuitement. On y trouve des outils tels que des compilateurs en ligne de commande, ainsi que des exemples et de la documentation.

2.3.2.4-.NET à Selligent

Chez Selligent, les développeurs utilisent l’édition Enterprise Architect de Microsoft Visual Studio .NET. Ce logiciel leur permet le développement des éléments en C#, ASP, ASP.NET, JavaScript, VBScript, HTML, CSS, XML et XSLT mais aussi du code non managé (c'est-à-dire l’ancien code C++).Le logiciel Selligent Xi for Web tourne sur le framework .NET version 1.0 et la migration vers le framework 1.1 est en cours.

2.3.3-Programmation avec C#Le langage adopté par Selligent pour la programmation des services .NET est C#.Il s’agit d’un langage de programmation conçu par Microsoft. Il est fortement inspiré de C++ et Java. Microsoft présente C# comme suit : “C# est un langage de programmation simple, moderne et objet orienté dérivé de C et de C++. C# est fermement enraciné dans la famille des langages C et C++. C# vise à combiner la productivité élevée de Visual Basic et la force brute de C++.”

2.3.4-Interfaçage avec ASP et ASP.NETL’interfaçage du logiciel Selligent Xi for Web est réalisé grâce à ASP. La migration vers ASP.NET devrait être effectuée dans un proche avenir.ASP (Active Server Pages) est un langage de script Microsoft pour développer des applications serveur Web dynamiques et interactives : une page Web ASP affiche un contenu pouvant être différent selon divers paramètres alors qu'une page Web HTML classique est fixe. C'est un


langage de script interprété du côté du serveur (les scripts CGI, PHP, JSP, etc, sont aussi exécutés du côté du serveur) et non du côté du client comme les scripts JavaScript ou les Applets, qui s'exécutent dans le navigateur.ASP.NET n'est pas une évolution mais une révolution par rapport à ASP. Tout d'abord, une page ASP.NET n'est plus un script interprété par le serveur, mais une dll (fichier binaire) compilée qui sera invoquée par le serveur, lequel enverra un flux HTML vers le navigateur. Cela permet de programmer les événements coté serveur en VB.NET ou en C#.

2.3.5-Architecture Selligent .NET

2.3.5.1-Présentation

Fin 2002, les développeurs de Selligent ont migré vers les nouvelles techniques offertes par le framework .NET de Microsoft. Comme évoqué plus haut, C++ a été délaissé au profit de C# et ASP.NET va remplacer ASP. Par contre, il n’est pas à l’ordre du jour de transformer les anciens composants COM et pages ASP à la technologie .NET, les changements étant beaucoup trop importants et coûteux.L’architecture du logiciel Selligent Xi for Web, baptisée en interne Selligent .NET, est un modèle n-tiers : client, serveur multicouches et données, dont voici un schéma récapitulatif :


2.3.5.2-Client

Du côté client, on est dans le cas “zéro client”. Ce terme signifie qu’aucune application ne doit être installée côté client. Seul un navigateur Internet Explorer est requis. Il est ainsi possible de se connecter, grâce à Internet ou à un Réseau Privé Virtuel, au logiciel Selligent Xi for Web depuis n’importe quel ordinateur (système d’exploitation quelconque) ou même avec un autre support : téléphone GSM (Wap) ou assistant personnel (PDA). Côté client, les technologies mises en oeuvre sont HTML, CSS, XSLT, JavaScript et VBScript.


2.3.5.3-Serveur

Côté serveur, on distingue les user scripts des business scripts. Les premiers concernent l’interfaçage utilisateur avec les pages ASP et ASP.NET hébergées sur un serveur Microsoft IIS. Les business scripts sont les composants COM et les services .NET utilisés par l’application et appelés par les pages ASP et ASP.NET. Actuellement, environ 10% des business scripts sont des services .NET mais cette proportion est appelée à croître.Les business scripts peuvent être décomposés en facade, business et data objects. Les premiers transforment les informations à transmettre aux user scripts ; les business objects sont chargés des opérations évoluées du logiciel ; les data objects s’occupent de l’accès et de la récupération des données.

2.3.5.4-Données

Les données sont stockées dans des bases de données gérées par Microsoft SQL Server ou Oracle. Les bases de données utilisées par le logiciel Selligent Xi for Web contiennent un maximum d’informations : en plus des tables contenant les données “classiques” (tables sur les sociétés, les accès, les personnes, etc), les bases de données contiennent les propriétés des champs de formulaires, la mise en forme graphique et toute autre information personnalisable pour les utilisateurs.Les queries SQL au moteur de bases de données sont par conséquent très nombreuses. Or, chaque query a un coût qui n’est pas négligeable. Pour limiter le nombre de queries, les développeurs de Selligent ont mis au point deux techniques :La première, appelée “object pooling”, consiste à récupérer lors du démarrage de l’application toutes les données lentes à charger et à traiter, par exemple, les informations concernant l’interface. Cette fonctionnalité utilise environ 150 queries. Ces données sont chargées une seule fois puis mémorisées et tous les utilisateurs vont récupérer ces informations directement en mémoire. Ainsi, 150 queries sont économisées à chaque fois qu’une page est chargée par un client Internet Explorer.La deuxième technique d’économie de queries est la mise en cache. Lorsqu’un utilisateur récupère des données dans la base, celles-ci sont


gardées en mémoire au cas où un autre utilisateur en aurait prochainement besoin.

2.3.5.5-Usage du XML

La personnalisation du logiciel par des personnes extérieures à Selligent exige que les données échangées par chaque composant soient intelligibles et exploitables par tous. De plus, le logiciel Selligent Xi for Web peut interagir avec d’autres applications telles que Microsoft Outlook et Lotus Notes.La plupart des échanges de données se fait donc au format XML, langage standard de définition des données, afin d’offrir une interopérabilité maximale intra et inter applications.

2.3.5.6-Sessions

Le protocole HTTP permet la communication entre un client et un serveur de la façon suivante :Le client (c’est-à-dire le navigateur Web) effectue une requête HTTP puis le serveur trait la requête et envoie une réponse HTTP au client.L’inconvénient majeur est que cette communication est aussitôt coupée dès que la réponse a été envoyée par le serveur. Or, dans le cas du logiciel Selligent Xi for Web, il est important de garder une trace du client sur le serveur. Grâce à cela, le serveur pourra identifier un client qui envoie une nouvelle requête et pourra donc associer des objets en mémoire à un utilisateur spécifique. Le mécanisme qui permet cette identification du client auprès du serveur est le principe des sessions. Concrètement, lorsqu’un utilisateur se connecte au logiciel, le serveur lui attribue un identifiant de session qu’il sauve dans la base de données avec tous les objets associés à cet utilisateur. Ensuite, lorsqu’un client émet une requête, il fournit son identifiant de session ce qui permet au serveur de retrouver l’état de cet utilisateur.Ce mécanisme a été entièrement développé par Selligent, car le dispositif de session proposé par ASP ne convient pas à l’utilisation du logiciel qui peut être fait en clustering, c’est-à-dire avec plusieurs serveurs.

2.3.5.7-Interopérabilité

En raison de l’utilisation récente des technologies .NET, les développeurs de Selligent ont dû mettre en oeuvre une communication entre le code C#


et C++. Cette mise en relation, appelée interopérabilité, permet à des composants COM d’appeler des méthodes .NET et inversement. Le framework .NET propose des techniques qui facilitent cette communication.

2.4-ConclusionGrâce à ces choix techniques, le logiciel Selligent Xi for Web remplit les critères de qualité suivants : performance, fonctionnalité, flexibilité et facilité de mise en oeuvre.

Intégration d’un outil de surveillance à un logiciel existant - Description du projet

3-Description du projet

3.1-ContratSelligent a l’habitude de recevoir des stagiaires et leur confie dans tous les cas un travail réel et pas un cas de programmation d’école qui ne servirait jamais à autre chose qu’à la soutenance du mémoire de stage.Il m’a donc été confié un projet nommé en interne “trace”. Ce projet devait être impérativement terminé à la fin de mon stage car il devait être intégré à la version 6.10.400 du logiciel mise sur le marché fin juin.J’ai pu travailler durant tout le stage avec de nombreuses personnes qui m’ont guidé dans l’analyse et la conception de cet outil.

3.2-PrésentationLe projet qui m’a été attribué durant le stage est la conception d’un outil de trace. Il s’agit d’une fonctionnalité ajoutée au logiciel Selligent Xi for Web. Ce composant existe déjà dans le logiciel Selligent Xi for Windows et son absence dans la version Web mécontentait les clients.

3.3-FonctionnalitésL'instrumentation de trace permet aux développeurs et aux administrateurs de surveiller la santé de Selligent Xi for Web fonctionnant dans des conditions réelles (par opposition à une exécution dans un débogueur). Parfois, l'utilisation d'un débogueur peut cacher des bogues et masquer des problèmes de performance et de threads. Le traçage est un outil de surveillance et de résolution de problèmes très important pour cette application qui est distribuée multicouches. Les applications de ce genre contiennent souvent des problèmes que l’on ne peut observer que lorsque le logiciel est sous une lourde charge et dans les conditions aléatoires inhérentes à un environnement réel.

3.4-UtilisateursEn conjuguant des fonctions d’optimisation, de monitoring, d’audit, de configuration, de détection des anomalies, cet outil répond aux attentes des développeurs de Selligent, du support (assistance), des consultants

Rémy Liscia 18

Intégration d’un outil de surveillance à un logiciel existant - Description du projet

chargés de configurer le logiciel dans les entreprises, des administrateurs réseaux dans les entreprises, etc.

3.5-Fonctionnement détailléLe mécanisme de trace récupère les événements (exceptions…) provoqués par le logiciel ainsi que les queries SQL générées par le logiciel lors des appels aux bases de données. Toutes ces informations sont triées puis sauvegardées dans des fichiers.On distingue deux mécanismes de trace, répondant à des besoins différents :

-il y a la trace globale qui est lancée par l’administrateur depuis un outil de configuration. Cette trace récupère toutes les informations et queries SQL générées par le logiciel, quelques soient les utilisateurs qui en sont à l’origine (certaines queries sont anonymes).-il y a la trace utilisateur qui est soit lancée par l’administrateur depuis un outil de configuration soit par l’utilisateur lui-même depuis son interface. Cette trace récupère toutes les informations et queries SQL générées par l’utilisateur précisé. Ce dernier pourra afficher dans son interface toute la trace qui a été récupérée.

A terme, ces fonctionnalités seront reprises dans un outil de monitoring qui effectuera d’autres opérations. Il s’agit donc de concevoir des composants réutilisables.

Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

4-Etapes du projet

4.1-DocumentationLors de mon arrivée, je ne connaissais pas l’entreprise, ni les logiciels qu’elle publiait. Quelques visites sur leur site Web m’avaient donné une petite idée de leur activité (la CRM) mais ça restait très flou pour moi. Dès mon arrivée à Selligent, j’ai donc été informé par plusieurs personnes (Walter Tricknot, Pascal Evrard) des technologies utilisées, des logiciels édités et du projet qui allait m’être confié.En plus de plusieurs réunions d’information, j’ai dû pousser mes connaissances par moi-même en me documentant sur divers ouvrages (anglophones). Cette documentation consista d’abord par l’étude des fonctionnalités des logiciels de Selligent (fonctions CRM), des technologies utilisées par ces logiciels (COM, DNA, .NET), de l’architecture complexe du logiciel Selligent Xi for Web et enfin par l’apprentissage du langage C# qui était nécessaire pour les développements ultérieurs.Souvent ennuyeuse et harassante, je tire tout de même un bilan positif de cette période de documentation. L’apprentissage de toutes ces technologies m’a énormément apporté, au même titre qu’un enseignement à l’IUT. La bonne maîtrise (ou au moins la compréhension) de ces techniques s’est révélée payante pour la suite. J’ai vraiment eu le sentiment d’avoir appris des concepts très importants dans l’informatique d’aujourd’hui.Quant à l’étude d’un nouveau langage de programmation, je l’appréhendais grandement. A tort car C# est un langage proche de C++ que je maîtrisais bien et de Java dont j’avais eu une initiation à l’IUT. La syntaxe et les mécanismes du langage ne me posèrent donc pas beaucoup de problèmes, à l’inverse des concepts propres au framework .NET (remoting, services Web, graphisme, etc) que je laissais finalement de côté.Il m’a fallu deux semaines pour me mettre au niveau que l’on me demandait.

Rémy Liscia 20


4.2-AnalyseL’analyse était un passage obligé dans ce projet que j’appréhendais énormément en raison de l’aperçu que j’en ai eu à l’IUT. J’ai vite changé d’opinion.L’équipe des quatre analystes est fortement liée aux développeurs. Ils prennent des décisions techniques et fonctionnelles ensemble par le biais de très fréquentes réunions.Walter Tricknot et Jenny Migliore m’ont encadré pour l’analyse du projet de trace. Ils m’ont d’abord présenté leur travail, avec l’appui de nombreux exemples. Ils utilisent comme méthode d’analyse OMT (Object Modeling Technique) qui est antérieure à UML mais tout de même orientée objet. Malgré son universalité, ils reprochent à UML de ne proposer qu’une syntaxe, sans aucune méthode d’analyse clairement spécifiée. Les méthodes existantes basées sur UML ne répondent pas aux besoins de Selligent : Rational Rose et d’autres méthodologies basées sur UML ont été testées par le passé mais aucune ne s’est révélée satisfaisante. Ces méthodes, très complètes, prenaient énormément de temps et la rédaction des documents d’analyse finissait par être plus longue que le développement à proprement parler.C’est pourquoi Selligent a adopté OMT qui permet de couvrir l'ensemble des processus d'analyse et de conception en utilisant le même formalisme. L'analyse repose sur trois points de vue : statique, dynamique et fonctionnel.En pratique, il m’a d’abord fallu rédiger un document texte qui énonçait les besoins liés à ce projet (cf. documents d’analyse en annexe).La modélisation statique qui suivait consistait à identifier et à documenter les classes au format texte. Ensuite, il a fallu réaliser un diagramme de classes reprenant ces informations et qui présente l’ensemble des classes du système d’information et des liaisons entre ces classes.Les diagrammes sont réalisés à Selligent grâce à Visio, produit Microsoft de la suite Office qui fournit des outils visuels.La modélisation dynamique est composée des principaux scénarios de séquences au format texte et sous la forme de diagrammes. Il s’agit là d’identifier toutes les principales séquences d’événements. Les diagrammes d’état composent également la modélisation dynamique et


consistent à représenter tous les états possibles de chaque objet (ou classe) du système.Enfin, la modélisation fonctionnelle présente sous la forme de texte et de diagrammes les principales fonctions d’entrées-sorties et d’interface.A chaque fois que je passais au modèle suivant, Walter Tricknot et Jenny Migliore validaient mon travail et me donnaient des pistes pour continuer. Ce contrôle régulier m’a permis de ne pas partir sur une mauvaise voie dès le début.De plus, il m’a naturellement fallu tout au long de l’analyse garder un regard critique sur ce que j’avais fait au préalable afin de corriger d’éventuelles erreurs ou imprécisions.L’analyse, qui a duré deux semaines, a été ponctuée de nombreuses réunions avec diverses personnes afin de déterminer au mieux les besoins du projet ; ces réunions ont beaucoup influé sur la réalisation des documents d’analyse.A l’issue de cette période d’analyse, il est apparu une contrainte imprévue : en plus du développement des classes et des fonctions déterminées par l’analyse, il faudrait effectuer un grand nombre de modifications au sein du logiciel Selligent Xi for Web car ce dernier est bien entendu lié au mécanisme de trace. Pascal Evrard, le développeur qui devait coordonner mes travaux a pris ces modifications à sa charge.En ayant côtoyé des analystes durant plusieurs semaines, la conclusion que j’en retire est qu’il existe indéniablement deux sortes d’analystes : il y a d’abord les analystes informaticiens qui chercheront la meilleure solution technique à un besoin et qui se concentreront principalement sur cet aspect technologique. Il y a aussi les analystes qui ne prennent en compte aucune contrainte technique mais qui expriment le besoin et développent cet aspect là. Alors que les uns ont une approche beaucoup plus technique, les autres sont dans une optique orientée fonctionnelle et utilisateur final.Cette distinction est clairement établie au sein de Selligent. Les uns comme les autres jouent un rôle primordial et complémentaire. Mais selon les dires de Monsieur Téchy, directeur technique, “l’analyste idéal, la perle rare, est celui qui parvient à travailler avec ces différents points de vue”.


4.3-Développement

4.3.1-Langage et environnementDepuis quelques mois, tous les nouveaux développements de Selligent sont effectués en C#. Le passage à ce langage ne s’est pas fait sans âpres discussions. Pour ma part, je n’ai vu que des avantages à C#. J’ai vraiment eu le sentiment d’utiliser un langage de programmation plus clair, plus intuitif, moins complexe que C++, que j’avais appris à l’IUT. Cela dit, à de plus hauts niveaux de programmation, certains développeurs de Selligent affirment que C++ était un langage bien plus puissant. Voici leurs arguments :-L’héritage multiple de classes, permis en C++, n’est pas autorisé en C#.-Les pointeurs sont automatiques en C#. Leur utilisation est masquée, ce qui a pour conséquence que l’on ne se rend pas toujours compte de ce que l’on fait.-Autre absence dans C# : les templates (patrons) qui apportaient beaucoup de puissance.-La copie de code dans le fichier binaire (mot-clé include) n’a pas d’équivalent en C#. Elle est remplacée par l’ajout de références.-On trouve en Visual C++ des macros, absentes en C#.Revoici ces arguments discutés par les adeptes de C# à Selligent : L’impossibilité en C# d’utiliser l’héritage multiple, de manipuler les pointeurs encourage une programmation plus intuitive et un code plus lisible. Le remplacement de la copie de code par l’ajout de référence réduit la redondance de code binaire et allège les fichiers dll et exe.Le problème des templates peut être contourné par la dérivation entre plusieurs dll. Les macros sont des lourdeurs évitables impossibles à déboguer. De plus, il existe une multitude de types en C++ (par exemple, 20 types pour des chaînes de caractères en C++ contre 2 en C#) ce qui rend le code encore plus opaque.En outre, pour utiliser COM, il a été ajouté à C++ une couche ATL qui imposait beaucoup de limitations et qui ne permettait donc pas au final d’exploiter au mieux C++.Ils concluent en affirmant que C# contraint le développeur à une programmation plus rigoureuse ce qui a pour résultat un code plus lisible,


plus intuitive, moins sale ; alors que C++, par sa puissance, est une véritable “usine à gaz”, ils espèrent résoudre leurs problèmes passés (par exemple la gestion de la mémoire) avec C#.L’adoption de C# par Selligent étant entérinée, les premiers bilans font état d’un triplement de la productivité au niveau du développement.Un autre débat, antérieur, fut celui de l’adoption des technologies de Microsoft .NET. En effet, des plateformes Java comme J2EE ou Jbuilder sont apparues sur le marché à peu près en même temps que les solutions .NET de Microsoft. Les qualités des environnements Java sont nombreuses mais le choix de Selligent pour Microsoft est justifié par les raisons suivantes : les entreprises clientes de Selligent utilisent principalement les technologies Microsoft ; de plus, les technologies utilisées auparavant par Selligent étaient des produits Microsoft (DNA, COM, etc) ; enfin, les solides garanties d’une entreprise comme Microsoft ont été préférées à l’esprit communautaire des technologies Java.

4.3.2-Implémentation des classesIl existe d’excellents générateurs de code qui créent du code source à partir des documents d’analyse. Ils présentent les avantages suivants : respect des spécifications du référentiel, qualité constante, délais connus, pas de surcoût.Cependant, Selligent n’utilise pas ce genre d’outils pour les raisons suivantes : Ces outils sont très efficaces dans le cas de développement de logiciels sur mesure, pour du RAD (Rapid Application Development). Dans le cadre des logiciels de Selligent, on observe une “optimisation à outrance” du code. Chaque développeur doit faire évoluer le logiciel en modifiant ce qui existe, il a “les mains dans le cambouis”. S’il devait se plonger dans du code généré automatiquement, son travail deviendrait colossal. De plus, on ne saurait utiliser un générateur de code pour venir ajouter des fonctionnalités au logiciel. Par ailleurs, un générateur de code efficace exige des documents d’analyse très complets, ce qui n’est pas le cas chez Selligent. Enfin, les générateurs de code ne sont pas adaptés à des architectures multicouches, ils ne savent générer à la fois du visuel et des objets programmés.


J’ai donc commencé par traduire l’analyse en écrivant les classes principales, puis en complétant le code des fonctions au fur et à mesure. J’ai également créé un programme de test sous la forme d’un formulaire Windows, très simple à mettre en oeuvre grâce à Visual Studio .NET.Cette partie de la programmation fut très rapide (quelques jours) pour plusieurs raisons :-après plusieurs semaines de théorie, je passais à la pratique en goûtant enfin à ce langage C#, ma motivation était donc sans limite.-par ailleurs, toutes les notions de programmation requises pour implémenter les classes et les fonctions principales étaient plutôt simples et similaires à la programmation effectuée à l’IUT.J’ai donc implémenté les classes principales, effectué des tests pour vérifier que la communication entre ces classes s’effectuait correctement. Naturellement, ma production n’était pas encore reliée au logiciel et n’était nullement dans les conditions réelles. Le programme de test proposait la saisie des informations qu’il faudrait recevoir du logiciel plus tard et lançait le mécanisme de trace pour ces informations.Un débat survint alors entre les analystes et les développeurs : fallait-il transmettre les résultats de la trace sous forme de fichiers textes simples ou au format XML ?La première réponse fut d’aller dans le sens du XML. En effet, ce méta standard est exploitable par tout programme et un futur outil de monitoring aurait ainsi pu récupérer ces données aisément.Cependant, gérer le XML n’est pas chose simple. En plus de la gestion de caractères spéciaux, il fallait veiller à respecter la mise en forme propre au XML (deux balises racines qui limitent tout le document). Cela augurait de multiples opérations sur les données à sauver et sur le fichier. Il était évident que persister la trace dans un simple fichier texte à considérer comme un journal d’événements était plus aisé. Finalement, le XML fut choisi car il était nécessaire de pouvoir récupérer les données afin de les mettre en forme pour les afficher ultérieurement. Quant aux opérations qui s’annonçaient délicates, je les contournai grâce à l’utilisation pertinente de classes du framework .NET de manipulation XML et de fichiers.En parallèle à la réalisation des nouvelles classes de trace, il fallait, comme cela avait été déterminé dans l’analyse, modifier le logiciel


existant pour que la trace récupère toutes les queries et événements. Cette modification du code (principalement du C++) a été effectuée par Pascal Evrard. Il m’a présenté à plusieurs reprises l’étendue de cette tâche extrêmement rébarbative en raison des kilomètres de code à vérifier et de l’imbroglio propre au C++.

4.3.3-Intégration dans le logicielC’est à ce niveau que la programmation est devenue plus complexe et que ma productivité a fortement chuté.Il a d’abord fallu connecter les classes que j’avais développées avec le logiciel que Pascal Evrard avait mis à jour. Etant donné que ces classes étaient pour la plupart des composants COM écrits en C++ et que mon application de trace était en C# géré par le framework .NET, il a fallu mettre en oeuvre une interopérabilité .NET/COM : en effet, les composants COM du logiciel devaient appeler et envoyer les messages de trace aux méthodes C# que j’avais développées.Pour mettre en place l’interopérabilité dans ce sens (de COM vers .NET), il faut agir de la manière suivante : les objets .NET sont accessibles à COM au travers d'un Wrapper (“emballage” en français) nommé COM Callable Wrapper. Ce Wrapper transforme l'interface .NET exposée par la classe C# en interface compatible COM. A noter que pour qu'un composant COM puisse voir un objet .NET, celui-ci doit être enregistré dans la base de registres (c’est automatique). Pour tester, il suffisait à présent d’exécuter le logiciel et de constater le résultat dans les fichiers XML générés.On m’a alors demandé de développer un service qui permettait de gérer la trace grâce à du “remoting asynchrone”.Le remoting consistait ici à diviser l’application de trace en deux processus distincts à l’image du modèle client-serveur. On fait tourner le serveur en arrière-plan et on instancie un canal de communication. Lorsque le logiciel envoie un message à tracer, un client est créé et transfère le message sur le serveur grâce au canal de communication précité. L’objet sur le serveur se charge alors de la sauvegarde au format XML.


Concernant la communication interprocessus, il a fallu faire un choix entre les protocoles de communication HTTP et TCP. Le protocole HTTP a pour avantage d’être le plus souple car il peut passer au travers des proxies et des firewalls car il transporte les données au format SOAP (texte). Mais ce format (SOAP est dérivé de XML) est relativement lourd. Le protocole TCP est quant à lui plus léger (transformation binaire). En revanche, le passage par des firewalls ou des proxies n’est pas garanti. Etant donné que le mécanisme de trace sera sur une seule machine (deux au maximum), nous avons opté pour une communication TCP.L’asynchronité permet de traiter la trace sans ralentir le logiciel. En effet, dans un environnement de production réel, il se peut que le mécanisme de trace soit ralenti pour une raison quelconque ; il ne faut surtout pas que le logiciel en soit affecté. Mieux vaut saturer la trace que ralentir toute l’application. C’est pour cela que l’envoi des messages vers le serveur de trace se fait de façon asynchrone c'est-à-dire sans attendre la fin de la sauvegarde dans le fichier.La mise en place du remoting asynchrone a fait appel aux notions de sérialisation, de thread, de delegate, etc.Dans l’ensemble, on peut dire que le framework .NET apporte beaucoup de solutions simples à des problèmes très complexes. Par exemple, le remoting est un mécanisme extrêmement compliqué, qui aurait pris énormément de temps avec du code C++. Grâce à quelques classes du framework correctement utilisées, le puissant mécanisme se met en route avec seulement quelques lignes de code. En fait, la complexité du framework .NET réside seulement dans la connaissance et la compréhension des services fournis.


C’est alors que survinrent quelques soucis. L’environnement de développement que j’utilisais, Visual Studio .NET, s’est mis à fonctionner aléatoirement, perturbant sérieusement l’avancée de mon travail. Cela s’est exprimé par des exceptions systèmes qui se déclenchaient par moments, par le débogueur qui ne montrait aucune de ces anomalies, par des erreurs de gestion de mémoire, par des défaillances dans l’interopérabilité, par une fermeture anticipée du serveur de trace, etc. Je me mis à maudire cet environnement jusqu’à ce que Pascal Evrard vérifie mon code et découvre que je déclarai un objet du service, je désactivai ensuite le service puis appelai une méthode sur l’objet supprimé au préalable. Alors que je me demandais pourquoi il y avait des problèmes, j’aurais dû me demander pourquoi ça marchait parfois. Cette mésaventure a mis en évidence la “garbage collection”, c’est-à-dire la libération de la mémoire effectuée par la CLR du framework et qui ne libère pas la mémoire de façon instantanée ce qui me permettait parfois d’appeler l’objet lorsque le garbage collector n’était pas encore intervenu. Une fois que ça a marché, j’ai dû intégrer la trace dans le logiciel Selligent Xi for Web. Cela s’est traduit d’abord par l’intégration de l’objet Trace à un des composants binaires déjà existants (c’est-à-dire à une des dll utilisées par le logiciel). J’ai ensuite défini le service de trace parmi les services Windows accessibles depuis la Microsoft Management Console, outil qui permet de visualiser, démarrer ou arrêter les services définis (on y trouve le serveur IIS, la messagerie MSN Messenger, les connexions réseaux, etc).J’ai pu alors tester une nouvelle fois la trace dans des conditions quasi-réelles.

4.3.4-Interface utilisateurJ’ai ensuite eu l’opportunité de découvrir le côté visuel du logiciel. Selligent Xi for Web possède un outil de configuration accessible, comme le reste de l’application, depuis un navigateur Web. Il me fallait procéder à une modification de certaines pages de cet outil de configuration afin que la trace puisse être activée, désactivée et configurée depuis cet outil. J’ai donc eu accès aux sources de cette partie de l’application. A l’inverse de mes développements précédents où j’avais travaillé sur des codes sources en local, en toute tranquillité, je travaillais maintenant sur des codes


sources partagés. Je n’avais pas le droit à l’erreur, car si j’effectuai une mauvaise manipulation, c’était toute l’équipe de R&D qui était pénalisée. J’y suis donc allé avec des pincettes, manipulant précautionneusement des pages ASP et XSLT. J’ajoutai donc mes éléments visuels dans le code HTML, puis reliai les évènements (par exemple activation ou changement du numéro de port TCP) au service de trace ou à la base de registres.J’avais étudié le langage PHP à l’IUT, qui est, comme l’ASP, un langage de programmation côté serveur. Alors que le PHP ressemblait énormément au langage C, l’ASP m’a semblé très proche du Visual Basic.Concernant l’utilisation de cette trace, il reste à insérer les mécanismes d’affichage des messages de trace dans l’interface utilisateur pour que la trace soit tout à fait opérationnelle. Ce domaine (l’interface utilisateur du logiciel) est le domaine réservé de quelques informaticiens de Selligent qui avaient d’autres priorités à ce moment. Cela est cependant moins primordial car la trace est sauvée au format texte XML et est donc présente dans des fichiers sur le serveur (récupérables par l’administrateur). J’ignore à ce jour si je serai impliqué dans ces développements.La période de développement a duré cinq semaines.

4.4-TestsTout au long du développement, je faisais subir à mon application toutes sortes de tests. Cependant, durant la plus grande partie du développement, seules les classes de démarrage du logiciel envoyaient des messages au mécanisme de trace ; bien que ces classes envoient jusqu’à 12 messages par seconde pendant quelques secondes (surtout des queries SQL) et que la trace fonctionnait sans problème, je ne peux prétendre avoir testé la trace dans des conditions réelles d’utilisation. J’aurais peut-être l’occasion de réaliser des tests plus sérieux avant la fin du stage.Il faut cependant savoir que seuls les tests unitaires et d’intégration sont à la charge des développeurs de Selligent, étant donné qu’un département de l’entreprise composé de quatre informaticiens est chargé du contrôle qualité c'est-à-dire des tests finaux.


Les tests unitaires consistent à tester toutes les éventualités pour chacun des objets, séparément, à l’inverse des tests d’intégration qui permettent d’évaluer la robustesse de l’objet replacé (intégré) dans l’application.

4.5-RécapitulatifAvec en moyenne deux réunions hebdomadaires avec l’informaticien qui supervisait mon stage (analyste ou développeur), je pouvais avancer efficacement en pouvant rectifier le tir si je partais dans la mauvaise direction. C’était aussi l’occasion pour moi de demander plus d’informations sur les concepts complexes que j’avais eu à affronter.J’ai également assisté à quelques réunions de toute l’équipe de R&D qui m’ont fait apparaître comment une vingtaine d’informaticiens parviennent à travailler ensemble.Les dix semaines du stage se sont réparties ainsi :Deux semaines de documentation, deux semaines d’analyse et cinq semaines de développement, avec très souvent des interactions entre les trois : la documentation n’a pas cessé durant le développement et l’analyse a été peaufinée tout au long du projet.La dernière semaine du stage verra probablement la finalisation du projet

Intégration d’un outil de surveillance à un logiciel existant - Le bilan du stage

5-Le bilan du stage

5.1-Bilan du projetAu tout début du stage, lorsque j’ai réalisé l’étendue de ce qui m’attendait, en plus du “simple” développement de mon projet, à savoir la compréhension des technologies mises en oeuvre et que j’aurais à utiliser, je fus effrayé car cela me paraissait aussi indigeste qu’impossible à assimiler par soi-même en si peu de temps. Puis vinrent la lecture des ouvrages et les explications promulguées par les informaticiens de Selligent. Là, la documentation ne fut pas vraiment source d’ennuis mais avais-je bien compris tous ces concepts ? Enfin, le développement me fit apparaître les lacunes que j’avais, les points de la documentation que j’avais négligés ou mal interprétés et je dus donc me replonger dans les livres.Les conclusions que je tire de cette auto apprentissage sont que le plus important est de ne pas hésiter à affronter la complexité, quitte à questionner ensuite le maître de stage ou un professeur ou encore à aller chercher des compléments d’information sur Internet. Savoir affronter l’inconnu pour le maîtriser me semble primordial dans ce métier.En outre, la réalisation du projet m’a apporté de nouvelles connaissances techniques. Il me semble que, sans pour autant les maîtriser totalement, ma compréhension du principe des technologies .NET de Microsoft est un atout majeur car il s’agit vraisemblablement de méthodes de développement d’avenir.Enfin, la conduite d’un projet concret et dont la finalité est d’être utilisée dans des cas de production réels est extrêmement motivant et valorisant.

5.2-Un stage à l’étrangerVivre 10 semaines dans un pays étranger pour travailler ne peut être comparé ni à des vacances, ni à un stage “à domicile”.La Belgique est un pays proche de la France, que ce soit géographiquement ou culturellement. En raison des nombreux points communs entre ces deux pays, je n’eus aucune difficulté à m’intégrer dès le début dans la vie quotidienne. Les plus grands désagréments furent la médiocre qualité de la baguette de pain belge et le fait que le 8 mai ne

Rémy Liscia 31


soit pas un jour férié, c’est dire ! Quant aux apports positifs, je peux aujourd’hui me vanter de connaître ce pays, ses habitudes, ses gens, etc. J’en retire beaucoup de maturité et je pense que si j’ai l’opportunité de faire un autre stage dans les années à venir, je chercherai à le réaliser dans un milieu encore plus “hostile” (langue, culture, mentalités différentes).En outre, ce stage a eu un aspect linguistique : d'une part la Belgique est nettement plus ouverte sur l’étranger que la France et d'autre part, j’étais dans une entreprise multinationale.En effet, bien que Charleroi soit en région Wallonne (francophone), mes progrès en anglais ont été immenses. Car avec trois langues officielles, les belges francophones ne sont pas attachés comme en France à la pérennité de la francophonie. Ainsi, de nombreux termes anglais sont préférés au français au quotidien. Alors dans le secteur informatique, qui plus est dans une entreprise vouée à l’export, la langue anglaise est omniprésente, certains employés de Selligent allant jusqu’à communiquer entre eux en anglais. Et naturellement, tous les ouvrages techniques qui ont été mis à ma disposition étaient dans la langue de Shakespeare. Ce fut donc une surprise immense mais pas vraiment désagréable : s’il m’avait fallu maîtriser le néerlandais (la langue belge des affaires), j’aurais été sérieusement ennuyé…

5.3-Un stage en entrepriseN’ayant jamais travaillé dans une société de cet acabit, l’expérience a été nouvelle pour moi. J’en retiens beaucoup d’enseignements : comme dans une fourmilière, chacun à sa fonction bien déterminée, la coordination entre chacun par les dirigeants n’a lieu que très rarement car les employés font preuve de beaucoup d’autonomie et d’initiative. Je pense avoir eu aussi beaucoup de chance car j’ai été reçu dans une entreprise qui alliait avec succès sérieux et bien-être des employés, ce qui m’a vraiment impressionné dans une société de cette importance. Ainsi, les horaires sont totalement libres, les locaux accessibles 24h/24, avec de nombreux espaces de détente (cafétéria, ping-pong, salon…), dans un cadre agréable (bâtiment rutilant au sein d’un technopôle, plantes vertes dans les locaux, grandes baies vitrées, distributeurs de boissons…) en échange d’un travail rigoureux. Ce contexte de confiance est pour


beaucoup dans la bonne humeur qui règne dans les bureaux et qui est fortement stimulante pour travailler.Cela dit, comme dans toute entreprise, il y a une hiérarchie bien définie, des délais, des réunions, du stress, des désaccords, des conflits. Ayant eu sur tout cela une vision de l’intérieur, j’en tire beaucoup de leçons sur les relations patron employés et entre employés, sur le travail, sur le monde de l’entreprise…

5.4-Un stage de fin d’étudesAprès un an et demi d’études en IUT informatique qui est une formation à vocation professionnelle, ce stage de deux mois et demi a été l’occasion de mettre en application toute la théorie vue à Rodez. Cependant, ce stage apporte beaucoup de recul : avoir eu de bons résultats à l’IUT n’implique pas forcément une réussite sur le plan professionnel, si chacun ne fournit pas l’effort nécessaire en temps voulu pour répondre au mieux à ce que l’on attend de lui.En fait, l’IUT, en plus d’offrir de solides bases d’un point de vue technique, nous prépare au monde du travail en nous apportant les réflexes qu’un informaticien doit avoir acquis (rigueur, autonomie, dynamisme, relationnel, motivation). Quant au stage, il apporte le recul nécessaire pour comprendre tout cela.Ce stage m’apparaît comme indispensable et est une conclusion parfaite à ce cycle d’études.C’est une excellente introduction au monde du travail. Et pour ceux, comme moi, qui souhaitent poursuivre leurs études, ce stage permet d’aborder de nouveau l’enseignement avec un regard totalement différent et une approche beaucoup plus positive (avec par exemple une curiosité accrue et plus de recul).

Intégration d’un outil de surveillance à un logiciel existant - Annexes

Annexes

GlossaireASP et ASP.NET (Active Server Pages)

Langages Microsoft de programmation Web qui proposent une dynamicité côté serveur et qui permettent de créer de puissantes applications Internet.

C# (prononcer “see sharp”)Langage de programmation récent (certifié ISO en avril 2003) créé par Microsoft pour son framework .NET. Il reprend les points positifs de C++ et de Java.

C++Langage de programmation conçu en 1982 qui reprend le langage C en y ajoutant principalement les possibilités de la programmation “orientée objet”.

COM (Component Object Model)Modèle d’objets et ensemble de règles programmatiques, permettant aux objets (composants) d’interagir les uns avec les autres par le truchement d’interfaces. On parle de norme binaire à propos de COM car cette spécification concerne la réutilisation du code machine.

CRM ou GRC (Customer Relationship Management, en français : Gestion de la Relation Clientèle)

Ensemble de méthodes qui permettent aux entreprises de mettre en avant les relations qu’elles ont avec leurs clients, relations axées sur le cycle prospection, vente, maintenance et relance.

DNA (Distributed interNet Applications Architecture)Architecture tripartie basée sur COM et destinée à faciliter la création d’applications Windows distribuées.

IIS (Internet Information Server)Serveur (de Microsoft) réseau ou Web de fichiers et d’applications, compatible avec de nombreux protocoles.

Rémy Liscia 34


InteropérabilitéCapacité des applications, des composants… à coopérer en se passant des données, en appelant les méthodes des uns ou des autres, etc.

Logiciel à base de composantsLogiciel dont les fonctionnalités sont réparties sur une multitude de composants COM capables d’interagir.

OMT (Object Modeling Technique)Méthode d’analyse orientée objet qui a pour principal atout d’indiquer clairement la marche à suivre.

Query SQL (en français : requête SQL)Opération qui consiste à extraire d'une table (d'une base de données) tout ou partie des éléments qui s'y trouvent.

R&D (Recherche et Développement)Dans le cas d’une entreprise informatique, département chargé de la recherche et de l’exploitation de nouvelles technologies, ainsi que de la production logicielle.

SelligentSociété basée à Gosselies près de Charleroi (Belgique), éditeur de logiciels de CRM.

Selligent.NETTechnologie serveur mise en oeuvre pour le logiciel Selligent Xi for Web, basée sur les technologies ASP.NET et C#.

Selligent XiGamme de produits logiciels commercialisés par Selligent. Comprend une version Windows et une version Web.

Selligent Xi for WebProduit phare de Selligent. Basé sur une architecture distribuée à client léger. La version 7.0 est prévue pour l’été 2003.

SOAP (Simple Object Access Protocol)Protocole d’échange d’information dans un environnement distribué. Il est basé sur XML.

SQL (Structured Query Language)Langage de définition, de manipulation et de contrôle des données utilisé pour les bases de données relationnelles.

SQL Server


Système de gestion de bases de données de Microsoft.UML (Unified Modeling Language)

Notation permettant de modéliser un problème de façon standard.XML (eXtensible Markup Language)

Langage standard de description des données (alors que HTML est un langage de représentation des données).

XSLT (eXtensible Stylesheet Language Transformations)Langage de transformation de documents XML en autres documents (de type XML, HTML, texte, RTF, etc).

Bibliographie

OuvragesDesigning for scalability with Microsoft Windows DNA (Microsoft programming series – Sten and Per Sundblad)Au coeur de COM+ (Microsoft press – Guy et Henry Eddon)C# and the .NET Platform (Apress – Andrew Troelsen)OMT – Modélisation et conception orientée objet (Masson – James Rumbaugh)OOP in .NET (U2U - Win Uyttersprot)Advanced .NET Remoting (Apress – Ingo Rammer)

Documents numériquesMSDN for Visual Studio.NET et http://msdn.microsoft.comhttp://www.selligent.com et documentation à usage internehttp://www.bvamyfra.frhttp://www.dotnet-fr.orghttp://dotnet.developpez.comhttp://www.dotnetguru.org


Chronologie du stageLundi 14 avril 2003 avec Walter Tricknot : présentation des logiciels Selligent Xi, des architectures.Début de la documentationJeudi 17 avril 2003 avec Walter Tricknot, Jenny Migliore, Laurent De Greef pour faire le point sur mes travaux de documentation et pour discuter du projet SQLTrace ; Cette réunion fait apparaître que l’idée de départ concernant le projet ne pourra être réalisée car l’architecture du logiciel “Selligent Xi for Web” ne le permet pas (il est possible d’identifier le client (côté client) et de tracer les requêtes SQL (côté base de données) mais cela risque d’être trop lourd par rapport à l’application).Mardi 22 avril 2003 avec Walter Tricknot, Laurent De Greef, Pascal Evrard, Paula Gonzaga de Sa, Jenny Migliore : réévaluation du projet SQLTrace et prises de décisions techniques et fonctionnelles: SQLTrace devient Trace (fonctions étendues).Mercredi 23 avril 2003 avec Pascal Evrard pour une explication détaillée de la réunion de la veille.Vendredi 25 avril 2003 avec Pascal Evrard pour définir le projet d’un point de vue et mettre en évidence les questions importantes.Lundi 28 avril 2003 avec toute l’équipe R&D (22 personnes) pour une réunion de mise au point globale au retour de congés du directeur du département R&D.Lundi 28 avril 2003 avec Walter Tricknot et Jenny Migliore pour parler analyse : ils m’ont présenté leur méthode d’analyse, il s’agit d’OMT, une méthode antérieure à UML mais qu’ils préfèrent car elle indique plus clairement la marche à suivre. Début de l’analyseMardi 6 mai 2003 avec Walter Tricknot, Jenny Migliore et Pascal Evrard pour faire le point sur l’analyse et affiner le projet.Vendredi 9 mai 2003 avec Pascal Evrard pour déterminer comment débuter la programmation.Début de la programmationLundi 12 mai 2003 : appel de l’IUT représenté par Monsieur Barrios.Puis réunions bihebdomadaires (en moyenne) pour faire le point sur la programmation.


Mercredi 4 juin 2003 avec Frédéric Loesch pour commencer la programmation visuelle.Mercredi 11 juin 2003 : envoi du présent mémoire à l’IUT.

Documents produits lors de l’analyse du projetVoir page suivante

Brochure de publicitéVoir dernière page

Projet Trace – AnalyseÉtape 1 : énoncé

LE BESOIN GLOBALTrop souvent, les développeurs de Selligent perdent du temps en essayant en vain de localiser l’origine d’anomalies ; il en est de même pour le help desk qui doit souvent essayer de comprendre des problèmes, exposés à distance, rencontrés par des utilisateurs ou des intégrateurs ; les administrateurs de systèmes sur lesquels le logiciel Selligent ne fonctionne pas parfaitement (par exemple : ralentissement du système) ne parviennent pas à déterminer précisément l’origine de cette anomalie ; ces mêmes administrateurs qui souhaitent effectuer des contrôles (de sécurité) ou des statistiques d’utilisation n’en ont pas les moyens ; les consultants chargés de configurer et de personnaliser le logiciel chez le client souhaitent connaître la localisation des informations dans la base de données, l’ordre d’exécution, le principe de fonctionnement… Actuellement, aucun outil ne répond aux attentes de tous ces acteurs primordiaux et dont le logiciel Selligent ne saurait se passer.Il convient donc d’élaborer un outil qui puisse améliorer les conditions de travail de tous.Ainsi, cet outil devra faciliter l’optimisation de l’application, le monitoring, l’audit, la configuration, la détection et la résolution des anomalies.

ANALYSE DETAILLEE DU BESOIN“Trop souvent, les développeurs de Selligent perdent du temps en essayant en vain de localiser l’origine d’anomalies”Cet outil leur permettra de récupérer les exceptions et les évènements propagés par le logiciel. D’autres informations, comme le plan d’exécution, leur seront fournies afin de mettre en évidence l’origine de l’évènement.“il en est de même pour le help desk qui doit souvent essayer de comprendre des problèmes, exposés à distance, rencontrés par des utilisateurs”Afin de ne plus perdre de temps dans la compréhension du problème, le help desk se verra transmettre par l’utilisateur un fichier contenant les messages générés par le logiciel. Le traitement de l’anomalie en sera facilité.“les administrateurs de systèmes sur lesquels le logiciel Selligent ne fonctionne pas parfaitement (par exemple : ralentissement du système) ne parviennent pas à déterminer précisément l’origine de cette anomalie”Souvent, de simples queries à la base de données suffisent à ralentir de manière conséquente toute l’application. Il est donc nécessaire de pouvoir connaître quelles sont les queries SQL les plus lourdes.

Analyse – page 39

“ces mêmes administrateurs qui souhaitent effectuer des contrôles (de sécurité) ou des statistiques d’utilisation n’en ont pas les moyens”De multiples opérations d’audit peuvent être décidées par les administrateurs ; il peut s’agir de contrôles de sécurité (par exemple : déterminer les tentatives de connexion échouées afin de savoir s’il y a des essais de piratage), ou de statistiques par exemple : savoir qui se connecte le plus).“les consultants chargés de configurer et de personnaliser le logiciel chez le client souhaitent connaître la localisation des informations dans la base de données, l’ordre d’exécution, le principe de fonctionnement”La personnalisation du logiciel passe parfois par l’ajout de nouveaux composants. La conception de ces composants est effectuée par des personnes externes à l’équipe de R&D (des consultants, des intégrateurs) qui n’ont pas forcément une juste représentation des aspects techniques du logiciel. Il faut donc leur fournir une idée de la localisation des données en affichant les queries SQL.

Ce mécanisme de trace devra être intégré au logiciel Selligent Xi for Web.Il pourra être mis en route par l’administrateur ou par l’utilisateur, selon les cas.En plus de proposer un affichage via l’interface du logiciel, on pourra récupérer les résultats au format texte dans des fichiers, afin de les transmettre par email au help desk par exemple.Différencions les cas d’utilisation :Un utilisateur qui rencontre un problème dans sa session pourra activer une trace qui récupérera tous les évènements générés par l’utilisation du logiciel par cette personne. Les queries SQL liées à cet utilisateur seront également récupérées. L’activation de la trace sera une option accessible depuis le menu de Selligent Xi for Web. Durant toute la période où la trace sera activée, il faudra qu’un indicateur le rappelle via une icône sur l’interface du logiciel.Cette trace cessera de fonctionner lorsque l’utilisateur demandera l’affichage de la trace via le menu ou lorsqu’il fermera sa session.L’affichage de la trace se fera dans une fenêtre Web pop up qui permettra de faire défiler l’ensemble des informations récupérées par la trace.Ces informations seront également accessibles sur le serveur par un fichier au format texte.Lorsque la trace sera lancée, il ne sera plus possible d’afficher les informations de la précédente trace.L’administrateur pourra lancer la trace d’un utilisateur via la config du logiciel, en cochant simplement une option pour cet utilisateur.A ce moment, et durant toute la période où la trace sera active, l’utilisateur sera prévenu qu’il est “tracé” grâce à une icône sur l’interface du logiciel.

Analyse – page 40

Lorsque l’utilisateur se déconnectera, sa trace restera quand même à l’état actif. La trace de cet utilisateur sera accessible et visualisable via le fichier texte présent sur le serveur.L’administrateur pourra de plus activer une trace globale, par l’intermédiaire de la config. Cette trace récupèrera tous les évènements et toutes les queries SQL. Cela permettra de récupérer aussi les queries anonymes, c’est-à-dire celles qui servent lors du démarrage de l’application à charger les informations partagées (pool) par tous les utilisateurs.Le seul moyen de désactiver la trace sera de repasser par la config. Ainsi, la fermeture du logiciel ne désactivera pas la trace et celle-ci sera de nouveau active dès le redémarrage du logiciel. Là aussi, la visualisation de la trace se fera directement par l’accès au fichier texte généré sur le serveur.

Analyse – page 41

Projet Trace – AnalyseÉtape 2 : modélisation statique

IDENTIFICATION DES CLASSESLes classes C++ existantes RecordsetContainer et CommandContainer sont reliées à une classe C++ TraceFilter qui juge la pertinence de chaque message et le propage ou non. Cette classe, ainsi que les classes C# existantes TableReader et TableWriter sont reliées à la classe statique Trace. Celle-ci peut implémenter un objet de type TraceMessage ou une des classes qui en dérivent : TraceQuery ou TraceEvent.La classe Trace accède ensuite à la classe TraceWriter.

DICTIONNAIRE DES DONNEESVoici le dictionnaire des données : TraceMessage Information récupérée du logiciel

Selligent Xi for WebTraceQuery Type de message qui correspond à une

query SQLTraceEvent Type de message qui correspond à un

évènement propagé par le logicielTrace Ensemble ordonné de messages

spécifiques à un utilisateur ou global à tout le logiciel

TableReader et TableWriter, RecordsetContainer et CommandContainer

Services .NET (C#) et composants COM (C++) existants dans le logiciel Selligent Xi for Web qui permettent l’accès aux bases de données (lecture, écriture, modification et suppression de données)

Analyse – page 42

Projet Trace – AnalyseÉtape 3 : modélisation dynamique

SCENARIOS DE SEQUENCES TYPIQUES1- Lancement de la Trace utilisateur par l’utilisateur lui-même ou par l’administrateur

L’activation de la Trace par l’utilisateur provoque un changement de l’état en mémoire de cet utilisateur. L’activation de la Trace via la config provoque un changement dans la base de données de l’état de cet utilisateur.Lorsque RecordsetContainer (ou CommandContainer, TableReader, TableWriter) constate un changement, il transmet l’information (création d’une nouvelle Trace utilisateur) au composant qui crée une nouvelle instance de Trace.Celle-ci transmet ses informations au service qui, lui aussi crée une instance de Trace.

2 – Lancement de la Trace globaleL’activation de la Trace via la config provoque un changement de l’état d'un paramètre dans la base de registres. Lorsque RecordsetContainer (ou CommandContainer, TableReader, TableWriter) constate un changement, il transmet l’information (création d’une nouvelle Trace globale) au composant qui crée une nouvelle instance de Trace.Celle-ci transmet ses informations au service qui, lui aussi crée une instance de Trace.

3 – Enregistrement d’un message pour une Trace utilisateurRecordsetContainer (ou CommandContainer, TableReader, TableWriter) vérifie si une Trace est active pour l’utilisateur indiqué par le message ; le cas échéant, le message est transmis à la Trace en question dans le composant.Celui-ci vérifie la pertinence du message. Si le message est validé, il est transmis à la Trace correspondante dans le service de manière asynchrone.La Trace instanciée dans le service écrit le message dans le fichier (création du fichier s’il n’existe pas).

4 – Enregistrement d’un message pour une Trace globaleRecordsetContainer (ou CommandContainer, TableReader, TableWriter) vérifie si une Trace globale est active ; le cas échéant, le message est transmis à la Trace en question dans le composant.

Analyse – page 44

Celui-ci vérifie la pertinence du message. Si le message est validé, il est transmis à la Trace correspondante dans le service de manière asynchrone.La Trace instanciée dans le service écrit le message dans le fichier (création du fichier s’il n’existe pas).

5 – Désactivation d’une TraceLorsque l’état en mémoire ou dans la base de registres concernant la Trace est désactivé, RecordsetContainer (ou CommandContainer, TableReader, TableWriter) envoie un message au composant qui désactive la Trace en question.Celle-ci transmet au service un message de désactivation.Le service désactive cette Trace.

Analyse – page 45

Analyse – page 46

Analyse – page 47

Analyse – page 48

Projet Trace – AnalyseÉtape 4 : modélisation fonctionnelle

CREER UNE TRACEEn entréeL’acteur RecordsetContainer (ou autre…) fournit le type de trace et l’utilisateur.OpérationsVérifier que la trace demandée est bien inactiveCréer la traceEn sortieL’acteur trace est instancié

CREER UN MESSAGEEn entréeL’acteur RecordsetContainer (ou autre…) fournit l’utilisateur.OpérationsVérifier que la trace est activeCréer un messageEn sortieL’acteur message est instancié

ENVOYER UN MESSAGEEn entréeL’acteur message fournit tous ses attributsOpérationsSérialiser le messageEnvoi asynchrone du message par remotingEn sortieNéant

ECRIRE UN MESSAGEEn entréeLe texte qui correspond au message sérialiséOpérationsÉcriture dans le fichierEn sortieNéant

Analyse – page 49