Following Flo

JWT moved to Eclipse SOA

2010-03-17T14:14:00.000-07:00

The Eclipse SOA top-level project has a new member: the Java Workflow Tooling (JWT) project finished the Move Review successfully. JWT aims to build design time, development time and runtime workflow tools and to foster an ecosystem of interoperable Business Process Management (BPM) platforms.
Therefore, it supports the enrichment of business process models (e.g. initially modeled in BPMN) with runtime data or services, allows the user to generate code (e.g. in XPDL or to BPEL) and provides an extensible mechanism to customize the models via aspects.

Thereby, JWT has already been part of Eclipse Galileo. With this move, the project has once more proven to be mature. JWT will graduate from incubation probably together with or shortly after the Helios release in June 2010.

Congratulations to the team and the new project leads of JWT!

Together with the move review, I took a step back and will only be a committer of the JWT project anymore, but no longer project co-lead. Reason for this is that I finished my Ph.D. successfully and work as a technical consultant now (my employer is Senacor Technologies) which leaves me with less time for JWT. In my opinion being a project lead requires a lot more time than only one hour every two weeks or so. As Chris Saad already supported me in the last few years, it was only natural that he stepped forward to fill this place.

I would like to say thanks for your support, Chris, as well as to my project co-lead colleague and friend, Marc Dutoo (OpenWide SA). We had been a great team and complemented each other perfectly. Now as a committer, I hope to find more time to code again while being less focused on the roadmap, release train, etc. as I know that those will be in good hands at Chris and Marc.

One of the good things of my new job is my current location: I'm working at a project for the Deutsche Post at the moment and am therefore only meters away from Sopera who are deeply involved in the Eclipse SOA project. I already met some of the guys during lunch and hope that we can use the close distance to bring the Eclipse SOA projects closer together, too.

To learn more about JWT and the whole SOA top-level project, come to EclipseCon and follow the talk about Eclipse SOA TLP: Lock, Stock and Barrel. If you have questions about JWT, feel free to ask the two project co-leads who will both be available at the talk.

Two talks at EclipseCon 2010 related to JWT

2010-01-14T05:46:00.000-08:00

Only recently the program for EclipseCon 2010 has been announced and the program committee did a fairly good job in my opinion: they found a good mixture of different topics that the audience will be interested in.

There will be at least two talks that are related to the Technology project "Java Workflow Tooling" (JWT). Our project community submitted some more which were unfortunately rejected. Those had JWT in their focus, so the audience won't be able to hear a detailed talk about JWT this year. Maybe we will have more luck next year.

The first one will give a short overview about JWT as part of the talk Eclipse SOA TLP: Lock, Stock and Barrel where the upcoming top-level project Eclipse SOA will be described and all the sub-projects that will be part of it.

The second one is about how a metamodel evolution can be done and whether this might be painfull or painless for the modeler. This one is presented by my colleague Chris Saad from the University of Augsburg and Etienne Juliot from Obeo SA: Painless (?) Metamodel Evolution.

I didn't submit an abstract this year as from February on I won't work for the University of Augsburg anymore and I am not sure whether my future employer would pay me the trip.

Java Workflow Tooling (JWT) 0.7 released

2009-12-22T00:22:00.000-08:00

The Eclipse project Java Workflow Tooling (JWT) released version 0.7 which is now available for download. JWT aims to build design time, development time and runtime workflow tools and to foster an ecosystem of interoperable Business Process Management (BPM) platforms. JWT is integrated in the yearly release train of Eclipse and was already part of Eclipse Galileo.

The main features of the new release are:

The meta model has been restructured: the project team separated the meta model that includes the business logic from the layout information. An independent meta model now allows developers to handle JWT workflows without causing unnecessary dependencies. View specific data like coordinates are now stored in a separate diagram file which makes the original files not only more robust, but also much lighter and easier to handle. Model transformations, like from and to BPMN, XPDL or the STP project's Intermediate Model are therefore easier to implement and maintain. To improve the visual representation of workflows, multiple layout information can now be stored for each element in the model.

Automatic layout algorithms, which have been included from the popular GEF Zest project, finally remove the need of tedious rearranging of positions. Simply using an horizontal, vertical, spring or tree-based theme, the workflow models can now easily be arranged to a preferred layout.

New converter: Full support for workflow files from previous versions of JWT is now guaranteed by a new ATL-based converter. While the old converter transformed the model elements using Java code, the new converter allows an easy adaptation to future changes of the meta model, including migration of user developed model extensions.

Besides the mentioned changes, version 0.7 provides a better support for aspect-oriented model extensions and significant improvements in performance and stability.

Version 0.7 is a joint release by researchers and developers of the University of Augsburg (Institute of Software and Systems Engineering, group of Prof. Dr. Bernhard Bauer) and the French company OpenWide SA. The University of Augsburg is now also an official (associate) member of the Eclipse Foundation.

Ph.D. thesis submitted

2009-11-24T04:16:00.000-08:00

After four years of work, I now submitted my Ph.D. thesis entitled "Semantic Business Process Modeling - Principles, Design Support and Realization" to the University of Augsburg, Germany.

In this thesis I describe how ideas and technologies of the Semantic Web can be transferred to the modeling area and how business process models can be semantically annotated.
These semantic annotations are used to compute proposals for process models that only need to be checked and maybe refined by the modeler, reducing the amount of manual work. Furthermore, the thesis shows how existing process models can automatically be adapted when requirements have changed.

As part of a developed methodology, the thesis also outlines the realization of process models using model-driven technologies and their execution using semantic web services.

Thanks for the excellent mentoring and support to my supervisor and advisors (Prof Dr. Bernhard Bauer, Prof. Dr. Dragan Gasevic and Prof. Dr. Wolfgang Reif). In addition, I would like to thank my project colleagues (e.g. from the Eclipse project Java Workflow Tooling or the DFG-project SEMPRO)! Each of them contributed in their own way to this thesis, by working together on projects and also by discussing joint research ideas.

In the next weeks and months, I will probably find more time again to work on the project JWT. Several feature requests are waiting...

Aspect-oriented Modeling

2009-10-21T08:55:00.000-07:00

Do you like AspectJ or at least the idea of aspect-oriented programming (AOP)? Do you use EMF and create your own metamodels? Do you at some point of time miss the possibility to extend existing metamodels from an outside plugin with the specific properties or metamodel elements that you just need right now?

Then you should not miss the talk Marc Dutoo and I will give at Eclipse Summit Europe: it is all about Aspect-Oriented Modeling.

