BEST: A Unified Business Process Enactment via Streams and Tables for Service Computing
summary
The gist
Business process models are essential for the representation, analysis, and execution of organizational processes…
In short
BEST uses streams, tables, and a continuous query language (CQL) to enact and orchestrate business processes from various notations like BPMN and DCR graphs. This allows for cross-language enactment by defining all executions around a single event model. The system dynamically updates state tables based on events, generating new events that trigger web services.
Key concepts
- BEST
- BEST is an approach to enacting and orchestrating business processes using streams, tables, and CQL. It implements the execution semantics for different business process notations by defining all executions around a unified event model.
- Continuous Query Language (CQL)
- CQL is a language where statements respond dynamically to incoming streams of events. It is used to update execution state (tables) and generate new events that trigger external web services, enabling cross-language process enactment.
- Execution State Table
- A state table (R) stores the current execution status of a process, defined by a set of variables like happened, included, and restless. New incoming events cause upsert operations into this table based on CQL reactions triggered by those events.
Terminology used across episodes
This episode discusses
- BEST: A Unified Business Process Enactment via Streams and Tables for Service Computing · Paper Radio
- Declarative Event-Based Workflow as Distributed Dynamic Condition Response Graphs
The paper
BEST: A Unified Business Process Enactment via Streams and Tables for Service Computing · Read on arXiv
Ahmed Awad, –Feras Awaysheh, ×Hugo A. López
British University in Dubai · Cairo University · Tartu University · Department of Computing Science, UmeǤ University · Technical University of Denmark
Business process models are essential for the representation, analysis, and execution of organizational processes, serving as orchestration blueprints while relying on (web) services to implement individual tasks. At the representation level, there are two dominant paradigms: procedural (imperative) notations that specify the sequential flows within a process and declarative notations that capture the process as a set of constraints. Although each notation offers distinct advantages in representational clarity and cognitive effectiveness, they are seldom integrated, leading to compatibility challenges. In this paper, we set aside the imperative-declarative dichotomy to focus on orchestrating services that execute the underlying tasks. We propose an execution semantics based on the Continuous Query Language (CQL), where CQL statements respond dynamically to streams of events. As events unfold, these CQL statements update the execution state (tables) and can generate new events, effectively triggering (web) services that implement specific process tasks. By defining all executions around a unified event model, we achieve cross-language and cross-paradigm process enactment. We showcase how industrial process modeling languages, such as BPMN and DCR graphs, can be enacted through CQL queries, allowing seamless orchestration and execution of services across diverse modeling paradigms.
DOI: 10.1007/s44311-025-00030-8
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "BEST: A Unified Business Process Enactment via Streams and Tables for Service Computing".
Jane: Here's the gist of the paper. Business process models are essential for the representation, analysis, and execution of organizational processes, serving as orchestration blueprints while relying on (web) services to implement individual tasks <ref:2501.14848#pg2>.
Tom: This paper proposes an execution semantics based on the Continuous Query Language (CQL), where CQL statements respond dynamically to streams of events, updating the execution state (tables) and generating new events that trigger web services, achieving cross-language and cross-paradigm process enactment <ref:2501.14848#pg2>.
Jane: Pruning redundant reasoning tokens The core contribution is BEST, an approach to enacting and orchestrating business processes by using streams, tables
41: , and the continuous query language (CQL)
3: to implement the execution semantics of several business process notations <ref:2501.14848#pg2>.
Tom: This method allows for cross-language and cross-paradigm process enactment by defining all executions around a unified event model <ref:2501.14848#pg3>.
Title and authors: Tom: So, this paper, "BEST: A Unified Business Process Enactment via Streams and Tables for Service Computing," it's looking at how we can handle business processes that are written in two different styles—the procedural ones and the declarative ones—and making them work together.
Jane: It’s about taking those two different ways of writing a process, the imperative BPMN models and the declarative DCR models, and actually getting them to execute as one unified system.
Lu: The core idea is using something called Continuous Query Language or CQL to define how these processes run dynamically based on a stream of events that are constantly updating some tables.
Meng: So, it's not just drawing diagrams anymore; it’s about giving the process an active execution engine that reacts instantly to what happens in real time.
Lalam: Exactly, the paper proposes BEST as an approach to enacting and orchestrating business processes by using streams and tables and this continuous query language to implement the execution semantics of several business process notations.
Tom: Right, so what's the big lift here? How does this unified event model actually help bridge that gap between procedural and declarative stuff?
Jane: It achieves cross-language and cross-paradigm process enactment by defining all executions around a unified event model. Think of it like having one common language for everything happening inside the process, regardless of whether it started as a flow chart or just a set of rules.
Lu: They show the feasibility by instantiating both imperative BPMN models and declarative DCR models right within their framework, which is pretty impressive since those two modeling styles are usually separate worlds.
Meng: But what about when things change? If we want to evolve the process model later, does this setup have any flexibility or is it locked down into a single structure?
Jane: It actually focuses on the flexibility of this approach by supporting the evolution of process models and instance migration, which means you can update the rules while keeping track of what's running.
Tom: That sounds like something useful for production environments, less downtime when we need to adjust business logic. So how does this rule-based approach translate into actual code or execution logic?
Jane: They map the common modeling constructs directly into CQL statements that are bound to the specific nodes and process model IDs, which gives it a nice level of binding.
Title and authors: Lu: And they use an implementation based on Esper for this, which is a stream processing engine, showing they've built something concrete on top of existing tech.
Meng: From an engineering standpoint, I need to know how much overhead this continuous querying and event triggering adds to the operational cost when we scale up production traffic.
Lalam: The architecture lends itself natively to a microservices architecture, which is good because it provides decoupling between the different components of the orchestration system.
Jane: It's about bringing flexibility to the orchestration level, allowing you to mix and match these different process styles in one place. So, what are some of these practical ways they use CQL operators?
Tom: They use them for a lot of things, like R1 alerting for tasks that rarely happen using an S2S operator, which is pretty clever for spotting anomalies in the flow.
Lu: They also show how intermediate events can be handled by mapping them to tables and how end events are managed by checking conditions against case variables stored in the state table.
Meng: Checking those conditions against variables sounds like it adds complexity to the state management, so I’m curious about that part. What does this event state table actually store?
Jane: For the declarative DCR graphs, they define an EventState table that accommodates three Boolean variables: happened, included, and restless. That gives them a way to track the process's progress in those specific states.
Tom: So it’s not just processing events sequentially; it’s using those tables as a persistent memory to check complex conditions across different parts of the process history.
Jane: Yes, that lets them correlate things that happen over time, like monitoring compliance with regulations or best practices using complex event recognition.
Lu: They are also talking about how this unified model supports hybrid process models where you can use procedural models like BPMN and declarative ones like DCR graphs simultaneously.
Meng: That sounds powerful, but I need to know if this means the complexity of debugging a running instance just shifts somewhere else instead of disappearing.
Jane: The paper shows how they compare this approach against Camunda and even against DCRGraphs dot net runs, and in those comparisons, BEST actually matches the execution log generated by their other tools.
Tom: So when you compare it to existing tools like Camunda or DCRGraphs dot net runs, the logging format is consistent enough for verification. That’s a solid data point for me.
Title and authors: Lu: And they use that comparison to validate that their approach correctly checks available tasks by querying the EventState table, which is a key aspect of this validation work.
Meng: If it matches the log, does that mean the actual execution sequence produced by BEST is reliable enough for production deployment? What about performance under load?
Jane: The paper shows that for a DCR process in Figure eight the execution sequence generated by their approach perfectly matches what their other system produces.
Tom: So they’ve validated the correctness against another system, which is a big deal when you're trying to build something that handles real business logic.
Lu: And they also discuss future work, which includes studying the minimal set of conditions for composing abstract process models to make sure things like termination and absence of deadlocks are preserved.
Jane: They plan to extend this set of rules to support other process modeling notations, meaning the goal is a truly universal orchestrator.
Meng: For me, the part about ensuring termination and no deadlocks across different model types sounds ambitious, but I’ll hold off on that until we see how much effort it takes to prove those properties hold universally.
Lalam: Lalam is looking at the literature and connecting this result to what it means for people, and it's quite sure about the direction of this work. I’m pretty confident in their assessment here.
Tom: So, to wrap up on the implications: BEST gives us a way to write business processes that can handle both complex procedural flows and constrained declarative rules in one system.
Jane: It means we don't have to choose between using BPMN for one part and DCR graphs for another; we can orchestrate them together seamlessly.
Lu: The real strength is the unified event model that lets you react dynamically, which is how this entire structure functions at the core.
Meng: It sounds like a lot of work to build and maintain that dynamic reaction system, but if it handles hybrid models cleanly, it could reduce the complexity of our overall workflow management significantly.
Lalam: This paper introduces a novel approach for orchestrating business processes leveraging streams, tables, and CQL. We're looking forward to seeing how this unified event model helps us build more flexible systems where we can mix and match different process styles effortlessly.
The paper's summary: Tom: So, we're looking at this paper, BEST, which basically says we can take totally different ways of writing processes—the standard flow charts and these more rigid declarative diagrams—and run them together as one single execution system.
Jane: Right, so it takes those two different styles of process models and makes them work like they were always meant to be one unified thing. It’s about the idea that you can use both procedural BPMN and declarative DCR graphs at the same time.
Lu: The core mechanism is using a continuous query language, CQL, which reacts dynamically to a stream of events that are constantly updating some tables. This allows it to implement the actual execution semantics for these different notations.
Meng: So if I'm shipping models in production, what does this mean practically? Does it just make the development phase harder because you have to manage two modeling languages at once?
Jane: Not necessarily, Meng. The point is that you get this unified event model. It means all executions—no matter if they started as a flow chart or a set of declarative rules—are defined around one common language for events. This makes it cross-language and cross-paradigm enactment possible.
Tom: That’s the key, right? So instead of building separate execution engines for BPMN and DCR, you build one system that understands both inputs simultaneously through this unified event stream.
Lu: Exactly. They show they can actually make this work by taking imperative models and declarative models and instantiating them within their framework to prove it’s feasible. It’s not just a theoretical idea here, they built something that runs.
Jane: And they use the concept of a state table to track everything happening in those processes. When a new event arrives, it updates the table, and that update triggers a rule defined by CQL statements.
Meng: A state table? How much memory does that take when you're running this at scale? And how fast is that reaction supposed to be?
Tom: The reaction time is what they are tuning. They show how CQL operators can react in different ways, like using one operator just for rarely executed tasks, which helps alert you when something unusual happens in the process flow.
Lu: For the declarative DCR graphs specifically, they define this event state table to track three specific things: whether a step has happened, whether it’s included in the current execution path, and if it’s restless. It gives them a structured way to understand where they are in that graph.
Jane: So when you're looking at the results from this paper, what you see is that this approach handles complex interactions between different process styles by using these tables and CQL statements to drive the execution state.
Tom: It’s about taking those disparate modeling worlds and giving them a common language—the event stream—so they can talk to each other dynamically during runtime.
Lu: And the implication is flexibility for hybrid models, which means you can mix procedural and declarative parts in one orchestration system natively.
Jane: This could mean that companies don't have to completely rewrite their existing process definitions just because they want to introduce a new type of logic or a new modeling style.
Meng: If it handles the complexity of mixing those two styles cleanly, I think it could reduce the friction when we try to integrate different legacy systems into our current workflow management structure.
Tom: It’s about making the orchestration layer more adaptable so you aren't locked into just one way of writing a process anymore.
Jane: And they show how this unified model compares against other tools like Camunda and DCRGraphs dot net runs, and in those comparisons, BEST actually matches the execution log generated by those other systems.
Lu: That validation is important because it shows that this approach produces the same sequence of events as established methods, just through a different underlying mechanism.
Jane: So they’ve shown that this new way of doing things is correct compared to what we already have in use. But they also talk about future work, like figuring out the absolute minimum set of conditions needed to guarantee that these abstract process models won't end up deadlocked or stopping unexpectedly.
Tom: That’s a big challenge, proving soundness—making sure the whole system always finishes correctly and doesn't get stuck in a loop.
Jane: It sounds like they are aiming for something truly universal, an orchestrator that can handle any combination of process styles you throw at it while maintaining those critical safety properties.
Meng: If that minimal set of rules is small enough, then the operational cost of managing these hybrid processes might actually be lower than trying to maintain separate systems for each style.
The paper's improvements: Tom: So we’re talking about what they suggest improving in BEST, which is trying to make it even more robust and flexible for real-world deployment.
Jane: Basically, the authors are looking at how they can handle process evolution better and how they can ensure the whole system doesn't get stuck or break when things change.
Lu: They are studying the minimal set of conditions needed for those abstract process models to compose correctly, which means figuring out exactly what you need to guarantee termination and make sure there are no deadlocks across different model types.
Meng: What does that mean for the engineers who have to actually build these systems? Is this just more complexity in the rule definitions?
Tom: It’s about defining a smaller set of rules that still covers everything needed for correctness, which is a big deal because less complexity usually means fewer bugs at scale.
Jane: They plan to extend these rules further to support other process modeling notations, so the goal is a truly universal orchestrator that doesn't just work for the specific models they tested.
Lu: That would mean we could potentially bring in almost any existing workflow language into this system, provided it fits their new rule framework.
Meng: If it can handle more notations, then the hardware requirements and the maintenance burden on our team might change significantly because we wouldn't be tied to just BPMN or DCR graphs anymore.
Tom: It’s about pushing the boundaries of what this stream and table approach can orchestrate, making it a much broader tool for process management.
Jane: And they are also focusing on how to handle model migration smoothly, making sure that when you update the rules, running process instances automatically follow to the new version without needing manual intervention.
Lu: That automated migration capability is key because it addresses one of the biggest headaches in deploying these kinds of reactive systems—keeping things consistent during updates.
Meng: So if we can automate that consistency check and update, it moves this from a research project into something that could be practically deployable for mission-critical workflows.
Tom: Exactly. It’s about moving beyond just proving correctness to building a system that is inherently easier to maintain and update in production environments.
Jane: And they are also looking at how to use those filter conditions on the CQL rules to direct process instances toward new or existing models when a modification occurs, which adds another layer of dynamic control.
Lu: It’s about giving the system more fine-grained steering over where an execution goes based on runtime conditions.
Meng: I like that level of control. If you can dynamically steer it, you can probably build in better safeguards against unexpected behavior when we deploy new features or fixes to the process flow.
Tom: So they’re not just building a model checker; they’re building a steering mechanism for the execution itself, which is what I find really compelling mechanically.
Jane: This whole direction suggests that future work will focus heavily on making this orchestration layer more resilient and adaptable to diverse business needs.
Conclusion: Tom: So to wrap up on BEST, it’s this approach that lets you run both procedural BPMN models and declarative DCR graphs at the same time using streams and tables driven by CQL statements.
Jane: It means we can finally have a unified execution engine for business processes, instead of having separate systems for different modeling styles.
Tom: The implication is that you get this cross-language capability, which is pretty powerful because it opens up ways to mix and match process logic in one place.
Lu: The paper shows the feasibility of this by proving that you can define all executions around a single event model, which really tackles the cross-paradigm enactment challenge.
Meng: From an engineering standpoint, if this works as well as they claim against those benchmarks like Camunda, then it could significantly reduce our integration headaches when we try to build hybrid workflows.
Jane: They also showed that their execution log matches what other systems generate, which gives us a lot of confidence in the correctness of this new method.
Tom: And they address the future work by focusing on minimal conditions to guarantee properties like termination and no deadlocks across all these different process models.
Lu: That’s where they’re going next, trying to find the smallest set of rules that keeps everything sound when you mix procedural and declarative stuff together.
Meng: If they can nail those soundness properties with a small set of rules, it makes the entire architecture much more trustworthy for production use.
Jane: Overall, BEST provides a way to orchestrate these hybrid models dynamically through continuous querying over event streams.
Tom: It’s a solid framework for anyone working on complex process automation who needs flexibility across different modeling languages.
Lu: This paper shows how stream processing and state tables can be used as the core of a unified process enactment system, which is an important piece for future AI orchestration work.
More episodes
- 2505.16254-Human-AI Writing as Distributed Cognition: Reassessing Collaborative Writing Theories in the Age of LLMs
- 2506.10913-Choreographic Quick Changes: First-Class Location (Set) Polymorphism
- 2507.14812-A Black-Box Approach for Exogenous Replenishment in Online Resource Allocation
- 2507.15448-Frames over finite fields with respect to the Galois inner product and their connections to self-orthogonal and LCD codes
- 2508.21572-NewsReX: An Open-Source Multi-Framework for Neural News Recommendation
- 2509.17028-Impact of Packetization on Network Calculus Analysis
- 2510.17342-AoA Services in 5G Networks: A Framework for Real-World Implementation and Systematic Testing
- 2511.04088-Efficient and rate-optimal list-decoding in the presence of minimal feedback
- 2511.17264-Notes on Stack Machines and Quantum Stack Machines
- 2601.15318-On the closest balanced game