Modélisation des connaissances normatives en vue l'évaluation de la recyclabilité d'un produit en conception : des normes aux contraintes

Un des principes de l'ingénierie concourante consiste à prendre en compte des contraintes liées à des étapes aval du cycle de vie d'un produit. Une meilleure prise en compte de ces exigences peut être obtenue par la mise à disposition d'outils d'aide à la décision permettant de vérifier rapidement la satisfaction des contraintes sur l'état actuel de description du produit. L'intégration des contraintes environnementales lors de la conception d'un produit est un excellent exemple de cette problématique, car représentative du problème général de la modélisation des connaissances, puis de leur interprétation au sein d'un système informatisé. En effet, les critères que le produit doit satisfaire sont contenus dans des normes et standards rédigés en langage naturel ; ces derniers peuvent être parfois ambigus, donc difficiles à interpréter, aussi bien par un humain que par un logiciel. Dans cette thèse, notre travail vise à proposer puis valider une démarche de traduction des connaissances normatives sous une forme exploitable pour l'évaluation de la recyclabilité d'un produit lors de sa conception. Nous proposons tout d'abord de définir un modèle « étendu » de produit à partir de l'analyse d'un échantillon représentatif d'éco-labels ; ces derniers étant considérés comme corpus de connaissances contenant des règles permettant d'évaluer la recyclabilité. Un langage de modélisation à base d'ontologies est pour cela utilisé afin de faciliter le passage du langage naturel à un modèle semi-formel. Il s'agit ensuite de propager les contraintes de recyclabilité extraites du corpus considéré dans la nomenclature du produit ; celle-ci étant choisie comme cadre de définition des paramètres de la recyclabilité. La démarche proposée est alors validée à partir d'un algorithme basé sur des techniques de CSP, tandis qu'une implémentation à l'aide du langage objet CLAIRE est décrite

Approche pour le développement de logiciels intégrant des concepts de qualité de service

In critical domains such as avionics, railways or automotive, to certify a system, it is required to demonstrate that it achieves its function, with respect to specified timing requirements. Indeed, longer-than-predicted function computing can make data erroneous, leading potentially to endanger people lives. Today, most approaches propose to ensure these Quality of Service requirements at platform level, e.g., through deterministic bandwidth, static time slots allocation and predefined scheduling. These constraints ensure applications can’t overpass allocated time slots; applications are then fed with requirements decoupled to their functionality. However, it shall be possible to certify timing requirements, dedicated to an application. Hence, guarantees at platform-level are not sufficient anymore. It should be possible to take into account these requirements from the stage of application design. Today, most of existing approaches in this domain, focus on supporting QoS at individual stages of the software development process, preventing requirements traceability. This thesis proposes a design-driven approach to supporting QoS throughout software development process, integrated in a tool-based methodology, namely DiaSuite. The QoS extension enriches the DiaSpec design language, with the capability to instantiate QoS requirements onto software components. A runtime execution support to monitoring these timing requirements, is then generated, directly from the specification. This thesis uniformly integrates timing concepts with error ones, around DiaSuite methodology, to propose a supervision layer that could lead to application reconfiguration in case of QoS contract violation. Contributions of this thesis are evaluated through respect of coherence and conformance critera, illustrated through a case study in avionics.Dans les domaines critiques tels que l’avionique, le ferroviaire ou encore l’automobile, il faut, afin de pouvoir certifier un système, démontrer qu’il réalise la fonction pour laquelle il a été conçu, selon des exigences temporelles spécifiées. En effet, un rendu temporel trop long peut rendre des données erronées, et ainsi mettre en danger la sûreté des personnes. Aujourd’hui, la plupart des approches proposent d’assurer ces exigences de Qualité de service au niveau des couches basses, e.g., au travers d’une bande passante déterministe, d’allocation statique d’intervalles de temps, et d’un ordonnancement prédéfini. Ces contraintes assurent que les applications ne peuvent dépasser le temps d’exécution alloué ; les applications récupèrent de ce fait des exigences qui sont découplées de leur fonctionnalité. En revanche, il faut aussi pouvoir certifier des exigences temporelles spécifiques à une application. De là, les garanties au niveau des couches basses ne sont plus suffisantes. Il faudrait pouvoir prendre en compte ces exigences dès la phase de conception des applications. Aujourd’hui, la plupart des approches existant dans ce domaine se concentrent sur le support de QoS à des phases isolées du processus de développement logiciel, empêchant la traçabilité des exigences. Cette thèse propose une approche dirigée par la conception pour supporter les exigences de QoS tout au long du processus de développement logiciel, intégrée dans une méthodologie outillée, appelée DiaSuite. L’extension de QoS enrichit le langage de conception DiaSpec avec la capacité d’instancier les exigences de QoS sur les composants logiciels. Un support de surveillance à l’exécution de ces exigences temporelles est ensuite généré, directement à partir de la spécification. Cette thèse intègre uniformément les concepts temporels avec les concepts de gestion d’erreurs, au travers de la méthodologie DiaSuite, afin de proposer une couche de supervision qui puisse effectuer une reconfiguration applicative, dans le cas de violation de contrat de QoS. Les contributions de cette thèse sont évaluées au regard du respect des critères de cohérence et de conformité, illustrés au travers d’une étude de cas dans le domaine avionique

