Frameworks são ferramentas importantes no contexto atual da tecnologia de desenvolvimento de software, fornecendo funcionalidades através de código previamente testado, o que leva a uma redução na quantidade de código necessário para se implementar soluções e no tempo de implementação. Porém, devido a complexidade dos frameworks atuais, seu uso se torna trabalhoso, requerendo um gasto de tempo elevado para se aprender um framework novo. Neste trabalho de pesquisa foi desenvolvido o Framer, um método de transformação de modelos capaz de selecionar componentes de um framework, a partir de seu modelo UML, que são necessários para implementar as funcionalidades providas pelo framework para uma aplicação em desenvolvimento. Este método de transformação utiliza uma versão modificada do algoritmo NONLIN de planejamento, para identificar não somente os componentes que serão utilizados, mas como e em qual ordem devem ser invocados pela aplicação. Uma vez identificados os componentes, são criados os Diagramas UML necessários para representar sua utilização. / Frameworks are important tools for current software development technology, providing functionalities through previously tested code, reducing the amount of code and time necessary to implement the solution. However, due to framework complexity, a developer needs a significant investment in time to learn it. This work presents the Framer, a model transformation method capable of selecting components, from a framework\'s UML model, that will be used to construct the functionalities of the target application. Once the components are identified, the UML Diagrams necessary to describe its use are created.

Uma das principais atividades dos enfoques de desenvolvimento de software centrados em modelos, como por exemplo a Arquitetura Dirigida por Modelo (Model Driven Architecture - MDA), é o processo de transformação de modelos. Geralmente, um passo preliminar para a transformação dos modelos é o mapeamento dos elementos do meta-modelo fonte nos elementos do meta-modelo alvo. Este trabalho apresenta uma aplicação de uma técnica de mapeamento de modelos denominada tecelagem de modelos. Esta técnica permite ao usuário definir a semântica das ligações estabelecidas entre os elementos do meta-modelo fonte e os elementos do meta-modelo alvo. A semântica é definida através de tipos fortes associados às ligações. O presente trabalho analisa, através de dois experimentos, alguns aspectos da geração de modelos de transformação de modelos no arcabouço MDA, utilizando a técnica de tecelagem de modelos. A análise utiliza duas alternativas de especificação de transformação de modelos a título de comparação: a que usa somente uma linguagem de especificação de modelos de transformação e a que usa a técnica de tecelagem de modelos. Os aspectos analisados são: a reutilização de trechos de código escritos na linguagem de geração de especificações de transformação e a reutilização de decisões de projeto (design) no mapeamento entre dois meta-modelos distintos. / One of the main activities of the model-centric approaches of software development, as for example the Model Driven Architecture (MDA), is the process of model transformation. Usually, a preliminary step for model transformation is the mapping of source metamodel elements into target metamodel elements. This work presents an application of a technique for model mapping called model weaving. This technique allows the user to define the semantics of the links binding source metamodel elements and target metamodel elements. The semantics is defined through types associated to links. The work analyzes, through two experiments, some aspects of the generation of models transformation in the MDA framework, using a technique known as model weaving. The analysis, for comparison purposes, uses two techniques of model transformation specification: one using only a specification language for model transformation specification and another using model weaving. The analyzed aspects are: the reuse of pieces of code written in the language that generates the transformation of specifications and the reuse of design decisions in the mapping between two distinct metamodels.

Uma das principais atividades dos enfoques de desenvolvimento de software centrados em modelos, como por exemplo a Arquitetura Dirigida por Modelo (Model Driven Architecture - MDA), é o processo de transformação de modelos. Geralmente, um passo preliminar para a transformação dos modelos é o mapeamento dos elementos do meta-modelo fonte nos elementos do meta-modelo alvo. Este trabalho apresenta uma aplicação de uma técnica de mapeamento de modelos denominada tecelagem de modelos. Esta técnica permite ao usuário definir a semântica das ligações estabelecidas entre os elementos do meta-modelo fonte e os elementos do meta-modelo alvo. A semântica é definida através de tipos fortes associados às ligações. O presente trabalho analisa, através de dois experimentos, alguns aspectos da geração de modelos de transformação de modelos no arcabouço MDA, utilizando a técnica de tecelagem de modelos. A análise utiliza duas alternativas de especificação de transformação de modelos a título de comparação: a que usa somente uma linguagem de especificação de modelos de transformação e a que usa a técnica de tecelagem de modelos. Os aspectos analisados são: a reutilização de trechos de código escritos na linguagem de geração de especificações de transformação e a reutilização de decisões de projeto (design) no mapeamento entre dois meta-modelos distintos. / One of the main activities of the model-centric approaches of software development, as for example the Model Driven Architecture (MDA), is the process of model transformation. Usually, a preliminary step for model transformation is the mapping of source metamodel elements into target metamodel elements. This work presents an application of a technique for model mapping called model weaving. This technique allows the user to define the semantics of the links binding source metamodel elements and target metamodel elements. The semantics is defined through types associated to links. The work analyzes, through two experiments, some aspects of the generation of models transformation in the MDA framework, using a technique known as model weaving. The analysis, for comparison purposes, uses two techniques of model transformation specification: one using only a specification language for model transformation specification and another using model weaving. The analyzed aspects are: the reuse of pieces of code written in the language that generates the transformation of specifications and the reuse of design decisions in the mapping between two distinct metamodels.

