Enterprise Modeling - Model Persistence

Quite some discussions regarding the persistence of models took place at the Eclipse Summit Europe 2010. It seemed to me that there are two main camps. One side prefers files while the other looks for a scalable repository. Three questions are related to this:

How are model elements identified?

• Each model element has a unique identifier
• Selected model elements have a unique name

How are models edited?

• With a text editor which means that there are transient states where a model is syntactically invalid   
• With a specialized model editor which does not allow the user to create  syntactically inconsistent states
• With a projecting editor combining the two approaches

How are models stored?

• Textual modeling languages are naturally file based to be able to handle the transient states and will use the element names for identification as required by the implemented language. Other model elements have no identifier.
• The ‘traditional’ modeling approach is more flexible as the elements have an implicit or explicit id. It and can use both files and repositories for persistence and always has a form of model element identity.

There are some differences which become important to select the appropriate approach when looking at a specific use case.

The first essential difference is the guarantee of traceability over the life cycle of model elements.

• The identity based approach is more robust – traceability is only lost if an element is deleted and then re-created again (which results in a new element). 
• The name based approach is more brittle. A name change breaks the traceability (unless there is some magic done behind the scenes)

The level of traceability is important when dealing with model evolution. The conventional approach enables tracking of every change in the model whereas the textual makes only those states visible, when the model representation is syntactically correct.

The next difference is directly influenced by the storage mechanism and becomes relevant for large models.

• Repository based approaches scale better as model elements can be retrieved using the identifier when required
• The file based approach requires partitioning of large models. The partitioning may by straightforward in certain use case but it can also be artificial when the model has no natural partitioning. It is also problematic when different views on the same model are possible as they often do not have the same natural partitioning needs.

What does this mean? The selection of the persistency mechanism depends on the actual use case – it will be influenced by the required level of traceability and by the natural structure of the domain being modeled. The user of the modeling environment should have the flexibility to choose one or the other approach or even combine them. The modeling platform must allow the user to make the choice. And as we learned in the key note by Jeff Norris – we should have the freedom to stay uncommitted and make the decision late. Sounds like a standard interface to me where the best suited storage provider can be injected.

Eclipse Summit Europe 2010 - Modeling Platform Focus Day

Here is a view on the Eclipse Modeling Platform in the light of the key note by Jeff Norris he held at ESE this Wednesday. He made the point that innovation requires having a vision, being willing to take risks and to stay uncommitted as long as possible in order to keep agility high.

Vision – the Eclipse Modeling Platform has an agreed vision “The Eclipse Modeling Platform (EMP) is an industrial quality integrated software platform designed to enable a complete tool chain of model-centric tools. It will be based on existing Eclipse modeling technologies but focus on better integration, quality, scalability and usability for use in the enterprise“.

Risks –the group is certainly willing to take risks but it is also important to mitigate known risks. So far the group has not worked out a risk list. A solid risk management will be needed as part of the wider initiative going forward. One of the risks is that the projects do not pick up the envisioned interfaces and that the fragmentation stays as it is.

Commitment – stay uncommitted as long as possible but when the point comes make the required decision. An iterative approach tackling the right things at the right time in the right way is hence imperative.

The key point is to get the architecture sound and stable so that technology suppliers, tool providers and consumers can hook into the platform.

This means that for all technology providers know what they have to respect in order to contribute to the platform. The overall initiative must have a snowball effect with the architecture and the standard interfaces as its core.

There is an iterative plan which follows the priorities defined by the workgroup participants. The important point is that the initiative delivers iteratively interfaces and implemented reference services and consumers which can be used by all modeling projects and provides them a benefit. The plan complementing the gap analysis shows the following milestones:

·         The 1^st milestone’s focus is on establishing a sound architecture and on closing some of the obvious gaps in individual technologies.

·         The 2^nd milestone mainly provides a revised version of UML support which can work on the repository as well as merging functionality.

·         The 3^rd milestone mainly adds traceability, security and more support of versioning and evolution of models or parts thereof. 

·         The 4^th milestone adds multi user and distributed team support as well as first functionality for model management.

An industry working group is envisioned to implement realize the vision. For me the key point is that interfaces are defined which get a wide acceptance so that the integration of the individual technologies becomes as smooth as possible. The difficult point is that we talk here about interfaces which may (or even should) be implemented and also used by many projects.

If you or your company is interested to join the initiative, then please contact Ian Skerrett.

Eclipse Summit Europe 2010 - The last day

Today is the last day of the Eclipse Summit Europe 2010.

3^rd Key Note by Günter Dueck on the industrialization of the services sector

The world is getting industrialized and professionalized – the required level of mastership is continuously increasing. What does this mean for the different service sectors?

