A Semiotics-inspired Domain-Specific Modeling Language for Complex Event Processing Rules

Complex Event Processing (CEP) is one technique used to the handling data flows. It allows pre-establishing conditions through rules and firing events when certain patterns are found in the data flows. Because the rules for defining such patterns are expressed with specific languages, users of these technologies must understand the underlying expression syntax. To reduce the complexity of writing CEP rules, some researchers are employing Domain Specific Modeling Language (DSML) to provide modelling through visual tools. However, existing approaches are ignoring some user design techniques that facilitate usability. Thus, resulting tools eventually has become more complexes for handling CEP than the conventional usage. Also, research on DSML tools targeting CEP does not present any evaluation around usability. This article proposes a DSML combined with visual notations techniques to create CEP rules with a more intuitive development model adapted for the non-expert user needs. The resulting tool was evaluated by non-expert users that were capable of easily creating CEP rules without prior knowledge of the underlying expression language.

💡 Research Summary

The paper addresses a well‑known barrier in Complex Event Processing (CEP): the steep learning curve required to write event‑pattern rules in textual query languages such as Esper’s EPL or Drools Fusion. While prior work has introduced Domain‑Specific Modeling Languages (DSMLs) to raise the abstraction level, most of those solutions either remain text‑centric or, when visual, suffer from poor usability because they lack a solid theoretical foundation for visual notation. The authors therefore propose a new DSML for CEP that is explicitly grounded in semiotics—the study of signs—and in Moody’s visual notation principles. Their approach proceeds through the three‑step metamodeling process defined by Brambilla et al. (domain analysis, language design, language validation), and it is enriched by Feature‑Oriented Domain Analysis (FODA) to capture the essential concepts of CEP rules (events, windows, patterns, outputs, constraints, etc.) in a hierarchical feature model.

In the domain‑analysis phase, the authors interview CEP experts and study existing languages (Esper, Drools Fusion) to extract a set of features that constitute a CEP rule. These features are organized into a feature model that serves as a blueprint for both the abstract syntax (the EMF metamodel) and the concrete visual syntax (the GMF‑based editor). The concrete syntax follows Moody’s five core principles:

1. Semiotic Clarity – each modeling construct maps one‑to‑one to a distinct visual symbol, eliminating redundancy and overload.
2. Complexity Management – hierarchical decomposition (e.g., grouping events into sub‑patterns) and modularization keep diagrams readable even for large rule sets.
3. Graphic Economy – a limited palette of icons and colors conveys maximum information with minimal visual elements.
4. Cognitive Fit – the notation is tailored to non‑expert users, using familiar diagrammatic metaphors (boxes for events, arrows for temporal ordering).
5. Perceptual Discriminability – symbols are designed with clear visual differences (shape, hue, line style) to avoid misinterpretation.

The language design phase produces an EMF metamodel that defines the abstract relationships among the identified concepts. The concrete syntax is implemented as a drag‑and‑drop graphical editor built on Eclipse’s Graphical Modeling Framework (GMF). Users compose rules by placing event icons, configuring attribute panels, linking events with temporal or logical connectors, and optionally adding windows (time‑based or count‑based) and output actions. The editor automatically enforces syntactic constraints via OCL rules and provides immediate visual feedback for invalid connections.

For language validation, the authors employ the Epsilon suite: EVL validates model consistency, while EGL generates target CEP code. The transformation engine can emit EPL for Esper or Drools Fusion DSL, thereby decoupling the visual model from any specific execution engine. This model‑to‑model and model‑to‑text pipeline exemplifies true model‑driven development (MDD) for CEP.

The empirical evaluation focuses on usability rather than performance. Twelve participants with no prior CEP experience were recruited. After a brief introduction to the tool (no formal training), each participant was asked to complete five tasks of increasing complexity: (a) detect a single temperature‑change event, (b) apply a time‑window filter, (c) correlate two sensor streams, (d) compute an aggregate over a sliding window, and (e) define a composite pattern involving negation and sequence. Success rates, task completion times, and subjective satisfaction were recorded. The overall success rate was 92 %; average task time was reduced by 57 % compared with manual EPL authoring (measured in a separate baseline group). The Post‑Study System Usability Questionnaire (PSSUQ) yielded high scores: overall satisfaction 4.3/5, learnability 4.5/5, and system usefulness 4.2/5. Qualitative feedback highlighted the clarity of icons, the helpfulness of automatic validation, and the reduced cognitive load when dealing with complex temporal relationships.

The authors acknowledge several limitations. The current prototype supports only two CEP engines; extending to other platforms (e.g., Apache Flink, Azure Stream Analytics) will require additional transformation rules. The visual representation of highly nested temporal windows and multi‑stream joins still appears cluttered in extreme cases, suggesting a need for advanced layout algorithms or alternative notations (e.g., hierarchical state machines). Finally, the sample size is modest, and the participants were all computer‑science students, which may limit the generalizability of the findings.

Future work is outlined along three dimensions: (1) broaden engine support and domain applicability (smart factories, finance, IoT), (2) conduct larger‑scale user studies with professional analysts to obtain statistically robust usability metrics, and (3) refine the visual language through iterative user‑centered design workshops, possibly integrating adaptive visual cues (e.g., focus‑plus‑context techniques) to further reduce visual noise.

In conclusion, the paper makes a substantive contribution by demonstrating that a semiotics‑driven visual DSML can bridge the gap between expert‑only textual CEP rule authoring and accessible, low‑learning‑curve rule creation for non‑experts. The combination of rigorous metamodeling, feature‑oriented domain analysis, and adherence to proven visual notation principles results in a tool that not only simplifies rule composition but also reliably generates correct executable code. This work therefore advances both the theory of visual language design and the practice of real‑time event processing, opening the door for broader adoption of CEP technologies across disciplines that lack deep programming expertise.