DEV Community: Process Analytics

Process Analytics - July 2023 News

Nour Assy — Mon, 07 Aug 2023 13:55:21 +0000

Welcome to the Process Analytics monthly news 👋.

Our “always” reminder: The goal of the Process Analytics project is to provide a means to rapidly display meaningful Process Analytics components in your web pages using BPMN 2.0 notation and Open Source libraries.

Welcome to our July project news update ⛵! This edition spotlights the launch of our new experimental library, and showcases a captivating new demo. Let's dive right in!

Promotion highlights

All you need to know about style management in bpmn-visualization

We've published a fresh article delving into the styling of BPMN elements using our bpmn-visualization TypeScript library. This piece not only covers the basics of style management but also features some advanced usage scenarios to inspire your projects. Intrigued? Find out more 👉 here.

We're listed on BPMN Tool Matrix

For those interested in exploring different BPMN-based tools, the BPMN Tool Matrix is an invaluable resource. We're proud to inform you that our project, backed by our "free" and "open source" Apache 2 license, is featured there 😉.

Website Improvements

Our website revamp is ongoing, and the latest update includes a new, user-friendly design for the 'cards' of our articles and blogs. We hope you'll find this update both aesthetically pleasing and practical 😊.

bpmn-visualization TypeScript library

In July, we released version 0.38.0. Below are some highlights.

New experimental library with great new features

We're excited to announce the launch of our new experimental library, bv-experimental-add-ons. This fresh addition will offer an array of novel features, primarily concentrating on computing and visualizing paths in BPMN.

Why are paths so important, you might ask? Well, within the realm of process intelligence and optimization, being able to mine path information has a wide range of applications: What is the most/least performant path in my BPMN process? Which path is the most/least frequent? What's the predicted remaining path to complete the process instance? These and many other use cases require "computing and visualizing paths" to produce results.

Interested? Star and follow the progress of our experimental library. If any of the already opened issues seem familiar to you, you're more than welcome to contribute 🤗.

API enhancement

The updateStyle API has been enriched to support the ‘Gradient’ fill color as shown in the image below.

New prediction demo is out

This new demo employs bpmn-visualization to visualize late/on-time activities as well as predicted late/on-time remaining paths using mock data. Feel free to explore both the live demo and the source code.

That’s all folks!

We hope you've enjoyed this July project update. Enjoy your summer holidays and stay tuned for more exciting updates when we return. See you after the break 👋.

In the meantime, stay on top of the latest news and releases by following us:

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: Join our server!
YouTube: Process Analytics YouTube channel

Cover photo by jcob nasyr on Unsplash

bpmn-visualization: All you need to know about styling BPMN elements

Nour Assy — Fri, 21 Jul 2023 09:23:05 +0000

In this article, we're going to dive deep into the capabilities of the bpmn-visualization Typescript library, with a specific focus on managing styles. You'll learn how to use its APIs to set styles and, when necessary, revert them back to their default state. Additionally, we'll feature some advanced usage scenarios to provide you with inspiration for your own use.

If you're just getting started with bpmn-visualization, we recommend that you take a look at our Getting Started tutorial. It provides a step-by-step guide on how to set up and begin using the library.

You can try out and experiment with the APIs in one of our preconfigured live environments, available here (see the 'Miscellaneous' section).

So let's dive in 🏊!

Setting styles in bpmn-visualization

There are two primary ways to go about setting styles of BPMN elements: via CSS or programmatically. Let's delve into these two methods.

Styling with CSS: The addCssClasses API

The first method involves CSS, the cornerstone technology used to apply stylistic choices to elements on a web page. To use CSS for styling your BPMN elements, bpmn-visualization provides the addCssClasses API. This method is especially useful when you've already defined CSS class names that you wish to apply to your BPMN elements.

In order to use addCssClasses, begin by defining your styles in your stylesheet, assigning a unique class name to each style. You can then apply these classes to your BPMN elements using the API.

To illustrate, let's consider an example where we're styling activities to indicate an error state. Here's how you could define such a CSS class in your CSS file:

/* Define your CSS class in your CSS file */ 
/* CSS class for an activity in error */ 
.bpmn-activity-error > rect { 
  fill: Tomato !important; 
  fill-opacity: 15% !important; 
  stroke: Tomato; 
}

Once you've defined your CSS class, apply it in your JavaScript or TypeScript code. This can be done by calling the addCssClasses API, which accepts the IDs of one or multiple BPMN elements, along with the CSS classes to be applied. Here's an example of how you can add the bpmn-activity-error class to two different activities:

// Create a new instance of BpmnVisualization
const bpmnVisualization = new BpmnVisualization(...);

// Load your BPMN diagram
bpmnVisualization.load(...);

// Apply the CSS class to a BPMN element
bpmnVisualization.bpmnElementsRegistry.addCssClasses(['task_id1', 'task_id2'], 'bpmn-activity-error');

For a more in-depth explanation of styling BPMN elements through CSS, be sure to check out our Getting Started tutorial.

Dynamic styling: The updateStyle API

There might be cases where the style of a BPMN element is not known beforehand, or needs to change dynamically based on certain conditions. In these cases, the ability to programmatically apply styles is necessary.

This is where the updateStyle API comes into play. The updateStyle API allows you to alter the style of BPMN elements directly within your code. This offers the flexibility to adjust styles instantly and responsively.

Much like the addCssClasses method, updateStyle accepts the identifiers of one or more BPMN elements, along with a set of style properties defined through the StyleUpdate type. The properties that can be adjusted are dependent on the type of BPMN element: edge or shape (e.g., activities, events, gateways, etc.).

Let's consider the following example:

bpmnVisualization.bpmnElementsRegistry.updateStyle(
  ['task_id1', 'task_id2'], { 
    fill: { color: "blue", opacity: 15 }, 
    font: { opacity: 40 }, 
    stroke: { color: "blue", width: 3 }, 
    opacity: 30
});

In this instance, the style is directly applied to the BPMN elements identified by task_id1 and task_id2.

Resetting styles in bpmn-visualization

Inevitably, there will be cases where you want to reset the styles applied to your BPMN elements, either returning them to their default state or preparing them for a new style. bpmn-visualization provides easy-to-use APIs for this as well, mirroring the ways you can set styles.

Resetting CSS classes: The removeCssClasses API

You can easily remove classes for styles that have been applied using CSS with the addCssClasses API, by using the removeCssClasses API, providing the IDs of the BPMN elements, and providing the names of the CSS classes you want to remove. If you want to remove all CSS classes, you can do so with a call to removeAllCssClasses.

