Dissertations / Theses on the topic 'Model Driven Development'
To see the other types of publications on this topic, follow the link: Model Driven Development.
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 dissertations / theses for your research on the topic 'Model Driven Development.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Liyanagama, Pulitha Lakmith. "Aspect-driven model transformations in model driven development." Thesis, University of Kent, 2009. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.509637.
Full text
2
Shappee, Bartlett A. "Test First Model-Driven Development." Digital WPI, 2012. https://digitalcommons.wpi.edu/etd-theses/339.
Full textAbstract:
Test Driven Development (TDD), Model-Driven Development (MDD), and Test Case Generation with their associated practices and tools each in their own right promise to deliver robust higher quality code more economically then other approaches. These process are not mutually exclusive but are not typically used together. This thesis develops a combined approach using complimentary aspects of each of the above three process. Test cases are described, generated, and then injected back into the model, which is then used to produce the test and production code. We have enhanced a model-driven tool to support the approach, adding a test case generator, capable of understanding augmented MDD software model and utilizing the constraints captured in our test-centric language to generate model-level test cases back into the model. Our results show that, with a reduction in overall effort one can produce a tested model-based system in which its test and implementation for multiple platforms such as C and Java, using one of multiple test xUnit frameworks.
3
Kasa, Narasimha Murthy Arjun. "MODEL DRIVEN PRODUCT REALIZATION : A holistic demonstration of model driven product development." Thesis, KTH, Industriell produktion, 2014. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-151257.
Full textAbstract:
Model driven product realization is an emerging methodology in industrial scenario. It focuses onusing 3D models in various formats to design, manufacture and inspect a product. The benefits ofthis methodology are improved cross functional interoperability, reliable modeling and simulation,optimized design decision making, improved performance predictability, strengthened collaborative environment and shortened development time. Currently the prominence of 2Ddrawings and its usage is still prevalent in the industries which results in under‐utilization of the presently available CAx systems leading to diminished productivity. This thesis is aimed to demonstrate the capabilities and impact of model driven approach to formulate an efficient product development methodology in a real industry scenario. For achieving the intent a prototype product is considered which is used in suspension system of the research concept vehicle developed by KTH transport labs. The scope includes the industrialization of the prototype resulting in new/final design, process plan, operation plan inspection plan and eventually a manufactured part using annotated 3D models at all stages. It also showcases the process and product feedback methodologies possible by this approach. The foundations for this demonstration are ISO 10303 standard and STEP (standard for the exchange of product model data) application protocols. These define the computer interpretable representation and exchange of product manufacturing information across various domains. There have been considerable advancements in these standards in recent years but a standard way of approaching the model driven product development does not exist. Hence this demonstration enables as a stepping stone for implementation of this approach in real world.
4
Abdelzad, Vahdat. "Promoting Traits into Model-Driven Development." Thesis, Université d'Ottawa / University of Ottawa, 2017. http://hdl.handle.net/10393/36246.
Full textAbstract:
Traits are primitive units of code reuse that serve as building blocks of classes. In this research, we enhance reuse by extending the capabilities of traits; in particular, we add modeling abstractions to them.
Traits have a variety of benefits, including facilitating reuse and separation of concerns. They have appeared in several programming languages, particularly derivatives of Smalltalk. However, there is still no support for traits that contain modeling abstractions, and no straightforward support for them in general-purpose programming languages. The latter is due to structural concerns that exist for them at runtime, especially traits that contain modeling abstractions.
Model-driven technologies are making inroads into the development community, albeit slowly. Modeling abstractions such as state machines and associations provide new opportunities for reuse, and can be combined with inheritance for even greater reusability. However, issues with inheritance apply also when these new abstractions are inheritable units. This suggests that traits and models ought to be able to be synergistically combined. We perform a comprehensive analysis of using modeling elements in traits. We implement such traits in Umple, which is a model-oriented programming language that permits embedding of programming concepts into models.
The contributions of the thesis are: a) Adding new elements including state machines and associations into traits, hence bringing more reusability, modularity, and applications to traits; b) Developing an algorithm that allows reusing, extending, and composing state machines through traits; c) Extending traits with required interfaces so dependencies at the semantic level become part of their usage, rather than simple syntactic capture; d) Adding template parameters with associations in traits, offering new applications for traits in which it is possible to define design patterns and to have a library of most-used functionality; e) The implementation of all the above concepts, including generating code in multiple general-purpose programming languages through automatic model transformation.
5
Kovése, Jernej. "Model-driven development of versioning systems /." Kaiserslautern : Techn. Univ, 2005. http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&doc_number=013525692&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA.
Full text
6
Johannes, Jendrik. "Component-Based Model-Driven Software Development." Doctoral thesis, Saechsische Landesbibliothek- Staats- und Universitaetsbibliothek Dresden, 2011. http://nbn-resolving.de/urn:nbn:de:bsz:14-qucosa-63986.
Full textAbstract:
Model-driven software development (MDSD) and component-based software development are both paradigms for reducing complexity and for increasing abstraction and reuse in software development. In this thesis, we aim at combining the advantages of each by introducing methods from component-based development into MDSD. In MDSD, all artefacts that describe a software system are regarded as models of the system and are treated as the central development artefacts. To obtain a system implementation from such models, they are transformed and integrated until implementation code can be generated from them. Models in MDSD can have very different forms: they can be documents, diagrams, or textual specifications defined in different modelling languages. Integrating these models of different formats and abstraction in a consistent way is a central challenge in MDSD.
We propose to tackle this challenge by explicitly separating the tasks of defining model components and composing model components, which is also known as distinguishing programming-in-the-small and programming-in-the-large. That is, we promote a separation of models into models for modelling-in-the-small (models that are components) and models for modelling-in-the-large (models that describe compositions of model components). To perform such component-based modelling, we introduce two architectural styles for developing systems with component-based MDSD (CB-MDSD).
For CB-MDSD, we require a universal composition technique that can handle models defined in arbitrary modelling languages. A technique that can handle arbitrary textual languages is universal invasive software composition for code fragment composition. We extend this technique to universal invasive software composition for graph fragments (U-ISC/Graph) which can handle arbitrary models, including graphical and textual ones, as components. Such components are called graph fragments, because we treat each model as a typed graph and support reuse of partial models.
To put the composition technique into practice, we developed the tool Reuseware that implements U-ISC/Graph. The tool is based on the Eclipse Modelling Framework and can therefore be integrated into existing MDSD development environments based on the framework.
To evaluate the applicability of CB-MDSD, we realised for each of our two architectural styles a model-driven architecture with Reuseware. The first style, which we name ModelSoC, is based on the component-based development paradigm of multi-dimensional separation of concerns. The architecture we realised with that style shows how a system that involves multiple modelling languages can be developed with CB-MDSD. The second style, which we name ModelHiC, is based on hierarchical composition. With this style, we developed abstraction and reuse support for a large modelling language for telecommunication networks that implements the Common Information Model industry standard.
7
Wang, Chen-Wei. "Model-driven development of information systems." Thesis, University of Oxford, 2012. http://ora.ox.ac.uk/objects/uuid:9d70647c-e1b6-4cbb-b88c-707f09431db6.
Full textAbstract:
The research presented in this thesis is aimed at developing reliable information systems through the application of model-driven and formal techniques. These are techniques in which a precise, formal model of system behaviour is exploited as source code. As such a model may be more abstract, and more concise, than source code written in a conventional programming language, it should be easier and more economical to create, to analyse, and to change. The quality of the model of the system can be ensured through certain kinds of formal analysis and fixed accordingly if necessary. Most valuably, the model serves as the basis for the automated generation or configuration of a working system. This thesis provides four research contributions. The first involves the analysis of a proposed modelling language targeted at the model-driven development of information systems. Logical properties of the language are derived, as are properties of its compiled form---a guarded substitution notation. The second involves the extension of this language, and its semantics, to permit the description of workflows on information systems. Workflows described in this way may be analysed to determine, in advance of execution, the extent to which their concurrent execution may introduce the possibility of deadlock or blocking: a condition that, in this context, is synonymous with a failure to achieve the specified outcome. The third contribution concerns the validation of models written in this language by adapting existing techniques of software testing to the analysis of design models. A methodology is presented for checking model consistency, on the basis of a generated test suite, against the intended requirements. The fourth and final contribution is the presentation of an implementation strategy for the language, targeted at standard, relational databases, and an argument for its correctness, based on a simple, set-theoretic semantics for structure and operations.
8
Aboulsamh, Mohammed A. "Model-driven data migration." Thesis, University of Oxford, 2012. http://ora.ox.ac.uk/objects/uuid:44ddbf8b-a6a0-4830-baeb-13b2c746802f.
Full textAbstract:
Information systems often hold data of considerable value. Their continuing development or maintenance will often necessitate evolution of the system and migration of the data from one version to the next: a process that may be expensive, time-consuming, and prone to error. That such a process remains a source of challenges, is recognized by both academia and industry. In current practice, data migration is often considered only in the later stages of development, leaving critical data to be transformed and loaded by hand-written scripts, long after the design process has been completed. The advent of model-driven engineering offers an opportunity to consider the question of information system evolution and data migration earlier in the development process. A precise account of the proposed changes to an existing system model can be used to predict the consequences for existing data, and to generate the necessary data migration implementation. This dissertation shows how automatic data migration can be achieved by extending the definition of a data modeling language to include model level operations, each of which corresponds to the addition, modification, or deletion of a model component. Using the Unified Modeling Language (UML) notation as an example, we show how the specification of these operations may be translated into an abstract program in the Abstract Machine Notation (AMN), employed in the B-method, and then formally checked for consistency and applicability prior to translation into a concrete programming notation, such as Structured Query Language (SQL).
9
Baerisch, Stefan. "Domain-specific model-driven testing." Wiesbaden Vieweg + Teubner, 2009. http://d-nb.info/995466882/04.
Full text
10
Pleuss, Andreas. "Model-Driven Development of Interactive Multimedia Applications." Diss., lmu, 2009. http://nbn-resolving.de/urn:nbn:de:bvb:19-114969.
Full text
11
AmaÌlio, Nuno. "Generative frameworks for rigorous model-driven development." Thesis, University of York, 2006. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.437624.
Full text
12
Mayer, Philip. "MDD4SOA: Model-Driven Development for Service-Oriented Architectures." Diss., lmu, 2010. http://nbn-resolving.de/urn:nbn:de:bvb:19-124405.
Full text
13
Zakariapour, Amid. "Model-Driven Development of Distributed Systems in Umple." Thesis, Université d'Ottawa / University of Ottawa, 2018. http://hdl.handle.net/10393/37143.
Full textAbstract:
Model-driven software development can help tackle complexity when developing large software systems. Model-driven development tools facilitate this. Such tools support multiple features and languages; some are multi-platform and support multi-language code generation from models. Umple is a full-featured open source language and modelling tool that we used as a basis for this thesis.
Distribution concerns have become a critical part of modern software systems. In this thesis, we present how we extended Umple to support the development of model-driven synchronous or asynchronous distributed systems. Our contributions provide simple syntax, model analysis capabilities, and programming APIs, which allow users to change the configuration of systems both at development and deployment stages. We also demonstrate how a system can be modeled without distribution concerns and easily be transformed to a distributed system through our approach.
The contributions of this thesis are: a) Creating a mechanism to distribute objects in Umple; b) Developing new semantics for modelling of distributed objects and providing supporting syntax for this in Umple; c) Investigating different patterns and technologies to implement code generation for distributed systems; d) Implementation, testing, and comparison of the distributed feature in Umple for executable Java code; and e) implementing a mechanism to dynamically modify the distribution plan at runtime.
14
Minton, Susan. "Model-driven software development techniques and case study /." [Denver, Colo.] : Regis University, 2007. http://165.236.235.140/lib/SMinton2007.pdf.
Full text
15
Abuseta, Yousef M. "AutoTaSC : model driven development for autonomic software engineering." Thesis, Liverpool John Moores University, 2009. http://researchonline.ljmu.ac.uk/5927/.
Full textAbstract:
Whilst much research progress has been achieved towards the development of autonomic software engineering tools and techniques including: policy-based management, modelbased development, service-oriented architecture and model driven architecture. They have often focused on and started from chosen object-oriented models of required software behaviour, rather than domain model including user intentions and/or software goals. Such an approach is often reported to lead to "misalignment" between business process layer and their associated computational enabling systems. This is specifically noticeable in adaptive and evolving business systems and/or processes settings. To address this long-standing problem research has over the years investigated many avenues to close the gap between business process modelling and the generation of enactment (computation) layer, which is responsive to business changes. Within this problem domain, this research sets out to study the extension of the Model Driven Development (MOD) paradigm to business/domain model, that is, how to raise the abstraction level of model-driven software development to the domain level and provide model synchronisation to trace and analyse the impact of a given model change. The main contribution of this research is the development of a MOD-based design method for autonomic systems referred to as AutoTaSC. The latter consists of a series of related models, where each of which represents the system under development at a given stage. The first and highest level model represents the abstract model referred to as the Platform Independent Model (PIM). The next model encapsulates the PIM model for the autonomic system where the autonomic capabilities and required components (such as monitor, sensor, actuator, analyser, policy, etc.) are added via some appropriate transformation rules. Targeting a specific technology involves adding, also via transformation rules, specific information related to that platform from which the Platform Specific Model (PSM) for the autonomic system is extracted. In the last stage, code can be generated for the specific platform or technology targeted in the previous stage, web services for instance. In addition, the AutoTaSC method provides a situated model synchronisation mechanism, which is designed following the autonomic systems principles. For instance, to guarantee model synchronisation each model from each AutoTaSC stage has an associated policy-based feedback control loop, which regulates its reaction to detected model change. Thus, AutaTase method model transformation approach to drive model query, view and synchronisation. The Auto'Iast? method was evaluated using a number of benchmark case-studies to test this research hypothesis including the effectiveness and generality of AutaTaSe design method.
16
Giachetti, Herrera Giovanni Andrés. "Supporting Automatic Interoperability in Model-Driven Development Processes." Doctoral thesis, Universitat Politècnica de València, 2011. http://hdl.handle.net/10251/11108.
Full textAbstract:
By analyzing the last years of software development evolution, it is possible to observe that
the involved technologies are increasingly focused on the definition of models for the
specification of the intended software products. This model-centric development schema is the
main ingredient for the Model-Driven Development (MDD) paradigm.
In general terms, the MDD approaches propose the automatic generation of software
products by means of the transformation of the defined models into the final program code.
This transformation process is also known as model compilation process. Thus, MDD is
oriented to reduce (or even eliminate) the hand-made programming, which is an error-prone and
time-consuming task. Hence, models become the main actors of the MDD processes: the
models are the new programming code.
In this context, the interoperability can be considered a natural trend for the future of
model-driven technologies, where different modeling approaches, tools, and standards can be
integrated and coordinated to reduce the implementation and learning time of MDD solutions
as well as to improve the quality of the final software products. However, there is a lack of
approaches that provide a suitable solution to support the interoperability in MDD processes.
Moreover, the proposals that define an interoperability framework for MDD processes are still
in a theoretical space and are not aligned with current standards, interoperability approaches,
and technologies.
Thus, the main objective of this doctoral thesis is to develop an approach to achieve the
interoperability in MDD processes. This interoperability approach is based on current
metamodeling standards, modeling language customization mechanisms, and model-to-model
transformation technologies. To achieve this objective, novel approaches have been defined to
improve the integration of modeling languages, to obtain a suitable interchange of modeling
information, and to perform automatic interoperability verification.Giachetti Herrera, GA. (2011). Supporting Automatic Interoperability in Model-Driven Development Processes [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/11108
Palancia
17
SINDICO, ANDREA. "Model driven development of context aware software systems." Doctoral thesis, Università degli Studi di Roma "Tor Vergata", 2009. http://hdl.handle.net/2108/1018.
Full textAbstract:
In questa tesi viene descritto il lavoro svolto nella realizzazione di un framework model driven per la progettazione e lo sviluppo di sistemi software context aware ovvero capaci di adattare il proprio comportamento in funzione delle informazioni afferenti ad un "contesto" percepito. Il framework si basa su due linguaggi di modellazione e programmazione "domain specific", CAMEL (Context Aware ModEling Language) e JCOOL (Java COntext Oriented Language), appositamente definiti e per i quali sono stati sviluppati editor ed interpreti. L'obiettivo è quello di poter fornire al progettista strumenti che permettano di meglio gestire la progettazione di comportamenti dipendenti dal contesto anche rispetto a sistemi già esistenti.With the aim to provide a contribute toward a major comprehension of the context awareness issues in software engineering in this thesis we present a modeling framework that can be used by engineers to model systems’ context aware characteristics independently of the possible implementation they could have. To this end we have appositely defined proper domain specific modeling and programming languages, respectively named CAMEL (Context Aware ModEling Language) and JCOOL (Java COntext Oriented Language), which allow the designer to be focused on the information related to the entities involved into the realization of a context aware behaviour making easy to share his/her understanding of such concern with other designers or developers. Moreover our modeling approach is based on aspect oriented modeling techniques so that it is possible to model context aware behaviours for already existing systems without having to modify their original models but only referring to their elements. Models based on this framework can be therefore object of transformation processes aimed at producing usefull artifacts such as: metrics or other measurments giving the designer feedbacks about his/her desigin choices; documentation which can be shared with the system’s stakeholders; code which actually implements them.
18
Lima, Massoni Tiago. "A Model-driven approach to formal refactoring." Universidade Federal de Pernambuco, 2008. https://repositorio.ufpe.br/handle/123456789/1556.
Full textAbstract:
Made available in DSpace on 2014-06-12T15:51:08Z (GMT). No. of bitstreams: 2
arquivo2011_1.pdf: 1679074 bytes, checksum: c82d3e4381d7c70bcfaffe3bf1eddd78 (MD5)
license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5)
Previous issue date: 2008Coordenação de Aperfeiçoamento de Pessoal de Nível Superior
Como qualquer outra tarefa evolucionária, a aplicação de refatoramentos em software orientado a objetos normalmente afeta código-fonte e seus modelos relacionados, aumentando a dificuldade de manutenção de artefatos corretos e consistentes. Devido à distância de representação entre artefatos de modelagem e programação, o esforço ligado a refatoramentos logo torna-se duplicado e custoso. Neste contexto, suporte de ferramentas utilizado atualmente, em especial ferramentas de Round-Trip Engineering (RTE), falha em automatizar tarefas de evolução. Consequentemente, a maioria dos projetos de software descarta artefatos de modelagem precocemente, adotando abordagens centradas unicamente em código-fonte. Esta tese propõe uma abordagem formal para consistentemente refatorar modelos de objeto e programas orientados a objetos, baseando o refatoramento apenas em modelos de objetos. Refatoramento de modelos é fundamentado com transformações formais primitivas { leis de modelagem { que são garantidamente preservadoras de semântica. Cada refatoramento aplicado a um modelo de objetos é associado a uma sequência semi-automática de aplicações de leis de programação preservadoras de comportamento, chamadas estrategias. Estrategias são aplicadas na dependência de um relacionamento especifico de conformidade entre modelos de objetos e programas, que devem satisfazer também um dado grau de confinamento. Este trabalho formaliza 14 estratregias, duas para cada lei de modelagem que afeta estruturas do programa. Estas estratregias são formalizadas como táticas de refinamento. Desta forma, refatoramento correto de programas pode ser realizado com reduzida intervenção manual do desenvolvedor, baseado apenas nas transformações que o mesmo aplicou ao modelo. Neste cenario, refatoramentos complexos que afetam as principais estruturas do programa podem ser aplicados a um artefato de mais alto nível de abstra ção, deixando a atualização semi-automática dos detalhes de implementação para as estratregias. Além disso, invariantes do modelo podem ser usados para aprimorar ferramentas especializadas em refatoramento, já que modelos de objetos oferecem informação semântica que permite refatoramentos automáticos mais poderosos. Esta tese considera Alloy como linguagem de modelagem formal, além de uma linguagem de programação similar a Java que chamamos BN. Para esta linguagem, introduzimos quatro novos refatoramentos e leis de programação orientada a objetos, com suas provas e derivações correspondentes. Adicionalmente, as leis de programação foram aplicadas em uma semântica de referências, mais próxima de linguages de programação utilizadas na prática. Com o intuito de delimitar a aplicabilidade desta abordagem, formalizamos uma noção de conformidade entre modelos de objetos e programas, a partir de um framework formal para definição de relacionamentos de conformidade; as definições formais relacionadas foram especificadas e checadas quanto ao tipo na ferramenta PVS. Além disso, estabelecemos e provamos manualmente um teorema para a corretude das estratregias, definindo que elas preservam comportamento e conformidade dos programas refatorados. Mesmo sendo uma abordagem formal, temos a preocupação de discutir sua utilização prática, além de aplica-la em três estudos de caso. Os problemas apresentados nesta tese certamente serão enfrentados em qualquer abordagem de desenvolvimento dirigida por modelos, no momento em que se lida com evolução
19
Biehl, Matthias. "Supporting model evolution in model-driven development of automotive embedded system." Licentiate thesis, KTH, Mekatronik, 2010. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-27323.
Full textAbstract:
Innovative functions in cars, such as active safety systems and advanced driver assistance systems, are realized as embedded systems. The development of such automotive embedded systems is challenging in several respects: the product typically has several crosscutting system properties, experts of diverse disciplines need to cooperate and appropriate processes and tools are required to improve the effciency and the complexity management of development. Model-driven development captures the architecture of the embedded system in the form of models with well-defined metamodels. Model-driven development provides a partial solution to some of the challenges of embedded systems development, but it also introduces new challenges. Models do not remain static, but they change over time and evolve. Evolution can change models in two ways: (1) by making design decisions and adding, deleting or changing model elements, or (2) by reusing models in different tools. We propose support for both aspects of model evolution. (1) When models are changed, the design decisions and the justification for the change are usually neither captured nor documented in a systematic way. As a result, important information about the model is lost, making the model more difficult to understand, which hampers model evolution and maintenance. To support model evolution, design decisions need to be captured explicitly using an appropriate representation. This representation reduces the overhead of capturing design decisions, keeps the model and the design decision documentation consistent and links the design decision documentation to the model. As a result, the captured design decisions provide a record of the model evolution and the rationale of the evolution. (2) Several models and views are used to describe an embedded system in different life cycle stages and from the viewpoints of the involved disciplines. To create the various models, a number of specialized development tools are used. These tools are usually disconnected, so the models cannot be transferred between different tools. Thus, models may become inconsistent, which hampers understandability of the models and increases the cost of development. We present a model-based tool integration approach that uses a common metamodel in combination with model transformation technology to build bridges between different development tools. We apply this approach in a case study and integrate several tools for automotive embedded systems development: A systems engineering tool, a safety engineering tool and a simulation tool. As a part of future work, we plan to extend the tool integration approach to exchange not only models but also the attached documentation of design decisions. As a result, the design decision documentation is linked consistently to corresponding model elements of the various tool-specific models, supporting model evolution across several development toolsQC 20101209
20
Adesina, Opeyemi. "Integrating Formal Methods with Model-Driven Engineering." Thesis, Université d'Ottawa / University of Ottawa, 2017. http://hdl.handle.net/10393/36269.
Full textAbstract:
This thesis presents our method to integrate formal methods with model-driven engineering. Although a large amount of literature exists with the goal of facilitating the adoption of formal methods for educational and industrial practice, yet the adoption of formal methods in academia and industry is poor. The goal of this research is to improve the adoption of formal methods by automating the generation of formal methods code while maintaining scalability and bridging the gaps between formal analysis and actual implementation of the complete system.
Our approach is based on generating formal representations of software abstractions expressed in a textual language, called Umple, which is derived from UML. Software abstractions of interest include class models and state machines. For state machines, we address concerns such as composite and concurrent states separately. The resulting systems are analyzable by back-end analysis engines such as Alloy and nuXmv or NuSMV for model checking.
To ensure correctness of our approach, we have adopted simulation, empirical studies and rigorous test-driven development (TDD) methodologies. To guarantee correctness of state machine systems under analysis (SSUAs), we present methods to automatically generate specifications to analyze domain-independent properties such as non-determinism and reachability analysis. We apply these methods in various case studies; certify their conformance with sets of requirements and uncover certain flaws.
Our contributions include a) The overall approach, involving having the developer write the system in Umple and generating both the formal system for analysis and the final code from the same model; b) a novel approach to encode SSUAs even in the presence of and-cross transitions; c) a fully automated approach to certify an SSUA to be free from nondeterminism even in the presence of unbounded domains and multiple and-cross transitions within the same enclosing orthogonal state; d) an empirical study of the impact of abstraction on some performance parameters; and e) a translator from Umple to Alloy and SMV.
21
Hutchinson, John Edward. "An empirical assessment of model driven development in industry." Thesis, Lancaster University, 2011. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.658016.
Full textAbstract:
Model driven development (MDD) is one of a number of proposals for software development that promises a number of important benefits. As with any "new" approach, it would be expected that there would be proponents of the approach and those who are opposed to it. MDD has been surprisingly contentious, though, perhaps because it challenges the code-centric model of software development (which therefore challenges the natural approach of those who develop software). But it remains the case that stories abound about significant successes resulting from using MDD in industry, and at the same time, detractors claim that MDD is inherently wrong - it is an abstraction too far: the cost of raising the level of abstraction from code to models can only ever result in an increase of costs or effort that can never be recovered. This thesis reports on work that has attempted to uncover the truth in this area in a way that has never been applied on a large-scale to MDD-based software development in industry. By going to industry practitioners, via a widely completed questionnaire and a number of in-depth interviews, it reports on what real software developers are doing in real companies. The results should lay to rest the belief that "MDD doesn't work" - apparently, it does. Companies around the world are using MDD in a variety of settings and are reporting significant benefits from its use. However, there is a subtle balance of potentially positive and potentially negative impacts of MDD use which successful users in industry prove able to manage, so that they are able to take advantages of the benefits rather than being dogged by the negatives.
22
Konrad, Sascha J. "Model-driven development and analysis of high assurance systems." Diss., Connect to online resource - MSU authorized users, 2006.
Find full text
23
Brumbulli, Mihal. "Model-driven development and simulation of distributed communication systems." Doctoral thesis, Humboldt-Universität zu Berlin, Mathematisch-Naturwissenschaftliche Fakultät II, 2015. http://dx.doi.org/10.18452/17233.
Full textAbstract:
Verteilte Kommunikationssysteme haben in den letzten Jahren enorm an Bedeutung gewonnen, insbesondere durch die Vielzahl von Anwendungen in unserem Alltag. Die Heterogenität der Anwendungen und Anwendungsdomänen spricht für die Komplexität solcher Systeme und verdeutlicht die Herausforderungen, mit denen ihre Entwickler konfrontiert sind. Der Schwerpunkt dieser Arbeit liegt auf der Unterstützung des Entwicklungsprozesses von Anwendungen für verteilte Kommunikationssysteme. Es gibt zwei Aspekte, die dabei berücksichtigt werden müssen. Der erste und offensichtlichste ist die Unterstützung der Entwicklung der Anwendung selbst, die letztendlich auf der vorhandenen verteilten Kommunikationsinfrastruktur bereitgestellt werden soll. Der zweite weniger offensichtliche, aber genauso wichtige Aspekt besteht in der Analyse der Anwendung vor ihrer eigentlichen Installation. Anwendungsentwicklung und analyse sind also "zwei Seiten der gleichen Medaille". Durch die Berücksichtigung beider Aspekt erhöht sich jedoch andererseits der Aufwand bei der Entwicklung. Die Arbeit kombiniert und erweitert vorhandene Technologien entsprechend dem modellgetriebenen Entwicklungsparadigma zu einer einheitlichen Entwicklungsmethode. Die Eigenschaften der Anwendung werden in einer vereinheitlichten Beschreibung erfasst, welche sowohl die automatische Überführung in Installationen auf echten Infrastrukturen erlaubt, als auch die Analyse auf der Basis von Modellen. Darüber hinaus wird der Entwicklungsprozess mit zusätzlicher Unterstützung bei der Visualisierung der Analyse ergänzt. Die Praktikabilität des Ansatzes wird anschließend anhand der Entwicklung und Analyse einer Anwendung zur Erdbebenfrühwarnung unter Beweis gestellt.Distributed communication systems have gained a substantial importance over the past years with a large set of examples of systems that are present in our everyday life. The heterogeneity of applications and application domains speaks for the complexity of such systems and the challenges that developers are faced with. The focus of this dissertation is on the development of applications for distributed communication systems. There are two aspects that need to be considered during application development. The first and most obvious is the development of the application itself that will be deployed on the existing distributed communication infrastructure. The second and less obvious, but equally important, is the analysis of the deployed application. Application development and analysis are like "two sides of the the same coin". However, the separation between the two increases the cost and effort required during the development process. Existing technologies are combined and extended following the model-driven development paradigm to obtain a unified development method. The properties of the application are captured in a unified description which drives automatic transformation for deployment on real infrastructures and/or analysis. Furthermore, the development process is complemented with additional support for visualization to aid analysis. The defined approach is then used in the development of an alarming application for earthquake early warning.
24
Ramaswamy, Arunkumar. "A model-driven framework development methodology for robotic systems." Thesis, Université Paris-Saclay (ComUE), 2017. http://www.theses.fr/2017SACLY011/document.
Full textAbstract:
La plupart des applications robotiques, telles que les véhicules autonomes, sont développées à partir d’une page blanche avec quelques rares réutilisations de conceptions ou de codes issus d’anciens projets équivalents. Qui plus est, les systèmes robotiques deviennent de plus en plus critiques, dans la mesure où ils sont déployés dans des environnements peu structurés, et centrés sur l’humain. Ces systèmes à fort contenu logiciel qui utilisent des composants distribués et hétérogènes interagissent dans un environnement dynamique, et incertain. Or, il s’agit là d’étapes indispensables pour la mise en place de méthodes d’évaluation extensibles, ainsi que pour permettre la réutilisation de composants logiciels pré-existants. Le développement de structures logicielles et d’outils de conception d’architectures, orientés pour la robotique, coûte cher en termes de temps et d’effort, et l’absence d’une approche systématique pourrait conduire à la production de conceptions adhoc, peu flexibles et peu réutilisables. Faire de la meta-structure de l’architecture un point de convergence offre de nouvelles possibilités en termes d’interopérabilité, et de partage de la connaissance, au sein des communautés dédiées à la mise en place d’architectures et de structures. Nous suivons cette direction, en proposant un modèle commun, et en fournissant une approche méthodologique systématique aidant à spécifier les différents aspects du développement d’architectures logicielles, et leurs relations au sein d’une structure partagéeMost innovative applications having robotic capabilities like self-driving cars are developed from scratch with little reuse of design or code artifacts from previous similar projects. As a result, work at times is duplicated adding time and economic costs. Absence of integrated tools is the real barrier that exists between early adopters of standardization efforts and early majority of research and industrial community. These software intensive systems are composed of distributed, heterogeneous software components interacting in a highly dynamic, uncertain environment. However, no significant systematic software development process is followed in robotics research. The process of developing robotic software frameworks and tools for designing robotic architectures is expensive both in terms of time and effort, and absence of systematic approach may result in ad hoc designs that are not flexible and reusable. Making architecture meta-framework a point of conformance opens new possibilities for interoperability and knowledge sharing in the architecture and framework communities. We tried to make a step in this direction by proposing a common model and by providing a systematic methodological approach that helps in specifying different aspects of software architecture development and their interplay in a framework
25
Abeti, Luca. "Business-oriented model driven development of service oriented architectures." Thesis, IMT Alti Studi Lucca, 2009. http://e-theses.imtlucca.it/18/1/Abeti_phdthesis.pdf.
Full textAbstract:
Context & motivation: The success in the adoption of innovative technologies and new software systems inside an organization is related not only to technical problems. Several authors pointed out the importance of business modelling in software development in order to understand for instance: how the organizational environment relates to its software infrastructure and how the development of a new software-intensive service for a company implies changes in the company business and in its processes. The growing complexity of organizations, such as: networked and information-dependent companies; globalization of the companies structures; evanescent services provided by companies, increase the uncertainty in software projects. Software engineering successes in turn became more and more bounded to the understanding of the organizational assets and their relation to the software. Question/problem: How can we model the business in requirements engineering phases and, at the same time, enable business-level concepts (such as strategies, goals, trust, etc.) to relate to system-level artifacts? Principal ideas/results: Our aim is to define a framework that helps software engineers to develop their systems in what we named the business-oriented approach. The business-oriented approach to software development has been defined as an approach
that carefully consider the processes, actors and goal
of the business in developing a software system and also analyzes the changes that the software will cause to the organization itself. In order to define such a framework we exploit model driven engineering that helps in managing high level abstractions for the software. In particular, our work relies on the service architectural paradigm that is particularly suitable in modeling socio-technical systems. Contribution: In order to define our framework we define: a method; a framework of technologies and a set of tools. Our method, named the Enterprise-Service-Implementation (ESI), starts from the requirements of the organization and the system, it derives a platform independent service model that can be in turn transformed into platform specific implementations. ESI exploits the service concept as an intermediate abstraction. Model driven technologies help us to translate concepts from the business domain, such as goals, into services concretely bounded to a specific implementation platform. A framework of technologies and languages helps us to implement the ESI method. We exploit and combine: a goaloriented language named Si*; UML Use Cases and a business process modeling language named Buiness Process Modeling Notation (BPMN), in order to model the business from different perspectives. We develop two tools to put into practice our framework. TheWiki Requirements tool (WikiReq) is a collaborative
system and business requirements management Web application based on a wiki. WikiReq uses semantic wiki features
for requirements gathering and management and is able
to export semantically annotated knowledge to the Eclipse Integrated Development Environment (IDE). The Service Modeling Tool for Eclipse (SMOTE) is an Eclipse IDE application that exploits the Eclipse model driven architecture in order to perform the models transformations needed in our framework. We present a case studio where we experienced our framework in the challenging domain of Civil Protection. We present first results on the adoption of our approach concerning both the stakeholders experience and quantitative data.
26
Jayatilleke, Gaya Buddhinath, and buddhinath@gmail com. "A Model Driven Component Agent Framework for Domain Experts." RMIT University. Computer Science and Information Technology, 2007. http://adt.lib.rmit.edu.au/adt/public/adt-VIT20080222.162529.
Full textAbstract:
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.
27
Grammel, Birgit. "Automatic Generation of Trace Links in Model-driven Software Development." Doctoral thesis, Saechsische Landesbibliothek- Staats- und Universitaetsbibliothek Dresden, 2014. http://nbn-resolving.de/urn:nbn:de:bsz:14-qucosa-155839.
Full textAbstract:
Traceability data provides the knowledge on dependencies and logical relations existing amongst artefacts that are created during software development. In reasoning over traceability data, conclusions can be drawn to increase the quality of software.
The paradigm of Model-driven Software Engineering (MDSD) promotes the generation of software out of models. The latter are specified through different modelling languages. In subsequent model transformations, these models are used to generate programming code automatically. Traceability data of the involved artefacts in a MDSD process can be used to increase the software quality in providing the necessary knowledge as described above.
Existing traceability solutions in MDSD are based on the integral model mapping of transformation execution to generate traceability data. Yet, these solutions still entail a wide range of open challenges. One challenge is that the collected traceability data does not adhere to a unified formal definition, which leads to poorly integrated traceability data. This aggravates the reasoning over traceability data. Furthermore, these traceability solutions all depend on the existence of a transformation engine.
However, not in all cases pertaining to MDSD can a transformation engine be accessed, while taking into account proprietary transformation engines, or manually implemented transformations. In these cases it is not possible to instrument the transformation engine for the sake of generating traceability data, resulting in a lack of traceability data.
In this work, we address these shortcomings. In doing so, we propose a generic traceability framework for augmenting arbitrary transformation approaches with a traceability mechanism. To integrate traceability data from different transformation approaches, our approach features a methodology for augmentation possibilities based on a design pattern. The design pattern supplies the engineer with recommendations for designing the traceability mechanism and for modelling traceability data.
Additionally, to provide a traceability mechanism for inaccessible transformation engines, we leverage parallel model matching to generate traceability data for arbitrary source and target models. This approach is based on a language-agnostic concept of three similarity measures for matching. To realise the similarity measures, we exploit metamodel matching techniques for graph-based model matching. Finally, we evaluate our approach according to a set of transformations from an SAP business application and the domain of MDSD.
28
Safie, Lily Suryani Binti. "A software component model that is both control-driven and data-driven." Thesis, University of Manchester, 2012. https://www.research.manchester.ac.uk/portal/en/theses/a-software-component-model-that-is-both-controldriven-and-datadriven(ce21c34b-7257-4b8f-aa79-f6456b49a3a0).html.
Full textAbstract:
A software component model is the cornerstone of any Component-based Software Development (CBSD) methodology. Such a model defines the modelling elements for constructing software systems. In software system modelling, it is necessary to capture the three elements of a system's behaviour: (i) control (ii) computation and (iii) data. Within a system, computations are performed according to the flow of control or the flow of data, depending on whether computations are control-driven or data-driven. Computations are function evaluations, assignments, etc., which transform data when invoked by control or data flow. Therefore a component model should be able to model control flow, data flow as well as computations. Current component models all model computations, but beside computations tend to model either control flow only or data flow only, but not both. In this thesis, we present a new component model which can model both control flow and data flow. It contains modelling elements that capture control flow and data flow explicitly. Furthermore, the modelling of control flow is separate from that of data flow; this enables the modelling of both control-driven and data-driven computations. The feasibility of the model is shown by means of an implementation of the model, in the form of a prototype tool. The usefulness of the model is then demonstrated for a specific domain, the embedded systems domain, as well as a generic domain. For the embedded systems domain, unlike current models, our model can be used to construct systems that are both control-driven and data-driven. In a generic domain, our model can be used to construct domain models, by constructing control flows and data flows which together define a domain model.
29
Fatolahi, Ali. "An Abstract Meta-model for Model Driven Development of Web Applications Targeting Multiple Platforms." Thèse, Université d'Ottawa / University of Ottawa, 2012. http://hdl.handle.net/10393/23262.
Full textAbstract:
In this thesis, we present an abstract meta-model for model driven development of web applications targeting multiple platforms. We review the existing technologies and the related work in order to obtain a list of requirements for such an abstract model. The abstract model is built by extending an existing UML-based model for web applications. We demonstrate that it is possible to map this abstract model to more than one specific development platform by providing transformations for these mappings. We also lay out the general outline of a model-driven process based on the proposed abstract model. The abstract model and the model-driven process are supported by a set of tools, case studies and a visual modeling notation. Model-driven techniques have been used in the area of web development to a great extent. Most of the existing approaches are tuned toward specific platforms or develop only certain parts of web applications. These approaches generally use meta-models adapted to their targeted platforms. In order to flexibly target multiple platforms, the level of abstraction of the meta-model must be raised. Such a meta-model must allow the description of relevant features of web applications independently from the specificities of specific platforms. Additionally, transformations mapping from abstract to specific web descriptions must be expressible in a flexible way. In this thesis, we propose such an abstract meta-model. Mappings that transform abstract models to specific platforms are also presented. Different benefits can be foreseen from this approach. By relieving developers from low-level platform-specific related design, the approach has the potential to shift the development task to issues related to business needs. Another benefit is shortened development time. This could help web developers to overcome the problem of schedule delays, which is recognized as one of the top five most-cited problems with large-scale web systems. The approach is specifically suitable for information-intensive web-based systems. These applications typically involve large data stores accessed through a web interface. A distinctive aspect of this approach is its use of a specification of the data mapping as part of its high-level input. More importantly, the common features required to process data and communicate data objects between different layers and components are targeted.
30
Koksal, Algin Ceren Fatma. "Ontology Driven Development For Hla Federates." Master's thesis, METU, 2010. http://etd.lib.metu.edu.tr/upload/3/12611943/index.pdf.
Full textAbstract:
This thesis puts forth a process for ontology driven distributed simulation through a case
study. Ontology is regarded as a domain model, including objects, attributes, methods and
object relations. The case study involves trajectory simulation. A trajectory simulation is a
piece of software that calculates the flight path and other parameters of a munition, such as
its orientation and angular rates, from launch to impact. Formal specification of trajectory
simulation domain is available as a domain model in the form of an ontology, called
Trajectory Simulation ONTology (TSONT). Ontology driven federation development
process proposed in this thesis is executed in three steps. The first step is to analyze the
TSONT and to create instances of individuals guided by the requirements of the targeted
simulation application, called Puma Trajectory Simulation. Puma is the simulation of a
ficticious air-to-ground guided bomb. The second step is to create the High Level
Architecture(HLA) Federation Object Model (FOM) using Puma Simulation individuals.
FOM will include the required object and interaction definitions to enable information
exchange among federation members, including the Puma federate and the Exercise
Manager federate. Transformation from the ontology to FOM is realized in two ways:
manually, and by using a tool called OWL2OMT. The third step is to implement the
Trajectory Simulation federation based on the constructed FOM. Thus, the applicability of
developing HLA federates and the federation under the guidance of ontology is
demonstrated.
31
Hebig, Regina. "Evolution of model-driven engineering settings in practice." Phd thesis, Universität Potsdam, 2014. http://opus.kobv.de/ubp/volltexte/2014/7076/.
Full textAbstract:
Nowadays, software systems are getting more and more complex. To tackle this challenge most diverse techniques, such as design patterns, service oriented architectures (SOA), software development processes, and model-driven engineering (MDE), are used to improve productivity, while time to market and quality of the products stay stable. Multiple of these techniques are used in parallel to profit from their benefits. While the use of sophisticated software development processes is standard, today, MDE is just adopted in practice.
However, research has shown that the application of MDE is not always successful. It is not fully understood when advantages of MDE can be used and to what degree MDE can also be disadvantageous for productivity. Further, when combining different techniques that aim to affect the same factor (e.g. productivity) the question arises whether these techniques really complement each other or, in contrast, compensate their effects. Due to that, there is the concrete question how MDE and other techniques, such as software development process, are interrelated. Both aspects (advantages and disadvantages for productivity as well as the interrelation to other techniques) need to be understood to identify risks relating to the productivity impact of MDE.
Before studying MDE's impact on productivity, it is necessary to investigate the range of validity that can be reached for the results. This includes two questions. First, there is the question whether MDE's impact on productivity is similar for all approaches of adopting MDE in practice. Second, there is the question whether MDE's impact on productivity for an approach of using MDE in practice remains stable over time. The answers for both questions are crucial for handling risks of MDE, but also for the design of future studies on MDE success.
This thesis addresses these questions with the goal to support adoption of MDE in future. To enable a differentiated discussion about MDE, the term MDE setting'' is introduced. MDE setting refers to the applied technical setting, i.e. the employed manual and automated activities, artifacts, languages, and tools. An MDE setting's possible impact on productivity is studied with a focus on changeability and the interrelation to software development processes. This is done by introducing a taxonomy of changeability concerns that might be affected by an MDE setting. Further, three MDE traits are identified and it is studied for which manifestations of these MDE traits software development processes are impacted. To enable the assessment and evaluation of an MDE setting's impacts, the Software Manufacture Model language is introduced. This is a process modeling language that allows to reason about how relations between (modeling) artifacts (e.g. models or code files) change during application of manual or automated development activities. On that basis, risk analysis techniques are provided. These techniques allow identifying changeability risks and assessing the manifestations of the MDE traits (and with it an MDE setting's impact on software development processes).
To address the range of validity, MDE settings from practice and their evolution histories were capture in context of this thesis. First, this data is used to show that MDE settings cover the whole spectrum concerning their impact on changeability or interrelation to software development processes. Neither it is seldom that MDE settings are neutral for processes nor is it seldom that MDE settings have impact on processes. Similarly, the impact on changeability differs relevantly. Second, a taxonomy of evolution of MDE settings is introduced. In that context it is discussed to what extent different types of changes on an MDE setting can influence this MDE setting's impact on changeability and the interrelation to processes. The category of structural evolution, which can change these characteristics of an MDE setting, is identified. The captured MDE settings from practice are used to show that structural evolution exists and is common. In addition, some examples of structural evolution steps are collected that actually led to a change in the characteristics of the respective MDE settings. Two implications are: First, the assessed diversity of MDE settings evaluates the need for the analysis techniques that shall be presented in this thesis. Second, evolution is one explanation for the diversity of MDE settings in practice.
To summarize, this thesis studies the nature and evolution of MDE settings in practice. As a result support for the adoption of MDE settings is provided in form of techniques for the identification of risks relating to productivity impacts.Um die steigende Komplexität von Softwaresystemen beherrschen zu können, werden heutzutage unterschiedlichste Techniken gemeinsam eingesetzt. Beispiele sind, Design Pattern, Serviceorientierte Architekturen, Softwareentwicklungsprozesse oder modellgetriebene Entwicklung (MDE). Ziel dabei ist die Erhöhung der Produktivität, so dass Entwicklungsdauer und Qualität stabil bleiben können. Während hoch entwickelte Softwareentwicklungsprozesse heute schon standardmäßig genutzt werden, fangen Firmen gerade erst an MDE einzusetzen. Jedoch zeigen Studien, dass der erhoffte Erfolg von MDE nicht jedes Mal eintritt. So scheint es, dass noch kein ausreichendes Verständnis dafür existiert, inwiefern MDE auch Nachteile für die Produktivität bergen kann. Zusätzlich ist bei der Kombination von unterschiedlichen Techniken damit zu rechnen, dass die erreichten Effekte sich gegenseitig negieren anstatt sich zu ergänzen. Hier entsteht die Frage wie MDE und andere Techniken, wie Softwareentwicklungsprozesse, zusammenwirken. Beide Aspekte, der direkte Einfluss auf Produktivität und die Wechselwirkung mit anderen Techniken, müssen aber verstanden werden um den Risiken für den Produktivitätseinfluss von MDE zu identifizieren. Außerdem, muss auch die Generalisierbarkeit dieser Aspekte untersucht werden. Das betrifft die Fragen, ob der Produktivitätseinfluss bei jedem Einsatz von MDE gleich ist und ob der Produktivitätseinfluss über die Zeit stabil bleibt. Beide Fragen sind entscheidend, will man geeignete Risikobehandlung ermöglichen oder künftige Studien zum Erfolg von MDE planen. Diese Dissertation widmet sich der genannten Fragen. Dafür wird zuerst der Begriff MDE Setting'' eingeführt um eine differenzierte Betrachtung von MDE-Verwendungen zu ermöglichen. Ein MDE Setting ist dabei der technische Aufbau, inklusive manueller und automatische Aktivitäten, Artefakten, Sprachen und Werkzeugen. Welche Produktivitätseinflüsse von MDE Settings möglich sind, wird in der Dissertation mit Fokus auf Änderbarkeit und die Wechselwirkung mit Softwareentwicklungsprozessen betrachtet. Dafür wird einerseits eine Taxonomie von Changeability Concerns'' (potentiell betroffene Aspekte von Änderbarkeit) vorgestellt. Zusätzlich, werden drei MDE Traits'' (Charakteristika von MDE Settings die unterschiedlich ausgeprägt sein können) identifiziert. Es wird untersucht welche Ausprägungen dieser MDE Traits Einfluss auf Softwareentwicklungsprozesse haben können. Um die Erfassung und Bewertung dieser Einflüsse zu ermöglichen wird die Software Manufaktur Modell Sprache eingeführt. Diese Prozessmodellierungssprache ermöglicht eine Beschreibung, der Veränderungen von Artefaktbeziehungen während der Anwendung von Aktivitäten (z.B. Codegenerierung). Weiter werden auf Basis dieser Modelle, Analysetechniken eingeführt. Diese Analysetechniken erlauben es Risiken für bestimmte Changeability Concerns aufzudecken sowie die Ausprägung von MDE Traits zu erfassen (und damit den Einfluss auf Softwareentwicklungsprozesse). Um die Generalisierbarkeit der Ergebnisse zu studieren, wurden im Rahmen der Arbeit mehrere MDE Settings aus der Praxis sowie teilweise deren Evolutionshistorien erhoben. Daran wird gezeigt, dass MDE Settings sich in einem breiten Spektrum von Einflüssen auf Änderbarkeit und Prozesse bewegen. So ist es weder selten, dass ein MDE Setting neutral für Prozesse ist, noch, dass ein MDE Setting Einschränkungen für einen Prozess impliziert. Ähnlich breit gestreut ist der Einfluss auf die Änderbarkeit.Zusätzlich, wird diskutiert, inwiefern unterschiedliche Evolutionstypen den Einfluss eines MDE Settings auf Änderbarkeit und Prozesse verändern können. Diese Diskussion führt zur Identifikation der strukturellen Evolution'', die sich stark auf die genannten Charakteristika eines MDE Settings auswirken kann. Mithilfe der erfassten MDE Settings, wird gezeigt, dass strukturelle Evolution in der Praxis üblich ist. Schließlich, werden Beispiele aufgedeckt bei denen strukturelle Evolutionsschritte tatsächlich zu einer Änderung der Charakteristika des betreffenden MDE Settings geführt haben. Einerseits bestärkt die ermittelte Vielfalt den Bedarf nach Analysetechniken, wie sie in dieser Dissertation eingeführt werden. Zum Anderen erscheint es nun, dass Evolution zumindest zum Teil die unterschiedlichen Ausprägungen von MDE Settings erklärt. Zusammenfassend wird studiert wie MDE Settings und deren Evolution in der Praxis ausgeprägt sind. Als Ergebnis, werden Techniken zur Identifikation von Risiken für Produktivitätseinflüsse bereitgestellt um den Einsatz von MDE Settings zu unterstützen.
32
Hoisl, Bernhard, and Mark Strembeck. "A UML Extension for the Model-driven Specification of Audit Rules." Springer, 2012. http://epub.wu.ac.at/3820/1/paper2.pdf.
Full textAbstract:
In recent years, a number of laws and regulations (such as
the Basel II accord or SOX) demand that organizations record certain
activities or decisions to fulfill legally enforced reporting duties. Most of
these regulations have a direct impact on the information systems that
support an organization's business processes. Therefore, the definition of
audit requirements at the modeling-level is an important prerequisite for
the thorough implementation and enforcement of corresponding policies
in a software system. In this paper, we present a UML extension for the
specification of audit properties. The extension is generic and can be applied
to a wide variety of UML elements. In a model-driven development
(MDD) approach, our extension can be used to generate corresponding
audit rules via model transformations. (author's abstract)
33
Vitorino, dos Santos Filho Jairson. "CHROME: a model-driven component-based rule engine." Universidade Federal de Pernambuco, 2009. https://repositorio.ufpe.br/handle/123456789/1638.
Full textAbstract:
Made available in DSpace on 2014-06-12T15:51:39Z (GMT). No. of bitstreams: 2
arquivo2757_1.pdf: 5759741 bytes, checksum: 8075c58c36a6d409b242f2a7873fb02f (MD5)
license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5)
Previous issue date: 2009Coordenação de Aperfeiçoamento de Pessoal de Nível Superior
Vitorino dos Santos Filho, Jairson; Pierre Louis Robin, Jacques. CHROME: a model-driven component-based rule engine. 2009. Tese (Doutorado). Programa de Pós-Graduação em Ciência da Computação, Universidade Federal de Pernambuco, Recife, 2009.
34
Burger, Erik [Verfasser]. "Flexible Views for View-based Model-driven Development / Erik Burger." Karlsruhe : KIT Scientific Publishing, 2014. http://www.ksp.kit.edu.
Full text
35
Provost, Marc 1981. "Himesis : a hierarchical subgraph matching kernel for model driven development." Thesis, McGill University, 2005. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=98772.
Full textAbstract:
Himesis is a complete yet minimal kernel for meta-modelling and model transformation, which consists of a specification of hierarchical graphs and in a highly efficient matching algorithm. Himesis graphs encode the essence of models: nodes, edges, containment, attributes, names and labels. There is a defined set of events which transform the graphs. Above all Himesis introduces an explicit notion of hierarchy, which allows the specification of formalisms which were very hard to meta-model in the past, such as graph grammars. Moreover, with containment, it is possible to couple and reuse existing formalisms.Himesis implements HVF, a new matching algorithm based on the VF2 approach. HVF extends VF2 with hierarchy and with several optimization strategies. It was designed to support advanced features that are required for graph rewriting, such as matching from a context as well as negative application conditions. We show that HVF is a faster algorithm than VF2 for matching of flat graphs. HVF is particularly efficient when matching irregular graphs.
36
Kyaw, Phyo. "Attribute based component design : supporting model driven development in CbSE." Thesis, Durham University, 2007. http://etheses.dur.ac.uk/2338/.
Full textAbstract:
In analysing the evolution of Software Engineering, the scale of the components has increased, the requirements for different domains become complex and a variety of different component frameworks and their associated models have emerged. Many modern component frameworks provide enterprise level facilities and services, such as instance management, and component container support, that allow developers to apply if needed to manage scale and complexity. Although the services provided by these frameworks are common, they have different models and implementation. Accordingly, the main problem is, when developing a component based application using a component framework, the design of the components becomes tightly integrated with the framework implementation and the framework model is embedded in the component functionality, and hence reduces reusability. Another problem arose is, the designers must have in-depth knowledge of the implementation of a component framework to be able to model, design and implement the components and take advantages of the services provided. To address these problems, this research proposes the Attribute based Component Design (AbCD) approach which allows developers to model software using logical and abstract components at the specification level. The components encapsulate the provided functionality, as well as the required services, runtime requirements and interaction models using a set of attributes. These attributes are systemically derived by grouping common features and services from light weight component frameworks and heavy weight component frameworks that are available in the literature. The AbCD approach consists of the AbCD Meta-model, which is an extension of the บML meta-model, and the Component Design Guidelines (CDG) that includes core Component based Software Engineering principles to assist the modelling process for designers. To support the AbCD approach, an implementation has been developed as a set of plug-ins, called the AbCD tool suite, for Eclipse IDE. An evaluation of the AbCD approach is conducted by using the tool suite with two case studies. The first case study focuses on abstraction achieved by the AbCD approach and the second focuses on reusability of the components. The evaluation shows that the artefacts produced using the approach provide an alternative architectural view to the design and help to re-factor the design based on aspects. At the same time the evaluation process identified possible improvements in the AbCD meta-model and the tool suite constructed. This research provides a non-invasive approach for designing component based software using model driven development.
37
Jedryszek, Jakub. "A model-driven development and verification approach for medical devices." Thesis, Kansas State University, 2014. http://hdl.handle.net/2097/18222.
Full textAbstract:
Master of ScienceDepartment of Computing and Information Sciences
John Hatcliff
Medical devices are safety-critical systems whose failure may put human life in danger. They are becoming more advanced and thus more complex. This leads to bigger and more complicated code-bases that are hard to maintain and verify. Model-driven development provides high-level and abstract description of the system in the form of models that omit details, which are not relevant during the design phase. This allows for certain types of verification and hazard analysis to be performed on the models. These models can then be translated into code. However, errors that do not exist in the models may be introduced during the implementation phase. Automated translation from verified models to code may prevent to some extent. This thesis proposes approach for model-driven development and verification of medical devices. Models are created in AADL (Architecture Analysis & Design Language), a language for software and hardware architecture modeling. AADL models are translated to SPARK Ada, contract-based programming language, which is suitable for software verification. Generated code base is further extended by developers to implement internals of specific devices. Created programs can be verified using SPARK tools. A PCA (Patient Controlled Analgesia) pump medical device is used to illustrate the primary artifacts and process steps. The foundation for this work is "Integrated Clinical Environment Patient-Controlled Analgesia Infusion Pump System Requirements" document and AADL Models created by Brian Larson. In addition to proposed model-driven development approach, a PCA pump prototype was created using the BeagleBoard-xM device as a platform. Some components of PCA pump prototype were verified by SPARK tools and Bakar Kiasan.
38
Fernández, Martínez Adrián. "A Usability Inspection Method for Model-driven Web Development Processes." Doctoral thesis, Universitat Politècnica de València, 2012. http://hdl.handle.net/10251/17845.
Full textAbstract:
Las aplicaciones Web son consideradas actualmente un elemento esencial e indispensable en toda actividad empresarial, intercambio de información y motor de redes sociales. La usabilidad, en este tipo de aplicaciones, es reconocida como uno de los factores clave más importantes, puesto que la facilidad o dificultad que los usuarios experimentan con estas aplicaciones determinan en gran medida su éxito o fracaso. Sin embargo, existen varias limitaciones en las propuestas actuales de evaluación de usabilidad Web, tales como: el concepto de usabilidad sólo se soporta parcialmente, las evaluaciones de usabilidad se realizan principalmente cuando la aplicación Web se ha desarrollado, hay una carencia de guías sobre cómo integrar adecuadamente la usabilidad en el desarrollo Web, y también existe una carencia de métodos de evaluación de la usabilidad Web que hayan sido validados empíricamente. Además, la mayoría de los procesos de desarrollo Web no aprovechan los artefactos producidos en las fases de diseño. Estos artefactos software intermedios se utilizan principalmente para guiar a los desarrolladores y para documentar la aplicación Web, pero no para realizar evaluaciones de usabilidad. Dado que la trazabilidad entre estos artefactos y la aplicación Web final no está bien definida, la realización de evaluaciones de usabilidad de estos artefactos resulta difícil. Este problema se mitiga en el desarrollo Web dirigido por modelos (DWDM), donde los artefactos intermedios (modelos) que representan diferentes perspectivas de una aplicación Web, se utilizan en todas las etapas del proceso de desarrollo, y el código fuente final se genera automáticamente a partir estos modelos. Al tener en cuenta la trazabilidad entre estos modelos, la evaluación de estos modelos permite detectar problemas de usabilidad que experimentaran los usuarios finales de la aplicación Web final, y proveer recomendaciones para corregir estos problemas de usabilidad durante fases tempranas del proceso de desarrollo Web.
Esta tesis tiene como objetivo, tratando las anteriores limitaciones detectadas, el proponer un método de inspección de usabilidad que se puede integrar en diferentes procesos de desarrollo Web dirigido por modelos. El método se compone de un modelo de usabilidad Web que descompone el concepto de usabilidad en sub-características, atributos y métricas genéricas, y un proceso de evaluación de usabilidad Web (WUEP), que proporciona directrices sobre cómo el modelo de usabilidad se puede utilizar para llevar a cabo evaluaciones específicas. Las métricas genéricas del modelo de usabilidad deben operacionalizarse con el fin de ser aplicables a los artefactos software de diferentes métodos de desarrollo Web y en diferentes niveles de abstracción, lo que permite evaluar la usabilidad en varias etapas del proceso de desarrollo Web, especialmente en las etapas tempranas. Tanto el modelo de usabilidad como el proceso de evaluación están alineados con la última norma ISO/IEC 25000 estándar para la evaluación de la calidad de productos de software (SQuaRE).
El método de inspección de usabilidad propuesto (WUEP) se ha instanciado en dos procesos de desarrollo Web dirigido por modelos diferentes (OO-H y WebML) a fin de demostrar la factibilidad de nuestra propuesta. Además, WUEP fue validado empíricamente mediante la realización de una familia de experimentos en OO-H y un experimento controlado en WebML. El objetivo de nuestros estudios empíricos fue evaluar la efectividad, la eficiencia, facilidad de uso percibida y la satisfacción percibida de los participantes; cuando utilizaron WUEP en comparación con un método de inspección industrial ampliamente utilizado: La Evaluación Heurística (HE). El análisis estadístico y meta-análisis de los datos obtenidos por separado de cada experimento indicaron que WUEP es más eficaz y eficiente que HE en la detección de problemas de usabilidad. Los evaluadores también percibieron más satisfacción cuando se aplicaron WUEP, y lesFernández Martínez, A. (2012). A Usability Inspection Method for Model-driven Web Development Processes [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/17845
Palancia
39
Gomes, Andrigo, and Andreas Pettersson. "Market-Driven Requirements Engineering Process Model – MDREPM." Thesis, Blekinge Tekniska Högskola, Avdelningen för programvarusystem, 2007. http://urn.kb.se/resolve?urn=urn:nbn:se:bth-3533.
Full textAbstract:
Research findings in requirements engineering (RE) report that software organizations still struggle in establishing processes that lead to proper requirements handling. This leads to the acknowledgement that the adoption of good requirements engineering practices by industry is still not common. Although some initiatives have been made to spread the use of good practices of bespoke RE, the area of market-driven requirements engineering (MDRE) still lacks a contribution in that direction. MDRE is characterized by strong market and strategic orientation, which contrasts with the customer/development organization relationship of bespoke RE. This poses several challenges to software product organizations, such as the need for aligning development activities with organizational and product strategies. In an attempt to help these organizations to realize the benefits of MDRE, this Master Thesis presents the Market-Driven Requirements Engineering Process Model (MDREPM). MDREPM is both a collection of good practices in MDRE, and an assessment tool for organizations to get a snapshot of the current state of their MDRE practices. The assessment intends to reveal problem areas of organization’s requirements process, which can then be worked upon by introducing good practices described in the model. The thesis describes the motivation for creating MDREPM, both from an academia and industry perspectives. In addition, it describes the process of developing the model, from its creation through to its validation within academia and industry. As the series of three case studies conducted indicate, the MDREPM has been shown to be useful for industry practitioners. A unanimous opinion has been found as to the good coverage it provides of issues related to MDRE, and as to its usefulness for driving improvement efforts in requirements engineering.
40
Waldemarin, Ricardo Cacheta. "Suporte ao desenvolvimento e à integração de ontologias no domínio biomédico." Universidade de São Paulo, 2015. http://www.teses.usp.br/teses/disponiveis/95/95131/tde-18112015-100645/.
Full textAbstract:
O surgimento e o uso crescente de novas tecnologias têm levado à produção e armazenamento de grandes volumes de dados biomédicos. Tais dados são provenientes de diferentes técnicas, armazenados em formatos de representação diversos e utilizados por diferentes ferramentas. Esta heterogeneidade representa um empecilho ao maior uso desses dados em abordagens integrativas de pesquisa como, por exemplo, a biologia sistêmica. Neste cenário, artefatos de modelagem conceitual, tais como ontologias, têm sido utilizados para organizar e integrar dados heterogêneos de uma forma coerente. A OBO Foundry representa, atualmente, o maior esforço no desenvolvimento de ontologias biomédicas de forma colaborativa. Dentre as ontologias desenvolvidas pela OBO Foundry, destaca-se Ontologia de Relacionamentos (RO-OBO). A RO-OBO provê definições formais para um conjunto de relacionamentos de propósito geral utilizados nas ontologias biomédicas e busca promover a criação de ontologias mais corretas e integráveis. Um perfil UML foi proposto para representar formalmente o conjunto de conceitos e relacionamentos existentes na RO-OBO. Este perfil permite desenvolver modelos UML utilizando os conceitos presentes nesta ontologia, bem como torna possível o desenvolvimento de suporte à validação sintática dos modelos criados em relação a um conjunto de restrições formalmente definidas. Adicionalmente, percebe-se na literatura que o suporte à integração de modelos UML e ontologias OBO, em particular as ontologias representadas na linguagem OBO File Format, é limitado. Neste sentido, este trabalho teve como objetivo geral investigar o suporte ao desenvolvimento de ontologias biomédicas na linguagem UML. De forma específica, investigou-se o desenvolvimento de um editor gráfico, chamado OBO-RO Editor, para o suporte à construção de ontologias utilizando o perfil UML proposto, bem como a integração de ontologias desenvolvidas utilizando UML e ontologias desenvolvidas na linguagem OBO File Format. De forma a atingir nossos objetivos, uma arquitetura de referência foi definida e um processo de desenvolvimento orientado a modelos foi utilizado. A arquitetura definida é composta por uma série de artefatos inter-relacionados os quais são transformados (semi) automaticamente em código de aplicação, possibilitando a obtenção de ciclos de desenvolvimento mais rápidos e confiáveis. O OBO-RO Editor disponibiliza um conjunto de elementos gráficos de modelagem definidos a partir do perfil UML proposto, bem como provê mecanismos para a validação sintática (semi) automática de uma ontologia desenvolvida segundo as restrições definidas neste perfil. Adicionalmente, o OBO-RO Editor também provê suporte à integração de modelos UML a outras ontologias da OBO Foundry, permitindo o reuso e o desenvolvimento menos propenso a erros de ontologias no domínio biomédico.The development and increasing use of new technologies has resulted in the production and storage of a huge amount of biomedical data. These data are produced using different techniques, stored in different formats and consumed by different (software) tools. This heterogeneity hinders effective data usage in integrative research approaches, including systems biology. In this scenario, conceptual modeling artifacts, such as ontologies, have been used to organize and integrate heterogeneous data in a coherent manner. Nowadays, the OBO Foundry represents the most important effort for the collaborative development of ontologies in the biomedical domain. The OBO Relation Ontology (OBO-RO) can be considered one of the most relevant ontologies in the domain. This ontology provides formal definitions for a number of general purpose relationships used in biomedical ontologies, thus facilitating the integration of existing ontologies and the development of new ontologies in the domain. An UML profile has been proposed to formally define the different types of concepts and relationships provided by the OBO-RO. This profile enables the creation of UML models using such concepts and allows the development of support for the automatic validation of these models based on formal constraints. Additionally, the support for the integration between UML models and OBO ontologies, particularly ontologies represented using the OBO File Format, is limited. In this sense, this project aimed at investigating the support for the development of biomedical ontologies using UML. In particular, we investigated the development of a graphical editor, named OBO-RO Editor, to support ontology development using the proposed UML profile. Additionally, we also investigated the integration of ontologies developed using UML and ontologies developed using the OBO File Format. In order to achieve our goals, we have defined a reference architecture and a model-driven development process. The reference architecture consists of a number of related artifacts that are transformed to application code (semi) automatically. Such characteristic allowed us to obtain faster and more reliable development cycles. The OBO-RO Editor provides a number of graphical elements defined in the proposed UML profile for the modeling of biomedical ontologies and support the (semi) automatic syntactic validation of such ontologies against the contraints defined in the profile. Additionally, OBO-RO Editor also provides support for the integration of developed UML models and other OBO ontologies, allowing the reuse and the accurate development of biomedical ontologies.
41
Reda, Renas, and Yusuf Tözmal. "Model Driven Architecture : Test Metoder och Verktyg." Thesis, Blekinge Tekniska Högskola, Avdelningen för programvarusystem, 2006. http://urn.kb.se/resolve?urn=urn:nbn:se:bth-2519.
Full textAbstract:
This thesis describes methods and tools available to test products developed with Model Driven Architecture (MDA) frameworks. The purpose of the research presented in this thesis is to find appropriate methods and tools available to test products developed in an MDA compatible way in an industrial setting. To find appropriate methods and tools a literature study as well as a case study were conducted at Ericsson. The results of the case study show that there exist important criteria both from an MDA perspective and Ericsson’s own perspective. Based on the criteria a set of tools were evaluated and the results were that Pathfinder PathMATE in conjunction with Rational Software Architect were the most appropriate tools for Ericsson to use when testing their MDA application.
42
Prout, Adam. "Parameterized Code Generation From Template Semantics." Thesis, University of Waterloo, 2006. http://hdl.handle.net/10012/1027.
Full textAbstract:
We have developed a tool that can create a Java code generator for a behavioural modelling notation given only a description of the notation's semantics as a set of parameters. This description is based on template semantics, which has previously been used to describe a wide variety of notations. As a result, we have a technique for generating Java code for models written in any notation describable in template semantics. Since template semantics allows for models containing nondeterminism, we introduce mechanisms for eliminating this nondeterminism when generating code. We describe Java implementations of several template-semantics composition operators that have no natural Java representations and give some techniques for optimizing the generated code without sacrificing correctness. The efficiency of our generated code is comparable to that of commercial notation-specific code generators.
43
Brückmann, Tobias. "Model Driven Development and Maintenance of Business Logic for Information Systems." Doctoral thesis, Universitätsbibliothek Leipzig, 2011. http://nbn-resolving.de/urn:nbn:de:bsz:15-qucosa-64148.
Full textAbstract:
Since information systems become more and more important in today\'s society, business firms, organizations, and individuals rely on these systems to manage their daily business and social activities. The dependency of possibly critical business processes on complex IT systems requires a strategy that supports IT departments in reducing the time needed to implement changed or new domain requirements of functional departments. In this context, software models help to manage system\'s complexity and provide a tool for communication and documentation purposes. Moreover, software engineers tend to use automated software model processing such as code generation to improve development and maintenance processes. Particularly in the context of web-based information systems, a number of model driven approaches were developed. However, we believe that compared to the user interface layer and the persistency layer, there could be a better support of consistent approaches providing a suitable architecture for the consistent model driven development of business logic.
To ameliorate this situation, we developed an architectural blueprint consisting of meta models, tools, and a method support for model driven development and maintenance of business logic from analysis until system maintenance. This blueprint, which we call Amabulo infrastructure, consists of five layers and provides concepts and tools to set up and apply concrete infrastructures for model driven development projects. Modeling languages can be applied as needed. In this thesis we focus on business logic layers of J2EE applications. However, concrete code generation rules can be adapted easily for different target platforms.
After providing a high-level overview of our Amabulo infrastructure, we describe its layers in detail: The Visual Model Layer is responsible for all visual modeling tasks. For this purpose, we discuss requirements for visual software models for business logic, analyze several visual modeling languages concerning their usefulness, and provide an UML profile for business logic models.
The Abstract Model Layer provides an abstract view on the business logic model in the form of a domain specific model, which we call Amabulo model. An Amabulo model is reduced to pure logical information concerning business logic aspects. It focuses on information that is relevant for the code generation. For this purpose, an Amabulo model integrates model elements for process modeling, state modeling, and structural modeling. It is used as a common interface between visual modeling languages and code generators. Visual models of the Visual Model Layer are automatically transformed into an Amabulo model.
The Abstract System Layer provides a formal view onto the system in the form of a Coloured Petri Net (CPN). A Coloured Petri Net representation of the modeled business logic is a formal structure and independent of the actual business logic implementation. After an Amabulo model is automatically transformed into a CPN, it can be analyzed and simulated before any line of code is generated.
The Code Generation Layer is responsible for code generation. To support the design and implementation of project-specific code generators, we discuss several aspects of code integration issues and provide object-oriented design approaches to tackle the issues. Then, we provide a conceptual mapping of Amabulo model elements into architectural elements of a J2EE infrastructure. This mapping explicitly considers robustness features, which support a later manual integration of generated critical code artifacts and external systems. The Application Layer is the target layer of an Amabulo infrastructure and comprises generated code artifacts. These artifacts are instances of a specific target platform specification, and they can be modified for integration purposes with development tools.
Through the contributions in this thesis, we aim to provide an integrated set of solutions to support an efficient model driven development and maintenance process for the business logic of information systems. Therefore, we provide a consistent infrastructure blueprint that considers modeling tasks, model analysis tasks, and code generation tasks. As a result, we see potential for reducing the development and maintenance efforts for changed domain requirements and simultaneously guaranteeing robustness and maintainability even after several changes.
44
Güldali, Barış [Verfasser]. "Integrating contract-based testing into model-driven software development / Barış Güldali." Paderborn : Universitätsbibliothek, 2015. http://d-nb.info/1073201511/34.
Full text
45
Aksønov, Sergei. "Embedded Control of a Wind Turbine Based on Model Driven Development." Thesis, Norges teknisk-naturvitenskapelige universitet, Institutt for teknisk kybernetikk, 2012. http://urn.kb.se/resolve?urn=urn:nbn:no:ntnu:diva-19213.
Full textAbstract:
Todays technological projects become increasingly complex. This increases the demands for seamless interaction between development tools. Problems like tool lock-in, and tool obsolescence become more significant. For large and complex projects, it is important to maximize the efficiency of the toolchain to avoid wasting time and money. To achieve this, a framework is being developed that aims to provide a seamless way to interchange tools and avoid many common problems. A demonstrator needs to be developed to validate this framework. This paper presents an implementation of a hardware-software system that can be used for that purpose. This system will rely on an integrated tool chain and thus provide grounds for experimentation using the abovementioned framework. It has been decided that this demonstrator will be in form of a wind turbine. Any other sufficiently complex hardware-software system could be used.First, the physics behind a fullscale turbine was studied. Then, several solutions for the implementation of the model were considered. A design was made and the components were chosen. A mechanical model was built, and a mathematical model was designed in Matlab Simulink. Also, a controller model was made in Matlab Simulink, which was loaded onto an industrial controller. Electrical circuits and interfaces were developed, as well as a communication protocol. In the end, verification was performed and an example usage of the demonstrator given.The result and product of this work is a platform, in shape of a scale wind turbine, for developing and validating a tool chain framework.
46
Sarabi, Mahdi. "Evaluation of Structural Testing Effectiveness in Industrial Model-driven Software Development." Thesis, Mälardalens högskola, Akademin för innovation, design och teknik, 2012. http://urn.kb.se/resolve?urn=urn:nbn:se:mdh:diva-14904.
Full textAbstract:
Software testing is a crucial but cost consuming practice in the development of safety critical software-intensive systems. In industry software testing techniques are chosen heuristically rather than scientifically. Researchers have studied for many years which test method is more efficient and effective in an industrial setting. Nevertheless, test design decisions still remain a challenge when applied in industry. Structural testing effectiveness is influenced by program code structure and the software development method used for designing and implementing industrial software-intensive systems. In the field of structural testing, the industrial approach toward different development methods and programming standards is studied insufficiently in the literature. In this thesis, we have found that applying structural testing on the actual generated source code from a Function Block Diagram (FBD) conforming to the IEC 61131-3 industrial standard is not effective. The FBD model is transformed to an FBD program code composed of almost exclusively assignments with Boolean expressions and function calls, which are not detected in code coverage analysis. In this thesis, we use the FBD model as a good candidate for measuring structural coverage, since it expresses the system behavior and it is the model from which the actual target code is generated. We propose a new automated method with potential application to our case study that evaluates the test suite based on structural coverage criteria. This leads to a shorter lifecycle with more effective structural testing for model-driven software development.
47
Pop, Adrian. "Integrated Model-Driven Development Environments for Equation-Based Object-Oriented Languages." Doctoral thesis, Linköping : Department of Computer and Information Science, Linköpings universitet, 2008. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-11416.
Full text
48
Vitiutinas, Ruslanas. "Model driven development of plug-ins for UML based modeling tools." Doctoral thesis, Lithuanian Academic Libraries Network (LABT), 2011. http://vddb.laba.lt/obj/LT-eLABa-0001:E.02~2011~D_20110808_111443-92074.
Full textAbstract:
This dissertation presents the principles and examples for building AMI for UML-based modeling environments. Modelers may use proposed AMI interface to extend UML modeling tools by modeling plug-ins using modeling tools itself. The work discusses four cases of AMI realization implemented in MagicDraw UML. Moreover, the proposed AMI implementation might be realized in other modeling tools that provide API and access to the model elements via standard UML metamodel interfaces. The ideas and results of this dissertation can be directly applied in numerous UML modeling tools available in the market. Although the focus in this dissertation is on UML modeling tools, many ideas are also applicable in other software systems that are developed using model driven approach.Šiame darbe yra pristatoma modeliavimu grindžiama praplėtimo sąsaja, kurią siūloma vadinti aplikacijos modeliavimo sąsaja (angl. Application Modeling Interface, AMI). Modeliuotojai, naudodami siūlomą aplikacijos modeliavimo sąsają, gali kurti UML įrankių įskiepius juos modeliuodami pačių UML įrankių pagalba. Darbe taip pat nagrinėjamas aplikacijos modeliavimo sąsajos apibrėžimo ir realizavimo UML įrankiuose aspektai.
49
Allen, Matthew S. "Performance Assessment of Model-Driven FPGA-based Software-Defined Radio Development." Digital WPI, 2014. https://digitalcommons.wpi.edu/etd-theses/943.
Full textAbstract:
"This thesis presents technologies that integrate field programmable gate arrays (FPGAs), model-driven design tools, and software-defined radios (SDRs). Specifically, an assessment of current state-of-the-art practices applying model-driven development techniques targeting SDR systems is conducted. FPGAs have become increasingly versatile computing devices due to their size and resource enhancements, advanced core generation, partial reconfigurability, and system-on-a-chip (SoC) implementations. Although FPGAs possess relatively better performance per watt when compared to central processing units (CPUs) or graphics processing units (GPUs), FPGAs have been avoided due to long development cycles and higher implementation costs due to significant learning curves and low levels of abstraction associated with the hardware description languages (HDLs). This thesis conducts a performance assessment of SDR designs using both a model-driven design approach developed with Mathworks HDL Coder and a hand-optimized design approach created from the model-driven VHDL. Each design was implemented on the FPGA fabric of a Zynq-7000 SoC, using a Zedboard evaluation platform for hardware verification. Furthermore, a set of guidelines and best practices for applying model-driven design techniques toward the development of SDR systems using HDL Coder is presented."
50
Smyth, Steven [Verfasser]. "Interactive Model-Based Compilation - A Modeller-Driven Development Approach / Steven Smyth." Kiel : Universitätsbibliothek Kiel, 2021. http://d-nb.info/1232812544/34.
Full text