Graphical modeling is becoming an increasingly important part of software engineering as it provides means of increasing productivity by raising the level of abstraction in software devel-opment. One of the most widely adopted modeling notations is the Unified Modeling Language (UML) which has gained popularity due to its generality and broad applicability. Despite its advantages, this general purpose notation is burdened with the lack of purpose specific model-ing abstractions. The modeling abstractions in the language lack specialized properties and thus models might not precisely express the intentions of the modeler. In consequence, this leads to ineffectiveness of using models in UML. This thesis presents research aimed at improving modeling with UML. By exploiting the language customization mechanisms inherent in UML – stereotypes and profiles – the research presented in the thesis explores such aspects of improving modeling as creating language cus-tomizations or using a customized modeling language. The context, in which the modeling is considered, is delineated by the principles of model driven software development (MDD). The principles recognize the usage of models as the primary artefacts in software development thus providing a solid foundation for considering the use of models in software development. One of the contributions in the thesis is the identification and definition of factors determin-ing the successful realization of MDD in industry. These factors provide means of positioning language customization in the forefront of MDD. Another contribution in the thesis is eliciting and prioritizing a set of criteria for choosing between language customization mechanisms, which is a result of another industrial case study. A series of experiments in academic and industrial environments showed the magnitude of improvements to be expected after replacing a standard modeling language with a customized modeling notation. This series of experiments provided a basis for experimenting with stereo-types and software inspections which indicated a considerable increase in effectiveness of the reading techniques used in software inspections after replacing a standard notation with a cus-tomized one. The results from all empirical studies affected the development of quality assessment crite-ria for stereotypes. The criteria and the exploration of several existing profiles led to the devel-opment of guidelines for creating “good” stereotypes by analyzing existing UML profiles. An additional contribution in the thesis is exploring the usage of an alternative mechanism to stereo-types – model libraries – for adaptation of a modeling language. The way in which model librar-ies can be created in an efficient way is studied by creating a method for extracting knowledge from ontologies into UML domain models. The results of the research presented in the thesis show how to improve modeling with UML by customizing the language with stereotypes. The main contribution is the exploration and evaluation of issues related to creating language customizations and using the customized language.

Formal methods is a discipline of using a collection of mathematical techniques and formalisms to model and analyze software systems. Motivated by the new formal methods-based certification recommendations for safety-critical embedded software and the significant increase in the cost of verification and validation (V\&V), this research is about creating a software development process for control systems that can provide mathematical guarantees of high-level functional properties on the code. The process, dubbed credible autocoding, leverages control theory in the automatic generation of control software documented with proofs of their stability and performance. The main output of this research is an automated, credible autocoding prototype that transforms the Simulink model of the controller into C code documented with a code-level proof of the stability of the controller. The code-level proof, expressed using a formal specification language, are embedded into the code as annotations. The annotations guarantee that the auto-generated code conforms to the input model to the extent that key properties are satisfied. They also provide sufficient information to enable an independent, automatic, formal verification of the auto-generated controller software.

A real-time system is one in which the correctness of the computations not only depends upon the logical correctness of the computation but also upon the time at which the result is produced. If the timing constraints of the system are not met, system failure is said to have occurred. Real-time system consist specialized hardware an software components. Nowadays, systems are so big and complex that teams of architects, analysts, programmers, testers and users must work together to create reliable real-time system. To manage this, a number of system development life cycle models have been created. System development life cycle refers to a methodology for developing systems. It provides a consistent framework of tasks and deliverables needed to develop systems. System development consist stages, that are common for all models: project planning, requirements definition, system design, implementation, testing, deployment and maintenance. However, there still are problems, that lead project to the failure. Problems appear while iterating from design stage to the implementation or prototype creation. Thesis describes methodology, that provide a way to overcome these problems. The main idea is to transform functional structure of the real-time system, that is designed using easy to understand graphical environment, to the executable code that will be able to run on target hardware components. Thesis describe the methods of doing such transformation. Methodology allows to create... [to full text]