Günter shows IBM’s vision of a Smarter Planet “the world is getting smarter – the area of IT usage is exploding”. Many of today’s systems have to be overhauled and can or will be replaced with smarter solutions over time. This will have a substantial impact on all sectors of the services industry.

It will be possible to work everywhere … this is not yet possible. But once the coverage is there then this will change the world substantially. It will be possible to work at home; this will have an impact on industrial and private real estate ecosystem. No need to go to the office each day … video conferencing and alike will be standard. So other sectors like health care or energy can use this. As there is no need to go to the office on a daily base also the supporting sectors like restaurants, etc. will be affected as they will have fewer customers showing up, which will affect their suppliers, and so on.

Devices like energy meters will become smarter – and they will be attached to the internet. This will enable individual energy consumption statistics for each device and allow optimizing the energy consumption. But it will also enable the devices to send out notifications and to receive instructions. Somewhere companies will collect the data and provide condensed views to the customers allowing to oversee and control their infrastructure from their mobile devices.

Cars move towards electronic engines. This will change the car industry and the universities too which focus today mainly on engines burning fossil energy. But changing the engine does also impact other parts of the car as less vibration; less heat and noise are produced. So also the car suppliers have to change.

Also health care will change once devices are wired up as it becomes possible to analyze data samples somewhere on the world. So it becomes possible to look at all the patients which need the same treatment and provide industrialized advice to all of them. Some of these devices will be used actively to control treatment and to inject medicine which means that they can be remotely controlled.  Many of the standard treatments will be possible from somewhere in the world.

Having faster networks allows concentrating data centers. The workload shifts to these centers – at least the work which has to be done onsite. The other can be done from remote … by the people with the highest degree of professionalism at the lowest cost.

The people can browse information – they can we very well informed before using a service. Even today it is often easier to be better informed on a specific topic than a so called specialists or advisors in a company. This means that also that part of the services sector will change.

All professions will be split in routine and premium parts. Routine will move to the cloud and disappear … premium will stay.  So identifying and being engaged in “premium services” is the key question.

More from Günter Dueck on this can be found in his book “Lean Brain Management”.

Models To Go

Different mobile devices have different characteristics, programming paradigms and API’s. To create a neutral model and use a generator for the different phone platforms is a way to avoid the need to perform individual platform specific coding. Itemis has developed such a language using Xtext. The language contains the required abstractions and has a Java like look and feel to make developers feel comfortable. Xpand is then used to translate the model in to the app for the respective devices.

Building a UI styling language for E4 with Xtext

Xtext is used for CSS styling. The approach bases on Xbase. Xbase predefines a Java like expression language which can be embedded into Xtext based languages. Xbase seems very interesting for

Language development and Java oriented code generators. No other language bindings are planned at the moment.

Sphinx

Sphinx is an industrial strength tool platform for the model driven development of embedded systems which covers the full life cycle. For this the parallel support of multiple standards and DSL’s is required. There are two major initiatives: Artop and Papyrus. Both initiatives have platforms which offer generic modeling platform services. The idea of Sphinx is to provide a common base for these two but also other industry strength modeling tools.

Sphinx provides many of the services envisioned by the Eclipse Enterprise Modeling Platform.  The project is currently in the created state with the vision to integrate it into the Eclipse Enterprise Modeling Platform.  A lot of efforts went into dealing with the problems around the traditional file orientation of the Eclipse modeling environment and move the focus in the IDE to models.

Modeling in the cloud

Ed Merks starts by talking about his experiences learning the Google Web Toolkit. GWT comes with a fantastic Eclipse integration and it’s is based on Java.

A major difference is the asynchronous way how resources and alike are accessed in the cloud. This means that a request is sent and that there eventually follows an event with the response. This is visible in the generated applications. The example application shown in the presentation can be found under http://library-editor.appspot.com/ in the cloud.

Some rumors say that Ed did prepare the presentation in a plane. More details are here.

The end

 

This is the end of the ESE 2010.

Eclipse Summit Europe 2010 - The second day

The day starts with Mike Milinkovich officially opening the Eclipse Summit 2010. He is very pleased with the 452 registrations and 242 applications for talks. I guess the selection of the applications for the 72 available slots was not easy.

1st Keynote, Code and Religion by Prof. Hendrik Speck

Prof. Speck starts his presentation comparing Christian religions - mainly the Catholicism and the Protestantism.

They both base on different assumptions, traditions and they both have their specific objectives. One of the main differences is the way how authority is structured in the two organizations. The Catholic Church is centrally controlled by the pope (top down) whereas the Protestants are the protestant church (bottom up).

