Thèse (M.Sc.)--Université Laval, 2007. / Bibliogr.: f. [125]-128. Publié aussi en version électronique dans la Collection Mémoires et thèses électroniques.

Notre proposition consiste à présenter un modèle et une infrastructure d'exécution orienté composant pour le domaine des applications multi-tâches à contraintes temps réel souples et embarquées (nommé Tinap). Nous définissons un modèle de composant reposant sur plusieurs vues : une vue structurelle, placée au centre du cycle de conception, reposant initialement sur le modèle Fractal, une vue dynamique permettant au concepteur, dans une démarche descriptive, de personnaliser l'architecture métier pour définir les aspects de son applicatif liés à la concurrence, et enfin une vue implantation et une vue comportement fournissant respectivement une abstraction de l'implantation interne des composants et de leur comportement à l'égard de leur environnement. De plus, notre proposition est intégrée à un cadre méthodologique dirigé par les modèles. Nous avons également expérimenté le paradigme composant à différents niveaux d'abstraction: pour l'applicatif et pour celui de l'infrastructure d'exécution qui les implante. Enfin, au niveau du système d'exploitation fournissant les services élémentaires nécessaires. Cette démarche est motivée par la volonté d'exploiter notre modèle multi-vues canonique et de l'adapter en fonction des besoins de chaque niveau d'abstraction. Cette expérimentation est menée avec Think, une implantation en C des spécifications Fractal. Nous expérimentons Tinap par deux cas d'étude que nous avons prototypés. En premier lieu, pour concevoir une application d'analyse et de contrôle de flux multimédias par l'intermédiaire de disques vinyles. En second lieu pour expérimenter la mise en oeuvre du modèle d'exécution Accord (une méthodologie de conception pour applications temps-réel). / Our proposal is to present a component-oriented model and execution infrastructure for soft realtime and embedded applications (called Tinap). We define a component model based on several views : a structural view placed at the centre of the design cycle and based initially on the Fractal component model. A dynamic view, allowing the designer, in a descriptive way, to directly customize its functional architecture with concurrency-related aspects. Finally, an implementation and a behavioral view, providing respectively an abstraction of the structure and the behavior of the internal implementations of the components according to the environment. Moreover, our proposal has been incorporated into a model-based approach in order to mitigate the complexities of the design phases. We also experienced the component paradigm at different levels of abstraction: at application level and at execution infrastructure one. The latter implements the high-level concepts provided to the designer. Finally, at the operating system level which provides the services required by the infrastructure. This approach is motivated by the will to exploit our canonical model at these different levels, and to adapt it depending on their needs. This experimentation was conducted with Think, a C implementation of Fractal specifications. We present two case studies prototyped with Tinap. First, an application for DJ's: From a dedicated signal pressed on a vinyl and analysed by the software, the user is able to control various multimedia sources (audio/video). Secondly, for the implementation of the Accord execution model (a design methodology for real-time applications).

