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. / Maintenance consumes a large part of the cost of software development which makes the optimization of that cost among the important issues in the world of software engineering. In this thesis we aim to optimize this cost by making these maintenances modular. To achieve this goal, we define transformations of program architectures that allow to transform a program to maintain into an architecture that facilitates the maintenance tasks required. We focus on transformation between architectures having dual modularity properties such as Composite and Visitor designpatterns. In this context, we define an automatic and reversible transformation based on refactoring between a program structured according to the Composite structure and its corresponding Visitor structure. This transformation is validated by generating a precondition which guarantees statically its success. It is also adapted to take into account the transformation of four variations of Composite pattern and it is then applied to JHotDraw program in which these four variations occur. We define also a reversible transformation in the Singleton pattern to benefit from optimization by introducing this pattern and flexibility by its suppression according to the requirements of the software user.

There is a high demand for program developers, but the dropouts from computer science courses are also high and course enrolments keep decreasing. In order to overcome that situation, several studies have found serious games as good tools for education in programming learning. As an outcome from such research, several game solutions for programming learning have appeared, each of them using a different approach. Some of these games are only used in the research field where others are published in commercial stores. The problem with commercial games is that they do not offer a clear map of the different programming concepts. This dissertation addresses this problem and analyses which fundamental programming concepts that are represented in commercial games for programming learning. The study also identifies game design patterns used to represent these concepts. The result of this study shows topics that are represented more commonly in commercial games and what game design patterns are used for that. This thesis identifies a set of game design patterns in the 20 commercial games that were analysed. A description as well as some examples of the games where it is found is included for each of these patterns. As a conclusion, this research shows that from the list of the determined fundamental programming topics only a few of them are greatly represented in commercial games where the others have nearly no representation. This shows potential spots for future research in games for programming teaching.

傳統上，決策支援系統皆為單機作業，隨著資訊科技與網路的興起，決策支援系統也開始利用Web-based的機制達成決策資訊即時共享的目的，突破以往的地域與時間限制，但也增加了系統整體架構的複雜度，提高了這類系統在開發與維護時的困難度。過去十年中，物件導向（Object-Oriented）的軟體工程開發方式成為相當熱門的話題，主因在於可以有效地提高軟體可再使用性並降低了軟體結構的複雜度，設計樣版（Design Patterns）即屬於物件導向技術中的一項，其被認為定位於整合軟體系統的標準程序與專家經驗概念成為一些物件設計的指引或參考原則，以更有彈性的結構來描述某些特定的功能與行為，以及系統構成物件間相互關係，可以用來有效提昇軟體再使用與維護的應用層面。簡單來說，設計樣版即為程式設計師在解決特定問題上經驗的累積，也可以視為是另一種軟體物件再利用的方法。所以本研究的主要目的為建立一個以設計樣版為基礎之主從架構式的網頁式（Web-based）決策支援架構，並提出一相對應之發展流程與設計樣版的找尋原則，以期望透過此一可再用之發展架構，減輕開發者的負擔並增加開發時的效率，並增強所開發的系統的彈性，使系統能擁有更高的可維護性與可再用性。最後並以資金轉撥計價的應用做為例子說明，以說明此架構之應用方式。

<p>Att designa en generell och utbyggbar mjukvara är inte enkelt, då det krävs en bred kompetens inom många olika områden. Vi belyser i detta arbete en del av problematiken kring design. Utgångspunkten är ett praktikfall vars målmiljö rör processer och integrationer. Huvudfokus ligger på designmönster, men även en bredare genomgång av ämnen så som utvecklingsmetodik, Service Oriented Architecture (SOA), Web Services (WS) och utvecklingsmiljöer presenteras. Arbetet bedrivs i enlighet med riktlinjer från Rational Unified Process (RUP) och slutprodukten är en checklista på tre punkter. De tre punkterna speglar de lärdomar vi dragit av arbetet genom saker vi gjort och saker vi borde ha gjort. God design kan uppnås genom att förstå den uppgift man åtagit sig, utvärdera sitt resultat och delresultat samt genom användandet av rätt verktyg. Framtida forskningsområden med anknytning till vårt rör förslagsvis metoders betydelse för mjukvarudesign, dynamiska perspektiv hos utvecklare och mer enhetlighet kring begreppet SOA.</p>

