La tendance actuelle vers l’encapsulation d’un assemblage comportant plusieurs puces favorise l’incorporation d’un procédé de réusinage compatible avec l’enlèvement et le remplacement d’une puce défectueuse. La vérification électrique est un procédé inhérent au réusinage qui identifie facilement les puces défectueuses sans en compromettre leur intégrité. Malheureusement, l’aspect qui optimise l’intégrité mécanique et électrique des dispositifs, soit l’encapsulant (underfill), rend les étapes subséquentes d’enlèvement des puces extrêmement difficile. Il devient alors souhaitable d’évaluer le comportement de certaines puces sans underfill qui sont sujettes aux conditions de vérifications électriques souhaitées afin de déterminer s’il existe une zone de test favorable à la qualité et la fiabilité du produit. Ceci est d’autant plus vrai en considérant le peu de données publiées concernant un chargement en compression qu’une puce sans underfill et sans capot peut supporter. Ce projet de recherche présente une étude du comportement des puces renversées sans capot, utilisant un alliage SAC, qui est sans plomb, pour les interconnexions, face à une charge compressive appliquée directement. Les puces sont assemblées sur un substrat organique sans underfill dans une configuration à plusieurs puces. Pour différentes tailles de puces, une série de compressions ont été observées afin de couvrir une vaste étendue de forces potentiellement utilisées pour assurer le contact électrique du laminé non planaire. Les chargements ont été faits à température ambiante et élevée ainsi qu’à angle normal et incliné. La caractérisation par l’analyse des courbes de chargement, la coplanarité, la mesure des hauteurs des interconnections et la tomographie par rayon X a démontré qu’un angle normal ne provoquait qu’une légère déformation qui était relativement indépendante de la température ou de la force dans l’étendu testé. Bien que les données de fluage semblent entrer dans le cadre des modèles précédemment publiés et un nouveau modèle plus juste a été créé avec l’aide de test de nanoindentation. L’inclinaison du chargement a démontré produire des déformations significatives qui, durant un test électrique typique de 20 minutes, étaient similaire pour un faible ou un grand chargement. Par contre, ces déformations avaient tendance à être plus importantes pour une température élevée et pour une petite taille de puce. De telles déformations ont démontrés induire une recristallisation des grains en une taille plus fine sans retrouver leur forme après un recuit. De plus, les déformations sévères ont démontrées une présence de fissurations à température ambiante et d’espace réduit à température élevée pouvant nuire à l’intégrité de l’assemblage. Un cyclage thermique de 1000 cycles n’a pas induit de défaillance électrique pour le nombre d’échantillons testés, mais des tests avec un plus grand échantillonnage sont recommandés. En somme, cette étude conclue qu’une vérification électrique dans des conditions normales d’une puce sans capot ne va pas endommager l’intégrité des interconnections sans plomb. Toutefois, un contrôle des procédés robustes est nécessaire afin d’éviter des conditions anormales résultant en une inclinaison de la charge qui pourrait compromettre l’intégrité des assemblages.

Mettre à jour des applications durant leur exécution est utilisé aussi bien en production pour réduire les temps d’arrêt des applications que dans des environnements de développement interactifs (IDE pour live programming). Toutefois, ces deux scénarios présentent des défis différents qui font que les solutions de mise à jour dynamique (DSU pour Dynamic Software Updating) existantes sont souvent spécifiques à l’un des deux. Par exemple, les DSUs pour la programmation interactives ne supportent généralement pas la détection automatique de points sûrs de mise à jour ni la migration d’instances, alors que les DSUs pour la production nécessitent une génération manuelle de l’ensemble des modifications et manquent d’intégration avec l’IDE. Les solutions existantes ont également une capacité limitées à se mettre à jour elles-mêmes ou à mettre à jour les bibliothèques de base du langage ; et certaines d’entre elles introduisent mêmle une dégradation des performances d’exécution en dehors du processus de mise à jour.Dans cette thèse, nous proposons un DSU (nommé gDSU) unifié qui fonctionne à la fois pour la programmation interactive et les environnements de production. gDSU permet la détection automatique des points sûrs de mise à jour en analysant et manipulant la pile d’exécution, et offre un mécanisme réutilisable de migration d’instances afin de minimiser les interventions manuelles lors de l’application d’une migration. gDSU supporte également la mise à jour des bibliothèques du noyau du langage et du mécanisme de mise à jour lui-même. Ceci est réalisé par une copie incrémentale des objets à modifier et une application atomique de ces modifications.gDSU n’affecte pas les performances globales de l’application et ne présente qu’une pénalité d’exécution lors processus de mise à jour. Par exemple, gDSU est capable d’appliquer une mise à jour sur 100 000 instances en 1 seconde. Durant cette seconde, l’application ne répond pas pendant 250 milli-secondes seulement. Le reste du temps, l’application s’exécute normalement pendant que gDSU recherche un point sûr de mise à jour qui consiste alors uniquement à copier les éléments modifiés.Nous présentons également deux extensions de gDSU permettant un meilleur support du développement interactif dans les IDEs : la programmation interactive transactionnelle et l’application atomique de reusinages (refactorings). / Updating applications during their execution is used both in production to minimize application downtine and in integrated development environments to provide live programming support. Nevertheless, these two scenarios present different challenges making Dynamic Software Update (DSU) solutions to be specifically designed for only one of these use cases. For example, DSUs for live programming typically do not implement safe point detection or insistance migration, while production DSUs require manual generation of patches and lack IDE integration. These sollutions also have a limited ability to update themselves or the language core libraries and some of them present execution penalties outside the update window.In this PhD, we propose a unified DSU named gDSU for both live programming and production environments. gDSU provides safe update point detection using call stack manipulation and a reusable instance migration mechanism to minimize manual intervention in patch generation. It also supports updating the core language libraries as well as the update mechanism itself thanks to its incremental copy of the modified objects and its atomic commit operation.gDSU does not affect the global performance of the application and it presents only a run-time penalty during the window. For example, gDSU is able to apply an update impacting 100,000 instances in 1 second making the application not responsive for only 250 milliseconds. The rest of the time the applications runs normally while gDSU is looking for a safe update point during which modified elements will be copied.We also present extensions of gDSU to support transactional live programming and atomic automactic refactorings which increase the usability of live programming environments.