In modern times, human life is intrinsically depending on real-time embedded systems (RTES) with increasingly safety-critical and mission-critical features, for instance, in domains such as automotive and avionics. These systems are characterized by stringent functional requirements and require predictable timing behavior. However, the complexity of RTES has been ever increasing requiring systematic development methods. To address these concerns, model-based frameworks and component-based design methodologies have emerged as a feasible solution. Further, system artifacts such as requirements/specifications, architectural designs as well as behavioral models like statemachine views are integrated within the development process. However, several challenges remain to be addressed, out of which two are especially important: expressiveness, to represent the real-time and causality behavior, and analyzability, to support verification of functional and timing behavior. As the main research contribution, this thesis presents design and verification techniques for model-based development of RTES, addressing expressiveness and analyzability for architectural and behavioral models. To begin with, we have proposed a systematic design process to support component-based development. Next, we have provided a real-time semantic basis, in order to support expressiveness and verification for structural and behavioral models. This is achieved by defining an intuitive formal semantics for real-time component models, using ProCom, a component model developed at our research centre, and also using the CCSL (Clock Constraint Specification Language), an expressive language for specification of timed causality behavior. This paves the way for formal verification of both architectural and behavioral models, using model checking, as we show in this work, by transforming the models into timed automata and performing verification using UPPAAL, a model checking tool based on timed automata. Finally, the research contributions are validated using representative examples of RTES as well as an industrial case-study. / ARROWS

En este trabajo de tesis se describirá una técnica de modelado centrado en mockups, introduciéndola primero con MockupDD Web. Luego de haber ejemplificado el desarrollo centrado en mockups para metodologías MDWE, se describirá un marco general para el modelado sobre mockups (lo que se referenciará como metodología MockupDD general) y una instanciación particular de esta metodología además de la ya presentada para la Web. Las principales contribuciones de la metodología MockupDD y sus especializaciones son: (1) Mejorar el workflow en cascada de las metodologías MDD tradicionales (en especial, aquellas MDWE) para permitir acortar las iteraciones y permitir a usuarios finales y clientes involucrados interactuar más rápidamente son el software generado, agilizando el proceso. (2) Mejorar la productividad en el modelado de aplicaciones a través de la técnica de modelado de aplicaciones sobre mockups reduciendo sus errores y tiempo requerido, como se mostrará luego en las secciones de validación (3) Introducir a clientes y usuarios finales en el proceso de desarrollo, utilizando artefactos de especificación de requerimientos de fácil comprensión para los mismos en lugar de conceptos de modelado comprensibles sólo para desarrolladores. En este contexto se utilizarán mockups y diferentes técnicas de anotación y especificación de requerimientos formales sobre los mismos. (4) La implementación de un lenguaje de modelado sobre mockups con diferentes vistas, satisfaciendo al mismo tiempo la necesidad de comprensión de requerimientos por parte de los usuarios finales y las capacidades técnicas requeridas por los desarrolladores. (5) Con ayuda de esta versatilidad del lenguaje y del uso de mockups (los cuales son comprensibles en su totalidad por usuarios finales), proveer un método de modelado más trazable desde el punto de vista de los requerimientos.

