With BPM maturing over time new customers buy into BPM or improve their existing infrastructure. These new BPM initiatives aim at raising the abstraction level with end to end modeling capabilities, harvesting SOA investments made in the last years, and take advantage of new BPM engines.
With higher abstraction in place combined with agile methods the development cycles tend to be shorter and the cost for functional units are decreasing.
This leads to a surge in processes to be automated. An increasing number of implemented processes leads to more complexity.
In this presentation you will be shown ways on how to tame the complexity with a development process that includes business architecture, iterative (BPMN2 roundtrip modelling with Runtime Extension developed for Eclipse BPMN2Modeler) process development and deployment based on Eclipse Stardust.
Presenters:
Gregor Gisler, ITpearls AG
Bob Brodt, Red Hat, Inc.
VIP High Class Call Girls Jamshedpur Anushka 8250192130 Independent Escort Se...
EclipseCon BPM Day Ludwigsburg - Roundtrip Modelling with Eclipse Stardust
1. Eclipsecon
Process Driven Software Development
at a larger Financial Institution
Iterative and agile methodology, BPMN2
Modeling, Eclipse Stardust Roundtrip
with BPMN2Modeler Runtime Extension
Version 1.0
Presentation 27.10.2014
The editor is extended through user-written plugins which implement one or more of the following extension points. The plugin defines what we call a «Target Runtime» because it customizes the editor for the BPMN2 language subset that is supported by a specific execution engine.
The Target Runtime language subset can be extended in a number of ways:
You can bring your own model. If you already have an EMF ecore file and java implementation classes, these can be directly used by your editor plugin. This is how the Stardust plugin implements the model extensions for the Stardust engine.
Extensions can be defined using plugin.xml definitions.
Finally, these definitions can be declared in a configuration file in your runtime workspace and will be dynamically loaded when the editor is started.
The Tool Palette can be completely redefined. Tool Profiles allow you to define a set of tools and associate them with a profile name. These tool sets can then be customized for a specifc developer role, or task. There is also a Domain Specific Language that allows you to create what are called «compound tools». Thus, you could define a single tool that creates a sequence of connected activities, gateways, events, etc.
Property sheet tabs can be customized for each type of BPMN2 element. The core editor provides default tabs that can either be subclassed, replaced by a custom implementation or completely omitted.
Graphical elements can be customized using hooks into certain Graphiti implementation classes.
We have found that not all XML parsers are created equal. Some engine language parsers are written by hand and don’t necessarily follow all of the rules of XML. This is why the editor allows for overriding the EMF Resource implementation. This is where parsing and serializing behavior can be defined.
Finally, the editor provides hooks into the editing session lifecycle, object creation, initialization and finalization for specialized handling.
[Transition slide: Gregor, this is where you hand off to me.]
In 2012 Red Hat sponsored development of the original prototype for what was to become the BPMN2 Modeler.
BPMN2 Modeler is an eclipse project under the SOA top-level project and, as such, is open source so we invite the community to use the product, make suggestions for improvement, and contribute bug fixes and enhancements.
The mandates for the project were simple:
First, Make it BPMN 2.0 spec compliant. The BPMN 2.0 specification is huge and overly complex in my opinion because it tries to be all things to everyone. In our case compliance does not necessarily mean exposing the entire specification through the UI, but make that which is implemented, conform to the specification.
The editor uses the Eclipse BPMN2 metamodel project as the underlying model. This model does indeed implement the complete BPMN 2.0 spec so the editor can surface all of the BPMN2 elements through the UI. However, for simplicity we chose not to do so for the core editor. This leads us to the second mandate...
Mandate 2: Make it extensible. I’m not aware of any execution engine that implements the entire BPMN 2.0 spec, and each has different requirements depending on the applications it is designed for. Our baseline during development of the editor’s public API, was jBPM which is Red Hat’s offering in the BPM space. The jBPM engine implements a rich subset of BPMN 2.0 but also defines several extension elements. So, not only does the editor’s plugin API need to be able to surface these extension elements through the GUI, it also needs to hide those elements which are not supported by the engine.
Mandate 3: Leverage the eclipse Graphiti graphical editor framework. Graphiti is an abstraction layer on top of eclipse GEF and Draw2d which makes it relatively simple to build rich graphical editors with very little coding. There are several benefits to using such a framework:
A flat learning curve: the user interaction and graphical rendering is all handled by Graphiti and provides reasonable defaults. The developer needs to focus only on managing the model and responding to model changes triggered by user interactions.
Fast development: because most of the editor is already implemented in the framework itself, developing a new editor is relatively simple.
Common look and feel: Graphiti provides all of the features you would expect from a graphical editor, including Drag-n-drop support, tool palette, an Overview page, Property pages, hover help and tooltips, etc.
Accessibility: refers to a software tool’s usability by disabled persons. This is already part of the Graphiti framework.
The editor is extended through user-written plugins which implement one or more of the following extension points. The plugin defines what we call a «Target Runtime» because it customizes the editor for the BPMN2 language subset that is supported by a specific execution engine.
The Target Runtime language subset can be extended in a number of ways:
You can bring your own model. If you already have an EMF ecore file and java implementation classes, these can be directly used by your editor plugin. This is how the Stardust plugin implements the model extensions for the Stardust engine.
Extensions can be defined using plugin.xml definitions.
Finally, these definitions can be declared in a configuration file in your runtime workspace and will be dynamically loaded when the editor is started.
The Tool Palette can be completely redefined. Tool Profiles allow you to define a set of tools and associate them with a profile name. These tool sets can then be customized for a specifc developer role, or task. There is also a Domain Specific Language that allows you to create what are called «compound tools». Thus, you could define a single tool that creates a sequence of connected activities, gateways, events, etc.
Property sheet tabs can be customized for each type of BPMN2 element. The core editor provides default tabs that can either be subclassed, replaced by a custom implementation or completely omitted.
Graphical elements can be customized using hooks into certain Graphiti implementation classes.
We have found that not all XML parsers are created equal. Some engine language parsers are written by hand and don’t necessarily follow all of the rules of XML. This is why the editor allows for overriding the EMF Resource implementation. This is where parsing and serializing behavior can be defined.
Finally, the editor provides hooks into the editing session lifecycle, object creation, initialization and finalization for specialized handling.
Highlights:
Graphical drawing canvas
mulitpage tabs at top – diagrams
multipage tabs at bottom – sub processes within a diagram
Property Sheet
Alternative: use popup dialogs to save screen space
Tool Palette
Profiles
Outline
Business Model
Diagram Interchange Model
Thumbnail