{'fraction_non_alphanumeric': 0.029376641987102936, 'fraction_numerical': 0.006994438568357842, 'mean_word_length': 4.858484909054567, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Evaluating Perceived Usefulness and Ease of Use of CMMN and DCR

Case Management has been gradually evolving to support Knowledge-intensive business process management, which resulted in developing different modeling languages, e.g., Declare, Dynamic Condition Response (DCR), and Case Management Model and Notation (CMMN). A language will die if users do not accept and use it in practice - similar to extinct human languages. Thus, it is important to evaluate how users perceive languages to determine if there is a need for improvement. Although some studies have investigated how the process designers perceived Declare and DCR, there is a lack of research on how they perceive CMMN. Therefore, this study investigates how the process designers perceive the usefulness and ease of use of CMMN and DCR based on the Technology Acceptance Model. DCR is included to enable comparing the study result with previous ones. The study is performed by educating master level students with these languages over eight weeks by giving feedback on their assignments to reduce perceptions biases. The students' perceptions are collected through questionnaires before and after sending feedback on their final practice in the exam. Thus, the result shows how the perception of participants can change by receiving feedback - despite being well trained. The reliability of responses is tested using Cronbach's alpha, and the result indicates that both languages have an acceptable level for both perceived usefulness and ease of use.


Introduction
Case Management is a research paradigm that supports knowledge-intensive process (KiP) management [9]. The support is defined around the concept of the case, e.g., patient in the healthcare or customer in the insurance domain. In these processes, knowledge workers decide how a case shall proceed instead of predefined rigid rules. As a result, the support for KiPs differs from the workflowbased processes so that even the management lifecycle needs its variation, known as Collaborative knowledge work lifecycle [9].
The collaborative nature of work in KiPs requires more freedom by knowledge workers to decide how a case shall proceed. Therefore, traditional workflowbased models could not support case management, for they become too complex by capturing the high degree of flexibilities required by different cases. Thus, several case management modeling languagues are defined, e.g., Declare [27,28], Dynamic Condition Response (DCR) [16], and Case Management Model and Notation (CMMN) [25] which is based on Guard-Stage-Milestone (GSM) [17]. As these languages are new, it is hard to predict if they will be accepted by users, which opens up rooms for further investigation.
The user acceptance of process modeling languages, like other information systems, can be evaluated based on two variables, i.e., perceived usefulness (PU) and perceived ease of use (PEU) [8]. Currently, there are few studies on how users perceive Declare and DCR, e.g. [13,30,35]. However, there is a gap in how users perceive CMMN. Therefore, this study aims to evaluate the user acceptance of CMMN language. It also includes DCR to have a comparison reference to relate the result to other investigations. DCR is selected because it is expected to be more comprehensive than Declare, as it has fewer modeling elements [30]. The evaluation is performed based on the Technology Acceptance Model [8].
As these languages are new, it is hard, if not impossible, to find users who already know them. Thus, the users shall be trained, and the acceptance shall be measured based on their perception (self-assessment). As the self-assessment is a subjective score, it can differ during the learning process due to biased factors, i.e., over-or under-confidence [10]. These biased factors can be minimized by repeated experiences and feedback [10]. In this study, we aim to answer this research question: -How do trained process designers perceive the usefulness and the ease of use of DCR and CMMN languages for modeling knowledge-intensive processes?
To answer this question, we trained students in the business process and case management course at Stockholm University. The students practiced DCR and CMMN for around eight weeks and received feedback on their assignments -to minimize the overconfidence and underconfidence biases. Finally, we collected perceptions from those who were interested in participating in this study before and after the feedback on their performance on the exam. Participation in this study was optional. The reliability of responses is tested using Cronbach's alpha, and the result shows that both languages have an acceptable level for both perceived usefulness and ease of use.
The remainder of this paper is structured as follows. Section 2 gives a brief background on related work. Section 3 describes the method that is used in this study. Section 4 reports the result, and Section 5 concludes the paper.

Background
This section summarizes related works and excerpts of DCR and CMMN notations, which are used later to present sample processes. Please note that we do not aim to give the full syntax of these languages, which can be found in related literature.

Users perceptions in business process management
A language will eventually die if people do not accept and use it in practice, which is also true for business process modeling languages. Thus, it is important to evaluate how users perceive languages to determine if there is a need for improvement. The evaluation can help us to improve process modeling languages. Here, we mention some related work that evaluated the user acceptance in the Business Process Management (BPM) area, in general, and in the case management area, in particular.

Users perceptions in business process modeling
Process models can easily become complex as they represent complex business processes in practice, so different approaches have been developed to enable process designers to deal with the complexity. La Rosa et al., categorize these approaches into two main category, i.e., concrete syntax modifications [22] and abstract syntax modifications [23]. They also identified different patterns that can be applied in each category.
The concrete syntax modifications refer to i) using highlights, ii) following layout guidelines, iii) following naming guidelines, or iv) applying different representations techniques, e.g., using icons for tasks or etc [22]. The abstract syntax modifications refer to applying different abstraction techniques in business process modeling, e.g., using vertical, horizontal, or orthogonal modularization technqiues [23]. La Rosa et al. evaluated how users perceived usefulness and ease of use of the identified patterns by applying the technology acceptance model [8].
Their evaluation study showed that all identified patterns are perceived as relevant.
The users' perception evaluation is important because the artifact's actual usage is influenced by the potential users' perceptions -which can be measured in terms of usefulness and ease of use [8]. Therefore, researchers have used techniques like the technology acceptance model to evaluate different business process modeling techniques. For example, the technology acceptance model is used to evaluate i) how users perceived orthogonal modularization based on aspect-oriented business process modeling in [19,20], ii) how users perceived the vertical decomposition using BPMN in [32], and iii) how graphical highlights can increase the cognitive effectiveness of business process models in [21].

