Patent Grant
10037197
A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
The current invention relates to a system and method for providing programming constructs for executing any arbitrary Business Process Model and Notation (BPMN) task, gateway and/or event.
Within large business enterprises, management of business processes is becoming a more significant issue as companies vie to improve efficiency, reduce costs, increase profits and gain more flexible and dynamic infrastructures. Business processes are a part of the day-to-day operations and services of any corporation. For example, a business process may include applying for a home loan (e.g. loan origination process), starting a mobile phone service (account initiation process), hiring a new employee (employee on-boarding process), building a new jet engine (parts and assembly process), as well as countless other processes performed by enterprises and organizations in order to accomplish specific goals.
Processes can range from very simple to highly complex and sophisticated, involving numerous decisions, tasks and activities. In this context, a business process can be thought of as a series of steps (tasks) that are executed in a particular order or path in order to achieve an objective in an organization. A business process can be visualized as a flowchart of a sequence of activities. Business processes often change over time and are useful for analyzing and optimizing the business model of a particular organization.
Business Process Model and Notation (BPMN) has been developed as a graphical representation of business processes in a business process model (formerly known as Business Process Modeling Notation). BPMN is a public standard maintained by Object Management Group, Inc. (Needham, Mass.) for business process modeling which provides a uniform graphical notation for specifying business process in a business process diagram. The primary goal of BPMN is to provide a standard notation readily understandable by all business users. BPMN supports business process management, for both technical users and business users, by providing a notation that is intuitive to business users, yet able to represent complex process semantics. The shapes, the symbols (also referred to as markers), the borders, the placement of the BPMN diagram elements, as well as their properties have well defined meanings and have to be interpreted in the same manner by all tools.
The BPMN specification maps the graphics of the notation to the underlying constructs of execution languages, for example, Business Process Execution Language (BPEL). Business Process Execution Language (BPEL) is a text-based (XML) executable language for representing business processes. It is particularly useful to define business processes that use Web Services to interact with other entities. BPEL can be used as a standard executable orchestration language to specify interactions with Web Services. The BPEL processes are represented in extensible markup language (XML) and these processes orchestrate synchronous and asynchronous services into end-to-end flows.
Even with the popularity of BPMN and other similar systems, there exists a multitude of shortcomings and other needs in this area of technology. For example, non-executable Business Process Modeling languages, such as BPMN, lack the precise semantics that are necessary to automatically validate, simulate, and execute business processes.
It is desirable to provide a runtime capable of executing Business Process Modeling languages, such as BPMN in order to automatically validate, simulate, and execute business processes. Various software systems have been developed to enable business processes to be defined in a computer language that can be directly executed by a computer. These systems use automated applications in conjunction with human based tasks to deploy and execute business processes, as well as maintain, analyze and modify them over time. Using such automated software systems to directly execute processes can be more straightforward and easier to improve. The present invention provides a framework which allows a business process designed in a business process modeling language (e.g. BPMN) to be compiled into executable procedures thereby enabling automatic validation, simulation, and execution of the business processes.
A runtime capable of executing a business process requires a set of operations, derived directly from the process execution semantics. However, each BPMN task, gateway, or event defines a set of operations specific to their own semantics. Typically, a standalone program is written for each task, gateway, or event thus duplicating code required for overlapping features and/or requirements, for example receiving and sending arguments. This approach has penalties at development time due to the duplication of code. This approach also has runtime performance penalties because the compiler defines the process flow and the task or event configuration at runtime. Furthermore, adding new features and process extensions requires significant development time to write code to express the set of operations specific to the semantics of the new features and process extensions. Additionally, the implementation is limited to a specific business process modeling language.
Embodiments of the present invention define a minimal set of atomic and simple operations, called Microinstructions, which, when combined in compound programs, called Microprograms, execute any BPMN task, event or gateway. The Microinstructions framework allows a business process designed in a business process modeling language (e.g. BPMN) to be compiled into executable procedures thereby enabling automatic validation, simulation, and execution of the business processes while also facilitating code reuse and maintainability.
Selection of the set of atomic and simple operations selected for implementation as Microinstructions takes into account several factors, including but not limited to: the semantic executions, performance, re-usability, and the underlying state machine implementation. In accordance with embodiments of the invention, a set of Microinstructions define a set of primitives or instructions to execute a business process modeling language in accordance with the semantics defined by the language. The Microinstructions define atomic operations that can be executed as part of a running process. The Microinstructions thereby provide flexibility for executing business process modeling languages in any business process execution language.
Process execution semantics of the business process modeling language are formally described in terms of Microprograms. A Microprogram is a Microinstruction procedure defined using one or more Microinstructions. The Microprograms define Microinstruction procedures which map to the business processes of the business process modeling language. The business process in the business process modeling language can be compiled into Microinstruction procedures using a compiler—the Microinstruction procedures are executable on a suitable execution platform.
The Microinstructions approach provides several advantages over the previous model. The approach permits reuse of artifacts that have common semantics. The approach enhances performance because the compiler (at compile time) can statically analyze the process flow and the task or event configuration, and generate the procedures with a minimal set of Microinstructions to achieve the execution. The approach facilitates process extensions by significantly reducing the development time required to add new features and extensions into a process diagram.
In accordance with a specific embodiment, the present invention provides an implementation of the Microinstructions as part of a runtime execution of the Business Process Model and Notation 2.0 specification, and a compiler that compiles or transforms a process when it is activated to execute, into a program that runs the process using the compiled Microinstructions procedures. The compiler specifies the required procedures for each task, event or gateway, and a mechanism to build the procedure using Microinstructions. The interaction between the different compiled programs that are implemented by executing Microinstructions, defines the execution model for a specific process diagram.
Other objects and advantages of the present invention will become apparent to those skilled in the art from the following detailed description of the various embodiments, when read in light of the accompanying drawings.
In the following description, the invention will be illustrated by way of example and not by way of limitation in the figures of the accompanying drawings. References to various embodiments in this disclosure are not necessarily to the same embodiment, and such references mean at least one. While specific implementations are discussed, it is understood that this is provided for illustrative purposes only. A person skilled in the relevant art will recognize that other components and configurations may be used without departing from the scope and spirit of the invention.
Furthermore, in certain instances, numerous specific details will be set forth to provide a thorough description of the invention. However, it will be apparent to those skilled in the art that the invention may be practiced without these specific details. In other instances, well-known features have not been described in as much detail so as not to obscure the invention.
Common reference numerals are used to indicate like elements throughout the Figures and detailed description; therefore, reference numerals used in a Figure may or may not be referenced in the detailed description specific to such figure if the element is described elsewhere. The first digit in a three digit reference numeral indicates the series of Figures in which the element first appears.
Although the Figures depict components as logically separate, such depiction is merely for illustrative purposes. It will be apparent to those skilled in the art that the components portrayed in this figure can be combined or divided into separate software, firmware and/or hardware. Furthermore, it will also be apparent to those skilled in the art that such components, regardless of how they are combined or divided, can execute on the same computing device or can be distributed among different computing devices connected by one or more networks or other suitable communication means.
Embodiments of the present invention provide a Microinstruction framework which defines a minimal set of atomic and simple operations, called Microinstructions, which, when combined into compound programs, called Microprograms, execute any BPMN task, event or gateway. The set of atomic and simple operations selected for implementation as Microinstructions takes into account several factors, including but not limited to: the semantic executions, performance, re-usability and the underlying state machine implementation. The Microinstructions define atomic operations that can be executed as part of a running process. The Microinstructions thereby provide flexibility for executing business process modeling languages in any business process execution language.
In accordance with an embodiment of the invention, the process execution semantics of the business process modeling language are formally described in terms of Microprograms. A Microprogram is a Microinstruction procedure defined by one or more Microinstructions. The Microinstructions are thereby combined into Microprograms which map to business processes of the business process modeling language, for example BPMN.
In accordance with an embodiments of the invention a compiler is provided which compiles business processes in the business process modeling language into Microinstruction procedures (Microprograms) defined by one or more Microinstructions. The business process written in e.g. BPMN is compiled into executable Microinstruction procedures. The executable Microinstruction procedures allow for validation, testing and execution of the business process on a suitable execution platform.
In accordance with a specific embodiment, the present invention provides an implementation of the Microinstructions as part of the runtime execution of BPMN 2.0, and a compiler that compiles or transforms a process when it is activated to execute, into a program that runs the process using the compiled Microinstructions procedures. The compiler specifies the required procedures for each BPMN task, event or gateway, and a mechanism to build the procedure using Microinstructions. The interaction between the different compiled programs that are implemented by executing Microinstructions, defines the execution model for a specific process diagram.
The Microinstruction framework is essentially transparent to the user who interacts with the modeling system (e.g.) BPMN and executable result. Even though the Microinstructions are not visible to the end user, the Microinstructions approach provides several advantages over the previous model. The Microinstructions approach permits reuse of operations between artifacts that have common semantics. A clear example in BPMN is Data Associations, where several tasks and events define a way of receiving and sending arguments. The Microinstructions approach enhances performance because the compiler can statically analyze the process flow and the task or event configuration, and generate the procedures with a minimal set of Microinstructions to achieve the execution. Previously process flow and task or event configuration was defined at runtime, which implies a performance penalty. The Microinstructions approach also facilitates process extensions by significantly reducing the development time required to add new features and extensions into a process diagram. Debugger, performance improvements, process execution language extensions and management can be released quicker than other products. The Microinstructions approach also provides the capability to execute other graphical or textual business modeling languages in addition to BPMN, BPEL and other business process modeling languages.
Business Process Model and Notation (BPMN) has been developed as a graphical representation of business processes in a business process model. BPMN provides a uniform graphical notation as part of GUI 152 for specifying business process in a business process diagram. The primary goal of BPMN is to provide a standard notation readily understandable by all business users. BPMN System 150 supports business process management for business users with business user tools 154 by providing a notation that is intuitive to business users, yet able to represent complex process semantics. BPMN System 150 also allows technical users to interact with the model via Developer Tools 156.
At its heart, BPMN has only three main elements, also referred to as Flow Objects—Activity (rectangle), Events (circle), and Gateways (diamond). The output of BPMN System 150 is BPMN Process Data 160 in BPMN language. The BPMN Process Data 160 comprises a plurality of Tasks 162, Events 164, and Gateways 166 descriptive of the process developed using Business Users Tools 154, Developer Tools 156 and GUI 152. An Activity represents some work done; Gateway represents a decision point or parallel forking or merge or join; Event represents either a trigger generated by the process or received by the process (from external source or from some other part of the process). The Activity can be either a Task (an atomic process step) or Embedded Sub-process (compound process step). These Flow Objects are linked by connections referred to as Sequential Flows. These Sequential Flows represent the chronological sequence of process steps. The preceding steps pass control to the following step(s) along the connection. The data is also passed along the connection flow.
The BPMN 2.0 Specification is essentially model driven rather than operational. The notation is focused modeling business processes for business users and thus, is very high level in nature. Because the notation is high level, the semantic gap between the declarative language of BPMN Process Data 160 and an infrastructure layer (Process Execution Engines 180) that can implement the business process is bigger than for other programming languages. Additionally, in BPMN 2.0 the activity semantics are highly influenced by activity configuration and context. To achieve specificness on runtime, BPMN semantics code has to be built dynamically on process compile phase. This means essentially leaving BPMN interpretation in runtime.
In embodiments of the present invention specificness capture is shifted to compile-time, by capturing activity specificness in execution logic. Using execution logic to achieve specificness and runtime performance facilitates maintainability in a long running system. This is one rationale behind the development of the Microinstruction Framework 100 which allows capturing executable semantics that can be injected in compile time and then be executed in runtime. The set of Microinstructions 110 constitute an intermediate language that decouples BPMN semantics from low level semantics to favor code reusability. Frontend decoupling allows supporting different end user languages or extensions in terms of the intermediate code (Microprograms 132), and backend decoupling allows portability to different SOA-based runtime stacks (process Execution Engines 180) by porting Microinstructions 100.
Microinstruction Framework 100 thus spans the semantic gap between the declarative language of BPMN Process Data 160 and an infrastructure layer (Process Execution Engines 180) that can implement the business process. Microinstruction Framework 100 includes a set of Microinstructions 110, and a BPMN Microinstruction Compiler 120. BPMN Microinstruction Compiler 120 is operative to compile BPMN Process Data 160 (including Tasks 162, Events 164, Gateways 166 and associated syntax) into Microprocedure Data 130 which consists of one or more Microprograms 132 written in terms of Microinstructions 110.
The Microinstructions Framework 100 mainly introduces the concept of a set of Microinstructions 110 and a BPMN Microinstructions Compiler 120 that compiles BPMN Process Data 160 into procedures (Microprograms 132) of Microinstructions 110—Microprocedure 130. The set of Microinstructions 110 defines a minimal set of atomic and simple operations, which, when combined into Microprograms 132 are capable of executing any BPMN task, event or gateway. The atomic and simple operations selected for implementation in the set of Microinstructions 110 takes into account several factors, including but not limited to: the semantic executions, performance, re-usability and the underlying state machine implementation.
The set of Microinstructions 110 define a set of primitives or instructions to execute BPMN Process Data 160 in accordance with the semantics defined by the language. The set of Microinstructions 110 define atomic operations that can be executed by Process Execution Engines 180 as part of a running process. The process execution semantics of the BPMN Process Data 160 are then formally described in terms of Microprograms 132.
Microprograms 132 are Microinstruction procedures identifying a procedure including one or more of the set of Microinstructions 110. The Microprograms 132 in combination with the Microinstructions 110 to which they refer comprise instruction sets which can be directly interpreted by Process Execution Engines 180.
Process Execution Engines 180 execute Microinstructions 110 in accordance with Microprograms 132. The interaction between the different Microprograms 132 that are implemented by execution by the Process Execution Engine 180 of the Microinstructions 110, defines the execution model for a specific process diagram as specified in BPMN Process Data 160. The runtime phase is just a sequence of Microinstructions 110 specified by the Microprograms 132, no BPMN processing occurs at runtime, all conditional code has been resolved during compiling phase such that the only conditional code is runtime state conditionals.
Runtime graph based execution model, can be defined as:
The following is a pseudocode that demonstrate how root Microinstruction 110 procedures (in uppercase) are hooked to a Microprogrammable Node Performer and are triggered by the low level SOA infrastructure (Process Execution Engine 180).
Microinstructions
As described above, the set of Microinstructions 110 defines a minimal set of atomic and simple operations, which, when combined into Microprograms 132 are capable of executing any BPMN task, event or gateway. The following is a subset of the Microinstruction list that compose the intermediate language to implement these root microprocedures on compile phase.
Control Flow:
Work Item (activity execution state) Management:
Data Handling:
Logic:
Messaging Handling:
Token Flow Control:
Exception Handling:
As described above, Microprograms 132 are Microinstruction procedures identifying a procedure including one or more of the set of Microinstructions 110. The Microprograms 132 in combination with the Microinstructions 110 to which they refer comprise instruction sets which can be directly interpreted by Process Execution Engines 180.
The present invention may be conveniently implemented using one or more conventional general purpose or specialized digital computer, computing device, machine, or microprocessor, and/or network of same, programmed according to the teachings of the present disclosure.
Business process diagram 200 illustrates a SynchProcess. Essentially it receives an input message by catching a message event and then synchronously replies back to caller by throwing a message event. A slight variation will be later introduced that shows compile output changes when response is asynchronous instead.
BPMN Microinstructions compiler input is the process data in terms of BPMN language. In this case, start catch message event. Although the business user interacts with the graphical notation, the output of BPMN system 150 (see
Start Microprogram 222
End Microprogram 224
Comparing the microprocedure code for the Start Microprogram 222 and End Microprogram 224 it can be observed that they essentially share the same Microinstructions code. Essentially the only difference is that the DO_EXECUTE_STATEMENT microprocedure, that is basically the activity differential semantic (start process inbound message, end replies back), and the processing of sequence flows in the GENERATE_NEXT_TOKENS (start process start the flow and end finishes it). Thus, the use of the Microinstructions framework facilitates widespread reuse of the code. Reusability of code in this manner facilitates management of code complexity and code maintenance.
Runtime
The following output shows the execution log in runtime phase for a given instance. Data is presented as:
[<bpmn thread of execution, microprocedure being executed>] <Microinstruction being executed> <Microinstruction actual parameters>.
It should be noted that the runtime phase is just a sequence of Microinstructions. No BPMN processing is conducted at runtime. All conditional code has been resolved on compile phase. The only conditional code would be runtime state conditionals. Thus, there is no additional execution overhead as a result of the use of the Microinstructions framework.
The above illustrates a novel conceptual framework model, based on the idea of “Microprogramming” for the design of a BPMN runtime stack. As shown above, the Microinstructions framework has proved being useful on achieving results on reusability of code maximization, and consistent performance, by ensuring specificness on execution. The use of the Microinstructions framework facilitates widespread reuse of the code. Reusability of code in this manner facilitates management of code complexity and code maintenance without additional execution overhead.
At step 302 a set of Microinstructions is provided. The Microinstructions define atomic operations that can be executed as part of a running process. At step 304, a compiler is provided. The compiler is adapted to compile the business process model represented in the business process modeling language (for example BPMN) into one or more procedures of Microinstructions. A business process model may be represented by one or more procedures of Microinstructions which may be referred to as Microprograms. At step 306, the compiler is used to compile the business process model as represented in the business process modeling language (for example BPMN language) into one or more Microinstruction procedures. At step 308, the business process is executed by executing the Microinstruction procedures. It should be noted that the runtime phase is just a sequence of Microinstructions without BPMN processing. All conditional code has been resolved during compilation, the only conditional code would be runtime state conditionals.
Appropriate software coding can readily be prepared by skilled programmers based on the teachings of the present disclosure, as will be apparent to those skilled in the software art. The invention may also be implemented by the preparation of application specific integrated circuits or by interconnecting an appropriate network of conventional component circuits, as will be readily apparent to those skilled in the art.
The various embodiments include a computer program product which is a storage medium (media) having instructions stored thereon/in which can be used to program a general purpose or specialized computing processor(s)/device(s) to perform any of the features presented herein. The storage medium can include, but is not limited to, one or more of the following: any type of physical media including floppy disks, optical discs, DVDs, CD-ROMs, microdrives, magneto-optical disks, holographic storage, ROMs, RAMs, PRAMS, EPROMs, EEPROMs, DRAMs, VRAMs, flash memory devices, magnetic or optical cards, nanosystems (including molecular memory ICs); paper or paper-based media; and any type of media or device suitable for storing instructions and/or information. The computer program product can be transmitted in whole or in parts and over one or more public and/or private networks wherein the transmission includes instructions which can be used by one or more processors to perform any of the features presented herein. The transmission may include a plurality of separate transmissions. In accordance with certain embodiments, however, the computer storage medium containing the instructions is non-transitory (i.e. not in the process of being transmitted) but rather is persisted on a physical device.
The foregoing description of the preferred embodiments of the present invention has been provided for purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise forms disclosed. Many modifications and variations can be apparent to the practitioner skilled in the art. Embodiments were chosen and described in order to best explain the principles of the invention and its practical application, thereby enabling others skilled in the relevant art to understand the invention. It is intended that the scope of the invention be defined by the following claims and their equivalents.
| Number | Name | Date | Kind |
|---|---|---|---|
| 5721913 | Ackroff et al. | Feb 1998 | A |
| 5799297 | Goodridge et al. | Aug 1998 | A |
| 5978836 | Ouchi | Nov 1999 | A |
| 6003011 | Sarin et al. | Dec 1999 | A |
| 6026365 | Hayashi | Feb 2000 | A |
| 6035123 | Razdan | Mar 2000 | A |
| 6161113 | Mora et al. | Dec 2000 | A |
| 6170002 | Ouchi | Jan 2001 | B1 |
| 6308224 | Leymann et al. | Oct 2001 | B1 |
| 6327702 | Sauntry | Dec 2001 | B1 |
| 6397182 | Cruickshank et al. | May 2002 | B1 |
| 6397191 | Notani et al. | May 2002 | B1 |
| 6470227 | Rangachari et al. | Dec 2002 | B1 |
| 6496831 | Baulier et al. | Dec 2002 | B1 |
| 6507845 | Cohen et al. | Jan 2003 | B1 |
| 6516507 | Noel et al. | Feb 2003 | B2 |
| 6519642 | Olsen et al. | Feb 2003 | B1 |
| 6567783 | Notani et al. | May 2003 | B1 |
| 6574675 | Swenson | Jun 2003 | B1 |
| 6574736 | Andrews | Jun 2003 | B1 |
| 6584487 | Saboff | Jun 2003 | B1 |
| 6606740 | Lynn et al. | Aug 2003 | B1 |
| 6742015 | Bowman-Amuah | May 2004 | B1 |
| 6889231 | Souder et al. | May 2005 | B1 |
| 6895573 | Nørgaard et al. | May 2005 | B2 |
| 6970844 | Bierenbaum | Nov 2005 | B1 |
| 7020697 | Goodman et al. | Mar 2006 | B1 |
| 7062746 | Roesner et al. | Jun 2006 | B2 |
| 7124192 | High et al. | Oct 2006 | B2 |
| 7174514 | Subramaniam et al. | Feb 2007 | B2 |
| 7236939 | Chen et al. | Jun 2007 | B2 |
| 7272816 | Schulz et al. | Sep 2007 | B2 |
| 7289966 | Ouchi | Oct 2007 | B2 |
| 7370335 | White et al. | May 2008 | B1 |
| 7403989 | Beringer et al. | Jul 2008 | B2 |
| 7406432 | Motoyama | Jul 2008 | B1 |
| 7418475 | Stewart et al. | Aug 2008 | B2 |
| 7428495 | Dhar et al. | Sep 2008 | B2 |
| 7448046 | Navani et al. | Nov 2008 | B2 |
| 7451477 | Griffin et al. | Nov 2008 | B2 |
| 7464366 | Shukla et al. | Dec 2008 | B2 |
| 7493593 | Koehler | Feb 2009 | B2 |
| 7498866 | Choi | Mar 2009 | B2 |
| 7519711 | Mohindra et al. | Apr 2009 | B2 |
| 7543292 | Haller et al. | Jun 2009 | B2 |
| 7603674 | Cyr et al. | Oct 2009 | B2 |
| 7631291 | Shukla et al. | Dec 2009 | B2 |
| 7644432 | Patrick et al. | Jan 2010 | B2 |
| 7676483 | Klug | Mar 2010 | B2 |
| 7680683 | Hilerio et al. | Mar 2010 | B2 |
| 7685604 | Baartman et al. | Mar 2010 | B2 |
| 7689562 | Schaad et al. | Mar 2010 | B2 |
| 7702736 | Ouchi | Apr 2010 | B2 |
| 7730162 | Lynch et al. | Jun 2010 | B2 |
| 7814142 | Mamou et al. | Oct 2010 | B2 |
| 7885847 | Wodtke et al. | Feb 2011 | B2 |
| 7925527 | Flam | Apr 2011 | B1 |
| 7953696 | Davis et al. | May 2011 | B2 |
| 8046747 | Cyr et al. | Oct 2011 | B2 |
| 8065315 | Rapp et al. | Nov 2011 | B2 |
| 8069439 | Shukla et al. | Nov 2011 | B2 |
| 8140369 | Paul et al. | Mar 2012 | B2 |
| 8140573 | McKay et al. | Mar 2012 | B2 |
| 8145944 | Fong et al. | Mar 2012 | B2 |
| 8156083 | Banerjee et al. | Apr 2012 | B2 |
| 8165993 | Broda et al. | Apr 2012 | B2 |
| 8170897 | Cohen et al. | May 2012 | B1 |
| 8175936 | Ronen et al. | May 2012 | B2 |
| 8280822 | McKeown et al. | Oct 2012 | B2 |
| 8381180 | Rostoker | Feb 2013 | B2 |
| 8424011 | Barros et al. | Apr 2013 | B2 |
| 8443351 | Haselden et al. | May 2013 | B2 |
| 8464206 | Jenkins et al. | Jun 2013 | B2 |
| 8560372 | Balko et al. | Oct 2013 | B2 |
| 8762974 | Smith et al. | Jun 2014 | B1 |
| 20020178119 | Griffin et al. | Nov 2002 | A1 |
| 20030135384 | Nguyen | Jul 2003 | A1 |
| 20030158832 | Sijacic et al. | Aug 2003 | A1 |
| 20040093593 | Jhanwar et al. | May 2004 | A1 |
| 20040230466 | Davis et al. | Nov 2004 | A1 |
| 20050049924 | DeBettencourt et al. | Mar 2005 | A1 |
| 20050071347 | Chau et al. | Mar 2005 | A1 |
| 20060069995 | Thompson et al. | Mar 2006 | A1 |
| 20060074703 | Bhandarkar et al. | Apr 2006 | A1 |
| 20060074915 | Bhandarkar et al. | Apr 2006 | A1 |
| 20060218394 | Yang | Sep 2006 | A1 |
| 20060229925 | Chalasani et al. | Oct 2006 | A1 |
| 20070016465 | Schaad | Jan 2007 | A1 |
| 20070055960 | Damron et al. | Mar 2007 | A1 |
| 20070156486 | Sanabria et al. | Jul 2007 | A1 |
| 20070203589 | Flinn et al. | Aug 2007 | A1 |
| 20070276715 | Beringer et al. | Nov 2007 | A1 |
| 20070288885 | Brunel et al. | Dec 2007 | A1 |
| 20080065656 | Theeten et al. | Mar 2008 | A1 |
| 20080091712 | Daherkar et al. | Apr 2008 | A1 |
| 20080114627 | Baeuerie et al. | May 2008 | A1 |
| 20080120129 | Seubert et al. | May 2008 | A1 |
| 20080189679 | Rodriguez et al. | Aug 2008 | A1 |
| 20090125366 | Chakraborty et al. | May 2009 | A1 |
| 20090125766 | Safarpour et al. | May 2009 | A1 |
| 20090164985 | Balko et al. | Jun 2009 | A1 |
| 20090199293 | Song et al. | Aug 2009 | A1 |
| 20090260021 | Haenel et al. | Oct 2009 | A1 |
| 20090281865 | Stoitsev | Nov 2009 | A1 |
| 20090307162 | Bui et al. | Dec 2009 | A1 |
| 20090327105 | Moussa et al. | Dec 2009 | A1 |
| 20100106546 | Sproule | Apr 2010 | A1 |
| 20100153150 | Prigge et al. | Jun 2010 | A1 |
| 20100153432 | Pfeifer et al. | Jun 2010 | A1 |
| 20100205013 | Guyan et al. | Aug 2010 | A1 |
| 20100235213 | Channabasavaiah | Sep 2010 | A1 |
| 20100251242 | Sivasubramanian | Sep 2010 | A1 |
| 20110004862 | Kerjriwal et al. | Jan 2011 | A1 |
| 20110078606 | Hoff et al. | Mar 2011 | A1 |
| 20110154253 | Lehr et al. | Jun 2011 | A1 |
| 20120192143 | Elaasar | Jul 2012 | A1 |
| 20130139164 | Balko | May 2013 | A1 |
| Entry |
|---|
| Oracle Fusion Middleware Modeling and Implementation Guide for Oracle Business Process Management 11g Release 1 (11.1.1.5.0) Copyright 2011. |
| Buelow, Heidi et al., “Process Modeling using BPMN 2.0 Chapter 7”, Getting Started with Oracle BPM Suite 11gR1, Sep. 13, 2010, Packt Publishing Ltd., Olton, Birmingham, UK. |
| Oracle Business Process Management Suite, Oracle Fusion Middleware 11g, <http://www.oracle.com/us/technologies/bpm/suite/overview/index.html>, retrieved Nov. 18, 2013, 2 pages. |
| Number | Date | Country | |
|---|---|---|---|
| 20140282366 A1 | Sep 2014 | US |
