Diese Diplomarbeit behandelt das Themengebiet der automatischen Erzeugung von grafischen Benutzeroberflächen (GUIs) im Kontext von Webservices. Es geht dabei konkret um einen Editor, mit dem Hinweise zur Generierung von Dialogen erstellt werden können. Diese Hinweise sollen dann von den dialogerzeugenden Anwendungen einbezogen werden, um eine dynamische Interaktion mit Webservices durch beliebige Nutzer ohne dienstspezifische Software zu ermöglichen. Die Arbeit führt in die aktuellen Techniken zur GUI-Generierung ein und stellt Transformationsprinzipien vor, die eine Generierung ausgehend von einem formalen Datenmodell ermöglichen. Dabei müssen mangelnde Modellparameter in Beschreibungen von Webservices manuell ausgeglichen werden (WSGUI-Konzepte). Diese Zielstellung führt zum Entwurf des WSGUI-Editors. Die anschließende Implementierung berücksichtigt darüber hinaus Integrationsaspekte wie die Publizierung von WSGUI-Hinweisen, Einbindung von GUI-Übersetzungen und eine Vorschau auf die zu generierenden Dialoge. Abgeschlossen wird die Arbeit mit einer Bewertung des Editors, aber auch einer Reihe von Vorschlägen zur Vereinfachung ähnlich gelagerter zukünftiger Projekte im Umfeld von Webservices.

The nature of Web system development is significantly different from conventional software development. Good method for system development is needed. Analysis show, that main known system development methods are good at describing static web application aspects, but does not provide a good description for modeling web application behavioral characteristics. This work uses model driven approach as one, suitable for dealing with web application development problems. The key aspect of model driven approach is specifying system domain model independent of any particular technology (J2EE, Microsoft .NET, etc.) and then generating platform specific model or its implementation. The UML is user-friendly, easy to use and is useful for describing system effectively. Specification expressed in terms of UML can be rendered into an XML document using the OMG’s XMI DTD for UML, which makes UML suitable for model driven approach implementation. In this work, method for specifying application behavior design using UML was presented. This method gives rules for specifying web application behavior model, suitable for its implementation code generation. The main components used in today’s web application which implementation could be generated from the model were also described. It was shown, that it is possible to generate much of implementation, just using such a model representation in XMI. The main idea presented in this work is that web application development should be model driven as... [to full text]

We present an approach based on Model-Driven Development ideas to create Software Product Lines(SPLs). In Model-Driven SPL approaches, the derivation of a product starts from a domain application model. This model is transformed through several stages reusing model transformation rules until a product is obtained. Transformations rules are selected according to variants included in configurations created by product designers. Configurations include variants from variation points, which are relevant characteristics representing the variability of a product line. Our approach (1) provides mechanisms to improve the expression of variability of Model-Driven SPLs by allowing designers to create fine-grained configurations of products, and (2) integrates a product derivation process which uses decision models and Aspect-Oriented Programming facilitating the reuse, adaptation and composition of model transformation rules. We introduce constraint models which make it possible for product line architects to capture the scope of product lines using the concepts of constraint, cardinality property and structural dependency property. To configure products, we create domain models and binding models, which are sets of bindings between model elements and variants and satisfy the constraint models. We define a decision model as a set of aspects. An aspect maintains information of what and when transformations rules that generate commonalities of products must be intercepted (joinpoints) and what transformation rules (advices) that generate variable structures must be executed instead. Our strategy maintains uncoupled variants from model transformation rules. This solves problems related to modularization, coupling, flexibility and maintainability of transformations rules because they are completely separated from variants; thus, they can evolve independently.