Users perceptions in case management
Case management is fairy new paradigm in comparison with Business Process Management, and few languages have been developed to support managing cases. Declarative Service Flow Language (DecSerFlow) [33] (a.k.a., Declare) can be considered as one of the first attempts for such lanaguagues.
The understandability and maintainability of process models is a crucial requirement for any process modeling language. Thus, Fahland et al. identified and hypothesized a set of propositions for differences between imperative and declarative process modeling languages concerning understandability and maintainability in [11] and [12], respectively. Weber et al. [34] conducted a controlled experiment to investigate if process designers can deal with increased levels of constraints when using Declare. The participants were 41 students from two universities. The results show that the participants can deal with introduced constraints, which justified further development of declarative process modeling.
Pichler et al. investigated if the imperative or the declarative process modeling languages are better understood by running an experiment with 27 students [29]. Their study shows that the imperative process modeling languages are better understood by students. The technology acceptance model is used for the first time to assess how professionals perceived Declare, and DCR languages by Reijers et al. [30]. Ten professionals from the industry participated in their workshop, and the result shows that they found the languages easy to learn. This study also revealed the potential for defining hybrid approaches. Several hybrid process modeling is proposed, among which the understandability of DCR-HR is investigated through an explorative study [2].
Zugal et al. [35] investigated the effect of using hierarchies in expressiveness and understandability of declarative models. The study is based on nine participants in two universities. It shows that hierarchies enhance expressiveness. It also shows that the hierarchies can increase the models' understandability, but they should be applied with care. Haisjackl et al. [13] investigated how declarative models are understood through an explorative study. Their study shows that the subjects could understand a single constraint well, but it was challenging for them to handle a combination of constraints. This study also shows that some graphical notation in Declare, which are similar to imperative modeling languages, causes considerable trouble in understandability.

Dynamic Condition Response (DCR)
Hildebrandt and Mukkamala introduced DCR in 2010 as a declarative process modeling languague [14]. The syntax of the language includes the definition of nodes (the group of an activity and its roles) and the relation that can be defined among them, i.e., response (•→), condition (→•), inclusion (→+), and exclusion (→%) [14].
They also defined semantics for DCR, where several events can occur for a node. A node can be included or excluded from the process structure. A node can also be in the pending state, meaning that the process cannot successfully be finished until an event of the node occurs. In short, the response relation among nodes a and b (a •→ b) means that the state of node b will be pending if an event of node a happens. More precisely, event b must eventually happen if event a happens. The condition relation among nodes a and b (a →• b) means that an event of b cannot be occured unless a occurs.
The DCR's syntax and semantics have evolved over the years. For example, the syntax is enriched to represent the excluded nodes by dashed border line [16]. The extended syntax also represents a node's pending state by decorating it with an exclamation mark (!). In addition, milestone relation (→ ) and nested nodes are also introduced to the languague [15]. The milestone relation among two nodes a and b (a → b) means that b can occur as long as a is not in the pending state. DCR graph is the toolset that enables modeling and simulation of DCR models. Currently, it supports other relations, including Pre-Condition. The precondition relation among two nodes a and b means that a → b ∧ a →• b. This relation is represented with the same graphical notation as the milestone but with a different color. Fig. 1 shows an excerpt of DCR syntax.

