The research reported in this thesis is focused on the creation of a CAE system to support Reverse Engineering. It is centred around the computational representation of products (Product Model) and manufacturing capabilities (Manufacturing Model). These models are essential for modem and future software systems aimed to assist the design process, enabling data sharing among the participants who use various computational tools. Reverse Engineering is employed as a particular context and motivation for exploring the application of the models. The research builds on the achievements of the recently finished Model Oriented Simultaneous Engineering System (MOSES) project, undertaken jointly by Leeds University and the Department of Manufacturing Engineering of Loughborough University. MOSES' work on information modelling was analysed and combined together with the original proposals of the author to elaborate a suitable support to Reverse Engineering, applicable to redesign in general. A process for Reverse Engineering is proposed and documented and a data model driven CAE system to support it is specified. The CAE system includes a Product Model, a Manufacturing Model and two software application environments. The Product Model of the system is based on the information requirements of the Reverse Engineering process and is suitable for representing multi-component products, from different perspectives through its life cycle. The applications assist the characteristic activities of Reverse Engineering. In particular, the system is used for exploring the application of Product and Manufacturing Models in supporting Design for Manufacture. The theoretical research is tested by the use of a case study which explores the Reverse Engineering of a component. This work is supported by a prototype software instance of the CAE system. The case study component is an axle which forms part of a product designed and manufactured by a collaborating company.

When developing domain-specific modeling languages (DSMLs), software engineers have to make a number of important design decisions on the DSML itself, or on the software-development process that is applied to develop the DSML. Thus, making well-informed design decisions is a critical factor in developing DSMLs. To support this decision-making process, the model-driven development community has started to collect established design practices in terms of patterns, guidelines, story-telling, and procedural models. However, most of these documentation practices do not capture the details necessary to reuse the rationale behind these decisions in other DSML projects. In this paper, we report on a three-year research effort to compile and to empirically validate a catalog of structured decision descriptions (decision records) for UML-based DSMLs. This catalog is based on design decisions extracted from 90 DSML projects. These projects were identified - among others - via an extensive systematic literature review (SLR) for the years 2005 - 2012. Based on more than 8,000 candidate publications, we finally selected 84 publications for extracting design-decision data. The extracted data were evaluated quantitatively using a frequent-item-set analysis to obtain characteristic combinations of design decisions and qualitatively to document recurring documentation issues for UML-based DSMLs. We revised the collected decision records based on this evidence and made the decision-record catalog for developing UML-based DSMLs publicly available. Furthermore, our study offers insights into UML usage (e.g. diagram types) and into the adoption of UML extension techniques (e.g. metamodel extensions, profiles).

Unified Modeling Language (UML) is a de-facto standard modeling language with an extensive syntax and notations that can be used to model systems of any kind. However, being a general-purpose language, its semantics are intrinsically under-specified and broad to leave a room for different interpretations. This, in general, hinders the ability to perform formal verification of models produced with a specific domain in mind. In these cases, it is usually more suitable to map the UML models to other domains, where modeling concepts have stricter semantics. Notably, Reactive Objects Language (Rebeca) is an actor-based language with a formal foundation and formal verification support. This paper aims to identify a subset of UML modeling concepts compatible with the domain of reactive and distributed systems as modeled in Rebeca. In this respect, this work proposes a conceptual mapping between a sub-portion of UML and Rebeca, with the goal of enabling formal verification early in the design process. In particular, we investigate Rebeca syntax, and for each Rebeca concept, we provide the corresponding concept in the UML, as part of an iterative process. This process ends when all Rebeca concepts are exhausted and comprehensive mapping procedure emerges. Additionally, validation is an important part of this paper as it aims to establish confidence in the developed mapping procedure (in post-conversion validation) and avoid doing the transformation if the design is not compatible with the mapping procedure (in pre-conversion validation). As part of the pre-conversion validation, in order to establish the compatibility with the mapping procedure, we provide an extensive list of correctness attributes. As part of the post-conversion validation, the mapping procedure is validated by transformation on the provided examples. The results of this transformation show the wide range applicability of the mapping procedure and serve as an assertion of its comprehensiveness.

