Dissertations / Theses on the topic 'Déploiement dirigé par les modèles'

Notre objectif est la fourniture de services Internet basés sur des architectures "n-tiers". Dans notre contexte, ces architectures sont composées de cinq tiers : "équipements", "passerelles", "médiation", "serveur Internet" et "clients finaux". L'appréhension du tiers "passerelle" nécessite l'introduction d'applications à services qui sont destinées à répondre à des requêtes du tiers "médiation" et à collecter et transformer des données provenant du tiers "équipements" qui seront ensuite utilisées par le tiers "médiation" puis manipulées par le tiers "serveur Internet" qui est chargé de leur présentation aux clients finaux. L'introduction de telles applications à services destinées à fonctionner dans des environnements d'exécution à services nécessite la résolution de problématiques propres : <br>- au développement d'applications à services métiers [ML07], <br>- à leur déploiement dans des environnements d'exécution à services (ce qui est l'objectif de cette thèse) [CL07a] <br>- à la gestion dynamique des interactions entre les applications à services et les équipements (dé)- branchés à la passerelle (qui sont exposées comme des services) [EBL+08]. Le cycle de vie logiciel est composé de plusieurs phases. Les principales sont l'analyse, la conception, l'implémentation, le test et le déploiement. Cette dernière est une phase complexe qui est composée d'activités et de sous-activités comme l'installation, l'activation, la désactivation, les mises à jour statique et dynamique, l'évolution, le dynamisme et la désinstallation. L'introduction et l'utilisation de l'approche à service augmente encore la complexité de la phase de déploiement, en particulier lorsqu'il s'agit de déployer des applications à services sur des environnements d'exécution à services. Les enjeux sont, ici : <br>- d'exécuter des activités de déploiement sur les applications tout en respectant l'architecture de chaque application (c'est-à-dire le modèle de chaque application), <br>- de maîtriser l'état de déploiement des (implémentations de) services réalisant ces applications, <br>- d'exécuter des activités de déploiement sur des services appartenant à ces applications en ne touchant que le service ciblé et donc sans impacter entièrement les applications dans leur ensemble. Nous appelons ce dernier enjeu : "déploiement au plus près". Il impose que les unités de développement (c'est-à-dire les composants orientés service contraints) utilisées pour développer les applications et les unités de déploiement (c'est-à-dire les implémentations de services) utilisées pour réaliser les applications aient le même grain. Cette thèse propose un prototype, nommé DMSA (pour Deployment Manager for Services Applications), automatisant le déploiement d'applications à services sur des environnements à services en suivant une approche dirigée par les modèles. L'utilisation de l'approche dirigée par les modèles est une réponse à la constante montée en abstraction du déploiement et de son point d'entrée. Le découplage total entre les niveaux modèles et "réalité" a été choisi afin de permettre la réutilisation des implémentations de services entre modèles de services. Cette thèse explicite notre approche, le méta-modèle pour les applications à services, la définition du déploiement pour les applications à services, l'architecture du DMSA et nos propositions. Ces dernières ciblent le déploiement d'un, puis de plusieurs modèles d'application à services sur un environnement d'exécution à services, le déploiement "transactionnel", l'appréhension de notre contexte embarqué/réactif et l'exécution de listes ordonnées d'activités de déploiement sur des environnements d'exécutions à services.

Notre objectif est la fourniture de services Internet basés sur des architectures "n-tiers". Dans notre contexte, ces architectures sont composées de cinq tiers : "équipements", "passerelles", "médiation", "serveur Internet" et "clients finaux". L'appréhension du tiers "passerelle" nécessite l'introduction d'applications à services qui sont destinées à répondre à des requêtes du tiers "médiation" et à collecter et transformer des données provenant du tiers "équipements" qui seront ensuite utilisées par le tiers "médiation" puis manipulées par le tiers "serveur Internet" qui est chargé de leur présentation aux clients finaux. L'introduction de telles applications à services destinées à fonctionner dans des environnements d'exécution à services nécessite la résolution de problématiques propres : - au développement d'applications à services métiers [ML07], - à leur déploiement dans des environnements d'exécution à services (ce qui est l'objectif de cette thèse) [CL07a] - à la gestion dynamique des interactions entre les applications à services et les équipements (dé)- branchés à la passerelle (qui sont exposées comme des services) [EBL+08]. Le cycle de vie logiciel est composé de plusieurs phases. Les principales sont l'analyse, la conception, l'implémentation, le test et le déploiement. Cette dernière est une phase complexe qui est composée d'activités et de sous-activités comme l'installation, l'activation, la désactivation, les mises à jour statique et dynamique, l'évolution, le dynamisme et la désinstallation. L'introduction et l'utilisation de l'approche à service augmente encore la complexité de la phase de déploiement, en particulier lorsqu'il s'agit de déployer des applications à services sur des environnements d'exécution à services. Les enjeux sont, ici : - d'exécuter des activités de déploiement sur les applications tout en respectant l'architecture de chaque application (c'est-à-dire le modèle de chaque application), - de maîtriser l'état de déploiement des (implémentations de) services réalisant ces applications, - d'exécuter des activités de déploiement sur des services appartenant à ces applications en ne touchant que le service ciblé et donc sans impacter entièrement les applications dans leur ensemble. Nous appelons ce dernier enjeu : "déploiement au plus près". Il impose que les unités de développement (c'est-à-dire les composants orientés service contraints) utilisées pour développer les applications et les unités de déploiement (c'est-à-dire les implémentations de services) utilisées pour réaliser les applications aient le même grain. Cette thèse propose un prototype, nommé DMSA (pour Deployment Manager for Services Applications), automatisant le déploiement d'applications à services sur des environnements à services en suivant une approche dirigée par les modèles. L'utilisation de l'approche dirigée par les modèles est une réponse à la constante montée en abstraction du déploiement et de son point d'entrée. Le découplage total entre les niveaux modèles et "réalité" a été choisi afin de permettre la réutilisation des implémentations de services entre modèles de services. Cette thèse explicite notre approche, le méta-modèle pour les applications à services, la définition du déploiement pour les applications à services, l'architecture du DMSA et nos propositions. Ces dernières ciblent le déploiement d'un, puis de plusieurs modèles d'application à services sur un environnement d'exécution à services, le déploiement "transactionnel", l'appréhension de notre contexte embarqué/réactif et l'exécution de listes ordonnées d'activités de déploiement sur des environnements d'exécutions à services<br>Our goal is to provide Internet services on top of "n-tier" architectures. In our context, these architectures are made of five tiers: devices, gateways, mediation, Internet servers and presentation. Apprehending the gateways tier needs the introduction of services applications to answer the requests of the mediation tier and to collect and transform data from the "devices" tier, these data are then used by the "mediation" tier, next they are manipulated by the "Internet server" tier which is in charge of the displaying to the end users. The introduction of such services applications intended to run in services execution environments raises issues related to: - the development of business-specific services applications [ML07], - their deployment in services execution environments (this is the focus of this thesis) [CL07a] - the dynamic management of interactions between services applications and the devices (un)- plugged to the gateways (these devices are exposed as services in the environments) [EBL+08]. Software lifecycle is made of several phases. The main ones are analysis, conception, implementation, test and deployment. The latter is a complex one; it is made of activities and subactivities like installation, activation, deactivation, static and dynamic updates, evolution, dynamism and deinstallation. The introduction and use of the service approach still raises the deployment phase complexity, in particular when the goal is the deployment of services applications on services execution environments. Stakes, here, are: - to execute deployment activities targeting services applications while respecting each application's architecture (i. E. Each application's model), - to control the deployment state of the services (implementations) realizing these applications, - to execute deployment activities on services belonging to these applications while acting only the targeted service and avoiding to impact the whole applications. We called this last stake: "closely deployment" or "deployment in the small". It imposes that development units (i. E. Constraints service-oriented components) used for developing applications and deployment units (i. E. Services implementations) used for realizing applications have the same (fine) grain. This thesis proposes a software prototype, called DMSA (for Deployment Manager for Services Applications), automating the deployment of services applications on services execution environments while following a model-driven approach. Using a model-driven approach is an answer for the constant rise in abstraction of the deployment phase and of its entry point. The full decoupling between model level and "reality" level has been chosen in order to reuse services implementations between services models. This document clarifies our approach, the services applications meta-model, the services applications deployment definition, the DMSA's software architecture and our propositions. These latter target deployment of several applications models on several services execution environments, "transactional" deployment, our embedded context apprehension and execution of deployment activities ordered lists on services execution environments

Face à la complexité des logiciels multitâches, liée aux contextes économique et concurrentiel très pressants, la portabilité des applications et la réutilisabilité des processus de déploiement sont devenues un enjeu majeur. L'ingénierie dirigée par les modèles est une approche qui aspire répondre à ces besoins en séparant les préoccupations fonctionnelles des systèmes multitâches de leurs préoccupations techniques, tout en maintenant la relation entre eux. En pratique, cela se concrétise par des transformations de modèles capables de spécialiser les modèles pour des plates-formes cibles. Actuellement, les préoccupations spécifiques à ces plates-formes sont décrites implicitement dans les transformations eux même. Par conséquence, ces transformations ne sont pas réutilisables et ne permettent pas de répondre aux besoins hétérogènes et évolutifs qui caractérisent les systèmes multitâches. Notre objectif est alors d'appliquer le principe de séparation de préoccupation au niveau même de la transformation des modèles, une démarche qui garantie la portabilité des modèles et la réutilisabilité des processus de transformation.Pour cela, cette étude propose premièrement une modélisation comportementale détaillée des plates-formes d'exécutions logicielles. Cette modélisation permet d'extraire les préoccupations spécifiques à une plate-forme de la transformation de modèle et les capturer dans un modèle détaillé indépendant et réutilisable. Dans un second temps, en se basant sur ces modèles, elle présente un processus générique de développement des systèmes concurrents multitâches. L'originalité de cette approche réside dans une véritable séparation des préoccupations entre trois acteurs à savoir le développeur des chaînes de transformation, qui spécifient une transformation de modèle générique, les fournisseurs des plates-formes qui fournissent des modèles détaillés de leurs plates-formes et le concepteur des applications multitâche qui modélise le système. A la fin de cette étude, une évaluation de cette approche permet de montrer une réduction dans le coût de déploiement des applications sur plusieurs plates-formes sans impliquer un surcoût de performance.

Les préoccupations inhérentes au domaine de l’embarqué et du temps réel, telle que la maîtrise du temps et des ressources impliquées, dépendent étroitement du support d’exécution. En outre, les besoins de réutilisation des applications sur différents supports d’exécution orientent le développement logiciel vers des conceptions indépendantes de tout support d’exécution. Pour faciliter l’adaptation des applications à ces supports, l’ingénierie dirigée par les modèles (IDM) propose alors une approche qui vise à spécialiser successivement le modèle d’une application pour des technologies précises (identifiées sous le terme de plate-forme), via des processus de transformations de modèles. Toutefois, peu de travaux ont été menés pour préciser comment considérer les plates-formes durant ces processus. Dans un premier temps, les travaux de cette thèse comparent donc différents processus de transformation d’un modèle d’application indépendant du support d’exécution en un modèle dépendant de ce support. Ce comparatif s’articule autour de la considération implicite ou explicite des plates-formes d’exécution de notre domaine d’intérêt (les systèmes d’exploitation temps réel embarqués). Dans un second temps, cette thèse explore une voie dans laquelle la plate-forme d’exécution est explicitement modélisée. Pour cela, un langage dédié à la modélisation des systèmes d’exploitation temps réel embarqués est proposé. Puis, un processus de déploiement d’applications basé sur ce langage est présenté et évalué. L’originalité de ce processus réside dans son articulation autour de règles de transformations génériques ou générées, et d’un langage dédié au déploiement d’applications<br>Real-time and embedded software concerns, such as time and resource usage, are closely related to the execution platform. But the need for reuse leads to design platformindependent software. In order to ease platform integration of the application software, model-driven engeneering (MDE) aims at specializing application model using model transformations. But few works specify how to consider a platform within a transformation. On the one hand, this study compares several processes that transform a platform-independent model of an application into a platform-dependent model. This comparative work focuses on implicit or explicit consideration of real-time and embedded operating systems. On the other hand, this study explores a modeling method where platforms are explicitly described. A domain-specific modeling language (DSML) dedicated to the description of execution platforms is proposed. Then an application deployment process based on this language is introduced and evaluated. The process uses generic or generated transformation rules and a DSML dedicated to the description of application deployment

Le déploiement reste l'une des étapes du cycle de vie des logiciels la moins standardisée et outillée à ce jour. Dans ce travail, nous identifions quatre grands défis à relever pour dé- ployer des systèmes logiciels distribués et hétérogènes. Le premier défi est de réussir à initier le consensus manquant autour d'un langage générique de déploiement de logiciels. Le deuxième défi consiste en la vérification statique de déploiements logiciels décrits dans ce langage pour assurer un déroulement correct avant d'exécuter les opérations de déploiement. Le troisième défi est de réaliser une plate-forme intergicielle capable d'interpréter ce langage et d'effectuer le déploiement de n'importe quel système logiciel réparti. Enfin le quatrième défi est d'appli- quer ces déploiements de systèmes dans les environnements ouverts distribués, c'est-à-dire les réseaux fluctuants et à grande échelle comme les réseaux ubiquitaires ou les grilles de calcul. Notre contribution consiste à définir une démarche de déploiement de systèmes distribués cen- trée sur quatre rôles pour relever ces défis : l'expert réseau, l'expert logiciel, l'administrateur système et l'architecte métier. D'un côté, l'approche DeployWare, conforme à l'ingénierie des modèles, est définie par un méta-modèle multi-rôles pour décrire le déploiement de la couche intergicielle du système ainsi que par une machine virtuelle capable d'exécuter automatique- ment le déploiement de cette couche. L'utilisation d'un langage de méta-modélisation permet d'écrire des programmes de vérification statique des modèles de déploiement. De l'autre côté, l'approche DACAR propose un méta-modèle d'architecture générique pour exprimer et exé- cuter le déploiement d'une application métier à base de composants. Cette double approche DeployWare/DACAR permet de prendre en compte, lors de la description du déploiement, les propriétés des environnements ouverts distribués selon une approche conforme à l'informatique auto-gérée. Notre contribution est validée par plusieurs expériences pour valider la capacité de prise en charge des environnements ouverts ubiquitaires, et pour éprouver l'hétérogénéité des technologies déployables dans le monde des services d'entreprise.

Les travaux présentés dans cette thèse s’inscrivent dans le cadre du développement logiciel des systèmes temps réel embarqués. Nous définissons dans ce travail une méthodologie nommée DRIM. Cette méthodologie permet de guider le déploiement des applications temps réel sur différents RTOS en suivant la ligne de l’IDM et en assurant le respect des contraintes de temps après le déploiement. L’automatisation de la méthodologie DRIM montre sa capacité à détecter les descriptions non-implémentables de l’application, réalisées au niveau conception, pour un RTOS donné, ce qui présente l’avantage de réduire le temps de mise sur le marché d’une part et de guider l’utilisateur pour un choix approprié de l’RTOS cible d’autre part<br>The main purpose of this Phd is to contribute to the software development of real-time embedded systems. We define in this work a methodology named DRIM: Design Refinement toward Implementation Methodology. This methodology aims to guide the deployment of a real-time application on to different RTOS while respecting MDE principals and ensuing that the timing properties are still met after deployment. The automation of DRIM shows its ability to detect non-implementable design models describing the real-time application, on aparticular RTOS, which permits to reduce the time-to-market on the one hand and guide the user to the selection of the appropriate RTOS from the other hand

Nous présentons FieSta, une approche basée sur les idées de l'ingénierie dirigée par les modèles pour créer des lignes de produits logiciels. Dans les approches dirigées par les modèles pour créer lignes de produits logiciels, la dérivation d'un produit commence par un modèle d'application du domaine. Ce modèle est transformé en plusieurs étapes en utilisant des règles de transformation de modèles, jusqu'à ce qu'un produit final soit obtenu. Les règles de transformations sont choisies selon les variantes incluses dans les congurations créés par le concepteur des produits. Les congurations comportent des variantes associées des points de variation, qui sont des caractéristiques représentant la variabilité d'un ligne de produit. FieSta (1) fournit des mécanismes pour améliorer l'expression de la variabilité des lignes de produits dirigées par les modèles en permettant des concepteurs de créer des congurations grain des produits, et (2) intègre un processus de dérivation des produits qui emploie des modèles de décision et la programmation dirigé par les aspects pour faciliter la réutilisation, l'adaptation et la composition des règles de transformation des modèles. Nous présentons les modèles de contraintes qui permettent aux architectes du produit de capturer le domaine des produits en utilisant les concepts de contrainte, de propriété de cardinalité et de propriété de dépendance structurale. Pour congurer les produits, nous créons les modèles de domaine et les modèles de décision, qui sont des ensembles de liens entre des éléments et des variantes et satisfont les modèles de contraintes. Nous définissons un modèle de décision comme un ensemble d'aspects au sens de la programmation par aspects. Un aspect mémorise l'information concernant quand, où et comment intercepter une règle de transformation produisant la base commune du produit. Ces aspects détectent les points de jonctions ou de nouvelles règles de transformation, gérant la variabilité, doivent être exécutées. Notre stratégie maintient la création des variantes découplé des règles de transformation pour les parties communes. Ceci résout des problèmes liés la modularisation, l'appariement, la exibilité et la maintenance des règles de transformations. Parce que les règles communes sont complètement séparées des variantes, elles peuvent plus facilement évoluer indépendamment<br>We present FieSta, an approach based on Model-Driven Development ideas to create Software Product Lines (SPLs). In Model-Driven SPL approaches, the derivation of a product starts from a domain application model. This model is transformed through several stages reusing model transformation rules until a product is obtained. Transformations rules are selected according to variants included in congurations created by product designers. Congurations include variants from variation points, which are relevant characteristics representing the variability of a product line. FieSta (1) provides mechanisms to improve the expression of variability of Model-Driven SPLs by allowing designers to create ne-grained congurations of products, and (2) integrates a product derivation process which uses decision models and Aspect-Oriented Programming facilitating the reuse, adaptation and composition of model transformation rules. We introduce constraint models which make it possible for product line architects to capture the scope of product lines using the concepts of constraint, cardinality property and structural dependency property. To congure products, we create domain models and binding models, which are sets of bindings between model elements and variants and satisfy the constraint models. We dene a decision model as a set of aspects. An aspect maintains information of when transformation rules that generate commonalities of products must be intercepted (joinpoints) and what transformation rules (advices) that generate variable structures must be executed instead. Our strategy maintains uncoupled variants from model transformation rules. This solves problems related to modularization, coupling, exibility and maintainability of transformations rules because they are completely separated from variants; thus, they can evolve independently

En France, comme dans l'ensemble des pays développés, le même constat est dressé : la population vieillit. Cette évolution démographique sans précédent dans l'histoire de l'humanité pose un certain nombre d'enjeux économiques et sociaux liés à la prise en charge des personnes âgées dépendantes et/ou en situation de handicap, dont le nombre augmente considérablement au fil des ans. Le nombre d'aidants potentiels ne pouvant augmenter en conséquence, il faut penser dès aujourd'hui à des solutions alternatives pour permettre à ces personnes de garder un niveau d'autonomie suffisant leur permettant de rester dans leur environnement domestique préféré le plus longtemps possible. Les systèmes domotiques, qui regroupent l'ensemble des technologies de l'informatique, de l'électronique et des télécommunications au sein d'un habitat, permet d'y apporter des solutions technologiques. Dans ces travaux, nous proposons un flot de conception dirigé par les modèles pour la commande et la supervision de systèmes domotiques d'assistance. Dans un premier temps, nous cherchons à intégrer une personne non-experte en domotique (e.g. membre de la famille / aidant, ergothérapeute) dans certaines étapes de la conception pour une meilleure prise en compte des besoins de personnes en situation de handicap mais aussi pour limiter l'intervention relativement coûteuse de l'expert. Pour cela, nous proposons un langage de modélisation (DSML : Domain Specific Modeling Language) permettant de décrire un système domotique en manipulant des concepts à un haut niveau d'abstraction. Ce DSML est composé de deux vues : une vue physique pour représenter l'environnement domotique et une vue fonctionnelle pour définir les interactions entre l'utilisateur et son système domotique. Dans cette dernière vue, deux types d'interactions sont définis pour prendre en compte un nombre de besoins utilisateur le plus grand possible. Ainsi, il est possible de définir des requêtes de différents types (i.e. services) comme des interdictions temporaires (i.e. modes) sur des ressources domotiques. À partir des modèles définis à l'aide de ce langage, notre flot de conception permet de générer la partie commande à l'aide de transformations de modèles successives. Une évaluation sur le cas d'étude des appartements tremplins du centre de Kerpape avec des étudiants puis des ergothérapeutes permet d'avoir des retours intéressants sur l'utilisabilité du DSML et du flot de conception proposé. Dans un deuxième temps, nous cherchons à offrir une solution alternative aux approches de supervision basées sur l'utilisation massive de capteurs, qui peut parfois être problématique lorsque l'on s'intéresse à l'acceptabilité de la solution par l'utilisateur (coût, intrusivité). Nous proposons pour cela d'intégrer dans le flot de conception un modèle de supervision non-intrusif basé sur une ontologie pour représenter les interactions utilisateur-système. Contrairement aux solutions existantes, ce modèle n'est pas basé sur des données de capteurs, mais sur l'analyse sémantique des commandes domotiques envoyées par l'utilisateur. L'ontologie et les règles qui lui sont associées permettent à un moteur d'inférences d'extraire des informations habituellement captées : suivant la manière dont l'utilisateur interagit avec son système domotique, sa localisation et son intention peuvent être déduites par inférences logiques, permettant d'aboutir à la proposition de services contextuels. Une évaluation sur les jeux de données de l'appartement Domus permet de montrer l'intérêt d'une telle approche tant pour limiter l'utilisation de capteurs que pour augmenter la sûreté de fonctionnement par redondance d'informations. Une partie de ces travaux est reprise dans le cadre du projet ASIM porté par l'entreprise Vity Technology. La syntaxe concrète (i.e. représentation graphique) du langage de modélisation sera notamment retravaillé dans un but de commercialisation.

Les applications de Réalité Virtuelle (RV) requièrent une puissance de calcul importante qui peut être apportée par des architectures distribuées telles que les grappes de PC, des ensembles d'ordinateurs connectés par des réseaux performants, qui présentent des avantages en terme de coût, d'évolutivité et de puissance de calcul sur les calculateurs spécialisés traditionnellement utilisés. Afin d'exploiter la puissance de ces architectures, une approche consiste à décomposer les applications en plusieurs composants qui sont ensuite déployés sur les différentes machines. Les performances de telles applications dépendent alors des performances des matériels ainsi que des synchronisations entre les différents composants. Evaluer les performances d’une application de RV selon un déploiement donné consiste ensuite à observer si son exécution permet l'interactivité. Si ce n’est pas le cas il faut alors envisager un autre déploiement. Cependant, cette recherche d'un déploiement répondant à ce critère par succession d’essais et d’erreurs est longue et fastidieuse et monopolise l'utilisation de l'architecture. Afin de réduire le temps d’élaboration d’un déploiement efficace, nous proposons de définir et d’utiliser un modèle de performance basé sur la modélisation de l’architecture, de l’application et de son déploiement. Dans un second temps, nous proposons d’utiliser la programmation par contraintes pour assister ou automatiser la résolution de notre problème de déploiement à partir de contraintes issues de notre modèle, des caractéristiques de l’architecture, et des performances attendues par l’utilisateur. Cette approche permet ainsi de répondre aux nombreuses questions que peut se poser un développeur : Existe t'il un ou plusieurs déploiements de mon application permettant l'interactivité sur mon architecture ? Si oui, quels sont ils ? L'ajout de machines supplémentaires permet il un gain de performances ?

La construction d'applications par composition d'éléments existants permet de réduire le temps de développement des applications ; pour cette raison, c'est un thème central du génie logiciel. On peut trouver quatre types de composition proposés par les approches actuelles : l'intégration, la connexion, la coordination et l'orchestration. Tandis que l'intégration et la connexion se basent sur les liens directs liant les éléments à composer, la coordination et l'orchestration utilisent une architecture à deux niveaux dans laquelle la logique de composition est exprimée séparément. Cette thèse propose un modèle de composition, basé sur la coordination, où la réutilisation, l'évolution et l'adaptation sont les objectifs premiers. Le concept de domaine est proposé pour représenter un groupe d'éléments coordonnés fournissant une fonctionnalité clairement identifiée par un modèle conceptuel. La composition de domaines est effectuée en établissant des relations entre les concepts provenant des modèles conceptuels de ces domaines. Une fédération est introduite comme une architecture logicielle permettant la structuration des domaines et la composition de domaines. La composition de domaines est réalisée par la synchronisation de domaines à travers un espace partagé et contrôlé (univers commun) contenant la matérialisation des modèles conceptuels des domaines composés ainsi que des relations liant leurs concepts. Les environnements pour la conception, le développement, l'exécution et l'administration d'une fédération ont été réalisés, et plusieurs applications ont été construites afin de valider l'approche proposée dans cette thèse.

La syntaxe Arden est un standard de représentation de la connaissance médicale destiné à l'exécution automatique de règles par des systèmes d'aide à la décision Ce standard reste cependant peu implémenté (manque d'implémentations, d'intégrations). Ce travail propose de décrire une approche basée sur un noyau appelé Environnement Système Arden (ESA), avec des spécifications pour l'intégration à un système d'information. Les modules spécifiques au CHU Henri Mondor seront décrits, ainsi que les différentes stratégies d'intégration. Enfin sera décrite l'implémentation d'un système appelé "serveur d'alerte", qui ajoute à l'ESA une base de données acceptant des documents XML, des éléments hiérachiques, de multiples nomenclatures, et de nouvelles syntaxes pour les requêtes données. L'utilisation de ces nouveaux formalismes permet d'augmenter l'étendue des inférences qu'il est possible de réaliser avec la Syntaxe Arden, sans recours aux systèmes utilisant des règles de production.

Aujourd'hui, les applications automobiles sont devenues de plus en plus complexes avec des ressources limitées et plus de contraintes de temps et de safety. La vérification temporelle est effectuée très tard aujourd'hui au cours du processus de développement automobile (après l'implémentation et au cours de la phase d'intégration). Pour apporter des solutions aux problèmes du développement logiciel automobile, plusieurs approches de développement dirigé par les modèles ont été définit. Ces approches donnent des langages, des concepts et des méthodologies pour la description de l'architecture des systèmes automobiles. Cependant, ces approches ne donnent aucun guide méthodologique pour intégrer l'analyse temporelle (notamment l'analyse d'ordonnancement) tout au long du processus de développement. Ce travail de thèse propose de développer une méthodologie décrivant un processus d'analyse temporelle dirigé par les modèles. Cette méthodologie décrit les différentes phases du processus de développement dirigé par les modèles et comment l'analyse temporelle est effectuée durant chaque phase.

Nos travaux de thèse portent sur la modélisation et la simulation à base d'agents de systèmes complexes, appliquées au phénomène de propagation de la Schistosomose. Plus particulièrement, nous nous sommes intéressés aux aspects spatiaux et sociaux de la propagation de cette maladie, en utilisant une approche de couplage de modèles à base d'agents. En effet, nous avons initialement étudié la modélisation mathématique de la Schistosomose et la complexité du phénomène de sa propagation. Ce qui nous a permis d'identifier deux dynamiques épidémiologiques (dynamiques spatiale et sociale) sous-jacentes à la propagation de la Schistosomose pour lesquelles, les modèles mathématiques présentent des limites. Cette problématique nous a poussés à étudier isolément ces deux dynamiques et à proposer un modèle multi-agents pour chacune d'elles. Ces deux modèles à base d'agents, représentant deux dynamiques complémentaires d'un même système, ont été implémentés selon des formalismes et des plateformes différentes : un modèle dans GAMA, une plateforme de simulation à base d'agents ; et un autre dans JASON, une plateforme de programmation d'agents BDI (Belief, Desire, Intention). Le modèle GAMA implémente l'aspect comportemental (pour la dynamique spatiale) qui se penche sur la réactivité des individus face à l'environnement physique et le suivi de l'infection. Le modèle JASON implémente l'aspect décisionnel (pour la dynamique sociale) qui introduit la dimension cognitive et mentale des individus en assurant leur capacité de décision et de sélection qui sont déterminées par leur environnement social, culturel, économique, etc. Pour assurer la composition des deux modèles, nous avons proposé une solution de couplage (par Co-simulations) des deux plateformes GAMA et JASON. Nous avons finalement expérimenté le modèle avec un cas de dynamique de propagation de la maladie à Niamey (au Niger) pour lequel les données étaient accessibles<br>Our thesis work focuses on agent-based modeling and simulation of complex systems, applied to the spread of schistosomiasis. Specially, we were interested in the spatial and social aspects of the spread of the disease, using an agent-based coupling approach of models.Indeed, we initially studied the mathematical modeling of schistosomiasis and the complexity of its propagation, which allowed us to identify two epidemiological dynamics (spatial and social dynamics) underlying the spread of schistosomiasis for which mathematical models have limits. This problematic led us to study separately these two dynamics and propose an agent-based model for each. These two agent-based models, representing two complementary dynamics of a system, were implemented according different formalisms and different platforms: one model on GAMA (an agent-based simulation platform); and another on JASON (a programming platform of BDI agents). The GAMA model implements the behavioral aspect (for the spatial dynamic) that focuses on individuals reactivity with regards to the physical environment, and the monitoring of the infection. The JASON model implements the decisional aspect (for the social dynamic) that introduces the cognitive and mental dimension of individuals, ensuring their decision and selection capacities which are determined by their social, cultural and economic environment. To ensure the composition of the two models, we proposed an agent-based coupling solution (co-simulation) of the two platforms (GAMA and JASON). We finally experienced the model with a case of dynamic spread of the disease in Niamey (Niger) for which data were available

L'Internet des Objets (IdO) couvre peu à peu tous les aspects de notre vie. À mesure que ces systèmes deviennent plus répandus, le besoin de gérer cette infrastructure complexe comporte plusieurs défis. En effet, beaucoup de petits appareils interconnectés fournissent maintenant plus d'un service dans plusieurs aspects de notre vie quotidienne, qui doivent être adaptés à de nouveaux contextes sans l'interruption de tels services. Cependant, ce nouveau système informatique diffère des systèmes classiques principalement sur le type, la taille physique et l'accès des nœuds. Ainsi, des méthodes typiques pour gérer la couche logicielle sur de grands systèmes distribués comme on fait traditionnellement ne peuvent pas être employées dans ce contexte. En effet, cela est dû aux capacités très différentes dans la puissance de calcul et la connectivité réseau, qui sont très contraintes pour les appareils de l'IdO. De plus, la complexité qui était auparavant gérée par des experts de plusieurs domaines, tels que les systèmes embarqués et les réseaux de capteurs sans fil (WSN), est maintenant accrue par la plus grande quantité et hétérogénéité des logiciels et du matériel des nœuds. Par conséquent, nous avons besoin de méthodes efficaces pour gérer la couche logicielle de ces systèmes, en tenant compte les ressources très limitées. Cette infrastructure matérielle sous-jacente pose de nouveaux défis dans la manière dont nous administrons la couche logicielle de ces systèmes. Ces défis peuvent entre divisés en : Intra-nœud, sur lequel nous faisons face à la mémoire limitée et à la puissance de calcul des nœuds IdO, afin de gérer les mises à jour sur ces appareils ; Inter-noeud, sur lequel une nouvelle façon de distribuer les mises à jour est nécessaire, en raison de la topologie réseau différente et le coût en énergie pour les appareils alimentés par batterie ; En effet, la puissance de calcul limitée et la durée de vie de chaque nœud combiné à la nature très distribuée de ces systèmes, ajoute de la complexité à la gestion de la couche logicielle distribuée. La reconfiguration logicielle des nœuds dans l'Internet des objets est une préoccupation majeure dans plusieurs domaines d'application. En particulier, la distribution du code pour fournir des nouvelles fonctionnalités ou mettre à jour le logiciel déjà installé afin de l'adapter aux nouvelles exigences, a un impact énorme sur la consommation d'énergie. La plupart des algorithmes actuels de diffusion du code sur l'air (OTA) sont destinés à diffuser un microprogramme complet à travers de petits fragments, et sont souvent mis en œuvre dans la couche réseau, ignorant ainsi toutes les informations de guidage de la couche applicative. Première contribution : Un moteur de modèles en temps d'exécution représentant une application de l'IdO en cours d'exécution sur les nœuds à ressources limitées. La transformation du méta-modèle Kevoree en code C pour répondre aux contraintes de mémoire spécifiques d'un dispositif IdO a été réalisée, ainsi que la proposition des outils de modélisation pour manipuler un modèle en temps d'exécution. Deuxième contribution : découplage en composants d'un système IdO ainsi qu'un algorithme de distribution de composants efficace. Le découplage en composants d'une application dans le contexte de l'IdO facilite sa représentation sur le modèle en temps d'exécution, alors qu'il fournit un moyen de changer facilement son comportement en ajoutant/supprimant des composants et de modifier leurs paramètres. En outre, un mécanisme pour distribuer ces composants en utilisant un nouvel algorithme appelé Calpulli est proposé<br>The Internet of Things (IoT) is covering little by little every aspect on our lives. As these systems become more pervasive, the need of managing this complex infrastructure comes with several challenges. Indeed, plenty of small interconnected devices are now providing more than a service in several aspects of our everyday life, which need to be adapted to new contexts without the interruption of such services. However, this new computing system differs from classical Internet systems mainly on the type, physical size and access of the nodes. Thus, typical methods to manage the distributed software layer on large distributed systems as usual cannot be employed on this context. Indeed, this is due to the very different capacities on computing power and network connectivity, which are very constrained for IoT devices. Moreover, the complexity which was before managed by experts on several fields, such as embedded systems and Wireless Sensor Networks (WSN), is now increased by the larger quantity and heterogeneity of the node’s software and hardware. Therefore, we need efficient methods to manage the software layer of these systems, taking into account the very limited resources. This underlying hardware infrastructure raises new challenges in the way we administrate the software layer of these systems. These challenges can be divided into: intra-node, on which we face the limited memory and CPU of IoT nodes, in order to manage the software layer and ; inter-node, on which a new way to distribute the updates is needed, due to the different network topology and cost in energy for battery powered devices. Indeed, the limited computing power and battery life of each node combined with the very distributed nature of these systems, greatly adds complexity to the distributed software layer management. Software reconfiguration of nodes in the Internet of Things is a major concern for various application fields. In particular, distributing the code of updated or new software features to their final node destination in order to adapt it to new requirements, has a huge impact on energy consumption. Most current algorithms for disseminating code over the air (OTA) are meant to disseminate a complete firmware through small chunks and are often implemented at the network layer, thus ignoring all guiding information from the application layer. First contribution: A models@runtime engine able to represent an IoT running application on resource constrained nodes. The transformation of the Kevoree meta-model into C code to meet the specific memory constraints of an IoT device was performed, as well as the proposition of modelling tools to manipulate a model@runtime. Second contribution: Component decoupling of an IoT system as well as an efficient component distribution algorithm. Components decoupling of an application in the context of the IoT facilitates its representation on the model@runtime, while it provides a way to easily change its behaviour by adding/removing components and changing their parameters. In addition, a mechanism to distribute such components using a new algorithm, called Calpulli is proposed

Intégrés dans un projet de développement d'un système multit-robots de neurochirurgie mini-invasive pour l'ablation de tumeurs, ces travaux ont pour objectif la conception et modélisation d'un robot déployable dans le cerveau, selon des trajectoires curvilignes, sans espace libre autour de sa structure et sans guide naturel pour aider à sa progression. Après définition de la tâche de déploiement, un état de l'art recense un large panel de concepts et une évaluation sélectionne un concept continu bio-inspiré des trompes d'éléphant. La solution modulaire du robot est définie et modélisée géométriquement en associant une chaîne cinématique aux mobilités continues du robot. Une statégie de déploiement, reposant sur une succession ordonnée d'extensions/rétractions locales pour une élongation itérative du robot est formalisée pour le cas générique à N modules, puis validée par des plans de simulations de robots ayant 1 à 3 modules (erreur de suivi inférieure à un mm). Sur un modèle d'étude de gels d'agar (texture proche du cerveau), les efforts de pénétration du robot dans le cerveau sont estimés, puis la conception CAO et la programmation d'un démonstrateur à ressorts sont réalisées. Une interface homme/machine, simulant et commandant le robot, est programmée et des tests sont effectués pour valider certains aspects du déploiement. Un deuxième démonstrateur actionné pneumatiquement est à finaliser pour procéder à une étude comparative des deux prototypes. Même si des perspectives d'amélioration restent à explorer, les résultats obtenus sont encourageants. Un travail collaboratif entre spécialistes de différents domaines devrait conduire à l'optimisation de ce robot de déploiement.

The major problem addressed in this thesis is the definition of a new SPLE methodology that covers both phases of the SPLE process and focuses on the derivation of behavioral models of SPL products. In Chapter 2 three research areas scope context of this thesis: Software Product Lines, Business Processes, and Model-Driven Engineering. Throughout Chapter 3, we propose a new SPLE methodology that focuses on the derivation of product behavior. We first describe the main flow of the methodology, and then detail the individual steps. In chapter 4 we propose a new domain specific language called CBPF created for modeling composable business process fragments. A model driven approach is followed for creating CBPF: definition of the abstract syntax, graphical concrete syntax and translational semantics. In Chapter 5 we propose several types of verifications that can be applied to business processfragments to determine their "correctness". For structural verification we definine a set of fragment consistency rules that should be valid for every business process fragment created with CBPF. To check behavioral correctness we first transform the business process fragment into an equivalent HCPN. We can then check generic properties but also define aset of fragment specific properties. In chapter 6 we exemplify the proposed SPL methodology by applying it to a case study from the crisis management system domain. We also propose a tool suite that supports our methodology. Chapter 7 describes possible improvements and extensions to the contributions of this thesis. We conclude the thesis in Chapter 8 and draw some conclusions.

Les organisations sont fortement dépendantes de leurs logiciels dans l'exercice de leurs activités quotidiennes. Malheureusement, les changements répétés qui sont appliqués à ces systèmes rendent leur évolution difficile. Cette évolution peut être rendue nécessaire afin de maintenir le logiciel, de le remplacer ou de le moderniser. Dans le cas de systèmes légataires complexes et mal documentés, la modernisation est la seule solution réalisable afin d'atteindre les objectifs d'évolution, le but de la modernisation étant de faire évoluer un système lorsque les pratiques conventionnelles ne le permettent plus. Mais, il s'agit d'une tâche complexe. Notamment, la prévision des risques et des coûts est difficile. Afin de faire face aux difficultés de la modernisation, l'OMG a créé l'initiative « Architecture-Driven Modernization » ADM qui propose entre autres de réaliser la modernisation par l'ingénierie dirigée par les modèles (IDM). Dans ce contexte, la modernisation d'un système légataire, non développé dans un environnement IDM, débute par sa migration vers ce type d'environnement. Ce qui pose la problématique de la découverte des modèles nécessaires à l'utilisation d'IDM représentant ce système. Une seconde problématique est que le processus IDM manque de précision au sujet des modèles à employer et de l'application des transformations pour passer d'un à l'autre. Dans cette thèse, nous présentons une nouvelle approche de modernisation ADM afin d'utiliser l'IDM pour moderniser un système légataire non IDM. Nous y définissons les modèles nécessaires et les transformations à réaliser pour passer d'un à l'autre. La plate-forme d'implémentation y est représentée par deux modèles. Le premier est un profil UML décrivant ses concepts et le second est un ensemble de modèles de transformations paramétrés capturant son code d'infrastructure. Le modèle représentant les éléments du domaine du problème prend la forme d'un diagramme de classes UML. Aussi, nous proposons des algorithmes pour la découverte de ces modèles en analysant le code source du système légataire. Notre approche a été validée sur plusieurs systèmes écrits en Java et a donné de bons résultats pour les systèmes bien structurés avec un bon style de programmation. ______________________________________________________________________________

La construction de logiciels par coordination d'applications existantes et autonomes permet de réaliser des logiciels de grande taille, réutilisant le savoir-faire contenu dans ces applications. Les procédés, utilisés dans différents domaines et de différentes manières pour coordonner des applications ou des humains, se présentent comme étant de bons candidats pour réaliser ces coordinations. Cependant, la plupart des procédés sont rigides, fortement couplés, et se basent sur un grand nombre de concepts spécialisés. Ils sont aussi souvent réservés à une catégorie d'applications. Nous présentons les points forts et les points faibles des formalismes et moteurs de procédés actuels et nous en déduisons quels sont les besoins pour la coordination d'applications via un procédé. <br /><br />Nous présentons dans cette thèse l'environnement réalisé dans notre équipe qui propose une architecture des logiciels à trois couches : conceptuelle, médiateur, et outils. Le niveau conceptuel contient un meta-modèle qui ne définit que les concepts basiques des procédés. Nous définissons ensuite quatre classes d'extension de ce meta-modèle minimal. Notre environnement permet alors de construire et exécuter des logiciels basés sur des procédés de coordination extensibles et évolutifs.