Design and Implementation of a Runtime Environment of an Object-Aware Process Management System

Contemporary business process management systems manage their processes based on the activity-centric paradigm. However, many business processes are un- or semistructured and cannot be represented adequately by the activity-centric paradigm. The fundamental reason for this insufficiency is the lack of cohesion between processes on one hand and data on the other. Object-aware process management provides a solution for this issue by tightly integrating processes with data. Data is represented as structured object types with complex data dependencies. This is mirrored in the concepts of object behavior and object interactions. Object behavior is captured in micro processes, whereas object interactions are represented by macro processes. Both micro and macro processes are integral parts of the runtime of an object-aware process management system. Furthermore, the execution of micro and macro processes is governed by process rules. The process rules advance the process state depending on the available data, react to user interactions or perform error handling. PHILharmonicFlows is a framework that aims at the proper support of object-aware processes. A prototype implementing the framework is currently under development. This thesis contributes to the prototype by describing concepts concerning process rules and by providing implementations as well. In detail, the contributions are as follows. The ongoing development of the prototype requires process rules to be easily created and altered, i.e. to enable a high maintainability. Therefore, a high level of abstraction for the process rule definitions is necessary. The Process Rule Framework enables the creation and alteration of process rules and satisfies the high maintainability requirement by leveraging functional programming devices. Using the Process Rule Framework, a high productivity can be achieved when handling process rules. Moreover, the Process Rule Framework has the possibility to be extended to a general-purpose rule engine in which rules may be created, compiled and executed during runtime. At runtime, process rules provide one of the cornerstones to object-aware process execution. This requires complex interactions between process rules, as they can trigger each other and therefore chain together. The challenge is to enable these interactions while keeping the individual process rules independent from each other and only loosely coupled. The Process Rule Manager enables the complex interactions between process rules by providing the means to coordinate and control process rule interactions. Additionally, the Process Rule Manager abstracts from the inner workings of process execution and provides a well-defined interface to interact with a micro process

Executing Lifecycle Processes in Object-Aware Process Management

Data-centric approaches to business process management, in general, no longer require specific activities to be executed in a certain order, but instead data values must be present in business objects for a successful process completion. While this holds the promise of more flexible processes, the addition of the data perspective results in increased complexity. Therefore, data-centric approaches must be able to cope with the increased complexity, while still fulfilling the promise of high process flexibility. Object-aware process management specifies business processes in terms of objects as well as their lifecycle processes. Lifecycle processes determine how an object acquires all necessary data values. As data values are not always available in the order the lifecycle process of an object requires, the lifecycle process must be able to flexibly handle these deviations. Object-aware process management provides operational semantics with built-in flexible data acquisition, instead of tasking the process modeler with pre-specifying all execution variants. At the technical level, the flexible data acquisition is accomplished with process rules, which efficiently realize the operational semantics

A Modeling Tool for PHILharmonicFlows Objects and Lifecycle Processes

Abstract. As opposed to contemporary activity-centric, process-aware information systems (PAIS), for which a multitude of concepts and implementations exist, there is only a very limited number of PAIS implementing data-centric, artifact-centric or object-aware approaches. This demo paper presents the implementation of a modeling environment for the object-aware approach to business process management. Our implementation is based on the PHILharmonicFlows framework, which allows for the definition and execution of business object models. The current implementation of the modeling environment supports the modeling of objects, their attributes as well as relations to other objects. Furthermore, it allows modeling object lifecycle processes, which define the runtime behavior of the various objects. Finally, the modeling environment features a simple app design, reducing complexity for process modelers while still supporting all features of PHILharmonicFlows

A Runtime Environment for Object-Aware Processes

In contrast to contemporary activity-centric process-aware information systems (PAIS), for which a multitude of concepts and implementations exist, there is only a very limited number of PAIS implementations using data-centric, artifact-centric or object-aware approaches. This demo paper presents the implementation of a client-server runtime environment for the object-aware approach to process management. Our implementation is based on the PHILharmonicFlows conceptual framework, where individual processes define the behavior of an object and its interactions with other objects. The current implementation of thebruntime environment allows for the instantiation and execution of micro processes, which define object behavior. Interaction with a data-driven micro process instance is enabled through automatically generated userforms as part of a graphical user interface. Additionally, the user interface can display the progression of a micro process instance using an interactive graph

A Tool for Supporting Ad-Hoc Changes to Object-Aware Processes