Model-driven engineering promotes the migration from code-centric to model-based software development. Systems consist of model collections integrating different concerns and perspectives, while semi-automated model transformations generate executable code combining the information from these. Increasing the abstraction level to models required appropriate management technologies supporting the various software development activities. Among these, model comparison represents one of the most challenging tasks and plays an essential role in various modelling activities. Its hardness led researchers to propose a multitude of approaches adopting different approximation strategies and exploiting specific knowledge of the involved models. However, almost no support is provided for their evaluation against specific scenarios and modelling practices. This thesis presents Benji, a framework for the automated generation of model comparison benchmarks. Given a set of differences and an initial model, users generate models resulting from the application of the first on the latter. Differences consist of preconditions, actions and postconditions expressed using a dedicated specification language. The generator converts benchmark specifications to design-space exploration problems and produces the final solutions along with a model-based description of their differences with respect to the initial model. A set of representative use cases is used to evaluate the framework against its design principles, which resemble the essential properties expected from model comparison benchmark generators.

Sistemas embarcados estão presentes em inúmeras atividades realizadas diariamente, por exemplo, eles são parte integrante dos meios de transporte, encontram-se em sistemas de entretenimento como os tablets e telefones celulares e ainda podem estar dentro das pessoas, como nos usuários de marca-passo. Os sistemas embarcados são desenvolvidos em níveis de complexidade bem distintos, variando de sistemas bem simples até sistemas altamente elaborados e complexos. Essa complexidade pode ser atribuída a diversos fatores, incluindo a necessidade de poder executar múltiplas tarefas em unidades de processamento heterogêneas (baseadas em CPU, GPU, DSP e FPGAs) e atendendo aos requisitos exigidos pelos usuários. Em função do aumento da complexidade e da necessidade de manter o tempo e custo do desenvolvimento de novos sistemas embarcados baixo, uma solução que vem sendo discutida é o uso de metodologias de projetos baseadas em modelos. Estas metodologias usam o modelo como fonte principal de informação. As informações contidas nos modelos variam de acordo com o estágio de desenvolvimento do sistema: nos modelos iniciais são descritivas, simples, incompletas mas permitem realizar simulações que podem ser usadas para guiar o desenvolvimento do próprio sistema. Com o amadurecimento do projeto, mais informações são agregadas aos modelos, tornando-os mais próximos do sistema a ser implementado. Este processo reduz o nível de abstração dos modelos até o ponto que é possível gerar, entre outros artefatos, o código fonte. Neste contexto, sistemas de processamento de imagens embarcados são exemplos de sistemas complexos que fazem processamento de dados de forma intensiva. Estes sistemas são tradicionalmente desenvolvidos em um nível de abstração baixo que tipicamente incluem diagramas blocos e diagrama de estados. Para que seja possível administrar o crescente aumento da complexidade, em um baixo tempo de desenvolvimento, destes sistemas é necessário que sejam criados métodos que permitam desenvolvê-los em um nível mais alto de abstração. Além disso é necessário que existam ferramentas que auxiliem no seu desenvolvimento permitindo, entre outras coisas, aumentar o reúso dos blocos parametrizáveis do sistema e a exploração de espaço de projetos em fases iniciais do projeto para guiar o seu próprio desenvolvimento. Neste trabalho é feita uma proposta de um novo método de desenvolvimento de sistemas embarcados de processamento de imagens baseado na metodologia de engenharia dirigida por modelos. São parte integrantes do método proposto: combinar a modelagem de requisitos funcionais (usando modelagem orientada a objetos) e requisitos não-funcionais (usando modelagem orientada a aspectos); a exploração de espaço de projeto baseada em modelos para resolver o problema de alocação das tarefas nas diferentes unidades de processamento; validação funcional dos modelos; e a geração de código em linguagens de programação. O método proposto chama-se HIPAO, do inglês “Hardware Image Processing system based on model driven engineering and Aspect-Oriented modeling”. O ciclo de desenvolvimento de projeto de sistemas de processamento de imagens embarcado inicia com a coleta dos requisitos técnicos em diagramas de requisitos da linguagem SysML A especificação deste requisitos é feita através de um metamodelo para requisitos técnicos de processamento de imagens que foi desenvolvido em conjunto com o método HIPAO. Estes requisitos são transformados automaticamente em modelos independentes de plataforma (PIM) iniciais. Esta transformação é feita a partir da ferramenta HIPAO desenvolvida em linguagem Java como mecanismo de apoio ao método. Os modelos PIM iniciais evoluem de forma iterativa através da adição de informações feita de forma manual e também de forma automática através da costura ou composição de modelos. O método sugere que modelos de plataforma (PM) sejam desenvolvidos de forma semelhante ao proposto para os modelos PIM, porém sua implementação é considerada trabalho futuro e os modelos PM apresentados neste trabalho são fruto de um desenvolvimento manual. De posse dos modelos PIM e PM o método realiza uma etapa de otimização do modelo através da sua transformação (tipo modelo para texto) para um formato compatível com o framework que realiza a exploração de espaço de projetos dirigida por modelos (MD-DSE). Os modelos específicos de plataforma (PSM) são produzidos com o auxílio de informações obtidas a partir de gráficos tipo Fronteira de Pareto que são produzidos pelo framework MD-DSE que realiza a atividade de alocação das tarefas (modelo PIM) na plataforma (modelo PM) com base em algoritmos heurísticos. O ciclo de desenvolvimento do projeto se encerra com a geração de código, de forma semelhante à maioria dos métodos baseados em engenharia dirigida por modelos, a partir de modelos PSM e alguns exemplos são apresentados. Para o uso e validação do método proposto foram realizados dois estudos de caso. O primeiro é um sistema de processamento de imagens para câmeras científicas de alta resolução e alta velocidade. O segundo estudo de caso propõe o desenvolvimento de um sistema de processamento de imagens a ser integrado a um veículo autônomo não-tripulado. / Embedded systems are present in many daily activities, for example, they are found in entertainment systems such as tablets and cell phones and they could even be inside a person’s body, which is the case of a pace-maker. Embedded systems can have very distinct complexity levels, from very simple to very complex and sophisticated ones. This complexity can be attributed to many different sources, which include the need to execute multiple tasks or deploy them in heterogeneous platforms (i.e. CPU, GPU, DSP and FPGAs) while fulfilling the users requirements. In order to cope with the rising system’s complexity and the need to keep the time to market and cost low, some solutions using methodologies based on model driven engineering are being considered. These methodologies use the model as the primary source of information. The information in the model varies based on the system’s development stage: at the beginning the models are descriptive, simple and incomplete, however they enable to simulate the system at a high level which can be used to drive the system’s development. As the project evolves, more information is added to them and the models looks closer to its final system. This process reduces the models abstraction level to the point that is possible to generate many artifacts from them, such as, source code. In this context, embedded image processing systems are examples of complex systems that perform data intensive processing. These systems are traditionally developed in a low level of abstraction, which typically include block diagrams and state charts. In order to handle the rising system’s complexity, while keeping time to market low, it is necessary to develop new methods that enable these systems development at a high abstraction level. Also, it is necessary the development of new tools to support these methods enabling, among other things, increase in the design reuse of its blocks and the design space exploration at an early stage such that it could guide the systems own development. In this work it is proposed a novel design method for embedded image processing systems based on model driven engineering concepts. This method proposes the following: combine functional requirements (using object oriented modeling) and non-functional requirements (using aspect oriented modeling); perform model based design space exploration in order to tackle task allocation in platforms with multiple processing units; functional model validation; and code generation. The proposed method is called HIPAO, which stands for “Hardware Image Processing system based on model driven engineering and Aspect-Oriented modeling”. The development cycle of embedded image processing systems starts starts with the elucidation of technical requirements using SysML requirements diagram. The specification of the image processing technical requirements is done using a metamodel, which has been developed with the HIPAO method. These requirements are transformed automatically into initial platform independent models (PIM). The transformations are performed by the HIPAO tools developed using Java language. The PIM models evolve by adding new information to it, which can be done manually or in some cases automatically by model weaving or composition. The proposed method suggests that the platform models (PM) should be developed in a similar fashion as the PIM models, but this task is considered a future work therefore all PM models presented in this thesis have been developed manually. Once the PIM and PM models are available the method executes an optimization phase that includes the model transformation (model to text) that produces the information needed by the model driven - design space exploration (MD-DSE). The platform specific models (PSM) are produced based on the information presented as Pareto Fronts that are generated the the MD-DSE framework while performing task (PIM model) allocation on the platform (PM model) using heuristic algorithms. The method development cycle ends with code generation from the PSM models using model to text transformations and some examples are presented. Two case-studies were designed to validate the proposed method. The first one consists of an image processing system for high speed, high resolution scientific image sensors. The second case study consists of an image processing system that is deployed in small Unmanned Autonomous Vehicles.

