In (An efficient necessary condition for compatibility, 2009) the authors discuss a method to find out, if two services are compatible or not. This obviously presupposes that the behavior of the services is modeled. One method to do this is to use BPMN 2.0 and model two or more participants offering respective public processes.

Compatibility of the services is not so obvious in the first place. The question to be answered is, if for all possible sent messages the other participant (or service) is ready to process it, and if both can complete their control flow in all cases. For example if one participants sends an order cancellation, but the other participant cannot process it, because the order is already delivered, and it has no control flow to deal with the late cancellation, then the services are not compatible.

Typically this can be checked by comparing all possible states of all participants and all messages. However this brute force method consumes much memory and computing time. Probably this is one reason, why it is not yet offered in so many or even a modeling product at all – which I do not exactly know. The proposed method in (An efficient necessary condition for compatibility, 2009) is to use a method known from petri nets: to convert them into matrices (state equation) and use the matrices to determine the compatibility in a much more efficient way. This is definitely interesting to consider.

The paper states, that this can be used for service discovery and mediator construction. In my personal opinion these use cases are very advanced research use cases, which are not yet so relevant in the practical industry application. Even the mediator construction I have severe doubts, if this is a way that will lead to somewhere at all. But I might be convinced later.

But very relevant is to support the design process of services which need to interact. If there were a repository, that would contain such compatibility determination method – that would be a great step forward. Furthermore it would provide the industry use cases that are needed for further research on the matter.

References

An efficient necessary condition for compatibility. Oanea, Olivia und Wolf, Karsten. 2009. [Hrsg.] Oliver Kopp und Niels Lohmann. Stuttgart : Universität Stuttgart, Fakultät Informatik, Elektrotechnik und Informationstechnik, 2009. Services und ihre Komposition, Erster zentraleuropäischer Workshop, ZEUS 2009. Bd. CEUR Workshop Proceedings Vol. 438, S. 81-87. http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-438/paper13.pdf.

Understanding Modeling Element of a modeling language – like BPMN 2.0 – is a necessary condition for successful modeling, but by no means sufficient.

Models must have a meaning within a context in the end, otherwise they are useless. For example what does a model mean, where there are acitivies like “go to the shop” and “buy some milk” and “pay”? It is a modeled description of what a person sometimes does, if he needs milk. But nothing else. The process model is to be used as documentation only. This is the context of the model. Such a model can not be used as a workflow. There is no need to create a workitem “pay” for buying milk. This is done by the shop’s design anyway. Also it can not be a web service orchestration description, because there is no web service “go to the shop”.

Modeling a process makes sense, if the context is know, in which the process will be embedded. The context is what I call an architecture. An architecture is a set of rules that determine under which boundary conditions a software system is to be designed. As part of such a design the design of a process makes sense. For example the architecture could be to design a system that is capable of performing the functionality of a milk web shop, that milk order and milk delivery are business objects that expose web services like “order” and “pay”, that there will be a workflow system that is able to compose these services – for example. The architecture are the rules that describe the creation of the system, the business objects, the web services and the workflow. These first need to be professionally defined and confirmed. They need to be obligatory for the whole project.

Only after that it makes sense to create models, which then will have a meaning within the context of the defined architecture. And therefore it is of very limited merit to “just model” or to train or coach modeling of a modeling language without a reference to a defined architecture or without the preceding process of professionally defining the reference architecture before. On the contrary – if the architecture is defined, then it perfectly makes sense to coach and govern a modeling process, because then there are the rules, that are needed for coaching and governance.

This is my opinion.

Beginning of the week there was held the First European Workshop on Behavior Modelling in Model Driven Architecture [BM-MDA].

Why is it, that the structural aspects of software enjoys universality of modeling (UML) while the behavioral aspect does not (yet) and what can and should be done about it?

The same is – obviously – true for Web Service Descriptions. You will get a WSDL description which describes the syntactical aspect of the services, but the behavioral aspect is left undescribed.

The invited speaker was Prof. Gregor Engels, University of Paderborn about “Automatic generation of behavioral code – too ambitious or even unwanted?”

I am – as always – only giving my personal opinion here. I agree to the goal of behaviorable modelling. It was proposed, that preconditions and postconditions of operations should be used to do this. The advantage of the approach has been proposed to be able to become more specific step by step or level by level.

I mainly agree to the statement and I think it is pointing in the right direction. My personal opinion is, that preconditions alone are not enough, as long as they can contain every expression, because then they can not be linked with each other. Postconditions are in my opinion important, but they do not describe, how the state is changed by an operation. This is a difference to the ASM (Abstract State Machine) Approach, that was presented later and that I will discuss in another post.

Furthermore I think that code generation is the wrong way. The reason is, that code is too static to be extended later. A runtime model interpreter helps to avoid many problems, including extensibility and the deviations of models from the implemented reality. Furthermore in my personal opinion graph transformations should be avoided.

So this is my personal opinion about the first talk, which I think pointed into the right direction in general.