Umberto Eco picked this up in an essay  and showed that there is a similar difference between the MAC and DOS community. The first is centrally controlled with clear guidelines and standards given to its 'followers', the second one is much more open giving the people much more freedom and choice.  Does this influence the way innovation works in the two communities?

Above is the comparison of two technologies - the iPad and the Rosetta stone. This leads the the the topic innovation. Where does innovation come from? How can it be fostered? A well working approach is to setup a completion to win a price. The price is lower than a traditional investment to achieve the same with an organized program as many parties may try to win the price … one will eventually make it but all of them have to look at approaches and try out things never done before and like that inspire their environment. This approach was often done successfully in the past as the longitude price or the Dole Air Race show.  Maybe this is something to consider for the evolution of the Eclipse Modeling Platform.

What happens in closed systems, systems which are ring-fenced by walls and centrally controlled? People will try to break the walls in order to get some of the freedom back. In IT this is a flavor of hacking - like ‘jail breaking the iPad’ allowing it to run software prohibited by the central authority before or to use infrastructure not accessible before like more than one Bluetooth device.

Comments:

•  Apple is controlling the ecosystem is has created which includes the app stores. This control allows protecting the users but it also allows apple to gain insights like that an overview of all the clients using a certain app - e.g. the customers of a certain company or the people with specific interests.
• Eclipse in the current form evolved from a centrally controlled technology to a community based environment.
• I have not seen an iBeamer - maybe this explains why a lot of the presenters using a Mac had problems with the resolution of the projected picture ;-)

Enrich your models with OCL

UML 1 has used programming languages to specify constraints, etc. which were then somehow inserted into the final product using generator magic. UML 2 uses OCL to do this. Some of the main OCL features include:

• OCL has four types of collections to cover uniqueness and ordering
• OCL uses different operators on objects ‘.’ and collections ‘->’.
•  OCL differentiates between objects and collections.
• OCL is side effect free.
• OCL 2.4 specification is done by models and generated with Acceleo. 

Different attempts have been made to include OCL into Eclipse.

Since EMF 2.6 OCL is invoked dynamically – before it was embedded by a generative approach. The convenient way is to use the OCLinEcore editor (tutorial) which extends Ecore with the OCL annotation support transparently in the background and provides syntax checking. The OCL support works with dynamic models too.

Comments

·         The same problem can be modeled in many different ways. One approach is to do very explicit models with minimal constraints. Another is to use more generic models and add constraints and derived values to achieve the same semantics (e.g. a person needs to have a male and female parent).

·         Most models I have seen actually need constraints which cannot be explicitly modeled to be fully specified (e.g. a person cannot be its own parent)

·         Many ‘aspects’ like attributes and references can be derived (e.g. the father of a person) with OCL and they are well visible in the models.

EEF

The main goal of EEF is to add sexy properties editors to the model editor. EEF generates ‘polished’ property views – more support for dynamic views is planned. It allows structuring the property view in sections and supports the usage of specific widgets for the individual properties as well. It does however not support EMF data binding which limits its usage.

EState

EState (an Eclipse Labs project) is a framework to bring models to life using state machines. The advantage of this approach is that the logic for state management is in a single place and hence well maintainable. It follows the UML approach using guards and actions. Currently the project is in a very early phase having various limitations. The direction and the aim however are very interesting.

Comment:

• Try to find the project using Google – there is a lot of estate named ‘Eclipse’. I guess the people around Eike Stepper seem to like names which hide the project well in the web. Just try to find CDO and you know what I mean. 

2^nd Key Note Mission Critical Agility by Jeff Norris

The note starts with a monk wired up in Paris participating in an electricity experiment showing that electricity moves fast and that monks have a limited resistance. Aleck Graham Bell’s story leading to the invention of the telephone followed showing his vision and the critical decisions he had to make. His finances daughter had the vision to show the phone at the world exhibition in 1876. It became the sensation of the exhibition. Actually the success of the telephone was the result of the combined visions of more than a single person. This story shows that vision is an essential ingredient for agility.

Another ingredient is taking risks. This includes taking the risk of thinking out of the box and considering approaches nobody has tried before. What’s following is a truly great presentation using a camera capturing symbols on paper and software translating the paper symbols into graphical symbols being projected.  

The story explains the radical different approach taken to fly to the moon – a risk as all the other experts promoted at the time when Kennedy declared that the US will go to the moon within a decade.

Staying uncommitted as long as possible to keep options open is the third important aspect to agility. As soon as you are committed, you cannot change anymore. There is a risk of change – but there is also a risk of not to change.  Keep the options open is important as we are learning and making experiences while we are working. So try to push the point of no return as far as possible to allow take as much learning’s as possible into account.