Hoje em dia, desenvolvedores de sistemas embarcados enfrentam uma crescente complexidade de projeto, tanto nas aplicações quanto nas plataformas usadas para executá-las. O uso de plataformas complexas faz com que os engenheiros precisem fazer escolhas não-triviais, e muitas vezes contra-intuitivas durante a fase de projeto. Para permitir que os projetistas gerenciem esta complexidade, o uso de metodologias baseadas em modelos tem atraído atenção, e dentro deste contexto, a metodologia HIPAO2 está sendo desenvolvida dentro da UFRGS. Dentre os problemas que os engenheiros precisam enfrentar, o mapeamento entre tarefas e processadores em sistemas multiprocessados heterogêneos é um problema NP-completo, onde o espaço de projeto rapidamente se torna grande demais para que seja explorado satisfatoriamente de maneira manual. Este trabalho detalha a extensão das ferramentas que suportam a metodologia HIPAO2, de maneira a incluir facilidades de Exploração de Espaço de Projeto semi-automática para a solução deste problema. A ferramenta proposta faz uso de um algoritmo genético multiobjetivo para evidenciar tradeoffs existentes no projeto, e algoritmos de análise de aplicações modeladas como synchronous dataflow para avaliar possíveis mapeamentos sem um custo computacional proibitivo. / Designers of today’s embedded systems are faced with increasing complexity both in the applications being developed and the platforms they run on. The use of complex platforms means that the engineers need to make non-trivial and many times non-intuitive decisions during the design phase. To help developers work with this complexity, model-driven techniques are gaining attention, and in this context, the HIPAO2 model-driven engineering methodology is being developed at UFRGS. Among the problems that designers must solve, the task-to-processor mapping in heterogeneous multiprocessor systems is an NP-complete problem and the design space will quickly become too large to be explored adequately by humans. This work details the extension of the tools that support HIPAO2 to include semiautomatic Design-Space Exploration capabilities for the mapping problem. The proposed tool includes the use of a multiobjective genetic algorithm to make tradeoffs explicit to the designers; it also uses synchronous dataflow analysis algorithms to evaluate potential alternatives with a reasonable computational cost.

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.

