Demonstrating Flexible Support for Knowledge-Intensive Processes with proCollab Nicolas Mundbrod and Manfred Reichert Institute of Databases and Information Systems Ulm University, Germany {nicolas.mundbrod,manfred.reichert}@uni-ulm.de http://www.uni-ulm.de/dbis Abstract. Knowledge-intensive processes (KiPs) are driven by knowl- edge workers utilizing their skills, experiences, and expertise. As these processes are emergent and unpredictable, their support constitutes a big challenge. For coordinating and synchronizing the various tasks of a KiPs, knowledge workers still rely on simple task lists like, e.g., to-do list or checklists. Though task lists are intuitive, their current implemen- tations are very ineffective: tasks are neither made explicit nor are they personalized or synchronized. In addition, no task management lifecycle support is provided and media disruptions frequently occur. This tool demonstration presents the proCollab framework supporting a wide range of KiPs (e.g., projects and cases) through integrated, lifecycle-based task management. In particular, proCollab task trees support the provision of task list templates and to constitute digital task lists of any kind. For customization, it further allows integrating domain-specific methodologies as well as configuring task lists at design and run time. Overall, the pro- Collab framework shall improve coordination among knowledge workers, increase work awareness, and record valuable coordination efforts. Keywords: knowledge-intensive processes, task management, task list, checklist, to-do list, knowledge worker Introduction Residing in sensitive key business areas, such as research, healthcare, or engi- neering, knowledge-intensive processes (KiPs) have become the centerpiece for creating value in many companies [ ]. While driving KiPs, knowledge workers uti- lize their skills, experiences, and expertise to cope with sophisticated tasks. Thus, the systematic and sustainable support of KiPs constitutes a prerequisite for achieving business goals. KiP support, however, still poses a big challenge. KiPs can be characterized as non-predictable, emergent, goal-oriented, and knowledge- creating processes [ , ]. Consequently, KiPs have not been fully supported by contemporary process-aware information systems so far. Instead, knowledge workers still rely on simple task lists (e.g., to-do lists, checklists) to coordinate their work [ ]. But these instruments are error-prone and ineffective. Moreover, Nicolas Mundbrod and Manfred Reichert knowledge workers suffer from media disruptions and a lack of lifecycle-based task management preventing them from reusing existing artifacts (e.g., task lists) in similar KiPs [ ]. The proCollab framework aims at the systematic and sustainable support of KiPs. As tasks constitute the key objects regarding planning and quality assurance for knowledge workers, proCollab provides process- and lifecycle-based task management [ ], empowering knowledge workers to collaborate more effectively. To make use of best practices and knowledge gained in the context of comparable KiPs, proCollab provides process and task list templates, which knowledge workers may instantiate on demand. To foster the reuse of these templates, a context- aware approach for configuring task list templates is included as well. Knowledge workers may then easily configure task lists either at design or run time. To increase work awareness in addition, proCollab encompasses a flexible state management concept. The latter may be customized to optimally align KiPs, task lists, and tasks with domain-specific requirements. Finally, the proCollab framework aims to improve coordination among knowledge workers, prevent media disruptions, and record valuable coordination efforts and knowledge. proCollab and its Significance to the BPM field To enable a generic, but customizable support for KiPs, the proCollab framework relies on processes, task trees, and tasks as the conceptual pillars for representing a wide range of KiPs as well as task-based artifacts used by knowledge workers. To establish and provide lifecycle-based task management support in the context of KiPs [ ], processes are refined to process templates and process instances, whereas task trees are refined to task tree templates (with task templates) and task tree instances (with task instances) respectively. Figure illustrates the relationship and interplay of those components. Process Process Process Process Act Process Process Process Act Act Process Act Act Act Templates TaskTree Task Task Tree Tree TaskTree Task Task Tree Tree Task Tree TaskTree Task Task Tree Tree Task Tree TaskTree Task Task Tree Tree Instances Task Task Tree Tree Task Task Tree Tree Task Tree Root Task Task Tree Tree Root Task Tree Task Tree Task Tree Root Task Tree Plan Root Root Root Study Root Root Task Tree Root Task Tree Plan Root Plan Root Root Study Root Root Root Study Root Root Root Plan Plan Root Root A B Root Study Root Root A B Study Root Root Root Root Root AA BB Plan AA BB Root Root Root Root Study A Root B A Root B 0-1 0-n A B A B AA BB AA BB AA Root BB AA Root BB AAA A1 A2 BBB B1 B2 AAA A1 A2 BBB B1 B2 AA BB AA BB Instantiation AA A1 A1 A2 BB A2 B1 B1 B2 B2 AA A1 A1 A2 BB A2 B1 B1 B2 B2 A A1 A2 B B1 B2 A A1 A2 B B1 B2 A1 A1 A2 A2 B1 B1 B2 B2 A1 A1 A2 A2 B1 B1 B2 B2 A1A1 A2A2 B1B1 B2B2 A1A1 A2A2 B1B1 B2B2 A A1 A2 B B1 B2 A A1 A2 B B1 B2 A1 A1 A1 A2 A2 A2 B1 B1 B1 B2 B2 B2 A1 A1 A1 A2 A2 A2 B1 B1 B1 B2 B2 B2 A1A1 A2A2 B1B1 B2B2 A1A1 A2A2 B1B1 B2B2 A1 A1 A2 A2 B1 B1 B2 B2 A1 A1 A2 A2 B1 B1 B2 B2 A1 A2 B1 B2 A1 A2 B1 B2 Do A1 A2 B1 B2 A1 A2 B1 B2 Do Do Do Subordinated Do Do Subordinated 0-n 1-n Process Templates 0-n 1-n Process Instances 0-n 0-n TaskTree Tree 0-n TaskTree Tree 0-n Task Task Optimization Task Tree Root Root Root Root Task Tree Instances Templates A B 0-1 0-n A B A B TaskTree Task Task Tree Tree Sub-Task Tree A B with Task Instances TaskTree Task Task Tree Tree Sub-Task Tree with A1 A2 Root Root A1 A2 Root Root Templates with Instances with Root Root A1 A2 B1 B2 A1 A2 B1 B2 Task Templates Root Root B1 B2 A A B B B1 B2 A A B B 1-n 0-n B A1 1 A1 A2 A2 B2B1 B1 B2 B2 Task Templates 1-n 0-n B1 A1 A1 A2 A2 B2B1 B1 B2 B2 Task Instances Fig. . Overview of proCollab Components Process templates and task tree templates enable knowledge workers to ac- celerate planning of their tasks based on best practices. Every process template may have several subordinated process templates and feature various properties, Process-aware Support for Collaborative Knowledge Workers The proCollab Demonstrator conditions, and linked resources. Every process template may be linked to an arbitrary number of task tree templates. A task tree template, in turn, contains task templates and, optionally, subordinated task tree templates. Thereby, it reflects best practices for planning (to-do list) or quality assurance (checklist) in the context of KiPs. For example, process template for clinical surgeries may contain a task tree template for ensuring patient safety during surgeries. At run time, knowledge workers collaborate in the context of process instances. A process instance may represent a running project, a case, or any kind of knowl- edge worker collaboration. Moreover, it has properties like a goals and it features resources (e.g., documents). A process instance may have subordinated process instances to let knowledge workers focus on specialized sub-goals. Every process instance may comprise multiple task tree instances with corresponding task in- stances. A task tree instance constitutes the generic representation of common task-based artifacts (e.g., a to-do list) in use. For example, an automotive engi- neering project with to-do lists for planning and checklists for quality assurance can be supported by a respective proCollab process instance with corresponding task tree instances (of type “to-do list” and “checklist”) (cf. Figure ). Name: Name: Name: DevelopmentProject Development Development Projectfor Project forAirbag for AirbagControl Airbag ControlUnit Control UnitACU-5891 Unit ACU-5891V14 ACU-5891 V14 V14 Name: E/E Car Component Development Project Name: Development Project for Airbag Control Unit ACU-5891 V14 Goal: Goal: Goal: ACU-5891V14 ACU-5891 ACU-5891 V14Sa�sfying V14 Sa�sfyingSpecifica�on Sa�sfying Specifica�onCCS-8641 Specifica�on CCS-8641 CCS-8641 Goal: E/E Car Component Sa�sfying Specifica�on Goal: ACU-5891 V14 Sa�sfying Specifica�on CCS-8641 Due Due DueDate:Date: Date: 15 Date: 15 October 15October 15 2016 October2016 October 2016 2016 Due Date: 2 Years A�er Start Due ... Status:Running Running ... ......... Status: Status: Status: Running Running Specifica�ons Specifica�ons Designs TaskListList Specifica�ons Designs Designs Checklist Specifica�on Design Task Task Task Task List List List Specifica�ons Designs Checklist Checklist TaskList List Checklist Task Task Task List List List Checklist Checklist Checklist Checklist Task Templates Guidelines Checklist Task To-do Task To-do Task List List List List List Task Task Instances AA Instances Checklist Checklist Checklist Checklist Instances Check InstancesItemAA Task List Templates Checklist To-do Task List Task AAA Instances Checklist ChecklistCheck Item Instances Check Item To-do List Task A Checklist Templates Check Item A To-do Task List Task TaskInstances TaskAAAATask A1 ChecklistCheck Item Instances Check Check Item Item AAA Task A Check Item A Task TaskAA To-do Task ATask ATaskA1A1 ... Check Check Check Item Item Item Check CheckItem AAAAItem A1 ItemAAAAItem ......... Task ATask A1 CheckCheck Item AItem A1 To-do Task AA Task Task A1 A1 Check Check Check Item Item Check Check ItemA1 A1 A1 To-do Task Task A1 A1 Check Item Check AItem Item To-do ATask A1 TaskTask A1 ... CheckCheck Item AItem Check Item A1 A1 To-do ATask Task Task To-do Task To-do Task To-do A1 A1 A1 Task A1 A1A1 Task A1 Task Task A1 Task A2 A2 A2 A2 A2 Check Check Item Check Check Check Item Check Check Check Check Check Check Check Check Check Check AItem AItem Item Item Item Item Item Item Item A1 A1 Item A1 Item A1 Item A1 A1 A1 A1 A1 A1 A2 A2 A2 To-do A1A2A2 Check Check Item Item A1 A2 To-do Task Task A1 Task Task A2 A2 A2 A2 Check Check Check Check Check Check Item Item Item A1 Item Item Item A1 A2 A2 A2 A2 Task Check Item A2 Task To-do Task To-do Task Task A2 A2 Task A2A2 A2 BB B LinkedResources Linked Resources Check Check Check Check CheckCheck Item Item Item Item Item Item A2 A2 A2 A2 A2 BB Task A2 To-do TaskA2B Linked Resources Check Item A2 Check CheckItem A2B Item To-doTask Task Task To-do Task A2A2 BB TaskBBBBTask B1 Task Linked Linked Resources Resources Check Check Check Check Check Check Check Check Check Item Item Item Item Item Item Item Item Item A2 A2 A2 A2 BBB Task B Check Item B Task Task To-do Task To-do BTask BB BTaskB1 Task B1 B1 Check Check Check Check Check Item Item Item Check Item Item BBBItem BItem BBItem B1 Task B Task B1 CheckCheck Item BItem B1 Task B To-doBTask B Task TaskTask Task B1 B1 B2 B1 Check Check CheckCheck Item Check Item Check Item Check BB BItem ItemB1 B1 B1 B1 To-do B CheckCheck Item BItem B1 To-do Task Task To-do B1 B1 B1 B1 Check Check Item Check Check Item Check BItem BItem Item Item B1B1 B1 Task B1 Task To-do Task B1 Task B1 Task B2 B2 B2 Check Check Check Check CheckItem Item Item B1 B1 Item B1 B1 B2 TaskTask To-do B1 B1B2B2 Check Item B1 Check Check Item Item B1 B2 Task To-do To-do B1 Task Task B1 Task B1 Task Task B2 B2 B2 B2 B2 Requirements Requirements System System Check Check Check Check Check Check Check ItemItem Item Item Item B1 B1 Item B1 B2 Item B2 B2 B2 Task Task B2 Requirements System Check Item B2 Task To-do Task To-do Task B2 B2 B2B2 B2 Requirements Requirements System System Check Check Check Item Check Check Check Check Check Item Item B1 Item Item Item Item Item B2 B2 B2 B2 B2 B2 B2 To-do B2 Check Item B2 To-do To-do B2B2 Engineering Engineering Design Design Check Check Check Item Item Item B2 B2 B2 Engineering Design Check Item B2 Engineering Engineering Design Design ... Check Item B2 ... ......... Planning Planning SubordinatedProcess Subordinated ProcessTemplates Templates QualityAssurance Quality Assurance Planning Subordinated Process Templates Quality Assurance Planning Planning Subordinated Subordinated ProcessTemplates Process Templates Quality Quality Assurance Assurance a) Process Templates of Specializa�on Type Project Instantiation b) Process Instances of Specializa�on Type Project Fig. . Visualization of Process Templates and Instances from the Automotive Domain In general, knowledge workers may create a process instance based on a process template or starting without any template at all. If a process template is instantiated, the linked task tree templates are instantiated, too. Further, the created task tree instances are linked to the corresponding process instance. In the context of a particular process instance, knowledge workers may instantiate further task tree templates or add “blank” task tree instances on demand. To support a wide range of application scenarios, proCollab employs spe- cialization types enhancing the generic data structures of processes and task trees. Depending on the chosen specializations, processes (e.g., projects) and task trees (e.g., to-do lists) may feature additional properties (e.g., states), conditions, constraints, or assignments. For example, a proCollab process may be adapted to a specific automotive project (cf. Fig. ). If a task tree instance is linked to the specialization type to-do list, it will be interpreted as a to-do list instance with corresponding user interface representations and properties. To ensure a coherent use of specialization types, the latter may be linked to each other. For example, the specialization types to-do list and to-do item are interlinked and, hence, task trees of type to-do list may only contain tasks of type to-do item. To further Nicolas Mundbrod and Manfred Reichert increase domain-specific support, proCollab employs a generic state management for its stateful key components. This enables us to integrate domain-specific methodologies as well as to manage different types of proCollab components in a controlled manner. Additionally, proCollab provides a configuration concept for task tree templates. The latter enables the efficient configuration of task list templates in accordance to the given application context. Due to a lack of space, both the state management and the configuration concept are presented in the screencast of this demonstration in more detail (cf. Section ). Concerning the significance of proCollab to the BPM field, the design of a systematic KiP support still constitutes a big challenge. While predictable business processes can be well supported by process-aware information systems based on pre-specified process models (doing-by-design), unpredictable and emergent KiPs require a degree of flexibility traditional systems are not able to provide due to the limitations of model-driven approaches. In turn, the proCollab framework relies on the design-by-doing approach necessitating different concepts and functions to support a wide-range of KiPs in a generic, but still domain-specific way. In comparison to declarative process execution systems like Declare or DCR Graphs [ ] and approaches based on CMMN [ ], proCollab focuses on the stateful and flexible task (list) management support for KiPs and knowledge workers. In particular, knowledge workers themselves shall drive proCollab processes and, as a consequence, the management of tasks and task lists, too. The proCollab Tool and its Maturity To prepare empirical studies and to evaluate the technical feasibility of the proCollab framework, we developed the proCollab tool. The latter is realized with Java EE and relies on a MVC-based architecture (cf. Fig. ). In particular, the application logic layer represents the core of the tool realizing the key services of the proCollab framework. The REST-based interface enables web and mobile applications to communicate with these key services. Finally, the web application based on AngularJS provides state-of-the art user interfaces (cf. Fig. ) to the knowledge workers interacting with the proCollab tool. The current version of the proCollab tool enables knowledge workers to manage the proCollab key components, i.e., they may manage KiPs in the shape of common projects or cases (i.e., proCollab processes) including task trees embodied as, e.g., to-do lists or checklists. Moreover, knowledge workers may configure task tree templates or instantiate process/task tree templates on demand (see screencast). Furthermore, the proCollab tool allows integrating domain-specific state models for templates and instances of processes, task trees, and tasks. In turn, the assignment of users to tasks, the integration of process resources (e.g., documents, structured data), and the synchronization of tasks and processes are currently in development to be integrated in the web application. Based on its architecture and the technologies in use, the proCollab tool can scale up well and even be deployed in cloud-based environments to serve a significant amount of knowledge workers concurrently. The proCollab Demonstrator Presenta�on Web Applica�on Mobile Applica�ons Communic ati on REST API Process Services Task Tree Services User and Role (Instances) (Instances) Management Applica�on Process Template Task Tree Template Repository Repository Data Management Java Persistence API Java Content Repository P ersist ence Database Management Systems a) b) Fig. . Architecture and Screenshot of the proCollab Tool Finally, we prepared a screencast available on bpm demo.procollab.de to demonstrate proCollab. The screencast illustrates the key aspects of the proCollab framework using the scenarios of developing a website and conducting a surgery. Conclusion This demo presented the proCollab framework and its proof-of-concept tool. The latter is implemented as a scalable, cloud-ready, and web-based application plat- form. This allows users to collaborate in the scope of KiPs and to simultaneously manage proCollab key components to receive optimal KiP support. Based on the tool, user experiments will be conducted to systematically analyze whether KiPs can be successfully evolved when using the proCollab framework. Overall, we believe that the proCollab framework will improve coordination among knowledge workers, increase work awareness, and record valuable coordination efforts. References . Di Ciccio, C., Marrella, A., Russo, A.: Knowledge-Intensive Processes: Characteristics, Requirements and Analysis of Contemporary Approaches. J on Data Semantics ( ), – ( ) . Mundbrod, N., Beuter, F., Reichert, M.: Supporting Knowledge-Intensive Processes through Integrated Task Lifecycle Support. In: Proc. EDOC . pp. – ( ) . Mundbrod, N., Kolb, J., Reichert, M.: Towards a System Support of Collaborative Knowledge Work. In: BPM Workshops. LNBIP ( ) . Mundbrod, N., Reichert, M.: Process-Aware Task Management Support for Knowledge-Intensive Business Processes: Findings, Challenges, Requirements. In: Proc. EDOCW’ . pp. – ( ) . Object Management Group: Case management modeling and notation (cmmn) . ( ), http://www.omg.org/spec/CMMN/ . / . Pryss, R., Mundbrod, N., Langer, D., Reichert, M.: Supporting medical ward rounds through mobile task and process management. Inf Sys and e-Business Management ( ), – ( ) . Reijers, H.A., Slaats, T., Stahl, C.: Declarative Modeling—An Academic Dream or the Future for BPM? In: Proc. BPM , pp. – . Springer ( )