Here's an example:

// Remove one or more CSS classes
bpmnVisualization.bpmnElementsRegistry.removeCssClasses(['task_id1', 'task_id2'], ['bpmn-activity-error']);

// Remove all CSS classes
bpmnVisualization.bpmnElementsRegistry.removeAllCssClasses(['task_id1', 'task_id2']);

Resetting dynamic styles: The resetStyle and updateStyle APIs

bpmn-visualization provides a couple of options for programmatically applied styles. If you want to completely reset the style of a BPMN element, you can use the resetStyle API. Just pass the IDs of the BPMN elements to this API and it will clear all style settings applied through the updateStyleAPI. Here's an example:

// Reset the style of a BPMN element 
bpmnVisualization.bpmnElementsRegistry.resetStyle(['task_id1', 'task_id2']);

If, however, you want to reset some specific style properties while leaving others intact, you can use the updateStyle API. Instead of setting the property to a specific value, you pass the value as default. Here's an example:

// Reset specific style properties of a BPMN element
bpmnVisualization.bpmnElementsRegistry.updateStyle('task_id1', { 
  fill: {color: 'default', opacity: 'default'},
  stroke: 'default' 
});

In this case, the fill and stroke properties are reset to their default values, while other style settings remain unchanged.

And that's it for the basics of bpmn-visualization's styling APIs. In the next section, we'll be looking at some more advanced usage scenarios, so keep reading 👌

Advanced usage scenarios

Beyond the basics, bpmn-visualization can be used in a multitude of scenarios to address your specific needs. To illustrate this, we'll examine two practical applications of the library: interactive styling and data-driven styling.

Interactive styling

Interactive styling brings your BPMN diagrams to life by enabling them to respond to user actions. This could include actions like highlighting an element on hover, changing the style upon clicking, or indicating the active task in a process.

Our team has prepared different demos that showcase how to implement interactive styling using bpmn-visualization. Although the library does not currently support attaching event listeners directly to BPMN elements, we can still achieve interactivity by accessing the corresponding HTML elements.

Here's a code snippet that shows how to change the style of a BPMN element while the mouse is hovered on it, as it is done in the Draw me a path demo:

// Retrieve the BPMN element using its ID
const bpmnElementId = 'task_id';
const bpmnElement= bpmnVisualization.bpmnElementsRegistry.getElementsByIds(bpmnElementId)[0];

// Retrieve the corresponding HTML element
const htmlElement = bpmnElement.htmlElement;

// Add a mouse event listeners to the HTML element
htmlElement.onmouseenter = () => {
    // Change the style of the corresponding BPMN element
    bpmnVisualization.bpmnElementsRegistry.updateStyle(bpmnElementId, {
     stroke: 'MediumVioletRed',
     font: {color: 'MediumVioletRed'}
    });
};

htmlElement.onmouseleave = () => {
    // Reset the style of the corresponding BPMN element
    bpmnVisualization.bpmnElementsRegistry.resetStyle(bpmnElementId);
};

In this snippet, we first retrieve the BPMN element using its ID by calling getElementsByIds. We then access the corresponding HTML element. After this, we add hover event listeners to this HTML element. As a result, when the mouse hovers over this HTML element, the style of the corresponding BPMN element changes. As soon as the mouse leaves, the style resets to its original state.

Below is a screenshot from the demo illustrating the final outcome:

For more inspiration on interactive styling use cases, we invite you to explore the additional interactive features in our Draw me a path and Bonita Day 2023 demos. You might also be interested in checking out an example of integration with the Vue framework, contributed by our amazing community. Happy exploring! 🤗

Data-driven styling

Data-driven styling allows you to customize the appearance of BPMN diagrams based on associated data. This can be particularly useful when you want to display certain characteristics or metrics related to your process, such as frequency or performance statistics, directly on your BPMN diagrams.

For example, consider one of our demos that integrates the bpmn-visualization library with pm4py. In this demo, we perform process discovery, compute frequency of execution statistics, carry out conformance checking, and then visualize the results using bpmn-visualization.

One interesting aspect of this demo is how it handles the computation and visualization of process statistics. The first step involves using the scaleSequential function from the D3 library to map frequency statistics to a color gradient, ranging from light blue to dark blue as shown in the code snippet below:

// Create a D3 scale to map frequency to a color
const colorScale = d3.scaleSequential()
  .domain([0, 1]) // Initialize domain with dummy values
  .interpolator(d3.interpolatePuBu);

Next, we use the fetch API to retrieve frequency statistics computed in the backend by pm4py. After obtaining these statistics, we call the visualizeFrequency function to visualize the results on our BPMN diagram:

// Compute frequency statistics using pm4py in the backend
fetch(`${apiUrl}/stats/frequency`)
    .then(response => response.json())
    .then(data => visualizeFrequency(data))
    .catch(error => console.log(error));

For clarity, let's examine key portions of the visualizeFrequency function. In the code snippet below, we show how this function updates the fill color and the color of labels for activities based on their frequency of execution:

// Function to visualize frequency data on BPMN elements
function visualizeFrequency(stats) {
    // Update the domain of colorScale with the actual values
    colorScale.domain([0, d3.max(Object.values(stats))]);
    // Compute the mean of frequencies
    const avg = d3.mean(Object.values(stats))];

    // Update the color of activities based on their frequency
    for (const [elementId, frequency] of Object.entries(stats)) {
        // isActivity is a function that returns true if elementId corresponds to an activity
        if (isActivity(elementId){
           const fillColor = colorScale(frequency);
           const fontColor = frequency > avg ? 'white' : 'default';

           bpmnVisualization.bpmnElementsRegistry.updateStyle(elementId,{
               fill: { color: fillColor },
               font: { color: fontColor }
           });
        }
    }
}

Below is a screenshot from the demo that displays the end result of these manipulations:

Conclusion

That wraps up our overview of style management in bpmn-visualization. If you're interested in learning more or looking for some inspiration, feel free to check out our bpmn-visualization-examples repository on GitHub. Have fun on your learning journey!

If you want to stay on top of the latest news and releases from the Process Analytics project, follow us through:

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: https://discord.com/invite/HafnBYsRXd
YouTube: Process Analytics YouTube channel

Process Analytics - June 2023 News

Nour Assy — Wed, 05 Jul 2023 07:58:25 +0000

Welcome to the Process Analytics monthly news 👋.

Here is our June project news update ☀️! In this edition, we'll cover the highlights of some successful webinars, new API introductions, and the exciting integration of bpmn-visualization with the Vue framework. Let's get started!

