Overzicht Deel I — Inleiding & Achtergrond Declaratieve Programmeertalen Constraint Handling Rules (CHR) Doelstellingen Deel II — Taalontwerp Deel III — Optimaliserende Compilatie

Voorbeeld: routebepaling

Beste route tussen: A: Naamstraat 22, Leuven B: Ladeuzeplein, Leuven

Abstractie: wereld  kaart

Abstractie: kaart  gerichte gewogen graaf

20 Edsger Dijkstra ( ) Kortste pad?

Edsger Dijkstra ( )

Imperatieve Programmeertalen Meeste conventionele programmeertalen Fortran, Cobol, Pascall, C, C++, Java,... Van Dale: im·pe·ra·tief de; m (taalk) gebiedende wijs Programma = specificatie opeenvolgende stappen HOE? // HOE? overloop alle getallen uit de gegeven ‘invoer’ for (int i = 0; i < invoer.length; i++) { if (invoer[i] > 0) positief.add(invoer[i]); } FILTER POSITIEVE GETALLEN (J AVA )

HOE? // HOE? overloop alle getallen uit de gegeven ‘invoer’ for (int i = 0; i < invoer.length; i++) { if (invoer[i] > 0) positief.add(invoer[i]); } J AVA [ x | x 0 ] H ASKELL positief(X) :- invoer(X), X > 0. P ROLOG “the Holy Grail of programming: the user states the problem, the computer solves it” Programma = beschrijving probleem / oplossing “ WAT, niet HOE ” Wiskundig formalisme (functies, logica,...) Declaratieve Programmeertalen {x | x  invoer en x > 0} invoer(X), X > 0 => positief(X). CHR 2 logische implicatie ‘  ’ (“daaruit volgt”) logische implicatie ‘  ’ (“volgt uit”)

“the Holy Grail of programming: the user states the problem, the computer solves it” Programma = beschrijving probleem / oplossing “ WAT, niet HOE ” Wiskundig formalisme (functies, logica,...)  Voordelen: Minder en eenvoudiger programmmeerwerk Beknopt, leesbaar, onderhoudbaar,... Analyses (terminatie, correctheid,...) Efficient Declaratieve Programmeertalen

