Modèle de communication entre un laboratoire virtuel réflexif et un tuteur dans un systeme tutoriel intelligent

L'intégration des laboratoires virtuels à des agents tuteurs d'un système tutoriel intelligent (STI) s'est souvent réalisée avec une perte de leur autonomie. En effet, l'encapsulation des composantes est difficile à préserver parce qu'elles doivent collaborer intimement. Il en résulte que les modifications de ces composantes sont difficiles. Notre objectif est de réconcilier ces deux aspects, c'est-à-dire d'ouvrir les fonctionnalités du laboratoire virtuel aux agents tuteurs tout en réduisant le couplage. Nous proposons à cet effet un cadre méthodologique de développement de laboratoires virtuels sous forme d'un modèle générique. Ces laboratoires sont réflexifs aux agents tuteurs et à l'apprenant et peuvent s'intégrer aisément à une architecture de STI à travers une interface de communication qui fait partie du présent travail. La réflexivité permet aux laboratoires virtuels de décrire leurs caractéristiques et leurs fonctionnalités aux agents tuteurs via les ontologies. Elle permet également une adaptation plus facile de ces entités, tout en encapsulant les caractéristiques et les fonctionnalités de chacun

Prévention et détection des interférences inter-aspects (méthode et application à l'aspectisation de la tolérance aux fautes)

La programmation orientée aspects (POA) sépare les différentes préoccupations composant un système informatique pour améliorer la modularité. La POA offre de nombreux bénéfices puisqu'elle permet de séparer le code fonctionnel du code non-fonctionnel améliorant ainsi leur réutilisation et la configurabilitè des systèmes informatiques. La configurabilité est un élément essentiel pour assurer la résilience des systèmes informatiques, puisqu elle permet de modifier les mécanismes de sûreté de fonctionnement. Cependant le paradigme de programmation orientée aspect introduit de nouveaux défis pour le test. Dans les systèmes de grande taille où plusieurs préoccupations non fonctionnelles cohabitent, une implémentation à l'aide d'aspects de ces préoccupations peut être problématique. Partageant le même flot de données et le même flot de contrôle les aspects implémentant les différentes préoccupations peuvent écrire dans des variables lues par d'autres aspects ou interrompre le flot de contrôle commun aux différents aspects empêchant ainsi l'exécution de certains d'entre eux. Dans cette thèse nous nous intéressons plus spécifiquement aux interférences entre aspects dans le cadre du développement de mécanismes de tolérance aux fautes implémentés sous forme d aspects. Ces interférences sont dues à une absence de déclaration de précédence entre les aspects ou à une déclaration de précédence erronée. Afin de mieux maîtriser l assemblage des différents aspects composant un mécanisme de tolérance aux fautes, nous avons développé une méthode alliant l'évitement à la détection des interférences au niveau du code. Le but de l'évitement est d'empêcher l'introduction d'interférences en imposant une déclaration de précédence entre les aspects lors de l'intégration des aspects. La détection permet d'exhiber lors du test les erreurs introduites dans la déclaration des précédences. Ces deux facettes de notre approche sont réalisées grâce à l utilisation d une extension d'AspectJ appelée AIRIA. Les constructions d'AIRIA permettent l instrumentation et donc la détection des interférences entre aspects, avec des facilités de compilation permettant de mettre en œuvre l évitement d interférences. Notre approche est outillée et vise à limiter le temps de déboguage : le testeur peut se concentrer directement sur les points où une interférence se produit. Nous illustrons notre approche sur une étude de cas: un protocole de réplication duplex. Dans ce contexte le protocole est implémenté en utilisant des aspects à grain fin permettant ainsi une meilleure configurabilité de la politique de réplication. Nous montrons que l'assemblage de ces aspects à grain fin donne lieu à des interférences de flot de données et flot de contrôle qui sont détectées par notre approche d'instrumentation. Nous définissons un ensemble d'aspects interférant pour l'exemple, et nous montrons comment notre approche permet la détection d'interférences.Aspect-oriented programming (AOP) separates the different concerns of a computer software system to improve modularity. AOP offers many benefits since it allows separating the functional code from the non-functional code, thus improving reuse and configurability of computer systems. Configurability is essential to ensure the resilience of computer systems, since it allows modifying the dependability mechanisms. However, the paradigm of aspectoriented programming introduces new challenges regarding testing. In large systems where multiple non-functional concerns coexist, an AOP implementation of these concerns can be problematic. Sharing the same data flow and the same control flow, aspects implementing different concerns can write into variables read by other aspects, or interrupt the control flow involving various aspects, and thus preventing the execution of some aspects in the chain. In this work we focus more specifically on interference between aspects implementing fault tolerance mechanisms. This interference is due to a lack of declaration of fine-grain precedence between aspects or an incorrect precedence declaration. To better control the assembly of the various aspects composing fault tolerance mechanisms, we have developed a method combining avoidance of interferences with runtime detection interferences at code level. The purpose of avoidance is to prevent the introduction of interference by requiring a statement of precedence between aspects during the aspects integration. Detection allows exhibiting during the test, errors introduced in the precedence statement. These two aspects of our approach are performed through the use of an extension called AspectJ AIRIA. AIRIA s constructs allow instrumentation and therefore the detection of interference between aspects, with facilities compilation to implement the interference avoidance. Our approach is designed and equipped to limit the debugging time : the tester can focus directly on the points where an interference occurs. Finaly, we illustrate our approach on a case study : a duplex replication protocol. In this context, the protocol is implemented using fine grained aspects allowing a better configurability of the replication policy.We show that the assembly of these fine-grained aspects gives rise to interference data flow and control flow that are detected by our instrumentation approach. We define a set of interfering aspects in this example, and show how our approach allows the detection of interferences.TOULOUSE-INP (315552154) / SudocSudocFranceF

Prévention et détection des interférences inter-aspects : méthode et application à l'aspectisation de la tolérance aux fautes

La programmation orientée aspects (POA) sépare les différentes préoccupations composant un système informatique pour améliorer la modularité. La POA offre de nombreux bénéfices puisqu'elle permet de séparer le code fonctionnel du code non-fonctionnel améliorant ainsi leur réutilisation et la configurabilitè des systèmes informatiques. La configurabilité est un élément essentiel pour assurer la résilience des systèmes informatiques, puisqu’elle permet de modifier les mécanismes de sûreté de fonctionnement. Cependant le paradigme de programmation orientée aspect introduit de nouveaux défis pour le test. Dans les systèmes de grande taille où plusieurs préoccupations non fonctionnelles cohabitent, une implémentation à l'aide d'aspects de ces préoccupations peut être problématique. Partageant le même flot de données et le même flot de contrôle les aspects implémentant les différentes préoccupations peuvent écrire dans des variables lues par d'autres aspects ou interrompre le flot de contrôle commun aux différents aspects empêchant ainsi l'exécution de certains d'entre eux. Dans cette thèse nous nous intéressons plus spécifiquement aux interférences entre aspects dans le cadre du développement de mécanismes de tolérance aux fautes implémentés sous forme d’aspects. Ces interférences sont dues à une absence de déclaration de précédence entre les aspects ou à une déclaration de précédence erronée. Afin de mieux maîtriser l’assemblage des différents aspects composant un mécanisme de tolérance aux fautes, nous avons développé une méthode alliant l'évitement à la détection des interférences au niveau du code. Le but de l'évitement est d'empêcher l'introduction d'interférences en imposant une déclaration de précédence entre les aspects lors de l'intégration des aspects. La détection permet d'exhiber lors du test les erreurs introduites dans la déclaration des précédences. Ces deux facettes de notre approche sont réalisées grâce à l’utilisation d’une extension d'AspectJ appelée AIRIA. Les constructions d'AIRIA permettent l’instrumentation et donc la détection des interférences entre aspects, avec des facilités de compilation permettant de mettre en œuvre l’évitement d’interférences. Notre approche est outillée et vise à limiter le temps de déboguage : le testeur peut se concentrer directement sur les points où une interférence se produit. Nous illustrons notre approche sur une étude de cas: un protocole de réplication duplex. Dans ce contexte le protocole est implémenté en utilisant des aspects à grain fin permettant ainsi une meilleure configurabilité de la politique de réplication. Nous montrons que l'assemblage de ces aspects à grain fin donne lieu à des interférences de flot de données et flot de contrôle qui sont détectées par notre approche d'instrumentation. Nous définissons un ensemble d'aspects interférant pour l'exemple, et nous montrons comment notre approche permet la détection d'interférences. ABSTRACT : Aspect-oriented programming (AOP) separates the different concerns of a computer software system to improve modularity. AOP offers many benefits since it allows separating the functional code from the non-functional code, thus improving reuse and configurability of computer systems. Configurability is essential to ensure the resilience of computer systems, since it allows modifying the dependability mechanisms. However, the paradigm of aspectoriented programming introduces new challenges regarding testing. In large systems where multiple non-functional concerns coexist, an AOP implementation of these concerns can be problematic. Sharing the same data flow and the same control flow, aspects implementing different concerns can write into variables read by other aspects, or interrupt the control flow involving various aspects, and thus preventing the execution of some aspects in the chain. In this work we focus more specifically on interference between aspects implementing fault tolerance mechanisms. This interference is due to a lack of declaration of fine-grain precedence between aspects or an incorrect precedence declaration. To better control the assembly of the various aspects composing fault tolerance mechanisms, we have developed a method combining avoidance of interferences with runtime detection interferences at code level. The purpose of avoidance is to prevent the introduction of interference by requiring a statement of precedence between aspects during the aspects integration. Detection allows exhibiting during the test, errors introduced in the precedence statement. These two aspects of our approach are performed through the use of an extension called AspectJ AIRIA. AIRIA ‘s constructs allow instrumentation and therefore the detection of interference between aspects, with facilities compilation to implement the interference avoidance. Our approach is designed and equipped to limit the debugging time : the tester can focus directly on the points where an interference occurs. Finaly, we illustrate our approach on a case study : a duplex replication protocol. In this context, the protocol is implemented using fine grained aspects allowing a better configurability of the replication policy.We show that the assembly of these fine-grained aspects gives rise to interference data flow and control flow that are detected by our instrumentation approach. We define a set of interfering aspects in this example, and show how our approach allows the detection of interferences

Adaptation en ligne de mécanismes de tolérance aux fautes par une approche à composants ouverts

L'adaptation en-ligne du logiciel de tolérance aux fautes permet de renforce la sûreté de fonctionnement du système et prenant en compte son environnement. L’adaptation nécessite de nouvelles techniques de conception. Ces travaux visent à comprendre et maîtriser l'impact des modifications du logiciel de tolérance aux fautes en opération sur les fonctionnalités du système, pour en maîtriser les effets de bords. L’approche proposée introduit une architecture réflexive à composants et une modélisation du logiciel. Un modèle structurel du logiciel permet de calculer et appliquer les modifications du contenu du logiciel. Un modèle comportemental décrit les observations attendues en fonctionnement. Il permet de déterminer les états permettant d’appliquer les modifications, d’amener et de maintenir le système dans ces états. Ces travaux montrent que, grâce aux capacités de manipulation et de contrôle en ligne du logiciel, la modification des mécanismes de tolérance aux fautes peut être réalisée en ligne de manière maîtrisée. ABSTRACT : On-line fault tolerance adaptation aims at enforcing system dependability by taking into account operational conditions and environment. Adapting the system requires new design techniques. This work aims at understanding and mastering the impact of such software modification in operation, especially regarding side effects on functionalities and dependability properties. Our approach relies on a reflective architecture based on components and models of the software that reflects on the one hand the content of the software in terms of state and algorithms (architectural model) and on the other hand the expected correct behaviour (behavioural model). The first one is used to determine the modifications and apply them at runtime, and the second one is used to drive the system in a state in which modifications can be done consistently, and maintain the system in such a state. We show that; thanks to manipulation capabilities and execution control, we can master the modification of fault tolerance software and ensure correctness properties

Ethics of autonomous information systems towards an artificial thinking

Many projects relies on cognitives sciences, neurosciences, computer sciences and robotics. They concerned today the building of autonomous artificial beings able to think. This paper shows a model to compare the human thinking with an hypothetic numerical way of thinking based on four hierarchies : the information system classification, the cognitive pyramid, the linguistic pyramid and the digital information hierarchy. After a state of art on the nature of human thinking, feasibility of autonomous multi-agent systems provided with artificial consciousness which are able to think is discussed. The ethical aspects and consequences for humanity of such systems is evaluated. These systems lead the scientific community to react.Comment: in Frenc

Adaptation des composants centrée sur l'utilisation

Avec la notion de composant logiciel, la démarche de conception d'applications informatiques a vu apparaître une alternative intéressante à l'approche classique, où le développement est mené selon une approche centralisée. L'idée est en effet de permettre la construction d'applications adaptées aux besoins spécifiques de chaque utilisateur par assemblage de composants préexistants. Néanmoins, le choix de composants prédéfinis, sur étagère, pose le problème de leur adéquation à une utilisation spécifique. Dans ce contexte, la possibilité d'adapter les composants semble cruciale, si l'on souhaite rendre réellement effective l'approche de développement par assemblage de composants. Cette thèse introduit une nouvelle approche de l'adaptation de composants logiciels qui consiste à adapter le composant à ses contextes d'utilisation en se basant sur le point de vue de l'utilisateur. Nous décrivons le profil d'utilisation sous la forme d'un ensemble de triplets dont chacun spécifie les propriétés souhaitées, les réactions correspondantes à traiter dans le cas où une condition n'est pas vérifiée et les échéanciers d'évaluation des propriétés. Nous proposons aussi un service de supervision de composant (SSC) qui repose sur la surveillance de l'état des composants pour obtenir des clichés qui reflètent l'état actuel du composant et les changements récents. Nous définissons également le service de sûreté de service (SSS) qui intercepte les requêtes clientes et qui les délègue vers le composant le plus convenable, tout en gérant l'exécution du composant en fonction du profil d'usage. ABSTRACT : The concept of software component, provides an interesting alternative to the traditional way of designing data-processing applications, where the development is undertaken according to a centralized approach. The idea is indeed to allow the construction of applications adapted to the specific needs for each user by assembling preexistent components. Nevertheless, the choice of off-the-shelf components, raises the problem of their adequacy to a specific use. In this context, the ability to adapt components appears to be crucial, if one wishes to make really effective the approach of development by assembling components. This thesis introduces a new approach of the adaptation of software components which consists in adapting the component to its contexts of use centered on the point of view of the user. We describe a user profile as a set of triples, where each triple specifies the desired properties, the reactions to be run if a condition is not checked and the schedule of evaluation of properties. We propose also a service of supervision of component (SSC) which is based on the monitoring of the state of the components to obtain snapshots which reflect the current state of the component and the recent changes. We also define the service of safety of service (SSS) which intercepts the user requests and delegates them towards the most suitable component, while managing the execution of the component according to the profile of use

Modélisation générique d'un retour d'expérience cognitif. Application à la prévention des risques

Nous avons défini dans cette thèse une architecture logicielle générique permettant de réaliser des applications de retour d'expérience cognitif. Ces derniers intègrent une formalisation de l'analyse experte et sont une alternative aux Systèmes à Bases de Connaissance. Les applications sont opérationnalisées à partir de la définition du modèle de l'expérience qui est basé sur une structure objet simple couplée avec le modèle des croyances transférables pour prendre en compte les intertitudes. Nous avons développé des algorithmes génériques de recherche adaptés à la formalisation retenue de l'entité expérience ainsi qu'un alogorithme d'extraction d'un indicateur du risque. Ces algorithmes sont basés sur une proposition de similarité ensembliste particulière. Le modèle générique est basé sur un modèle adaptatif (Adaptive Object Model). Nous avons appliqué une partie des résultats de la thèse dans le cadre d'un projet Européen INTERREG SUP (Sécurité Urgence Pyrénées)

Modélisation en UML/OCL des langages de programmation et de leurs propriétés et processus IDM

Cette étude est axée sur l'activité de génération de composants logiciels se situant en phase terminale des processus de développement de logiciels dirigés par les modèles. Dans une première partie, nous présentons les travaux de recherche déjà existants sur les modèles et les transformations de modèles, ainsi que sur la modélisation en UML/OCL des langages de programmation limitée, la plupart du temps, aux aspects syntaxiques. Dans une deuxième partie, nous montrons comment nous modélisons en UML/OCL, les propriétés comportementales et axiomatiques des langages de programmation de style impératif. La modélisation des propriétés comportementales et axiomatiques d'un langage, en UML/OCL enrichi d'un langage d'actions, nous amène à montrer comment on peut, à l'aide de triplets de Hoare, vérifier que des segments de modèles de programmes sont corrects. Les assertions déduites des triplets de Hoare par application des propriétés axiomatiques du langage sont transmises à un Atelier B en vue d'étudier leurs éventuelles validités. Dans une troisième partie, nous montrons comment on peut injecter au niveau du Méta-Modèle UML des propriétés comportementales et axiomatiques spécifiques à un domaine d'applications particulier. Nous nous sommes limités au fragment du Méta-Modèle UML définissant les diagrammes d'activité se situant donc en amont des modèles de codes, avant la génération proprement dite des codes. La cohérence entre les modèles et les codes peut se vérifier à l'aide de propriétés comportementales et axiomatiques en comparant les modèles issues des exigences et les modèles des codes. Ces travaux de recherche ont été financés dans le cadre de l'ANR.Our work focuses on the software component generation phase that takes place at the last phase of a model driven development process. Our work is related to either the modelware or the grammarware because the model driven process can be considered as a successive of model transformations whereas the code generation is a specific transformation from the model to a language grammar. In the first part, we resume some relative works in the domain of the models and of the models transformation; we also present the language modeling in UML which is generally restricted by the syntax modeling. In the second part, we show how we model in UML/OCL the behavioral and axiomatic properties of imperative programming languages. The modeling of the behavioral properties helps to execute the code models if we dispose a right execution environment. In the other hand, the modeling of the axiomatic properties helps to demonstrate the correctness of the code model. In fact, the assertions obtained from the modeling of the axiomatic properties of the language will be transferred to a B atelier in order to have further validation. In the third part, we show how we inject into the UML metamodel the considered domain behavioral and axiomatic properties. We focus on the activity diagram metamodel of the UML which defines the behavior part of a UML model. The coherence between the models and the codes can be then verified in comparing the behavioral and axiomatic properties of the models issued from the requirements and that of the codes. Our work is financed by the ANR research projects