Webinar highlights

This month has been quite a ride with our participation in two informative webinars!

A 3-hour virtual workshop as part of Vivatech Tech Days Week: during this workshop, we dove deep into process mining, shed light on our project's process analytics, and demonstrated how to extract process mining data from Bonita.

If you missed it, the replay (in French) is available right here.

As one of Bonitasoft's monthly webinars: 3 one-hour sessions in each of three languages: French, English, and Spanish! We seized this opportunity to showcase the capabilities of our bpmn-visualization through a monitoring demo.

If you didn't catch any of these webinars live, you can find the replays in all three languages (English, French and Spanish).

If you are interested in a hands-on experience, our demo is ready for you on GitHub. Feel free to give it a try here.

A big thank you to Vivatech and Bonitasoft for these opportunities.

bpmn-visualization TypeScript library

In June, we released two versions 0.36.0 and 0.37.0.

New API to reset the style programmatically

In bpmn-visualization, styling can be applied in two ways: either by adding a CSS class name or by updating the style programmatically. The same principle applies when it comes to resetting a style. Last month, we introduced removeCssClasses, an API designed to reset the CSS classes applied to one or multiple BPMN elements.

This month, we've added a new resetStyle API in version 0.37.0. This lets you easily reset styles applied programmatically via updateStyle. Just call resetStyle with element IDs to revert their style, or with no IDs to reset all elements as shown in the code snippet below.

// Reset task and sequence flow styles
bpmnVisualization.bpmnElementsRegistry.resetStyle('task_1', 'sequenceFlow_1'); 

// reset the style of all elements of the diagram 
bpmnVisualization.bpmnElementsRegistry.resetStyle();

Support for Transaction Sub-Processes

Version 0.36.0 brought support for transaction Sub-Process in BPMN. Transaction Sub-Processes executes a group of activities as a single, fail-or-succeed unit within a larger process. If any activity fails, changes are rolled back to ensure data consistency.

Transaction Sub-Processes have a distinct double line edge as shown below.

BPMN in color support officially referenced by BPMN MIWG

Following our announcement last month about the support for _BPMN in color _specification, we've now been formally referenced on the BPMN MIWG's official GitHub account. BPMN MIWG, also known as the OMG BPMN Model Interchange Working Group, is an initiative that aims to ensure the smooth interchange of BPMN models between various BPMN modeling tools.

An example of integration with Vue framework

A new integration project for Vue has been contributed to the bpmn-visualization Examples repository, thanks to the efforts of @brendanlaschke. We appreciate this contribution.

Feel free to explore this example here.

You can also check out the list of all integrations here.

That’s all folks!

We hope you enjoyed this June project news and stay tuned for more exciting updates in the coming months 👋.

In the meantime, stay on top of the latest news and releases by following us:

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: Join our server!
YouTube: Process Analytics YouTube channel

Cover photo by Dominik Scythe on Unsplash

Process Analytics - May 2023 News

Nour Assy — Fri, 02 Jun 2023 10:00:00 +0000

Welcome to the Process Analytics monthly news 👋.

In the blink of an eye, May whisked us away with an abundance of holidays (in France, May is the month of many long holiday weekends! 🤗). This month, we introduced new functionalities, including support for BPMN in color, which enables the rendering of color-modeled BPMN. We also updated our examples with the latest APIs and achieved a milestone with the publication of an article on integrating our bpmn-visualization library with pm4py.

bpmn-visualization TypeScript library

In May, we released 3 versions: 0.34.0, 0.34.1 & 0.35.0. Below are some highlights of the main features of these versions. For more details, check out the release notes.

BPMN in Color specification now supported

The BPMN in Color specification is a reference to define the colors of BPMN modeling elements. This specification is recommended for color exchange between BPMN modeling tools. More information about this specification is available in the bpmn-miwg/bpmn-in-color GitHub repository.

In bpmn-visualization 0.35.0, support for BPMN in Color was introduced with a fallback to bpmn.io-specific BPMN extensions for colors.

Rendering of colors defined in the BPMN source is disabled by default. To enable BPMN in Color, use the following code snippet:

const bpmnVisualization = new BpmnVisualization({ 
            container: 'bpmn-container', 
            renderer: { ignoreBpmnColors: false }
});

⏩ Want to test it live? Give it a try with the following examples:

Load and navigation demo
Example that loads diagrams from miwg-test-suite. Load A.4.1 or C.1.0 for the instance.

New API for CSS style reset

In earlier versions of bpmn-visualization, we provided functionality to remove specific classes from BPMN elements by specifying their IDs and class names, as demonstrated in the code snippet below:

// Remove CSS classes from the BPMN elements in styledElements
bpmnVisualization.bpmnElementsRegistry
                 .removeCssClasses(styledElements, 
                                    ['highlight-info', 
                                     'highlight-success', 
                                     'highlight-error', 
                                     'highlight-warning']);

While this approach served its purpose in removing a portion of CSS classes, it became cumbersome when applications required a complete restoration of default rendering or a transition to an entirely different visualization. For example, in our monitoring demo, switching from a frequency view to a time performance view, or in our Bonita Day 2023 demo, switching between different use cases necessitated a complete style reset.

With the release of bpmn-visualization 0.34.0, we introduced a new API called removeAllCssClasses in the BpmnElementsRegistry. This API empowers users to effortlessly remove all CSS classes from BPMN elements. Take a look at the code snippet below:

// Remove all CSS classes from the BPMN elements in styledElements
bpmnVisualization.bpmnElementsRegistry
                 .removeAllCssClasses(styledElements);

And if you wish to reset the CSS classes of all BPMN elements, you can simply call the function with no arguments:

// Remove all CSS classes from all BPMN elements
bpmnVisualization.bpmnElementsRegistry.removeAllCssClasses();

bpmn-visualization examples

We have updated the existing examples to showcase the enhancements of the latest functionalities. For a comprehensive overview of all the changes, please refer to the examples 0.34.0 release notes.

In particular, the monitoring demo now uses the Update Style API instead of the CSS API to have a consistent stroke width even when zooming. Curious to explore the updated demo? Take a look at our ⏩ live environment.

The examples that allow users to play with the library, and that are running in the Live IDE, have been updated as well. Want to give it a try? ⏩ live environment.

Sharing Key Insights from bpmn-visualization and pm4py Integration

We recently developed an integration example between bpmn-visualization and pm4py. This example allows the user to discover a BPMN process model from process execution data and to compute various statistics using pm4py. The results are then displayed visually using our bpmn-visualization library. The figure below showcases an example of a BPMN process model enriched with frequency data obtained from process execution data sourced from the process mining book.

