In model-driven engineering (MDE), software is developed based on models which hence constitute the central artifacts in the software development process. Consequently, tools supporting MDE, such as model editors, interpreters, and debuggers are crucial in MDE. For developing such tools efficiently, modeling languages have to be defined formally. While for formally defining a modeling language's syntax standard means exist, this is not the case for defining its semantics. This impedes the efficient development of tools which build upon the modeling language's semantics, such as model interpreters, debuggers, and testing environments. To overcome this limitation, we present an approach for formally defining the semantics of modeling languages making use of the standardized and UML 2 compliant action language foundational UML (fUML).
Over the past years, the software development methodology model-driven
engineering (MDE) gained significant popularity as it is a promising approach to address the
growing complexity of the software systems that have to be built today [
The abstract syntax of a modeling language defines the modeling language’s
concepts and their relations. For formally defining the abstract syntax, metamodels are the
standard means. MOF [
The behavioral semantics of a modeling language defines the execution behavior
of conforming models. A formal specification of the behavioral semantics is not only
needed for precisely and unambiguously defining the behavior of models, but also to
1 In the remainder of this paper we will refer to tools for MDE, which are based on the definition
of a modeling language, as model-based tools.
establish the basis for an efficient development of model-based tools which build upon
the behavioral semantics of a modeling language, such as model interpreters, debuggers,
and testing environments [
The behavioral semantics of many modeling languages, including widely adopted
languages such as UML [
A commonly used approach to make models executable is to utilize code generators or to develop model interpreters with general-purpose programming languages (GPLs). However, in this approach the behavioral semantics is encoded in the manually constructed code generation templates or model interpreter implementations and hence is only defined implicitly. A problem that arises is that the behavior of models can again not be analyzed easily. Furthermore, the semantics can hardly be extended and reused which makes it costly to create and maintain.
To overcome these limitations, adequate techniques for formally and explicitly specifying the behavioral semantics of modeling languages are needed. This need stimulated intensive research resulting in various approaches proposed in the past which can be divided into translational approaches and operational approaches.
In translational approaches, models conforming to a modeling language are
translated into models conforming to another language whose semantics is formally and
explicitly defined. The advantage of this approach is that tools available for the target
language can be used for the translated models. Its drawback, however, is that a
translation from the source into the target language as well as a mapping of results obtained for
the translated models to the original models have to be developed. Examples for
translational approaches are the work of Chen et al. [
In the operational approach, the behavioral semantics is directly introduced into the
modeling language without moving to another language. This can be done by utilizing
graph transformations as for instance proposed by Engels et al. [
Despite the fact that several approaches for formally and explicitly specifying the
behavioral semantics of modeling languages exist, none of these approaches is widely
adopted especially in industry. Moreover, the challenge of automatically generating
model-based tools from semantics specifications is only addressed by few approaches
which provide only partial solutions [
To use fUML as semantics specification language and leverage the semantics specification of a modeling language to execute conforming models, the following challenges had to be addressed. First, fUML had to be integrated with existing metamodeling languages. Second, state-of-the-art metamodeling methodologies and environments had to be adequately extended to support a systematic and efficient development of behavioral semantics specifications based on fUML. Third, a generic model interpreter had to be developed to enable the execution of models based on the behavioral semantics specification of the modeling language they conform to.
To enable the usage of fUML for specifying the behavioral semantics of modeling
languages, we identified two strategies: a transformation-based and an integration-based
strategy [
Based on xMOF we elaborated a tool-supported methodology for developing the behavioral semantics of modeling languages (cf. Figure 1). The input for the semantics specification is the Ecore-based metamodel of a modeling language. As preparatory step we automatically generate a subclass for each metaclass defined in the metamodel. The language designer then adds operations and their implementations in the form of activities to these subclasses, which specify the behavior of the metaclasses. By subclassing the metaclasses for specifying their behavioral semantics, the behavioral semantics specification is clearly separated from the abstract syntax specification. This Semantics Specification
Syntax (Ecore) Model Execution Modeling Language Definition
(xMOF) Syntax Semantics (Ecore) (fUML)
Semantics Initialization Model
Semantics (fUML) [initial] xMOF2fUML Conversion Instance Conversion
Semantics
Specification fUML Model fUML Input
Values
Semantics (fUML) [complete] Model Execution
Execution Output Execution
Trace Execution Events
Caption:
Artifact
Task Automated
Task
Manual in/out relation Model-based Tools
Model Debugging
Model Testing Model Analysis … fosters reusability and flexibility in the semantics specification and facilitates the seamless integration of the development of a modeling language’s behavioral semantics into existing metamodeling methodologies and environments which are by our methodology only extended concerning the semantics specification.
Having the behavioral semantics of a modeling language defined using xMOF, our
approach enables to execute conforming models based on this semantics specification
by leveraging the fUML VM2. For this, we automatically convert the modeling
language definition into an fUML compliant model. In this conversion, metaclasses are
converted into fUML classes and the implementations of the metaclasses’ operations
(in the form of activities) are converted into fUML activities. Furthermore, the
elements of the model to be executed are converted into corresponding fUML objects, i.e.,
instances of the fUML classes generated for the metaclasses of the model elements, and
are provided as input to the fUML VM. The fUML VM interprets the activities and
manipulates the objects, which represent the executed model, accordingly. The primary
output of the model execution is the set of manipulated objects which represents the
runtime state of the executed model after the model execution finished and is provided
to the user in the form of model annotations. For enabling the observation and
analysis of a model execution being carried out we extended the fUML VM in previous
work [
Formalizing the behavioral semantics of modeling languages and leveraging this
formalization for automatically generating model-based tools building upon the modeling
languages’ semantics is an open challenge in MDE [
To qualitatively evaluate the applicability of our semantics specification approach based on fUML, we carried out case studies in which we developed the behavioral semantics specifications of distinct modeling languages using xMOF. In summary, the case studies confirmed that the proposed metamodeling language xMOF as well as its accompanying tool-supported methodology are applicable for defining the behavioral semantics of different kinds of modeling languages. Moreover, by utilizing the generic model interpreter based on the fUML VM it was possible to execute models conforming to the modeling languages by interpreting their semantics specifications. Regarding the suitability of fUML as action language for metamodeling we come to the conclusion that due to its object-oriented and imperative nature, fUML is highly suitable as semantics specification language. The case studies also revealed possible improvements of our approach regarding the reusability of semantics specifications and tooling. Furthermore, we recognized that the runtime information about the execution of a model provided by our generic model interpreter in the form of execution events and an execution trace helps in debugging and analyzing the xMOF-based semantics specification as they provide detailed information about the executed fUML activities contained in the semantics specification. However, to also provide this detailed runtime information to the modeler, the execution events and trace should be tailored to the respective modeling language as the modeler is only concerned with the concepts of the modeling language and not with its semantics specification in terms of fUML activities.
Our research is concerned with formally specifying the behavioral semantics of modeling languages using fUML and utilizing the semantics specifications for efficiently developing model-based tools building upon the behavioral semantics of modeling languages. Our implementation of a generic model interpreter capable of executing models based on the semantics specification of the used modeling language defined with fUML is only the first step towards addressing the challenge of generating model-based tools from a modeling language’s semantics specification. We will, in future work, further investigate methods for generating model-based tools from fUML-based semantics specifications. In particular, we are currently investigating the semi-automatic generation of model debuggers. Furthermore, we will carry out a large-scale case study applying our proposed semantics specification approach to fUML itself. This case study serves two purposes; first, we will evaluate the applicability and scalability of our semantics specification approach and second, having defined the behavioral semantics of fUML in fUML enables to bootstrap fUML’s model execution capabilities for instance to support a larger subset of UML without extending the fUML VM itself.