Engineering is often described as the application of scientific and technical knowledge to solve problems. In this thesis, I support a more general view that engineering should be treated as a continuous process of learning and action that aims to make well understood improvements within dynamically complex environments of co-evolving social, man-made and natural systems. I argue that this can only be achieved by adopting an approach that systematically develops, manages and integrates the knowledge and expertise of many disciplines to conceive, develop, modify, operate and retire systems. A novel implementation of such an approach, called Aspect-Oriented Thinking, is presented. ¶ Aspect-Oriented Thinking begins with the development and verification of a set of domain Models. Each Domain Model represents knowledge about a separate, autonomous and possibly discipline specific concern or view within a given context. Domain models are developed by engineers, scientists, sociologists, psychologists, lawyers, philosophers, economists and others, using languages and techniques with which they are familiar. Knowledge captured in a set of Domain Models is then woven together, in accordance with a set of separately developed patterns and rules, to construct, modify, operate and retire systems, including models, hardware, software, processes and simulations. This is a continuous process which, in the first instance, involves those systems used to learn about a given context and to make decisions regarding required changes. Later, the process involves those systems used to implement and evaluate the impact of these decisions. ¶ The significance of Aspect-Oriented Thinking lies in its broad applicability to any situation in which the expertise and knowledge of diverse disciplines is required to understand and make improvements within complex multifaceted environments such as those that involve sustainable development and national security. ¶ A proof-of-concept within the context of software engineering is provided to demonstrate the mechanics and viability of Aspect-Oriented Thinking. The results of this demonstration are used to support an argument for future experimentation aimed at evaluating the effectiveness of Aspect-Oriented Thinking in a more general interdisciplinary environment.

The Graphical User Interface (GUI), as the most prevailing type of User Interface (UI) in today’s interactive applications, restricts the interaction with a computer to the visual modality and is therefore not suited for some users (e.g., with limited literacy or typing skills), in some circumstances (e.g., while moving around, with their hands or eyes busy) or when the environment is constrained (e.g., the keyboard and the mouse are not available). In order to go beyond the GUI constraints, the Multimodal (MM) UIs apear as paradigm that provide users with great expressive power, naturalness and flexibility. In this thesis we argue that developing MM UIs combining graphical and vocal modalities is an activity that could benefit from the application of a methodology which is composed of: a set of models, a method manipulating these models and the tools implementing the method. Therefore, we define a design space-based method that is supported by model-to-model colored transformations in order to obtain MM UIs of information systems. The design space is composed of explicitly defined design options that clarify the development process in a structured way in order to require less design effort. The feasability of the methodology is demonstrated through three case studies with different levels of complexity and coverage. In addition, an empirical study is conducted with end-users in order to measure the relative usability level provided by different design decisions.

Identical domain concepts reified in different (meta)modelling projects may be named, represented and connected differently. It turns out that a transformation defined for a particular metamodel cannot be directly used for another metamodel; that is, the reuse of transformations is restricted. To tackle this problem, in this dissertation, we propose a solution for automatically migrating legacy transformations. Such a transformation is adapted to the new metamodel that has a slightly different representation in comparison with the original one, while preserving the original semantics of the transformation. To this end, we first introduce MetaModMap, a Domain Specific Language that allows the description of the correspondences of intended semantics between the elements of two metamodels that model the same domain. Then we provide a rewriting mechanism using these user-defined correspondences to migrate the transformation automatically. The proposed solution uses a graph-based model typing relation that enables safe adaptations. Our approach has been prototyped with MOMENT2 and can be used with any framework based on the same graph transformation paradigm.

This thesis presents a semantic-based modeling approach for describing Service-Oriented Architectures (SOA). Ontologies are utilized as a major representation mechanism for describing various elements available in the architecture. The methodology proposes an architecture specification mechanism to constuct a unified ontology that enables transition from design concerns to the modeling elements. A multi-level modeling is also achieved by employing Model-Driven Engineering (MDE) techniques to describe various models at different stages of the software architecture. This aims to organize service-oriented models within a number of architecture viewpoints in order to provide an architectural perspective for SOA. The use of ontologies for model specification also allows us to make use of ontology mapping to specify the transformation between different models. Additionally, we present a case study to demonstrate the proposed methodology on a real-world healthcare scenario.