There is a strong synergy between the concepts of evolution and adaptation in software engineering: software adaptation refers to both the current software being adapted and to the evolution process that leads to the new adapted software. Evolution changes for the purpose of adaptation are usually made at development or compile time, and are meant to handle predictable situations in the form of software change requests. On the other hand, software may also change and adapt itself based on the changes in its environment. Such adaptive changes are usually dynamic, and are suitable for dealing with unpredictable or temporary changes in the software's operating environment. A promising solution for software adaptation is to develop self-adaptive software systems that can manage changes dynamically at runtime in a rapid and reliable way. One of the main advantages of self-adaptive software is its ability to manage the complexity that stems from highly dynamic and nondeterministic operating environments. If a self-adaptive software system has been engineered and used properly, it can greatly improve the cost-effectiveness of software change through its lifespan. However, in practice, many of the existing approaches towards self-adaptive software are rather expensive and may increase the overall system complexity, as well as subsequent future maintenance costs. This means that in many cases, self-adaptive software is not a good solution, because its development and maintenance costs are not paid off. The situation is even worse in the case of making current (legacy) systems adaptive. There are several factors that have an impact on the cost-effectiveness and usability of self-adaptive software; however the main objective of this thesis is to make a software system adaptive in a cost-effective way, while keeping the target adaptive software generic, usable, and evolvable, so as to support future changes. In order to effectively engineer and use self-adaptive software systems, in this thesis we propose a new conceptual model for identifying and specifying problem spaces in the context of self-adaptive software systems. Based on the foundations of this conceptual model, we propose a model-centric approach for engineering self-adaptive software by designing a generic adaptation framework and a supporting evolution process. This approach is particularly tailored to facilitate and simplify the process of evolving and adapting current (legacy) software towards runtime adaptivity. The conducted case studies reveal the applicability and effectiveness of this approach in bringing self-adaptive behaviour into non-adaptive applications that essentially demand adaptive behaviour to sustain.

Changing artifacts is intrinsic to the development and maintenance of software projects. The changes made to one artifact, however, do not come about in isolation. Software models are often vastly entangled. As such, a minuscule modification in one ripples in- consistency through several others. The primary goal of the this thesis is to investigate techniques and processes for the synchronization of artifacts in model driven development environments in which projects comprise manifold interdependent models, each being a live document that is continuously altered and evolved. The co-evolution of these artifacts demands an efficient mechanism to keep them consistent in such dynamic environments. To achieve this consistency, we intend to explore methods and algorithms for impact anal- ysis and the propagation of modifications across heterogenous interdependent models. In particular, we consider large scale models that are generated from other models by complex artifact generators. After creation, both the generated artifacts, and also the ones they are generated from, are subject to evolutionary changes throughout which their mutual consistency should be maintained. In such situations, the model transformation is the pri- mary benchmark of consistency rules between source and target models. But the rules are often implanted inside the implementation of artifact generators and hence unavailable. Trivially, the artifacts can be synchronized by regeneration. More often than not however, regeneration of such artifacts from scratch tends to be unwieldy due to their massive size. This thesis is a summary of research on effective change management methodologies in the context of model driven development. In particular, it presents two methods of in- crementally synchronizing software models related by existing model transformations, so that the synchronization time is proportional to the magnitude of change and not to the size of models. The first approach treats model transformations as black-boxes and adds to it incremental synchronization by a technique called conceptualization. The black-box is distinguished from other undertakings in that it does not require the extraction, re- engineering and re-implementation of consistency rules embedded inside transformations. The second approach is a white-box approach that uses static analysis to automatically transform the source code of the transformation into an incremental one. In particular it uses partial evaluation to derive a specialized, incremental transformation from the exist- ing one. These two approaches are complementary and together support a comprehensive range of model transformations.