Case Management Model and Notation (CMMN)
Case Management Model and Notation (CMMN) is a case modeling language which is defined by Object Management Group (OMG) [25]. This language is developed by extending the Guard-Stage-Milestone (GSM) languague [17,18]. Fig. 2 shows an excerpt of CMMN syntax.
The case plan model, represented by a folder, is the core part of a CMMN model. The case plan model captures the complete behavior of a case, and all other elements will be children of the case plan model. The case file item represents the data, Task represents activities that can happen, Stage represents a container that includes other elements (like subprocess in BPMN), Milestone represents an achievable target, and event respresents something that happens during the course of a case. Some elements like tasks can have sentries on their border. A sentry can represent entry criterion or exit criterion, which defines the condition or event -based on which the element can be enabled or terminated, respectively.
Tasks and Stages can also be represented by the dashed borderline, which is known as discretionary task or discretionary stage. Discretionary elements are not available to knowledge workers at runtime. However, they can add these elements to their case plan at runtime. These elements can be related to each other through lines, and the connection rules are defined in CMMN specification [25]. Elements can also be decorated using different decoration icons. For example, ! or # indicates that the task, stage, or milestone are mandatory or repetitive, respectively.

Research Method
Davis F.D. describes how the actual system's usage depends on the attitude of users, which can be predicted using two variables: perceived usefulness (PU) and perceived ease of use (PEU) of a system [7]. He also defined measurement scales that can be used to evaluate these variables [8]. This evaluation technique is widely used to evaluate different information systems including different business process modeling languagues, e.g. [19,20,22,23,30]. This study adopted the technology acceptance model to evaluate how users perceive DCR and CMMN in concern with these variables.
The user acceptance evaluation is a sort of subjective score because users need to respond based on self-assessment. Thus, the result can change during repeated experiences due to self-assessment biases. These biases are rooted in over-or under-confidence, which can be minimized by repeated experience and feedback [10]. Indeed, the answers will be more reliable when these biases are minimized.
To minimize the over-and under-confidence, we trained the students in the business process and case management course at Stockholm University for around eight weeks. In this period, students practiced DCR and CMMN languages in groups by designing process models, and they received feedback. They also had two sessions with an external expert to ask their questions for DCR language. Then, they participated in the exam where they needed to design a DCR and a CMMN model for a given case description individually. The data collection and data processing for this study starts after the exam, which is shown in Fig. 3. Participation in this study was voluntary.
In this study, we collect data from students through two surveys conducted before and after giving feedback on their exams. We call them Survey 1 and Survey 2, respectively. The surveys were identical, but students did not know about it beforehand. The questions are defined based on [7] could response by choosing options in the range of extremely unlikely (1), quite unlikely (2), slightly unlikely (3), neither likely nor unlikely (4), slightly likely (5), quite likely (6), and extremely likely (7). After the exam, survey 1 is sent out, and the responses are collected upon the announced deadline. Then, we published the grades and comments for the exam result. We gave students five days to go through the comments and discuss their questions with the teacher. Then, we sent out the second survey to those who participated in the first survey. We collected data that were submitted before the announced deadline. Finally, we started data analysis.
We analyzed the collected data from Survey 1, and we name it Study 1. The second survey responses are linked with the first one to analyze the result before and after the feedback. We analyzed the collected data from the linked data source containing both Survey 1 and Survey 2, and we name it Study 2. This study includes the result of students who participated in both Survey 1 and Survey 2, enabling us to track how opinions are changed after receiving the feedback. We tested if the changes in responses are significantly different through three nonparametric test of the null hypothesis techniques. To test the reliability of responses, we used Cronbach's alpha, which is widely used in related work, e.g. [5,6,24,26]. The Cronbach's alpha value above 0.7 is usually considered as reliable.
The details of the study will be given in the result section. Here, we also give the case description for which students designed a DCR and a CMMN model.