La modernisation logicielle est un domaine en plein essor du fait du vieillissement des technologies datant des années 1960, tel que COBOL ou FORTRAN. Aujourd'hui, bon nombre de ces applications sont toujours en service du fait de leur criticité. Ce sont elles qui continuent d'assurer le bon fonctionnement du système d'information de l'entreprise. Face à l'arrivée en force de technologies récentes de type Cloud ou Mobile, il devient urgent de les moderniser. Toutefois, près de deux projets de modernisation sur trois échouent à cause du manque ou la perte de documentation de l'application, la complexité du logiciel (qui lui n'a cessé de grandir avec le temps), la perte des connaissances techniques (les jeunes développeurs n'ont jamais étudié ces anciennes technologies), tout cela couplé à un manque d'outils et de méthodes industrielles. Face à ce constat implacable, cette thèse suggère une solution pour l'industrialisation du processus de modernisation à travers l'utilisation de l'Ingénierie Dirigée par les Modèles (IDM), notamment en prenant pour base les métamodèles issus de l'initiative Architecture Driven Modernisation de l'OMG. Nous montrons qu'il est ainsi possible d'automatiser une majorité du processus du fait de l'utilisation de métamodèles pivots technologiquement neutres, ainsi que l'utilisation d'une série d'outils permettant d'obtenir une automatisation des tâches de migration de l'application. Nous proposons également de rendre cette solution adaptable à n'importe quel langage légataire au travers d'une chaîne de modernisation paramétrable via l'utilisation d'un moteur de transformation dédié offrant des mécanismes d'extensibilité et de réutilisabilité. Pour terminer, nous illustrons l'ensemble des idées développées dans cette thèse sur l'exemple concret d'une application codée en COBOL. / Software modernization is a fast-growing sector due to the aging technologies from the 1960s, such as COBOL or FORTRAN. Nowadays, many of these applications are still being used because of their criticality. These applications allow companies to maintain their information system. But to face the arrival of newer technologies and platforms, like Cloud or Mobile, companies must modernize their systems to deliver the same services and also develop new ones in order to compete. However, nearly two out of three modernization projects fail because of the lack or the loss of applications documentation, the complexity of the software (that has continued to grow over time), the loss of technical knowledge (the junior developers have never studied these ancient technologies), plus a lack of tools and industrial methods. Faced with this relentless observation, this thesis suggests a solution to the industrialization process of modernization through the use of Model Driven (IDM) Engineering, especially by using metamodels base from Driven Architecture Modernization of the OMG. We therefore demonstrate that it is possible to automate the process thanks to technologically neutral metamodels and by using a set of tools to get the automation of application migration tasks. We also propose to have this solution adapted to any languages through a configurable chain of modernization by using a dedicated processing engine that provides scalability and reusability mechanisms. Finally, we illustrate the ideas developed in this thesis in the concrete case of a coded COBOL application.

Ce mémoire est une évaluation de la qualité de Moodle, une plateforme de téléapprentissage (PTA) basée sur du logiciel libre et récemment implantée à l'UQAM pour remplacer la plateforme propriétaire WebCT. Cette évaluation a été entreprise selon une approche du génie logiciel, en l'occurrence une analyse de conformité de Moodle aux exigences de la norme de qualité ISO 9126, un référentiel normatif international qui décrit 6 caractéristiques de qualité et leurs sous caractéristiques. Ce choix méthodologique a semblé moins subjectif et plus rigoureux que celui des méthodes courantes d'évaluation de la qualité des PTA (ex: méthode de la grille des critères ou les questionnaires) car cette norme repose sur un modèle très structuré et un ensemble de métriques pour évaluer la qualité du logiciel. En outre l'approche est fiable si l'on considère que cette norme a fait l'objet d'applications multiples en génie logiciel et possède une reconnaissance internationale. Les résultats obtenus montrent un haut niveau de conformité de Moodle1.6.5 aux exigences de qualité technique d'ISO 9126, à raison de 91% pour la fonctionnalité et un indice de conformité de 87,5% aux exigences de qualité ergonomique pour les facteurs d'utilisabilité. L'évaluation montre aussi que l'interopérabilité, qui est un facteur technique critique dans un environnement Open Source comme Moodle, a connu une amélioration importante avec un indice de conformité de 86 % à la norme alors que cet indice n'est que de 37 % pour l'interopérabilité technique et 57 % pour l'interopérabilité pédagogique pour la PTA propriétaire WebCT. Au terme de ce processus d'évaluation, cette méthode du génie logiciel nous est apparue aussi comme étant plus efficace et plus efficiente que les méthodes traditionnelles d'évaluation car elle exige moins de temps, moins d'argent et ne nécessite pas le recours à des évaluateurs experts. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : e-Learning, Moodle, ISO 9126, Évaluation, Exigence, Génie logiciel, Interopérabilité, Fonctionnalité, Ergonomie, Conformité.