<p>The development of advanced embedded systems requires a systematic approach as well as advanced tool support in dealing with their increasing complexity. This complexity is due to the increasing functionality that is implemented in embedded systems and stringent (and conflicting) requirements placed upon such systems from various stakeholders. The corresponding system development involves several specialists employing different modeling languages and tools. Integrating their work and the results thereof then becomes a challenge. In order to facilitate system architecting and design integration of different models, an approach that provides dedicated workspaces/views supported by structured information management and information exchange between domain models and tools is required.</p><p>This work is delimited to the context of embedded systems design and taking a model based approach. The goal of the work is to study possible technical solutions for integrating different models and tools, and to develop knowledge, support methods and a prototype tool platform.</p><p>To this end, this thesis examines a number of approaches that focus on the integration of multiple models and tools. Selected approaches are compared and characterized, and the basic mechanisms for integration are identified. Several scenarios are identified and further investigated in case studies. Two case studies have been performed with model transformations as focus. In the first one, integration of Matlab/Simulink® and UML2 are discussed with respect to the motivations, technical possibilities, and challenges. A preliminary mapping strategy, connecting a subset of concepts and constructs of Matlab/Simulink® and UML2, is presented together with a prototype implementation in the Eclipse environment. The second case study aims to enable safety analysis based on system design models in a UML description. A safety analysis tool, HiP-HOPS (Hierarchically Performed Hazard Origin and Propagation Studies), is partially integrated with a UML tool where an EAST-ADL2 based architecture model is developed. The experience and lessons learned from the experiments are reported in this thesis.</p><p>Multiple specific views are involved in the development of embedded systems. This thesis has studied the integration between system architecture design, function development and safety analysis through using UML tools, Matlab/Simulink, and HiP-HOPS. The results indicate that model transformations provide a feasible and promising solution for integrating multiple models and tools. The contributions are believed to be valid for a large class of advanced embedded systems. However, the developed transformations so far are not really scalable. A systematic approach for efficient development of model transformations is desired to standardize the design process and reuse developed transformations. To this end, future studies will be carried out to develop guidelines for model and tool integration and to provide support for structured information at both meta level and instance level.</p>

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

Business processes describe a set of tasks for accomplishing business objectives of an organization. Business applications automate business processes to improve the productivity of business users. Nowadays, the business environment changes fast due to rapid market growth and technological innovations. Business processes are continuously updated to reflect new business initiatives. Business applications are frequently evolved to add features to meet new requirements and fix defects. Quite often, business processes and business applications evolve independently without direct reference to each other. Over time, it becomes more and more challenging to maintain the consistency between a business application and the corresponding business processes. Moreover, the existing development approaches rely on software developers’ craftsmanship to design and implement business applications. Such a development paradigm is inefficient and leads to inconsistency between business processes and business applications. To facilitate the alignment between business applications and business processes, we present an approach that automatically generates software architecture and code skeletons of business applications from business processes. We identify architectural components from business processes by analyzing dependencies among tasks. To verify the achievement of quality requirements, we extend a set of existing product metrics to automatically evaluate the quality of the generated software architecture designs. Eventually, we apply refactoring strategies, such as software architectural styles or design patterns, to optimize the generated software architecture designs and resolve identified quality problems. Moreover, we also present an approach to automatically refine software architecture to design models and code skeletons of business applications. The effectiveness of our proposed approach is illustrated through case studies. / Thesis (Ph.D, Electrical & Computer Engineering) -- Queen's University, 2011-01-30 00:06:34.77

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

In this thesis, we describe how to use UML sequence diagrams with MARTE timing constraints to specify entirely the behavior of component-based systems while abstracting as much as possible the functional roles of components composing it. We have shown how to conduct compositional analysis of such specifications. For this, we have defined operational semantics to sequence diagrams by translating them into TIOSTS which are symbolic automata with timing constraints. We have used symbolic execution techniques to compute possible executions of the system in the form of a symbolic tree. We have defined projection mechanisms to extract the execution tree associated with any distinguished component. The resulting projected tree characterizes the possible behaviors of the component with respect to the context of the whole system specification. As such, it represents a constraint to be satisfied by the component and it can be used as a correctness reference to validate the system in a compositional manner. For that purpose, we have grounded our validation framework on testing techniques. We have presented compositional results relating the correctness of a system to the correctness of components. Based on these results, we have defined an incremental approach for testing from sequence diagrams.