Model-Checking symbolique pour la vérification de systèmes et son application aux tables de décision et aux systèmes d'éditions collaboratives distribuées

Résumé Dans le cycle de vie de tout système logiciel, une phase cruciale de formalisation et de validation au moyen de vérification et/ou de test induit une identification d'erreurs probables infiltrées durant sa conception. Cette détection d'erreurs et leur correction sont avantageuses dans les premières phases de développement du système afin d'éviter tout retour aux travaux ardus d'analyse de spécifications et de modélisation du système précédant sa réalisation. Par conséquent, cette étape mise en oeuvre à travers des méthodes et des outils formels dans les phases amont de la conception contribue à augmenter la confiance des concepteurs et utilisateurs vis-à-vis de la fonctionnalité du système. L'objectif de cette maîtrise s'insère dans le cadre d'une recherche qui vise à exploiter une technique formelle spécifique d'analyse de programmes et de spécifications: l'exécution symbolique combinée au model-checking. Cette technique représente une approche émergente à laquelle les chercheurs ont porté une attention particulière ces dernières années. D'une part, l'exécution symbolique permet d'explorer les chemins d'exécution possibles d'un programme modélisant un système avec des variables d'entrée non initialisées, en d'autres termes en manipulant des variables abstraites ou "symboliques". Ces chemins caractérisent ainsi le comportement du programme de manière abstraite. D'autre part, le model-checking permet d'explorer systématiquement ces différents chemins d'exécution à l'aide d'une énumération exhaustive des états accessibles afin de générer ultérieurement des contreexemples en cas de violation de propriétés du système. De ce fait, l'exécution symbolique combinée au model-checking englobe les points forts de ces deux techniques octroyant aux concepteurs du système une compréhension accrue des situations d'erreur dans les contre-exemples ainsi générés.----------Abstract Verification is one crucial activity in any software life cycle. Its major role is to ensure an identification of potential design and implementation flaws integrated in the software system during its development process. Such an identification leads to eventual corrections in the early steps of the development cycle, thus avoiding tedious work otherwise required in the system requirements' reanalysis as well as in its remodelling preceding its deployment. As a consequence, the verification step is rigorously put into practice through formal methods and tools. Given such a formalisation contributes to give another level of insurance to both the system's designers and users. This thesis is related to a research which aims at applying one specific formal method in program and requirements analysis: symbolic execution intertwined with model checking. This technique has known a major development in the past few years, thus raising interest among researchers in the field. On one hand, symbolic execution explores all possible execution paths of a program modelling a system using uninitialised input variables. As its name implies, this specific execution deals with abstract or "symbolic" variables. Hence, those visited paths characterise the abstract program behaviour. On another hand, model checking ensures a systematic exploration of those different execution paths through an exhaustive visit of all reachable states. This approach is necessary for subsequent generation of counterexamples in case of property violations within the system. Therefore, symbolic execution along with model checking is a resulting approach enforced with advantages of both techniques. This yields a higher degree of interpreting the retrieved flaws provided through generated counterexamples, for even the most sophisticated systems