Current technologies such as anti-virus software programs and network firewalls provide reasonably secure protection at the host and network levels, but not at the application level. When network and host-level entry points are comparatively secure, public interfaces of web applications become the focus of malicious software attacks. In this thesis, we focus on one of most serious web application vulnerabilities, broken access control. Attackers often try to access unauthorized objects and resources other than URL pages in an indirect way; for instance, using indirect access to back-end resources such as databases. The consequences of these attacks can be very destructive, especially when the web application allows administrators to remotely manage users and contents over the web. In such cases, the attackers are not only able to view unauthorized content,but also to take over site administration. To protect against these types of attacks, we have designed and implemented a security analysis framework for dynamic web applications. A reverse engineering process is performed on an existing dynamic web application to extract a role-based access-control security model. A formal analysis is applied on the recovered model to check access-control security properties. This framework can be used to verify that a dynamic web application conforms to access control polices specified by a security engineer. Our framework provides a set of novel techniques for the analysis and modeling of web applications for the purpose of security verification and validation. It is largely language independent, and based on adaptable model recovery which can support a wide range of security analysis tasks. / Thesis (Ph.D, Computing) -- Queen's University, 2010-04-30 14:30:53.018

Transformations play a central role in Model Based Software Engineering. Similar to the development of other types of software, a transformation's specification and implementation does not necessarily remain static over the course of a project's lifetime; the transformation may develop incrementally and evolve. The goal of this thesis is to propose metrics that can be used to characterize the evolution of model transformations. To perform an initial demonstration of the metrics, this thesis considers an incrementally defined model transformation task. The transformation is implemented using two model transformation languages, a textual language and a graphical language, and metrics are extracted from the historical artifacts. The thesis defines a set of change metrics based on an abstract syntax difference model. Language feature metrics are also defined for both transformation languages. A process for extracting model-based change metrics and language metrics from the abstract syntax of the transformation languages is introduced. The applicability of the metrics in characterizing changes is demonstrated using exploratory clustering analysis on a transformation task. We show how, for this transformation task using both languages, metrics derived from the difference model result in clusters that reflect characteristics of individual changes, in contrast to clusters obtained with language metrics. / Thesis (Master, Computing) -- Queen's University, 2012-09-28 10:47:10.999

This document presents a synthesis of the research results conducted in the eld of software veri cation for model-driven engineering (MDE). MDE is becoming one of the dominant software engineering paradigms in the industry. The main characteristic of MDE is the use of software models and model manipulation operations as main artifacts in all software engineering activities. This change of perspective implies that correctness of models (and model manipulation operations) becomes a key factor in the quality of the nal software product. The problem of ensuring software correctness is still considered to be a Grand Challenge for the software engineering community. At the modellevel, we are still missing a set of tools and methods that helps in the detection of defects and smoothly integrates in existing MDE-based tool-chains without an excessive overhead. Characteristics of existing tools, which require designer interaction, deep knowledge of formal methods or extensive manual model annotations seriously impair its usability in practice. In this document, we present our pragmatic set of techniques for formal model veri cation to overcome these limitations. We call our techniques pragmatic because they try to nd the best trade-o between completeness of the veri cation and the usability of the process.

Today's business world is very dynamic and organizations have to quickly adjust their internal policies to follow the market changes. Such adjustments must be propagated to the business logic embedded in the organization's information systems, that are often legacy applications not designed to represent and operationalize the business logic independently from the technical aspects of the programming language employed. Consequently, the business logic buried in the system must be discovered and understood before being modified. Unfortunately, such activities slow down the modification of the system to new requirements settled in the organization policies and threaten the consistency and coherency of the organization business. In order to simplify these activities, we provide amodel-based approach to extract and represent the business logic, expressed as a set of business rules, from the behavioral and structural parts of information systems. We implement such approach for Java, COBOL and relational database management systems. The proposed approach is based on Model Driven Engineering,that provides a generic and modular solution adaptable to different languages by offering an abstract and homogeneous representation of the system.