Les logiciels dépendent de bibliothèques tierces pour réduire les coûts liés à leur développement et à leur maintenance. Elles proposent un ensemble de fonctionnalités robustes dont les développeurs peuvent tirer parti depuis une interface de programmation. Cependant, cette forte dépendance entre un logiciel et ses bibliothèques oblige les développeurs à reconsidérer leur rôle lorsque le logiciel évolue. Dans cette thèse, nous identifions plusieurs problématiques impliquant les bibliothèques tierces dans un contexte de maintenance logicielle. Plus particulièrement, une bibliothèque peut ne plus répondre aux besoins d’un logiciel et doit être remplacée par une nouvelle.Nous nommons cette opération une migration de bibliothèque.Nous soulevons dans ce contexte trois points qui caractérisent les difficultés rencontrées par les développeurs. Vers quelle bibliothèque migrer ? Comment appliquer la migration ? Avec l’aide de quels développeurs ? Cette thèse discute de solutions et apporte des contributions autour de ces problèmes. Nous présentons plusieurs approches et les évaluons lors de différents cas d’étude. L’analyse de l’évolution logicielle sera notre support de travail, dont la méthodologie est basée sur l’observation des changements de logiciels. Nous décrivons les limites actuelles de nos contribu-tions et ouvrons des perspectives futures pour enrichir l’état de l’art dans ce domaine / Software depend on third-party libraries to reduce development and maintenance costs. Developers have access to robust functionalities through an application programming interface designed by these libraries. However, due to the strong relationship with these libraries, developers have to reconsider their position when the software evolves. In this thesis, we identify several re-search problems involving these third-party libraries in a context of software maintenance. More specifically, a library may not satisfy the software new requirements and has to be replaced by anew one. We call this operation a library migration.We leverage three points that characterize the impediments met by developers in this situation.To which library should they migrate ? How to migrate their software ? Who can help them in this case ? This thesis suggests answers and exposes several contributions to these problems. We define three approaches that are evaluated through several case studies. To achieve this work, weuse a methodology based on software evolution analysis to observe and understand how software change. We describe numerous perspectives to overcome the current limitations of our solutions.

Le présent document présente d'abord un bref historique ainsi que les concepts de base de la génétique de population pour ensuite présenter les concepts utilisés pour développer le module d'assistance au jumelage du programme Analypop, un programme de gestion et d'analyse de registre de population. Par la suite, nous verrons comment la conception choisie permet aux chercheurs d'effectuer la consultation ainsi que d'enregistrer certains changements dans le registre de population. Finalement, nous verrons deux fonctionnalités qui permettent d'exporter les données pour qu'elles puissent être traitées par d'autres programmes. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : Logiciel, Démographie, Registre de Population, Analypop.