The use of models for designing and developing Information Systems (IS) has changed in recent years. Models are no longer considered a peripheral documentation medium that is poorly maintained and often neglected. Rather, models are increasingly seen as essential parts of the final product—as central artifacts that drive and guide the development efforts. The knowledge that modelers rely on when designing models is represented as formal models and clearly defined rules for transforming the models. The flexibility, reliability, and effectiveness offered by the formal models and the transformations are making Model Driven Development (MDD) a popular choice for building IS. Models also serve in describing enterprise design, where enterprise-level models capture organizational knowledge and aid in understanding, improving, and growing the enterprise. Enterprise Modeling (EM) offers a structured and unified view of the enterprise, thereby enabling more informed and accurate decisions to be made. Many MDD approaches have been proposed to tackle a wide range of IS-related issues, but little attention is being paid to the source of the knowledge captured by the IS models. EM approaches capture organizational knowledge and provide the necessary input and underlying context for designing IS. However, the results produced by EM approaches need to be manually analyzed by modelers to create the initial MDD model. This interruption of the MDD process represents a gap between enterprise models and MDD models. Limited research has been done to connect EM to MDD in a systematic and structured manner based on the principles of model-driven development. This thesis proposes a unifying meta-model for integrating EM and MDD. The meta-model captures the inherent links that exist between organizational knowledge and IS design. This helps to improve the alignment between organizational goals and the IS that are created to support them. The research presented herein follows the guidelines of the design science research methodology. It starts with a state-of-the-art survey of the current relationship between MDD and prior stages of development. The findings of the survey are used to elicit a set of necessary properties for integrating EM and MDD. The unifying meta-model is then proposed as the basis for an integrated IS development approach that applies the principles of MDD and starts on the enterprise level by considering enterprise models in the development process. The design of the meta-model supports the elicited integration properties. The unifying meta-model is based on the Enterprise Knowledge Development (EKD) approach to EM. A prototype tool is developed to support the unifying meta-model, following a study to choose a suitable implementation environment. The use of the unifying meta-model is demonstrated through the implemented tool platform using an example case study, revealing its advantages and highlighting the potential for improvement and future development.

La tesis propone un lenguaje específico de dominio (DSL) para modelar Sistemas Colaborativos (CSSL - Collaborative Software System Language). Este lenguaje fue diseñado como una extensión de UML usando el mecanismo de metamodelado y posee una sintaxis abstracta formalizada que permitirá entre otras cosas definir más de una sintaxis concreta a partir de ella, lo cual aumenta la legibilidad y flexibilidad del lenguaje. Finalmente se presenta una guía que facilita la construcción de Sistemas Colaborativos. Dentro del paradigma MDD (Model Driven Development) y utilizando el lenguaje CSSL se describe las etapas iniciales de un método para modelar los Sistemas Colaborativos.

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.

This thesis describes the AP1 system, which serves as a platform for model-based CASE technology. AP1 is a set of libraries and tools that support different activities in the software development process. It provides different layers of reusable CASE functionality, and thus facilitates CASE tool development and integration. Some key problems of software development are addressed, such as the storage and management of artifacts, their creation and modification, and the generation of program code. The main parts of the abstract platform are a typed repository for models and model data, and a generic editor that acts as an integrated software development environment (IDE). The former enables data integration; the latter serves as a basis for presentation integration. Both parts have an extensible and customizable architecture that makes it possible for developers to adapt the system to their own individual needs. The thesis discusses different data models, explaining why the parsimonious data model was chosen for the repository. A mapping onto the relational data model is given that makes it possible to leverage a RDBMS for data management. On top of the RDBMS, the AP1 system implements new mechanisms for caching, event notification and change control, resulting in a unique architecture. The thesis introduces novel concepts of robustness and reflection for user interfaces, and delineates their implementation in the generic editor. Furthermore, a concept for code generators is presented that offers a particularly high degree of type-safety, which we call generator type-safety.

This thesis describes the AP1 system, which serves as a platform for model-based CASE technology. AP1 is a set of libraries and tools that support different activities in the software development process. It provides different layers of reusable CASE functionality, and thus facilitates CASE tool development and integration. Some key problems of software development are addressed, such as the storage and management of artifacts, their creation and modification, and the generation of program code. The main parts of the abstract platform are a typed repository for models and model data, and a generic editor that acts as an integrated software development environment (IDE). The former enables data integration; the latter serves as a basis for presentation integration. Both parts have an extensible and customizable architecture that makes it possible for developers to adapt the system to their own individual needs. The thesis discusses different data models, explaining why the parsimonious data model was chosen for the repository. A mapping onto the relational data model is given that makes it possible to leverage a RDBMS for data management. On top of the RDBMS, the AP1 system implements new mechanisms for caching, event notification and change control, resulting in a unique architecture. The thesis introduces novel concepts of robustness and reflection for user interfaces, and delineates their implementation in the generic editor. Furthermore, a concept for code generators is presented that offers a particularly high degree of type-safety, which we call generator type-safety.