Model interoperabilty in MDE: a lost battle?

If you have been extensively using software modeling tools, you have probably experienced the awful situation where you want to move models from one tool to the other, but this ends up not being possible.
Why? Because you are using different languages? Not at all: even just moving a “standard” model from a modeler to another is a pain.
Concretely, each tool stores and manages the models with its own internal format or its own “dialect”, even if a standard format is adopted.

This is a major concern for developers, who need to check every time the actual possibility of exchanging the same kinds of models between editors, and often still need to struggle finding the mappings and defining the bridges between the formats by themselves. This hampers the possibility of effectively exploiting different tools in the development process. This is is definitely a minus for the developers, since having several tools at hand to be used upon the same model could allow to use the different features provided by the different vendors, based on availability but also taste of the developer himself. For instance, in an ideal world a developer could design the models with a modeling tool MT1 (e.g., because the editor of MT1 is more usable and allows higher productivity) and then immediately move to another tool MT2 for the verification phase (e.g., because MT2 provides more precise or extensive rules), and to tool MT3 for model execution (code generation or model interpretation, e.g., because it’s not provided by other tools).
Even in the case of well established standards like UML or BPMN, their abstract definition is still not enough for leading modeling tools from different vendors to share their models in a seamless way.

Interoperability is addressed also by standardization bodies. They are well aware that the supposed role of facilitating communication and information interchange that (standard) models should cover, is not a reality yet.
To improve interoperability between modeling tools, standardization bodies have defined specific model interchange languages. Examples of these languages can be found both for GPLs and for DSLs.
The most known model interchange language is XMI (XML Metadata Interchange), a standard proposed by OMG for serializing and exchanging UML models. Unfortunately, even if this has been devised as an interchange format, different tools still adopt it with different flavors. Therefore, the need arises of constraining the language even more. That’s why OMG is now running an activity for defining a canonical version of XMI (Canonical XMI), which is a strict subset of XMI and forces the adopters to follow stricter constraints.
A similar situation can be found in the most popular DSLs too. For instance, BPMN has an interchange counterpart in the XPDL language (XML Process Definition Language). In turn, this interchange language suffers of the same problems of XMI. Indeed, it is very difficult to actually move BPMN projects from a modeling environment to another.

This leads to my initial question:

  • Is modeling interoperability a moving target that will never be reached? 
  • Is it doomed to fail anyway and anyhow?

To keep updated on my activities you can subscribe to the RSS feed of my blog or follow my twitter account (@MarcoBrambi).

Bruce Silver’s keynote speech at BPMN 2011 workshop: interoperability and other issues in BPMN and UML

Today at the BPMN 2011 workshop in Luzern, Bruce Silver gave an interesting talk on the status of BPMN 2.0, its adoption, and his proposal for improving its general usage.
I really appreciated the talk because:

  • it focused on the ambiguities of the BPMN notation, even in the so acclaimed 2.0 version
  • it highlighted how users tend to be confused once the notation is so complex.

Bruce presented his well-known approach, with the caveat that probably method and style is too weak as a position, so he proposes to move to the rules term, so that people feel somehow more obliged to comply 🙂 .

    The first issue I take away is the problem of interoperability.
    I would also identify a trend on what I heard here, through a parallel to what is happening in OMG within the Canonical XMI initiative (read something here), performed by the Canonical XMI Finalization Task Force: given a modeling language (or an exchange format like XMI) which is under-specified, too general, or too open for dialects generation, the need arises for putting some stricter limitations to the designers, for making the tools more interoperable and for improving the quality of the models. Interoperability is the explicit aim of XMI, but, since it failed to an extent. Probably the same would apply to XPDL itself: it was designed as an interchange format for business process models, but then ended up being prone to several dialects and interpretations as well. For XMI, the improved interoperability aim is now in charge of Canonical XMI (while no action is being taken on XPDL).  The same purpose is addressed by the BPMN-I initiative by Bruce Silver.

    A similar problem that has been addressed is executability:
    Also on this, I see strong parallelism with the UML world. There is definitely a push towards executability of models: just think about the executable UML fUML and Alf initiatives (you can find a nice overview on both on Jordi’s blog here), at OMG or also some new activities like MiUML, an open-source executable UML project.
    On the other side, also BPMN 2.0 is addressing executability and within WebRatio we are also providing somehow a pragmatic approach to BPMN executability, by generating running Web applications. The question is: are customers asking for that? The claim by Bruce is that they are not for BPMN. Most people only want to model, not to execute. Probably, if you look at the share of interested people, for UML it’s the same. However, I think executability is an interesting property that should be granted to give a general grounding to reality to models (although I acknowledge that some models may not need/allow that).

    A final take from the day is related to choreography.
    Interestingly enough, again people are not using it: neither in the BPMN world nor in the UML one. I don’t have stats on the usage of the different kinds of UML models, but I’m pretty sure people only use class diagrams basically. Some will use activity diagrams, and few sequence diagrams. Anything else?

    Bruce Silver, with Bruce Silver Associates,
    presenting his keynote at the BPMN 2011 workshop.

    To keep updated on my activities you can subscribe to the RSS feed of my blog or follow my twitter account (@MarcoBrambi).