Dans ce début du troisième millénium, nous sommes témoins d'un nouvel âge. Ce nouvel âge est caractérisé par la transition d'une économie industrielle vers une économie basée sur la technologie de l'information. C'est l’âge de l'information. Aujourd’hui le logiciel est présent dans pratiquement tous les aspects de notre vie. Une seule vulnérabilité logicielle peut conduire à des conséquences dévastatrices. La détection de ces vulnérabilités est une tâche qui devient de plus en plus dure surtout avec les logiciels devenant plus grands et plus complexes. Dans cette thèse, nous nous sommes intéressés aux vulnérabilités de sécurité impactant les applications développées en langage C et particulièrement les vulnérabilités provenant de l'usage des fonctions de ce langage. Nous avons proposé une liste de vérifications pour la détection des portions de code causant des vulnérabilités de sécurité. Ces vérifications sont sous la forme de conditions rendant l'appel d'une fonction vulnérable. Des implémentations dans l'outil Carto-C et des expérimentations sur la base de test Juliet et les sources d'applications réelles ont été réalisées. Nous nous sommes également intéressés à la détection de vulnérabilités exploitables au niveau du code binaire. Nous avons défini en quoi consiste le motif comportemental d'une vulnérabilité. Nous avons proposé une méthode permettant de rechercher ces motifs dans les traces d'exécutions d'une application. Le calcul de ces traces d'exécution est effectué en utilisant l'exécution concolique. Cette méthode est basée sur l'annotation de zones mémoires sensibles et la détection d'accès dangereux à ces zones. L'implémentation de cette méthode a été réalisée dans l'outil Vyper et des expérimentations sur la base de test Juliet et les codes binaires d'applications réelles ont été menées avec succès / In the beginning of the third millennium we are witnessing a new age. This new age is characterized by the shift from an industrial economy to an economy based on information technology. It is the Information Age. Today, we rely on software in practically every aspect of our life. Information technology is used by all economic actors: manufactures, governments, banks, universities, hospitals, retail stores, etc. A single software vulnerability can lead to devastating consequences and irreparable damage. The situation is worsened by the software becoming larger and more complex making the task of avoiding software flaws more and more difficult task. Automated tools finding those vulnerabilities rapidly before it is late, are becoming a basic need for software industry community. This thesis is investigating security vulnerabilities occurring in C language applications. We searched the sources of these vulnerabilities with a focus on C library functions calling. We dressed a list of property checks to detect code portions leading to security vulnerabilities. Those properties give for a library function call the conditions making this call a source of a security vulnerability. When these conditions are met the corresponding call must be reported as vulnerable. These checks were implemented in Carto-C tool and experimented on the Juliet test base and on real life application sources. We also investigated the detection of exploitable vulnerability at binary code level. We started by defining what an exploitable vulnerability behavioral patterns are. The focus was on the most exploited vulnerability classes such as stack buffer overflow, heap buffer overflow and use-after-free. After, a new method on how to search for this patterns by exploring application execution paths is proposed. During the exploration, necessary information is extracted and used to find the patterns of the searched vulnerabilities. This method was implemented in our tool Vyper and experimented successfully on Juliet test base and real life application binaries.level. We started by defining what an exploitable vulnerability behavioral patterns are. The focus was on the most exploited vulnerability classes such as stack buffer overflow, heap buffer overflow and use-after-free. After, a new method on how to search for this patterns exploring application execution paths is proposed. During the exploration, necessary information is extracted and used to find the patterns of the searched vulnerabilities. This method was implemented in our Vyper tool and experimented successfully on Juliet test base and real life application binaries

Les simulations multi-agents reproduisent un phénomène en modélisant intuitivement son fonctionnement au niveau microscopique. Ce fonctionnement est décrit par le comportement d'entités autonomes qui agissent dans un environnement commun. Toutefois, les approches actuelles restreignent les interactions à des effets de bord ou ne fournissent aucune méthodologie réifiant la notion d'interaction. La conception de simulations contenant un grand nombre d'agents interagissant de manière variée s'en trouve complexifiée. Nous soutenons que pour faciliter la conception des simulations, il est préférable que toute entité soit concrétisée par un agent et tout comportement par une interaction. Le moteur de simulation doit de plus être clairement séparé des agents et interactions, de sorte que tout le système multi-agents soit régi par le même algorithme de simulation. Une telle approche procure de nombreux avantages tels que l'automatisation de l'implémentation, la réutilisabilité des interactions ou la conception graduelle du modèle du phénomène. En nous fondant sur ces principes, nous avons développé une approche centrée sur les interactions (IODA) composée d'une pyramide d'outils : un modèle formel, un ensemble d'algorithmes de simulation et une méthodologie. Nous confirmons la faisabilité de cette approche par une plateforme de simulation paramétrable (JEDI) fidèle au modèle formel et un environnement de développement intégré (JEDI-Builder) qui automatise le passage du modèle IODA au code JEDI. Nous montrons ainsi que la concrétisation logicielle des interactions a conduit à une unification du concept d'agent et à une simplification du processus de conception de simulations. / This thesis focuses on the design of Multi-Agent Based Simulations (MABS). MABS are aimed at reproducing real phenomena of intuitively modeling their inner mechanisms using autonomous entities behaving in a synthetic environment. For either of the following two reasons, current MABS design techniques are unsatisfactory: the interactions are limited to exchanging messages or MABS are restricted to formal specifications. As a consequence, large-scale simulations --e.g. featuring many agents and many interactions-- are still hard to design. In this context, our research promotes a more homogeneous knowledge representation, resulting in practice into the reification of each entity by an agent and each behaviour by an interaction. That way, the simulation engine has to be separated from both the agents and the interactions, enabling the MABS to be ruled by a single and accurate algorithm. Besides, we show that the interactions can be re-used, the models incrementally designed and the implementation automated. Based on these principles, we have developped IODA, an interaction-oriented approach to simulation design. IODA provides a formal model for describing the agents and their interactions, a set of algorithms for unifying their action selection and a methodology for incremental design. IODA also features JEDI, a parameterizable simulation framework faithful to IODA's principles, and JEDI-Builder, an automated tool for translating IODA models into JEDI code. As a result of this research, it is shown that the reification of the interaction leads not only to the unification of the agent concept, but also to a simplification of the simulation design process.

