Improving the Understandability of Conceptual Models via Abstract Notation Engineering
arXiv:2607.29552v1 [cs.SE] 31 Jul 2026
Amine Abbad-Andaloussi, Daniel Jeppe Schütt, Kasper Solhøj Jørgensen, Tobias van Deurs Lundsgaard, and Hugo A. López
Abstract. Conceptual modeling supports the design, analysis, and communication of the properties of complex systems, yet conceptual models can be difficult to understand when domain-level abstractions must be encoded through low-level constructs required mainly for semantic conformity. Prior work has mainly improved how existing individual constructs are visually represented. We shift the focus from individual constructs to recurring configurations of constructs, and propose abstract notation engineering as a language-agnostic method for replacing such configurations with higher-level, semantically transparent constructs. The method comprises pattern identification, pattern formalization, visual notation design, and empirical validation. We instantiate it for Dynamic Condition Response (DCR) graphs, where common workflow patterns require elaborate low-level configurations. The resulting extension, DeCleaR, replaces such configurations with compact patternbased abstractions. The results of our empirical validation show that DeCleaR improves perceived empirical quality, pragmatic quality, and user preference over standard DCR graphs. Keywords: Conceptual Modeling, Visual Notation, Abstract Notation Engineering, Process Model Comprehension, DCR Graphs.
1
Introduction
Conceptual modeling is fundamental for the design, analysis, and communication of the characteristics of complex systems [28]. Languages such as the Unified Modeling Language (UML), Entity-Relationship diagrams (ERD), Business Process Model and Notation (BPMN), and Dynamic Condition Response (DCR) enable modelers to capture static and dynamic aspects of systems, including organization, operational logic, and data constraints, with formal precision. To support understandability, these languages rely on graphical notations [14]. The effectiveness of conceptual models depends on how well they convey concepts and interrelations. While the semantic capabilities of modeling languages have received considerable attention [14], their pragmatic aspects are less understood. Indeed, conceptual modeling languages are typically optimized for semantic correctness rather than pragmatics. For example, representing a many-tomany relationship in an ER diagram requires an associative entity and multiple connecting relationships. The intention is captured, but through artificial constructs foreign to the modeler’s domain, needed mainly to satisfy the language
2
Abbad-Andaloussi et al.
semantics. Behavioral languages face similar issues. Translating a BPMN model into a workflow net may require auxiliary places that are absent from the original BPMN representation but needed to preserve behavior. This creates an understandability gap, as practitioners must distinguish domain-relevant constructs from helper constructs introduced for semantic conformity. From a cognitive systems perspective, modeling involves an encoding phase, where practitioners’ mental models are translated into a conceptual model, and a decoding phase, where the conceptual model is interpreted back into mental models. The greater the distance between mental models and their conceptual representation, the more effort users are expected to exert during comprehension tasks [48,40]. A major contribution to pragmatic aspects of conceptual models is Moody’s Physics of Notations (PoN) [33], which has influenced the representation of BPMN [20], DCR graphs [32], and other notations. A central PoN principle is semantic transparency, denoting the degree to which a visual construct’s meaning can be inferred from its appearance [33]. Achieving semantic transparency remains challenging across languages [42,33]. Prior work has mainly improved the transparency of individual visual constructs, for instance, by redesigning constraints between process model activities with alternative glyphs [8,42], exploring alternative 3D representations [9], or overlaying domain-specific representations [27]. However, these efforts focus on notational elements in isolation. This work shifts the focus from improving individual constructs to abstracting recurring configurations of constructs into higher-level, semantically transparent constructs. We refer to this approach as abstract notation engineering. It aims to identify mental abstractions used by practitioners and represent them within an existing modeling language. The approach is inspired by earlier abstraction efforts in conceptual modeling, namely, Declare, which can be seen as an abstraction over recurring Linear Temporal Logic (LTL) formulas in industrial settings [15]. This initiative showed that recurring low-level configurations can be lifted into reusable modeling constructs. However, Declare was not developed as part of a systematic notation engineering method focusing on understandability. Besides, common abstraction mechanisms mainly take the form of modularization, where constructs are grouped into containers that hide internal details [48]. Such mechanisms exist in several notations, including subprocesses in BPMN [14], nestings [23], and links in DCR graphs [13]. Although modularization reduces visible complexity, it does not necessarily introduce higher-level constructs aligning with practitioners’ mental abstractions. Once the container is expanded, the same low-level configuration reappears and must still be interpreted. Abstract notation engineering, therefore, combines abstraction with encapsulation to define behavioral encodings [47], i.e., language fragments that behave as a unit according to an intended higher-level concept. These encodings provide the semantic basis for new constructs, which must be complemented by symbol elicitation to ensure that their meaning can be inferred from their appearance. The obtained visual abstractions require then empirical validation to assess their alignment with practitioners’ mental schemas and understandability.
Understandability of Conceptual Models via Abstract Notation Engineering
3
In a nutshell, our main contribution is a language-agnostic method for enhancing the understandability of conceptual modeling notations through abstract notation engineering. We demonstrate the method on declarative process modeling languages, focusing on DCR graphs. Declarative languages, such as Declare [36] and DCR Graphs [25], specify constraints while leaving execution order open [6]. This flexibility is valuable for constraint-governed processes in banking, healthcare, and law, where decisions are discretionary, and the space of possible executions is too large to prescribe as sequential flows. However, it also incurs a representational cost, since common control-flow patterns, such as a sequence of two activities or an exclusive choice, require elaborate constraint configurations [17]. We use DCR as a representative for declarative languages, given its consistently demonstrated practical value in digitalization initiatives over the years [29,24]. Applying our method to DCR resulted in DeCleaR, a set of nine pattern abstractions for recurring process behaviors. We evaluated selected DeCleaR patterns empirically and found significant improvements in perceived empirical quality, perceived pragmatic quality, and user preference compared with standard DCR representations. With this contribution, we aim to support the adoption of declarative languages among industrial users of DCR, while also providing a method that other notations, such as Declare, BPMN, UML, and ER, could adopt. The remainder of the paper is structured as follows. Section 2 reviews relevant background. Section 3 presents our method. Section 4 instantiates the method on DCR graphs and presents our empirical evaluation. Section 5 discusses findings and limitations. Section 6 concludes the paper.
2
Background and Related Work
2.1
Empirical Work on the Understandability of Conceptual Models
Empirical work on the understandability of conceptual models can be divided into studies investigating the (1) presentation, (2) users, and (3) tasks in which models are used [18,30]. This work subscribes to the first stream, which includes studies on presentation mediums and tools [43,2], and studies on the syntax, semantics, and visual representation of conceptual models [44,19,42,4,18]. Focusing on visual representations, prior research has examined a range of modeling languages (overview in [18]). In this paper, declarative languages such as Declare and DCR graphs are particularly relevant because their declarative nature creates representational challenges despite modeling advantages and increasing adoption [6,8,24] (cf. Sect. 1). Existing studies have proposed new visual representations and modeling guidelines to support modeling practices and model comprehension [42,8,9,27,22]. However, these works focus on improving individual symbol representations, and no prior work has proposed an empirically guided, language-agnostic method for improving visual representations using abstraction techniques, which constitutes the core focus of this paper.
4
Abbad-Andaloussi et al.
Fig. 1: Simplified passenger airport journey modeled in DCR Graphs.
2.2
Improving Modeling Notations
A substantial body of literature has examined how diagrammatic representations, including conceptual and process models, can support understandability [33]. Two theoretical perspectives are particularly informative for this study. PoN formulates design principles for improving conceptual model comprehension, including Semiotic Clarity, Perceptual Discriminability, Semantic Transparency, Complexity Management, Cognitive Integration, Visual Expressiveness, Dual Coding, Graphic Economy, and Cognitive Fit [33]. Relevant here are semantic transparency, which concerns whether a symbol’s meaning can be inferred from its visual appearance, and dual coding, which concerns the complementarity of visual and textual elements [33]. Apart from PoN, two major frameworks consider the understandability of conceptual models. The Semiology of Graphics [7] identifies fundamental visual variables, including shape, color, size, orientation, brightness, and texture. SEQUAL [30] provides quality dimensions, including empirical quality, which addresses how clearly and distinctly representation elements can be identified, and pragmatic quality, which concerns whether the intended meaning is correctly understood. These foundations structure the design and evaluation of our abstract notation engineering approach in Sect. 3. 2.3
DCR Graphs
A DCR graph [25] represents processes as a multidirected graph where nodes correspond to events (i.e., process activities) and edges define behavioral constraints. We introduce the main notation elements via Fig. 1. Each event appears as a rectangle and can have different states based on its current marking. A blue exclamation mark denotes a pending event, i.e., an obligation that must be fulfilled before the process can complete. Events with dashed borders are excluded and temporarily unavailable for execution. A green checkmark indicates executed status, meaning the activity has occurred. The edges between events represent DCR constraints. We use the notational f : f cannot be executed until variant introduced in [42]: (1) Condition e e has been executed, or e is excluded; (2) Response e f : when e executes, f becomes pending and must eventually occur or be excluded; (3) Dynamic inclusion e f : after executing e, f is included among the possible actions; (4) Dynamic exclusion e f : after executing e, f is excluded from the f : if e is pending, f cannot be enabled. possible actions; and (5) Milestone e
Understandability of Conceptual Models via Abstract Notation Engineering
5
DCR uses nesting [23] (rectangles with n) and subprocesses [12] (rectangles with s) to group related events. Nesting reduces diagram complexity: an edge pointing to or from a nesting event behaves as if each event inside the nesting had that edge. Subprocesses add a semantic layer by endowing the outer layer (i.e., the subprocess) with an execution marking whose state depends on the markings and constraints of its internal events. Thus, a subprocess is completed once it reaches an accepting state, i.e., no pending events. Fig. 1 presents a DCR graph modeling a (simplified) airport passenger journey from check-in to boarding. The process begins with a “Check-in” subprocess containing two alternatives: “Go through self-service kiosk” and “Go through staffed counter”. Since these events are inside a subprocess, “Check-in” reaches an accepting state as soon as one alternative is executed. This also means that the two outbound DCR relations take effect once one of the two “Check-in” events is executed. The “Security check” is a nest with two required events, “Scan bags” and “Scan passenger with body scanner”. The condition between “Check-in” and “Security check” states that the nested security events cannot execute until “Check-in” has been completed at least once. The response relation specifies that completing “Check-in” triggers a requirement to undergo the “Security check”. The milestone relation from “Security Check” to “Board plane” prevents boarding while security obligations remain pending. Hence, boarding becomes available only after all security requirements are completed. “The Board Plane” event has a self-referential exclude relation, removing boarding from the process upon execution and preventing multiple boardings. The include relation from “Security check” to “Board Plane”, however, allows including “Board Plane” again if another security check is performed.
3
Method
This section presents our method for designing visual notation abstractions. The method is language-agnostic and can be applied to any formal language with a visual representation and an underlying computational semantics. It represents one iteration of an iterative abstract notation engineering process: candidate patterns are identified, formalized, visually designed, and empirically evaluated. The results can inform subsequent refinements, either by redesigning existing abstractions or by adding further patterns, until theoretical saturation is reached, i.e., until further iterations reveal no substantially new patterns, design issues, or empirical insights. Its four steps build upon established foundations: Pattern identification (Step 1) is based on pattern-oriented conceptual modeling [38,16], where recurring patterns are organized into catalogues to ease modeling practices. Pattern formalization (Step 2) draws on test-driven modeling [11] and behavioral encodings [47]. Visual notation design (Step 3) is grounded in visual notation design principles [33,7]. Finally, empirical validation (Step 4) follows empirical research guidelines [45]. The method was refined by the co-authors over six months during its application on the DCR use case (Sect. 4), until convergence on the current version. Fig. 2 provides an overview of our method.
6
Abbad-Andaloussi et al. 1
Pattern identification
1.1. Language selection and comparability analysis 1.2. Corpus analysis 1.3. Cutoff and pattern selection 1.4. Iterative refinement and expert intervention
2
Pattern formalization
2.1. Behavioral specification 2.2. Behavioral encoding 2.3. Parameterization
3
Visual notation design
3.1. Principle selection 3.2. Symbol and label design 3.3. Panel validation of designs
4
Empirical validation
4.1. Hypotheses and comprehension operationalization 4.2. Experiment design 4.3. Analysis and crossmethod synthesis
Repeat until theoritical saturation
Fig. 2: Overview of the notation engineering method.
3.1
Step 1: Pattern Identification
The first step determines which patterns would benefit most from pattern-based abstractions for a specific language or community. It comprises four activities. Step 1.1: Language Selection and Compatibility Analysis. We begin by selecting a target language and evaluating which patterns can be expressed in it. Established catalogues, such as the 43 workflow patterns [38], can serve as a starting point for process-oriented languages, while domain-specific catalogues should be consulted for other languages. Each candidate pattern should be assessed by asking: Can the target language express the pattern’s behavior through its existing constructs? Inexpressible patterns should be excluded. Step 1.2: Corpus Analysis. Compatibility alone does not ensure relevance. Our method therefore, encourages analyzing natural language process specifications to determine how frequently each compatible pattern occurs in practice. Annotation studies [31] of language patterns could reveal those that dominate daily practice and would thus yield better conceptual model comprehension if abstracted. Step 1.3: Cutoff and Pattern Selection. A threshold-based cutoff may be applied to the annotation results to select a concise set of patterns. Step 1.4: Iterative Refinement and Expert Intervention in Pattern Selection. Pattern selection should be iterative, allowing refinement based on expert input and emerging insights. Rather than fixing the pattern set upfront, domain expertise should be incorporated throughout this step. Experts may propose additional patterns not strongly represented in the literature, yet relevant and useful for the target use case. Their inclusion is permitted if compatibility with the target modeling language is verified. We recommend balancing coverage, i.e., abstracting enough patterns to be useful, against complexity, i.e., keeping the number of abstractions manageable for users to learn. 3.2
Step 2: Pattern Formalization
Each pattern must be defined in terms of the host notation’s semantics, ensuring that the abstraction is a semantically grounded configuration of constructs. This step contains three activities. Step 2.1: Behavioral Specification. For each pattern, the method defines its intended behavior through representative valid and invalid execution traces. This
Understandability of Conceptual Models via Abstract Notation Engineering
7
trace-based characterization specifies what the pattern means in observable behavior before defining how it is implemented. It may also include modeling decisions to resolve ambiguities. Step 2.2: Behavioral Encodings. This step extends the compatibility analysis by translating abstracted patterns into model fragments in the host notation. Each fragment captures the abstraction’s semantic content and serves as its computational counterpart. This backward mapping maintains compatibility with the original notation and ensures that existing computational support, such as execution, simulation, verification, and conformance checking, remains applicable. A key constraint is the encapsulation rule, i.e., no relations may cross the boundary of the abstracted fragment. This keeps the abstraction self-contained and substitutable without side effects on the surrounding conceptual model. Step 2.3: Parameterization. Some patterns may require parameters, such as “at least n occurrences” of an event. The formalization should capture them. 3.3
Step 3: Visual Notation Design
The third step designs the visual representation of each pattern view. It comprises three activities. Step 3.1: Principle Selection. The designer should select visual design principles to guide the new representation. Established frameworks include PoN [33] and the Semiology of Graphics [7] (cf. Sect. 2.2). Other frameworks, such as Gestalt principles of perception [41], may apply depending on the domain context. Based on the literature [33,7], we posit that designers should prioritize two concerns: (i) interpretability, ensuring that each symbol’s meaning can be inferred from its appearance, and (ii) distinguishability, ensuring that symbols for different patterns are visually distinct from one another and from existing constructs. Step 3.2: Symbol and Label Design. For each pattern, candidate visual constructs, i.e., symbols, and labels should be generated. A symbol should depict the behavioral essence of the pattern in a way recognizable to practitioners. The label should provide a textual anchor that names the pattern in clear, unambiguous terminology. Both should maximize interpretability and distinguishability. Step 3.3: Panel Validation of Designs. To ensure that the chosen symbols align with practitioners’ mental schemas, our method adopts a structured elicitation procedure based on the Delphi method [34]. This method gathers expert input over several iterations, each time sharing a summary of group answers so experts can review their opinions and converge toward agreement [34]. Applied to our context, experts should evaluate candidate designs across multiple rounds to reach a consensus that maximizes interpretability and distinguishability. 3.4
Step 4: Empirical Validation
The fourth step evaluates the chosen patterns from a user perspective. Here, we focus only on the aspects most relevant for evaluating visual notations, while comprehensive guidelines for conducting empirical studies can be found in [45].
8
Abbad-Andaloussi et al.
Step 4.1: Hypotheses and Comprehension Operationalization. Empirical evaluation may target several activities, including model comprehension, modeling, and maintenance. Because comprehension is inherent to all these activities, we recommend prioritizing it first. In this context, the independent variable should be the notation condition, i.e., abstracted versus standard notation. The dependent variables should capture separate comprehension dimensions rather than a single one, since a visual abstraction may improve users’ perception of a model’s clarity and interpretability without improving how accurately they decode its behavior. Relevant measures include answer correctness, assessed through decoding tasks (e.g., producing valid execution traces for a given model [3]); perceived quality, captured with questionnaire items grounded in SEQUAL [30]; and preference, quantified through comparisons between abstracted and standard notations. Measures, such as eye tracking or EEG, can be additionally incorporated to capture the cognitive processes underlying model comprehension [26]. Step 4.2: Experimental Design. Participants, stimuli, instruments, and procedure should follow established guidelines [45]. Both within-subject and betweensubject designs could be applicable, depending on the study’s objectives. A within-subject design, where each participant interprets models both with and without visual pattern abstraction, is preferable when the participant pool is small because it results in more data points for statistical analyses by using each participant as their own control and eliminates individual differences as a confounding factor. A between-subject design may be appropriate to avoid fatigue due to long experiments and the learning effect between conditions, common in within-subject settings. Yet, the learning effect could also be mitigated in a within-subject design by counterbalancing the presentation order. Each pattern should be embedded in an identical base model, so the notation variant is the only manipulated variable. A mixed-methods approach is advisable. Beyond quantitative instruments, semi-structured interviews can explore how participants interpret visual elements and what challenges their understanding. Step 4.3: Analysis and Cross-method Synthesis. Hypotheses should be tested with statistical tests suited to the data properties [45]. In addition, the empirical study can be complemented by interviews to gain qualitative insights about users’ experience. Herein, interview transcripts should undergo structured qualitative coding [39], with independent coders and inter-rater reliability checks. Quantitative and qualitative insights should then be related to better understand the observed effects. This integration makes the empirical study a source of actionable design insights.
4
Use Case: Instantiation in DCR Graphs
We demonstrate our method by instantiating it on DCR. The instantiation produces DeCleaR, an extension that equips DCR with nine abstracted patterns.
Understandability of Conceptual Models via Abstract Notation Engineering
4.1
9
Step 1: Pattern Identification
Language Selection and Compatibility Analysis (Step 1.1). DCR was selected as the target language owing to the challenges practitioners face when expressing common flow-based patterns under its declarative, constraint-based semantics. While compatibility analyses of the 43 workflow patterns of Russell et al. [38] exist for BPMN [46], YAWL [21], and CMMN [10], no such analysis had been undertaken for DCR. We therefore examined the 43 patterns for compatibility with DCR constructs and documented how, or whether, each behavior can be reproduced using combinations of DCR constructs. Patterns that could not be faithfully expressed within the basic DCR formalism1 were excluded. The full results are available in our online repository [5]. Corpus Analysis (Step 1.2). To determine which expressible patterns appear frequently enough to justify abstraction, we analyzed 50 declarative process descriptions from a study on textual ambiguity in business process models [31]. The analysis followed a sentence-level scanning procedure. For each sentence, we determined whether it fully instantiated one compatible workflow pattern and incremented the corresponding occurrence count. Partial matches were carried forward and checked against the subsequent sentence before any tally decision. The complete annotation results are available in our online repository [5]. Cutoff and Pattern Selection (Step 1.3). The analysis produced a clear frequency stratification. The top seven patterns were observed 84, 46, 24, 23, 21, 20, and 18 times, respectively, across the 50 descriptions. The eighth-ranked pattern appeared only 7 times, a sharp drop that marked a natural boundary between widely-used and rarely-used patterns. Iterative Refinement and Expert Intervention in Pattern Selection (Step 1.4). Given the iterative nature of our approach, we also explored compliance patterns [16]. Although less widely adopted than Russell’s patterns [38], they capture compliance modeling behaviors relevant to the DCR community and compliantby-design Case Management Systems [24]. Applying the same compatibility procedure confirmed that six compliance patterns could be expressed in DCR, expanding the candidate pool to thirteen patterns. Following co-author discussions guided by the industry-oriented DCR expertise of some of them, nine patterns were selected by balancing coverage against complexity. These became the final DeCleaR pattern set. Table 1 lists the nine identified patterns with concise descriptions. 4.2
Step 2: Pattern Formalization
Behavioral Specification (Step 2.1). For each selected pattern, we characterized the intended behavior through representative valid and invalid traces. Since the 1
By “basic” we refer to whether the patterns could be encoded in the original presentation of DCR graphs [25]. Some patterns could be expressed in extensions of DCR graphs with time or data, but they were deemed out of scope in this iteration.
10
Abbad-Andaloussi et al. Table 1: Final set of selected patterns and their concise behavioral definitions. Pattern Name Definition Sequence Enforces a strict execution order across a series of events, requiring the entire sequence to complete once initiated. Deferred Choice Provides mutually exclusive options where the execution of one alternative permanently disables all others. Bounded Exists Constrains the occurrence of an event to a parameterized threshold, enforcing a minimum (≥ n), maximum (≤ n), or exact (= n) execution count. Explicit Initialization Specifies a mandatory starting event that must be executed before any other activity in the process can occur. Explicit Termination Defines a specific event that immediately finishes the entire process upon its execution, preventing further activities. Exists Mandates that a designated event must occur at least once before the process can successfully finish. isAbsent Strictly prohibits the execution of a specified event throughout the entire process instance. Precedes A set-based constraint where all events in a precursor set must execute before any event in a target set is permitted. LeadsTo A set-based rule dictating that the execution of any event in a trigger set necessitates the eventual execution of all events in a target set.
original pattern definitions are specified in natural language, this characterization required resolving ambiguities when mapping their intended semantics to DCR. We therefore selected the interpretation that best preserved the pattern’s behavioral intent within DCR’s semantics. For instance, since every DCR event is inherently repeatable, the chosen event in Deferred Choice may be executed multiple times, and Sequence must be completed once initiated, with ordering preserved across repetitions. For Explicit Initialization and Explicit Termination, we opted for process-level scope, meaning that the initial event precedes all events and the terminating event finishes the entire process. For Precedes and LeadsTo, we extended the original atomic definitions [16] to sets of events. As an example to illustrate our behavioral specification approach, for a Sequence over A, B, C, valid traces include A → B → C and A → B → C → A → B → C. Invalid traces include A, A → B, B → C → A, A → C, A → B → B → C, and A → B → C → A. Similar specifications were established for all nine patterns. Behavioral Encodings (Step 2.2). Each pattern was then translated into a DCR graph. The encapsulation principle was a fundamental design decision for the encodings, i.e., no DCR relation may cross a pattern’s boundary. This prevents external interference with internal pattern behavior and ensures that each pattern preserves its intended semantics when composed. The resulting DCR graphs for all nine patterns are shown in Fig. 3 (labeled from (a) to (k)). We refer the reader to our repository for a detailed explanation of the DCR construct configuration underlying each pattern [5]. Parameterization (Step 2.3). Bounded Exists is parameterized by the threshold N ∈ N, which determines the number of identically labeled events, while the constraint type, i.e., at least, at most, or exactly, determines the pending markings and exclusion relations. Precedes and LeadsTo are parameterized by the cardinalities of their event sets X and Y . The other patterns are similarly parameterized by their number of constituent events (cf. Fig. 3).
Understandability of Conceptual Models via Abstract Notation Engineering
11
Fig. 3: DCR model fragments of the identified patterns. For the sake of illustration, we set N to 3.
4.3
Step 3: Visual Notation Design
Principle Selection (Step 3.1). Following our method’s guidance, we adopted two complementary frameworks. From PoN [33], we prioritized semantic transparency and dual coding to address interpretability. From the Semiology of Graphics [7], we drew on its visual variables (shape, color, size, orientation, brightness, texture) to ensure distinguishability across pattern symbols. Symbol and Label Design (Step 3.2). We generated five candidate symbols per pattern, drawn from public signage, traffic signs, and BPMN notation to maximize semantic transparency and visual distinctiveness. We also generated nine candidate labels per pattern, using synonyms and abbreviations to complement the symbols through dual coding. The symbols and labels pairs are available in our repository as part of our Delphi survey [5]. Panel Validation of Designs (Step 3.3). To converge on final designs, we conducted a two-round Delphi survey [34], involving an associate professor (expert in DCR and conceptual modeling), 2 senior researchers (both experts in conceptual modeling; one expert in DCR), and three graduate students (with one year of training in DCR and other modeling languages). Anonymous voting mitigated authority bias. Participants ranked symbol, label, and visual-variable candidates based on interpretability and distinguishability. Aggregated responses were shared in the second round, and convergence required majority consensus on each symbol-label pair. Our Delphi survey is available in our online repository [5]. The results confirmed color and shape as dominant variables for distinguishability and converged toward the DeCleaR representations shown in Fig. 4.
12
Abbad-Andaloussi et al. Only one of
Sequence
Do at least N times
Do at most N times
Precedes
Start
Do exactly N times
End
Exists
Leads to
Fig. 4: DeCleaR Patterns. Note: The Bounded Exists patterns (e,f,g) include a dynamic circular bar at the bottom denoting a progress bar that advances at run time to show how many times the pattern has been executed.
4.4
Step 4: Empirical Validation
Hypotheses and Comprehension Operationalization (Step 4.1). We formulated four null hypotheses targeting distinct comprehension dimensions. H1 tests answer correctness: DeCleaR and DCR exhibit the same error rate during decoding tasks. H2 and H3 test perceived quality via the SEQUAL framework [30]: H2 posits no significant difference in empirical quality, while H3 posits no significant difference in pragmatic quality. H4 tests preference: participants favor DeCleaR and DCR equally. Experimental Design (Step 4.2). We adopted a counterbalanced within-subject design with fourteen participants familiar with DCR, recruited from university courses, BPM research groups, and industry partners2 . To demonstrate the abstract notation engineering method while limiting fatigue, four DeCleaR patterns were selected for a first experiment: Bounded Exists at Least N times, Sequence, Explicit Initialization, and Explicit Termination. The selection was made through anonymous co-author voting. Each pattern was embedded in an identical base model, ensuring that the notation variant was the only manipulated variable. Our data collection combined four instruments. Decoding tasks (H1 ) required participants to answer with valid execution traces [3]. A Likert questionnaire (H2 , H3 ) measured empirical and pragmatic quality using items adapted from validated instruments [35]. User preference comparisons (H4 ) presented semantically identical DeCleaR and DCR representations side by side. Finally, semistructured interviews explored participants’ reasoning about symbols, labels, colors, shapes, pattern difficulty, and perceived complexity. Our experiment material is available in our online repository [5]. Analysis and Cross-Method Synthesis (Step 4.3). With fourteen participants, four patterns, and one task per pattern, we obtained 56 data points for DCR and 2
Anonymized for the reviewing process.
Understandability of Conceptual Models via Abstract Notation Engineering
13
56 for DeCleaR. Given non-normal distributions, we tested the hypotheses using Wilcoxon signed-rank paired tests. Interview transcripts were analyzed through grounded-theory-inspired coding (involving initial coding, focused coding, and axial coding) [39], with substantial inter-rater reliability (Cohen’s κ = 0.82). Our coding is documented in our online repository [5]. H1 could not be rejected (p = 0.23), indicating no significant difference in answer correctness. H2 (p = 0.013, median ∆=+0.667), H3 (p = 0.012, median ∆=+1.5), and H4 (p < 0.001, median ∆=+1.0) were rejected in favor of DeCleaR, showing significantly improved perceived empirical quality, pragmatic quality, and preference, respectively. The integration of qualitative and quantitative insights revealed a central perception-performance gap. Indeed, subjective dimensions improved, while answer correctness remained unchanged. Our qualitative coding could explain this divergence. Participants found the individual DeCleaR patterns intuitive and clearly distinguishable, symbols expressive, labels useful, and their combination supportive for interpretability. However, they struggled to trace how external DCR relations interact with the patterns’ behaviors within the process models, resulting in comparable error rates across notations. Our qualitative coding also yielded 42 exploratory usability insights. For brevity, these insights are reported in our repository [5].
5
Discussion
This paper’s primary contribution is a systematic, language-agnostic method for designing visual notation abstractions. Unlike prior work proposing notationspecific visual improvements [42,9], our method provides a general framework grounded in pattern-oriented conceptual modeling [38,16], trace-based behavioral specification [48], visual notation design principles [33,7], and empirical validation guidelines [45]. The DCR use case serves as a proof of concept demonstrating the method’s applicability. In this use case, applying our method to DCR resulted in DeCleaR, which participants rated higher on empirical and pragmatic quality, and preferred it over standard DCR representations. Answer correctness, however, showed no significant difference between conditions. This suggests that DeCleaR improves user experience without degrading accuracy, while the complexity of surrounding DCR relations may still dominate task difficulty. These insights are consistent with prior work on declarative model comprehension [37,1]. Our results can guide the next iteration of notation engineering. For DeCleaR, this means preserving the pattern-level abstractions while improving how their interaction with surrounding DCR relations is represented and supported. Implications. For notation designers, our method provides a structured, theorygrounded direction to extend existing languages with pattern-based visual abstractions. For tool builders, the formalization step produces specifications that can be implemented as transformation rules or visual overlays. For practitioners and educators, pattern-based abstractions bridge domain vocabulary and formal notation, enabling faster onboarding and reducing the expertise barrier
14
Abbad-Andaloussi et al.
that may limit declarative modeling adoption [1]. More broadly, the method opens a design space for domain-specific modeling profiles, where communities can systematically develop and standardize patterns relevant to their practice. Limitations. The method was instantiated on one language, although it was designed to be language-agnostic. To avoid overfitting, we grounded each step in language-independent foundations that have been applied to several conceptual modeling languages. Still, this creates a potential threat to external validity, and future work should apply the method to other languages. A second limitation concerns the scope of the DCR instantiation, which involved a limited participant group and covered few patterns. These decisions align with the paper’s objective, namely demonstrating that visual notation abstractions can be systematically designed and do yield measurable benefits. Exhaustive pattern coverage and large-scale validation remain necessary future steps.
6
Conclusion and Future Work
In this work, we presented a method for designing visual notation abstractions that replace complex configurations of low-level constructs. Grounded in established theoretical foundations, the method comprises four replicable steps. Its instantiation on DCR graphs produced DeCleaR and showed positive effects on empirical quality, pragmatic quality, and user preference. Future work should apply the method to other languages to further validate its generalizability. For DeCleaR, broader evaluations should include more patterns and larger participant groups. Eye-tracking studies could further examine how abstractions affect practitioners’ cognitive processes, while tool integration would enable evaluation at scale, extending to modeling and maintenance tasks. Acknowledgments This work has been supported by the grant “Center for Digital CompliancE (DICE)” (VIL57420) from VILLUM FONDEN, and by the Innovation Foundation project “Explainable Hybrid-AI for Computational Law and Accurate Legal Chatbots” 4355-00018B XHAILe, and Predictive and Prescriptive Process Analytics for Industry 4.0 (P3AI4, grant 4105-00045B )
References 1. Abbad Andaloussi, A., Zerbato, F., Burratin, A., Slaats, T., Hildebrandt, T., Weber, B.: Exploring how users engage with hybrid process artifacts based on declarative process models: a behavioral analysis based on eye-tracking and think-aloud. SoSyM (2020) 2. Abbad-Andaloussi, A., Buch-Lorentsen, J., López, H.A., Slaats, T., Weber, B.: Exploring the modeling of declarative processes using a hybrid approach. In: ER. pp. 162–170. Springer (2019) 3. Abbad-Andaloussi, A., Burattin, A., Slaats, T., Kindler, E., Weber, B.: Complexity in declarative process models: Metrics and multi-modal assessment of cognitive load. Expert Systems with Applications 233, 120924 (2023)
Understandability of Conceptual Models via Abstract Notation Engineering
15
4. Abbad-Andaloussi, A., Franceschetti, M., López, H.A., Schreiber, C., Weber, B.: When a model gives you mixed signals: cognitive effects and visual behavior. Process Science 2(1), 19 (2025) 5. Abbad-Andaloussi, A., Schütt, D.J., Kasper Solhøj Jørgensen, T.v.D.L., López, H.A.: Improving the understandability of conceptual models via abstract notation engineering (online repository), https://github.com/aminobest/DeCleaR 6. Andaloussi, A.A., Burattin, A., Slaats, T., Kindler, E., Weber, B.: On the declarative paradigm in hybrid business process representations: A conceptual framework and a systematic literature study. Information Systems 91, 101505 (2020) 7. Bertin, J.: Semiology of graphics. University of Wisconsin press (1983) 8. Blasilli, G., Ferro, L.S., Lenti, S., Maggi, F.M., Marrella, A., Catarci, T.: Improving the understandability of declarative process discovery results using easydeclare. Information Systems p. 102667 (2025) 9. Caballero-Villalobos, J., Jensen, S., López, H.A.: 3DCR: A tool for immersive process mining. In: ICPM. CEUR-WS (2024) 10. Carvalho, R., Boubaker, A., Gonzalez-Huerta, J., Mili, H., Ringuette, S., Charif, Y.: On the analysis of cmmn expressiveness: revisiting workflow patterns. In: EDOC Workshop. pp. 1–8 (2016) 11. Christfort, A.K., Cosma, V.P., Debois, S., Hildebrandt, T.T., Slaats, T.: Static and dynamic techniques for iterative test-driven modelling of dynamic condition response graphs. Data & Knowledge Engineering 157, 102413 (2025) 12. Debois, S., Hildebrandt, T., Slaats, T.: Hierarchical declarative modelling with refinement and sub-processes. In: BPM. pp. 18–33. Springer (2014) 13. Debois, S., López, H.A., Slaats, T., Andaloussi, A.A., Hildebrandt, T.T.: Chain of events: modular process models for the law. In: iFM. pp. 368–386. Springer (2020) 14. Dumas, M., La Rosa, M., Mendling, J., Reijers, H.A., et al.: Fundamentals of business process management, vol. 1. Springer (2013) 15. Dwyer, M.B., Avrunin, G.S., Corbett, J.C.: Patterns in property specifications for finite-state verification. In: Proceedings of the 21st international conference on Software engineering. pp. 411–420 (1999) 16. Elgammal, A., Turetken, O., van den Heuvel, W.J., Papazoglou, M.: Formalizing and appling compliance patterns for business process compliance. SoSyM 15(1), 119–146 (2016) 17. Fahland, D., Lübke, D., Mendling, J., Reijers, H., Weber, B., Weidlich, M., Zugal, S.: Declarative versus imperative process modeling languages: The issue of understandability. In: International Workshop on Business Process Modeling, Development and Support. pp. 353–366. Springer (2009) 18. Figl, K.: Comprehension of procedural visual business process models: a literature review. BISE 59(1), 41–67 (2017) 19. Figl, K., Di Ciccio, C., Reijers, H.A.: Do declarative process models help to reduce cognitive biases related to business rules? In: ER 2020. pp. 119–133. Springer (2020) 20. Genon, N., Heymans, P., Amyot, D.: Analysing the cognitive effectiveness of the bpmn 2.0 visual notation. In: SLE. pp. 377–396. Springer (2010) 21. Han, Z., Zhang, L., Ling, J., Huang, S.: Control-flow pattern based transformation from uml activity diagram to yawl. In: International IFIP Working Conference on Enterprise Interoperability. pp. 129–145. Springer (2012) 22. Hanser, M., Di Ciccio, C., Mendling, J., et al.: A new notational framework for declarative process modeling. Softwaretechnik-Trends 36(2), 53–56 (2016) 23. Hildebrandt, T., Mukkamala, R.R., Slaats, T.: Nested dynamic condition response graphs. In: FSEN. pp. 343–350. Springer (2011)
16
Abbad-Andaloussi et al.
24. Hildebrandt, T.T., Andaloussi, A.A., Christensen, L.R., Debois, S., Healy, N.P., López, H.A., Marquard, M., Møller, N.L., Petersen, A.C., Slaats, T., et al.: Ecoknow: Engineering effective, co-created and compliant adaptive case management systems for knowledge workers. In: ICSSP. pp. 155–164 (2020) 25. Hildebrandt, T.T., Mukkamala, R.R.: Declarative event-based workflow as distributed dynamic condition response graphs. arXiv preprint arXiv:1110.4161 (2011) 26. Holmqvist, K., Nyström, M., Andersson, R., Dewhurst, R., Jarodzka, H., van de Weijer, J.: Eye Tracking: A comprehensive guide to methods and measures. OUP Oxford (2011) 27. Jensen, S.J., López, H.A.: Towards immersive environments for declarative process models. In: BPM Forum. pp. 214–231. Springer (2024) 28. Karagiannis, D., Mayr, H.C., Mylopoulos, J.: Domain-specific conceptual modeling. Springer (2016) 29. Keramidis, P., Hildebrandt, T.T.: On the business value of declarative business process management. In: HICSS. pp. 5631–5640 (2026) 30. Krogstie, J.: Model-based development and evolution of information systems: A Quality Approach. Springer Science & Business Media (2012) 31. López, H.A., Feng, B., Lindner, J., Franceschetti, M., Abbad-Andaloussi, A.: Ambiguity detection in business process descriptions: An evidence and an automated approach. In: BPM. pp. 379–396. Springer (2025) 32. López, H.A., Simon, V.D.: How to (re) design declarative process notations? a view from the lens of cognitive effectiveness frameworks. In: POEM. CEUR-WS (2022) 33. Moody, D.: The “physics” of notations: toward a scientific basis for constructing visual notations in software engineering. IEEE Trans. Softw. Eng. 35(6), 756–779 (2009) 34. Okoli, C., Pawlowski, S.D.: The delphi method as a research tool: an example, design considerations and applications. Information & management 42(1) (2004) 35. Pacheco, D., Aveiro, D., Pinto, D., Freitas, V.: User-perceived quality and functional suitability of representations of demo’s process and fact models: Conclusions from a family of three studies. Ieee Access 13, 140742–140770 (2025) 36. Pesic, M., Schonenberg, H., Van der Aalst, W.M.: Declare: Full support for looselystructured processes. In: EDOC 2007. pp. 287–287. IEEE (2007) 37. Reijers, H.A., Slaats, T., Stahl, C.: Declarative modeling–an academic dream or the future for bpm? In: BPM. pp. 307–322. Springer (2013) 38. Russell, N.C., Ter Hofstede, A.H., Van Der Aalst, W.M., Mulyar, N.A.: Workflow control-flow patterns: A revised view (2006) 39. Saldaña, J.: The Coding Manual for Qualitative Researchers. SAGE Publications, 4th edn. (2021) 40. Siegmund, J., Peitek, N., Parnin, C., Apel, S., Hofmeister, J., Kästner, C., Begel, A., Bethmann, A., Brechmann, A.: Measuring neural efficiency of program comprehension. In: FSEN. pp. 140–150 (2017) 41. Todorovic, D.: Gestalt principles. Scholarpedia 3(12), 5345 (2008) 42. Trinh, D.M.T., Abbad-Andaloussi, A., López, H.A.: On the semantic transparency of declarative process models: the case of constraints. In: CoopIS. pp. 217–236. Springer (2023) 43. Turetken, O., Rompen, T., Vanderfeesten, I., Dikici, A., van Moll, J.: The effect of modularity representation and presentation medium on the understandability of business process models in bpmn. In: BPM. pp. 289–307. Springer (2016)
Understandability of Conceptual Models via Abstract Notation Engineering
17
44. Winter, M., Pryss, R., Probst, T., Baß, J., Reichert, M.: Measuring the cognitive complexity in the comprehension of modular process models. IEEE Transactions on Cognitive and Developmental Systems 14(1), 164–180 (2022) 45. Wohlin, C., Runeson, P., Höst, M., Ohlsson, M.C., Regnell, B., Wesslén, A., et al.: Experimentation in software engineering. vol. 236. Springer (2012) 46. Zeising, M., Schönig, S., Jablonski, S.: Towards a common platform for the support of routine and agile business processes. In: 10th IEEE international conference on collaborative computing: networking, applications and worksharing. IEEE (2014) 47. Zhou, Y., López, H.A.: A compositional approach to mapping bpmn to dcr for cross-paradigm process modeling. In: FormaliSE ’26. vol. To appear (2026) 48. Zugal, S.: Applying Cognitive Psychology for Improving the Creation, Understanding and Maintenance of Business Process Models. Ph.D. thesis, University of Innsbruck (2013)