Je nachdem, was man so als Ressourcenzuteilung und sozusagen betrachtet,
um so etwas dann zu bekommen, an weiteren Ressourcen.
Die Idee war, dass man Kredite hat, also nicht verdrängende Betriebssysteme,
die also entsprechend Prozesse bedienen in endlicher Zeit, müssen die aber dann auch ihre Sachen abschließen.
Und man möchte halt vermeiden, dass da Zuteilung des Verklemmungen kommt. Das war die Hauptidee. Hatten wir dann ein Beispiel der beiden einfachen Dinge hier gemacht und mit 8 und 6,
wobei man dann recht einfach sehen konnte,
dass man so Innenvarianten hat, jeweils,
dass immer acht da drüber oder sechs darüber enthalten sind,
sodass man also diese Dinge, die wir schon vorher hatten,
gut wiederfinden kann an den Stellen,
das Ganze als Herreiperkeitsgrad beziehungsweise als Darstellung von dem,
was wir jetzt hier erreichen können,
wobei das jetzt hier die entsprechend unsicheren Markierungen sind,
die wir da drin finden und das Ganze einmal durchgespielt,
dass wenn ich da jetzt schalte,
dass ich da entsprechend dann auch weiter rutsche in den entsprechenden Grafen,
sodass ich da, wenn ich immer weitergehen würde,
ich das bis zum Ende durchspielen könnte, hier dann das Problem,
dass ich entsprechend hier diese zwei sozusagen da noch habe,
aber das nicht mehr alles erst befriedigt werden kann.
Beziehungsweise an dem Fall war es genauso, dass es noch ging.
Hier waren die beiden so, dass sie da nicht mehr gehen.
Genau, Entschuldigung. So, die entsprechenden Verteilungsmöglichkeiten,
die wir dann haben, sieht man hier deutlich,
dass wir da oben jetzt noch zwei Ligen haben.
Hier unten noch drei haben und da noch drei.
Und dass das deswegen halt nicht funktioniert an dem Stellen.
Und das wird als unsicher bezeichnet und durch diese Bankis-Idee
verkauft man jetzt sozusagen die entsprechenden Ressourcen da drin
So. Spannender wird es dann mit drei Dimensionen,
wo wir dann eben noch interessanterweise die Möglichkeit hatten,
das ist hier ein unendlich langes Schaltverhalten sozusagen noch geben kann in dem Netz.
Also ich kann durchaus noch Kredite, bediene mich lange wieder vergeben,
aber dass sie sozusagen prinzipiell einige nicht mehr ganz abdecken kann und damit sozusagen in einem Bereich bin,
den ich nicht haben möchte, weil ich genau die Forderung von diesem,
beziehungsweise in diese Richtung hier nicht mehr weiter bedienen kann.
Und das möchten wir nicht haben, sieht man auch,
dass relativ viel zwar okay ist und selbst im unsicheren Bereich kann man noch was tun,
aber es ist eben nicht mehr so, dass das ist,
was das System verspricht, zu tun an den Stellen.
Und das Ganze kann man dann entsprechend falten,
sodass man gesagt hat,
das Netz draus machen kann und mit der entsprechenden Färbung kann man dann entsprechend auch wieder durchspielen,
die einzelnen Fälle, die wir dann da hatten,
dass man halt das B hat und dass man eben einen Modus
B dann schaltet oder für den Kunden A oder Kunden C,
dann entsprechend die Zuteilung hat.
Genau, so, und das kann man einzeln so durchgehen und kann dann einzelne Sachen zurücknehmen,
sodass man dann hier jetzt das Zurückschalten dann halt hat. So,
dann habe ich kurz was erzählt zu den flexiblen Fertigungssystemen,
in denen halt ähnliche Verfahren zum Einsatz kommen und wo relativ schnell klar wird,
dass man das nicht mehr einfach so mal per Daumen einfach abschätzen kann,
dass man da eine schnelle Unterstützung braucht, Zustandsräume wachsen entsprechend schnell.
Auch das konnte man dann anhand dieser entsprechenden einfachen Grafik sehen,
wobei das ja relativ simple Geschichten sind,
aber allein schon mit den Zuteilungsmöglichkeiten,
die hier in diesem einfachen, kleinen Bereich drin sind,
kann man sich vorstellen,
was in der Fabrikhalle passiert und dass man da ganz andere Algorithmen auch noch dann wiederum braucht nachher.
Aber die prinzipielle Idee ist hier halt, dass Bankiers Problem dahinter.
Dann hatte ich die Sache mit dem entsprechenden Workflow,
mit den entsprechenden Weiterreichungen, was dann aber jetzt hier,
wie gesagt, nicht in dem gefärbten Netz,
was man dahinter noch sehen kann,
dann vorgeführt wird
So, dann kamen wir zum Rinho und da hatte ich noch ein bisschen was zu erzählt,
was sich so dahinter verbirgt an der Stelle.
Und da hatten wir eben jetzt ganz am Anfang ein Netzsystem,
wo wir halt irgendwie beschränkte Ressourcen hier haben,
die sich wieder vermehren lassen,
indem man sich halt gemeinsam trifft und gemeinsam hier quasi bei
der Arbeit Wertschöpfung voll verbringt sozusagen oder eben irgendwas verbraucht,
quasi hier durch, durch diese Aboration.
Das kann man halt einzeln so durchspielen und das kann man
jetzt so machen. Oder man kann nicht entsprechend etwas produzieren,
sodass dann da wieder entsprechend mehr Marken entstehen.
Also genau das übliche Spiel, was wir
da drin haben
So, dann haben wir gesehen, okay,
wir können das Ganze auch wieder falten,
indem wir das Ganze einfärben und da jetzt hingehen und die entsprechenden Farben für die Schaltmodi verwenden.
Dann hatten wir gesehen, das Konto können wir auch noch anders verwalten,
auch das, was ja aus der Objektorientierung ja schon kennt,
wie man sowas machen kann.
Dann die beiden nebeneinander dargestellten Netzteile, die man dann aber wiederum auch zusammenbringen kann.
Dadurch wird das Ganze aber halt eben zu einem sehr großen
Netzsystem zusammengefasst, was wir nicht haben wollen. So,
dadurch kommen wir wiederum auf die Idee,
dann müssen wir es halt trennen und das aber trotzdem wieder de facto doch zusammenbringen,
weil einfach so ein Strichzeichen dazwischen ist dann auch nicht die Lösung,
wenn wir das Und doch wieder in einem Zeichnen,
was wir also haben, ist,
dass wir hiervon quasi nachher Netzinstanzen anlegen können und das Separat unterbringen können.
Wobei das mit dem This hier an dieser Stelle erfordert natürlich,
dass es in demselben Modell quasi drin liegt.
Das werden wir gleich nochmal sehen, was das eigentlich genauer bedeutet.
So, dieses Teil hier ist quasi jetzt der synchrone Kanal,
den wir da drin haben.
Und der uns jetzt eben entsprechend erlaubt, einen Aufruf vorzunehmen.
Und diese Transition hier kann also nur noch schalten,
wenn diese hier ebenfalls schalten kann. Das erfordert also,
dass die entsprechenden Marken hier liegen habe,
wobei ich jetzt hier keine Vorbedingungen habe, weil ich einfach draufpackt.
An dieser Stelle hier, also die kann nicht schalten,
ohne dass die hier dabei ist. Hier erfolgt auch der Aufruf,
dass hier sagt, um welches Objekt es sich an,
wo es auch dran aufgerufen wird, dass eben dasselbe Netz,
deswegen steht da das.
Und hier vorne muss man auch entsprechende Marke liegen. Das heißt,
was wir nehmen können, wir können ein A nehmen und hier weiterschalten,
wobei das zum Weiterschalten natürlich hier oben schon irgendwas passiert sein muss.
Kommen wir da auch vorher nochmal drauf,
wenn wir das Wiscraw und da haben wir entsprechend hier.
Hier haben wir drei As liegen,
wir können uns ein A abziehen und das A,
das wir drüben haben,
auch benutzen.
Wir können sich
ein A hinlegen
Das A hier liegen haben,
können wir auch noch ein entsprechendes B hier drüben noch schalten.
Weitere Möglichkeiten haben wir nicht. B funktioniert ebenfalls,
haben wir hier A und B liegen,
damit sind X und Y gebunden, entsprechend, weil wir zwei Marken brauchen.
Und dann haben wir halt das Deposit und dann geht es eben in der Hinsicht,
dass wir bei X und Y jeweils ein A wieder hinlegen können.
Und das können wir dann mehrfach entsprechend schalten. So,
was jetzt dann wirklich gesehen werden muss, ist,
dass diese beiden Transitionen, beziehungsweise diese beiden Transitionen hier,
die Hüftbraw und Deposit-Funktion,
dass die sozusagen zusammen jeweils für sich
nur Atomarsch halten können
Damit habe ich also genau diese Lebenslinien-Idee wieder aufgegriffen.
Ich verfolge eine Lebenslinie von einer Person und einem Konto.
Und wenn da irgendwas passieren soll,
dann muss das irgendwie dann auch wieder zusammen synchronisiert werden.
Die Synchronisation habe ich natürlich in gewisser Weise auch hier vorne,
dass ich sage, wenn da das A und da das B ist,
dann können die nur zusammen was tun.
Das wäre genau die Idee, die wir davor auch schon hatten,
wo wir eben genau die entsprechenden beiden Marken liegen hatten.
Und dann hat die eine Transition geschaltet, auf beide konnten etwas getan. Das heißt,
da war ohnehin schon gedanklich das vorgenommen, aber dadurch,
dass wir dann halt diese Mehrfachmarken auf einer Stelle haben,
konnten wir das sozusagen da vielleicht nicht ganz so gut
auch sehen
Hier wird es mal explizit deutlich, dass das jetzt
sozusagen mit diesem zweiten Bereich was zu tun hat.
Und dieser Bereich hier, dass wir zwei drin sind,
steckt halt da schon in diesen Netzen mit drin.
Gut, so, das war, das war jetzt die,
die Geschichte mit dem, mit diesem synchronen Kanälen,
die wir jetzt hier haben.
Die Bindung ist jetzt natürlich nochmal spannend,
was mit dem X und dem Y,
wie man das binden kann oder was da drauf sein darf oder auch nicht.
Und hier genauso. Die Dinge, was ich jetzt hier
benennen kann, ist sozusagen immer lokal. Das heißt,
ob ich hier jetzt ein X ranschreibe und hier auch ein
X. Oder da ein Y und noch ein Y, das ist völlig egal.
Ich kann noch irgendwelche anderen Variablen nehmen. Das hat mit denen X,
was hier drüben steht, nichts weiter zu tun, außer,
dass sie sozusagen als Parameter für diese Funktionen hier mit drin jeweils gleich sein muss.
Der entsprechende Aufruf, so wie man es ja auch sich so vorstellt,
dass sich vom Rufenden auf gerufenen Parameter nicht dieselben Bezeichner benutzen muss an der Stelle.
Okay, das This ist jetzt die Notlösung,
damit ich jetzt nicht noch ein Objekt hier einführen musste,
was ich dann als Konto bezeichne und dadurch,
dass es hier im selben Also im Grafiklicht kann ich auch das Bist direkt verwenden.
Kein Problem dabei. So, die andere Möglichkeit, die ich jetzt habe,
hier ist, dass ich das Deposit sozusagen nur einfach hier aufpacke.
Wenn ich selber was aufs Konto einzahle, würde ich ja
auch nur einfach was einzahlen und nicht irgendwie auf das da zwei,
auf zwei gleichzeitig was eingezahlt werden muss. Das heißt,
wenn ich das jetzt hier mir anschaue,
habe ich hier ein Konto für X,
was jetzt hier verwalten kann und hier können X da raufgelegt,
wenn wir runtergenommen werden,
dann werden,
wenn wir jetzt nur aus und wie es haben,
können also hier mit X und A
mit A und B
entsprechende Werte draufgepackt werden
So, jetzt ist das so, dass wir hier drüben,
aber weiterhin diesen Aufruf machen wollen, aber weiterhin,
dass hier drüben zwei Marken erzeugt werden.
So, jetzt packe ich das hier rauf. Was bedingt das
? Und das bedingt, dass sich Depossile überhaupt zweimal schalten kann,
weil das könnte ja eine Vorbedingung haben und eine Stelle,
die irgendwie auf die Fressetransition reingeht.
Und wenn da dann nur eine Marke drin wäre,
könnte ich die ja gar nicht zweimal aufrufen
Genau, aber wir haben ja gar keine andere Stelle im Vorbereich hier.
Also das war jetzt eine hypothetische Aussage, wenn da eine Stelle wäre,
also wie sieht es jetzt aus mit dem Teil?
Wir haben ja oben das Netz. Also hier oben.
Und da habe ich gesagt, jo, unterschalten wir jetzt
und dann packen wir hier ein A und B rauf.
Jetzt ist die Frage,
wenn ich jetzt hier mein A und B hier hingeschaltet habe,
funktioniert das jetzt noch?
Oder muss ich jetzt
ein zweites Konto irgendwo hinmalen
Was jubel ich euch damit jetzt unter?
Welches Konzept in den Netzen? Naja, hier drüben steht
das zweimal dran und da steht nur einmal was.
So, jetzt werde ich das ja hingeschrieben haben aus einem
bestimmten Grund. Jetzt könnt ihr euch übrigens gleich kommt,
damit irgendwas, was ihr das dann löst
Aber ich sag, das ist schon die Lösung.
Und jetzt ist die Frage, warum ist das jetzt schon die Lösung?
Und auf welches Prinzip verweise ich jetzt sozusagen bei den Netzen?
Das ist jetzt so wie eine Methode zu gesehen.
Da kommt einfach jetzt, wir haben jetzt unser X oder unser Rüstümer.
Und das kommt einfach jetzt immer in Stunden bei Java, jetzt eine Methode.
Ja. Super. Nächste sozusagen unsere paar Meter. Gut
. Und in Java kannst du es direkt so implementieren.
Und deinemselben Objekt rufst du zur selben Zeit zweimal dieselbe Methode
aktiv auf. Zur selben Zeit. Wie machst du das
Da musst du mir erst mal die genaue Spezifikation deiner Methode jetzt genauer offenlegen. Also ich glaube,
worauf sie hinaus wollen, ist die Selbstnebenläufigkeit von Transition,
dass ich halt hier eben genau das machen kann,
dass ich hier eine Transition in einem Moment zweimal schalten kann.
Genau, das ist die Voraussetzung,
dass bei den Java-Sachen muss man erst mal sich genauer durch den Kopf gehen lassen,
wie man es schaffen möchte, zur selben Zeit,
dieselbe Methode, am selben Objekt, zweimal aufzurufen,
was einen doppelten Kontrollfluss, also Aufluft erfordert,
wie man das sozusagen gedanklich hinkriegen soll.
Das ist eine der wesentlichen Unterschiede hier, dass eben genau
die Netze ja zu sich selbst nebenläufig schalten können.
Ich kann ja auch hier oben Diese Transition zur selben Zeit für A und B
schalten, sodass beide zur selben Zeit hier hinschalten können.
Und zur selben Zeit wird diese hier drüben aufgerufen. Das ist eins der Dinge,
die ja in diesen Netzen drinsteckt, durch unsere Faltung,
haben wir gesagt, okay, die Faltung bedeutet nur,
dass wir die ganz verschiedenen Modi so zusammenlegen.
Und dieses Zusammenwalten sind dann halt eben andersrum betrachtet die Möglichkeit,
entsprechend viele Instanzen aufgrund der Markierung hinzubekommen.
Was bedeutet hier, könnte ich beliebig viele obende Kanäle sozusagen
hinschreiben von dieser Seite her,
ohne dass mich dieses Netz
hier irgendwie behindern würde
Ja, weil die einfach sagen, okay,
das wird nach Bedarf eben 1, 200,
10.000 eine Million Mal zur selben Zeit aufgerufen und tut was rein.
Das ist das, was sozusagen da da drin steckt. Das ist auch so,
dass wenn ich jetzt noch eine weitere Transition hätte,
die auch noch Deposit, die Posizet aufrufen würde von irgendeiner anderen Stelle,
hätte das mit der hier sozusagen noch keine Probleme,
weil das ja wirklich keinerlei Vorbedingungen hat.
Und die könnten zur selben Zeit, vielleicht auch unterschiedlich lang, sozusagen aufgerufen werden,
je nachdem, wie lange halt die Ausführung von einer solchen Transition ausschaut.
Das ist genau das, was der Simulator implementiert hat,
sodass sich also diese entsprechenden Transitionen Wenn ich sie aufrufe,
die schalten halt irgendwie lang, je nachdem,
was darin passiert, eventuell sogar beliebig lang.
Wenn ich nämlich da eine Totschleife dran schreibe,
dann ist dann sozusagen die Action, die da noch passiert,
die wir jetzt hier noch gar nicht sehen können,
kann dann sozusagen zuführen, dass diese Transsitzung beliebig lange weiterschaltet,
ohne dass sie dann jemals terminiert.
Auch das ist möglich. Stört mich im Rest des Netzes aber nicht,
weil dann ist die halt sozusagen im Schalten,
aber der Rest des Netzes kann ruhig weiterarbeiten.
Also das ist dadurch auch eine gewisse Unabhängigkeit da drin.
Selbstverständlich will ich sowas aber nicht haben, weil es natürlich Ressourcen schluckt,
wenn irgendwas mit einer Totschleife nebenbei bei meinem Programm läuft.
Das ist halt nicht das, was wir
unbedingt haben möchten
Gut, was wir jetzt also hier haben, ist,
dass wir das X entsprechend hier reinpacken und wir können es
tatsächlich dann für A und B unterschiedlich hier reinlegen,
weil wir den Schaltmodi für diese Transition wirklich unabhängig berechnen können und dann zu allem,
was von außen irgendwie kommt, auch was machen können.
Und das hier sagt nichts anderes aus,
als dass wir wirklich zwei weitere Möglichkeiten der Bindungssuche brauchen,
die dann instanziert werden und dann auch schalten können.
Und genau das würde dann von dieser Seite her,
durch den Simulator bereitgestellt werden, dann sagt,
okay gut, ich habe hier ein A und B,
wenn du das möchtest, Und das biete ich an.
Ich hätte auch noch dreimal A, wenn also hier zwei As draufliegen würden,
könnte ich also genauso gut auch selbst Geld in die Tasche schaufeln.
Das ist natürlich die Idealbedingung, wenn man sich selbst jederzeit wieder Sachen selbst darauf liegen kann. Was nicht funktioniert,
ist, was nicht funktioniert, dass man ein A nehmen kann,
hier drauflegen kann und sagen kann, ja okay,
dann bin ich eben X und Y beide auch an ein A. Wenn ich ja zwei As liegen habe,
wie ich jetzt gerade gesagt habe, das bedeutet ja nicht,
dass X und Y hier ungleich sein müssen, das fragen wir ja nicht weiter ab.
Wenn da so zwei As hier liegen könnten,
dann könnte es auch zweimal schalten.
Dann wird das ja auch funktionieren. Aber wenn ich nur
ein A hier liegen habe, warum geht es dann nicht?
Was ist dann
die Begründung
Ja? Wenn das kleine Adeln hat, das Ex gebunden
ist und so gesehen nicht mehr auf der Stelle liegen.
Ja, genau. Bei der Bindungssuche wird geguckt,
da habe ich auch genügend Marken im Vorbereich.
Und wenn nur ein A da ist,
ich habe zwei Eingangskanten in diese Transition habe,
dann ist das etwas, was wir nicht haben wollen.
Genau, richtig. Sehr schön. Gut. Dieses X
wird dann nämlich entsprechend hier drüben widerentsprechend untergebracht und aufgrund der
entsprechenden Markierung, die da vorne drinsteht.
Auch hier benutzen wir wieder den Bezeichner des Netzes,
wir da so untergejubelt haben, dass es immer noch weiter
dieses Dokument hier, deswegen das List da drin.
Wir könnten das auch in ein anderes,
in eine Netzinstanz jetzt auslagern, zum Beispiel Konto.
Und wenn ich dann also Konto, Doppelpunkt, Deposit aufrufen würde,
würde das hier sozusagen in einem Objektkonto liegen und da drin dann verwaltet werden.
Gut, so. Jetzt kommen wir noch ein bisschen die
Buchhaltung angucken, was wir so in dem Teil machen können.
Wir haben also jetzt hier irgendwie sowas,
dass wir jetzt sagen, wir nehmen einen runter, eine Einheit
Und wir tun mal einen rauf. Das wäre das,
was wir jetzt hier drin stehen haben. Das heißt,
wenn ich jetzt hier aufrufe, schalte nehme ich das X
hier raus und da bist du raw X und gucken,
was da da hinkommt.
Und hier habe ich jetzt sozusagen eine 3 drauf liegen und mit
dem Whistbraw, gucke ich also jetzt hier hinten hin.
Und was mache ich da? Na, ich bin jetzt
in X und M. So, was mache ich jetzt?
Ich ziehe jetzt hier eine entsprechende Marke ab,
also X, Komma A und packe entsprechend das X,
A-M, nämlich das,
was von hier kommt,
entsprechend wieder zurück
Also, wenn wir einmal schalten, nehmen wir also die drei raus.
Also zum Beispiel A, 1,3, nehmen eine Geldeinheit weg
und packen das A,2 aufgrund der Rechenoperation hier wieder hin.
Das Gegenstück dazu ist dann natürlich ganz einfach hier drüben.
Wir haben das Deposit X1, rufen das hier entsprechend auf,
ziehen hier das A ab und packen A plus M wieder zurück.
Immer natürlich unter der Färbung X für das A jeweils oder für das Bi,
je nachdem, was wir uns da gerade angucken.
So, das ist also ein ganz einfache Operation,
ein ganz einfaches Zuordnen von den Dingen
Und wir kümmern uns auch darauf rechnen, auf diesen Dingen.
Können wir so entsprechend mit unterbringen. Die Operation kann man
beliebig noch komplizierter gestalten. Selbstverständlich kann ich auch mehr oder weniger
abholen. Ich kann auch mehr oder weniger hier raufpacken.
Ich kann auch hier von irgendwelchen Berechnungsfunktionen anschreiben und so weiter und so fort.
Gut, dass wir da rechnen können. Das wäre Java-Anschriften
ranschreiben können. Das dürfte dann kein Problem sein. Das heißt,
alles, was Sie mit Java sozusagen einschreiben könnt,
können wir da auch machen.
Bleibt also völlig gleich. Insbesondere können wir das als Action
sozusagen an diese hier noch ranpacken oder noch weitere Nebeneffekte haben wollen.
Wenn wir zum Beispiel noch irgendwelche Aufrufe für die Oberfläche und
sowas haben wollen,
kann man
das unterbauen
So ein kleines bisschen, was zeige ich jetzt davon noch,
wie es jetzt dann weitergeht in Richtung Netzbenutzung,
wenn wir jetzt Netze in Netzen haben.
Und zwar wollen wir jetzt mal gucken,
wie wir das jetzt auf andere Netze verteilen,
wird es jetzt da hinkriegen an der Stelle.
So, und ich habe jetzt hier so ein Hauptnetz-Creator,
nennen wir das mal.
Was ist der hier? Und ich hatte ein X und Y,
was ich mit einem New Atternet binde.
Und ich habe das als Anschrift für diese entsprechende Transition.
Da habe ich einen Token im Vorbereich,
ich kann also einmal schalten,
pack X und
Hier hin. Und habe dann was auf den Stellen liegen. Naja,
das, was da in diesen X halt drinsteckt,
das fange ich jetzt erst mal sozusagen von der ersten Idee
her mal so da so hin.
Das heißt, ich habe jetzt hier ein anderes Netz,
was wir da erst mal erzeugen.
Ob ich jetzt nur das Netz oder eine Referenz darauf habe,
werden wir gleich noch sehen.
So, dann haben wir ihm das Netz adanett,
das ist erst mal sehr einfach strukturiert hier.
Wenn wir da jetzt reingucken, ist es ein bisschen komplizierter
als so eine Transition.
Es ist also eine Stelle und eine Transition
und kann dorthin schalten
So, was ist jetzt das mögliche Verhalten in meinem Netzsystem, was ich damit habe? So,
ich habe die letzte Stunde ein bisschen was dazu gesagt,
dass wir jetzt mit einmal auf die Idee kommen,
dass unsere Datenstrukturen, die wir in unserem System hin und her schieben,
nicht mehr wie bisher, nur beim gefärbten Netzen,
nur einfache Datentypen sind, also ein Rekord von irgendetwas,
Datensatzen, Buchhaltung für irgendeine Geschichte, sondern ich möchte jetzt,
dass ich dort aktive Systeme wiederum drin habe.
Und die beschreibe ich zufälligerweise dann wieder mit Plätzen hier.
Kann man auch mit anderen Sachen machen,
machen wir auch in unseren Programmiergeschichten,
kann man auch beliebige andere Objekte da natürlich rein,
sagen wir das Ganze im Java-Kontext,
entsprechend bleibt
Und insbesondere kann man natürlich auch Referenzen, auch beliebige andere Dinge außerhalb haben.
So, das Spannende ist jetzt hier aber,
dass wir hier ein gewisses Verhalten haben in so einem Netz und hier drüben natürlich auch.
Und jetzt ist die Frage, wann passiert denn da jetzt was?
So, was ich, ja? Ja, ich würde vermuten,
dass da auch Großkonditionen 2, 9 jetzt sehr erscheinen werden.
Ja. Mhm. Dann, mit dem wir wieder wieder sprechen.
Ja, genau. Das wäre so die Idee dabei.
Jetzt ist natürlich die Frage, es werden auf der
rechten Seite Netze generiert, genau. Also, das,
was wir bisher immer sehen mit dem hellen Hintergrund,
ist quasi nur ein Template
Oder eine Klasse. Und was wir da aber brauchen,
ist, dass wir eine Instanz haben und Instanzen sozusagen von
diesen Dingen anlegen. Weil deshalb wäre die Frage,
wenn ich jetzt dieses New Othernet, kann ich also,
muss ich irgendwie sehen, wie ich das doppelt hinbekomme.
So, und mein Adadnet ist erstmal nur eine Datenstruktur,
die im Dateisystem vielleicht irgendwo liegt,
die ich nehmen kann und die kann ich aufrufen.
Und bei diesem Teil, das ist dann quasi wiederum sozusagen eine Klassenbeschreibung,
die ich dann davor finde, von der kann ich entsprechende Objekte instanzieren.
Das ist genau das, was ich mit dem New Othernet
sozusagen hier an der Stelle durchführe
Dann ist genauso, wie es eben beschrieben wurde,
ich schalte hier also und erzeuge hier ein Netz und noch ein
zweites Netz und von diesen beiden mache ich dann in Instanz.
Wie du das ja schon im Review gesehen habt,
habt ihr die weißen Netze zum Zeichnen und dieses wunderschöne Blau,
Taubenblau oder welche Fabi auch immer dafür nehmen möchtet,
ist dann der Hintergrund, wenn wir das Ganze ins Schalten bringen.
So, das heißt also, dieses Netz hier links kann
gar nicht schalten, weil das nur ein Template ist sozusagen.
Ich muss das hier also irgendwie über die Umgebung erstmal überhaupt zum Laufen gebracht haben,
also irgendwie muss das erste Netz,
muss in der Umgebung gestartet werden quasi von außen muss an diesem Teil irgendwas zum Laufen gebracht werden.
Kennt ihr ja auch nicht anders,
eure Programme laufen ja auch nicht von alleine durch,
ihr braucht eine Umgebung, in der ihr die Main-Geschichten oder die Haupt, irgendwo müsst ihr starten.
So, wenn das jetzt also instanziert wird,
dann haben wir ja schon durch die Anfangsmarkierung,
durch diesen schwarzen Token auch hier eine Transition drauf liegen,
die ist dann aktiviert und der Simulator sagt dann, okay,
gut, wenn ich Lust habe, schalte ich die mal.
Wenn ihr also in dem Udo seid,
dass ihr in Ringen gesagt, jo, immer ausführen,
dann wird die auch entsprechend geschaltet.
Ansonsten würde erst mal, wenn ihr den Mose nicht eingeschaltet habt,
sozusagen erst mal nur das instanziert werden
Wird nichts passieren. Und dann könnt ihr per Hand
auswählen und sagen, bitte nichts mögliche Transition schalten.
Das hier drüben ist sozusagen Licht noch sozusagen im System
und ist erstmal bei den Instanzen noch gar nicht dabei.
Wenn ich jetzt schalte und die beiden jetzt hier hinlege,
dann existieren zwei solche Teile und das können wir uns jetzt mal angucken.
Oben haben wir noch unsere Beschreibung und was wir jetzt haben hier,
ist quasi eine Marke,
die dann wieder auf dieses Athernet 1 und das,
also eine 2 zeigt hier
Beide Variablen haben unterschiedliche Zuordnungen und machen das jetzt hier separat.
Und hier drüben sehen wir jetzt auch noch etwas,
was ich euch zu euch untergeschoben habe.
Nämlich, dass dieses Netz hier sozusagen schon geschaltet hat.
Das heißt, dieses hier hat irgendwie unten drunter,
denn es war aktiviert, hat jetzt auch irgendwie geschaltet.
Und das hier entsprechend noch nicht. Und jetzt ist die Frage,
wann können die denn eigentlich wie sich verhalten und wann dürfen die wie schalten?
Naja, das ist Bei einem echt nebenläufigen System halt so.
Wann immer die wollen, können sie. Oder wenn es immer
ihnen möglich ist. Wenn also Simulator genügend Ressourcen bereitstellt,
bühlen viele Kerne und sonst was. Kann das entsprechend ausgeführt
werden. Diese Netze können auch in anderen Systemen laufen.
Das heißt, sie können wirklich also auf anderen Maschinen laufen.
Auch das kriegen wir problemlos hin mit dem Rinho.
Das heißt also, die können irgendwo anders sein.
Nur dann sind die Referenzen nicht mehr ganz so einfach und
die Bindungssuche ist nicht mehr so einfach hier
Entsprechenden Möglichkeiten in einem Rechner jetzt, also auf einem Renio,
sind jetzt so, dass wenn dieser Modus aktiviert ist,
dann kann jede aktivierte Transition gezeigt entsprechend schalten.
Und hier ist dann so, dass diese beiden wirklich unabhängig
voneinander schalten können. Die sind also jetzt nicht getaktet.
Das ist das, wenn ich jetzt mit Referenzen arbeite.
Wenn ich jetzt auf die Idee komme, zu sagen,
jo, ich lege da jedes Mal so eine Referenz an.
Eine andere Möglichkeit wäre auch, dass man hingeht und sagt,
ja, dann machen wir es einfach so.
Wir nehmen einfach ein Avanett, das wird instanziert von
den Creator und dann haben wir sowas da.
Und so eine Kante darüber
Das ist natürlich dann ein bisschen unglücklich,
weil dann sozusagen das mit dem New anders definiert ist,
dass man einfach nur einen Zeiger auf dieses Netz hätte.
Auch das wäre eine der Möglichkeiten gewesen, das zu implementieren.
Das wollten wir aber nicht, weil das eben sozusagen uns weiter einschränkt.
Wir haben also jetzt die vorherige Variante erlaubt uns eben,
jedes Netz genau so zu behandeln wie ein Java-Objekt.
Und jedes Java-Objekt kann genau wie ein Netz behandelt werden.
Da gibt es also für den Simulator
keinerlei Unterschiede
Außer, dass das Java-Objekt natürlich innen drin nicht genauso sich so verhält
wie ein Netzsimulator und dass der Simulator sich nicht genauso verhält wie ein Java-Programm.
Insbesondere aufgrund der Ausführungssemantik, dass das Netz sich selbst nebenläufig schalten kann,
was bei dem Java-Objekt ein bisschen schwieriger ist. Was man machen kann,
ist, dass man entsprechend des Dubs generiert,
also entsprechende sozusagen Interface dafür sorgen,
dass man das an die Objekte oder an die Netze jeweils in beide Richtungen, die Aufrufe zur Verfügung stellt.
Das ist also entsprechende Aufrufe jeweils rein und raus aus dem System gehen,
ohne dass ich euch das jetzt hier alles zeige.
Das ist etwas, was wir dann im Praktika bzw. in
den Projekten dann uns genauer anschauen
Gut, genau. Und dann kann hier geschaltet werden,
wenn das dann ungleich ist, da es hier nicht ungleich ist,
kannst du entsprechend auch nicht schalten und so weiter. So,
das Interessante bei dem Teil ist jetzt noch die Gabage Collection,
bei dem Netz halt davor,
wo wir jetzt diese beiden Netze haben, ist es so,
wenn die jetzt schaltet, dann ist ja die Frage,
kann das Netz dann hinterher immer noch schalten,
selbst wenn die schon geschaltet hat?
Weil irgendwie hier werden die ja weggeschmissen.
Was würdet ihr erwarten? Welche Möglichkeiten seht ihr und warum
ist das sinnvoll oder nicht sinnvoll?
Gibt es
verschiedene Lösungen
Also ich würde sagen, die können dann noch schalten,
wenn sie sich von irgendeiner anderen Stelle ausreferenzieren würden.
Wenn sie von einer Stelle ausreferenziert würden, ja,
das ist eine Variante. Also nehmen wir das mal in
diesem Netz hier, das schaltet, die Referenzen werden gelöscht.
Was passiert dann? Ja, ich würde erwarten,
dass das auf Jepkern wenigstens in einen dysfunktionalen Zustand versetzen wird,
sodass es dann eben nicht weiterschreiten kann, bis es gegebenenfalls abgeräumt wird.
Genau, man würde also jetzt hier dann,
ich könnte mir sich vorstellen, jo,
wenn die jetzt hier sagt, ist ja Schluss,
dann muss das auch aufhören hier drüben,
dann darf da auch nichts mehr passieren
Das wird aber erfordern, dass ich in meinem ganzen System immer genau wüsste,
welche Teile von meinen Objekten jetzt gerade noch aktiv sind oder sowas ähnliches oder sein könnten.
Und vor allen Dingen würde ich, also eigentlich braucht man das
nicht zu wissen, ob sie es sind oder nicht,
sondern sagt dann, ich schalte einfach ab.
Das bedeutet, aber ich habe eigentlich so eine globale Kontrolle darüber.
Aber was machen wir denn, während die jetzt sagt,
ich will schalten, die auch auf die Idee kommt,
sagt, schalten und durch.
Ab wann ist denn der Zeitpunkt,
wo es wirklich nicht mehr
schalten darf
Das heißt, ich müsste also das Schaltverhalten von diesem eigentlich unabhängigen Objekt
hier drunter, dadurch reglementieren, was hier drüben passiert.
Es gibt aber keine eingetragene Korrespondenz zwischen diesen beiden Transitionen.
Also wenn hier ein synchroner Kanal wäre, für den Fall
könnte man da irgendwas binden, aber es gibt hier keine Beschränkung.
Also müsste ich sozusagen von hier aus, um da einzugreifen,
dass eigentlich die ganze Zeit eine Kontrolle behalten.
Und genau das wollten wir da natürlich nicht,
sondern wir haben gesagt, okay, gut, wir machen das so,
dass wir jedes Objekt, das ist ein eigenständiges Objekt,
Und wenn man da so einen C rumhantiert oder sowas,
da ist ja auch solche Möglichkeiten, dass man noch irgendwas hat.
Die Frage ist jetzt hier nur, die haben immer eine eigene Kontrolle.
Jedes Objekt hier quasi ist für sich selbst gestellt ein eigenständiges Ding.
Was in einem Simulator laufen kann. Und solange ich nicht
von außen Simulationen abstelle, global, kann ich das eigentlich gar nicht mehr kontrollieren.
Das heißt, wir haben hier einen Gablish Collector eingebaut,
der so funktioniert, dass dieses Netz hier,
wenn jetzt hier geschaltet worden ist und diese beiden Referenzen nicht mehr existieren,
dass man dann sagen kann, okay, hier drin finde ich keine aktivierte Transition.
Ich finde auch keine schaltende Transition da drin.
Von daher ist das Netz tot. Insbesondere finde ich auch keine
weitere Referenz mehr auf dieses Netz, was vorhin ja schon erwähnt wurde.
Deswegen kann ich auch nicht mehr wieder zum Schalten bringen.
Also auch wenn ich ein totes Netz habe, kann ja sein,
von außen mit einmal wieder, dass da so eine Transition war,
wie wir sie ja vorhin hatten, nämlich eine ohne Vorbereich,
dass wir von außen mit einmal was reinstopfen können.
Das Netz ist irgendwie da gewesen und irgendeiner kennt das noch obwohl
das Netz erstmal an sich erstmal nichts tun kann und weil
sie ja über die Bindung der synchronen Kanäle sozusagen nichts tun kann,
kann von außen immer eingegriffen werden.
So, das haben wir hier nicht. Deswegen können wir
das jetzt in den Garbage Collector schmeißen. Dieses Netz hier unten,
das würde, glaube ich, Collector nicht wegwerfen,
weil es noch eine aktivierte Transition enthält. Es könnte sogar sein,
dass wenn wir hier gesagt, eben eine Action ranpacken,
wie leuchte eine Stunde lang und wir feuern das und während das anfängt zu feuern,
schaltet auch diese Transition und sagt, okay,
jetzt leuchte ich mal eine Stunde, dann bleibt das so,
dass das eine Stunde lang dabei bleibt,
bis es zu Ende ist
Und erst dann wird es sozusagen wieder beseitigt. Wenn ich so was killen möchte,
abschließen möchte, ändern möchte und so weiter und so fort,
dann muss ich andere Mechanismen einbauen,
die das entsprechend verhindern und das anders gestalten.
Gut, das heißt also an dieser Stelle haben wir das
ganz normale Gablish Collection, was man dann sozusagen da benutzen kann.
Noch ein kleines bisschen aufgebohrt. So, und hier drüben
haben wir halt die Referenzen auf diesem Wert und dann auch noch so wertig,
dass es sozusagen nur einmal instanziert werden kann.
So, jetzt gehen wir nochmal ein bisschen auf die Parameter
zu sprechen
Wir haben synchrone Kanäle mit Parameterübergabe. Das machen wir jetzt
hier so. Wir haben hier ein A und ein B.
Und jetzt habe ich ja vorher schon mal erzählt, hier,
wir haben unser Diss, wir sind also in einem Netz,
haben hier einen Kanal und ein X und Y. Meine Frage an euch ist,
was landet hier?
Und was landet da oben? Und landet da überhaupt was
Ich würde sagen, dass Proben landen an einem A,
weil die Vorbereitung, dass nichts anders angefunden ist.
Und dann danach bereitet auch der echte Bewusstsein.
Ja. Und es wird die 2010 Paar aufgerufen,
wo halt nichts mehr bei das Album ist.
Das heißt, dort wird am 50er nach A gefunden.
Und dementsprechend würde man auch bei der Unterren.
Okay. Was mache ich hier mit dem U?
Das ist immer so,
dass die Verständnis
Okay. Ja, das war genau die Erklärung, die dazu passt.
Wir haben die lokalen Bindungsbindungssuche hier. Wir bleiben bei den Y.
Binnen das hier also entsprechend in dieser Form. Das heißt,
es ist relevant, was hier über den Kanal kommt für diese Transition.
Dass hier trotzdem noch ein B sein muss,
damit es schalten kann, ist auch klar,
weil es reicht nicht, wenn hier nichts liegen würde,
könnte es nicht schalten, weil es U nicht gebunden werden würde.
Was diese Leute auch nicht mag, ist, dass man sagt,
fuck nochmal, ein Z draus von irgendwo jetzt hier.
Und das ist nicht weiter gebunden,
das mag der Simulator auch nicht
Da keine ungebundenen Variablen drin haben wollen, sondern es muss geklärt werden.
Genau, okay, dann kommen wir also von da auf
genau diese entsprechende Schaltung, wo das A halt drin vorkommt.
Okay, nächste Variante, was passiert noch beim Schalten?
Was passiert hier? Wir haben wieder ein Netz und wir haben ein New Object Netz,
also das Objekt Netz, haben wir noch irgendwo rumliegen.
Warum heißt das Objektnetz eigentlich? Naja,
wir nehmen das, was wir sozusagen auf der oberen,
obersten Ebene haben, bezeichnet das Systemnetz und die Marken,
die da drin sind in diesem,
in den entsprechenden Stellen,
das sind sozusagen Objektnetze,
weil sie als Objekte in dem System
sich bewegen können
So, was machen wir jetzt hier?
Wir haben jetzt hier zwei Transitionen, mal unterschiedlich dick gezeichnet.
Da haben wir eine entsprechende Marke liegen, das heißt,
das kann jetzt hier etwas tun.
Das schaltet also und wir haben jetzt hier ein X,
wodurch das X hier drüben entsprechend gebunden wird und das wird daran gebunden an ein Objektnetz.
Gut, hier drüben können wir nichts tun,
weil da keine Marke drin ist, können wir also machen.
So, dann haben wir also so ein Objektnetz hier oben
und das hat eben genau dieses BU Y und so weiter,
das, was wir gerade eben schon mal hatten.
So, das heißt, das Objektnetz kommt jetzt da rein
und wird hier als entsprechende Instanz sozusagen angelegt
Hier oben sehe ich sozusagen das normale nackte Netz,
also das Template. Und hier oben kann ich jetzt sehen,
dass es sich um die Instanz handelt,
weil die entsprechend durchnummeriert wird mit diesen Dingen.
So, dann haben wir da drin, jetzt also das entsprechende Objekt.
Dann haben wir hier das A drin, was das Z ist.
Und hier drüben haben wir das Z als Parameter.
Hier entsprechendes Y, was dazu führt,
dass wir eben das hier unten schalten können.
Hier dieses X soll da dran stehen und entsprechend dort.
Das heißt, wie sieht jetzt die Nachfolgemarkierung aus,
wenn das Ganze schaltet
Ja, in der letzten Markierung wird dann dieses Objektnetz eins da liegen,
wo aber dann der Vorbereich, das B abgezogen ist,
also in dem Objektnetz jetzt,
und im Nachbereich dann das A liegt aus der Stelle da drüber da oben.
Es kommt das Objektnetz hier rüber, das ist auch abgezogen worden, genau.
Das hatten wir auch so. Und wir hatten hier das
A, genau wie eben beschrieben, auch entsprechend drin.
Genau, haben wir das entsprechend durchgeschoben und weitergebracht. So,
was wir dabei jetzt noch haben können, ist,
dass wir Hier unten ja Transition ohne solche synchronen Kanäle gehabt haben können.
Also sowohl im Vorbereich als auch im Nachbereich.
Die können denn unabhängig von dem System jetzt schalten?
Ich habe also drei Möglichkeiten im Wesentlichen.
Ich kann einfach oben das Netz schalten und irgendwie weiter bewegen,
ohne sich es an das unterbinden muss.
Ich muss ja nicht unten einen Kanal aufrufen.
Das heißt, das Systemnetz kann also die Marken irgendwie durchschieben.
Genauso kann aber auch das Netz, das unten drunter liegt,
auch irgendwas tun, solange es keine Beschränkungen nach oben hat,
das aufgerufen wird.
Oder es ist selbst irgendwas aufruft
Und das andere ist, dass sich diese beiden Netze
in irgendeiner Form synchronisieren müssen. Jetzt ist die Frage,
muss ich jetzt eigentlich aus dem Systemnetz heraus immer die Objektnetze aufrufen?
Habe ich also immer so eine klare Hierarchie an den Stellen?
Oder was könntet ihr euch da vorstellen? Ich wüsste erst mal nicht,
was halt im Objektnetz nicht auch neu ist,
aber wie Ecken jetzt erzeugen können sollte.
Okay, das Objekt, das kann also auch wieder für
andere, dann hätten wir so einen Baum.
Von Aufrufmöglichkeiten. Jo, das ist nicht nahe.
Weitere Möglichkeiten
Ja. Ich könnte ja auch ein Netz als Parameter
an so eine Kanalsynchronisation übergeben. Ja, man kann genau
die Referenz nämlich über die Kanäle übergeben, ja, und dann?
Dann kann ein Netz auf einem anderen arbeiten und dadurch entstehen
dann weitere Referenzen und dann wird das halt einfach nur noch
ein bisschen Graf und nicht mal mir ein Baum.
Genau. Ich kann also die Referenzen übergeben,
die entsprechend wieder benutzen und das quasi auch andersrum aufrufen.
Also es könnte hier genauso gut sein, dass aus dem
Objektnetz heraus das Systemnetz immer aufgerufen wird und so weiter.
Was steckt also dahinter? Eine wichtige Sache ist dabei,
dass man quasi eine Art, wer kennt wen da drin hat.
Und der Hauptgrund, warum ist ein Rinho,
das hatte ich schon mal erwähnt, am Rande,
aber das ist wahrscheinlich nicht klar geworden da, erwähnt.
Wir haben da so eine Triebrechnung drin. Die Kanäle haben
ja im Moment jetzt einen Rufenden, also einer,
der irgendein andere Netz kennen muss und das andere aufruft.
Und dadurch gehen bestimmte Dinge. So, und unten habe ich
sozusagen einen eingerufenen Kanal. Und von einem Netz aus kann ich durchaus,
also von einer Transition aus, kann ich durchaus mehrere Netze aufrufen,
weil ich sie kenne, aber ich habe nicht mehrere Kanäle, auf die ich lauschen kann gleichzeitig.
Wenn ihr euch das mal so vorstellt,
woran das wohl liegen mag, es liegt an den Algorithmen,
solange diese Bindung, nämlich nur sozusagen raumförmig,
immer von den Rufenden immer einmal nach unten gehen können,
dann können mehrere irgendwie sagen, jetzt rufen wir mal,
weil da gibt es genau einen Partner,
den man da drin finden muss und dann ist die Sache auch geklärt.
Wenn jetzt dazu käme,
dass man auch von mehreren noch wieder was finden könnte,
dann könnte man sozusagen solche zyklischen Geschichten da einbauen und mehrfach suchen,
werden ja entsprechend notwendig.
Durch diese Beschränkung, die wir jetzt drin haben,
bleiben die Algorithmen im Wesentlichen polemiell bei der Bindungssuche.
Wenn wir nachgucken, wer ist denn jetzt hier eigentlich
mit dabei und wen können wir eigentlich aufrufen?
Und gerade bei komplexen, wie du schon sagst,
wenn die Referenz ergeben wurde und kann der wieder aufrufen oder
der kann wieder erzeugen und kann wieder aufrufen, das kann über mehrere Ebenen gehen.
Ich kann also über mehrere Ebenen hinweg auch Netze synchronisieren.
Und man muss sich gut überlegen,
wer wen kennt und wer wen damit auch quasi benutzt,
wenn man es so sehen möchte, als serviceorientierte Betrachtung.
So, da kann man sich längere Zeit drüber unterhalten und
was da gutes Systemdesign ist, das ist das,
was in der Software-Team genauso auch berücksichtigt wird.
Und wie gesagt, das kommt in den Veranstaltungen,
wo wir uns um die praktischen Dinge kümmern. So,
mal gucken, wie viele ich nachher noch bei der,
nochmal eine Demo-Mache für das Rinho.
Müssen wir nochmal schauen, wie weit wir jetzt dazu kommen.
Gibt es jetzt bis dahin erstmal Fragen von eurer Seite aus?
Zu den Parametern, zu Aufrufsachen, zu der Vorstellung von Objekt-Systemnetz,
von der Instanzierung, die Referenz-Semantik, Wert-Semantik, irgendwelche Fragen dazu?
Das sind also als Begriffe, die genauso bei der Klausur gut rankommen.
Oder auch gerade die Frage, Welche Sachen liegen nachher,
in welchem Teil drin? Das muss man sich einmal beschäftigt haben,
ist eine ganz einfache Sache eigentlich. Das ist wirklich so
ein einfaches Bingo-Spiel sozusagen da durchzulaufen. Aber ich bin,
wenn man sich gar nicht vorher angeguckt hat,
dann gibt es durchaus trickreiche Varianten, muss also genau gucken,
welche Parameter wo gebunden werden und ob sie überhaupt schalten kann in der Klausur,
dass sie genau aufpasst dabei, wie diese Dinge aussehen.
So, wenn man es ein bisschen übt,
ihr könnt mit dem Ring das ein paar Mal üben,
da könnt ihr selber ein bisschen rumspielen,
mit ganz einfachen Aufrufen in dieser Art und Weise hier.
Das dauert echt ein paar Sekunden, habt ihr das Netz ja gezeichnet.
Und da könnt ihr ein bisschen rumspielen und selber merken,
was dann wie passiert und welcher Wert rübergegeben wird
Mehrere Beispiele in dem Beispielordner, dass ihr euch runterladen könnt.
Und dass Hamples dann halt die ganzen Varianten von Sachen drin sind.
Es sind durchaus einige überraschende Teile dabei. Also wenn ihr genauer hinguckt,
das sind also genau solche Sachen,
die in der Prüfung gut unterzubringen sind und wo man ganz nett,
ganz letztlich mal Gedanken zu gemacht haben kann.
Okay, bevor wir da jetzt einsteigen, machen wir noch
ein bisschen mit Netzen weiter. Und zwar in einer Form,
was dann durchaus so eine irre Stelle ja schon mal dran war,
beziehungsweise jetzt nochmal dran kommen wird,
was also jetzt verschiedene Darstellungen hat.
Das Athenibit-Protokoll
Im Wesentlichen geht es jetzt darum,
dass wir hier eine Spezifikation haben von diesem Teil hier.
Und wir haben also einen Senderempfänger und wollen dann hier in irgendeiner Weise Daten übertragen.
Und der Sender soll halt irgendwelche Daten in diesen Receiver übertragen.
Das Ganze soll dann möglichst einfach sozusagen hier durchlaufen.
So sieht es relativ einfach aus. Ich habe hier so ein Datum drin,
das nehme ich und dann schicke ich das Datenpaket hier so
über diese Transitionen hier hin und lege es da ab.
So, kommt das nächste Datenpaket,
schiebt mir hier durch und so weiter
Jetzt kann ich ja hier sozusagen immer schon sehen,
ich kann immer so ein Teil nehmen und dann kann ich ja so ein B plus 1 nehmen,
das ist eine Zahl, eine 3,8,
schicken wir die 8 los und kann das dann passieren,
dass wir hier jetzt sozusagen 8, 9,
das war jetzt irgendwie, was haben wir jetzt überholt,
also dass ich jetzt sage, hier kommt jetzt die,
habe ich einen hochgezählt,
das ist endlich jetzt die 9 drin,
dass also die 9 jetzt noch sozusagen vor der 8 ankommt,
kann das da passieren?
Ja, ich bin schon noch einer über Jüngermark nehmen.
Ja, genau, man kann immer irgendeine Marke im Vorbereich
nehmen, aber wann darf ich das nur tun
Wann darf ich die Neuen losschicken? Nachdem ich die Acht
auf die Reise geschickt hatte. Ja. Warum? War wieder
Tradition. 500 Prozent Marke nach Erdepark. Und omix,
die zahlen uns für nichts auf, dann zu finden,
braucht man nicht mal. Genau. An der Stelle
kann ich mich die Neuen erst auf die Reise schicken,
wenn ich da die entsprechenden Vorbereich drin habe.
Und will ich, als ich alle Belicht habe
Das bedeutet, dass da eben was drin liegen muss.
Das heißt, ich kann erst da wieder die Neuen auf
die Reise schicken, wenn mir drüben angekommen sind.
Das heißt, es kann nicht passieren, dass ich Daten hier rüber schicke,
bevor ich sozusagen das andere wirklich erfolgreich hinten abgelegt habe.
So. Damit haben wir ein tolles Übertragungsprotokoll und alles ist in Ordnung. Unter dieser heile Welt-Ansicht,
da würde Herr Wolf gegen die Hände klatschen,
wenn es immer so wäre,
da hätte er allerdings auch viel weniger zu tun,
aber immer noch genug, aber es würde die Welt an vielen Stellen sehr einfach machen.
Problem, was wir jetzt haben können, ist halt,
dass wir auch so eine Übertragung haben,
die nicht unbedingt so richtig funktioniert und dann wird hier
irgendwas Falsches übertragen
Nicht böse, wenn wir da das D nehmen und dann
hier Error übertragen und da steht da Error drin,
dann wird um sieben, acht Error, neun Error,
Error, Error, irgendeine Zahl dann weiter und so fort.
Also jetzt bin ich schon beim Zielen rausgekommen. Also genau
das würde also sozusagen statt des Hochzählens würde jetzt hier,
also quasi festgestellt, okay, mal mit dem Fehler da drin.
Welches Problem, wie lösen wir dieses Problem? Naja,
wir gehen hin und bauen das mal ein bisschen um.
Jetzt macht es buffts, genau,
an dieser Stelle wird es dann gleich
ein bisschen umfangreicher
Wir haben weiterhin unser X hier unten, schicken das los und sagen,
geh mal los, geh mal rüber und komm hier bitte mal an und sag mal da.
So, jetzt haben wir so ein bisschen aufgeteilt und gesagt,
okay gut, damit jetzt wieder dieses Token zurückkommt,
dass es in Ordnung ist,
das muss irgendwie jetzt hier noch wieder zurückgeschickt werden,
damit hier hinten wieder die Marke hat, dass wir es auch wirklich losschicken darf.
Hier sorge ich dafür intern bei mir,
dass ich nur einen erzeugen kann,
wenn ich das losgeschickt habe, dann liegt das da wieder,
kann ich schon die nächsten hinlegen und kann das also das nächste losschicken.
So, der erfolgreiche Weg läuft also genauso wie vorher
Und sobald das A dann losgeschickt hat, kann ich das nicht
so wieder bereitgelegt werden und dann muss jetzt übertragen werden.
So, haben wir jetzt also hier aber, das ist nur der positive Fall,
den er so schön sehen kann, wie es dann hier weitergeht.
So, was kann jetzt passieren? Es kann auch sein,
dass wir oben einen Fehler haben. Was machen wir dann? Naja,
dann packen wir sozusagen quasi hier was hin,
schalten diese Transition, sagen nicht, okay,
packen das zurück und sagen, Mensch, nicht,
okay, ist, dann schick doch nochmal das D,
das habe ich hier liegen lassen.
Das haben wir intern, haben wir gesagt, okay,
kriegen wir schon auf die Reihe,
das wäre nichts kaputtes übertragen,
aber wir haben jetzt diesen Ertragungskanal,
der kann uns jetzt kaputt gehen,
intern können wir
es irgendwie sicherstellen
Das Dee kann also hier ausgelesen werden, losgeschickt werden, kann wieder ein Fehler auftreten.
Das können wir also jetzt hier eine bestimmte Zahl mal laufen lassen.
Wenn ich einen Stecker gezogen habe und keine Verbindung mehr so richtig an der Stelle oben vernünftig funktioniert,
weil irgendwas prinzipiell kaputt ist, dann läuft das hier dementsprechend weiter,
aber auf jeden Fall kommen wir nicht dazu,
dass wir hier irgendwelche falschen Zahlen auf der anderen Seite haben.
Nehmen wir mal an, das klappt aber jetzt irgendwann,
dann sagen wir, ja okay,
ist in Ordnung und wir laufen wieder unseren positiven Fall hier
durch und dann läuft ja dieser Weg,
weil es dem jetzt ja okay ist und wir können den
Nächsten losschicken.
Soweit klar
Gut. Was haben wir jetzt also da eingeführt?
Wir haben hier so einen Zwischenspeicher und gesagt, okay,
dem merken wir uns mal, was wir losgeschickt haben.
Und bei einem Licht, okay, ich schicke mir das halt nochmal.
Und wenn es okay ist, dann nehmen wir das Lied
auch wieder weg und vernichten das und sorgen dafür,
dass dann das nächste De genommen wird und das nächste wieder reingepackt.
Wir müssen, dass wir wieder wegkriegen, hier,
das darf ja nicht liegen bleiben an der Stelle.
Müssen wir es sauber machen. Und hier drüben kommt es eben
immer genau an und wir kriegen ja auch hier drüben nur was rüber,
in dem Augenblick, wo ich auch erfolgreich übertragen habe.
Dass ich ab, soweit ich es übernommen habe,
hier dann keine Fehler mehr habe und nichts mehr Falsches produziere,
ist sozusagen der optimistische Fall,
dass im Rechner nichts passieren kann,
sondern nur auf dem Weg dazwischen bei der entsprechenden Übertragung,
über irgendeine X-Leitung
Gut. So. Wenn man das jetzt so ein bisschen umbaut in das Referenznetz,
dann haben wir jetzt hier so unser D, die bleibt auch da.
Hier schicken wir jetzt ein X und D los.
Jetzt wird es also spannender. Jetzt packen wir also,
dass wir als Tuppel sozusagen rüber, unser XD,
das D wird hier rausgenommen, hier abgelegt.
Das X wird wieder zurückgeschickt. Und wir laufen hier durch
und wir wechseln hier mal das X auf 1 minus X.
Und kommen hier wieder weiter. Dann wird also mit einmal
aus der 1, die wir hier entspanngen losgenommen haben,
habe ich auch gar nicht erst mal gesagt und ich habe nur ein X gesprochen.
Von der 1 machen wir jetzt also null
Der Stelle. Und schicken wir es entsprechend wieder los und lassen das hier rumlaufen.
So, was mache ich hier drüben mit dem Teil?
Ich habe hier das XB sozusagen liegen und ich nehme entsprechend,
dass hier wieder mit. So,
an der Stelle hier drüben in der Fehlerfall auftritt,
tritt einfach nur der Arror hier auf und bei Arror kann
nur diese Transition hier unten wieder sich binden.
Es nimmt das Y und packt das hier raus.
Das ist das. Das ist sozusagen die entsprechende Null für
den Gramm, dass wir Anfang Mitte 1
gestartet sind
Und legen das hier hin. Und jetzt würden wir hier
das X nehmen. Und da muss x,3 und hier ist
das x, hier ist der entsprechende Guard.
Dass die ungleich sind hier quasi gleich. Das fehlt da
eigentlich jetzt noch. Und wir schicken das halt entsprechend nochmal
los mit dem entsprechenden Y, wenn die beiden sich unterscheiden.
Warum ist das so? Weil wir hier entsprechend das X
und Y, ach so, X und Y,
Weil wir den entsprechenden Wert, den wir da haben,
entsprechend erscheiden. Von dem Null hier. Diese Null und
diese einzeln unterschiedlich. Wenn wir selber aufpassen hier. So,
solange also diese Null weit übertragen wird hier und wir
die eins hier am Anfang losgeschickt haben, passiert nichts weiter.
So, jetzt nehmen wir an, wir haben es erfolgreich durchgeschickt.
Was passiert dann? Dann wird hier das x-minus eins
sozusagen rausgenommen und ein x hier wieder zurückgepackt.
Das war jetzt sozusagen unsere Eins,
die wir jetzt hier hinlegen und laufen hier jetzt wieder durch
und haben hier unsere Null entsprechend jetzt drin stehen
So, beim nächsten Mal schicken wir es uns wieder durch.
Und das funktioniert jetzt hier, weil es hier diese Muddel-Operation jetzt drin steckt.
Weil wir hätten ja die 1 drin. Und hier haben
wir die entsprechende Null drin, die wir jetzt rumschicken.
Und 1 und 0 kommt wieder hin und dann können wir
sie wieder losschicken. Und hier wieder entsprechend zurückpacken.
Packen dann hier aber die entsprechende Null wieder zurück.
Und kommen hin wieder null an und 1 minus 0 ist
1. Also kommen wir da wieder entsprechend rein. So,
das heißt, in diesem Durchlauf, den wir jetzt hier drin haben,
sorgen wir also durch dieses eine Bit,
was wir da drin stehen haben,
dass wir diesen Fehler erkennen können
Und Alternierbit-Protokoll, bis im Sofa jetzt wieder spannend,
habt ihr wahrscheinlich schon gehört, die Story,
gibt halt Leute, die gezeigt haben in einem Papier,
jo, man braucht mindestens zwei Bit und so etwas mit der vernünftigen Vertragung hinzubekommen.
Und dann kann man ein paar Praktiker, die gesagt haben,
jo, und wir haben es implementiert mit einem,
guck mal, hier läuft es.
Also dieses Algorithmen zu verstehen und wirklich immer gut aufschreiben zu können
, ist durchaus eine Kunst. Und da wird man erstmal
nur auf dem Papier stehen, muss man halt gucken,
wie man das gut beweist und wie man das entsprechend vernünftig nachreicht.
Also durchaus immer schwierig, genau diese formalen Eigenschaften auch wirklich
sauber nachzuweisen und sauber zu beschreiben
So, dieser Wechselmechanismus, den wir jetzt hier drin stecken,
haben ist natürlich ein bisschen tricky,
weil wir sozusagen beide Seiten richtig erstmal initialisieren müssen.
Mit 1 und 0 entsprechend. Und dann müsst ihr da
hier drin ja natürlich nichts kaputt gehen. Und hier bei
dem Übertragen darf nichts Falsches sein. Und der Arrow,
der jetzt hier zurückkommt, der wird,
da kommt eben irgendwas an Fehler,
wie man das jetzt genau feststellt und warum das jetzt als Arrow auch wirklich so erkannt wird,
das lassen wir an der Stelle erstmal außen vor.
Wir wollen nur wissen, dass ein Fehler gewesen ist.
Und da steckt so ein bisschen Magic drin mit dem
einen Bit,
aber na gut
Dieses Teil hier wird dann entsprechend wieder rumgereicht. Und wie gesagt,
wenn es eben aus dieser Ecke kommt, geht man hier wieder zurück.
Und wenn es halt eben erfolgreich war, wird ja was anderes zurückgeschrieben.
Und wir laufen sozusagen hier unten durch mit dem Teil.
Gut, und dadurch, dass das X jetzt genau wieder
mit diesem X übereinstimmen muss, wird das sozusagen genau richtig zugeordnet.
Okay, was jetzt noch dazu kommt, ist,
dass wir auch hier unten noch eine inkorrekte Übertragung haben könnten,
aber dann wird das Ganze sozusagen einfach automatisch wieder losgeschickt,
wenn das hier mit dem X
nicht übereinstimmt
Weil wir da sozusagen die 13 raufpacken an der Stelle dann,
was nicht zulässig ist natürlich. Weil es wieder 0 noch eins ist,
was dann immer mit einem Witt natürlich wieder ein bisschen schwieriger wird.
Also das heißt, dass X dort, zeigt das
entsprechend an, wenn man da sozusagen einen Fehler hat.
Und das Ganze wird eben immer jetzt hier mit dem Fehlerfall übertragen,
mit der 13, die als Fehlerfall gesehen wird und geht entsprechend raus.
Gut, okay. Und genau so läuft jetzt halt diese Übertragung, dass man damit das, als ich mit Protokoll hinbekommen kann. So,
jetzt kannst du jetzt nochmal als Gefärbtes Netz in Rinho,
war das sozusagen jetzt, jetzt haben wir hier nochmal die allgemeine Spezifikation,
wo man nur sagt, okay, gut,
ich habe eben einen Host und dazwischen trage ich das halt und da muss das irgendwo passieren,
da muss das Protokoll rein,
du musst Protokolle entsprechend implementiert werden über das entsprechende Netz,
was wir dann hier durch diese Struktur genau ja zur Bestätigung sozusagen,
dass es richtig gelaufen ist, wieder reinpacken können.
Und wenn wir jetzt so ein Halbduplex-Kanal mit Fehlerkennung hat,
dann halt die Möglichkeit mit dem F sozusagen so darzustellen,
Und bei dem Gefärbnetz,
wie das entsprechend so aus mit dem Hin- und Rückweg,
den wir jeweils mit Vorwärts und Rückwärts sozusagen hier bestätigen wollen.
Und dann wird es entsprechend weiter aufgedrösselt,
indem man halt darunter das halt so aufführt.
Und hier haben wir dann halt unser D,
was hier das generiert wird, kann man einfach so machen.
Und dann wird das A, das,
wertet das viel entsprechend ab und schickt das genau so wieder auf die entsprechende Reise,
wie wir es gerade eben schon gesehen haben,
mit den entsprechenden Zähloperationen,
mit dem X-Quer halt hier entsprechend und dann einmal einmal so
So, bei dem Fehlerfall hatten wir genau diese Geschichte, dass wir hier durchlaufen.
Da wird der entsprechende Guard halt angeschaut mit dem Y,
das gleiche XXXD, was wir hier aufpassen.
Und wir haben das an den entsprechenden Fehlerfall F sozusagen vorliegen.
Einer von beiden kann dann sozusagen jeweils fehlerhaft sein. So,
und hier unten entsprechend genauso, dass wir das nochmal losschicken müssen,
wenn hier der Fehlerfall eintritt,
beziehungsweise wenn die falsche Meldung für falsch hier rüberkommt.
Wenn es korrekt ist, dreht es sich halt neu durch
an der Stelle. So, das heißt,
da haben wir also jetzt die Möglichkeit,
in dem Renio das auch so entsprechend darzustellen und auszuprobieren,
was man so damit machen kann
Gut, aber dass man das gefärbtes Netz oder als Renio so,
ihr seht das kaum ein großer Unterschied und das sollte keine großen Probleme bereiten. So,
jetzt, das war das, wenn wir es jetzt genauer angucken,
um es nochmal genauer jetzt in den Teil hier zu sehen,
kann man es entsprechend immer so eintragen, diese Ärror-Geschichten mit reinpacken,
dann dieses als nicht okay hier zurücksetzen,
damit es also jetzt direkt da drin,
da sieht man jetzt auch schon die,
einfach nur erstmal die Marke hier so drin liegen
Und an der Stelle halt die Eins und hier die entsprechenden Guards,
die für die jeweiligen Fehlerfälle, für Error oder für das Y,
wenn das Üb von hier falsch durchgekommen ist, eintragen müssen.
Und das sind ja die beiden Fälle.
Errorhi, der Fehler da oder der Fehler hier unten.
Und entsprechend die üblichen XDs, die wir hier vorher drin
hatten, sind auch hier wieder dabei.
Und hier ist auch die einfache Rechenoperation entsprechend drin. So,
damit kann man jetzt also wirklich genau sehen,
dass die Netze das genau jetzt so wieder abbilden können und
da kann man jetzt mit rumspielen
So, das Spannende dabei ist, es ist einfach so ein eins der vielen Protokolle,
die man sich anschauen kann. Es gibt durchaus,
es gab durchaus mal Ideen, auch für den Fachbereich,
ich habe unsere Art Protokoll-Engineering als Abschluss hier einführen sollte,
also sich nur mit solchen Protokollen zu beschäftigen,
ist durchaus eine Aufgabe,
wo man eine ganze Menge Zeit mit investieren kann.
Diese Protokolle treten in allen möglichen Ecken von Systemen immer wieder auf,
gerade im Telekommunikationsbereich natürlich oder nicht,
eine Branche wird das sehr viel eingesetzt.
Aber auch Protokolle an anderen Stellen sind recht wichtig und dafür
braucht man entsprechend Algorithmendesign und dann die Sachen,
die bei Herrn Wolfinger Zuhauf eben auch unterrichtet werden.
Der hat das also zum großen Teil
auch mitgetragen
Gut, dann gibt es noch einen letzten Ausflug bezüglich des Skriptes in Richtung,
was können wir mit den Netzen eigentlich ausdrücken oder was können wir nicht ausdrücken.
Und da kommen wir dann nicht nur auf solche Anwendungen jetzt zu sprechen,
sondern auf die Ausdrucksmächtigkeit allgemein. Das heißt, das,
was ihr in FGI 1 ja auch schon hattet,
mit entsprechend Touring-Maschinen oder Keller oder solchen komischen Dingern oder Grammatiken,
verschiedene Arten von Grammatiken,
Jumpsky-Herarchie ist ja irgendwas,
was euch noch
so hoffentlich im Gedächtnis rumschwirrt
Und einfach, um in diesen Ebenen sozusagen die Sprachen,
Grammatiken und Automaten jeweils einordnen zu können.
Und in dieser unendlichen Hierarchie die Sachen auch entsprechend einsortieren zu können.
Netze ordnen sich nicht ganz so leicht ein,
sind also keins, was wir so direkt in die Chance
gerecht einfach so irgendwo dazwischen stecken können oder da reinstöpfen können.
Und es hängt auch jeweils von den jeweiligen entsprechenden Konzepten ab,
die wir in diese Dinge mit einbauen und was wir
sozusagen für Annahmen treffen über das Netz.
Dass wir das Thema ein bisschen diskutieren.
Und zwar Richtung Tonmächtigkeit und dann eben auch für bestimmte Konstrukte
einbauen in diese Netze,
was das für Auswirkungen hat
So, vom Prinzip her wissen wir irgendwas,
dass wir so Tream-Maschinen haben, also das ist das Gleiche
wie so zwei Zehlerautomaten, ja bedeutet.
Und ja, dann ist die Frage,
ist das jetzt das Gleiche wie ein PT-Netz?
Also kann ich, kann ich mit PT jetzt das Gleiche,
was ich mit diesem Zehleautomaten machen kann?
Und die Antwort ist ja und nein und warum sie ja
und nein ist, das werden wir gleich nochmal sehen.
Im Wesentlichen ist man nein für euch, aber gut.
So, wenn wir jetzt ein Zehleautomat uns angucken,
dann gab es so eine Beschreibung,
dass wir so einen Zustand einzustand 2 haben und eine
entsprechende Übergangsrelation mit entsprechenden Beschriftungen
So, was machen wir da? Naja,
wir haben irgendwelche Zähler, die mich auch mal vorsehen können,
X, Y und Z. Und auf denen liegen irgendwelche Dinge drauf.
Und ja, dann gibt es hier so einen Anfangszustand.
Und es gibt entsprechende Operationen, was wir so machen.
Und hier vorne dann weitere Dinge sorgen.
Ich muss mal gucken, was das eigentlich genau bedeuten soll.
Nämlich erhöhe den Zähler Nummer eins sozusagen um eins.
Und erniedrige erzähle immer zwei, falls er größer ist als null.
So, und dann entsprechend den anderen Zähler,
den belässt du halt
So, und diese Abfrage kann man jetzt so zeigen,
so durchgehen und dann für die entsprechenden Zähler jetzt durchgehen.
Und da unten haben wir unsere Zähler ja stehen für die drei und sagen,
dass wir tun müssen, dass wir das minus eins angucken.
Das heißt also, ein Medienzähler, falls er größer ist
als null, dann hier vorne das Gleiche nochmal.
Und das hier erhöhe den Zähler da hinten,
so als ein Beispiel. Oder hier belaste den Zähler 1
und 3 so und entsprechend für,
nur wenn das Ganze
gleich null ist
So, und das haben wir hier, Übergang,
falls erzählt wird, drei gleich Null ist,
was haben wir hier stehen an der Stelle?
Gut, was wir jetzt dabei haben, ist,
dass wir so ein X-Modeloo Y rechnen können und das kann jetzt
hier sozusagen ihren Automaten versuchen, dann mal entsprechend zu kodieren.
Und hier haben wir eben so drei Zähler,
die wir drin haben und das Ganze sieht dann halt entsprechend so aus,
dass wir das Netz da drin haben.
Das habt ihr wahrscheinlich schon gesehen,
das war schon eine Weile her, wie gesagt,
nochmal angucken,
damit das besser einsortieren kann
Ja, und jetzt kann man hier loslegen, die entsprechende Werte sind gesetzt.
Und dann können wir gucken, was dabei jeweils rauskommt.
So, was passiert dort? Wir haben als erstes die
7-2-1, wie ist die zustande gekommen?
Aus der 8-3-0. Wie ist denn einmal
die Kante da, die angezeigt ist? Genau. Ja,
dann ist immer wieder, man muss erstmal einen Überblick kriegen.
Einige haben eben durchaus Fragen geguckt gerade an der Stelle,
oder vielleicht auch nur was will er jetzt von mir, ne?
Aber gut. Ja, jetzt ist die Frage,
wie geht es denn weiter
Ja. Die ist leicht, ich schaue mir nochmal auf das Gefühl.
Ja. Okay. Nochmal, ja, ich sehe schon,
okay, jetzt sehen auch oben die entsprechenden Zahlen,
was da so jetzt jeweils passiert.
Was kommt jetzt? Jetzt kann halt die Kantrin nach Z2 aussuchen,
weil der das Bedingung hat,
dass der zweite Ziel an seinen Brüdern
ist.
Und wir belassen aber die Zahlen erst mal so und wechseln einfach nur.
Was passiert jetzt? Ja? Jetzt geht es ja wieder
noch bei weder die nächste noch dieser Strecke.
Genau. Darf ich jetzt beim Blaue da die Zahlen entsprechend durch,
genau, können wir also da entsprechend zählen, bis wir bei null ankommen.
So, was kommt jetzt? Okay, jetzt haben wir
das gleich null. Es gibt also entsprechend weiter.
Also die ganze Geschichte mit diesen Zählern und mit diesen Anschriften
und so weiter, das fand ich nicht weiter wild.
Das kann man also so durchlaufen
Die Frage ist nur, wie kommen wir auf die Idee,
den Automaten so zu konstruieren und das dann so zu machen,
dass da Modlu sowas rauskommt, ja.
Aber das ist eine andere Geschichte, die ihr euch
genau überlegen könnt, wie ihr selber solche Automaten konstruiert,
die dann bestimmte Dinge erledigen mit diesen einfachen Operationen.
Es geht einfach nur darum, dass wir verschiedene einfache Operationen haben.
So, jetzt geht es hier wieder weiter mit den entsprechenden Schleifen
hier oben. Das zählen halt nur zweimal rum und dann
haben wir eben das Gleichheit hier vorne. Das heißt,
da haben wir uns irgendwas jetzt gemerkt und entsprechend können wir jetzt
hier unten runterzählen und jetzt zählen wir halt die schwarzen Zahlen.
Jetzt haben wir hier die gleiche Null erreicht und entsprechend sind
wir fertig
So, und was sehen wir dann da? Naja,
es kommt eine Zwei zu überraschen in aller Baus, ne?
Das sind Deperationen so, wo man so draufguckt und weiß,
was für das Ergebnis sein soll, denn ist das klar?
Wenn man erst mal auf die Automaten geschaut hätte,
wäre schon mal schwierig gewesen zu sagen, was tut er eigentlich genau?
Und sich das anzugucken. So,
im Wesentlichen war jetzt aber erst mal so,
dass wir jetzt hier die entsprechenden Zählerautomaten drin haben und wir hatten ja gesehen,
dass wenn wir so einen Zählerautomaten haben,
können wir sozusagen mit zwei Zählerautomaten Touring-Sachen darstellen.
Das war ein Beweis, der NFG1 dran war und
da musste man so ein bisschen gucken
Mindestens in der weiterführenden Literaturware drin. Ich glaube,
aber ansonsten war bestimmt auch kurz erwähnt worden in einer der Veranstaltungen.
Würde mich überraschen, wenn nicht. Die Verfahren,
wie das dann genau funktioniert und was man darauf macht und wie man darauf rechnet,
da muss man sich halt das nochmal anschauen.
Das ist sozusagen so eine Art Trickkiste, in die man da greifen kann.
Das ist einfach so ein klassischer Ergebnis. Entscheidet es aber
einfach, dass man mit diesen Zählergeschichten was macht.
Aber was war jetzt das, was ich in den Zähler
auf jeden Fall benötige? Das ist ja etwas,
was ich sozusagen in einem Netz nicht so direkt habe
Darauf, was uns bei den Letzten da eigentlich fehlt.
So, jetzt kann ich das Ganze ja auch mal versuchen,
zum Netz darzustellen. Dann sage ich, okay,
gut, ich habe hier acht und da drei und jetzt
kann ich das versuchen, sozusagen so darzustellen.
Und jetzt schalte ich da mal eben mal so durch und
mache das hier auch so. Ja, die Frage ist,
wie weit das dann so funktioniert an den Stellen,
was wir genau machen. Was wir nämlich sehen,
ist, dass da gar keine Beschriftungen dran sind,
wann das wie schaltet und wo das längst geht und so weiter und so fort.
Das heißt, uns fehlt sozusagen vor allem die Abprüfung auf
Null und auf die Werte, die da drin sind.
Und das ist genau das, was letztendlich immer wieder ein Problem bereitet.
So, jetzt die Frage, sind die Petrinetze Thuring mächtig?
Wenn ich jetzt hier so eine Erfrage habe,
nicht null und null und dann entsprechend hier was erhöhe oder erniedrige an den Stellen,
da ist genau dieser Test auf null, das entscheidende Element,
was man da da drin haben muss.
Na gut, jetzt kann ich ja mit Komplimentärstellen arbeiten.
Ich kann also hingehen und sagen, ja,
das sind zwei und den, wenn ich auf null teste,
nicht null, arbeite ich hier längs und bei null,
ja, dann muss ich nur gucken, ob da keiner mehr drin ist.
Das wäre jetzt sozusagen eine der Grundüberlegungen dabei
Könnt ihr aber so an die Transition erstmal nicht ranschreiben.
Weil wenn ich keine Kante hinzeichne und dann eine Null,
also ich schreibe eine Kante, eine Null,
dann ist ja eigentlich nicht da.
Also das ist genau das, was gerade nicht so richtig funktioniert an dieser Stelle.
So, und jetzt kommt auf die Idee und sagen,
jo, haben wir einen komplementären Platz?
Dann prüfen wir nur, ob das jetzt so hinkommt.
Und dann haben wir halt die entsprechenden Invarianten und sagen,
okay, das Chaos ist immer gleich zwei hier.
Und dann haben wir es ja so gebaut.
Und jetzt funktioniert das ja. Jetzt können wir auf Null
testen an der Stelle. Soweit wir da zwei haben,
dann geht das weiter an der Stelle
Damit hätten wir sozusagen auch einen Test und hätten quasi sichergestellt,
wenn da zwei drin sind,
dass wir drüben null drin sind an der Stelle.
So, und jetzt kommen wir zu der Frage,
sind gefärbte fehlnette Turing mächtig, ja oder nein?
Und mit diesen gleich zwei Abfragen. Und ob diese PT-Netze
eben Turing mächtig sind. Und das ist halt nicht der
Fall. So, warum sind gefärbte Netze Turing mächtig?
Wenn man einfach so immer auf Java guckt,
wenn ich da irgendwelche beliebigen Zahlen drin stehen haben kann,
kann ich genauso zählen wie mit meinen anderen Programmiersprachen,
die auch Turing mächtig sind
Also wenn ich da irgendeine Funktion dran habe und ich kann das
auch vor allen Dingen ranschreiben und auf ist gleich null prüfen,
dann kann ich das entsprechend mit einbauen.
Bei den PT-Netzen selbst kann ich nur so Tests auf diese Komplimentärstellen
machen, aber das ist dann gefixt und so weiter.
Und ich kann mich beliebig hochzählen, runter erzählen, das funktioniert nicht so gut.
Das ist also an der Stelle dann nicht möglich, dass man da tour mächtig wird. So,
die Möglichkeit, wie man das jetzt auch hinkriegen kann mit den PT-Netzen,
aber in der entsprechenden Kantenerweiterung, indem man eine Merikante einführt,
ist dann halt, dass man so eine Komplimentärkante macht und sagt,
okay, du, Du bist jetzt hier nur aktiviert,
wenn hier auf dieser Stelle null Marken drin sind,
dann kann ich sozusagen direkt immer abprüfen und ich könnte auch hier drüben noch irgendwas verwalten,
rauftun, runternehmen und so weiter und so fort mit aufbauen, ohne dass das mir irgendwie ein Kopfzerbrechen entsprechend bereitet.
Und das Ganze nimmt man im entsprechenden Hibido-Kante, die ihr auch haben könnt. Das Problem ist,
auch wenn ihr es im Ringe benutzt, ihr könnt es benutzen,
dann schaltet ihr aber in speziellen Simationsmodus ein,
dann schalten die Tensationen nicht mehr selbst lebenläufig,
weil das sozusagen die globale Eigenschaft ist und wir dann bestimmte Eigenschaften verlieren müssen in dem Simulator-Simulator.
Wir könnten das im Simulator immer noch Also wir können es ja auch machen,
wir können es ja auch benutzen, die Inhibitor-Sachen,
wir haben auch sonst Java-Programme, die wir ausführen.
Aber die Entscheidbarkeit von diesen Fragen,
die geht uns sozusagen verloren von den Modellen, die dahinterstehen.
Und für den Simulator ist es eben ein Problem,
wenn die zu sich selbst lebendläufig schalten können, dadurch,
dass sie jetzt global sicherstellen muss,
dass nicht parallel mehr noch was raufliegt, während ich sage,
da ist doch null drauf in meinem Schritt.
Darf ich nur einen nach der anderen schalten? Das ist letztendlich die Begründung,
warum die nicht mehr zu sich selbst lebendläufig schalten können.
Sonst könnte mich einer einen rauflegen und einen einen runternehmen.
Und die andere würde testen, ob es der Null
ist und dann wird es falschen Test ergeben.
Deswegen funktioniert das nicht
So, jetzt die Frage, sind diese,
mit den Bibliokanten, dann entsprechend Touring mächtig, ja,
und das kann man dann, wenn die entsprechenden Touringkanäle einbaut,
entsprechend auch so bauen und grüßen ein, ja.
So, dann hier nochmal die Übersicht sozusagen für diese Geschichten,
die Fitnesse selbst, also PT-Netzte sind erstmal nicht doing mächtig,
die Nebitronetze, ja, Netze mit endlichen Farbmengen,
nein, und mit beliebigen Farbmengen, ja,
was will ich damit jetzt aussagen?
Wer kann da was zu erzählen?
Wenn ein Ausblende hätte nicht funktioniert, weil das ist eine
andere Geschichte
Also, was im Hibütennetz habe ich einfach so postuliert,
da kann ich auf null testen, das geht.
Jetzt habe ich eben gerade gesagt, gefährdete Netze können doch
beliebig viel. Jetzt sage ich wieder, ja und nein
. Was will ich jetzt von euch? Ja,
das ist eine fröhliche Stermilie, Ression und sehr arm manchmal.
Du kannst ja Berlin nicht hochziehen. Ja. Zum Beispiel
. Ja, das ist schon gar nicht geil.
Ja. Genau. Wir brauchen, um das Turingband
sozusagen darstellen zu können,
genau diese beliebigen Farbmengen
Werden wir auch tun, möchte ich, wenn das endliche Farbmengen sind,
dann habe ich eine endliche Anzahl von Stellen, die ich hinmalen kann.
Das Netz wird zwar vielleicht recht groß, aber es ist endlich.
Und damit kann ich das wieder sozusagen einfangen und kann sozusagen dann eben nicht
die gleichen Dinge ausdrücken, wie bei den entsprechenden Toolmaschinen.
Gut, das kann jetzt einzeln durchgehen für die einzelnen Fragen,
sollte eigentlich einzeln eingeblendet werden.
Das war es dann erstmal soweit.
Gut, okay
In der Betracht der fortgeschrittenen Zeit, denke ich mal,
sind das weit durch.
Gibt es noch Fragen zu den Themen heute von eurer Seite?
Weil dann habe ich erstmal ein weißes Blatt sozusagen.
Sonst alles klar, soweit bei euch. Wo ist denn
die erste Vorlesung im neuen Jahr? Hast du die wieder
hier? Ja, die Vorlesungen sind wieder hier.
Also alle weiteren acht Veranstaltungen finden dann hier statt.
Und es sind noch acht, sechsmal kommt der Falk.
Dann bin ich dran, noch einmal mit den, wie gesagt,
Parallelen sortieren, genau. Und mit der letzten Veranstaltung,
wo dann auch kein Lecture-to-go stattfindet,
weil wir dann einfach nochmal ein bisschen üben und noch ein bisschen uns allgemein die Sachen nochmal querbeet unterhalten.
Ich kann ihm sagen, es war um 10 nach 12 anfangen sollen.
Mir ist egal. Ja, oder? Ist das überhaupt
noch wichtig? Ja. Was früher Schluss ist,
ist okay, gut, alles klar, ja.
Okay, alles klar. Ja, dann denke ich
mal, würde ich euch