Cette thèse propose une extension de la logique de séparation pour les programmes parallèles et orientés-objets. La logique de séparation est un formalisme récent et prometteur pour vérifier les programmes impératifs. Cependant, jusqu'à présent, la logique de séparation a été appliquée à des programmes utilisant un opérateur parallèle irréaliste (||) et des verrous non-ré-entrants (contrairement au langage Java). Dans cette thèse, nous adaptons la logique de séparation aux opérateurs "fork" et "join" (utilisés par de nombreux langages: C, Java, etc...) et aux verrous ré-entrants (utilisés par le langage Java).<br /><br />Cette adaptation inclut un système de vérification pour des programmes similaires aux programmes Java. Ce système est constitué d'un ensemble de triplets de Hoare qui forment un algorithme de vérification. La preuve de correction de ce système a été effectuée et ce système a été évalué sur plusieurs exemples ambitieux (dont la classe Itérateur de la librairie Java et un algorithme de couplage de verrous).<br /><br />En plus de l'extension décrite ci-dessus, plusieurs analyses utilisant la logique de séparation ont été inventées.<br /><br />La première analyse consiste à spécifier les séquences d'appels de méthodes autorisées (appelés "protocoles") dans les classes. Cette analyse décrit finement des protocoles complexes (telle que celui de la classe Itérateur). En outre, nous avons proposé une nouvelle technique permettant de vérifier que les spécifications d'un programme sont correctes en utilisant les protocoles.<br /><br />La seconde analyse permet de montrer qu'une formule en logique de séparation n'implique pas une autre formule. Cela est utile dans les vérificateurs de programmes car ceux-ci doivent fréquemment démontrer des implications entre formules. L'intérêt de cette analyse est que sa complexité est basse : cela permet de l'utiliser souvent sans consommer beaucoup de ressources.<br /><br />La troisième analyse permet de paralléliser automatiquement des programmes. Cette analyse prend en entrée des programmes prouvés en logique de séparation et rend en sortie des programmes parallélisés, optimisés, et prouvés. Notre analyse utilise la sémantique de séparation de l'opérateur "*" pour détecter quand deux sous programmes accèdent à des parties disjointes du tas. Dans ce cas, la parallélisation est possible. L'algorithme de détection est implémenté par un système de réécriture.

Ce travail montre que l'introduction de contraintes dans un modèle de connaissances à objets permet d'en accroître à la fois l'expressivité (les contraintes sont des énoncés déclaratifs de relations entre attributs) et les capacités d'inférence (la maintenance et la résolution des contraintes sont chargées de la cohérence et de la complétion des bases de connaissances). Les répercussions de la présence de contraintes au sein d'un tel système sont également étudiées. Les attributs contraints sont désignés à l'aide de la notion d'accès, qui étend la notion classique de chemin au traitement des attributs multivalués (dont la valeur est un ensemble ou une liste de valeurs). Les niveaux de représentation considérés (concept, classe, instance) définissent la portée d'une contrainte comme l'ensemble des objets sur lesquels elle doit être posée, et induisent alors entre eux un héritage de ce trait descriptif. De même, le maintien d'un certain degré de consistance locale sur les domaines des attributs exige une gestion interne de leurs types. Vis-a-vis des mécanismes d'inférence du modèle (instanciation, classification, procédures, etc.), un comportement adapté des contraintes est établi, qui ne remet pas en cause la sémantique de ces mécanismes. Ces principes d'intégration ont été validés dans le modèle de connaissances à objets Tropes. Nous avons réalisé un module de programmation par contraintes, appelé Micro, qui est semi-faiblement couplé à Tropes. Micro répond à de nombreuses exigences de la représentation de connaissances par objets, en gérant la maintenance et la résolution de Problèmes de Satisfaction de Contraintes (CSP) dynamiques, définis sur des variables numériques, booléennes, ou multivaluées, dont les domaines sont finis ou infinis. L'intégration qui a été réalisée autorise, en outre, l'utilisation de la puissance expressive et calculatoire des contraintes par le système de représentation de connaissances lui-même. Ainsi, la présence des contraintes permet d'étendre et de contrôler la sémantique de notions diverses et évoluées comme celles d'objet composite, de tâche, de relation, ou encore de filtre.