In this talk we discuss current shortcomings of technologies like EMF and standards like UML, and show how these can be dealt with using research approaches in the area of aspect-oriented modeling (AOM), allowing e.g. to enrich models with orthogonal sets of information pertaining to different concerns.

Several techniques and implementations based on Eclipse products and projects (such as EMF extensibility, secondary models such as EMF GenModel's, the aspect-oriented configuration profiles of the Eclipse technology project Java Workflow Tooling) will be presented. At the end, an outlook about current standardization approaches in this area by the OMG will complete this session.

So, don't miss the opportunity and join us in Ludwigsburg on Wednesday, October 28th (and of course also from Monday to Thursday for the rest of the conference!). You will find us in Bürgersaal 1 starting at 5.30pm. See you next week!

Views on process models

2009-08-13T08:50:00.000-07:00

We just finalized an article explaining how users can write their own views on a process model using the extension points of the JWT Workflow Editor. Thereby, we describe the aspect-oriented mechanism which is part of JWT to extend the existing metamodel by external plugins. But not only the extension of the metamodel is important: also the customizing of the tooling (palette, figures, editparts, etc.) from the outside is covered.

Hopefully, the article will be accepted at the German speaking Eclipse magazine. But if you (and we) are lucky, then the talks about views and aspect-oriented modeling will get accepted at Eclipse Summit Europe. So maybe we'll meet in Ludwigsburg and we might have the chance to show you how to create your own view and use the extension points and components of our project.

Lowering Open Source Contribution Barriers

2009-07-15T02:14:00.000-07:00

Chris Aniszczyk recently talked in his blog about how the barriers for contributors could be lowered. One of his topics was "how about us making it easier for users to file bugs?"
He then talked about a feedback agent included in Eclipse.

I think that's quite a good idea. Especially when an unhandled exception appears somewhere inside Eclipse, it would be great to have a new GUI dialog to add this exception to a new bug message.

What I have in mind is that each time a severe exception happens, then it can either be added to the Eclipse log or (maybe as an extension of the logging mechanism) is displayed in an error window to the user (the developer can decide that during design-time). The user can see a user-friendly message (Please *not* the exception message itself!) and can then decide to click on a button whether to report this bug (similarly as Microsoft Windows offers his users to do so, but I don't know anybody who ever klicked on "Report this bug to Microsoft").

If the user agrees and clicks on this button, then another window shows up that allows the user to specify what exactly he had done before. The window automatically suggests the top-level-project, project and component where this bug should be added to and fills in all the platform details and adds the stacktrace of the exception. Maybe with an integration of Mylin also the context of work could be added automatically.

That would probably make it easier for users to give us feedback about bugs, but it would also make it easier for the contributors of a project to find out whether two bugs are similar (since the stacktrace is automatically added to the bug message, too, and can easily be compared).

Maybe that would be another feature that could be added to e4?

JWT 0.6 released

2009-06-24T09:07:00.000-07:00

Today, as part of Galileo, the newest release of JWT, the Java Workflow Tooling project, has been released. Java Workflow Tooling in version 0.6 brings open business process design and development to the Eclipse platform. JWT-modeled processes can look the way the analyst wants, hold any implementation information the developer adds in, and be deployed to the runtime platform of choice.

This is possible thanks to a flexible framework allowing extensible views, model and transformations, that communities and vendors can build on. JWT comes with several built-in extensions like UML Activity Diagram or Event-driven Process Chains (EPC) views, BPMN interoperability, code generation (e.g. XPDL, or WSBPEL-code in the AgilPro integration, but also HTML documentation). There are actually already a few solutions that integrate JWT, such as the SOA-focused Scarbo of the OW2 consortium, or AgilPro in SourceForge.

JWT is available in Galileo using Help -> Install New Software... -> Galileo -> General Purpose Tools -> Java Workflow Tooling (Incubation).

Come and get it!

Everything prepared for Galileo

2009-06-17T06:44:00.000-07:00

Last night I fixed the last bug for Eclipse Galileo. Just in time! Today the release candidate RC5 is built for version 0.6 of our project Java Workflow Tooling (JWT) and this release candidate will be used in the final Eclipse Galileo build. You'll find JWT on the Galileo update server in the area General Purpose Tools.

But this doesn't mean that we'll now have time to rest and lie in the sun. Now is the time to summarize the development in JWT of the last months in a few sentences for articles and blogs. It's also the time to plan ahead: how shall the project plan for the next years look like? Which releases will we have and how will the general strategy for e4 as well as beyond look like?

In addition to that there are also integrators of JWT that need to be updated with the new version. In our SourceForge project AgilPro we have a toolsuite that allows to model, simulate and execute workflows. It includes all the plugins (e.g. workflow editor but also several transformations) from the JWT Galileo release.

In addition it also contains the Workflow codegeneration framework which allows us to transform the graph-based to a block-based structure in order to generate BPEL-code (1). So we are just updating and adapting everything until next week in order to have hopefully a joint release of Galileo and AgilPro.

(1) I know that BPEL is not only a block-based language, but can also be used graph-based. But the block-based structure is much better to read and maintain in BPEL-editors.

Article about JWT in Eclipse magazine

2009-05-28T02:48:00.001-07:00

If you are interested in process modeling or workflow execution, you might want to have a look in the newest German-speaking Eclipse magazine ("eclipse Magazin"). In their current issue there is an article called "Geschäftsprozesse ausführen mit Eclipse JWT". It reports about the latest progress of the Eclipse Technology project Java Workflow Tooling (JWT).

If you want to learn more about this project, please don't hesitate to contact the mailing list or the newsgroups.

JWT and Galileo M7

2009-05-07T04:12:00.000-07:00

Yesterday our milestone M7 for the Galileo release of the Java Workflow Tooling (JWT) project has been finalized and published. As we are part of the yearly release train we are bound to the deadlines of Galileo. Please find the milestone build either on our JWT stable update site or on the Galileo staging repository.
JWT allows you to model your workflows (e.g. starting with the STP BPMN editor), to generate code in XPDL, jPDL or other languages out of your model and deploy that code to a workflow engine. Thereby, the workflow editor provides you with different views on your process (different icons, figures, names, etc.).

We built and tested JWT against Galileo M7, EMF 2.5 and ATL3.0 as well as with Ganymede, EMF 2.4 and ATL2. At the beginning we were facing some problems with ATL3, but thanks to our committers from Obeo and OpenWide, these problems have been resolved.

The M7 was the freeze date for our release, so we won't make any more changes on the features, UI or API any more, but will still work on some bugs that we are currently aware of. Please feel free to try the newest release and give us some feedback or report any issues, enhancement request or feature request on Bugzilla.

If you are new to JWT, but would like to know more about the project without downloading the newest release right now, please feel free to have a look at these slides that have been presented at Eclipse Forum Europe or at this screencast from EclipseCon.

Summary JAX, SOACON, Eclipse Forum Europe

2009-04-27T04:31:00.000-07:00

Did you have the chance to visit this years JAX? I thought it will be mostly about Java-related technologies. Surely, I have already heard about Scala, Rails, Groovy or JRuby, but the huge amount of different programming languages that exist nowadays and that were presented there, really overwhelmed me!

Have you already heard about F#, Newspeak, Fortress or Boo? At least, I didn't. What Markus Voelter explained in his talk about Trends in Languages 2009, was that Scala on the one side is an approach that combines an object-oriented language with ideas from functional programming. F# on the other side is the .NET derivate of the JVM-based Scala and goes the other way round: it extends a functional programming language with object-oriented concepts.
Newspeak is a further development of Smalltalk and Fortress improves Fortran. The language with the probably most interesting name (besides BrainFuck) is Boo, an object-oriented statically typed programming language.

With all these languages it's quite hard for any newcomer to understand which language to use in when situation and whether it has advantages or disadvantages in some areas. So, if you have some document that explains the difference between Ruby, JRuby, Groovy, Rails, Grails, Scala and all the others, I would be happy if you could share it! For me it seems that the box of Pandora has been opened again. A while now we only had one programming language besides .NET and that was Java. Now the pendulum points to the other side again (as Markus Voelter explained) and we have lots of different languages. We'll see how long this pendulum stays there and when it will go back again (which I think it will!) - whether it will go back to Java or a completely different programming language - nobody knows!

Besides these languages (that were presented in several talks and keynotes), JAX offered a lot of other interesting topics of course. Since it was combined with SOACON and Eclipse Forum Europe there had been a lot of talks about Eclipse, SOA and BPM which I attended.
Of course, I also had my own talk about how to execute process models where I showed some screencasts (1,2,3,4). Alas there had only been few people in the talk, but the feedback that I got from persons or via different mailing list showed that the interest of the community is there.

Most important (as always) are discussions with other people working in the same area. Here, I met quite a lot of interesting people from different companies that are also concerned about "How do I execute a model?", "What advantages does BPMN 2.0 have?", "How can I use UML for modeling an enterprise?", "Can aspect-oriented modeling assist me in my work?", etc. These discussions where really fruitful and I'm looking forward to some more on PlanetEclipse, my personal blog or maybe also our JWT mailing list.

If you want to read more about JAX, please also have a look at JAXEnter where several people blogged about their experiences in the last few days. You can also find some blog messages which I have written there, too. Als for all English guys, but they are only available in German!

With more than 1,700 attendees, it was really a successful conference and I'm already looking forward to next years JAX or this years W-JAX!

Eclipse Forum Europe in the sun, but one cloud

2009-04-20T09:27:00.000-07:00

Today started Eclipse Forum Europe in Mainz, Germany. The weather is lovely, so it's really difficult to convince himself to go to the talks. But there are so many interesting ones that this won't be a problem at all: talks about Eclipse of course, but also a lot about SOA and BPM at SOACON and about Java and project management at JAX (all three happen in parallel).

As I'm mostly working on SOA and BPM support with Java inside Eclipse (as part of the JWT project), this combination is really perfect for me!

So, it could not be better, if we wound not have heard that Bjorn Freeman-Benson, one of the first people you think about when the name "Eclipse Foundation" is mentioned, will resign working for the foundation already from at the end of this month! So, this is a really a pity, as Mike Milinkovich in the name of the Eclipse foundation announced. One can't think about EclipseCon without Bjorn! So the Eclipse Forum Europe starts with one happy and one sad eye and it seems that between all the sun, the first cloud comes up.

Google Summer of Code and Eclipse Forum 2009

2009-03-30T06:20:00.000-07:00

Now that EclipseCon has passed by and probably most people are back in the office again (I hope your trip back was better than mine where we needed to interrupt our flight on Iceland because of a person requiring immediate medical assistance), it's time to prepare for the next topics that are of interest for the Eclipse Community.

First, at the end of this week the Google Summer of Code deadline approaches. This is a great opportunity for students interested in developing code to get involved! Surely this covers a lot of different platforms, but there is even an own Eclipse GSoC program where we ask interested students to get involved in the various Eclipse projects. So if you have any ideas, please feel free to let us know! Post them on the GSoC Eclipse wiki page, but also send an email to the mailing list and discuss our ideas in order to get a mentor. Finally, submit your idea until Friday to the Google webpage. Besides the financial aspect (you'd get $4.500 if your proposal is selected and everything works fine during this summer) it's a great opportunity to strengthen your developing skills and to get in contact with many interesting Eclipse people!

Second, the Eclipse Forum Europe already shows up on the horizon. Happening together with JAX and SOACon in April in Mainz, Germany, it is again a good opportunity to meet people and get some more knowledge about all the interesting projects in Eclipse. Since we only had a ten minutes talk at EclipseCon, the JWT project team is looking forward to now present our ideas and existing development in a long talk.

Meetings, meetings, meetings

2009-03-26T08:26:00.001-07:00

Yesterday I didn't have the chance to listen to many talks at EclipseCon, because I used the opportunity to meet several people. After the keynote in the morning I sat together with John Graham, the mentor of our project JWT, which I actually met here at EclipseCon the first time and his colleague Koen Aers and we talked about how we can further improve our project.
After lunch I talked with Wayne Beaton, PMC lead of Technology, about JWT and about other project ideas that spin around in my mind. Then Jerry Preissler from Sopera had some time and since we always tried to fasten the collaboration with the STP project, it was really great to have some chat.
And the evening was dedicated to the poster session, where it's of course all about meeting people and discuss your ideas and code with their ideas and code. So this was really fun, too!

That's why I can't report too much about the conference yesterday, but I promise to get to some talks today again (e.g. my own presentation together with Chris at 10.10am about "Make your processes executable!").
If you are curious about other things that happened in the last two days, maybe this German blog might also be interesting for you.

Model and Execute!

2009-03-24T20:23:00.001-07:00

The focus of the talks that I attended today at EclipseCon, was about modeling and execution. The first talk (after the really great keynote that others on PlanetEclipse already posted about) was about a model-driven build management suite called Storm that is currently developed by Brane. If you ever had the problem, that you want to build your Eclipse distribution customized yourself, then this software might be interesting for you.

The second talk, "Executing BPMN" described the differences between graphical process modeling languages like BPMN and executing languages such as jPDL. Koen Aers, the presenter of this talk, also explained why an overall coverage of BPMN will not be possible in their tool (and is not even necessary as research found out). But he gave a quick preview on the coming modeler that will be distributed in the jBPM release in July and it already looked really nice (alas it is not yet build upon JWT!).

The next track was a set of SOA talks from the STP project: how the policy editor is evolving, what is currently happening around the Enterprise Integration Designer, how one can model SCA composites and how the STP-IM all connects these components has been summarized in short time quite well. Probably the tuturial on Monday has given much more insight, but having four hours is of course much more than only one.

Another track of this day was about an EMF repository, workflow and model execution. Actually, it have been three different talks: the first one was about EMFStore, a project some colleagues from the TU Munich presented and which was integrated in their tool suite Unicase. Alas, I didn't find the time to talk to them, but they said that they will have a poster at the poster session tomorrow, so I'm already looking forward to that. The second presenter was Bryan Hunt who gave a quick introduction into the MWE project and how the classes he has designed work together. The third one in this track was from the HU Berlin (so a lot of German Ph.D. students here!) and presented a framework for the execution of models. He demonstrated it on a C# interpreter where the dynamic behavior was actually modeled with his toolset(building on OCL and UML State diagrams). It reminded me a little bit at Executable UML (xUML), but I didn't have the time to look further into the differences between both.

In the end I got a good impression how the next major release, Galileo, is currently build using model-driven development tools: model-to-model transformations (QVTO) and model-to-text-transformations (XPand) are used in order to assemble and build all the milestone builds for Galileo. So, it seems to me that more and more areas are open to modeling and I'm already looking forward to the talks on this topic tomorrow.

Latest findings of the CAOS Report 2008

2009-03-24T09:14:00.000-07:00

No, this is not a new version of the CHAOS Report of the Standish Group which reports about how many IT projects failed in the last year again. This is about a report concerning the Commercial Adoption of Open Source (CAOS) which the 451 group created last year and which Matt Aslett introduced us yesterday at the Eclipse Annual Member Meeting.

Hmm, if one only looked at the number of attendees, it seems that the Eclipse community is getting smaller, as only about 40 people attended the member meeting. But this is probably due to several really interesting tutorials that were part of EclipseCon and that happened at the same time. All in all there are about 1,000 people here at EclipseCon, so the community is much bigger!

So what did the CAOS report contain? The title of the presentation was "Open Source is not a business model". And as Matt finished, "Open Source is a business tactics, not a business model".
They had a look at 114 companies and investigated their business strategies. These were categorized in 4 categories:
- license choice
- development model
- vendor licensing strategy
- reveneue trigger.

Already the first category, the license choice, offered some quite interesting insights: most of these companies (51,8%!) use the GPLv2. All in all the usage of GPL and LGPL covered 72,8 % of all companies. The Eclipse Public License (EPL) for example is only used by 6,1 %! With probably hundreds of different open source licenses around, only 10 are mainly used!

Interesting was also the revenue triggers: many companies probably started their open source strategy with offering service and support for money. In the meanwhile this is only 7,9 % of how revenue is achieved. Mostly these companies make money by subscriptions(34,2%) and commercial licenses (24,6%).

There were a lot of more interesting things that were mentioned, but I guess this short summary shows already that this report might be interesting for you!

Oh yes, as we already have a look at different numbers, I might add some more statistics that different people from the Eclipse Foundation explained at the Annual Member Meeting: the Eclipse Foundation currently has 172 members and 901 different committers from at least 75 organizations! Wow, that's not bad!
There are approximatelly 1 million downloads each month of the different Eclipse releases whereas 26% of all downloads come from China! A huge number! Of all downloads 34% were the IDE for JEE and 22% the IDE for Java. So, Eclipse is still mostly important for developing Java.
But this will change in the future as the planning for Eclipse version 4.0 (Codename: e4) is already in an advanced state.

Oh, yes, some last numbers: when looking at the European region of Eclipse Germany is with 44% still in front, after that comes France with 16% and Sweden with 8%. As the committers of our JWT project mostly come from Germany and France, this meets perfectly our profile *g*.

Looking forward to EclipseCon - to meet you!

2009-03-20T03:12:00.000-07:00

Next week EclipseCon 2009 will already start in Santa Clara, California. I guess most of you will look forward to have the best conference ever. Not only because the huge amount of interesting talks, but also because this is probably the best possibility to meet the persons you always wanted to talk to in person!

It already starts on Monday with quite interesting tutorials such as how to use Mylin, work with Eclipse RCP, apply the latest research results in model transformation, have a dive in the platform resource model or develop your SOA with Eclipse. There are so many tutorials (besides the Eclipse annual member meeting that happens on Monday afternoon, too), that I don't know yet which one to choose.

And it's getting much more difficult once the conference starts on Tuesday! Not only the BOFs will be fun, but of course also the plenty presentations. Since we'll have a talk on Thursday about how to execute a process (by the way, the presentation is nearly finished!), I'm of course interested in what other companies do in this context and am already looking forward to Koen having his talk Executing BPMN.

But besides that a lots of other talks (that are not related with BPM, SOA, Workflows, etc.) seem to be interesting: how to evolve a user community, what will happen in Eclipse e4, the newest development concerning Galileo, newest tools for web development, building and translation as well as others.

I'm sure everybody will find a topic that he's interested in!! And if not, you can still sing Karaoke, watch some posters or talk to exhibitors. And with the long list of presenters, you'll definitely find somebody to talk to!

I'm looking forward to meet you all in the next few days!

Aspects for type-safe extensions of process models

2009-01-30T07:45:00.001-08:00

Did you ever face the problem that you have a process model and would like to generate code and execute it on a process engine?

There are different possibilities: either you model your process directly in a BPEL-editor or you have a more abstract process model (and modeling editor), but then you don't know where to put the technical details.

The typical approach is that you start with a high-level process model, e.g. in BPMN, and then transform your process into another format where you then specify the technical details. But what do you do, if the technical engineer does not agree with the abstract model that the business analyst did design? Does he simply change the flow in the technical model or tell the business analyst where she needs to adapt her abstract model?

It's quite easy for such simple process models, but it becomes especially hard for bigger ones. Additionally, especially SMEs won't have the time and money to buy a lof of different tools and change their model transformations time and again. They are happy with one kind of tool where they can model their process, add some technical details and execute the processes.

If it would only be BPMN, then life would be easy. But there are a lot of languages out there and especially in order to collaborate with others a company needs adapters to these languages. As you can see in the following image, standardization organizations were quite active in the last few years and it is not foreseeable which new standards will emerge in the coming years.

But not only the graphical notations differ, also the different process engines each have their own requirements. This is why you specify some hooks in the generated XPDL code or change the generated BPEL code again, so that it can be executed in your process engine.

That's probably okay if you have only one process engine or there is already a modeling tool that supports your process engine and generates exactly the right code. However, quite often there is a lack of compatible tools (either because the vendor doesn't support own modeling tools or because the process modeling tool of your choice doesn't support exactly the process engine that you would like to use). Then, you will have to change all the generated files manually so they can be executed.

But how can a modeling tool give you the possibility to add the kind of details that you need for the process engine of your choice? Surely, you can specify some annotations in BPMN which the process engine can evaluate. But there is no type safety, i.e. you can specify there anything you like (numbers, Strings, boolean values as Strings, etc.).

What would be preferable is a possibility where you have one single modeling tool you can build on and this tool allows you to specify the additional parameters that are needed for execution as well as their types and everytime after that you only have these parameters and types.

That was the reason why we developed in the Eclipse project JWT an aspect-oriented extension mechanism for vendors and other persons who want to extend the already existing metamodel.

The extension metamodel looks as follows:

For each process model you can specify a configuration model (actually, this has been implemented on top of EMF, so you can extend any EMF metamodel!). This ConfModel contains a set of profiles with several aspects in them. For each profile you can specify the name, version, author, some description and an URL. The interesting things are the Aspects: they allow to point to some already existing metamodel elements (via targetModelElements) which shall be extended. Thereby you can specify whether this extension shall be the same for all elements of this kind or different (multiple). You can also say whether this extension shall be automatically added to the model element once it is created or only on request. You can set some default value for the extension and name an identifier. The aspect instances then specify what you exactly want to add: some new properties, completely new nodes, etc.

We already added e.g. new properties. These can then be seen in an additional properties tab which can be adapted to the needs of a vendor (see the new tab Advanced in the following screenshot).

If a vendor wants to have another view on the process (either with more or less details or with different figures, one for BPMN, one for UML activity diagrams, one for EPCs, etc.), then they can simply add it to JWT, too.

Additionally, its quite easy to add an own editor sheet, if somebody prefers to have much more information in their editor: copyright information, nice images, more text, whatever!

With these extension points as a basis and some more that will come soon (e.g. enhancements on the current view mechanisms, additional transformations, etc.), the above described problems can hopefully be decreased!

We hope that more and more vendors will be interested in JWT in the future and we look forward to work with them together on their requirements!

Talk at Eclipse Forum Europe 09

2009-01-20T07:20:00.000-08:00

In April, just right after EclipseCon, the Eclipse Forum Europe (EFE) is happening in Mainz, Germany. EFE is organized together with JAX and SOACON, so it offers insight into many interesting themes: Java and other languages on the JVM, SOA, Model-driven Engineering, Business Process Management, OSGi and Equinox as well as other tools.

There, I'll have a talk about Execute your processes with Eclipse JWT (Abstract), where I will have 60 minutes (luckily some more than at EclipseCon) to describe many details of JWT: the view mechanisms, aspect-oriented extensions of the metamodel, model transformations and code generation, monitoring, etc. This will be my first JAX, but I'm already looking forward to it!

Talk at EclipseCon 2009

2008-12-17T02:07:00.000-08:00

Our talk with the title "Make Your Processes Executable!" for EclipseCon 2009 has been accepted. Alas, it has been shortened from half an hour to ten minutes only.

For a university in Germany having a business trip to California for only 10 minutes of presentation is a very high financial burden. Especially in todays monetary crisis!
Thanks to our boss, we are allowed nevertheless to make the trip in order to bring the project some steps further, to discuss with project partners and other project leads or committers. Probably we will try to have an additional poster in the poster session in order to have some more discussion about our project.

But for the next time, we will surely make it like other committers, too: we simply make several submissions. It is kind of strange now to read on e.g. PlanetEclipse that some people get a short talk, a long talk and a tutorial accepted, whereas other people are not even allowed to speak more than 10 minutes. But for next years Eclipse Summit Europe and the following EclipseCons we will probably consider that, too!

Reviewing the JWT metamodel

2008-12-16T02:19:00.000-08:00

In JWT we are working on all kinds of tools for workflows. One of these tools is the workflow editor (WE) which allows to model all kinds of workflows in order to deploy them to a workflow engine or process engine afterwards. Since we now developed an aspect-oriented mechanism with profiles and configurations to extend the metamodel by external plugins (I will post on this in another blog message), it is now time to review how the core metamodel currently looks like, what has been used till now, how these elements were designed and whether we might utilize them in the future.

The JWT metamodel currently consists of several packages. The main package (JWT Model) contains several other packages: Core, Processes (including ControlNodes), Events, References, View, Organisations, Application, Data and Functions. I will describe them shortly here, a more detailed (but somehow outdated) reference can also be found here.

Core package:

The Core package contains all necessary elements to display a model in the workflow editor (without the graphical layout stuff). The basis for all other elements is ModelElement. Every element that wants to be usable in the workflow editor must be a subclass of ModelElement. Each ModelElement might have some Comment attached. This cannot be displayed graphically at the moment, but one of my students is currently working on this (besides the integration in the tree-like outline view). A Comment itself is a GraphicalElement. Lateron we will see that all elements that are visible in the graphical editor (not only in the palette or outline view) need to inherit from GraphicalElement.

The mostly used subclass of ModelElement is NamedElement. Each NamedElement has a name and an icon with which it can be shown in the packages, palette or somewhere else. The icon describes the URI/URL to an image (in PNG or GIF) that might be used for showing this NamedElement (depending on the figure of the element).

In order to have not a flat hierarchy but some more intelligent structuring for future model elements, these can be differentiated in Packages. Packages can be nested and contain PackageableElements (which are themselves NamedElements again). One example for a PackageableElement is a ReferenceableElement which can be defined once, but referenced several times.
One specific Package is the Model: this is the root of all workflow models and contains the name of the workflow file, the author, the version of the modeled processes, the fileversion of JWT (only internally represented) as well as a human-understandable description.

Please note that in this image as well as in all coming pictures, I am using String, Boolean, Integer, etc. but actually mean the EMF-equivalents EString, EBoolean, EInteger, etc. My modeling tool only supported these standard datatypes natively, so please don't be confused.

REVIEW: When reviewing what has been used in the last years of this part of the metamodel, then we will find that except the Comment all elements have been used frequently. All of those are abstract, so the user didn't actually see that (s)he uses them.
It is understandable that the Comment was not used much, because there was no possibility to show this one graphically. But as already mentioned this will be changed in the near future, so the hope is that the Comment will be used much more frequent in the future, too.

Process package:

The next (and most important) package is Processes. In there, the basic elements of all workflows / processes are described. Most models contain nodes and edges connecting these nodes. You can also find this in the centre of this metamodel package: ActivityNode and ActivityEdge.
But of course these elements need to be defined in a specific Scope. This can be a single process model (called Activity here in analogy to UML2 Activity diagrams) or as part of an activity (called StructuredActivityNode). Activities can be integrated in packages again (as PackageableElements). ActivityNodes are GraphicalElements as well as NamedElements which means that they have a name and can be displayed in the graphical editor.
Each ActivityNode can have several incoming and/or outgoing ActivityEdges and each ActivityEdge has exactly one ActivityNode as source and one as target.

ActivityEdges can be constrained: you can specify whether you would like to have a Guard on the edge which restrictes the number of "tokens" (similar to Petri-nets) that are allowed on this ActivityEdge. Each Guard has a shortDescription and a textualDescription; each one is used in a different view on the process model. Guards can be specified (detailedSpecification) with a GuardSpecification which then uses well-known constructs like Equals, Lower, GreaterEquals, etc. (see OperationType) and BooleanConnectors between them (such as XOR or AND). The parameters that are used here can be existing Data elements or operations from an Application (see both later on) or self-defined constructs.

To use an ActivityNode one needs much more information than only "this is a node". Therefore, the subclass ExecutableNode says that this ActivityNode can be executed itself (dividing it from so-called ControlNodes that are only relevant for the control flow of the process).

An Action is one example for an executable node and means one specific task/action/activity (each standard speakes with different terms here) that can either be executed automatically or performed manually. One might want to specify a targetExecutionTime for an Action and compute afterwards whether the totalExecutionTime (as parameter of Activity) is fulfilled for a given model or not.
The last element in this package is the ActivityLinkNode. This specifies a sub process call from the internal of a given process. Therefore the ActivityLinkNode can be modeled similar to an Action in one Activity but actually linkto another Activity which shall then be executed when the ActivityLinkNode is reached. This allows a nesting of Activities.

REVIEW: The parameters of Action and Activity (target- and totalExecutionTime) have not been used at all as far as I know, since there is no algorithm currently that calculates whether the process can be executed in time or not. This might be removed from the metamodel and outsourced into its own aspect extension which then includes such an algorithm.
The Guards including their GuardSpecification are useful for code generation or simulation of the workflow. But different engines will probably need different constructs. Therefore, it might be possible that the current GuardSpecification will be removed to an extending plugin and only the Guard as a wrapper class will stay in the metamodel.
Since the ParameterMapping of the ActivityLinkNode is connected to the Data and Application package, it's future depends on how these packages will evolve.

Process package (Control node part):

The next screenshot is another part of the Process package and contains all kinds of ControlNodes. As already mentioned these are responsible for starting a process, specifying alternative pathes, parallel pathes or stopping them. The InitialNode and FinalNode are part of every process model and specify when the process shall start its execution and when it stops.
There are different possibilites how the flow can evolve: either we have a simple sequence (Action connected with another Action using an ActivityEdge) or we have alternative (XorControlNode) or parallel (AndControlNode) threads. To specify whether the alternative starts we distinguish between DecisionNode (the point where a decision needs to be made) and MergeNode (two already existing different pathes are merged together again). For parallel pathes the ForkNode (start) and JoinNode (stop) describe the same. Please note, that a JoinNode waits for a token on every incoming edge whereas a MergeNode only on one of the incoming edges.

REVIEW: We just added the AndControlNode and XorControlNode to the metamodel. Now it might be unclear whether to use the more abstract version like AndControlNode or the more concrete version like ForkNode or JoinNode in a model. This is probably specific for each view (e.g. BPMN might use an AndControlNode whereas UML activity diagrams will need the ForkNode and JoinNode), but occasionally inconsistencies between several models might occur. Therefore, this part is still under discussion and might change in the near future again.

Events package:

Another kind of ExecutableNode can be an Event. An Event happens at some point (a message comes in, a sensor recognizes something, a timelimit has been reached, etc.) and then triggers the following activity. In order to cope with these events, an EventHandler has been integrated in the metamodel as part of each Activity. An EventHandler can handle several Events in a predefined way.

REVIEW: Currently Events can be added to the model but one cannot specify any details for this event. Additionally, the EventHandler can't be specified graphically as well and therefore, both are not used very much right now. However, with the integration of the BPMN view in the WE we will need all kinds of Events (MessageEvent, TimerEvent, etc.) and therefore the Events will surely stay in the metamodel. But the future of the EventHandler is unsure at the moment. This might be helpful for BPEL-generation, but whether other languages or process engines actually need this construct is something that will only come up in the future.

References package:
A Reference is a construct to define something that will be available not only in one scope, but in several. Therefore, we will later show different kinds of ReferenceableElements. The Reference will be the element that stands for this ReferenceableElement and is connected with a ReferenceEdge to an Action. A Reference is only available in one specific Scope whereas the ReferenceableElement in more than one.

REVIEW: This technique is very helpful in practice and is quite often used for modeling data, applications or roles. It's usage will probably increase in the future.

View package:
The next package is the View package. This contains details that are necessary in order to display model elements similar all the time when closing and opening the file again. Therefore, the coordinates of each element are needed (Point) as well as the width, height or size (Dimension). Additionally, the direction an edge has needs to be defined (does it point on one side, the other or on both?).

REVIEW: Since the graphical representation of a model is not helpful when executing the workflow later on, we are currently sourcing this out into a separate file. This is also necessary, because different views probably need a different location and size for a model element which is currently not possible.

Organisation package:
As already mentioned there are several kinds of ReferenceableElements. One of these is the Role. A Role describes who is responsible for the execution of a specific Action. If the Role is left out, then this points to a fully automatic execution. Otherwise, people (at least one person) are involved in the execution. In order to structure the different Roles, they can be performed by OrganisationUnits which can be packaged and nested.

REVIEW: Roles are another important aspect of workflow modeling when human interaction is needed (see e.g. the discussions about BPEL4People). They are used quite often, whereas the OrganisationUnits are not used at all. We will see whether those will be removed in the future or whether we will develop an own graphical viewer for these OrganisationUnits in order to support their usage better.

Application package:

The next package (Application) describes how an Action be executed fully automatically. Therefore, one needs to specify several values such as which javaClass is needed, which method shall be invoked or whether the javaClass can be found in a specific jarArchive. The Application comes with an ApplicationType which describes what kind of Application we have: Is it ERP, CRM, PPS, etc.?
After this basic structure we recognized the need for web services and added the WebServiceApplication. This does not need a javaClass, but only an Interface and Operation (and probably some more).

REVIEW: This package needs a complete restructuring. With the subclass-relationship between Application and WebServiceApplication, a WebServiceApplication now contains both: a method and an operation. The ApplicationType is not used at all, so we are already discussing how this part of the metamodel will look in the future.

Data package:

The Data package provides the user with a possibility to specify which files or parameters are needed for a specific execution. Therefore, an Action might have 0..n input and output Data. These data can be structured in several Parameters, whereby Applications have Parameters, too. With the DataMapping the Parameters of an Application can be mapped to the Parameter of the Data and vice versa. Data can be specified in more detail in DataType and InformationType, the former showing the file format (e.g. Adobe Acrobat Reader file), the latter describing the topic of the file (e.g. Order, Invoice, etc.).

REVIEW: The only tool that currently utilizes the Data, is the AgilPro Simulator. But, it only uses the Data and it's value, not considering that there is something like Parameter or DataMapping at all. Additionally, DataType and InformationType are neglected, too. The compution which data is needed for a specific application is only via String-comparison (does the name of the data fit to the needed application-internal parameter? If yes, then it is loaded). Therefore, this whole package probably needs a restructuring as well. Nevertheless, the idea of the DataMapping and binding two parameters together, seems to be a good one, IMHO, and maybe other vendors might find that useful for their tooling. We will see in the future...

Function package:

The last package, a quite easy one, is the one for functions. Similar to EPCs where the function of a specific process can be specified, this function also provides the user with another easy possibility to say what kind of function an action is for. This can be specified on a very high-level business analyst perspective without even knowing what kind of applications and data might be needed for executing the action and can be the basis for a developer in the technical view to decide which application shall be invoked.

REVIEW: The functions are not visible graphically and (probably therefore) not used right now at all. They should be part of an aspect-based extension plugin, but probably removed from the main metamodel.

SUMMARY: We are currently finalizing the aspect-related mechanisms that will allow us to source specific parts of the metamodel out into other plugins. As we have seen, there are many areas where the metamodel should be refined. We will shortly make an own plugin for the metamodel only (currently it is included in the WE) and during this development step we will refine our metamodel. Any comments, ideas and requests are welcome on this blog, the JWT newsgroup or the JWT mailing list. If you already have an Eclipse Bugzilla account, then please feel free to add your comments to the following bug.

JWT welcomes its new mentor!

2008-11-26T12:26:00.000-08:00

The whole team of the Eclipse technology project Java Workflow Tooling (JWT) welcomes it's mentor John Graham. After we struggled for the last two years with the formerly unknown Eclipse processes (but nevertheless managed already two releases), we are glad to have some support for all questions now. John is currently in the PMC of the DTP project and has been working as a committer (and PMC Chair) for quite a while now and is therefore more than knowledgable about everything that we need to know about releasing, packaging, building, IP due dilligence and all the other things that are quite difficult to understand at the beginning.

With him we are looking forward to be integrated into Galileo. Our PMC already gave us the approval to get on the release train, so we are currently preparing everything that is necessary in order to be included in Eclipse Galileo in 2009.

Now you might ask: what is JWT about? With the included Workflow Editor (WE) one can model the business processes and workflows which are initial process engine-independent, but soon with the support of several vendors there will be first implementations and adaptations for important process engines that exist in the market. Using the already existing transformations the modeled workflows can easily be transformed into other models (such as into BPMN or STP-IM) or also to generate code e.g. in XPDL. If somebody prefers the SOA world and web services, then it's also possible to generate BPEL code using the friend Workflow Codegeneration framework. Additionally, there are also already first standalone RCP-applications available that build on JWT such as AgilPro.

Eclipse Summit Europe 2008

2008-11-20T01:50:00.000-08:00

Right now Eclipse Summit Europe just happens in Ludwigsburg and many many people from all different kinds of projects are here to explain what they are doing, how their tools can be used or simply to chat with other experts about their experiences.

As part of this conference there has been an STP face to face meeting. Since we are closely collaborating with these guys in several other projects, the JWT guys had been there too. And actually it was the first opportunity for the project leads of JWT to meet each other in person. After we now discussed all kind of matters via mailing list or on the telephone for the last two years, it was a pleasure to meet the other one in person for the first time. This was the picture that Anne Jacko (Eclipse EMO) has taken from us when we met for the first time.

´

During this meeting we also learned to know other people that are part of STP or met people again that we already knew since EclipseCon 2008 or Eclipse Summit Europe 2007.
It was quite interesting for us that also top-level projects that already exist a lot longer than we do, still cope with problems such as "How to organize the website", "How to make builds", etc.
Specific topics of this meeting were about existing components (SCA modeler, the Policy editor, etc.), but also about the collaboration between STP and JWT. There are a lot of touchpoints between the two projects and we hope that in the future we can work much more closely together than we already did in the last month.

But not only this discussion was quite interesting. Much more the different talks were fabulous. Thanks to Oisin (STP PMC Lead) we got a few minutes in the SOA Tools - New and Noteworthy talk which Marc used to explain the basics about JWT. Unfortunately, the keynote in the morning took much longer, so Oisin was supposed to start later which had a direct effect on the time that Marc had open to introduce JWT. During his talk many people left the audience to go to other talks that had just started, but also others came in who were not interested in STP or workflow details at all probably. Nevertheless it gave us a good opportunity to tell people what we are currently working on.

Another thing that was quite interesting was the Google Summer of Code which Eclipse joins every year now. Each student can apply with a specific topic to that program and from the 30 proposal 20-something have been accepted last year. Each student does get a fund of $4,500 from Google for his/her work, and the mentor needs probably something between 1 and 5 hours a week to work with the student together. Thereby it doesn't matter if the student already worked before on the project or is somehow related to the mentor. Therefore, this would be a good opportunity for our students at the University of Augsburg to get some funding for their work. We will consider that and ask our current students to apply in March.

We also learned to know some other projects such as Eclipse Babel or Buckminster that could be very helpful for us. Actually, the usage of Babel will also be mandatory for all Eclipse projects that would like to join the next Eclipse release (3.5, codename Galileo), so we will definitely have a closer look and integrate it with JWT. Buckminster on the other side allows projects to build an RCP-product or Eclipse application using code from different repositories. Thereby it doesn't matter whether these repositories are SVN, CVS, Maven or something else. So especially for the build of AgilPro or other projects that rely on JWT this will be very interesting to use.

There had also been many improvements on the Eclipse plattform or Plugin Development Environment (PDE) which will make work in the future much more easier. These improvements had either already been included in Ganymede (Eclipse 3.4) or are part of the milestones of Galileo.

What was also quite interesting to hear was that after Galileo, there will be two releases in 2010. One for Eclipse 3.6 (codename not known right now) and another one for Eclipse 4.0 (currently work starts in the e4 project). The workbench of Eclipse will be mostly re-written. Therefore, I heard a talk from somebody who said that it should be based on EMF. This is surely a good idea, but the strange thing was that the person who submitted the first version of this EMF-model did not use EMF for more than one year. So at the first moment, I thought, this is probably not good to build a new workbench on the proposal of somebody who didn't completely knew the technology. But afterwards he said that he works closely together with Ed Merks and other EMF committers and project leads, so I guess the EMF model has been reworked quite well.

As you can see on the following picture, the conference was quite crowded. But nevertheless, it's fun, too :-)

After lunch we attended the talk by Janet Campbell about IP for Eclipse Committers. Since we struggled several times with how this process works for our last release, it was great to hear the process explained in more detail and to get all our questions answered. So, hopefully, the work for the next release will be a lot easier.

Alas, after this talk and after lunch we needed to leave the conference already, since we had some other appointments the same day back at the office. So we missed interesting talks such as Modeling Amalgam as a DSL Toolkit or Eclipse Swordfish (and many others of course). Maybe somebody else listened to them and will write a short summary about them, too. If interested, you can find some more pictures from the conference here.

How to semantically annotate a process model?

2008-11-11T00:01:00.000-08:00

During my research I got confronted with a lot of different approaches how Semantic Business Process Management (SBPM) can be done. This means in the first step, that the process models need a semantic annotation. But what does that mean?

If you model something (and here it doesn't matter whether this is a business process via BPMN, a UML class diagram or a flow chart) you make use of a standard that defines what kind of model elements exist: in BPMN you have Activities, Events, Gateways, etc. In UML class diagrams you have classes, attributes, methods and assoziations.
So these define what the metamodel element is about. There is often no clear defined semantics in a machine-readable way how a Gateway in BPMN or a method in UML shall be used. The semantics of these elements is mostly captured in a textual way.

So for every human who has a little bit of knowledge about BPMN or UML it is mostly clear what these diagrams mean. But what does a computer do with that? Can it "understand" what we model? Sure, you could say, I tell him that each Activity in BPMN shall be executed. Okay, that's fair. But what does it need to execute? What does the label in these Activities mean? And are there e.g. any relations between an Activity in BPMN and e.g. an Action in UML activity diagrams? The PC simply can't say.

That's where the semantic annotation comes into play. Annotation is contemporary English and has two meanings:
(1) a note added by way of comment or explanation
(2) the act of annotating.

As outlined in this session the annotation can be about a whole document (document-level annotation) or refer to just a specifi part of a text (character-level annotations). Additionally, it can be about the constructs defined in a metamodel (metamodel-level annotations) and on elements in the model itself (model-level annotations).

So, with semantic annotation we aim to capture the semantics of the metamodel elements when different representations are used as well as the terms that describe the model elements.

Now you may ask: what for?

Business process models and workflow models have despite their growing usage still some obstacles to cope with:
- they are used for documentation purposes only
- they are often not up-to-date
- they are not executable
- not all processes /workflows in a company are modeled
- there are different (somehow incompatible) representations used in different companies or departments
- several constructs for one real-world entity exist
- and (the other way round) one construct can be used for different purposes

Now I'd like to come to the initial question: how to semantically annotate a process model?

There are several research projects in the world and many of those need a semantic annotation of the process model (for the rest of this blog post I'll only speak about process models and workflows, however, semantic annotation is definitely something used also for other modeling areas such as software or systems engineering).

Yun Lin describes in her dissertation "Semantic Annotation for Process Models" an approach where an additional tool is used that can read an existing process model and one or more ontologies and can then annotate the model elements with concepts of the ontology and store that in an additional file. This approach (also called "Use metadata to bridge models and ontologies" makes it easy to leave the proprietary process model independent so it can be changed in the modeling tool, but once changes are performed the semantic annotation might not be actual any more.

Michael Fellmann and Oliver Thomas describe in their paper "Semantic Business Process Management: Ontology based Process Modeling Using Event-Driven Process Chains" and in a newer version in German I just got to read how semantic process modeling (a synonym for the semantic annotation of process models) can be done. In their approach they also use metadata to describe what each process action in a business process model means. This metadata connects the process model to an ontology that builds on the Suggested Upper Merged Ontology (SUMO) and where not only domain knowledge but also knowledge about the process language is stored (e.g. they have Activities as well as Offer). But in my opinion this approach makes it quite difficult to use existing ontologies: a domain ontology probably won't have concepts such as Process, but will only talk about the domain at hand.
Additionally, it remains somehow unclear how the semantic annotation is done in practice. They say that they use Protégé for ontology creation and in another paper they speak about semantic wikis for storing the relationsships in a process model. But neither of those two makes a semantic annotation possible. That there is a relationship can be seen on the website of one of the authors, where Semantic Business is linked with a semantic wiki.

The problem with both approaches (by Y. Lin and M. Fellmann) seems to me that they always need another tool. How can business managers be persuaded to first model their processes (which they don't seem to like that much) and afterwards also annotate these models in another tool? I guess this could be quite hard.

Therefore, our approach builds on the extension of a single tool. This can bring the problem that one is bound to a single modeling language for which this extension in the tool is created and that is of course not something we should aim for. Therefore, we'll leverage an existing well-known plattform that by now supports several modeling languages and a lot of more things and which usage is still growing more and more: the Eclipse plattform.

Therefore, we'll use the extension points that are one critical element in Eclipse and extend any existing EMF model with a semantic annotation. By this, we are not only bound to a specific modeling language (such as BPMN), but can support the semantic annotation for several existing modeling languages that already exist in Eclipse or will be integrated in Eclipse at a later time.

Our prototypical implementation will be based on the Eclipse project Java Workflow Tooling (JWT) that is a plattform for modeling, execution, simulating, deploying and monitoring any business process or workflow. More details on the project JWT as well as on our mechanism how this semantic annotation is made independent on the underlying metamodel will be described in the next blog post.

Just started...

2008-11-06T02:17:00.001-08:00

So, this is the first article in this new blog. This blog will be concerned about personal experiences, many things about programming in general and especially about Eclipse. I'm a project co-lead of the Java Workflow Tooling (JWT) project and will write time and again about things that we experience there.
I'm working as a researcher on my Ph.D. at the Programming distributed Systems lab. My thesis is concerned about how business process and workflow models can be extended by semantic information and how this additional information can be used for other purposes. A list of my current publications can be found here.