BEST: A Unified Business Process Enactment via Streams and Tables for Service Computing
Listen
Radio episode about this paper
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.
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
cs.SE
Submitted: 2025-01-24
Updated: 2025-01-24
DOI: 10.1007/s44311-025-00030-8
Code: https://github.com/AhmedAwad/Flexible-Process-Enactment-CEP
License: http://creativecommons.org/licenses/by-nc-nd/4.0/
Importance score: 86/100
The gist: Business process models are essential for the representation, analysis, and execution of organizational processes…
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
Summary
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. p. 0 Lyngby, Denmark Email: hulo@dtu. dk
Abstract—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. 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.Where the paper says it
Where the paper says it
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>. This method allows for cross-language and cross-paradigm process enactment by defining all executions around a unified event model <ref:2501. p. 0 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. Moreover, as we adopt the streams and
tables abstraction, we are able to enact hybrid process models
and service compositions. This paper will show the feasibility of our approach by
instantiating both imperative BPMN models and declarative
DCR models in our framework.Where the paper says it
Where the paper says it
How the training signal is built
The execution infrastructure is built around event streams and state tables, where raw execution events are tuples like re = ⟨model, case, node, state, payload, executor, ts⟩ <ref:2501.14848#pg4>. A state table R is defined as R ⊆ M×C×N ×Lc×T whose primary key PK ⊆ M × C × N <ref:2501. p. 2 Definition 7 ((State) Table): Let S be an event stream, let T be the
set of timestamps, and Lc = {started, completed, skipped} a set of
lifecycle states. A state table R is defined as R ⊆ M×C×N ×Lc×T
whose primary key PK ⊆ M × C × N , where M is the universe
of process models, C is the universe of case identifiers, and N is the
universe of nodes identifiers within process models. As stated in Definition 7, the update or insert (upsert) operation
on the table is a reaction to the arrival of new events on the stream. The reaction is defined as a CQL statement that is triggered by theWhere the paper says it
Where the paper says it
Where the gains come from
The paper details how CQL operators can react to events in several ways, such as R1 alerting for rarely executed tasks using an S2S operator <ref:2501.14848#pg4>. It shows how intermediate events can be handled by mapping them to tables, and how end events are handled by checking conditions against case variables in the state table <ref:2501. p. 4 Handling a start event
Intermediate events can be handled as we handle tasks (the next
section). 6 handles end events. We show how
CQL and tables can be used to orchestrate (execute) DCR graphs’
processes. Following Definition 4, each event state can be described
by three Boolean variables to indicate whether the event has happened
(h), is restless (r), i.Where the paper says it
Where the paper says it
Flexibility in service-oriented architecture by bringing flexibility to the orchestration level
The approach enables enacting hybrid process models by using procedural models like BPMN and declarative models like DCR graphs simultaneously <ref:2501.14848#pg10>. This is achieved by mapping execution semantics of language constructs into CQL statements, which are bound to nodes by their IDs and process model ID <ref:2501. p. 3 The generator
instantiates predefined CQL templates for the modeling constructs
of the respective process modeling language (Definition 1). The
generated CQL rules (statements) are bound to the nodes of the
model by their IDs and the respective process model ID. The engine updates the state table and generates more events
that can be consumed internally or thrown to the event cloud so that
external agents interested in the event can consume it, do their logic,
and then generate other events. The architecture lends itself natively
to a microservices architecture, which provides the most decoupling
between the components.Where the paper says it
Where the paper says it
Comparing with Camunda
The implementation validates the approach by comparing execution sequences of BPMN processes against those deployed on Camunda <ref:2501.14848#pg13>. The paper shows that the freemium subscription level with Camunda does not allow extraction of the execution log, whereas BEST extracts events in a format following Definition 5 <ref:2501.14848#pg13>. The hybrid model execution is compared against DCRGraphs. p. 8 Then, we develop
a procedural BPMN process, a declarative DCR process, and a hybrid
model combining imperative and declarative aspects, and show how
they can be mapped to CQL and their execution semantics. Moreover,
we compare the execution of our BPMN and DCR processes to
those deployed on Camunda and DCRGraphs, respectively, to show
that we can reach similar execution sequences. org/
4https://www. net/
5https://www.Where the paper says it
Where the paper says it
Comparing with DCRGraphs. p. 8 Then, we develop
a procedural BPMN process, a declarative DCR process, and a hybrid
model combining imperative and declarative aspects, and show how
they can be mapped to CQL and their execution semantics. Moreover,
we compare the execution of our BPMN and DCR processes to
those deployed on Camunda and DCRGraphs, respectively, to show
that we can reach similar execution sequences.Where the paper says it
The comparison shows that the execution log generated by BEST matches the log generated by DCRGraphs.net for a process in Figure 8. p. 0 org/
4https://www. net/
5https://www. 8
1 create table EventState (ProcessModelID long primary key,
caseID long primary key, eventID string primary key,
happened boolean, included boolean, restless boolean, ts
Timestamp);
Listing 11. DCR Event State table
The EventState is populated with records for each event in the
DCR graph model. Clearing the ending
case events from the memory does not necessarily mean losing the
execution footprint. A logging agent (Figure 2) can listen to the
generated events on the P rocess_Event stream and save a copy
of these events to a log.Where the paper says it
Where the paper says it
Where the paper says it
Conclusion and future work
The paper introduces a novel approach for orchestrating business processes leveraging streams, tables, and CQL <ref:2501.14848#pg10>. Future work includes studying the minimal set of conditions for the composition of abstract process models to preserve soundness properties like termination and absence of deadlocks <ref:2501.14848#pg10>. The plan is to extend the set of rules to support other process modeling notations for hybrid notations <ref:2501. p. 0 Other declarative notations, for example, Declare [37], can be defined and executed via encodings
to Coloured Petri Nets 5
. As these engines vary in their
support for the execution semantics of the different modeling
constructs [20], migrating running instances to a changed
process model or deploying newer versions of the orchestrator
has considerable technical debt.Where the paper says it
References
[1] M. Adams, A.V. Hense, and A.H.M. ter Hofstede <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[2] Anti Alman, Fabrizio Maria Maggi, Marco Montali, Fabio Patrizi, and Andrey Rivkin <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[3] Arvind Arasu, Shivnath Babu, and Jennifer Widom <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[4] Arvind Arasu, Shivnath Babu, and Jennifer Widom <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[5] Alexander Artikis, Alessandro Margara, Martín Ugarte, Stijn Vansummeren, and Matthias Weidlich <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[6] Ahmed Awad, Ahmed Barnawi, Amal Elgammal, Radwa El Shawi, Abduallah Almalaise, and Sherif Sakr <ref:2501. p. 0 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed.Where the paper says it
[7] Ahmed Awad and Sherif Sakr <ref:2501. p. 0 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed.Where the paper says it
[8] Ahmed Awad, Riccardo Tommasini, Samuele Langhi, Mahmoud Kamel, Emanuele Della Valle, and Sherif Sakr <ref:2501. p. 0 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed.Where the paper says it
[9] Stephan Buchwald, Thomas Bauer, and Manfred Reichert <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[10] Josep Carmona, Boudewijn F. van Dongen, Andreas Solti, and Matthias Weidlich <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[11] Flavio Corradini, Andrea Polini, Barbara Re, and Francesco Tiezzi <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[12] Peter Dadam and Manfred Reichert <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[13] Søren Debois, Thomas T Hildebrandt, Morten Marquard, and Tijs Slaats <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[14] Søren Debois, Hugo A. p. 0 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed. 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed. net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
Where the paper says it
Where the paper says it
[15] Remco M. Dijkman, Marlon Dumas, and Chun Ouyang <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[16] Ting Ding, Yantai Gao, and Yinglong Ma <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[17] Dirk Fahland, Daniel Lübke, Jan Mendling, Hajo A. p. 0 14848v1 [cs. SE] 24 Jan 2025 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
Where the paper says it
[18] Dirk Fahland and Others <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[19] Dirk Fahland and Hagen Völzer <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[20] M. Geiger, S. Harrer, J. Lenhard, and G. Wirtz <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[21] Beat Gfeller, Hagen Völzer, and Gunnar Wilmsmann <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[22] Nikos Giatrakos, Elias Alevizos, Alexander Artikis, Antonios Deligiannakis, and Minos N. Garofalakis <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[23] Pieter Van Gorp and Remco M. Dijkman <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[24] Daniel Grathwol, Han van der Aa, and Hugo A. p. 0 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed. 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed. 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed.Where the paper says it
Where the paper says it
Where the paper says it
[25] Heerko Groefsema and Doina Bucur <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[26] K. Grunert, J.J. Shoferi, K. Rohwer, E. Pankovska, and L. Gold <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[27] Iman M. A. Helal and Ahmed Awad <ref:2501. p. 0 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed.Where the paper says it
[28] Simon V.H. Hermansen, Ragnar Jónsson, Jonas L. Kjeldsen, Tijs Slaats, Vlad Paul Cosma, and Hugo A. p. 0 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed.Where the paper says it
[29] Thomas T Hildebrandt and Raghava Rao Mukkamala <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[30] Hojjat Jafarpour and Rohan Desai <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[31] Ajay Krishna, Pascal Poizat, and Gwen Salaün <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[32] Orlenys López-Pintado, Luciano García-Bañuelos, Marlon Dumas, Ingo Weber, and Alexander Ponomarev <ref:2501. p. 0 1
BEST: A Unified Business Process Enactment via
Streams and Tables for Service Computing
Ahmed Awad∗
,
†
,Feras Awaysheh‡
,
¶
, and Hugo A. López§
∗The British University in Dubai, Dubai, The UAE Email: ahmed.Where the paper says it
[33] J. Mendling, H.A. Reijers, and W.M.P. van der Aalst <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501. net/
5https://www. nl/declare/
arXiv:2501. net/
5https://www. nl/declare/
arXiv:2501. net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
[34] Leandro Nahabedian, V Braberman, Nicolás D’Ippolito, Jeff Kramer, and Sebastian Uchitel <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[35] OASIS <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[36] OMG <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[37] Maja Pesic, Helen Schonenberg, and Wil M. P. van der Aalst <ref:2501.14848#pg4>.
[38] T. M. Prinz, Y. Choi, and N. Long Ha <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[39] Stefanie Rinderle-Ma and Manfred Reichert <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[40] Niklas Ruhkamp and Stefan Schönig <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[41] M.J. Sax, G. Wang, M. Weidlich, and J.-C. Freytag <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[42] Alexander Seeliger, Michael Stein, and Max Mühlhäuser <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[43] Tijs Slaats <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[47] Wil M. P. van der Aalst, Michael Adams, Arthur H. M. ter Hofstede, Maja Pesic, and Helen Schonenberg <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[48] W.M.P. van der Aalst <ref:2501.14848#pg4>.
[49] Boudewijn F. van Dongen, Monique H. Jansen-Vullers, H. M. W. Verbeek, and Wil M. P. van der Aalst <ref:2501.14848#pg4>.
[50] J. Verwiebe, P. M Grulich, J Traub, and M Volker <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[51] Michael Westergaard and Tijs Slaats <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[52] B. Wickramanayake, C. Ouyang, Y. Xu, and C Moreira <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
[53] Jianwei Yin, Zhiling Luo, Ying Li, and Zhaohui Wu <ref:2501. p. 0 net/
5https://www. nl/declare/
arXiv:2501.Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Process Orchestration via CQL Engine: The system can enact hybrid process models by using a CQL-compliant stream processing engine as a process orchestrator, allowing it to implement execution semantics for both imperative BPMN models and declarative DCR models across diverse modeling paradigms.
-
Unified Event Model: By defining
all executions around a unified event model,
the system achieves cross-language and cross-paradigm process enactment, enabling the consumption of events from procedural processes by declarative ones and vice versa. -
Hybrid Process Modeling Capability: The approach allows for orchestrating hierarchical hybrid models where sub-processes are modeled with either procedural or declarative languages, enabling events from procedural processes to be consumed by declarative ones and vice versa.
-
Dynamic Model Evolution: The system supports the evolution of process models by allowing rules to be tracked by IDs, enabling the undeployment of old rules and deployment of new ones, while filter conditions on CQL rules can direct process instances to follow new or existing models.
-
Automated Process Migration: The architecture allows for ensuring consistency between pre- and post-states during model changes by adding filter conditions to CQL rules that direct running instances to the correct rule when a modification occurs.
Abstract
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.
Sources
Related papers
- ArkEval: Benchmarking and Evaluating Automated CodeRepair for ArkTS
- TestPrism: Rethinking Test Evaluation Beyond a Single Reference
- Mining Workflow Graphs for Black-Box Boundary Testing of Conversational LLM Agents
- Falsification-Based Verification of LLM-Generated Optimization Models: Sound Test Batteries and Their Detection Limits
- GitSkills: A Dataset of Agent Skills on GitHub
- For Coding Agents, the Repository Matters