Industrial software systems are becoming more complex with a large number of interacting parts distributed over networks. Due to the inherent complexity in the problem domains, most such systems are modified over time to incorporate emerging requirements, making incremental development a suitable approach for building complex systems. In domain specific systems it is the domain experts as end users who identify improvements that better suit their needs. Examples include meteorologists who use weather modeling software, engineers who use control systems and business analysts in business process modeling. Most domain experts are not fluent in systems programming and changes are realised through software engineers. This process hinders the evolution of the system, making it time consuming and costly. We hypothesise that if domain experts are empowered to make some of the system changes, it would greatly ease the evolutionary process, thereby making the systems more effective. Agent Oriented Software Engineering (AOSE) is seen as a natural fit for modeling and implementing distributed complex systems. With concepts such as goals and plans, agent systems support easy extension of functionality that facilitates incremental development. Further agents provide an intuitive metaphor that works at a higher level of abstraction compared to the object oriented model. However agent programming is not at a level accessible to domain experts to capitalise on its intuitiveness and appropriateness in building complex systems. We propose a model driven development approach for domain experts that uses visual modeling and automated code generation to simplify the development and evolution of agent systems. Our approach is called the Component Agent Framework for domain-Experts (CAFnE), which builds upon the concepts from Model Driven Development and the Prometheus agent software engineering methodology. CAFnE enables domain experts to work with a graphical representation of the system , which is easier to understand and work with than textual code. The model of the system, updated by domain experts, is then transformed to executable code using a transformation function. CAFnE is supported by a proof-of-concept toolkit that implements the visual modeling, model driven development and code generation. We used the CAFnE toolkit in a user study where five domain experts (weather forecasters) with no prior experience in agent programming were asked to make changes to an existing weather alerting system. Participants were able to rapidly become familiar with CAFnE concepts, comprehend the system's design, make design changes and implement them using the CAFnE toolkit.