Mobilių technologijų populiarėjimas tarp vartotojų ir jų platformų įvairovė skatina mobilių programėlių kūrėjus užimti vis didesnę rinkos dalį. Kiekviena mobili platforma turi savo specifiką, todėl kūrėjams reikia vis daugiau žinių arba specialistų kuriant mobilias aplikacijas, tam reikalinga papildomų resursų, apmokymų,kaštų ir laiko. Vienas iš galimų problemos sprendimų, sukurti tam tikrus įrankius, kurie mobilių programėlių projektavimo ir kūrimo bei testavimo etape, leistų automatiškai suprojektuoti, suprogramuoti mobilias aplikacijas, nepriklausomai kokiai platformai išlaikant tos programėlės logiką. Tam pakaktų mobilių programų kūrėjams turėti vienai mobiliai platformai aprašytą modelį arba programėlę, ir iš jų remiantis MDA (Model Dirven Architecture) metodologijomis arba aprašytais karkasais atliktų transformacijas į reikiamą platformą. Šiame darbe pateikimas MDA principais paremtos sukurtos priemonės , kurios, atlieka programų transformacijas iš Android į Windows Phone. Įrodant transformacijų svarbą, atliktas transformavimo priemonių tyrimas, įvedant tam tikras metrikas ir jų palyginimą tarp atskirai realizuotų programų, šių priemonių transformuotų programų ir naudojant universalias priemones kaip JavaScript arba žiniatinklio principu veikiančių programų. / There is growth of mobile technologies and platforms providing for users so and developers of mobile applications need to take a larger market. There is some specificity of platforms, therefore developer needs a more knowledge or experts of mobile application developing where require a more resources, training, costs and it takes a time. One of the possible solutions to the problem, to make the tools which allow design and create mobile applications independent by platform keep the logic in design and development or testing phase. This is sufficient for developers to design or creates one mobile applications and using methods of Mobile Driven Architecture (MDA) and frameworks create transformations more applications many platforms. In this research paper representing the tools developed based MDA to carry out transformations from Android to Windows Phone. To prove the importance of transformations performed research of transformation tools with certain comparison of metrics between the programs of separated implementation, these tools transformed programs and used universal tools like JavaScript or web-based software implementation.

The overall contribution of this thesis is to propose an integrated approach for modeling and verifying the requirements of Self Adaptive Systems using Model Driven Engineering techniques. Model Driven Engineering is primarily concerned with reducing the gap between problem and software implementation domains through the use of technologies that support systematic transformation of problem level abstractions to software implementations. By using these techniques, we have bridged this gap through the use of models that describe complex systems at multiple levels of abstraction and through automated support for transforming and analyzing these models. We take requirements as input and divide it into Functional and Non Functional Requirements. We then use a process to identify those requirements that are adaptable and those that cannot be changed. We then introduce the concepts of Goal Oriented Requirements Engineering for modeling the requirements of Self Adaptive Systems, where Non Functional Requirements are expressed in the form of goals which is much more rich and complete in defining relations between requirements. We have identified some problems in the conventional methods of requirements modeling and properties verification using existing techniques, which do not take into account the adaptability features associated with Self Adaptive Systems. Our proposed approach takes into account these adaptable requirements and we provide various tools and processes that we developed for the requirements modeling and verification of Self Adaptive Systems. We validate our proposed approach by applying it on two different case studies in the domain of Self Adaptive Systems.

There is an increasing trend to consider the processes of an organization as one of its highly valuable assets. Processes are the reusable assets of an organization which define the procedures of routine working for accomplishing its goals. The software industry has the potential to become one of the most internationally dispersed high-tech industry. With growing importance of software and services sector, standardization of processes is also becoming crucial to maintain credibility in the market. Software development processes follow a lifecycle that is very similar to the software development lifecycle. Similarly, multiple phases of a process development lifecycle follow an iterative/incremental approach that leads to continuous process improvement. This incremental approach calls for a refinement based strategy to develop, execute and maintain software development processes. This thesis develops a conceptual foundation for refinement based development of software processes keeping in view the precise requirements for each individual phase of process development lifecycle. It exploits model driven engineering to present a multi-metamodel framework for the development of software processes, where each metamodel corresponds to a different phase of a process. A process undergoes a series of refinements till it is enriched with execution capabilities. Keeping in view the need to comply with the adopted standards, the architecture of process modeling approach exploits the concept of abstraction. This mechanism also caters for special circumstances where a software enterprise needs to follow multiple process standards for the same project. On the basis of the insights gained from the examination of contemporary offerings in this domain, the proposed process modeling framework tends to foster an architecture that is developed around the concepts of ''design by contract" and ''design for reuse". This allows to develop a process model that is modular in structure and guarantees the correctness of interactions between the constituent activities. Separation of concerns being the motivation, data-flow within a process is handled at a different abstraction level than the control-flow. Conformance between these levels allows to offer a bi-layered architecture that handles the flow of data through an underlying event management system. An assessment of the capabilities of the proposed approach is provided through a comprehensive patterns-based analysis, which allows a direct comparison of its functionality with other process modeling approaches.

