Page 191 -
P. 191

182                                                          M. Pesic
                           6.2.2 Constraint Templates


                           Procedural workflow languages such as YAWL provide constructs such as AND-
                           split, AND-join, cancelation region, etc. These constructs aim at supporting fre-
                           quently needed workflow patterns. For our declarative approach, we also aim at
                           supporting frequently needed patterns to model relationships (constraints) between
                           tasks. However, we aim at different types of patterns, that is, declarative constructs
                           aiming at more flexibility. In principle, LTL offers everything needed to support
                           such patterns. However, because LTL formulas can be difficult to understand by
                           nonexperts, we provide a graphical representation of constraints that hides the asso-
                           ciated LTL formulas from users of declarative workflow, in the form of constraint
                           templates. Each template has (1) a name, (2) an LTL formula, and (3) a graphi-
                           cal representation. A constraint inherits the name, graphical representation, and the
                           LTL formula from its template. Figure 6.5 depicts some example constraint tem-
                           plates. The template parameters are depicted by boxes. Templates can be used to
                           create actual constraints for a specific process. In actual constraints, tasks replace
                           template parameters, both in the graphical representation and the associated LTL
                           formula.
                              The existence template is graphically represented with the annotation “1:: ”
                           above the task. This indicates that A is executed at least once in each instance. The
                           template init.A/ can be used to specify that task A must be the first executed task in
                           an instance. Templates response, precedence,and succession consider the ordering
                           of tasks. Template response requires that every time task A executes, task B has to be
                           executed afterwards. Note that this is a very relaxed interpretation of the notion of
                           response, because B does not have to execute straight after A, and another A can be


                                        1..*        init
                            existence(A)   A  init(A)   A  alternate precedence(A, B)   A  B


                            response(A, B)   A      B      not co-existence(A, B)   A     B

                            precedence(A, B)   A    B                            A   1 of 4  D
                                                           1 of 4 (A,B,C,D)
                            succession(A, B)   A    B                             B      C
                                       Where
                                       existence.A/      ♦A
                                       init.A/           A
                                       response.A; B/     .A ) ♦B/
                                       precedence.A; B/    .:B/WA
                                       succession.A; B/    response.A; B/ ^ precedence.A; B/
                                       not co-existence.A; B/  :.♦A ^ ♦B/
                                       1of 4.A; B; C; D/    ♦A _ ♦B _ ♦C _ ♦D
                           Fig. 6.5 Constraint templates
   186   187   188   189   190   191   192   193   194   195   196