During the process, we encountered some limitations of the BPMN-based process mining approach we followed ⛔️. In our latest article, we delve into the high-level details of the integration and shed light on those limitations of BPMN-based visualization in process mining. Read more about it 👉 in our Medium article.

That’s all folks!

That's a wrap for this edition of our May project news! We hope you found it informative and enjoyable. Stay tuned for more exciting updates on the horizon! 👋

In the meantime, stay on top of the latest news and releases by following us:

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: Join our server!
YouTube: Process Analytics YouTube channel

Cover photo by Ricardo Gomez Angel on Unsplash

Exploring the intersection of BPMN with Process Mining: Insights from integrating bpmn-visualization with pm4py

Nour Assy — Tue, 30 May 2023 11:15:00 +0000

Introduction

You know what they say: “you can't improve what you can't measure,” and that's where process mining has a role. Process mining is a powerful set of techniques for analyzing and optimizing business processes based on data. Similar to machine learning and data analytics, process mining uses data-driven methodologies to extract insights from process execution data, also known as event data.

One of the key requirements for effective process mining is the ability to visualize and interact with the results of analysis on process models. This is especially crucial as process mining findings are often used by business experts who may not have a technical background. However, many of the available industrial process mining tools have limited support for BPMN-based visualization, despite BPMN being a widely-used standard for process modeling and execution. As a result, there is a clear need for tools and libraries that can provide more comprehensive BPMN-based visualization capabilities.

There is an evident requirement for process mining tools and libraries that can offer enhanced visualization capabilities based on BPMN (Business Process Model and Notation).

To fill this need, Process Analytics - an open-source initiative under Apache 2.0 license led by Bonitasoft - is committed to developing developer-centric BPMN-based visualization components that can be seamlessly integrated into process mining projects. A pivotal component of this initiative is the bpmn-visualization library which empowers developers to visualize the results of process mining techniques on BPMN process models. With support for both TypeScript and R, bpmn-visualization provides developers with a straightforward means to render, style, and interact with BPMN elements.

Note that the popular Python process mining library pm4py offers a range of methods for process discovery, conformance checking, and performance analysis. By integrating bpmn-visualization with pm4py, we aim to take a step towards enabling BPMN-based process mining and visualization. The source code and documentation of this integration is available on GitHub, which offers an open opportunity for testing, exploration and contribution.

In this article, we will describe our experience in integrating these two libraries, and discuss the challenges we encountered due to the limited support for BPMN-based process mining. Our goal is to provide high-level insights and takeaways for the process mining community, including researchers, process mining experts, editors, and developers. Furthermore, we aim to engage anyone interested in the fusion of BPMN with process mining, including individuals from the BPM domain or other related fields. By doing so, we hope to raise awareness about the importance of native BPMN-based process mining and its potential impact across different domains.

Integration

Architecture

The integration involves the development of two main components - the frontend and the backend.

The frontend component is written in JavaScript and leverages the capabilities of bpmn-visualization to visualize BPMN process models and the result of the backend analysis.

The backend component is built using pm4py and is responsible for processing data and performing process mining analysis. More details about the architecture, the technologies used, and the application setup are available on GitHub.

Use cases

Three process mining techniques are used in this integration example: process discovery, conformance checking, and enhancement.

Process discovery: The inductive miner algorithm is used to automatically create a process model from event data stored in an event log using the XES storage standard.

Conformance checking: The event log is compared with the BPMN process model to detect deviations or non-conformities.

Enhancement: The BPMN process model is enriched with statistics data computed from the event log, such as the frequency of execution of BPMN elements and the conformance data obtained from the conformance checking technique.

Figure 2 below shows an excerpt of a BPMN process model discovered from a simple synthetic event log and enriched with frequency data using our developed integration example.

Approach

BPMN-based process mining is an emerging topic that is still under development in the research world, and not fully exported to the industrial world. This is because most process mining techniques originate from research efforts which are based on Petri net, a formalism for modeling concurrent systems. This is true of pm4py, as most of its implemented algorithms are based on Petri nets.

BPMN-based process mining is a developing research area that has not yet fully transitioned to industry. The integration process involves converting between BPMN and Petri nets, enabling the utilization of existing process mining algorithms designed for Petri nets and visualizing the results on BPMN diagrams.

Therefore, to develop the integration, we followed the approach described in enabling BPMN-based process mining. Generally, this approach consists of converting between BPMN and Petri nets. This means that existing process mining algorithms developed for Petri nets can be used and the obtained results are then processed to be visualized on BPMN.

To give a sense of this approach, Figure 3 below illustrates the workflow of generating the visualization shown in Figure 2 above (the discovered BPMN enriched with frequency information).

The first step consists of importing an event log. In the backend, Process Discovery and Enhancement components are required to discover and compute frequency information, respectively.

The Process Discovery component first creates a Petri net from the imported event log, which is then converted to BPMN. In our integration, this conversion is performed by the BPMN variant of the inductive miner using the discover_bpmn_inductive method. It's important to note that newer process discovery algorithms that can directly create BPMN process models are emerging (e.g. see the Model Generation Application developed as part of the Process Analytics project or the Split miner used by Apromore).

Next, a layout generation algorithm is employed to determine the positions (i.e., x and y coordinates) of elements on the BPMN diagram. In our example, we used the bpmn-layout-generators library developed as part of the Process Analytics project. Finally, this component outputs a serialized BPMN xml file that is sent to bpmn-visualization for rendering.

The Enhancement component enables the enrichment of the BPMN model with statistical data, such as frequency and performance information. To achieve this, a mapping between the event log and the process should be first established using replay algorithms. Once the mapping is established, the statistical data, such as frequency and performance data, can be computed for Petri net elements. The computed statistics then need to be mapped back to the corresponding BPMN elements. Finally, bpmn-visualization is utilized to visualize the results on top of the BPMN model.

Challenges & limitations

No native support for BPMN-based process mining

One of the main challenges we encountered is the lack of native support for BPMN-based process mining. While most process mining techniques rely on Petri nets, these can be challenging for non-technical business users to comprehend and utilize effectively. Existing industry-based solutions are primarily built on non-formal representations of process maps. Although process maps offer initial insights, they have limitations in representing the full process behavior and cannot support thorough and detailed analysis. In contrast, BPMN already has widespread acceptance within the business community, making it a more suitable and comprehensive approach for process mining.

Converting BPMN to Petri nets for BPMN-based process mining has limitations such as information loss, performance issues, and maintenance overhead.

