Recently I was invited to read and review a recent publication on an important component of the Oracle Fusion Middleware stack: BPM Suite 11g. This book is titled Oracle BPM Suite 11g Developer’s Cookbook. It was written by Vivek Acharya and has been published by Packt Publishing. It contains close to 500 pages. The book homepage on the Packt Web Site is: : http://www.packtpub.com/oracle-bpm-suite-11g-developers-cookbook/book.
This article provides an overview of this book and my first impressions of it. In short:
The breadth of the book is impressive. Vivek has done a great job in describing many topics and aspects of the BPM Suite story. Along with the impressive scope, he also manages to provide a lot of details and in depth descriptions, for example in his discussion of business indicators and BAM, configuration of fault policies and on the development of User Interfaces with ADF to support Human Tasks. He uses a single case throughout the book – a case that is clear and comprehensive. Not too simplistic to become trivial and neither too complex to overburden the reader. Both business and process analysts as well as developers will benefit from this book – although I think that the former roles may find the level of technical detail a little overwhelming (the discussion of Data Objects for example very early on mentions XSD – too early in my opinion).
On the other hand, even though the book is very recently published, it does not discuss the very important new features in BPM Suite first introduced in the PS 4 Feature Pack (August 2011) and release as part of PS 5 (February 2012) (apart from a two sentence reference to the ability to do correlation for BPM instances). Subjects such as draft processes, instance migration and altering running instances (as one way to add improvisation) should in my opinion have been part of this book. I also find the discussion of the Composers (both the SOA and Process Composer) wanting: when it comes to run time, business driven agility, these tools are very valuable. Yet they are hardly mentioned at all. The same applies to events and the event delivery network (at the same time JMS based interaction is discussed at length – arguably less business level than EDN).
Although many topics are explained as well as demonstrated in a large number of useful screenshots, some subjects are mentioned in passing but not explained at all -leaving the reader a little bewildered about what just hit them.
All in all when you want to get a pragmatic introduction to Oracle BPM Suite that gets you started with doing things and also helps you understand many of those things, this book is an excellent investment. Even for readers who may not do BPM Suite but only SOA Suite, this book is very useful because of its introduction and detailed discussion of Business Rule, Human Task and ADF based User Interfaces for Human Tasks and several examples of fault handling, adapter usage and run time monitoring and configuration.
The central case in the book is a business process for responding to a Sales Quote request. Some customer wants to order certain products. The process for determining the offer to be made to the customer – including the discount, the final price, additional terms etc. – is modeled and implemented over the subsequent chapters. This includes the implementation of the Business Rules and the User Interfaces for the Human Tasks. It even includes configuration of a File Adapter for writing the Quote details to a file.
Packt publications over the past months have adopted a structure based on recipes. For example the OSB 11g Development Cookbook that I recently reviewed is organized that way – and for that particular book it works very well. This book on BPM Suite is best read back-to-back, so the recipe structure does not provide a lot of additional value.
The Chapters
Chapter 1 (Process Modeling) provides the foundation for the book. It describes the relative position of BPM in the enterprise, linked to Business Strategy and Enterprise Architecture. It describes the phases an enterprise will go through in applying BPM. It then drills down a bit to talk about the activities and roles in doing BPM Modeling. It discusses when to use BPA Suite (IDS Scheer’s ARIS based) and when to use BPM Studio. It briefly mentions Process Composer and MDS. It introduces the organization of the book’s business case – FusionNX – and the SalesQuote business process under scrutiny in the book. After these initial necessities, on page 21 the modeling of the process flow starts in anger. On page 22 the first reference to XSD is made (way too early in my opinion, and not explained at all). The SalesQuote process that the book will further explore and implement is introduced step by step and the visualization of the process is provided. Subsequently, the reader is invited to start JDeveloper and open BPM Studio to model the business process that was just introduced – pretending to play the part of the process analyst.
One can argue about best practices. One practice I advocate is to not refer to individual users in applications or business process definitions, but only to roles. The mapping between roles and users is made elsewhere, outside the process implementation. The author decided to not apply this practice, but instead include direct references to users (from the WebLogic Server internal LDAP directory). To make things even more confusing, the users have role-like names such as salesrepresentative and businessanalyst .
When the organization units have been created and members have been added, when the business calendar with working hours and the holiday rules have been created, then on page 39 the business process itself is created. In a brisk pace the first activities are added as are some gateways and sequence flows. The first data object is defined – called BusinessAnalystReviewRequire. Here is the first of several examples in the book where naming conventions have not been applied rigorously and some confusion may arise. In this case, an added d – BusinessAnalystReviewRequired – would have been more logical. More confusing choices with regards to naming occur throughout the book (for example in the chapter on business rules).
After Exclusive Gateways the Parallel Gateways are also introduced. Additionally, interaction with other processes and services is introduced – through Service Tasks.
The author chooses to not only discuss the process activities, gateways and flows but also dive into the details of data objects and sequence flow conditions. For a technically inclined reader, that is perfect – because it quickly makes the story more tangible and concrete. However, a process analyst may not feel comfortable with a discussion of booleans and strings and the example of an XPath expression so early on. (it is my experiences that there is a fairly sharp division between implementors/developers on the one hand and analysts/modelers on the other. Variables, data types and expressions are very much not part of the comfort zone for that latter group. Perhaps it should have been introduced a little bit later on in this book.
The final part of this first whirlwind chapter is a discussion of MDS and the publication of the process from BPM Studio (== JDeveloper) to MDS to share it through Process Composer. It would have been nice to also describe and show the Process Composer end of things; the chapter now leaves you with the instruction of connect to MDS and deploy from BPM Studio but does not take that next step.
Undoubtedly however, at the end of this chapter (page 77) the author has accomplished an awful lot. The reader may have to read the chapter twice, but he will most certainly have made a lot of progress in getting going with his first BPM process. To the point where we could already simulate the process! However, the author has chosen to postpone that discussion until chapter 6.
Chapter 2 discusses process implementation. This includes User Interaction activities that translate to Human Task components at SOA Composite application level. The default task forms are generated and outcomes are defined. The next step is a little bit advanced (too advanced for this stage in the book perhaps): how to create a common task and task form that can be used for several user interaction activities in the process. Next Data Associations are created – mappings between Process Data Objects and the Input and Output for process activities. Then a Service Task is implemented by creating a File Adapter service to write data from the process to the file system. This is a very concrete implementation task, one that will be beyond most process analysts I believe. Note: in a real system I would adopt the practice of not linking a business process directly to a technical adapter, but inserting a Mediator component in between. I can see how that would unnecessarily complicate the chapter – yet now it seems to almost encourage very direct dependencies from the process on the fairly technical directly environment dependent adapters.
At the end of chapter 2, the process is designed and implemented and ready to be deployed. It has flow, logic, human interaction and even a service that will write data to the file system.
Chapter 3 has the reader deploy and initiate the process and subsequently act on the tasks assigned to various users. It demonstrates the BPM Workspace, the generated Task Forms and the Enterprise Manager FMW Control console.
This illustration shows the visual trace of a process instance that was triggered and executed:
The last section of the chapter is titled Debugging. A little deceptive as true debugging is not supported in the BPM Suite. The section really explains how to configure the most fine grained audit level in the EM console.
Chapter 4 is on Business Rules. From my own experience of writing a book on Oracle SOA Suite, back in 2010, I remember all too well that Business Rules are a tricky topic. It is hard to explain what the Business Rules are and how they work. It is easy to either provide too little or too much detail. The rules are not as intuitive as one would expect from a concept and a tool that is so clearly aimed at business users.
The author describes both types of business rules: the (simple) IF/THEN rules and the ‘clustered’ Decision Tables. He introduces the latter using the business rule CheckCustomer that a few pages later is suddenly called CustomerCheck:
This rule needs to decide on the approval flow that is required and the effective discount that is awarded given the type of the customer (new or known) and the quantity of the quote. So far so good. However, the author makes things a little confusing in the ensuing discussion.
- he introduces the ApprovalFlow Data Object with several properties including Tier1ApprovalNeeded. However, this property is not assigned any value but false and therefore seems superfluous. It caused me some confusion.
- he introduces a global variable – a constant – to compare the value of the Quote.CustomerType with in order to determine if the customer type is New; this global is called CustomerType – rather than something like NewCustomType or any other name that explicitly refers to New. Again, quite confusing
- he creates an incomplete end result: a decision table that does not cater for the case where the customer is not new and the quantity is under 50; again, confusing for someone trying to figure out what all of this means.
In the second example, the business rule DiscountCheck that is used to determine whether the size of the discount in conjunction with the type of Customer (premium or not) is discussed. Here too the author is a little sloppy: he discusses the cases where the discount is higher than the threshold (spelled Threashold) and the custom type is Premium or not, but he fails to discuss the situation where the discount <= threshold.
Not only is the logic incomplete, the Business Rule will actually return a fault when invoked for cases where the discount is not over the threshold. Also, the name of the global constant used for holding the discount threshold value is Discountvar, a vague and unclear name. This would also be the perfect opportunity to talk about the SOA Composer where at run time the value of this threshold value can be altered. Vivek hints at the possibility of modifying the business rules at run time – a very powerful notion I believe – but unfortunately he does not explain nor demonstrates this in any detail. I believe that a missed opportunity.
The author demonstrates how the rule can be tried out by starting the business process with different input values. He could also have demonstrated testing the business rule using a test function inside JDeveloper – the easier way to test an individual business rule.
Note that despite my criticism, the chapter does a fair enough job of making clear what business rules can do and how they are configured.
Chapter 5 – Human Workflow in BPM Process continues the introduction on Human Interaction activities in chapters 1 and 2. It introduces the Human Workflow Services in the SOA Suite – including aspects such as allocation (aka assignment), escalation and notification. This chapter does not really discuss any BPM specific details. It does a great job of explaining some Human Task theory that applies to anyone using Human Task components in the SOA Suite. For example Task Stages (Sequential and Parallel) and Participant Types such as user, role, management chain (with dynamically determined number of levels) or dynamically generated list of task participants produced using business rules. It talks about Approval Groups defined at run time through the BPM Workspace application and about Adhoc Routing. All in all a great overview of some quite advanced features of the Human Task component. Note that Appendix B continues on this discussion by introducing AMX – Approval Management Extension – and providing some even more advanced examples of creating task approval routing.
Chapter 6 – Process Simulation. Vivek uses a lot of words to explain why he discusses simulation only so late in the book. It is as if a reviewer suggested he move it more to the front and he did not want to do that and instead tries to justify that decision. I feel simulation could have been discussed earlier on. The process analyst can make perfect use of simulation and could already to do right after chapter 1. I fear that this analyst will not make it through chapter 2 all the way to this chapter 6, which is unfortunate. Despite his many words of defending his choice, Vivek does not convince me.
He argues that “Implementation before simulation is helpful” using various reasons that more or less amount to: implementation results in data that can be used for better simulation models. However, he does not demonstrate how that works: which data becomes available by first implementing for simulating and how can that data be fed into the simulation? The question is relevant: the simulation is configured for example with percentages of process instances that go in each direction at gateways and with the average time required to complete an activity. Deriving these values from real, accurate data rather than just feeding in some best guesses would be perfect. Vivek writes “It [Oracle BPM Simulation] actively assists the user with setting model parameters to match known aggregated metrics of the as-is process”, but he omits an explanation of exactly how this is done – deriving the metrics and loading them into the simulation model.
The description Vivek gives of how simulations are set up and run is very clear. He makes a good case explaining why simulating the process can be instructive. His primary example of improvements that can be achieved is by finding that additional resources for specific human tasks will reduce the average time to completion by a staggering degree. He also concludes that by doing so, a more than substantial cost reduction would be realized: from $17000 to $3000. He does not explain how adding resources will decrease the total cost – and that might be the most valuable piece of advice in the entire book. In addition to adding resource where it helps the most, BPM Process Simulation will also typically help spot opportunities for parallel paths in the process instead of currently sequential flows; such findings are typically more dramatic and less obvious than adding resources; I would have liked such an example too.
Chapter 7 Developing UI using Oracle ADF is not really about BPM Suite. Developing User Interfaces with ADF, to support Human Tasks, is not strictly speaking a BPM topic but a much more general subject. That makes Chapter 7 no less useful – quite the opposite in fact. It goes a long way in explaining the various approaches for creating an ADF user interface for a Human Task defined in a SOA Composite application – including generation of the task form, using the task wizard and leveraging the task data control for individual bits and pieces of the task definition. It even explains routing between ADF Faces pages and using a Train (multi step wizard) component. The final segment of the chapter is called Creating a Task form with ADF Business Components. Here it seems the author had a plan but in the end decided to do something else. The text introduces ADF Business Components – a framework for interacting with a relational database – and then goes on to use the Database Adapter in SOA Suite to connect a BPEL process to a PL/SQL procedure. The BPEL process exposes its service interface as a web service. The chapter then uses the ADF Web Service Data Control to create a data control for the web service that represents the BPEL process that virtualizes the database adapter that represents the PL/SQL procedure. Why the ADF Business Components framework is not used, is not explained. The Data Control is given the name OpportunityVO – suggesting an association with ADF BC that also uses the VO abbreviation for ViewObject. However, that association does not really exist. Note that the next erroneously states Data Source Name instead of Data Control Name. Not a biggy, but confusing for novice readers.
The chapter demonstrates how this Data Control can be leveraged to add fields based on the Web Service (aka BPEL process aka PL/SQL procedure) output to the Task-supporting-ADF-pages – which is neatly done. Quite cool in fact.
The chapter then describes the creation of a real ADF BC Entity and View Object, based on a Database Table – but it never makes use of it, making me wonder why it was discussed at all.
Chapter 8 – Exceptions. A clear and straightforward discussion of the Error Catch Event activity used in the business process to handle an exception raised by a service task (upon reception of a SOAP Fault from the Web Service).
Subsequently a good explanation of a business event that are raised within the BPM process itself and that is handled by an Event Handler (of type Error as opposed to Timer and Message) at the start of a sub process. The Fault Management Framework in the SOA Suite is intended to provide error handling that is external to SOA and does not impact the SOA/BPEL design or runtime. Even though that framework is quite far removed from the level of the business process – as it deals with system errors, not with business exceptions -the book provides and extensive example of using the Fault Management Framework, including detailed configuration of xml files. The next topic discussed is the Timer Event that can be used to throw a time out exception when a certain period of time has passed (and the scope on which the timer event was specified has not yet been completed). Annoyingly, all activities in this example are misspelled: CatchSLAVoilation, SLAVoilated, ThrowSLAVoilation etc. The example is fine, the spelling distracts a little.
The chapter concludes with a demo of all the exceptions (and their handling) at run time. This further clarifies what is already a well explained area.
Chapter 9 BPM and SOA in Concert. Of course we have been using BPM and SOA in concert throughout the book. The BPM(N) component that defines the Business Process worked with Human Tasks, Business Rules, Service Components and even Adapters at various points throughout the book. This chapter makes some of that interaction a little bit more explicit.
The chapter shows how the BPM process can invoke an asynchronous service task – receiving the call back response at a later point in the process flow. The wording is a little unclear at times: “Invocation is carried out by the throw message event, which is configured to initiate a conversation. The BPMN service engine performs the invocation and callback.” It is the remote service (engine) that performs the call back I would think, the BPMN engine handles the response received during that call back – it does not perform it. Unless of course the asynchronous service that is invoked is just another BPM process that has to do the callback.
A little later, the text makes clear that when the process has not reached the Catch Message Event activity that receives the call back, when the call back comes in “then the engine waits for the service operation to complete before passing the token to the next flow object in the process”. I take this to mean that when the process is specified with: A – throw message Event – B – C – D – catch message event – E – F (where A-F are process activities) and the process is executing C when the call back message is received by the engine, that in that case C is completed, D is performed and only then the message is fed into the process flow. I also suppose, though the book does not explicitly say so, that when D is complete and no callback is received yet, that then the process instance will freeze until the callback is received.
A little further on, Vivek writes: “You can use send and receive tasks too for invoking asynchronous services and BPMN processes.” (instead of message throw and message catch). He does not make clear what is the difference between the two approaches and why/when you would use one or the other.
The synchronous invocation of (what becomes a child) process is discussed – straightforward.
Then a somewhat detailed demonstration of how a BPM process can be triggered via JMS. The JMS Adapter is configured – twice: inbound linked to the BPM process and outbound linked from a BPEL process that is used to publish the event that has to trigger the BPM process. I wonder why the author chose this fairly elaborate, technical JMS approach instead of using the Event Delivery Network (EDN) in SOA Suite, that would seem more appropriate. The description though is clear and potentially useful.
Chapter 10 End User Interaction. The introduction to this chapter is promising: “Post deployment, it’s the end users who will interact with the process by participating in it. In this chapter, you will focus on end-user interaction in the running process. While learning about end-user interaction, you will also experience the power of Social BPM.” The chapter is only some 15 pages and it is a bit of a disappointment: it shows some screenshots from Process Spaces and it demonstrates how to create a Poll and an Announcement. But it fails to give an overview of what can be seen about a process instance at run time and how discussion around that ‘case’ or instance would take place. Nor does it tell us anything about collaboration “on the design of the model” or “task collaboration and is used to view details for all running processes”. The introduction of some features of the Business Process Workspace is relevant, but it is only a tiny little bit of information dispensed in this chapter.
Chapter 11 Manage, Monitor and Administer BPM Process – the final chapter. It opens with a very good explanation of business indicators, such as counters, dimensions and measures, that process instances can expose and that can be used to report on. The author clearly describes the definition in the business process of the indicators and the measurement marks (the moment on which values are reported). He then demonstrates how in the Business Process Workspace these indicators can be used to create dashboards from. Next, the integration between BPM and BAM is introduced and demonstrated. Again, this is done in great and clear detail.
The last part of the chapter is devoted to monitoring and administration via the Enterprise Manager Fusion Middleware Control Console – focused more on technical than on business details. The Audit Level is revisited as is the instance tracing facilities. Fine grained logging is mentioned, but neither illustrated nor explained. A brief discussion on deployment. But no reference to what happens to running instances upon deployment of either an overwriting revision or a new revision. An extension of discussion in chapter 8 on exception handling – showing a ‘retry’ for a previously failed instance. Configuration of notification settings for a human task.
In the section on deployment, Vivek mentions: “You can even attach a configuration plan to include with the archive. The configuration plan enables you to define the URL and property values to use in different environments.” And that is all on this subject. Not even a ‘read this resource for more details’ . It is very valuable, this use of a configuration plan, and I am curious to know which aspects of a BPM process can perhaps be customized in this way. For example the values of constants in Business Rules or the business SLA set in Timer Events.
The configuration required to integrate BPM with BAM – leveraged in the first part of this chapter – is now described in detail. Then the definition of organization units and the vacation rules for users; the link between the units and rules that were defined in BPM Studio, 9 chapters ago, and the units and rules that can be maintained through the BPM Workspace is not made clear ( I believe there is no link, frustratingly enough).
The final explanation about Flex Fields that can be defined for Human Tasks, mapping values from the task payload to these fields that can be included in the BPM Worklist application to list for tasks and even search on is valuable and again, quite clear.
Appendix A is titled Oracle BPM — Application Development Lifecycle. It seems largely a repeat of information from Chapter 1. I am not convinced it adds anything meaningful.
Conclusion
It is an attractive book, providing a fine balance between information, action (hands-on) and background. At times it could perhaps do little bit more on best practice On the whole: When you want to get a pragmatic introduction to Oracle BPM Suite that gets you started with doing things and also helps you understand many of those things, this book is an excellent investment and I would certainly recommend it.
Even for readers who may not do BPM Suite but only SOA Suite, this book is very useful because of its introduction and detailed discussion of Business Rule, Human Task and ADF based User Interfaces for Human Tasks and several examples of fault handling, adapter usage and run time monitoring and configuration.