Cette thèse s'inscrit dans le domaine des bases de données orientées objet ; elle propose des solutions pour décrire et manipuler des bases de données intégrant des versions. Le concept de version est nécessaire dans de nombreux domaines d'application comme la gestion de documentations techniques, la conception assistée par ordinateur et le génie logiciel. Les versions permettent notamment de conserver et manipuler l'évolution des entités du monde réel gérées dans de tels domaines. Différentes gestions de versions sont possibles. Certains travaux gèrent des versions de base ou d'une partie de base pour décrire l'évolution globale d'une base de données ; notre étude s'intéresse, quant à elle, à la représentation de l'évolution de chaque entité décrite dans la base, de manière indépendante. Nous proposons, d'une part, un modèle conceptuel intégrant la gestion de versions d'objets et de classes. Les relations de composition et d'association, dont la sémantique est affinée à l'aide de cardinalités, intègrent les versions pour des entités complexes. De telles relations, incluant les versions, induisent des contraintes d'intégrité structurelle complexes, dont nous faisons l'étude. D'autre part, nous proposons un langage pour manipuler ce type de bases de données. Ce langage permet notamment une interrogation de type Select From Where qui prend en compte les spécificités liées aux versions ; les différents niveaux d'abstraction liés aux versions c'est-à-dire les forêts de dérivation, les arbres et les versions, peuvent être exploités lors d'une interrogation. Une réalisation du modèle et du langage est effectuée au sein d'un prototype. Ce prototype est une interface destinée à des utilisateurs occasionnels, en permettant de manipuler graphiquement une base de données intégrant des versions.

Ce travail de thèse présente la conception et la mise en œuvre de méthodes innovantes d'évaluation quantitative et automatique de la qualité des outils de planification géométrique des traitements en radiothérapie externe. Le contrôle de qualité des systèmes de planification des traitements (TPS) est obligatoire en France et dans le monde de par les risques encourus, mais les outils physiques<br />recommandés pour mener à bien ce contrôle de qualité sont inadaptés. Nous présentons une nouvelle méthodologie de contrôle qualité basée sur la définition d'Objets-Tests Numériques (OTN) qui sont directement introduits dans le TPS sans passer par le capteur. Ces objets numériques sont définis à la fois sous des représentations continues et discrètes cohérentes. Les réponses des TPS aux OTN d'entrée sont comparées aux résultats théoriques grâce à des figures de mérite spécifiquement définies pour chaque type de données. Ce procédé permet alors d'évaluer quantitativement et automatiquement la qualité des TPS. Les tests effectués au cours de ce travail ont permis de valider nos solutions de contrôle qualité pour les outils de contourage automatique, d'expansion et d'érosion automatiques, de positionnement de l'isocentre, de conformation du collimateur, de génération des radiographies digitales reconstruites, de positionnement des marqueurs cutanés, ainsi que pour la rotation du collimateur, l'incidence, la divergence et les dimensions des faisceaux affichés. Les solutions d'assurance qualité des TPS que nous proposons dans ce travail sont donc rapides et efficaces d'une part (aucune acquisition par le capteur source, manipulations réduites), et plus précises d'autre part, de par l'équivalence continue-discrète mise en place à la source de la modélisation.