The approach of converting BPMN to Petri nets is not a perfect solution for BPMN-based process mining due to several limitations:

Loss of information: The conversion process from BPMN to Petri nets may result in a loss of information, which can affect the accuracy of the analysis. In the BPMN-based process mining approach, a subset of BPMN elements is used to ensure a conversion with no loss.

Performance issues: The conversion process can be computationally intensive, which can lead to performance issues, especially when dealing with large process models.

Maintenance overhead: The use of Petri nets requires additional maintenance overhead, as the models need to be updated whenever changes occur in the business process.

Furthermore, the enhancement process mining technique, which involves establishing a mapping between the process model and the event log and computing various statistics, relies on replay algorithms that have been developed for Petri nets. Unfortunately, to the best of our knowledge, there is currently no known open-source implementation available for BPMN. Since event logs cannot be directly replayed against BPMN models, they must first be converted to Petri nets before the replay can be performed.

Despite these limitations, the conversion approach is currently the most viable solution for BPMN-based process mining, given the lack of native support for BPMN in the process mining community.

BPMN layout generation

Another challenge in BPMN-based process mining is generating a layout for the discovered process model. While process discovery algorithms can automatically extract a process model from event logs, they do not generate a visual layout that represents the model in a way that is easily understandable by humans. Process mining has primarily relied on existing hierarchical graph layout algorithms that do not take into account specific process properties, such as centralizing the most frequent path or the most performant path.

Recent efforts have emerged to address these issues in process maps, such as the Tracy algorithm by UIPath. Notably, there are currently no proposed layout algorithms specifically tailored for BPMN. In our bpmn-layout-generators library, we currently focus on experimenting and generating more comprehensible BPMN layouts. In the future, we will continue exploring opportunities to enhance the layouting of BPMN models, including considerations for process properties.

Conclusion & takeaways

Despite the current lack of native support for BPMN-based process mining, integrating BPMN with process mining techniques offers valuable insights that outweigh the discussed limitations.

BPMN, with its higher level of detail and formality, surpasses the limitations of process maps, which are commonly used by existing process mining tools for result visualization. At Process Analytics, we are dedicated to developing BPMN-based visualization libraries like bpmn-visualization and bpmn-layout-generators.

We envision a future, as hinted by Prof. Wil van der Aalst, where there will be a seamless transition from process maps to BPMN.

As this transition unfolds, we anticipate a growing demand for BPMN-based process mining tools capable of harnessing the full potential of this formalism, providing more accurate and comprehensive insights.

If you want to stay on top of the latest news and releases from the Process Analytics project, follow us through:

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: https://discord.com/invite/HafnBYsRXd
YouTube: Process Analytics YouTube channel

Useful resources

