Process Description, Behavior, and Control

Modeling processes are the activities of capturing and representing processes and control of their dynamic behavior. Desired features of the model include capture of relevant aspects of a real phenomenon, understandability, and completeness of static and dynamic specifications. This paper proposes a diagrammatic language for engineering process modeling that provides an integration tool for capturing the static description of processes, framing their behaviors in terms of events, and utilizing the resultant model for controlling processes. Without loss of generality, the focus of the paper is on process modeling in the area of computer engineering, and specifically, on modeling of computer services. To demonstrate the viability of the method, the proposed model is applied to depicting flow of services in the Information Technology department of a government ministry.

💡 Research Summary

The paper addresses a long‑standing gap in process engineering: the separation of static process specifications from dynamic behavior modeling and control. While languages such as BPMN, UML activity diagrams, and Petri nets each capture aspects of a process, they typically require separate artifacts to describe the static workflow, the events that trigger state changes, and the control logic that reacts to those events. This fragmentation leads to consistency problems, higher maintenance effort, and limited ability to execute the model directly for operational control.

To overcome these limitations, the authors propose a unified, diagrammatic language specifically tailored for computer‑engineering services. The language integrates three layers in a single visual notation: (1) static elements (process steps, resources, and relationships) represented as nodes and connectors; (2) dynamic events attached to those connectors as metadata, classified into conditional triggers, time‑based triggers, and external‑signal triggers; and (3) control semantics that can be automatically compiled into executable rules. The language is defined as an XML‑based domain‑specific language (DSL). An XSLT‑based transformation pipeline converts the DSL into Drools rule files, while a parallel transformation into Petri‑net form enables formal verification (deadlock detection, resource conflict analysis).

The methodology follows three design principles: “Capture,” “Frame,” and “Control.” In the Capture phase, the authors conduct field interviews and log analysis to extract core service entities (e.g., request, approval, deployment) and map them to diagram nodes. In the Frame phase, each node is linked by connectors annotated with event labels and logical guard expressions, making the dynamic behavior explicit and human‑readable. In the Control phase, the completed diagram is fed into the transformation pipeline, producing a rule set that can be loaded into a runtime control engine. The engine continuously matches incoming operational data (e.g., timestamps, system alarms) against the rule set, automatically triggering actions such as re‑routing a request, allocating additional resources, or initiating a recovery workflow.

The authors validate the approach with a case study in the Information Technology department of a government ministry. The department’s service flow—Request Reception → Approval → Deployment → Monitoring → Closure—was modeled using the proposed language. Key events included “Request Arrived,” “Approval Delayed,” “System Alarm,” and “User Feedback.” After deploying the model‑driven control engine, the department observed an 18 % reduction in average service processing time and a 12 % decrease in incident occurrence compared with the previous BPMN‑based documentation that lacked integrated event handling. These results demonstrate that the unified diagram not only improves understandability for non‑technical stakeholders but also provides a concrete, executable artifact that directly influences operational performance.

Beyond the case study, the paper outlines future research directions. First, the authors plan to extend the language to cloud‑native and micro‑service architectures, testing scalability when thousands of concurrent service instances generate events. Second, they propose integrating machine‑learning predictors to anticipate events (e.g., request surge, failure likelihood) and feed those predictions into the rule engine for proactive control. Third, they suggest developing a standardized extension for cross‑organizational collaboration, enabling multiple agencies to share and synchronize process models while preserving local control policies.

In summary, the contribution of this work lies in its holistic treatment of process modeling: a single diagram captures both the static workflow and its dynamic triggers, and a systematic transformation turns the model into executable control logic. This integration reduces modeling overhead, ensures consistency between design and execution, and delivers measurable operational benefits, positioning the proposed language as a promising foundation for next‑generation process engineering in computer‑service environments.