Thesis (Ph. D.)--University of Alabama at Birmingham, 2007. / Additional advisors: Marjan Mernik, Jeffrey G. Gray, Alan P. Sprague, Elliot J. Lefkowitz. Description based on contents viewed May 29, 2008; title from title screen. Includes bibliographical references (p. 140-152).

A crescente demanda da indústria exige a produção de dispositivos embarcados em menos tempo e com mais funcionalidades diferentes. Isso implica diretamente no processo de desenvolvimento destes produtos requerendo novas técnicas para absorver a complexidade crescente dos projetos e para acelerar suas etapas de desenvolvimento. A linguagem UML vem sendo utilizada para absorver a complexidade do projeto de sistemas embarcados através de sua representação gráfica que torna o processo mais simples e intuitivo. Para acelerar o desenvolvimento surgiram processos que permitem, diretamente a partir modelos UML, a geração de código para linguagens de descrição de software embarcado (C, C++, Java) e para linguagens tradicionais de descrição de hardware (VHDL, Verilog). Diversos trabalhos e ferramentas comerciais foram desenvolvidos para automatizar o processo de geração de código convencional a partir de modelos UML (software). No entanto, pela complexidade da transformação existem apenas poucos trabalhos e nenhuma ferramenta comercial direcionado à geração de HDL a partir de UML, tornando este processo ainda pouco difundido. Nossa proposta é focada na geração de descrições de hardware na linguagem VHDL a partir de modelos UML de sistemas tempo-real embarcados (STRE), surgindo como alternativa ao processo de desenvolvimento de hardware. Apresenta uma metodologia completa para geração automática de código VHDL, permitindo que o comportamento descrito para o sistema modelado seja testado e validado antes de ser desenvolvido, acelerando o processo de produção de hardware e diminuindo as chances de erros de projeto. É proposto como um processo de engenharia dirigido por modelos (MDE) que cobre desde as fases de análise de requisitos e modelagem UML, até a geração de código fonte na linguagem VHDL, onde o foco é gerar na forma de descrições de hardware, todas aquelas funções lógicas de um sistema embarcado que normalmente são desenvolvidas em software. Para atingir este objetivo, foi desenvolvido neste trabalho um conjunto de regras de mapeamento que estende a funcionalidade da ferramenta GenERTiCA, utilizada como suporte ao processo. Adicionalmente, foram pesquisados e desenvolvidos conceitos que serviram como base para o desenvolvimento de regras utilizadas pela ferramenta suporte para guiar o processo de mapeamento entre as linguagens. Os conceitos e as regras propostas foram validados por meio de um estudo de caso, cujos resultados obtidos estão demonstrados nesta dissertação. / The growing market demand requires the production of embedded devices in less time and with more different features. This directly implies on the development process of these products requiring new techniques to absorb the growing complexity of projects and to accelerate their development stages. UML has been used to handle the embedded systems design complexity through its graphical representation that makes the process simpler and more intuitive. To speed up the development cycle, it has emerged some processes that permit code generating directly from UML models to embedded software description languages (C, C++, Java), and traditional hardware description languages (VHDL, Verilog). Several researches and commercial tools have been developed to automate the code generation process from UML models to conventional languages (software). However, due to the transformation complexity there are only few studies and no commercial tool addressed to HDL generation from UML models, making this process almost unknown. Our proposal is focused on generating hardware descriptions as VHDL code from UML models of real-time embedded systems (RTES), emerging as an alternative to the hardware development. It presents a complete methodology to the VHDL code generation, allowing the behavior described to the modeled system to be tested and validated before being implemented, accelerating the hardware production and decreasing the chances of design errors. It is proposed as a model-driven engineering (MDE) process that covers the phases of requirements analysis, UML modeling, models transformations, and the source code generating process to the VHDL language, where the focus is to generate as hardware descriptions all the logic functions of an embedded system which are usually developed as software. To achieve this goal, this work was developed a set of mapping rules which extends the functionality of the tool GenERTiCA, used to support the process. Additionally, it was researched and developed concepts that were the basis for the development of rules used by the tool support to guide the mapping process between languages. The concepts and proposed rules have been validated through a case study, whose results are shown in this dissertation.