The Unified Modelling Language (UML) is intended to express complex ideas in an intuitive and easily understood way. It is important because it is widely used in software engineering and other disciplines. Although an official definition document exists, there is much debate over the precise meaning of UML models. ¶ In response, the academic community have put forward many different proposals for formalising UML, but it is not at all obvious how to decide between them. Indeed, given that UML practitioners are inclined to reject formalisms as non-intuitive, it is not even obvious that the definition should be “formal” at all. Rather than searching for yet another formalisation of UML, our main aim is to determine what would constitute a good definition of UML. ¶ The first chapter sets the UML definition problem in a broad context, relating it to work in logic and the philosophy of science. More specific conclusions about the nature of model driven development are reached in the beginning of Chapter 2. We then develop criteria for a definition of UML. Applying these criteria to the existing definition, we find that it is lacking in clarity. We then set out to test the precision of the definition. The test is to take an apparently inconsistent model, and determine whether it really is inconsistent according to the definition. ¶ Many people have proposed that UML models are graphs, but few have justified this choice using the official definition of UML. We begin Chapter 3 by arguing from the official definition that UML models are graphs and that instantiation is a graph homomorphism into an interpretation functor. The official definition of UML defines the semantics against its abstract syntax, which is in turn defined by a UML model. Chapters 3 and 4 prepare for our test by resolving this apparent circularity. The result is a semantics for the metamodel fragment of the language. ¶ In Chapter 5, we find, contrary to popular belief, that the official definition does provide sufficient semantics to classify the example model as inconsistent. Moreover, the sustained study of the semantics in Chapters 3 to 5 confirms our initial argument that the semantic domain is graphs. The Actions are the building blocks of UML’s prescriptive dynamics. We see that they can be naturally defined as graph transformation rules. Sequence diagrams are the main example of descriptive dynamics, but we find that their official semantics are broken. The “recorded history” approach should be replaced, we suggest, by a graph-oriented dynamic logic. ¶ Chapter 6 presents our early work on dynamic logic for UML sequence diagrams and further explores the proposed semantic repairs. In Chapter 7, guided by the criteria developed in Chapter 2, we critically survey the UML formalisation literature and conclude that an existing body of graph transformation based work known as “dynamic metamodelling” is very close to what is required. ¶ The final chapter draws together our conclusions. It proposes a category theoretic construction to merge models of the syntax and semantic domain, yielding a type graph for the graph transformation system which defines the dynamic semantics of the language. Finally, it outlines the further work required to realise a satisfactory definition of UML.

<p>Dynamic model driven architecture (DMDA) is a architecture made to aid in the</p><p>development of parallel computing code. This thesis is applied to an implementation of</p><p>DMDA known as DMDA3 that should convert graphs of computations into efficient</p><p>computation code, and it deals with the translation of Platform Specific Models (PSM)</p><p>into running systems. Currently DMDA3 can generate schedules of operations but not</p><p>finished code.</p><p>This thesis describes a DMDA3 module that turns a schedule of operations into a</p><p>runable program. Code was obtained from the DMDA3 schedules by reflection and a</p><p>framework was build that allowed generation of low level language code from</p><p>schedules. The module is written in Java and can currently generate C and Fortran code</p><p>for computational tasks. Based on runtime tests for matrix multiplication algorithms the</p><p>generated code is almost as fast as handwritten code.</p><p> </p>