ACTION TECH #105 - Wat is'n Nachrichtenfluss? Gast: Prof. Volker Stiehl

ACTION TECH #105 - Wat is'n Nachrichtenfluss? Gast: Prof. Volker Stiehl - YouTube
https://www.youtube.com/watch?v=_MhtcCMYNa4

Transcript:
(00:05) [musik] Willkommen in der Wunderwelt des gut gepflegten Geschäftsprozesses. Wir modellieren, automatisieren und optimieren Geschäftsprozesse. Und hier ist dein Host. Moin zusammen, ich bin Mirko, ich bin Prozessberater, das ist Process Pitch, die Show für Prozessretter und alle, die es werden wollen.
(00:29) Ähm, wir machen heute wieder Action. Wir wollen uns darum kümmern, was zu lernen, ja? Also lange genug haben wir ja nur gequatscht, jetzt müssen wir wieder was lernen. Und ähm, wer was lernen möchte, ähm, bleibt dran, ja? Wer nicht, der muss es auch dran bleiben, denn er hat eine Lücke zu füllen, die wir gemeinsam mit dem Freund der Show, ähm, füllen wollen.
(00:52) Da ist er nämlich der ähm, Volker Stiel ist endlich wieder zu Gast. Hallo, Volker. Ja, hallo Mirko und hallo an alle, die jetzt schon an den gespannt hoffentlich an den Geräten hängen, um zu sehen, was wir heute wieder vorhaben. Ich wollte dich noch loben, ich wollte nämlich sagen, dass du der geduldigste Gast bist, den ich je hatte, ja? Wir haben uns nämlich gerade wieder durch die Audioeinstellungen geboxt, ja? Bis wir kurz vor [gelächter] kurz vor Toresschluss noch ähm mit äh halbwegs guter Laune festgestellt haben, wie es funktioniert, ja? Ich
(01:24) Wir haben es geschafft, Gott sei Dank. Ich bin ich bin stolz auf dich. Ähm So, äh wir haben viel durch, ne? Also wir haben schon ähm ordentlich was gewälzt hier und werden heute uns bisschen intensiver mit den Nachrichtenflüssen beschäftigen. Genau. Eines der spannendsten Features in der BPMN, nämlich äh durch die Nachrichten wird es uns ermöglicht, mit anderen Prozessen zu kommunizieren, Nachrichten auszutauschen und damit ein höchstdynamisches System aufzubauen.
(01:55) Von daher natürlich äh eines äh der ja Kernthemen, ohne dass man eigentlich nicht auskommt. Ja, also ich kenne kein reales Szenario, wo man nicht mehr irgendwo mit anderen Prozessen kommunizieren muss. Und deswegen ist das natürlich ein ganz spannendes Hilfsmittel. Und wir werden heute mal ein bisschen tiefer schauen, was man damit alles so machen kann.
(02:15) Ich habe ich habe letztens schon diskutiert, ob das die Basis der der der der der der Orchestrierungsidee zwischen Prozessmanagement überhaupt ist und die Nachrichtenflüsse da eine große Rolle spielen. Ist das die richtige Einschätzung oder ist das eher so ein so ein Ja, grundsätzlich Grundsätzlich gilt, Prozesse leben nicht in Isolation.
(02:38) Ja. Ja. Und allein dieser Tatbestand lässt schon darauf schließen, dass wir mit unserer Außenwelt kommunizieren müssen. Mhm. Und es gibt so viele Szenarien, ja, wo wir, ich meine Wenn du an die Prozessmodellierung denkst und dir überlegst, dass ein Prozessmodell sich primär auf ein Geschäftsobjekt konzentrieren sollte, auf eine Bestellung, auf einen Antrag, dann und in größeren Szenarien logischerweise mehrere Objekte involviert sind, dann kommst du um diese Nachrichtenaustausche nicht hinaus. Ich mache das auch
(03:15) tatsächlich während der Vorlesung an einem ganz einfachen Beispiel, wo man dann merkt, okay, mit einem Prozessmodell kriege ich das nicht gebacken. Und das ist so was ganz Einfaches, wie die Einstellung eines neuen Mitarbeiters. Und da haben wir nämlich auf der einen Seite die offene Position, die offene Stelle, die besetzt werden soll, und auf der auf der anderen Seite die Bewerbung, ja? Mhm.
(03:38) [räuspern] Von der Bewerbung gibt es halt sehr, sehr viele. Von der offenen Stelle gibt's genau eine. Das heißt, wir haben hier ein Eins-zu-N-Problem. Und wenn du beide Objekte in einem Prozessmodell unter einen Hut bringen willst, dann wirst du feststellen, okay, dann wird entweder das Szenario nicht so richtig Realitätsnah, ja, muss da irgendwelche Kompromisse eingehen oder du trennst die beiden Objekte, das heißt auf der einen Seite hast du die offene Stelle und auf der anderen Seite die Behandlung der Bewerbung und wenn dann
(04:08) bei der Behandlung der Bewerbung ein entsprechender Kandidat oder Kandidatin ausgewählt wird, dann informiert der den Prozess für die offene Position, dass wir jemanden gefunden haben und dann kann die offene Position geschlossen werden. Also an dem Beispiel, ich kann es jetzt hier nur skizzieren, vielleicht machen wir dazu mal eine extra Session dazu.
(04:30) Dann wird es sehr deutlich, dass man an diesen Nachrichten nicht umhin kommt und wenn wir Prozessautomatisierung im echten Leben anschauen, dann haben wir sowieso keine Mickey Mouse Beispiele, die wir mit BPMN automatisieren, sondern da kommt man alle Nase lang an dieser Problematik vorbei und deswegen Nachrichten für mich eines der wesentlichen Elemente der BPMN.
(04:54) Um die kümmern wir uns heute. So. Genau. Wie gehen wir es denn an? Wieder wieder mit mit viel rot mit viel rot ein Beispiel. Wie immer. So haben wir das immer gemacht. Wir schauen uns ein Beispiel an, gucken, wie wir das Tierchen konfigurieren müssen, damit es dann ausführbar ist. Und dann schauen wir uns das im echten Leben an und gucken, wie wir das nachvollziehen können.
(05:15) Okay. Ja. Also Wollen wir dann wollen wir dann Screen teilen? Ja, dann mache ich das. darum. So. So machen wir das. Sogar zwei Screens sozusagen. Ja. Ja, genau. Ich habe auf der linken Seite den altbekannten Modeler, auf der rechten Seite die Runtime, sodass wir dann sowohl in die Aufgabenliste reinschauen können, als auch in den Betrieb, also in das Cockpit.
(05:38) Wir fangen auf der linken Seite an mit unserem Prozessmodell und wir haben hier zwei Pools. Normalerweise macht man das natürlich nicht in einer BPMN Datei, sondern [räuspern] man trennt das sauber. Nur jetzt hier zum Einstieg bewusst mal zwei Pools. Beide Pools sind ausführbar, was wir ja hier in unserer Umgebung sehr schön hier durch dieses Executable Flag setzen können, ne? Mhm.
(06:04) Gut, also wie [räuspern] gesagt, normalerweise sollte man das nicht in einer BPMN Datei machen. Ich hab's jetzt der Einfachheit halber gemacht. Wir haben auf der oberen Seite einen Prozess, der nur eine Nachricht sendet, und auf der unteren Seite ein Startereignis, ein Nachrichtenstartereignis, das genau auf diese Nachricht losläuft.
(06:25) So, [räuspern] und was muss man bei der Konfiguration von Nachrichten beachten? Die Empfängerseite ist ganz einfach. Ich selektiere mal hier das Nachrichtenstartereignis. Und das Nachrichtenstartereignis wartet nur auf einen Nachrichtennamen. Das sehen wir hier auf der rechten Seite, da steht Message. Und hier habe ich diese Nachricht angelegt, ja? Und was ist jetzt hier wichtig? Tatsächlich muss man sich ja im Klaren sein, dass diese Pools in separaten BPMN Dateien liegen, ja? Ich hab's ja, wie gesagt, hier nur der Einfachheit halber gemacht,
(07:05) das ist nicht der Standard. Und wenn ich die dann auf die Process Engine übertrage, dann müssen die Nachrichtennamen ja global verfügbar sein, denn ein Prozess 1 sendet eine Nachricht an einen Prozess 2. Das heißt, diese Nachrichtennamen liegen Process Engine global zur Verfügung, ne? Das ist ein ganz wichtiger Aspekt bisher.
(07:31) Wenn man sich die anderen Videos anschaut, dann waren das immer lokale Definitionen. Der Prozess wurde konfiguriert, die UIs dazu, aber die Daten dazu, das Das alles schön gekapselt innerhalb meiner BPMN Datei und das ist jetzt bei Nachrichten natürlich was anderes, was Neues, denn die Process Engine muss das jetzt überwachen, wenn ein Prozess eins eine Nachricht schickt, dann muss sie gucken, ob gegebenenfalls ein Prozess zwei darauf wartet und insbesondere, wenn es ein Startereignis ist, haben wir ja überhaupt noch keine Instanz von dem
(08:02) Tierchen laufen. Da muss man gucken, ob dieses Startereignis eben mit diesem Nachrichtenamen gestartet werden soll. Also, das ist ja tatsächlich ja ein ganz neuer Aspekt und das muss man immer im Hinterkopf behalten, dass diese Namen jetzt der Engine, also Process Engine weit global verfügbar sind. So, unter diesen Namen kann man hier über Create New ganz einfach definieren.
(08:27) Ich habe jetzt hier einfach, wie ihr seht, einfach Auftragsnachricht benannt. Ja, den habe ich hier definiert, Auftragsnachricht und wenn die mal definiert ist, können dann auch, und das ist das Spannende, andere Prozessmodelle diesen Namen aus der Dropdown-Liste auswählen. Das ist auch eine ziemlich coole Geschichte.
(08:50) Das eben und daran kann man eben erkennen, dass dieser Name dann global zur Verfügung steht. Also, das ist ein ganz wichtiger Aspekt und wie man hier sieht, der Empfänger, der wartet nur auf den Nachrichtenamen. Damit [räuspern] ist schon alles erledigt auf der Empfängerseite. Auf der Senderseite, liebe Leute, wird es leider ein bisschen kompliziert.
(09:13) Da klicken wir nämlich mal hier auf die Senderaufgabe und da sehen wir hier eine Lasche Implementation. Und dann habe ich hier Expression ausgewählt. Man kann da auch Java-Klassen und Konnektoren und Tod und Teufel auswählen. Ich habe es natürlich wieder so einfach gemacht, wie es geht und habe deswegen Expression ausgewählt.
(09:37) Und dann kann man hier in diese Zeile etwas ganz Spezielles kryptisches eingeben. Das ist relativ lang. Ich könnte das jetzt hier natürlich soweit aufziehen, na, dass man alles sieht, aber [gelächter] ich habe es uns ein bisschen einfacher gemacht. Ich habe das mal raus kopiert. Hier in mein Texteditor. Ja? So, den mache ich jetzt noch ein bisschen größer.
(10:01) Und ich habe das jetzt auch mal so zeilenweise aufgedröselt, damit man erkennen kann, was dort steht. Denn am Ende steht da jetzt ein bisschen Code, den kann man zur Verfügung stellen und dann kann das jeder kopieren, dann ist das auch gar nicht so schlimm. Was passiert da? Wir hatten ja schon mal das Thema Daten.
(10:24) Und diese Daten haben wir in unserem Gedächtnis hinterlegt. Ja, und das war der Prozesskontext und der hat in unserem Umfeld ja einen Namen gehabt und dieser Name war Execution. Und das sehen wir hier. Wir wenden uns also wieder an diese Execution. Die ist ja immer verfügbar, wenn wir einen Prozess ausführen und bei dem kann ich mir Dienste anfordern, fordern, ne? Das geht hier über GetProcessEngineServices, GetRuntimeServices.
(10:51) Das ist einfach so Standard. Das sind fixe Werte, die kann man direkt verwenden. Dann jetzt die nächsten Zeilen, die sind die spannenden. Denn da steht drinne, pass auf, ich will die Auftragsnachricht, ne? Das war genau der Name. Weil ich das so das jetzt im Hintergrund haben können, wir das hier auch hier bei dem Empfangsereignis, das kann ich mir parallel hierher holen.
(11:14) So, ne? So, und da sehen wir, hier steht Auftragsnachricht drinne und hier in meinem Stückchen Code steht auch Auftragsnachricht drinne. So, und damit sage ich also jetzt meiner ProcessEngine, pass mal auf, bitte versende eine Nachricht. Und zwar mit dem Namen Auftragsnachricht und der entsprechende Aufruf in meiner Process Engine, ja, das muss man wissen, heißt Create Message Correlation.
(11:43) Also, der versucht eine Korrelation, also etwas zu finden in meiner Process Engine, was auf den Nach- auf den [räuspern] Nachrichten-Namen Auftragsnachricht reagiert, ne? Und dieses Herausfinden, das ist die Aufgabe der Process Engine. diesen Dienst in Anspruch, wir als Entwickler sagen nur, pass mal auf, liebe Process Engine, ich versende hier eine Nachricht unter dem Namen Auftragsnachricht, korreliere das mal mit alles, was dir in deinem Prozess-Universum zur Verfügung steht.
(12:17) Und damit meine ich, schau mal, ob es Prozessmodelle gibt, die auf ein Startereignis mit diesem mit dieser Nachricht reagieren. Das ist damit gemeint. Korreliere das mal mit deinem Prozess-Universum, finde etwas, was auf diesem Nachrichten-Namen Auftragsnachricht lauscht. Ist das verständlich? Ja, schon. Okay, gut.
(12:41) Also, wir schmeißen das im Prinzip der Process Engine nur zum Fraße vor und die hat jetzt die eigentliche Arbeit, dadurch ihr durch ihr gesamtes Prozess-Universum zu gehen und zu gucken, ob es da einen Prozess gibt, der auf diese Nachricht lauscht. Und wir wissen ja, dadurch, dass wir den anderen Prozess der Process Engine zur Verfügung gestellt haben, dass es da einen solchen Prozess gibt.
(13:04) Und wenn wenn dann diese Process Engine diesen Prozess findet, dann ist diese Korrelation erfüllt, ja? Mhm. Und das ist eine ganz einfache Korrelationsbedingung, die nämlich nur auf den Nachrichten-Namen zielt. Wir werden gleich im zweiten Beispiel einen etwas komplizierteren Korrelationsmechanismus kennenlernen, aber wir wollen ja erstmal langsam anfangen.
(13:29) Mir jetzt erstmal wichtig, ähm, dass diese Korrelation vollautomatisiert durch die Process Engine erledigt wird. Wir sagen, wir geben der Process Engine nur die Info mit, pass mal auf, es geht hier um diesen Auftrags- Nachrichtennamen, also um den Namen "Mach mal". Ja? Und äh, wenn sie, wenn sie da was findet, dann äh, wird die Nachricht, die wir jetzt gleich verschicken werden, genau diesem Prozess zugeordnet und übergeben. Das ist das Schöne.
(13:57) Also, das passiert hier, äh, wenn man es lesen kann, in dieser Zeile 4. Und das wird durch diese eine Zeile ausgedrückt über den Nachrichtennamen. So, 'ne Nachricht hat natürlich auch einen Inhalt. Ja? Und äh, was ist das für ein Inhalt? nicht immer, aber ja, äh, bei uns schon. Genau, wir können auch leere Nachrichten versenden, dann haben wir nur den Nachrichtennamen, aber ich möchte jetzt, wie man äh, in diesem Stückchen Code erkennen kann, auch noch Daten übergeben.
(14:25) Ja. Und das passiert in typischer Name-Wert-Manier. Soll heißen, hier der Name der Variablen im Zielprozess soll Produkt heißen und als Wert übergebe ich ihm ein Auto. Und dann soll noch 'ne Variable erzeugt werden. Diese Variable soll im Zielprozess Quantity heißen und ich gebe dem eine Zahl mit, nämlich die Zahl 1.
(14:51) Also, lange Rede, kurzer Sinn, ich übergebe hier einen Auftrag, möchte nämlich ein Auto bestellen und zwar genau eins. So, und wenn ich das gemacht habe, auf welche Nachricht soll er reagieren, welche Daten sollen übergeben werden, dann sage ich nur noch, und jetzt leg los. Na, und dieses Loslegen, das wird hier durch diese letzte Zeile äh, ähm, erreicht, Correlate with Result.
(15:16) Und dieses With Result bedeutet, meine Process Engine bekommt eine Quittierung zurück, hat geklappt oder hat nicht geklappt. Ja. Okay, also das ist hier so ein Stückchen Standardcode, der ist für die Aufrufe mehr oder weniger immer gleich. Man kann dann noch ein bisschen was dran ändern, das schauen wir gleich im zweiten Beispiel an, aber im Wesentlichen war es das.
(15:39) Ja, auf der Sendeseite ein Stückchen Code, in dem Code schreibt ihr rein, welche Nachricht verschickt wird und gegebenenfalls welche Daten übergeben werden. Und auf der empfangenden Seite, wie man hier oben in der Konfigurierung sieht, nur die Na- der Nachrichtenname. Das ist alles. Soweit okay? Für mich ja. Wie wollen wir es dann handhaben? Ich habe hier ein paar Fragen, die schon angekommen sind.
(16:07) Wollen wir die dazu nehmen? dann dann dann flechten wir die gerade ein. Ja, wir haben hier, was ist der häufigste Denkfehler bei Entwicklern, wenn sie Sequence Flow und Message Flow verwechseln? Was ist der Was war der Anfang? Der Fehler bei Entwicklern, wenn sie Sequence Flow und Message Flow verwechseln. Ähm, der der häufigste Fehler da Oder ja, also also verwechselt man das? Also jetzt mal so, sagen wir es mal so.
(16:32) Na ja, ähm, der der häufigste Fehler oder was man sich einfach klar machen muss, ist, dass der Sequenzfluss nur innerhalb eines Pools zu verwenden wird und nie für die Kommunikation über die Poolgrenzen hinweg. Also der Sequenzfluss muss immer innerhalb eines Pools sein. Eines Pools laufen, ja, ja. Flow, beim Message Flow ist es genau umgekehrt, der muss immer zwischen Pools durchgeführt werden, aber nie innerhalb eines Pools.
(16:59) Das Dieser Fehler passiert aber bei Toolverwendung nicht, weil der das natürlich automatisch feststellt. Ja. Aber tatsächlich bei Anfängern stelle ich das sehr häufig fest, dass sie Startereignis und Empfangsereignis in denselben Prozess modellieren und die damit im Sequenzfluss verbinden und denken, dass das Ja, also das habe ich durchaus schon gesehen.
(17:23) Funktioniert natürlich dann in der Runtime nicht. Und der ansonsten gilt. Damit damit kann die Engine nichts anfangen. Also, wenn ich das wenn ich das tue, hat hat die Engine ein Problem. Ja. [gelächter] Ich meine, dann kannst du aber zwar was versenden, aber es ist ja dann an der Stelle kein Token an der Empfangsstelle, deswegen funktioniert dann die Korrelation an der Stelle nicht.
(17:42) Okay, okay, verstehe. Ja, aber tatsächlich, wenn ich Tools verwende, dann werden mir die Verbindung auch automatisch gestrichelt bzw. Durchgezogen dargestellt und der Sequenzfluss ist durchgezogen, der Nachrichtenfluss ist der gestrichelte, den wir ja da oben sehen, von daher kann man daran den Fehler nicht machen.
(18:01) Wenn ich allerdings mit der Hand modelliere, da sehe ich durchaus, dass dort die Fehler gemacht werden. Aber ich wüsste nicht, worauf dann die Frage noch abziehen könnte, was man dann noch falsch machen kann. Ja, im Grunde kann man das Verständnis, also man muss das Verständnis dafür haben, also zwischen zwei Pools, ja, und bzw.
(18:18) Innerhalb eines Pools bewegt sich das entsprechend, ja, wenn das falsch deutet. Wie kann man denn ohne ohne Tool modellieren? Mal so ohne ohne ja. Ja, gut, ich meine, bei meiner Klausur müssen meine armen Studierenden das alles per Foto malen, ja. Ehrlich? Ja? Ja, natürlich. [gelächter] Die haben dann ein Blatt Papier ja? Sie kriegen das BPMN Poster mit, das altbekannte BPMN Poster, wo alles drauf ist.
(18:46) Aber die richtige Verwendung der Verbindungen, ne, wir haben ja dann noch den Datenfluss kennengelernt durch die Assoziation, durch die gerichtete Assoziation. Da haben wir dann den gepunkteten Pfeil, also da diese drei Pfeilarten, die müssen sie schon auseinanderhalten können, wenn sie da die Dinger modellieren. Wenn man wenn man bei dir studiert, dann muss man ein Blatt Papier und einen Stift nehmen und und modellieren? Zur Klausur.
(19:11) Während der Veranstaltung tatsächlich modellieren sie ganz klassisch mit den uns bekannten Tools, insbesondere BPMN.io. Ja. Schön. Das ist ja, dann dann können Sie wenigstens beweisen, dass Sie es verstanden haben. Ja, ja. So ist es. Bin allseits, ja, cool, ja. Gut, okay, dann lasse ich mich weiter stören. Also, ich habe hier noch Exception Handling, Timeouts bei verpassten Nachrichten, aber das sind ja Dinge, die da kommen wir vielleicht noch dazu, oder? So, okay.
(19:38) Mhm. Gut, also, wir haben die Nachricht jetzt soweit gesendet, wir haben sie empfangen. Jetzt schauen wir uns das zur Laufzeit an, das sehen wir ja auf der rechten Seite. Dann gehe ich jetzt mal hier auf Prozess starten. Und da haben wir den Sender. Gucken wir vielleicht mal ganz kurz rein, da doch noch nichts läuft, dass Sie mir auch glaubt, dass ich hier ohne Netz und doppelten Boden unterwegs sind.
(20:03) Das sind so diese klassischen Prozesse, die nach Auslieferung unserer Engines ja immer laufen, also, ansonsten läuft hier nicht. Ja. Dann gehen wir hier mal auf Prozess starten. Und wir sehen hier Sender und Empfänger, das sind genau die zwei, die wir auf der linken Seite sehen. Und los geht's.
(20:22) Ja, wir haben jetzt hier den Prozess gestartet. Und was haben wir? Aufträge anzeigen. Gehen wir ganz kurz wieder ins Cockpit rein. Der Sender, wie man hier sieht, der sendet nur und ist sofort fertig. Ja, wir haben, ich habe da bewusst jetzt keinen Benutzereintrag hinterlegt, um den Prozess anzuhalten, der startet und ist sofort fertig.
(20:45) Wir können uns das natürlich anschauen, dass der gelaufen ist. Unter Prozesse, genau. Und dann gehen wir hier auf Sender. Und hier sehen wir auch, dass das gestartet wurde. Schauen wir uns die Uhrzeit an, 11:41 Uhr, das passt ganz genau, ne? Also, das ist hier dieser Prozess, der dort gelaufen ist, können wir uns darum angucken.
(21:11) Ja, der ist da ganz rührig durchgelaufen. Damit haben wir wieder mal bewiesen, dass du kein Verkäufer bist, sondern wirklich dass dir an Wissensvermittlung gelegen ist und dass du nicht schummelst, sondern wirklich. Genau, hier wird nichts geschummelt, ne? Also der ist hier artig durchgelaufen und wir haben es ja dann auch im Cockpit gesehen, dass wir dort eine Instanz am Laufen haben.
(21:32) So, und da ist er, der Empfängerprozess. Da können wir dann direkt, na, dann bekommen wir hier wieder die Übersicht über die beendeten und laufenden Instanzen. Wir gucken uns natürlich die, na, da sieht man sehr schön, zwei Stück wurden gestartet. Ich hab das am 19. Oktober offensichtlich schon mal ausprobiert.
(21:50) Ähm, der eine ist durchgelaufen, das sind hier die hellblauen Token und hier der dunkelblaue, da stehen wir gerade dran. Und jetzt navigiere ich direkt zu der Instanz, die noch läuft. Na, und dann haben wir unten, wie altbekannt, unsere Variablen und wir sehen, dass die Daten auch sauber angekommen sind. Ja? Also hat funktioniert, der Nachrichtenaustausch hat geklappt, die Daten sind angekommen.
(22:13) Dann kann ich mir das jetzt in der Taskliste, kann ich mir das UI auch anzeigen lassen, logischerweise. Auftrag anzeigen. Auftrag anzeigen, genau. Und da sind unsere Daten noch angekommen, Produkt und Menge, und wir können die Sache abschließen. So, das war zum Warmwerden. Also hoffentlich nicht so schwierig. Jetzt wird ein bisschen anspruchsvoller.
(22:39) Oje, ich ich gehe mal jemand holen, der sich damit auskennt. Ja, okay. So. Jetzt wird es anspruchsvoller. Äh, nicht auf der sendenden Seite, sondern auf der empfangenden Seite. Okay. Denn jetzt äh kommt was ein Szenario, äh was ich persönlich immer sehr gerne demonstriere, äh weil wir dort wirklich auch ein ganz tolles Feature äh der BPMN Nachrichten zurückgreifen können, was ansonsten, wenn man das selber programmieren müsste, sich in den Wolf modelliert programmiert und das dann auch noch immer zu kontrollieren
(23:16) ist natürlich monster schwierig. Und zwar können wir uns ja alle gut vorstellen, dass es so etwas wie Sammelüberweisungen oder Sammelbestellungen gibt. Ja? Äh, zum Beispiel Sammelbestellungen. Äh, wir haben ähm, zwei Hersteller oder wir haben zwei Lieferanten, mit denen haben wir gute Preise verhandelt.
(23:42) Ähm, ich will jetzt hier natürlich keine Schleichwerbung machen jetzt, aber ähm, wir können als Beispiel jetzt mal HP und äh Lenovo nehmen bei Laptops, ne? Es gibt natürlich viele, viele andere. Ja. die jetzt einfach mal. Mhm. Und ähm, wir haben vereinbart, okay, wir wollen von dir, liebe Firma, nicht äh jeden einzelnen Laptop bestellt haben, sondern ihr kriegt besondere Preise, wenn ihr beispielsweise in Zehnerpack bestellt.
(24:11) Ja? Und äh dann bestellt eine Abteilung einen Lenovo und einen anderer bestellt einen HP, ne? Und das ist natürlich klar, wir müssen diese Bestellungen sammeln, bis diese zehn Laptops zusammengekommen sind. Und wenn dann diese zehn Laptops zusammengekommen sind, dann soll es als ein als eine Bestellung zu Lenovo bzw. HP gehen.
(24:34) Ja? So, und jetzt besteht natürlich die große Kunst in dieser Sammelbestellung, dass die reinrassig gesammelt werden müssen. Das heißt, wir haben eine Sammlung für HP-Rechner und eine Sammlung für Lenovo-Rechner, ne? Und äh das muss die Process Engine sauber auseinanderhalten können. Und dann wird schon klar, dass der Nachrichtenname für die Korrelation alleine nicht mehr genügt.
(25:02) Ja. Wir brauchen also noch ein Kriterium, anhand dessen die Process Engine erkennen kann, zu welchem Sammelprozess er eine Nachricht zuordnen darf. Und das ist eben das Szenario, auf das ich jetzt eingehen möchte. Das Schöne ist, auf der sendenden Seite haben wir nach wie vor nur unseren Sendeschritt. Der spannende Teil, ja, also wie wie wir das alles hinkriegen, werden wir gleich uns anschauen.
(25:36) Der spannende Teil ist hier auf der empfangenden Seite, denn ihr seht, wir haben hier ein Startereignis und wir haben hier ein Nachrichtenzwischenereignis. So, und wenn man sich die Konfiguration von Nachrichtenstartereignis und Nachrichtenzwischenereignis anschaut, dann sieht man, dass dort der identische Nachrichtenname ausgewählt wurde.
(26:02) New Order Message beim Startereignis Mhm. und New Order Message beim Zwischenereignis. Ja? Und ähm das Problem für eine Process Engine ist, dass die bei Nachrichten immer genau einen Prozess diese Nachricht nur zuweisen kann. Das heißt, wenn wir eine Nachricht verschicken und es gibt mehrere potenzielle Prozesse, die diese Nachricht empfangen könnten, dann ist das aus BPMN-Sicht ein Fehler.
(26:35) Denn eine Nachricht ist eine Eins-zu-Eins-Geschichte und die Nachricht muss eindeutig einem Prozess zugeordnet werden. Entweder der Prozess läuft schon, dann kann man die Nachricht dem Zwischenereignis zuordnen, oder der Prozess läuft noch nicht, dann kann man ihm dem Startereignis zuordnen. Ja, das mal soweit zum theoretischen Teil und weshalb dieses Szenario hier so spannend ist.
(27:05) Na? Wichtig ist, beide Nachrichtenereignisse sind identisch konfiguriert. Ja? Die erste Nachricht würde also hier diese Prozessinstanz starten. Wir gucken dann, ob unsere Liste voll ist. Das heißt, wir haben hier ein knallhartes Abbruchkriterium, nämlich nach wie vielen Nachrichten soll die Sammelbestellung rausgehen.
(27:29) Und das habe ich hier knallhart hardcodiert und es ist klar, ich habe jetzt hier keine Lust, zehn Nachrichten wegzuschicken, bis diese bis diese Schleife endet, sondern ihr seht hier Order List Length ist gleich zwei, größer gleich zwei. Okay. Also, sobald zwei Nachrichten zusammengekommen sind, dann soll diese Schleife beendet werden und wir sollen hier in dieser Benutzeraufgabe reinlaufen.
(27:53) Na, bei der ersten Nachricht gehen wir also hier zu dem Zwischenereignis. Wenn dann die zweite Nachricht reinkommt, dann brechen wir hier aus der Schleife aus und wir können uns die gesammelte Liste anschauen. Mhm. Okay? Ja. Soweit verständlich, gut. Du hast ge- Du hast gecheatet, hast nicht abwarten wollen, zehn Laptops zu bestellen. Habe ich verstanden, ja.
(28:12) Genau, also wir werden nur zwei Stück bestellen. Gut. Und jetzt kommen wir zu der Seite. Hier bei Hier haben wir die Magie versteckt, dass wir dann wirklich nachher sauber die Trennung haben, dass wir eine harmonische HP-Liste sammeln und eine harmonische Lenovo-Liste und das nicht eine Lenovo-Bestellung in die HP-Liste reinkommt.
(28:42) Denn das müssen wir jetzt sauber auseinanderhalten und da stellt sich jetzt natürlich die spannende Frage, wie schaffen wir das? Und das muss wieder hier auf der sendenden Seite passieren und dann ist es hier wieder in dem Code versteckt. Ja. Das heißt, wir gucken uns jetzt wieder da, dazu gehe ich jetzt wieder in meinen Editor rein, den ich extra für euch wieder vorbereitet habe.
(29:02) Und da habe ich eine zweite Lasche und da seht ihr jetzt. Das Stückchen Code, das notwendig ist, um diese Trennung hinzubekommen. Weil es nämlich ein kleiner Trick eingebaut. Gehen wir also hier wieder die ganze Geschichte Zeile für Zeile durch. Wir haben hier wieder den Zugriff auf die Execution, hatten wir schon Haken dran.
(29:23) Ja. Dann haben wir wieder unsere Aufrufe der Services, dass wir hier irgendwelche Laufzeitdienste benötigen, das ist Standard Pixar Text Haken dran. Dann haben wir wieder hier unsere Create Message Correlation, das kennen wir von dem ersten Beispiel, der dort steht der Nachrichtenname drinne. Und der Nachrichtenname ist New Order Message.
(29:47) Kennen wir Haken dran. Jetzt kommt die neue Zeile. Ja. Und die macht. Die haut es raus. Ja. Und das ist hier. Na, hier kommt jetzt eine ein neuer Bestandteil zur Korrelation hinzu. Das heißt, wir haben zur Korrelations. Bestimmung nicht nur den Nachrichtenname, weil der Nachrichtenname in diesem Fall ja offensichtlich nicht mehr. Ausreicht.
(30:17) Wir brauchen noch etwas. Und was ziehen wir heran? Ich hatte es ja schon gesagt gehabt, wir wollen harmonische. HP Liste haben und wir wollen eine eine harmonische Lenovo Liste haben und das ist ja offensichtlich das Produkt, das wir bestellen. Ja. Und jetzt müssen wir nur noch sagen, was die Process Engine vergleichen soll.
(30:40) Okay? Und das sehen wir hier in dieser Zeile. Und wir sagen der Process Engine, bitte vergleiche zwei Variablen auf Gleichheit. Variable equals. Vergleiche sie auf Gleichheit. Ja? Und welche Variablen soll er denn dort vergleichen? Diese erste Parameter, das ist der Name der Variable im Zielprozess, also auf der Empfängerseite.
(31:11) Das heißt, auf der Empfängerseite muss es eine Variable geben, die dort Product heißt. Und dessen Inhalt nehmen wir, und dann steht da beispielsweise HP drinne, und den vergleichen wir gegen unsere eigene Variable, die Product heißt. Und das ist hier, ne? Ihr seht, da sind keine Hochkommatas dran. Das heißt, das ist der Variablenname, aber das ist der Variablenname hier auf der sendenden Seite.
(31:45) Und dessen Inhalt, ne, das ist ja das, was ich verschicke, nämlich das Produkt, was ich verschicke, der Inhalt wird verglichen mit dem ähm mit dem Inhalt der Variablen Product auf der Empfängerseite. Und wenn diese beiden Namen gleich sind, dann wird diese Nachricht dem Nachrichten-Zwischenereignis zugeordnet.
(32:08) Wird keine solche Instanz gefunden, dann wird diese Nachricht dem Startereignis zugewiesen. Und diese ganze Magie nimmt uns die Process Engine ab. Wir müssen nur sagen, pass auf, schau mal im Zielprozess nach, da muss es eine Variable Product geben, schau mal nach, was da drinne ist, und vergleiche es mit der Variablen Product, die bei mir hier in meiner Prozessinstanz drinne ist.
(32:36) Wenn diese beiden Inhalte gleich sind, Variables equals, dann weise diese Nachricht, die ich jetzt gleich verschicken werde, dem Zwischenereignis zu. Wenn du das nicht findest, dann weise sie der dem Startereignis zu. Denn das ist genau das, was wir hier auf der Empfängerseite haben. Denn wir haben ja Startereignis und Zwischenereignis mit demselben Nachrichtenamen versehen.
(33:01) Das ist die ganze Magie, die man kennen muss. Und dann sorgt die Process Engine, und die hat die die ganze Arbeit. Die hat die ganze Arbeit. Ne, man muss sich ja vorstellen, im echten Leben laufen da ja Tausende, Zehntausende von Prozessinstanzen mit Zehntausenden von Nachrichten, die dort austauschen. Und dann muss die da rein, die arme Engine da hergehen und dann gucken, okay, welche Instanz erfüllt diese Bedingung? Und wenn es keine gibt, eine neue Instanz starten.
(33:29) Und das ist faszinierend. Wir als Entwickler sagen auf der sendenden Seite nur, pass auf, hier, ich habe diese Nachricht, die heißt New Order Message, und äh im Zielprozess muss es eine Variable Product geben, schau da mal rein. Und hier ist, gegen was du das vergleichen sollst, nämlich den Inhalt meiner Variablen Product, und guck, ob das Ding gleich ist.
(33:52) Einmal definiert, und dann ist die ganze Magie erfüllt. Und das fasziniert mich immer wieder. Ja. Absolut. Okay, gut. Also, so funktioniert dieser Korrelationsmechanismus, und der ist für dieses ganze Message Handling so fundamental wichtig. So, und dann habe ich hier noch einen Trick gemacht. Ähm, da verweise ich auf unser Video zu den Daten, denn wir haben uns ja darüber ausgelassen, wie man Daten im Prozesskontext hinterlegen kann.
(34:22) Und äh ich bin ein großer Fan davon, die im JSON-Format zu hinterlegen. Und das habe ich hier auch gemacht, dann kann ich gleich größere Objekte in einem Rutsch übergeben. In dem ersten Beispiel, da haben wir ja zwei Einzelvariablen übergeben, einen String und eine Zahl. Aber das ist natürlich, wenn das ein riesen Objekt ist mit 50, 60 Feldern, ist das natürlich nicht machbar, dass man dann ständig Set Variable, Set Variable, Set Variable in diesen Text da reinschreibt.
(34:48) Das macht ja gar keinen Sinn, ja? Sondern man wird das in ein Objekt packen und das geht eben hier durch diese eine Zeile auch. Ich habe vorher ein Objekt erzeugt, nämlich dieses Order-Objekt. Ja, das habe ich in JSON aufgebaut, das sehen wir gleich in der Laufzeit und dann kann ich das hier in einem Rutsch übergeben.
(35:07) Ja? Und dann geht da so ein richtig schönes, großes Objekt. Okay, in meinem Beispiel besteht dieses Objekt nur aus drei Feldern, aber sei's drum, man kann sich das dann ja sehr gut vorstellen, dass da auch dicke, fette Objekte mit Listen übertragen werden können. Alles überhaupt kein Problem in einem einzigen Aufruf.
(35:24) Ja? Und dann geht hier dieses Auftragsobjekt rüber und wird dann auch unter dem Namen Order in dem Zielprozess hinterlegt. Ist das cool oder ist das cool? Das ist selbstverständlich cool, ja, natürlich. Ja, also ich bin da immer wieder begeistert. Ich kann da meine Begeisterung nicht äh unterdrücken, das macht einfach Spaß.
(35:45) Und jetzt schauen wir uns das einfach in Action an und dann denke ich, wird das auch deutlicher, was damit gemeint ist. Okay? Ja. Lass die Engine arbeiten, bitte. Gut. [räuspern] Ich ich ich sehe hier so eine eine gewisse Reserviertheit heute, Mirko. Ich? Was? Eine Reserviertheit? Ach Gott, nein, ich habe ich möchte mehr Enthusiasmus bei dir sehen.
(36:08) Ich ich bin ich bin dein ich bin dein größter Fan, was das angeht, weil du du bringst eine Begeisterung dafür rüber, ja? Der da beneide ich deine Studenten, dass sie den Spaß haben mit dir da wirklich semesterweit beschäftigt zu sein damit. Das ist das ist ich habe es ja immer nur in in in kleinen Häppchen.
(36:29) Ich bin angetan, definitiv, ja. Also es ist [gelächter] Nachrichtenflüsse waren nun nicht mein mein mein Favorite, aber ich habe auch schon Gäste hier gehabt, die haben das Symbol vorgestellt, ja. Und und haben haben gesagt, das ist das wichtigste Ding überhaupt, ja. Das ist mein Lieblingssymbol. es auch total begeistert, weil man einfach so viel zaubern kann damit, ja.
(36:47) Ja, und mir sitzt immer noch ein bisschen unser Audioproblem im Nacken, ja. Ich wollte dich jetzt nicht weiter verärgern mit Zwischenfragen, deswegen bist du in den Enthusiasmus ein bisschen auf der Strecke irgendwie. Wir starten jetzt den Prozess, ne. Ja. Und ich erkläre alles, damit man auch nachvollziehen kann, was passiert.
(37:04) Wir haben jetzt hier den Aggregator, also dieses Muster, dass man Nachrichten sammelt, bis ein bestimmtes Limit erreicht ist und dann gesamtheitlich versendet wird. Das nennt man so ein Aggregator-Pattern in der in der Integrationswelt. Und wir sehen hier, das ist der Aggregator-Prozess, der ist deployed als separate Einheit, so wie es auch sein soll, ne, dass jedes Prozessmodell seine eigene BPMN-Datei hat.
(37:31) Und wir haben hier den Top-Level-Prozess, und den starte ich. Okay? Dann habe ich hier auch eine Aufgabe bekommen, und die führe ich jetzt aus. Und da kann ich jetzt nämlich meine Bestellung eingeben, und ich mache das jetzt mal. Ich bestelle jetzt ein HP, einen einer, okay, Fragezeichen. Und dann sage ich abschließen. Und so, ne, dann ist mein Prozess, jetzt schauen wir uns mal erstmal im Cockpit an, was passiert.
(38:05) Ne. So, und da sind jetzt hier so zwei kleine Segmente hinzugekommen, denn ich habe diesmal, wie man hier links noch sehen kann, das ist eben das Schöne, auf der sendenden Seite diesmal danach noch eine Benutzeraufgabe eingeführt, damit auch der Sender stehen bleibt. Ja. Und der ist jetzt hier bei bei dem Schritt "Data sent to Aggregator".
(38:28) Und das sehen wir hier, Top-Level-Prozess eine Instanz. Dann haben wir hier den Aggregator, der wurde jetzt eben durch das Versenden der Nachricht instanziiert, ganz vollautomatisch, wie wir das auch schon im ersten Beispiel gesehen haben. So, und dann kann ich da draufklicken. Und dann sehen wir, okay, ich habe schon sehr oft heute das probiert, insgesamt also äh fünfmal sind wir hier durchgelaufen, drei Instanzen, zwei, die beendet sind, die haben hier diese Zielflagge hier, und einer, der am Laufen ist. Na, und in den navigiere ich
(39:03) mal rein. So, und da sieht man das sehr schön, wie der Token-Verlauf ist, und wir sind jetzt hier an einem Zwischenereignis angekommen. Und jetzt können wir hier uns sehr schön, dadurch, dass ich alles im JSON-Format habe, kann ich mir die Variablen angucken. Wir sehen, welches aktuelle Produkt reingekommen ist, na? Hier haben wir's, Produkt HP, Quantity 1, Comment sauber angekommen, und ich habe hier eine Orderliste angelegt, ja? Das habe ich durch entsprechende Skripte, da gehen wir jetzt in die Details nicht
(39:39) ein, was ich dort gemacht habe. Ich kann es mir aber hier schön anschauen, ne? Ähm, das ist also dieses klassische JSON-Format, wie man das kennt, eckige Klammer, es ist eine Liste, und wir haben ein erstes Objekt hinterlegt, nämlich unseren HP-Rechner, mit der Bestellung 1. Hat also alles wunderbar funktioniert.
(39:57) So, und äh jetzt sehen wir hier auch, dass in dem Zielprozess, in dem Empfängerprozess, es eine Variable "Product" gibt. Hier sehen wir's. Hier sehen wir das jetzt, was ich gemeint habe. In dem Zielprozess gibt es eine Variable, die "Product" heißt, und da steht HP HP drinne. Und jetzt gehe ich zur senden sendenden Seite und dann gucken wir, dass es dort auch diese Variable Product gibt.
(40:23) Okay? Das heißt, wir gehen jetzt hier wieder in unser Cockpit rein und gehen zu dem Sender. Das ist hier der Top-Level-Prozess und da gehe ich natürlich auch in die laufende Instanz rein. Und dann sehen wir, dass es dort auch diese Variable Product gibt und da steht auch HP drinne, ja? Und deswegen dadurch kann diese Korrelation funktionieren, ja? So, also, jetzt haben wir einen Prozess gestartet und jetzt könnte ich natürlich noch mal ein HP schicken, aber dann springen wir bei dem gleich aus der Korrelation raus. Das ist natürlich
(40:55) nicht so spannend. Deswegen bestelle ich jetzt einen Lenovo und dann funktioniert die Korrelation am Zwischenereignis nicht. Warum nicht? Weil der Sender einen Lenovo schickt, der Empfängerprozess aber ein HP haben will. Ja? Und dann sehen wir eben, dass ein neuer Aggregator gestartet wird, der für Lenovo verantwortlich ist.
(41:18) Und das ist das, was wir jetzt sehen sollten. Das heißt, ich starte den Sendeprozess noch mal. Prozess starten Top-Level. Okay, wir haben hier eine neue Aufgabe bekommen, nämlich hier die Daten einzugeben. Und dort gebe ich jetzt ein als Produkt Lenovo. Quantity nehme ich jetzt mal zwei, damit die Zahlen auch unter schiedlich sind.
(41:46) Zwei, okay, und ich schließe die ganze Geschichte ab. So, ne? Wir sehen hier, das ist das ist der Schritt im sendenden Prozess, ne? Data sent to Aggregator, sind wir hier hinten angekommen. Das ist langweilig. Wir gucken uns jetzt die Aggregator-Prozesse an. Und das schauen wir uns im Cockpit. So, und da seht ihr jetzt, ich bin ja jetzt gerade mit der Maus drüber gefahren, dass wir zwei Aggregatoren haben.
(42:16) Also tatsächlich die Korrelation zu dem HP-Prozessor nicht funktioniert, also wurde die Nachricht dem Startereignis zugeordnet und wir haben jetzt einen neuen Aggregator instanziiert, der für Lenovo verantwortlich ist. Das können wir uns hier anschauen. Wir haben jetzt zwei laufende Instanzen und die letzte Instanz, die gestartet wurde, da navigiere ich jetzt rein und da sehen wir Product Lenovo.
(42:42) Also es ist funktioniert wirklich so, wie ich das gemacht habe, der hat das untersucht, da Mist, kann ich nicht dem Zwischenereignis zuordnen, ich muss es dem Startereignis zuordnen, wenn ich es dem Startereignis zuordne, heißt das automatisch instanziiere einen neuen Prozessinstanz. Okay. So. Und jetzt darfst du entscheiden, welchen Prozess wollen wir abschließen, den Lenovo oder den HP? Ich bin selbstverständlich für die führende Industrienation von China und würde gerne einen Lenovo bestellen.
(43:15) Okay, gut. Also starte ich hier noch mal den Top-Level. Wir haben wieder eine neue die Aufgabe gekriegt. Jetzt stoßen wir also die nächste Bestellung an. Und wir bestellen jetzt in diesem Beispiel noch mal einen Lenovo. Na, da nehmen wir jetzt 20, damit wir doch wieder eine andere Zahl haben. So, wir schließen die Sache ab.
(43:44) So, na, wir sind hier und jetzt sieht sieht man hier schon, hier ist eine neue Task hinzugekommen. Ja. Store orders in database. Und das ist in unserem hier der Schritt. Ja. Na? Also wir sind tatsächlich jetzt hier aus der Schleife raus. Ist ein abgebrochener. Na, der hat und jetzt müssen wir nur noch gucken, dass es auch der richtige ist.
(44:07) Da gehe ich jetzt wieder ins Cockpit rein. Also Cockpit. So, wir gehen in die Aggregatoren rein und der, der als letztes was bekommen hat, ist dieser hier. Ja, und wir sehen, er hat tatsächlich. Orderlist length, wir haben zwei Stück empfangen. Es ist der Lenovo Prozess. Wir können uns jetzt hier auch die gesamte Liste anschauen, was da drinne steht.
(44:35) Mache ich auch größer, damit wir alles nachvollziehen können und da sieht man es wunderbar, ne? Lenovo erste Bestellung mit zwei, Lenovo mit 20 die zweite Bestellung haben wir hier schön zusammengepackt und jetzt könnten wir das. In die Datenbank schreiben oder an Lenovo senden und der kriegt nur die Lenovo Bestellung und nicht die HP Bestellung, keine gemischte Liste.
(44:56) Großartig. Aggregation hat also wunderbar funktioniert. Und das heißt, wir können jetzt hier. wird der zweite Aggregator sozusagen geschlossen dann, wenn wenn er seinen Job erledigt hat oder lauscht er auf die nächste Bestellung? dir jetzt. Das zeige ich dir jetzt. Ich gehe jetzt hier in die Tasklist. Wir sind ja hier bei Store Orders in Database angekommen.
(45:18) Na, [räuspern] und ihr seht, da habe ich diesmal überhaupt kein UI zu definiert und wenn ich in unseren Umgebungen, was immer wir dort für eine Implementierung nehmen, dann können wir uns ja hier die Taskvariablen anzeigen lassen, ne? Das ist ja das Schöne, dass man da kein UI definieren muss, sondern dass ich mir das alles lassen kann, was gerade im Prozesskontext im Zugriff ist.
(45:40) Und dann sehen wir hier die Daten ganz genauso. Also, ich hätte mir auch hier die die Liste anschauen können, ne? Und ich könnte die jetzt hier auch wunderbar drinne verändern. Macht immer so viel Spaß. So, ne? Und jetzt beende ich hier diesen diesen Aggregator, indem ich hier auf Abschließen klicke. So, und dann kann ich in mein Cockpit gehen.
(46:04) Dann werden wir sehen, dass vom Aggregator nur noch einer läuft, nämlich derjenige, der für HP verantwortlich ist. Der Lenovo Aggregator ist abgeschlossen, hat seinen Dienst erledigt und hat sich jetzt sauber beendet. Ähm und unser HP ist immer noch bereit, weitere Nachrichten entgegenzunehmen.
(46:23) Und wenn wir dem auch die zweite Nachricht schicken würden, dann würde der sich logischerweise auch beenden. HP muss also noch Umsatz machen. Lenovo liegt vorne, okay. Genau. Ja, und äh das das ist auch das tatsächlich, was ich für heute vorbereitet habe und was ich transportieren wollte. Der Mechanismus äh des Nachrichtenversands, der Nachrichtenentgegennahme.
(46:44) Ähm in einfachen Szenarien genügt der Nachrichtenname. Mhm. Aber in der Realität werden wir diesen Korrelationsmechanismus mit realen Daten durchführen, sodass wir dann äh eindeutig die Kriterien haben. Äh und was wir hier gesehen haben, äh die Process Engine muss genau einen Empfänger finden. Das ist BPMN-konform.
(47:10) Na, dass wir bei Nachrichten eins zu eins Zuordnung haben. Und für diejenigen, nur als Hinweis, ähm die wirklich intensiv mit unseren Umgebungen, also all den Camunda-Forks arbeiten, da gibt es tatsächlich bei Nachrichten äh den äh Aufruf Correlate All. Das heißt, theoretisch wäre es denkbar, dass man über Nachrichten eine Nachricht an mehrere Prozesse schicken kann.
(47:40) Davor möchte ich aber bewusst warnen, weil das äh eigentlich nicht äh BPMN-konform ist, denn eine Nachricht sollte eine eins zu eins Korrelation haben. Es gibt diesen Aufruf Correlate All und man könnte damit mehrere Prozessinstanzen treffen. Äh davon rate ich aber dringend ab, weil das äh wie gesagt nicht der Sinn ähm einer Nachricht ist.
(47:59) Will man einen Broadcast machen, dann haben wir das Signal dafür, äh, und äh, dann löst man das bitteschön darüber, aber nicht über Nachrichten. Das wollte ich nur noch ergänzen an der Stelle. Womit du wieder, äh, bewiesen hast, dass du der Kämpfer für die reine BPMN Lehre bist schlechthin, ja? Und äh, und das ist [gelächter] und dir nicht unbedingt dazwischenfunken lassen willst. Okay, verstehe.
(48:20) Und das was ich jetzt hier gezeigt habe, wie gesagt, das ist, äh, auf allen Engines mehr oder weniger gleich. überall. Ja, genau. Damit sind wir auch beim beim Standard nochmal, ja? Wir können heben die Fahne hoch und sagen, okay, wenn sich alle daran halten an den Standard und nicht irgendwelchen Schnickschnack machen, dann, ähm, dann macht das auch Spaß, dann kannst du auch sagen, okay, ich benutz das auch woanders und so weiter und so fort. Ähm, ja. Okay.
(48:47) Vielen Dank. Äh, äh, ich habe noch eine Frage, was was was mögliche, nochmal um auf die Fehler zurückzukommen. Ähm, gibt's Dinge, die die man falsch machen kann bei den bei den Nachrichtenflüssen? Also grundsätzlich falsch machen kann oder wo wo liegt da ein mögliches Problem in der Anwendung oder ein mögliches Verständnisproblem oder überhaupt irgendwie? Ja.
(49:07) Oder ist es relativ einfach? ich ich denke, wenn man jetzt hier den grundsätzlichen Mechanismus verstanden hat, ja? Ähm, dass man damit eine Asynchronität letztendlich, ne? Der eine schickt was ab und läuft sofort weiter und der andere arbeitet dann auch Tag weiter und das ist eben zu unterscheiden ist mit einer Call Activity, also mit der Aufruf Activity, wo ich ja auch eine wiederverwendbare Prozessinstanziere, aber der Aufrufer auf die Rück an, also auf die vollständige Abarbeitung des aufgerufenen Prozesses wartet und erst
(49:43) dann weitermacht, ja? Wenn man diese Asynchronität, äh, und, äh, und dieses Verständnis hat, wann nutze ich was, äh, dann kann man außer mit Programmierfehlern, die natürlich immer passieren können bei diesem Stückchen Code, da kann man da eigentlich nicht so viel falsch machen, ja? Man kann auch mehrere Variablen heranziehen zu dieser Korrelation, also man muss es nicht auf eine Variable beschränken, also da ist man dann auch noch recht flexibel, aber wenn man das Prinzip einmal verstanden hat und nicht so was macht wie "correlate all", dann
(50:17) muss man auch einmal mehrere Instanzen oder sogar eine neue Instanz startet, weil ein Startereignis ja auch funktioniert, dann kann man da eigentlich nicht so viel falsch machen. Okay. Ähm. Gut, vielen Dank. vielleicht noch die Ergänzung, dass eben dieser Nachrichtenname dann nicht in mehreren Prozessen als Startereignis z.B. genommen werden kann.
(50:39) Ja. Ja. Denn dann würde ja schon, dann würde man da die Nachricht an die Process Engine übergeben und dann findet er auf einmal zwei Instanzen, die beide mit demselben Namen starten als Nachrichtenstartereignis. Und so was sollte man natürlich nicht machen und das fällt leider auch nicht sofort auf, ja? Nur wenn wenn man dann das Ding starten will, dann sagt auf einmal "Uuh, kann's nicht eindeutig zuweisen.
(51:02) " Mhm. Ocker, du hast sehr oft, ähm, nee, anders. Wir haben es sehr oft erlebt, nee, anders auch nicht sehr oft. Wir haben es oft erlebt, dass du gesagt hast, okay, wenn man sich an den Standard hält, dann ist alles in Ordnung, ja? Aber es gibt eben halt auch Tendenzen, diesen Standard zu unterlaufen, äh, finde ich, ja? mal meine persönliche Meinung ist das so.
(51:22) Ich teilst du diesen Eindruck, dass da viel Schmu gemacht Natürlich. Ja. Ja, also, was ich da schon für ein Murks gesehen habe. Ich meine, das klassische Beispiel ist, wenn es BPMN-Modelle gibt, die links oben in der Ecke, z.B. bei den ganzen Aufgabentypen was anderes haben als die, die von der BPMN-Spezifikation vorgegeben werden.
(51:44) Ja. Das ist der Klassiker. Ja, also all diese Tasks schmeißt sie auf den Müllhaufen. Ja, entsorgt sie, verwendet sie nicht. Ja, weil das hat mit BPMN nichts zu tun. Weg damit. Okay. Ja, also es gibt also Tendenzen, Schindluder zu treiben oder oder anders. Ja, okay. Also, ich meine, der Hintergrund ist doch vollkommen klar.
(52:08) Ja, ich liefere hier etwas, was nur ich habe und damit binden die natürlich die Kundschaft an sich selber. Das ist doch, ich meine, das machen, das versuchen doch alle. Ja, und meine Aussage ist, weh rette weh rette den Anfängen, ja, niemals, never ever. Ja, weg damit. Alles was proprietär nach proprietär aussieht ist ist der Teufel, oder? Also finde ich ja finde ich finde ich persönlich auch.
(52:35) Also im Grunde, also manche Hersteller verstecken das ja hinter hinter einem Servicegedanken, ja, und sagen, wir haben uns ganz besonders für dich was ausgedacht und wir machen das da. Aber ich sehe das ähnlich wie du. Also im Grunde ist das eine jeder Versuch, proprietäres Zeug jemandem aufzudrücken, ist schon ein ein Beschneiden von Freiheit, finde ich. Ja.
(52:55) Genau, und wir haben ja auch schon drüber diskutiert mit diesem ganzen Konnektorthema. Ja. Und das ist ja, wenn man den prozessgesteuerten Ansatz verwendet, überhaupt kein Thema. Ja, weil dieser gesamte Integrationsteil eben in professioneller Integrationssoftware ausgelagert ist. Ja. Ja, und dann brauche ich keine Konnektoren mehr. Ja.
(53:14) Ja. Ja, und dann kann ich mich voll auf den Fachprozess konzentrieren und das hilft dabei, Fachprozesse von Integrationsprozessen sauber zu trennen und dann habe ich Fachprozesse, die völlig unabhängig sind von der existierenden IT-Landschaft. Das ist ja schon immer meine Predigt gewesen. Ja. Ja, dass man lernen muss, was ist ein Fachprozess und was ist ein Integrationsprozess und alles, was mit Agentic AI zu tun hat, das ist einfach nur ein Rumkrebsen auf der Integrationsebene, aber nicht auf der Fachebene. Ja. Und das muss man einfach
(53:46) mal verstehen. Ich habe eine persönliche Frage. Darf ich darf ich die stellen? Also was heißt persönliche Frage? Ich habe etwas, was ich was was mich beschäftigt, ja? Also es gibt ja diese begeisterten KI Kunden, ja? Ja. Die sagen, ich muss ja ich ich brauche mal deine Meinung dafür. Also wir haben ja haben wir noch ein paar Minuten haben wir schon, ja? Also es gibt die begeisterten Welt.
(54:10) Ja, okay. Wir haben die begeisterten KI Typen, die sich hinstellen und sagen, wow, ich kann jetzt hier auf meiner Insel eine Viertelstunde Zeit einsparen, indem ich einen Agenten losschicke und gut ist, ja? Ganz toll, ganz wahnsinnig wichtig und so weiter und so fort. Und die probieren dann noch was und noch ein Gen AI Ding und so weiter und so fort.
(54:29) Schaffen also mehrere Silos und Inseln, ja? Und kommen irgendwann, aber so da viele sind da noch gar nicht, irgendwann zu der Erkenntnis, ah, ich habe ich bin ja nicht mehr Herr meiner eigenen Suppe, die ich hier gekocht habe. Irgendwas ist schwer, so. Jetzt propagieren wir ja immer mit in unserer Bubble Prozesse helfen dabei, den Kram zu orchestrieren und damit auch vernünftig umzugehen.
(54:57) Die Brücke zwischen beiden Ansichten, ja? Zu gestalten, ja? Halte ich für relativ schwierig, weil jeder in seiner Bubble ist nicht schwierig. Komm, jetzt lass knacken. Ist genau das, was ich sage. Ja, los. Das was was ich gerade gesagt habe. Ja. Also dieses ganze Agentic AI Gerappel ist ja im Prinzip, ich habe dort die Schnittstellen zu den Tools, MCP und so weiter.
(55:21) Binden sich und tun was und das ist einzig und allein ein Rumberken auf der Integrationsebene. Wenn man sich den Prozess gestalteten Ansatz anschaut, da gibt es eben diese Trennung zwischen der Fachebene und der Integrationsebene. Und dann kommt das wunderbar zusammen. Auf der fachlichen Ebene bin ich einzig und allein in der BPMN Welt unterwegs.
(55:37) Und in der Integrationsebene, das sagt ja auch gesteuerte Ansatz, kannst du die Technologie nehmen, was immer du willst. Ja. Nur vermische diese Ebenen bitte nicht. Aber das Verrückte ist, der Fachbereich macht das ja. Also es ist ja nicht immer nur der der ITler oder der Integrations- Wissende, der der der irgendwo da rumfuhrwerkt, sondern dieses ganze AI-Gedöns, ja, kommt ja durchaus auch aus dem Fachbereich.
(56:03) Also der das meinte ich auch. Na ja, aber was baut der Fachbereich dann zusammen, ja? Ja, aber was was ihm was ihm was nicht sein Job ist, offensichtlich, ja? Also Ganz genau. Also nochmal, gegen das Agentic AI will ich überhaupt nicht sagen, ne? Das ist eine Technologie, wie es früher auch schon, ne? RPA haben wir ja auch schon gehabt.
(56:22) Ja, genau, das war die Bots waren auch mal ganz ja, hm. Ja, genau, ne? Und die krebsen da immer unten auf der Grasnarbe rum, ne? Auf der Integrationsebene. Und das ist fair enough. Na, und für bestimmte Szenarien, die Fehler erlauben können, denn Agentic AI mit ich meine KI ist eine probabilistische Ausführung, ja? Es ist es gibt dort Halluzinationen.
(56:48) Und wenn man an den Stellen Fehler verkraften kann, ein Dokument, was vielleicht nicht so richtig gut zusammengepackt ist oder ne eine Abweichung, wo ich mit Fehlern leben kann. Ja, dann dann kann ich das auch einsetzen. Nur eben, wenn ich dann in in die Prozesswelt eintauche. Ja. Ja, wo ich Nachvollziehbarkeit haben muss, äh äh wo ich die Transparenz, ich meine, ich baue mir dort eine riesen Blackbox und wir haben mittlerweile ähm gesehen, dass Blackboxen schlecht sind.
(57:17) Ja. Insbesondere, wenn sich Situationen verändern, ich muss schnell eingreifen, ich muss Fehler analysieren können, äh ich muss Abläufe verändern können, ich muss auf einen Stand zurückgehen können, wieder neu anstarten können, in 10 Jahren, wenn eine Revision kommt, das nachweisen können und so weiter und so weiter.
(57:34) Ich meine, gibt's ja sich Kriterien, die für Prozesse eine Rolle spielen und da kann ich mit so etwas nichts anfangen. Ja. Aber ich kann es an der Integrationsebene an der ein oder anderen Stelle verwenden. Ja, warum denn nicht? Aber die Schnittstelle muss halt sauber definiert werden von dem Fachprozess BPMN basiert an die Integrationsebene, dort wo es wo es sinnvoll ist, ja und dann das Ergebnis wieder an den Fachprozess zurückliefern, ja.
(58:04) Was ich halt für fatal halte, wirklich für fatal. Ist, wenn man glaubt, das gesamte Prozessuniversum agentic umzusetzen. Ja, also daran glaube ich nicht und daran will ich auch nicht glauben. Ja. Denn wir müssen uns über eines klar sein, das komplexeste System. Was die gesamte Wirtschaft am Laufen hält, ist diese Prozesswelt von diesen gesamten.
(58:30) Und da sind wir wieder bei unserem Thema, bei diesen Nachrichten, diese da da. Agieren unzählige Prozesse miteinander, ne, wenn du Vorprodukte hast, die transportiert werden müssen, die hergestellt werden müssen, die Rohstoffe, die dafür erzeugt und her her transportiert werden müssen, Vorprodukte ein verarbeitet, dann der Vertrieb, das das sind ja unzählige Prozesse, die dort miteinander arbeiten.
(58:55) Und ein solches Geflecht, das ist das größte menschengeschaffene Geflecht. Und es funktioniert, ja, mehr oder weniger gut. Man kann es verbessern, aber und und da kommen wir jetzt eben zu dem Punkt, ein solches Geflecht, das will ich mir nicht vorstellen, dass das agentic mäßig abläuft. Deswegen wird es meiner Meinung nach immer diese Trennung geben, agentic Teile, ja, wo es Sinn macht, wo man Fehler verkraften kann, aber in in diesem komplexen Abläufen, da kann ich mir keine Fehler erlauben, das kann ich mir nicht erlauben. Und
(59:29) deswegen wird es immer diesen BPMN und den Prozess Engine Teil geben. Das heißt, sie ergänzen sich. Und das, was ich eben für fatal halte, ist ähm dass man denkt, "Agentic AI, if I have a hammer, everything looks like a nail." Und ich kann es jetzt für alles einsetzen. Stell dir doch auch mal vor, diese ganzen Prozessinstanzen, die werden ja hunderte von Millionen Mal ausgeführt.
(59:52) Und jedes Mal soll ich über Agentic mir errechnen lassen, welches der nächste beste Weg ist. Ich meine, allein das ist hirnverbrannt. Also, sorry. Ja. Da bin ich nicht dabei. Ja. Das macht keinen Sinn. Ja. Ja. Das Verrückte ist, die die sehen das gar nicht, die also diese Grasnarben, die Grasnarben Rookies sind. Ja. Ja, wer von Prozessen keine Ahnung hat, der sieht das nicht.
(1:00:13) Ist vollkommen klar. Okay, sind die verloren? Sind das verlorene Seelen oder muss man sich um die kümmern? nein, nein, die lernen das durch die Praxis. Okay, aber da muss ihnen muss ihnen ihre Grasnarbe erstmal abrennen, bevor sie begreifen. Genau. Genau. Genau. Ich meine, kostenmäßig, transaktional gesehen, die Transaktionskosten, ja, die du bei immerwährender Ausführung von komplexen Prozessabläufen, und ich meine, da sprechen wir von Geflechten von Prozessen, wie sie durch Collectivities und durch Nachrichtenversand und Empfang da
(1:00:45) aufgebaut werden. Leute, jetzt bleibt mal auf dem Teppich, ja? Es macht keinen Sinn, so etwas tutti completti Agentic abzuwickeln. Nein. Ja? Und wie gesagt, ähm wenn wir dann solche Ketten von Prozessen haben und an einer Stelle wird durch eben diese des Zuschlagens der Wahrscheinlichkeit ein Fehler transportiert, dann setzt sich dieser Fehler ja in den folgenden Prozessen fort.
(1:01:11) Und der führt dort auch wieder zu Fehlern und dann wieder zu Fehlern. Das ist dieses Kaskadieren von Fehlern. Ja. Nein. Ja. Und selbst, wenn man sich vorstellt, "Na ja, das wird dann irgendwann" Man wird nie, ich meine, sonst ist es kein KI-System. Man wird keine 100 % Wahrscheinlichkeit hinkriegen. Und wenn die Hunderte von Millionen Mal ausgeführt werden, dann ist auch eine sehr, sehr kleine Wahrscheinlichkeit dann irgendwann sehr wahrscheinlich, dass eben dieser Fehler passiert.
(1:01:34) Und darauf will ich mich nicht verlassen. Also, es gibt unzählige Gründe, warum das nichts wird. Meiner Meinung nach. Ja, okay. Ja, nee, ich finde das ich ja, okay. Also, rennst bei mir offene Türen ein, aber ich glaube Ich weiß, bin noch nicht ganz entschieden, ob ich die armen Seelen dann erstmal machen lasse und dann irgendwann hinkomme und sage, okay, also, ja, da könnte mal was anderes tun.
(1:01:59) Müssen die Das ist leider das Problem, dass das Seiteneffekte haben wird, ne? Die Kollateralschäden, die können durchaus übel werden. Ach so, wenn die alle auf die Mütze kriegen und sagen, okay, das Ding fliegt mir um die Ohren, weil ich nicht okay. Weil weil man einfach nicht mehr den Überblick hat, was wo passiert.
(1:02:17) Ich meine, wir haben über 50 Jahre, also, wenn ich jetzt mal die Gründung der SAP im Kopf habe, die ist 72 gegründet worden und das ist ja im Prinzip das Aushängeschild für für Standardsoftware. Also, seit über 50 Jahren wissen wir, was Blackboxen sind, ne? Und was das für für durchaus auch negative, neben den ganzen Vorteilen, die Standardprozesse haben, hat hat diese Blackbox aber eben auch die negativen Auswirkungen, dass die Transparenz völlig fehlt.
(1:02:44) Ja. Und und mit und meiner Meinung nach baut man eben mit diesem Agentic AI eine noch viel schlimmere Blackbox. Ja. Und das heißt, wir potenzieren das Problem der fehlenden Transparenz. Das halte ich einfach für fatal. Ich halte das für fatal. Ja. Was ist denn der Grund für die Begeisterung dieser dieser Grasnarbe? Weil man schnell Erfolge erzielt und weil man denkt, oh ja, jetzt kann ich es für alles einsetzen.
(1:03:13) Und da ist dann der Denkfehler drinne. Weil man eben das Epische, sage ich mal, dieser gesamten Prozesskomplexität und Prozesszusammenhänge nicht. Überschaut, warum nicht? Na, wer hat denn schon mal ein System gebaut, das 40 oder 50 Jahre gelaufen ist und was ich kontinuierlich weiterentwickeln muss.
(1:03:36) Und am Ende des Tages bauen wir über unsere Prozessautomatisierung höchstkomplexe Informationssysteme. Das ist ja nun mal mein mein Kerngebiet. Auch an der Hochschule. Und das muss ich ja 40 50. Ich meine, ein Unternehmen möchte ja, ich habe jetzt erst wieder einen Podcast gehört und da kam raus, dass Unternehmen so 100 Jahre leben und da muss ich ja ein solides Fundament haben.
(1:03:57) Was 100 Jahre trägt mit all dem, was in diesen 100 Jahren passiert. Wer hat denn von denen schon mal ein System gebaut, das wenigstens mal 20 30 Jahre gelaufen ist. Wer hat das denn gemacht? Und was das bedeutet. Wir wir gucken immer nur auf die Erstimplementierung. Wir schauen aber nicht auf die weitere Pflege von dem Tierchen.
(1:04:18) Die Erstimplementierung ist der geringste Kostenanteil an dem ganzen Tier, sondern das, was dann danach kommt, die nächsten Jahre, die Weiterentwicklung, die Pflege, die Nachweise, ne, wenn Fehler auftreten, die Fehleranalyse. Die Fehlerkorrektur, die unterschiedlichen Versionen, ne, wenn merkt ihr doch bitteschön einmal, du kannst mit Process Engines ja von einer Prozess, von einem Prozess sich Versionen parallel laufen lassen, ne, du kannst die Versionen migrieren.
(1:04:45) Wie wollen wir das alles mit, wenn das alles KI ist, wie wollen wir das denn hinkriegen? Wie wollen wir das überwachen? Wie wollen wir sichergehen, dass die das noch tatsächlich tun, was wir denen dann sagen? Letztendlich ist es ja eine verbale Geschichte und Wörter sind missverständlich, ja, und das wer ein bisschen mit dieser KI gearbeitet hat, da kommt ja oftmals nur eine kleine Sache, die ich vergessen habe und schon kommt totaler Schrott dabei raus, ja.
(1:05:09) Wer will darauf solche Systeme bauen? Alles unbeantwortete Fragen, ja, und okay, fair enough, wir haben noch kein System gebaut, konnten wir noch nicht, das 20 oder 30 Jahre läuft, aber wer das mal gemacht hat, der weiß, was da immer noch Neues dazu kommt, ja? Also, es ist trügerisch, ich kann es mir nicht vorstellen, ja? Es dann ist es eine trügerisch im Grunde darauf zu vertrauen, dass wenn ich jetzt also eine Insel mit einer Viertelstunde Zeitersparung mir hingebastelt habe, dass das dann auch skaliert und im Grunde mein mein Leben und mein IT-Umfeld rettet, wenn
(1:05:45) ich das einfach nur mehrfach mache. Okay, ja, ja, Ja, also, ich sehe so ein bisschen diese ganze Diskussion auch, als wir damals No-Code, Low-Code haben, da hatten wir die Diskussion auch schon, ne? Also dieses Quick and Dirty und auf Abteilungsebene und wenn derjenige geht und nachher funktioniert es nicht mehr und es ist nicht schlimm, alles gut, ja? Und genauso ist es mit mit diesem AI auch, ne? Und in der Unternehmensanwendung, wenn dann nur im Integrationslayer, ja, wenn da wieder der Hinweis, bitte mal nachschauen, wie baue ich nachhaltige
(1:06:19) Anwendungssysteme mit dem prozessgesteuerten Ansatz, dann kann ich es in dem Integrationslayer reinhängen, an den Stellen, wo ich mir Fehler, wo ich mir Fehler erlauben kann, ich muss immer damit rechnen, dass Fehler kommen. Fair enough, ja, aber oben drüber, da kommt mir nichts anderes hin als Process Engine und BPMN.
(1:06:36) Dann habe ich die volle Transparenz, ich habe die volle Nachweisbarkeit, ich bin super schnell in der Analyse, kann jederzeit eingreifen, ich habe das mit den Versionen, Historie und und und, ich meine, ich will jetzt hier keinen Vortrag über den Vorteil von Process Engines halten, aber das ist für mich das Nonplusultra, wenn es um große Anwendung geht, die über kurz oder lang daraus entstehen.
(1:06:58) Sind die Kunden alle halb geschädigt, die sich Okay. Natürlich. Na, also, ich meine, ich ich glaube, man kann sich Man kann sich Man kann sich dem ja nicht verwehren, ja? Und natürlich läuft dann im Kopf alles Amok, ne? Oh, was kann ich Wir spinnen dann natürlich weiter, was das bedeutet.
(1:07:23) Oh, jetzt kann ich da so ein Pipifax-Prozess in 0,nix machen und super, der findet mir den Weg und Oh, da kann ich doch eigentlich gleich SAP ganz abschaffen und ich habe das nur noch Ja, ich meine, das ist doch Humbug. Also, für mich, sorry. Liegt darin auch die Begründung für die 87 % AI POCs, die nicht skalieren und nicht in die Produktion umgesetzt werden? Geht da ab einem bestimmten Zeitpunkt jemand hin und sagt, ja, was bringt uns das und äh wie gefährlich ist das dann für die Zukunft? Du, das wäre Spekulation.
(1:07:54) Ich weiß es nicht, ja? Es kann sicherlich ganz, ganz viele Gründe haben. Müsste man mal eine Studie drüber laufen lassen, sagen wir mal, was ist denn da jetzt falsch gelaufen? Ich kenne derartige Auswirkungen, muss ich ehrlicherweise sagen, kenne ich nicht. Ähm, nur für mich Für mich kommt es halt nicht in Frage.
(1:08:12) Und solange man mir das Gegenteil nicht bewiesen hat, ähm, bin ich da raus aus der Nummer. Bleibst du mit bei dem, was du hast. Okay. Aber hallo. Und das ist Hallo, sagt er, ja, genau. Ähm, was war denn beim nächsten Mal, äh, Volker? Was Du bist ja im nächsten Monat wieder Da triffst du mich jetzt auf dem falschen Fuß. [gelächter] Ja. Ich dachte, wir Ich habe Wir haben den nächsten Termin im November, tatsächlich.
(1:08:33) okay. Äh, aber tatsächlich habe ich äh, Thema nicht parat. Äh, schreibe ich in die Shownotes rein. Genau, dann packen wir sie in die Shownotes. uns aber wieder im November. Gut, und dann lernen wir wieder was dazu. Ich, ähm, finde es großartig, jedes Mal, ja, ähm, wenn du hier bist. Ähm, äh, sorry noch mal für die Audio- ähm, Probleme am Anfang.
(1:08:52) Wir haben alles geregelt. Wir waren schnell genug, das zu lösen, das Problem. Wir haben ja nicht KI-verwandt, ja? Alles gut. Wir sind strukturiert vorgegangen und haben alles erledigt. Ich, äh, danke dir. Wir sehen uns im November und äh dann ähm klären wir, was wir dann klären. Wir schreiben es in die Shownotes, was es sein wird.
(1:09:11) Genau. Auch von meiner Seite ganz herzlichen Dank für alle, die auch dran geblieben sind. Äh ich hoffe, ihr ihr fandet es interessant und dann bis zum nächsten Mal im November. Macht's gut und bleibt gesund. Alles klar. Bis dann. Tschüss. Ich bin raus. Wir sehen