Contributions à la définition d'un nouveau langage d'exploitation des bases de données relationnelles

Le but du projet DOMINUS est de définir un modèle de SGBD adapté au développement de services de dépôt de données autonomes capables de maintenir un haut standard d'intégrité et de fiabilité dans un contexte applicatif contemporain.Le présent mémoire, réalisé dans le cadre du projet DOMINUS, vise à contribuer à la définition d'un premier langage conforme à ce modèle, Discipulus, et à mettre en oeuvre un premier traducteur expérimental de ce langage. Le modèle DOMINUS demeure basé sur le modèle relationnel de E. F. Codd tout d'abord parce qu'il est simple, facile à appréhender, et repose sur de solides bases théoriques qui permettent notamment de définir de façon formelle les langages de manipulation associés et, en second lieu, parce qu'il est éprouvé, comme le démontrent plus de trente années de prédominance ininterrompue. L'évolution de la gestion d'information a vu apparaître de nouvelles applications (systèmes de gestion intégrée, traitement d'images, vidéo...) nécessitant l'utilisation de bases de données complexes de plus en plus importantes. Ces nouvelles applications ont mis en évidence les insuffisances majeures des systèmes relationnels existants fondés sur le langage SQL: (1) L'inadéquation du modèle relationnel à représenter directement des données complexes, comme des dossiers médicaux structurés, des images radiographiques ou des textes annotés. (2) Les performances insuffisantes dans la manipulation de ces mêmes données. Ces lacunes ont conduit certains à vouloir remplacer le modèle relationnel par le modèle orienté objet. En effet, la notion d'objet (plus exactement de classe) permet de modéliser des éléments complexes et composites du monde réel. En 1990 sont apparus les premiers systèmes de gestion de bases de données à objets, mais, vu les performances et la maturité des systèmes de bases de données relationnelles, les systèmes à objets n'ont pas pris une place significative au sein des organisations. La voie explorée ici est plutôt celle de l'intégration du modèle objet au modèle relationnel, ce dernier demeurant prééminent. L'adoption des deux structures (la relation et la classe) semble donc nécessaire afin de répondre aux besoins et aux exigences des applications complexes tout en gardant la simplicité et la cohésion conceptuelle nécessaire à la vérification et à la validation. Le modèle DOMINUS est donc inspiré des travaux fondamentaux de E. F. Codd et de ses continuateurs, dont C. J. Date et H. Darwen [S1] ainsi que des modèles algorithmiques et de typage de B. Meyer[L13] . Au final, le langage Discipulus retient plusieurs acquis du langage SQL, s'inspire également de langage Tutorial D et emprunte la structure générale et plusieurs mécanismes syntaxiques du langage Eiffel[L13] . Notre proposition comporte également de nombreuses différences sensibles tant sur le fond que sur la forme[L1,L7] . Ces apports sont présentés au fil du mémoire. Le langage Discipulus a été conçu dans le but de permettre l'expression rigoureuse de modèles complexes (intégration complète des classes, des tuples et des relations dans un seul système de typage homogène et cohérent) tout en favorisant la réutilisation (l'utilisation d'un système de paquetage destiné à développer des modules cohérents tout en permettant leur réutilisation simple pour le développement d'autres systèmes), l'évolutivité (l'adoption de l'héritage multiple permet d'éviter la redondance de code et facilite l'extensibilité du logiciel et, par conséquent, l'évolutivité sans compromettre son intégrité et sa fiabilité) et la fiabilité (incorporation des principes de programmation par contrat et leur extension aux opérateurs relationnels, traitement cohérent de l'annulabilité)

Vérification des patrons temporels d’utilisation d’API sans exécution du code : une approche et un outil

La réutilisation est une pratique courante lors du développement de logiciel. Bien souvent, cette réutilisation se fait à travers l’utilisation des librairies. Cette dernière met ses fonctionnalités à disposition des développeurs en utilisant les Interfaces de Programmation d’Application (API). En théorie, les développeurs qui utilisent les API n’ont pas forcément besoin de se préoccuper de comment les éléments internes de cette API fonctionnent. En effet, les API mettent leurs fonctionnalités à disposition des développeurs sans forcément dévoiler ce qui se passe à l’interne. Cependant, pour utiliser correctement une API il est nécessaire de respecter des contraintes d’utilisation qui sont à la fois implicites et explicites ainsi que des modèles d’utilisation. L’usage des librairies et des API est très commun dans le domaine du développement de logiciel. Cela permet aux développeurs d’utiliser les fonctionnalités proposées par l’API et ainsi de se concentrer directement sur la tâche qu’ils doivent effectuer. Toutefois, apprendre et se familiariser avec les contraintes d’usage des API sont des tâches ardues et exigent un effort cognitif considérable de la part du développeur. Les chercheurs ont tenté de corriger ce problème en étudiant les modèles d’utilisation et en analysant les traces d’utilisation de code client pour s’assurer de leurs conformités. Néanmoins, les analyses dynamiques ne sont pas possibles pendant les phases précoces de développement du logiciel, car cela requiert une implémentation minimum et l’exécution du code. Nous proposons l’outil Temporal Usage PAttern Checker (Tupac). Une approche basée sur l’analyse statique interprocédural pour vérifier la conformité du code client aux modèles d’utilisation pendant la phase de développement. Tupac peut être déployé dans un envi- ronnement de développement (IDE) et ainsi fournir des informations relatives à l’utilisation des API plus tôt pendant la phase de développement du logiciel. Nous avons évalué notre approche sur quatre projets Java avec quatre API. Les résultats ont démontré que Tupac a une bonne précision et un taux de rappel intéressant. De plus, nous avons pu conclure qu’en moyenne cela prend une demi-seconde pour vérifier la confor- mité d’un patron pour un projet tout entier. Cela démontre que Tupac peut être déployé dans un rythme de codage régulier.In modern software development, reuse takes the form of using libraries that expose their functionality via Application Programming Interfaces (APIs). In theory, APIs allow developers to write client code that reuses library code without needing to know its internals. In practice, correctly using APIs requires respecting explicit and implicit constraints and usage patterns. This allows developers to use functionality proposed by API so that they can focus directly on the task they want to achieve. APIs require a significant effort from the developer to learn various usage constraint. Ignoring such patterns could lead to errors and design flaws. These often cannot be detected prior to integration and system testing. Researchers have attempted to solve this problem by extracting API usage patterns and analyzing client code traces for conformance. However, dynamic analysis is still impossible to perform early without a minimum of integration and execution. We propose the Temporal Usage PAttern Checker (Tupac) for API, an interprocedural static analysis approach that can verify that client code conforms to temporal API usage patterns as it is being developed. Tupac can be deployed inside an Integrated Development Environment (IDE), thus providing developers with feedback about API usage much earlier in the development process. We evaluated the effectiveness of our approach on four projects with four different APIs. Our evaluation shows that Tupac has good precision and interesting recall. Crucially, we also show that it takes, on average, half a second to check an entire project for conformance to a pattern, meaning that it can realistically be deployed in the regular coding rhyth

Implémentation d'un langage fonctionnel orienté vers la méta programmation

Ce mémoire présente l'implémentation d'un nouveau langage de programmation nommé Typer. Typer est un langage fonctionnel orienté vers la méta programmation. Il a été conçu pour augmenter la productivité du programmeur et lui permettre d'écrire des applications plus fiables grâce à son système de types. Pour arriver à ses fins, Typer utilise l'inférence de types et implémente un puissant système de macros. L'inférence de types permet à l'utilisateur d'omettre certains éléments, le système de macros, quant à lui, permet de compléter le programme pendant la compilation lorsque l'inférence n'est pas suffisante ou pour générer du code. Typer utilise les types dépendants pour permettre à l'utilisateur de créer des types très expressifs pouvant même être utilisés pour représenter des preuves formelles. De plus, l'expressivité des types dépendants permet au compilateur d'effectuer des vérifications plus approfondies pendant la compilation même. Ces mécaniques permettent au code source d'être moins verbeux, plus concis et plus simple à comprendre, rendant, ainsi l'écriture de programmes ou/et de preuves plus plaisante. Ces fonctionnalités sont implémentées dans l'étape que nous appelons l'élaboration, à l'intérieur de laquelle de nombreuses transformations du code source ont lieu. Ces transformations incluent l'élimination des aides syntaxiques, la résolution des identificateurs, l'expansion des macros, la propagation et l'inférence des types.This dissertation present the implementation of a new programming language named Typer Typer is a functional programming language oriented towards meta programming. It has been created to increase the programmer productivity and enable him to write safer programs thanks to his type system. To achieve his goal, Typer use type inference and a powerful macro system. Type inference enable to user to elide some elements while the macro system enable us to complete the program during compilation. Typer use dependent type which enable the user to create very expressive types which can even be used to represent formal proofs. Furthermore, dependent type's expressivity enable the compiler to perform a in-depth checks during compilation. Those mechanics enable the source code to be less verbose, shorter and easier to understand, making the writing of new programmes more enjoyable. Those functionalities are implemented during the step we call the elaboration in which numerous transformations occur. Those transformations include the removal of syntactic sugar, identifier resolution, macro expansion and the propagation and the inference of types

Conception d'un système de synthèse orienté-objet multiplateforme en vue d'une nouvelle méthode de synthèse

La loi de Moore prédit que le nombre de composants dans un circuit double tous les 18 mois. Cette augmentation permet de diminuer les délais dans ces composants, mais amènent une augmentation des délais liés aux interconnexions par rapport aux délais dans les composants et de la consommation de puissance. Récemment, les délais dans les interconnexions sont devenus trop importants par rapport aux délais dans les portes logiques au point où la méthode de synthèse automatisée de circuits intégrés actuelle est devenue inadéquate. Puisque le traitement des interconnexions s'effectue lors de la synthèse physique, une nouvelle approche, inversant les étapes de la synthèse physique et de la synthèse logique, a été envisagée. La conception d'un système, utilisant un langage orienté-objet et offrant de la portabilité et une intégration de modules futurs, a été l'objet de cette recherche puisqu'un système utilisant un tel procédé n'a pas encore vu le jour. Une plate-forme de synthèse a été développée et celle-ci a été testée à l'aide d'un module de gestion de budgets de délai. Premièrement, une lecture de la description logique du circuit provenant de la synthèse comportementale a été effectuée en utilisant un décomposeur analytique et un analyseur syntaxique. Ensuite, pendant cette lecture, un réseau booléen hiérarchique représentant le circuit a été bâti selon une infrastructure prédéfinie. Afin de pouvoir tester la plate-forme, des budgets de délais ont été assignés à chaque noeud du réseau en propageant le temps d'arrivée et le temps requis dans un circuit provenant d'une description logique hiérarchique complexe. Finalement, la gestion de budgets de délai a été faite par un algorithme conçu à cet effet et les résultats de celle-ci ont été analysés. Le résultat obtenu est une plate-forme de synthèse capable de faire de la gestion de budget de délais sur les chemins critiques dans un circuit donné. De plus, celle-ci pourra être utilisée de nouveau pour d'autres projets liés à la synthèse de circuits. La pertinence de cette recherche repose sur la résolution d'un problème grandissant dans le monde de la synthèse automatisée des circuits intégrés