457f 464c b e e e d d d ad ad e d ad ad d d e c2f c2f 2d64 696c 756e 2e78 6f73 322e e f e d b a c e d b fa c d e d b a 0000 ae c e 000f b d c e6d 6f73 362e 6c00 676f 5f00 764a 525f c f00 675f 6f6d 5f6e f74 005f 696c e 2e6f e d f c61 6f6c e e f 5f4f f6e f00 6c5f f f74 616d 6e c f43 2e d d ae e ae a ae ae6c ae ae ae ae7c ae ae ae ae8c d e5 08ec e5e e c 0000 a7e c900 00c3 35ff ae ff ae ff ae e900 ffe0 ffff 25ff ae6c e900 ffd0 ffff 25ff ae e900 ffc0 ffff 25ff ae e900 ffb0 ffff 25ff ae e900 ffa0 ffff 25ff ae7c e900 ff90 ffff 25ff ae e900 ff80 ffff 25ff ae e900 ff70 ffff 25ff ae e900 ff60 ffff 25ff ae8c e900 ff50 ffff ed31 895e 83e1 f0e e be8 ffff f4ff e5 00e b00 c f b c0 ff02 8bd0 fc5d c3c e5 08ec 3d80 ae a12d ad b d285 1b74 b68d c083 a304 ad d2ff 08a1 04ad 8b d2 c6eb ae 0108 c3c9 f e5 08ec 58a1 04ae c0 b c c ae e808 7a9c f7fb b68d bf8d ec89 c35d d2 57e5 c f6 ec81 011c 0000 db ff20 ffff d231 b589 ff2c ffff 9d89 ff28 ffff 8d89 ff24 ffff 9589 ff1c ffff b68d bf8d d8d ff78 ffff 0c89 e824 fe4e ffff c f be0f 7885 ffff ffff 2c8a5 ffff 83ff 64f8 840f 03f f0f f f49 853f 74c0 83c3 0af8 be74 10ba b04 951c ad b58b ff2c ffff 04c7 c c c 890c 2474 e808 fe10 ffff 04c e800 fe24 ffff f883 eb63 8dc bd8b ff20 ffff ff85 840f b ff1c ffff 953b ff64 ffff 8d0f d ff58 ffff 86be d08 788d ffff 89ff d10 54bd ffff 8dff 509d ffff 89ff 247c 890c 245c c e7e8 fffd 83ff 03f8 850f 00bc d8b ff50 ffff c f 00a b ff60 ffff c139 8f0f b ff54 ffff d f c239 8f0f b58b ff44 ffff bd8b ff1c ffff 9d8b ff40 ffff 44ff 048e 348d 8b ffff 89ff bb0c 9d8b ff30 ffff 3c8d 3bf0 4c95 ffff 8bff 58b5 ffff 89ff 047b d 9589 ff4c ffff 8d3b ff4c ffff 067d 8d89 ff4c ffff 953b ff48 ffff 067e 9589 ff48 ffff 8d3b ff48 ffff 067e 8d89 ff48 ffff 85ff ff1c ffff 8583 ff30 ffff e908 fe70 ffff 0fba 0000 e900 fead ffff 0eba 0000 e900 fea3 ffff 0dba 0000 e900 fe99 ffff 0cba 0000 e900 fe8f ffff f883 0f70 ff f00 9c8f ef8 850f fe72 ffff bd8b ff28 ffff ff85 7f74 958b ff20 ffff d285 6b75 96b d ffff bbff d89 ff20 ffff b58d ff5c ffff c e824 fcac ffff c e 858b ff5c ffff c085 1d78 958b ff60 ffff d f 9589 ff4c ffff c ff48 ffff c5e9 fffd baff 000a e9 fffe baff f8e9 fffd baff eee9 fffd baff e4e9 fffd 83ff 74f8 850f fdd6 ffff bd8b ff24 ffff ff85 3a75 758b 8d ffff b9ff 98a bb d89 ff24 ffff c de8 fffc 48ff 06ba f fffd e9ff fd97 ffff 05ba 0000 e900 fd8d ffff b68d bd8b ff28 ffff ff85 8f0f d8d ff64 ffff abb d08 608d ffff 89ff 245c 8d ffff beff b589 ff28 ffff 9d8d ff68 ffff 4c89 0c24 5c e824 fbae ffff f883 0f03 f fc00 bbbf 0498 b de89 a6f3 850f 00d b ff60 ffff c085 8e0f 00bf 0000 bd8b ff64 ffff ff85 8e0f 00b b c0 04be c be8 fffb 89ff 3885 ffff 8bff 64bd ffff baff c 2de8 fffb 89ff 3485 ffff 8bff 649d ffff 89ff c 15e8 fffb 89ff 4085 ffff 8bff 608d ffff b8ff c c f5e8 fffa 89ff 4485 ffff 8bff 3895 ffff 85ff 74d2 8b28 34b5 ffff 85ff 74f6 851e 74c0 8b1a 4085 ffff 8bff 349d ffff 85ff 89c0 309d ffff 0fff 1185 fffc baff ee9 fffc baff e9 fffc baff ae9 fffc baff e9 fffc 31ff e9d2 fc29 ffff 0bba 0000 e900 fc1f ffff 158b ae e824 fa16 ffff c085 11ba f fffc 8bff 2c85 ffff baff c f fbf1 ffff 9d8b ff64 ffff 12ba c9d ffff 0fff da8c fffb 8bff 24bd ffff 85ff 75ff 8b c7 6e75 6e6b 46c7 6f04 6e77 8b00 4c95 ffff 8bff 3485 ffff 8bff 38bd ffff 8dff 920c 8942 cf04 8d8b ff48 ffff 9589 ff3c ffff fca 8b3e 38b5 ffff 8dff 923c 148d 8bfe 3cb5 ffff 8bff 44bd ffff ffff 3c85 ffff 8bff b744 03fc b bb7 34b5 ffff 8dff c63c 3a89 c c8d ffff 7eff 8bce 4cbd ffff 8bff 4895 ffff 89ff 3cbd ffff 39ff 0fd7 1a8d d00 bf04 8d8b ff50 ffff bd8b ff38 ffff 958b ff58 ffff 748d 28c7 b589 ff14 ffff 858b ff14 ffff 9d8b ff34 ffff 308b 858b ff3c ffff de29 9d8b ff44 ffff fec b5 ffff 8bff 833c f739 8d0f 009a d8b ff40 ffff 0c8b 3bbb 3c8d ffff 89ff 0fc b00 349d ffff 8dff fb34 b589 ff30 ffff ce89 958b ff44 ffff 9d8b ff34 ffff 0c8b 8b ffff 8dff cb14 408b 8b04 045a b ffff 89ff b 1a8b b ff30 ffff 958b ff40 ffff b 898a ba04 858b ff44 ffff 3489 ff8a b b 3bba 3cb5 ffff 89ff 75f0 8ba3 3c8d ffff 89ff 47da bd3b ff18 ffff 8c0f ff66 ffff 85ff ff3c ffff bd8b ff48 ffff 8583 ff14 ffff cbd ffff 0fff 178c ffff 89ff 5895 ffff 8bff 649d ffff 89ff 508d ffff 8bff 0c7d b58b ff48 ffff 4d8b b1f 4c9d ffff 29ff 46de 5d8b b31 5c8d ffff 8bff 38b5 ffff 8dff c8d 8bd6 1c55 3b89 9d8b ff4c ffff 048d 899b 891a 8ddf c61c 758b bf ffff 89ff 8b1e 145d c 8d3b ff48 ffff 0a7e 13ba 0000 e900 f9bb ffff 558b 8b18 8b ea74 8d8b ff44 ffff 0c89 e824 f826 ffff bd8b ff40 ffff 3c89 e824 f818 ffff c c 0000 c031 5e5b 5d5f ebc3 900d a155 aea e bc0 a03d 04ae f53 b28e 0001 c f8b 4818 a8a3 04ae 8b f939 0d89 aed aeb f 01b f8b d2 bc1d 04ae 0f08 8b b89 a118 aed c f 016e 0000 d0a3 04ae 8b b aeac aec d8b aed b 8914 cc0d 04ae 8908 b815 04ae 8d b 891c 8bd aedc 0804 d f b d0f aec d89 aedc d8b aec b c b 8918 bc15 04ae a308 aec dca1 04ae 8b ff 891c 0c41 d aeb a110 aedc 0804 d0a3 04ae c708 9e d8b aed e9 ffff 90ff 428b a314 aebc a cdeb 0d89 aec eb 0c89 8b9e c00d 04ae 3908 cc0d 04ae 8908 d41d 04ae b11 b81d 04ae 8908 d01d 04ae e908 ff12 ffff 1d8b aeb d231 ffb9 ffff 893f a40d 04ae 8908 d415 04ae edb b b fc8e c085 2d74 dca3 04ae d2 8e54 a1fc aedc b 3b04 a415 04ae 7d08 890b a415 04ae zeer hoog niveau hoog niveau hoog niveau laag niveau machine- niveau machine- niveau MACHINECODE

