"heiko.braun@jboss.com" wrote:
Let's take a different angle: This is not about the process definition language. (It's going to be pluggable anyway, right?)
Ok, maybe we already look at it differently here. Executing process languages is the thing that jBPM (ok PVM) does for you and supporting that should be exposed by the API.
Pluggable yes, but you cannot drop-in replace jpdl for bpel or xpdl :-) and in each of these executable languages you can do things you cannot do with the other.
But instead of going into details, I'll read on first, maybe we agree more than I upfront think ;-)
"heiko.braun@jboss.com" wrote:
Building an API doesn't necessarily mean throwing away what's there, it could as well mean refactoring the existing one.
The API will have core elements and terminology. Each core elements has associated semantics which lead to implementation detail. We want the API to be correct, easy to use and easy to learn.
The process of finding these core elements (or core concepts) and establishing names for them is important to get one step closer to 'correctness'.
Establishing names... great (read my lips: no-more-mapping).
finding common elements or more complex elements (like different gateways) and use those in jbpm... ehh... jpdl, great, but that is process language. The gateway (decision in jpdl) is not something I've ever used from 'the' api...
Basic things I did do with 'the api' are
- start a process
- end a process
- signal process to continue (either via default or supplied transition)
- set a variable
- read variable
- get a tasklist
- end a task
- get basic properties of a task/node/.... in a process instance (e.g. task.hasEnded())
- ...
Although... working on tasks is already more complex. In jpdl you can have variables with a task scope, or on the process level. It has to be clear how to do that and should be possible via an api. In howfar this is possible in all process languages I'm not sure, so should this be generic? Or put in a more process language specific api, e.g. on that extends the basic api?
"heiko.braun@jboss.com" wrote:
The well known list of 'basic concepts', which Thomas suggested, is merely a collection of core elements that will lead to both a meaningful set of API that can represent of large number of use cases to begin with, but at the same time covers critical areas of the engine implementation. At least that's the idea.
You mean language implementation instead of engine implementation right? To me an 'engine' is the implementation of a language on the pvm. Regarding the number of use cases I wonder if this is from a theoretical of practical view. As Bernd points out the flexibility of jBPM/JPDL and the way you can use the current api is one of its usp`s
"heiko.braun@jboss.com" wrote:
If the list is incomplete or the terminology is somehow misleading then make suggestions how it could be changed.
Terminology is imo certainly not misleading, but the collection of concepts is, well not misleading, but maybe to theoretical, or as mentioned earlier something that belongs in a process language
"heiko.braun@jboss.com" wrote:
Again this doesn't necessarily mean we ditch the existing jBPM4 code base, it's merely a process of verification.
That is what, to a great extend, has been done the last years, hence we are now where we are with the api and language constructs. Verification against real live usecases and not just theoretical usecases (workflow patterns) or a non-excutable, visual definition (bpmn)
That BPMN is eventually becoming more popular, the alignment of BPMN 2.0 with XPDL and a usable (free) editor, the time is now indeed right to leverage it more, but *without* losing the flexibility.
"heiko.braun@jboss.com" wrote:
If the current code base would already have a precise and 'to the point' API, then we wouldn't need to do it.
The 'current, 3.x' api has grown, and once you know it (it is not hard to learn if you use it) is not to bad. It's not as to the point as it could be but that is something Tom was/is working on for jBPM4 (afaik) before this common api discussion started.
"heiko.braun@jboss.com" wrote:
Here's how I can picture the meeting:
We go through the list of core elements and for each of those we'll first discuss correctness and importance of that element in a BPM world and then secondly match it with jBPM4 elements. Either the BPMN expression is wrong to begin with or unnecessary for jBPM4 (no use case) then we can ditch it right away. But if it turns out to be important then it will either have a representation in jBPM4, just differently named or it requires changes to the code base.
Now I'm kind of lost... you start with saying it is about the api and not the process language, and now it is mostly the language (elements are for me language constructs)
What I think is more important is what we want to do with the (basic) api. Three things (quickly from my head, not complete maybe)
- work on individual process instances
- signalling
- setting properties
- reading properties (
- working on (a set) tasks
- getting a tasklist
- ending a task
- setting variables/propperties/...
- advanced things
- get a tasknode in a process-definition and create a task on it
- ending specific tasks on other nodes if something happens
- ...
Why these advanced things? Because up to now you could not do everything in the jpdl language (but also were not limited to it!!!!) but had to write some small (often reusable) javacode to achieve something (see my milestones blog).
Agreeing on a basic api for the first two items will not be hard at all with using BPMN terminology. Extending the language or providing additional node implementations via javacode so more bpmn elements are provided out of the box is also something we can agree on
The third item has a lot to do with the process language. In my milestone example I explicitly create a task from another node. In another upcomming example, I send the other node an event/signal/trigger (yes, we should standardize here ;-)) so it can create the task itself. Probably fits better in BPMN, but are these kinds of events supported? Currently looking into that.
Maybe we should have two api's per 'language', one basic that is common across process/workflow languages and an advanced one specifically for a language. For jpdl, the advanced api can be the jbpm api that is currently there. I'm just not sure though how pageflow, threadcontrol will fit in thebasic api (terminology wise) if that is a goal at all.
"heiko.braun@jboss.com" wrote:
But we'll start with a small set, and then gradually increase to the API until it is feature complete. In the beginning, the API would not allow you todo everything jBPM4 is currently capable of, but sooner or later it will.
Two things:
- Feature complete by the GA release? That is sooner than later.
- jBPM4 currently is not capable of 'anything' (ok exaggerated a little). The (new(er)!!) api`s are (were?) under development, JPDL4 is under development (maybe new language constructs like support for different gateways out of the box)
Two things I cannot stress enough:
- backwards compatibility needs to be there....
- do not underestimate the current flexibility of jBPM (jpdl) and how it is used in other products
Good discussion btw... lets keep it going, maybe the november meeting will be short then and we'll have lots of time to get used to kasteelbier ;-)