Siga este link para ver outros tipos de publicações sobre o tema: Code source (informatique) – Documentation.
Teses / dissertações sobre o tema "Code source (informatique) – Documentation"
Crie uma referência precisa em APA, MLA, Chicago, Harvard, e outros estilos
Veja os 50 melhores trabalhos (teses / dissertações) para estudos sobre o assunto "Code source (informatique) – Documentation".
Ao lado de cada fonte na lista de referências, há um botão "Adicionar à bibliografia". Clique e geraremos automaticamente a citação bibliográfica do trabalho escolhido no estilo de citação de que você precisa: APA, MLA, Harvard, Chicago, Vancouver, etc.
Você também pode baixar o texto completo da publicação científica em formato .pdf e ler o resumo do trabalho online se estiver presente nos metadados.
Veja as teses / dissertações das mais diversas áreas científicas e compile uma bibliografia correta.
1
Oumaziz, Mohamed Ameziane. "Cloning beyond source code : a study of the practices in API documentation and infrastructure as code". Thesis, Bordeaux, 2020. http://www.theses.fr/2020BORD0007.
Texto completo da fonteResumo:
Lors du développement de logiciels, la maintenance et l'évolution constituent une partie importante du cycle de vie du développement représentant 80% du coût et des efforts globaux.Au cours de la maintenance, il arrive que les développeurs aient copier-coller des fragments de code source afin de les réutiliser. Une telle pratique, apparemment inoffensive, est plus fréquente qu'on ne le pense.Communément appelés «clones» dans la littérature, ces doublons de code source sont un sujet bien connu et étudié en génie logiciel.Dans cette thèse, nous visons à mettre en lumière les pratiques du copier-coller sur les artefacts logiciels.En particulier, nous avons choisi de concentrer nos contributions sur deux types d'artefacts logiciels : Documentation d'API et fichiers de compilation (c.-à-d. Dockerfiles). Pour les deux contributions, nous suivons une méthodologie d'étude empirique commune.Tout d'abord, nous montrons que les documentations d'API et les fichiers de construction de logiciels (c.-à-d. Dockerfiles) sont confrontés à des problèmes de doublons et que de tels doublons sont fréquents.Deuxièmement, nous identifions les raisons derrière l'existence de ces doublons.Troisièmement, nous effectuons une enquête auprès de développeurs expérimentés et de constatons qu'ils sont conscients de ces doublons, et qu'ils les rencontrent souvent tout en ayant un avis mitigé sur eux.Enfin, nous montrons que les deux artefacts logiciels manquent de mécanismes de réutilisation pour faire face aux doublons, et que certains développeurs ont même recours à des outils ad-hoc pour les gérerWhen developing a software, maintenance and evolution represents an important part of the development's life-cycle, making up to 80% of the overall cost and effort.During the maintenance effort, it happens that developers have to resort to copying and pasting source code fragments in order to reuse them.Such practice, seemingly harmless is more frequent than we expect.Commonly referred to as ``clones'' in the literature, these source code duplicates are a well-known and studied topic in software engineering.In this thesis, we aim at shedding some light on copy-paste practices on software artifacts. In particular, we chose to focus our contributions on two specific types of software artifacts: API documentation and build files (i.e. Dockerfiles).For both contributions, we follow a common empirical study methodology. First, We show that API documentations and software build files (i.e. Dockerfiles) actually face duplicates issues and that such duplicates are frequent.Secondly, we identify the reasons behind the existence of such duplicates.Thirdly, We perform a survey on experimented developers and find that they're aware of such duplicates, frequently face them. But still have a mixed opinion regarding them.Finally, We show that both software artifacts lack reuse mechanisms to cope with duplicates, and that some developers even resort to ad-hoc tools to manage them
2
Latappy, Corentin. "Les pratiques de code : de la documentation à la détection". Electronic Thesis or Diss., Bordeaux, 2024. http://www.theses.fr/2024BORD0101.
Texto completo da fonteResumo:
Les pratiques de code sont de plus en plus utilisées dans le domaine du développement logiciel. Leur mise en place permet d’assurer la maintenabilité, la lisibilité et la consistance du code, ce qui contribue fortement à la qualité logicielle. La majorité de ces pratiques est implémentée dans des outils d’analyse statique, ou linters, qui permettent d’alerter automatiquement les développeurs lorsqu’une pratique n’est pas respectée. Toutefois, de plus en plus d’organisations, ayant tendance à créer leurs propres pratiques internes, rencontrent des problèmes sur leur compréhension et leur adoption par les développeurs. Premièrement, afin d’être appliquée, une pratique doit d’abord être comprise par les développeurs, impliquant donc d’avoir une documentation correctement rédigée. Or, ce sujet de la documentation n’a été que peu étudié dans la littérature scientifique. Ensuite, pour favoriser leur adoption, il faudrait pouvoir étendre les outils d’analyse existants pour y intégrer de nouvelles pratiques, ce qui est difficile compte tenu de l’expertise nécessaire pour apporter ces modifications. Packmind, société bordelaise, développe une solution pour accompagner les développeurs à faire émerger ces pratiques internes à l’aide d’ateliers. Cependant, elle souffre des mêmes problématiques citées précédemment. Dans cette thèse, nous nous sommes d’abord intéressés à fournir des recommandations aux auteurs de la documentation des pratiques. Pour cela, nous avons analysé la documentation de plus de 100 règles provenant de 16 linters différents afin d’en extraire une taxonomie des objectifs de documentation et des types de contenu présents. Nous avons ensuite réalisé une enquête auprès de développeurs afin d’évaluer leurs attentes en termes de documentation. Cela nous a notamment permis d’observer que les raisons pour lesquelles une pratique doit être appliquée étaient très peu documentées, alors qu’elles sont perçues comme essentielles par les développeurs. Dans un second temps, nous avons étudié la faisabilité de l’identification automatique de violations de pratiques à partir d’exemples. Notre contexte, nous contraignant à détecter des pratiques internes pour lesquelles nous avons peu d’exemples pour apprendre, nous a poussé à mettre en place du transfert d’apprentissage sur le modèle de machine learning CodeBERT. Nous montrons que les modèles ainsi entraînés obtiennent de bonnes performances dans un contexte expérimental, mais que la précision s’écroule lorsque nous les appliquons à des bases de code réellesCoding practices are increasingly used in the field of software development. Their implementation ensures maintainability, readability, and consistency of the code, which greatly contributes to software quality. Most of these practices are implemented in static analysis tools, or linters, which automatically alert developers when a practice is not followed. However,more and more organizations, tending to create their own internal practices, encounter problems with their understanding and adoption by developers. First, for a practice to be applied, it must first be understood by developers, thus requiring properly written documentation. Yet, this topic of documentation has been little studied in the scientific literature. Then, to promote their adoption, it would be necessary to be able to extend existing analysis tools to integrate new practices, which is difficult given the expertise required to make these modifications. Packmind, a company based in Bordeaux, develops a solution to support developers in bringing out these internal practices through workshops. However, it suffers from the same issues mentioned above. In this thesis, we first focused on providing recommendations to the authors of practice documentation. To do this, we analyzed the documentation of more than 100 rules from 16 different linters to extract a taxonomy of documentation objectives and types of content present. We then conducted a survey among developers to assess their expectations in terms of documentation. This notably allowed us to observe that the reasons why a practice should be applied were very poorly documented, while they are perceived as essential by developers. Secondly, we studied the feasibility of automatically identifying violations of practices from examples. Our context, forcing us to detect internal practices for which we have few examples to learn from, pushed us to implement transfer learning on themachine learning model CodeBERT.We show that the models thus trained achieve good performance in an experimental context, but that accuracy collapseswhenwe apply them to real code bases
3
Che, Denise. "Automatic documentation generation from source code". Thesis, Massachusetts Institute of Technology, 2016. http://hdl.handle.net/1721.1/112822.
Texto completo da fonteResumo:
Thesis: M. Eng., Massachusetts Institute of Technology, Department of Electrical Engineering and Computer Science, 2016.This electronic version was submitted by the student author. The certified thesis is available in the Institute Archives and Special Collections.
Cataloged from student-submitted PDF version of thesis.
Includes bibliographical references (page 46).
Many systems lack robust documentation because writing documentation comes at a cost for developers and offers little immediate benefits. To motivate developers to write more documentation, we need a framework that beneficially incorporates documentation into the functionalities of the codebase. We explored this idea in the context of Exhibit, a data publishing framework developed at MIT CSAIL's Haystack group. Exhibit enables those without much programming experience to create data-rich interactive webpages. We created an automatic documentation system with an approach that motives the creation of rich specifications by developers, which leads to good documentation. The code required for documentation benefits developers by simplifying the codebase and providing fault tolerance through a modular error checking mechanism. This system intends to aid new and returning users of Exhibit in learning the Exhibit syntax and in creating their Exhibits by providing extensive, up-to-date documentation for all the available views and facets in Exhibit along with an interactive example component. The interactive example component provides an interface that allows users to experiment with combinations of the different settings and also aids developers during the unit testing process.
by Denise Che.
M. Eng.
4
Jaeger, Julien. "Source-to-source transformations for irregular and multithreaded code optimization". Versailles-St Quentin en Yvelines, 2012. http://www.theses.fr/2012VERS0015.
Texto completo da fonteResumo:
Dans cette thèse, nous montrons que les optimisations source-à-source sont un moyen efficace pour générer des programmes irréguliers ou parallèles performants à partir d'une implémentation. Après avoir présenté l'évolution des architectures des processeurs, nous proposons deux méthodes distinctes. La première pour extraire des codelets d'un programme irréguliers, les optimiser et prédire les performances du programme modifié. L'autre pour limiter l'impact des problèmes d'alignements dus à la vectorisation ou aux conflits de bancs. Nous présentons aussi différentes techniques de parallélisation, l'une générant des codelets parallèles, l'autre ordonnançant un graphe de taches sur un système hétérogèneIn this dissertation, we show that source-to-source optimization is an efficient method to generate a high performance program for irregular and heterogeneous code from a basic implementation. After describing the evolution of processor architectures, we provide two methods. The first one extract codelets from an irregular code, optimizing these codelets, and predicting the performance of the modified program. The other one limits the impact of alignment issues due to vectorization or bank conflicts. We also present two parallelization technics, one generating parallel codelets, the other scheduling a task graph on an heterogeneous system
5
Tévar, Hernández Helena. "Evolution of SoftwareDocumentation Over Time : An analysis of the quality of softwaredocumentation". Thesis, Linnéuniversitetet, Institutionen för datavetenskap och medieteknik (DM), 2020. http://urn.kb.se/resolve?urn=urn:nbn:se:lnu:diva-97561.
Texto completo da fonteResumo:
Software developers, maintainers, and testers rely on documentation to understandthe code they are working with. However, software documentation is perceivedas a waste of effort because it is usually outdated. How documentation evolvesthrough a set of releases may show whether there is any relationship between timeand quality. The results could help future developers and managers to improvethe quality of their documentation and decrease the time developers use to analyzecode. Previous studies showed that documentation used to be scarce and low inquality, thus, this research has investigated different variables to check if the qualityof the documentation changes over time. Therefore, we have created a tool thatwould extract and calculate the quality of the comments in code blocks, classes,and methods. The results have agreed with the previous studies. The quality of thedocumentation is affected to some extent through the releases, with a tendency todecrease.
6
Depaz, Pierre. "The role of aesthetics in understanding source code". Electronic Thesis or Diss., Paris 3, 2023. http://www.theses.fr/2023PA030084.
Texto completo da fonteResumo:
Cette thèse examine comment les propriétés esthétiques du code source permettent la représentation d’espaces sémantiques programmés, et leur implication dans la compréhension de la fonction de processus computationels. Se basant sur un corpus de programmes-textes et des discours les accompagnant, nous montrons en quoi l’esthétique du code source est contingente d’autres domaines esthétiques littéraires, architecturaux et mathématiques, tout en demeurant dépendante du contexte au sein duquel circulent les programmes-textes, et se transformant à différentes échelles de lecture. En particulier, nous montrons que les propriétés esthétiques du code source permettent une certaine expressivité, en vertu de leur appartenance à une interface linguistique partagée et dynamique permettant de calculer le monde. Enfin, nous montrons comment une telle interface, organisée formellement, favorise la compression sémantique et l’exploration spatialeThis thesis investigates how the aesthetic properties of source code enable the representation of programmed semantic spaces, in relation with the function and understanding of computer processes. By examining program texts and the discourses around it, we highlight how source code aesthetics are both dependent on the context in which they are written, and contingent to other literary, architectural, and mathematical aesthetics, varying along different scales of reading. Particularly, we show how the aesthetic properties of source code manifest expressive power due to their existence as a dynamic, functional, and shared computational interface to the world, through formal organizations which facilitate semantic compression and spatial exploration
7
Lebras, Youenn. "Code optimization based on source to source transformations using profile guided metrics". Thesis, Université Paris-Saclay (ComUE), 2019. http://www.theses.fr/2019SACLV037/document.
Texto completo da fonteResumo:
Le but est de développer d'un cadriciel permettant de définir les transformations de code source que nous jugeons judicieuses et sur la base de métriques dynamiques.Ce cadriciel sera ensuite intégré à la suite d'outil MAQAO, développée à l'UVSQ/ECR.Nous présentons des transformations source-à-source automatique guidées par l'utilisateur ansi que par les métriques dynamiques qui proviennent des différents outils d'analyse de MAQAO, afin de pouvoir travailler à la fois sur des objets sources et binaires.Ce cadriciel peut aussi servir de pré-processeur pour simplifier le développement en permettant d'effectuer certaines transformations simples mais chronophage et sources d'erreurs (i.e.: spécialisation de boucle ou fonction)Our goal is to develop a framework allowing the definition of source code transformations based on dynamic metrics.This framework be integrated to the MAQAO tool suite developed at the UVSQ / ECR.We present a set of source-to-source transformations guidable by the end user and by the dynamic metrics coming from the various MAQAO tools in order to work at source and binary levels.This framework can also be used as a pre-processor to simplify the development by enabling to perform cleanly and automatically some simple but time-consuming and error-prone transformations (i.e .: loop/function specialization, ...)
8
Chilowicz, Michel. "Recherche de similarité dans du code source". Phd thesis, Université Paris-Est, 2010. http://tel.archives-ouvertes.fr/tel-00587628.
Texto completo da fonteResumo:
La duplication de code source a de nombreuses origines : copie et adaptation inter-projets ou clonage au sein d'un même projet. Rechercher des correspondances de code copié permet de le factoriser dans un projet ou de mettre en évidence des situations de plagiat. Nous étudions des méthodes statiques de recherche de similarité sur du code ayant potentiellement subi des opérations d'édition telle que l'insertion, la suppression, la transposition ainsi que la factorisation et le développement de fonctions. Des techniques d'identification de similarité génomique sont examinées et adaptées au contexte de la recherche de clones de code source sous forme lexemisée. Après une discussion sur des procédés d'alignement de lexèmes et de recherche par empreintes de n-grams, est présentée une méthode de factorisation fusionnant les graphes d'appels de fonctions de projets au sein d'un graphe unique avec introduction de fonctions synthétiques exprimant les correspondances imbriquées. Elle utilise des structures d'indexation de suffixes pour la détermination de facteurs répétés. Une autre voie d'exploration permettant de manipuler de grandes bases indexées de code par arbre de syntaxe est abordée avec la recherche de sous-arbres similaires par leur hachage et leur indexation selon des profils d'abstraction variables. Des clones exacts de sous-arbres de forte proximité dans leurs arbres d'extraction peuvent alors être consolidés afin d'obtenir des correspondances approchées et étendues. En amont et en aval de la recherche de correspondances, des métriques de similarité sont définies afin de préselectionner les zones d'examen, affiner la recherche ou mieux représenter les résultats
9
Habchi, Sarra. "Understanding mobile-specific code smells". Thesis, Lille 1, 2019. http://www.theses.fr/2019LIL1I089.
Texto completo da fonteResumo:
Au cours des dernières années, les applications mobiles sont devenues indispensables dans notre vie quotidienne. Ces applications ont pour particularité de fonctionner sur des téléphones mobiles, souvent limités en ressources (mémoire, puissance de calcul, batterie, etc). Ainsi, il est impératif de surveiller leur code source afin de s'assurer de l’absence de défauts de code, c.à.d., des pratiques de développement qui dégradent la performance. Plusieurs études ont été menées pour analyser les défauts de code des applications mobile et évaluer leur présence et leur impact sur la performance et l’efficience énergétique. Néanmoins, ces études n’ont pas examiné les caractéristiques et les motifs de ces défauts alors que ces éléments sont nécessaires pour la compréhension et la résolution de ce phénomène. L’objectif de cette thèse est de répondre à ce besoin en apportant des connaissances sur les défauts de code mobile. Pour cela, nous avons mené diverses études empiriques à caractère quantitatif et qualitatif pour comprendre ce phénomène et ses possibles résolutions. Les résultats de ces études montrent que les défauts de code mobile ne sont pas dus au pragmatisme, à la priorisation, ou aux comportements individuels des développeurs. En effet, l’essentielle raison derrière l’accumulation des défauts de code est l’ignorance générale de ces pratiques parmi les développeurs. Nos études ont aussi montré que le linter peut être un outil adéquat pour l’analyse des défauts de code et l’amélioration des performances. Cependant, certains défauts nécessitent une analyse dynamique pour une détection plus précise. Enfin, nous avons montré qu’il existe un écart entre les défauts de code étudiés par la communauté scientifique et les réelles mauvaises pratiques adoptées par les développeurs d’applications mobiles. Pour remédier à cet écart, nous recommandons à la communauté d’impliquer les développeurs dans le processus d’identification de défauts de codeObject-Oriented code smells are well-known concepts in software engineering. They refer to bad design and development practices commonly observed in software systems. With the emergence of mobile apps, new classes of code smells have been identified to refer to bad development practices that are specific to mobile platforms. These mobile-specific code smells differ from object-oriented ones by focusing on performance issues reported in the documentation or developer guidelines. Since their identification, many research works approached mobile-specific code smells to propose detection tools and study them. Nonetheless, most of these studies only focused on measuring the performance impact of such code smells and did not provide any insights about their motives and potential solutions. In particular, we lack knowledge about (i) the rationales behind the accrual of mobile code smells, (ii) the developers’ perception of mobile code smells, and (iii) the generalizability of code smells across different mobile platforms. These lacks hinder the understanding of mobile code smells and consequently prevent the design of adequate solutions for them. Therefore, we conduct in this thesis a series of empirical studies with the aim of understanding mobile code smells. First, we study the expansion of code smells in different mobile platforms. Then, we conduct a large-scale study to analyze the change history of mobile apps and discern the factors that favor the introduction and survival of code smells. To consolidate these studies, we also perform a user study to investigate developers’ perception of code smells and the adequacy of static analyzers as a solution for coping with them. Finally, we perform a qualitative study to question the established foundation about the definition and detection of mobile code smells. The results of these studies revealed important research findings. Notably, we showed that pragmatism, prioritization, and individual attitudes are not relevant factors for the accrual of mobile code smells. The problem is rather caused by ignorance and oversight, which are prevalent among mobile developers. Furthermore, we highlighted several flaws in the code smell definitions that are currently adopted by the research community. These results allowed us to elaborate some recommendations for researchers and tool makers willing to design detection and refactoring tools for mobile code smells. On top of that, our results opened perspectives for research works about the identification of mobile code smells and development practices in general
10
Chaabane, Rim. "Analyse et optimisation de patterns de code". Paris 8, 2011. http://www.theses.fr/2011PA084174.
Texto completo da fonteResumo:
Our work is performed in the context of a financial company that develops and maintains legacy software. This software has been existing for more than twenty years, it was written in a proprietary, procedural and 4GL language called ADL (or Application Development Language). This software was initially developed for VMS system and deals with old generation of DBMS. For commercial reasons, the software has been ported to UNIX systems and to new RDBMS; Oracle and Sybase. It has also been extended to offer web interfaces. This legacy software has to face some new challenges as databases grow. During these last 20 years, some phenomenons like the merging of two companies, make data grow up to more than 1Terabyte and will reach 1Petabyte in a few years. In these new contexts, the ADL language shows limits to handle such a mass of data. Some patterns of code with database access have been suspected to be responsible for important decrease in performance. Our work consists in detecting all the instances of a suspected pattern of code in the source code or procedures, and identifying the instances of code, the most often called and the most time consuming. We developed a first tool called Adlmap, which is based on static analysis. It detects all DB accesses and flags those that are suspected patterns of code. The second tool we developed, named Pmonitor, is based on hybrid analysis; a combination of static and dynamic analysis. We use it to highlight inefficient code patterns instancesNotre travail consiste en l’analyse et l’optimisation du code source d’applications de type système hérité (ou legacy system). Nous avons particulièrement travaillé sur un logiciel, appelé GP3, qui est développé et maintenu par la société de finances Sungard. Ce logiciel existe depuis plus d’une vingtaine d’années, il est écrit en un langage propriétaire, procédural et de 4ème génération, appelé ADL (ou Application Development Language). Ce logiciel à été initialement développé sous VMS et accédait à des bases de données d’ancienne génération. Pour des raisons commerciales, il fut porté sous UNIX et s’adresse maintenant à des SGBD-R de nouvelles génération ; Oracle et Sybase. Il a également été étendu de manière à offrir une interface web. Ce système hérité doit maintenant faire face à de nouveaux défis, comme la croissance de la taille des bases de données. Durant ces 20 dernières années, nous avons pu observer la fusion de plusieurs entreprises, ce qui implique la fusion de bases de données. Ces dernières peuvent dépasser les 1 Téra de données et plus encore sont à prévoir à l’avenir. Dans ce nouveau contexte, le langage ADL montre des limites à traiter une aussi importante masse de données. Des patterns de code, désignant des structures d’accès en base, sont suspectés d’être responsables de dégradations des performances. Notre travail consiste à détecter toutes les instances de patterns dans le code source, puis d’identifier les instances les plus consommatrices en temps d’exécution et en nombre d’appels. Nous avons développé un premier outil, nommé Adlmap, basé sur l’analyse statique de code, et qui permet de détecter toutes les accès en base dans le code source. Les accès en base identifiés comme patterns de code sont marqués. Le second outil que nous avons développé, nommé Pmonitor, est basé sur une analyse hybride ; combinaison d’analyses statique et dynamique. Cet outil nous permet de mesurer les performances des patterns de code et ainsi, d’identifier les instances les moins performantes
11
Le, Dilavrec Quentin. "Precise temporal analysis of source code histories at scale". Electronic Thesis or Diss., Université de Rennes (2023-....), 2024. http://www.theses.fr/2024URENS003.
Texto completo da fonteResumo:
Les systèmes informatiques jouent un rôle central dans les sociétés contemporaines, se développant et s'adaptant continuellement pour répondre aux nouvelles exigences et pratiques. Au fil des ans, grâce à des efforts de développement importants et à de nombreuses mises à jour du code, ces systèmes peuvent accumuler des millions de lignes de code. En outre, ils présentent des caractéristiques de complexité, de configurabilité et de multilinguisme, et s'appuient sur des pipelines de construction vastes et complexes pour cibler de multiples plateformes et matériels. Ce qui nécessite des analyses de code approfondies pour maintenir le code, contrôler la qualité et détecter les erreurs. L'analyse automatisée du code est un processus coûteux en ressources, principalement conçu pour examiner une seule version d'un logiciel. Actuellement, les méthodes d'analyse de code existantes peinent à évaluer efficacement plusieurs versions de logiciels au cours d'une seule analyse, ce qui prend beaucoup de temps. Ce type d'analyse de code, qui examine le code d'un logiciel à plusieurs moments de son existence, est appelé "analyse de code temporel". Les analyses temporelles de code ouvrent de nouvelles perspectives pour l'amélioration de la qualité et de la fiabilité des logiciels. Par exemple, de telles analyses permettraient d'étudier pleinement la façon dont le code et ses tests évoluent conjointement dans l'historique du code. Pour surmonter les différents défis qui empêchent de telles analyses de fonctionner à grande échelle, cette thèse apporte les contributions suivantes. Cette thèse démontre d'abord la faisabilité de l'analyse des changements de code source pour identifier les relations de causalité entre les changements (c'est-à-dire les co-évolutions). La deuxième contribution porte sur l'efficacité du calcul des modifications fines et de leurs impacts à partir de l'historique des codes. Pour ce faire, il a fallu revoir la manière dont les historiques des codes sources sont représentés et traités, en tirant parti de la nature structurée du code et de sa stabilité dans le temps. Cela a conduit à une approche, appelée HyperAST, qui calcule de manière incrémentale les dépendances référentielles. La troisième contribution est une nouvelle technique de différenciation structuré de code pour différencier les commits. Cette dernière contribution, appelée HyperDiff, complète HyperAST pour comparer les commits à grande échelleSoftware systems play a central role in contemporary societies, continuously expanding and adjusting to meet emerging requirements and practices. Over the years, through extensive development efforts and numerous code updates, those systems can accumulate millions of lines of code. Moreover, they exhibit complexity, configurability, and multi-language characteristics, relying on large and complex build pipelines to target multiple platforms and hardware. This requires extensive code analyzes to maintain code, monitor quality and catch bugs. Automated code analysis is a resource-intensive process primarily designed to examine a single specific software version. Presently, existing code analysis methods struggle to efficiently evaluate multiple software versions within a single analysis, taking up an impractical amount of time. This type of code analysis, which scrutinizes software code over several moments of its existence, is referred to as "temporal code analysis." Temporal code analyses open new opportunities for improving software quality and reliability. For example, such analyses would permit to fully study how code and their tests co-evolve in a code history. To overcome the different challenges that prevent such analyses to run at large scale, this thesis makes the following contributions. This thesis first demonstrates the feasibility of analyzing source code changes to identify causality relations between changes (ie. co-evolutions). The second contribution addresses the efficiency of computing fine-grained changes and their impacts from code histories. This required to revisit how source code histories are represented and processed, leveraging the structured nature of code and its stability through time. It led to an approach, called HyperAST, that incrementally computes referential dependencies. The third contribution is a novel code differencing technique for diffing commits. This last contribution, called HyperDiff, complements HyperAST to compare commits at scale
12
Zhang, Xu. "Analyse de la similarité du code source pour la réutilisation automatique de tests unitaires à l'aide du CBR". Thesis, Université Laval, 2013. http://www.theses.ulaval.ca/2013/29841/29841.pdf.
Texto completo da fonteResumo:
Réutiliser les tests unitaires automatiquement est une solution pour faciliter le travail de certains développeurs. Dans notre recherche, nous proposons une ébauche de solution en utilisant le raisonnement à base de cas (Case Based reasoning - CBR) issu du domaine de l’intelligence artificielle. Cette technique tente de trouver le cas le plus similaire dans une base de cas pour ensuite, après modifications, le réutiliser pour résoudre un nouveau problème. Nos travaux de recherche se concentrent sur l’analyse de la similarité du code dans l’optique de réutiliser des tests unitaires. Nous porterons donc une attention particulière à l’élaboration d’une technique de comparaison des classes adaptées au contexte des tests. Plus précisément, dans ce mémoire, nous aborderons les questions suivantes: 1. Trouver la classe la plus similaire dans le but de réutiliser ses tests unitaires (travaux principaux); 2. Trouver les méthodes similaires entre les deux classes similaires; 3. Chercher les tests réutilisables en fonction de la similarité des méthodes de ces deux classes. Pour ce faire, nous mènerons des expérimentations afin de trouver les meilleures attributs (caractéristiques) permettant de comparer deux classes. Ces attributs doivent être choisis en considérant le contexte particulier des tests qui ne sont pas les mêmes que pour, par exemple, détecter du code dupliqué. Cette recherche nous permet de proposer un premier algorithme d’analyse de la similarité des classes qui fonctionne assez bien dans le contexte de notre expérimentation. Nous avons également étendu le processus à la sélection et la réutilisation de tests à l’aide d’une technique simple permettant de vérifier que l’algorithme d’analyse de similarité des classes peut potentiellement fonctionner et s’intégrer à un processus complet. Nos travaux montrent qu’il est possible de réutiliser des tests unitaires, bien que l’algorithme reste à être améliorer. Nous proposons d’ailleurs plusieurs pistes à ce sujet.Automatically reusing unit tests is a possible solution to help developers with their daily work. Our research proposes preliminary solutions using case base reasoning (CBR), an approach coming from artificial intelligence. This technique try to find the most similar case in a case base to reuse it after some modifications against some new problems to solve. Our works focus on the similarity analysis of a program code with the goal of reusing unit tests. Our main focus will be on the elaboration of a technique to compare classes in the test context. To be more precise, in the thesis, we will discuss: 1. How to find the most similar class for which it will be possible to reuse its tests (main focus); 2. How to find similar methods between the new class and the most similar one; 3. Find which test could be reused considering the similarity of the methods. To achieve this, we will run some experiments to find the bests attributes (characteristics) to compare two classes. Those attributes must be chosen considering the specific context of testing. For example, those characteristics are not the same as for finding duplicated code. This research propose an algorithm to analyze the similarity of classes. Our experiment shows that this algorithm works quite well in the context of the experiment. We also extended the experiment to see if it could possibly work within the whole process of selection and reuse of unit tests. We did this by using some simple techniques that could certainly be refined. In fact, our works demonstrate that it is possible to reuse unit tests despite the fact that our algorithm could be perfected and we suggest some improvements about it.
13
Lecerf, Jason. "Designing language-agnostic code transformation engines". Thesis, Lille 1, 2019. http://www.theses.fr/2019LIL1I077.
Texto completo da fonteResumo:
Les transformations automatiques de code apparaissent dans diverses situations, les refactorings, les migrations inter-langages ou encore la spécialisation de code. Les moteurs supportant ces transformations cherchent dans le code source les occurrences de motifs spécifiés par l’utilisateur, puis les réécrivent grâce à une transformation. Cette transformation peut soit modifier les occurrences elles-mêmes, des éléments de la représentation intermédiaire (IR) du langage, en nouveaux éléments ou réécrire leur code source. Nous nous concentrons sur la réécriture de code source qui offre une meilleure flexibilité grâce à des transformations arbitraires particulièrement utiles à la migration et à la spécialisation de code. Les motifs sont divisés en deux catégories : les motifs explicites et syntaxiques. Les premiers demandent que l’utilisateur connaisse l’IR du langage, un effort d’apprentissage non négligeable. Les seconds demandent seulement de connaître la syntaxe du langage et non son IR, mais requièrent un effort d’implémentation supplémentaire pour les back-ends de langage du moteur. Tandis que les experts en langage connaissent l’IR et la syntaxe du langage, les autres utilisateurs connaissent seulement la syntaxe. Nous proposons un moteur de reconnaissance de motifs offrant une représentation hybride des motifs : les motifs peuvent être à la fois explicites et syntaxiques. Par défaut, le moteur se rabat sur un fonctionnement syntaxique, car la barrière à l’entrée est plus basse. Pour pallier au coup d’implémentation des back-ends de langage pour la reconnaissance syntaxique, nous prenons une approche générative. Le moteur de reconnaissance hybride est couplé avec un moteur de génération d’analyseurs syntaxiques. Ce dernier génère des analyseurs syntaxiques LR généralisés (GLR) capables d’analyser non seulement le code source à réécrire, mais également le motif à reconnaitre. L’implémenteur du back-end de langage n’a alors qu’à ajouter une ligne à la grammaire pour avoir accès au moteur de reconnaissance de motifs pour ce langage. L’approche est basée sur des analyseurs syntaxiques GLR pouvant se dupliquer et traquant ses sous-analyseurs. Ces implémentations particulières de GLR ne passent pas à l’échelle quand trop de duplications sont nécessaires pour gérer les ambiguïtés et notre approche ajoute de la duplication. Pour éviter une explosion du temps d’exécution, nos analyseurs syntaxiques FGLR fusionnent plus régulièrement et permettent une désambiguïsation à la volée pendant l’analyse via des effets de bordCode transformations are needed in various cases: refactorings, migrations, code specialization, and so on. Code transformation engines work by finding a pattern in the source code and rewriting its occurrences according to the transformation. The transformation either rewrites the occurrences, elements of the intermediate representation (IR) of the language, into new elements or directly rewrites the source code. In this work, we focused on source rewriting since it offers more flexibility through arbitrary transformations, especially for migrations and specializations. Matching patterns come in two different flavors, explicit and syntactic. The former requires the user to know the IR of the language, a heavy knowledge burden. The latter only relies on the syntax of the matched language and not its IR, but requires significantly more work to implement the language back-ends. Language experts tend to know the IR and the syntax of a language, while other users know only the syntax. We propose a pattern matching engine offering a hybrid pattern representation: both explicit and syntactic matching are available in the same pattern. The engine always defaults to syntactic as it is the lowest barrier to entry for patterns. To counterbalance the implementation cost of language back-ends for syntactic pattern matching, we take a generative approach. We combine the hybrid pattern matching engine with a parser generator. The parser generator generates generalized LR (GLR) parsers capable of not only parsing the source but also the hybrid pattern. The back-end implementer only needs to add one line to the grammar of the language to activate the pattern matching engine. This approach to pattern matching requires GLR parsers capable of forking and keeping track of each individual fork. These GLR implementations suffer the more forking is done to handle ambiguities and patterns require even more forking. To prevent an explosion, our Fibered-GLR parsers merge more often and allow for classic disambiguation during the parse through side-effects
14
Kiss, Fabian. "Documenting for Program Comprehension in Agile Software Development". Thesis, Högskolan i Borås, Institutionen Handels- och IT-högskolan, 2011. http://urn.kb.se/resolve?urn=urn:nbn:se:hb:diva-20393.
Texto completo da fonteResumo:
Program comprehension, i.e. to understand from its source code what a computer programdoes, is crucial for change and maintenance in software development. In this thesis, it is lookedfor innovative documentation techniques and tools that support program comprehension, butthat are also conform to agile values and principles – commonly, documentation is consideredcritical due to the agile value “working software over comprehensive documentation.”1 First,a research framework is developed that embodies detailed requisites for such techniques andtools. Apart from its internal use for examining techniques and tools subsequently obtainedfrom a literature search, this framework is intended to be likewise employed by software practitioners.Eventually, the findings of a series of survey studies conducted in an industrial softwareorganization for the primary purpose of evaluating the obtained techniques and tools are analyzed.Three innovative techniques that meet all requisites are revealed. These are regarded bypractitioners independently from the support of program comprehension as helpful for a changeimpact analysis conducted by non-developers. Therefore, a requisite deduced from the highestpriority in agile software development – customer satisfaction – is met. It says that a techniqueor tool has to directly induce a benefit for non-developer stakeholders besides the benefits forthem which are indirectly induced by the support of program comprehension, e.g. a potentiallyimproved source code quality. Further, the technique most beneficial for developers as well asfor non-developers among the three techniques is identified, which bases on design rationales– textual information related to the source code that states the reasons why a part of the programhas been implemented in a certain way. Secondarily, the studies revealed that the researchframework is difficult to understand for practitioners due to its unstructured form.Program: Magisterutbildning i informatik
15
Ouddan, Mohammed Amine. "Indexation et recherche des documents code source basées sur une caractérisation structuro-sémantique : application à la détection de plagiats". Université de Marne-la-Vallée, 2007. http://www.theses.fr/2007MARN0340.
Texto completo da fonteResumo:
La caractérisation du contenu d’un code source est une tâche très complexe en raison de la similitude qui existe entre les projets informatiques. Les différentes techniques de plagiat qui sont appliqués sur ce type de documents rendent la tâche de détection des plagiats de plus en plus difficile. Nous proposons un système multilangages de détection de plagiats basé sur une approche de caractérisation à deux niveaux, le premier niveau se porte sur l’aspect syntaxique du code permettant une caractérisation structurelle du code, et le second niveau concerne son aspect fonctionnel permettant une caractérisation sémantique. Notre approche se base sur la notion de Grammaire à Actions concrétisée par un module permettant d’accéder au contenu structurel et sémantique du code par le biais de la grammaire du langage dont ce code est écrit. Les actions de ce module consistent à traduire un code du langage source vers un langage de caractérisation où le code est représenté par un ensemble de séquences dites caractéristiques. Dans le premier niveau de caractérisation nous parlons de séquences structurelles et dans le second niveau nous parlons de séquences génétiques. Nous appliquons par la suite les techniques d’alignement de séquences pour mesurer le taux de similarité entre deux séquences caractéristiques, qui est considéré comme une abstraction au taux de plagiat entre les codes caractérisésSource code characterization is a very complex task due the amount of similarity between computer science assignments. The various transformations that occur within a plagiarized code make the plagiarism detection more difficult. We propose a multilanguage source code retrieval system for plagiarism detection which is based on twolevel characterization approach. The first level reflects the syntactic feature of the code allowing a structural characterization of its content, and the second level relates to its functional feature allowing a semantic characterization. Our approach is based on the concept of Grammar with Actions which consists to assign significance to the parsing process in a context of characterization, and at the same time, allowing access to the structural and semantic content of the code using the grammar of its programming language. The aim idea is to translate the source code into a set of symbols sequences called characteristic sequences. In the first level of characterization we talk about structural sequences and in the second level we talk about genetic sequences. In order to quantify the similarity between characteristic sequences, we use sequence alignment techniques where the similarity rate is considered as an abstraction of the plagiarism rate between the characterized codes
16
Amouroux, Guillaume. "Etude de l'analyse automatique des règles de conception des systèmes multitâches temps réel". Paris 11, 2008. http://www.theses.fr/2008PA112053.
Texto completo da fonteResumo:
Les travaux présentés dans cette thèse ont pour objectif de proposer une méthode permettant l’analyse de l’application de règles de conception à partir du code source d’une application. Les règles de conception permettent de garantir des propriétés intéressantes sur le programme final. Aussi, vérifier leur application permet-il de garantir la présence de ces propriétés. Au contraire, si la règle ne se trouve pas appliquée dans le programme final, alors il n’est pas possible d’émettre un avis quant à la qualité du code source, mais le fait que le développeur ait ignoré la règle est significatif. Les vérifications s’intéressent particulièrement aux problèmes liés aux systèmes multitâches. L’introduction d’un ordonnancement non-déterministe entre les tâches rend les analyses par les méthodes classiques de preuve de programme peu ou pas efficaces. C’est pourquoi une technique de décomposition de programme est proposée, ainsi que des méthodes de vérification à plusieurs niveaux. La technique développée se base sur l’étude du code source seul. Les analyses doivent n’être possibles qu’à partir de cet élément, en l’absence de tout autre élément de conceptionThe works presented in this thesis propose a novel method to verify the application of design rules based on the analysis of the source code. Design rules allow to guarantee the presence of sound properties on the final program. Therefore, verifying their presence allows to guarantee the presence of the associated properties. On the opposite, if a particular rule is not found to be applied upon the final program, no judgment may be given regarding the quality of the source code, but the fact that the developer didn’t follow the rule is significant in itself. The verifications are particularly aimed towards the problems specific to multitask systems. The introduction of a dynamic non-deterministic scheduling between the tasks renders the analyses by classical proof of programs inefficient or even useless. This led us to propose a new program analysis technique, based on multiple levels analysis and program slicing. The technique proposed is based on the study of the source code only. The analyses must be performed on this element only, if no other element regarding the system’s design is available
17
Come, David. "Analyse de la qualité de code via une approche logique et application à la robotique". Thesis, Toulouse 3, 2019. http://www.theses.fr/2019TOU30008.
Texto completo da fonteResumo:
La qualité d'un code informatique passe à la fois par sa correction fonctionnelle mais aussi par des critères de lisibilité, compréhension et maintenabilité. C'est une problématique actuellement importante en robotique où de nombreux frameworks open-source se diffusent mal dans l'industrie en raison d'incertitudes sur la qualité du code. Les outils d'analyse et de recherche de code sont efficaces pour améliorer ces aspects. Il est important qu'ils laissent l'utilisateur spécifier ce qu'il recherche afin pouvoir prendre en compte les spécificités de chaque projet et du domaine. Il existe deux principales représentations du code : son arbre de syntaxe abstraite (Abstract Syntax Tree en anglais, ou AST) et le graphe de flot de contrôle (Control Flow Graph en anglais, ou CFG) des fonctions qui sont définies dans le code. Les mécanismes de spécification existants utilisent exclusivement l'une ou l'autre de ces représentations, ce qui est dommage car elles offrent des informations complémentaires. L'objectif de ce travail est donc de développer une méthode de vérification de la conformité du code avec des règles utilisateurs qui puissent exploiter conjointement l'AST et le CFG. La méthode repose sur une nouvelle logique développée dans le cadre de ces travaux : FO++ , qui une extension temporelle de la logique du premier ordre. Cette logique a plusieurs avantages. Tout d'abord, elle est indépendante de tout langage de programmation et dotée d'une sémantique formelle. Ensuite, elle peut être utilisée comme moyen de formaliser les règles utilisateurs une fois instanciée pour un langage de programmation donné. Enfin, l'étude de son problème de model-checking offre un mécanisme de vérification automatique et correct de la conformité du code. Ces différents concepts ont été implémentés dans Pangolin, un outil pour le langage C++. Étant donné le code à vérifier et une spécification (qui correspond à une formule de FO++ , écrite dans le langage utilisateur de Pangolin), l'outil indique si oui ou non le code respecte la spécification. Il offre de plus un résumé synthétique de l'évaluation pour pouvoir retrouver le potentiel code fautif ainsi qu'un certificat de correction du résultat. Pangolin et FO++ ont trouvé une première application dans le domaine de la robotique via l'analyse de la qualité des paquets ROS et formalisation d'un design-pattern spécifique à ROS. Une seconde application plus générale concerne le développement de programme en C++ avec la formalisation de diverses règles de bonnes pratiques pour ce langage. Enfin, on montre comment il est possible de spécifier et vérifier des règles intimement liées à un projet en vérifiant des propriétés sur Pangolin lui-mêmeThe quality of source code depends not only on its functional correctness but also on its readability, intelligibility and maintainability. This is currently an important problem in robotics where many open-source frameworks do not spread well in the industry because of uncertainty about the quality of the code. Code analysis and search tools are effective in improving these aspects. It is important that they let the user specify what she is looking for in order to be able to take into account the specific features of the project and of the domain. There exist two main representations of the source code : its Abstract Syntax Tree (AST) and the Control Flow Graph (CFG) of its functions. Existing specification mechanisms only use one of these representations, which is unfortunate because they offer complementaty information. The objective of this work is therefore to develop a method for verifying code compliance with user rules that can take benefit from both the AST and the CFG. The method is underpinned by a new logic we developed in this work : FO++ , which is a temporal extension of first-order logic. Relying on this logic has two advantages. First of all, it is independent of any programming language and has a formal semantics. Then, once instantiated for a given programming language, it can be used as a mean to formalize user provided properties. Finally, the study of its model-checking problem provides a mechanism for the automatic and correct verification of code compliance. These different concepts have been implemented in Pangolin, a tool for the C++ language. Given the code to be checked and a specification (which corresponds to an FO++ formula, written using Pangolin language), the tool indicates whether or not the code meets the specification. It also offers a summary of the evaluation in order to be able to find the code that violate the property as well as a certificate of the result correctness. Pangolin and FO++ have been applied to the field of robotics through the analysis of the quality of ROS packages and the formalization of a ROS-specific design-pattern. As a second and more general application to the development of programs in C++, we have formalized various good practice rules for this language. Finally, we have showed how it is possible to specify and verify rules that are closely related to a specific project by checking properties on the source code of Pangolin itself
18
Hecht, Geoffrey. "Détection et analyse de l'impact des défauts de code dans les applications mobiles". Thesis, Lille 1, 2016. http://www.theses.fr/2016LIL10133/document.
Texto completo da fonteResumo:
Les applications mobiles deviennent des logiciels complexes qui doivent être développés rapidement tout en évoluant de manière continue afin de répondre aux nouveaux besoins des utilisateurs ainsi qu'à des mises à jour régulières. S'adapter à ces contraintes peut provoquer la présence de mauvais choix d'implémentation ou de conception que nous appelons défauts de code. La présence de défauts de code au sein d'une application peut dégrader la qualité et les performances d'une application. Il est alors important de connaître ces défauts mais aussi de pouvoir les détecter et les corriger. Les défauts de code sont bien connus pour les applications orientés objets et de nombreux outils permettent leurs détections, mais ce n'est pas le cas pour les applications mobiles. Les connaissances concernant les défauts de code dans les applications mobiles sont lacunaires, de plus les outils permettant la détection et la correction des défauts sont inexistants ou peu matures. Nous présentons donc ici une classification de 17 défauts de code pouvant apparaître dans les applications Android, ainsi qu'un outil permettant la détection et la correction des défauts de code sur Android. Nous appliquons et validons notre méthode sur de grandes quantités d'applications (plus de 3000) dans deux études qui évaluent la présence et l'évolution du nombre des défauts de code dans des applications populaires. De plus, nous présentons aussi deux approches destinées à évaluer l'impact de la correction des défauts de code sur les performances et la consommation d'énergie. Ces approches nous ont permis d'observer que la correction des défauts de code est bénéfique dans la plupart des casMobile applications are becoming complex software systems that must be developed quickly and evolve continuously to fit new user requirements and execution contexts. However, addressing these constraints may result in poor low-level design choices, known as code smells. The presence of code smells within software systems may incidentally degrade their quality and performance, and hinder their maintenance and evolution. Thus, it is important to know this smells but also to detect and correct them. While code smells are well-known in object-oriented applications, their study in mobile applications is still in their infancy. Moreover there is a lack of tools to detect and correct them. That is why we present a classification of 17 code smells that may appear in Android applications, as well as a tool to detect and correct code smells on Android. We apply and validate our approach on large amounts of applications (over 3000) in two studies evaluating the presence and evolution of the number of code smells in popular applications. In addition, we also present two approaches to assess the impact of the correction of code smells on performance and energy consumption. These approaches have allowed us to observe that the correction of code smells is beneficial in most cases
19
Ieva, Carlo. "Révéler le contenu latent du code source : à la découverte des topoi de programme". Thesis, Montpellier, 2018. http://www.theses.fr/2018MONTS024/document.
Texto completo da fonteResumo:
Le développement de projets open source à grande échelle implique de nombreux développeurs distincts qui contribuent à la création de référentiels de code volumineux. À titre d'exemple, la version de juillet 2017 du noyau Linux (version 4.12), qui représente près de 20 lignes MLOC (lignes de code), a demandé l'effort de 329 développeurs, marquant une croissance de 1 MLOC par rapport à la version précédente. Ces chiffres montrent que, lorsqu'un nouveau développeur souhaite devenir un contributeur, il fait face au problème de la compréhension d'une énorme quantité de code, organisée sous la forme d'un ensemble non classifié de fichiers et de fonctions.Organiser le code de manière plus abstraite, plus proche de l'homme, est une tentative qui a suscité l'intérêt de la communauté du génie logiciel. Malheureusement, il n’existe pas de recette miracle ou bien d’outil connu pouvant apporter une aide concrète dans la gestion de grands bases de code.Nous proposons une approche efficace à ce problème en extrayant automatiquement des topoi de programmes, c'est à dire des listes ordonnées de noms de fonctions associés à un index de mots pertinents. Comment se passe le tri? Notre approche, nommée FEAT, ne considère pas toutes les fonctions comme égales: certaines d'entre elles sont considérées comme une passerelle vers la compréhension de capacités de haut niveau observables d'un programme. Nous appelons ces fonctions spéciales points d’entrée et le critère de tri est basé sur la distance entre les fonctions du programme et les points d’entrée. Notre approche peut être résumée selon ses trois étapes principales : 1) Preprocessing. Le code source, avec ses commentaires, est analysé pour générer, pour chaque unité de code (un langage procédural ou une méthode orientée objet), un document textuel correspondant. En outre, une représentation graphique de la relation appelant-appelé (graphe d'appel) est également créée à cette étape. 2) Clustering. Les unités de code sont regroupées au moyen d’une classification par clustering hiérarchique par agglomération (HAC). 3) Sélection du point d’entrée. Dans le contexte de chaque cluster, les unités de code sont classées et celles placées à des positions plus élevées constitueront un topos de programme.La contribution de cette thèse est triple: 1) FEAT est une nouvelle approche entièrement automatisée pour l'extraction de topoi de programme, basée sur le regroupement d'unités directement à partir du code source. Pour exploiter HAC, nous proposons une distance hybride originale combinant des éléments structurels et sémantiques du code source. HAC requiert la sélection d’une partition parmi toutes celles produites tout au long du processus de regroupement. Notre approche utilise un critère hybride basé sur la graph modularity et la cohérence textuelle pour sélectionner automatiquement le paramètre approprié. 2) Des groupes d’unités de code doivent être analysés pour extraire le programme topoi. Nous définissons un ensemble d'éléments structurels obtenus à partir du code source et les utilisons pour créer une représentation alternative de clusters d'unités de code. L’analyse en composantes principales, qui permet de traiter des données multidimensionnelles, nous permet de mesurer la distance entre les unités de code et le point d’entrée idéal. Cette distance est la base du classement des unités de code présenté aux utilisateurs finaux. 3) Nous avons implémenté FEAT comme une plate-forme d’analyse logicielle polyvalente et réalisé une étude expérimentale sur une base ouverte de 600 projets logiciels. Au cours de l’évaluation, nous avons analysé FEAT sous plusieurs angles: l’étape de mise en grappe, l’efficacité de la découverte de topoi et l’évolutivité de l’approcheDuring the development of long lifespan software systems, specification documents can become outdated or can even disappear due to the turnover of software developers. Implementing new software releases or checking whether some user requirements are still valid thus becomes challenging. The only reliable development artifact in this context is source code but understanding source code of large projects is a time- and effort- consuming activity. This challenging problem can be addressed by extracting high-level (observable) capabilities of software systems. By automatically mining the source code and the available source-level documentation, it becomes possible to provide a significant help to the software developer in his/her program understanding task.This thesis proposes a new method and a tool, called FEAT (FEature As Topoi), to address this problem. Our approach automatically extracts program topoi from source code analysis by using a three steps process: First, FEAT creates a model of a software system capturing both structural and semantic elements of the source code, augmented with code-level comments; Second, it creates groups of closely related functions through hierarchical agglomerative clustering; Third, within the context of every cluster, functions are ranked and selected, according to some structural properties, in order to form program topoi.The contributions of the thesis is three-fold:1) The notion of program topoi is introduced and discussed from a theoretical standpoint with respect to other notions used in program understanding ;2) At the core of the clustering method used in FEAT, we propose a new hybrid distance combining both semantic and structural elements automatically extracted from source code and comments. This distance is parametrized and the impact of the parameter is strongly assessed through a deep experimental evaluation ;3) Our tool FEAT has been assessed in collaboration with Software Heritage (SH), a large-scale ambitious initiative whose aim is to collect, preserve and, share all publicly available source code on earth. We performed a large experimental evaluation of FEAT on 600 open source projects of SH, coming from various domains and amounting to more than 25 MLOC (million lines of code).Our results show that FEAT can handle projects of size up to 4,000 functions and several hundreds of files, which opens the door for its large-scale adoption for program understanding
20
Foucault, Matthieu. "Organisation des développeurs open-source et fiabilité logicielle". Thesis, Bordeaux, 2015. http://www.theses.fr/2015BORD0219/document.
Texto completo da fonteResumo:
La fiabilité du logiciel, c’est-à-dire sa capacité à produire les fonctionnalités attendues, est essentielle au succès des projets de développement logiciel. Afin de garantir cette fiabilité, les développeurs ont pour objectif de réduire le nombre de bogues présents dans le code source du logiciel.Une des techniques ayant pour but d’aider les développeurs dans cette tâche est l’utilisation de métriques logicielles, et notamment de métriques liées au procédé de développement.L’objectif général de cette thèse est de contribuer à la validation de métriques de procédé en étudiant leur relation avec la fiabilité. Ces métriques, une fois validées, pourront être utilisées dans des modèles de prédiction de bogues ayant pour but de mieux orienter les efforts de maintenance des développeurs ou pourront permettre de mettre en place des lignes de conduite relatives au procédé de développement. Devant l’étendue de ce domaine, nous avons centré nos contributions sur un aspect du procédé de développement qui est l’organisation des développeurs et avons observé cette organisation dans des projets open-source.En parallèle de la validation de ces métriques, nous avons contribué à l’amélioration de la méthodologie permettant l’extraction et l’analyse de métriques, grâce aux informations contenues dans les dépôts logicielsReliability of a software, i.e. its capacity to produce the expected behaviour, is essential to the success of software projects. To ensure such reliability, developers need to reduce the amount of bugs in the source code of the software. One of the techniques available to help developers in this task is the use of software metrics, and especially metrics related to the development process.The general objective of this thesis is to contribute to the validation of process metrics, by studying their relationship with software reliability. These metrics, once validated, can be used in bug predictionmodels with the goal to guide maintenance efforts or can be used to create development guidelines. Given the extent of this domain, we chose to focus on one particular aspect of the development process, which is developers organisation, and we studied this organisation in open-source software projects.In parallel to the validation of process metrics, we contributed to the improvement of the methodology used to extract and analyse metrics, thanks to information available in software repositories
21
Haddad, Axel. "Shape-Preserving Transformations of Higher-Order Recursion Schemes". Paris 7, 2013. http://www.theses.fr/2013PA077264.
Texto completo da fonteResumo:
Les schémas de récursion modélisent les programmes fonctionnels dans le sens qu'il décrivent les définitions récursives des fonctions créées par l'utilisateur sans interpréter les fonctions de base du langage. La sémantique d'un schémas est donc l'arbre potentiellement infini décrivant les exécutions d'un programme. Cette thèse s'intéresse à des problèmes de vérification. Le problème de décider si un schémas satisfait une formule de la logique monadique du second-ordre (MSO), a été résolu par Ong en 2006. En 2010, Broadbent, Carayol, Ong et Serre ont étendu ce résultat en montrant que l'on peut transformer un schémas de telle sorte que les noeuds de l'arbre associé satisfaisant une formule MSO donnée sont marqués, ce problème est appelé le problème de réflexion. Finalement, en 2012 Carayol et Serre ont résolu le problème de sélection : si l'arbre associé à un schéma donné satisfait une formule de la forme « il existe un ensemble de noeuds tels que. . . », alors on peut transformer le schéma tel qu'un ensemble témoin de la propriété est marqué dans l'arbre associé. Dans cette thèse, nous suivons une approche sémantique pour étudier des problèmes de transformation de schémas. Notre objectif est de proposer des solutions qui conservent la structure du schémas donné en entrée. Dans cette idée, nous établissons un algorithme permettant de simuler une politique d'évaluation avec une autre. Ensuite nous donnons de nouvelles preuves de la réflexion et la sélection, sans passer par les automates à pile avec effondrement, qui conservent aussi la structure du schéma donné en entréeHigher-order recursion scheme model functional programs in the sense that they describe the recursive definitions of the user-defined functions of a pro-gram, without interpreting the built-in functions. Therefore the semantics of a higher-order recursion scheme is the (possibly infinite) tree of executions of a program. This thesis focus on verification related problems. The MSO model- checking problem, i. E. The problem of knowing whether the tree generated by a scheme satisfy an monadic second order logic (MSO) formula, has been solved by Ong in 2006. In 2010 Broadbent Carayol Ong and Serre extended this result by showing that one can transform a scheme such that the nodes in the tree satisfying a given MSO formula are marked, this problem is called the reflection problem. Finally in 2012 Carayol and Serre have solved the selection problem: if the tree of a given scheme satisfies a formula of the form "There exist a set of node such that. . . ", one can transforrn the scheme such that a set witnessing the property is marked. In this thesis, we use a semantics approach to study scheme-transformation related problems. Our goal is to give shape-preserving solutions to such problems, i. E. Solutions where the output scheme has the same structure as the input one. In this idea, we establish a simulation algorithm that takes a scheme G and an evaluation policy r E {0I,I0} and outputs a scheme G' such that the value tree of G' under the policy Tif= is equal to the value tree of G under Then we give new proofs of the reflection and selection, that do not involve collapsible pushdown automata, and are again shape-preserving
22
Ruzé, Emmanuel. "Collaboration massivement distribuée et gestion du savoir en ligne: le cas de la communauté WordPress (2003-2008). "Code is poetry", but a "documentation resource should be managed"". Phd thesis, Ecole Polytechnique X, 2009. http://pastel.archives-ouvertes.fr/pastel-00006078.
Texto completo da fonteResumo:
Le déploiement du numérique se caractérise par une montée en puissance des communautés sur Internet. Celles-ci ont permis l'émergence de formes organisationnelles significativement nouvelles intéressant les managers et supportées par les technologies de l'information, en particulier les mouvements open-source puis Web 2.0.. Cependant, l'articulation entre les modes d'organisation sous-jacents à ces deux courants parfois confondus n'a pas été comprise de façon exhaustive. En particulier, les usages de la technologie wiki se situent à la frontière entre les deux mouvements ; ils constituent un point de tensions potentiel entre les pratiques de l'open-source et les principes de « collaboration massivement distribuée » caractéristiques des sites à « contenu ouvert ». Cette thèse propose une étude de cas en profondeur, celle du déploiement dans une communauté open-source d'un système d'information fondé sur la technologie wiki et ouvert aux contributions volontaires. La communauté WordPress l'a implémenté afin de centraliser et rendre public le savoir nécessaire à la viabilité du projet. Nous montrons dans quelle mesure des formes de gouvernance ont émergé pendant l'histoire de la communauté afin de gérer ce bien informationnel collectif : formes d'articulation avec la communauté et d'appropriation du savoir, routines, collaboration structurée entre volontaires, constitution dynamique du bien collectif. Notre thèse propose donc une contribution à la compréhension des formes informelles de gouvernance qui conditionnent la viabilité des biens publics numériques. Nous adoptons une approche micro-historique sur la période 2003-2008 à partir de matériaux d'archives traités selon plusieurs méthodologies qualitatives et quantitatives. Nous montrons ensuite la fécondité des concepts de l'économie cognitive pour comprendre l'émergence des formes de gouvernance observées. Cette thèse fut en effet une collaboration entre les laboratoires CRG et CREA de l'Ecole polytechnique.
23
Halli, Abderrahmane Nassim. "Optimisation de code pour application Java haute-performance". Thesis, Université Grenoble Alpes (ComUE), 2016. http://www.theses.fr/2016GREAM047/document.
Texto completo da fonteResumo:
Java est à ce jour l'un des langages, si ce n'est le langage, le plus utilisé toutes catégories de programmation confondues et sa popularité concernant le développement d'applications scientifiques n'est plus à démontrer. Néanmoins son utilisation dans le domaine du Calcul Haute Performance (HPC) reste marginale même si elle s'inscrit au cœur de la stratégie de certaine entreprise comme Aselta Nanographics, éditeur de l'application Inscale pour la modélisation des processus de lithographie par faisceaux d'électron, instigateur et partenaire industriel de cette thèse.Et pour cause, sa définition haut-niveau et machine-indépendante, reposant sur un environnement d'exécution, parait peu compatible avec le besoin de contrôle bas-niveau nécessaire pour exploiter de manière optimale des architectures de microprocesseurs de plus en plus complexes comme les architectures Intel64 (implémentation Intel de l'architecture x86-64).Cette responsabilité est entièrement déléguée à l'environnement d'exécution, notamment par le biais de la compilation dynamique, chargée de générer du code binaire applicatif à la volée. C'est le cas de la JVM HotSpot, au centre de cette étude, qui s'est imposée comme l'environnement de référence pour l'exécution d'applications Java en production.Cette thèse propose, dans ce contexte, de répondre à la problématique suivante : comment optimiser les performances de code séquentiel Java plus particulièrement dans un environnement HotSpot/Intel64 ?Pour tenter d'y répondre, trois axes principaux ont été explorés. Le premier axe est l'analyse des performances du polymorphisme, mécanisme Java haut-niveau omniprésent dans les applications, dans le lequel on tente de mesurer l'impact du polymorphisme sur les performances du code et d'évaluer des alternatives possibles. Le second axe est l'intégration de code natif au sein des applications - afin de bénéficier d'optimisations natives - avec prise en compte du compromis coût d'intégration/qualité du code. Enfin le troisième axe est l'extension du compilateur dynamique pour des méthodes applicatives afin, là encore, de bénéficier d'optimisations natives tout en s'affranchissant du surcout inhérent à l'intégration de code natif.Ces trois axes couvrent différentes pistes exploitables dans un contexte de production qui doit intégrer certaines contraintes comme le temps de développement ou encore la maintenabilité du code. Ces pistes ont permis d'obtenir des gains de performances significatifs sur des sections de code applicatif qui demeuraient jusqu'alors très critiquesL'auteur n'a pas fourni de résumé en anglais
24
Stankay, Michal. "Prístupy ku konsolidácii programovej a dátovej základne webového serveru Techno.cz". Master's thesis, Vysoká škola ekonomická v Praze, 2008. http://www.nusl.cz/ntk/nusl-4549.
Texto completo da fonteResumo:
In this diploma thesis, I conduct a research into approaches to consolidating data base and source code base of the Techno.cz webserver, which is the subject of the consolidation. By consolidation I mean bringing the server into the state where documentation is produced according to given requirements, data base is changed in order to improve data structure and consistency and source code base is reorganised in order to unify source code upon one platform, improve file system organization and remove problematic characteristics of the source code in general. The goals of this thesis are to create and describe general process of consolidation, sequence and contents of its steps; to describe contents of consolidation in given areas: documentation, data base and source code base; to describe actual steps made to achieve the final state of the server. My approach to accomplishing these goals is the study of relevant literature and usage of my practical experience in the field of web development. My contribution to the topic is the creation of the general consolidation process that has a potential to be reused by similar projects. Another contribution may be the description of handling the risks and problems that emerged during the consolidation process. This topic may find itself as a valuable source of knowledge for fellow developers facing similar issues. The thesis is divided into eight chapters. After the introduction chapter 2 follows. Chapter 2 describes parameters of the Techno.cz webserver. Chapter 3 discusses software engineering methodologies in order to create suitable consolidation process. Chapter 4, 5, 6 discuss particular fields of consolidation: documentation, data base and source code. In chapter 7 I am trying to assess suitability of created processes and approaches for usage in future development. In the conclusion I summarize the thesis according to required structure.
25
Singh, Neeraj Kumar. "Fiabilité et sûreté des systèmes informatiques critiques". Electronic Thesis or Diss., Nancy 1, 2011. http://www.theses.fr/2011NAN10129.
Texto completo da fonteResumo:
Les systèmes informatiques envahissent notre vie quotidienne et sont devenus des éléments essentiels de chacun de nos instants de vie. La technologie de l'information est un secteur d'activités offrant des opportunités considérables pour l'innovation et cet aspect paraît sans limite. Cependant, des systèmes à logiciel intégré ont donné des résultats décevants. Selon les constats, ils étaient non fiables, parfois dangereux et ne fournissaient pas les résultats attendus. La faiblesse des pratiques de développement constitue la principale raison des échecs de ces systèmes. Ceci est dû à la complexité des logiciels modernes et au manque de connaissances adéquates et propres. Le développement logiciel fournit un cadre contribuant à simplifier la conception de systèmes complexes, afin d'en obtenir une meilleure compréhension et d'assurer une très grande qualité à un coût moindre. Dans les domaines de l'automatique, de la surveillance médicale, de l'avionique..., les systèmes embarqués hautement critiques sont candidats aux erreurs pouvant conduire à des conséquences graves en cas d'échecs. La thèse vise à résoudre ce problème, en fournissant un ensemble de techniques, d'outils et un cadre pour développer des systèmes hautement critiques, en utilisant des techniques formelles à partir de l'analyse des exigences jusqu'à la production automatique de code source, en considérant plusieurs niveaux intermédiaires. Elle est structurée en deux parties: d'une part des techniques et des outils et d'autre part des études de cas. La partie concernant des techniques et des outils présente une structure intégrant un animateur de modèles en temps-réel, un cadre de correction de modèles et le concept de charte de raffinement, un cadre de modélisation en vue de la certification, un modèle du coeur pour la modélisation en boucle fermée et des outils de générations automatiques de code. Ces cadres et outils sont utilisés pour développer les systèmes critiques à partir de l'analyse des exigences jusqu'à la production du code, en vérifiant et en validant les étapes intermédiaires en vue de fournir un modèle formel correct satisfaisant les propriétés souhaitées attendues au niveau le plus concret. L'introduction de nouveaux outils concourt à améliorer la vérification des propriétés souhaitées qui ne sont pas apparentes aux étapes initiales du développement du système. Nous évaluons les propositions faites au travers de cas d'études du domaine médical et du domaine des transports. De plus, le travail de cette thèse a étudié la représentation formelle des protocoles médicaux, afin d'améliorer les protocoles existants. Nous avons complètement formalisé un protocole réel d'interprétation des ECG, en vue d'analyser si la formalisation était conforme à certaines propriétés relevant du protocole. Le processus de vérification formelle a mis en évidence des anomalies dans les protocoles existants. Nous avons aussi découvert une structure hiérarchique pour une interprétation efficace permettant de découvrir un ensemble de conditions qui peuvent être utiles pour diagnostiquer des maladies particulières à un stade précoce. L'objectif principal du formalisme développé est de tester la correction et la consistance du protocole médicalSoftware systems are pervasive in all walks of our life and have become an essential part of our daily life. Information technology is one major area, which provides powerful and adaptable opportunities for innovation, and it seems boundless. However, systems developed using computer-based logic have produced disappointing results. According to stakeholders, they are unreliable, at times dangerous, and fail to provide the desired outcomes. Most significant reasons of system failures are the poor development practices for system development. This is due to the complex nature of modern software and lack of adequate and proper understanding. Software development provides a framework for simplifying the complex system to get a better understanding and to develop the higher fidelity quality systems at lower cost. Highly embedded critical systems, in areas such as automation, medical surveillance, avionics, etc., are susceptible to errors, which can lead to grave consequences in case of failures. This thesis intends to contribute to further the use of formal techniques for the development computing systems with high integrity. Specifically, it addresses that formal methods are not well integrated into established critical systems development processes by defining a new development life-cycle, and a set of associated techniques and tools to develop highly critical systems using formal techniques from requirements analysis to automatic source code generation using several intermediate layers with rigorous safety assessment approach. The approach has been realised using the Event-B formalism. This thesis has mainly two parts: techniques and tools and case studies. The techniques and tools section consists of development life-cycle methodology, a framework for real-time animator, refinement chart, a set of automatic code generation tools and formal logic based heart model for close loop modeling. New development methodology, and a set of associated techniques and tools are used for developing the critical systems from requirements analysis to code implementation, where verification and validation tasks are used as intermediate layers for providing a correct formal model with desired system behavior at the concrete level. Introducing new tools help to verify desired properties, which are hidden at the early stage of the system development. We also critically evaluate the proposed development methodology and developed techniques and tools through case studies in the medical and automotive domains. In addition, the thesis work tries to address the formal representation of medical protocols, which is useful for improving the existing medical protocols. We have fully formalised a real-world medical protocol (ECG interpretation) to analyse whether the formalisation complies with certain medically relevant protocol properties. The formal verification process has discovered a number of anomalies in the existing protocols. We have also discovered a hierarchical structure for the ECG interpretation efficiently that helps to find a set of conditions that can be very helpful to diagnose particular disease at the early stage. The main objective of the developed formalism is to test correctness and consistency of the medical protocol
26
Tran, Vinh Duc. "Des codes pour engendrer des langages de mots infinis". Nice, 2011. http://www.theses.fr/2011NICE4109.
Texto completo da fonteResumo:
Le sujet de cette thèse est l’étude des langages de mots infinis, en particulier les puissances infinies de langages de mots finis (puissance ω). Plus précisément, nous nous intéressons à la question ouverte suivante : étant donné un langage L, existe-t-il un ω-code tel que Cω = Lω ? Cette question est l’analogue de celle pour la concaténation finie : un sous-monoïde d’un monoïde libre est-il engendré par un code ou non ? Dans un premier temps, nous étudions l’ensemble des relateurs d’un langage L, c’est-à-dire les couples de factorisations différentes d’un même mot de L* U Lω ; nous établissons une condition nécessaire pour que Lω ait un code ou un ω-code générateur. Ensuite, nous définissons une nouvelle classe de langages : les langages à un relateur. Leur ensemble de relateurs est le plus simple possible sans qu’il soit des codes. Pour cette classe intéressante de langages, on caractérise les langages L tels qu’il existe un ω-code ou un code C tels que Lω = Cω. On montre que C ne peut pas être un langage fini. Enfin, une caractérisation des codes concernant les mots infinis nous amène à définir les langages réduits ; nous considérons les propriétés de ces langages en tant que générateurs de langages de mots infinisThis thesis deals with the languages of infinite words which are the ω-powers of a language of finite words. In particular, we focus on the open question : given a language L, does there exist an ω-code C such that Cω = Lω ? It is quite similar to the question deciding whether a submonoid of a free monoid is generated by a code. First, we study the set of relations satisfied by language L, i. E. The double factorizations of a word in L* U Lω. We establish a necessary condition for that Lω has a code or an ω-code generator. Next, we define the new class of languages where the set of relations is as simple as possible after codes : one-relation languages. For this class of languages, we characterize the languages L such that there exists a code or an ω-code C such that Lω = Cω, and we show that C is never a finite language. Finally, a characterization of codes concerning infinite words leads us to define reduced languages. We consider the properties of these languages as generators of languages of infinite words
27
Duruisseau, Mickaël. "Améliorer la compréhension d’un programme à l’aide de diagrammes dynamiques et interactifs". Thesis, Lille 1, 2019. http://www.theses.fr/2019LIL1I042/document.
Texto completo da fonteResumo:
Les développeurs occupent une place prépondérante dans le développement logiciel. Dans ce cadre, ils doivent réaliser une succession de tâches élémentaires (analyse, codage, liaison avec le code existant...), mais pour effectuer ces tâches, un développeur doit régulièrement changer de contexte de travail (recherche d’information, lecture de code…) et analyser du code qui n’est pas le sien. Ces actions nécessitent un temps d’adaptation élevé et réduisent l’efficacité du développeur. La modélisation logicielle est une solution à ce type de problème. Elle propose une vue abstraite d’un logiciel, des liens entre ses entités ainsi que des algorithmes utilisés. Cependant, l’Ingénierie Dirigée par les Modèles (IDM) est encore trop peu utilisée en entreprise. Dans cette thèse, nous proposons un outil pour améliorer la compréhension d’un programme à l’aide de diagrammes dynamiques et interactifs. Cet outil se nomme VisUML et est centré sur l’activité principale de codage du développeur. VisUML fournit des vues (sur des pages web ou sur des outils de modélisation) synchronisées avec le code. Les diagrammes UML générés sont interactifs et permettent une navigation rapide avec et dans le code. Cette navigation réduit les pertes de temps et de contextes dues aux changements d’activités en fournissant à tout moment une vue abstraite sous forme de diagramme des éléments actuellement ouverts dans l’outil de codage du développeur. Au final, VisUML a été évalué par vingt développeurs dans le cadre d’une expérimentation qualitative de l’outil afin d’estimer l’utilité d’un tel outilDevelopers dominate in software development. In this context, they must perform a succession of elementary tasks (analysis, coding, linking with existing code ...), but in order to perform these tasks, a developer must regularly change his context of work (search information, read code ...) and analyze code that is not his. These actions require a high adaptation time and reduce the efficiency of the developer. Software modeling is a solution to this type of problem. It offers an abstract view of a software, links between its entities as well as algorithms used. However, Model-Driven Engineering (MDE) is still underutilized in business. In this thesis, we propose a tool to improve the understanding of a program using dynamic and interactive diagrams. This tool is called VisUML and focuses on the main coding activity of the developer. VisUML provides views (on web pages or modeling tools) synchronized with the code.The generated UML diagrams are interactive and allow fast navigation with and in the code. This navigation reduces the loss of time and context due to activity changes by providing at any time an abstract diagram view of the elements currently open in the developer’s coding tool. In the end, VisUML was evaluated by twenty developers as part of a qualitative experimentation of the tool to estimate the usefulness of such a tool
28
Richa, Elie. "Qualification des générateurs de code source dans le domaine de l'avionique : le test automatisé des chaines de transformation de modèles". Electronic Thesis or Diss., Paris, ENST, 2015. http://www.theses.fr/2015ENST0082.
Texto completo da fonteResumo:
Dans l’industrie de l’avionique, les Générateurs Automatiques de Code (GAC) sont de plus en plus utilisés pour produire des parties du logiciel embarqué. Puisque le code généré fait partie d’un logiciel critique, les standards de sûreté exigent une vérification approfondie du GAC: la qualification. Dans cette thèse en collaboration avec AdaCore, nous cherchons à réduire le coût des activités de test par des méthodes automatiques et efficaces.La première partie de la thèse aborde le sujet du test unitaire qui assure une exhaustivité élevée mais qui est difficile à réaliser pour les GACs. Nous proposons alors une méthode qui garantit le même niveau d’exhaustivité en n’utilisant que des tests d’intégration de mise en œuvre plus facile. Nous proposons tout d’abord une formalisation du langage ATL de définition du GAC dans la théorie des Transformations Algébriques de Graphes. Nous définissons ensuite une traduction de postconditions exprimant l’exhaustivité du test unitaire en des préconditions équivalentes qui permettent à terme de produire des tests d’intégration assurant le même niveau d’exhaustivité. Enfin, nous proposons d’optimiser l’algorithme complexe de notre analyse à l’aide de stratégies de simplification dont nous mesurons expérimentalement l’efficacité.La seconde partie du travail concerne les oracles de tests du GAC, c’est à dire le moyen de valider le code généré par le GAC lors d’un test. Nous proposons un langage de spécification de contraintes textuelles capables d’attester automatiquement de la validité du code généré. Cette approche est déployée expérimentalement à AdaCore pour le projet QGen, un générateur de code Ada/C à partir de Simulink®In the avionics industry, Automatic Code Generators (ACG) are increasingly used to produce parts of the embedded software. Since the generated code is part of critical software, safety standards require a thorough verification of the ACG called qualification. In this thesis in collaboration with AdaCore, we seek to reduce the cost of testing activities by automatic and effective methods.The first part of the thesis addresses the topic of unit testing which ensures exhaustiveness but is difficult to achieve for ACGs. We propose a method that guarantees the same level of exhaustiveness by using only integration tests which are easier to carry out. First, we propose a formalization of the ATL language in which the ACG is defined in the Algebraic Graph Transformation theory. We then define a translation of postconditions expressing the exhaustiveness of unit testing into equivalent preconditions that ultimately support the production of integration tests providing the same level of exhaustiveness. Finally, we propose to optimize the complex algorithm of our analysis using simplification strategies that we assess experimentally.The second part of the work addresses the oracles of ACG tests, i.e. the means of validating the code generated by the ACG during a test. We propose a language for the specification of textual constraints able to automatically check the validity of the generated code. This approach is experimentally deployed at AdaCore for a Simulink® to Ada/C ACG called QGen
29
Xiao, Chenglong. "Custom operator identification for high-level synthesis". Rennes 1, 2012. http://www.theses.fr/2012REN1E005.
Texto completo da fonteResumo:
Il est de plus en plus fréquent de faire appel à des opérateurs spécifiques en conception de circuits. Les opérateurs spécifiques peuvent être mis en œuvre par des unités matérielles dédiées, en vue de réduire la taille du code, d’améliorer les performances et de réduire la surface du circuit. Dans cette thèse, nous proposons un flot de conception basé sur l’identification d’opérateurs spécifiques pour la synthèse de haut niveau. Les points clés de ce flot de conception sont l’énumération automatique et la sélection des opérateurs spécifiques à partir d'un code de l'application de haut niveau et la re-génération du code source intégrant les opérateurs spécifiques sélectionnés. Contrairement aux approches proposées précédemment, notre flot de conception est adaptable et est indépendant des outils de synthèse de haut niveau (il ne nécessite pas d’intervenir sur les algorithmes d’ordonnancement et de projection des outils de synthèse de haut niveau). Les résultats expérimentaux montrent que notre approche permet de réduire la surface du circuit de 19% en moyenne, et jusqu'à 37% dans certains cas, par rapport à une synthèse de haut niveau traditionnelle. La latence du circuit est réduite en moyenne de 22%, et atteint jusqu'à 59%. De plus, la taille du code est réduite de 74% en moyenneIt is increasingly common to see custom operators appear in various fields of circuit design. Custom operators that can be implemented in special hardware units make it possible to reduce code size, improve performance and reduce area. In this thesis, we propose a design flow based on custom operator identification for high-level synthesis. The key issues involved in the design flow are: automatic enumeration and selection of custom operators from a given high-level application code and re-generation of the source code incorporating the selected custom operators. Unlike the previously proposed approaches, our design flow is quite adaptable and is independent of high-level synthesis tools (i. E. , without modifying the scheduling and binding algorithms in high-level synthesis tools). Experimental results show that our approach achieves on average 19%, and up to 37% area reduction, compared to a traditional high-level synthesis. Meanwhile, the latency is reduced on average by 22%, and up to 59%. Furthermore, on average 74% and up to 81% code size reduction can be achieved
30
Gastellier-Prevost, Sophie. "Vers une détection des attaques de phishing et pharming côté client". Phd thesis, Institut National des Télécommunications, 2011. http://tel.archives-ouvertes.fr/tel-00699627.
Texto completo da fonteResumo:
Le développement de l'Internet à haut débit et l'expansion du commerce électronique ont entraîné dans leur sillage de nouvelles attaques qui connaissent un vif succès. L'une d'entre elles est particulièrement sensible dans l'esprit collectif : celle qui s'en prend directement aux portefeuilles des Internautes. Sa version la plus répandue/connue est désignée sous le terme phishing. Majoritairement véhiculée par des campagnes de spam, cette attaque vise à voler des informations confidentielles (p.ex. identifiant, mot de passe, numéro de carte bancaire) aux utilisateurs en usurpant l'identité de sites marchands et/ou bancaires. Au fur et à mesure des années, ces attaques se sont perfectionnées jusqu'à proposer des sites webs contrefaits qui visuellement - hormis l'URL visitée - imitent à la perfection les sites originaux. Par manque de vigilance, bon nombre d'utilisateurs communiquent alors - en toute confiance - des données confidentielles. Dans une première partie de cette thèse, parmi les moyens de protection/détection existants face à ces attaques, nous nous intéressons à un mécanisme facile d'accès pour l'Internaute : les barres d'outils anti-phishing, à intégrer dans le navigateur web. La détection réalisée par ces barres d'outils s'appuie sur l'utilisation de listes noires et tests heuristiques. Parmi l'ensemble des tests heuristiques utilisés (qu'ils portent sur l'URL ou le contenu de la page web), nous cherchons à évaluer leur utilité et/ou efficacité à identifier/différencier les sites légitimes des sites de phishing. Ce travail permet notamment de distinguer les heuristiques décisifs, tout en discutant de leur pérennité. Une deuxième variante moins connue de cette attaque - le pharming - peut être considérée comme une version sophistiquée du phishing. L'objectif de l'attaque reste identique, le site web visité est tout aussi ressemblant à l'original mais - a contrario du phishing - l'URL visitée est cette fois-ci elle aussi totalement identique à l'originale. Réalisées grâce à une corruption DNS amont, ces attaques ont l'avantage de ne nécessiter aucune action de communication de la part de l'attaquant : celui-ci n'a en effet qu'à attendre la visite de l'Internaute sur son site habituel. L'absence de signes "visibles" rend donc l'attaque perpétrée particulièrement efficace et redoutable, même pour un Internaute vigilant. Certes les efforts déployés côté réseau sont considérables pour répondre à cette problématique. Néanmoins, le côté client y reste encore trop exposé et vulnérable. Dans une deuxième partie de cette thèse, par le développement de deux propositions visant à s'intégrer dans le navigateur client, nous introduisons une technique de détection de ces attaques qui couple une analyse de réponses DNS à une comparaison de pages webs. Ces deux propositions s'appuient sur l'utilisation d'éléments de référence obtenus via un serveur DNS alternatif, leur principale différence résidant dans la technique de récupération de la page web de référence. Grâce à deux phases d'expérimentation, nous démontrons la viabilité du concept proposé.
31
Richa, Elie. "Qualification des générateurs de code source dans le domaine de l'avionique : le test automatisé des chaines de transformation de modèles". Thesis, Paris, ENST, 2015. http://www.theses.fr/2015ENST0082/document.
Texto completo da fonteResumo:
Dans l’industrie de l’avionique, les Générateurs Automatiques de Code (GAC) sont de plus en plus utilisés pour produire des parties du logiciel embarqué. Puisque le code généré fait partie d’un logiciel critique, les standards de sûreté exigent une vérification approfondie du GAC: la qualification. Dans cette thèse en collaboration avec AdaCore, nous cherchons à réduire le coût des activités de test par des méthodes automatiques et efficaces.La première partie de la thèse aborde le sujet du test unitaire qui assure une exhaustivité élevée mais qui est difficile à réaliser pour les GACs. Nous proposons alors une méthode qui garantit le même niveau d’exhaustivité en n’utilisant que des tests d’intégration de mise en œuvre plus facile. Nous proposons tout d’abord une formalisation du langage ATL de définition du GAC dans la théorie des Transformations Algébriques de Graphes. Nous définissons ensuite une traduction de postconditions exprimant l’exhaustivité du test unitaire en des préconditions équivalentes qui permettent à terme de produire des tests d’intégration assurant le même niveau d’exhaustivité. Enfin, nous proposons d’optimiser l’algorithme complexe de notre analyse à l’aide de stratégies de simplification dont nous mesurons expérimentalement l’efficacité.La seconde partie du travail concerne les oracles de tests du GAC, c’est à dire le moyen de valider le code généré par le GAC lors d’un test. Nous proposons un langage de spécification de contraintes textuelles capables d’attester automatiquement de la validité du code généré. Cette approche est déployée expérimentalement à AdaCore pour le projet QGen, un générateur de code Ada/C à partir de Simulink®In the avionics industry, Automatic Code Generators (ACG) are increasingly used to produce parts of the embedded software. Since the generated code is part of critical software, safety standards require a thorough verification of the ACG called qualification. In this thesis in collaboration with AdaCore, we seek to reduce the cost of testing activities by automatic and effective methods.The first part of the thesis addresses the topic of unit testing which ensures exhaustiveness but is difficult to achieve for ACGs. We propose a method that guarantees the same level of exhaustiveness by using only integration tests which are easier to carry out. First, we propose a formalization of the ATL language in which the ACG is defined in the Algebraic Graph Transformation theory. We then define a translation of postconditions expressing the exhaustiveness of unit testing into equivalent preconditions that ultimately support the production of integration tests providing the same level of exhaustiveness. Finally, we propose to optimize the complex algorithm of our analysis using simplification strategies that we assess experimentally.The second part of the work addresses the oracles of ACG tests, i.e. the means of validating the code generated by the ACG during a test. We propose a language for the specification of textual constraints able to automatically check the validity of the generated code. This approach is experimentally deployed at AdaCore for a Simulink® to Ada/C ACG called QGen
32
Singh, Neeraj Kumar. "Fiabilité et sûreté des systèmes informatiques critiques". Thesis, Nancy 1, 2011. http://www.theses.fr/2011NAN10129/document.
Texto completo da fonteResumo:
Les systèmes informatiques envahissent notre vie quotidienne et sont devenus des éléments essentiels de chacun de nos instants de vie. La technologie de l'information est un secteur d'activités offrant des opportunités considérables pour l'innovation et cet aspect paraît sans limite. Cependant, des systèmes à logiciel intégré ont donné des résultats décevants. Selon les constats, ils étaient non fiables, parfois dangereux et ne fournissaient pas les résultats attendus. La faiblesse des pratiques de développement constitue la principale raison des échecs de ces systèmes. Ceci est dû à la complexité des logiciels modernes et au manque de connaissances adéquates et propres. Le développement logiciel fournit un cadre contribuant à simplifier la conception de systèmes complexes, afin d'en obtenir une meilleure compréhension et d'assurer une très grande qualité à un coût moindre. Dans les domaines de l'automatique, de la surveillance médicale, de l'avionique..., les systèmes embarqués hautement critiques sont candidats aux erreurs pouvant conduire à des conséquences graves en cas d'échecs. La thèse vise à résoudre ce problème, en fournissant un ensemble de techniques, d'outils et un cadre pour développer des systèmes hautement critiques, en utilisant des techniques formelles à partir de l'analyse des exigences jusqu'à la production automatique de code source, en considérant plusieurs niveaux intermédiaires. Elle est structurée en deux parties: d'une part des techniques et des outils et d'autre part des études de cas. La partie concernant des techniques et des outils présente une structure intégrant un animateur de modèles en temps-réel, un cadre de correction de modèles et le concept de charte de raffinement, un cadre de modélisation en vue de la certification, un modèle du coeur pour la modélisation en boucle fermée et des outils de générations automatiques de code. Ces cadres et outils sont utilisés pour développer les systèmes critiques à partir de l'analyse des exigences jusqu'à la production du code, en vérifiant et en validant les étapes intermédiaires en vue de fournir un modèle formel correct satisfaisant les propriétés souhaitées attendues au niveau le plus concret. L'introduction de nouveaux outils concourt à améliorer la vérification des propriétés souhaitées qui ne sont pas apparentes aux étapes initiales du développement du système. Nous évaluons les propositions faites au travers de cas d'études du domaine médical et du domaine des transports. De plus, le travail de cette thèse a étudié la représentation formelle des protocoles médicaux, afin d'améliorer les protocoles existants. Nous avons complètement formalisé un protocole réel d'interprétation des ECG, en vue d'analyser si la formalisation était conforme à certaines propriétés relevant du protocole. Le processus de vérification formelle a mis en évidence des anomalies dans les protocoles existants. Nous avons aussi découvert une structure hiérarchique pour une interprétation efficace permettant de découvrir un ensemble de conditions qui peuvent être utiles pour diagnostiquer des maladies particulières à un stade précoce. L'objectif principal du formalisme développé est de tester la correction et la consistance du protocole médicalSoftware systems are pervasive in all walks of our life and have become an essential part of our daily life. Information technology is one major area, which provides powerful and adaptable opportunities for innovation, and it seems boundless. However, systems developed using computer-based logic have produced disappointing results. According to stakeholders, they are unreliable, at times dangerous, and fail to provide the desired outcomes. Most significant reasons of system failures are the poor development practices for system development. This is due to the complex nature of modern software and lack of adequate and proper understanding. Software development provides a framework for simplifying the complex system to get a better understanding and to develop the higher fidelity quality systems at lower cost. Highly embedded critical systems, in areas such as automation, medical surveillance, avionics, etc., are susceptible to errors, which can lead to grave consequences in case of failures. This thesis intends to contribute to further the use of formal techniques for the development computing systems with high integrity. Specifically, it addresses that formal methods are not well integrated into established critical systems development processes by defining a new development life-cycle, and a set of associated techniques and tools to develop highly critical systems using formal techniques from requirements analysis to automatic source code generation using several intermediate layers with rigorous safety assessment approach. The approach has been realised using the Event-B formalism. This thesis has mainly two parts: techniques and tools and case studies. The techniques and tools section consists of development life-cycle methodology, a framework for real-time animator, refinement chart, a set of automatic code generation tools and formal logic based heart model for close loop modeling. New development methodology, and a set of associated techniques and tools are used for developing the critical systems from requirements analysis to code implementation, where verification and validation tasks are used as intermediate layers for providing a correct formal model with desired system behavior at the concrete level. Introducing new tools help to verify desired properties, which are hidden at the early stage of the system development. We also critically evaluate the proposed development methodology and developed techniques and tools through case studies in the medical and automotive domains. In addition, the thesis work tries to address the formal representation of medical protocols, which is useful for improving the existing medical protocols. We have fully formalised a real-world medical protocol (ECG interpretation) to analyse whether the formalisation complies with certain medically relevant protocol properties. The formal verification process has discovered a number of anomalies in the existing protocols. We have also discovered a hierarchical structure for the ECG interpretation efficiently that helps to find a set of conditions that can be very helpful to diagnose particular disease at the early stage. The main objective of the developed formalism is to test correctness and consistency of the medical protocol
33
Robillard, Benoît. "Verification formelle et optimisation de l’allocation de registres". Electronic Thesis or Diss., Paris, CNAM, 2010. http://www.theses.fr/2010CNAM0730.
Texto completo da fonteResumo:
La prise de conscience générale de l'importance de vérifier plus scrupuleusement les programmes a engendré une croissance considérable des efforts de vérification formelle de programme durant cette dernière décennie. Néanmoins, le code qu'exécute l'ordinateur, ou code exécutable, n'est pas le code écrit par le développeur, ou code source. La vérification formelle de compilateurs est donc un complément indispensable à la vérification de code source.L'une des tâches les plus complexes de compilation est l'allocation de registres. C'est lors de celle-ci que le compilateur décide de la façon dont les variables du programme sont stockées en mémoire durant son exécution. La mémoire comporte deux types de conteneurs : les registres, zones d'accès rapide, présents en nombre limité, et la pile, de capacité supposée suffisamment importante pour héberger toutes les variables d'un programme, mais à laquelle l'accès est bien plus lent. Le but de l'allocation de registres est de tirer au mieux parti de la rapidité des registres, car une allocation de registres de bonne qualité peut conduire à une amélioration significative du temps d'exécution du programme.Le modèle le plus connu de l'allocation de registres repose sur la coloration de graphe d'interférence-affinité. Dans cette thèse, l'objectif est double : d'une part vérifier formellement des algorithmes connus d'allocation de registres par coloration de graphe, et d'autre part définir de nouveaux algorithmes optimisants pour cette étape de compilation. Nous montrons tout d'abord que l'assistant à la preuve Coq est adéquat à la formalisation d'algorithmes d'allocation de registres par coloration de graphes. Nous procédons ainsi à la vérification formelle en Coq d'un des algorithmes les plus classiques d'allocation de registres par coloration de graphes, l'Iterated Register Coalescing (IRC), et d'une généralisation de celui-ci permettant à un utilisateur peu familier du système Coq d'implanter facilement sa propre variante de cet algorithme au seul prix d'une éventuelle perte d'efficacité algorithmique. Ces formalisations nécessitent des réflexions autour de la formalisation des graphes d'interférence-affinité, de la traduction sous forme purement fonctionnelle d'algorithmes impératifs et de l'efficacité algorithmique, la terminaison et la correction de cette version fonctionnelle. Notre implantation formellement vérifiée de l'IRC a été intégrée à un prototype du compilateur CompCert.Nous avons ensuite étudié deux représentations intermédiaires de programmes, dont la forme SSA, et exploité leurs propriétés pour proposer de nouvelles approches de résolution optimale de la fusion, l'une des optimisations opéréeslors de l'allocation de registres dont l'impact est le plus fort sur la qualité du code compilé. Ces approches montrent que des critères de fusion tenant compte de paramètres globaux du graphe d'interférence-affinité, tels que sa largeur d'arbre, ouvrent la voie vers de nouvelles méthodes de résolution potentiellement plus performantesThe need for trustful programs led to an increasing use of formal verication techniques the last decade, and especially of program proof. However, the code running on the computer is not the source code, i.e. the one written by the developper, since it has to betranslated by the compiler. As a result, the formal verication of compilers is required to complete the source code verication. One of the hardest phases of compilation is register allocation. Register allocation is the phase within which the compiler decides where the variables of the program are stored in the memory during its execution. The are two kinds of memory locations : a limited number of fast-access zones, called registers, and a very large but slow-access stack. The aim of register allocation is then to make a great use of registers, leading to a faster runnable code.The most used model for register allocation is the interference graph coloring one. In this thesis, our objective is twofold : first, formally verifying some well-known interference graph coloring algorithms for register allocation and, second, designing new graph-coloring register allocation algorithms. More precisely, we provide a fully formally veri ed implementation of the Iterated Register Coalescing, a very classical graph-coloring register allocation heuristics, that has been integrated into the CompCert compiler. We also studied two intermediate representations of programs used in compilers, and in particular the SSA form to design new algorithms, using global properties of the graph rather than local criteria currently used in the litterature
34
David, Robin. "Formal Approaches for Automatic Deobfuscation and Reverse-engineering of Protected Codes". Electronic Thesis or Diss., Université de Lorraine, 2017. http://www.theses.fr/2017LORR0013.
Texto completo da fonteResumo:
L’analyse de codes malveillants est un domaine de recherche en pleine expansion de par la criticité des infrastructures touchées et les coûts impliqués de plus en plus élevés. Ces logiciels utilisent fréquemment différentes techniques d’évasion visant à limiter la détection et ralentir les analyses. Parmi celles-ci, l’obfuscation permet de cacher le comportement réel d’un programme. Cette thèse étudie l’utilité de l’Exécution Symbolique Dynamique (DSE) pour la rétro-ingénierie. Tout d’abord, nous proposons deux variantes du DSE plus adaptées aux codes protégés. La première est une redéfinition générique de la phase de calcul de prédicat de chemin basée sur une manipulation flexible des concrétisations et symbolisations tandis que la deuxième se base sur un algorithme d’exécution symbolique arrière borné. Ensuite, nous proposons différentes combinaisons avec d’autres techniques d’analyse statique afin de tirer le meilleur profit de ces algorithmes. Enfin tous ces algorithmes ont été implémentés dans différents outils, Binsec/se, Pinsec et Idasec, puis testés sur différents codes malveillants et packers. Ils ont permis de détecter et contourner avec succès les obfuscations ciblées dans des cas d’utilisations réels tel que X-Tunnel du groupe APT28/SednitMalware analysis is a growing research field due to the criticity and variety of assets targeted as well as the increasing implied costs. These softwares frequently use evasion tricks aiming at hindering detection and analysis techniques. Among these, obfuscation intent to hide the program behavior. This thesis studies the potential of Dynamic Symbolic Execution (DSE) for reverse-engineering. First, we propose two variants of DSE algorithms adapted and designed to fit on protected codes. The first is a flexible definition of the DSE path predicate computation based on concretization and symbolization. The second is based on the definition of a backward-bounded symbolic execution algorithm. Then, we show how to combine these techniques with static analysis in order to get the best of them. Finally, these algorithms have been implemented in different tools Binsec/se, Pinsec and Idasec interacting alltogether and tested on several malicious codes and commercial packers. Especially, they have been successfully used to circumvent and remove the obfuscation targeted in real-world malwares like X-Tunnel from the famous APT28/Sednit group
35
Tigori, Kabland Toussaint Gautier. "Méthode de génération d’exécutif temps-réel". Thesis, Ecole centrale de Nantes, 2016. http://www.theses.fr/2016ECDN0019.
Texto completo da fonteResumo:
Dans les systèmes embarqués, la spécialisation ou la configuration des systèmes d’exploitation temps réel en fonction des besoins de l’application consiste en la suppression des services inutiles du système d’exploitation. Cela a non seulement pour but d’optimiser l’empreinte mémoire occupée par le système d’exploitation temps réel, afin de satisfaire les contraintes de mémoire auxquelles les systèmes embarqués font face, mais aussi de réduire la quantité de code mort au sein du système d’exploitation temps réel afin d’améliorer la sureté de fonctionnement. Dans nos travaux de thèse, nous nous intéressons à l’utilisation des méthodes formelles dans le processus de spécialisation des systèmes d’exploitation temps réel. Une difficulté majeure dans l’utilisation de modèles formels est la distance entre le modèle et le système modélisé. Nous proposons donc de modéliser le système d’exploitation de telle sorte que le modèle embarque son code source et les structures de données manipulées. Nous utilisons à cet effet un modèle à états finis (éventuellement temporisé) augmenté par des variables discrètes et des séquences d’instructions, considérées comme atomiques, manipulant ces variables. À partir du modèle du système d’exploitation et d’un modèle de l’application visée, l’ensemble des états accessibles du modèle du système d’exploitation traduisant le code effectivement utilisé lors de l’exécution de l’application est calculé. Le code source du système d’exploitation spécialisé est extrait de ce modèle élagué. L’ensemble de la démarche exposée est mise en oeuvre avec Trampoline, un système d’exploitation temps réel basée sur les standards OSEK/VDX et AUTOSAR. Cette technique de spécialisation garantit l’absence de code mort, minimise l’empreinte mémoire et fournit un modèle formel du système d’exploitation utilisable dans une étape ultérieure de modelchecking. Dans ce cadre, nous proposons une technique automatique de vérification formelle de la conformité aux standards OSEK/VDX et AUTOSAR à l’aide d’observateurs génériquesIn embedded systems, specialization or configuration of real-time operating systems according to the application requirements consists to remove the operating system services that are not needed by the application. This operation allows both to optimize the memory footprint occupied by the real-time operating system in order to meet the memory constraints in embedded systems and to reduce the amount of dead code inside the real-time operating system in order to improve its reliability. In this thesis, we focus on the use of formal methods to specialize real-time operating systems according applications. One major difficulty using formal models is the gap between the system model and its implementation. Thus, we propose to model the operating system so that the model embeds its source code and manipulated data structures. For this purpose, we use finite state model (possibly timed model) with discrete variables and sequences of instructions which are considered as atomic manipulating these variables. From the operating system model and an application model, the set of reachable states of the operating system model describing the code needed during application execution is computed. Thus, the source code of the specialized operating system is extracted from the pruned model. The overall approach is implemented with Trampoline, a real-time operating system based on OSEK/VDX and AUTOSAR standards. This specialization technique ensures the absence of dead code, minimizes the memory footprint and provides a formal model of the operating system used in a last step to check its behavior by using model checking. In this context, we propose an automatic formal verification technique that allows to check the operating systems according OSEK/VDX and AUTOSAR standards using generic observers
36
Noureddine, Adel. "Vers une meilleure compréhension de la consommation énergétique des systèmes logiciels". Phd thesis, Université des Sciences et Technologie de Lille - Lille I, 2014. http://tel.archives-ouvertes.fr/tel-00961346.
Texto completo da fonteResumo:
Avec l'augmentation de l'utilisation des ordinateurs et des appareils mobiles, et la hausse du prix de l'électricité, la gestion énergétique des logiciels est devenue une nécessité pour des logiciels, appareils et services durables. La consommation énergétique augmente dans les technologies informatiques, notamment à cause de l'augmentation de l'utilisation des services web et distribuée, l'informatique dans les nuages, ou les appareils mobiles. Par conséquent, des approches de gestion de l'énergie ont été développées, de l'optimisation du code des logiciels, à des stratégies d'adaptation basées sur l'utilisation des ressources matérielles. Afin de répondre à ces lacunes, nous présentons dans cette thèse, des modèles énergétiques, approches et outils pour estimer fidèlement la consommation énergétique des logiciels, au niveau de l'application, et au niveau du code, et pour inférer le modèle d'évolution énergétique des méthodes basé sur leurs paramètres d'entrées. Nous proposons aussi Jalen et Jalen Unit, des frameworks énergétiques pour estimer la consommation énergétique de chaque portion de code de l'application, et pour inférer le modèle d'évolution énergétique des méthodes en se basant sur des études et expériences empiriques. En utilisant des modèles énergétiques et d'outils d'estimations logicielles, nous pouvons proposer des informations énergétiques précises sans avoir besoin de wattmètres ou d'investissement de matériels de mesures énergétiques. Les informations énergétiques que nous proposons, offrent aussi aux approches de gestion énergétique des mesures directes et précises pour leurs approches d'adaptations et d'optimisations énergétiques. Ces informations énergétiques établissent aussi un modèle d'évolution énergétique des logiciels en se basant sur leurs paramètres d'entrées. Cela offre aux développeurs une connaissance plus profonde sur l'efficacité énergétique dans les logiciels. Cette connaissance amènera les développeurs à choisir un certain code au lieu d'un autre en se basant sur son efficacité énergétique. Les expérimentations utilisant l'implémentation de nos modèles énergétiques offrent des informations importantes sur comment et où l'énergie est consommée dans les logiciels. Plus particulièrement, nous proposons des comparaisons empiriques des langages de programmation (LP), des implémentations d'algorithmes, du coût de l'utilisation d'une machine virtuelle dans les LP, des options des compilateurs, et des primitives d'entrées/sorties. Nos outils permettent aussi de détecter les hotspots énergétiques dans les logiciels, permettant ainsi de focaliser sur les principaux endroits où davantage d'études sont nécessaires pour l'optimisation énergétique. Finalement, nous démontrons comment notre framework d'étude empirique permet de détecter les modèles d'évolution énergétique en se basant sur les stratégies d'évolution des paramètres d'entrées. Grâce à notre contribution, nous visons d'évoluer la connaissance dans le domaine de la consommation énergétique dans les logiciels, en proposant des modèles, des approches et des outils pour mesurer avec précision la consommation énergétique à des grains plus fins. En un mot, nous avons construit un microscope logiciel et énergétique, et avons mener des expérimentations afin de comprendre comment l'énergie est consommée dans les logiciels, et les chemins à prendre pour produire des logiciels optimisés énergétiquement.
37
Lassus, Saint-Genies Hugues de. "Elementary functions : towards automatically generated, efficient, and vectorizable implementations". Thesis, Perpignan, 2018. http://www.theses.fr/2018PERP0010/document.
Texto completo da fonteResumo:
Les fonctions élémentaires sont utilisées dans de nombreux codes de calcul haute performance. Bien que les bibliothèques mathématiques (libm) auxquelles font appel ces codes proposent en général plusieurs variétés d'une même fonction, celles-ci sont figées lors de leur implémentation. Cette caractéristique représente un frein à la performance des programmes qui les utilisent car elles sont conçues pour être polyvalentes au détriment d'optimisations spécifiques. De plus, la duplication de modèles partagés rend la maintenance de ces libms plus difficile et sujette à l'introduction de bugs. Un défi actuel est de proposer des "méta-outils" visant la génération automatique de code performant pour l'évaluation des fonctions élémentaires. Ces outils doivent permettre la réutilisation d'algorithmes efficaces et génériques pour différentes variétés de fonctions ou architectures matérielles. Il devient alors possible de générer des libms optimisées pour des besoins très spécifiques avec du code générateur factorisé, qui facilite sa maintenance. Dans un premier temps, nous proposons un algorithme original permettant de générer des tables sans erreur pour les fonctions trigonométriques et hyperboliques. Puis nous étudions les performances de schémas d'évaluation polynomiale vectorisés, premier pas vers la génération de fonctions vectorisées efficaces. Enfin, nous proposons une méta-implémentation d'un logarithme vectorisé, factorisant la génération de code pour différents formats et architectures. Ces contributions sont compétitives comparées à d'autres solutions, justifiant le développement de tels méta-codesElementary mathematical functions are pervasive in many high performance computing programs. However, although the mathematical libraries (libms), on which these programs rely, generally provide several flavors of the same function, these are fixed at implementation time. Hence this monolithic characteristic of libms is an obstacle for the performance of programs relying on them, because they are designed to be versatile at the expense of specific optimizations. Moreover, the duplication of shared patterns in the source code makes maintaining such code bases more error prone and difficult. A current challenge is to propose "meta-tools" targeting automated high performance code generation for the evaluation of elementary functions. These tools must allow reuse of generic and efficient algorithms for different flavours of functions or hardware architectures. Then, it becomes possible to generate optimized tailored libms with factorized generative code, which eases its maintenance. First, we propose an novel algorithm that allows to generate lookup tables that remove rounding errors for trigonometric and hyperbolic functions. The, we study the performance of vectorized polynomial evaluation schemes, a first step towards the generation of efficient vectorized elementary functions. Finally, we develop a meta-implementation of a vectorized logarithm, which factors code generation for different formats and architectures. Our contributions are shown competitive compared to free or commercial solutions, which is a strong incentive to push for developing this new paradigm
38
Abdallah, Rouwaida. "Implementability of distributed systems described with scenarios". Phd thesis, École normale supérieure de Cachan - ENS Cachan, 2013. http://tel.archives-ouvertes.fr/tel-00919684.
Texto completo da fonteResumo:
Distributed systems lie at the heart of many modern applications (social networks, web services, etc.). However, developers face many challenges in implementing distributed systems. The major one we focus on is avoiding the erroneous behaviors, that do not appear in the requirements of the distributed system, and that are caused by the concurrency between the entities of this system. The automatic code generation from requirements of distributed systems remains an old dream. In this thesis, we consider the automatic generation of a skeleton of code covering the interactions between the entities of a distributed system. This allows us to avoid the erroneous behaviors caused by the concurrency. Then, in a later step, this skeleton can be completed by adding and debugging the code that describes the local actions happening on each entity independently from its interactions with the other entities. The automatic generation that we consider is from a scenario-based specification that formally describes the interactions within informal requirements of a distributed system. We choose High-level Message Sequence Charts (HMSCs for short) as a scenario-based specification for the many advantages that they present: namely the clear graphical and textual representations, and the formal semantics. The code generation from HMSCs requires an intermediate step, called "Synthesis" which is their transformation into an abstract machine model that describes the local views of the interactions by each entity (A machine representing an entity defines sequences of messages sending and reception). Then, from the abstract machine model, the skeleton's code generation becomes an easy task. A very intuitive abstract machine model for the synthesis of HMSCs is the Communicating Finite State Machine (CFSMs). However, the synthesis from HMSCs into CFSMs may produce programs with more behaviors than described in the specifications in general. We thus restrict then our specifications to a sub-class of HMSCs named "local HMSC". We show that for any local HMSC, behaviors can be preserved by addition of communication controllers that intercept messages to add stamping information before resending them. We then propose a new technique that we named "localization" to transform an arbitrary HMSC specification into a local HMSC, hence allowing correct synthesis. We show that this transformation can be automated as a constraint optimization problem. The impact of modifications brought to the original specification can be minimized with respect to a cost function. Finally, we have implemented the synthesis and the localization approaches into an existing tool named SOFAT. We have, in addition, implemented to SOFAT the automatic code generation of a Promela code and a JAVA code for REST based web services from HMSCs.
39
El, Moussawi Ali Hassan. "SIMD-aware word length optimization for floating-point to fixed-point conversion targeting embedded processors". Thesis, Rennes 1, 2016. http://www.theses.fr/2016REN1S150/document.
Texto completo da fonteResumo:
Afin de limiter leur coût et/ou leur consommation électrique, certains processeurs embarqués sacrifient le support matériel de l'arithmétique à virgule flottante. Pourtant, pour des raisons de simplicité, les applications sont généralement spécifiées en utilisant l'arithmétique à virgule flottante. Porter ces applications sur des processeurs embarqués de ce genre nécessite une émulation logicielle de l'arithmétique à virgule flottante, qui peut sévèrement dégrader la performance. Pour éviter cela, l'application est converti pour utiliser l'arithmétique à virgule fixe, qui a l'avantage d'être plus efficace à implémenter sur des unités de calcul entier. La conversion de virgule flottante en virgule fixe est une procédure délicate qui implique des compromis subtils entre performance et précision de calcul. Elle permet, entre autre, de réduire la taille des données pour le coût de dégrader la précision de calcul. Par ailleurs, la plupart de ces processeurs fournissent un support pour le calcul vectoriel de type SIMD (Single Instruction Multiple Data) afin d'améliorer la performance. En effet, cela permet l'exécution d'une opération sur plusieurs données en parallèle, réduisant ainsi le temps d'exécution. Cependant, il est généralement nécessaire de transformer l'application pour exploiter les unités de calcul vectoriel. Cette transformation de vectorisation est sensible à la taille des données ; plus leurs tailles diminuent, plus le taux de vectorisation augmente. Il apparaît donc un compromis entre vectorisation et précision de calcul. Plusieurs travaux ont proposé des méthodologies permettant, d'une part la conversion automatique de virgule flottante en virgule fixe, et d'autre part la vectorisation automatique. Dans l'état de l'art, ces deux transformations sont considérées indépendamment, pourtant elles sont fortement liées. Dans ce contexte, nous étudions la relation entre ces deux transformations, dans le but d'exploiter efficacement le compromis entre performance et précision de calcul. Ainsi, nous proposons d'abord un algorithme amélioré pour l'extraction de parallélisme SLP (Superword Level Parallelism ; une technique de vectorisation). Puis, nous proposons une nouvelle méthodologie permettant l'application conjointe de la conversion de virgule flottante en virgule fixe et de l'exploitation du SLP. Enfin, nous implémentons cette approche sous forme d'un flot de compilation source-à-source complètement automatisé, afin de valider ces travaux. Les résultats montrent l'efficacité de cette approche, dans l'exploitation du compromis entre performance et précision, vis-à-vis d'une approche classique considérant ces deux transformations indépendammentIn order to cut-down their cost and/or their power consumption, many embedded processors do not provide hardware support for floating-point arithmetic. However, applications in many domains, such as signal processing, are generally specified using floating-point arithmetic for the sake of simplicity. Porting these applications on such embedded processors requires a software emulation of floating-point arithmetic, which can greatly degrade performance. To avoid this, the application is converted to use fixed-point arithmetic instead. Floating-point to fixed-point conversion involves a subtle tradeoff between performance and precision ; it enables the use of narrower data word lengths at the cost of degrading the computation accuracy. Besides, most embedded processors provide support for SIMD (Single Instruction Multiple Data) as a mean to improve performance. In fact, this allows the execution of one operation on multiple data in parallel, thus ultimately reducing the execution time. However, the application should usually be transformed in order to take advantage of the SIMD instruction set. This transformation, known as Simdization, is affected by the data word lengths ; narrower word lengths enable a higher SIMD parallelism rate. Hence the tradeoff between precision and Simdization. Many existing work aimed at provide/improving methodologies for automatic floating-point to fixed-point conversion on the one side, and Simdization on the other. In the state-of-the-art, both transformations are considered separately even though they are strongly related. In this context, we study the interactions between these transformations in order to better exploit the performance/accuracy tradeoff. First, we propose an improved SLP (Superword Level Parallelism) extraction (an Simdization technique) algorithm. Then, we propose a new methodology to jointly perform floating-point to fixed-point conversion and SLP extraction. Finally, we implement this work as a fully automated source-to-source compiler flow. Experimental results, targeting four different embedded processors, show the validity of our approach in efficiently exploiting the performance/accuracy tradeoff compared to a typical approach, which considers both transformations independently
40
Cornu, Benoit. "Automatic analysis and repair of exception bugs for java programs". Thesis, Lille 1, 2015. http://www.theses.fr/2015LIL10212/document.
Texto completo da fonteResumo:
Le monde est de plus en plus informatisé. Il y a de plus en plus de logiciels en cours d'exécution partout, depuis les ordinateurs personnels aux serveurs de données, et à l'intérieur de la plupart des nouvelles inventions connectées telles que les montres ou les machines à laver intelligentes. Toutes ces technologies utilisent des applications logicielles pour effectuer les taches pour lesquelles elles sont conçus. Malheureusement, le nombre d'erreurs de logiciels croît avec le nombre d'applications logicielles.Dans cette thèse, nous ciblons spécifiquement deux problèmes:Problème n°1: Il ya un manque d'informations de débogage pour les bugs liés à des exceptions.Cela entrave le processus de correction de bogues. Pour rendre la correction des bugs liées aux exceptions plus facile, nous allons proposer des techniques pour enrichir les informations de débogage.Ces techniques sont entièrement automatisées et fournissent des informations sur la cause et les possibilités de gestion des exceptions.Problème n ° 2: Il y a des exceptions inattendues lors de l'exécution pour lesquelles il n'y a pas de code pour gérer l'erreur.En d'autres termes, les mécanismes de résilience actuels contre les exceptions ne sont pas suffisamment efficaces. Nous proposons de nouvelles capacités de résilience qui gérent correctement les exceptions qui n'ont jamais été rencontrées avant. Nous présentons quatre contributions pour résoudre les deux problèmes présentésThe world is day by day more computerized. There is more and more software running everywhere, from personal computers to data servers, and inside most of the new popularized inventions such as connected watches or intelligent washing machines. All of those technologies use software applications to perform the services they are designed for. Unfortunately, the number of software errors grows with the number of software applications. In isolation, software errors are often annoyances, perhaps costing one person a few hours of work when their accounting application crashes.Multiply this loss across millions of people and consider that even scientific progress is delayed or derailed by software error: in aggregate, these errors are now costly to society as a whole.We specifically target two problems:Problem #1: There is a lack of debug information for the bugs related to exceptions.This hinders the bug fixing process.To make bug fixing of exceptions easier, we will propose techniques to enrich the debug information.Those techniques are fully automated and provide information about the cause and the handling possibilities of exceptions.Problem #2: There are unexpected exceptions at runtime for which there is no error-handling code.In other words, the resilience mechanisms against exceptions in the currently existing (and running) applications is insufficient.We propose resilience capabilities which correctly handle exceptions that were never foreseen at specification time neither encountered during development or testing. In this thesis, we aim at finding solutions to those problems. We present four contributions to address the two presented problems
41
Serrano, Lucas. "Automatic inference of system software transformation rules from examples". Electronic Thesis or Diss., Sorbonne université, 2020. http://www.theses.fr/2020SORUS425.
Texto completo da fonteResumo:
Le noyau Linux est aujourd'hui présent dans tous les types de systèmes informatiques, des smartphones aux supercalculateurs, comprenant à la fois le matériel le plus récent et les systèmes "anciens". Cette diversité d'environnement a pour conséquence une base de code importante, d'une dizaine de millions de lignes de code, pour les pilotes matériels. Cependant par souci d'introduction de nouvelles fonctionnalités, ou pour des raisons de performance ou de sécurité, certaines interfaces de programmation (APIs) internes doivent être parfois revues, ce qui peut impliquer des changements pour des milliers de pilotes les utilisant.Cette thèse propose une nouvelle approche, Spinfer, permettant d'effectuer ces migrations d'utilisation d'APIs de manière automatique. Cette nouvelle approche, basée sur l'assemblage de motifs en suivant des contraintes de flot de contrôle, est capable d'apprendre à partir d'exemples, même imparfaits, des règles de transformations adaptées aux enjeux des migrations d'utilisations d'APIs dans le noyau LinuxThe Linux kernel is present today in all kinds of computing environments, from smartphones to supercomputers, including both the latest hardware and "ancient" systems. This multiplicity of environments has come at the expense of a large code size, of approximately ten million lines of code, dedicated to device drivers. However, to add new functionalities, or for performance or security reasons, some internal Application Programming Interfaces (APIs) can be redesigned, triggering the need for changes of potentially thousands of drivers using them.This thesis proposes a novel approach, Spinfer, that can automatically perform these API usage updates. This new approach, based on pattern assembly constrained by control-flow relationships, can learn transformation rules from even imperfect examples. Learned rules are suitable for the challenges found in Linux kernel API usage updates
42
Van, Assche Gilles. "Information-Theoretic aspects of quantum key distribution". Doctoral thesis, Universite Libre de Bruxelles, 2005. http://hdl.handle.net/2013/ULB-DIPOT:oai:dipot.ulb.ac.be:2013/211050.
Texto completo da fonteResumo:
La distribution quantique de clés est une technique cryptographique permettant l'échange de clés secrètes dont la confidentialité est garantie par les lois de la mécanique quantique. Le comportement particulier des particules élémentaires est exploité. En effet, en mécanique quantique, toute mesure sur l'état d'une particule modifie irrémédiablement cet état. En jouant sur cette propriété, deux parties, souvent appelées Alice et Bob, peuvent encoder une clé secrète dans des porteurs quantiques tels que des photons uniques. Toute tentative d'espionnage demande à l'espion, Eve, une mesure de l'état du photon qui transmet un bit de clé et donc se traduit par une perturbation de l'état. Alice et Bob peuvent alors se rendre compte de la présence d'Eve par un nombre inhabituel d'erreurs de transmission.
L'information échangée par la distribution quantique n'est pas directement utilisable mais doit être d'abord traitée. Les erreurs de transmissions, qu'elles soient dues à un espion ou simplement à du bruit dans le canal de communication, doivent être corrigées grâce à une technique appelée réconciliation. Ensuite, la connaissance partielle d'un espion qui n'aurait perturbé qu'une partie des porteurs doit être supprimée de la clé finale grâce à une technique dite d'amplification de confidentialité.
Cette thèse s'inscrit dans le contexte de la distribution quantique de clé où les porteurs sont des états continus de la lumière. En particulier, une partie importante de ce travail est consacrée au traitement de l'information continue échangée par un protocole particulier de distribution quantique de clés, où les porteurs sont des états cohérents de la lumière. La nature continue de cette information implique des aménagements particuliers des techniques de réconciliation, qui ont surtout été développées pour traiter l'information binaire. Nous proposons une technique dite de réconciliation en tranches qui permet de traiter efficacement l'information continue. L'ensemble des techniques développées a été utilisé en collaboration avec l'Institut d'Optique à Orsay, France, pour produire la première expérience de distribution quantique de clés au moyen d'états cohérents de la lumière modulés continuement.
D'autres aspects importants sont également traités dans cette thèse, tels que la mise en perspective de la distribution quantique de clés dans un contexte cryptographique, la spécification d'un protocole complet, la création de nouvelles techniques d'amplification de confidentialité plus rapides à mettre en œuvre ou l'étude théorique et pratique d'algorithmes alternatifs de réconciliation.
Enfin, nous étudions la sécurité du protocole à états cohérents en établissant son équivalence à un protocole de purification d'intrication. Sans entrer dans les détails, cette équivalence, formelle, permet de valider la robustesse du protocole contre tout type d'espionnage, même le plus compliqué possible, permis par les lois de la mécanique quantique. En particulier, nous généralisons l'algorithme de réconciliation en tranches pour le transformer en un protocole de purification et nous établissons ainsi un protocole de distribution quantique sûr contre toute stratégie d'espionnage.
Quantum key distribution is a cryptographic technique, which allows to exchange secret keys whose confidentiality is guaranteed by the laws of quantum mechanics. The strange behavior of elementary particles is exploited. In quantum mechnics, any measurement of the state of a particle irreversibly modifies this state. By taking advantage of this property, two parties, often called Alice and bob, can encode a secret key into quatum information carriers such as single photons. Any attempt at eavesdropping requires the spy, Eve, to measure the state of the photon and thus to perturb this state. Alice and Bob can then be aware of Eve's presence by a unusually high number of transmission errors.
The information exchanged by quantum key distribution is not directly usable but must first be processed. Transmission errors, whether they are caused by an eavesdropper or simply by noise in the transmission channel, must be corrected with a technique called reconciliation. Then, the partial knowledge of an eavesdropper, who would perturb only a fraction of the carriers, must be wiped out from the final key thanks to a technique called privacy amplification.
The context of this thesis is the quantum key distribution with continuous states of light as carriers. An important part of this work deals with the processing of continuous information exchanged by a particular protocol, where the carriers are coherent states of light. The continuous nature of information in this case implies peculiar changes to the reconciliation techniques, which have mostly been developed to process binary information. We propose a technique called sliced error correction, which allows to efficiently process continuous information. The set of the developed techniques was used in collaboration with the Institut d'Optique, Orsay, France, to set up the first experiment of quantum key distribution with continuously-modulated coherent states of light.
Other important aspects are also treated in this thesis, such as placing quantum key distribution in the context of a cryptosystem, the specification of a complete protocol, the creation of new techniques for faster privacy amplification or the theoretical and practical study of alternate reconciliation algorithms.
Finally, we study the security of the coherent state protocol by analyzing its equivalence with an entanglement purification protocol. Without going into the details, this formal equivalence allows to validate the robustness of the protocol against any kind of eavesdropping, even the most intricate one allowed by the laws of quantum mechanics. In particular, we generalize the sliced error correction algorithm so as to transform it into a purification protocol and we thus establish a quantum key distribution protocol secure against any eavesdropping strategy.
Doctorat en sciences appliquées
info:eu-repo/semantics/nonPublished
43
Ejjaaouani, Ksander. "Conception du modèle de programmation INKS pour la séparation des préoccupations algorithmiques et d’optimisation dans les codes de simulation numérique : application à la résolution du système Vlasov/Poisson 6D". Thesis, Strasbourg, 2019. http://www.theses.fr/2019STRAD037.
Texto completo da fonteResumo:
Le modèle de programmation InKS vise à améliorer la lisibilité, la portabilité et la maintenabilité des codes de simulation tout en accroissant la productivité des développeurs de telles applications. Pour atteindre ces objectifs, InKS propose deux langages, chacun dédié à une partie de l’application. Le premier, InKS PIA , permet d’exprimer les aspects algorithmiques d’un code de simulation scientifique tout en laissant les choix d’optimisation de côté. Il s’agit de décrire les fondations de la simulation : son algorithme. Le second langage, InKS PSO , permet aux spécialistes de l’optimisation de réutiliser les informations contenues dans l’algorithme pour exprimer une large variété de choix d’optimisation. Le modèle permet d’écrire de nombreuses versions des optimisations, typiquement une par architecture, à partir d’un unique algorithme. En basant les différentes versions d’un programme sur sa partie invariante, l’algorithme, le modèle InKS limite la réécriture du code, boostant la productivité des développeurs. Suite à la proposition du modèle InKS et de son implémentation, nous avons évalué le modèle au travers de l'implémentation de simulations de plasma: le système Vlasov-Poisson 6D. Cette évaluation a permis de mettre en évidence certaines bonnes propriétés du modèle, notamment en matière de séparation des aspects, mais aussi à montrer sa généralité et ses performances. Pour ce faire, nous avons comparé l'efficacité de deux implémentations du système Vlasov-Poisson 6D, écrite sur InKS ou Fortran. Pour les optimisations les plus importantes, le nombre de lignes dans les deux cas est similaire. Cependant, la présence de l'algorithme permet d'ordonnancer automatiquement, en une simple ligne, un large ensemble de calcul, verbeux et potentiellement sujet aux erreurs. Ainsi, dans les parties non critiques du code, InKS PSO peut résumer une partie du programme de manière concise, permettant de se concentrer sur les parties de calcul intensif. Par ailleurs, en limitant la réécriture du code aux seules optimisations, InKS permet de tester plusieurs stratégies d'optimisations afin d'identifier la plus adaptée à une architecture donnée. En comparaison, dans ces situations, les applications traditionnelles requièrent la réécriture d'une plus grande partie du code, limitant le temps consacré à la recherche des meilleures stratégies d'optimisationThe InKS programming model aims to improve readability portability and maintainability of simulation codes as well as boosting developer productivity. To fulfill these objectives, InKS proposes two languages, each dedicated to a specific concern. First, InKS PIA provides concepts to express simulation algorithms with no concerns for optimization. Once this foundation is set, InKSPSO enables optimization specialists to reuse the algorithm in order to specify the optimization part. The model offers to write numerous versions of the optimizations, typically one per architecture, from a single algorithm. This strategy limits the rewriting of code for each new optimization specification, boosting developer productivity.We have evaluated the InKS programming model by using it to implement the 6D Vlasov-Poisson solver and compared our version with a Fortran one. This evaluation highlighted that, in addition to the separation of concerns, the InKS approach is not more complex that traditional ones while offering the same performance. Moreover, using the algorithm, it is able to generate valid code for non-critical parts of code, leaving optimization specialists more time to focus on optimizing the computation intensive parts
44
Gastellier-Prevost, Sophie. "Vers une détection des attaques de phishing et pharming côté client". Electronic Thesis or Diss., Evry, Institut national des télécommunications, 2011. http://www.theses.fr/2011TELE0027.
Texto completo da fonteResumo:
Le développement de l’Internet à haut débit et l’expansion du commerce électronique ont entraîné dans leur sillage de nouvelles attaques qui connaissent un vif succès. L’une d’entre elles est particulièrement sensible dans l’esprit collectif : celle qui s’en prend directement aux portefeuilles des Internautes. Sa version la plus répandue/connue est désignée sous le terme phishing. Majoritairement véhiculée par des campagnes de spam, cette attaque vise à voler des informations confidentielles (p.ex. identifiant, mot de passe, numéro de carte bancaire) aux utilisateurs en usurpant l’identité de sites marchands et/ou bancaires. Au fur et à mesure des années, ces attaques se sont perfectionnées jusqu’à proposer des sites webs contrefaits qui visuellement - hormis l’URL visitée - imitent à la perfection les sites originaux. Par manque de vigilance, bon nombre d’utilisateurs communiquent alors - en toute confiance - des données confidentielles. Dans une première partie de cette thèse, parmi les moyens de protection/détection existants face à ces attaques, nous nous intéressons à un mécanisme facile d’accès pour l’Internaute : les barres d’outils anti-phishing, à intégrer dans le navigateur web. La détection réalisée par ces barres d’outils s’appuie sur l’utilisation de listes noires et tests heuristiques. Parmi l’ensemble des tests heuristiques utilisés (qu’ils portent sur l’URL ou le contenu de la page web), nous cherchons à évaluer leur utilité et/ou efficacité à identifier/différencier les sites légitimes des sites de phishing. Ce travail permet notamment de distinguer les heuristiques décisifs, tout en discutant de leur pérennité. Une deuxième variante moins connue de cette attaque - le pharming - peut être considérée comme une version sophistiquée du phishing. L’objectif de l’attaque reste identique, le site web visité est tout aussi ressemblant à l’original mais - a contrario du phishing - l’URL visitée est cette fois-ci elle aussi totalement identique à l’originale. Réalisées grâce à une corruption DNS amont, ces attaques ont l’avantage de ne nécessiter aucune action de communication de la part de l’attaquant : celui-ci n’a en effet qu’à attendre la visite de l’Internaute sur son site habituel. L’absence de signes "visibles" rend donc l’attaque perpétrée particulièrement efficace et redoutable, même pour un Internaute vigilant. Certes les efforts déployés côté réseau sont considérables pour répondre à cette problématique. Néanmoins, le côté client y reste encore trop exposé et vulnérable. Dans une deuxième partie de cette thèse, par le développement de deux propositions visant à s’intégrer dans le navigateur client, nous introduisons une technique de détection de ces attaques qui couple une analyse de réponses DNS à une comparaison de pages webs. Ces deux propositions s’appuient sur l’utilisation d’éléments de référence obtenus via un serveur DNS alternatif, leur principale différence résidant dans la technique de récupération de la page web de référence. Grâce à deux phases d’expérimentation, nous démontrons la viabilité du concept proposéThe development of online transactions and "always-connected" broadband Internet access is a great improvement for Internet users, who can now benefit from easy access to many services, regardless of the time or their location. The main drawback of this new market place is to attract attackers looking for easy and rapid profits. One major threat is known as a phishing attack. By using website forgery to spoof the identity of a company that proposes financial services, phishing attacks trick Internet users into revealing confidential information (e.g. login, password, credit card number). Because most of the end-users check the legitimacy of a login website by looking at the visual aspect of the webpage displayed by the web browser - with no consideration for the visited URL or the presence and positioning of security components -, attackers capitalize on this weakness and design near-perfect copies of legitimate websites, displayed through a fraudulent URL. To attract as many victims as possible, most of the time phishing attacks are carried out through spam campaigns. One popular method for detecting phishing attacks is to integrate an anti-phishing protection into the web browser of the user (i.e. anti-phishing toolbar), which makes use of two kinds of classification methods : blacklists and heuristic tests. The first part of this thesis consists of a study of the effectiveness and the value of heuristics tests in differentiating legitimate from fraudulent websites. We conclude by identifying the decisive heuristics as well as discussing about their life span. In more sophisticated versions of phishing attacks - i.e. pharming attacks -, the threat is imperceptible to the user : the visited URL is the legitimate one and the visual aspect of the fake website is very similar to the original one. As a result, pharming attacks are particularly effective and difficult to detect. They are carried out by exploiting DNS vulnerabilities at the client-side, in the ISP (Internet Service Provider) network or at the server-side. While many efforts aim to address this problem in the ISP network and at the server-side, the client-side remains excessively exposed. In the second part of this thesis, we introduce two approaches - intended to be integrated into the client’s web browser - to detect pharming attacks at the client-side. These approaches combine both an IP address check and a webpage content analysis, performed using the information provided by multiple DNS servers. Their main difference lies in the method of retrieving the webpage which is used for the comparison. By performing two sets of experimentations, we validate our concept
45
Lévêque, Thomas. "Définition et contrôle des politiques d’évolution dans les projets logiciels". Grenoble, 2010. http://www.theses.fr/2010GRENM030.
Texto completo da fonteResumo:
L'Ingénierie Dirigée par les Modèles (IDM) vise à maitriser la complexité des logiciels en réalisant l'ensemble des activités d'ingénierie sur des modèles du système. A part quelques niches, l'IDM n'est pas encore adoptée par les grands producteurs de logiciels. Nous pensons que l'une des raisons est qu'un logiciel est constitué de modèles et de programmes développés tous deux manuellement. Le développement comme la maintenance font évoluer à la fois modèles et programmes ; il faut versionner modèles et programmes. Les équipes travaillant en parallèle il faut réconcilier les évolutions concurrentes, et surtout contrôler l'ingénierie coopérative. Or nous ne disposons pas aujourd'hui des concepts, mécanismes, e outils permettant de résoudre ces problèmes : nous ne savons pas gérer correctement l'évolution des logiciels en IDM. Cette thèse propose des concepts et des mécanismes permettant de gérer la coévolution des modèles et du code des logiciels à développer dans un domaine particulier, en utilisant un environnement dédié : un CADSE (Computer Aided Domain Specific Engineering environment). Nous proposons de décrire les politiques d'évolution des logiciels au niveau du méta-modèle du CADSE associé. Cette politique garantit la cohérence des versions et des compositions dans chaque espace de travail par une synchronisation dans les deux sens entre le modèle (conforme au méta-modèle du CADSE) et le code. Cette politique définit, garantit et contrôle également la cohérence du travail coopératif entre espaces de travails concurrentsModel Driven Engineering (MDE) aims at mastering software product complexity undertaking "all" software engineering activities on models. Except some specific domains such as critical systems, MDE is not yet widely adopted by large software manufacturers. We claim that one raison is that, in practice, in MDE software projects, an application is a mixture of models and code which are both developed manually. Development and maintenance activities modify at same time models and software; consistent versionning of models and code is needed. Software engineers are working in parallel: therefore, reconciling concurrent modifications and controlling cooperative engineering are needed. Unfortunately, the concepts, mechanisms and tools to solve these issues do not really exist today: we cannot manage conveniently software evolution for large MDE software projects. This thesis proposes concepts and mechanisms needed to manage the coevolution of models and code in a specific domain, using a dedicated engineering environment: a CADSE (Computer Aided Domain Specific Engineering environment). We propose to formally define evolution policies it the CADSE at meta model level. A policy enforces version consistency and evolution ripple effects in each workspace, through a bi-directional synchronization between model elements and files. A policy also defines and enforces the cooperative work strategy between concurrent workspaces
46
Corteggiani, Nassim. "Towards system-wide security analysis of embedded systems". Electronic Thesis or Diss., Sorbonne université, 2020. http://www.theses.fr/2020SORUS285.
Texto completo da fonteResumo:
Cette thèse se consacre à l'amélioration des techniques d'analyse dynamiques permettant la vérification de logiciels conçus pour des systèmes embarqués, couramment appelé micrologiciel. Au vu de l'augmentation significative de la connectivité des appareils électroniques, les préoccupations concernant leur sécurité s'intensifient. Les conséquences d'une faille de sécurité sur ces appareils peuvent impliquer des répercussions économiques non négligeables et des difficultés techniques importantes pour appliquer un correctif. C’est le cas notamment des amorceurs de code qui sont généralement stockés sur des mémoires mortes et intégrées dans les couches physiques qui constituent le microcontrôleur. Par conséquent, l’analyse de code source spécifique aux systèmes embarqués pendant la phase de production des micro-contrôleurs est cruciale. Cette thèse présente des techniques d'analyse afin de tester la sécurité de composants logiciel et matériel à l'échelle du système. En particulier, nous nous intéressons aux techniques de test basé sur l'émulation partielle dont nous améliorons les capacités avec trois nouvelles approches. Premièrement, Inception un outil d’analyse dynamique permettant d’appliquer des méthodes de tests exhaustifs (exécution symbolique) sur le code source de micrologiciel même lorsque ce dernier dépend de code plus bas niveau (exemple, code binaire ou assembleur). Deuxièmement, une sonde haute performance basé sur le protocol USB 3.0 afin de réduire la latence lors des communications entre l'outil d'analyse et le vrai matériel. Troisièmement, HardSnap une méthode permettant de générer des instantanés des périphériques matériel afin d'augmenter le contrôle et la visibilité lors de l'exécution symbolique. Cet outil permet de réaliser une exploration concurrente de plusieurs chemins d'exécution sans inconsistanceThis thesis is dedicated to the improvement of dynamic analysis techniques allowing the verification of software designed for embedded systems, commonly called firmware. It is clear that the increasing pervasiveness and connectivity of embedded devices significantly increase their exposure to attacks. The consequences of a security issue can be dramatic not least in the economical field, but on the technical stage as well. Especially because of the difficulty to patch some devices. For instance, offline devices or code stored in a mask rom which are read only memory programmed during the chip fabrication. For all these reasons, it is important to thoughtfully test firmware program before the manufacturing process. This thesis presents analysis methods for system-wide testing of security and hardware components. In particular, we propose three impvrovements for partial emulation. First, Inception a dynamic analysis tool to test the security of firmware programs even when mixing different level of semantic (e.g., C/C++ mixed with assembly). Second, Steroids a high performance USB 3.0 probe that aims at minimizing the latency between the analyzer and the real device. Finally, HardSnap a hardware snapshotting method that offers higher visibility and control over the hardware peripherals. It enables testing concurently different execution paths without corrupting the hardware peripherals state
47
Pham, Van Cam. "Model-Based Software Engineering : Methodologies for Model-Code Synchronization in Reactive System Development". Thesis, Université Paris-Saclay (ComUE), 2018. http://www.theses.fr/2018SACLS611/document.
Texto completo da fonteResumo:
Model-Based Software Engineering (MBSE) a été proposé comme une méthodologie prometteuse de développement de logiciels pour surmonter les limites de la méthodologie traditionnelle basée sur la programmation pour faire face à la complexité des systèmes embarqués. MBSE favorise l’utilisation de langages de modélisation pour décrire les systèmes d’une manière abstraite et fournit des moyens pour générer automatiquement de différents artefacts de développement, p.ex. code et documentation, à partir de modèles. Le développement d’un système complexe implique souvent de multiples intervenants qui utilisent différents outils pour modifier les artefacts de développement, le modèle et le code en particulier dans cette thèse. Les modifications apportées aux artefacts évoquent le problème de cohérence qui nécessite un processus de synchronisation pour propager les modifications apportées dans l’un artefact aux autres artefacts. Dans cette étude, le problème de la synchronisation des modèles d’architecture basés sur les éléments UML composite structure (UML-CS) et UML state machine (UML-SM) du langage de l’Unified Modeling Language (UML), et le code orienté objet est présenté. UML-CSs sont utilisés pour décrire l’architecture du logiciel basée sur les composants et UML-SMs pour les comportements discrets liés aux événements des systèmes réactifs. Le premier défi est de permettre une collaboration entre les architectes de logiciels et les programmeurs produisant de modèle et de code, en utilisant différents outils. Il soulève le problème de synchronisation où il existe de modifications simultanées des artefacts. En fait, il existe un écart de perception entre les langages à base de diagramme (langages de modélisation) et les langages textuels (langages de programmation). D’une part, les programmeurs préfèrent souvent utiliser la combinaison familière d’un langage de programmation et d’un environnement de développement intégré. D’autre part, les architectes logiciels, travaillant à des niveaux d’abstraction plus élevés, favorisent l’utilisation des modèles et préfèrent donc les langages à base de diagramme pour décrire l’architecture du système. Le deuxième défi est qu’il existe un écart d’abstraction significatif entre les éléments du modèle et les éléments du code: les éléments UML-CS et UML-SM sont au niveau d’abstraction plus élevé que les éléments du code. L’écart rend la difficulté pour les approches de synchronisation actuelles car il n’y a pas de façon facile de réflecter les modifications du code au modèle. Cette thèse propose une approche automatisée de synchronisation composée de deux principales contributions corrélées. Pour aborder le premier défi, on propose un patron méthodologique générique de synchronisation entre modèle et code. Il consiste en des définitions des fonctionnalités nécessaires et plusieurs processus qui synchronisent le modèle et le code en fonction de plusieurs scénarios définis où les développeurs utilisent différents outils pour modifier le modèle et le code. Cette contribution est indépendante de UML-CSs et UML-SMs. La deuxième contribution traite du deuxième défi et est basée sur les résultats de la première contribution. Dans la deuxième contribution, un mapping bidirectionnel est présentée pour réduire l’écart d’abstraction entre le modèle et le code. Le mapping est un ensemble de correspondances entre les éléments de modèle et ceux de code. Il est utilisé comme entrée principale du patron méthodologique générique de synchronisation entre modèle et code. Plus important, l’utilisation du mapping fournit les fonctionnalités définies dans la première contribution et facilite la synchronisation des éléments de UML-CS et UML-SM et du code. L’approche est évaluée au moyen de multiples simulations et d’une étude de casModel-Based Software Engineering (MBSE) has been proposed as a promising software development methodology to overcome limitations of traditional programming-based methodology in dealing with the complexity of embedded systems. MBSE promotes the use of modeling languages for describing systems in an abstract way and provides means for automatically generating different development artifacts, e.g. code and documentation, from models. The development of a complex system often involves multiple stakeholders who use different tools to modify the development artifacts, model and code in particular in this thesis. Artifact modifications must be kept consistent: a synchronization process needs to propagate modifications made in one artifact to the other artifacts. In this study, the problem of synchronizing Unified Modeling Language (UML)-based architecture models, specified by UML composite structure (UML-CS) and UML state machine (UML-SM) elements, and object-oriented code is presented. UML-CSs are used for describing the component-based software architecture and UML-SMs for discrete event-driven behaviors of reactive systems. The first challenge is to enable a collaboration between software architects and programmers producing model and code by using different tools. This raises the synchronization problem of concurrent artifact modifications. In fact, there is a perception gap between diagram-based languages (modeling languages) and text-based languages (programming languages). On the one hand, programmers often prefer to use the more familiar combination of a programming language and an Integrated Development Environment. On the other hand, software architects, working at higher levels of abstraction, tend to favor the use of models, and therefore prefer diagram-based languages for describing the architecture of the system. The second challenge is that there is a significant abstraction gap between the model elements and the code elements: UML-CS andUML-SM elements are at higher level of abstraction than code elements. The gap makes current synchronization approaches hard to be applied since there is no easy way to reflect modifications in code back to model. This thesis proposes an automated synchronization approach that is composed of two main correlated contributions. To address the first challenge, a generic model-code synchronization methodological pattern is proposed. It consists of definitions of necessary functionalities and multiple processes that synchronize model and code based on several defined scenarios where the developers use different tools to modify model and code. This contribution is independent of UML-CSs and UML-SMs. The second contribution deals with the second challenge and is based on the results from the first contribution. In the second contribution, a bidirectional mapping is presented for reducing the abstraction gap between model and code. The mapping is a set of correspondences between model elements and code elements. It is used as main input of the generic model-code synchronization methodological pattern. More importantly, the usage of the mapping provides the functionalities defined in the first contribution and eases the synchronization of UML-CS and UML-SM elements and code. The approach is evaluated by means of multiple simulations and a case study
48
David, Robin. "Formal Approaches for Automatic Deobfuscation and Reverse-engineering of Protected Codes". Thesis, Université de Lorraine, 2017. http://www.theses.fr/2017LORR0013/document.
Texto completo da fonteResumo:
L’analyse de codes malveillants est un domaine de recherche en pleine expansion de par la criticité des infrastructures touchées et les coûts impliqués de plus en plus élevés. Ces logiciels utilisent fréquemment différentes techniques d’évasion visant à limiter la détection et ralentir les analyses. Parmi celles-ci, l’obfuscation permet de cacher le comportement réel d’un programme. Cette thèse étudie l’utilité de l’Exécution Symbolique Dynamique (DSE) pour la rétro-ingénierie. Tout d’abord, nous proposons deux variantes du DSE plus adaptées aux codes protégés. La première est une redéfinition générique de la phase de calcul de prédicat de chemin basée sur une manipulation flexible des concrétisations et symbolisations tandis que la deuxième se base sur un algorithme d’exécution symbolique arrière borné. Ensuite, nous proposons différentes combinaisons avec d’autres techniques d’analyse statique afin de tirer le meilleur profit de ces algorithmes. Enfin tous ces algorithmes ont été implémentés dans différents outils, Binsec/se, Pinsec et Idasec, puis testés sur différents codes malveillants et packers. Ils ont permis de détecter et contourner avec succès les obfuscations ciblées dans des cas d’utilisations réels tel que X-Tunnel du groupe APT28/SednitMalware analysis is a growing research field due to the criticity and variety of assets targeted as well as the increasing implied costs. These softwares frequently use evasion tricks aiming at hindering detection and analysis techniques. Among these, obfuscation intent to hide the program behavior. This thesis studies the potential of Dynamic Symbolic Execution (DSE) for reverse-engineering. First, we propose two variants of DSE algorithms adapted and designed to fit on protected codes. The first is a flexible definition of the DSE path predicate computation based on concretization and symbolization. The second is based on the definition of a backward-bounded symbolic execution algorithm. Then, we show how to combine these techniques with static analysis in order to get the best of them. Finally, these algorithms have been implemented in different tools Binsec/se, Pinsec and Idasec interacting alltogether and tested on several malicious codes and commercial packers. Especially, they have been successfully used to circumvent and remove the obfuscation targeted in real-world malwares like X-Tunnel from the famous APT28/Sednit group
49
Tërnava, Xhevahire. "Gestion de la variabilité au niveau du code : modélisation, traçabilité et vérification de cohérence". Thesis, Université Côte d'Azur (ComUE), 2017. http://www.theses.fr/2017AZUR4114/document.
Texto completo da fonteResumo:
Durant le développement de grandes lignes de produits logiciels, un ensemble de techniques d’implémentation traditionnelles, comme l’héritage ou les patrons de conception, est utilisé pour implémenter la variabilité. La notion de feature, en tant qu’unité réutilisable, n’a alors pas de représentation de première classe dans le code, et un choix inapproprié de techniques entraîne des incohérences entre variabilités du domaine et de l’implémentation. Dans cette thèse, nous étudions la diversité de la majorité des techniques d’implémentation de la variabilité, que nous organisons dans un catalogue étendu. Nous proposons un framework pour capturer et modéliser, de façon fragmentée, dans des modèles techniques de variabilité, la variabilité implémentée par plusieurs techniques combinées. Ces modèles utilisent les points de variation et les variantes, avec leur relation logique et leur moment de résolution, pour abstraire les techniques d’implémentation. Nous montrons comment étendre le framework pour obtenir la traçabilité de feature avec leurs implémentations respectives. De plus, nous fournissons une approche outillée pour vérifier la cohérence de la variabilité implémentée. Notre méthode utilise du slicing pour vérifier partiellement les formules de logique propositionnelles correspondantes aux deux niveaux dans le cas de correspondence 1–m entre ces niveaux. Ceci permet d’obtenir une détection automatique et anticipée des incohérences. Concernant la validation, le framework et la méthode de vérification ont été implémentés en Scala. Ces implémentations ont été appliquées à un vrai système hautement variable et à trois études de cas de lignes de produitsWhen large software product lines are engineered, a combined set of traditional techniques, such as inheritance, or design patterns, is likely to be used for implementing variability. In these techniques, the concept of feature, as a reusable unit, does not have a first-class representation at the implementation level. Further, an inappropriate choice of techniques becomes the source of variability inconsistencies between the domain and the implemented variabilities. In this thesis, we study the diversity of the majority of variability implementation techniques and provide a catalog that covers an enriched set of them. Then, we propose a framework to explicitly capture and model, in a fragmented way, the variability implemented by several combined techniques into technical variability models. These models use variation points and variants, with their logical relation and binding time, to abstract the implementation techniques. We show how to extend the framework to trace features with their respective implementation. In addition, we use this framework and provide a tooled approach to check the consistency of the implemented variability. Our method uses slicing to partially check the corresponding propositional formulas at the domain and implementation levels in case of 1–to–m mapping. It offers an early and automatic detection of inconsistencies. As validation, we report on the implementation in Scala of the framework as an internal domain specific language, and of the consistency checking method. These implementations have been applied on a real feature-rich system and on three product line case studies, showing the feasibility of the proposed contributions
50
Robillard, Benoît. "Verification formelle et optimisation de l’allocation de registres". Thesis, Paris, CNAM, 2010. http://www.theses.fr/2010CNAM0730/document.
Texto completo da fonteResumo:
La prise de conscience générale de l'importance de vérifier plus scrupuleusement les programmes a engendré une croissance considérable des efforts de vérification formelle de programme durant cette dernière décennie. Néanmoins, le code qu'exécute l'ordinateur, ou code exécutable, n'est pas le code écrit par le développeur, ou code source. La vérification formelle de compilateurs est donc un complément indispensable à la vérification de code source.L'une des tâches les plus complexes de compilation est l'allocation de registres. C'est lors de celle-ci que le compilateur décide de la façon dont les variables du programme sont stockées en mémoire durant son exécution. La mémoire comporte deux types de conteneurs : les registres, zones d'accès rapide, présents en nombre limité, et la pile, de capacité supposée suffisamment importante pour héberger toutes les variables d'un programme, mais à laquelle l'accès est bien plus lent. Le but de l'allocation de registres est de tirer au mieux parti de la rapidité des registres, car une allocation de registres de bonne qualité peut conduire à une amélioration significative du temps d'exécution du programme.Le modèle le plus connu de l'allocation de registres repose sur la coloration de graphe d'interférence-affinité. Dans cette thèse, l'objectif est double : d'une part vérifier formellement des algorithmes connus d'allocation de registres par coloration de graphe, et d'autre part définir de nouveaux algorithmes optimisants pour cette étape de compilation. Nous montrons tout d'abord que l'assistant à la preuve Coq est adéquat à la formalisation d'algorithmes d'allocation de registres par coloration de graphes. Nous procédons ainsi à la vérification formelle en Coq d'un des algorithmes les plus classiques d'allocation de registres par coloration de graphes, l'Iterated Register Coalescing (IRC), et d'une généralisation de celui-ci permettant à un utilisateur peu familier du système Coq d'implanter facilement sa propre variante de cet algorithme au seul prix d'une éventuelle perte d'efficacité algorithmique. Ces formalisations nécessitent des réflexions autour de la formalisation des graphes d'interférence-affinité, de la traduction sous forme purement fonctionnelle d'algorithmes impératifs et de l'efficacité algorithmique, la terminaison et la correction de cette version fonctionnelle. Notre implantation formellement vérifiée de l'IRC a été intégrée à un prototype du compilateur CompCert.Nous avons ensuite étudié deux représentations intermédiaires de programmes, dont la forme SSA, et exploité leurs propriétés pour proposer de nouvelles approches de résolution optimale de la fusion, l'une des optimisations opéréeslors de l'allocation de registres dont l'impact est le plus fort sur la qualité du code compilé. Ces approches montrent que des critères de fusion tenant compte de paramètres globaux du graphe d'interférence-affinité, tels que sa largeur d'arbre, ouvrent la voie vers de nouvelles méthodes de résolution potentiellement plus performantesThe need for trustful programs led to an increasing use of formal verication techniques the last decade, and especially of program proof. However, the code running on the computer is not the source code, i.e. the one written by the developper, since it has to betranslated by the compiler. As a result, the formal verication of compilers is required to complete the source code verication. One of the hardest phases of compilation is register allocation. Register allocation is the phase within which the compiler decides where the variables of the program are stored in the memory during its execution. The are two kinds of memory locations : a limited number of fast-access zones, called registers, and a very large but slow-access stack. The aim of register allocation is then to make a great use of registers, leading to a faster runnable code.The most used model for register allocation is the interference graph coloring one. In this thesis, our objective is twofold : first, formally verifying some well-known interference graph coloring algorithms for register allocation and, second, designing new graph-coloring register allocation algorithms. More precisely, we provide a fully formally veri ed implementation of the Iterated Register Coalescing, a very classical graph-coloring register allocation heuristics, that has been integrated into the CompCert compiler. We also studied two intermediate representations of programs used in compilers, and in particular the SSA form to design new algorithms, using global properties of the graph rather than local criteria currently used in the litterature