Process management systems are often criticized for not being flexible enough, as they restrict the actions of users to those defined in a process model. When unforeseen events occur during process execution, deviation from the actions the process model permits may become necessary. Such ad-hoc changes to process execution are not widely supported by process management systems as they pose significant challenges. This work presents a new prototypical addition to the PHILharmonicFlows process engine that allows for ad-hoc changes to processes following the object-aware process support paradigm. We demonstrate the extensions to the preexisting PHILharmonicFlows modeling and runtime user interfaces that enable users to change the underlying process models of process instances they are executing. The demonstration is intended to not only show off the ad-hoc change capabilities in the context of object-ware process management, but also inspire other researchers to employ similar ideas in other process support paradigms

Enabling Fine-grained Access Control in Flexible Distributed Object-aware Process Management Systems

To increase flexibility, object-aware process management systems enable data-driven process execution and dynamic generation of form-based tasks at run-time. Therefore, a powerful access control concept becomes necessary to define which data elements users may read or write at a given point in time during process execution. The access control concept we present in this paper has been realized in the context of the PHILharmonicFlows framework, which provides a distributed data-driven process execution engine. We present solutions that allow for complex as well as fine-grained permissions and roles, which are granted depending on the states of processes and data elements. We show how one can resolve authorization queries in real-time over multiple business objects and process instances. This constitutes a significant advantage over centralized access control systems

Towards Hyperscale Process Management

Scalability of software systems has been a research topic for many years and is as relevant as ever with the dramatic increases in digitization of business operations and data. This relevance also applies to process management systems, most of which are currently incapable of scaling horizontally, i.e., over multiple servers. This paper discusses an approach towards hyperscale workflows, using a data-centric process engine to encapsulate data and process logic into objects, which can then be stored and concurrently manipulated independently from each other. As this allows for more concurrent operations, even within a single data-intensive process instance, we want to prove that an implementation of a hyperscale process engine is a feasible endeavor

Enabling runtime flexibility in data-centric and data-driven process execution engines

Contemporary process management systems support users during the execution of predefined business processes. However, when unforeseen situations occur, which are not part of the process model serving as the template for process execution, contemporary technology is often unable to offer adequate user support. One solution to this problem is to allow for ad-hoc changes to process models, i.e., changes that may be applied on the fly to a running process instance. As opposed to the widespread activity-centric process modeling paradigm, for which the support of instance-specific ad-hoc changes is well researched, albeit not properly supported by most commercial process engines, there is no corresponding support for ad-hoc changes in other process support paradigms, such as artifact-centric or object-aware process management. This article presents concepts for supporting ad-hoc changes in data-centric and data-driven processes, and gives insights into the challenges to be tackled when implementing this kind of process flexibility in the PHILharmonicFlows process execution engine. We evaluated the concepts by implementing a proof-of-concept prototype and applying it to various scenarios. The development of advanced flexibility features is highly relevant for data-centric processes, as the research field is generally perceived as having low maturity compared to activity-centric processes

Flexible Data Acquisition in Object-aware Process Management

Abstract. Data-centric approaches to business process management, in general, no longer require specific activities to be executed in a certain order, but instead data values must be present in business objects for a successful completion. While this holds the promise of more flexible processes, the addition of the data perspective results in increased complexity. Therefore, data-centric approaches must be able to cope with the increased complexity, while still fulfilling the promise of more flexible processes. Object-aware process management specifies business processes in terms of objects as well as their lifecycle processes. Lifecycle processes determine how an object acquires all necessary data values. As data values are not always available in the order the lifecycle process of an object requires, the lifecycle process must be able to flexibly handle these deviations. Object-aware process management provides operational semantics with flexible data acquisition built into it, instead of tasking the process modeler with pre-specifying a flexible process. At the technical level, the flexible data acquisition is accomplished with process rules

Coordinating Large Distributed Relational Process Structures

Representing a business process as a collaboration of interacting processes has become feasible with the emergence of data-centric business process management paradigms. Usually, these interacting processes have relations and, thereby, form a complex relational process structure. The interactions of processes within this relational process structure need to be coordinated to arrive at a meaningful overall business goal. However, relational process structures may become arbitrarily large. With the use of cloud technology, they may additionally be distributed over multiple nodes, allowing for scalability. Coordination processes have been proposed to coordinate relational process structures, where processes may have one-to-many and many-to-many relations at run-time. This paper shows how multiple coordination processes can be used in a decentralized fashion to more efficiently coordinate large, distributed process structures. The main challenge of using multiple coordination processes is to effectively realize the coordination responsibility of each coordination process. Key components of the solution are the subsidiary principle and the hierarchy of the relational process structure. Finally, an implementation of the coordination process concept based on microservices was developed, which allows for fast and concurrent enactment of multiple, decentralized coordination processes in large, distributed process structures