Executable Modeling Language Research Articles

An executable domain-specific modeling language for simulating organizational auction-based coordination strategies for crisis response

Emergency response environments in which the crisis occurs include many homogenous and heterogeneous entities, e.g., organizations and persons. These entities need to collaborate to address a crisis. However, most of the time, the organizations that are involved in a crisis suffer from communication and coordination problems. This may cause unfair resource distribution. To mitigate the problem, there is a pressing need to construct models of emergency response environments and simulate the coordination strategies proactively, before the onset of any crisis. This paper highlights the complexity of the system formed by interacting organizations during a crisis and the difficulty in programming for the simulation of such complex systems. To cope with this issue, this paper presents an executable domain-specific modeling language called CoorERE. The language facilitates modeling emergency response environments for the simulation of one of the most common coordination strategies, i.e., auction-based coordination strategies in crisis response. CoorERE is used for the graphical modeling of emergency response environments and simulation of both inter and intra-organizational auction-based coordination strategies. The paper presents two case studies with different complexities to show the applicability of CoorERE. An empirical study is conducted to compare CoorERE with MDD4ABMS, which is one of the most recent tools for modeling and simulation of multi-agent systems. The evaluation includes both objective and subjective assessments. The objective assessment considers the development effort required for modeling a complete case study, while the subjective assessment compares the tools in terms of satisfying modeling method requirements and quality metrics such as usability, productivity, and expressiveness. The results of the evaluation indicate that CoorERE reduces the development effort by about 47%. In terms of quality metrics, CoorERE obtained higher scores than MDD4ABMS for all the measurements considered, indicating its superior usability, productivity, and expressiveness.

A generic framework for representing and analyzing model concurrency

Recent results in language engineering simplify the development of tool-supported executable domain-specific modeling languages (xDSMLs), including editing (e.g., completion and error checking) and execution analysis tools (e.g., debugging, monitoring and live modeling). However, such frameworks are currently limited to sequential execution traces and cannot handle execution traces resulting from an execution semantics with a concurrency model supporting parallelism or interleaving. This prevents the development of concurrency analysis tools, like debuggers supporting the exploration of model executions resulting from different interleavings. In this paper, we present a generic framework to integrate execution semantics with either implicit or explicit concurrency models, to explore the possible execution traces of conforming models, and to define strategies for helping in the exploration of the possible executions. This framework is complemented with a protocol to interact with the resulting executions and hence to build advanced concurrency analysis tools. The approach has been implemented within the GEMOC Studio. We demonstrate how to integrate two representative concurrent meta-programming approaches (MoCCML/Java and Henshin), which use different paradigms and underlying foundations to define an xDSML’s concurrency model. We also demonstrate the ability to define an advanced concurrent omniscient debugger with the proposed protocol. The paper, thus, contributes key abstractions and an associated protocol for integrating concurrent meta-programming approaches in a language workbench, and dynamically exploring the possible executions of a model in the modeling workbench.

Towards the adoption of OMG standards in the development of SOA-based IoT systems

A common feature of the Internet of Things (IoT) is the high heterogeneity, regarding network protocols, data formats, hardware and software platforms. Aiming to deal with such a degree of heterogeneity, several frameworks have applied the Model-Driven Development (MDD) to build IoT applications. On the software architecture viewpoint, the literature has shown that the Service-Oriented Architecture (SOA) is a promising style to address the interoperability of entities composing these solutions. Some features of IoT make it challenging to analyze the impact of design decisions on the SOA-based IoT applications behavior. Thus, it is a key requirement to simulate the model to verify whether the system performs as expected before its implementation. Although the literature has identified that the SOA style is suitable for addressing the interoperability, existing modeling languages do not consider SOA elements as first-class citizens when designing IoT applications. Furthermore, although existing MDD frameworks provide modeling languages comprising well-defined syntax, they lack execution semantics, thus, are not suitable for model execution and analysis. This work aims at addressing these issues by introducing IoTDraw. The framework provides a fully OMG-compliant executable modeling language for SOA-based IoT systems; thus, its specifications can be implemented by any tool implementing OMG standards.

DSML4CS