Reliability and safety of complex software-intensive systems are proved to be a crucial matter since most of these systems fulfil tasks, where a failure could lead to catastrophic consequences. For example, in space systems such as satellites, a failure could result in the loss of the satellite. Therefore, a certain level of reliability and safety must be assured for such systems to trust the services they provide. Standards set this level and put requirements for the analysis and assurance of these properties using documented evidence. In particular, European Cooperation for Space Standardization (ECSS) standards for space systems require Fault Tree Analysis(FTA) for identifying the causes of system failure and consequently safety hazards, as well as fault trees as evidence for the assurance of reliability and safety. In this thesis, we present a tool supported model-based approach to generate fault tree automatically from an existing system modelling and analysis toolset. CHESS is a system and dependability modelling toolset and integrates Concerto-FLA to enable the support of failure logic analysis. We proposed a model-based transformation from Concerto-FLA to fault tree model and implemented it as an Eclipse plugin in CHESS toolset. A case study is performed in the aerospace domain; more specifically we modelled Attitude Control System (ACS) and automatically generated IEC-61025-compliant fault trees. / AMASS project

En Interaction Homme-Machine, la qualité est une utopie : malgré toutes les précautions prises en conception, il existe toujours des utilisateurs et des situations d'usage pour lesquels l'Interface Homme-Machine (IHM) est imparfaite. Cette thèse explore l'auto-explication des IHM pour améliorer la qualité perçue par les utilisateurs. L'approche s'inscrit dans une Ingénierie Dirigée par les Modèles. Elle consiste à embarquer à l'exécution les modèles de conception pour dynamiquement augmenter l'IHM d'un ensemble de questions et de réponses. Les questions peuvent être relatives à l'utilisation de l'IHM (par exemple, "A quoi sert ce bouton ?", "Pourquoi telle action n'est pas possible ?) et à sa justification (par exemple, "Pourquoi les items ne sont-ils pas rangés par ordre alphabétique ?"). Cette thèse propose une infrastructure logicielle UsiExplain basée sur les méta-modèles UsiXML. L'évaluation sur un cas d'étude d'achat de voitures montre que l'approche est pertinente pour les questions d'utilisation de l'IHM. Elle ouvre des perspectives en justification de conception. / In Human-Computer Interaction, quality is an utopia. Despite all the design efforts, there are always uses and situations for which the user interface is not perfect. This thesis investigates self-explanatory user interfaces for improving the quality perceived by end users. The approach follows the principles of model-driven engineering. It consists in keeping the design models at runtime so that to dynamically enrich the user interface with a set of possible questions and answers. The questions are related to usage (for instance, "What's the purpose of this button?", "Why is this action not possible"?) as well as to design rationale (for instance, "Why are the items not alphabetically ordered?"). This thesis proposes a software infrastructure UsiExplain based on the UsiXML metamodels. An evaluation conducted on a case study related to a car shopping webiste confirms that the approach is relevant especially for usage questions. Design rationale will be further explored in the future.STAR