To see the other types of publications on this topic, follow the link: Maintenance des logiciels.
Dissertations / Theses on the topic 'Maintenance des logiciels'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 dissertations / theses for your research on the topic 'Maintenance des logiciels.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Hérin-Aimé, Danièle. "Demsi : une méthode, un modèle et un logiciel pour l'évolution et la maintenance des systèmes d'information." Nice, 1986. http://www.theses.fr/1986NICE4038.
Full textAbstract:
La méthode se compose de 5 étapes : traduction d'un besoin, recherche de l'impact d'un besoin, puis de plusieurs besoins, étape de décision et étape de mise à jour du s. I. La modelisation inclut un modele de representation de S. I. Au niveau conceptuel, logique et physique et un modèle de décision. Le logiciel a la struture d'un système expert orienté objets
2
Diaz, Dolores. "Réaliser des évolutions logicielles sur des applications d'entreprise en phase de maintenance." Lille 1, 2007. http://www.theses.fr/2007LIL10167.
Full textAbstract:
Dans une conjoncture économique ambitieuse, les sociétés de services d'ingénierie informatique se doivent d'élaborer les applications de plus en plus vite et ce avec un minimum de moyen. C'est pourquoi, les sociétés informatiques sont attentives aux méthodes et outils pour l'industrialisation du développement et de maintenance des applications. Or, si le premier thème est approfondi par la littérature et sur le terrain. Le thème sur l'industrialisation de la maintenance des applications l'est beaucoup moins. Conscients du caractère inéluctable de la maintenance des applications d'entreprise, nous formulons dans cette thèse CI FRE avec pour terrain d'expérimentation la société NORSYS, une proposition scientifique aux problématiques réelles de la maintenance des applications d'entreprise. Nous proposons CAREL, un Cadre d'Aide à la Réalisation des Evolutions Logicielles, en phase de maintenance. Ce cadre constitue à la fois une méthode et un ensemble d'outils afin de guider le mainteneur dans son activité. Plusieurs étapes de la maintenance sont couvertes par CAREL. La compréhension d'une application peut être effectuée par EUCLIDE, un module de visualisation d'une application. L'analyse des impacts et la conception et l'implémentation d'une évolution peuvent être effectuées à l'aide de TRACEGEN. Ce dernier module propose de définir un modèle de traçabilité pour les fonctionnalités et un autre modèle de traçabilité pour les services techniques d'une application. Cette thèse illustre CAREL sur deux cas d'études réels. Enfin, une analyse sur les apports et les limitations de CAREL relève la pertinence de son utilisation directe dans le monde industriel.
3
Kessaci, Brahim. "Contribution à la formalisation de la qualité du logiciel." Toulouse, ENSAE, 1985. http://www.theses.fr/1985ESAE0003.
Full text
4
Abdeen, Hani. "Visualizing, Assessing and Re-Modularizing Object-Oriented Architectural Elements." Phd thesis, Université des Sciences et Technologie de Lille - Lille I, 2009. http://tel.archives-ouvertes.fr/tel-00498389.
Full textAbstract:
To cope with the complexity of large object-oriented software systems, developers organize classes into subsystems using the concepts of module or package. Such modular structure helps software systems to evolve when facing new requirements. The organization of classes into packages and/or subsystems represents the software modularization. the software modularization usually follows interrelationships between classes. Ideally, packages should to be loosely coupled and cohesive to a certain extent. However, Studies show that as software evolves to meet requirements and environment changes, the software modularization gradually drifts and looses quality. As a consequence, the software modularization must be maintained. It is thus important to understand, to assess and to optimize the organization of packages and their relationships. Our claim is that the maintenance of large and complex software modularizations needs approaches that help in: (1) understanding package shapes and relationships; (2) assessing the quality of a modularization, as well as the quality of a single package within a given modularization; (3) optimizing the quality of an existing modulariza- tion. In this thesis, we concentrate on three research fields: software visualizations, metrics and algorithms. At first, we define two visualizations that help maintainers: (1) to understand packages structure, usage and relationships; (2) to spot patterns; and (3) to identify misplaced classes and structural anomalies. In addition to visual- izations, we define a suite of metrics that help in assessing the package design quality (i.e., package cohesion and coupling). We also define metrics that assess the quality of a collection of inter-dependent packages from different view points, such as the degree of package coupling and cycles. Finally, we define a search-based algorithm that automatically reduces package coupling and cycles only by moving classes over existing packages. Our optimization approach takes explicitly into account the origi- nal class organization and package structure. It also allows maintainers to control the optimization process by specifying: (1) the maximal number of classes that may change their packages; (2) the classes that are candidate for moving and the classes that should not; (3) the packages that are candidate for restructuring and the packages that should not; and (4) the maximal number of classes that a given package can entail. The approaches presented in this thesis have been applied to real large object- oriented software systems. The results we obtained demonstrate the usefulness of our visualizations and metrics; and the effectiveness of our optimization algorithm.
5
Lambolez, Pierre-Yves. "Recherche d'informations pour la maintenance logicielle." Toulouse 3, 1994. http://www.theses.fr/1994TOU30201.
Full textAbstract:
Le travail presente ici s'inscrit dans le contexte de la maintenance logicielle de gros projets industriels du monde spatial. Dans ce cadre, un enorme volume de documents est produit et le mainteneur se trouve confronte a un probleme de recherche d'information, tant dans des documents en langage naturel que dans des codes sources. Afin d'offrir un support a cette activite, nous proposons un systeme generique de recherche d'information. La genericite est necessaire car les formats et les formalismes issus du developpement sont multiples et le mainteneur qui n'a pas pris part a ces choix est tenu de s'y adapter. Le systeme propose est constitue d'une chaine generique d'analyse de documents basee sur un moteur de reecriture syntaxique, d'une chaine generique d'indexation basee sur un moteur de reecriture lexicale et d'un frontal fenetre de requete
6
Abdeen, Hani. "Visualizing, assessing and re-modularizing object-oriented architectural elements." Electronic Thesis or Diss., Lille 1, 2009. http://www.theses.fr/2009LIL10069.
Full textAbstract:
Pour faire face à la complexité des grands systèmes logiciels orientés objets, les programmeurs organisent les classes en sous-systèmes en utilisant les concepts de module ou de package. Une telle structure modulaire permet aux systèmes logiciels d’évoluer face aux nouvelles exigences. L’organisation des classes dans des packages et / ou sous-systèmes, que nous appelons la modularisation du logiciel, suit habituellement les relations entre les classes. Il est d'usage de vouloir les packages faiblement couplés et assez cohésifs. Cependant, les études montrent que quand les systèmes logiciels s’adaptent aux exigences et aux modifications de l’environnement, leurs modularisations dérivent et perdent progressivement leur qualité. En conséquence, la modularisation des systèmes logiciels doit être maintenue. Il est donc important de comprendre, d’évaluer et d’optimiser l’organisation des packages et de leurs relations. Le point défendu dans la thèse est que le maintien des modularisations logiciels de grande taille et complexes requiert des approches qui contribuent à: (1) la compréhension des packages et de leurs relations; (2) l’évaluation de la qualité d’une modularisation, ainsi que la qualité d’un package dans le contexte d’une modularisation donnée; (3) l’optimisation de la qualité d’une modularisation existante. Dans cette thèse, nous nous concentrons sur trois domaines de recherche: visualisations de programmes, métriques et algorithmes. Dans un premier temps, nous définissons deux visualisations qui aident les mainteneurs à: (1) la compréhension de la structure des packages, et de leurs utilisations et leurs relations; (2) l’identification des modèles; et (3) l’identification des anomalies structurelles. En plus de visualisations, nous définissons un ensemble de métriques qui aident à évaluer la qualité d’un package (i.e., la cohésion et le couplage). Nous définissons également des métriques qui permettent d’évaluer la qualité d’une collection des packages inter-dépendants. Ceci en prenant en compte le degré de couplage et de cycles entre les packages. Enfin, nous définissons un algorithme de recherche qui réduit automatiquement le couplage et les cycles entre les packages, en déplaçant seulement les classes sur les packages existants. Notre approche d’optimisation prend explicitement en compte l’organisation des classes et la structure originale des packages. Il permet également aux mainteneurs de contrôler le processus d’optimisation en spécifiant: (1) le nombre maximal des classes qui peuvent changer leurs packages; (2) les classes qui sont candidates pour se déplacer et celles qui ne doivent pas changer leurs packages; (3) les packages qui sont candidates pour la restructuration et ceux qui ne doivent pas se changer; et (4) le nombre maximal des classes qu’un package donné peut contenir. Les approches présentées dans cette thèse ont été appliquées à des systèmes logiciels orienté objets, réels et de grand taille. Les résultats obtenus démontrent l’utilité de nos visualisations et métriques, et l’efficacité de notre algorithme d’optimisationTo cope with the complexity of large object-oriented software systems, developers organize classes into subsystems using the concepts of module or package. Such modular structure helps software systems to evolve when facing new requirements.The organization of classes into packages and/or subsystems represents the software modularization. the software modularization usually follows interrelationships between classes. Ideally, packages should to be loosely coupled and cohesive to a certain extent. However, Studies show that as software evolves to meet requirements and environment changes, the software modularization gradually drifts and looses quality. As a consequence, the software modularization must be maintained. It is thus important to understand, to assess and to optimize the organization of packages and their relationships. Our claim is that the maintenance of large and complex software modularizations needs approaches that help in: (1) understanding package shapes and relationships; (2) assessing the quality of a modularization, as well as the quality of a single package within a given modularization; (3) optimizing the quality of an existing modularization. In this thesis, we concentrate on three research fields: software visualizations, metrics and algorithms. At first, we define two visualizations that help maintainers: (1) to understand packages structure, usage and relationships; (2) to spot patterns; and (3) to identify misplaced classes and structural anomalies. In addition to visualizations, we define a suite of metrics that help in assessing the package design quality (i.e., package cohesion and coupling). We also define metrics that assess the quality of a collection of inter-dependent packages from different view points, such as the degree of package coupling and cycles. Finally, we define a search-based algorithm that automatically reduces package coupling and cycles only by moving classes over existing packages. Our optimization approach takes explicitly into account the original class organization and package structure. It also allows maintainers to control the optimization process by specifying: (1) the maximal number of classes that may change their packages; (2) the classes that are candidate for moving and the classes that should not; (3) the packages that are candidate for restructuring and the packages that should not; and (4) the maximal number of classes that a given package can entail.The approaches presented in this thesis have been applied to real large object-oriented software systems. The results we obtained demonstrate the usefulness of our visualizations and metrics; and the effectiveness of our optimization algorithm
7
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.
Full textAbstract:
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
8
Govin, Brice. "Support à la rénovation d'une architecture logicielle patrimoniale : un cas réel chez Thales Land and Air Systems." Thesis, Lille, 2018. http://www.theses.fr/2018LIL1I026.
Full textAbstract:
Les entreprises accordent énormément d'importance à identifier des démarches automatisées et réplicables pour résoudre leurs problèmes. Ce constat s'applique aussi au démarche de rénovation d'architecture logicielle. Au sein d'une grande entreprise, nous avons intégré l'équipe chargée de réaliser la rénovation de l'architecture d'un logiciel. Nous avons étudié la démarche informelle suivie par cette équipe afin d'en proposer une généralisation et des outils facilitant son automatisation et sa réplication à d'autres projets. La plupart des solutions proposées dans la littérature ne peuvent s'appliquer à ce projet, du fait de leur caractère manuel, de leurs contraintes particulières ou de leur manque d'application sur des cas réels. Toutefois, nous avons identifié que le Reflexion Model, la recherche d’information et le regroupement statistique peuvent s'y appliquer. Nous avons alors proposé une nouvelle démarche structurée qui se base sur une adaptation du Reflexion Model et sur la démarche réalisée par l'entreprise. Notre démarche utilise cinq critères permettant l'allocation du code source existant à l'architecture du logiciel rénové. Nous avons montré que l'application de nos critères d'allocation donne des résultats satisfaisants au contraire de la recherche d’information et du regroupement. Enfin, pour répondre au besoin d'automatisation, nous avons défini ce que nous appelons des opérateurs. Ils se basent sur les activités que nous avons identifiées dans le travail des ingénieurs de l’entreprise. Nous avons montré que ces opérateurs permettraient de répliquer entièrement notre démarche structurée autorisant ainsi son application efficace sur d'autres projetsCompanies attach great importance to identifying automated and replicable approaches to solving their problems. This observation also applies to the software architecture renovation process. Within a large company, we joined the team in charge of renovating the software architecture. We studied the informal approach followed by this team in order to propose a generalization and tools facilitating its automation and its replication to other projects. Most of the solutions proposed in the literature cannot be applied to this project because of their manual nature, their particular constraints or their lack of application to real cases. However, we have identified that the Reflexion Model, information retrieval and statistical grouping may apply. We then proposed a new structured approach based on an adaptation of the Reflexion Model and on the approach developed by the company. Our approach uses five criteria to allocate existing source code to the architecture of the renovated software. We have shown that the application of our allocation criteria gives satisfactory results as opposed to seeking information and grouping. Finally, to meet the need for automation, we have defined what we call operators. They are based on the activities we have identified in the work of the company's engineers. We have shown that these operators would allow us to fully replicate our structured approach, thus allowing its effective application on other projects
9
BARROS, SERGE. "Analyse a priori des consequences de la modification de systemes logiciels : de la theorie a la pratique." Toulouse 3, 1997. http://www.theses.fr/1997TOU30267.
Full textAbstract:
Longtemps consideree comme une besogne de second ordre dans l'ombre d'activites bien plus nobles, la maintenance du logiciel, au dela de la simple correction d'erreurs, revele aujourd'hui d'autres facettes, comme la reutilisation de composants ou l'adaptation des systemes a des evolutions de besoins ou d'environnement, qui contribuent a en faire un des points cles de l'amelioration de la competitivite de l'industrie du logiciel. Toutefois, les couts de la maintenance etant generalement sous estimes, la maintenance ne se fait pas dans de bonnes conditions et les logiciels vieillissent mal, devenant des edifices instables, la moindre modification pouvant en compromettre l'equilibre. Il est donc primordial de pouvoir prevoir les consequences d'une modification avant meme de la realiser, ce qui est l'objectif de l'analyse d'impact. Nous presentons dans ce memoire une nouvelle approche generique de l'analyse d'impact, basee sur une propagation automatique, controlee par des regles, d'evenements sur un graphe des dependances modelisant le systeme. Elle permet de concilier la simplicite et la puissance des analyses automatiques a la precision des analyses manuelles. De plus, au travers de la realisation d'un outil implementant cette technique, puis de sa mise en oeuvre sur divers systemes representatifs, nous montrons que cette approche est particulierement adaptee a des systemes logiciels volumineux, necessitant un haut niveau de qualite, tels que ceux que l'on rencontre dans l'industrie spatiale. Mots cles : maintenance de logiciels, maitrise des evolutions, analyse d'impact.
10
Favre, Jean-Marie. "Une approche pour la maintenance et la ré-ingénierie globale des logiciels." Phd thesis, Université Joseph Fourier (Grenoble), 1995. http://tel.archives-ouvertes.fr/tel-00724676.
Full textAbstract:
Alors que l'informatique est résolument tournée vers l'avenir, cette thèse se concentre sur le passé ; non pas par nostalgie mais plutôt parce que le futur des logiciels âgés est une question d'actualité. Plus particulièrement trois thèmes sont abordés : la maintenance, la ré-ingénierie et la programmation globale. L'objectif de cette étude est d'explorer l'intersection entre la ré-ingénierie et la programmation globale, domaine que nous avons baptisé ré-ingénierie globale. L'idée principale est de réutiliser des concepts et des techniques de programmation détaillée. En fait nous proposons de définir la programmation globale en distinguant 4 aspects du logiciel : l'architecture, la manufacture, la variation et l'évolution. Un modèle abstrait basé sur des concepts ensemblistes est proposé pour modéliser les différentes entités de programmation globale. La technologie relative à ce domaine est ensuite décrite en considérant aussi bien l'état de l'art que l'état de la pratique. La différence entre ces deux aspects souligne l'intérêt de la ré-ingénierie globale. A titre d'illustration, nous étudions le cas des préprocesseurs en tant qu'outils de programmation globale. Ces outils de bas niveau provenant des années 70 sont traditionnellement utilisés pour décrire des familles de programmes. Pour faciliter la compréhension de tels artefacts nous proposons d'utiliser des techniques comme l'évaluation partielle, l'analyse inter-procédurale de flot de données ou encore le découpage. Ces techniques, définies de manière rigoureuse, s'appuient sur la sémantique dénotationnelle du préprocesseur utilisé. Un prototype montrant leur utilité a été réalisé. Il prouve qu'une approche basée sur des fondements théoriques issus de la programmation détaillée est applicable pour résoudre des problèmes pratiques de programmation globale.
11
Cavalcante, Hora André. "Assessing and improving rules to support software evolution." Thesis, Lille 1, 2014. http://www.theses.fr/2014LIL10114/document.
Full textAbstract:
Les systèmes logiciels évoluent pour ajouter de nouvelles fonctionnalités, corriger des bugs ou refactoriser du code source. Durant ce processus, certains problèmes peuvent survenir provoquant l'inconsistance ou l'échec des systèmes en évolution et avec leurs clients, ce qui aboutit finalement à une baisse de la qualité du code. Pour faire face à ces problèmes, il est possible d'utiliser des règles. Ces règles peuvent être créées par des experts ou extraites de précédentes versions du code source. Nous soutenons que les approches existantes : (i) n'analysent pas précisément les avantages des règles créées par des experts; (ii) gagneraient à mieux utiliser les dépôt de codes sources pour extraire des règles basées sur l'historique, et (iii) devraient analyser à grande échelle et sur des cas réels l'impact de l'évolution du code source sur les clients. Dans cette thèse, nous proposons d'analyser et d'améliorer les règles pour aider les développeurs à mieux suivre l'évolution du code source. Pour cela, nous étudions trois aspects différents :- Les avantages prévus par les règles créées par des experts : nous analysons précisément ces règles pour comprendre si elles valent la peine d'être adoptées malgré le coût pour les produire.- L'amélioration des règles basées sur l'historique : nous proposons deux solutions pour extraire de meilleures règles à partir du dépôt de codes sources.- L'impact de l'évolution du code source sur un écosystème logiciel : nous étudions les conséquences de l'évolution de code source sur des systèmes clients dans le contexte d'un écosystème de grande échelle.Les résultats que nous avons obtenus démontrent l'utilité de nos approchesSoftware systems evolve by adding new features, fixing bugs or refactoring existing source code. During this process, some problems may occur causing evolving systems and their clients to be inconsistent or to fail, decreasing code quality. One solution to deal with such maintainability problems is the usage of rules to ensure consistency. These rules may be created by experts or extracted from source code repositories, which are commonly evaluated in small-scale case studies. We argue that existing approaches lack of: (i) a deep understanding of the benefits provided by expert-based rules, (ii) a better use of source code repositories to extract history-based rules, and (iii) a large-scale analysis of the impact of source code evolution on the actual clients.In this thesis we propose to analyze and improve rules to better support developers keeping track of source code evolution. We cover three aspects: - The benefits provided by expert-based rules: we report on an investigation of rules created based on expert opinion to understand whether they are worthwhile to be adopted given the cost to produce them.- The improvement of history-based rules: we propose two solutions to extract better rules from source code history.- The impact of source code evolution on a software ecosystem: we undergo an investigation, in a large-scale ecosystem, on the awareness of the client systems about source code evolution. We evaluated the proposed approaches qualitatively and quantitatively. The results we obtained demonstrate the usefulness of our approaches
12
Chaabane, Rim. "Analyse et optimisation de patterns de code." Paris 8, 2011. http://www.theses.fr/2011PA084174.
Full textAbstract:
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
13
Durieux, Thomas. "From runtime failures to patches : study of patch generation in production." Thesis, Lille 1, 2018. http://www.theses.fr/2018LIL1I037/document.
Full textAbstract:
Dans le cadre de la gestion du cycle de vie d’une application, la création de correctifs de bugs est une des tâches les plus importantes. Or celle-ci prend aussi le plus de temps, non seulement parce qu'il est difficile de créer un bon correctif, mais également parce qu'elle nécessite des interventions humaines. Un utilisateur doit en effet signaler le bug et le développeur doit le reproduire et le corriger, processus long et fastidieux. Il existe des techniques qui automatisent cette tâche mais elles exigent toujours l’intervention humaine à savoir qu'un développeur crée un test reproduisant le bug, exigence qui réduit considérablement leur applicabilité. Dans le cadre de cette thèse, nous proposons une nouvelle approche qui supprime cette exigence en créant de nouvelles techniques de génération de correctifs. Notre approche repose sur l'idée de rapprocher le plus possible la génération de correctifs de l'environnement de production. En effet c’est celui-ci qui contient toutes les données et toutes les interactions humaines qui mènent aux bugs. Au cours de cette thèse, nous présentons comment exploiter ces données pour détecter les bugs, comment générer les correctifs et comment les valider, le tout sans l'intervention d'un développeur. Nous évaluons notre approche sur sept jeux différents de correctifs réels provenant de projets open-sources en veillant, entre autres, à être particulièrement attentifs au nombre de correctifs générés, à leur validité ainsi qu’au temps requis pour leur génération. Ces évaluations démontrent l'applicabilité et la faisabilité de notre approche dans la génération de correctifs en production sans l'intervention d'un développeurPatch creation is one of the most important actions in the life cycle of an application. Creating patches is a really time-consuming task. Not only because it is difficult to create a good and valid patch, but also because it requires the intervention of humans. Indeed, a user must report the bug and a developer must reproduce it and fix it, which takes a lot of time. To address this problem, techniques that automate this task have been created but those techniques still require a developer to create a test that reproduces the bug. This requirement drastically reduces the applicability of the approach since it still relies on the human. This thesis proposes new patch generation techniques that remove the human intervention for the generation of patches. Our idea is to put as close as possible the generation of patches to the production environment. We adopt this approach because the production environment contains all the data and human interactions that lead to the bug. During this thesis, we present how to exploit this data to detect bugs, generate and validate patches without the intervention of developers. We evaluate this approach on seven different benchmarks of real bugs collected from open-source projects. During the evaluation, we are particularly attentive to the number of generated patches, the correctness and the readability of the generated patches and the time required for generating them. Our evaluation shows the applicability and feasibility of our approach to generate patches in the production environment without the intervention of a developer
14
Ajila, Samuel Adesoye. "Maintenance logicielle : analyse d'impact, problématique et mise en oeuvre." Nancy 1, 1995. http://docnum.univ-lorraine.fr/public/SCD_T_1995_0029_AJILA.pdf.
Full textAbstract:
Notre travail concerne l'évaluation a priori de l'impact des changements réalisés sur les objets logiciels. Il est parfois difficile de comprendre toutes les conséquences d'un changement et de garantir qu'il n'y aura pas d'effets de bord gênants au niveau de l'ensemble du système logiciel. Il est donc utile d'apporter une aide à la décision de changement permettant de comprendre et d'analyser un changement avant de le faire. En particulier on doit prendre en compte la complexité des liens qui existent entre les différents composants logiciels. Pour tenir compte des conséquences d'un changement donné, il faut avoir une connaissance précise sur les liens entre les objets logiciels et analyser l'impact du changement. Pour cette raison, nous avons étudié les caractéristiques souhaitables d'une analyse d'impact qui permettront de comprendre, de comparer, et d'évaluer des approches différentes et nous proposons un cadre générique d'analyse d'impact. Ce cadre générique comporte trois parties : une approche d'analyse d'impact, la structure de cette approche, et la mesure d'efficacité de l'approche. Nous proposons ensuite une approche d'analyse d'impact d'un changement et pour cela nous avons : défini un modèle générique à base de connaissances sur la nature des liens entre les objets logiciels et sur les règles de propagation du changement ; validé ce modèle avec un prototype limité à deux étapes de cycle de vie, la conception et le code. Pour cette validation, nous avons choisi la méthode HOOD pour la conception et le langage de programmation Ada pour le code. Les outils existants d'analyse de l'impact du changement sont basés sur les méthodes de simulation (les méthodes dites algorithmiques) et ils n'adressent souvent que le code et parfois même qu'une partie du code. Nous avos montré dans ce travail qu'avec le modèle proposé, on peut dépasser la limite des méthodes de simulation et donner des informations plus détaillées sur l'effet d'un changement.
15
Charpentier, Alan. "Contributions à l’usage des détecteurs de clones pour des tâches de maintenance logicielle." Thesis, Bordeaux, 2016. http://www.theses.fr/2016BORD0131/document.
Full textAbstract:
L’existence de plusieurs copies d’un même fragment de code (nommées des clones dans lalittérature) dans un logiciel peut compliquer sa maintenance et son évolution. La duplication decode peut poser des problèmes de consistance, notamment lors de la propagation de correction debogues. La détection de clones est par conséquent un enjeu important pour préserver et améliorerla qualité logicielle, propriété primordiale pour le succès d’un logiciel.L’objectif général de cette thèse est de contribuer à l’usage des détecteurs de clones dans destâches de maintenance logicielle. Nous avons centré nos contributions sur deux axes de recherche.Premièrement, la méthodologie pour comparer et évaluer les détecteurs de clones, i.e. les benchmarksde clones. Nous avons empiriquement évalué un benchmark de clones et avons montré queles résultats dérivés de ce dernier n’étaient pas fiables. Nous avons également identifié des recommandationspour fiabiliser la construction de benchmarks de clones. Deuxièmement, la spécialisationdes détecteurs de clones dans des tâches de maintenance logicielle.Nous avons développé uneapproche spécialisée dans un langage et une tâche (la réingénierie) qui permet aux développeursd’identifier et de supprimer la duplication de code de leurs logiciels. Nous avons mené des étudesde cas avec des experts du domaine pour évaluer notre approcheThe existence of several copies of a same code fragment—called code clones in the literature—in a software can complicate its maintenance and evolution. Code duplication can lead to consistencyproblems, especially during bug fixes propagation. Code clone detection is therefore a majorconcern to maintain and improve software quality, which is an essential property for a software’ssuccess.The general objective of this thesis is to contribute to the use of code clone detection in softwaremaintenance tasks. We chose to focus our contributions on two research topics. Firstly, themethodology to compare and assess code clone detectors, i.e. clone benchmarks. We perform anempirical assessment of a clone benchmark and we found that results derived from this latter arenot reliable. We also identified recommendations to construct more reliable clone benchmarks.Secondly, the adaptation of code clone detectors in software maintenance tasks. We developed aspecialized approach in one language and one task—refactoring—allowing developers to identifyand remove code duplication in their softwares. We conducted case studies with domain experts toevaluate our approach
16
Abou, Khalil Zeinab. "Understanding the impact of release policies on software development processes." Thesis, Lille, 2021. http://www.theses.fr/2021LILUI011.
Full textAbstract:
Avec la livraison rapide de nouvelles fonctionnalités, de nombreux projets logiciels ont modifié leurs processus de développement pour aller vers des modèles où les versions sont publiées selon des cycles courts de quelques semaines ou quelques jours. L’adoption de politiques de publication rapide des logiciels a considérablement réduit le temps de stabilisation, c’est-à-dire le temps nécessaire pour que le taux d’échec d’un produit logiciel atteigne un état stable pour l’ensemble des nouvelles fonctionnalités. Cette mise en place de livraisons rapides a obligé les organisations et les entreprises à modifier leur processus de développement et leurs outils pour publier les nouvelles versions, ceci en un temps réduit tout en garantissant la qualité. Ces nouveaux processus de développement sont censés offrir un délai réduit de mise sur le marché, un retour d'information rapide de la part des utilisateurs. Ils doivent également améliorer le temps de traitement de correction des bugs. Les utilisateurs finaux bénéficient alors d’un accès rapide aux améliorations des fonctionnalités avec des mises à jour fiables. Malgré ces avantages, des recherches antérieures ont montré que les versions rapides se font souvent au détriment de la fiabilité logicielle. Cependant, avec l'adoption croissante des versions rapides des logiciels open source et commerciaux, les effets de cette pratique sur le processus de développement logiciel ne sont pas bien compris.L'objectif de cette thèse est de fournir une compréhension approfondie de l'impact de la livraison rapide de versions dans les différentes phases du processus de développement de logiciels open source. Cette thèse présente une étude de cas empirique de la livraison rapide de versions dans les projets Eclipse et Mozilla Firefox. Nous présentons les résultats d’expériences sur l'impact à court et à long terme de la livraison rapide de versions sur le processus de gestion et de test des bugs dans les organisations open source, ainsi que le plan et les outils nécessaires pour une adoption réussie des livraisons rapides de versions. Nous suivons une approche avec des méthodes mixtes où nous analysons les référentiels de logiciels, contenant différents types de données tels que le code source, les données de test et les rapports de bugs. Nous avons également mené une enquête auprès des développeurs Eclipse. Nos travaux aident à comprendre l'évolution et les changements du processus de développement logiciel ainsi que les plans et les pratiques nécessaires pour une adoption réussie de la livraison rapide de versions et identifient plusieurs perspectives de rechercheThe advent of delivering new features faster has led many software projects to change their development processes towards more rapid release models where releases are shipped using release cycles of weeks or days. The adoption of rapid release practices has significantly reduced the amount of stabilization time, the time it takes for a software product’s failure rate to reach close to the steady-state, available for new features. This forces organizations to change their development process and tools to release to the public, in a timely manner and with good quality. Rapid releases are claimed to offer a reduced time-to-market and faster user feedback; end-users bene- fit of faster access to functionality improvements and security updates and improve turnaround time for fixing bad bugs. Despite these benefits, previous research has shown that rapid releases often come at the expense of reduced software reliability. Despite the increasing adoption of rapid releases in open-source and commercial soft- ware, the effects of this practice on the software development process are not well understood.The goal of this thesis is to provide a deeper understanding of how rapid releases impact different parts of the open-source software development process. We present empirical evidence about the short and long-term impact of rapid releases on the bug handling and testing process in open source organizations; and the plan and tools that are needed for successful adoption of rapid releases. This thesis presents an empirical case study of rapid releases in Eclipse and Mozilla Firefox projects. We follow a mixed-methods approach where we analyze software repositories, containing different types of data such as source code, testing data and software issues; and we conduct a survey with Eclipse developers. This help in understanding the evolution and changes of the software development process, the plans and practices that are needed for successful adoption of rapid releases and we identify several future research directions calling for further investigation
17
Uquillas, Gómez Verónica Isabel. "Supporting integration activities in object-oriented applications." Thesis, Lille 1, 2012. http://www.theses.fr/2012LIL10196/document.
Full textAbstract:
Les développeurs doivent souvent intégrer des modifications dans les versions en production de leurs applications. Des techniques de fusion avancée et automatique les aident dans cette intégration. Cependant ces techniques ne permettent pas de garantir un système fonctionnel et ne supportent pas une adaptation à la carte. Les techniques de pointe sont pour la plus part des outils textuels qui ne fournissent pas un aperçu global des modifications. En même temps, les outils existants n'offrent pas la possibilité de comprendre les changements au sein de leur contexte spécifique. Les développeurs doivent lire le code changé, vérifier les `diffs', se construire une idée d'un changement par eux-mêmes et comprendre le contexte pour évaluer l'impact des modifications.Cela peut être compliqué dans l'intégration de grands systèmes avec des modifications dans différentes `branches'. La fusion textuelle automatique ne prend pas en compte les entités de programme qu’une modification affecte ou leurs dépendances. Les développeurs doivent comparer manuellement chaque des changements et leur source d'origine. Cette thèse présente une solution pour les activités d'intégration, comme aider à comprendre l'effet d'un changement au sein d'une longue liste de changements dans un `commit'. Nous proposons une représentation de l'histoire du code source et des modifications d'un logiciel. Nous calculons les dépendances logiques entre les changements. Avec le soutien d'un outil visuel pour la caractérisation des changements et des dépendances, il est possible de fournir une approche globale pour aider les développeurs à comprendre les changements et de les guider au cours des processus d’intégrationDevelopers deal with the integration of source code changes into the system release. Automatic and advanced merging techniques help them to merge their modifications. While these techniques help to merge changes, they do not guarantee to have a functional system, and they do not support performing cherry picking. Current state-of-the-art consists mostly of textual diff tools that do not provide an overview of the changes (how changes are distributed? what groups of entities did change?). At the same time, existing tools do not offer the possibility to understand changes within their specific context. Developers need to manually read the changed code, check the diffs to build an idea of a change, understand its context and assess its impact. This can be more complicated when developing large systems and the integration of streams of changes between branches is needed. Merging changes does not take into account the program entities they affect or their dependencies. Developers are responsible for performing manual and tedious comparison within the input stream of changes and also with their originating source. This dissertation presents a solution that supports the integration activities, such as aiding in understanding changes within a commit or within a stream of changes. We propose a first-class representation of the source code history and changes of a software system to enable the calculation of dependencies between changes. This combined with visual tool support for characterizing changes and dependencies, makes it possible to provide encompassing support for software integration aiding developers in understanding changes and guiding them during the merging processes
18
Teyton, Cédric. "Gestion des bibliothèques tierces dans un contexte de maintenance logicielle." Thesis, Bordeaux, 2014. http://www.theses.fr/2014BORD0123/document.
Full textAbstract:
Les logiciels dépendent de bibliothèques tierces pour réduire les coûts liés à leur développement et à leur maintenance. Elles proposent un ensemble de fonctionnalités robustes dont les développeurs peuvent tirer parti depuis une interface de programmation. Cependant, cette forte dépendance entre un logiciel et ses bibliothèques oblige les développeurs à reconsidérer leur rôle lorsque le logiciel évolue. Dans cette thèse, nous identifions plusieurs problématiques impliquant les bibliothèques tierces dans un contexte de maintenance logicielle. Plus particulièrement, une bibliothèque peut ne plus répondre aux besoins d’un logiciel et doit être remplacée par une nouvelle.Nous nommons cette opération une migration de bibliothèque.Nous soulevons dans ce contexte trois points qui caractérisent les difficultés rencontrées par les développeurs. Vers quelle bibliothèque migrer ? Comment appliquer la migration ? Avec l’aide de quels développeurs ? Cette thèse discute de solutions et apporte des contributions autour de ces problèmes. Nous présentons plusieurs approches et les évaluons lors de différents cas d’étude. L’analyse de l’évolution logicielle sera notre support de travail, dont la méthodologie est basée sur l’observation des changements de logiciels. Nous décrivons les limites actuelles de nos contribu-tions et ouvrons des perspectives futures pour enrichir l’état de l’art dans ce domaineSoftware depend on third-party libraries to reduce development and maintenance costs. Developers have access to robust functionalities through an application programming interface designed by these libraries. However, due to the strong relationship with these libraries, developers have to reconsider their position when the software evolves. In this thesis, we identify several re-search problems involving these third-party libraries in a context of software maintenance. More specifically, a library may not satisfy the software new requirements and has to be replaced by anew one. We call this operation a library migration.We leverage three points that characterize the impediments met by developers in this situation.To which library should they migrate ? How to migrate their software ? Who can help them in this case ? This thesis suggests answers and exposes several contributions to these problems. We define three approaches that are evaluated through several case studies. To achieve this work, weuse a methodology based on software evolution analysis to observe and understand how software change. We describe numerous perspectives to overcome the current limitations of our solutions
19
Fleurquin, Régis. "Des langages pour améliorer le développement et la maintenance des logiciels à base de composants." Habilitation à diriger des recherches, Université de Bretagne Sud, 2010. http://tel.archives-ouvertes.fr/tel-00511595.
Full textAbstract:
La définition d'éléments pouvant contribuer à améliorer le développement et la maintenance des logiciels est l'objectif des travaux de recherche menés en Génie Logiciel. Mon domaine de recherche porte depuis 2003 sur la définition et l'usage de langages « supports » (c'est-à-dire complétant les langages de développement) ; ceci dans le but de faciliter et d'améliorer le développement et la maintenance des applications logicielles conçues à l'aide de composants. Mes travaux se trouvent au carrefour de plusieurs disciplines du Génie Logiciel : le développement orienté composant, les architectures des logiciels, la maintenance et l'évolution, la qualité et l'ingénierie dirigée par les modèles. Ce document constitue une synthèse de mes activités de recherche menées au cours des sept dernières années au sein de l'équipe SE du laboratoire VALORIA et de l'équipe-projet INRIA TRISKELL. Il commence par donner une vision assez personnelle des courants qui animent le Génie Logiciel et dresse un aperçu de l'état actuel de cette discipline. Puis il introduit les quelques notions dont la maîtrise est nécessaire pour évoluer dans les domaines dans lesquels se sont déroulées mes activités. Il retrace ensuite mon parcours thématique au cœur de ces disciplines et détaille mes travaux sur le contrôle de l'évolution des architectures, la sélection de composants et la documentation et l'exécution des bonnes pratiques de modélisation.
20
De, Souza Santos Gustavo Jansen. "Assessing and improving code transformations to support software evolution." Thesis, Lille 1, 2017. http://www.theses.fr/2017LIL10034/document.
Full textAbstract:
Dans le domaine du développement logiciel, le changement est la seule constante. Les logiciels évoluent parfois de façon substantielle et, pendant ce processus, des séquences de transformation de code (par exemple, créer une classe, puis surcharger une méthode) sont systématiquement appliquées dans le système (e.g. à certaines classes dans une même hiérarchie). De par la nature répétitive de ces transformations, il est nécessaire d’automatiser leur support afin d’assurer que ces séquences de transformations sont appliquées de façon consistante sur la globalité du système.Dans cette thèse, nous proposons d’améliorer les transformations de code pour mieux aider les développeurs dans l’application de transformation de code systématiques et complexes. Nous couvrons deux aspects:• Le support automatisé pour composer et appliquer des séquences de transformations de code. Nous réalisons une recherche de l’existence de telles séquences dans de vrais logiciels. Nous proposons un outil pour appliquer automatiquement ces séquences dans les systèmes que nous avons analysés. • La détection de violations de bons principes dans la conception lors d’efforts de transformation. Nous proposons un outil qui recommande des transformations additionnelles pour résoudre les violations de conception qui ont pu être détectées après avoir effectué les transformations de refactoring.Nous évaluons les approches proposées quantitativement et qualitativement sur des cas d’étude issus du monde réel, parfois avec l’aide des experts du système analysé. Les résultats obtenus montrent la pertinence de nos approchesIn software development, change is the only constant. Software systems sometimes evolve in a substantial way and, during this process, sequences of code transformations (e.g., create a class, then override a method) are systematically performed in the system (e.g., to some classes in the same hierarchy). Due to the repetitive nature of these transformations, some automated support is needed to ensure that these sequences of transformations are consistently applied to the entire system.In this thesis we propose to improve source code transformations to better sup- port developers performing more complex and systematic code transformations. We cover two aspects: • The automated support to compose and apply sequences of code transformations. We undergo an investigation on the existence of these sequences in real-world software systems. We propose a tool to automatically apply these sequences in the systems we analyzed. • The detection of design violations during a transformation effort. We undergo an investigation on cases of systematic application of refactoring transformations. We proposed a tool that recommends additional transformations to fix design violations that are detected after performing refactoring transformations.We evaluated the proposed approaches quantitatively and qualitatively in real-world case studies and, in some cases, with the help of experts on the systems under analysis. The results we obtained demonstrate the usefulness of our approaches
21
Mordal, Karine. "Analyse et conception d'un modèle de qualité logiciel." Paris 8, 2012. http://www.theses.fr/2012PA084030.
Full textAbstract:
Nous présentons un modèle et un prototype d'analyse et d'évaluation de la qualité de grands logiciels de taille industrielle, le modèle Squash, fondé sur le modèle empirique conçu par les entreprises Qualixo et Air-France KLM. Nous déterminons une méthodologie précise d'évaluation de principes de qualité, tant au niveau technique que fonctionnel. A partir de notre méthodologie nous avons formalisé un modèle de qualité prenant en compte les particularités et exigences du domaine industriel. L'implémentation de ce modèle est en cours de validation chez Générali. A partir de l’étude des domaines du développement informatique et de la validation fonctionnelle, nous avons formalisé un modèle de qualité hiérarchique fondé sur les normes ISO 9126 et SquARE. Ce modèle est composé de deux niveaux : le niveau conceptuel de la qualité qui définit les grands principes de qualité à évaluer et le niveau technique de la qualité qui décrit des règles techniques de base et les mesures associées permettant l'évaluation du niveau supérieur. La principale difficulté dans l’élaboration de ce type de modèle consiste à déterminer comment passer des principes de qualité aux mesures et vice versa, tout en respectant deux principes fondamentaux : ne pas masquer les progrès et mettre en évidence les problèmes. Pour y parvenir nous utilisons d'une part, des formules de combinaison et d’agrégation de métriques et d'autre part, des formules à base de logique floue permettant d'évaluer la qualité à partir de mesures non issues de métriquesWe present a model and prototype for analysis and assess quality of large size industrial software, Squash model based on the empirical model developed by Qualixo and Air France-KLM enterprises. We determine an evaluation methodology for both technical and functional quality principles. Then we formalized a quality model taking into account the industrial applications requirements from this methodology. The implementation of this model is being validated by Generali. From the domain of software development and functional validation, we have formalized a model based on hierarchical quality models from standards ISO 9126 and Square. This model is divided into two levels: the conceptual quality level that defines the main quality principles and the technical quality that defines basic technical rules and measures used to assess the top level. The main issue of quality model conception is how to bring the gap between metrics and quality principles : the metrics meannig often defined for individual components cannot be easily transposed to higher abstraction levels. Furthermore, we need to highlight problems and do not hide progress. To achieve this, we use combinaison and aggregation formulas to asses quality principles from metrics and fuzzy logic to assess quality principles from non-metric measurements
22
Lelli, leitao Valeria. "Testing and maintenance of graphical user interfaces." Thesis, Rennes, INSA, 2015. http://www.theses.fr/2015ISAR0022/document.
Full textAbstract:
La communauté du génie logiciel porte depuis ses débuts une attention spéciale à la qualité et la fiabilité des logiciels. De nombreuses techniques de test logiciel ont été développées pour caractériser et détecter des erreurs dans les logiciels. Les modèles de fautes identifient et caractérisent les erreurs pouvant affecter les différentes parties d’un logiciel. D’autre part, les critères de qualité logiciel et leurs mesures permettent d’évaluer la qualité du code logiciel et de détecter en amont du code potentiellement sujet à erreur. Les techniques d’analyses statiques et dynamiques scrutent, respectivement, le logiciel à l’arrêt et à l’exécution pour trouver des erreurs ou réaliser des mesures de qualité. Dans cette thèse, nous prônons le fait que la même attention doit être portée sur la qualité et la fiabilité des interfaces utilisateurs (ou interface homme-machine, IHM), au sens génie logiciel du terme. Cette thèse propose donc deux contributions dans le domaine du test et de la maintenance d’interfaces utilisateur : 1. Classification et mutation des erreurs d’interfaces utilisateur. 2. Qualité du code des interfaces utilisateur. Nous proposons tout d’abord un modèle de fautes d’IHM. Ce modèle a été conçu à partir des concepts standards d’IHM pour identifier et classer les fautes d’IHM ; Au travers d’une étude empirique menée sur du code Java existant, nous avons montré l’existence d’une mauvaise pratique récurrente dans le développement du contrôleur d’IHM, objet qui transforme les évènements produits par l’interface utilisateur pour les transformer en actions. Nous caractérisons cette nouvelle mauvaise pratique que nous avons appelée Blob listener, en référence à la méthode Blob. Nous proposons également une analyse statique permettant d’identifier automatiquement la présence du Blob listener dans le code d’interface Java SwingThe software engineering community takes special attention to the quality and the reliability of software systems. Software testing techniques have been developed to find errors in code. Software quality criteria and measurement techniques have also been assessed to detect error-prone code. In this thesis, we argue that the same attention has to be investigated on the quality and reliability of GUIs, from a software engineering point of view. We specifically make two contributions on this topic. First, GUIs can be affected by errors stemming from development mistakes. The first contribution of this thesis is a fault model that identifies and classifies GUI faults. We show that GUI faults are diverse and imply different testing techniques to be detected. Second, like any code artifact GUI code should be analyzed statically to detect implementation defects and design smells. As for the second contribution, we focus on design smells that can affect GUIs specifically. We identify and characterize a new type of design smell, called Blob listener. It occurs when a GUI listener, that gathers events to treat and transform as commands, can produce more than one command. We propose a systematic static code analysis procedure that searches for Blob listener that we implement in a tool called InspectorGuidget. Experiments we conducted exhibits positive results regarding the ability of InspectorGuidget in detecting Blob listeners. To counteract the use of Blob listeners, we propose good coding practices regarding the development of GUI listeners
23
Dias, Victor. "Supporting software integration activities with first-class code changes." Thesis, Lille 1, 2015. http://www.theses.fr/2015LIL10101/document.
Full textAbstract:
Les développeurs changent le code source en parallèle les uns des autres, ce qui fait diverger les bases de code. Ces divergences se doivent d'être réintégrées. L'intégration de bases de code divergentes est une activité complexe. Par exemple, réunir deux bases de code indépendamment correctes peut générer des problèmes. L'intégration peut être difficile avec les outils existants, qui, au lieu de gérer l'évolution des entités réelles du programme modifié, gère les changements de code au niveau des lignes de texte dans les fichiers sources. Les outils sont importants: les outils de développement de logiciels se sont grandement améliorés en passant par exemple d'éditeurs de texte génériques à des IDEs qui fournissent de la manipulation de code de haut niveau tels que la refactorisation automatique et la complétion de code. Cette amélioration a été possible grâce à la réification des entités de programme. Néanmoins, les outils d'intégration n'ont pas profité d'une réification similaire des entités de changement pour améliorer l'intégration. Dans cette thèse nous avons d'abord conduit une étude auprès de développeurs pour comprendre quelles sont les activités menées durant une intégration qui sont peu supportées par les outils. L'une d'elle est la détection de commits mêlés (qui contiennent des tâches non liées telles qu'une correction de bug et une refactorisation).Ensuite, nous proposons Epicea, un modèle de changement réifié et des outils d'IDE associés, et EpiceaUntangler, une approche pour aider les développeurs à démêler les commits en se basant sur Epicea. Les résultats de nos évaluations avec des études de cas issues du monde réel montrent l’utilité de nos approchesDevelopers typically change codebases in parallel from each other, which results in diverging codebases. Such diverging codebases must be integrated when finished. Integrating diverging codebases involves difficult activities. For example, two changes that are correct independently can introduce subtle bugs when integrated together. Integration can be difficult with existing tools, which, instead of dealing with the evolution of the actual program entities being changed, handle code changes as lines of text in files. Tools are important: software development tools have greatly improved from generic text editors to IDEs by providing high-level code manipulation such as automatic refactorings and code completion. This improvement was possible by the reification of program entities. Nevertheless, integration tools did not benefit from a similar reification of change entities to improve productivity in integration. In this work we first conducted a study to learn which integration activities are important and have little tool support. We discovered that one of such activities is the detection of tangled commits (that contain unrelated tasks such as a bug fix and a refactoring). Then we proposed Epicea, a reified change model and associated IDE tools, and EpiceaUntangler, an approach to help developers share untangled commits based on Epicea. The results of our evaluations with real-world studies show the usefulness of our approaches
24
Levreau, Gilles. "Un environnement de conception, de documentation et de maintenance de schémas de bases de données." Paris 6, 1995. http://www.theses.fr/1995PA066376.
Full textAbstract:
Lors du processus de conception d'une base de données, la représentation graphique du schéma conceptuel de cette base joue un rôle central car elle aide à comprendre et a communiquer le schéma. Cependant, cette représentation graphique peut être plus ou moins efficace selon son adéquation avec les attentes et besoins des concepteurs. La recherche présentée dans cette thèse concerne un éditeur graphique de schémas conceptuels de type entité/association. L'objectif de notre recherche est de concevoir l'éditeur de manière a favoriser le processus de conception et de maintenance des bases de données. A cette fin nous avons considèré deux axes de recherche. Le premier axe est base sur une étude de la convivialité de la représentation graphique des schémas, en ayant recours d'une part a l'ergonomie, d'autre part a une modélisation formelle de la représentation graphique de schémas. Le second axe de recherche consiste à se servir de l'éditeur graphique pour simplifier la gestion des informations liées au schéma d'une base de données. A cette fin nous proposons d'introduire des facilites hyper textuelles dans l'éditeur graphique
25
Zimmermann, Théo. "Challenges in the collaborative evolution of a proof language and its ecosystem." Thesis, Université de Paris (2019-....), 2019. http://www.theses.fr/2019UNIP7163.
Full textAbstract:
Dans cette thèse, je présente l'application de méthodes et de connaissances en génie logiciel au développement, à la maintenance et à l'évolution de Coq —un assistant de preuve interactif basé sur la théorie des types— et de son écosystème de paquets. Coq est développé chez Inria depuis 1984, mais sa base d’utilisateurs n’a cessé de s’agrandir, ce qui suscite désormais une attention renforcée quant à sa maintenabilité et à la participation de contributeurs externes à son évolution et à celle de son écosystème de plugins et de bibliothèques.D'importants changements ont eu lieu ces dernières années dans les processus de développement de Coq, dont j'ai été à la fois un témoin et un acteur (adoption de GitHub en tant que plate-forme de développement, tout d'abord pour son mécanisme de pull request, puis pour son système de tickets, adoption de l'intégration continue, passage à des cycles de sortie de nouvelles versions plus courts, implication accrue de contributeurs externes dans les processus de développement et de maintenance open source). Les contributions de cette thèse incluent une description historique de ces changements, le raffinement des processus existants et la conception de nouveaux processus, la conception et la mise en œuvre de nouveaux outils facilitant l’application de ces processus, et la validation de ces changements par le biais d’évaluations empiriques rigoureuses.L'implication de contributeurs externes est également très utile au niveau de l'écosystème de paquets. Cette thèse contient en outre une analyse des méthodes de distribution de paquets et du problème spécifique de la maintenance à long terme des paquets ayant un seul responsableIn this thesis, I present the application of software engineering methods and knowledge to the development, maintenance, and evolution of Coq —an interactive proof assistant based on type theory— and its package ecosystem. Coq has been developed at Inria since 1984, but has only more recently seen a surge in its user base, which leads to much stronger concerns about its maintainability, and the involvement of external contributors in the evolution of both Coq, and its ecosystem of plugins and libraries.Recent years have seen important changes in the development processes of Coq, of which I have been a witness and an actor (adoption of GitHub as a development platform, first for its pull request mechanism, then for its bug tracker, adoption of continuous integration, switch to shorter release cycles, increased involvement of external contributors in the open source development and maintenance process). The contributions of this thesis include a historical description of these changes, the refinement of existing processes, and the design of new ones, the design and implementation of new tools to help the application of these processes, and the validation of these changes through rigorous empirical evaluation.Involving external contributors is also very useful at the level of the package ecosystem. This thesis additionally contains an analysis of package distribution methods, and a focus on the problem of the long-term maintenance of single-maintainer packages
26
Tibermacine, Chouki. "Contractualisation de l'évolution architecturale de logiciels à base de composants : Une approche pour la préservation de la qualité." Phd thesis, Université de Bretagne Sud, 2006. http://tel.archives-ouvertes.fr/tel-00512361.
Full textAbstract:
De toutes les étapes qui constituent le processus de maintenance, l'étape de compréhension d'une application avant son évolution, et l'étape de vérification de sa progression et de sa non régression aprés évolution sont de loin les plus coûteuses. Dans cette these, je présente une approche qui diminue les coûts associés a ces deux étapes, pour des applications conçues à l'aide de composants. Dans cette approche, les liens unissant les attributs qualité d'une application et les décisions architecturales sont documentés formellement. La définition de ces liens se fait a chaque étape du cycle de vie de l'application. J'ai développé un environnement d'assistance à l'évolution, qui exploite cette documentation, pour d'une part, garantir sa mise a jour et d'autre part, notifier au développeur les effets possibles sur les exigences qualité des changements architecturaux proposés. Cette documentation forme ainsi un contrat dit d'évolution. Il s'agit d'un accord entre l'architecte de l'application et le responsable de son évolution. Le premier doit expliciter ses décisions de conception, sous la forme d'un ensemble de contraintes, afin qu'elles puissent être respectées lors du développement et de l'évolution. Le second doit respecter ce contrat afin de bénéficier d'une garantie de préservation de la qualité initialement requise. Ceci permet, principalement, de réduire les coûts associés aux tests de non-régression sur l'aspect non-fonctionnel. Cette même documentation est utilisée pour tracer toutes les décisions architecturales tout au long du processus de développement d'un logiciel. Il est possible, ainsi, de vérifier, à une étape donnée du processus, la non-altération de toutes les décisions prises dans les étapes en amont. J'ai proposé un outil permettant de transformer vers une représentation unique, puis évaluer, les contraintes définies lors des différentes étapes. Cette traçabilité des décisions a pour objectif de rendre persistants les attributs qualité qui sont à l'origine de ces décisions, à travers toutes les étapes du cycle de vie d'un logiciel.
27
Habchi, Sarra. "Understanding mobile-specific code smells." Thesis, Lille 1, 2019. http://www.theses.fr/2019LIL1I089.
Full textAbstract:
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
28
Prun, Daniel. "Methodologie de conception de composants logiciels cooperatifs : une approche pour l'observation, la mise au point et la maintenance evolutive d'applications reparties." Paris 6, 1998. http://www.theses.fr/1998PA066297.
Full textAbstract:
L'activite de maintenance represente plus de 80% du cycle de vie d'un logiciel. Cette part est croissante car les environnements d'execution sont de plus en plus complexes, et car l'inter-operation de composants applicatifs, d'extensions enfichables et de service de la plate-forme est beaucoup plus difficile a comprendre que l'execution d'une application monolithique. De plus, l'activite de maintenance n'apparait qu'a posteriori dans le cycle de vie du logiciel. Nous proposons une approche methodique centree sur l'interaction ou la mise au point et la maintenance sont prises en compte des la conception. Les applications visees sont celles que nous qualifions de cooperatives. Elles utilisent des organisations en groupe, des techniques d'appels d'offres, de prise de decisions collectives, de negociation. Elles utilisent au mieux la gestion du parallelisme, de la repartition et des phenomenes dynamiques (courtage de requetes, nomadisme des utilisateurs ou mobilite du code). L'approche que nous proposons : - est centree sur l'interaction : un composant s'execute dans le contexte d'une collaboration formalise par un squelette d'interaction. - favorise adaptation et re-utilisation : la demarche consiste a structurer l'application de maniere a faire apparaitre des problemes recurrents pour lesquels des patrons de conception existent. Les patrons de conceptions documentent les squelettes. - favorise la maintenance : les composants integrent des mecanismes d'observation et de re-execution de leur comportement. Cette methode est mise en oeuvre dans la conception et la realisation de structures de controle et d'outils d'observation et de re-execution dans le cadre de la plate-forme mathilda dont nous discutons les limites et les possibilites d'evolution.
29
Belkhatir, Noureddine. "NOMADE un noyau d'environnement pour la programmation globale /." Grenoble 2 : ANRT, 1988. http://catalogue.bnf.fr/ark:/12148/cb376117044.
Full text
30
Roume, Cyril. "Analyse et restructuration de hiérarchies de classes." Montpellier 2, 2004. http://www.theses.fr/2004MON20088.
Full text
31
Ahmad, Adeel. "Contribution à la multi-modélisation des applications distribuées pour le contrôle de l'évolution des logiciels." Thesis, Littoral, 2011. http://www.theses.fr/2011DUNK0387/document.
Full textAbstract:
Le contrôle de l'évolution des logiciels exige une compréhension profonde des changements et leur impact sur les différents artefacts du système. Nous proposons une approche de multi-modélisation pour l'analyse d'impact du changement pour une compréhension des effets des modifications prévus ou réels dans les systèmes distribués. Ce travail consiste à élaborer une modélisation des artefacts logiciels et de leur différents liens d'interdépendance pour construire un système à base de connaissance permettant, entre autres, d'assister les développeurs et les chargés de l'évolution des logiciels pour étblir une évaluation a priori de l'impact des modifications.La modélisation que nous élaborons intègre deux descriptions majeures des logiciels, dans un premier temps, la description structurelle sous-jacente qui englobe l'ensemble des niveaux granulaires et l'abstraction des constituants logiciels, et ensuite la description qualitative conçue pour s'intégrer à la description précédente. Deux modèles, d'abord élaborés individuellement pour les deux descriptions respectives, ont été intégrés ou mis en correspondance dans l'objectif d'étudier l'impact de toute modification et sa potentielle propagation à travers les constituants logiciels concernés. Lors de chaque modification, il devient alors possible d'établir un bilan qualitatif de son impact. La modélisation intégrée est élaborée pour se prêter à un raisonnement à base de règles expertes. La modélisation proposée est en cours d'expérimentation et validation à travers le développement d'une plate-forme d'implémentation basée sur l'environnement EclipseThe software evolution control requires a complete understanding of the changes and their impact on the various systems artifacts. We propose a multi-modeling approach for the change impact analysis to provide assistance in understanding the effects of projected or actual changes in distributed software systems. This work elaborate the modeling of software artifacts along with their various interdependencies to build a knowledge-based system, which allows, among others, an assistance for the software developers or maintenance engineers to establish an a priori evaluation of impact of changes. The model we develop integrates two major descriptions of software, at first, the underlying structural description that encompasses the levels of granularity and abstraction of software artifacts, and then the qualitative description designed to integrate the structural description. Initially, the formal models are designed separately for the respective descriptions, and then these are integrated for the objective to study the change impact and its potential propagation through the affected software artifacts. For a change, it is important to establish a qualitative assessment of its impact. The integrated modeling leads to a reasoning based on expert rules. The proposed model is being tested and validated through the development of a platform, implemented in the Eclipse environment
32
Laval, Jannik. "Package Dependencies Analysis and Remediation in Object-Oriented Systems." Phd thesis, Université des Sciences et Technologie de Lille - Lille I, 2011. http://tel.archives-ouvertes.fr/tel-00746240.
Full textAbstract:
Les logiciels évoluent au fil du temps avec la modification, l'ajout et la suppression de nouvelles classes, méthodes, fonctions, dépendances. Une conséquence est que le comportement peut être placé dans de mauvais paquetages et casser la modularité du logiciel. Une bonne organisation des classes dans des paquetages identifiables facilite la compréhension, la maintenance, les tests et l'évolution des logiciels. Nous soutenons que les responsables manquent d'outils pour assurer la remodularisation logicielle. La maintenance des logiciels nécessite des approches qui aident à (i) la compréhension de la structure au niveau du paquetage et l'évaluation de sa qualité; (ii) l'identification des problèmes de modularité, et (iii) la prise de décisions pour le changement. Dans cette thèse nous proposons ECOO, une approche qui aide la remodularisation. Elle concerne les trois domaines de recherche suivants: (i) Comprendre les problèmes de dépendance entre paquetages. Nous proposons des visualisations mettant en évidence les dépendances cycliques au niveau des paquetages; (ii) Proposer des dépendances qui devraient être changées. L'approche propose des dépendances à changer pour rendre le système plus modulaire; (iii) Analyser l'impact des changements. L'approche propose une analyse d'impact du changement pour essayer les modifications avant de les appliquer sur le système réel. L'approche présentée dans cette thèse a été validée qualitativement et les résultats ont été pris en compte dans la réingénierie des systèmes analysés. Les résultats obtenus démontrent l'utilité de notre approche.
33
Kadri, Reda. "Proposition d'une méthode et d'un outil pour le développement d'applications." Phd thesis, Université de Bretagne Sud, 2009. http://tel.archives-ouvertes.fr/tel-00511828.
Full textAbstract:
De nos jours, le traitement de l'information par l'intermédiaire d'applications Web est largement adopté. Les avantages de ces applications ne sont plus, aujourd'hui, à démontrer et leur adoption massive par les entreprises ou par les administrations est un fait indéniable. Nous remarquons, par exemple, la forte émergence d'applications et de systèmes collaboratifs de gestion de contenus en ligne, de syndication, d'importation et d'exportation de données. En plus du développement de nouvelles applications Web, les entreprises doivent, maintenant, faire face aux demandes de transformations, ou de pseudo migration, des applications de type Desktops vers le mode Web. Ainsi, des milliers d'applications de différents domaines sont appelées à être déployées sur le Web. Ainsi, dans un futur proche, nous n'aurons plus besoin d'installer de logiciels sur nos ordinateurs ni même d'y stocker des fichiers. En effet, d'ores-et-déjà, tous ces services peuvent être rendus par le Web 2.0. Chaque application ou presque a son pendant en ligne, qu'il s'agisse de retoucher une image, de faire du montage vidéo, de convertir des fichiers, de créer des documents, etc. L'objectif de cette thèse, dans le cadre d'une collaboration entre Alkante (société spécialisée dans le conseil et l'ingénierie des technologies de l'information) et le Valoria, est d'offrir un cadre (outils et méthodes) pour faciliter, dans le paradigme composant, le développement et l'évolution d'applications Web. Mon premier travail a consisté à proposer un protocole de migration permettant un passage, en douceur, d'un processus de développement classique à un processus de développement à base de composants logiciels. Ce protocole a rendu possible la réutilisation de codes existants et a permis, aux développeurs, de se familiariser avec les concepts et les bases du développement à base de composants logiciels. Une fois cette migration effectuée, j'ai proposé une nouvelle approche pour la modélisation d'applications Web dans un contexte purement composant. Cependant, une autre question liée à la maintenance et aux coûts d'évolution se posait. Les applications Web sont particulièrement sujettes à de nombreuses évolutions, très régulières dans le temps. Afin de maîtriser l'évolution des applications développées et pour réduire les coûts de maintenance, j'ai utilisé une solution appelée contrats d'évolution.
34
Asse, Abdallah. "Aide au diagnostic industriel par des méthodes basées sur la théorie des sous-ensembles flous." Valenciennes, 1985. https://ged.uphf.fr/nuxeo/site/esupversions/c72e776b-0420-445e-bc8f-063e67804dad.
Full text
35
Xiong, Joseph. "Une méthode d'inspection automatique de recommandations ergonomiques tout au long du processus de conception des applications Web." Toulouse 3, 2008. http://thesesups.ups-tlse.fr/373/.
Full textAbstract:
Les applications Web actuelles offrent de plus en plus de services. Pour éviter les difficultés d'usage de ces applications, l'utilisabilité doit être assurée. L'évaluation de l'utilisabilité est une tâche qui requiert une expertise en ergonomie logicielle. Cette expertise peut être capitalisée sous forme de recommandations qui sont l'expression d'une connaissance en ergonomie et qui vont aider à l'évaluation. Toutefois, puisqu'il est nécessaire d'appliquer celles-ci de manière systématique, leur inspection manuelle peut s'avérer laborieuse. Pour ne pas être limité par l'inspection manuelle, des outils ont été développés pour guider et supporter l'inspection automatique. Un des avantages de ces outils est que les connaissances en ergonomie y sont directement intégrées. De plus, le manque d'experts et le coût élevé des autres méthodes d'évaluation font que l'inspection automatique est une méthode adaptée. Cependant, ces outils ne peuvent évaluer que l'application finale et si des erreurs sont détectées, des modifications importantes de l'application peuvent avoir lieu. Dans cette thèse nous proposons une méthode d'évaluation basée sur modèles permettant de s'assurer tout au long du cycle de vie de l'utilisabilité des applications Web développées. Nous avons établi une ontologie qui organise les recommandations autour des éléments de l'interface pour identifier précisément quels éléments évaluer à chaque étape du cycle de vie. .The increasing use of the Web as a software platform together with the advance of technology has promoted Web applications as a start point for delivering information and services. Facing to the ever growing number of users, usability became a major requirement for the universal access of Web applications. In the last years, a number of evaluation methods have been developed by researchers, practitioners and Information Technology companies to help organizations to identify and to fix usability problems. However, usability evaluation of Web sites is not a straightforward process. On one hand, usability evaluation requires some knowledge and expertise in software ergonomics. One the other hand, due to constant evolution of Web application, it is required frequent evaluations to make sure that content updates do not introduce new usability problems. In order to overcome these limitations, much effort has been devoted in the development of tools for automating the inspection of usability and accessibility guidelines. However, tools currently available can only evaluate the final applications. In this thesis we propose a model-based evaluation method that allows ensuring the ergonomic quality of Web applications throughout the lifecycle. .
36
Feng, Haitang. "Data management in forecasting systems : optimization and maintenance." Phd thesis, Université Claude Bernard - Lyon I, 2012. http://tel.archives-ouvertes.fr/tel-00997235.
Full textAbstract:
Forecasting systems are usually based on data warehouses for data strorage, and OLAP tools for historical and predictive data visualization. Aggregated predictive data could be modified. Hence, the research issue can be described as the propagation of an aggregate-based modification in hirarchies and dimensions in a data warehouse enironment. Ther exists a great number of research works on related view maintenance problems. However, to our knowledge, the impact of interactive aggregate modifications on raw data was not investigated. This CIFRE thesis is supported by ANRT and the company Anticipeo. The application of Anticipeo is a sales forecasting system that predicts future sales in order to draw appropriate business strategy in advance. By the beginning of the thesis, the customers of Anticipeo were satisfied the precision of the prediction results, but not with the response time. The work of this thesis can be generalized into two parts. The first part consists in au audit on the existing application. We proposed a methodology relying on different technical solutions. It concerns the propagation of an aggregate-based modification in a data warehouse. the second part of our work consists in the proposition of a newx allgorithms (PAM - Propagation of Aggregated-baseed Modification) with an extended version (PAM II) to efficiently propagate in aggregate-based modification. The algorithms identify and update the exact sets of source data anf other aggregated impacted by the aggregated modification. The optimized PAM II version archieves better performance compared to PAM when the use of additional semantics (e.g. dependencies) is possible. The experiments on real data of Anticipeo proved that the PAM algorithm and its extension bring better perfiormance when a backward propagation.
37
Ajouli, Akram. "Vues et transformations de programmes pour la modularité des évolutions." Phd thesis, Ecole des Mines de Nantes, 2013. http://tel.archives-ouvertes.fr/tel-00866997.
Full textAbstract:
La maintenance consomme une grande partie du coût de développement des logiciels ce qui rend l'optimisation de ce coût parmi les enjeux importants dans le monde du génie logiciel. Dans cette thèse nous visons à optimiser ce coût par rendre ces maintenances modulaires. Pour atteindre cet objectif, nous définissons des transformations des architectures des programmes qui permettent de transformer le programme à maintenir vers une architecture qui facilite la tâche de maintenance voulue. Nous nous concentrons plus sur la transformation entre les architectures à propriétés de modularité duales tels que les patrons de conception Composite et Visiteur. Dans ce contexte, nous définissons une transformation automatique et réversible basée sur le refactoring entre un programme structuré selon le Composite et sa structureVisiteur correspondante. Cette transformation est validée par la génération d'une précondition qui garantit statiquement sa réussite. Elle est aussi adaptée afin qu'elle prenne en compte la transformation de quatre variations du patron Composite et est validée sur le programme JHotDraw qui comporte ces quatre variations. Nous définissons aussi une transformation réversible au sein du patron Singleton afin de pouvoir bénéficier de l'optimisation par l'introduction de ce patron et la souplesse par sa suppression selon les exigences de l'utilisateur du logiciel.
38
Teruel, Camille. "Adaptability and encapsulation in dynamically typed languages : taming reflection and extension methods." Thesis, Lille 1, 2016. http://www.theses.fr/2016LIL10004/document.
Full textAbstract:
Les utilisateurs s'attendent à ce que les logiciels soient à la fois continuellement disponibles et mis-à-jour à la volée. L'introduction de nouvelles fonctionnalités et l'intégration de correctifs ne doit pas perturber la bonne marche d'une application. Les développeurs bénéficient aussi de la modification dynamique des logiciels en adaptant le code à de nouvelle situations ou bien an exécutant des analyses dynamiques à des fins de monitorage, de déboguage et d’optimisation. Les langages de programmation doivent donc fournir aux développeurs des mécanismes qui améliorent l'adaptabilité logicielle. Dans le même temps, l'augmentation de la taille et de la complexité des logiciels requièrent des applications faites de nombreux composants développés par différents groupes. Dans ce contexte chaque composant doit être convenablement protégé des autres. Les langages de programmation doivent donc aussi fournir des mécanismes qui améliorent l'encapsulation. Le besoin de supporter des adaptations dynamiques d'un côté, et le besoin d'avoir des composants convenablement confinés d'un autre, poussent la conception des langages de programmation dans deux directions opposées: soit plus de flexibilité, soit plus de contrôle. Cette dissertation étudie cette tension dans le contexte des langages orientée-objet dynamiquement typés via deux mécanismes qui promeuvent l'adaptabilité logicielle: la réflexion et les méthodes d’extension. Pour chacun de ces mécanismes, nous démontrons leur utilité, leurs effets néfastes sur l'encapsulation et proposons des solutions qui conservent leurs forces tout en maintenant l'encapsulationUsers expect modern software to be both continually available and updated on the fly. Introduction of new features and integration of bug fixes should not trouble the smooth running of an application. Developers also benefit from dynamic modifications of software by adapting code to new unanticipated situations or by running dynamic analyses to get feedback about the behavior of running applications for monitoring, debugging and optimization purposes. Programming languages should thus provides developers with mechanisms that improve software adaptability. At the same time, the increasing size and complexity of software call for applications made up of many interacting components developed by different parties. In this context, each component needs to be properly protected from other ones. Programming languages should thus provide developers with mechanisms that improve encapsulation. The need for dynamic adaptations on the one hand and the need for properly confined components on the other hand pulls programming language design in two opposite directions: either more flexi-bility or more control.This dissertation studies this tension in the context of dynamically-typed object-oriented languages with two language mechanisms that promote software adaptability: reflection and extension meth-ods. For both mechanisms, we demonstrate their usefulness, their harmful effect on encapsulation and propose solutions to retain their power while maintaining encapsulation
39
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.
Full textAbstract:
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
40
Blondeau, Vincent. "Test selection practices in a large IT company." Thesis, Lille 1, 2017. http://www.theses.fr/2017LIL10101/document.
Full textAbstract:
Worldline, une importante société d’informatique, doit améliorer la qualité de ses projets. Nous avons réalisé un audit sur plusieurs projets de l’entreprise afin d’identifier comment éviter l’échec des projets: aucune conclusion définitive n'en a été tirée. Cependant, il a mis en lumière le besoin d’améliorer l’utilisation des tests. Effectivement, tester chaque partie du code est requis pour éviter l’échec du projet. Dans l’industrie, notamment à Worldline, l’automatisation des tests a commencé dans le but de maîtriser le comportement des applications. Mais, exécuter tous les tests après un changement peut être une coûter plusieurs heures. Le retour sur le code changé est retardé et le développeur perd du temps pour découvrir les potentiels bogues. La solution généralement proposée dans la littérature consiste à réduire le nombre de tests à lancer en sélectionnant seulement ceux relatifs aux derniers changements effectués. L’approche sélectionne un jeu de tests réduit et approprié qui détectera de potentielles régressions dans l’application. Chaque approche de sélection de tests a besoin d’être étudiée dans le contexte de Worldline et adaptée en conséquence pour convenir aux habitudes des développeurs. Avant d’intégrer une telle approche, une étude a été faite pour connaître les habitudes actuelles des développeurs vis-à-vis de la sélection de tests. Grâce à cette étude, nous avons développé un outil pour les développeurs visant à effectuer la sélection des tests. Le but est aussi d’étudier l’impact de cet outil sur leur comportement. Nous espérons que cette approche de sélection de tests apportera des changements dans leur processus de développementWorldline, a major IT company, has to increase the quality of its projects. We performed an audit of several projects of the company to identify how to avoid project failure: no final conclusion has been drawn. However, it highlighted a need to enhance testing usage. To test every piece of code is compulsory to avoid project failure. In industry and more specifically in Worldline, automation of tests has begun to ensure the proper behavior of their applications. But, ensuring the execution of all tests after a change can be a costly operation requiring several hours. Feedback on the changed code is delayed and developer has to spent time to discover the potential bugs. The solution generally proposed in literature consists in reducing the number of tests to run by selecting only the ones related to the last changes made by the developer. The approach selects a suitable and small set of tests to detect potential regression in the application behavior.These approaches need to be studied in the context of Worldline and consequently adapted to suit developers’ habits. Before integrating such an adapted test selection approach, a study of the testing behavior of the developers has been done to get their current test selection usage. Based on the study of the Worldline environment, we developed a tool for the developers aiming to perform test selection.The goal is also to study the impact of this tool on their behavior. We hope that the test selection approach that is packaged in a tool adapted to the Worldline developers will bring a change in their developmentprocess
41
Ayeb, Neil. "Administration autonomique et décentralisée de flottes d'équipements de l'Internet des Objets." Thesis, Université Grenoble Alpes, 2020. http://www.theses.fr/2020GRALM054.
Full textAbstract:
Avec l'avènement de l'internet des objets (IdO) qui se base sur des objets hétérogènes, dynamiques et de haute volumétries, des besoins en administration à distance. Il s'agit par exemple de mise à jour de logiciels, de configurations, de résolution de problèmes à distance ainsi que de récolte de données de fonctionnement. Ces opérations d'administration permettent d'assurer une bonne qualité de service et d'expérience pour les utilisateurs. Elles permettent en outre, le déploiement de nouvelles fonctionnalités, de correctifs logiciels, et de mise à jour de sécurité.Les plateformes industrielles existantes d'administration montrent leurs limites avec des parcs formés d'objets statiques, en termes de capacités et d'environnements, comme les passerelles internet domestiques et décodeurs de flux TV. Ces plateformes sont opérées manuellement par des équipes d'administrateurs systèmes et requièrent une expertise conséquente.Concernant les flottes de l'IdO, l'hétérogénéité se traduit en un ensemble d'équipements ayant des capacités différentes de calcul et de connectivité réseau. La dynamicité concerne les environnements de ces équipements qui varient en termes de services en cours d'exécution, de qualité du lien réseau, de capacité restante de calcul. La volumétrie des objets de d'IdO impose un besoin de passage à l'échelle afin de gérer des milliards d'équipements contrairement aux flottes composée de millions d'équipements aujourd'hui.Par suite, l'administration de flottes de l'IdO requiert une adaptation constante de ces opérations en termes de nature, de vitesse et de cible. Les approches manuelles existantes ne permettent pas de réaliser ces opérations en prenant en compte les spécificités de l'IdO.Afin d'adresser cette problématique, ce travail de thèse industrielle chez Orange, vise à appliquer le paradigme de l'informatique autonomique au pilotage et la distribution des plateformes d'administration. L'objectif est d'assurer que les besoins en administration des flottes de l'IdO soient automatiquement réalisés, et ce, avec une consommation optimale de ressources de calcul et de réseau, ainsi qu'avec un nombre le moins élevé possible, d'erreurs d'exécution.Notre proposition s'appuie sur quatre boucles autonomiques coordonnées. Deux d'entre elles sont responsables de l'automatisation du maintien à jour de la flotte d'équipements tandis que les deux autres sont chargées de la régulation de l'utilisation des ressources assurant ainsi un passage à l'échelle vertical et horizontal.Notre proposition est validée au travers de deux prototypes. Le premier sert de démonstrateur de l'utilisabilité de notre approche pour le pilotage d'une plateforme industrielle d'administration de l'IdO (Live Objects d'Orange) qui est utilisée en production. Le deuxième démontre les capacités de passage à l'échelle vertical de notre proposition. Il s'appuie sur des technologies à code source ouverts. Les résultats sont encourageants par rapport aux approches existantes (p. ex. Vitesse d'exécution multipliée par deux sans augmentation du taux d'équipements en dysfonctionnement)With the expansion of Internet of Things (IoT) that relies on heterogeneous; dynamic; and massively deployed devices; Device Management (DM), which consists of firmware update, configuration, troubleshooting and tracking, is required for proper quality of service and user experience, deployment of new functions, bug fixes and distribution of security patches.Existing Home and IoT industrial DM platforms are already showing their limits with a few static home and IoT devices (e.g., routers, TV Decoders). Currently, these platforms are mainly manually operated by experts such as system administrators, and require extensive knowledge and skills. Heterogeneity implies that devices have diverse compute and network capabilities. Dynamicity translates to variation of devices environments (e.g., network quality, running services, nearby devices). The massive aspect is reflected in fleets composed of billions of devices as opposed to millions currently.Therefore, IoT device administration requires launching administration operations that assure the well-functioning of device fleets. These operations are to be adapted in terms of nature, speed, target, accordingly to devices current service requirements, computing capabilities and network conditions. Existing manually operated approaches cannot be applied on these massive and diverse devices forming the IoT.To tackle these issues, our work in an industrial research context, at Orange Labs, proposes applying autonomic computing to platform operation and distribution. It aims to ensure that administration requirements of a device fleet are automatically fulfilled using the optimal amount of resources and with the least amount of execution errors.Specifically, our contribution relies on four coordinated autonomic loops. The first two loops are responsible for handling fleet variation and update operations dispatching, while the remaining two others focus on vertical and horizontal scalability. Our approach allows automatic administration platform operation, more accurate and faster error diagnosis, vertical and horizontal scaling along with simpler IoT DM platform administration.For experimental validation, we developed two prototypes: one that demonstrates the usability of our approach with Orange's industrial IoT platform for its piloting, while the other one demonstrates vertical scalability using extended open-source remote administration software. Our prototypes show encouraging results, such as two times faster firmware upgrade operation execution speed, compared to existing legacy telecommunication operator approaches
42
BLAZY, SANDRINE. "La specialisation de programmes pour l'aide a la maintenance du logiciel." Paris, CNAM, 1993. http://www.theses.fr/1993CNAM0183.
Full textAbstract:
L'objectif de cette these est d'etudier les modeles d'execution de la maintenance du logiciel, de concevoir une methode et un outil d'aide a la comprehension de programmes utilisant en particulier la simplification par specialisation, et de valider les resultats au travers d'exemples issus de reelles applications scientifiques ecrites en fortran. Nous avons utilise l'evaluation partielle (ou specialisation de programmes en fonction de proprietes de leurs donnees d'entree) pour des programmes difficiles a maintenir car trop generaux. A partir d'un programme fortran initial et de valeurs particulieres de certaines de ces donnees d'entree, l'outil fournit -entierement automatiquement- un programme simplifie qui se comporte comme le programme initial pour les valeurs particulieres. Ces programmes sont obtenus en propageant les valeurs constantes et en simplifiant le code. Cette technique aide le mainteneur a comprendre le comportement d'un programme dans un contexte particulier. Concernant son apport scientifique, la technique employee n'est pas nouvelle, mais la maniere dont nous l'avons utilisee (pour l'aide a la comprehension), specifie (en semantique naturelle), prouvee (par induction) et implantee (dans l'environnement centaur) est a notre connaissance originale
43
Moha, Naouel. "DECOR : Détection et correction des défauts dans les systèmes orientés objet." Phd thesis, Université des Sciences et Technologie de Lille - Lille I, 2008. http://tel.archives-ouvertes.fr/tel-00321081.
Full textAbstract:
Les défauts de code et de conception sont des problèmes d'implémentation et de conception qui proviennent de ''mauvais'' choix conceptuels récurrents. Ces défauts ont pour conséquence de freiner le développement et la maintenance des systèmes en les rendant plus difficiles à maintenir et évoluer. Une détection et une correction semi-automatiques sont donc des facteurs clefs pour faciliter les phases de maintenance et d'évolution.Des techniques et outils ont été proposés dans la littérature à la fois pour la détection et la correction des défauts. Les techniques de détection proposées consistent principalement à définir des règles pour détecter les défauts et à les appliquer sur le code source d'un système. Quant aux techniques de correction, elles consistent à appliquer de façon automatique des refactorisations dans le code source du système analysé afin de le restructurer de manière à corriger les défauts. Cependant, la phase qui consiste à identifier les restructurations est réalisée manuellement par les
ingénieurs logiciels. Ainsi, il n'est pas possible de corriger
directement et automatiquement les défauts détectés. Ce problème est dû au fait que la détection et la correction des défauts sont traitées de façon isolée.
Ainsi, nous proposons DECOR, une méthode qui englobe et définit toutes les étapes nécessaires pour la détection et la correction des défauts de code et de conception. Cette méthode permet de spécifier des règles de détection à un haut niveau d'abstraction et de suggérer des restructurations de code afin d'automatiser la correction des défauts.
Nous appliquons et validons notre méthode sur des systèmes libres orientés objet afin de montrer que notre méthode permet une détection précise et une correction adaptée des défauts.
44
BRIAND, LIONEL. "L'analyse et la modelisation du risque durant le developpement et la maintenance du logiciel." Paris 11, 1994. http://www.theses.fr/1994PA112099.
Full textAbstract:
Cette these a pour objectif de definir une methodologie de modelisation du risque adaptee au developpement du logiciel et qui soit applicable dans un cadre industriel. L'approche est basee sur la notion selon laquelle, comme toute science, le genie logiciel a des aspects empiriques et experimentaux et que, par consequent, les produits et processus du developpement logiciel doivent etre mesures et modelises. La section 1 de la these definit plus en detail les objectifs, notre cadre de travail, et la strategie globale dans laquelle cette these se situe. Par la suite, les solutions disponibles pour la modelisation du risque sont identifiees et evaluees (section 2). Une nouvelle methode (optimized set reduction) qui est basee sur des principes d'apprentissage et des tests statistiques d'inference, est presentee (section 3). Ses objectifs principaux sont d'ameliorer l'interpretabilite et la precision des modeles generes et de permettre une automatisation optimale de la construction et l'utilisation des modeles. L'application de cette methode dans le cadre de l'evaluation de la qualite des produits logiciels et de l'aide a la decision est abordee. Cette methode est ensuite validee experimentalement au travers de deux exemples provenant du developpement de trois systemes de simulation et de controle au sol pour satellites (section 4). Des metriques, dont certaines peuvent etre mesurees a la fin de la phase de conception et d'autres a la fin de la phase de codage, sont definies. Elles sont ensuite utilisees dans la construction de modeles d'identification de composants a risque. Trois strategies differentes sont utilisees et l'une d'entre elles est optimized set reduction (osr). Les modeles sont alors compares et l'utilite de l'approche presentee est alors demontree experimentalement: des modeles plus precis et interpretables sont generes par osr
45
Cippelletti, Emma. "Aide à la conception, test de l’usage et de l’acceptation d’un logiciel de maintenance." Thesis, Université Grenoble Alpes (ComUE), 2017. http://www.theses.fr/2017GREAH038/document.
Full textAbstract:
Avec le développement des nouvelles technologies de l’information et de la communication, les procédures de travail sont de plus en plus informatisées. Cette informatisation croissante des procédures pose la question de leur acceptation par les travailleurs qui doivent s’approprier de nouvelles manières de faire leur travail. La présente thèse vise à examiner les conditions de l’adoption de technologies véhiculant des procédures de travail par des techniciens de maintenance. Quatre études sont réalisées sur deux terrains de recherche (maintenance aéronautique et maintenance industrielle) avec comme objectif de comprendre comment des techniciens de maintenance perçoivent et utilisent ces procédures de travail informatisées. Deux études sont réalisées dans le domaine aéronautique et visent à investiguer l’acceptabilité sociale ainsi que l’usage de trois nouveaux formats de procédures (animation 3D, 2D et photos) avant leur mise en place au sein des ateliers. L’étude 1 porte sur la perception des nouveaux formats de procédures par des techniciens (N=136). Les résultats de cette étude montrent que les croyances liées à l’utilité et à la facilité d’utilisation sont les principaux prédicteurs de l’intention comportementale. De plus, il semble que les croyances diffèrent en fonction du type de comportement d’utilisation des procédures (utilisation quotidienne ou exceptionnelle). Afin de comprendre les difficultés possibles lors de l’utilisation de ces nouveaux formats, l’étude 2 porte sur la réalisation de tests utilisateurs (N=41). L’objectif est d’étudier l’utilité et l’utilisabilité des nouveaux formats de procédures en comparaison avec le format actuel (texte + image). Les résultats montrent que tous les techniciens réussissent la maintenance, peu importe le format utilisé. De plus, d’une manière générale, les nouveaux formats permettent aux techniciens d’être plus efficients car ils mettent moins de temps avec les nouveaux formats (animation 3D et photos) qu’avec les formats de référence et les erreurs commises au cours de la maintenance sont réduites. Les nouveaux formats, avec la présence d’informations visuelles, facilitent la localisation des informations sur le matériel. Enfin, une grande majorité des techniciens a l’intention d’utiliser les nouveaux formats. Deux autres études sont réalisées dans le domaine de la maintenance industrielle sur l’acceptation et l’usage d’un logiciel de gestion de procédures par les techniciens. Dans ce cadre, l’étude 3 porte sur la perception d’un logiciel en cours d’utilisation par des techniciens de maintenance (N=61). Les résultats font ressortir la croyance liée à la compatibilité perçue comme principal prédicteur de l’attitude, de l’intention comportementale et de l’utilisation effective du logiciel. Afin d’investiguer l’usage réel du logiciel, l’étude 4 porte sur l’analyse de l’activité de 8 techniciens issus de quatre ateliers (observation filmée et entretien). Les résultats montrent que le logiciel est adapté pour une partie seulement des techniciens. En effet, il semble représenter un frein pour les techniciens expérimentés et moyennement expérimentés dans le sens ils sont contraints dans l’utilisation du logiciel (impossibilité de naviguer librement entre les étapes). Cependant, le logiciel se révèle être une aide précieuse pour les techniciens inexpérimentés (support d’aide, aide à la formation…). Des recommandations sont émises en vue d’améliorer la conception des logiciels étudiés. Notamment des améliorations dans la conception des trois nouveaux formats de procédures de maintenance aéronautique sont suggérées (adapter le format à la tâche réalisée, améliorer l’ergonomie de la tablette tactile…). Dans le deuxième cas, nous formulons des recommandations afin de modifier le logiciel de gestion de procédures et de le rendre plus compatible avec le travail des techniciens (mise en place d’un mode expert, faciliter la recherche d’information, naviguer librement entre les étapes…)With the development of new information and communication technologies, working procedures are increasingly computerized. This increasing computerization of working procedures raises the question of their acceptance by workers who have to appropriate new ways of doing their work. The present thesis aims to examine the conditions for the adoption of technologies conveying work procedures by maintenance technicians. Four studies are carried out on two fields of research (aeronautical maintenance and industrial maintenance) with the aim of understanding how maintenance technicians perceive and use these computerized working procedures. Two studies are carried out in the field of aeronautics and aim to investigate the social acceptability and the use of three new formats of procedures (3D animation, 2D and photos) before they are set up in the workshops. Study 1 examines the perception of new procedure formats by technicians (N = 136). The results of this study show that beliefs related to usefulness and ease of use are the main predictors of behavioral intention. In addition, it appears that beliefs differ depending on the type of use behavior of the procedures (daily or exceptional use). In order to understand the possible difficulties in using these new formats, Study 2 concerns the realization of user tests (N = 41). The aim is to study the usefulness and usability of the new procedural formats compared to the current format (text + image). The results show that all technicians succeed in maintenance, regardless of the format used. In addition, in general, new formats allow technicians to be more efficient because they take less time with new formats (3D animation and photos) than with reference formats and so errors made during maintenance are reduced. The new formats, with the presence of visual information, facilitate the location of the information on the equipment. Finally, a large majority of technicians intend to use the new formats. Two other studies are carried out in the field of industrial maintenance on the acceptance and use of a management of procedures software by the technicians. In this framework, study 3 concerns the perception of software in use by maintenance technicians (N = 61). The results highlight the belief in perceived compatibility as the main predictor of attitude, behavioral intention, and actual use of the software. In order to investigate the actual use of the software, study 4 deals with the analysis of the activity of 8 technicians from four workshops (filmed observation and interview). The results show that the software is suitable for only some of the technicians. Indeed, it seems to represent a brake for experienced technicians and moderately experienced technicians in the sense they are constrained in the use of the software (impossibility to navigate freely between the steps). However, the software proves to be a valuable help for inexperienced technicians (help support, training aid ...). Recommendations are made to improve the design of the software studied. In particular, improvements in the design of the three new formats of aeronautical maintenance procedures are suggested (adapting the format to the task carried out, improving the ergonomics of the touch pad...). In the second case, we make recommendations to modify the procedure management software and make it more compatible with the work of the technicians (setting up an expert mode, facilitating the search for information, navigating freely between steps …)
46
Cailliau, Damien. "Maintenance du logiciel de vol de véhicules spatiaux scientifiques par le biais de la reconfiguration dynamique." Paris 6, 2001. http://www.theses.fr/2001PA066538.
Full text
47
Hérin-Aimé, Danièle. "DEMSI, une méthode, un modèle et un logiciel pour l'évolution et la maintenance des systèmes d'information." Grenoble 2 : ANRT, 1986. http://catalogue.bnf.fr/ark:/12148/cb375983553.
Full text
48
Meskens, Nadine. "Contribution à la conception d'un système d'analyse de la qualité de programmes informatiques." Valenciennes, 1991. https://ged.uphf.fr/nuxeo/site/esupversions/6e227419-3072-403c-a486-15046e429a36.
Full textAbstract:
Dans la plupart des entreprises, les programmes informatiques sont devenus de plus en plus volumineux et complexes. Ces développements posent le problème de la charge de maintenance. Afin de minimiser ce coût, il faut donner aux programmes les qualités garantissant leur bonne évolutivité : portabilité, maintenabilité, fiabilité, efficacité, flexibilité. . . Cette minimisation des couts de maintenance doit être précédée d'un diagnostic permettant de mesurer l'effort à faire pour y parvenir et de connaitre par programme les actions à entreprendre. Afin d'avoir une vue quantitative de la qualité des programmes développés, de nombreux outils ont été et continuent à être mis au point. Notre recherche participe à ces développements. Plus spécifiquement, nous montrons les limites des métriques et proposons une approche système expert qui permet de couvrir à la fois les aspects syntaxiques et sémantiques d'un programme. Outre l'évaluation de la qualité, le système contribue à l'amélioration de celle-ci en mettant en valeur les critères et sous-critères de qualité les plus pénalisants pour le programme considéré. Grace à ces directives, des personnes compétentes pourront entreprendre la rénovation des programmes à l'aide d'outils appropriés. Ceci permettra de rendre ces programmes à nouveau aptes à évoluer et de réduire considérablement leur charge de maintenance ultérieure et donc de libérer les ressources humaines nécessaires au développement de nouvelles applications. Conjointement, un important travail de collecte des métriques ainsi que l'élaboration d'une liste de règles de qualité ont été réalisésThis cost minimization must be preceeded by a diagnostic that allows to measure the effort required by a good quality and recommends actions to undertake. Many tools have been developed to obtain a quantitative view on software quality. However, much work remains to be done. Our research belongs to that stream of research. We show the limits of metrics and propose an expert system approach that allows to cover both syntactic and semantic aspects of software. Besides the software quality evaluation, the system helps to improve this quality by emphasizing the most penalizing quality criteria for the program under review. Given this information, programs could be graded and their maintenance cost reduced so that human ressources could develop new applications. In addition, an important work of collection of metrics and elaboration of quality checklists has been done
49
Sanlaville, Rémy. "Architecture logicielle : une expérimentation industrielle avec Dassault Systèmes." Phd thesis, Université Joseph Fourier (Grenoble), 2002. http://tel.archives-ouvertes.fr/tel-00004589.
Full textAbstract:
L'architecture logicielle est un domaine récent du génie logiciel qui a reçu une attention particulière ces dix dernières années. Les éditeurs de logiciels ont pris conscience qu'une architecture est un facteur critique dans la réussite du développement et facilite la maintenance et l'évolution du logiciel. Elle contribue à la maîtrise des grands logiciels. L'architecture logicielle permet d'améliorer ces aspects grâce à l'étude des structures de haut niveau du logiciel. De nombreuses avancées ont été proposées au niveau de la formalisation par des Langages de Description d'Architecture (ADLs: Architecture Description Languages), du raisonnement et de l'analyse au niveau architectural. Bien que la communauté scientifique ait réalisé des progrès significatifs, les résultats restent essentiellement académiques. Les retombées de ces recherches ont du mal à pénétrer le milieu industriel. Ce rapport de thèse relate notre expérience avec Dassault Systèmes : répondre aux besoins de Dassault Systèmes pour le développement de ses logiciels en utilisant une approche basée sur l'architecture logicielle. Dassault Systèmes est le leader mondial de la Conception Assistée par Ordinateur (CAO) avec son logiciel phare CATIA V5 (~5 MLoc). Pour atteindre cet objectif, nous avons parcouru les principales approches pour la description d'une architecture logicielle et tenté de les appliquer dans notre contexte industriel. Nous expliquerons les difficultés que nous avons rencontrées pour les utiliser et montrerons pourquoi ces approches ne sont pas adaptées pour la maintenance et l'évolution d'un logiciel tel que CATIA V5. Nous décrirons notre démarche basée sur l'analyse des besoins architecturaux des différents acteurs de Dassault Systèmes qui a permis de fournir des solutions concrètes et exploitables. Enfin, nous expliciterons ces besoins architecturaux et présenterons les divers prototypes que nous avons développés pour y répondre.
50
Zenati, Henda Nadia. "Contribution à la conception et à la réalisation d'un système de réalité augmentée pour la maintenance." Phd thesis, Université de Franche-Comté, 2008. http://tel.archives-ouvertes.fr/tel-00292097.
Full textAbstract:
Nos travaux présentés dans cette thèse s'inscrivent dans le cadre de l'Interaction Homme-Machine (IHM) et contribuent à la conception et à la réalisation d'un système de réalité augmentée (RA) dans le cadre précis de la maintenance. Dans cet axe de recherche de l'IHM, les avancées sont importants et se manifestent par de nombreux systèmes présents dans des domaines aussi diverses que la médecine, la maintenance, la robotique... Dans ce contexte, nous avons proposé une démarche de conception ergonomique pour les systèmes de RA. Dans cet axe, nous avons présenté les propriétés ergonomiques. Afin de caractériser plus finement la dualité de l'interaction (Utilisateur- Monde Réel et Utilisateur-Monde Virtuel), nous avons défini la notation UML. Poursuivant le cycle de vie d'un système interactif issu du génie logiciel, nous avons abordé l'étape de la conception logicielle du système de RA. Nous avons défini une solution générique de réalisation logicielle selon le modèle d'architecture logicielle PAC-Amodeus. Ce modèle adapté souligne la dualité de l'interaction avec deux branches indépendantes dédiées à l'interaction avec le monde réel et le monde informatique. En collaboration avec le technicien, nous avons appliqué et testé nos résultats méthodologiques sur une application en maintenance. Cette application, ARIMA, permet de guider les techniciens en leur procurant des informations sous forme d'augmentations multimédia afin d'accroître leur efficacité dans des activités de maintenance.