L'électronique dans les voitures devient de plus en plus complexe et représente plus de 30% du coût global d'une voiture. Par exemple, dans une BMW série 5 modèle 2008, on peut trouver jusqu'à 80 calculateurs électroniques communiquant ensemble et représentant aux alentours de 10 millions de lignes de code logiciel. Face à cette montée en complexité, les constructeurs et équipementiers électroniques de l'automobile s'intéressent de plus en plus à des méthodes efficaces de développement, vérification et validation de modules électroniques. Plus précisément, ils focalisent leurs efforts sur la partie logicielle de ces modules puisqu'elle est à l'origine de plus de 80% des problèmes détectés sur ces produits. Dans ce contexte, nous avons mené un travail de recherche dont l'objectif est de proposer une approche globale d'amélioration de la qualité des logiciels embarqués dans les véhicules. Notre recherche part d'un audit des processus et outils actuellement utilisés dans l'industrie électronique automobile. Cet audit a permis d'identifier des leviers potentiels d'amélioration de la qualité logicielle. En se basant sur les résultats de l'audit et en tenant compte de la littérature dans le domaine de la qualité logicielle, nous avons proposé une approche globale de conception de cas de test pour les produits logiciels. En effet, nous avons développé une plateforme de génération automatique de tests pour un produit logiciel. Cette plateforme consiste à modéliser les spécifications du produit logiciel pour le simuler lors de tests, à se focaliser sur les tests critiques (ayant une forte probabilité de détecter des défauts) et à piloter la génération automatique des tests par des critères de qualité ; telles que la couverture du code et de la spécification mais aussi le coût des tests. La génération de tests critiques est rendue possible par la définition de profils d'utilisation réelle par produit logiciel, ainsi que par la réutilisation des défauts et des tests capitalisés sur des anciens projets. En plus des aspects algorithmiques du test logiciel, notre approche prend en compte des aspects organisationnels tels que la gestion des connaissances et des compétences et la gestion de projet logiciel. Notre approche a été mise en œuvre sur deux cas d'étude réels d'un équipementier électronique automobile, disposant de données de tests historiques. Les résultats de nos expérimentations révèlent des gains de qualité significatifs : plus de défauts sont trouvés plus tôt et en moins de temps.