Case Description
Managing courses is a sort of knowledge-intensive process which relies on the skills and knowledge of academic staff as knowledge workers. This text describes the course management process at the department of computer and systems sciences (DSV) at Stockholm University.
The process starts when the course director registers each course coordinator when the course planning period begins. After the course coordinator is registered, (s)he can set up the courses. (S)he must publish the course contents and define the course schedule. It is important to check potential conflicts among mandatory sessions among different courses. Thus, the administrative personnel needs to check the conflicts after the course coordinator schedule the course. If they approve, the course coordinator needs to release the course, so students can see the schedule. Indeed, the course coordinator shall release the course after (s)he apply any changes so that students can see the changes.
To avoid having unreleased courses, the administrative personnel will notify course coordinators sometimes before the academic term starts. Note that the course coordinator can change the course content and schedule during the course several times, but the same process shall be followed. After the course is released, the course coordinator can run the course, which includes Registering groups, Publishing Recorded Lectures, opening submission box, and Registering Assignments Grades. These activities can be done several times during the course.
The course coordinator can also start preparing the exam after the course is released. It includes submitting exam questions and reporting the exam grades. The course coordinator needs to Upload Answer sheets after reporting the exam grades. The grades can vary between A to F. There is a special grade known as Fx. This grade means that the student has not passed the exam, but the submission was very close to the passing grade. In such a case, the course coordinator can Define and publish complementary Assignments for those students. The course coordinator needs to Correct Submissions and Report Grades in such a case. Note that this change will only be given to students once.
After the course and its examination is over, the course coordinator shall evaluate the course. The evaluation starts by defining and publishing the evaluation form. After the evaluation is done, the course coordinator shall write and Submit the Course Evaluation.

Result
Among 24 master level students who registered for the exam, 20 students participated in Study 1 among which 13 students also participated in Study 2. In Study 1, 9 and 11 students were male and female, respectively; while in Study 2, 5 and 8 students were male and female, respectively. The average age for students in both studies was around 34, who participated in the "Master's Programme in Open eGovernment" -which is a distance program. It is usual to have students with an industrial background in this course.
Students were familiar with BPMN process modeling languages, but they did not declare any prior experience on a declarative process modeling language. Each student submitted one DCR and one CMMN model, so we collected different versions of their designs. Here, we elaborate on how the process can be designed using these languages through two sample models. We will elaborate on the study result afterward.