.L3: addl$1, -148(%ebp) movzbl-116(%ebp), %eax movsbl%al,%eax movl%eax, -268(%ebp) cmpl$100, -268(%ebp) je.L7 cmpl$100, -268(%ebp) jg.L11 cmpl$97, -268(%ebp) je.L6 cmpl$97, -268(%ebp) jg.L12 cmpl$0, -268(%ebp) je.L2 cmpl$10, -268(%ebp) je.L2 jmp.L4.L12: cmpl$99, -268(%ebp) je.L2 jmp.L4.L11: cmpl$112, -268(%ebp) je.L9 cmpl$116, -268(%ebp) je.L10 cmpl$110, -268(%ebp) je.L8 jmp.L4.L9: cmpl$0, -144(%ebp) jle.L13 movl$0, -124(%ebp) jmp.L15.L13: movl$1, -144(%ebp) leal-220(%ebp), %eax movl%eax, 16(%esp) leal-204(%ebp), %eax movl%eax, 12(%esp) leal-119(%ebp), %eax movl%eax, 8(%esp) movl$.LC21, 4(%esp) leal-116(%ebp), %eax movl%eax, (%esp) callsscanf cmpl$3, %eax je.L16 movl$1, -124(%ebp) jmp.L15.L16: leal-119(%ebp), %eax movl%eax, -276(%ebp) movl$.LC22, - 280(%ebp) movl$3, -284(%ebp) cld movl-276(%ebp), %esi movl-280(%ebp), %edi movl-284(%ebp), %ecx repz cmpsb seta%dl setb%al movl%edx, %ecx subb%al, %cl movl%ecx, %eax movsbl%al,%eax testl%eax, %eax je.L18 movl$2, -124(%ebp) jmp.L15.L18: movl-204(%ebp), %eax testl%eax, %eax jle.L20 movl-220(%ebp), %eax testl%eax, %eax jg.L22.L20: movl$3, -124(%ebp) jmp.L15.L22: movl-204(%ebp), %eax addl$2, %eax movl$40, 4(%esp) movl%eax, (%esp) callcalloc movl%eax, -168(%ebp) movl-220(%ebp), %eax addl$1, %eax movl$8, 4(%esp) movl%eax, (%esp) callcalloc movl%eax, -160(%ebp) movl-220(%ebp), %eax movl$4, 4(%esp) movl%eax, (%esp) callcalloc movl%eax, -188(%ebp) movl-204(%ebp), %eax addl$2, %eax movl$4, 4(%esp) movl%eax, (%esp) callcalloc movl%eax, -192(%ebp) movl-220(%ebp), %edx movl-204(%ebp), %eax leal(%edx,%eax), %eax leal2(%eax), %edx movl-220(%ebp), %eax leal1(%eax), %ecx movl-204(%ebp), %eax addl$2, %eax movl$4, 24(%esp) movl%edx, 20(%esp) movl$8, 16(%esp) movl%ecx, 12(%esp) movl$40, 8(%esp) movl%eax, 4(%esp) movl$.LC23, (%esp) callprintf cmpl$0, -168(%ebp) je.L23 cmpl$0, -160(%ebp) je.L23 cmpl$0, -192(%ebp) je.L23 cmpl$0, -188(%ebp) jne.L27.L23: movl$4, -124(%ebp) jmp.L15.L27: movl-160(%ebp), %eax movl%eax, -156(%ebp) jmp.L2.L10: cmpl$0, -140(%ebp) je.L28 movl$5, -124(%ebp) jmp.L15.L28: movl$1, -140(%ebp) movl-264(%ebp), %eax movl%eax, 8(%esp) movl$.LC24, 4(%esp) leal-116(%ebp), %eax movl%eax, (%esp) callsscanf cmpl$1, %eax je.L2 movl$6, -124(%ebp) jmp.L15.L8: cmpl$0, -144(%ebp) jne.L32 movl$7, -124(%ebp) jmp.L15.L32: cmpl$0, -136(%ebp) je.L34 movl$8, -124(%ebp) jmp.L15.L34: movl$1, -136(%ebp) leal-208(%ebp), %eax movl%eax, 8(%esp) movl$.LC25, 4(%esp) leal-116(%ebp), %eax movl%eax, (%esp) callsscanf movl%eax, -128(%ebp) cmpl$0, -128(%ebp) jg.L36 movl$9, -124(%ebp) jmp.L15.L36: movl-208(%ebp), %eax testl%eax, %eax js.L38 movl-208(%ebp), %edx movl-204(%ebp), %eax cmpl%eax, %edx jle.L40.L38: movl$10, -124(%ebp) jmp.L15.L40: movl$0, -196(%ebp) movl-204(%ebp), %eax movl%eax, -200(%ebp) jmp.L2.L7: movl$11, -124(%ebp) jmp.L15.L6: cmpl$0, -136(%ebp) jne.L41 movl$12, -124(%ebp) jmp.L15.L41: movl-220(%ebp), %eax cmpl%eax, -132(%ebp) jl.L43 movl$13, -124(%ebp) jmp.L15.L43: leal-224(%ebp), %eax movl%eax, 16(%esp) leal-212(%ebp), %eax movl%eax, 12(%esp) leal-216(%ebp), %eax movl%eax, 8(%esp) movl$.LC26, 4(%esp) leal-116(%ebp), %eax movl%eax, (%esp) callsscanf cmpl$3, %eax je.L45 movl$14, -124(%ebp) jmp.L15.L45: movl-216(%ebp), %eax testl%eax, %eax js.L47 movl-216(%ebp), %edx movl-204(%ebp), %eax cmpl%eax, %edx jg.L47 movl-212(%ebp), %eax testl%eax, %eax js.L47 movl-212(%ebp), %edx movl-204(%ebp), %eax cmpl%eax, %edx jle.L51.L47: movl$15, -124(%ebp) jmp.L15.L51: movl-192(%ebp), %edx addl$4, %edx movl-216(%ebp), %eax sall$2, %eax addl%eax, %edx movl(%edx), %eax addl$1, %eax movl%eax, (%edx) movl-132(%ebp), %eax sall$2, %eax movl%eax, %edx addl-188(%ebp), %edx movl-216(%ebp), %eax movl%eax, (%edx) movl-212(%ebp), %eax movl%eax, %edx movl%edx, %eax sall$2, %eax addl%edx, %eax sall$3, %eax movl%eax, %edx addl-168(%ebp), %edx movl-156(%ebp), %eax movl%edx, 4(%eax) movl-224(%ebp), %edx movl-156(%ebp), %eax movl%edx, (%eax) movl-212(%ebp), %eax cmpl-200(%ebp), %eax jge.L52 movl-212(%ebp), %eax movl%eax, -200(%ebp).L52: movl-216(%ebp), %eax cmpl-200(%ebp), %eax jge.L54 movl-216(%ebp), %eax movl%eax, -200(%ebp).L54: movl-212(%ebp), %eax cmpl-196(%ebp), %eax jle.L56 movl-212(%ebp), %eax movl%eax, -196(%ebp).L56: movl-216(%ebp), %eax cmpl-196(%ebp), %eax jle.L58 movl-216(%ebp), %eax movl%eax, -196(%ebp).L58: addl$1, -132(%ebp) addl$8, -156(%ebp) jmp.L2.L4: movl$16, -124(%ebp) jmp.L15.L2:.L88: leal-116(%ebp), %eax movl%eax, (%esp) callgets testl%eax, %eax jne.L3 movlstdin, %eax movl%eax, (%esp) callfeof testl%eax, %eax jne.L61 movl$17, -124(%ebp) jmp.L15.L61: cmpl$0, -148(%ebp) jne.L63 movl$20, -124(%ebp) jmp.L15.L63: movl-220(%ebp), %eax cmpl%eax, -132(%ebp) jge.L65 movl$18, -124(%ebp) jmp.L15... zeer hoog niveau hoog niveau hoog niveau laag niveau machine- niveau machine- niveau ASSEMBLY