After the book, Design Patterns: Elements of Reusable Object-Oriented Software was published in 1994, usage of design patterns in object-oriented (OO) programming has been investigated by many researchers. However, the effects of design patterns on non-object oriented (non-OO) programming have not been analyzed too much in the literature. This study focuses on various design pattern implementations using non OO programming and investigates the benefits of design patterns upon real-time software. In order to evaluate the results, specific quality metrics were selected and performance of traditionally developed software was compared with that of software developed using design patterns.

<em>Virtual Frameworks</em> for source migration is a methodology to extract classes and interfaces from one or more frameworks used by an application. After migration, a new set of frameworks called virtual frameworks can replace the original frameworks used. The classes and interfaces extracted are used to create a proxy layer for these new frameworks. The application then depends on this proxy layer, and through it the new frameworks, rather than on the original frameworks. A combination of three patterns: Bridge, Adapter, and Proxy are used in these new frameworks. By doing so the changes made to the application source code are minimized during migration.

<em>Virtual Frameworks</em> for source migration is a methodology to extract classes and interfaces from one or more frameworks used by an application. After migration, a new set of frameworks called virtual frameworks can replace the original frameworks used. The classes and interfaces extracted are used to create a proxy layer for these new frameworks. The application then depends on this proxy layer, and through it the new frameworks, rather than on the original frameworks. A combination of three patterns: Bridge, Adapter, and Proxy are used in these new frameworks. By doing so the changes made to the application source code are minimized during migration.

The interrelations of a set of software objects are usually manifold and complex. Common object-oriented programming languages provide constructs for structuring objects according to shared properties and behavior, but fail to provide abstraction mechanisms for the interactions of objects. Roles seem to be a promising approach to solve this problem as they focus on the behavior of an object in a certain context. Combining multiple roles yields collaborations, an interesting abstraction and reuse unit. However, existing approaches towards roles in programming languages require vast extensions of the underlying language or even propose new languages. We propose a programming technique that enables role-based programming with commonly available language constructs. Thus, programmers can express roles and collaborations by simply using a library, and hence, without the need to change the language, its compiler, and its tools. We explain our proposal on a language-independent level. Moreover, we provide an implementation in form of a library for the Scala programming language. Finally, we apply our ideas to design patterns and analyze to which extent these can be expressed and reused with roles. / Die Zusammenhänge zwischen Softwareobjekten sind vielfältig und komplex. In den meisten objektorientierten Programmiersprachen werden Objekte an Hand von gemeinsamen Eigenschaften und Verhalten klassifiziert. Konstrukte zum Strukturieren bezüglich ihrer Interaktionen fehlen jedoch. Ein vielversprechender Lösungsansatz sind Rollen, welche das Verhalten von Objekten in einem bestimmten Kontext beschreiben. Zusammenhängende Rollen können zu Kollaborationen abstrahiert werden. Diese sind insbesondere als wiederverwendbare Bausteine interessant. Allerdings verändern bisherige Ansätze zu rollenbasiertem Programmieren die zu Grunde liegende Sprache erheblich oder schlagen gar neue Sprachen vor. Im Gegensatz dazu zeigen wir eine Programmiermethode, die rollenbasiertes Programmieren mit üblichen Sprachkonstrukten ermöglicht. Somit können Rollen und Kollaborationen als Bibliothek bereitgestellt werden, also ohne Sprache, Compiler und Werkzeuge anpassen zu müssen. Wir erläutern unseren Ansatz zunächst sprachunabhängig. Desweiteren wird eine Implementierung als Bibliothek für die Scala Programmiersprache präsentiert. Als praktische Anwendung stellen wir Entwurfsmustern dar und überprüfen, inwiefern sich diese mit Rollen ausdrücken und wiederverwenden lassen.

This thesis describes a methodology presented in a pattern language for design of questionnaire / survey information systems. It is intended to be used by professional programmers with negligible experience in the domain of questionnaire / survey software. A system of individual and discrete design patterns of various types is interconnected by varying relations enabling the user to navigate effortlessly and to implement a customizable level of expertise contained within the language. The design patterns contain expert knowledge about construction and contents of a universal high-end questionnaire / survey information system. Data structures, graphical user interface and psychological ramifications of questions’ formulations are discussed in detail. The descriptions of two different prototypes of information systems are supplied. They were created using the expertise of the pattern language and serve as a proof of eligibility for it. The innovation in the thesis is driven by the absence of pattern language for questionnaire design, usage of various types of design patterns / relations in the created language and the very design of universal metadata-based questionnaire information system described in the created language.

Mémoire numérisé par la Division de la gestion de documents et des archives de l'Université de Montréal