Moin, den wir letztes Mal ja in der Zweile wiederholt haben,
werde ich heute da die Veranstaltung der letztens noch nicht aufgezeichnet worden ist, ja?
Okay. Besser? Okay. Bescheid dann, wenn es
zu laut ist oder zu leise, sagt ihr Bescheid.
Wenn ich jetzt die Folie nochmal im Wesentlichen wiederholen vom letzten Mal,
aber nur ein Buchteil erzählen, was beim letzten Mal dran war.
Gut, Thema geht um Workflow,
was wir sozusagen als Fortentwicklung der Beschreibung von solchen,
irgendwie halte ich es heute wirklich sehr stark.
System sehen wollen,
von einer ganz normalen Informatiksystemen und insbesondere geht es halt um diese Idee,
dass man die Workflows,
also die Abläufe,
die Prozesse im System
irgendwie beschreibt
Und ein Beispiel, was wir dann hatten,
war halt eins von Wilvan der Alt,
der bestimmte Bearbeitungsprozesse hier beschrieben hat, das haben wir im Einzelnen durchgesprochen,
das solltet ihr euch genau ankennen, angucken,
denn du genau wisst, wie ihr Style auch ablaufen kann.
Die Idee dahinter ist,
dass man halt von so einer Anfangsmarkierung bis zu einer Endmarkierung
läuft und in irgendeiner Weise von der Aufnahme zur Beschwerde,
die man da hat, hinläuft bis zur Ablage,
bis es archiviert ist, dass sozusagen die Idee dahinter.
Gut, wie man dann dahin kommt, hängt eben entsprechend
von den jeweiligen Bearbeitungsschritten ab und den Alternativen, die man da hat.
Wir sehen, haben wir nicht nur jetzt wie bei den
Prozessen vorher sozusagen einen Fluss von link nach rechts,
sondern auch die entsprechenden Zyklen in dem System mit drin.
Gut, das heißt also, es ist das allgemeinere Beschreibung
als das, was wir vorher hatten. So,
die Idee von seinem Workflow-Netz ist dann eben halt,
dass wir zwei besondere Plätze haben,
nämlich den Anfang und das Ende und die
sehen wir jetzt hier nochmal eingekreist und dass eben alle Plätze
und Transitionen irgendwie auf dem Weg dazwischen zu finden sind
So, und wir haben in irgendeiner Weise eine Anfangsmarkierung und eine Entmarkierung,
die wir entsprechend noch angeben können, die sich eben genau
aus den beiden markierten Plätzen mit genau einer Marke ergeben.
Gut. So, das ist erstmal die Vorstellung,
wie man generell so ein Netz beschreiben kann.
Die Idee ist jetzt, dass man natürlich damit eine Systemstruktur beschreibt,
in der dann ganz viele verschiedene Prozesse für einzelne Fälle ablaufen können.
Diese Cases, die wir jetzt hier beschrieben haben,
Case 1 bis 6 oder 7, sechs,
die hier irgendwie durchs System durchrutschen sozusagen, werden,
wenn es natürlich unmarkierte Marken sind, die werden eben zur selben Zeit im Netz finden.
Problem hervorrufen, weil dann die Marken einfach irgendwas aktivieren,
was gar nicht zu ihnen dazugehört.
Aus dem Grund hat man halt die gefärbten Netze dort eingeführt,
sodass man halt hingeht und irgendwelche Zuordnung hat, sodass,
wenn etwas schaltet, nur noch die entsprechenden Sachen,
die auch zusammengehören, geschaltet werden.
So, durch dieses Schalten haben wir jetzt dann wiederum quasi eine Möglichkeit,
uns wieder darauf zu konzentrieren,
dass wir nur die ein Netz,
eine Instanz angucken können,
weil jetzt
keine Interferenzen mehr auftreten
Was war jetzt bei dem normalen System,
wenn ihr so irgendeine Firma habt, da gibt es eine Ablaufsteuerung,
irgendwie das Unternehmen, wie die einzelnen Prozesse abgearbeitet werden?
Warum ist das unrealistisch, wenn ich jetzt sage,
es gibt ja gar keine Abhängigkeiten mehr zwischen den Blauen und
den Grünen und den roten Dingen?
Was ist die Lücke bei dieser Modellierung
Ja, was beschreibe ich? Prozesse. Meine Frage lautet
. Was beschreibe ich nicht? Irgendeine Vorstellung? Irgendwas,
was so im normalen Ablauf... nehmt an,
ihr koordiniert eure Arbeit mit euren Kommilitonen.
Und die einzelnen Veranstalter von den Vorlesungen und Übungen,
die ihr besucht, geben euch einzelne Arbeitsaufträge.
Die Abarbeitung läuft eigentlich immer wieder gleich bei euch.
Ihr guckt euch die Sachen an,
ihr bearbeitet sie und dann sind sie irgendwann fertig
Alle völlig, völlig unabhängig voneinander.
Da bindet ihr alle immer so zu sagen,
wenn ihr euch selber sozusagen als so ein verarbeitendes System mit
euren Kommilitonen oder auch für sich selbst
Genau, also Zusammenfassung und Effizienz von Abarbeitung von Fällen haben wir nicht mit drin. Ja,
aber das würde ich dann als eine neue Art von Prozess bezeichnen,
dass ich sage, ich fasse jetzt hier bestimmte Dinge zusammen,
weil das ja eine Art von Verarbeitung ist, die ich extra beschreiben müsste.
Da ist richtig, fehlt, ist hier nicht drin,
aber das würde ich dann wieder als einen weiteren Prozess haben,
wo ich sage, okay,
jetzt muss ich hier die alle mal sammeln oder sowas ähnliches.
Das fehlt vollständig. Ich weiß,
dass jede Menge Leute von euch arbeiten,
also irgendwas muss euch eigentlich von so Abläufen in Firmen
bekannt sein
Ja. Ja, das regeln wir unser Netz,
weil wir nur die prinzipiellen Möglichkeiten von unserer Ablaufsteuerung angucken wollen,
ob die auch überhaupt sinnvoll möglich sind.
Ist uns das eigentlich egal, weil wir schon sagen,
da liegen 20 Marken irgendwo rum und dann wird irgendwie nicht der Terminister entschieden,
dass es durchschaltet und letztendlich wird es abgearbeitet.
Ist richtig, wir haben keine Prioritäten drin.
Ja, das wird in anderen Netzformulismen gemacht.
Aber auch das meinte ich nicht
Naja, wir haben doch jetzt hier so einzelne Fälle, die irgendwas evaluieren sollen.
Und wo irgendwas Check-Processing drin vorkommt oder Archivieren drin vorkommt.
Was sind dafür notwendig in einem Unternehmen?
Ja, irgendeiner muss es tun, genau.
Und wenn du jetzt 10.000 Anfragen gleichzeitig vor sich liegen hat,
gibt es halt ein Problem an der Stelle.
So, das heißt, was hier nicht drin ist,
ist die Abhängigkeit in Bezug auf Ressourcen
Und auf Daten. Das heißt, wenn diese Leute jetzt,
wie wir es ja vorher schon mal beschrieben hatten und diskutiert hatten,
in den anderen Veranstaltungen,
dass man in irgendeiner Weise so Datenabhängigkeiten hätte zwischen diesen Dingen,
dann hat man natürlich ein Problem.
So, und insbesondere, wenn jetzt also Ressourcen dabei sind,
die man benötigt, um diese Sachen auszuführen,
dann wird das hier nicht dargestellt.
Das heißt, die Workflows werden deswegen so einfach,
weil sie eine ganze Menge ausblenden. Ich sage nämlich gar nicht,
wer das tun muss und welche Ressourcen notwendig sind,
sondern ich sage nur,
welche Prozesse passieren da eigentlich
So, und damit fehlt eine ganze Menge. Was ich
auch noch erzeigen werde, während eine andere Perspektive einnehmen,
wo es um nicht so komplizierte Abläufe mehr geht.
Sondern wo es dann darum geht, wie man irgendwelche Ressourcenzuteilungen zu einzelnen Abläufen wieder hinbekommt.
In den flexiblen Fertigungssystemen fehlen noch kurz anschneiden,
nimm einfach nochmal einen Eindruck davon bekommt, was da funktioniert.
Das Spannende ist, dass man für diese Fälle von Workflows
bestimmte Berechnungsverfahren für die Korrektheit von solchen Workflows hat, die relativ flott sind.
Also Tastendruck und das Ergebnis ist da. Sobald ich da Ressourcen mit einbauen würde,
habe ich eine andere Komplexitätsklasse und komme auch in andere Schwierigkeiten rein,
wo wir Nachher noch mal darauf eingehen werden.
Aber die Idee dahinter ist, dass man versucht, Netzklassen zu bauen,
die einfach zu bearbeiten sind und die einfach zu verarbeiten und überprüfen sind.
Und die flexiblen Fertigungssysteme haben dann nachher nur einfache Sequenzen und Ressourcenzuordnung,
während hier jetzt sozusagen Nebenläufigkeit und nicht Demismus und sowas
drin ist und dafür aber keine Ressourcen.
Gut, das hatten wir letztes Mal nicht diskutiert,
das war noch mal eine Sache,
die hier durchaus noch mal
mit rein sollte
So, dann hatten wir irgendwie über entsprechende Strukturen gesprochen.
Die Idee dahinter war, es gibt jetzt irgendwelche bestimmten Konstellationen von Stellen,
Transitionen und Kanten, die wir immer wieder finden.
Und zwar sowohl im Kleinen, wie auch in etwas größeren Bereichen.
Wir gucken uns jetzt hier erstmal nur ein paar kleinere Sachen an.
Wir hatten hier den Parallel Split als ein Beispiel
So, und dass man hier die Sache aufteilt und hinterher nebenläufig Sachen abarbeiten kann.
Das ist ja auch ganz typisch in diesem Beispiel gesehen haben,
dass man anfangs dieses Teil empfängt, diese Anfrage und dann
sofort innerhalb des Unternehmenssachen aufteilt und parallel abarbeitet und damit unabhängig agieren kann.
Die wesentlichen Formen, die wir dann angetroffen haben,
war die Sequenz. Das heißt, wir haben ABC,
wir können so schön nacheinander ausführen, das ist etwas,
was man grundsätzlich beschreiben können muss.
Das nächste ist dann halt so ein Endsplit und Enjoin,
was eben dazu führt,
dass wir B und C nebenläufig bearbeiten können an dieser Stelle
Gut. Damit haben wir zwei wichtige Teile. Was haben wir
da noch? Dann haben wir die Möglichkeit von Alternativen.
Und wir haben jetzt hier zwei unterschiedliche Arten von Alternativen,
die in den entsprechenden Systemen, die der Befandals und andere Leute
eben beobachtet haben, immer wieder vorgekommen sind.
Das heißt, wir konnten immer wieder sehen, ja,
es gibt so ein und so eine Art von Split-Alternative,
die wir dort beschreiben können.
Sowas ist jetzt beim ersten Teil der Fall.
Wir haben dort eine Ein Prozess A,
der irgendwie ausgeführt über deine Aktivität A, die ausgeführt wird.
Dann haben wir B und C als Alternative,
wobei den Prozess A es egal ist, an welcher Stelle,
ob danach eben B oder C entsprechend weiterarbeiten.
Die Auflösung für dieses Problem liegt dann bei unserer Ausführungsumgebung.
Das heißt, bei unserem Simulator,
der das ausführt oder was wir dann in der Realität haben,
wenn wir sagen, hier, pack mal hin.
Und B und C erscheinen als Möglichkeiten auf der Agenda von
zwei Leuten auf ihrem Porm oder ihren entsprechenden mobilen Geräten
oder sowas oder ihren Arbeitsplätzen in der Umgebung
Dann drücken wir irgendwann eine Taste und damit wird quasi nicht die Themistisch entschieden,
wer von den beiden eigentlich weitermacht. Problem ist ja natürlich,
wie man dafür sorgt, dass der andere,
der ja auch gedrückt hat, mitkriegt,
dass er das nicht mehr bekommen hat und wer das jetzt hat und all diese Dinge kann man sich dann überlegen,
ob das eine spannende Angelegenheit ist,
dass man so 20 Leuten sonst noch die Agenda packt und
dann greift sich das einer und der andere wollte auch gerade.
Es gibt sinnvolle Anwendungen dafür. So, und dahinterher
gibt es dann einen Or-Join und eine entsprechende Aktivität.
Wir haben also die Möglichkeiten, ABD oder ACD auszuführen
So, eine ganz einfache Angelegenheit. Unten haben wir auch die Möglichkeit,
ABD oder ACD auszuführen, weil diese Transition,
keine Transition ist, die wir hier haben,
diese Aktivität A, die wir dort haben,
ist keine normale Transition, wird extra gekennzeichnet,
grafisches Symbol dran.
Und das bedeutet jetzt letztendlich, dass wir nur eine Marke
daraus kommen haben und dann eben entsprechende Marke auf C2 oder C3,
also entweder oder liegen haben.
So, jetzt kann man sich fragen,
wozu braucht man das
Naja, die entscheidende Idee dahinter ist,
dass jetzt die Lösung für das Problem, ob nun B oder C,
als nächstes weiterarbeiten sollen oder sich an diese Aktivität A anschließen sollen,
wird jetzt am Ende von A entschieden.
Wenn ich mir irgendeinen Zettel angeschaut habe, auf dem irgendetwas draufstand,
irgendeine Beschwerde und ich habe das jetzt angesehen,
dann kann ich das beurteilen und sagen,
okay, als nächstes soll B weitermachen,
weil das hier war einfach nur abzulehnen und wiedersehen.
Oder ich sage ja, ich möchte jetzt gerne,
dass das in irgendeiner Weise hier intern nochmal überprüft wird,
dass das bearbeitet wird und so weiter.
Ich kann also sozusagen am Ende meine Aktivität sagen,
Wie die nächste Aktivität im System eigentlich aussehen soll.
Und das Gute daran ist dann, dass B&C eigentlich gar keine Tiefen haben.
Das heißt, wenn B das Ganze auf seinem Bildschirm sieht,
in irgendeiner Weise, dann weiß er auch,
dass er diese Aufgabe quasi zu erledigen hat an dieser Stelle.
Wenn es halt bei C liegt,
es wird dann halt entsprechend bei C ausgeführt. So,
und das Sammeln ist dann wieder das ganz normale C4,
wo man einfach sagt, okay,
pack mal einen drauf und wird wieder abgezogen hier.
So, die Problematik dahinter ist, dass,
wenn man das erst mal so sieht, dann sagt er,
also eigentlich ein Petri-Netz und das geht so nicht.
Ja, das ist einfach eine entsprechende Semantik,
die man hinter die grafischen Elemente legt
Wo das Verhalten entsprechend irgendwo anders definiert ist.
Wenn ich jetzt so einen Teil also an der,
in irgendeinem Simulator ausführe oder in irgendeiner Umgebung ausführe,
weil mein Unternehmen hat diese Abläufe jetzt entsprechend so aufgemalt,
dann möchte ich gerne, dass die Sachen entsprechend umgesetzt werden,
du musst dahinter eine Semantik packen.
Und das ist eben genau das,
was man ganz gut mit den Netzen halt machen kann,
weil die relativ klar sagen, dass man dort machen kann.
Das Interessante ist vor allen Dingen,
das hatte ich vorher nicht mehr erwähnt, ist,
dass wir sozusagen jetzt hier zwischen den Aktivitäten und den Zuständen
noch unterscheiden können
Ja, die Frage war,
warum das Orjoin so komisch hingezeichnet ist, ist ein Zeichenfehler.
Ja, das ist richtig. Das müsste also sozusagen zum C weitergehen.
Dass es jetzt irgendwie anders ist, ist unsinnig,
weil das die Aktivität ist. Ja. Gut,
was wir haben, ist,
dass wir uns also nicht nur auf Aktivitäten beschränken und nicht nur auf entsprechende Zustände,
die wir dann beschreiben, was andere Techniken vorher gemacht haben,
versuchen die entsprechenden Alternativen, die wir jetzt hier darstellen können,
nachzubilden, wird es entsprechend schwierig und umständlich.
Dadurch, dass wir eben sowohl stellende Transitionen haben,
kann man alle möglichen Zustände bei Prozessen darstellen,
was wir genau mit dem machen,
was wir in der vorletzten und vorvorletzten Veranstaltung gesehen haben,
nämlich mit kausalen Netzen, Prozessen und so weiter,
wie man es entsprechend aufmalt.
Was aber auch deutlich wird, ist, dass man nicht
so direkt einfach durch ein grafisches Element in den Petri-Netzen Aktivität hat,
die hinterhin nur das eine oder andere wieder ausspuckt.
Nämlich genau unser Explicit Allsplit. Das heißt,
dass die Netze an dieser Stelle in der Ausdrucksmächtigkeit,
so wie die Leute das gerne eigentlich darstellen wollen,
möglichst wenig grafischen Elementen, dass das nicht funktioniert.
Weil es einfach nicht so definiert ist. Sehr wohl kann man aber
dieses Netz natürlich anders zeichnen und dann auch den gleichen Inhalt sozusagen darstellen,
indem er genau das benutzt,
was wir schon Ganz am Anfang dieser Veranstaltung gehört haben,
nämlich Vergröberung und Verfeindung von Stellen und Transitionen.
Wo es also hingeht und wir die Aktivität A jetzt durch ein anderes Subnetz quasi
... Entschuldigung. Durch ein anderes Subnetz ersetzen. Wie würde
dieses Netz A aussehen? Wenn ich nur bestellen,
Transition und Kanten benutzen dürfte
Ja, für das Explicit All, ja. Ja,
aber dann wäre das Problem, wenn ich jetzt nur,
statt des As, zwei neue Transitionen hinzeichne,
brauche ich auch entsprechend zwei neue Kanten,
eine lösche ich,
nämlich die eingehende Kante von A wird gelöscht und die müsste zwei neue Kanten haben.
Das heißt, ich würde den Konflikt,
genau wie bei der Stille C2 oben,
jetzt einfach auf die Stelle C1 verlagern
Wollte ich ja ungern. Ich wollte ungern,
dass sozusagen außerhalb meines Ars irgendwie dieses Bereichs,
den ich jetzt hier separat modelliere, dieser Konflikt in der Simulation auftritt.
Ich möchte ihn gerne sozusagen innerhalb dieser Aktivität A
in dem Subbereich, den ich angucken möchte, lösen.
Aber die Idee ist schon genau, ist schon genau richtig.
Genau, was man machen kann, richtig, genau.
Was man jetzt machen kann, ist, man kann natürlich sagen,
okay, ich spalte das so auf,
ich ziehe erstmal die Marke ab von C1 mit einer einfachen Transition,
ist klar geregelt, wo das hingeht.
Dann packe ich es an eine interne Stelle,
die ich von außen gar nicht sehen kann
Dann habe ich meine beiden Abarbeitungsdinge oder Entscheidungsdinge,
die ich da immer tun möchte oder ich habe
meine Verarbeitung erstmal innen drin auch noch,
taxi dann auf eine Stelle und habe dann zwei entsprechende Transitionen,
die dann intern in diesem Bereich,
also im Nachbereich von der Verarbeitung von A,
wie auch immer man es genau machen möchte,
die dann anschließend die beiden Marken
eben entsprechend rauspacken
Ja, gut. Also die Frage ist,
es gibt jetzt hier so ein Explicit All Split als Transition,
aber interessanterweise gar nicht als Stelle.
Und die Frage ist, warum ist dieses Join nicht erstens eine Aktivität?
Und zweitens, warum wird das jetzt genau so dargestellt?
Warum ist da nicht auch so eine komische Transition,
die das zusammenführt? Naja, das liegt daran,
dass wir jetzt erst mal ein Konzept angucken wollen,
nämlich genau da, wo es jetzt knifflig ist.
Und gleich werden wir nochmal sehen,
werden wir auch die anderen entsprechenden komischen Transitionen einführen,
die keine Transition sind, wo genauso was möglich ist.
Werde ich gleich nochmal zeigen,
wenn wir eine zwei Folien weiterkommen
An der Stelle. Man kann das, Konstrukt,
was wir da unten bei dem A haben,
natürlich auch sozusagen auf dem Teil für das Join in irgendeiner Weise wieder reinnehmen.
Ist aber, wie gesagt, verpönt, aber ich sag da gleich noch mehr,
ich sag da gleich noch ein bisschen mehr zu.
Die Frage ist ja genau berechtigt. So, noch mal
zurück. Wir können also für diese Konstrukte,
die wir jetzt hier einführen, eine andere Semantik angeben,
muss ja auch irgendwie programmiert werden in unserem Rechner,
dass wir lokal eine Entscheidung treffen in einem A,
so dass hinterher in unseren Ablauf es nicht mehr vorkommt,
dass B&C sich in einem System irgendwie um diese Marken
kümmern müssen
Warum möchte ich das? Naja, die Netze sind in
der Lage, nebenläufige und insbesondere verteilte Systeme zu beschreiben.
Wenn einer also in Hongkong und einer in Hamburg sitzt,
dann möchte ich nicht, dass die beiden erst mal telefonieren
müssen und erst mal aufwendig irgendwie so eine Konfliktlösung herbeiführen müssen,
um dann sozusagen die Bearbeitung anschließend weiterzumachen.
Sondern ich möchte dann die Bearbeitung nach München verlegen,
wo die Sachen eben ausgearbeitet werden für den Fall A.
Dann gibt es eine Entscheidung und danach ist auch klar,
an welcher Stelle hinterher die entsprechende Verarbeitung weitergehen soll,
nämlich für A oder für B oder für C
in dem jeweiligen Ort
So, das heißt, meine entsprechend verteilten Aktivitätsausführer müssen sich
da nicht darum kümmern, wie sie denn diesen Konflikt irgendwie lösen.
Insbesondere muss ich dann nicht mehr,
wenn ich eine verteilte Workflow-Engine habe,
nicht mehr dafür sorgen, dass zwei Workflow-Engines,
die in München und in New York und in Hamburg und sonst wo überall laufen,
sich weltweit abstimmen müssen, um dann Konflikte aufzulösen.
Sondern in dem Moment,
wo irgendein Auftrag nach München oder New York übertragen wird,
wird entsprechend dort auch verarbeitet und nicht mehr
wieder zurückgenommen,
zumindest nach diesem Bild erstmal
Gut, okay. Zu dem Explicit All-Join komme ich gleich noch. So,
die entsprechende Iteration, die wir drin haben,
das ist jetzt sozusagen das Wiederverwenden eines Konstruktes,
was wir jetzt in so einer Modellierungssprache,
die wir jetzt hier verwenden wollen, neu eingeführt haben.
Nämlich unser entsprechendes Explicit All Split. Das können wir auch unten in
der Abbildung 229, was jetzt natürlich nur hier gilt,
aber nicht in eurer Abbildung in eurem Skript.
Was wir da auch benutzen bei dem C,
sodass wir dort einen Split haben,
was dann entsprechend die Kante wieder zurückführen lässt,
sodass wir hier eine Rückkante haben, sodass wir hier beliebig oft durchlaufen können.
Was man auch hier wieder sieht,
es gibt hier in dem C einen entsprechenden,
eine entsprechende Entscheidung und da wird festgelegt,
was am Ende von C sozusagen passiert.
So, dieses Endsplit und Enjoin ist quasi etwas,
was man nicht unbedingt braucht.
Warum nicht
Warum brauche ich dieses extra Kästchen, extra Kästchenmalerei nicht in dem Netz normalerweise?
Okay, kommen wir gleich noch wieder zurück. Vielleicht wird das
gleich klarer. Wir haben das Implicit Osplit und implicit or join.
Gibt halt eine normale Stelle, eine normale Transition.
Es gibt dort den entsprechenden Konflikt und entsprechend wir die Zusammenführung.
Und jetzt haben wir auch genau die Antwort auf die Frage von eben,
wo nämlich dieses Express Explicit or Split und or join,
wie das jetzt hier funktioniert
So, für die beiden unteren sage ich, das ist echt ein Unterschied,
warum habe ich bei dem Oberen nicht mehr die normale Sache hingezeichnet?
Also warum sage ich jetzt, man braucht eigentlich diese Spezialnotationen oben gar nicht? Genau,
man kann eine normale Transition nehmen,
weil die grundlegendsemantiken Netzen halt eben genau diese ist,
zur Verdeutlichung, hat man aber dann zur Unterscheidung,
das nochmal so eingezeichnet,
dass man da oben sozusagen dieses Auseinandergehen hat,
beziehungsweise auf der rechten Seite sozusagen das Zusammenführen von den entsprechenden Wöchslein da und hier drüben eben diese Alternativgeschichte.
Ob das unbedingt eindeutig ist von der Lesbarkeit her,
muss man sich halt selbst überlegen,
ob einem das intuitiv sozusagen nahe geht.
Wichtig ist, dass sich eine Sprache eingeführt habe,
die jetzt sozusagen mit einer anderen Semantik unterlegt wird und die
man dann entsprechend auch noch in weiteren Formen einführen kann.
Ja,
das ist eine Frage
Ja, jetzt kommen wir zum nächsten Thema, was wir,
was wir in den Folien eigentlich nicht weiter groß thematisieren wollte,
aber wenn die Frage auftaucht, okay, greife ich es auf.
Die Frage ist, wie machen wir denn das,
wenn wir jetzt so ein Ohr haben,
was sozusagen zwei Marken raustun kann? Dass diese Geschichte,
ich kann den oder den oder auch beide sozusagen beliefern,
weil wir ja ein Entweder-oder eigentlich immer vornehmen wollen,
mit dem Ohr gibt es eine Menge Schwierigkeiten bei
der Semantik,
wenn man das entsprechend zusammenführen möchte
Wenn ich jetzt mal dieses Netz,
was wir hier unten haben, und jetzt würde ich sagen,
das ist jetzt ein entsprechendes Ohr,
wo auch zwei Marken ankommen können.
Welches Problem tritt dann auf? Tritt ein Problem auf?
Ja. Nee, das explizite, ne
Gut, okay, was können wir also machen?
Wir können hier eine Marke oben oder eine Marke
unten oder zwei Marken rauspacken bei dieser anderen Semantik,
wo ich ein normales Oder verwende, was auch beides beinhalten kann.
Welches Problem habe ich dann hier? Ich kann hier ein,
zwei, also eine oben eine unten,
eine oben oder eine unten oder eben zwei Marken haben.
Was ist also dann das Problem,
wenn ich jetzt
das Ganze ausführen möchte
Es wird eine Marke verschluckt. Nö, ne? Weil ich nehme jetzt
meine beiden Marken hier. Dann schalte ich das so durch,
dann kommen die beide hier an und dann waren ja auch zwei rausgekommen.
Da wird ja keine verschluckt. Bitte? In dem Fall,
wenn man das, wie wir es jetzt definiert haben wollen,
so nimmt, ja, aber ich habe ja gerade gesagt,
wir nehmen jetzt hier diese Oder-Interpretation und wollen jetzt diskutieren,
welche Probleme damit auftreten,
die der Herr
dort aufgeworfen hat
Und das war eine lange Diskussion und das ist wirklich eine,
da gibt es jede Menge Artikel zu, welche Probleme dahinter stehen.
Habe ich selber auch was zu veröffentlicht? Also es ist,
das ist eine typische Geschichte, die, ups,
die diskutiert wurde und wohlfür es verschiedene Arten von Lösungen nachher gibt,
um die Probleme, die auftreten können, eben wieder zu beseitigen.
Ich möchte es nur wissen, ist euch klar, welche Probleme auftreten können?
Also, warum frage ich das, warum diskutiere ich das?
Erstens war es eine Frage aus dem Auditorium.
Zweitens halte ich es auch für eine spannende Thematik,
weil wenn ihr in irgendeiner Weise sowas implementieren müsst in verteilten Systemen,
Da müsst ihr euch immer darüber im Klaren sein,
ob ihr aber eine Entweder-Oder, eine Oder-Logik hinter den Sachen stehen habt,
wenn ihr mit Leuten redet.
Das ist etwas, was ganz typisch ist,
dass man damit nicht zurechtkommt. Was ganz spannend war,
wir haben jetzt gerade noch ein Projekt,
unser Herot-Projekt gehabt, wo halt modelliert wurde.
Und da haben wir so ein paar Sachen entsprechend zu oft gemalt.
Und da gab es ein anderes Projekt,
was hier in der Betriebswirtschaft gelaufen ist.
Und da kamen eben Leute, die spezielle Anwendungsprobleme hatten aus
dem Wirtschaftsbereich an
Und die haben selber sowas aufgemalt und Erklärungsmodelle hingemalt und haben uns mal gefragt,
ob das denn alles so stimmig ist mit den Sachen,
was wir bei Herod entwickelt haben,
kommt man da mal drauf gucken und konnten relativ einfach sehen,
dass die genau dieses typische Oder-Problem hatten.
Und das war für die Mitarbeiter ganz spannend zu sehen,
dass tatsächlich diese Problematik, die man dann hinterher meint,
gar nicht mehr haben zu können,
tatsächlich ständig antrifft in der Praxis.
Das tritt immer wieder auf, dieses Problem. Als Informatiker sollte man
dieses Problem aber erstens kennen und zweitens dann auch durchdenken können.
Das heißt, ihr sollt jetzt überlegen,
welche Probleme treten auf, wenn ich dort sozusagen mal
ein oder mal zwei
Marken rausschmeißen kann
Richtig, genau, das ist völlig richtig.
Auf der linken Seite haben wir eigentlich kein Problem,
weil da tun wir entweder ein oder zwei Marken raus und fertig,
ja, das ist, das wird dort klar eindeutig,
da gibt es eine klare eindeutige Beschreibung für,
wie das geregelt wird intern.
So,
welches Problem tritt dann aber auf dieser Seite auf
Genau. Also das war jetzt auch genau die Antwort.
Das Problem ist, wenn jetzt eine Marke ankommt,
kann ich jetzt schalten, kann ich jetzt nicht schalten.
Weil es könnte ja sein, dass in diesem Durchlauf vorne zwei losgeschickt wurden.
Bei mir war erst eine angekommen ist. Zum Beispiel unser Beispiel,
das wir eben hatten, das Archivieren,
wenn da oben halt eine Marke liegt,
kann ich jetzt sofort feuern oder muss ich erst noch warten,
bis von unten irgendwas kommt und dann kann ich erst schalten?
Oder war das eigentlich überflüssig? Weil ganz am Anfang
gar keine Auswertung gewesen ist, weil der sagbar,
wenn er gleich gesehen, das Ding archivieren wir nur,
das war nur Unsinn,
wir archivieren,
dass es Unsinn war,
Nein, das weiß man nicht einfach so.
Dieses teile ich in Hamburg, das liegt in Tokio.
Und dadurch läuft ihr aus für Führungs-Engine und dazwischen sind 10.000 verschiedene Schritte,
die wir jetzt gerade nicht dem modelliert haben, also in Abläufe,
die irgendwie seit der Schiffsbestellung in Hamburg bis zur Auslieferung in Tokio,
vergehen eineinhalb Jahre und jetzt muss klar sein,
ob da vorne zwei Sachen gestartet wurden und da finden wir
zwei Sachen gesammelt werden müssen für die Ausführung oder nicht.
Genau, das ist das Problem. Das ist nicht einfach
das falsche Ohr. Okay, wenn es egal ist,
was ankommt, ja, aber dann habe ich ein Problem mit meinen Prozessbeschreibungen.
Dann kann genau das auftreten, was gerade die Antwort von eben war,
dass nämlich eine Marke geschluckt wird oder eine Marke generiert wird.
Wenn also jetzt zum Beispiel, ich sage,
ich schicke hier zwei Marken raus.
Und jetzt kommt hier eine an und sagt, jo,
ich arbeite jetzt mal ab, fertig.
So, dann wird das abgearbeitet. Die Aktivität wird ausgeführt
. Und dann kommt die zweite Marke hier an,
weil die zweite Marke jetzt auch irgendwie verarbeitet wurde.
Und dann schalte ich ein zweites Mal diese Transition
Dann würde ich für diesen Ablauf diese Bearbeitung zu mal durchführen und müsste irgendwann
diese Marke wieder einsammeln, damit wir auf diesen einfachen Zustand kommen.
Wir haben eine Anfangsmarke und kommen genau zu einer einzigen Entmarkierung.
Und genau da liegt das Problem drin. Und das Interessante ist wirklich,
dass in diesem verteilten System genau diese Sachen ein Problem darstellen,
wie das dann wieder zusammengeführt werden soll. Und das geht nur,
indem man entsprechende Informationen durch das System durchschleust,
sodass die entsprechende Aktivität, die hier stattfindet,
eben einen Kenntnisstand darüber hat,
wie die Entscheidung vorher hier gewesen ist,
weil sie ansonsten hier drüben einfach ein nicht vollständiges Wissen hat
zum Abarbeiten
Das heißt,
wenn ihr also hingeht und irgendwelche Verarbeitungsprozesse für Leute entwickelt,
müsst euch immer im Klaren darüber sein,
ob ihr über ein Oder im Sinne von Entweder-Oder redet oder so ein Oder,
was ein oder zwei Möglichkeiten hat dabei.
Gut, dieses Teil hatte ich jetzt extra nicht raufgebracht,
weil das immer wieder zur Verwirrung führt.
Aber wenn es schon gefragt wird,
greifen wir es doch mal auf
Die interessante Sache, die ich jetzt hier nochmal verkaufen möchte in Bezug auf,
wofür verwendet ihr eigentlich diesen Formalismus-Krams, ist einfach der,
dass ihr hingeht und euch eine Sprache entwickelt.
Das heißt, man kann Sachen auch viel einfacher darstellen,
weil wenn ich das, wie gesagt, mit einem Netz darstellen müsste,
um das jetzt hier aufzumalen, dann wird es halt wesentlich größer.
Und das einfach unangenehmer, wenn sozusagen ich doch eigentlich auch Sachen
viel einfacher darstellen kann. An manchen Stellen ist es auch sinnvoller,
nur die Aktivitäten sozusagen, nur die Zustände einzuzeichnen,
wie Übergänge, dass sich das, was dazwischen passiert,
gar nicht mehr aufmalt.
Zum Beispiel, wenn ich endlich Automaten habe,
dann muss ich sozusagen
einen Zustand hinmalen
Stelle. Dann male ich eine Kante beim endlichen Automaten und
gehe nächsten Zustand, bin fertig und schreibe dann Aaron.
Wenn ich das mit dem Netz mache, dann muss ich
zwei Stellen und die Transition und zwei Kanten malen.
Das ist einfach umständlicher und aufwendiger. Und in bestimmten Situationen
ist damit ein endlicher Automat einfach netter als ein Petri-Netz.
Und das gilt für tausend andere Dinge auch. Das Interessante
ist für jede Anwendung, die den Anwendungsbereich kann man unterschiedliche Sprachen entwickeln.
Und eine der Sachen, die ihr tut,
wenn ihr nachher in der Praxis irgendwo tätig seid und ihr
wollt irgendwelchen Anwendern irgendwas ermöglichen, dann baut ihr quasi Sprachen,
wie die nämlich mit dem System kommunizieren.
Und das müsst euch klar sein. Und die Möglichkeiten,
die ihr da habt, versucht ihr inzwischen,
wie es häufig üblich ist,
mit grafischen Notationen
zu machen
Sich einmal die UML-Sachen dazu an. Da muss man dahinter
auch wissen, was für einen Programmcode man dahinter packt.
Spannend wird es jetzt nicht mehr in den Einzelplatzsystemen,
weil für ein, zwei Systeme ist die Generierung schon ziemlich
weit und der ganze Stand der Forschung ist auch relativ weit.
Verteiltesysteme sind immer noch eine Menge offene Fragen da, weil dort sozusagen Probleme auftreten,
die relativ schwierig gefasst werden können durch die entsprechenden Beschreibungssprachen.
Netze können das schon ganz gut, haben aber,
wie gesagt, den Nachteil,
dass sie immer alles sehr detailliert und versuchen ja sozusagen formal eindeutig darzustellen,
wenn wir etwas eindeutig darstellen möchte
Fällt es halt schwer, dass sozusagen mal kurz,
mal so und mal so hinzumalen. Wenn man das machen möchte,
so wie hier, führt man neue Elemente,
grafische Elemente ein, die dann mit einer entsprechenden gleichartigen Semantik,
wie man sie sonst im System auch verwendet, wieder hinterlegt werden,
die aber dann nicht unbedingt an diesen Stellen sozusagen direkt ersichtlich sind,
wie wir jetzt mit diesen Kästchen halt sehen.
So, machen wir weiter. Wir haben bei dem Beispiel Netz
gab es jetzt vier Arten von Transitionen, nämlich die automatischen Transitionen,
das heißt unsere normalen, da gehe ich davon aus,
dass die dann einfach irgendwie schalten, wann sie schalten,
haben wir nicht gesagt,
aber wir wissen,
das wird eben abgearbeitet an der Stelle
Bei B, bei dem User erwarten wir also,
dass in irgendeiner Weise ein Benutzer kommt und eine Taste drückt und sagt, jo,
jetzt will ich das haben, jetzt will ich das ausführen,
das ist sozusagen das, wo wir die Benutzereingabe abwarten können.
Das heißt, innerhalb unseres Systems wird kein Fortschritt passieren,
so lange, bis ein Benutzer sagt, go.
C ist sehr ähnlich, da erwarten wir nur irgendeine Nachricht,
da muss es nicht unbedingt der Benutzer sein,
sondern es muss irgendwer eine Nachricht von irgendwas anderem ankommen.
Wenn wir so zwei Verteilsysteme haben, wir beschreiben die per Nachrichtenkommunikation,
dann kann das eine Computer sich was anderes schicken,
dass etwas anderes als das, was wir sozusagen annehmen,
dass wir dort einen Benutzer stehen haben, Entschuldigung,
der irgendetwas drückt oder nach der tut.
Vom Konzept her sind die aber sehr ähnlich. Und das andere ist eine Zeit,
dass wir halt quasi eine Uhr dabei packen und dann muss man sich halt nochmal genau überlegen,
ob es sozusagen eine Uhr ist, die anfängt zu laufen,
sobald eine Marke am Anfang der Transition liegt.
Ob sie das erste Mal aktiviert worden ist,
ob das bedeutet, dass, wenn sie angefangen hat zu schalten,
dann eine Zeit verschreicht und sie unter die normalen Bedingungen aktiviert wird,
Frage ist, gibt es da große Unterschiede?
Man muss mich halt einmal überlegen dazu,
wie das ausschaut
Wenn ich zwei Eingangsstellen für eine Transition habe und die hat entsprechende Zeit dran,
dann muss man sich genau überlegen,
was diese Zeit bedeuten soll und dafür gibt es die Time Patreonetts und das ist ein weiteres Thema,
was wir dann hier nicht weiter sozusagen verfolgen.
Hier läuft einfach eine Uhr eine Zeit, die sozusagen ausdrückt,
wenn sie Transition aktiviert war, wird nach einer Stunde einem Tag,
einem Jahr, einem Monat, was auch immer angegeben wird, schaltet diese Transition.
Hatten wir dem Beispiel gesehen, dass man entweder eine interne Verarbeitung im System hat,
die also irgendwann mal schaltet, Oder aber eben,
dass die Zeit zuschlägt, beziehungsweise wenn ein Benutzer nicht antwortet,
eine Nachricht nicht kommt, seine alte Alternative, die entsprechende Uhrzeit.
Ich glaube, für die automatische Sachen hatten wir das nicht.
So, es gibt also keine, es gibt eine Zeitbedingung für die entsprechende Bearbeitung. So,
Erfahrung aus der Praxis ist jetzt,
Würfelprozesse werden oft nicht richtig verstanden, Mehrdeutigkeiten, Widersprüche,
Verklemmungen, das ist etwas, was immer wieder dort auftreten kann,
indem man sozusagen Sachen schlecht darstellt,
indem man Abläufe eben nicht richtig verstanden hat und indem solche Dinge verwendet werden,
wie dieses Oh, Teil, wo man dann irgendwie was hat,
wo mal eine,
man kann ja sozusagen auch in so ein Workflow-Netz jetzt weiterhin Fehler einbauen.
Ich kann eine Stelle haben und im Nachbereich sind zwei Transitionen und
die zwei Transitionen tun einmal zwei und einmal eine Marke raus
und hinten werden die wieder zusammengesammelt durch ein entsprechendes Ort und wenn er nicht aufgepasst wird und dieses obere Teil,
wo zwei Marken rausgegangen sind, nicht vorher durch zwei Marken wieder eingesammelt werden,
habe ich genau diese typischen Probleme mit Marken erzeugen und so weiter.
Das heißt, bei dem Aufmalen, was wir jetzt machen können,
können wir immer noch weiterhin falsche Dinge aufmalen
Wir haben zwar unser Anfangs- und Endmarkierung, aber wir mögen
unsere Endmarkierung vielleicht nicht erreichen. Deswegen kann ich auf meinem Workflow-Netz,
was ich dort definiert habe, das trotzdem hinzeichnen.
Allein schon die Versuchsweise Modellierung durch Petrinetze deckt dementsprechende Mängel auf.
Ja, wenn wir uns so über einigen,
wie wir jetzt irgendwas abarbeiten und wir versuchen das irgendwie so mal so abzusprechen,
sag mal da, mal da, mal da, mal da.
Man übersieht das, man vergisst etwas,
was der andere gerade eben gesagt hat und es ist nicht ganz klar,
wenn man das erstmal sozusagen expliziert und hinschreibt, sei es ein Programm,
sei es ein schönes Netz, sei es irgendwas anderes.
In dem Moment sozusagen besser zu kommunizieren. Und genau dafür dienen
auch die Netze. Zum Zweiten werden dort eben Sachen visualisiert,
die man auch relativ schnell sieht,
wenn man eine gewisse Erfahrung mit dem Netz modellieren hat.
Wenn man das zum allerersten Mal macht,
läuft man genau diese typischen Probleme rein und baut genau diese Fehler
in dieser entsprechenden Darstellung mit ein und sieht sie auch nicht mal.
Wenn man gar nicht weiß, dass solche Probleme existieren,
ist man noch schmerzbefreiter in den Zeichnungen.
War ganz spannend. Wir waren halt bei,
ich bin in diversen GI-Fachgruppen. Ich hoffe, ihr seid
auch alle GI-Mitglieder
Die GI ist halt Gesellschaftsinformatik, nur so als Information.
Die Idee war dort, dass wir so ein Fachgruppentreffen hatten,
wo es um Informationssystemmodellierung ging. Und wir wurden dort eingeladen,
nach Waldorf zur SAP und haben uns ein paar Dinge angeschaut.
Und das Interessante war dort, dass die eben auch genau
die internen Abläufe von ihrem Programm versucht haben,
auf die entsprechenden Netze zu übertragen. Und genau dieses Phänomen,
dass diese Abläufe, wenn sie irgendwo im Programm stehen,
gar nicht mehr richtig im Groben sozusagen oder im Großen und Ganzen
gesehen werden, sondern dass man lokal halt irgendwas macht.
Und dadurch haben sie halt sozusagen, dass sie wirklich Räume
vollgepackt haben mit Tapeten über Petrinetz-Modellierung von ihren einzelnen Programmmodulen.
Haben sie eine Menge von diesen Problemen,
die in so einem großen System halt auftreten,
auch gefunden und konnten die auch entsprechend dadurch beseitigen.
Das war also schon ganz beeindruckend. So, bei fertiggestellten
Petrinetz-Modellen vom Workflow-System kann man eben jetzt die Menge durch strukturelle Untersuchungen aufdecken.
Man kann sogar durch Werkzeuge automatisch finden. Das ist jetzt etwas,
das wir so hingegangen sind und die entsprechenden Modelle,
die ja von irgendeinem System,
was wir bauen wollen oder untersuchen wollen und so weiter,
dargestellt haben
Dass man das jetzt irgendwie festhält. In diesem Modell,
was wir erstellt haben, stecken bestimmte Eigenschaften drin,
die ihr schon kennengelernt habt,
mit dieser Beschränktheit oder Lebendigkeit und solchen Dingen.
Die stecken halt irgendwie da drin in diesen Modellen.
Und die Kunst besteht jetzt genau da drin,
dass ihr die Eigenschaft, die in dem realen System existieren,
auch entsprechend auf die formalen Modelle wieder übertragt.
Wenn ihr programmiert, macht ihr auch nichts anderes.
Das ist ein formales Modell,
wo es eine genaue Maschinenbeschreibung gibt, nämlich Compiler X,
der genau das dann ernimmt und dann in der Laufzeitumgebung
entsprechend ausführt
Und wenn du dein einziges Bit falsch habt, dann macht das Programm was anderes.
Ja? Bitte, wenn ihr if than Els,
wenn ihr die beiden Dinger vertauscht habt bei eurer logischen,
bei eurer Programmierung, dazu ist genau das Gegenteil von dem, was es tun soll.
Ja, das ist halt ganz normal entsprechend damit drin.
Wenn ihr halt entsprechende Ablaufstrukturen eben erstellt habt im verteilten System mit irgendwelchen Streets,
dann wird es eben genauso spannend, wie ihr die wieder zusammenführt,
wann ihr welche habt, wenn ihr die eingesammelt habt und so weiter.
So, und die Idee ist jetzt,
dass man sowas mithilfe von Aktivitätsdiagrammen, EPKs oder Petrinetzen eben entsprechend darstellt,
dann Werkzeuge anwirft und die einem dann sagen, ja,
pass mal auf, also es gibt da so ein paar Eigenschaften im System,
die zählen folgendermaßen aus.
Das Teil ist unbeschränkt, es ist beschränkt,
bestimmte Bereiche sind unbeschränkt, das ist nicht lebendig,
es ist lebendig, was man so sonst auch noch haben möchte.
So, das ist das, was mit diesen Modellen jetzt
entsprechend hier machen kann.
So, welche Probleme seht ihr jetzt hier?
Also erste Frage, ist das ein Workflow-Netz?
Nein,
warum doch
Besser dafür, dass es ein Workfornetz ist? Okay,
wer ist dagegen? Keiner, sehr schön. Wir haben
unseren Anfang und unseren Enden, während es A und E.
Und alle unsere Stellen und Transitionen liegen zwischen diesen beiden Stellen.
So, das war unsere Definition, wir wollten wir nicht.
So, dass wir jetzt noch sozusagen so eine Anfangs-Sendmarkierung haben wollen.
Müssen wir gucken, ist das denn jetzt auch wirklich
ein vernünftiges Netz an dieser Stelle?
Was kann jetzt auch auftreten? Naja,
also am Anfang ist es nicht allzu schwierig,
was dort passieren kann
Wir können nach oben und unten schalten und können halt jetzt was tun.
So, jetzt können wir unten irgendwas tun. Jetzt kommt so
ein Brief rein und sagen wir, jo, geht.
Was machen wir jetzt um? Naja, da gibt es
ein Timeout. Und dann sagen wir, okay, gut,
das war nicht in Ordnung. So, es ist jetzt
ein Workflow, den wir so erwartungsgemäß wohl haben möchten.
Nein, es ist nicht, genau,
sie hat schon das Kopfschütteln schon.
Da hat es jetzt so eine Marke hängen geblieben und
genau das wollten wir nicht haben
So, nächste Möglichkeit, wir packen das wieder hin.
Wir schalten jetzt mal oben rum, weil wir wussten ja unten,
wenn wir unten jetzt den Brief kriegen,
dann machen wir es mal so rum.
Leider kommt kein Brief und in einer gewissen Zeit mit oben rumgeschaltet
und wir sind wieder bei dem Teil dabei und haben wieder so
eine Marke da drin, die wir nicht haben wollten.
Nächster Fall. Wir teilen das Ding auf und sagen,
na gut, okay, dann schalten wir deswegen gleich mit der Uhrzeit durch,
weil kam keine, dann kann trotzdem das noch sein,
dass wir da oben auch den Timeout haben,
weil da auch kein Brief ankommt.
Es kommt eben gar kein Brief an,
schlechte Zuordnung der Briefe
Und entsprechend haben wir da auch wieder eine falsche Marke übrig,
weil wir jetzt hier die Marke wieder eine Liegen haben.
Je nachdem, welche jetzt die falsche sein soll hier. Gut,
die entsprechende Abarbeitung, die man dann ansonsten haben möchte,
ist halt, dass sozusagen von oben der Brief ankommt und unten.
Oder ja, das mit den Timeouts hat nicht funktioniert mit
den Modellieren
So, da muss man also hingehen und sich genau überlegen,
was möchten die Leute dort eigentlich darstellen?
Was soll das? Und das hängt jetzt rein von dem
Anwendungsbereich ab. Dass wir jetzt hier dieses Beispiel haben,
ist einfach ein kaputtes Beispiel, weil ich habe da extra die Fehler eingebaut.
Also jetzt jemand kommt ja jetzt aber komisch,
weil das würde man doch nicht so machen.
All diese Modelle sind mehrfach selber so implementiert und gemacht worden.
Glaubt mir. Das ist einfach so, ja.
So, aus welchen Gründen noch immer.
Ob wenn du gerade eine entsprechende Uhr oder einen Brief,
also eine Nachricht oder eine Benutzungseingabe drin stand,
das ist eigentlich relativ egal.
Solche Sachen kommen halt vor. So. Und jetzt kann man
sich natürlich überlegen, wie man es denn gerne hätte
Gut, und jetzt kommen wir zu einem zentralen Abschnitt in
diesem Bereich Workflow, dass sie nicht hingehen und sagen,
was ist eigentlich ein korrektes Workflow-Netz?
Was finde ich schön? Ja. So,
und so ein Workflow-Netz heißt eben entsprechend korrekt,
falls aus jeder erreichbaren Markierung eine ordnungsgemäße Termination möglich ist.
Das ist meine erste Forderung, die ich habe.
Also egal, wo ich hinkomme, bin ich ordnungsgemäß terminieren.
Was heißt das? Das heißt,
für alle Markierungen aus dem Erreichbarkeitsgrafen,
den ich jetzt sozusagen da habe,
meine erreichbaren Markierungen von meinem Netz,
existiert immer so
ein Wort
Kann auch leer sein, die Folge,
sodass ich von diesem M, was ich mir jetzt gerade ausgesucht habe,
nicht für alle, die ich mit ausgesucht habe,
kann ich mir so ein entsprechendes Wort weh suchen,
sodass ich zu meinem ME komme.
Was heißt das auf gut Deutsch? Egal wo ich hinkomme,
kann ich so schalten, dass ich zu meiner Endmarkierung komme
und zu keiner weiteren, die irgendwo liegen bleibt.
Reicht das nicht schon
Ja, und nicht lange scheiden kann man auch noch.
Ja. Ja, wir gucken jetzt einfach mal die nächsten
Sachen an, bevor wir das jetzt hier weiter diskutieren.
Genau eine Marke in dem Endplatz E ist die einzige Möglichkeit zu terminieren.
Damit liege ich da sozusagen fest und sage,
es darf nur genau die eine Markierung sein.
Wo ich gesagt habe, ich komme irgendwie,
dass das ME markiert ist,
Ja, genau. Das ist jetzt sozusagen so ein Teil,
dass man sagt, dass man ME markiert.
Das ist relativ ähnlich an der Stelle, ja. So,
das heißt aber jetzt an dieser Stelle hier,
dass ich für alle Markierungen, die ich da habe,
dafür sagen kann, dass dieses ME,
Grüße gleich 1 ist,
sodass man das M gleich dem ME sozusagen finden kann
So, jede Transition kann in der möglichen Schaltfolge schalten,
denn sonst wäre sie nutzlos. Was heißt das? Ich habe
zwar da irgendwie so ein Ding auf dem Pfad liegen,
aber irgendwie sind da immer zwei Stellen im Vorbereich und ich kann sie gar nicht aktivieren,
weil ich nur immer eine Marke da jeweils draufpacken könnte vielleicht oder sowas.
Wie stelle ich das da, dass für alle Transitionen,
also egal was für Aktivitäten ich im System habe,
existiert eine Markierung, mindestens eine Markierung,
für die ich das Ding aktivieren kann.
Ja, normal. Nein, es gibt genau ein MA.
Genau. Das ist also jetzt sozusagen die Idee,
dass sich die Aktivitäten, die ich da habe,
in irgendeiner Weise wieder ansprechen kann und dafür sorgen kann,
dass sie auch wirklich schalten kann.
Wenn das der Fall ist, habe ich eine Nachfolgemarkierung und
von der aus muss ich wieder zu meiner Endmarkierung kommen.
Das ist sozusagen das, was dahinter steht. So,
jetzt wird es spannend an der Stelle,
dass wir jetzt, jetzt haben wir erst mal definiert,
was so ein korrektes Workful Netz ist.
Und das Interessante ist jetzt, wenn wir so ein N
quer haben, Und das ist lebendige beschränkt.
Dann können wir daraus folgen, dass das Netz korrekt ist.
Und wenn es jetzt korrekt ist, wissen wir,
dass das N quer lebendig und beschränkt ist.
Das geht in beide Richtungen. So, das können wir
uns mal genauer dann angucken. Das heißt,
es gibt also bei denen beschränkt,
habe ich jetzt nicht nochmal wieder rausgeholt an der Stelle,
es gibt also eine obere Schranke für die Markenzahl.
Das heißt, es gibt sozusagen ein Limit,
egal wo ich hinkomme, ich packe da nie beliebig viele Dinge drauf.
Und lebendig heißt, jede Transition behält die Eigenschaft potenziell zu
Das heißt also, ich kann da immer wieder hinkommen.
Wie soll es jetzt bei meinem Workvernetzen funktionieren,
wenn ich so ein A habe und ich komme bis zum E und jetzt
habe ich so ein Quer und das soll jetzt lebendig und beschränkt sein,
was heißt das jetzt?
Eigentlich ist das Netz doch tot irgendwie,
wenn ich bei E angekommen bin, ist Schluss, ne?
Was fehlt jetzt hier gerade noch? Ja. Genau,
man muss also irgendwie von dem ME zu dem MA
wieder zurückkommen und muss sozusagen jetzt einen Strich angucken,
weswegen wir oben ja auch N und das Endstrich
jetzt nochmal unterscheiden
Wo ein Strich eben der entsprechende Abschluss ist.
Was wir ja erst mal haben, ist,
dass wir jetzt für diese beiden Eigenschaften, die wir dort haben,
bestimmte Algorithmen vorfinden, sonst wäre es angeben können,
ob das denn auch stimmt, was da entsprechend steht.
So, das Workflitz ist also genau dann korrekt,
wenn sein Abschluss eng quer lebendig und beschränkt ist.
Naja gut, da gucken wir uns mal oben an.
Wir haben irgendwie so ein Workflow-Netz,
dann haben wir so eine Blackbox-Geschichte und dann mit A und E
und was dazwischen liegt, interessiert uns erst mal gar nicht.
Wir wissen das aber alles, was wir da haben
auf dem Pferd dazwischen liegt.
Dann packen wir so eine Transition T-Stern da rein,
die wir jetzt entsprechend verbinden und sagen,
das ist unser Abschlussnetz
Was passiert jetzt? Naja, ich habe jetzt also meine Anfangsmarkierung,
kann ich durchlaufen bis zum E, dann spreche ich mir
nach vorne, kann ich den nächsten Fall durchspielen.
Was hat man damit? Naja, alle Möglichkeiten,
die im System überhaupt machbar sind, sind damit abgedeckt.
An der Stelle. Das ist mir das auch in der
strukturierten Analyse sozusagen mit benutzt wird,
was ich bei meinen Szenariennetzen und sowas benutzt habe.
Das sind Sachen, die immer wieder genommen werden,
wenn man ein System sozusagen auf sinnvolle Wiederholbarkeit einstellen möchte
So, es tanzt sich um die Eigenschaften beschränkt und lebendig,
die eben auf irgendwelchen anderen Seiten,
die Seiten stehen jetzt hier, glaube ich, nicht ganz,
definiert werden und wozu eben die entsprechenden Entscheidungsalgorithmen da sind.
So, und wenn wir uns jetzt oben das angucken,
haben wir da unser problematisches Workflow-Netz mit Beschwerdebearbeitung und können jetzt halt schauen,
welche Eigenschaft wird denn jetzt verletzt,
das guckt man sich in den entsprechenden Werkzeugen
an und bekommt das
entsprechend angezeigt
Was wir zum Beispiel gemacht haben, ist,
dass wir in Reniu entsprechende Plugins eingebaut haben,
auch im Rahmen von dem entsprechenden Herold-Projekt.
Und können jetzt sozusagen eine entsprechende Analyse anwerfen. Und die
entsprechenden Aussagen für einzelne Stellen bekommen, ob sie beschränkt sind oder nicht.
Und die werden entsprechend Brot oder Grün angezeigt,
wenn das Ganze jetzt grün ist, habe ich sozusagen die entsprechende Beschränkte da drin.
Wenn die Sachen unbeschränkt sind, an irgendeiner Stelle oder sowas,
oder wenn sie tot sind, wird das entsprechend jeweils angezeigt.
Man kann sich die einzelnen Eigenschaften auch entsprechend auswählen,
welche man sich anzeigen lassen möchte,
was dazu benutzt wird, ist das Werkzeug aus Rostock,
das Lola-Werkzeug, das packen wir in den Hintergrund,
das wird sozusagen damit beschickt,
liefert die Ergebnisse zurück,
die werden umgesetzt und werden dann in der grafischen Darstellung
wieder auf das Netz projiziert und zeigen die Ergebnisse dann auch
visuell an
Interessant ist das insofern, als dass man jetzt,
wenn ihr ein Netz entwickelt und euch Gedanken macht,
ist das denn jetzt alles schön und gut.
Könnt ihr selber für euch so ein System,
ja seinen Abschluss ja eigentlich bauen für eure Abarbeitung.
Ihr lasst das entsprechend durchlaufen und sagt,
ist das denn jetzt ein korrektes Workflow-Netz und könnt euch
das selber sozusagen bei euren Modellierungen entsprechend anschauen.
Das ermöglicht dann sozusagen schon bei der Entwicklung
die Überprüfung von solchen Netzen
So, die entsprechenden Abarbeitungen,
wenn man das jetzt hier halt ausprobiert mit den entsprechenden Netzen,
ist halt jetzt genau das,
dass man zu diesen Sachen kommt und dann feststellt,
naja, die entsprechende falsche Marke liegt halt da.
Jetzt kann ich mit dem E wieder zurücklaufen, kann es nochmal,
was ist die Schlussfolgerung, warum ist das jetzt eine falsche Marke?
Welche Eigenschaft wird jetzt hier verletzt? Viel Beschränktheit, ne?
Genau. Das ist jetzt genau das, was man offensichtlich sieht.
Gerade wenn irgendwas liegen bleibt und wir können jetzt beliebig oft durchlaufen,
wissen wir, wir können das beliebig hochpumpen,
weil es sozusagen keine Möglichkeit gibt,
dass dann irgendwie diesen speziellen Durchlauf dann entsprechend zu verhindern.
So, und es geht ja um die möglichen Fehlverhalten.
Es geht ja nicht um die Sachen, die wahrscheinlich eintreten werden oder sowas.
So, es geht nur darum, welche prinzipiellen Möglichkeiten im System sind.
Wenn wir Systeme bauen wollen, dann soll es prinzipiell nicht möglich sein,
dass ein Atomkraftwerk irgendwann einmal irgendwelche Brennstäbe nicht mehr gesichert werden können, ja.
Man möchte das immer in das Ding so reinführen,
dass am Ende sozusagen keine Energie mehr rauskommt.
Oder denkt euch was anderes aus, ja.
Wenn ihr in eine Bremse tretet in eurem Auto,
dann soll die immer funktionieren und nicht Irgendwann mal nicht mehr.
Das ist etwas unglücklich an den Stellen. Und diese Rückrufaktion,
wenn ich das angucke, was jetzt immer wieder bei den Autoherstellern passiert,
wo sie hunderttausende Autos zurückrufen müssen,
wo sie entsprechende Geräte austauschen müssen, abgesehen vom Imageschaden,
der damit entsteht, sind das riesige Kosten,
die damit entstehen.
Und aus dem Grunde wird eben auch jetzt in allen möglichen Bereichen,
insbesondere im Moment aktiv in der Automobilbranche massiv daran geforscht,
wie man mit formalen Methoden diese ganzen möglichen Zustände,
die man da hat,
untersuchen kann und angucken kann
Dadurch, dass man den Rechner inzwischen als ein verteiltes,
nebenläufiges System angucken muss mit teilweise hunderten von Rechnern da drin inzwischen,
also die Luxusvarianten haben dort sehr viele Verschiedene Schaltkreise und Recheneinheiten.
Ist die Frage, wie man sie überhaupt miteinander kommunizieren lässt,
wie auf dem Bus vernünftig gearbeitet wird,
weil wenn dummerweise durch euren CD-Player, der gerade irgendwie versucht,
irgendein Lied zu finden und auf dem Bus irgendwas kommuniziert mit
den Lautsprechern und euer AWS-System reagiert deswegen mal eine Sekunde später,
weil das hängt halt gerade an der CD,
die nicht ordentlich lesbar ist,
dann wäre es relativ unglücklich,
wenn ihr
solche Sachen da habt
Das Gleiche geht zum Beispiel im Sicherheitsbereich, wenn ihr Flugsicherungssachen anschaut,
nach Möglichkeit wollt ihr hundertprozentig getrennte Kreise für die Anzeige von Informationen,
über den Flugzeugzustand sozusagen, dann haben wir, ihr wisst,
wir sind in dieser Höhe und dies und das und jenes.
Gleichzeitig sollen da aktuelle Filme eingespielt werden. Die werden zu Beginn
des Starts vom irgendeinem Menschen ja eingespielt in das System.
Und man muss aber trotzdem auf die Daten von dem Flugschreiber
irgendwie oder von den Fluggeräten sozusagen zugreifen. Das heißt,
diese Trennung zwischen den Geräten,
die gerade messen und irgendwas beeinflussen und dem,
was von außen mit dem Internet verbunden worden ist,
um das Teil hochzuladen, nämlich die Filme,
die dann in diesem Flugzeug gezeigt werden sollen, ist nicht mehr gegeben.
Die spannende Frage ist, wie sozusagen für den Bereich,
der sich halt sichergestellt werden kann, dass es keine Interferenz zwischen diesen beiden Programmsystemen gibt.
Und es ist inzwischen so,
dass diese Bereiche halt nicht mehr hundertprozentig getrennt sind an allen Stellen,
weil ganz wichtigen Sachen wird es klar getrennt,
da gibt es aber auch kein Informationssystem auf dem Display,
in dem den aktuellen Zustand des Flugzeugs sehen kann.
Das sind so Fragen, mit denen man sich jetzt beschäftigt,
weil es uns relativ teuer ist,
diese entsprechenden Leitungen mehrfach durch das Flugzeug
zu legen
Wenn man die verschiedenen Systeme ja getrennt hat,
wenn man sie physikalisch trennen will, muss man physikalisch Leitung legen,
dass ein Flugzeug ein Problem ist,
wenn man dazu viel in die Luft fliegen möchte.
Okay, so, das heißt, diese Workflow-Netze haben eine
relativ weite Verbreitung für alle möglichen Arten von Prozessbeschreibungen, die ihr irgendwo vorfindet.
Es dreht sich also nicht nur um Business-Systeme,
sondern es dreht sich auch um technische Systeme und um ganz normale Programmsysteme.
Eine andere Sache ist, wenn euch klar werden wollt,
wie ihr eure Softwareentwicklungsprozesse ablaufen sollen, ist das genau das Gleiche.
Da müsst ihr auch irgendwelche Aktivitäten von irgendwelchen Leuten.
Ihr seid in irgendeinem Open-Source-Projekt, was weltweit verteilt ist.
Da müsst ihr halt hingehen und schauen, wie ihr eure Prozesse,
die ihr uns abstimmt und wann irgendeiner anfängt,
jetzt irgendwie das Release doch auszugeben,
weil wenn der halt nicht kommt,
dann möchte man gerne so eine Timeout-Funktion haben.
Möchte nicht deswegen mit einmal mit zwei Releases rauskommen,
nur weil der eine anders kompiliert als der andere und dann zwei verschiedene Versionen haben.
Das heißt, auch für verteilte Softwareentwicklung sind diese Workflow-Prozesse inzwischen relativ spannend.
Es ging jetzt also gar nicht mehr darum,
dass man nur so hart verdrahtete Workflow-Prozesse angucken möchte,
sondern ich möchte mein System in Zukunft auch flexible Workflow-Systeme eigentlich haben.
Das heißt, ich möchte im Entwicklerteam sagen können, wir wollen jetzt dieses Untermodul aufbauen.
Wenn ihr in einem großen Konzern seid, sind normalerweise diese Prozesse,
wie ihr mögliche Arbeitsabläufe gestalten dürft, fest vorgegeben.
Es wird also bestimmte Schemata geben. Hier muss genehmigt werden,
hier muss beantragt werden, dann wird es hier genehmigt.
Dann gibt es irgendeinen Ausführungsprozess, wo hinterher nochmal getestet wird,
bevor es ins Produktivsystem gehen kann,
wo es auf diesem System noch getestet werden und so weiter.
Es gibt also verschiedene Durchläufe, die dafür erstellt werden.
Dann ist also das noch nicht klar,
wenn ihr mit jemand anders absprecht,
wir wollen jetzt das und das entwickeln,
ist noch nicht klar,
welche wirklichen Aktivitäten stattfinden müssen und so weiter und so fort,
sondern die sind flexibel und werden dazugepackt,
sind aber nach einem Schema
sozusagen da drin
Bei neueren Systemen war agilen Systemen,
wo ja völlig frei sowas gestalten könnt,
müsst ihr jetzt hingehen und sagen, okay,
wir machen das jetzt mal so, ihr und ihr und du da vorne,
ihr setzt euch mit hin und ihr übernehmt diese Aufgaben,
wir übernehmen diese Aufgaben und das entscheiden wir jetzt mal so und starten das mal.
So, wenn ich so ein Beschreibungsmittel in der Hand habe,
möchte ich eben wissen,
ob hinterher genau ein Release rauskommt oder ob da zwei rauskommen oder ob noch irgendwo was liegen bleibt,
weil irgendeiner noch irgendwelche Aktivitäten noch irgendwo laufen hat oder sowas ähnliches,
das möchte ich mir gerne sehen und genau dafür braucht man für solche Abläufe,
die man vereinbart hat, kurz einen Check,
ob das in Ordnung war.
Das ist das, woran wir gerade sitzen und wo
bei uns halt verschiedene Leute zu auch promovieren,
zu solchen Themen
Gut, also die große Frage ist jetzt,
welche Eigenschaften hat das und so weiter und so fort.
Das könnt ihr in den entsprechenden Vertiefungsveranstaltungen bei uns noch nicht angucken.
Wir werden nächstes Semester wieder das Modul für Modellierung verteilter Systeme,
wo es eben genau um solche Fragestellungen geht und wo wir
das dann noch ein bisschen vertiefen und gucken,
wie wir das dann wirklich konkret verwenden können,
sowohl als auch dem noch vertieften theoretischen Background natürlich.
Gut. Ups
Jetzt habe ich die falschen Sachen hier. Bin ich zurückgesprungen,
dann habe ich aus Versehen die Folien kopiert, habe ich das Gefühl.
Sehr schön. Sekunde? So. Fängst du mich mit einem
neuen Thema los? Was wir jetzt sonst noch mal
anschauen wollen,
sind entsprechende KKN
Durch AKW oder irgendwie sowas ähnliches, sondern kannten konstante Netze.
Und da wollen wir noch mal schauen, wie wir jetzt
sozusagen die Sprache der Benetze noch mal wieder verändern können.
Wir hatten jetzt ja gerade gesagt,
bei den Workflow haben wir diese einzelnen Konstrukte so eingeführt.
Und dafür musste ich aber quasi eine Semantik dahinterlegen,
die ich auch mit Netzen darstellen kann, die aber irgendwo anders beschrieben ist.
Aber ich habe damit einmal ein ganz anderes Konstrukt liegen.
Die Beschreibung, jetzt an dieser Stelle sind,
dass wir jetzt hier Netze haben, die Nur wieder mit Netzelementen,
die wir auch in der Originaldefinition vorfinden, zu sehen haben.
Das heißt, wir müssen uns hinter den einzelnen Sachen wieder noch weitere Pepri-Netz-Dinge direkt wieder vorstellen,
sondern wir können das direkt mit der Definition,
die wir dann auch verwenden, direkt wieder entsprechend einsetzen.
So, dieses Netz sollte euch irgendwie bekannt vorkommen. Das war nämlich dieses Stellentransitionsnetz,
wo wir unseren Starter, hatten sie,
unsere Rennbedingungen hatten mit dem Starter und so weiter,
zwei unabhängige Geschichten mit dem Starter in der Mitte steht,
der, sobald er die Ready-Signale bekommen hat,
sein Fähnchen schwenkt und so weiter.
So, diesen Ablauf werden wir gleich noch ein paar Mal uns angucken.
Das heißt, wenn ihr euch zum Nächsten Mal,
dann auch nochmal diese Sachen anschaut.
Auch die Stellentransitionssachen. Und die Netze, Fitness,
die wir ganz am Anfang hatten, wiederholt.
Das wäre sehr hilfreich, weil ich beim nächsten Mal
dann mit den Gefärbtennetzen das Gleiche nochmal spielen werde.
Was man nicht machen kann, ist, man kann jetzt ja hier falten.
Man kann die Sachen zusammenlegen, hat mir so festgestellt,
okay, unten die Struktur ist genauso wie die da drüber.
Legen wir doch mal zusammen. So,
der Nachteil ist jetzt aber, eigentlich weiß ich gar nicht mehr,
welcher von diesen beiden schwarzen Punkten jetzt der eine,
der andere Wagen war.
Während ich oben, also noch bestimmte Informationen hatte,
fehlen sie mir im unteren Netz
Würde mich aber nicht, weil für so ein Rennen ist es eigentlich,
wenn ich eine neutrale Geschichte haben möchte für so einen Startbedingungen,
dann will ich sowas gar nicht mehr unterscheiden.
Das heißt, ich will da gar nicht mehr genau wissen,
ich brauche nur eine Anzahl von Ready Signal, nämlich alle,
die gestartet sind, müssen alle sagen, ist okay,
dann sagt der Starter go und dann fahren sie alle mal.
So, das ist eine Sache,
die bei diesen Netz hier unten jetzt auch entsprechend dargestellt wird,
ist also überhaupt kein Problem.
Wir haben also hier die Idee von Mehrfachmarkierung und entsprechenden Kantengewichten
So, damit haben wir unsere PT-Netze und die haben halt einen gewissen Informationsverlust,
weil wir halt die beiden Marken da so raufschmeißen,
wir wissen nicht mehr genau, welcher,
welcher jetzt eigentlich genau ist.
So, auf Seite 187 findet ihr dann nachher nochmal die anderen Sachen,
das ist jetzt sozusagen ein Vorgriff, ist nur zur Einordnung,
dass wir jetzt eine Netzweitung zu Kantenkonstanten beziehungsweise zu Gefährtennetzen haben.
Wir beschäftigen uns heute nur mit dem roten Teil,
der andere Teil bleibt weg, eigentlich gehört das nur eine Zeile,
ein Stückchen höher.
Was passiert da? Wir wollen jetzt also hingehen und
Dinge zusammenlegen
Nämlich unter Stellen werden wir einfach nur noch diese Stellen draus.
Sieht genauso aus wie das Netz eben vorher. Nur möchte ich
jetzt die Informationen, um welchen Wagen es sich handelt,
nämlich A oder B. Nämlich oben oder unten.
Das möchte ich gerne einen Tick anders haben. Das heißt,
oben diese quasi gedachten PT-Netze,
die ich also durch die gekringelten Sachen dargestellt habe,
werden jetzt ohne Informationsverlust auf die kanntenkonstanten Netze abgebildet.
Was ist der Vorteil, was ist der Nachteil?
Der Futter ist, ich weiß ein bisschen mehr,
was ist der Nachteil? Naja, offensichtlich muss ich jetzt anfangen,
irgendwelche Buchstaben da rein zu pinseln und irgendwie muss ich da
noch mal ein bisschen mehr Dinge tun.
Das wird mir immer komplizierter. So, ja, Ausdruck stärker,
also meine Technik mache, je mehr ich machen kann,
desto höher ist der Preis für die Ausführungs-Engine.
Was ist jetzt für, was ist jetzt sozusagen die Ausführungs-Engine,
die für das Papier, was ihr vor euch liegen habt,
gilt,
dass euer Kopf
Einfaches Netz, könnt ihr relativ einfach sagen, ja,
da schaltet der und dann schaltet der und dann muss er zwei Token haben,
wenn Weidemarkt, beide Stellen markiert sind im Vorbereich der Transitione,
nimmt er die und packt alle Nachstellen was.
Das ist relativ simpel. Die Sachen,
die jetzt kommen, gehen halt hin,
dass ich in da irgendwelche gefärbten Netze habe,
die als Unterstützung einfach auch noch mal kurz ML oder Java oder sowas als Beschriftungssprache haben,
wodurch dann die entsprechenden Komplexitäten natürlich viel größer werden.
Das heißt, wenn ich das dann lesen will und verstehen will,
was da steht, muss ich die Programmiersprache im Kopf selber
haben und ich muss genau diese Mantik verwenden,
die auch dieser Compiler,
der es nachher ausführt,
auch haben wird
Es nützt also gar nichts,
wenn ihr NA nicht kennt und ihr liest ihn im L-Programm und da stehen irgendwelche Funktionen dran,
dann bist du doch lange nicht, wie das genau ausgeführt wird,
dieses Netz und was diese Funktion bedeutet oder wenn ihr irgendeine Funktionsbeschreibung
an so einer Transition her seht oder an irgendeiner Stelle in diesem Netz,
nützt euch das nichts.
Bin in irgendeiner einem Java-Programm, ein Aufruf einer Methode seht,
wo ihr nur den Methodennamen habt,
aber nicht die Erklärung dahinter, habt ihr ein Problem.
So, wenn ihr jetzt also diese Netze lest,
müsst ihr die Semantik im Kopf haben. Das heißt,
ihr müsst euch, damit ihr beim nächsten Mal versteht,
wenn ich über die gefärbten Netze rede,
müsst ihr euch vorher die Sachen angeguckt haben und durchgelesen haben,
damit ihr eine Chance habt,
diesen ganzen Salat,
der dann an der Wand hier erscheinen wird,
vernünftig aufnehmen zu können
Weil bestreben ist, euch zu erzählen, was es soll und wie man es liest.
Ihr müsst es dann aber selber in den Kopf kriegen,
weil bei euch muss dieses Modell im Kopf genau diese Ausführung bekommen,
die dann dahinter die entsprechende Semantik letztendlich hat.
So, was don't jetzt für ein Gebirgestil mit
X gleich A oder Y gleich RSA und so weiter,
das lassen wir erst mal außen vor,
was jetzt immer so ganz gut andeutet.
Da oben haben wir jetzt also ein Netz,
was wir in der zweiten Stufe haben,
wo wir A und B dran stehen haben,
kanntenkonstante heißt jetzt auch an die Kanten, schreiben wir halt entsprechende Konstanten.
Und das ist das, was jetzt noch einführen,
mehr nicht.
Keine Variablen im Moment
Das bedeutet, dass wir jetzt da irgendwelche Buchstaben ranschreiben und
mit denen noch ein bisschen rumhantieren. Wie das geht und
was das soll, da kommen wir jetzt nochmal zu.
Wir haben ja unsere Stelle 1 und 10 und haben da
unsere entsprechenden Autos A und B und die werden entsprechend mit A und B einfach hingezeichnet.
Können wir auch eine Stelle hinzeichnen, weil wir jetzt aufgrund dessen,
dass wir Konstanten da reinpacken, keine schwarzen Token,
können wir hingehen und sagen, okay,
auf dieser Stelle ist das Auto A oder B oder beide.
Ich kann sie genau unterscheiden, welches der Autos
ich jetzt gleich nehmen werde und dass das was tut.
Das wird entsprechend so abgebildet auf das entsprechende Netz,
was wir eben genauso zusammengefasst haben
So, und was wir dann sehen, ist,
dass wir A und B da oben schalten,
die Transitionen werden nicht zusammengefasst.
Weil für die Transition muss klar sein, wie sie aktiviert wird.
Und das wird eben durch genau eine entsprechende Konstante gemacht.
Und das wird sozusagen dann auch benutzt und verwendet an den Stellen.
So, da haben wir jetzt nur oben die As und Bs unterschieden.
Das ist jetzt nur eine Unterscheidung der entsprechenden Autos an der Stelle.
So, was habe ich da jetzt gemacht?
Ich gehe mal eins zurück. Ups, zu schnell nochmal
So, wir sind jetzt hier und haben aber für die
entsprechenden Stellen P4 und P8 keine Unterscheidung.
Also haben wir nicht zusammen gemalt, sondern haben wir auch schön separat hingepackt.
Na gut, wenn ich solche Stellen habe, sind Leuten das Gleiche,
die bedeuten irgendwie so ein Valley-Signal, ist sozusagen da angekommen.
Kann ich euch zusammenpacken? Ich muss nur die Signale wieder auseinanderschalten.
Und das ist das, was jetzt hier steht,
da haben wir halt entsprechend die Möglichkeit,
um das zusammenzupacken und müssen dann aber von der Stelle natürlich auch die beiden verschiedenen Signale abziehen.
Wir ziehen nicht einfach nur zwei Marken ab,
das wird nicht gemischt mit den PT-Netzen hier,
sondern wir müssen dann die entsprechenden Konstanten ranschreiben
Wenn wir jetzt sozusagen zwei verschiedene Konstanten abziehen wollen,
wie zum Beispiel hier oben das RSA und RSB aus der Stelle P4,
die Ready sagt,
dann schreiben wir das hin und machen Plus dazwischen.
So. Damit ist die Bedingung für T3,
dass wir so einen Staat da liegen haben,
also unser S,
dass wir RSA und RSB im Vorbereich auf der Stelle Ready liegen haben,
die durch die beiden Transitionen von oben T1 und T4 kommen
Und, dass wir dann haben,
dass Stadtsignal A und der Staatssignal B,
weil wir jetzt ja wieder an die beiden verschiedenen Autos,
genau dieses entsprechende Signal wieder zurückgeben möchten,
packen wir also ein SSA und SSB auf die Stelle P5
für den Start und unser Starter bleibt erhalten und liegt weiterhin auf P7.
Was wir da machen ist, wir haben lauter Farben.
Diese Farben werden eben genau entsprechend benannt und sind eben die Autos,
A und B, der Starter mit S,
das Ready mit RSA,
Ready Signal A und Ready Signal B,
ein schönes gemischtes Englisch und Deutsch und einem Staat
entsprechend mit SSA und SSB
da drin
So, und damit haben wir ein kantenkonstantes,
gefärbtes Netz, was wir da verwenden können.
Gut, die Nummern, 210, 310 sind leider falsch,
da ist es mir irgendwie die Verdeckung verrutscht.
Das sollte jetzt eigentlich irgendwas anderes stehen, neun irgendwas. So,
die Schaltregelphysikanten konstanten gefärbten Netze ist jetzt wieder so,
dass wir hingehen und AB oben liegen haben,
dann haben wir hier BBC liegen und wir können jetzt sagen,
wir wollen zweimal B zwei, Strich B oder zweimal B, abziehen.
Das ist unsere Eingangsbedingung und ein A plus B von der oberen Stelle.
Und hinten wollen wir zwei Bs jeweils rauspacken und die Markimlischen
sind in C und A meinetwegen. So,
wenn es als geschaltet hat,
ziehen wir entsprechend hier die A und B bei der oberen Stelle
ab und die entsprechenden beiden Bs, die wir da haben,
sind hier entsprechend weg und es tauchen hier wieder zwei Bs auf.
Was ist da jetzt das Problem,
wenn ich mit meinen normalen Mengen von Dingen
jetzt normalerweise rumhantiere
Warum kann ich hier nicht mal male Mengen Geschichten machen?
Genau. Wir haben jetzt also Multinengen hier vorliegen und
das ist eine hässliche Angelegenheit in Bezug auf das,
was man sonst so rechnet. Ist aber eben sehr schön,
weil ich eben jetzt auch 30 mal B da liegen haben
kann und 30 mal B abziehen kann.
Ich kann es sozusagen ein bisschen einfacher hinschreiben.
Ist also eine Sache, die man sich da nochmal
angucken kann
So, wenn wir jetzt die Makioma-PT-Netzen hatten,
hatten wir irgendwie so einen Vektor und konnten das auf verschiedene Weisen hinschreiben.
Wir hatten oben irgendwelche Zahlen und dann irgendein Vektor mit zwei und eins und so weiter.
Oder hatten hier das entsprechend für zweimal die Stelle P1 und
einmal die Stelle P6 sozusagen hingeschrieben. Und ja,
das findet man da entsprechend auf den jeweiligen Darstellungen wieder.
So, das wird jetzt ein bisschen aufwendiger mit den anderen Sachen kommen.
Kommen wir gleich nochmal hin. Oben haben wir halt die
entsprechende Abstimmung als Abbildung oder als Vektor oder eben entsprechend als Wort.
Matrix haben wir hier
gar nicht
So. Jetzt haben wir also solche komischen Mengen. Jetzt gibt
es einen kurzen Einschub für Multimengen-Lehre. Nicht mehr Mengenlehre,
aber Multimengen-Geschichte ist relativ intuitiv, was da passiert.
Wir haben unser AAA, BBB, BB und D.
Und jetzt in Klammern, und da habe ich schreiben ein
kleines B unten dran. B für? Back. Für
diesen Sack, in den wir alles reinschmeißen jetzt sozusagen.
Und da haben wir dann entsprechend halt,
das ist sozusagen nicht das Gleiche ist wegen der Mengengeschichte.
Weil wenn ich jetzt AAA mit einer Menge hinschreibe,
dann ist das eigentlich nur ABD.
Und nicht mehrfach diese Sachen. Also genau das, was
man sich darunter auch vorstellt. So. Hinschreiben kann ich das
jetzt als dreimal A und zweimal B und null mal C und einmal
D. Kann ich jetzt also sozusagen auch so schön wieder aufschreiben und entsprechend hinpinseln.
Dass dann die entsprechende Darstellung auch ohne die Null da mal reinzuschreiben.
Ich schreibe auch nichts über E und F und Z und P und Q
und so weiter. So, das heißt,
ich bilde also irgendwie diese Menge A auf L-Up und habe
die entsprechende So ein Formel darüber.
So, was können wir jetzt damit machen? Wir können zwei Wänken addieren,
wir können kleiner oder größer oder größer gleich kleiner gleich haben.
Wir haben eine Differenz und wir haben eine entsprechende Anzahl da drin.
So, was machen wir, wenn wir das addieren?
Naja, ein Apfel und noch ein Apfel sind zwei Äpfel.
Das ist eine relativ einfache Angelegenheit, die man dabei machen
muss und die man dabei dann entsprechend einträgt. So,
und was wir so haben, ist also irgendwie eine Menge Vereinigung,
wo wir dann einfach die entsprechenden mal wegen drei As und noch was irgendwas zusammenpacken.
Das ist für die beiden Mengen da oben uns angucken,
haben wir die Berg 1 und Berg 2.
Und haben wir eben A, B, C drin und 3As,
2Bs und AMD. Und wenn man das jetzt hinschreibt,
kommt entsprechend 4As raus, 3Bs, 1C, 1D,
die wir dann da liegen haben.
Also genau das, was man so auch erwartet, ne?
Halt 4 Apfel, viel Behörden, eine Tomate,
eine Melone. So, das ist irgendwie,
ob die eine der Emmy dann enthalten ist,
ist die Frage,
ob die kleine Menge in der Großmenge
denn drin steckt
Naja, das Ziel ist halt nicht dabei. Und entsprechend gilt
diese kleine Beziehung einfach nicht. Da habe ich eine Differenz,
dann ziehe ich das einfach ab. Dann ist die andere Geschichte,
was man dann machen kann, dass wir natürlich nur abziehen kann,
wenn es wirklich kleiner ist, sonst zieht man irgendwie das,
uns einmal Minus-C oder Schulden oder sowas,
was man nicht so gerne haben möchte.
Kann man ja jetzt auch so abziehen an den Stellen.
So, und dann die Mengen Kardinalität,
ist die Mächtigkeit die Kardinalität von BG, nur definiert,
falls die Summe entsprechend endlich ist.
Und wir haben halt die leere Mutiminge,
wo eben nichts drin ist mit Null angegeben
So, und ja, die Kanalität ist da entsprechend sechs. So,
was jetzt machen ist, jetzt nehmen wir uns einen Tupel
und packen da halt unter mal eine letzte Definition drauf, PTF,
an den Stellen, sagen, es ist ein endliches Netz.
C ist eine Menge von Farbmengen. CD ist eben die Farbzu-Farbzuweisungsabbildung,
wo wir die stellen,
also mit den entsprechenden Farben versehen und wird eben durch
dieses FFC beschrieben
Die Idee, wie wir ja hatten bei unseren letzten,
war jetzt, dass wir die entsprechenden As und Bs da drüben stehen haben,
hier definieren wir unsere Farben und für jede der Stellen wirkt jetzt irgendwas hingeschrieben.
Und was wir natürlich machen, ist, wenn wir da Autos stehen haben,
wollen wir da keinen Starter mit drin haben oder sowas, ja?
Das heißt, wir können jetzt hingehen und unsere einzelnen Bereiche
in den Netzen sinnvollerweise mit Dingen versehen,
die in irgendeiner Weise Ja, die Sachen sinnvoll gruppieren.
Nämlich genauso, wie wir sie ja auch angeordnet haben,
dass wir ausgehen, dass oben die Autos längs fahren,
unten bleibt der Staat da und dazwischen sind die Nachrichten,
die zwischen ihnen hin und her gehen.
Die Art der Nachrichten wirkt jetzt nicht unterschieden, wir hätten
auch nur Nachricht hinschreiben können und dann die Menge zusammenlegen können.
Hätte man auch machen können. Das kann man sich dann nochmal überlegen,
was dort sozusagen eine sinnvolle Modellierung ist an der Stelle.
Jede Trotz wird es einfach so mit den entsprechenden Dingen von oben abgebildet. So,
das sind also die entsprechenden Farbmengen mit Typ und Farbe,
die wir da drin haben, was wir noch haben,
ist natürlich unsere entsprechende Kantengewichtung,
wo wir jetzt eben einfach eine Multimenge von Dingen ranschreiben,
was wir ja ganz gut hier unten sehen können,
dass wir halt unsere SSA und SSB bzw. RSA und RSB damit ranpacken,
packen wir so irgendwelche Multimengen ran.
So, die Anfangsmarkierung ist ähnlich, dass wir sagen,
wir bewegen jetzt irgendeine Markierung für diese Dinge und packen die
entsprechend darauf
So, das Ganze kann man jetzt als Abbildung oder als Vektor machen,
deswegen hat es eben nochmal gezeigt. Das heißt,
wir gehen jetzt hin und haben so eine Abbildung,
die eben genau diese Stellenzuweisungssache mit beinhaltet, als entsprechender Vektor,
sodass du da entsprechende Mengen in diese oder Multimengen entsprechend auf
diese einzelnen Stellen legen und das entsprechend auch als Schaltung sozusagen sehen können.
Das T4 schaltet T1,
Schalt T3 und so weiter und können es entsprechend angucken.
Das ist das, was wir normalerweise unten als
möglichen Erreichbarkeitsgrafen haben
So, die Markierung von so einem kantenkonstanten Netz ist dann
eben entsprechender Vektor und wir können den jetzt entsprechend darstellen. So,
die entsprechende Tradition aktiviert, naja, genau das,
wie es eben auch schon erläutert habe, ist natürlich,
wenn wir im Vorbereich die entsprechenden Marken drin haben,
was ich jetzt genauso ausdrückt wie in unseren letzten vorher,
sieht also sehr ähnlich aus.
Man muss nur wissen, in welchem Kontext man sich jetzt gerade bewegt,
dass wir so entsprechend jetzt hier die für alle Stellen,
dass die Vorbereich von Tee entsprechend viele Marken liegen haben müssen,
sodass die Transitionen eben entsprechend auch dann aktiviert ist.
Wird genauso geschrieben mit dem MFIT
So, die Idee ist jetzt, dass wir so ein,
was du überhaupt jetzt einen, ja gut, diese Kantengewichtung,
Funktionen muss man jetzt hier mal genauer angucken.
Wir bringen jetzt ein wenig Schlange dort einführen,
was einfach die Null in irgendeiner Weise, beziehungsweise da keine Kante ist,
sozusagen noch mit drin hat und mit dem Weg
Schlange wird immer gearbeitet und die werden beide entsprechend,
wie Schlange, TP und PT werden entsprechend definiert,
indem man halt genau diese normale Kantenfunktion wiederverwendet und dann hat es eine Null einsetzt,
beziehungsweise die leere Menge, statt der Null.
So, ist das T, also ein M aktiviert,
dann ist die Nachfolgemarkierung definiert als und jetzt haben wir wieder unsere entsprechende M-File am Strich.
Das entsprechende Schalten mit da drin und wir können es eben
hinschreiben, genau wie wir es vorher hatten.
Wir müssen jetzt halt nur darauf achten,
dass wir entsprechende Multiming-Operationen haben,
dass wir also wie Schlange PT und wie lange TP
dort benutzen,
um das
entsprechend wieder auszudrücken
Gut, und dann kommt noch dazu, dass D,
man ist jetzt entsprechend definiert, man kann jetzt wieder Sachen zusammenfassen,
das heißt, sie sagt, okay, alle stellen,
das ist halt der gesamte Vector,
den wir dann halt wieder nehmen und einmal über alles rübergeht an der Stelle.
Und die Nachfolgemarkierung sieht dann halt genauso aus, wie wir es dahin geschrieben haben.
Also genauso wie vorher, nur für das andere Netz, für das Kantenkonstante-Netz jetzt entsprechend definiert. So,
und damit sind dann die,
dabei sind dann die entsprechenden Multiming-Operatoren komponentenweise auf Vektoren zu erweitern,
ist natürlich klar, dass man sich jetzt angucken muss,
wie man das rüberzieht und das heißt,
das muss man sich ein bisschen in den Tabellen angucken,
was man da genau macht, die entsprechenden eins,
zwei,
drei Sachen hatten wir vorher bei den normalen Netzen so drin und konnten das halt entsprechend uns so angucken.
Das ist sozusagen jetzt die Wiederholung von dem, was natürlich
schon da war, wie man entsprechend schaltet für die PT-Netze.
Und wenn man das Ganze jetzt sozusagen anguckt,
für die Kartenkonstantennetze sieht es ein bisschen anders aus.
An der Stelle schicke ich 2 und 1 und so weiter da drin.
Sondern jetzt muss man aufpassen, dass man halt diese RSA
und RSB und so weiter da reinschreibt und damit die Sachen darstellt.
Wenn ihr euch die Seiten anschaut und vergleicht,
werdet ihr sehen, dass das wirklich genau das Gleiche ist,
was ihr vorher schon verstanden habt.
Nur jetzt nicht mehr undifferenziert für 1 und 2,
sondern halt genau angegeben für die entsprechenden Konstanten,
die dann da drin vorkommen an den Stellen
So, und das sieht man in einzelnen Bereichen, könnt ihr euch nochmal angucken.
Ich werde die vorhin ja auch nochmal wieder ins Netz stellen,
so wie sie jetzt hier sind,
dass ihr die dann auch nochmal nachvollziehen könnt.
So, die entsprechenden Kantenkonstante Peternetze und so weiter,
können wir jetzt wieder auf die Stellen Transitionsnetze zurückbilden,
von der Fehltoken alle noch kollabieren lässt und einfach noch Token reinpackt.
So, über die Art und Weise,
wie man das dann so ein bisschen sehen kann und warum
das jetzt ein Unterschied ist,
ob ich da sieben Boken raufmale oder eine Sieben hinschreibe,
das werden wir
beim nächsten Mal sehen
Wenn wir das noch zu Ende führen,
da fehlen noch drei Folien und dann ist das genau der Übergang,
den ich mir vorgestellt habe für die Gefärbtennetze, wo es dann weitergeht.
Was mir lieb wäre, ist,
wenn ihr euch die entsprechenden Definitionen vor euch einmal anguckt,
weil das ein relativ großer Buchstabensalat ist,
der dann hier an der Leinwand erscheint,
damit ich euch das sozusagen anschaulich erklären kann,
möchte ich ganz gerne dann über die Sachen ein bisschen hinweggehen,
sodass ihr den einfachen Zugang über das Verständnis kriegt und
das Nachlesen macht ihr halt zu Hause im stillen Kämmerlein.
Gut,
dann bis Donnerstag