Cyber physical systems (CPS's) are a kind of complex system with highly integrated interaction between computing resources and physical environment in a network environment. There are some challenges in modeling and simulation of heterogeneous CPS due to its hybrid and heterogenous characteristics. To address the issue, we propose an executable domain specific modeling language for co-simulation (DSML4CS) to model the co-simulation of CPS. According to the construction method of domain modeling language, we present the abstract syntax, concrete syntax and operational semantics of DSML4CS. We also propose a flexible co-simulation mechanism, which supports partial step revision of specific co-simulation process with the state event fault-tolerant mechanism. The co-simulation language for heterogeneous CPS is implemented based on the GEMOC platform. Our aim is to provide the co-simulation service in CPS. The usability of DSML4CS is illustrated with a case study of a temperature control system in an energy-aware building.

Beyond Model-Based Systems Engineering towards Managing Complexity

Abstract Systems Engineering domain lacks in methodologies for integration of development artefacts (e.g. requirements, functions, geometrics, or behavior) and enterprise models (e.g. organizational structures, processes, or IT infrastructure). Especially the rising complexity driven by integrated product service systems, smart services, systems of systems and cyber physical systems (CPS) leads to a new paradigm further on called Advanced Systems Engineering (ASE). It empowers enterprises to cope with such complex developments. The employment of ASE technologies in design and manufacturing enterprises requires a reachability of technical information and continuity along vertical and horizontal dimensions. A widely used approach to implement this is Model-based System Engineering (MBSE). This paper introduces a solution to achieve the goals of manufacturing excellence as well as complexity management by identifying and analyzing relevant requirements and possible approaches for an innovative simulation enabling and executable modelling language, the so-called advanced MBSE+.

Lossless compaction of model execution traces

Dynamic verification and validation (V&V) techniques are used to verify and validate the behavior of software systems early in the development process. In the context of model-driven engineering, such behaviors are usually defined using executable domain-specific modeling languages (xDSML). Many V&V techniques rely on execution traces to represent and analyze the behavior of executable models. Traces, however, tend to be overwhelmingly large, hindering effective and efficient analysis of their content. While there exist several trace metamodels to represent execution traces, most of them suffer from scalability problems. In this paper, we present a generic compact trace representation format called generic compact trace metamodel (CTM) that enables the construction and manipulation of compact execution traces of executable models. CTM is generic in the sense that it supports a wide range of xDSMLs. We evaluate CTM on traces obtained from real-world fUML models. Compared to existing trace metamodels, the results show a significant reduction in memory and disk consumption. Moreover, CTM offers a common structure with the aim to facilitate interoperability between existing trace analysis tools.

Advanced and efficient execution trace management for executable domain-specific modeling languages

Executable Domain-Specific Modeling Languages (xDSMLs) enable the application of early dynamic verification and validation (V&V) techniques for behavioral models. At the core of such techniques, execution traces are used to represent the evolution of models during their execution. In order to construct execution traces for any xDSML, generic trace metamodels can be used. Yet, regarding trace manipulations, generic trace metamodels lack efficiency in time because of their sequential structure, efficiency in memory because they capture superfluous data, and usability because of their conceptual gap with the considered xDSML. Our contribution is a novel generative approach that defines a multidimensional and domain-specific trace metamodel enabling the construction and manipulation of execution traces for models conforming to a given xDSML. Efficiency in time is improved by providing a variety of navigation paths within traces, while usability and memory are improved by narrowing the scope of trace metamodels to fit the considered xDSML. We evaluated our approach by generating a trace metamodel for fUML and using it for semantic differencing, which is an important V&V technique in the realm of model evolution. Results show a significant performance improvement and simplification of the semantic differencing rules as compared to the usage of a generic trace metamodel.

The influence of cyclomatic complexity distribution on the understandability of xtUML models

Executable software models formalize functional software requirements. This means that the understandability of software models is of paramount importance. In this paper, we investigate the influence of cyclomatic complexity on the understandability of executable translatable unified modeling language (xtUML) models. We adapt traditional cyclomatic complexity metrics to different xtUML sub-models and present two different ways of measuring complexity distribution: horizontal, among elements of the same type, and vertical, among elements of different types. In order to test our hypothesis that cyclomatic complexity distribution influences the understandability of xtUML models, we have performed an experiment with student participants in which we have evaluated the understandability of three semantically equivalent xtUML models with different complexity distributions. Results indicate that a better distribution of cyclomatic complexity has a positive influence on model understandability.

TOWARDS A MULTI-SCALE AGENT-BASED PROGRAMMING LANGUAGE METHODOLOGY.

Living tissues are dynamic, heterogeneous compositions of objects, including molecules, cells and extra-cellular materials, which interact via chemical, mechanical and electrical process and reorganize via transformation, birth, death and migration processes. Current programming language have difficulty describing the dynamics of tissues because: 1: Dynamic sets of objects participate simultaneously in multiple processes, 2: Processes may be either continuous or discrete, and their activity may be conditional, 3: Objects and processes form complex, heterogeneous relationships and structures, 4: Objects and processes may be hierarchically composed, 5: Processes may create, destroy and transform objects and processes. Some modeling languages support these concepts, but most cannot translate models into executable simulations. We present a new hybrid executable modeling language paradigm, the Continuous Concurrent Object Process Methodology (CCOPM) which naturally expresses tissue models, enabling users to visually create agent-based models of tissues, and also allows computer simulation of these models.

Model-Driven Engineering of Self-Adaptive Software with EUREMA

The development of self-adaptive software requires the engineering of an adaptation engine that controls the underlying adaptable software by feedback loops. The engine often describes the adaptation by runtime models representing the adaptable software and by activities such as analysis and planning that use these models. To systematically address the interplay between runtime models and adaptation activities, runtime megamodels have been proposed. A runtime megamodel is a specific model capturing runtime models and adaptation activities. In this article, we go one step further and present an executable modeling language for ExecUtable RuntimE MegAmodels (EUREMA) that eases the development of adaptation engines by following a model-driven engineering approach. We provide a domain-specific modeling language and a runtime interpreter for adaptation engines, in particular feedback loops. Megamodels are kept alive at runtime and by interpreting them, they are directly executed to run feedback loops. Additionally, they can be dynamically adjusted to adapt feedback loops. Thus, EUREMA supports development by making feedback loops explicit at a higher level of abstraction and it enables solutions where multiple feedback loops interact or operate on top of each other and self-adaptation co-exists with offline adaptation for evolution.

Conceptual Model-Based Systems Biology: Mapping Knowledge and Discovering Gaps in the mRNA Transcription Cycle

We propose a Conceptual Model-based Systems Biology framework for qualitative modeling, executing, and eliciting knowledge gaps in molecular biology systems. The framework is an adaptation of Object-Process Methodology (OPM), a graphical and textual executable modeling language. OPM enables concurrent representation of the system's structure—the objects that comprise the system, and behavior—how processes transform objects over time. Applying a top-down approach of recursively zooming into processes, we model a case in point—the mRNA transcription cycle. Starting with this high level cell function, we model increasingly detailed processes along with participating objects. Our modeling approach is capable of modeling molecular processes such as complex formation, localization and trafficking, molecular binding, enzymatic stimulation, and environmental intervention. At the lowest level, similar to the Gene Ontology, all biological processes boil down to three basic molecular functions: catalysis, binding/dissociation, and transporting. During modeling and execution of the mRNA transcription model, we discovered knowledge gaps, which we present and classify into various types. We also show how model execution enhances a coherent model construction. Identification and pinpointing knowledge gaps is an important feature of the framework, as it suggests where research should focus and whether conjectures about uncertain mechanisms fit into the already verified model.

Observable behavior of distributed systems: Component reasoning for concurrent objects

Distributed and concurrent object-oriented systems are difficult to analyze due to the complexity of their concurrency, communication, and synchronization mechanisms. Rather than performing analysis at the level of code in, e.g., Java or C++, we consider the analysis of such systems at the level of an abstract, executable modeling language. This language, based on concurrent objects communicating by asynchronous method calls, avoids some difficulties of mainstream object-oriented programming languages related to compositionality and aliasing. To facilitate system analysis, compositional verification systems are needed, which allow components to be analyzed independently of their environment. In this paper, a proof system for partial correctness reasoning is established based on communication histories and class invariants. A particular feature of our approach is that the alphabets of different objects are completely disjoint. Compared to related work, this allows the formulation of a much simpler Hoare-style proof system and reduces reasoning complexity by significantly simplifying formulas in terms of the number of needed quantifiers. The soundness and relative completeness of this proof system are shown using a transformational approach from a sequential language with a non-deterministic assignment operator.

Platform-Variant Applications from Platform-Independent Models via Templates

By raising the level of abstraction from code to models, model-driven development (MDD) emphasises design rather than implementation and platform-specificity. This paper presents an experiment with a MDD approach, which takes platform-independent models and generates code for various platforms from them. The platform code is generated from templates. Our approach is based on EP, a formal executable modelling language, supplemented with OCL, and FTL, a formal language of templates. The paperʼs experiment generates code for the mobile platforms Android and iPhone from the same abstract functional model of a case study. The experiment shows the feasibility of MDD to tackle present day problems, highlighting many benefits of the MDD approach and opportunities for improvement.

Past–future separation and normal forms in temporal predicate logic specifications

Temporal specifications are often used when phenomena are modelled where dynamics play a main role. If simulation is one of the aims of modelling, usually a restricted, executable modelling language format is used, based on some form of past to future implications. In this paper a detailed transformation procedure is described that takes any temporal predicate logic specification and generates a specification in a past-implies-future normal format. The procedure works for temporal specifications in which the atoms either express time ordering relations or are state-related, i.e., include only one time variable.

The syntax and semantics of the PROforma guideline modeling language

PROforma is an executable process modeling language that has been used successfully to build and deploy a range of decision support systems, guidelines, and other clinical applications. It is one of a number of recent proposals for representing clinical protocols and guidelines in a machine-executable format (see 〈www.openclinical.org〉). In this report, the authors outline the task model for the language and provide an operational semantics for process enactment together with a semantics for expressions, which may be used to query the state of a task during enactment. The operational semantics includes a number of public operations that may be performed on an application by an external agent, including operations that change the values of data items, recommend or make decisions, manage tasks that have been performed, and perform any task state changes that are implied by the current state of the application. Disclosure: PROforma has been used as the basis of a commercial decision support and guideline technology Arezzo (Infermed, London, UK; details in text).

A modelling language for the design and execution of enterprise models in manufacturing

This paper proposes an enterprise modelling language (EML) for model-based shop floor control. To introduce a new computer executable modelling language, two modelling frameworks were analysed, namely the CIMOSA and GERAM frameworks. This language covers the different life cycle phases of enterprise modelling (design, implementation and operation), allowing an easy and fast transition from each phase to the next. In the operation phase the models can be used to control and monitor (on-line) the enterprise resources behaviour. Section 3 presents an example of an operational model, based on the proposed EML, for real-time enterprise activity control. Despite the fact that the proposed modelling language does not intend to be a full CIMOSA compliant language, it could easily be a first step in that direction. Section 4 tries to validate this hypothesis by showing how a CIMOSAmodel (functional view), could be built based on the proposed EML.

On Formal Semantics and Analysis of Typed Modeling Languages: An Analysis of Ascend

The use of strong typing, exemplified in the Ascend modeling language, is a recent phenomenon in executable modeling languages for mathematical modeling. It is also one that has significant potential for improving the functionality of computer-based modeling environments. Besides being a strongly typed language, Ascend is unique in providing operators that allow dynamic type inference, a feature that has been shown to be useful in assisting model evolution and reuse. We develop formal semantics for the type system in Ascend—focusing on these operators—and analyze its mathematical and computational properties. We show that despite the strong interactions between various statements involving the operators, the language does possess certain desirable mathematical and computational properties. Further, our analysis identifies general issues in the design and implementation of type systems in mathematical modeling languages. The methods used in the article are applicable beyond Ascend to a class of typed modeling languages that may be developed in the future.

Integrated Modeling Environments in Organizations: An Empirical Study

Considerable attention in the information systems and management science literature has focused on computer-based modeling environments, sometimes called integrated modeling environments or model management systems. This research has been primarily concerned with suggesting features/components of modeling environments such as improved executable modeling languages for model creation, integration, and data representation; specialized database systems for managing model data; and customized model-solver software. However, there has been little (if any) empirical guidance offered in the literature about the specific needs of business and industry for computer-based integrated modeling environments. Using a data set compiled from a national survey of modelers (analysts) and model users (decision makers), we empirically investigate the validity of several of the key assumptions of modeling environment research reported in the literature, and examine the relationships between the modeling factors: data complexity, model complexity, modeling intensity, modeler/user requirements, and need for computer-based integrated modeling environments in organizations. Our empirical analysis of the data set shows that practitioners rank automated access to model data and automated error checking (e.g., model syntax and semantics checking) high as desirable components in modeling environments. We find that users prefer to have modeling environments linked to their current modeling and modeling-support software systems. Our findings further suggest that a high percentage of modelers and users are dissatisfied with the software systems they are currently using to support their modeling activities. Finally, a covariance structure analysis of the modeling environment factors clearly shows that: (a) model complexity has a direct positive effect on modeling intensity; (b) data complexity has an insignificant direct effect on modeling intensity, but has a negative effect on modeler/user requirements; and (c) modeler/user requirements have a direct positive effect on need for computer-based integrated modeling environments in organizations.

Model-driven distributed systems

The work described in this article supports the view that distributed-system component behavior can be captured during system design and directly used to drive the system at runtime. The authors present methods for achieving this one step design and implementation of system behavior through the use of a Petri-net-based executable modeling language. This language provides a direct mapping between modeling constructs and executable code. The work is set in an industrial context through a real problem in electronics-manufacturing shop-floor system design. Through a description of the proposed facilities and their application in an industrial case study, the authors conclude that the decomposition of function, behavior, and system interaction better supports rapid distributed-system development and the required modification of systems to support business-process change.

Integrating dynamic environmental models in GIS: The development of a Dynamic Modelling language

An integrated, executable mathematical modelling language for environmental and ecological applications has been developed to create and run Dynamic Models in a GIS. The modelling language is embedded in the GIS, providing the ability to model complex space‐time systems free from the technical burdens of database management and algorithm optimization. The spatial modelling language uses a structured script, which is illustrated here by an example of a model of plant dispersion.