Le contrôle de version est la pierre angulaire des processus de développement de logiciels modernes. Tout en construisant des logiciels de plus en plus complexes, les développeurs doivent comprendre des sous-systèmes de code source qui leur sont peu familier. Alors que la compréhension de la logique d'un code étranger est relativement simple, la compréhension de sa conception et de sa genèse est plus compliquée. Elle n'est souvent possible que par les descriptions des révisions et de la documentation du projet qui sont dispersées et peu fiables -- quand elles existent. Ainsi, les développeurs ont besoin d'une base de référence fiable et pertinente pour comprendre l'historique des projets logiciels. Dans cette thèse, nous faisons les premiers pas vers la compréhension des motifs de changement dans les historiques de révision. Nous étudions les changements prenant place dans les métriques logicielles durant l'évolution d'un projet. Au travers de multiples études exploratoires, nous réalisons des expériences quantitatives et qualitatives sur plusieurs jeux de données extraits à partir d'un ensemble de 13 projets. Nous extrayons les changements dans les métriques logicielles de chaque commit et construisons un jeu de donnée annoté manuellement comme vérité de base. Nous avons identifié plusieurs catégories en analysant ces changements. Un motif en particulier nommé "compromis", dans lequel certaines métriques peuvent s'améliorer au détriment d'autres, s'est avéré être un indicateur prometteur de changements liés à la conception -- dans certains cas, il laisse également entrevoir une intention de conception consciente de la part des auteurs des changements. Pour démontrer les observations de nos études exploratoires, nous construisons un modèle général pour identifier l'application d'un ensemble bien connu de principes de conception dans de nouveaux projets. Nos résultats suggèrent que les fluctuations de métriques ont le potentiel d'être des indicateurs pertinents pour gagner des aperçus macroscopiques sur l'évolution de la conception dans l'historique de développement d'un projet. / Version control is the backbone of the modern software development workflow. While building more and more complex systems, developers have to understand unfamiliar subsystems of source code. Understanding the logic of unfamiliar code is relatively straightforward. However, understanding its design and its genesis is often only possible through scattered and unreliable commit messages and project documentation -- when they exist. Thus, developers need a reliable and relevant baseline to understand the history of software projects. In this thesis, we take the first steps towards understanding change patterns in commit histories. We study the changes in software metrics through the evolution of projects. Through multiple exploratory studies, we conduct quantitative and qualitative experiments on several datasets extracted from a pool of 13 projects. We mine the changes in software metrics for each commit of the respective projects and manually build oracles to represent ground truth. We identified several categories by analyzing these changes. One pattern, in particular, dubbed "tradeoffs", where some metrics may improve at the expense of others, proved to be a promising indicator of design-related changes -- in some cases, also hinting at a conscious design intent from the authors of the changes. Demonstrating the findings of our exploratory studies, we build a general model to identify the application of a well-known set of design principles in new projects. Our overall results suggest that metric fluctuations have the potential to be relevant indicators for valuable macroscopic insights about the design evolution in a project's development history.