The task of interfacing sub-simulators in a co-simulation often remains difficult, tedious, and prone to error. Here, we describe how this process, and the validation of the resulting interface connections, can be made simpler, faster, and more reliable. Especially when, as is often the case, several individuals or teams collaborate on modeling and simulating a full system. This is achieved by grouping functional mock-up interface (FMI) variables into types close to the relevant engineering domains using semantics formalized as an ontology. Several benefits, we argue, are gained from this: clearer communication, increased validation potential, and reduced number of interface connections to deal with. The validity and the limitations of our approach are demonstrated with a detailed case study of a real maritime system: A dynamic positioning (DP) hardware controller connected to several independent co-simulation models via 156 variables in 78 connections. The proposed solution greatly reduces the complexities and the error potential related to interfacing such systems. All results including reference implementations are openly available through the open simulation platform.

Conceptual models represent the world, but the world changes over time, and is different, to some extent, depending on who you ask. To cater for these aspects, conceptual models must address the representation of temporality and subjectivity. Although some work has been done to incorporate these aspects into conceptual modelling languages, no mainstream language incorporates explicit support for temporality and subjectivity in relation to the existence and predication on the represented entities. In this article, I propose an approach to conceptualising and implementing temporality and subjectivity into conceptual modelling languages as cross-cutting aspects that provide built-in language primitives to the modeller while not imposing any particular manner to represent time or subjects. The approach has been adopted by ConML, a conceptual modelling language geared towards the humanities and social sciences, implemented in the Bundt software tool, and applied to a number of research projects.

Modern enterprise systems are likely to have a very long life. Their specifications therefore need to employ mechanisms that allow them to evolve during their lifetime; where they exploit generic components, these must be adaptable for use in novel situations. The paper looks at some of the issues that arise from this requirement, and how the exploitation of domain-specific language technologies in the tool-chain can assist in maintaining consistency of the specification as a whole. First, it reviews the final state of the family of standards supporting the ODP Enterprise Language, which is intended to handle this kind of application. In particular, it looks at the way the framework for defining policies can be used to accommodate changing requirements during the lifetime of an evolving system. It also looks at the way the idea of deontic tokens enables factoring out of the management of obligations from the basic behaviour of interacting system components. It then proposes a roadmap for building tools that can be used to unify the constraints from different areas of concern into a single specification. The approach taken is to exploit the power of domain-specific languages (DSLs) to allow designers in the various areas of concern to provide their input in terms natural to them. Finally, it looks at the way this approach promotes the establishment of a robust tool-chain capable of handling the evolution and scalability of enterprise systems. The paper uses a running example from the e-health domain to show how specific areas identified in the e-health standards can lead to language definitions, and so to tooling, that can be used to manage unified, system-wide specifications.

MDE enables the centrality of the models in semi-automated development processes. However, its level of usage in industrial settings is still not adequate for the benefits MDE can introduce. This paper proposes a semi-automatic approach for the completion of high-level models in the lifecycle of critical systems, which exhibit an event-driven behaviour. The proposal suggests a specification guideline that starts from a partial SysML model of a system and on a set of requirements, expressed in the well-known Given–When–Then paradigm. On the basis of such requirements, the approach enables the semi-automatic generation of new SysML state machines model elements. Accordingly, the approach focuses on the completion of the state machines by adding proper transitions (with triggers, guards and effects) among pre-existing states. Also, traceability modelling elements are added to the model. Two case studies demonstrate the feasibility of the proposed approach.

Abstract Like conventional software projects, projects in model-driven software engineering require adequate management of multiple versions of development artifacts, importantly allowing living with temporary inconsistencies. In previous work, we have introduced multi-version models for model-driven software engineering, which allow checking well-formedness and finding merge conflicts for multiple versions of the same model at once. However, situations where different models are linked via automatic model transformations also have to be handled for multi-version models. In this paper, we propose a technique for jointly handling the transformation of multiple versions of a source model into corresponding versions of a target model. This enables the use of a more compact representation that may afford improved execution time of both the transformation and further analysis. Our approach is based on the well-known formalism of triple graph grammars and the aforementioned encoding of model version histories called multi-version models. In addition to batch transformation of an entire history, the technique covers incremental synchronization of changes in the framework of multi-version models. Our solution is complemented by a dedicated pattern matching technique for multi-version models. We show the correctness of our approach with respect to the standard semantics of triple graph grammars and conduct an empirical evaluation to investigate the performance of our technique regarding execution time and memory consumption. Our results indicate that the proposed solution affords lower memory consumption and may improve execution time for batch transformation of large version histories, but can also come with computational overhead in unfavorable cases.

The paper proposes universal conceptual modeling, conceptual modeling that strives to be as general-purpose as possible and accessible to anyone, professionals and non-experts alike. The idea of universal conceptual modeling is meant to catalyze new thinking in conceptual modeling and be used to evaluate and develop conceptual modeling solutions, such as modeling languages, approaches for requirements elicitation, or modeling tools. These modeling solutions should be usable by as many people and design agents as possible and for as many purposes as possible, aspiring to the ideals of universal conceptual modeling. We propose foundations of universal conceptual modeling in the form of six principles: flexibility, accessibility, ubiquity, minimalism, primitivism, and modularity. We then demonstrate the utility of these principles to evaluate existing conceptual modeling languages and understand conceptual modeling practices. Finally, we propose future research opportunities meant to realize the ideals of universal conceptual modeling.

603