Les applications coopératives mettent en jeu des interactions complexes entre les différents éléments qui les composent. L'environnement utilisé pour leur programmation doit donc offrir les mécanismes nécessaires à la réalisation de ces interactions. Le choix d'un environnement à objets pour cette mise en œuvre revêt de nombreux avantages, relatifs aux caractéristiques canoniques des modèles à objets (notion d'interface, héritage, encapsulation), mais certains mécanismes nécessaires aux applications coopératives ne sont pas ou peu pris en compte dans ce contexte. Parmi ceux-ci, nous nous intéressons plus particulièrement à un mode de communication asynchrone et anonyme, complément de l'appel de méthode synchrone. Nous proposons d'intégrer un tel mode de communication dans les modèles à objets en utilisant la notion d'événement: un événement peut être émis et déclencher de manière asynchrone des actions dans les objets. Nous décrivons les différents choix possibles pour intégrer cette communication à base d'événements dans un modèle à objets. Ces choix concernent à la fois les aspects déclaratifs du mécanisme et ceux relatifs au modèle d'exécution associé. Nous examinons également les effets de cette extension sur les caractéristiques canoniques des modèles à objets. Nous appliquons ensuite cette étude au modèle Guide, qui offre des objets répartis, partageables et persistants. Nous montrons comment le mode de communication proposé peut être intégré à ce modèle particulier, en insistant sur les critères qui motivent nos choix. Enfin, la réalisation d'un prototype et d'applications qui l'utilisent a permis de valider les propositions faites

Dans cette thèse, nous intéressons au problème de l'évolution des schémas pour les bases de données à objets. Nous considérons d'abord les solutions proposées pour la gestion de l'évolution de schéma de bases de données à objets. Nous proposons une classification des approches existantes. Pour chacune de ces approches nous décrivons son principe, les mécanismes d'évolution associés, ainsi que les produits et les prototypes qui l'implantent. Nous analysons ces travaux en soulignant les avantages et les inconvénients de chaque approche. Nous présentons ensuite notre approche. D'une part, cette approche propose un cadre qui permet de combiner les fonctionnalités de la modification et du versionnement pour une meilleure gestion de l'évolution de schéma. D'autre part, elle offre à l'utilisateur un langage permettant de décrire les liens entre les différents états de la base de données afin de traduire le plus fidèlement possible les évolutions du monde réel. Le versionnement de schéma évite la perte d'informations et assure que les anciens programmes d'applications continuent de fonctionner. Cependant, le nombre de versions peut devenir important ; ce qui rend complexe leur gestion. Notre approche permet de limiter le nombre de versions: (1) l'évolution d'un schéma est traduite par sa modification si l'évolution est non-soustractive (ne provoque pas la suppression de propriétés) ou si l'utilisateur le décide, (2) La technique utilisée pour adapter les instances au schéma après l'évolution, est basée sur la caractérisation de l'importance de l'existence en tant que telle d'une version d'objet. Ainsi, le nombre de versions est limité à celles qui sont fréquemment accédées par des programmes, (3) la possibilité donnée à l'administrateur de réorganiser la base de données lui permet de supprimer des versions historiques du schéma

Le travail presente dans cette these consiste a definir les fonctionnalites d'une machine virtuelle ParObj, supportant la notion d'objets concurrents et adaptee aux exigences du parallelisme massifs. Cette these s'inscrit dans le cadre du projet PARX de l'equipe "SYstemes Massivement PAralleles" du LGI qui vise a specifier et a realiser un systeme d'exploitation pour machines paralleles. A travers l'analyse de quelques Systemes Distribues a Objets connus, nous degageons les mecanismes de base que doit supporter ParObj. Nous avons arrete notre etude sur les aspects suivants : structures des entites, gestion des entites, gestion des interactions entre entites, et gestion des ressources. Dans notre approche, nous offrons dans ParObj un support parallele pour des objets passifs et actifs qui peuvent etre a la fois a gros grains (fichier, processus, etc.), et a grains intermediaires (liste chainee, thread, etc.). Pour une gestion encore plus fine du parallelisme, nous supportons aussi la notion d'objet fragmente. Un objet fragmente est un objet qui est decoupe en plusieurs sous-objets independants (fragments de l'objet) de taille quelconque, et qui peuvent etre accedes individuellement, de maniere concurrente.En revanche, nous avons decide de laisser aux compilateurs le soin de gerer les objets a grains fins. De plus, pour eliminer les conflits d'acces aux donnees, nous offrons un mecanisme de synchronisation des objets. L'architecture generale de ParObj est basee sur le modele original a trois niveaux de processus de PARX : le thread (qui est un flot de controle sequentiel a l'interieur d'une tache), la tache (qui est un contexte d'execution), et la Ptache (qui represente un programme parallele a l'execution). Une Ptache definit un domaine de communication et de protection, et assure la correction semantique du programme parallele (synchronisation des taches, controle des protocoles d'echanges, etc.). Au sein d'une Ptache, la protection des objets est assuree grace a des capacites. La localisation d'une entite (qui depend de sa visibilite et de sa reference) est realise grace a un mecanisme original de designation. Les experimentations que nous avons realisees montrent que ce mecanisme est parfaitement adapte a la gestion du parallelisme massif.

Dans un monde régi par les lois physiques, notre cerveau est capable d'extraire des invariants et de générer des attentes pour préciser notre percept visuel. Pourtant, en éclairant une pièce, ou en naviguant à travers les chaînes de télévision, nous comprenons quasi-instantanément l'essence de ces nouvelles scènes naturelles. A quelle vitesse peut-on extraire une représentation sémantique globale des scènes? Quelle est l'influence du contexte sur la reconnaissance de l'objet d'intérêt? Quelles sont les informations visuelles nécessaires et la nature des traitements sous-jacents? Les deux premiers articles démontrent notre capacité à reconnaître la catégorie superordonnée du contexte d'une scène en moins de 400 ms tandis que l'accès au niveau basique nécessite 50 ms de traitement additionnel. Ils démontrent aussi que la présence d'objets saillants interfère sur la catégorisation rapide du contexte. Ces temps de traitements très similaires à ceux enregistrés dans la catégorisation rapide d'objets suggèrent un traitement global et parallèle de l'ensemble de la scène. Le troisième article montre que la congruence (incongruence) du contexte avec l'objet influence immédiatement le traitement de l'objet et le dernier précise les informations visuelles à la base de l'analyse du contexte. Je défends ainsi l'idée d'interactions bidirectionnelles précoces entre les traitements visuels ascendants et parallèles de l'objet et du contexte et recherche dans une dernière étude la latence minimale de ces interactions en remplaçant réponse manuelle par réponse oculaire. L'implication de ces résultats fondamentaux est discutée dans la perspective des recherches à venir.

Si la sécurité est une notion essentielle aux applications, particulièrement aux applications distribuées, ses nombreux concepts représentent une étape difficile de leur développement. Les intergiciels actuels intègrent un grand nombre de technologies relatives aux concepts de sécurité. Cependant, ils laissent aux développeurs la tâche de choisir la technologie la plus adaptée ainsi que la gestion des processus sous-jacents. Cet exercice se révèle d'autant plus difficile lorsque l'application évolue dans un environnement dynamique tel que celui des grilles de calcul. Afin de faciliter le déploiement d'applications distribuées et sécurisées, cette thèse présente un modèle de sécurité décentralisé permettant aux divers acteurs (administrateurs, fournisseurs de ressources, utilisateur) d'exprimer leurs politiques de sécurité. Son utilisation se veut totalement transparente au code métier des applications. La configuration de la politique de sécurité d'une application est exprimée dans des fichiers externes en dehors du code source de cette dernière. Il est ainsi possible d'adapter la sécurité de l'application en fonction de son déploiement. Notre mécanisme de sécurité est conçu pour s'adapter dynamiquement aux situations survenant dans le cycle de vie d'une application distribuée, notamment l'acquisition de nouvelles ressources et la création de nouveaux objets. L'implantation du modèle au sein d'une bibliothèque pour le calcul distribué a permis de démontrer la faisabilité de l'approche et ses avantages. En effet, son implantation transparente a permis son intégration immédiate avec les autres modules de la bibliothèque (communications de groupe, mobilité, composants, pair-à-pair). Les tests de performance réalisés afin d'évaluer son surcoût ont confirmé la validité de l'approche.

Dans une première partie, nous définissons un nouveau langage à base fonctionnelle et avec récursion généralisée, en utilisant le système de types avec degrés de Boudol pour éliminer les récursions dangereuses. Ce langage est ensuite étendu par des enregistrements récursifs, puis par des mixins, permettant ainsi de mêler totalement les paradigmes fonctionnels et objets. Nous présentons également une implémentation, MlObj, ainsi que la machine abstraite servant à son exécution.<br /><br />Dans une deuxième partie, nous présentons un nouvel algorithme d'inférence pour les systèmes de types avec intersection, dans le cadre d'une extension du lambda-calcul. Après avoir prouvé sa correction, nous étudions sa généralisation aux références et à la récursion, nous le comparons aux algorithmes d'inférence déjà existants, notamment à celui de Système I, et nous montrons qu'il devient décidable à rang fini.