Official process mining website
Getting started tutorial to bpmn-visualization
Limitations of process maps from a practitioner’s perspective by Wil van der Aalst
More articles about BPMN process discovery and layout generation by Process Analytics project can be found on: (https://process-analytics.dev/model-generation-application/)

Process Analytics Monthly Report - April 2023

Thomas Bouffard — Tue, 09 May 2023 05:13:00 +0000

Process Analytics - April 2023 News

Welcome to the Process Analytics monthly news 👋.

In this edition, you'll find the details of the new bpmnVisualizationR package release and a refresh of the bpmn-visualization demo integrating with pm4py. 🤗 We're always looking for ways to improve your workflow, so read on for more details on these exciting developments!

bpmnVisualizationR package

In April, we released a new version: 0.4.0. This new version allows you to choose the style and position of the overlays.

In earlier versions, the style and the position of the overlays were not configurable.

Display overlays with default position and style

Now, it is possible to change the position and the style of the overlays, like in the following screenshot 👇:

Display overlays with a position and style change

Improvements in the bpmn-visualization pmp4py demo

Before pm4py 2.6.1, it was not possible to obtain statistics about the edges of the Petri net corresponding to the sequence flows of the BPMN diagram. This is a recurrent problem in the Process Mining community and a correction has been made in pm4py 2.6.1: pm4py/pm4py-core@84e85c6.

The demo has been updated to benefit from the fix and it is now able to display execution frequency on the sequence flows of the BPMN diagram 🥳.

Display execution frequency on sequence flows

That’s All Folks!

We hope you enjoyed this “edgy” April project news and are looking forward to what the rest of the spring will bring 👋.

In the meantime, stay on top of the latest news and releases by following us:

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: Join our server!
YouTube: Process Analytics YouTube channel

Cover photo by James Wheeler on Unsplash

Process Analytics - March 2023 News

Thomas Bouffard — Thu, 06 Apr 2023 09:09:00 +0000

Welcome to the Process Analytics monthly news 👋.

Greetings, fellow process enthusiasts 👋 As we welcome the first signs of spring, the Process Analytics team has been hard at work, bringing you some exciting updates for March. We recently took the stage at the Bonita Day Paris event, where we showcased our project to an enthusiastic audience. And that's not all! We've also been busy cooking up a new API that lets you style BPMN elements with just a few lines of code. We're always looking for ways to improve your workflow, so read on for more details on these exciting developments!

Highlights from our participation at Bonita Day

We recently had the pleasure of participating in Bonita Day Paris 2023, an event that brings together experts and enthusiasts in the field of business process management and automation. Not only did we get to showcase our latest project features and functionalities, but we also had the chance to network with other professionals in the industry and hear feedback from analysts and clients of Bonitasoft.

We introduced attendees to the exciting world of process mining, and explained our project, Process Analytics. To give attendees a deeper understanding of our project's capabilities, we demonstrated process monitoring in two scenarios: offline and online. Using bpmn-visualization, we showed how developers can use our libraries to create custom visualizations that fit their specific needs.

Overall, it was a great experience for us to connect with other experts in the field and demonstrate the unique benefits of the Process Analytics project.

Our demo at Bonita Day: a look inside

Our live demo at Bonita Day gave attendees a deep look into the capabilities of our project. We showed two process monitoring scenarios that demonstrated the various features of the bpmn-visualization TypeScript library, including applying CSS and overlays, registering interactions, and styling elements programmatically.

We demonstrated the interaction possibilities of the library that allows us to explore the different BPMN processes used in the demo and navigate to the sub-process, which was also part of the presentation.

In case monitoring, we demonstrated the ability to visualize the results of a mock recommendation system and take actions by interacting with the BPMN elements.

Our process monitoring scenario also showed the happy path animated on the BPMN process diagram.

For more details, check out the demo on GitHub.

The Process Analytics Project website

In February, we gave our website a fresh new look, and in March we focused on reworking the menu and improving the design for mobile users (see figure below). We're happy to announce that we have more improvements in the pipeline, so stay tuned for further updates in the coming months!

bpmn-visualization TypeScript library

In March, we released 2 versions: 0.32.0 & 0.33.0. The former includes several improvements, while the latter introduces the new update style API for programmatically styling BPMN elements.

Update style programmatically

Release 0.33.0 includes a new functionality that allows you to easily and programmatically style BPMN elements. Let's take a sneak peek at how to use this new feature with an example.

Let's say you want to monitor the progress of the execution of a BPMN process dynamically and progressively, like in the "Supplier Contact" process shown in our case-monitoring demo at Bonita Day.

With the update style API, you can achieve this easily by defining three states for the style - the activity currently under execution, the element that has just finished execution, and the elements that are already executed. To configure the style of the activity currently under execution, you can use the updateStyle method with the following parameters:

bpmnVisualization.bpmnElementsRegistry.updateStyle(activityId,
   {
      fill: {color: 'blue', opacity: 10},
      font: {opacity: 'default'},
      opacity: 'default',
      stroke: {color: 'blue', width: 3},
   });

For the element that has just finished execution, you can reduce its opacity using the updateStyle method like this:

bpmnVisualization.bpmnElementsRegistry.updateStyle(
  lastExecutedId, {opacity: 50});

Finally, for the elements that are already executed, you can further reduce their font and fill opacities using the updateStyle method with the following parameters:

bpmnVisualization.bpmnElementsRegistry.updateStyle(
  pastExecutedId,
  {
    font: {
      opacity: 15,
    },
    opacity: 20,
  });

In the coming weeks, we will provide several examples demonstrating the usage of this API in various use cases, and we also have plans for several improvements to be made on this API.

That’s All Folks!

That’s everything we were up to in March and we hope you found something in there to like. Stay tuned for more cool stuff coming up this spring 👋.

In the meantime, stay on top of the latest news and releases by following us:

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: Join our server!
YouTube: Process Analytics YouTube channel

Cover photo "Spring ball" by Hannah Jacobson on Unsplash

Process Analytics - February 2023 News

Nour Assy — Fri, 03 Mar 2023 06:15:00 +0000

Welcome to the Process Analytics monthly news 👋.

Hey there and welcome to our February monthly news! In this edition, you'll find exciting highlights from our latest release, including some new features and improvements to our bpmn-visualization TypeScript library. We've also got some news to share about upcoming events you won't want to miss. So sit back, relax 🎵, and enjoy reading through the February edition of our monthly news 📖.

Join us at Bonita Day 2023 in Paris

Save the date for Bonita Day 2023, Bonitasoft's annual event in Paris where you can discover all things BPM and get valuable feedback from our clients. This year, we'll be showcasing our "Process Analytics" project with a live demo. If you happen to be in or around Paris on March 30th, 2023, we invite you to join us for a day filled with informative sessions, expert speakers, and networking opportunities with industry professionals.

We can't wait to see you there! Register now!

If you don't want to miss events like this, please sign up for our newsletter, which is accessible from our website. Then you’ll always be informed!

Pitch at AI4BPM during AAAI 2023

We're happy to share that our project was recently pitched at the AI4BPM event, which was organized as part of the larger AI conference AAAI 2023. If you missed the event, you can still watch our video pitch. Check it out and let us know what you think!

This was a fantastic opportunity for us to showcase our project. We're grateful for the chance to participate in such a prestigious event!

Our website gets a fresh look

Our website has undergone a makeover! Overall, we find that the new design is clean and streamlined, with plenty of white space to make the content more readable. We're thrilled to share this new site with you and can't wait for you to see all the changes!

bpmnVisualizationR package

Our R package bpmnVisualizationR has been published on CRAN 🎉.

Publishing on CRAN means that the package is now available to a wider audience of R users, with increased visibility and accessibility. For more information on the package and how to use it, check out our documentation and examples.

We're always looking for ways to improve our package and make it more useful for our users. 🔌 If you have any feedback, suggestions, or feature requests for bpmnVisualizationR, we'd love to hear from you! You can reach out to us directly via our Discord channel.

bpmn-visualization TypeScript library

In February, we released 2 versions: 0.30.0 & 0.31.0.

Navigate BPMN diagrams with neighborhood information

We added a new feature that enables users to retrieve neighborhood information for BPMN elements.

The js-popover example has been updated to display this new information as shown below.

With this feature, users can easily navigate through the diagram and identify related elements, making it easier to analyze BPMN diagrams. This feature also allows for implementing advanced search functionalities.

Access to underlying mxGraph context

The library now provides access to the underlying mxGraph context. This functionality is intended for advanced users who want to customize and extend the library's functionality.

One example of where this feature comes in handy is our latest integration example with pm4py. In this example, we dynamically updated the style of BPMN elements based on data received from the backend processing by pm4py. You can see an excerpt in the gif below.

New demo for navigating a BPMN diagram

A new demo that illustrates how users can interact and navigate a BPMN diagram by highlighting two consecutive shapes is available. The demo video below shows how this feature works in action.

That’s all folks!

We hope you enjoyed this February project news and stay tuned for more updates and exciting developments in the coming months 👋!

In the meantime, stay on top of the latest news and releases by following us:

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: Join our server!
YouTube: Process Analytics YouTube channel

Cover photo by Ray Hennessy on Unsplash

Process Analytics - January 2023 News

Nour Assy — Thu, 02 Feb 2023 07:00:00 +0000

Welcome to the Process Analytics monthly news 👋.

It's a new year 🎊 and what better way to kick off 2023 than with some Process Analytics news! January brought us exciting developments in the world of bpmn-visualization and pm4py integration 🔗. With our team working hard to connect the dots, we’re making bpmn-visualization more accessible and easier to integrate with the Process Mining ecosystem.

Let's dive into the details and see what else this month has to offer 👀.

Integrating bpmn-visualization and pm4py

We released an integration example between bpmn-visualization and the state-of-the-art process mining library pm4py. This integration means you can perform process mining and visualize the results on BPMN models. You can watch the video showcasing the integration example on our youtube channel.

With this integration, the Process Analytics project empowers the community to take control of your process visualization and bring your process mining results to life with ease ✨. Additionally, the integration offers a way to gain a deeper understanding of the limitations and requirements when it comes to BPMN based process mining and visualization.

Bringing Process Analytics into the Classroom

Recently, Nour, our developer advocate, had the opportunity to bring process analytics into the classroom by presenting an introduction to process mining at Telecom SudParis 🎓. The lecture was followed by a hands-on session using bpmn-visualization and pm4py, so students got a practical understanding of the process mining and visualization tools.

This educational experience gave them an opportunity to learn about the usefulness of process mining and visualization and how it can be applied to real-world scenarios 💪.

bpmnVisualizationR Package

Versions 0.3.0 and 0.3.1 were released in January.

These new versions include documentation improvements to better meet CRAN's requirements.

Notice that the package has been renamed. Please check out the corresponding release notes to see what changes you need to make in your R project to use the updated package.

bpmn-visualization TypeScript library

In January, we released two maintenance versions of the bpmn-visualization TypeScript library: 0.29.1 and 0.29.2.

They mainly include documentation improvements.

That’s all folks!

We hope you enjoyed this January project news and are looking forward to the exciting developments and advancements that are coming in the next months. Stay tuned for more updates and insights from the process analytics project 👋.

In the meantime, stay on top of the latest news and releases by following us:

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: Join our server!
YouTube: Process Analytics YouTube channel

Cover photo by Tomáš Malík on Unsplash

Process Analytics - December 2022 News

Nour Assy — Thu, 29 Dec 2022 06:15:00 +0000

Welcome to the Process Analytics monthly news 👋.

December is here ❄️, bringing with it the holiday season 🥳 and the end of another year. As 2022 comes to a close, we would like to share some of the highlights and updates from this month. We hope you enjoy reading about what we did and stay tuned for more news in the coming year!

Roadmap 2023 🛣️

December was one of the busiest and most exciting times of the year as the Process Analytics team worked hard and proactively to prepare the roadmap for 2023 💪.

We carefully reviewed, and made sure to take into account, all the feedback that we collected throughout the year from our users - and from our participation in the ICPM conference. Abstraction layers, interaction APIs, and much more is on the list ✨.

Your Feedback Matters: Share Your Thoughts with Us

We want to hear from you! In May 2023, we will be reaching out to the community for feedback and suggestions to incorporate into the second half of the roadmap.

Do you have ideas for features you would like to see in our libraries? We welcome your input and encourage you to contact us through one of the communication channels listed at the end of this report 👇. Your feedback is valuable to us and we are committed to considering and implementing your suggestions.

ICPM demo on Youtube

In case you missed our demo at the ICPM conference, we released a video on the Process Analytics YouTube channel showcasing our bpmn-visualization TypeScript library in action. Be sure to check it out for a sneak peek of all the exciting features and capabilities the library has to offer.

If you enjoyed our demo video and want to stay up to date with all our latest content and updates, be sure to subscribe to our YouTube channel! Just click the "Subscribe" button on our channel page to start receiving notifications whenever we post new content. Thank you for your support 😍!

bpmn-visualization TypeScript library

In December, we released the 0.29.0 version. We are pleased to announce that we added support for the BPMN complex gateway.

The complex gateway is a type of gateway that allows users to make decisions based on multiple variables and can be used to create more sophisticated process models.

According to the BPMN 2.0 specification, it is represented by a diamond-shaped symbol with an asterisk. It is activated when all incoming sequences are completed, and then evaluates the conditions associated with each outgoing sequence to determine which one to follow next. This allows users to design process flows that can adapt to different situations and make decisions based on multiple factors.

That’s all folks!

We hope you enjoyed this December project news. We will now take some time to rest and recharge over the holiday season, so that we can start the new year refreshed and ready to tackle all the exciting projects and initiatives that we have planned 🤞. We wish you a joyful holiday season and look forward to seeing you in 2023 👋.

In the meantime, stay on top of the latest news and releases by following us through one or more of the channels below, and please send us your ideas for our development roadmap through your favorite medium!

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: Join our server!

Cover photo by Aaron Burden on Unsplash

Process Analytics - November 2022 News

Nour Assy — Mon, 05 Dec 2022 08:12:42 +0000

Welcome to the Process Analytics monthly news 👋.

One month before the end of 2022, what a great year ✨. November flew by so quickly while the Process Analytics team was very busy preparing the 2023 roadmap 🤩. But before the holiday season, we made sure to release great content, most notably an article about our conversation with Prof. Wil van der Aalst on the current state and the future of Process Mining. We are also very happy to announce that our bpmn-visualization R package is alive! Check out the details 👇.

Promotion

ICPM: Interview with Professor Wil van der Aalst

Last month, we were on stage presenting a live demo at the International Conference on Process Mining (ICPM) 2022. Our team’s developer advocate, Nour, had the chance to meet and discuss with Professor Wil van der Aalst, one of the most cited computer scientists in the world, known for his work on Process Mining.

Nour asked Wil questions about the definition of process mining, its current state, its adoption by the industry and what the future holds. We wrote an article summarizing this discussion and highlighting some important takeaways 💡. Check out the details 👉 here.

Hacktoberfest: Results & Recap

Now that Hacktoberfest has become an official Process Analytics tradition 💪, we’ve written an article highlighting the contributions and lessons learned as maintainers 👷‍♂️.

We would like to warmly thank our contributors and all the people who contacted us via our Discord channel to express their enthusiasm about the project and their willingness to make their first open source contributions 💖. It’s just fantastic and rewarding for us as maintainers 🌟!

Hope to see you all again at Hacktoberfest 2023!

bpmn-visualization JS/TS library

In November, we released 2 versions: 0.28.1 and 0.28.2. They provide internal improvements.

In addition to these 2 new releases, we introduced a new example showing how to integrate bpmn-visualization in Angular applications. We thank @akantcheff for this contribution done during Hacktoberfest 👇.

bpmn-visualization R library

In November, we released 2 versions: 0.2.1 and 0.2.2.

The new versions make improvements to the documentation, mainly to correct the comments associated with the recent attempts to submit to CRAN. We are waiting for feedback from the CRAN maintainers and we hope the package will be soon available on CRAN.

🎥 The HTML documentation is now available on GitHub Pages: https://process-analytics.github.io/bpmn-visualization-R/

It provides all the information you need to install and use the package, and some live examples - like the following 👇

That’s all folks!

We hope you enjoyed this November project news and are looking forward to what the end of 2022 will bring** **👋.

In the meantime, stay on top of the latest news and releases by following us:

Website: https://process-analytics.dev
Twitter: @ProcessAnalyti1
GitHub: https://github.com/process-analytics
Discord: Join our server!

Cover photo by Priscilla Du Preez on Unsplash

Interview with Professor Wil van der Aalst at ICPM 2022

Nour Assy — Mon, 28 Nov 2022 10:02:33 +0000

This past October, Nour Assy, the Process Analytics team’s developer advocate, attended the International Conference on Process Mining (ICPM). ICPM is an important forum for researchers, practitioners and developers in the field of Process Mining. During the week-long conference, knowledge and recent trends in this field are shared and exchanged through scientific talks, industry discussions and technical panels.

Nour had the lucky opportunity to talk with professor Wil van der Aalst, one of the most cited computer scientists in the world, known for his work on process mining. Prof.dr.ir. van der Aalst is an Alexander-von-Humboldt professor at RWTH Aachen, heading the Process and Data Science Group (PADS) and is the Chief Scientist of Celonis.

Here we are happy to share a synthesis of their conversation about the scope of Process Mining, research advances in the field, industry adoption, and what the future holds.

Nour: Process mining, process analytics, process intelligence, and other terms are being interchangeably used. Do you see a difference in terms of scope and techniques?

Wil: Process Mining is a broad concept that ranges from data extraction and preparation to discovery, compliance and conformance checking, predictions and improvements. It is important to note that Process Mining should not be reduced to process discovery as some think. Looking at the ICPM conference topics, it is clear that Process Mining is not just about process discovery. The use of other terms is often associated with commercial reasons. So I think it would be very helpful if everyone would stick to the term Process Mining.

In the coming years, Object-Centric Process Mining will be the topic that's going to get a lot of attention. All the vendors are going to be moving in that direction.

Nour: We are seeing a wave of Process Mining adoption in industry, and many R&D initiatives to put research ideas into practice. How do you see the current state of Process Mining in industry compared to advances in research?

Wil: Process Mining has a longer history of research and it has applications. The first tools appeared 15 years ago, but they were not very successful at doing very basic things. Right now, there are about 40 tools. I think the development of tools has accelerated in the last few years and what's really accelerating now is the adoption in the industry. For example, Process Mining has become the normal thing to do in northern European countries. Right now, the industry is catching up, but I would say we are just at the beginning.

The transition between the basic process map view and BPMN will become more fluid. The separation that currently exists is not necessary.

The boundary between user-driven modeling and data-driven process discovery will become more fluid by following a “human in the loop” approach.

Nour: If we compare research results to commercial tools, it looks like the latter wins in terms of visualization. How do you see the future of visualization in Process Mining?

Wil: I'm not sure I agree with that statement. I think commercial tools typically have a much better usability, but they offer much more limited functionality. I think this is a big difference. In terms of visualization, I expect that process models will continue to play an important role in any type of visualization, as for example when we talk about visualizing compliance and performance data. Most importantly is that the boundary between the basic visualization of Directly-Follows Graphs (DFG) (known as process maps) and BPMN will become more fluid and I think it will become easier to switch between DFG and BPMN views. Another dimension that we will witness is that the boundary between modeling and discovery, by putting “humans in the loop”, will become fluid. In the research domain, there are many prototypes of interactive process discovery in which domain knowledge can be combined with available data, demonstrating that this boundary can become fluid.

Nour: The BPMN 2.0 has become mainstream in the BPM market but it is still not that popular in the Process Mining market. Do you think there is an opportunity for a bigger adoption of BPMN in Process Mining?

Wil: The higher end tools already offer a BPMN view of the data. But as I mentioned, it is typical that the default view is a DFG, and the BPMN view is a more advanced view. So I think in the future, any Process Mining tool will support BPMN and the boundary between the two views will be more fluid. For process discovery, people usually use DFGs, while for conformance checking, they use BPMN models. You can also do conformance checking using a DFG model, and you can also discover BPMN models. That separation is not necessary. This is why I say it should become more fluid. Of course, when we talk about BPMN, we need to make it clear that if we discover things only based on the data, we are talking about a limited subset of BPMN. For example, it is possible to discover AND and XOR gateways, resources, etc., but BPMN is a rich language with many different constructs that cannot be derived from the data at this stage.

We will move from fixed and hard-coded visualization to intelligent interactive visualization. If we see bottlenecks, we will be able to click and get visualizations that explain these bottlenecks.

Nour: In the Process Mining Manifesto, there is a clear desire to combine Process Mining with Visual Analytics. Do you think we are there yet? And what challenges do you foresee in putting this idea into practice?

Wil: There are currently a few nice examples. The dotted chart is a very nice visualization which clearly complements process models. In the future, intelligent interactivity will play an important role. For example, currently, filtering based on case activity attributes is done by providing a query, pressing buttons or exploring a hard-coded dashboard. I expect this to become more fluid. For example, users will be able to click on bottlenecks and have visualizations that explain these bottlenecks. We don't see those capabilities right now, but it's clear that with smart visualization, you could do simple things like bar charts, but also dotted charts and other advanced visual components.

Nour: Currently, we discover and use 2D process models. Are we going to move on to 3D models?

Wil: This reminded me of the time when I used to visit Australia. We have developed a ProM plugin that allows us to visualize a process in 3D and walk through it in virtual reality. I think 3D visualizations are nice and get people's attention, but adding a third dimension can quickly become limiting and we should be careful about that.

Nour: In addition to the obvious use cases in BPM and Process Mining technologies, there are many other situations where process-related execution data needs to be visualized (RPA, BI, test automation, CI/CD pipelines). Do you think Process Mining technologies will start to offer these capabilities as part of their solutions?

Wil: Let's take the example of RPA and Process Mining. There is a clear relationship. The RPA part generates the events based on screen scraping or whatever is used. So the RPA will provide event data. Then for a Process Mining tool, this is not new. I think it's also true for many other application areas. The requirements for Process Mining are not so different. That's why we see increasingly that, for example, Process Mining is used in production. Previously, it was mainly financial and administrative processes. For Process Mining, I think the challenges are more on the data preparation side. For example, how do you convert sensor data into event data? But I would consider that this is actually something that is outside of what you would expect from a normal Process Mining tool.

Nour: In the opening session of ICPM 2022, we saw words like “prediction” and “alignment” in the top topics of the word cloud of ICPM 2022. What words or topics do you think will appear in the word cloud of ICPM 2030?

Wil: That is difficult. But in the coming years, the topic that's going to get a lot of attention is Object-Centric Process Mining. I think there is a lot of research going on in this area and all the vendors are going to be moving in that direction. If you think a bit further, it is not so clear what it would be. What I find fascinating is that even though we have good techniques for process discovery, compliance checking, prediction, etc. some of which work in practice, however, it's clear that these problems are not solved. So I predict that in 2030 we will still be talking about process discovery techniques, because it is a very difficult problem that requires years of follow-up.