Sample DCR model
The case is modeled differently by each student, as there is the possibility to decide on the level of flexibility that a KiP model shall support. Fig. 4 shows a sample DCR model for the given case description.
In this model, the start of the process is modeled to be rigid -meaning that the process has only one start point, i.e., Register course coordinators. The course director can perform this activity, and it is annotated as mandatory to apply more constraints for knowledge-workers to finish the process. This activity excludes itself after execution, meaning that it can only be performed once! This constraint is not specified in the case description, and it can be considered as an extra control that the designer applied. This constraint may cause a problem as the course director may want to assign another course coordinator later, which is not given in the case description. As there might be many similar situations in the real world, it might be better if the process designer avoids applying extra control on models when designing KiPs. The execution of register course coordinators activity enables course setup, which includes five activities. The process model captures the case description. Here, the self-Exclude relation applies extra control, which can be avoided. After Release course activity, Running course and Examination are enabled. The Running course is quite flexible to give freedom to the course coordinator to choose how to do the activities. The Examination includes five activities -all decorated with a self-Exclude relation to limit the number of their execution. All exclusions are fine as they are aligned with the case description, except Submit Exam questions. Again, the process is designed too rigid as it is expected for this node.
After Submit Exam questions is performed, the Course Evaluation will be enabled. The self-Exclude relations are not needed again here, as they make the process rigid. Fig. 5 represents a sample CMMN model for the given case description. In this model, every top-level task, stage, and milestone has a sentry as an entry criterion, which means that they are not enabled when the model is created -as their condition is not fulfilled. Thus, the process starts when the Start of course planning timer event occurs AND the course director starts Register course coordinators task. Note that if two events are related to an entry criterion sentry, both of them shall be fulfilled, which is equivalent to AND join in workflowbased models. To show the OR relation, events shall be related to different entry criterion sentries, e.g., look at Release Course activity. To specify the resource that performs a task, one can relate the resource directly to the entry criterion. However, this can make the model very complex. Thus, DCR representation for resources seems better in terms of model simplicity.  There is also one difference in how DCR and CMMN enable flexibility in terms of repeatable tasks/activities. In DCR, an activity can be repeated unless explicitly limited. In contrast, a task is not repeatable in CMMN by default. It needs to be decorated with Repition Rule (#). So knowledge-worker can repat the task.

Sample CMMN model
When the course director performs the Register course coordinators, the Course setup stage would be enabled. After the stage is completed, the Course released milestone would be achieved. This milestone enables Running Course and Examination stages. Finally, the Course Evaluation can be done to finish the process.
It is possible to analyze all students' submissions to explore how the case is modeled differently in these languages. We skip this analysis as it is outside the scope of this paper. and Study 2 representing the perception of students before and after recieving the feedback, respectively. It worth reminding that some students from Study 1 did not participated in Study 2, so the perception of students for Study 1 who participated in Study 2 is also demonstrated in the Study 2 through dashed box plot.

Perception Analysis
In Study 1, represented by the left-sub-figure in Fig. 6), the median for both PU and PEU is around 5 (out of 7). In Study 2, represented by the right-subfigure in Fig. 6), the median for PU before and after the feedback is around 5. The difference is visible in the first and second quartiles, where some students lowered their scores for PU after receiving feedback. The difference for PEU is even more, where the median is lowered by one after receiving the feedback. We will check if the difference is significant later. Fig. 7 shows the means and 95% confidence interval for all measures that are demonstrated in Fig. 6. The distribution of our data is not normal, so we cannot for the responses that we received before and after the feedback. Fig. 8 shows the distribution of responses in these two cases in addition to the p-values. The null hypothesis (H 0 ) is that the distribution of responses before and after the feedback are the same for both PU and PEU. The p-values are greater than 0.05, so we cannot reject the null hypothesis. Thus, the feedback did not change the perceptions significantly. Table 1 shows the Cronbach's alpha result that we calculated per variable per language, where all values are above 0.7, which is generally considered as the accepted threshold. The Cronbach's alpha for PU for both languages and PEU of DCR is quite high, i.e., above 0.9. However, Cronbach's alpha for PEU of CMMN is not as high as others. Table 2 shows the Cronbach's alpha result that we calculated per variable per language before and after feedback, where all values are above 0.7. The Cronbach's alpha for all measures is quite high, i.e., above 0.9, except the Cronbach's alpha for PEU of CMMN before the feedback, which is 0.78. It is worth mentioning that Cronbach's alpha for PU and PEU of both languages before the feedback is similar to their Cronbach's alpha for the whole population reported in Table 1

Discussion on biases and threats to validity
First, we have used students as our test subjects instead of real process designers as explained and motivated in this paper. Students are considered valid subjects in this area as these languages are new and are mostly unknown for practitioners outside. Thus, students can be used to evaluate how these languages can be perceived by process designers, which is also used in related work such as [1-4, 13, 29, 31, 34]. The use of students as subjects can weaken the causal relation for predicting if the artifact will be used in the future. The fact that students belong to the same class and trained under the same process can also be considered as a learning bias. Second, it shall be mentioned that students were familiar with BPMN business process modeling language, which may potentially impact their PU and PEU of declarative languages. From the author's perspective, this impact is unknown, and it will be interesting to evaluate if prior knowledge on workflow-based modeling language can have a positive or negative impact! Third, feedback can impact the subjects' opinions as they can be used as positive or negative treatment. However, the lack of feedback can result in underor over-confidence biases. We tried our best to use neutral wording [10] to minimize this effect in this study.

Conclusion
In this paper, we reported our study result on how CMMN and DCR has been perceived in terms of usefulness and ease of use. The study is performed by applying the technology acceptance model, where we educated master level students with these languages over eight weeks by giving feedbacks to reduce perception biases. The students' perceptions are collected through two questionnaires as two sub-studies (studies 1 and 2). We collected students' opinions before and after sending feedback on their final practice in the exam in study 1 and study 2, respectively. In total, twenty students participated in Study 1 among which thirteen students also participated in Study 2.
The study result indicates that both languages have an acceptable level for both perceived usefulness and ease of use. The students' perceptions have changed a little before and after receiving the feedback. We performed three nonparametric statistical significance tests, and the result indicates that the difference is not significant. We also evaluated the reliability of responses using Cronbach's alpha. The result showed an acceptable level of reliability in students' responses.
As future work, it is interesting to investigate how prior knowledge on workflowbased business process modeling can influence users' perception when learning declarative modeling languages. It is also interesting to perform this study with more participants and different backgrounds.