#define nod(node) (long)(node-nodes+1) #define VERY_FAR #define NNULL (node*)NULL typedef struct fheap_st { node *min; long dist; long n; node **deg_pointer; long deg_max; } f_heap; f_heap fh; node *after, *before, *father, *child, *first, *last, *node_c, *node_s, *node_r, *node_n, *node_l; long dg; #define BASE #define NOT_ENOUGH_MEM 2 #define OUT_OF_HEAP 0 #define IN_HEAP 1 #define MARKED 2 #define NODE_IN_FHEAP( node ) ( node -> status > OUT_OF_HEAP ) void Init_fheap (n) long n; { fh.deg_max = (long) (log ((double) n) / log (BASE) + 1); if ((fh.deg_pointer = (node **) calloc (fh.deg_max, sizeof (node *))) == (node **) NULL) exit (NOT_ENOUGH_MEM); for (dg = 0; dg < fh.deg_max; dg++) fh.deg_pointer[dg] = NNULL; fh.n = 0; fh.min = NNULL; } void Check_min (nd) node *nd; { if (nd->dist < fh.dist) { fh.dist = nd->dist; fh.min = nd; } void Insert_after_min (nd) node *nd; { after = fh.min->next; nd->next = after; after->prev = nd; fh.min->next = nd; nd->prev = fh.min; Check_min (nd); } void Insert_to_root (nd) node *nd; { nd->heap_parent = NNULL; nd->status = IN_HEAP; Insert_after_min (nd); } void Cut_node (nd, father) node *nd, *father; { after = nd->next; if (after != nd) { before = nd->prev; before->next = after; after->prev = before; } if (father->son == nd) father->son = after; (father->deg)--; if (father->deg == 0) father->son = NNULL; } void Insert_to_fheap (nd) node *nd; { nd->heap_parent = NNULL; nd->son = NNULL; nd->status = IN_HEAP; nd->deg = 0; if (fh.min == NNULL) { nd->prev = nd->next = nd; fh.min = nd; fh.dist = nd->dist; } else Insert_after_min (nd); fh.n++; } void Fheap_decrease_key (nd) node *nd; { if ((father = nd->heap_parent) == NNULL) Check_min (nd); else { if (nd->dist dist) { node_c = nd; while (father != NNULL) { Cut_node (node_c, father); Insert_to_root (node_c); if (father->status ==IN_HEAP) { father->status = MARKED; break; } node_c = father; father = father->heap_parent; } node * Extract_min () { node *nd; nd = fh.min; if (fh.n > 0) { fh.n--; fh.min->status = OUT_OF_HEAP; first = fh.min->prev; child = fh.min->son; if (first == fh.min) first = child; else { after = fh.min->next; if (child == NNULL) { first->next = after; after->prev = first; } else { before = child->prev; first->next = child; child->prev = first; before->next = after; after->prev = before; } if (first != NNULL) { node_c = first; last = first->prev; while (1) { node_l = node_c; node_n = node_c->next; while (1) { dg = node_c->deg; node_r = fh.deg_pointer[dg]; if (node_r == NNULL) { fh.deg_pointer[dg] = node_c; break; } else { if (node_c->dist dist) { node_s = node_r; node_r = node_c; } else node_s = node_c; after = node_s->next; before = node_s->prev; after->prev = before; before->next = after; node_r->deg++; node_s->heap_parent= node_r; node_s->status = IN_HEAP; child = node_r->son; if (child == NNULL) node_r->son = node_s->next = node_s->prev = node_s; else { after = child->next; child->next = node_s; node_s->prev = child; node_s->next = after; after->prev = node_s; } node_c = node_r; fh.deg_pointer[dg] = NNULL; } if (node_l == last) break; node_c = node_n; } fh.dist = VERY_FAR; for (dg = 0; dg < fh.deg_max; dg++) { if (fh.deg_pointer[dg] != NNULL) { node_r = fh.deg_pointer[dg]; fh.deg_pointer[dg] = NNULL; Check_min (node_r); node_r->heap_parent = NNULL; } else fh.min = NNULL; } return nd; } int dikf (n, nodes, source) long n; node *nodes, *source; { long dist_nieuw, dist_old, dist_from; long pos_nieuw, pos_old; node *node_from, *node_to, *node_last, *i; arc *arc_ij, *arc_last; long num_scans = 0; Init_fheap (n); node_last = nodes + n; for (i = nodes; i != node_last; i++) { i->parent = NNULL; i->dist = VERY_FAR; } source->parent = source; source->dist = 0; Insert_to_fheap (source); while (1) { node_from = Extract_min (); if (node_from == NNULL) break; num_scans++; arc_last = (node_from + 1)->first; dist_from = node_from->dist; for (arc_ij = node_from->first; arc_ij != arc_last; arc_ij++) { node_to = arc_ij->head; dist_nieuw = dist_from + (arc_ij->len); if (dist_nieuw dist) { node_to->dist = dist_nieuw; node_to->parent = node_from; if (NODE_IN_FHEAP (node_to)) Fheap_decrease_key(node_to); else Insert_to_fheap (node_to); } n_scans = num_scans; return (0); } zeer hoog niveau hoog niveau hoog niveau laag niveau machine- niveau machine- niveau C C

