Dans cette thèse, nous proposons une approche rigoureuse pour la conception et le développement de systèmes à base de composants hiérarchiques distribués. L’idée de base du travail présenté est de combiner les techniques de conception de logiciels dirigées par les modèles, bien connues des programmeurs, avec des méthodes de vérification formelles puissantes, capables d’assurer les propriétés fonctionnelles d’un système distribué et de détecter les erreurs dès le stade de la conception. Tout d’abord, nous introduisons un formalisme graphique basé sur UML pour l’architecture et le comportement des composants hiérarchiques de modélisation. Deuxièmement, nous spécifions formellement un ensemble de contraintes qui assurent la correction de la composition des composants, en mettant l’accent sur la séparation entre les aspects fonctionnels et non-fonctionnels. Troisièmement, nous expliquons comment nos modèles graphiques peuvent être traduits automatiquement dans le formalisme d’entrée d’un model-checker. Nous nous concentrons ensuite sur le codage des fonctionnalités avancées de composants distribués, comme communications de 1 vers N, la reconfiguration et les communications asynchrones basées sur les appels de procédures distants. Enfin, nous mettons en oeuvre cette approche dans une plateforme intégrée orienté modèle qui comprend un ensemble d’éditeurs graphiques, un module de validation de la décision correcte de l’architecture statique, un module traduisant le modèle conceptuel dans une entrée pour la plateforme de vérification CADP, et enfin un générateur de code exécutable / In this thesis we introduce an approach for rigorous design and development of distributed hierarchical component-based systems. The core idea of the presented work is to combine the well-known among the programmers techniques for modeldriven software design and the powerful formal verification methods able to ensure the functional properties of a distributed system and to detect errors at the early design stage. First, we introduce a UML-based graphical formalism for modelling architecture and behaviour of hierarchical components. Second, we formally specify a set of constraints that ensure the correct components composition with a focus on separation between the functional and non-functional aspects. Third, we explain how the graphical models can be automatically translated into an input for a model-checker. For this aim, we rely on a formally specified intermediate structure encoding the semantics of components behaviour as a network of synchronised parametrised label transition systems. We focus here on encoding the advanced features of distributed components such as one-to-many communications, reconfiguration, and asynchronous communications based on request-reply. Finally, we implement the approach in an integrated model-driven environment which comprises a set of graphical editors, an architecture static correctness validation plug-in, a plug-in translating the conceptual model into an input for a verification toolsuite CADP, and a generator of the implementation code

Current advances in the software development industry are growing more ubiquitous by the day. This has caused for security, not only in the broader sense, but specifically within the design and overall development of software itself, to become all the more important. An evidently prevalent problem in the domain of software development is that software security is not consistently addressed during design, which undermines core security concerns, and leads to the development of insecure software. This research seeks to address this issue via a model for secure software design, which is based on a software design pattern, namely, the Model-View-Controller (MVC) pattern. The use of a pattern to convey knowledge is not a new notion. However, the ability of software design patterns to convey secure software design is an idea worth investigating. Following identification of secure software design principles and concepts, as well as software design patterns, specifically those relating to the MVC pattern, a model was designed and developed. With the MVC pattern argued as being a suitable foundation for the model, the security conscious MVC (SecMVC) combines secure software design principles and concepts into the MVC pattern. Together herewith, the MVC pattern’s components in the MVC Compound pattern, namely: the Observer pattern, the Strategy pattern, and the Composite pattern, have provided further sub-models for less abstraction and greater detail. These sub-models were developed, as a result of the SecMVC model’s evaluation in the validation for this study, an expert review. Argued in the light of similar research methods, the expert review was chosen – along with a process that included the use of two expert participants to validate the SecMVC model. It was determined through the expert review that the SecMVC model is of sufficient utility, quality, and efficacy to constitute research value. The research methodology process followed was design science, in which the SecMVC model, which includes its related sub-models, serves as the artefact and research output of this study. This research study contributes evidence of the feasibility for integrating knowledge into software design patterns. This includes the SecMVC model itself. In addition, it argues for the use of an expert review, as an evaluative research method for such an artifact.