Les technologies logicielles ne cessent d'évoluer pour faciliter le développement, le déploiement et la maintenance d'applications dans différents domaines. En parallèle, ces applications évoluent en continu pour garantir une bonne qualité de service et deviennent de plus en plus complexes. Cette évolution implique souvent des coûts de développement et de maintenance de plus en plus importants, auxquels peut s'ajouter une augmentation des coûts de déploiement sur des infrastructures d'exécution récentes comme le cloud. Réduire ces coûts et améliorer la qualité de ces applications sont actuellement des objectifs centraux du domaine du génie logiciel. Récemment, les microservices sont apparus comme un exemple de technologie ou style architectural favorisant l'atteinte de ces objectifs.Alors que les microservices peuvent être utilisés pour développer de nouvelles applications, il existe des applications monolithiques (i.e., monolithes) cons-truites comme une seule unité et que les propriétaires (e.g., entreprise, etc.) souhaitent maintenir et déployer sur le cloud. Dans ce cas, il est fréquent d'envisager de redévelopper ces applications à partir de rien ou d'envisager une migration vers de nouveaux styles architecturaux. Redévelopper une application ou réaliser une migration manuellement peut devenir rapidement une tâche longue, source d'erreurs et très coûteuse. Une migration automatique apparaît donc comme une solution évidente.L'objectif principal de notre thèse est de contribuer à proposer des solutions pour l'automatisation du processus de migration d'applications monolithiques orientées objet vers des microservices. Cette migration implique deux étapes : l'identification de microservices et le packaging de ces microservices. Nous nous focalisons sur d'identification en s'appuyant sur une analyse du code source. Nous proposons en particulier deux approches.La première consiste à identifier des microservices en analysant les relations structurelles entre les classes du code source ainsi que les accès aux données persistantes. Dans cette approche, nous prenons aussi en compte les recommandations d'un architecte logiciel. L'originalité de ce travail peut être vue sous trois aspects. Tout d'abord, les microservices sont identifiés en se basant sur l'évaluation d'une fonction bien définie mesurant leur qualité. Cette fonction repose sur des métriques reflétant la "sémantique" du concept "microservice". Deuxièmement, les recommandations de l'architecte logiciel ne sont exploitées que lorsqu'elles sont disponibles. Enfin, deux modèles algorithmiques ont été utilisés pour partitionner les classes d'une application orientée objet en microservices : un algorithme de regroupement hiérarchique et un algorithme génétique.La deuxième approche consiste à extraire à partir d'un code source orienté objet un workflow qui peut être utilisé en entrée de certaines approches existantes d'identification des microservices. Un workflow décrit le séquencement de tâches constituant une application suivant deux formalismes: un flot de contrôle et/ou un flot de données. L'extraction d'un workflow à partir d'un code source nécessite d'être capable de définir une correspondance entre les concepts du mon-de objet et ceux d'un workflow.Pour valider nos deux approches, nous avons implémenté deux prototypes et mené des expérimentations sur plusieurs cas d'étude. Les microservices identifiés ont été évalués qualitativement et quantitativement. Les workflows obtenus ont été évalués manuellement sur un jeu de tests. Les résultats obtenus montrent respectivement la pertinence des microservices identifiés et l'exactitude des workflows obtenus. / Software technologies are constantly evolving to facilitate the development, deployment, and maintenance of applications in different areas. In parallel, these applications evolve continuously to guarantee an adequate quality of service, and they become more and more complex. Such evolution often involves increased development and maintenance costs, that can become even higher when these applications are deployed in recent execution infrastructures such as the cloud. Nowadays, reducing these costs and improving the quality of applications are main objectives of software engineering. Recently, microservices have emerged as an example of a technology or architectural style that helps to achieve these objectives.While microservices can be used to develop new applications, there are monolithic ones (i.e., monoliths) built as a single unit and their owners (e.g., companies, etc.) want to maintain and deploy them in the cloud. In this case, it is common to consider rewriting these applications from scratch or migrating them towards recent architectural styles. Rewriting an application or migrating it manually can quickly become a long, error-prone, and expensive task. An automatic migration appears as an evident solution.The ultimate aim of our dissertation is contributing to automate the migration of monolithic Object-Oriented (OO) applications to microservices. This migration consists of two steps: microservice identification and microservice packaging. We focus on microservice identification based on source code analysis. Specifically, we propose two approaches.The first one identifies microservices from the source code of a monolithic OO application relying on code structure, data accesses, and software architect recommendations. The originality of our approach can be viewed from three aspects. Firstly, microservices are identified based on the evaluation of a well-defined function measuring their quality. This function relies on metrics reflecting the "semantics" of the concept "microservice". Secondly, software architect recommendations are exploited only when they are available. Finally, two algorithmic models have been used to partition the classes of an OO application into microservices: clustering and genetic algorithms.The second approach extracts from an OO source code a workflow that can be used as an input of some existing microservice identification approaches. A workflow describes the sequencing of tasks constituting an application according to two formalisms: control flow and /or data flow. Extracting a workflow from source code requires the ability to map OO conceptsinto workflow ones.To validate both approaches, we implemented two prototypes and conducted experiments on several case studies. The identified microservices have been evaluated qualitatively and quantitatively. The extracted workflows have been manually evaluated relying on test suites. The obtained results show respectively the relevance of the identified microservices and the correctness of the extracted workflows.