public class DijkstraShortestPath { private List edgeList; private double pathLength; public DijkstraShortestPath(Graph graph, V startVertex, V endVertex) { this(graph, startVertex, endVertex, Double.POSITIVE_INFINITY); } public DijkstraShortestPath( Graph graph, V startVertex, V endVertex, double radius) { CFIterator iter = nieuw CFIterator (graph, startVertex, radius); while (iter.hasNext()) { V vertex = iter.next(); if (vertex.equals(endVertex)) { createEdgeList(graph, iter, endVertex); pathLength = iter. getShortestPathLength(endVertex); return; } edgeList = null; pathLength = Double.POSITIVE_INFINITY; } public List getPathEdgeList() { return edgeList; } public class FHNode { T data; FHNode child, left, right, parent; boolean mark; double key; int degree; public FHNode(T data, double key) { right = this; left = this; this.data = data; this.key = key; } public final double getKey() { return key; } public final T getData() { return data; } public class FH { private static final double oneOverLogPhi = 1 / Math.log((1 + Math.sqrt(5)) / 2); private FHNode minNode; private int nNodes; public FH() {} public boolean isEmpty() { return minNode == null; } public void clear() { minNode = null; nNodes = 0; } public void decreaseKey( FHNode x, double k) { x.key = k; FHNode y = x.parent; if ((y != null) && (x.key < y.key)) { cut(x, y); cascadingCut(y); } if (x.key < minNode.key) { minNode = x; } public void delete(FHNode x) { decreaseKey(x,Double.NEGATIVE_INFINITY); removeMin(); } public void insert(FHNode node, double key) { node.key = key; if (minNode != null) { node.left = minNode; node.right = minNode.right; minNode.right = node; node.right.left = node; if (key < minNode.key) minNode = node; } else minNode = node; nNodes++; } public FHNode removeMin() { FHNode z = minNode; if (z != null) { int numKids = z.degree; FHNode x = z.child; FHNode tempRight; while (numKids > 0) { tempRight = x.right; x.left.right = x.right; x.right.left = x.left; x.left = minNode; x.right = minNode.right; minNode.right = x; x.right.left = x; x.parent = null; x = tempRight; numKids--; } z.left.right = z.right; z.right.left = z.left; if (z == z.right) { minNode = null; } else { minNode = z.right; consolidate(); } nNodes--; } return z; } protected void cascadingCut(FHNode y) { FHNode z = y.parent; if (z != null) { if (!y.mark) { y.mark = true; } else { cut(y, z); cascadingCut(z); }... zeer hoog niveau hoog niveau hoog niveau laag niveau machine- niveau machine- niveau J AVA

:- chr_constraint edge(+node,+node,+length), dijkstra(+node), distance(+node,+length), scan(+node,+length), relabel(+node,+length). :- chr_type node == int. :- chr_type length == number. dijkstra(A) scan(A,0). scan(N,L), edge(N,N2,W) ==> L2 is L+W,relabel(N2,L2). scan(N,L) distance(N,L), (extract_min(N2,L2) -> scan(N2,L2) ; true). distance(N,_) \ relabel(N,_) true. relabel(N,L) decr_or_ins(N,L). :- chr_constraint insert(+item,+key), extract_min(?item,?key), decr_or_ins(+item,+key), decr(+item,+key), mark(+item), ch2rt(+item), decr(+item,+key,+item,+item,+mark), findmin, min(+item,+key), item(+item,+key,+item,+item,+mark). :- chr_type item == int. :- chr_type key == number. :- chr_type mark ---> m ; u. insert(I,K) item(I,K,0,0,u), min(I,K). min(_,A) \ min(_,B) A =< B | true. extract_min(X,Y), min(I,K), item(I,_,_,_,_) ch2rt(I), findmin, X=I, Y=K. extract_min(_,_) fail. ch2rt(I) \ item(C,K,R,I,_)#passive item(C,K,R,0,u). ch2rt(I) true. findmin, item(I,K,_,0,_) ==> min(I,K). findmin true. item(I1,K1,R,0,_), item(I2,K2,R,0,_) ( K1 item(I2,K2,R,I1,u), item(I1,K1,R+1,0,u) ; item(I1,K1,R,I2,u), item(I2,K2,R+1,0,u) ). decr(I,K), item(I,O,R,P,M) K < O | decr(I,K,R,P,M). decr(I,K) fail. item(I,O,R,P,M), decr_or_ins(I,K) K < O | decr(I,K,R,P,M). item(I,O,_,_,_) \ decr_or_ins(I,K) K >= O | true. decr_or_ins(I,K) insert(I,K). decr(I,K,_,_,_) ==> min(I,K). decr(I,K,R,0,_) item(I,K,R,0,u). item(P,PK,_,_,_) \ decr(I,K,R,P,M) K >= PK | item(I,K,R,P,M). decr(I,K,R,P,M) item(I,K,R,0,u), mark(P). mark(I), item(I,K,R,0,_) item(I,K,R-1,0,u). mark(I), item(I,K,R,P,m) item(I,K,R-1,0,u), mark(P). mark(I), item(I,K,R,P,u) item(I,K,R-1,P,m). mark(I) writeln(error_mark), fail. zeer hoog niveau hoog niveau hoog niveau laag niveau machine- niveau machine- niveau CHR(P ROLOG )

:- chr_type node == int. :- chr_type length == number. :- chr_constraint source(+node), edge(+node, +node), path(+node, +length, +list(node)). +source(V) => path(V,0,[]). +path(V,D,P), +edge(V,C,U) => path(U,D+C,[U|P]). +path(V,D1,_), -path(V,D2,_), D1 =< D2. priority filter > label(_), label(X) > label(Y) if X < Y. zeer hoog niveau hoog niveau hoog niveau laag niveau machine- niveau machine- niveau CHR 2 (P ROLOG )

CHR = Constraint Handling Rules Hoog-niveau declaratieve programmeertaal Logische als-dan regels Operationeel: meerhoofdige herschrijfregels Oorspronkelijk: specificatie van constraint solvers Constraint = beperking +oorsprong(K)  afstand(K,0). +afstand(K,A), +boog(K,K’,G)  afstand(K’,A+G). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. “D IJKSTRA ” verwijderen built-in constraint (gasttaal) “ true.” matching_ bijhouden

oorsprong(K)  afstand(K,0). +afstand(K,A), +boog(K,K’,G)  afstand(K’,A+G). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. “D IJKSTRA ” boog(3,6,11) boog(1,2,7) boog(1,14,4) boog(1,3,9) boog(2,3,10) boog(2,9,15) boog(4,5,9) boog(6,5,6) boog(3,4,2) oorsprong(1) Constraint Store

oorsprong(K)  afstand(K,0). +afstand(K,A), +boog(K,K’,G)  afstand(K’,A+G). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. “D IJKSTRA ” boog(1,2,7) boog(1,3,9) boog(2,3,10) boog(2,9,15) boog(4,5,9) boog(6,5,6) boog(3,4,2) boog(3,6,11) Constraint Store

“D IJKSTRA ” boog(1,2,7) boog(1,14,4) boog(1,3,9) boog(2,3,10) boog(2,9,15) boog(4,5,9) boog(6,5,6) boog(3,4,2) boog(3,6,11) Constraint Store K=1

“D IJKSTRA ” boog(1,2,7) boog(1,14,4) boog(1,3,9) boog(2,3,10) boog(2,9,15) boog(4,5,9) boog(6,5,6) boog(3,4,2) boog(3,6,11) oorsprong(1) Constraint Store K=1

“D IJKSTRA ” boog(2,3,10) boog(2,9,15) boog(4,5,9) boog(6,5,6) boog(3,4,2) boog(3,6,11) oorsprong(1) Constraint Store K=1

oorsprong(K)  afstand(K,0). +afstand(K,A), +boog(K,K’,G)  afstand(K’,A+G). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. “D IJKSTRA ” boog(1,2,7) boog(1,14,4) boog(1,3,9) boog(2,3,10) boog(2,9,15) boog(4,5,9) boog(6,5,6) boog(3,4,2) boog(3,6,11) oorsprong(1) Constraint Store afstand(1,0) afstand(3,9) afstand(4,14)

“D IJKSTRA ” boog(1,2,7) boog(1,14,4) boog(1,3,9) boog(2,3,10) boog(2,9,15) boog(4,5,9) boog(6,5,6) boog(3,6,11) oorsprong(1) Constraint Store afstand(1,0) afstand(4,14) 11

“D IJKSTRA ” boog(1,2,7) boog(1,14,4) boog(1,3,9) boog(2,3,10) boog(2,9,15) boog(4,5,9) boog(6,5,6) boog(3,4,2) boog(3,6,11) oorsprong(1) Constraint Store afstand(1,0) afstand(3,9) 11

oorsprong(K)  afstand(K,0). +afstand(K,A), +boog(K,K’,G)  afstand(K’,A+G). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. “D IJKSTRA ” boog(1,2,7) boog(1,14,4) boog(1,3,9) boog(2,3,10) boog(2,9,15) boog(4,5,9) boog(6,5,6) boog(3,4,2) boog(3,6,11) oorsprong(1) Constraint Store afstand(1,0) afstand(3,9) 11 afstand(4,11)

oorsprong(K)  afstand(K,0). +afstand(K,A), +boog(K,K’,G)  afstand(K’,A+G). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. “D IJKSTRA ” boog(1,2,7) boog(1,14,4) boog(1,3,9) boog(2,3,10) boog(2,9,15) boog(4,5,9) boog(6,5,6) boog(3,4,2) boog(3,6,11) oorsprong(1) Constraint Store afstand(1,0) afstand(4,11) afstand(3,9) afstand(6,22)afstand(5,20) afstand(2,7)

Onderzoeksdoelstellingen Verbeteren van de praktische bruikbaarheid van CHR 1. Hoog-niveau, declarative programmeerstijl  Part II: CHR Language Design 2. Efficiënt uitvoering  Part III: Optimising Implementation of CHR 3. Integratie met mainstream programmeertaal (Java)  Chap. 7: CHR for imperative host languages  Chap. 8-9: optimising implementation

K.U.Leuven JCHR 2 ‘referentiesysteem’ CHR rp = CHR + regelprioriteiten

Ontwerp van CHR 2 Nieuwe generatie CHR Doel: h oog-niveau, declarative programmeerstijl 1. Syntax 2. Uitvoeringscontrole 3. Semantiek 4. Uitbreidingen

Gestroomlijnde Syntax  CHR syntax: 18 jaar ongewijzigd Voorbeeld: regelcondities prog(L, CJUMP,R,_), mem(R,X) \ pc(L) X ≠ 0 | pc(L+1). -pc(L), +prog(L, CJUMP,R,_), +mem(R,X), X ≠ 0 => pc(L+1). behouden verwijderd guard

Algoritme = Logica + Controle  CHR programma = regels + prioriteiten 1. Logica: hoog-niveau regels 2. Uitvoeringscontrole

oorsprong(K) => afstand(K,0). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. +afstand(K,A), +boog(K,G,K’) => afstand(K’,A+G). priority filter > label(_). “D IJKSTRA ” Uitvoeringscontrole: eindigheid oorsprong(K) => afstand(K,0). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. +afstand(K,A), +boog(K,G,K’) => afstand(K’,A+G). “D IJKSTRA ”

Uitvoeringscontrole: performantie oorsprong(K) => afstand(K,0). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. +afstand(K,A), +boog(K,G,K’) => afstand(K’,A+G). priority filter > label(_). “D IJKSTRA ” oorsprong(K) => afstand(K,0). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. +afstand(K,A), +boog(K,G,K’) => afstand(K’,A+G). priority filter > label(_), label(X) > label(Y) if X > Y. D IJKSTRA ! Stad (knopen)O(N log N)O(N 2 )O(N!) Leuven (~5.000) 2 ms25 ms120 ms Brussel (~50.000) 23 ms2.5 sec~10 48 jaar New York ( ) 151 ms1 min 17 sec... Florida ( ) 747 ms25 min N.-Amerika ( ) 22 sec> 10 dagen

Algoritme = Logica + Controle  CHR programma = regels + prioriteiten 1. Logica: hoog-niveau regels 2. Uitvoeringscontrole Eindigheid Performantie Correctheid

CHR: “refined operational semantics” De facto standaard operationele semantiek Uitvoering ≈ imperatieve taal CHR constraints ≈ procedure van boven naar onder, van links naar rechts Uitvoeringscontrole uitermate complex Laag-niveau constructies Redeneren over “hoe” Voorbeeld: kortste pad naïef: 3 regels Dijkstra: 27 regels

CHR rp : numerieke prioriteiten CHR programma = regels + prioriteiten CHR rp Prioriteit = geheel getal Globale prioriteiten Moeilijk uitbreidbaar, onderhoudbaar,... 1 :: oorsprong(K) ==> afstand(K,0). 1 :: afstand(K,A 1 ) \ afstand(K,A 2 ) A 1  A 2 true. A+2 :: afstand(K,A), boog(K,G,K’) ==> afstand(K’,A+G). D IJKSTRA IN CHR rp

CHR 2 : prioriteitsconstraints CHR programma = regels + prioriteiten CHR 2 Prioriteitsconstraints Optionele, lokale prioriteiten oorsprong(K) => afstand(K,0). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. +afstand(K,A), +boog(K,G,K’) => afstand(K’,A+G). priority filter > label(_), label(X) > label(Y) if X > Y. D IJKSTRA IN CHR 2

Hoofdstuk 5: Besluit Nieuwe generatie CHR H oog-niveau, declarative programmeerstijl: “wat, niet hoe” / “algoritme = logica + controle” 1. Syntax: hoog-niveau logische regels 2. Uitvoeringscontrole (optioneel): prioriteitsconstraints + sequentiële conjuncties 3. Semantiek: zie thesis 4. Uitbreidingen: zie thesis (+ aggregaten: hoofdstuk 6)

klant(C),..., Som > => platinum(C).klant(C), rekening(C,B), B > => platinum(C). klant(C), rekening(C,B 1 ), rekening(C,B 2 ), B 1 + B 2 > => platinum(C).... Motivatie “Een platinum klant is een klant wiens bankrekeningen samen meer dan € bevatten.” P LATINUM KLANTEN klant(C), som(C,Som), Som > => platinum(C). rekening(C,B) => som(C,B). -som(C,S 1 ), -som(C,S 2 ) => som(C, S 1 + S 2 ). priority som > _. klant(C), som(C,Som), Som > => platinum(C). rekening(_,C,B) => som(C,B). -som(C,S 1 ), -som(C,S 2 ) => som(C, S 1 + S 2 ). priority som > _. -stort(R,X), -rekening(R,C,B) => rekening(R,_,B + X). -haalaf(R,X), -rekening(R,_,B), B > X => rekening(R,_,B - X). klant(C), som(C,Som), Som > => platinum(C). klant(_,C,B) => som(C,0). -som(C,S 1 ), -som(C,S 2 ) => som(C, S 1 + S 2 ). priority {init, som} > _. -stort(R,X), -rekening(R,C,B), -som(C,S) => rekening(R,_,B + X) & som(C, S + X). -haalaf(R,X), -rekening(R,_,B), B > X, -som(C,S) => rekening(R,_,B - X) & som(C, S – X).

Motivatie Aggregatie: Hulpconstraints en –regels Crosscutting code Nadelen: Vervelend verboos en repititief Foutgevoelig Bemoeilijkt leesbaarheid, onderhoudbaarheid... “A programming language is low level if its programs require attention to the irrelevant.” - A LAN J. P ERLIS, E PIGRAMS IN P ROGRAMMING, S EPT. 1982

Aggregaten Voordelen: Hoog-niveau, declaratieve regels Verkorte ontwikkelingstijd Beknopt, eenvoudig, leesbaar, onderhoudbaar Correct, robuust en efficiënt... P LATINUM KLANTEN “... the Holy Grail of programming: the user states the problem, the computer solves it.” - E UGENE C. F REUDER, C ONSTRAINTS, A PRIL 1997

euler, node(N) ==> test(N). euler true. test(N), edge(N,_) ==> degree(in, 1). test(N), edge(_,N) ==> degree(out,1). test(N) get_d(in,X), get_d(out,X). degree(X,Y), degree(X,Z) degree(X,Y+Z). get_d(X,Q), degree(X,Y) Q = Y. get_d(X,Q) Q = 0. E ULER

Aggregaten: Besluit Hoog-niveau, declaratieve taaluitbreiding Algemeen, uitbreidbaar raamwerk sum, count, min, max, average, not, exists,... genest, gebruikersgedefinieerd,... Betere expressiviteit, kwaliteit code, productiviteit,... Implementatie in SWI Prolog Source-to-source Incrementele berekening aggregaten Efficiënt: juiste complexiteit

JCHR & JCHR 2 Prolog HaskellJava (& C)

CHR voor imperatieve gasttalen Specifieke uitdagingen door verschillen met (C)LP Focus: Integratie met gasttaal Natuurlijk voor imperatieve programmeur

package be.kuleuven.jchr2.examples; public handler dijkstra { public constraint oorsprong(int knoop), boog(int van, int naar, float gewicht); local constraint afstand(int knoop, float afstand); oorsprong(K) => afstand(K,0); +afstand(K,A1), -afstand(K,A2), A1 <= A2; +afstand(K,A), +boog(K,G,Kx) => afstand(Kx,A+G); priority filter > label(_), label(X) > label(Y) if X > Y; } D IJKSTRA IN JCHR 2

JCHR Compilatie CHR(Prolog) compiler Prolog JCHR compiler Java

Luie Evaluatie 1.Bereken alle vuurbare regel-instantiaties R 2.Als R leeg: stop 3.Selecteer r  R met hoogste prioriteit 4.Vuur r 5.Ga naar stap 1 Naïef

Luie Evaluatie 1.Bereken alle vuurbare regel-instantiaties R 2.Als R leeg: stop 3.Selecteer r  R met hoogste prioriteit 4.Vuur r 5.Voeg nieuwe vuurbare instanties toe aan R + verwijder niet langer vuurbare instanties uit R 6.Ga naar stap 2 IncrementeelIncrementeel Voorbeelden: Rete: production rule systemen (OPS5, CLIPS, Jess, Drools,...) TREAT,...

Luie Evaluatie  Lui: niets berekenen tenzij echt nodig 1.Bereken vuurbare instantiatie r met hoogste prioriteit 2.Als niet gevonden: stop 3.Vuur r 4.Ga naar stap 1 LuiLui “Efficiency is intelligent laziness.” — A RNOLD G LASGOW

‘referentiesysteem’ eerste efficiënte systeem refined op. semantics ‘referentiesysteem’ eerste efficiënte systeem refined op. semantics HAL & K.U.Leuven CHR numerous optimizations static program analysis HAL & K.U.Leuven CHR numerous optimizations static program analysis K.U.Leuven JCHR & JCHR 2 CHR rp : prioriteiten HAL & K.U.Leuven CHR optimalisatie programma-analyse HAL & K.U.Leuven CHR optimalisatie programma-analyse

Bijdragen CHR(Prolog)  CHR(imperatief) Voordelen: geneste lussen, index-datastructuren,... Uitdagingen: recursie (Hfdst. 9) Tal van nieuwe en verbeterde optimalisaties Uitbreiding naar negatie en prioriteiten Samenhangend, toegankelijk raamwerk Implementatie JCHR and JCHR 2 State-of-the-art CHR en CHR 2 compilers voor Java

PJJ2J2 C Invariants Invariant derivation Unenforced invariantsnieuw Join computation Loop-invariant code motionuitgebreid Indexingverbeterd Exploiting invariants Pre-commit backjumpingnieuw Post-commit backjumpingnieuw Fragile iteratorsverbeterd Join orderingverbeterd Constraint store Late storage / indexingverbeterd Late allocation In-place/delayed modification Lazy indexingnieuw Activation Reducing schedule overheadverbeterd Passive occurrencesuitgebreid Passive removalsnieuw Dynamic passive occurrencesnieuw Reactiation Selective constraint reactivation Delay avoidanceverbeterd Generations Specialisation Constraint specialisation Guard simplificationuitgebreid

76.3%

-lus 1 (N), N > 0 => print(N), lus 1 (N-1). lus 1 (1000) print(1000) lus 1 (1000-1) print(999) lus 1 (999-1) print(998) _999 _998 Recursie

-lus 2 (N), N > 0 => lus 2 (N-1), print(N). _ 1... _998 _999 lus 2 (1000) print(1000) lus 2 (1000-1) print(999) lus 2 (999-1) print(998)... print(1000) print(999) print(998) Stapel

-lus 2 (N), N > 0 => lus 2 (N-1), print(N). lus 2 (1000) print(1000) lus 2 (1000-1) print(999) lus 2 (999-1) print(998)... Recursie print(1000) print(999) print(998)...

-lus 1 (N), N > 0 => print(N), lus 1 (N-1). -lus 2 (N), N > 0 => lus 2 (N-1), print(N). lus 2 (1000) print(1000) lus 2 (1000-1) print(999) lus 2 (999-1) print(998)... lus 1 (1000) print(1000) lus 1 (1000-1) print(999) lus 1 (999-1) print(998)... JCHR (JRE 1.5) JCHR (JRE 1.6) CCHRSWIYAP lus 1 35,9003,200∞∞∞ lus 2 38,7003,200500,0003,300,000±∞ Tail-call- optimalisatie Groeiende stapel Tail-call

Recursie-optimalisatie 1. Tail-call optimalisatie (“Trampoline”) Relatief eenvoudig te implementeren Enkel CHR tail calls Optimale ruimtecomplexiteit 2. Groeiende stapel Moeilijker te implementeren Overhead (> 20%)  na extra optimalisatie (< 10%) Stapel enkel beperkt door geheugen Geïmplementeerd in JCHR (en CCHR: Pieter Wuille) JCHR 2 : uitbreiding naar prioriteiten (schedule)

JCHR BenchmarkOrigineel schema Nieuw schema (naïef) Nieuw schema (geöptimaliseerd) BEER (2,000) 7,6 (overloop  3.500) 7,3 (-3%)7,1 (-7% / -4%) BOOL (1,000,000) 4,15,2 (+27%)4,9 (+20% / -6%) D IJKSTRA (5,000) overloop  ,21,1 (-13%) FIB (33) 9,413 (+37%)11 (+17% / -15%) GCD (64,000,000) overloop  ,55,5 (-0%) LEQ (300) 3,85,5 (+45%)4,3 (+13% / -22%) MERGESORT (100k) 10,612.3 (+16%)11,3 (+7% / -8%) PRIMES (10,000) overloop  ,04,4 (-13%) RAM_ FIB (150,000) overloop  300 3,13,0 (-5%) UNION (210,000) 2,62,7 (+2%)2,6 (+0% / -2%) AVERAGE +21%+8% / -9%

Propagatieregels verwijderen geen constraints blijven toepasbaar: triviale non-terminatie Hertoepassingspreventie maximaal 1 keer vuren met zelfde constraintcombinatie oorsprong(K) => afstand(K,0). +afstand(K,A 1 ), -afstand(K,A 2 ), A 1  A 2. +afstand(K,A), +boog(K,G,K’) => afstand(K’,A+G). priority filter > label(_), label(X) > label(Y) if X > Y. D IJKSTRA

Propagatiegeschiedenis Verzameling van alle gevuurde regelinstanties Enkel vuren als combinatie niet in geschiedenis Duur! Zowel in ruimte als tijd Potentiële geheugenlek Oplossingen 1. Efficiëntere propagatiegeschiedenisdatastructuren 2. Alternatieve hertoepassingspreventietechnieken 3. Geen hertoepassingspreventie

Propagatiegeschiedenisoptimalisatie 1. Efficiëntere propagatiegeschiedenisdatastructuren 2. Alternatieve hertoepassingspreventietechnieken 3. Geen hertoepassingspreventie

Propagatiegeschiedenisoptimalisatie 1. Efficiëntere propagatiegeschiedenisdatastructuren 2. Alternatieve hertoepassingspreventietechnieken ‘general purpose’ CHR: meestal niet reactief timestamp-gebaseerde hertoepassingpreventie (vaak zelfs overbodig) geheugen: constante factor 3. Geen hertoepassingspreventie

Propagatiegeschiedenis 1. Efficiëntere propagatiegeschiedenisdatastructuren 2. Alternatieve hertoepassingspreventietechnieken 3. Geen hertoepassingspreventie ‘constraint solvers’: meestal idempotent Hertoepassing idempotente CHR regels geen effect Hertoepassing typisch goedkoper dan preventie Propagatiegeschiedenisoptimalisatie D IJKSTRA

Propagatiegeschiedenis 1. Efficiëntere propagatiegeschiedenisdatastructuren 2. Alternatieve hertoepassingspreventietechnieken 3. Geen hertoepassingspreventie  Meeste regels: geen geschiedenis meer!  Propagatiegeschiedenisoptimalisatie

Besluit Praktische bruikbaarheid van CHR sterk verbeterd 1. Hoog-niveau, declarative programmeerstijl  CHR2: logische regels + flexibele uitvoeringscontrole  “Wat, normaal niet hoe”  Aggregaten 2. Efficiënte uitvoering  Nieuwe en verbeterde optimalisatietechnieken  Recursie- en propagatie-optimalisaties  JCHR: veruit meest efficiënte systeem 3. Integratie met mainstream programmeertaal (Java)  Taalontwerp + implementatie

Mandarijns teken voor paard (Yale) transcriptie: CHR “to speed, to propagate, to be famous”