Value-based hospital is a concept that is causing a major transformation of hospitals and their information systems. Currently, hospitals are organized by medical units and by specialties that tend to operate as separate silos, without much communication between them. The transitions of care are not optimal for the patients, thus negatively impacting patient outcomes. Value-based hospitals focus on groups of patients with similar conditions, and end-to-end care pathways like Hip & Knee Replacement. They organize service lines that provide end-to-end care for these patient groups through the Emergency Department, Diagnostic Imaging, Lab tests, the surgical procedure in the Operating Room, the stay in the Surgery unit, Rehabilitation, and then discharge from the hospital. To enact such a transformation, hospitals have to redesign their Clinical Operations Management (care processes and organization) and the supporting information systems. Enterprise Architecture is the discipline, defined by international standards bodies, which concerns itself with transformational change of large complex organizations supported by information technology. Model-Driven Engineering is an approach to designing and generating information systems based on models. This thesis proposes an Enterprise Architecture for Model-Driven Clinical Operations Management (COM) to address the required transformation and improvement of clinical information systems to support value-based hospitals. The first thesis contribution is an Enterprise Architecture for Model-Driven COM in value-based hospitals, including COM Models, UML/BPMN/DMN Models, an Architecture and Design for a Clinical Operations Support System (COSS) for COM, and four COM Diagrams and Templates. The COM Models are the Business Architecture of the Enterprise Architecture; they are the foundation of our model-driven transformation approach. The UML/BPMN/DMN Models are derived from the COM Models, and are the Information System Architecture of the Enterprise Architecture. The COSS for COM, generated from the above models, is the Technology Architecture of the Enterprise Architecture. Finally, the COM Diagrams and Templates enable to better communicate the Enterprise Architecture; they are the COM Functions Table, the COM Enterprise Architecture Diagram, the COM Service Line Template, and the COSS Architecture Diagram. A second thesis contribution is the design of two domain-specific model-driven tools, based on the Eclipse environment, which support the design and generation of information systems support of COM in a value-based hospital. The COMP Tools include a Modeling Tool for COM based on a COM Functions Table for Hospitals, a Domain-Specific Modeling Language for COM (COMP: the COM Profile), and its Meta Model. The COSBench software development workbench provides support to the Model-Driven Engineering of information systems for COM. Finally, a third contribution is examples of COM Models for Joint Replacement service line and for Cardiac Procedures service line, used in our case studies to illustrate and validate the approach. There are also examples of COSS Decision Support Systems for patient flow management, operational business intelligence, full-capacity protocol, demand management, and capacity management.

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.

This thesis analyzes the situation in the area of Business Intelligence at O2 Czech Republic. It focuses on identifying key issues and finding solutions to the overall improvement of the service within the company. It can be a guide for managers on how to proceed in the analysis of the BI environment, finding opportunities for improving organization setup and technical aspects, especially in the data warehouse solution. Here one can also find recommendations on how to proceed with the definition of development methodologies and how to effectively set the tools and processes associated with the development of the data warehouse. This approach results in an efficient, clearly documented and sustainable development concept of the data warehouse in a large company.

In this thesis, we present mixsets, an approach to combine annotative and compositional fragments for specifying code variants to form software product lines (SPLs). There are three key contributions of our research: introducing mixsets to represent software variability, extending mixsets to construct feature models, and improving software composition to achieve fine-grained variability. The concept of mixsets is introduced in Umple as a conditional unit and a first-class entity to allow smoothly transitioning software to compositional SPLs. A mixset is a named set of mixins; each mixin belonging to the mixset is called a fragment. A mixset fragment can be a top-level entity that contains nested entities or can be embedded as a conditional fragment in other entities such as methods. Mixset content normally includes code blocks or statements of any type, and may include require statements, which describe explicit dependencies among mixsets. Mixsets can be used to specify product lines using code composition, code annotation or both. A strength of mixsets lies on the straightforward mechanism to transform annotated segments into compositional segments when used in a combined approach. Therefore, preplanning effort and time to transform annotative SPLs to compositional SPLs can be reduced. Mixsets can provide a backbone structure to realize product line features in a feature-based SPL. Hence, a feature model can be formed using a subset of specific dependent mixsets. Feature interactions within an SPL can be identified and separated in specific modules by mixset nesting. Furthermore, product configuration, feature modeling analysis and generation of feature diagrams can be accomplished based on mixsets. The thesis also demonstrates a method to enable the granularity of compositional approaches to be expressed at the statement level. This is achieved by allowing aspects to inject code into labelled places, or points of variation, within method code. Such injected code has a full access to the context in which its placed, such as access to local variables. Mixsets are implemented in Umple, a model-driven development (MDD) technology that allows combining abstract models, such as associations and state machines, with pure code, and generating code in multiple programming languages. Mixsets can thus be used to describe variations in models, not just code. The thesis uses a design science approach as its research methodology. The mixset concept is evaluated through three case studies. The first applies mixsets to the Oracle Berkeley Database SPL, which is used in other literature to evaluate SPL concepts. This study shows that the mixset implementation improves on the state of the art in several respects, such as elimination of complex workarounds that are required by other approaches. In the second study, mixsets help to refactor Umple into feature-oriented SPL. The case study shows how annotative fragments can be easily transformed into compositional counterparts. In the third study, mixsets help to present two alternative solutions the to the Rover Control Challenge Problem of the MDETools 2018 workshop.

