ACTION BPMN #99 – Schleifen in BPMN: So geht's richtig!

ACTION BPMN #99 – Schleifen in BPMN: So geht's richtig! - YouTube
https://www.youtube.com/watch?v=0BSO9yKgtk0

Transcript:
(00:06) Willkommen in der Wunderwelt des gut gepflegten Geschäftsprozesses. Wir modellieren, automatisieren und optimieren Geschäftsprozesse. Und hier ist dein Host. Du bist gemutet. Ein ein Mikrofon, das stumm ist. Genau. Vielen Dank Volker für den Hinweis. Was wäre ich ohne meine Gäste nix. Also noch mal Mirko äh Prozesse pitchen.
(00:38) Heute gibt's Action BPMN mit dem großartigen Volkerstil. So, damit das alles hier gleich wieder richtig läuft. Hallo Volker, grüß dich. [gelächter] Hallo Mirko und ein Gruß an alle, die jetzt schon live dabei sind und zuschauen. So, letzte Woche haben wir über Progressive BPM BPM gesprochen. Ja, großartiges Thema.
(00:59) Wir haben gesagt, hört auf mit dem alten Scheiß, ja? Kümmert euch um neue Geschäftsbodelle. Ähm und heute gehen wir wieder in Wissensvermittlung. Ein riesen Spaß jedes Mal für mich, also weil ich immer wieder was dazu lerne. Ähm bei ich habe festgestellt, ich kriege gar nicht mehr zusammen, also wir haben schon so viele Folgen gemacht, ich kriege gar nicht mehr zusammen, was wir schon alles äh besprochen haben.
(01:20) Ja, leg das mal alles schön in einen Ordner zusammen in eine Liste, damit da nichts verloren geht. Ich soll es ausdrucken. Genau. Ja, ausdrucken. Und dann sagen in eine Videoliste, dass dann die finde ich gut. Und was ist denn da schon gelaufen? Ja, okay. Das das würde ich mal glaube ich das muss ich noch mal angeben.
(01:39) Es muss noch eine Playliste geben, ja, wo drin steht, okay, das ist hier Volker only. Ja, also da ist jetzt hier kein Enterprise gedöns, sondern wir kümmern uns um Open Source Dinge, die wir beide vorantreiben und haben Spaß damit daran das den Leuten Okay, aber lass mich lass mich trotzdem also was ist was ist eine eine Engine, ne, haben wir haben wir gehabt. Mhm.
(02:01) Und da und dann hört's bei mir schon auf. Also was hast du noch alles drauf? Na ja, die ganzen Services, die ganzen Aufgaben, die wir hatten, Unterprozessechniken, Datenmodelle hatten wir besprochen, die Daten übergeben werden, richtig? Ja, das haben wir schon alles hinter uns gebracht, tatsächlich haben schon Ja, du hast schon viel gearbeitet, bist immer wie immer gut vorbereitet.
(02:24) Ähm heute geht's um Schleifen. Schleifchen finde ich cool. Ja. Ja, ich finde auch cool. Was sind denn schleif Schleifen? Genau. Ich habe ein bisschen was wieder vorbereitet. Äh, ich teile dafür wieder meinen Bildschirm, deswegen eine Sekunde. Das haben wir gar nicht probiert vorhin bei [räuspern] Wir sind doch sind doch mittlerweile so eingespielt.
(02:45) Ja. Ja, dafür hat sich aber dann das wieder erledigt mit dem Mikrofon, dass ich nicht eingeschaltet habe. Also das insofern als Warte mal so, jetzt müssten wir das da machen und das hinzufügen. Genau. Und jetzt seht ihr da und ich sehe das auch bei dir äh BPMN Modelle. Da kommt jetzt aber gleich was anderes hin, nämlich das hier.
(03:07) Kannst du mir ganz kurz bestätigen, dass du eine Folie siehst? Ich sehe ein Slide. Genau. Ach so, gar nicht gesagt, wo du herkommst. Hier rechts oben. Ja. technische Hochschule Inwaldstadt. Das sind tatsächlich, da bediene ich mich aus meinem Fundus, die ich auch in den Vorlesungen verwende und natürlich didaktisch so aufbereite, dass da wieder massenhaft Fehler drin [gelächter] sind, dass auch gescheit was lernen.
(03:31) Äh, tatsächlich wollen wir uns ein bisschen mit dem Thema Schleifen beschäftigen und die können wir in BPMN auch explizit modellieren, ne? Das sehen wir hier. Wir haben hier vorne einen Prozess Start und dann kommen wir hier zu einem exklusiven Gateway. Siehst du? Gateways hatten wir natürlich auch schon behandelt.
(03:49) Ja, genau. Und da wird jetzt die entscheidende Frage gestellt, ob diese Schleife schon am Ende angekommen ist. Und wenn das nicht ist, dann tun wir etwas und dann gehen wir wieder zurück, um dann zu überprüfen, ob jetzt das Schleifenende Kriterium erreicht ist. So kann man in BPMN explizit eine Schleife modellieren.
(04:09) Und da sind jetzt zwei Dinge schon mal gleich unschön dran. Punkt Nummer 1, oben einen Sequenzfluss, der wieder zurückgeht. Und also zurückgeht, wir gehen wieder nach links, wir modellieren hier ja offensichtlich von links nach rechts und ein Fall ein Sequenzfluss, der wieder zurückgeht, da meine ich, er ist sozusagen ein Geisterfahrer.
(04:32) Ja, läuft der eigentlichen Modellierungsrichtung entgegen und sowas ist unschön und vor allen Dingen, wenn Prozessmodelle größer werden und wir haben mehr solcher Geisterfahrer, dann wird das sehr schnell sehr unübersichtlich. Das ist Punkt Nummer 1. Und Punkt Nummer 2, da können wir mal wieder aus Wissen zurückgreifen, dass wir nämlich in der Folge über Gateways besprochen haben, ist, dass ein Gateway immer eine eindeutige Rolle übernehmen sollte.
(05:01) Also entweder eindeutig verzweigend oder eindeutig zusammenführend. Was war da zur Erinnerung noch mal der Unterschied? ein verzweigendes Gateway, da geht ein Sequenzfluss rein und mehrere Sequenzflüsse verlassen das Gateway. Das ist ein verzweigendes Gateway und ein zusammenführendes Gateway ist das natürlich genau umgekehrt.
(05:23) Mehrere Sequenzflüsse zeigen auf das Gateway und nur ein Gateway verlässt nur ein Sequenzfluss verlässt das Gateway. So sollte das idealerweise sein. Was wir hier links aber sehen, das ist das, was ich immer als Spinne bezeichnet. Klar, so viele hässliche Beine und da gehen mehrere Sequenzflüsse rein, ne? Hier 1 2 und es gehen mehrere Sequenzflüsse raus hier, die mit no und Yes beschrieben ist. Und sowas sollte man nicht tun.
(05:50) Das heißt, eins sollte man auf alle Fälle tun, hier noch ein zusätzliches Gateway davorchalten, wo dann die Zusammenführung reingeht und dann ist jedes Gateway wieder eindeutig zusammenführend oder verzweigend. So, also gar nicht schön, ja, sollte man tunlichst vermeiden. Und was wir hier lernen, das ist eine abweisende Schleife.
(06:12) Das heißt, ich überprüfe erstmal, okay, bin ich überhaupt zuständig? Und äh nur wenn ich zuständig bin, tue ich etwas. Man kann auch sagen, das ist die faule Schleife, ne? Erstmal überprüfen, äh muss ich was tun, ehe ich dann wirklich was tue. Mhm. Diese Schleife kann ich auch andersrum modellieren, dass ich zuerst etwas tue und danach das Schleifenende Kriterium überprüfe.
(06:37) Auch hier wieder explizit modelliert, indem ich das exklusive Gateway verwende und ne didaktisch böses faul, ja, wieder zwei Pfeile, die da auf die Aufgabe weisen. Sollte man auch nicht tun. An der Stelle wä wäre ein zusammenführendes exklusives Gateway auch wieder sehr zielführend und dann hätten wir auch wieder die schöne Pärchenbildung.
(07:00) Also in diesem Modell, in diesem kleinen Ausschnitt rechts, äh finden wir denselben Fehler, den wir auf der linken Seite auch schon haben. Da fehlt einfach ein Gateway und dann hätten wir dort auch die Pärchenbildung, die wir in besagter äh in besagter Folge ja auch besprochen haben. Soweit so gut, soweit verständlich, Mirko. Ja, doch, ich habe es verstanden.
(07:22) Ja, gut. So, wir haben jetzt diese vielen Nachteilen der expliziten Schleifenmodellierung kennengelernt und die in der OMG, der Object Management Group, die ja für die Standardisierung von BPMN verantwortlich sind, die haben das natürlich erkannt und haben gesagt, das ist doch alles Mist, machen wir es doch gescheit.
(07:39) Und sie haben sich etwas überlegt, nämlich eine sogenannte Schleifenmarkierung. Markierung ist wieder ein Fachbegriff aus der BPMN und das sind so kleine Symbole, die bei Aufgaben und Unterprozesse hier unten in der Mitte angeordnet werden und im Laufe unseres kleinen Kurses werden da noch die eine oder andere Markierung dazu kommen.
(08:03) Und für die Schleife hat man sich hier diesen sinnigen gekrümmten Kreis überlegt und der offizielle Name ist die Standardschleifenmarkierung Standard Loop Marker im Englischen. So und das sagt, dass do something mehrfach ausgeführt werden soll. Das genügt aber den geneigten BPMN Leser nicht, denn er muss ja irgendwie noch wissen, okay, und wann hört diese ganze Sache aufzuschleifen? [räuspern] Und das, was wir hier oben gesehen haben, nämlich hier diese faule Schleife und die fleißige Schleife, wie kann ich das denn bitteschön unterstützen in
(08:44) Bpmn? Ja, und da fehlt uns ein bisschen was rein visuell, ne? Denn ich kann weder den Fall unterscheiden, ob es eine fleißige oder eine faule Schleife ist. Und dieses zweite, ob sie nämlich wann die Schleife letztendlich beendet wird. Auch das kann ich nur dadurch, dass ich diesen Kringel da unten rein äh projiziere, kann ich das leider auch nicht erkennen. So.
(09:09) Und wie kommt man aus dieser Nummer raus, damit auch der Leser versteht, wann diese beiden Bedingungen erfüllt sind? nämlich ist es eine eine abweisende oder eine fleißige Schleife und wann ist die Schleife beendet? Muss man das tatsächlich in Textform ergänzen. Mhm. So und dann kommen jetzt wieder neue Fachbegriffe ins Spiel.
(09:33) Äh und wir haben hier unten nämlich, das habe ich jetzt hier ergänzt, äh etwas in der BPMN. Die nennen das nicht einfach Kommentar. Das wäre ja auch viel zu einfach gewesen. Nein, das muss natürlich ein bisschen akademischer klingen. Deswegen heißt der Kommentar im BPMN Sprachgebrauch Textannotation. Im Englischen, Achtung, schwierige Übersetzung, Text annotation.
(10:02) Und was diese Textannotation hier mit dieser Aufgabe verbindet, diese Punkte dort, diese Punkt gepunktete Linie, das ist eine Assoziation. So und damit haben wir jetzt das gesamte Konstrukt hier erklärt. Ist also eine Textannotation, die über eine ähm Assoziation mit der Aufgabe verbunden ist.
(10:28) Und in diese Textannotation kann ich jetzt einen beliebigen Text hinterlegen. Und die beiden wichtigsten Informationen, die man dort hinterlegen sollte, ist ob die Schleife fleißig oder faul ist und wann die Ende aufhört zu schleifen. Okay. Und tatsächlich gibt es dafür in der BPMN Spezifikation auch ganz konkrete Namen, nämlich ob es eine faule oder fleißige Schleife ist.
(10:56) Dafür gibt's ein Attribut und das habe ich jetzt hier nicht mir selber ausgedacht, sondern das kommt tatsächlich aus der WPMN Spezifikation und das ist dieses Attribut Test before. Und ihr seht, das ist ein Wahrheitswert, wahr falsch. Den kann man auf true oder false setzen. Und test before true heißt, wir haben es mit einer faulen Schleife zu tun.
(11:24) Ich überprüfe die Schleifen Ende Bedingung, bevor ich den Schritt do something ausführe und test before false bedeutet logischerweise dann das umgekehrte. Ich führe erst do something aus und dann überprüfe ich die Schleifen Endebedingung. Und wenn die Schleifen Ende Bedingung noch nicht erfüllt ist, na ja, dann führe ich do something noch mal aus.
(11:50) Und ist sie erfüllt, dann wandert das Token in unserem [räuspern] Fall jetzt hier zum Endereignis weiter. So, jetzt mal wieder ein kurzer Zwischencheck. Soweit alles dor? Ich bin noch nicht eingeschlafen. Ja, alles alles alles gut. Okay, gut. [gelächter] Ja, dieses Test before wird sehr oft auch in den Modellierungsumgebung vergessen.
(12:10) Tatsächlich äh manche haben es, manche haben es nicht drinne. Äh interessant ist natürlich die Frage äh wenn ich dieses Test bevor nicht angebe und wenn ich das nicht konfigurieren kann, was ist denn bitteschön das Default Verhalten? Ist es der faule Fall oder ist es der fleißige Fall? Und da lasse ich dann immer meine Studierenden abstimmen.
(12:33) Ja, und typischerweise ist immer ganz interessant, kommt zu fiy50 raus. 50% denkt, na ja, äh es wird erst überprüft und dann do something ausgefühlt und 50% denken, okay, es wird erst etwas ausgeführt und dann wird die Schleifenendebedingung überprüft. Und Trommelwirbel ähm der Default ist, es wird erst etwas getan und dann wird das Endekriterium überprüft.
(12:59) Also die fleißige Schleife, das ist die Default Einstellung. Und wenn man also nichts angibt in der Textannotation zu Test Before dann kann man davon ausgehen, dass der Autor des Prozessmodells davon auskennt, dass man diese Regel kennt und dann auch automatisch daraus folgert, dass wir erst etwas tun und dann die Schleifenendebedingung überprüfen.
(13:20) So wenn und wenn er darf ich eine Frage stellen? Ja, natürlich. [räuspern] Wenn er wenn er es vergessen hat und und nicht die fleißige Schleife meinte, es ist ein Fehler, es ist dann dann dann sieht er das, dann sollte er das beim Testen herausfinden und Flux äh diese Checkbox, die ist meistens gesetzt. Da steht auch tatsächlich dann in den Entwicklungsumgebungen Test before dabei.
(13:45) Die ist defaultmäßig mit dem Haken gesetzt und dann dort den Haken zurücksetzen und dann verhält sie sich. Also, ich muss bewusstes ich muss den die Vollfelt bewusst abwählen, wenn ich das andere meine. Okay, so ist das. So ist das, ne? Ich meine, von der Logik her, von der fachlichen Modellierung her ist das Default Verhalten aber auch gut nachvollziehbar, ne? Ich möchte erst etwas tun.
(14:08) Ja, das Token kommt zu der Aufgabe hin und ich denke mal vom normalen Denken gehe ich auch davon aus, dass ich dieses do something dann auch ausführe und dann überprüfe ich erst, ob damit die Schleifenbedingung erfüllt ist oder nicht. Ja, [schnauben] und das bringt mich auch tatsächlich die Brücke ist genial zu der eigentlichen Schleifenendbedingung, die ich auch angeben sollte und dafür gibt's dieses Attribut end Criteria.
(14:35) Ja, und da sollte man was fachliches angeben, ne? Wie z.B. ähm über die gesamten Bestellungen ist der Gesamtumsatz bei diesem Kunden größer 10.000 und die Schleife soll so lange durchgeführt werden, bis der Gesamtumsatz größer 10.000 ist oder die Schleife soll so lange durchgeführt werden, bis der Kunde ein Goldkunde ist oder was auch immer.
(14:59) Also was fachliches reinschreiben, ne? Denn wir sind ja auf der fachlichen Modellierungsebene unterwegs und dann sollte man dort etwas fachliches reinschreiben. Sowas, was ich da reingeschrieben habe, Variable XY = N. Das ist natürlich ein no Goo, also auch wieder didaktisch, ne, gesehen, du musst dich meine Folie immer didaktisch sehen, damit sie auch gleich lernen, so macht man es nicht.
(15:18) Okay. Und noch eine Ergänzung, was mir jetzt noch gerade einfällt, tatsächlich zu dem, was du als letztes gefragt hast. Wenn du äh bewusst ein anderes Verhalten haben möchtest und du diese Checkbox eben zurücknimmst mit Test Before, also du möchtest Test Before äh damit auf True setzen, ja? Ähm halt nicht, dass ich jetzt ein Schm erzähle.
(15:44) Test before ist defaultmäßig nicht angeschaltet, dass er nämlich durchläuft und äh wir was tun. Und Test bevor setzen heißt, ich will ja vorher testen, ne? Also bitte genau hinschauen. Das ist mit dieser doppelten Logik immer so so eine Sache. Also Test bevor Haken setzen heißt ich mache es vorher. Und wenn du das machst und damit das Default Verhalten überschreibst, dann bitte unbedingt das in diese Textannotation ergänzen, denn jeder Leser geht natürlich davon aus, dass das Default Verhalten stattfindet.
(16:16) Also, dann ist tatsächlich zwingend angeraten, äh dieses veränderte Verhalten in der Textannotation auch zu ergänzen, nicht, dass der Leser dann was falsches interpretiert. Okay, so. Ich hoffe, ich konnte das jetzt noch mal richtig rücken mit diesem Test before und wann man dieses Test before unbedingt ergänzen sollte, nämlich dann, wenn das Test des Default Verhalten ganz bewusst nicht durchgeführt werden soll.
(16:43) Mhm. Okay, so. Damit haben wir die Standardschleifenmarkierung erläutert. Wie wir oder der ein oder andere vielleicht aus der Informatik noch weiß, gibt es ja noch eine andere Schleife, nämlich eine Schleife, bei der man die Anzahl der Schleifendurchläufe vorher kennt. Bei der Standardschleifenmarkierung, die wir so gerade diskutiert hatten, wissen wir nicht, wie oft die Schleife durchlaufen wird.
(17:15) ist es 10, 20, 100, 1000 mal, wir wissen es nicht, denn es muss ja erst dieses Kriterium eintreten. Das kann halt nach 1500 oder 200 mal sein. Das heißt, dort wissen wir die Anzahl der Schleifendurchlaufe nicht. Die, die aus der Programmierung kennen, kennen das unter do while oder while do schleifen. Das sind die Pondance aus der Programmierung.
(17:35) Und ich ziehe jetzt die Parallele zur Programmierung, weil es dort eben auch noch die sogenannte Vorschleife kennt äh gibt. Und vorheißt führe diese Schleife genau so viel mal aus. Also da ist die Anzahl der Schleifendurchläufe vorher bekannt. Und sowas gibt es in der BPMN auch. Also ne, die Leutchen, die sind da richtig richtig clever.
(17:59) Und das sehen wir hier. Und äh wer die Folge über Datente äh sich angeschaut hat, dem sollte diese Markierung auch tatsächlich nicht neu sein, denn das ist die mehrfach Instanzmarkierung. Jawohl. Die mehrfach Instanzmarkierung können wir also nicht nur bei den Datenobjekten verwenden, wie wir es hier auch sehen, sondern auch bei den Aufgaben.
(18:27) Und das bedeutet, führe diesen Schritt so oft aus. So. Und jetzt brauche ich eine Bezugsgröße, der ich entnehmen kann, wie oft diese Schleife durchlaufen wird. Und die Bezugsgröße ist hier eine Liste, denn eine Liste enthält eine vorher bekannte Anzahl an Elementen und dann wird eben der Schritt so oft ausgeführt, wie es Einträge in dieser Liste gibt.
(18:57) Und jeder Schleifenprozessdurchlauf, jede Schleifeninstanz bekommt aus dieser Liste ein Element zugewiesen, auf dem dann der Schritt agiert. So ist das hier zu interpretieren und dann wissen wir, dass do something so oft ausgeführt wird, wie es hier Einträge in List Data Object gibt. Und das ist schon auch wieder eine sehr coole Konstruktion, was ich nur wieder in der freien Wildbahn erlebe.
(19:30) Und damit meine ich die Prozessmodelle, die mir so gezeigt werden, ist zwar der Schritt mit der Standard äh mit der äh mehrfach Instanzmarkierung angezeigt ist, dass aber hier dieses Datenobjekt nicht mitgeliefert wird, worüber dann die Schleife laufen soll. Ja, was soll denn das denn? Dann kann ich doch mit dieser Schleifenmarkierung bei der Aufgabe überhaupt nichts anfangen.
(19:56) Also macht keinen Sinn. Der Regel also, wenn man die mehrfach Instanzmarkierung verwendet, dann bitteschön auch ein Datenobjekt ergänzen, das ebenfalls die mehrfach Instanzenmarkierung enthält und der man entnehmen kann, wie oft dann die entsprechende Aufgabe durchlaufen hat. Macht Sinn. Absolut.
(20:17) Aber dann ist doch das Modell sowieso nicht vollständig, wenn ich das Datenobjekt dann nicht nicht habe. Also [gelächter] du weißt aber auch von unseren Process Engines, die wir verwenden, dass dort das Datenobjekt ja nur in Anführungsstrichen Lametta ist. Ja, stimmt. Das ist ja nicht ganz, ne? Da haben wir mit unseren Process Engines an der Stelle ein kleines Problem.
(20:40) Da sind natürlich die Process Engines ein bisschen besser aufgehoben, bei denen Datenobjekte tatsächlich eine Ausführungssemantik beinhalten. So, bei unserem Process Engine können wir dieses Tierchen weglassen. Äh in die Konfiguration ein existierendes Objekt, was in unserem Prozessktext vorhanden ist, hernehmen und sagen, schleife darüber und ja, alle sind glücklich.
(21:04) Nur der Leser eines fachlichen Modells bleibt dort völlig im Unklar. Deswegen bad practice und deswegen Datenobjekte sehr wichtig. Und unbedingt, wer das noch hier zum ersten Mal sieht, unbedingt die Folge über die Datenobjekte noch mal anschauen. Da haben wir das nämlich schon alles thematisiert.
(21:26) Also ganz ganz wichtig dieser Zusammenhang zwischen den Datenobjekten und der mehrfach Instanzmarkierung heißt es. Ich muss noch mal darauf zurückkommen. Also, man zeigt ja nicht mit mit dem Finger auf die eigene Workflow Engine, ne? und sagt, okay, du kannst das nicht so richtig. Heißt [gelächter] das, dass dass diese Art der der Schleife mit den Engines nicht machbar ist oder wie? Dochil doch doch, doch, weil du hast ja trotzdem deinen Prozessktext.
(21:55) Jetzt kommen wir wieder zu den Begrifflichkeiten. Hatten wir auch schon eingeführt. Prozesscast ist ja das Gehirn des Prozesses. Bei unseren beiden Process Engines heißt dieser Prozess Kontext Execution. Und in dieser Execution kannst du ja durchaus ein Listendatenobjekt hinterlegen und dann kannst du dieses Listendatenobjekt in der Konfiguration natürlich äh hinter diese Schleifenmarkierung legen und dann tut unsere Process Engine auch genau das, was ich jetzt hier theoretisch erklärt habe. Wir schauen uns ja gleich dazu
(22:27) auch ein Beispiel an. Ja, wir wollen ja nicht nur theoretisch das Ganze uns anschauen, sondern wir wollen das ja zum Leben erwecken und das ist ja auch der Sinn unserer kleinen Reihe, nicht nur Theorie, sondern diese Theorie zum Leben erwecken und Spaß daran haben, ne? Das heißt, du zeigst uns jetzt noch was.
(22:43) Aber hallo. Natürlich, aber hallo. Ja, genau. Aber hallo. So, ich bin aber noch nicht fertig. Acho, denn denn die OMG ist noch cleverer. Die hat noch eine mehrfach Instanzmarkierung. hinzugefügt. Da sind auf einmal diese drei senkrechten Striche umgefallen und die liegen [räuspern] jetzt wagerecht da. So und jetzt steht man da wieder wieder Ox vom Berg, ne? Das ist ist das ist der Hamburger.
(23:12) Kennt man das? Ja, genau. Und das ist natürlich immer ein sehr schöner Zeitpunkt, wo ich dann mit meinen Studierenden auch ins Gespräch kommen kann und sie spekulieren dürfen, wo denn jetzt der signifikante Unterschied zwischen diesen beiden Symbolen ist, ne? Mhm. Und das ist auch eine mehrfache Instanzmarkierung. Äh nur sie löst etwas anderes aus.
(23:35) Ja, und die Frage ist, wo ist jetzt der Unterschied? Und der Unterschied ist ganz einfach, denn äh ich kann dort die Parallele ziehen zu zwei Gateways, die wir schon hatten, nämlich einmal das Gateway mit dem Plus und einmal das Gateway mit dem X. Ja. Mm. Das Plus war das parallele Gateway. Und äh wir hatten in der Folge schon gesagt, paralleles Gateway ist ein hundsmiserabler Name.
(24:00) Viel wichtiger ist die Botschaft, dass das, was danach kommt, keine Abhängigkeiten zueinander hat und dass die Schritte dann in einer beliebigen Reihenfolge ausgeführt werden können. Das ist der eigentliche äh semantische Hintergrund des parallelen Gateways, viel wichtiger als dass diese Dinger da parallel ausgeführt werden. Und bei dem exklusiven Gateway, da konnte es immer nur ein, Entschuldigung, das will ich ja gar nicht.
(24:23) Ich will ja gar nicht das exklusiv Gateway, sondern ich will den normalen Sequenzfluss haben. Das da will ich haben. Dann also beim parallelen Gateway war, es gab keine Reihenfolge Vorgabe. Du konntest die Schritte dahinter ausführen, wann immer du willst. habe ich einen Sequenzfluss mit drei Schritten, die dort A, B, C haben, dann bedeutet das, ich muss das zwingend in dieser Reihenfolge machen und ich modelliere es auch nur in dieser Reihenfolge, weil B abhängig ist von A, ja, und C ist abhängig von B, ne? Klassisches Beispiel, jemand gibt ein
(24:56) Formular ein, ein anderer muss das genehmigen und beim äh beim Sechsaugenprinzip muss da noch jemand drüber schauen, aber erst nachdem der erste drüber geschaut hat. Da ist also zwingend eine Reihenfolge einzuhalten. Warum? Weil zwischen den Schritten A, B, C eine Abhängigkeit ist. Sind die Dinger unabhängig voneinander, dann kann ich sie durch ein paralleles Gateway entkoppeln und die Reihenfolge bleibt dann beliebig.
(25:22) Und genau diese Gedanken von zwingender Ausführungsreihenfolge und Reihenfolge ist wurscht. Das wird eben jetzt auch durch diese äh Instanz mehrfach Instanzmarkierungen zum Ausdruck gebracht, denn dies auf der rechten Seite ist die parallele mehrfach Instanzmarkierung. Das ist nämlich jetzt hier der offizielle lange Name Parallele mehrfach Instanzmarkierung.
(25:48) Ja, und wenn das eine das Parallele ist, muss das hier logischerweise die sequentielle sequentielle mehrfachinstanzmarkierung sein. Und die Folge ist ganz einfach und das sehen gleich auch in der Demo. Bei der parallelen mehrfachstanzmarkierung kommen alle Aufgaben gleichzeitig zur Ausführung. Bei der sequentiellen mehrfach Instanzmarkierung werden die die wird die Liste in der Reihenfolge abgearbeitet, so wie die Einträge in dieser Liste eingetragen sind, einer nach dem anderen.
(26:23) Ja, und das ist hier der große Unterschied. Ja. Äh alles soweit verstanden? Absolut. Ja, ich bewundere immer deine deine roten Striche. Also das ist [gelächter] dann fehlt nur noch tatsächlich eine Ergänzung und dann kommen wir zur Demo, dass diese Schleifenmarkierungen auch bei Unterprozessen eingesetzt werden können, ne? Und das bedeutet, wir wissen ja, dass bei einer Aufrufaktivität oder auch bei einem eingebetteten Unterprozess, eben das jetzt wieder äh bömische Dörfer sind, bitte das Video zu Unterprozessen
(27:02) anschauen. Da gab es nämlich hier unten dieses Pluszeichen, ne? Das hat ja angedeutet, du bist ein Unterprozess bzw. eine Collectivity. Wenn man jetzt also diese Schleifenmarkierungen auch bei Unterprozessen einsetzen darf, bedeutet das, dass hier unten das dazugefügt wird. Also dann wird's da langsam unten richtig eng und ich kann natürlich nur eine der genannten Schleifenmarkierungen da unten platzieren.
(27:31) Es macht natürlich keinen Sinn parallel und sequentiell äh oder parallel und Standardschleifenmarkierung gleichzeitig da unten dran zu friemeln. Das ist natürlich sinnfrei. Ähm, aber wie gesagt, ich kann das auch bei Unterprozessen anwenden und die logische Konsequenz ist, dass ich eine Menge von Schritten ausführen kann.
(27:50) Dann komme ich zum Ende meines Unterprozesses und dann werden wieder die Schleifen Endemarkierungen durchgeführt. Und das ist natürlich ein ganz mächtiges Instrument, Dinge in einem Unterprozess zu kapseln und die dann in Schleife ausführen zu lassen. Und da bekomme ich dann wirklich ganz grandiose kompakte Darstellungsmöglichkeiten, die eben auch schön anzuschauen sind und die Nachteile, die wir bei den oben explizit modellierten Schleifen dann eben nicht mehr haben, dass da diese hässlichen Sequenzflüsse als Geisterfahrer wieder rückwärts gewandt
(28:26) sind. Da kommt dann natürlich eine ganz besondere Power in die BPMN rein, wenn wir eben Unterprozesse mit den Schleifenmarkierungen kombinieren. Kurze Zwischenfrage noch mal: Die Geisterfahrer, sind die grundsätzlich falsch oder sind die nach deinem Verständnis äh irreführend? Also, also es ist theoretisch möglich, sie so zu modellieren äh oder ist es verboten? Nein, es ist nicht verboten.
(28:52) Du kannst das alles genauso modellieren. Deswegen habe ich das auch als Beispiel oben hinzugefügt, ne? Man sollte natürlich noch noch diese zusätzlichen Gateways ergänzen. Grundsätzlich ist das erlaubt in der BPM zu modellieren, aber für mich ist es keine Best practice, wo wir doch diese schönen Schleifenmarkierungen haben und man das so kompakt darstellen kann und den Prozessfluss innerhalb eines Unterprozesses beispielsweise dann konsequent von links nach rechts modellieren kann.
(29:22) Ich gebe meinen Studierenden vor, versuch doch einfach mal nur noch von links nach rechts zu modellieren. Nie mehr, nie mehr einen Sequenzfluss zurück. Wenn ihr da in diese Versuchung geratet, bitte packt das in einen Unterprozess und verwendet die Standardschleifenmarkierung oder äh eben eine mehrfach Instanzmarkierung. Und das ist immer eine sehr interessante Übung und vor allen Dingen öffnet das äh den Blick dafür.
(29:46) Ja, sonst man ist einfach so versucht, oh, dann dängele ich da eben diesen Sequenzfluss zurück. Ist ja so einfach. Ja. Ja. Ja. Das das gehört dann eben dazu, wenn ich eben gute übersichtliche Prozessmodelle entwickeln möchte, die auch gut zu überblicken sind, rein visuell tatsächlich. Ja. Mhm. Okay. Da sind da sind wir wieder bei der Kunst, ne? Auch ein bisschen.
(30:08) Also richtig. Ja. Ja. Okay, dann dann lass mal sehen. Äh demotechnisch, ich würde das gerne mal Jetzt geht's in die Praxis und hier haben wir es schon. Ja. Ja. Äh, wir haben oben, ich werde mich auch nur auf dieses Modell konzentrieren, ähm ein Prozessmodell, wo ich auch tatsächlich, wie du siehst, mit Datenobjekten arbeite.
(30:30) Ja, und wäre ich richtig gut gewesen, ne, wäre das hier auch noch gegangen, denn tatsächlich möchte ich dieselbe Liste auch für die sequentielle Verarbeitung verwenden. So, wir haben hier äh eine Liste. Was tue ich da? Wir können ja in die Konfiguration reinschauen. Äh für diejenigen äh die dann mehr oder weniger an der Ausführung interessiert sind, die können jetzt mal kurz ein kleines Nickerchen machen, weil ich jetzt mal ein bisschen äh für diejenigen, die dann Interesse dran haben, das durchaus mal zeigen möchte. Wie habe ich jetzt hier
(31:00) in einer Scriptgabe die Liste erstellt? Ich nehme da immer ganz gerne JavaScript dafür und man sieht es, das es ist sehr einfach, ne? Ich habe hier ein ja Jason Array mit drei Namen drinne. Dein deine bekannten Namen. Ja, genau. Susi, Hugo und ne? Und hier kommt unsere Execution ins Spiel, ne? Execution, das ist ja unser Gedächtnis, indem ich das reinschreiben kann.
(31:28) Und ich mache, was da hinten ist, das ist sehr, sehr technisch. Also, vergisst das einfach. Für die, die es interessiert. Ich arbeite einfach sehr gerne mit Jason im Prozessktext, also in der Execution. Also wandle ich hier ein JavaScript Array in ein Jason Objekt um. Das ist das, was ich hier tue. Ähm das kann man sich dann auch logischerweise im Prozesskontext nachher angucken und damit ist die Liste definiert, ne? ähm Mirko.
(31:55) Und jetzt bräuchte ich hier gar nicht dieses Datenobjekt verwenden. Äh ich könnte trotzdem genau dieses Aist hier bei der Konfiguration meiner mehrfach Instanzmarkierung verwenden, ohne eben mit Datenobjekten zu arbeiten. Ja. Gut. Ähm wie modelliere ich übrigens hier so eine mehrfache Instanzmarkierung dran? Da geht man hier auf den Schraubenschlüssel und dann bekomme ich hier rechts oben.
(32:21) Das wird leider oft immer übersehen, ne? guckt hier immer ganz schnell nach unten. Das kann ich da einstellen und dann vermisst man eben diese Markierung und da sind sie, ne? Da sind die drei Markierung. Okay, also jetzt habe ich dieses Tierchen. Jetzt kommen wir zur Konfiguration und ich habe hier offensichtlich mehrfach Instanz parallel verwendet und das einzige, was ich im Wesentlichen brauche, ist, dass ich angebe, okay, über welche Liste iteriere ich? Und das sieht man hier in der Konfiguration. Sehr schön, dass ich
(32:54) jetzt hier einen Abschnitt Multi Instance bekommen habe. Der ist nur da, wenn ich hier eben auch so eine mehrfach Instanzmarkierung verwendet habe. Und dann gibt es hier dieses Feld Collection und dort sage ich bitte verwende diese Liste. Und dann nehme ich hier eben diese Namelist, die ich in meinen Prozesscontext ähm hinterlegt habe.
(33:19) Hier sieht man das, ne? Nur dass man das eben auch unterscheidet. In den Prozess Context, in die Execution habe ich die Variable Name List hinterlegt. Mein JavaScript Array, als ich es angelegt habe, hieß Elist. Elist. Ja. Und hier rüber über dieses Zeugs nehme ich List her und verwandele verwand es in ein Jason Objekt. Das hat einfach damit zu tun, weil ich lieber mit Jason Objekten im Prozess Kontext arbeite.
(33:50) Da muss ich keine zusätzlichen Java Klassen generieren. Nimmt eine ganze Menge an Ballast weg. Mhm. Und das habe ich eben hier unter Namelist hinterlegt. Und genau diese Namelist, die nehme ich jetzt her und sage, nimm diese Namelist und füge ne über Elements komme ich an die einzelnen Elemente dran. Dann pickt er sich ein Element aus dieser Liste, ja, und startet damit. Wir haben drei Einträge.
(34:14) Also wird diese Aufgabe, diese Benutzeraufgabe dreimal ausgeführt und jedes individuelle Ausführen bekommt aus der Liste einen Namen zugewiesen, ne? Und jetzt muss natürlich dieser Schritt wissen, okay, ich bekomme jetzt aus der Liste einen Namen, z.B. die Susi sorglos zugewiesen, aber unter welchen Namen kann ich die denn ansprechen? unter welchen Variablennamen.
(34:43) Ja, das fehlt noch. Und deswegen gibt es hier unter Collection den Eintrag Element Variable und das ist genau der Variablenname, den ich verwenden kann, um dann an dieses Einzelelement ranzukommen, also an die Susi sorglos. Und was bietet sich dann natürlich anderes an, als diese Variable name zu nennen? Ja, so und das sind also die zwei Dinge, die ich jetzt an so einer mehrfach Instanzmarkierung konfigurieren muss. Wir fassen zusammen.
(35:14) Erstens die eigentliche Liste, über die iteriert werden soll und anhand derer die Process Engine erkennen kann, wie viele Instanzen, also wie oft dieser Schritt ausgeführt wird. in unserem Fall 3 und dann der Variablenname unter der das Aktuellement für eine Instanz und zwar jetzt nicht Prozessinstanz, sondern Schrittinstanz, ne? Unter welchem Namen diese Schrittinstanz auf diesen Namen zugreifen kann.
(35:45) Und das ist die Variable. Und das ist alles also sehr sehr cool, sehr einfach zu machen und deswegen sehr sehr mächtig und mir macht's ein riesen Spaß mit diesen Instanzmarkierungen zu arbeiten. So, dann kommen wir zum sequentiellen Teil. Das ist von der Konfiguration natürlich exakt gleich, ne? Ähm, ich habe hier nur das andere Symbol auch.
(36:12) Ich muss hier auf die Liste verweisen, auf die ich zugreife. Und auch hier gilt, ich muss den Namen hinterlegen oder die Variable hinterlegen, über die ich auf das Einzelelement zugreifen kann. Ansonsten werden wir dort bei der Ausführung sehen, dass die uns dass dort die Aufgaben nacheinander präsentiert werden.
(36:34) Im ersten Fall bei der parallelen Mehrfachinstanzmarkierung werden uns alle drei Schritte gleichzeitig in der Aufgabenliste angezeigt. Das werden wir dann während der Ausführung erkennen. Mhm. [räuspern] So, und jetzt kommen wir zu etwas ganz seltsamen hier hinten, denn äh wo ist die Standard Schleifenmarkierung, lieber Mirko, wo ist sie? Sie ist nicht da.
(36:58) Aber wir haben sie doch hier Wir haben sie doch hier in der Konfiguration gesehen. Ist der Stil jetzt zu blöd, die auszuwählen oder was? Ja, jetzt kommen wir wieder so ein bisschen an die Grenzen unserer Prosers Engines. Lieber Mirko, ich weiß nicht, ob das bei euch mittlerweile korrigiert ist, aber in der Version, in der ich hier habe, gibt es zwar das Symbol, aber ich kann das Dinge nicht konfigurieren.
(37:22) Okay. Ja, und dann habe ich hier ein bisschen jetzt gemogelt, ne? Denn wir wissen ja, äh die Standardschleifenmarkierung wird ja auf alle Fälle sequentiell ausgeführt. Also ich tue etwas, dann gucke ich die Schleifenendebedingung, wenn sie nicht erfüllt ist, geht's wieder nach vorne und ich tue dasselbe noch mal.
(37:39) Das klingt ja nach einer sequentiellen Abarbeitung an. Äh das klingt nach einer sequentiellen Abarbeitung und deswegen sehen wir hier die sequentielle mehrfach Instanzmarkierung. Nur wenn ich jetzt in die Konfiguration reinschaue, dann ist keine Collection angegeben und auch keinen Element Variable, weil ich iteriere ja auch nicht über eine Liste.
(38:00) Das ist ja der Unterschied zu einer Standardschleifenmarkierung. Was unsere Umgebungen aber alternativ anbieten, das sind hier zwei Felder. Loop Cardinality und Completion Condition. [räuspern] Completion Condition. Mensch, klingt das nicht nach einer Möglichkeit, ein engendeekriterium zu setzen? Dumme Frage, ne? Natürlich, [gelächter] natürlich ist es das.
(38:27) Das ist doch genau das, was ich bei der Standardschleifenmarkierung angegeben habe. Irgendein Kriterium. Jawohl. Also, ich verwende jetzt hier tatsächlich dieses Feld Completion Condition und kann hier eine Endebedingung eingeben. Und zwar habe ich hier wieder eine Benutzeraufgabe. Da habe ich ein UI definiert und dort in diesem UI gibt es ein Feld, das heißt X.
(38:51) Ja, und wenn ich in dieses XDE eingebe, dann hört diese Schleife auf. Ja, und ähm äh das alleine genügt leider nicht. Also, wenn ich das nur alleine eingebe, dann sagt äh der der Modeler: "Ja, Moment, ist ja ganz nett, dass du das da reingeschrieben hast, aber ich brauche noch eine Bedingung.
(39:09) " Und da siehst du hier oben Loop Cardinality. Ja, und da habe ich jetzt eine irwitzig große Zahl reingeschrieben mit dem Hintergedanken, dass diese Anzahl der Schleifendurchlaufe nie erreicht wird im echten Leben. Ja, sonst würde das Ding, ich glaube es jetzt eine Million, ne? 1 mit 60 genau eine Million mal durchläuft.
(39:29) Das ist irwitzig hoch und das habe ich auch extra so gesetzt, weil dann vorher [schnauben] meine Completion condition zuschlägt. Also das ist einfach nur hier gigantisch groß gesetzt, damit äh ich damit meine Standardschleifenmarkierung sozusagen simuliere. Ja, gecheatet. Ja, ganz genau. Aber ich habe hier unten artig, wie ich bin äh in diese Textannotation Text.
(39:52) Ja, das Endebedingung und du siehst äh dieses ähm Test before habe ich hier nicht ergänzt. Äh können wir bei unserer Engine leider auch nicht konfigurieren. Also, wir sind jetzt hier immer in der fleißigen Variante unterwegs. Wir führen erst den Schritt aus und dann wird die Schleifenbedingung überprüft. So, also damit habe ich das so ein bisschen hingemurst.
(40:14) Äh, ich hoffe aber, weil im Prinzip alle Inkredenti für die Standardschleifmarkierung sind da. Wir müssen es eigentlich nur noch sauber implementieren. Äh, lange Rede, kurzer Sinn, unsere Process Engines können die Standardschleifenmarkierung. Sie ist halt noch nicht in der Konfiguration sauber drin. Okay. Ja. Okay.
(40:34) Also dieses Tierchen habe ich deployed und jetzt können wir uns das Ganze in Action anschauen. Ich logge mich mal ein. Äh natürlich sollte man auf Credents angeben. So. Ähm ich nehme mal tatsächlich äh was uns allen geläufig ist, die das Standard Cockpit, ne? Das kennt hier einfach jeder, wenn es aus der Kamunda Vergangenheit kommt. Äh da können wir in die Deployments schauen und da ist hier ne Schleifen deployed ist also auf meiner Process Engine vorhanden und da sind auch beide Prozessmodelle da.
(41:08) Wie du siehst, ich habe es hier unten auch mal im Unterprozess dran geheftet. Funktioniert alles ganz genauso. Okay, wir führen aber hier oben diesen Prozess aus. Das heißt, ich starte jetzt mal den Prozess und zwar schleifen mit Benutzeraufgabe. Here we go. So, ne? Und wir haben hier unten, siehst mal, siehst du hier unten you are assigned to the following tasks in the same process.
(41:33) Und da steht Eintrag bearbeiten, Eintrag bearbeiten, Eintrag bearbeiten. Wir können also unmittelbar die Wirkung unseres neuen Prozesses erkennen, nämlich dass dieser erste Schritt, an dem wir jetzt gelandet sind, ich zeige das auch noch mal hier oben in groß, damit wir das alles gut nachvollziehen [räuspern] können, denn die Nachvollziehbarkeit ist ja wichtig, ne? Wir sehen wir haben die Liste erstellt.
(41:59) Hier unten sieht man die auch, die Namelist, ne? Ich habe jetzt die Zeile und das ist eben das, was ich meine. Das ist jetzt ein Jason Array, ne? Sieht man hier beim Datentyp Jason. Ja, also da kann ich dann auch reingehen, kann das verändern, sehr einfach. Kann Namen hinzufügen, löschen. Ja, so. Also das ist Namelist, die ganze Liste.
(42:23) Und dann sehen wir hier noch ganz viele andere seltsame Variablen. Wir sehen vor allen Dingen, dass von diesem Schritt Eintrag bearbeiten drei Instanzen entstanden sind, ne? Und das ist einfach, ah, ich liebe es einfach so diese Transparenz. Und äh wir sehen, dass diese drei Instanzen gleichzeitig aktiv sind, ja, und dass jede einzelne Instanz ihren eigenen Namen bekommen haben, ne? Wir haben hier einmal die Variable Name, in der len Lang steht, eine andere Instanz name in die in der Hugo Habicht steht und eine dritte Instanz Name, die Susi
(43:02) sorglos beinhaltet. Und das Schöne ist, die Process Engine sorgt automatisch dafür, dass sie vollkommen unabhängig voneinander sind. Und wenn ich jetzt z.B. den Namen hier von ländere, dass das keine Auswirkungen auf die anderen Instanzvariablen hat. Und das ist eben eine ganz große Stärke von Process Engines, dass die die verschiedenen Sichtbarkeiten sauber auseinanderhalten können.
(43:30) Ah, und das ist einfach mega, ne? Ich modelliere es einfach, sage das Ding heißt Name. Äh aber so dieses ganze aufwendige, dass die auch wirklich sauber voneinander getrennt sind. Und wenn ich in einer Instanz etwas verändere, dass das keine Auswirkung auf eine andere Instanz hat, das ist schon großes Kino. Ja, und das sieht man hier eben sehr, sehr schön, dass da jede Instanz ihren eigenen Namen hat.
(43:52) Ähm, jede Instanz bekommt automatisch auch noch eine Variable mitgeliefert, ähm zu welchen, also die werden ja durchnummeriert, die einzelnen Instanzen. Und das wird hier über Loop Counter jeder einzelnen Instanz auch noch mitgegeben. Dann kann er sagen, bin ich 0, 1 oder 2. Du siehst, ist auch dreimal vorhanden.
(44:14) Mhm. [räuspern] Der Namestring ist dreimal vorhanden, den ich dort erzeugt habe. Und dann gibt es für die gesamte Mehrfach Instanz Markierung für alle Instanzen übergreifende Variabel, nämlich wie viele Schleifeninstanzen sind gerade aktiv? Drei Stück. Wie viele von diesen dreien sind bereits abgeschlossen? Keinen. Ja.
(44:40) Und wie viele Instanzen gibt es insgesamt? Ja, drei Stück. Ja, also man unterscheidet auch noch mal die, die gerade aktiv sind von denen, die es insgesamt gibt. Da bietet natürlich die Möglichkeit, wenn ich 10000 habe, nur drei aktiv zu setzen oder sowas. Ja, also dass man das auch erkennen kann hier direkt ähm äh durch übergreifende Variablen, die automatisch von der Process Engine zur Verfügung gestellt werden.
(45:09) Also wirklich äh toll toll implementiert, kann man gar nicht anders sagen. So, das war jetzt also hier der Betrieb, dass man da mal reingeschaut hat. Jetzt gehen wir in die Tasklist und da seht ihr hier diese 3A Aufgaben und das ist genau das mehrfach Instanz parallel. Ich kann jetzt einfach eine rausgreifen.
(45:26) Ich kann mir hier die Variablen anzeigen lassen, die für diese Instanz relevant sind. Ja, da sehen wir hier, dass wir hier die Ellen lang haben und das ist Instanz Nummer 3. Ja, das sieht man hier schön. Gucken wir uns den anderen an. Das ist der Hugo Habicht. Ja, und das ist ähm der mit der Loop Counter 1 und dann bleibt noch die Susi sorglos und das ist der mit der Nummer null.
(45:58) Ja, also das kann hier wunderbar sehen. Jetzt beende ich mal die Susi sorglos. Jetzt sind hier zwei noch übrig geblieben. Wie haben sich die globalen Variablen verändert? Äh, Loop Counter. Ja, sind jetzt das ist Loop Counter 2. Namestring ist klar. Ähm, number of completed instances, da haben wir's. Ist eine. Ja, wir haben eine beendet.
(46:22) Jetzt completen wir hier und die aktiven aktiven Instanzen sind auch runtergegangen. Also das so Ja, genau. Number of active instances ist jetzt nur noch eine aktiv. Ja, ne? Der Loop Counter ist ein completed sind zwei. Ja, und kaum habe ich hier diesen beendet, zack, hat sich hier der Eintrag verändert. Eintrag sequentiell bearbeiten.
(46:45) Das heißt, jetzt lohnt es sich mal wieder ins Cockpit zurückzugehen. Ja, wir gehen hier in unseren Prozess rein. Das ist weitergegangen. Ja, so ne. Ah, ich liebe es. Ja, ich kann mich da nicht oft genug wiederholen. Wir haben diesen Schritt abgearbeitet und wir sind jetzt bei der sequentiellen Ausführung und du siehst hier sofort die Konsequenz.
(47:09) Wir haben nur eine aktive Instanz, weil wir die Schritte ja jetzt nacheinander abarbeiten und du siehst Name ist jetzt auch nur noch einmal vorhanden und da steht der erste Eintrag drinne, nämlich die Susi Saglos. Ja, ist das cool oder ist das cool? Das ist cool. Es ist einfach mega. Also es ist einfach wirklich richtig schön. Ja, und da kommt jetzt einfach die Begeisterung, ne? Ich bearbeite jetzt hier äh die Susi sorglos.
(47:35) Ich schließe den Schritt ab und wir wissen als nächster an der Reihe ist Hugo H. Der Hugo, genau, ne? Und wir sehen hier unten auch number of completed instances ist eins, aber wieder nur ein Eintrag, ne? Da wir jetzt sequentiell abarbeiten. Jetzt sind wir beim dritten angekommen und das ist jetzt unsere gute Ellen. Genau.
(47:57) Zwei sind completed. Ja, also schöner geht's. Jetzt schließe ich diese Sache auch ab. Und jetzt sind wir hier beim letzten angekommen. Eintrag in Standardschleife bearbeiten. Gehen wir da auch noch mal kurz ins Cockpit rein. Wie hat sich das da jetzt? Wie manifestiert sich das da? So. Also machen wir das mal wieder groß.
(48:19) Unser Prozessmodell. Prozessmodell plus ähm Entschuldigung hier plus falsches Plusgemäß. keine Variable hinzufügen, sondern genau. Wir sehen hier äh Tokens sind durchgelaufen. Wir sind jetzt hier beim letzten Schritt angekommen und äh wir sehen hier unten eine Variable X, die ist defaultmäßig mit okay belegt, ne? Also X ist noch nicht Ende, ne? Äh auch für die Standardschleifenmarkierung gibt es diese Variablen und wir sehen das hier unten.
(48:58) Aktiv ist einer, komplettiert ist noch keiner. Number of Instances, ihr sieht eine Million. Ja, das ist das, was ich dort vorbelegt habe und completed ist auch noch nichts. Und das ist jetzt hier unsere entscheidende Variable X. Und ich habe diese Variablen auch in das UI reingelegt.
(49:17) Also, da habe ich jetzt tatsächlich einen UI für konfiguriert und da sehen wir diese ganzen Variablen auch. Und jetzt kann ich hier lustig auf complete klicken. Ja, wir bekommen immer wieder unser UI, weil die Variable X und ihr seht, das ist die einzige, die ich belegen kann. Ja, kann ich jetzt hier lustig weiterlaufen lassen? Ich kri steht immer noch auf jetzt. Ja, okay.
(49:37) Verbrauchste Prozessinstanzen sozusagen. So, machen wir das hier unten mal weg. So ne. Und jetzt sehen wir number of completed instances 4. Der aktuelle Loop Counter ist 4. 0 bis 3 haben wir schon bearbeitet. Der aktuelle Loop Counter ist vier und jetzt gehe ich hier auf Ende und damit wird jetzt die Schleifenendebedingung erfüllt und der Prozess ist damit auch zu Ende.
(50:05) Genau. Werter aufzuarbeiten. Großartig. Genau. Hat er keine Lust mehr. Und äh da kann man jetzt natürlich in das Cockpit gehen und sich den finalen Prozess anschauen. Schleifen Benutzeraufgabe. Genau. Hier sehen wir, ne? Um 10:1 habe ich es einmal ausprobiert. Jetzt habe ich es noch mal ausprobiert und [schnauben] äh da können wir die das Gesamtergebnis all unserer Variablen sehen, die sich dort angesammt haben.
(50:33) Also das ist jetzt hier der abgeschlossene Prozess und da können wir alles noch mal nachvollziehen. Das sieht man hier auch in dem Modell ähm ne, dass wir hier ähm drei Instanzen hatten, sieht man da, dass wir hier drei Instanzen hatten und dass wir in der Standardschleife fünf Instanzen hatten. Ja.
(50:54) Also das ist und ja, da geht einfach nichts drüber, ne? Und ja, das ist es, was ich mit heute auf den Weg geben wollte. Ja. Äh Schleifen mega spannend, äh sehr mächtig und hilft die Übersichtlichkeit von unseren Prozessmodellen signifikant zu erhöhen. Deswegen eine klare Empfehlung, keine Geisterfahrer mehr bauen. Setzt auf die entsprechenden Markierung.
(51:22) sehr gut dargestellt. Was ich festgestellt habe in der knappen Stunde, die wir hier hatten, wir haben schon eine Menge Vorarbeit geleistet, ne? Also, wir hatten sehr sehr oft äh, dass du gesagt hast, also ja, wer wer jetzt noch eine Frage hat, gucke die Sendung X und und so weiter und so fort.
(51:39) Das ist schon ähm beeindruckende Sammlung von Darstellungen, die wir da produziert haben. Das muss ich wirklich in eine Playliste packen. Ja, damit wir dann genau das mal Okay. Ja, das mache ich. Das ist das und es geht ja noch weiter. Das geht ja noch weiter. Ja. Ja, apropos weiter. Nächstes Mal kollaborative Prozesse.
(51:57) Das ist so mein Lieblingsgebiet. [gelächter] Du hast vielleicht sollten wir dort eine zwei Stunden Session einfahren, weil einfach so viel Spaß macht. [gelächter] Okay. Kollaborative. Okay. Ganz genau. Richtig. Nachrichten senden und empfangen zwischen Prozessen hin und her schicken, wie die Process Engine sowas erkennen, mehrere Nachrichten sammeln und die dann als Aggregat weiterschicken.
(52:21) Also da kommt dann so richtig Leben in die Bude, da geht das Herz auf. Äh da hast da ist das wird der Spaß dann deutlich. Okay, aber das das hast du jedes Mal abgeliefert. Also ja, ich kann mir nicht vorstellen, wo die Steigerungsrate ist, aber da werden wir uns dann überraschen lassen beim nächsten Mal. Genau. Genau. Okay, gut. Volker, ich danke dir.
(52:40) Ähm, was haben wir hier? Haben wir noch Fragen? Können Schleifenautomatisierungsleistung verbessern? Na ja, klar, das werden Schleifen von von allen BMN Engines unterstützt. Ja, standardmäßig sollte das so sein, ne? Oder? Ja, bitte was? Äh äh sollten werden Schleifen von allen BPMN Engines unterstützt. Ja, klar, natürlich.
(52:58) Ja, also in unterschiedlichsten Ausprägungen, ne? Da muss man dann äh gucken äh was jeweils unterstützt wird. Ich denke, ich habe hier auch auf die Feinheiten hingewiesen gerade bei der Starkierung. Sehr sehr beeindruckend. Ja, aber auch dein dein Scheiten war auch sehr beeindruckend, was das angeht. Also du hast da offensichtlich ähm ja, also wir haben gesagt, wir haben die Wahrheit gesagt, ja, das ist ja auch Unterschiede gehört gehört mit dazu, das ist unsere Einstellung.
(53:26) Nichtsdestotrotz sind es ja beides grandiose Process Engines. Wie gesagt, was die BPMN Abdeckung angeht, äh ist das schon stark. Du hast es beim letzten Mal hast du es schon mal genannt, noch mal genannt und ich bin ja, ich zöge ja nicht Namen zu nennen auch von von Engines selber. Ähm die das vernünftig abhandeln, also eine Workflow Engine kannst du eine nennen, die die das oder anders handelt als unsere beiden? Äh äh tatsächlich könnte ich diesen Namen nennen, aber ich möchte es bewusst nicht machen, weil dann kommt wieder
(53:57) jemand und du hast mich vergessen und du hast mich vergessen. [gelächter] Das wäre nicht fair, ne? Wir wir sind jetzt hier auf der Open Source Schiene und das möchte ich an der Stelle tatsächlich so weiten. Das ist überhaupt nichts. Bitte schaut euch auch diese Process Engines an.
(54:14) auf LinkedIn äh schreibe ich auch öfters mal was über die eine oder die andere Engine oder dass ich eine Veranstaltung von dem einen oder anderen Engine Hersteller besucht habe und gerade im deutschsprachigen Raum äh ganz großartige Process Engines, die da unterwegs sind und äh ich ich es gibt ja die Kommentarfunktion, ich würde sagen, lasst dir das darunter schreiben, haben wir nichts dagegen.
(54:35) Okay oder Mirko, ich habe ich bin ein offen kommunikativer, nicht immer netter, aber trotzdem grundsätzlich positiver Mensch. Also genau wie du. Also also insofern ja, wir wir machen das schon wie wie wie immer. So genau. Okay, dann ähm jetzt steigt gerade mein Kopfhörer aus. Das ist Zeit jetzt glaube ich auszuschalten.
(54:58) Ja, das war Ich danke dir noch mal. Ich wünsche dir äh noch eine gute Woche und noch einen guten Sommer, bis wir uns äh dann in der nächsten Folge wiedersehen. Ganz genau. Ich freue mich drauf, allen, die jetzt vielleicht auch den Urlaub noch vor sich haben. Schönen Urlaub, erholt euch alle. Akkus aufladen ist angesagt und dann starten wir im Oktober, glaube ich, wieder so richtig durch. Ich freue mich drauf.
(55:20) Bis dahin, tschüss. Bis dann. Ciao. [musik] [musik] Ich bin raus. Wir sehen uns nächste Woche.