21 |
Measuring Incrementally Developed Model Transformations Using Change MetricsPaen, EYRAK 28 September 2012 (has links)
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
|
22 |
MDE 2.0 : Pragmatical formal model verification and other challengesCabot, Jordi 10 September 2012 (has links) (PDF)
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.
|
23 |
A model-based approach for extracting business rules out of legacy information systemsCosentino, Valerio 18 December 2013 (has links) (PDF)
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.
|
24 |
Model driven visualization: towards a model driven engineering approach for information visualizationBull, Robert Ian 07 August 2008 (has links)
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.
|
25 |
From Models to Code and Back : A Round-trip Approach for Model-driven Engineering of Embedded SystemsCiccozzi, Federico January 2014 (has links)
The complexity of modern systems is continuously growing, thus demanding novel powerful development approaches.In this direction, model-driven and component-based software engineering have reached the status of promising paradigms for the development of complex systems. Moreover, in the embedded domain, their combination is believed to be helpful in handling the ever-increasing complexity of such systems.However, in order for them and their combination to definitively break through at industrial level, code generated from models through model transformations should preserve system properties modelled at design level. This research work focuses on aiding the preservation of system properties throughout the entire development process across different abstraction levels. Towards this goal, we provide the possibility of analysing and preserving system properties through a development chain constituted of three steps: (i) generation of code from system models, (ii) execution and analysis of generated code, and (iii) back-propagation of analysis results to system models.With the introduction of steps (ii) and (iii), properties that are hard to predict at modelling level are compared with runtime values and this consequently allows the developer to work exclusively at modelling level thus focusing on optimising system models with the help of those values. / Denna doktorsavhandling presenterar nya och förbättrade tekniker för modelldriven och komponentbaserad utveckling av programvara. Syftet är att bevara systemegenskaper, som specificerats i modeller, genom de olika stadierna av utvecklingen och när modeller översätts mellan olika abstraktionsnivåer och till kod. Vi introducerar möjligheter att studera och bevara systemets egenskaper genom att skapa en kedja i tre steg som: (i) genererar kod från systemmodellen, (ii) exekverar och analyserar den genererade koden och (iii) slutligen återkopplar analysvärden till systemmodellen. Introduktionen av steg (ii) och (iii) gör det möjligt att genomföra en detaljerad analys av egenskaper som är svåra, eller till och med omöjliga, att studera med hjälp av endast systemmodeller. Fördelen med det här tillvägagångssättet är att det förenklar för utvecklaren som slipper arbeta direkt med kod för att ändra systemegenskaper. Istället kan utvecklaren arbeta helt och hållet med modeller och fokusera på optimering av systemmodeller med hjälp av analysvärden från testkörningar av systemet. Vi är övertygade om att denna typ av teknik är nödvändig att utveckla för att stödja modelldriven utveckling av programvara eftersom dagens tekniker inte möjliggör för systemutvecklare att specificera, analysera och optimera systemegenskaper på modellnivå. / La continua crescita in complessitá dei sistemi software moderni porta alla necessitá di definire nuovi e piú efficaci approcci di sviluppo. In questa direzione, metodi basati su modelli (model-driven engineering) e componenti (component-based software engineering) sono stati riconosciuti come promettenti nuove alternative per lo sviluppo di sistemi complessi. Inoltre l'interazione tra loro é ritenuta particolarmente vantaggiosa nella gestione nello sviluppo di sistemi integrati. Affinché questi approcci, cosí come la loro interazione, possano definitivamente prendere piede in campo industriale, il codice generato dai modelli tramite apposite transformazioni deve essere in grado di preservare le proprietá di sistema, sia funzionali che extra-funzionali, definite nei modelli. Il lavoro di ricerca presentato in questa tesi di dottorato si focalizza sul preservamento delle proprietá di sistema nell'intero processo di sviluppo e attraverso i diversi livelli di astrazione. Il risultato principale é rappresentato da un approccio automatico di round-trip engineering in grado di sostenere il preservamento delle proprietá di sistema attraverso: 1) generazione automatica di codice, 2) monitoraggio e analisi dell'esecuzione del codice generate su piattaforme specifiche, e 3) offrendo la possibilitá di propagare verticalmente i risultati da runtime al livello di modellazione. In questo modo, quelle proprietá che possono essere stimate staticamente solo in maniera approssimativa, vengono valutate in rapporto ai valori ottenuti a runtime. Ció permette di ottimizzare il sistema a livello di design attraverso i modelli, piuttosto che manualmente a livello di codice, per assicurare il preservamento degli proprietá di sistema d'interesse.
|
26 |
Synthèse d'applications de réalité virtuelle à partir de modèles / Model driven synthesis of virtual reality applicationsLe Moulec, Gwendal 26 September 2018 (has links)
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.
|
27 |
A model-driven design-space exploration tool for the HIPAO 2 methodology / Ferramenta de exploração de espaço de projeto baseada em modelos para a metodologia HIPAO2Lerm, Rafael Andréas Raffi January 2015 (has links)
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.
|
28 |
A model-driven design-space exploration tool for the HIPAO 2 methodology / Ferramenta de exploração de espaço de projeto baseada em modelos para a metodologia HIPAO2Lerm, Rafael Andréas Raffi January 2015 (has links)
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.
|
29 |
Behavioral java code generation from imperative object constraint language expressions in plataformindependent UML modelsTAVARES, Marcellus Antonius de Castro 31 January 2011 (has links)
Made available in DSpace on 2014-06-12T15:49:38Z (GMT). No. of bitstreams: 1
license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5)
Previous issue date: 2011 / Antonius de Castro Tavares, Marcellus; Pierre Louis Robin, Jacques. Behavioral java code generation from imperative object constraint language expressions in plataformindependent UML models. 2011. Dissertação (Mestrado). Programa de Pós-Graduação em Ciência da Computação, Universidade Federal de Pernambuco, Recife, 2011.
|
30 |
Use of Global Consistency Checking for Exploring and Refining Relationships between Distributed Models : A Case StudyRad, Yasaman Talaei, Jabbari, Ramtin January 2012 (has links)
Context. Software systems, becoming larger and more complex day-by-day, have resulted in software development processes to become more complex to understand and manage. Many companies have started to adapt distributed software engineering practices that would allow them to work in distributed teams at different organizations and/or geographical locations. For example, model-driven engineering methods are being used in such global software engineering projects. Among the activities in model-based software development, consistency checking is one of the widely known ones. Consistency checking is concerned with consistent models; in particular, having a consistent group of multiple models for a whole system, e.g., multiple models produced by distributed teams. Objectives. This thesis aims to find out how ‘Global Consistency Checking (GCC)’ can be utilized for exploring inconsistency problems between distributed models; particularly among UML class diagram relationships (in terms of consistency), as well as how GCC can be scaled with large number of models and relationships. Thereby, these inconsistencies are also aimed to incrementally resolve in our approach. Methods. We made a review in distributed software development domain and model management, in particular, methods of consistency checking between ‘Distributed Models (DM)’. Next, we conducted two case studies in two problem domains in order to apply our ‘consistency checking methodology’. We concurrently constructed and implemented new consistency rules, most of which are gathered from literatures and brainstorming with our coordinators. Generally, the method contains implementing different models of the case studies with a tool support and trying to figure out overlaps, merging models and checking the merged model against the consistency rules, and evaluating the results of GCC. We mainly addressed issues focused on consistency checking of individual models and the mapping between them e.g., pair-wise consistency checking (PCC), which are incapable of fully addressing problems against any consistency rules encountered in distributed environments. Results. We have identified seven types of inconsistency, which are divided in two groups named ‘Global inconsistency’ and ‘Pair-wise inconsistency’. In the first case study, we have 94 global inconsistencies and 73 pair-wise. In the second one, 14 global and 25 pair-wise inconsistencies are resulted. During ‘Resolution approach’, we followed six steps as a ‘systematic procedure’ for resolving these inconsistencies and constructed new merged model in each iteration. The initial merged model (inconsistent model) as an input for the first step has 1267 elements, and the consistent merged model (the output) from the sixth step has 686 elements. ‘time duration’ and ‘required effort’ for checking consistency against each ‘consistency rule’ were recorded, analyzed and illustrated in Sections 4.1.5 and 4.2.4. Conclusions. We concluded that GCC enables us to explore the inconsistencies, inclusive of resolving them and therefore, refining the relationships between different models, which are difficult to detect by e.g., a pair-wise method. The most important issues are: The number of model comparisons conducted by PCC, The inability of PCC for identifying some inconsistencies, Model relationships refinement and classification based on PCC approach will not lead to a final consistent DM, whereas, GCC guarantees it. Consistency rules application, inconsistency identification and resolving them could be generalized to any UML class diagram model representing a problem domain within the fields of consistency checking in software engineering. / 0046760850792, 0046737749752
|
Page generated in 0.021 seconds