Collaborative Process Maturing Support by Mining Activity Streams Christian Ochsenkühn
René Peinl
Hof University Alfons-Goppel-Platz 1 95028 Hof, Germany +49 9281 409 6216
Hof University Alfons-Goppel-Platz 1 95028 Hof, Germany +49 9281 409 4820
[email protected]
[email protected]
ABSTRACT Usually, knowledge workers are said to not benefit from business process management (BPM) systems, since their main tasks are weakly structured and not representable by a workflow. However, not all of their tasks are equally weak structured, and with adaptive case management (ACM) solutions, a new category of tools came up to support those processes, even if they are weakly structured. This paper introduces an approach to support the creation of cases for ACM engines by mining activities from an activity stream and suggesting tasks that a knowledge worker can use to create a case. Furthermore, the approach supports maturing of the case towards a workflow by detecting repeating sequences in the execution of tasks and suggesting sub processes for the case which is possible with the case management model and notation (CMMN) together with the business process model and notation (BPMN). To allow for further enhancement of the cases, the ACM solution is extended with social collaboration features, so that people working on the case can comment and rate single tasks. The goal is to show that it is possible to establish ties from social activities and Web 2.0 to ACM and BPM. The presented solution uses a graph database as a basis for activity mining.
CCS Concepts • Content Analysis and Indexing➝Abstracting methods • Office Automation➝Workflow Management • Group and Organization Interfaces➝Collaborative computing, Computer-supported cooperative work • Pattern Recognition➝Clustering➝Similarity measures
Keywords Adaptive Case Management, Activity Stream, Business Process Management, Collaboration, Process Maturing.
1. INTRODUCTION Business processes and workflows are well established in science and businesses. The classical business process management (BPM) covers structured and routine processes of companies and supports them [1]. Typically it is supported by BPM systems, which work in three phases [2]: 1) Define: a business analyst creates a process Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. i-KNOW ’15, October 21–23, 2015, Graz, Austria. Copyright is held by the owner/author(s). Publication rights licensed to ACM. ACM 978-1-4503-3721-2/15/10…$15.00 DOI: http://dx.doi.org/10.1145/2809563.2809583
model with a modelling tool. 2) Execute: this model is transferred by IT staff into a workflow model, usually running in a process engine. This engine is used to delegate the tasks of the workflow model to the users or systems. 3) Analyze: process performance can be monitored and measured by business analysts. However, there are more and more knowledge workers, who often have to achieve tasks that are hard to structure or model [3]. Because traditional modelling approaches are often too strict and inflexible for these tasks [4], there is a need for new solutions in this area. Additionally, processes usually are not in a steady state [5]. They change with their respective circumstances, and the “holy grail” of BPM is the control of user behavior through process models [6], which requires up-to-date models. On the other hand, they also have to mature based on end-user behavior during run-time. Thus, process models have to change due to new requirements [7], which cannot be done top-down alone. The approach presented here targets those weakly structured processes of knowledge workers by using adaptive case management (ACM) and supports both creation of case models, as well as their maturing towards process models with the help of mining activities in an activity stream and letting users collaborate (social BPM) in an integrated open source environment. To achieve this goal we first review literature within the areas of ACM, social BPM (S-BPM), process mining and process maturing. We move on comparing some well-known implementations of ACM and S-BPM in research and practice. Based on these findings we present our new approach starting with the system environment to the point of our algorithm in pseudo code. We finish with evaluating the algorithm against quality requirements derived from the literature and a discussion of challenges and limitations.
2. BACKGROUND 2.1 Adaptive Case Management The mentioned gap between routine tasks in well-structured processes and weakly structured knowledge-intensive processes can be addressed with adaptive case management (ACM) [1]. An ACM system does not force the user to follow a strict workflow, but suggests some actions or tasks she might perform in the current situation, to solve her ongoing problem. Milestones can be introduced as a means to provide some structure and act like a gate in a stagegate process. A group of relevant elements, required to come to a decision for a problem’s solution during a case, is called a pattern [8]. A user can adopt these suggested tasks, but also adapt them [1]. The user is able to e.g. combine single tasks to a sub-workflow during run-time, as well as skip or repeatedly perform single tasks. This means, there is not a strict separation of design-time and runtime in the ACM paradigm [9] [10]. New requirements or other tasks which were not considered at planning can be added to an
existing case, in order to improve enterprise processes. Thus, ACM is not meant to replace BPM but to complement it. Case Management Model and Notation (CMMN) is a standard for ACM published by OMG in May 2014 similar to BPMN for processes and even interoperable with it. Based on a requirements analysis for an ACM notation, the authors of [10] conclude that CMMN version 1.0 supports most of these requirements (at least partially or implicitly), but still has some minor issues. It lacks for example a standardized visualization for ad-hoc changes to a case as well as a means to represent a running case in an ACM system. However, much more grave is the fact that usual ACM systems let knowledge workers freely decide which ad-hoc actions to take, but mostly do not use those decisions to improve the case model for future execution [8]. This missing learning mechanism is where our approach comes into play.
2.2 BPM research streams Subject-oriented BPM is considering the fact that business is increasingly characterized by interactions among stakeholders rather than the functional decomposition of work by focusing sending and receiving of messages as an indication of functional task accomplishment [11]. Subjects represent the information processing entities that communicate with each other, embedded in an organizational and technical environment. They coordinate their work by exchanging information contained in business objects. In that way, subject-oriented BPM uses the potential of social media for business process modelling of collaborative processes and helps to overcome traditional BPM drawbacks like “model-reality divide” and “lost innovations” [12]. Other approaches to help knowledge workers structuring their tasks with the help of social media features are discussed under the headline social BPM, which tries to enhance the classical BPM with social features, to break through the central top-down definition of processes [13]. It “is the practice of actively involving all relevant stakeholders into a BPM endeavor through the use of social software and its underlying principles” [14]. In a social environment the (non-technical) end-users of a process are not only users of this process but should also be able to improve them, because this community of practice knows how the processes they really need look like [14]. Leveraging this crowd knowledge, often results in better solutions than a single expert could achieve. Social BPM can have a number of additional benefits like exploitation of weak ties and implicit knowledge, increased transparency of information sharing and decision distribution as well as improved knowledge sharing [15], but also has some drawbacks like steep learning effort, security, possibly lower quality process models and difficulties in evaluation (ibid.). Our approach builds on social BPM by allowing users to collaborate on improving cases using comments that can be attached to any case model element.
2.3 Process Mining Process mining concentrates on “discovering, monitoring, and improving real processes by extracting knowledge from event logs” [5] [16]. Since behavior of users in processes change over time, you have to mine the processes and use the results for up-to-date process support. Business might change so fast, that a well-defined process model is already outdated when it is instanced for the first time [17]. Without mining, users may create their own workarounds, which are never captured and thus can never improve or mature the processes. Three major types of process mining were identified in literature [16]. In the discovery type you take event logs and produce process models out of them. They are represented in formal languages like BPMN, Casual Nets, or Petri Nets. In the
conformance checking type you compare existing process models with event logs to detect differences between the model and the real behavior of users. The enhancement type goes one step further and improves or extends existing models by using additional data available in the logs (e.g., in order to circumvent bottlenecks).
2.4 Process Maturing Knowledge and process maturing literature states, that process modelling should be agile, flexible, and personalized for users to react fast and adapt processes during run-time [4] [18]. Usually processes are modelled top-down by experts, who try to incorporate all relevant knowledge in the models, which often differs from real circumstances in the process execution [19]. A pure bottom-up approach is also not the solution. In fact, enterprises should combine top-down and bottom-up process modelling, to support maturing of ideas, knowledge and processes [18]. The idea of process maturing as described in literature is derived from the knowledge maturing model [20]. This model describes how (process) knowledge evolves from an idea by discussing it in communities and formalizing it later on towards approved knowledge tested in prototypes or pilot project until it finally may become a company or even industry standard. Applied to weakly structured processes, this means that the disability to describe a process in a structured way does not necessarily entail that it is a process-inherent characteristic, but may also be a consequence of immature knowledge about the process and missing experience. With ongoing practice of process instances, a stable backbone of necessary tasks together with additional optional tasks or process variants may emerge from initial task lists or detected task patterns [18]. Thus, organizations could use sharing and recording of the users’ activities and tasks to support creation and maturing of processes [18]. To understand task descriptions correctly, it is necessary that the semantics are comprehensible. Furthermore, tasks often require documents or contents as input or produce them as output so that there is a close connection between process, content and semantic maturing [18]. Process maturing therefore can be considered a special case of workplace learning [21]. Systems supporting it should aim for context awareness and help users both knowing about relevant knowledge resources as well as taking all possibly relevant aspects into account (ibid.) Instead having to find out how to deal with a process instance on their own, it makes more sense to learn from others how to do it. Additional effort for knowledge sharing has to be kept low so that knowledge workers can concentrate on their work [22]. Scherp et al. identify a discrepancy between processoriented organizational and individual knowledge work, where the latter is characterized by high variability, self-organization and communication-orientation [23]. They identify IT support for weakly structured and structured workflows as well as their integration as major requirements for linking organizational and individual knowledge work, which is exactly the goal of our approach. They compare 16 models for knowledge work and conclude that none of them fulfils the requirements. They therefore present their own approach called strukt, which is ontology-based and its domain-specific implementation in a Web-based system. Although they claim to have fulfilled all requirements, they “assume that the strukt prototype is integrated in an existing business process engine providing its own interface” [23]. DYONIPOS is another ontologybased approach [22]. It identifies tasks based on aggregating low level events like mouse clicks and suggests relevant resources based on tagging. It also supports analysis of task patterns but dropped the initial goal of recommending workflows based on the detected user activity.
Process maturing is closely connected with process knowledge and is especially relevant for knowledge-intensive processes [17], [19]. The latter can contain routine tasks, but also consist of knowledgeintensive tasks. The relevant knowledge needed to decide if and how to complete these tasks is often shared informally via email or in the enterprise’s wiki. However, users that have to execute a task are often not aware of it. So, the gap between learning by doing and the possibilities for proper sharing and adding of individual knowledge about the processes should be bridged. This can be achieved by directly linking information from the task descriptions in a process or case.
3. RELATED WORK 3.1 Research Prototypes According to [7] you can view a process from six different perspectives, e.g. the behavioral perspective. This perspective describes the order in which its steps should be executed. This is also interesting for ACM, as the order of task execution is relevant for suggestions of a potential workflow a user might create. The next important parts are the persons and roles, responsible for the task-execution, which is arranged in the organizational perspective. This is more or less neglected in both BPMN and CMMN. Furthermore, each process contains data (e.g. a document), which is either consumed or produced. This is defined in the data perspective and a focus of CMMN. The systems we use to support the tasks are defined in the operational perspective. And, the number of times that a process can (or must) be run through, which is described in the functional perspective, is also important for our approach. For example, if a process (or case) instance is only used once, it understandably cannot mature. In ACM, users are usually supported with knowledge captured in previous tasks. The authors of [8] try to gather this knowledge through a user-trained agent built on pattern recognition technology, which acquires ad-hoc actions of knowledge workers and gives support through “best next action” recommendations in volatile situations. Thus, without explicit training the agent observes ad-hoc actions, created during run-time, together with their state and recommends such an action in a similar situation, which means in a similar state of the case. A state of a case can be recognized through contextual elements like goals, artifacts, tasks, processes and data objects in ACM. Another important part of supporting ACM is finding the right collaborators to perform a given case. In [24], the authors try to recommend eligible colleagues through a user’s social graph and their provided skills. For this purpose a user first adds a goal and corresponding requirements to a case. Then an algorithm runs through her social graph in order to detect users who are not connected to her but to her connections. The existing skills of these users are compared to the required skills for the goal. Based on their similarities, a list of convenient colleagues is generated, from which she can choose suitable people to ask for taking the task. An approach similar to ours is presented in [25]. Böhringer calls the concept emergent case management und built a prototype that is mining manually, semi-automatically and automatically created entries in an activity stream inside a microblogging system. He is detecting cases based on hashtags used in the activity entry and illustrates the prototype with an example from a project in the textile industry. Although text mining is mentioned, the paper presents no details about the implementation of the mining algorithm. In [26] they also try to make user recommendations and predictions in ACM, based on process mining. Their prototype stores every action a knowledge worker performs, similar to an activity stream,
but related to a case. Such a log is recorded in the manner “Person A completed task T1 in Case5”. Based on these logs, the prototype shows next step recommendations for all cases on the one side and predictions for the presumably remaining time on the other side. Furthermore recommendations contain notes if the recommended action supports case goals, shortens case duration or avoids deadline transgression. There is also an approach that attempts to combine ACM and Subject-oriented BPM, which is called Subject-oriented ACM [1]. It is based on the assumption that not all process participants are working towards the same goal, which is especially possible in processes spanning multiple enterprises. It builds upon a multi-agent framework to model enterprises and extends it with the possibility to model temporal-logical dependencies of tasks within a knowledgeintensive cross-enterprise process. This prevents users that are able to alter a case during runtime from creating deadlock situations by deleting essential tasks required for starting dependent tasks. To do this, they extended the UML meta-model with subtasks, external events and other elements. An approach presented in [15] builds on social BPM in order to recommend roles and tasks for ad-hoc processes based on user-defined as well as system-defined tags. It also considers process maturing towards a standardized process in a stable state. The role recommender shows community members with a list of tasks they have completed before and the number of times they were recommended for a task with a specific skill requirement. One drawback of this approach is that all tasks are required to be tagged and tags have to be structured in a hierarchy by the community. It also stresses the community as an important factor, where community members decide whether a task was completed instead of the person who performed the task or the process owner who delegated it. An approach from [27] for ad-hoc geo-referenced BPM tries to integrate geo information systems with BPM and suggests using microblogging for coordination. Thus, they want to model processes by selecting a set of places and associating tasks to them. Furthermore they found six requirements for their approach: 1) Coordination is primarily made by geo-dependencies (secondarily by task dependencies). 2) Users determine the order of activities and places provide the specific context how to order them. 3) Each place should have an appendant sub-process or ad-hoc workflow. 4) An unframed sub-process can be combined with a place, where informal messages would be substituted between the diverse participants in that sub-process. 5) Specific types of framed sub-processes can mature according to tasks and workflows specified during run-time. 6) An ad-hoc geo-referenced BPM can be implemented on a microblogging platform, assumed the messages are also geo-referenced. A formal evaluation of the approach in a fire-fighting scenario found that using a lower number of workflow pattern as a basis was easier to understand for users not familiar with BPM. The authors of [3] try to discover task recommendations by mining process constraints (model) and formerly performed actions (log). They use the JBoss Drools Planner to generate feasible next tasks within boundaries of process constraints, based on an event log. Those generated tasks are scored on the basis of soft constraints, such as best practices. Furthermore they record process steps and incorporate data from participants during their process observation, to automatically give suggestions for future process executions. Another approach dealing with agile business processes and process maturing is the Knowledge-Intensive Service Support (KISS) and its implementation KISSmir [17]. It consists of a task pattern repository and a task recommendation engine. This engine recommends next tasks based on historical cases, the task patterns derived
from them as well as runtime information about the current process instance (ibid.). Whereas routine tasks are always executed, knowledge-intensive tasks are optionally executed depending on the context. Suggestions are chosen via business rules [19]. Not only tasks, but also potentially useful resources associated with a task are suggested. The system was evaluated with a use case from the student admission process of a university.
3.2 Commercial Solutions Existing ACM and BPM solutions act as a reference point for our own solution presented here. We used the three leaders in Gartner’s Magic Quadrant for Intelligent Business Process Management Suites: Appian, IBM and Pegasystems [28]. All three offer both business process as well as case management solutions, which confirmed us in our strategy to connect both concepts. Appian provides (besides traditional BPM software) a solution for case management with the following features. Knowledge workers can access or share converged information from multiple systems. They can work on a case collaboratively or initiate a task from a single interface. To handle ad-hoc processes Appian provides rules (with its own rules engine), process capabilities and an event management. Appian’s BPM software provides some real-time features for task management. It allows the users to reassign tasks, view real-time task progress or to collaborate with others. To support case workers in finding the right colleague to achieve a task, there is a skills-based routing for tasks. The solution Pega 7 Case Management claims to not only automate processes, but also guide work that needs flexibility or judgement by a user, by automating the lifecycle of both structured and unstructured processes. “Pega's primary strength is its unified architecture based on a powerful BRMS (Business Rule Management System) and predictive analytics decision management engine” [28]. The platform combines process flow definitions with rule processing and data handling. It further supports case management, application integration, and other functions in one model-based architecture that supports structured and unstructured process styles. IBM’s family of process and case management tools is hard to understand due to the complexity necessary for combining several tools and their overlapping functionality. Blueworks Live and IBM Business Process Manager's design, development, governance and administrative features are broad and deep [28]. Process Designer supports integrated analysis, simulation and testing, and Process Center provides extensive version control with collaboration support. Process "Coach" UIs guide end users through unfamiliar or complex tasks. Smarter Process solutions may optionally leverage capabilities from the IBM business analytics portfolio. Microsoft offers a solution called Office Delve, in combination with their Enterprise Social Network Yammer, their document management systems Office 365 and their storage OneDrive for Business. Microsoft tries to show a user her most relevant documents she might be working with next, by analyzing activities round the user and the documents [29]. For example, if several colleagues, a user regularly works with, act with a specific document, it might be interesting for the user and will be shown on his Delve page. Signavio offers a process editor capable of handling both BPMN and EPC (event-driven process chain) diagrams. It doesn’t integrate collaborative editing and commenting directly inside the editor, but allows to publish selected process models in a so called collaboration portal [30]. Within this portal, users can view process models and comment them. These comments can then be reviewed by the modelling expert and incorporated into the next version of the process model.
4. OWN APPROACH 4.1 Environment Our approach is embedded in the Social Collaboration Hub (SCHub, https://www.sc-hub.de), a BMBF funded project (the German ministry for education and research), which aims at providing a unified collaboration solution based on well-known open source software. The project integrates a collaborative system landscape following a modular micro-service approach [31]. It consists of a collaboration portal with blog-, wiki- and forum-functionality (Liferay) and uses an enterprise content management (ECM) platform (Nuxeo), which is specialized in document, digital asset and case management. Email and calendar functionality are provided by Open-Xchange. This groupware also supplies task management, in combination with a BPM system (Camunda). Camunda does not only offer workflow and processes management but also implements ACM with support for CMMN. Thus, we are using this functionality of Camunda for our approach. The BPM system is integrated with the portal, the ECM system and the groupware. BPMN.io is used as a graphical Web-based editor for processes. Although the Camunda engine is already capable of processing CMMN cases, the respective editor is not yet ready and has to be extended to handle CMMN as part of the SCHub project. The OpenSocial reference implementation Apache Shindig is combined with Liferay to show an activity stream und the other systems to collect the activities and provide micro-blogging. An activity from the ECM system could look like “User A created “document B” of type project proposal”. We therefore followed the suggestion in [25] to build adapters for existing information systems. All activities are stored in a graph database. Furthermore, the SCHub project uses Elasticsearch for full-text search across all systems and the Central Authentication Service (CAS) for single sign-on.
4.2 Concept Our approach aims at supporting process maturing through mining activities from an activity stream and suggesting a case model in terms of ACM. We use activities due to the fact, that they keep records of the interactions between users and information objects (blogs, documents, messages …). Organizational information exchange always travels along with processes [32]. Doing so allows detecting tasks associated with processes that are not yet modeled. We therefore support both creation of new case models and maturing existing case models towards process models, by suggesting sequences for some tasks of a case, which can be expressed in BPMN sub-processes inside a CMMN case. The approach combines social media technology with case and process management technology in order to foster both bottom-up and top-down modelling of cases and (sub-)processes. However, the main challenge for mining activities is, that users are involved in several projects, activities and tasks at the same time and the software needs some context hints in order to distinguish actions associated with the process of interest from those that are unrelated. To get a proper context for activity mining, we use the document lifecycle as well as document contents. The “document created” event and the “document published in version 1.0” event are used as a temporal frame for activity mining. The document type, title, headlines and keywords extracted from paragraphs are used as a semantic context. This is all context information available for the initialization phase (see description below), which has the goal of suggesting tasks for a new case model. Within the collaborative maturing phase (see below), the existing case model is used as additional context, especially task titles and descriptions from a content perspective, as well as milestones from a temporal perspective.
Once an existing case has completed several instances, these instances and their activities are reviewed to integrate changes back into the case [10]. This is done in the collaborative maturing phase. Furthermore both phases contain two sub-phases respectively: an analysis phase and a suggestion phase. The former collects relevant activities and can only occur once the document creation process was run through several times. The suggestion phase creates task and sequence suggestions out of the collected activities. All phases are described in more detail in the next sections.
4.2.1 Phase of Initialization In order to get context for mining, we concentrate on cases which are connected to a document. For internal validation of concepts we use two examples: creating a project proposal and creating an offer for a complex customer project, e.g. a software development project or a construction project. Both require knowledge-intensive processes for their creation and usually involve multiple people.
4) Finally, the case has to be suggested in an appropriate manner, so that users are able to create, adapt or remove tasks. They should also be able to add milestones and save the case in CMMN standard. The following pseudo code formally describes the algorithm used. Listing 1: formal description of the mining algorithm List dcrList = repository.getDCRlist(“doctype”); List tcList = new List(); foreach(DocCreationRecord dcr in dcrList) { Document doc = helper.downloadDoc(dcr.docID); DocumentTextStatistics dts = miner.compute(doc); List aList = repository.getActivities(“SELECT * FROM activities a WHERE a.date BETWEEN(%1, %2) AND a.creator IN %3 “, dcr.startDate, dcr.endDate, dcr.users, );
Analysis phase: The document and its state act as a bracket for the pattern detection algorithm. Thus, event collection for the mining process begins with the document created event in the ECMS and finishes with the version 1.0 published event for the document. The algorithm analyzes every activity of every user that can be traced in the system to deal with the document in this period. This is similar to the so called process observation in [3]. Thus, we identify users connected to a document and record the document type and ID, user list, as well as start and end time. The data is stored in Apache Shindig, which was extended to accommodate this need.
Collection mails = Search.find(“sender IN %1 AND sent BETWEEN(%2, %3) and (body contains %4 OR body contains %5)”, dcr.users, dcr.startDate, dcr.endDate, dcr.docType, dts.keywords); aList.add(Activities.createFrom(mails, “send”, “note”)) foreach(Activity a in aList) { if (a.object.URL){ // associated artefacts
Suggestion phase: After several iterations of the document creation process with the same type of document and several users, the suggestion phase is started. All recorded activities are retrieved and analyzed. This includes retrieval of linked artefacts like wiki pages, blog posts, forum discussions, related documents, tasks from the groupware (recorded in the activity stream as task completed events) and meetings in the calendar (recorded as meeting invitation event). We don’t include secondary artefacts like documents attached to a meeting event in the calendar. Based on text analysis of both activities and artefacts as well as comparison with (chapters of) the final document as well as similar activities and artefacts from other iterations, a similarity measure is calculated for the activity to be a proper basis for a task candidate. All candidates with a similarity higher than a certain threshold are exported to a CMMN case, stored in the ACM/BPM solution and associated with the document type in the ECMS. The next time a user creates a new document of the respective type, a hint is given to the user, that a new case is available. Since the tasks are not ordered within the case and there are only few milestones if at all, the user has to manually improve the case to make it completely useful. She can manually add, edit and remove tasks and create a new case with these tasks. In order to prevent single users from being overwhelmed with the demand of modeling a case, we suggest the user to invite colleagues from the recorded document creation iterations for improving the case model together. By doing this, the chance to share knowledge in an emerging community of practice [33] and get the best possible result for the case model is increased. Thus, we need the following features: 1) Identify which of the mined activities are relevant for the case and which are not. Only the relevant ones are processed. 2) Based on these activities, tasks for the case have to be generated. For example each activity could create one task. 3) Determine temporal relations between tasks based on the recorded date for activities
Artefact af = helper.retrieve(a.object.URL); ContentStatistics cs = miner.compute(af); if(miner.checkSimilarity(dts, cs) > threshold) tcList.add(new TaskCandidate(dcr.docID, a, af)); }
// microblogging messages
else if (a.object.objectType == “note” && a.target.objectType == “person”){ ContentStatistics cs = miner.compute(a.object.content); if(miner.checkSimilarity(dts, cs) > threshold) { tcList.add(new TaskCandidate(dcr.docID, a); } } } groupTasksByTypeAndRole(tcList); removeNonRepeatingTasks(tcList); consolidateTasks(tcList); //remove duplicates uploadCMMN(createCMMN(tcList)).associateWith(“doctype”); The presented algorithm is a simplification of the real algorithm and does not include every case regarding activity types (e.g., meeting invitations or personal tasks from the groupware). As shown in the algorithm, there is an exception to using activities as the basis for mining. Since we did not want to pollute the activity stream with “email sent” and “email received” entries, we are using the search functionality to retrieve possibly relevant emails and generate temporary activities from them. Afterwards, the algorithm treats those activities equally to all others, so that we can benefit from those activities in the same way as from interactions that are directly recorded as activities in the system.
4.2.2 Phase of Collaborative Maturing Other users that are involved in the case or subsequent instances of it can comment on single tasks as well as other case elements and the whole case. They can also add, edit and remove tasks from the case. In that way, we support manual collaborative maturing of the case. Additionally, there is also semi-automatic maturing support. Analysis phase: For the second analysis phase, the case provides additional context for mining activities and the focus is on identifying task sequences, as well as missing or emerging tasks. Recording of activities stays the same as before. Suggestion phase: After some iterations, the algorithm is able to identify task patterns within the case, where tasks are frequently executed in the same sequence. Again, the user who is currently running such a case instance gets a suggestion for including a structured sub-process as part of the case. New requirements include: 5) An algorithm to identify which activities or tasks are (often) achieved in the same order. 6) Based on these activities, tasks for the case have to be generated and also sequences or pre-built sub-processes/workflows. 7) Finally the tasks and sub-processes have to be suggested in an appropriate manner. The user can accept the proposals and also add or remove other tasks. As visible in listing 2, the algorithm for detection of task sequences first generates a global list containing a superset of all task candidates from the different case iterations. It then iterates through this list and checks for every single task candidate, whether it occurs in all case instances before another task candidate. If so, a link is established indicating the predecessor successor relation. These relations are then used in a last step to generate sub-processes in the CMMN model to represent the temporal relations, if there are at least three subsequent tasks and a dependency otherwise. Listing 2: formal description of the task sequence detection Hashtable tcDict = getTaskCandidates(); List tcGlobal = getRepeatedTasks(tcDict); foreach(TaskCandidate tc1 in tcGlobal) { foreach(TaskCandidate tc2 in tcGlobal) { boolean tc1BeforeTC2 = true; if(tc1 != tc2) { foreach(String docID in tcDict.keys()) { ArrayList tcList = tcDict.get(docID); if(tcList.contains(tc1) && tcList.contains(tc2)) && getTask(tcList, tc1).date > getTask(tcList, tc2).date) tc1BeforeTC2 = false;
break;
} if(tc1BeforeTC2) { tc1.addSuccessor(tc2); tc2.addPredecessor(tc1); }} }} mapTaskSequencesToCMMN(tcGlobal);
4.3 Challenges A first challenge is the abstraction of activities found in the activity stream to task descriptions for ACM or BPM. The presented approach uses text mining and especially text analysis techniques to
identify similarities from the artefacts linked in the activity stream to chapters of the document. If the similarity is higher than an empirically determined threshold, a task candidate will be generated suggesting to “prepare chapter in a together with ”. Furthermore, a second depending task candidate is generated which suggests to “integrate contents from into chapter ”. A second challenge is the abstraction of communication partners found in the activity stream (short messages or meetings) or email (search-based) to formal roles like department assistant, superior or subject matter expert in topic X. In order to extract a task description from a communication act, you have to abstract from the concrete person and find out the relation between the two communication partners. Two paths can deliver this abstract description. The first possible relation is regarding the organization hierarchy. A few different cases can be distinguished: a) sender and receiver are within the same organizational unit (OU) on the same level. The deduced recommendation is “talk to a colleague”. b) the sender is a subordinate of receiver on first or second level or vice versa. The deduced recommendation is “talk to a superior / subordinate”. c) the receiver is always in the same OU irrespective of the OU of the sender. The deduced recommendation is “talk to an employee of department X” (e.g., finance department). d) the receiver always has the same job position irrespective of the job position of the sender. The deduced recommendation is “talk to a ” (e.g. project manager). The second possible relation is regarding the skills. Again a few different cases can be distinguished: i) the receiver has always the same combination of skills irrespective of the sender (up to three skills in combination are considered). The deduced recommendation is “talk to a subject matter expert with skills ”. ii) the receiver has a certain skill that the sender doesn’t have and both together always have the same combination of skills. The deduced recommendation is “talk to a subject matter expert with complementary skills ”. iii) the receiver has the same skills that the sender has as well. The deduced recommendation is “talk to a colleague with similar skills as you”. In all cases, a link to a search query is provided that leads to an always recent result list of people with the required skills or position in the organization hierarchy. Both skill and organizational data is stored in the Shindig graph database. The latter stems from the LDAP directory and is synchronized on a regular basis.
4.4 Case Example In this section, the described algorithms are illustrated with an example that should show the benefits more clearly. Anna is working for a company that is building customer specific collaboration solutions based on a commercial portal platform. She has to compile an offer for a customer, which is a knowledge-intensive process, requiring many task involving different experts. She creates the offer document based on a company template, fills in first information like the customer’s name and a description of the requirements and stores it on the server. Our system detects the creation of a document of type offer and finds out that it has collected enough data about previous offer creation processes, to suggest a case. After running the algorithm shown in listing 1, it notifies Anna about the case model. She opens the model in the system and learns about
potential tasks like “create work breakdown structure” and “ask head of development department for available capacities”, as well as milestones like “requirements analysis document completed”. She therefore learns which tasks might be relevant to her and also gets system support for task follow up and an overview about the linked resources like a forum discussion about “reusability of and existing portlet for the new customer” or a project plan for the offered project. The system also suggests colleagues to involve in the effort estimation based on a skill set derived from former document creation processes. Anna also decides to meet with two colleagues who created offers before her in order to collaboratively enhance the case model and learn from their experiences. The names are provided by the system. After Anna and a few further colleagues have finished offer creation processes, the system suggests new task sequences to Bernd, who is the next consultant to compile an offer, after the system has learned enough about task patterns to offer a recommendation. Bernd accepts the new version of the case model which now states that review of the offer by a senior consultant and adjustment of offer amount by the head of sales are parallel activities that always conclude the case.
5. EVALUATION Since the prototype implementing the algorithm is not yet finished, this section presents an evaluation against quality requirements from literature [9]. Flexibility at run-time: Users should be able to adapt a case during run-time [9]. This is fulfilled in our solution, as they can remove suggestions or integrate several suggestions to a sub-process. Evolving cases and templates: cases should be continuously improved for future instantiation [9]. This is fulfilled, since both manual collaborative maturing as well as semi-automatic maturing are supported in our solution. Transparent responsibilities: Responsibilities for various parts in the case must be visible to all case workers [9]. This is not related to the suggestion mechanism, but to the user interface of the ACM solution and therefore not evaluated here. Visible progress in the case: Case workers must be able to identify which parts of the case are work in progress and what the overall state of the case is [9]. BPMN.io allows highlighting of completed tasks and has to be extended to indicate skipped tasks. Flexible assignment of roles: New case workers should be able to join the case [9]. Their roles should be flexible. Our solution supports this by describing suggested roles in terms of organizational hierarchy and/or skill sets. Despite help by search for respective people, the final assignment of a user to a task is a manual process. Definition of case objectives: Users should understand why they should achieve a task [9]. Our solution is only able to express goals in terms of the final document or chapters of it. Other kinds of goals have to be added manually by the user. Hierarchical task structure: Users should get aid in maintaining an overview of the case [9]. Camunda supports sub-cases and sub-processes and therefore fulfills this requirement. Integration of data in the case: Processes and data have to be tightly integrated in ACM due to the documentcentric nature of knowledge work [9]. Since our task suggestions for a case are based on activities interrelated with the documents (data), this requirement is fulfilled. Definition of logical dependencies between tasks: Temporal-logical dependencies are required in the solution since not all tasks might be executable at any time in a process [9]. Our task suggestions include temporal dependencies in the case or in sub-processes linked with the case. This requirement is therefore fulfilled. Understandable and adaptable for business user: Not only technical experienced but also normal business users should be able to add milestones or create case-related workflows as easy as possible [9]. In our case, we target knowledge workers, which are by definition flexible, knowledgeable people who should come to terms with CMMN, even without having seen it before.
The editor will provide a help function explaining the symbols and typical usage. Furthermore, the initial structuring of the suggested tasks should be done by a group consisting of the user who started the new case and those who created documents of the respective type before as described in section 4.2.2. The system will directly suggest inviting them to a meeting for the new case owner. In this way, knowledge transfer is fostered not only via the case description, but also face to face.
6. LIMITATIONS Despite the positive evaluation against the quality requirements for case management presented above, there are some significant limitations that need to be mentioned. First of all, the prototype is not yet completed. Therefore, no empirical evaluation results can be presented yet. The algorithm needs at least a few iterations of document creation cases, so that it doesn’t help with document types that are created only a few times. Thus, we are not targeting ad-hoc processes that occur only a single time, as some papers mentioned in the related work section do. Only document-centric workflows are supported by the approach, since document creation and document published events are used as triggers and the document serves as context information. Furthermore, up to date skill entries in the skill management solution are required for the algorithm to identify subject matter experts. An unsolved issue is the question whether tasks that were suggested by the algorithm, but deleted by a user should be re-suggested later on, if the algorithm detects them in the activity stream, or they should be treated as failures of the algorithm and therefore suppressed. Since edited cases are stored as new versions, previously suggested tasks can be traced by comparing the current version of the case with older ones. Some important parameters, like the number of iterations before the suggestion phase can start or the threshold for content similarity have to be determined empirically and might not be robust for different document types or companies. Finally, the sequence detection algorithm is not able to distinguish between AND or OR connections if multiple tasks are predecessors of another task.
7. CONCLUSION AND OUTLOOK As seen above, our approach combines collaborative but manual maturing steps with semi-automatic steps based on mining activities in an activity stream. It supports both creating a new case as well as improving an existing case towards a more structured process. It therefore follows Fischer’s seeding – growth – reseeding model described in [18] and serves as a means to further workplace learning and contextual awareness as demanded in [21]. Abstraction from concrete activities to abstract task descriptions as well as abstraction from concrete users to formal role descriptions based on organizational relation or skills were identified as major challenges. An algorithm was presented to deal with both. The effort for users to deal with task suggestions of the system has to be kept in balance with the benefits of learning about tasks performed by others [22]. Our solution helps knowledge workers transferring knowledge about weakly structured process steps. As with any data analysis solution, data protection laws have to be considered. We believe that our solution which processes person-related data, but only makes anonymous data visible to users of the system in form of formal role descriptions is conforming to strict data protection laws in Germany, but a juridical evaluation was not performed up to now. For the future, we plan to complete the implementation and evaluate it with real end users, as well as strengthen the integration of the Camunda case management part, BPMN.io and the Nuxeo case management capabilities.
REFERENCES [1] [2]
[3]
[4] [5]
[6]
[7] [8]
[9]
[10]
[11] [12] [13]
[14]
[15]
[16]
M. Kurz and M. Lederer, “Subject-Oriented Adaptive Case Management,” in S-BPM ONE - Scientific Research, Springer, 2014, pp. 123–132. B. Wetzstein, Z. Ma, A. Filipowska, M. Kaczmarek, S. Bhiri, S. Losada, J.-M. Lopez-Cob, and L. Cicurel, “Semantic Business Process Management: A Lifecycle Based Requirements Analysis,” in SBPM, 2007. S. Schönig, M. Zeising, and S. Jablonski, “Comprehensive Business Process Management through Observation and Navigation.,” in 6th IFIP Conf. on the Practice of Enterprise Modeling (PoEM 2013), Riga, Latvia, 2013, vol. 1023. A. Martin and R. Brun, “Agile Process Execution with Kissmir,” in SBPM, 2010, vol. 682, pp. 36–41. R. J. C. Bose, W. M. van der Aalst, I. Zliobaite, and M. Pechenizkiy, “Dealing with concept drifts in process mining,” Neural Networks and Learning Systems, IEEE Transactions on, vol. 25, no. 1, pp. 154–171, 2014. H. F. Sem, T. B. Pettersen, S. Carlsen, and G. J. Coll, “Patterns Boosting Adaptivity in ACM,” in On the Move to Meaningful Internet Systems: OTM 2013 Workshops, vol. 8186, Y. T. Demey and H. Panetto, Eds. Berlin, Heidelberg: Springer Berlin Heidelberg, 2013, pp. 102–111. M. Igler, P. Moura, M. Zeising, and S. Jablonski, “ESProNa: Constraint-Based Declarative Business Process Modeling,” 2010, pp. 91–98. T. T. T. Kim, C. Ruhsam, M. J. Pucher, M. Kobler, and J. Mendling, “Towards a Pattern Recognition Approach for Transferring Knowledge in ACM,” IEEE 18th Intl. Enterprise Distributed Object Computing Conf. Workshops and Demonstrations, Ulm, 2014, pp. 134–138. M. Hauder, D. Munch, F. Michel, A. Utz, and F. Matthes, “Examining Adaptive Case Management to Support Processes for Enterprise Architecture Management,” 18th Intl. Enterprise Distributed Object Computing Conf. Workshops and Demonstrations (EDOCW), Ulm, 2014, pp. 23–32. M. Kurz, W. Schmidt, A. Fleischmann, and M. Lederer, “Leveraging CMMN for ACM: examining the applicability of a new OMG standard for adaptive case management,” in 7th Intl. Conf. on Subject-Oriented Business Process Management, Kiel, Germany, 2015. A. Fleischmann, W. Schmidt, and C. Stary, “Subject-oriented BPM,” in Handbook on Business Process Management 2, Springer, 2015, pp. 601–621. S. Bögel, S. Stieglitz, and C. Meske, “A role model-based approach for modelling collaborative processes,” Business Process Management Journal, 20 (4), pp. 598–614, 2014. M. Brambilla, P. Fraternali, and C. Vaca, “BPMN and Design Patterns for Engineering Social BPM Solutions,” in Business Process Management Workshops, vol. 99, F. Daniel, K. Barkaoui, and S. Dustdar, Eds. Berlin, Heidelberg: Springer Berlin Heidelberg, 2012, pp. 219–230. N. Pflanzl and G. Vossen, “Challenges of Social Business Process Management,” presented at the 47th Hawaii International Conference on System Sciences (HICSS) 2014, Waikoloa, HI, 2014, pp. 3868–3877. M. E. Rangiha, M. Comuzzi, and B. Karakostas, “Role and Task Recommendation and Social Tagging to Enable Social Business Process Management,” in Enterprise, BusinessProcess and Information Systems Modeling, Springer, 2015. V. Rubin, I. Lomazova, and W. M. van der Aalst, “Agile development with software process mining,” Intl.Conf. on Software and System Process, 2014, pp. 70–74.
[17] [18]
[19]
[20]
[21]
[22]
[23]
[24] [25]
[26]
[27] [28] [29] [30] [31] [32]
[33]
S. Brander, K. Hinkelmann, A. Martin, and B. Thönssen, “Mining of Agile Business Processes,” in AAAI Spring Symposium: AI for Business Agility, 2011. A. Schmidt, K. Hinkelmann, T. Ley, S. Lindstaedt, R. Maier, and U. Riss, “Conceptual Foundations for a Serviceoriented Knowledge and Learning Architecture: Supporting Content, Process and Ontology Maturing,” in Networked Knowledge - Networked Media, vol. 221, Springer Berlin Heidelberg, 2009, pp. 79–94. H. F. Witschel, B. Hu, U. V. Riss, B. Thönssen, R. Brun, A. Martin, and K. Hinkelmann, “A Collaborative Approach to Maturing Process-Related Knowledge,” in Business Process Management, vol. 6336, Springer Berlin Heidelberg, 2010. R. Maier and A. Schmidt, “Characterizing knowledge maturing: A conceptual process model for integrating e-learning and knowledge management,” 4th Conf. Professional Knowledge Management (WM ’07), Potsdam. 2007. A. Schmidt and S. Braun, “Context-aware workplace learning support: Concept, experiences, and remaining challenges,” in Innovative approaches for learning and knowledge sharing, Springer, 2006, pp. 518–524. M. Granitzer, G. Granitzer, K. Tochtermann, S. Lindstaedt, A. Rath, & W. Groiß, “Automating knowledge transfer and creation in knowledge intensive business processes,” Business Process Management Workshops, 2009, pp. 678–686. A. Scherp, D. Eißing, and S. Staab, “Analysis and Comparison of Models for Individual and Organizational Knowledge Work,” Multikonferenz Wirtschaftsinformatik, Braunschweig, 2012. S. Heil, S. Wild, and M. Gaedke, “Collaborative Adaptive Case Management with Linked Data,” 23rd Intl. Conf. on World Wide Web Companion, Geneva, Switzerland, 2014. M. Böhringer, “Emergent case management for ad-hoc processes: A solution based on microblogging and activity streams,” in Business Process Management Workshops, 2011, pp. 384–395. S. Huber, M. Fietta, and S. Hof, “Next step recommendation and prediction based on process mining in adaptive case management,” 7th Intl. Conf. on Subject-Oriented Business Process Management, Kiel, Germany, 2015. P. Antunes, G. Zurita, and N. Baloian, “Requirements for Ad-hoc Geo-referenced BPM with Microblogging,” in Collaboration and Technology, vol. 8658, Springer 2014. T. Jones, W. R. Schulte, and M. Cantara, “Magic Quadrant for Intelligent Business Process Management Suites,” Gartner, Mar. 2014. J. White, “Office Delve—discover exactly what you need, when you need it,” MS Office Blogs, 26-Mar-2015. http://bit.ly/1LiGjOb. A.-B. Möhr, “AOK: Signavio process platform for a health insurance company,” AOK Nordost, Customer success story, 2015. R. Peinl, “Supporting KM Instruments with Composable Micro‐Services,” 8th Conf. on Professional Knowledge Management (ProWM 2015), Dresden, Germany, 2015. H. H. Hoang and T. M. Le, “BizKB: A Conceptual Framework for Dynamic Cross-Enterprise Collaboration,” in Computational Collective Intelligence. Semantic Web, Social Networks and Multi-agent Systems, vol. 5796, Springer Berlin Heidelberg, 2009, pp. 401–412. E. C. Wenger and W. M. Snyder, “Communities of practice: The organizational frontier,” Harvard business review, 78(1), pp. 139–146, 2000.
