Cette thèse étudie, à partir d’un corpus d’environ 950 images, l’iconographie du Procès du Christ dans la culture italienne de la fin du Moyen Âge. Elle est le fruit d’une double ambition : celle de retracer l’évolution iconographique des scènes (Comparutions devant les juges, Outrages, Couronnement d’épines, Flagellation) et du cycle dans son ensemble, et ce, dès les premiers siècles de l’art chrétien, mais au-delà, celle de replacer ces images d’injustice dans le champ spirituel, culturel, judiciaire et politique d’une société profondément imprégné d’une pluralité de discours sur la justice. La première partie remonte aux sources, textuelles et visuelles, afin de mieux comprendre l’élaboration progressive du cycle visuel et de mieux cerner l’inventivité des solutions italiennes à partir de la seconde moitié du XIIIe siècle. La deuxième partie est une exploration d’un corpus de 950 images. L’analyse des évolutions iconographiques scène après scène est enrichie par une analyse sémantique. Il s’agit en effet de montrer comment sont figurés à la fois une justice dysfonctionnelle et le paradoxe du Christus iudicatus, en regard notamment des images contemporaines de la justice. La dernière partie est une réflexion sur les diverses modalités de mise en acte de ces images, selon les supports et les contextes, dévotionnels, judiciaires, mais également politique. Cet éclairage multiple confère à ce thème iconographique une profondeur et une résonance particulière. Dans une société pénétrée par le thème de la justice, à la fois institution en quête d’elle-même, vertu chrétienne et puissance divine, il fait office d’un repoussoir rhétorique efficace, tout en étant chargé d’une forte ambivalence propre à la culture médiévale.Mots clés : apparatus visuel, Arena, Aula épiscopales de Bergame, Ben Comune, Caïphe, Pietro Cavallini, Christ, Comune rubato, conforto, Couronnement d’épines, croix peinte, dévotion, Diligite iustitiam, discipline Duccio, fama, Flagellation, Florence, fresque, Giotto, Giustizia bendata, Hérode, imitatio Christi, infamia, injustice, Jugement dernier, juifs, justice, Lavement des mains, Pietro Lorenzetti, Maestà, Meditationes Vitae Christi, memento falliri, memoria, métalepse visuelle, Passion, Pilate, Présentation au peuple, procès, retable, Rhetorica ad Herennium, rituels, rituels judiciaires, Sienne, spiritualité mendiante, tavoletta, vertu, vice / This dissertation examines, from a corpus of about 950 images, the various scenes of the Trial of Christ in the late medieval Italian culture. It claims two aims. Firstly, it draws the iconographic evolution of each scene (Christ before his judges, Mocking, Crowning of Thorns, Flagellation) and of the entire sequence, from the first centuries of Christian art ; secondly, it inserts theses images of injustice in the spiritual, cultural, judicial and political context of a society which is profoundly pervaded by the theme of justice. The first section deals with the textual and visual sources in order to examine the elaboration of the sequence and the inventiveness of the Italian solutions since the second half of the XIIIth century. The second section is a survey of the corpus, lead by a geographico-historical analysis of the production of these images. This aspect is extended by a semantic approach of these scenes picturing the injustice and the infamia endured by the Son of God, notably through the light of the increasing corpus of images of institutional justice. The last section examines the question of the efficacity of these images in various contexts (devotion, judicial rituals, civic rhetoric, politics). Thanks to that diversity of approaches, the theme of the Trial of Jesus reveals profound resonances in the web of Italian societies, where justice is an institution in search of its own identity, a Christian virtue and the privilege of God at End Time. Its acts notably as a powerful but ambivalent rhetorical counterexample.Key words : agency of image, altarpiece, visual apparatus, Arena, episcopal aula of Bergamo, Ben Comune, Blind Justice, Caiaphas, Pietro Cavallini, Christ, Comune rubato, conforto, Crowning of Thorns, devotion, Diligite iustisiam, discipline, Duccio, Ecce Homo, efficace des images, fama, Flagellation, Florence, frescoes, Giotto, Herode, imitatio Christi, infamia, injustice, Jews, Last Judgment, justice, Pietro Lorenzetti, Maestà, Meditationes Vitae Christi, memento falliri, memoria, visual metalepsis, painted cross, Passion, Pilate, Pilate washing his hands, Rhetorica ad Herennium, rituals, judicial rituals, Siena, mendicant spirituality, tavoletta, trial, vice, virtue.

Capsules are modeling language elements which are sometimes used to develop real-time software. One way to test such capsule elements without relying on dependencies to other units is to use mock objects. The aim of the study was to look at existing object-oriented design patterns and investigate how they could be used for capsules, in order to perform mock testing. The focus was to find solutions that were usable from the programmers’ point of view, meaning that they should promote high user effectiveness, efficiency and satisfaction when implementing them. It was also important that program efficiency wasn’t affected negatively. 5 design- or refactoring patterns were adapted for capsules: Constructor Injection, Setter Injection, Parameterize Method, Factory Method and Abstract Factory. Those patterns were evaluated by 5 programmers in a usability test, where Incarnate Injection (an adaptation of Constructor Injection) and Abstract Factory were considered most usable. Incarnate Injection seemed to be easier to implement and promoted high user efficiency, while Abstract Factory was considered more flexible. The performance tests indicated that Abstract Factory compromises program efficiency when the factory product is resource-heavy and is required frequently by dependent capsules. The study showed that it is possible to adapt design patterns to capsules by looking at conceptual similarities between capsules and classes. However, there are cases when this adaptation is impossible. Furthermore, even when adaptation is possible, it was apparent that different patterns adapt differently well to capsules.

Software companies often choose to develop in C++ because of the high performance that the language offers. Facilitated by static compilation and powerful optimization options, runtime performance is paid for with compilation time. Although the trade-off is inevitable to some extent, building very large C++ programs from scratch can take up to several hours if extra care is not taken during development. This thesis analyzes compilation times for C++ programs and shows how they can be reduced with the help of design patterns, implementation hiding, and framework related fixes. The results presented prove that compilation times can be decreased significantly with no drawbacks to the maintainability of a program. An in-depth analysis of compilation times and dependencies has been conducted for two large software modules from a representative company. Both modules take over an hour of CPU time each to compile. The time consumption for different compiler activities, such as parsing, preprocessing, and runtime optimization tasks have been measured for the modules. The compilation times for unit tests and mocks which use the GoogleTest framework have been analyzed. A simple method that may reduce compilation times by up to 50% for programs that use GoogleTest is presented. A dependency metric has been created, based on the number of include statements found recursively throughout a program. The dependency metric was found to be connected to compilation time for the two analyzed modules. Other factors that can influence compilation times are also shown, such as runtime optimization options, and the use of templates. Experiments which show how a typical usage of templates can drastically increase compilation times are presented. In addition, a solution which allows templates to be used while avoiding code bloat across translation units is reviewed. The solution effectively rivals non-template code in terms of compilation time. The Pointer to Implementation (PImpl) and Dependency Injection design patterns have been used to refactor a small program. Both design patterns performed well, reducing the total compilation time and total compiler memory usage by 70%. A program that detects dependency cycles has been created, but no cycles were found in any of two modules from the representative company.