The major motivation for self-adaptive computing systems is the self-adjustment of the software according to a changing environment. Adaptive computing systems can add, remove, and replace their own components in response to changes in the system itself and in the operating environment of a software system. Although these systems may provide a certain degree of confidence against new environments, their structural and behavioral changes should be validated after adaptation occurs at runtime. Testing dynamically adaptive systems is extremely challenging because both the structure and behavior of the system may change during its execution. After self adaptation occurs in autonomic software, new components may be integrated to the software system. When new components are incorporated, testing them becomes vital phase for ensuring that they will interact and behave as expected. When self adaptation is about removing existing components, a predefined test set may no longer be applicable due to changes in the program structure. Investigating techniques for dynamically updating regression tests after adaptation is therefore necessary to ensure such approaches can be applied in practice. We propose a model-driven approach that is based on change propagation for synchronizing a runtime test model for a software system with the model of its component structure after dynamic adaptation. A workflow and meta-model to support the approach was provided, referred to as Test Information Propagation (TIP). To demonstrate TIP, a prototype was developed that simulates a reductive and additive change to an autonomic, service-oriented healthcare application. To demonstrate the generalization of our TIP approach to be instantiated into the domain of up-to-date runtime testing for self-adaptive software systems, the TIP approach was applied to the self-adaptive JPacman 3.0 system. To measure the accuracy of the TIP engine, we consider and compare the work of a developer who manually identifyied changes that should be performed to update the test model after self-adaptation occurs in self-adaptive systems in our study. The experiments show how TIP is highly accurate for reductive change propagation across self-adaptive systems. Promising results have been achieved in simulating the additive changes as well.

Les travaux de recherche présentés dans ce mémoire se situent dans les thématiques de la génération des applications interactives et de la personnalisation du contenu. Cette thèse propose une approche de type MDA (Model Driven Architecture), indépendante du domaine d’application, permettant la conception et la génération semi-automatique des applications interactives à contenus personnalisés, compte tenu des informations sur le contexte d’utilisation et l’ontologie de domaine. Cette approche met en œuvre deux méthodes de personnalisation du contenu, à savoir le remplissage automatique des formulaires et l’enrichissement des requêtes. Pour atteindre cet objectif, nous avons développé la solution technique permettant la conception, la transformation des modèles ainsi que la génération de l’IHM (Interface Homme-Machine) finale. / The research work presented in this thesis belongs to the fields of interactive applications generation and content personalization. This thesis proposes an MDA (Model Driven Architecture) approach, independent of the domain application, allowing the design and the semi-automatic generation of personalized content interactive applications. This generation relies on context information and the domain ontology. This approach implements two content personalization methods ; namely the forms auto-filling and the automatic queries enrichment. To achieve this goal, we developed the technical solution allowing the design, the models transformations as well as the generation of the final HCI (Human-Computer Interface).

In the digital age that we live in today, we are dependent on numerous web applications or services, from dealing with banking, booking air flights, and handling our taxes. We expect these applications and services to support high availability, data loss prevention, and fast response time. Microservices is a design pattern to support faster software change, and it also supports other non-functional attributes such as scalability and high availability. One way to deploy your software as microservices is to use containers and deploy them on a container cluster such as Kubernetes. The public opinion about writing Kubernetes deployment files is that it is complex and repetitive writing. This project aims to see how model-driven development can assist with the creation of the Kubernetes deployment files. To see how model-driven development can assist in the creation of Kubernetes files. The project will implement a domain-specific modeling language for Kubernetes, and the language should be able to model the application's desired states. And by using model transformation, the tool can generate Kubernetes deployable files.

Researchers in software engineering proposed design method for distributed applications to construct a set of communicating system components from a global behavior. The joint behaviors of these components must precisely satisfy the specified global behavior. The next concern is to transform the constructed models of these components into executable business processes by ensuring the exchange of asynchronous messages among the generated business processes. The introduction of Service-Oriented Architecture (SOA) has helped to achieve this goal. SOA provides high flexibility in composing loosely-integrated services that can be used among business domains to carry out business transactions; this composition is known as service orchestration. Moreover, SOA supports Model Driven Architecture (MDA) such that services modeled as UML Activity Diagrams (AD) can be transformed into a set of Business Execution Language (BPEL) processes. Many researchers discussed the transformation of UML AD and the Business Process Modeling Notation (BPMN) into BPEL. However, they did not discuss the practical limitations that some of these transformations impose. This thesis addresses the imitations of the transformation from UML AD to BPEL processes using the IBM Rational Software Architect (RSA). We showed here that the tool is unable to create the correct BPEL artifacts from UML AD components in certain cases, for instance when the behavior includes the alternative for receiving single or concurrent messages, a weak loop, or certain choice activities. Furthermore, we provided novel solutions to the transformations in these cases in order to facilitate the transformation from UML AD to BPEL.