Best practices question.
I am trying to model a situation where I have a person that is counting widgets (manually pressing a button) as they pass by him one at a time.
Every once in a while the color of the widget will change, when this occurs, the operator presses a different button. I don't know how often the color will change but I do know what the next color will be.
After each widget passes the operator, the widgets will be boxed (always x number of widgets to a box without respect to color) in the exact order they are created.
Now, these widgets are fairly valuable and need to be tracked individually as they are processed further. Although widgets are boxed together, they have specific processing rules for each individual widget that are assigned as the widget passes the operator. The boxing of widgets makes it easier to transport widgets and control loss until the next processing step.
What are some thoughts on how to design this process? The goal of this system is to:
1) track the widgets, gather BAM statistics to determine inefficiencies
2) automate the process so that a person doesn't need to assign specific processing requirements for each individual widget - the system should do this.
3) not worry about the processing before the widgets pass the operator. This is already automated/controlled by a third-party system that I have no access to.
4) track how 'effecient' the operator of the button is.
I see the operator 'button-pressing' as a process in itself. Kind of a 'looping' process definition that doesn't end until one operator is relieved by a second person. As the operator presses a button, a transition to a second node is taken, this second node creates a individual process instance for that widget. The process then transistions back to the first button to wait for another button press.
The other process definition describes the operations/tasks that are performed to further process an individual widget. This is fairly well defined but there are quite a few decisions that control the flow of the process.
Couple of best practice questions:
1) does it make sense for one process to create/communicate with another process? If not, how should I handle the above example?
2) Is there going to be an issue with performance in that I would be losing button presses (widgets) if I am not back to the 'waiting' node before the button is pressed?
3) I am not planning on jBPM being implemented in a web environment as shown in the getting started wiki pages. Instead, it is going to be embedded inside our 'application' and used more to control process state and decision making. Is this a correct way to use jBPM?
Thanks for the input,