The talk closes with the reminder that it is important to break out and try new things. This is easy at the start but more difficult once something is successful. Initially failure may not even be recognized - later on it may have a huge impact. 

Eclipse Summit Europe @ Modeling Symposium

Ed Merks has just opened the modeling symposium at the ESE indicating that the agenda is rather full with 14 presentations following in the next few hours.

1. Jen von Pilgrim shows semi-automated transformations using MITRA (MIcro TRAnsformation) and GEF3D. The approach transforming individual elements on demand visualized in 3D looks attractive. It will be interesting to see if this is picked up by some real industry use cases.

2. Markus Hermannsdoerfer demonstrates  how to migrate models with COPE. The presentation shows progress made on this technology since his last talk a year ago. The history of change made to the model is recorded and can then be used to migrate istances. The change history can be modified while ensuring that the transformations stay semantically correct (e.g. respecting dependencies)
3. Frederic Madiot uses EMF to represent Eclipse 3.x plug-ins with MoDisco which is a technology to renovate legacy systems using a model based approach. His presentation shows how to apply the technology to Eclipse plug-ins and how it can be used to support the migrationto E4.

4. Jonas Helming and Maximilian Koegel show three lightning fast demos. The first one is the EMF client platform which provides an application directly based on an EMF model. The second one is about EMF store which allows storing EMF models. In some way similar to CDO but not supporting lazy loading but model migration. With EMF store you always work with a file based offline copy of the model . The last part showed how to useEMF store for Ecore.
5. Eike Stepper shows the latest CDO developments including the offline clone repository (nothing to to do with Star Wars the Clone Wars though). The replciation speed is impressive - in general these are features which I would like to see transparently supported in modeling tools base on the Eclipse Modeling Platform. CDO supports lazy loading as well  as cache eviction and with that it can handle large models effiently. Cool technology, cdo is ... hmmm yes!
6. Remi Schnekenburger and Patrick Tessier continue the presentations after a break showing the impressive progess Papyrus has made since last year. Papyrus supports standard languages like UML or SysML but also DSL's. UML profiles with custom shapes are supported giving UML based DSL's an appropriate visual representation.
7. Stephane Begaudeau presents the features of Acceleo and the impact of its migration to E4 based on practical experiences.
8. The BPMN 2 editor based on EMF is presented by Reiner Hille-Doering. He also points out many of the benefits which come with BPMN 2 like th exchange format for model exchange (or more accurately two exchange formats). He uses the CMOF and XSD definitions from OMG, converts them into Ecore. Both results have advantages and disadvantages - e.g. XSD has no proper way to handle typed references, the CMOF base ecore model does nothave the usual XSD annotations. He shows how the two ecore models can be merged into a final ecore model which combine the benefits from the both input files which alows to serialize the model instance as xml as well as xmi.
9. The buinessAppTester shown by Florian Pirchner simplifies the unit testing of applications.
10. Aurelien Pupier shows Bonita Studio which has leveraged graphical modeling power for customization of its user interface. The interface looks really nice and it demonstrates the potential GMF has.
11. Markus Voelter demonstrates the integration of a type system into Xtext. The appoach includes verification rules implemented as far as possible declaratively in Java.
12. The integration of modeling and JDT is the topic of the presenttaion of Sebastian Zarnekow. He demonstrates how the java type system can be mapped into Xtext.
13. Sven Efftinge invites the audience to place requests for a Xtext community site under a specific bugzilla id (which I did not note). He also demonstrates a language called xdoc (in Xtext of course) simplifying the documentation of software.It allows integrating documentation and code so that it is easier to keep both of them in sync.
14. Jan Köhnlein shows railroad diagrams (syntax graph) for each rule in Xtext. This technology is under development but will be part of Xtext 2. The diagrams really look like rail roads.
15. Stephan Eberle gives an update on the Eclipse Modeling Platform, the requirements (version management, collaboration, auditing, ...), strategy and direction. Companies interested to join the initiative are invited to contact Ian Skerrett.

Here are some subjective comments and observations:

• As last year many interesting technologies are presented - it would be great to see each of them with a practical use case and with the experiences made applying the technology in practice. Often the new technologies are just applied to existing Eclipse technologies instead of using a real world example.
• In some case it stays unclear what the intended purpose or use case of the technology is. They seem more to demonstrate the cool things enabled by the Eclipse technologies. Maybe an idea for the next symposium is to ask all presenters to list some of the intended or already implemented use cases.
• Some of the examples seem to show that we as IT like to do work for IT - merging two BPMN 2 definitions to allow to produce two BPMN interchange formats.
• The strategy to develop graphical model editors seems not very clear as substantial efforts go into GMF based editors while in parallel Graphiti is shaping up.