Model Driven Engineering (MDE) is an approach to software development by which software is specified, designed, implemented and deployed through a series of models. While the capabilities of MDE have been realized in many aspects of software development, there is no MDE supported technique for generating information visualizations. Information visualization is a technique that supports human cognition through interactive graphics by enabling users to identify data patterns more easily, summarize information or abstract concepts that are not easily comprehended from the underlying data. As more systems are designed using model driven engineering approaches there is now a need to support a model driven approach for creating such visualizations. This research explores the feasibility of a model driven approach to view creation that is compatible with the goals of MDE. We approach the problem of developing an MDE technique for view creation in two ways. First, we examine how MDE technologies are used for specifying, designing, and maintaining software systems to uncover the aspects of software customization that are supported through MDE. Second, we analyze six existing visualization tools to determine three functional requirements and six design recommendations for visualization creation and customization tools. Combining MDE principles and information visualization requirements, we propose Model Driven Visualization (MDV), a model based approach to view creation. MDV includes platform independent models for common visualizations, as well as a technique to generate platform specific instances of these models. Finally, using MDV we show that standard visualizations can be recreated in a concise syntax, that is compatible with the goals of model driven engineering. MDV contributes to the fields of model driven engineering, information visualization and software engineering. In particular, this research 1) provides a collection of formal view models for common information visualization techniques, 2) outlines a method for designing and customizing information visualizations using MDE, 3) presents a code generation technique for integrating MDE with the model-view-controller pattern, and 4) contributes an open-source visualization toolkit to the Eclipse project.

Les pratiques de développement des logiciels de Réalité Virtuelle (RV) ne sont pas optimisées. Ainsi, chaque société utilise ses propres méthodes. L'objectif de la thèse est d'automatiser la production et l'évaluation des logiciels de RV en utilisant des techniques issues de ! 'Ingénierie Dirigée par les Modèles (IDM). Les approches existantes en RV ne permettent pas de tirer parti des points communs que partagent ces logiciels. Ces manques de réutilisation et d'abstraction sont des problèmes connus en !DM, qui propose le concept de Ligne de Produits Logiciels (LPL) pour automatiser la production de logiciels de la même famille par réutilisation de composants communs. Cependant cette approche n'est pas adaptée au développement de logiciels reposant sur un scénario, comme en RV. Nous proposons deux frameworks qui comblent respectivement les manques en IDM et en RV : LPLOS (LPL Orientée Scénario) et LPLRV (LPL pour la RV). LPLOS repose sur un modèle de scénarios qui manipule un modèle de variabilité logicielle (Feature model, FM). Chaque étape du scénario correspond à une configuration du FM. LPLRV repose sur LPLOS. Le scénario supervise la manipulation des objets virtuels, générés automatiquement à partir d'un modèle. Nous avons implémenté ces frameworks au sein d'outils qui ont été essayés sur des exemples et évalués par des utilisateurs cibles. Les résultats soutiennent l'utilisation de ces frameworks pour la production de logiciels reposant sur un scénario. / Development practices in Virtual Reality (VR) are not optimized. for example, each company uses its own methods. The goal of this PhD thesis is to automatize development and evaluation of VR software with the use of Model-Driven Engineering (MDE) technics. The existing approaches in VR do not take advantage of software commonalities. Those lacks of reuse and abstraction are known problems in MDE, which proposes the Soflware Product Line (SPL) concept to automatize the production of software belonging to the same family, by reusing common components. However, this approach is not adapted to software based on a scenario, like inVR.We propose two frameworks that respectively address the lacks in MDE and VR : SOSPL (scenario-oriented software product line) and VRSPL (VR SPL). SOSPL is based on a scenario model that handles a software variability model (feature model , FM). Each scenario step matches a configuration of the FM. VRSPL is based on SOSPL. The scenario manages virtual objects manipulation, the objects being generated automatically from a model. We implemented these frameworks inside tools that have been tried on exemples and evaluated by their target users. The results promote the use of these frameworks for producing scenario-based software.