21 |
Um estudo sobre MDA: suporte fornecido pela UML e reuso de soluções pré-definidas. / A study on MDA: support provided by UML and reuse of pre-defined solutions.José Eduardo Belix 07 April 2006 (has links)
Este trabalho tem por objetivo propor a utilização de soluções pré-definidas e comprovadas na abordagem MDA, auxiliando o desenvolvedor na resolução de problemas recorrentes ao desenvolvimento de software. A utilização destas soluções pré-definidas leva a um aumento de produtividade no contexto MDA e na geração de software baseado em boas práticas. Para que este objetivo seja cumprido, é empreendida uma análise sobre o MDA e sobre como operacionalizar as transformações entre modelos. Também é empreendida uma análise sobre o suporte fornecido pela UML e sobre reutilização em desenvolvimento orientado a modelos. Por fim este trabalho apresenta partes de uma aplicação protótipo, construída para ser uma prova de conceito de código gerado através da combinação de UML e soluções pré-definidas. / The goal of this work is to propose the use of pre-defined solutions on MDA approach, supporting the developer in solving recurrent problems of software development. The use of these pre-defined solutions leads to an increase of productivity in MDA context, and in the generation of software based on best practices. To reach this goal, an analysis of MDA is undertaken, as well as an analysis of how to enable the transformations between models. It is also undertaken an analysis about the use of UML and the reuse in model driven development. Finally this work presents portions of a prototype application, constructed to be a proof-of-concept of generated code, combining UML and the pre-defined solutions.
|
22 |
Desenvolvimento baseado em modelos de ferramentas para avaliação da aderência de processos de software em relação a modelos de maturidadeLIBÓRIO, Luiz Felipe de Oliveira 27 August 2014 (has links)
Submitted by Irene Nascimento (irene.kessia@ufpe.br) on 2016-08-22T18:54:13Z
No. of bitstreams: 2
license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5)
DissertacaoCD_LuizFelipeLiborio.pdf: 3777707 bytes, checksum: a7937e9fc359d5b560c37ea3abf5e74c (MD5) / Made available in DSpace on 2016-08-22T18:54:13Z (GMT). No. of bitstreams: 2
license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5)
DissertacaoCD_LuizFelipeLiborio.pdf: 3777707 bytes, checksum: a7937e9fc359d5b560c37ea3abf5e74c (MD5)
Previous issue date: 2014-08-27 / Capes / Atualmente, é cada vez mais exigido como critério competitivo a aderência do processo
de software de uma organização a um modelo ou norma de qualidade. Alcançar altos níveis de
aderência é uma tarefa complexa para as organizações, pois a atividade de avaliar essa aderência
exige cuidado ao ser realizada. Com isso, busca-se cada vez mais o apoio de ferramentas de avaliação
computadorizadas, cujo objetivo é agilizar e tornar mais confiável o processo de avaliação
dos processos de software. Ainda assim, um dos fatores que tendem a dificultar a utilização e
propagação do uso de ferramentas é a atualização das normas de qualidade e dos métodos de
avaliação associados, que visam se adequar constantemente às boas práticas do mercado. Ora, se
uma ferramenta é criada baseada na norma de qualidade e no seu método de avaliação, qualquer
mudança em algum dos dois componentes significa mudanças na ferramenta, gerando custos de
manutenção e de distribuição da nova versão da ferramenta. Este trabalho busca criar uma engine
de geração que seja sensível a esses mudanças, sem que seu processo de desenvolvimento necessite
ser executado novamente. Para isto, utiliza o processo MDD (Model-Driven Development)
para atender a esses requisitos, dado que o seu objetivo é transformar elementos mais abstratos
em elementos mais concretos utilizando uma sucessão de transformações, através de modelos. O
objetivo deste trabalho é, então, aplicar as regras de MDD aos modelos de qualidade e métodos
de avaliação. Isto torna possível a criação de ferramentas para avaliação baseada nos modelos
necessários à avaliação. Ou seja, através de um modelo de processo e de um metamodelo da
norma de qualidade, além do método de avaliação, é possível criar de forma automática via
MDD uma ferramenta que possa ser atualizada sob demanda, sem que seu código-fonte precise
ser alterado manualmente. / Nowadays, it is increasingly required as a competitive criteria the adherence of an
organization to a software model or quality standard process. Achieving high levels of adherence
is a complex task for organizations, because the activity of evaluating this adherence requires
care to be performed. Thus, it is increasing the nedd of computerized evaluation tools whose
goal is to speed up and make more reliable the process of evaluating software processes.Still, one
of the factors that tend to hamper the use and propagation of tool use is the change of the quality
standards and assessment methods, which aim to adapt constantly to best practices in the market.
So, if a tool is created based on quality standard and its evaluation method, any change in any of
the two components mean changes in the tool, generating costs of maintaining and distributing
the new version of the tool. This work seeks to develop a tool that is sensitive to that changes,
but without the need of performing its development process again. For that, it uses MDD (Model-
Driven Development) processes meet these requirements, since their goal is to transform more
abstract elements into more concrete elements using a succession of transformations, through
models. So, the goal of this work is to apply the rules of MDD to quality models and assessment
methods. It makes possible to create tools based on models. In other words, through a process
model and a metamodel quality standard, besides the evaluation method, it is possible to create
automatically via MDD a tool that can be updated on demand, without its source code need to be
changed manually.
|
23 |
Projeto e implementação de um gerador automático de serviços web a partir de diagramas de classes / Design and implementation of an automatic generator of web services from class diagramsDomenico Schettini Filho 21 March 2016 (has links)
A indústria de desenvolvimento de software está em constante evolução e em busca de novos desafios, como por exemplo: novas tecnologias, linguagens de programação e estratégias para aumentar a produtividade no desenvolvimento. Com o passar do tempo, essa evolução desejada tem se concretizado, em especial com o surgimento de conceitos como Service Oriented Architecture (SOA) e Model-Driven Development (MDD). Nesse contexto, ganha importância a reutilização de software, por exemplo por meio do uso de serviços que facilitam a interoperabilidade entre diferentes sistemas. Ambientes de desenvolvimento de software, em especial ambientes de reúso de software, poderiam se adequar à arquitetura SOA para facilitar a disponibilização de serviços a outros ambientes, promovendo sua integração e aumentando a possibilidade de reúso. Após um levantamento bibliográfico sobre ambientes integrados de reúso que utilizassem serviços para permitir o compartilhamento de recursos, percebeu-se que os trabalhos nessa direção são poucos. Ao mesmo tempo, observou-se que para integração de sistemas por meio de serviços é necessário criar camadas de acesso às entidades dos sistemas que compartilharão informações. A implementação desses serviços de forma manual é repetitiva e sujeita a erros, principalmente por programadores que não estão familiarizados com SOA. Por outro lado, diagramas de classes em UML (Unified Modeling Language) são de amplo conhecimento por parte de desenvolvedores e estão em um nível de abstração que é suficientemente detalhado para permitir a derivação de serviços de acesso às suas classes. Desta forma, para atender uma demanda crescente de sistemas que precisam oferecer serviços para possibilitar sua integração com outros sistemas, este mestrado tem por objetivo promover a geração automatizada de código de serviços por meio de transformações de modelo para texto, em que o modelo de entrada é um diagrama de classes derivado da UML e os serviços gerados cobrem operações básicas do tipo CRUD. O gerador resultante foi validado por meio de duas provas de conceito e mostrou-se adequado para cumprir os objetivos estabelecidos, visto que o desenvolvedor trabalha com um modelo em alto nível de abstração, não precisando conhecer os detalhes inerentes à implementação dos serviços. / The software development industry is constantly evolving and looking for challenges, such as: new technologies, programming languages and strategies to increase developers productivity. During the course of time, this required evolution has been concretized, especially with the emergency of concepts such as Service Oriented Architecture (SOA) and Model-Driven Development (MDD). In this context, software reuse gains importance, for example through the use of services that ease the interoperability of different systems. Software development environments, in special reuse environments, could be adapted to the SOA architecture to ease the availability of services to other environments, thus promoting its integration and possibility of reuse. After a literature review about integrated reuse environments that use services to allow resources sharing, it has been observed that there are only a few works in this direction. At the same time, it was observed that for system integration through services it is required to create an access layer for the system entities that share information. The manual implementation of these services is repetitive and error prone, especially for programmers who are not familiar with SOA. On the other hand, UML (Unified Modeling Language) class diagrams are widely known by developers and are at a level of abstraction that is sufficiently detailed to allow the derivation of access services to their classes. Thus, to meet a growing demand for systems that need to provide services to enable its integration with other systems, this masters dissertation aims to promote the automated generation of service code through transformations from model to text, where the input model is a class diagram derived from UML, and the generated services cover the basic CRUD operations. The resulting generator has been validated through two proofs of concepts and was adequate to meet the stated objectives, as the developer works with a model in a high abstraction level, and does not need to know the details related with the service implementation.
|
24 |
An approach to architecture-centric domain-specific modelling and implementation for software development and reuseDuan, Qing January 2010 (has links)
Model-driven development has been considered to be the hope of improving software productivity significantly. However, it has not been achieved even after many years of research and application. Models are only and still used at the analysis and design stage, furthermore, models gradually deviate from system implementation. The thesis integrates domain-specific modelling and web service techniques with model-driven development and proposes a unified approach, SODSMI (Service Oriented executable Domain-Specific Modelling and Implementation), to build the executable domain-specific model and to achieve the target of model-driven development. The approach is organised by domain space at architectural level which is the elementary unit of the domain-specific modelling and implementation framework. The research of SODSMI is made up of three main parts: Firstly, xDSM (eXecutable Domain-Specific Model) is proposed as the core construction for domain-specific modelling. Behaviour scenario is adopted to build the meta-modelling framework for xDSM. Secondly, XDML language (eXecutable Domain-specific Meta-modelling Language) is designed to describe the xDSM meta-model and its application model. Thirdly, DSMEI (Domain-Specific Model Execution Infrastructure) is designed as the execution environment for xDSM. Web services are adopted as the implementation entities mapping to core functions of xDSM so as to achieve the service-oriented domain-specific application. The thesis embodies the core value of model and provides a feasible approach to achieve real model-driven development from modelling to system implementation which makes domain-specific software development and reuse coming true.
|
25 |
Rahmenwerk zur integrativen Gestaltung von ServicesAugenstein, Christoph 05 July 2016 (has links) (PDF)
Die vorliegende Arbeit befasst sich mit der modellgetriebenen Servicebeschreibung, einem Ansatz zur integrativen Beschreibung bzw. Modellierung von Services. Ausgehend von der Prämisse, dass die Natur von Services nur schwer zu erfassen ist und eine Disziplinen-übergreifende Positiv-Definition nicht erreicht werden kann, soll mit dem Ansatz eine Syn-these bisher vorhandener Modellierungsansätze erfolgen. Das Ziel liegt dabei nicht in einem erneuten Versuch, ein vollständiges Modell zur Beschreibung von Services zu entwickeln, sondern vielmehr vorhandene Perspektiven so zu integrieren, dass ein vollständiges Bild als eine Art Mosaik entsteht. Den Kern der Arbeit bildet das Service Modeling Framework. Als Rahmenwerk umfasst es Anforderungen und Restriktionen für die Arbeit mit unter-schiedlichen Servicemodellen, definiert Methoden zur Integration und bietet Werkzeuge, mit deren Hilfe die darin enthaltenen Konzepte umgesetzt werden.
Ziel der Konstruktion des Rahmenwerks ist es Nutzer in die Lage zu versetzen mittels mo-dellgetriebener Verfahren eine Zusammenführung von Modellen zu ermöglichen. Auf Basis einer fachlichen, nicht nur syntaktischen Beschreibung von Beziehungen zwischen Model-len und Modellelementen sollen Zusammenhänge modelliert werden, die einen Informati-onsaustausch zwischen Modellen realisieren. Dadurch werden Abhängigkeiten zwischen Modellen explizit formuliert oder aber die Entwicklung neuer Modelle auf Basis bereits bestehender Modelle vorangetrieben.
Der Beitrag dieser Arbeit besteht in der Erarbeitung der notwendigen Konzepte und in der Bereitstellung geeigneter Verfahren sowie Werkzeugen zur Umsetzung. Insbesondere stellt diese Arbeit einen Metamodell-basierten Ansatz zur Verfügung, mit dem Modelle über ein Domänen-neutrales Basismetamodell zueinander in Beziehung gesetzt werden können. Zugehörige Werkzeuge, wie Editoren, zeigen eine prototypische Umsetzbarkeit.
|
26 |
Preservation of Extra-Functional Properties in Embedded Systems DevelopmentSaadatmand, Mehrdad January 2015 (has links)
The interaction of embedded systems with their environments and their resource limitations make it important to take into account properties such as timing, security, and resource consumption in designing such systems. These so-called Extra-Functional Properties (EFPs) capture and describe the quality and characteristics of a system, and they need to be taken into account from early phases of development and throughout the system's lifecycle. An important challenge in this context is to ensure that the EFPs that are defined at early design phases are actually preserved throughout detailed design phases as well as during the execution of the system on its platform. In this thesis, we provide solutions to help with the preservation of EFPs; targeting both system design phases and system execution on the platform. Starting from requirements, which form the constraints of EFPs, we propose an approach for modeling Non-Functional Requirements (NFRs) and evaluating different design alternatives with respect to the satisfaction of the NFRs. Considering the relationship and trade-off among EFPs, an approach for balancing timing versus security properties is introduced. Our approach enables balancing in two ways: in a static way resulting in a fixed set of components in the design model that are analyzed and thus verified to be balanced with respect to the timing and security properties, and also in a dynamic way during the execution of the system through runtime adaptation. Considering the role of the platform in preservation of EFPs and mitigating possible violations of them, an approach is suggested to enrich the platform with necessary mechanisms to enable monitoring and enforcement of timing properties. In the thesis, we also identify and demonstrate the issues related to accuracy in monitoring EFPs, how accuracy can affect the decisions that are made based on the collected information, and propose a technique to tackle this problem. As another contribution, we also show how runtime monitoring information collected about EFPs can be used to fine-tune design models until a desired set of EFPs are achieved. We have also developed a testing framework which enables automatic generation of test cases in order verify the actual behavior of a system against its desired behavior. On a high level, the contributions of the thesis are thus twofold: proposing methods and techniques to 1) improve maintenance of EFPs within their correct range of values during system design, 2) identify and mitigate possible violations of EFPs at runtime. / CHESS / MBAT / ITS-EASY
|
27 |
Extracting Reusable Design Decisions for UML-based Domain-specific Languages: A Multi-Method StudySobernig, Stefan, Hoisl, Bernhard, Strembeck, Mark January 2016 (has links) (PDF)
When developing domain-specific modeling languages (DSMLs), software engineers have to make a number of important
design decisions on the DSML itself, or on the software-development process that is applied to develop the DSML. Thus, making well-informed design decisions is a critical factor in developing DSMLs. To support this decision-making process, the model-driven development community has started to collect established design practices in terms of patterns, guidelines, story-telling, and procedural models. However, most of these documentation practices do not capture the details necessary to reuse the rationale behind these decisions in other DSML projects. In this paper, we report on a three-year research effort to compile and to empirically validate a catalog of structured decision descriptions (decision records) for UML-based DSMLs. This
catalog is based on design decisions extracted from 90 DSML projects. These projects were identified - among others - via an extensive systematic literature review (SLR) for the years 2005 - 2012. Based on more than 8,000 candidate publications, we finally selected 84 publications for extracting design-decision data. The extracted data were evaluated quantitatively using a
frequent-item-set analysis to obtain characteristic combinations of design decisions and qualitatively to document recurring
documentation issues for UML-based DSMLs. We revised the collected decision records based on this evidence and made the decision-record catalog for developing UML-based DSMLs publicly available. Furthermore, our study offers insights into UML usage (e.g. diagram types) and into the adoption of UML extension techniques (e.g. metamodel extensions, profiles).
|
28 |
A Model Driven Component Agent Framework for Domain ExpertsJayatilleke, Gaya Buddhinath, buddhinath@gmail.com January 2007 (has links)
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.
|
29 |
The Meaning of UML ModelsO'Keefe, Greg, gregokeefe@netspace.net.au January 2010 (has links)
The Unified Modelling Language (UML) is intended to express complex ideas
in an intuitive and easily understood way. It is important because it is widely
used in software engineering and other disciplines. Although an official definition
document exists, there is much debate over the precise meaning of UML models.
¶
In response, the academic community have put forward many different proposals
for formalising UML, but it is not at all obvious how to decide between
them. Indeed, given that UML practitioners are inclined to reject formalisms as
non-intuitive, it is not even obvious that the definition should be formal at all.
Rather than searching for yet another formalisation of UML, our main aim is to
determine what would constitute a good definition of UML.
¶
The first chapter sets the UML definition problem in a broad context, relating
it to work in logic and the philosophy of science. More specific conclusions about
the nature of model driven development are reached in the beginning of Chapter 2.
We then develop criteria for a definition of UML. Applying these criteria to the
existing definition, we find that it is lacking in clarity. We then set out to test the
precision of the definition. The test is to take an apparently inconsistent model, and
determine whether it really is inconsistent according to the definition.
¶
Many people have proposed that UML models are graphs, but few have justified
this choice using the official definition of UML. We begin Chapter 3 by arguing
from the official definition that UML models are graphs and that instantiation
is a graph homomorphism into an interpretation functor. The official definition of
UML defines the semantics against its abstract syntax, which is in turn defined by
a UML model. Chapters 3 and 4 prepare for our test by resolving this apparent
circularity. The result is a semantics for the metamodel fragment of the language.
¶
In Chapter 5, we find, contrary to popular belief, that the official definition does
provide sufficient semantics to classify the example model as inconsistent. Moreover,
the sustained study of the semantics in Chapters 3 to 5 confirms our initial
argument that the semantic domain is graphs. The Actions are the building blocks
of UMLs prescriptive dynamics. We see that they can be naturally defined as graph
transformation rules. Sequence diagrams are the main example of descriptive dynamics,
but we find that their official semantics are broken. The recorded history
approach should be replaced, we suggest, by a graph-oriented dynamic logic.
¶
Chapter 6 presents our early work on dynamic logic for UML sequence diagrams
and further explores the proposed semantic repairs. In Chapter 7, guided
by the criteria developed in Chapter 2, we critically survey the UML formalisation
literature and conclude that an existing body of graph transformation based work
known as dynamic metamodelling is very close to what is required.
¶
The final chapter draws together our conclusions. It proposes a category theoretic
construction to merge models of the syntax and semantic domain, yielding
a type graph for the graph transformation system which defines the dynamic semantics
of the language. Finally, it outlines the further work required to realise a
satisfactory definition of UML.
|
30 |
Model Synchronization for Software EvolutionIvkovic, Igor 26 August 2011 (has links)
Software evolution refers to continuous change that a software system endures from inception to retirement. Each change must be efficiently and tractably propagated across models representing the system at different levels of abstraction. Model synchronization activities needed to support the systematic specification and analysis of evolution activities are still not adequately identified and formally defined.
In our research, we first introduce a formal notation for the representation of domain models and model instances to form the theoretical basis for the proposed model synchronization framework. Besides conforming to a generic MOF metamodel, we consider that each software model also relates to an application domain context (e.g., operating systems,
web services). Therefore, we are addressing the problems of model synchronization by focusing on domain-specific contexts.
Secondly, we identify and formally define model dependencies that are needed to trace and propagate changes across system models at different levels of abstraction, such as from design to source code. The approach for extraction of these dependencies is based on Formal Concept Analysis (FCA) algorithms. We further model identified dependencies
using Unified Modeling Language (UML) profiles and constraints, and utilize the extracted dependency relations in the context of coarse-grained model synchronization.
Thirdly, we introduce modeling semantics that allow for more complex profile-based dependencies using Triple Graph Grammar (TGG) rules with corresponding Object Constraint Language (OCL) constraints. The TGG semantics provide for fine-grained model synchronization, and enable compliance with the Query/View/Transformation (QVT) standards.
The introduced framework is assessed on a large, industrial case study of the IBM Commerce system. The dependency extraction framework is applied to repositories of business process models and related source code. The extracted dependencies were evaluated by IBM developers, and the corresponding precision and recall values calculated with results
that match the scope and goals of the research. The grammar-based model synchronization and dependency modelling using profiles has also been applied to the IBM Commerce system, and evaluated by the developers and architects involved in development of the system. The results of this experiment have been found to be valuable by stakeholders, and a patent
codifying the results has been filed by the IBM organization and has been granted. Finally, the results of this experiment have been formalized as TGG rules, and used in the context of fine-grained model synchronization.
|
Page generated in 0.1052 seconds