Die Architektur und Idee hinter Heisenware #100

Hallo Leute zur Folge 100 von einfach komplex. Wir haben es 100 Folgen Schaftpoker ist das nicht cool? Ja, das ist ziemlich cool. Ja, bisschen ja, bisschen krass irgendwie und sehr besonders irgendwie die Folge runter zu machen jetzt irgendwie. Extrem besonders und vorweg bevor wir jetzt hier starten, erstmal ein fettes Dankeschön fürs Hören. Wir haben inzwischen fast 7000 Follower irgendwie auf diesem Podcast.

Ich weiß gar nicht täglich n paar 100 Abrufe von den Folgen und so und ja echt super Feedback. Also man sieht es an den Sternen und wir kriegen immer wieder fragen und wir kriegen inzwischen auch n paar Kundenanfragen durch den Podcast.

Also vielen Lieben Dank und macht gerne weiter so und hört uns immer ordentlich zu so und wir haben tatsächlich auch mal die Frage bekommen oder den Hinweis Hey mach doch mal was über heisenware ja das würde mich total interessieren, hat irgendein Hörer mal geschrieben und seitdem geisterte das so in unserem Kopf rum und. Jetzt wollen wir natürlich die Folge 100 Mal nutzen und n bisschen was über Heisenware

erzählen. Und Heisenware ist ja eigentlich unsere Firma und unser Produkt auch ein Low Code Application Builder. Die Heisenware erlaubt Personen sag ich mal mit technischem Background viel schneller und einfacher eigene Web Software zu bauen, Web Apps die sich eben auch besonders gut noch in bestehende Systeminfrastrukturen integrieren, also zum Beispiel im produzierenden Gewerbe oder

in anderen. Industrien, die ja lange gewachsen sind und wo viele Systeme mit der Zeit dazu gekommen sind, dort Software zu bauen, die für jedermann nachvollziehbar ist. Wie ist eigentlich diese Software gebaut worden und dann auch einfach änderbar und ohne IT Aufwand treibbar? Das ist mal so ganz kurz was was was was die heißen da macht und jetzt gucken wir uns das aber mal von der technischen Seite heute an, wir haben die Chance Burkhard Mal zwischen die Ohren zu gucken.

Zwischen die Ohren auf und liest da alles gewaschen. Und und so rauszufinden, was hat er sich eigentlich dabei gedacht? Weil ja. Die Idee kommt von Burkhard, die größte, der größte Teil der Umsetzung natürlich auch. Ich glaub, wir arbeiten da als Firma alle zusammen mit, aber das ist schon so, dass es burkhards Baby ist. Die heißen wir und die Software und daran wird uns heute teilhaben lassen, oder Burkhard

auf. Jeden Fall. Ja genau ja danke Gerald. Ja die Idee, das war meine Idee, um das klarzustellen, aber die Firma ohne Firma geht gar nichts, ja alleine bist du verloren, das Team braucht es um dann sowas auch in die Realität tatsächlich umzusetzen. Ja genau. Tatsächlich ist die Idee schon sehr alt, älter als die Firma und die Firma ist ja auch schon

gar nicht mehr so jung. Also ich glaube, das geht schon irgendwie 8 Jahre zurück, vielleicht geht es sogar mental in mir noch viel weiter zurück, weil ich immer schon irgendwie ja so n so n so n Schmerz empfunden hab, das hab ich auch schon mal bei VHPC gesagt, ungefähr was das für n Schmerz ist. Aber das wollen wir heute noch mal irgendwie gucken. Ja was was wir damit gelöst haben und warum und wieso und wie die ganze Architektur

aussieht, es ist. Es ist ne große Aufgabe, die komplette Heisenware als Architektur zu beschreiben und es ist sowieso noch ne größere Aufgabe, das im Podcast zu machen, ohne Bildchen und ohne alles.

Also Softwarearchitekturen gehen fast eigentlich nie ohne Diagramme und so, aber ich versuch es mal wieder irgendwie da durch mich da durch zu Wursteln und Gerrit wenn wenn ich anfange irgendwie n klaren Quatsch zu erzählen ja wie immer ne, dann hakst du noch mal nach und wollen das n bisschen verstehen ne? Ich hake auf jeden Fall nach.

Ich glaub, was das Spannende jetzt hier wird oder das schwierige auch für mich, ich hab ja die ganze Zeit n Bild vor Augen, ich weiß nämlich genau wie unsere Software aussieht, ich kenn natürlich da auch schon n bisschen was und so und ich benutz das ja auch viel und ich erklär das ja auch Kunden und zeig das und so und ich kann euch nur dazu einladen das auch zu tun wenn ihr da Lust habt ja das ist klar n bisschen Werbung aber ich meine wär ja vielleicht auch cool, wenn man sich bei uns

einfach mal n Account anlegt und n bisschen rumspielt und mal was ausprobiert was Kleines baut. Wir haben viele tolle Tutorials auch auf youtube und in unserer Dokumentation und vielleicht gibt diese ganze Folge dann noch n noch n bisschen mehr Sinn am Ende, aber das ist natürlich kein muss, ich glaube man kann auch so ne ganze Menge mitnehmen, es wird glaub ich auch darum gehen Denkprozesse eines Softwarearchitekten jetzt hier zu verstehen. Der der der, der gestern

Weihnachtsfeier hatte, glaub. Ich gestern Weihnachtsfeier hatte. Genau. So OK, na gut, aber ihr wisst was ich meine. Ja, also auf jeden Fall kann man hier schon auch n bisschen auch sowas lernen und es wird keine reine Werbeveranstaltung ne wir gucken uns auch eher die Technik an und weniger das Drumherum. Um diese Firma so also. Das soll es auch zur Einleitung gewesen sein. Ne, da wollen wir nicht so lange rumschwafeln. Hey Ho, Let's go.

Wie wie strukturieren wir das denn jetzt hier heute mal? Ja, ich hab mir natürlich n kleinen Plan gemacht. Sowas schüttel dich jetzt auch nicht aus der linken Hand. Mal gucken, wie meine Denkmuster heute funktionieren, aber ich fühl mich gerade ganz wach und fit.

Also insofern geht es los. Meine Idee war als Intro einmal kurz das zu erwähnen, was was das was so n überliegendes Ziel ist, noch viel überliegender als vielleicht jetzt unsere Low Code Plattform und so weiter und das ist nämlich was mich eigentlich immer genervt hat ist oder ne Idee die ich hatte es wär doch toll wenn man den ganzen existierenden Softwarecode, also ich sprech vom Quellcode den es ja gibt.

Wenn man den irgendwie noch n bisschen leichter zugänglich machen könnte, und zwar nicht nur für Softwareentwickler, sondern auch für Leute, die vielleicht keine Softwareentwickler sind, aber irgendwie nah dran.

Ja, weil da steckt ja so viel Power und so viel Know How drin und ich weiß, unsere Zuhörer wissen es vielleicht, wenn man es nicht weiß, aber man kann ja mal bei github gucken, das ist halt gigantisch, ja man sieht wie viel Power da drinne steckt in diesen Open Source Quellen. Daran, dass KI sehr gut ist im Coden, ne, das hat nämlich gelernt mit den mit diesen vielen quelloffenen, ja Stücken Code, die Tausende Probleme

lösen. Ne, es gibt ja halt für alles irgendwie schon existierenden Code. Ja, und die Schwierigkeit dabei ist das direkt den Mehrwert daraus direkt rauszuschöpfen ne, das ist nämlich nicht so einfach, jeder hat dann irgendwie n Stück Quellcode geschrieben und es passt nicht unbedingt zu dem das eine zu dem anderen. Die APIS sind nicht gleich, ich muss mich einarbeiten in den ganzen Kram.

Ich muss es irgendwie installieren, ich muss das Main tain und also ich muss halt quasi einen Sourcecode schreiben, ne und das ist halt nicht so einfach so, wenn man es halt aber noch nicht gemacht hat so, das ist das grundlegende Ding und dann hab ich mir überlegt, was kann denn also wie kann man und das ist sehr fundamental. Was ich jetzt sage, aber wie kann man im Prinzip diesem Softwareentwicklungsteil, was ich eigentlich machen müsste ne Abstraktion geben, die etwas drüber liegt?

Sodass ich mich nicht über diesen ganzen Scheiß befassen muss, ich aber doch direkten Zugriff hab auf diese, auf diese quelloffenen Open Source Bibliotheken, die es so gibt. Ja, und vielleicht auch auf Open Source, der noch entsteht, den ich dann dazufüge und so weiter ja ohne und es ist wichtig, ohne dass ich jetzt da irgendwie wieder ganz viel coden muss für und und irgendwelche Rapper schreiben muss und so weiter ja

denn. Ganz oft heißt ja, offenen Quellcode zu benutzen, dass ich wieder ganz viel eigenes Code

schreiben muss. Muss das irgendwie eindengeln und so weiter das ist die, die der Start, die Grunderkenntnis, die das Grundproblem von allem, was dann gefolgt ist, ja und was ich mir überlegt hab ist und und was man designen musste ist, was ist halt quasi auf welchem Level funktioniert diese Abstraktionsebene, das hab ich auch schon ganz oft gesagt, das definiert dann quasi auch sofort auf welchem Level ein loco Tool, wenn ich nämlich das n bisschen anfassbarer und Benutzbarer

machen will. Dann zieht es quasi fest, auf welchem Level die kleinsten Bauteile sag ich mal, wir sagen, wir sagen gerne Legosteine oder legoblöcke. So kann man sich auch vorstellen, also das das kleinste, die kleinste Entität die ich noch definieren und bedienen kann, wo ist die und was ist das?

Ja und das definiert das ja und und tatsächlich bleibt es eine Funktion im Sinne des Software Engineerings eine Software Funktion und tatsächlich bleibt es auch eine Klasse und eine Instanz ja und eine Funktion und so weiter ja. Und kurzum, man kann, ich hab das versucht, so n bisschen ja noch mal in andere Worte zu verpacken.

Man könnte fast sagen, was wir haben ist n digitaler Zwilling und das kennt das kennen so n Zuhörer ne von der von der Machining, da sagt man halt ne Maschine und da haben wir n digitalen Zwilling von der Maschine und was wir eigentlich machen, das ist jetzt n bisschen irre, aber das will ich gleich n bisschen länger noch drauf rumreiten ist wir haben so ne Art digitalen Zwilling einer Softwarefunktion geschrieben, ja und warum digitaler Zwilling weil auf einmal wird die

Funktion anfassbar anschaubar. Und auch grafisch repräsentiert in einer UI. Ja, und auch die Klassen und die Instanzen, die entstehen, was eigentlich so ja in so einer höheren Sphäre operationspattern sind in der Software, die kannst du. Normalerweise siehst du die nicht, du machst Instanzen, die Leben halt im RAM.

Ja die sind da gibt es dann halt n pointer während der Laufzeit, aber das das kann man alles nicht fühlen, nicht sehen, nicht anfassen, auch die Funktionen ne die sind halt irgendwie da und laufen im Hintergrund, machen irgendwas ja und hier haben wir

versucht. An der Stelle was rauszuholen, was ich jetzt mal für den Podcast, einen digitalen Zwilling einer Funktion oder einer Instanz nennen würde, um damit dann Code zu schreiben, tatsächlich also komplexe Dinge zu lösen, weil diese Funktion jetzt wieder genau die Sachen sein können, diese Open Source Bibliotheken, wovon ich gesagt hab, open zum Beispiel OPCUA, irgendwas komplexe Protokolle, alles schon fertig geschrieben, super getestet von Leuten und

jetzt wenn ich das aber als Funktion hier an ranholen kann, grafisch, ja dann kann ich sagen connect. Die Funktion connect zu einem OPCA Server nehm ich einfach und

guck was passiert. Und wenn ich connected bin, dann nehm ich ne andere Funktion und sage jetzt machst du das und das ja und das ist die fundamentale Idee und die gesamte Architektur die danach kommt ist quasi um diese fundamentale Idee zu stützen und bedienbar zu machen und ja auch mit n bisschen Spaß irgendwie und fun irgendwie dann ja den den quasi letztendlichen Nutzer ja zu ermöglichen quasi Code zu schreiben auf einer ganz neuen Ebene, ja. Das finde ich n ziemlich

spannendes Bild mit dem digitalen Zwilling.

Ich finde es passt gut so, ich weiß ja wie es aussieht bei uns im Produkt, also man könnte auch sagen n visuelles Abbild von von Code irgendwie n standardisiertes visuales Abbild, vor allem ja alle Funktionen, egal was sie tun, ob es jetzt n connect ist oder n read oder nen Combine oder n Merch oder whatever, die sind ja alle auf ein gleiches Aussehen gebracht bei uns also ein standardisiertes Abbild dieser dieser dieser Funktion ne. Und ich find die find die

Beschreibung ganz schön. Ja und? Wenn man das nämlich hat, und dann hat man also n digitaler Zwilling heißt ja dann auch an der Stelle ne Art Standardisierung. Ja, und das ist aber auch gar nicht, da muss ich auch noch mal drauf rumreiten, weil es ist ja auch nicht so, dass wir nur einen eine Programmiersprache haben, wir haben ja viele Programmiersprachen, es gibt C plus plus, es gibt Python, es gibt Java Script, es gibt Java und so weiter es gibt ja ganz, ganz viele, ja, und wenn ich

jetzt aber sage, ich hab einen digitalen Zwilling von der Funktion gemacht, dann mein ich aber auch, dass es völlig Wurst ist. Was die unterliegende echte Funktion ist die physikalische Funktion, ob man so sagen will, ja, ob die jetzt in Java geschrieben ist oder in C plus

plus mal egal. Ja, weil das wird abstrahiert und standardisiert, ja, und wenn man das dann hat, dann ermöglicht das quasi, und das ist wichtig, ganz easy ne Mixtur von verschiedenen Bibliotheken zu nutzen, denn das ist nämlich auch ne Wahrheit. Es gibt Open Source Tools, aber manche sind in Python geschrieben und sind wunderbar vor dem Number Crunching KI Machine Learning, ganz viel Python. Dann gibt es wunderbare Sachen, zum Beispiel PDF Handling oder so weiter weiß ich vielleicht in

No JS geschrieben und auf einmal kann ich die aber alle nehmen und auch zusammenbringen und ineinander verhaken und verketten ist völlig Wurst von welcher Technologie die herkommen. Ja und das ermöglicht gigantische neue Möglichkeiten ja dann weiter noch weil ich n digitalen Zwilling hab der quasi über n Netzwerk abstrahiert ist. Weil ich bin jetzt ja quasi in der in der UI, da kommen wir später noch zu wie das genau funktioniert. Hab ich auch ne Ortsunabhängigkeit drin?

Ne es ist völlig egal wo letztendlich die physikalische Funktion die ich da ausführt ja im Shopfloor in der Cloud, hier oder da direkt an der Maschine völlig egal. Ja und es bleibt komplett similes, weil ich nur den digitalen Zwilling in der Hand hab, der zeigt mir einfach immer an was was passiert. Die Argumente den den Rückgabewert und so kommen wir noch dazu, ist aber egal wo die Funktion ist ja. Die wird aber schon immer auf irgendeinem Computer ausgeführt oder sowas.

Ja. Aber du siehst an einer zentralen Stelle für dich sieht, also das interessiert dich gar nicht, wenn du bei uns das Produkt bedienst. Ja, du siehst tatsächlich immer, sieht immer gleich für dich aus und es wird aber genau da ausgeführt, wo es ausgeführt werden muss, um dein um dein Case zu erfüllen. Jetzt in dem Fall. Genau, genau.

Es gibt quasi immer ein, das kann ich ja mal sagen, es gibt immer ein Programm, was laufen muss, also die Funktion wird jetzt nicht, also sie liegt nicht als Pfeil da irgendwo und wir, wir hängen uns auch nicht an github dran oder sowas, sondern. Es ist schon ein Programm, was läuft und ein das Programm intern hat halt diese Funktion zur Verfügung und das Programm im Prinzip agiert erst, indem wir die Funktion von außen triggern.

Ne, das ist sehr anders, also es gibt jetzt 2 Sorten sag ich mal 2 grundsätzliche Sorten von Programmen, es gibt ja so Scripts die man kennt so da da sagt man los ja oder startet das und das fängt Halt von oben an und macht irgendwas und dann ist es fertig ja es hört dann auf zu funktionieren, ja es hat dann zum Beispiel. Das konvertiert zum Beispiel deine ganzen J. Pegs in PNGS oder Irgendsowas, die du da im Ordner drin hast. Ja dann rattelt das irgendwie. 2

Minuten ist das fertig. Ja, das ist nicht das wovon ich spreche, ja da sind auch Funktionen drin und so weiter aber die führen sich von alleine aus, es läuft Blackbox durch, ja ich spreche mehr von so Agenten das das Wort Agenten ist gar nicht falsch, das hat man jetzt ja hört man durch die KI und so weiter das sind quasi Lebewesen die also Programme die dauerhaft da sind die laufen 24 7 und können quasi von außen geschubst werden getriggert werden ja. Und wenn man das Halt machen

will in der in der Software, dann tut man das in dem, mit dem man irgendwie dafür sorgt, dass da drinne Funktionen ausgeführt werden, getriggert werden und dann macht das Halt schon irgendwas, das nämlich das, was in der Funktion implementiert

ist. Davon spreche ich ja genau und deswegen brauchen wir ja laufende Programme, aber wo du die startest, welchem Betriebssystem und so mit welcher Technologie, ob das ein T plus plus Programm ist oder ein Java Programm oder ein Note s Programm scheißegal. Ja du wirst halt diese Funktionen sehen sobald das

startet. Das ist unsere Technologie, die wir da haben, die die Funktionen werden quasi gebeamt, also der digitale Zwilling wird quasi gescannt aus den echten und dir zur Verfügung gestellt zur Ansicht und zum in die Hand nehmen als Legoblog für das Back and bauen in deinem Baukasten, den den, wie heißen wir lockhood Bilder.

Und das Spannende ist jetzt nur, das ist ja nicht nur zur Ansicht der digitale Zwilling, sondern indem du ihn dort befüllst mit input, Argumenten und mit irgendwie einem Trigger oder sowas Element konfigurierst du ja sogar.

Den Agenten zum Beispiel. Richtig, wenn wir jetzt so n bisschen über die Architektur sprechen, da will ich dann noch n Moment bleiben auf dem Level und dann haben wir jetzt ja verstanden, dass wir quasi eine eine so ne Art digitalen Zwilling einer Funktion haben und jetzt, wenn man jetzt als Softwarearchitekt dabei ist, jetzt muss man ja das n bisschen genauer definieren, ne, also wir haben so ne Art standardfunktion, ne und das sind natürlich sehr fundamentale

Software, fundamentale Dinge die man jetzt aus sich bedenken muss, denn das ist ja quasi. At the got, wie Software selber funktioniert. Ja und ich hab halt versucht für mich hab das macht das ja auch nicht seit gestern aus zu

extrahieren. Was sind die Kernelemente und zwar Cross den ganzen Technologien, die haben ja ihre Unterschiedlichkeiten. Ja es ist schon so, dass Python Funktionen anders sind und es vielleicht andere Ausprägungen gibt als NC plus Plus und so, das kann man nicht wegdiskutieren, aber was ist das kleinste gemeinsame Vielfache unter diesen unter dem Begriff Funktion, ja was gibt es da mit

dem ich quasi. 99,9% abdecken kann ja und zufrieden bin, damit es halt n generischer standardisierter Block, mit dem Ich arbeiten kann, damit man später keinen keine Roadblocks hat beim Bauen von von komplexen Applikationen. Ja und wenn man sich das anguckt, da kann man so n paar

Schlüsse schließen. Ja also ich hab die ebenfalls geschlossen und ich hab gesagt es gibt erstmal 4 Kategorien von Funktionen 4 Typen von Funktionationen wenn du die 4 hast, dann kannst du 99,9% erschlagen von den Sachen die du brauchst. Ja und welche Typen gibt es? Das gehen wir jetzt mal durch. Und die diese Typen der Funktion haben ganz eng was damit zu tun, was objektorientierte

Programmierung ist. Was ja ein Pattern ist, was es schon sehr lange in der Softwareentwicklung gibt und was sich durchgesetzt hat und was gekommen ist, um zu bleiben.

Ja und was quasi auch eingebaut ist in diese Open Source Bibliotheken, die bestehen nämlich aus Klassen, ne, das muss man einmal wissen, das hatten wir auch schon mal ne Folge ich, wir nehmen das heute nicht im Detail auseinander, Klassen sind quasi Blaupausen. Und können wiederverwendet Instanziert werden, halten ihren eigenen State.

Das sind dann die Instanzen der Klassen, ja, also das, das muss man auf dem Zettel haben, wenn man das auf dem Zettel hat, dann gibt es 4 Kategorien Funktionen, nämlich die Konstruktorfunktionen, das ist ne sehr spezielle Funktion, das ist quasi die Funktion in der Blaupause der Klasse, die sagt Mach mal bitte eine neue Instanz von mir ja, also mit einem State und dann gibt es da analog dazu die Destruktorfunktion.

Tatsächlich ist das nicht so, dass die, dass es die explizit gibt, in allen Programmiersprachen, ich sag mal aus dem javascript gibt es zum Beispiel keine Destruktorfunktion ja, aber ich sag nachher, warum das wichtig ist in C plus Plus gibt es die zum Beispiel, aber die macht das Gegenteil, ja, also die Konstruktorfunktion sind da da, die Ruf ich auf und dann entsteht eine neue Instanz und bei der Destruktorfunktion dann sag ich lösch diese Instanz

macht macht es unglaublich. Bei uns heißen die immer create und delete. Genau, gerät richtig.

Ja, genau das ist das, was ihr parallel anguckt, jetzt richtig, und das ist das, was wir dann in der EUI machen, wenn wir sagen, OK, wir machen den digitalen Zwilling unserer Funktion, dann heißt das, dann gibt es ja auch wieder zig Namen und wir haben einfach gesagt, Create und delete sind halt irgendwie ja verständliche Namen dafür, dass man halt irgendwie ne Instanz kreiert oder ne Instanz slash da genau so und dann gibt es die

statischen Funktionen, die muss man auch einmal verstehen, die statischen Funktionen agieren. Auf Klassenebene, das heißt, die sind immer richtig, die haben quasi keinen unterliegenden

State, wie man so schön sagt. Ja so so, statische Funktion könnte zum Beispiel sein, ich, ich sag mal was ich hab ne hab ich weil ich hab ich gerade im Kopf weil ich es gerade gemacht hab, ich hab ne Klasse die zum Beispiel von so einem Raspberry Pi diese GPIO Pins ausliest oder irgendsowas ja da könnte ne statische Funktion sein kann ich überhaupt zugreifen auf so NGPIO in dieser Klasse? Ja ich hab ich hab so ne GPIO Klasse. Und dann hab ich ne statische

Funktion, is accessible. Ja und die sagt einfach nur ja oder nein ja, also kann ich gerade auf diese Hardware zugreifen überhaupt, ja da muss ich jetzt nicht eine bestimmte einen bestimmten Instanz von so einem PIN in der Hand haben, sondern das ist ja ne grundsätzliche Information war für diese ganze GPIO pin Klasse, ja die die da funktioniert ja aber wenn ich zum Beispiel und jetzt kommt der dritte Typ der der vierte Typ der Funktion eine Instanzfunktion und zwar hab ich

die Klasse GPIO pin. Und ich sage, jetzt mach mir eine Instanz für pin 26. Ich hab da ja relativ viele Pins. Ja und jetzt sage ich, OK, ich bin quasi solange ich lebe auf diesen PIN 26 gebunden und darauf gibt es jetzt die Funktion Read und write ja und wenn ich read mache und da kommt halt 1 raus, dann heißt es PIN 26 hat 3,3 Volt Anliegen und ist gerade true das ist eine Memberfunktion oder Instanzfunktion die ist das deswegen weil sie wissen muss, dass die PIN 26 ist.

Das ist Teil Ihres Days ja. Und dass die PIN 26 ist, konnte ich ihr zum Beispiel im Konstruktor sagen. Es führt mich gleich dann zu was anderem, es führt mich nämlich dazu, was wie Funktionen überhaupt grundsätzlich aufgebaut sind, Funktionen haben nämlich Argumente, ja, aber jetzt trink ich kurz n Schluck Kaffee, Gerrit kannst ja auch noch mal. Vielleicht machen wir mal kurz ne Atempause und dann geht es gleich weiter was Funktionen.

Innerlich sind ich brauch hier gar nichts zu sagen, ja, kannst auch mal weitermachen. OK, also das heißt, du bist soweit schon noch mitgekommen. Das ist gut. Ich, ich komm wie gesagt, ich komme mit. Ja, du hast auch den Vorteil, weil du es im Kopf hast, glaub ich, du siehst was ich erzähle, quasi in unserem als Logo Blog

quasi vor dir. Es ist ja genau wie wir es anfangs gesagt haben, es ist ja nicht nur wahr für heisenwer, du erklärst ja hier quasi OOP noch mal oder Teile dessen auf jeden Fall genau, von daher ist das total relevant für alle. Ja, das ist richtig. Genau.

Noch noch sind wir gar nicht heisenwer, speziell das stimmt ja, also ich fass noch mal zusammen, wir haben die Konstruktorfunktion, die Destruktorfunktion, die statische Funktion. Und dann haben wir ja die Instanzfunktion. Diese 4 haben wir und müssen die auseinanderhalten, das tun wir auch in unserer Local Plattform ne so und was haben jetzt Funktionen noch mal gemeinsam, wo können wir jetzt weiter standardisieren?

Ne wenn wir uns Funktionen angucken ja also jede Funktion hat keins 1 oder mehrere Argumente wie man so schön sagt, das sind quasi die Eingabeposition für die Funktion. Ja das kann ich mir ausdenken wenn ich ne Funktion schreibe, ja. Zum Beispiel die Funktion, die ich gerade gesagt hab. Die Static Funktion ist accessible. Ist diese Hardware überhaupt sind die GPOI Pins überhaupt grundsätzlich accessible? Die hat gar kein Argument.

Ja weil ich ich frag ist accessible Klammer auf Klammer zu ich geb dir nichts mit ja und da kommt schon n wert raus ja wenn ich zum Beispiel sage create also als Konstruktorfunktion jetzt eine Instanz von dem pin, dann würde ich dir zum Beispiel mitgeben welchen pin denn welche Nummer create und dann sag ich 26 ja weil ich pin 26 kreieren will.

Dann hat diese create Funktion genau ein Argument ja eines bestimmten Datentyps, in diesem Falle 26 eine Nummer, ja ein integer, ganz genau aber eine Number im im großen Sprecher. Also führt mich zum zweiten Punkt, jede Funktion hat keine 1 oder mehrere Argumente und jedes Argument und das kann man auch so sagen, muss von einem bestimmten Datentyp sein. Von diesen Datentypen gibt es jetzt verschiedene.

Grundsätzlich wenn du dir jetzt alle Programmiersprachen anguckst wirst du irre, dann haben wir wahrscheinlich ne Liste von 70 Datentypen. Und hier muss man jetzt wieder gucken, wie abstrahiere ich das, um trotzdem alles machen zu

können. Ja, da haben, da hat uns Jason was vorgemacht, da haben wir geshealt, da kommen wir nachher noch drauf, aber man kommt zurecht, wenn man die Datentypen Wahrheitswert, Bulien, Textwert, String Nummer number array, also Abfolgen von Elementen, die jetzt bulien, String oder number sein können oder array selber und Objekt. Diese Key Value Sachen. Ja ich geh da nicht drauf ein.

Wir haben ne Folge wer wer noch mal genau gucken will wie das alles so geht, möge sich die Folge über Jason zum Beispiel anhören. So und wenn wir das haben, dann sind wir schon mal wieder n Stück weiter.

Also wir haben verstanden wir haben Argumente die haben ne Reihenfolge und die ist halt n Datentyp und jetzt muss man einmal aufpassen jetzt gibt es einen besonderen Vogel als als Datentyp, den muss man auch besonders behandeln und es gibt nämlich ne Ausnahme. Es gibt tatsächlich den Datentyp in einem Argument der ist Funktion.

Ist jetzt n bisschen irre, ne Gerrit hat auch gerade die Augenrauen zusammengezogen, das nennt sich dann Callback in der in der Software und das muss man auch wenn man Junior Entwickler ist und das erste Mal sieht, das muss man erst mal verdauen, das ist nämlich das ist einfach, da kriegt man erst mal kurz ne Blockade im Gehirn, was soll das?

Ich versuch das kurz zu. Erklären also, man kann quasi in eine Funktion eine andere Reingeben als Argument, die wird dann von der von der Funktion, die eigentlich ausführt mehr oder weniger registriert gespeichert. Und wenn dann irgendwie der Prozess.

Und meistens ist es gekoppelt an der Instanz, wenn der meint, ich müsste jetzt irgendwie was benachrichtigen, dafür ist es nämlich da, deswegen heißt es callback, ich ruf dich zurück, ja dann kann halt diese Funktion, die hier reingegeben werden, aufgerufen werden durch die Instanz als Seiteneffekt, aber auch irgendwann, ja, es ist nicht garantiert, dass das jetzt quasi aufgerufen wird, während die eigentliche Funktion läuft, sondern irgendwann, ja, das muss man einmal verstanden haben,

weil das ist wie Software Publish und Subscribe löst. Wir haben ja auch in der Software die verschiedenen Kommunikationspattern. Ja direktes Ausführen und n Ergebnis erwarten und so weiter und ich kann aber auch in Software sagen Alter gib mir halt mal ne Nachricht wenn irgendwas passiert ist. Ja also wir kennen das aus dem Leben, für weiß ich nicht, ich nehm noch mal das Beispiel GPIO

pin was wir gerade hatten. Ja da will ich vielleicht gar nicht immer fragen, was ist denn der Wert Grad am pin sondern ich will ne Nachricht bekommen wenn das 1 ist oder irgend so was oder wenn es sich ändert zum Beispiel ja on change ja. So und in der in der Software Low Level würde man jetzt quasi typischerweise eine Funktion machen, die einen als Argument, eine andere Funktion erwartet, die ich dann aufrufen kann, der ich dann sage, jetzt hat sich es geändert auf 1.

Das glaube ich war n bisschen komplex, aber jetzt haben wir dann verstanden, wir haben die Argumente, die verschiedenen Datentypen und diesen einen speziellen der quasi n callback ist und den haben wir auch bei uns in der in der Local Plattform. Und da wird gar nicht so viel Brimborium gemacht. Das sieht spezieller aus, weil das sieht aus, wieso n Output und da da taucht dann einfach der Wert auf, der zurückgegeben wird, irgendwann nachdem quasi dieser Callback registriert wurde.

Ja, das ist aber was was was immer so n bisschen Schwierigkeiten bereitet beim Nachdenken. Ich würde fast sagen, wir müssen es fast eher Visual Coding Plattform oder sowas nennen. Ja weil. Ja. Im Grunde genommen ist es Coding, nur du kannst es halt jederzeit sehen und du weißt genau was da passiert, das stimmt oder Visual Development oder wie auch immer. Ist so wichtig, aber ne um das noch mal zu übertragen auf das was da eigentlich bei uns

passiert. Wir machen kurz das Intermetro Gerrit weil das ist nämlich n cooler Einwand. Es gibt es gibt tatsächlich Visual Programming und da müssen wir uns aber auch n bisschen von separieren, weil jetzt kommt es drauf an ob du versuchst das was in der Funktions in dem Funktionskern man sagt auch in der im Funktionsblock quasi implementiert ist, zu coden, also ob du den Inhalt einer Funktion locoden möchtest oder ob du nur das Ausführen von

Funktionen locoden möchtest. Ist n großer Unterschied zwischen unserer Plattform und anderen.

Es gibt nämlich ganz viel Plattform, die kennt ihr ja auch als Nutzer, wo man so ne Art flussdiagramme macht, wo man dann auch IF Else Konditionen hat und so weiter und jetzt ist man eher dabei, quasi den Inhalt einer Funktion zu definieren und grafisch zu programmieren, das machen wir genau nicht, sondern wir nehmen fertige Funktionen, die schon fertig implementiert wurden von irgendjemanden mit viel Know How, nämlich genau diese Open Source Dinger ist alles cool.

Ja und was wir nur noch machen und das ist nämlich n Abstraktionslevel höher. Wir gucken uns diese Funktion an und können die Argumente konfigurieren und mit n rückgabewerten Art arbeiten. Mach ich gleich weiter.

Wir versuchen aber nicht quasi selber ne Funktion zu bauen auf dem Level. Ja da sind wir ein Stück höher um das mal ganz klar, es passte gerade so schön ne auf der Spur zu sagen also es ist ne Art Visual Coating ja aber wir coden nicht Inhalte von Funktionen, sondern wir wir coden indem wir Funktionen aneinanderkabeln und aufrufen ne.

Gut, dann machen wir weiter was. Wir hatten jetzt gesagt, die Argumente ist, das ist ne Einheitlichkeit bei Funktionen und was ist noch Standard ist Funktion kann man immer ausführen, das ist auch wichtig, dabei werden dann die Argumente die ich reingegeben hab verarbeitet und in der Funktion je nachdem was da halt drinne passiert entstehen Seiteneffekte, das ist dann halt dokumentiert, muss man halt gucken was macht der hat zum Beispiel ne Verbindung mit

aufgebaut zu einem TCP Server oder irgendwas ja wenn es connected ja das sind halt quasi seiteneffekte die ausgeführt werden und. Ich kriege eigentlich immer nen Rückgabewert zurück. Das ist auch wichtig. Ja, also ich pack was rein, ich führ es aus und ich bekomme was zurück. Ja Punkt so ist es ja und der Rückgabewert ist halt auch wieder nen Datentyp.

Man kann sich vorstellen wie ein einziges Argument, ein einziger Rückgabewert exakt wieder von den von den Sorten Bulien Number, String Array oder Object so einfach so gut, ja und jetzt Achtung hier gibt es jetzt in dem Falle 2 spezialkollegen 2 sonderbare. Kollegen, die da neben den normalen Vorkommen können. Und das ist, wenn man sich jetzt ganz abstrakt betrachtet, eine Instanz selber als rückgabewert.

Gerrit Jetzt quizfrage fies, aber ich glaube du hast es drauf, ich glaub in seinen Augen seh ich, dass du, dass du verstehst, welche Funktion wird vielleicht wohl ne Instanz als Rückgabewert haben von den 4 die ich habe. Vermutlich der Konstruktor. Ja, ganz genau und auch nur deswegen qualifiziert es den als Kategorie für sich. Ja, weil die ist sehr speziell, weil der Konstruktor.

Hat zwar Argumente ganz normal, aber der Rückgabewert ist quasi ne Instanz, also ein Zeiger auf eine neu geschaffene Instanz einer Klasse. Ja und genau den muss man speziell behandeln, das ist ein spezieller Kollege, bei uns sieht man quasi die Instanz, das ist schön, wenn man bei uns auch die Instanz sehen und halten kann, ne die wird quasi angezeigt als Punkt. Normalerweise sieht man die

nicht, die existiert nur im RAM. Wenn wenn ne Software läuft ja aber bei uns kann man die halt sehen, man kann sehen welche Funktionen sind da, man kann auch die Konfiguration der Instanz auslesen indem man die Funktion darauf. Aufruft und halt auch die Rückgabewerte sich visualisiert und anschaut. Ja, normalerweise kann man das halt einfach nicht n Code wir können, wir haben quasi ein Fenster in den in diesen in diese Blackbox von Code geschaffen, wenn man so will, ja.

Ja, und vielleicht zur Orientierung, wie das bei uns aussieht. Das ist wieso n baumdiagramm glaub ich sagt man ne, also wir haben auf der obersten Ebene die die Klasse meinetwegen MQTT Client oder so und da drinne haben wir dann den Konstruktor und den D struktor also created lead. Und da drunter existieren dann die jeweiligen Instanzen, die schon geschaffen sind oder die

gerade vorhanden sind. Und die kann man wieder ausklappen und da drin sind die ganzen Instanzfunktionen oder memberfunktionen ne. Richtig. Und die statischen Funktionen, die hängen direkt unter der Klasse, weil die nämlich klassenkontext haben. Ne das weil die kannst du ja ausrufen, ohne dass du ne

Instanz brauchst. Ja und dann gibt es alle Mischungen von denen es gibt, manche Klassen, die haben nur statische Funktionen, es gibt Klassen, die haben gar keine statische Funktion und haben nur instanzfunktionen und und und. Aber das ist egal, weil Gerrit sagt genau richtig. Kann man halt ausklappen und man sieht dann schon was los ist. So, jetzt hatte ich gesagt, es gibt 2 sonderbare Rückgabewerte, bei dem Rückgaben und das zweite ist der ist sehr sonderbar und

den gibt es schon nicht immer. Das ist aber im modernen Webwelt sehr sehr wichtig. Es gibt den Rückgabewert Versprechen, der heißt in Englisch Promis und da muss ich irgend n ganz bisschen erklären, das ist normaler und das hat was mit der Asynchronität zu tun von Funktionen ja, ganz oft ist es so, dass wir Funktionen haben, die ne Weile brauchen um das zu

tun was sie tun sollen. Das klassische immer Beispiel ist SQL Anfrage zum Beispiel. Ja du sagst Halt, hol mir aus der Datenbank dies und jenes raus.

Ja und das kann halt dauern, je nachdem wie groß die Datenbank ist und je nachdem was du da rausholen möchtest und so ja es kann dauern, kann halt auch schon ne Millisekunde schon lang ja für Software und wenn man nicht möchte, dass man wenn man weiß, dass die Funktion etwas länger dauert, dann möchtest du nicht, dann möchtest du nicht den Rückgabewert. Also du möchtest nicht warten bis die fertig ist und alles anhalten dann ist das ist jetzt wichtig.

Normalerweise laufen Funktionen der Reihe nach, also wenn du wenn du im synchronen ne das hat asynchron und synchron und in einer synchronen Welt bist laufen Funktionen immer seriell immer nacheinander. Ja du kannst die zwar verketten und die kann auch automatisch dich aufrufen und so weiter aber das passiert in einer dedizierten Reihenfolge, nämlich nacheinander. Wenn wir synchron programmieren würden wollen in in der Webwelt, wenn wir da wäre vorbei.

Ja, da kannst du kein Internet machen. Ja, also das ist alles gleichzeitig, du hast ganz viele Nutzerklicks und sowas, das heißt, alles ist im Prinzip asynchron, was heißt das, Funktionen können potenziell gleichzeitig laufen und man wartet nicht mehr bis irgendwas

fertig ist. Ja man muss aber wissen wann es fertig ist, damit man weiß, ich muss ja irgendwann mal den Wert in die Hand nehmen, ich will das haben, was aus der Datenbank hat oder ich will den Fehler in die Hand haben können, ja wenn es nicht geklappt hat und dann kriegt man ein Versprechen zurück und das Versprechen ist ja, du hast die Funktion ausgeführt, ist cool ja hier und ich geb dir als Rückgabewert n versprechen in die Hand das sich auflösen wird, entweder in den

in das Ergebnis was du eigentlich erwartest oder in einen Fehler, weil ich es nicht konnte, aber zu irgendeiner Zeit in der Zukunft und jetzt will ich nicht rumdüdeln an das das ist das sehr, das ist das komplexeste Thema und die schwierigste Schwierigkeit für unseren digitalen Funktionszwilling weil diese Asynchronizität ist sehr krass unterschiedlich organisiert in den verschiedenen Programmiersprachen, ne sehr schön organisiert, zum Beispiel

in in in Javascript mit Asyncle Wait ganz modern ne. Also das kann auch C. Sharp nicht so schön organisiert in C plus plus so na ja wie auch immer haben es wir aber geschafft Architekturell und da sprech ich jetzt, das ist Detailkrams vom VRBC Protokoll, das löst das, aber wir können quasi auch standardmäßig mit solchen Versprechen umgehen.

Und in unser UI, das merkt man gar nicht, wird einfach ordentlich gewartet und irgendwann löst sich das Versprechen auf und das ist n großer Unterschied dazu, dass ne

Funktion ne lang ausführt. Ja das Gerrit, Du kennst das, vielleicht war dir das nicht so klar, aber ich sag das mal, manchmal führt ne Funktion lange aus und dann wird ja der der der wir haben so ne LED quasi an der Funktion, die ist normalerweise grün wenn es wenn es der gut geht der Funktion wenn du die aber klickst und die braucht lange und dann wird die irgendwann blau ich glaub noch 2 Sekunden ja die wird aber nur

blau. Wenn die tatsächlich lange ausführt und der Rückgabewert nicht kommt, wenn die n versprechen geliefert hat, dann ist die gleich. Wieder ist die Grünen, dann kann das aber trotzdem, dann kann das 5 oder 10 Sekunden dauern, dann kommt der Halt irgendwann der Wert, ja das ist nämlich das genau das Ding bei der Asynchronizität sagst du OK ich hab ich hab n versprechen gekriegt, das hat also die Funktion hat schon mitgekriegt, dass ich das haben will und irgendwann löst sich das schon

auf. Ja das ist der Punkt.

So, und jetzt sind wir fast fertig mit der standardisierten Funktion. Jetzt ist es so, dass ich jetzt, hab ich gesagt, immer rückgabewert gibt n Rückgabewert gibt n rückgabewert stimmt nicht, klassischerweise kann ne Funktion auch keinen Rückgabewert geben und dann muss sie einen Fehler schmeißen und das ist schon wieder n kleinstes gemeinsames Vielfache. Das ist in allen Programmiertechnologien so ja also wenn kein Rückgabewert kommen kann, weil es kann passieren ich ich ich sag zum

Beispiel lies Pfeil XY aber Pfeil XY gibt es einfach verdammt noch mal nicht auf der Platte ja nein dann kann ich ja den Rückgabewert nicht haben auf dem Pfeilhändel ja das macht ja keinen Sinn, ja. Also bekommt man einen Fehler.

Ja und der Fehler ist halt quasi der ja, das ist halt der fehlerpfad Funktion konnte nicht ausgeführt werden und so n Fehler hat immer ne Information was ist warum ja warum hat es nicht funktioniert ja in in in der Informatik spricht man auch Exception ja so also das muss man quasi auch noch können im digitalen Zwilling grundsätzlich exceptions zu fangen.

Ja und dann gibt es als letztes gemeinsames Vielfaches hat ne Funktion muss nicht aber hat zu haben würde ich sagen ne Dokumentation ne. Also tatsächlich ist es so, dass im Source Code, das kennen alle, die n bisschen Code schon mal geschrieben haben, die sie es nicht kennen, den sag ich jetzt so, man schreibt halt nicht nur den Quelltext hin, sondern typischerweise schreibt man halt mit irgendwie was weiß ich noch mal so 2 schräge Striche oder mal n Raute oder Irgendsowas

gibt je nach Programmiersprache quasi n Zeichen dafür, dass ich jetzt n Kommentar schreibe, ja und dass du sogar das ist noch besser organisiert, wenn du ordentlichen Code schreibst, dann gibt es bestimmte Arten und weisen, das sind quasi Policies wie du diese Kommentare zu schreiben hast, nämlich zum Beispiel als JS Stock, das ist n ganz klassisches Ding.

Und da beschreibst du quasi, was deine Funktion ist, was die Macht und welche Argumente sie erwartet und von welchem Datentyp die Argumente sind und so weiter ja, zum Beispiel Funktion Connect zu einer Datenbank, da könntest du eine ein Argument haben, wo du sagst welchen Dialekt denn ja Post crease I Sequel und so weiter das musst du dann da eingeben.

Ja und dann würde quasi in der Dokumentation stehen Pass auf, hier musst du als dringend eingeben den Dialekt und übrigens hast du zur Auswahl nur. My Secret Postgress Maria DB und was weiß ich, schieß mich tot.

Ja, und das ist guter Ton, dass man sowas macht für die, für die, für die Funktion, die ja auch benutzt werden dürfen nach außen ne, und jetzt kann man sich schon vorstellen, mit diesem guten Ton kann man sehr viel machen, wenn man das jetzt auch visualisiert, ja weil wir haben quasi eine Dokumentation at the Single Source of Truth direkt bei der Funktion, ja und wenn wir die abholen, das tun wir. Direkt aus dem Code mit der Dokumentation.

Dann ist alles klar und der User weiß auch, sonst wisst ihr das nämlich nicht, müsste man das Raten vom Funktionsnamen ja, jetzt weiß der User aber ah in Argument 1 muss ich wohl irgendwie den Dialekt von der scheiß Datenbank eingeben ne und wenn das sogar so genau geschrieben ist, dass man dass da drin steht My SQL und so weiter und sofort, dann kann man sich auch vorstellen, kann ich mir im Web auch n dropdown zusammenbauen, dynamisch hochgenerisch ja.

Das machen wir auch, sind wir vorweg.

Wir bauen quasi aus der Dokumentation, die wir scannen, aus diesen ganz verschiedenen Technologien, und Python wird zum Beispiel ganz anders dokumentiert, da ist die Funktionsdokumentation Teil der Programmiersprache, das ist richtig cool an der Stelle, das ist der Here Text, aber das ist auch egal, das machen wir, ist unsere, das ist quasi das, was wir gearbeitet haben an Software, wir vereinheitlichen das und Ende des Tages wird da so n jsons Schema sogar

rausgebaut, das ist wieder ne ne Standard Web Datenstruktur ist normiert ist n Standard. Und dann gibt es, weil es n Standard ist, Tools, die können halt aus dem Json scemer, das ist Scemer ist in der Anleitung was kann ich konfigurieren, die bauen dir daraus ne webform dynamisch n dropdown und alles ja das passiert bei uns und deswegen kann man jetzt in der letzten Version 89 kann man einfach weil so n Argument auf n Knopf drücken, man bekommt quasi eine eine automatisch generierte

Form die sich tatsächlich automatisch aus der Dokumentation der Funktion die irgendwo lag ingeneriert hat. Ja und das ist eigentlich ganz cool. Weil dann wird es halt richtig nutzbar. Ja, dann kann ich die einfach aufrufen.

Ja, mega cool. Das gilt für alle, die Funktionen, die sag ich mal, in den originalen Open Source Libraries gut dokumentiert sind oder in denen, die du vielleicht selber gebaut hast oder n anderer Entwickler bei uns im Team oder so, das gibt es ja durchaus auch denk ich mal ne ja und was ist wenn nicht? Ja, dann steht da nichts. Ja dann OK, ja ist schwieriger und dann haben wir ja immer noch unsere Dokumentation dox Punkt, da heißen wir.

Nee, Spaß beiseite. Also wenn wir, wenn wir von Heisenberg quasi unsere eingebauten Module haben, und es gibt keine gute Dokumentation oder sie ist wild oder irgendsowas oder ich will gar nicht alles exposen, sag ich mal, dann schreibe ich meistens ne ganz dünne Schicht drüber.

Das ist aber auch n Klassiker. Also ich hab am Anfang gesagt, wir wollen nicht so viel Action haben, aber dann dann schreibe ich halt einfach nur einen Rapper, wo ich quasi die Funktion des Open Source Bibliothek einfach noch mal rappe, da hat quasi jede Funktion einen einzigen Buddy. Und zwar den Aufruf der Open Source Funktion und ich mach das eigentlich nur um ne saubere Dokumentation dran zu kleben.

Ja, ich adaptiere quasi die Open Source Funktion und schreib dann oft sehr sauberen Days Dock Kommentar, damit unsere Nutzer verstehen was da los ist. Ja genau also das mach ich da an der Stelle, weil ich auch nicht später irgendwo das einfügen will, das ist dann die Arbeit die wir machen müssen, wenn wenn die Open Source Bibliothek das das mach ich aber tatsächlich meistens um das schön zu strukturieren damit alles

einheitlich ist. Ja wäre aber nicht unbedingt notwendig, ja wenn das schon von vornherein da ist. Und all das, was du jetzt sagst. Deshalb sind wir extrem schnell oder oder relativ schnell. Neue Konnektoren zum Beispiel oder sowas einfach in die heißen Wir aufzunehmen, wollen wir es einfach dranhängen und und das so benutzen, wie es da ist.

Von der Funktion selber bis hin zum Kommentar der Funktion oder als Doku der Funktion. Ja, da triffst du Nagel auf dem Kopf, weil das ist also mehr flexibel und more extendable kannst du eine Architektur nicht gestalten?

Ja, weil. Wir können halt, ohne dass wir unser unser Framework anfassen müssen, ohne dass wir es noch mal testen müssen, können wir halt einfach neue Funktionalität hinzukleben, genauso wie du es gesagt hast, indem wir einfach neuen Code registrieren, der dann als Baustein auftaucht und da hat ja erst mal noch nichts gemacht.

Ja und ob der dann in sich funktioniert oder nicht, das ist ne andere Frage, aber unsere Plattform, die stört das nicht, die die hat einfach nur mehr Power, mehr Funktionalität da, das ist halt Key. Ja dadurch sind wir unglaublich schnell, ja. Und kleiner Teaser darüber sprechen wir heute nicht zu lange, aber wir wissen ja alle, KI kann sehr gut coden und vor allen Dingen, wenn es kleine Blöckchen sind, ja, und das kommt jetzt auch nächstes Jahr,

könnte könnte schon gespannt sein, wir werden KI quasi zum Coden animieren von genau diesen Funktionen und und die kann auch gut dokumentieren und so weiter und dann wird unser Produkt very extendable ja also wir können dann diese Lego blöckchen können wir dann. In höchster Geschwindigkeit quasi generieren, weil KI sie schreibt. Es wird sofort registriert, ploppt auf in dem, was Gerrit gesagt hat, in dieser Seitenansicht mit dem Treview und wird sofort benutzbar. Ja und?

Wenn du sagst, wir können das, dann heißt das, unsere Nutzer können. Unsere Nutzer können das genau. Ja, unsere Nutzer können dann einfach Wipe coden. Ja, innerhalb von unserem, unserem Produkt und jetzt und das das sag ich nur einmal, weil weil sonst komm ich in Schwingung, wie ich das so cool finde, denn. Das größte Problem, was wir mit dem Vipe Code haben im Moment ist, dass MKI es noch noch nicht beherrscht, große Komplexität

abzubilden. Ja, sie ist hervorragend da drinne, spezifische Prompts durch zu implementieren, zu sagen macht mir die Funktion, die genau das Macht, oder haben wir ne Klasse von mir aus sogar die das und das kann ne und und die Komplexität, aber ja das machen wir genau, indem wir Funktionen ineinander in Beziehung setzen, später mit unserem Loco oder wir machen ja Flows und Events und Komplexität mit User und Mandantenfähigkeit alles schon fertig bei uns ja.

Und das ist halt hier. Können wir die KI voll einsähmen, dass wir, obwohl wir Vibe Coden können, wir Enterprise Quality Software kreieren, weil wir diese legoblöcke können wir nämlich sehr mehr internen und und stabilisieren und reviewen und den Rest, da wissen wir ja, dass es funktioniert, das ist der Quality Check Bass.

Ja, insofern können wir sehr komplexe Apps aufbauen und trotzdem dieses volle Potenzial von KI ausschöpfen, ohne dass KI überfordert ist mit der Komplexität dann das sieht die dann gar nicht, das ist auch Wurst, das machen. Das macht quasi noch am Anfang noch der unser Nutzer. Vielleicht am Ende gibt es dann quasi ne zweite KI Instanz, die dann auch noch diese diese Sachen zusammenschiebt, aber da da wollen wir jetzt mal nicht zu steil versprechen abgeben, aber.

Genau. Wenn das alles soweit ist, melden wir uns noch mal würde ich sagen ne genau so, jetzt haben wir die Funktion durch die x und mal verstanden wie das Prinzip oder das Konzept der OOP bei uns eigentlich abgebildet ist. Ne und und was Funktionen so gemein haben. Ja, genau.

Genau. Und jetzt hab ich irgendwie so schön n Bildchen erzählt und jetzt jetzt gehen wir noch mal n bisschen ins Eingemachte für für alle die jetzt coden können, die wissen jetzt immer noch nicht was wir genau machen, also beantworte ich die Frage, wo lebt denn eigentlich dieser digitale Funktionszwilling den ich so nenne, der heißt übrigens die Klasse heißt übrigens executor, das sag ich mal gerade die könnte hätte man auch Funktion nennen können, aber ich

find in Klasse die Funktion heißt fand ich irgendwie schwierig, mentaler Flip, insofern heißt die Executor einfach ausführer einer Funktion. Und tatsächlich ist, das muss ich mir jetzt auch noch mal n Paar sagen, Sachen wie sieht das aus, ja, und was ist das genau?

Ja, natürlich muss der Executor in einem Backend sein, also wir haben gerade am Anfang gesagt, wir haben ne Webanwendung, wir haben also zum Beispiel n Frontend, also unseren Baukasten zum Beispiel, ja, und wir haben auch n Backend, und dieser digitale Zwilling, den kann man zwar im UI sehen, aber leben tut er im Backend, ja, das ist wichtig, da muss man vorher auch einmal überlegen bei der Architektur, weil du willst ja

nicht. Also du könntest natürlich auch n Frontend machen, das hieß ja aber wenn du die App zumachst, dann ist vorbei mit Funktionsaufrufen.

Ja du willst ja aber so Sachen machen, keine Ahnung, alle 2 Sekunden will ich von meiner Hardware irgendwas rausholen und so weiter ja das soll ja gefälligst auch noch weiterlaufen, selbst wenn ich die App schließe, sonst ne gesamtkatastrophe ja, also das ist relativ klar, das lebt halt im im im Backend ja von uns ja und der Executor der quasi digital Zwilling einer Funktion ist ist selber erstmal ne klasse technisch ich hab halt ne executor Klasse geschrieben,

klar ist executor in no chair ist ja hat.

Ungefähr zweieinhalbtausend teilen Code ja, also ist kein kleines Ding. Ja, ist da, da steckt relativ viel Know How drin, ne weil und und das macht aber nichts anderes als ne Funktion abzubilden, ja, aber diese ganze Standardisierung, dieses Ganze behandeln von den Promises und von den Exceptions und so weiter das ist halt auch zum Teil mit drin, zum Teil auch VAPC, aber genau deswegen ist das nicht nicht gerade kurz, ja. So, und aber dieser Executor,

das das ist noch mal, um das klar zu sagen, ist nicht die Funktion, die wir aufrufen wollen.

Das ist quasi n Proxy dafür. Also das ist, das ist der digitale Zwilling, der dann noch aufruft, das heißt, wenn wenn der User sagt für aus in der UI, dann geht dieser Befehl runter zu dem digitalen Zwilling der Funktion im Backend, da wird dann gesagt für aus diese Funktion und der hat quasi nur die Adresse gespeichert zu der echten physikalischen Funktion, die irgendwo liegt und der sagt dann noch mal für aus du Funktion ne. Und gib mir erstmal das

Ergebnis. Ich hab das dann im Backend drin und dann schick ich es wieder ans Frontend zurück. Ah guck mal, hast auch hab ausgeführt da ist der Rückgabewert so du. Meinst jetzt aber, wenn man im im App Builder ist quasi wenn man. Noch im MM Builder ist ja ja ja genau, also es ist n Dreieck ne, also es sind 3 Dinger. Ja die UI hat ne hat ne Darstellung der Funktion, dann gibt es im Backend eine Darstellung der Funktion als aber technisch quasi ja.

Und tatsächlich ist das ist jede einzelne Funktion, die wir so ziehen können, auf unser Brett, auf unserem, Wir nennen es Flow Builder, ja ist eine Instanz der Executor Klasse.

Ja, das und das ist auch wichtig, weil wir müssen den State isolieren, ja, jede Instanz merkt sich halt die die Argumente, die ich rein konfiguriert hab und so weiter ja jetzt kommt, vielleicht kommt vielleicht das Bild zusammen, ja, aber ich kann jetzt in dem in der UI kann ich in die Argumente konfigurieren, da schreib ich das halt rein ne was weiß ich my Sequel oder Irgendsowas bei dem Dialekt ja.

Das muss ja jetzt irgendwo gemerkt werden und das merkt sich halt der digitales Zwilling im Backend. Der speichert das alles hin, ja, und ganz wichtig, das war n. Knackpunkt in der ganzen Architektur hier an dieser Stelle lösen wir die Mandantenfähigkeit, was mein ich denn jetzt, damit ich mein jetzt damit, dass am Ende des Tages wird? Ja, es ist ja n App Baukasten und jetzt ist ja so, dass die App nicht nur einer bedient.

Ja, das ist einfache, ich sag mal Dashboard Builders, die haben nur einen Nutzer im Kopf. Alle sehen das Gleiche und bekommen das Gleiche. Und wenn du da irgendwie dann im Hebel ziehst, dann zieht sich der Hebel für alle gleich. Ja, das ist dann nicht mandantenfähig.

Das Single User Interface sagt man auch, ja, wir haben aber n Multi User Interface und das heißt wenn wenn wir jetzt ich mach mal das Beispiel ganz einfach wenn dann einfach 2 Leute die gebaute App in die Hand bekommen und die eine Funktion die Gerrit dahin gemacht hat und jetzt nehmen wir nehmen wir die Funktion Get Weather und die das Argument wäre wie viele. Wie viele Get Weather Forecast und das Argument wäre zum Beispiel wie viele Stunden

voraus? Ja dann muss es so sein, dass diese eine Funktion, die da steht, wenn der Gerrit sagt, 2 Stunden voraus für den Gerrit wieder zurück die 2 Stunden voraus Rückgabewert liefert aber für mich wenn ich sage 5 Stunden voraus meine 5 Stunden vorausliefert und das auch nicht durchmixt und so weiter und sofort, ja, das nennt sich Mandantenfähigkeit und die muss ich krasserweise sogar durchziehen, wenn wir Funktionen koppeln, wir können nämlich wir

können sagen der der Rückgabewert, der einen Funktion wird Eingabe wird quasi Argument einer nächsten Funktion.

So machen wir komplexe Logik und das kann ja auch sein, dass zum Beispiel wenn jetzt Gerrit sagt, 2 Stunden Vorhersage für das Wetter, das kommt dann erst mal aus dieser API Funktion raus und dann geht das noch in eine andere Funktion rein, rechnet irgendwas weiter und dann kommt das zum Gerrit zurück und während dieses ganzen Prozesses. Muss klar sein, das wird das ist von Gerrit, das ist nur für Gerrit und nicht für jemanden anders, das darf auch nicht liegen.

Ja und das kommt auch nur zu Gerrit zurück. Ja, während des ganzen Durchflaufen und gleichzeitig vielleicht macht der Burkhard das gleiche, aber mit ganz anderen Argumenten, Parametern auf der gleichen Funktion, ne, das ist very twicky und das haben wir gelöst, indem sich halt so ne executor Instanz tatsächlich den User merkt. Ja da stehen die alle drin ne und macht das sauber. Macht das Sauber in der Instanz klar im Backend über alle Funktionen hinweg. Existiert also für jeden User

der App eine Instanz? Nein, es existiert eine Instanz der Funktion und innerhalb der Instanz habe ich State, dass das ist ja das, was eine Instanz ausmacht. Da habe ich quasi eine Dictionary tatsächlich für alle User, die gerade diese Funktion ausführen und ich ruf dann die Funktion auf Get Weather für dich, Gerrit.

Und und kriege dann den auf den Rückgabewert und Speicher, den in der einen Instanz dieser Funktion unter deinem Namen da steht quasi gerrits, rückgabewert, Doppelpunkt, irgendwas und dann steht da burkhards, ja genau, burkhards rückgabewert doppelpunkt, ja, das ist quasi innen drin und das Dispatching später zu der zu der UI, das passiert wieder clever, deswegen hat das auch zweieinhalbtausend Zeilen Code, das da muss man n bisschen aufpassen, ja das ist aber an

der Stelle, das ist ich weiß, ich weiß gar nicht, ob das so gut ist, wir es heute, wir machen, dass ich das Nähkästchen relativ weit aufhaut da kann man richtig weit reingucken an die Volleyball, aber das ist der Knackpunkt, da hab ich lange dran gezappelt, aber das ist, stellt sich heraus, die einzig elegante Art und Weise, wie ich finde, dass man auf so einem generischen Level dieses Multi tendency Problem lösen kann, ne das nicht du weißt Gerrit, ich hab ich bin früher mit

rauchendem Kopf gelaufen, es hat auch nicht immer von von vornherein funktioniert und es ist Hardcore kompliziert. Weil wir auch noch Events aus der Hardware können.

Und die sind ganz anders, die haben keine Nase, da gibt es quasi nur eine Sorte n Garagentor gibt es nur einmal ja oder der GPIO pin ja wenn der sagt ich hab was, dann ist es halt nur der verdammte GPIO pin ja und möglicherweise wollen dann aber der Gerrit, der Burkhard und der Albert den GPIO Pinwert sehen in ihrer Funktion und so weiter also da muss man, da muss man in 1015 20 mal drüber nachdenken, dass man das dann richtig hinkriegt, aber wenn es einmal hat hat man es

halt, dann funktioniert es für alles. Ja das ist das geile ja. Deswegen hat es auch n bisschen gedauert, bis wir jetzt so da sind, wo wir da sind. Aber jetzt sind wir ja so generisch, dass wir sicher sein können, es funktioniert halt, egal was für ne Funktion. Ja wenn es einmal funktioniert, funktioniert es halt immer. Ja, dafür war halt die die anfängliche Arbeit n bisschen härter, ja. Das kann ich bestätigen, dass

das. Die ein oder andere Session am Whiteboard gefordert hat, dass wir das auseinander geknotet hatten. Überhaupt, dass wir das Problem verstanden haben. Komplett würde ich sagen, ja, das ist dann, um dann verschiedene Lösungen durchzuexen ja und ich war fast eher so n robber Duck, dann in dem Fall. Ja, ihr könnt. Ihr könnt euch nicht vorstellen, was es da alles für Edge Cases

und Probleme gibt. Ja, das ist der Hammer, wenn man sich, wenn man sich aufmalt das wird n relativ großes Whiteboard ja, aber um das noch mal zu sagen und das das würde ich gerne noch mal festhalten ist du kannst bei uns wirklich hingehen

und. Durch die Nutzung dieser visuellen Abbilder oder irgendwann digitalen Zwege der Funktionen deine Logik aufbauen, ne wie Burkhard sagte, dass den Output von der einen Funktion auch wieder als Input Argument für ne weitere benutzen und so beliebig lange Logik zu bauen.

Wir sprechen manchmal von Flows, dann auch wirklich aufzubauen, dann irgendeinen Wert auch in einem Frontend auch anzuzeigen, ja der da vielleicht aus dem Flow rauspurzelt wie zum Beispiel n Wetter forecast jetzt in aus deinem Beispiel und wenn das mal gebaut ist und man diese App deployed, dann können das beliebig viele Nutzer. Benutzen ja sogar ohne dass sie sich einloggen müssten oder so. Und jeder kann das genau so benutzen, wie er das möchte, also seinen persönlichen

Podcasts, also in Stunden angeben und kriegt n Ergebnis raus. Ja das das das ermöglicht, das würd ich gern noch mal unterstreichen hier ja im Grunde genommen wie wenn ihr euch ne Wetterapps installiert, ihr geht ja auch nicht davon aus, dass ihr n Wetterbericht von wem anders seht. Ja, es ist irgendwie ganz klar, dass es so sein muss, aber technisch ist es überhaupt nicht

so klar, wie man das realisiert. Ja, das ist der Channel und vor allem, dass es Halt möglich ist, das zu das so generisch zu bauen, ja, und das ist dann für den Nutzer der das Apple das einfach gelöst ist. Ja dann muss sich aber keiner Gedanken, das ist ja das Spannende hier. OK, genau also ich, ich unterstreich vielleicht noch mal diese 3 Komponenten, es gibt also quasi die UI. Im Prinzip konfiguriere ich ne Funktion mit den Eingabewerten,

dann kann ich sie ausführen. Und dann wird quasi über das über den digitalen Zwilling dann Beck endlich tatsächlich die

Funktion da auch ausgeführt. Das heißt, die diese Instant hat ne Adresse, das ist sehr wichtig, muss wissen mit wem sprech ich, diese Adresse ist auch standardisiert bei uns, dann mach ich diesen diesen Aufruf wie ich den mache ist mit VRPC per Remote procedure Call sag ich gleich noch was, kommt er wieder zurück und wir haben für alles und jedes also wir haben die Funktion noch mal auseinander genommen, ihr könnt euch ja jetzt vorstellen, ich hab Argumente gesagt und

Rückgabewert und Fehler und so weiter und Trigger. Tatsächlich sind das eigene Boxen. Bei uns ist auch wichtig, jedes Argument ist ne eigene Box, wo ich quasi den Datentyp reintun kann und dann der Trigger ist quasi ne eigene Box, ist also n Knopf.

Ich führ aus ja oder ich lass ausführen alle 2 Sekunden oder irgend so was kann man da alles möglich machen und der Output quasi auch ne Box da zeigt sich dann quasi der Rückgabewert an und alle und alle diese Boxen und so das ganze Gedöns ist quasi liegt auch im State innerhalb einer Instanz von so einem Execute drinne und diese ganzen Boxen haben alle IDS, das will ich noch mal sagen wenn wenn ihr.

Also mein Tipp, wenn man größere Architekturen baut IDS alles braucht ne Halt jedes jede Entität ist die noch so klein die du irgendwie individuell behandeln willst. Später hat ne ID zu haben, aber bei uns hat halt alles und jedes ne ID und wir nutzen halt irgendwie nano ID zum Beispiel ist auch egal. Du brauchst halt irgendwie ne globale ID die nicht kollidiert. Ja und dann wird alles ganz einfach ja und dann kannst du mit die und diese ganzen.

Dieses Ganze, dass dass in der UI das richtig artig anzeigt und so weiter das hat alles damit zu tun, dass dass sich bestimmt auf diese ganzen IDS registriert wird und die ganzen IDS schütt ich quasi als Information in die UI und das wird plötzlich alles

aussortierter. This is the way to go ja man, man arbeitet mit IDS und bloß nicht mit Instagram und irgendwas gezählten und irgendwelchen Indizes und so weiter nutzt IDS ja kurzer Tipp für für alle die irgendwie was Größeres bauen wollen hab ich auch nicht immer gemacht, war ne Katastrophe ja geht schief, IDS nehmen gut so, da haben wir das verstanden. Und jetzt hab ich immer noch.

Jetzt hab ich zwar schon wieder n bisschen mehr gesagt, wie wir das gemacht haben und wo es ist und so, aber jetzt haben wir noch nicht, hab ich noch nicht gesagt welchen Werkzeugkoffer mit welcher Technologie attackieren wir das ja dazu sag ich jetzt noch 23 schnelle Sätze, grundsätzlich erstellen wir halt Datentypen die wir für die Argumente und die Rückgabewerte brauchen und so weiter da mit Jason Jason ist The Way to User Jason kann genau das ja hat genau diese datentype

kann das darstellen, es ging React wunderbar auch darstellbar gibt es Libraries. Sieht man bei uns, kann man auch so einklappen, das kann ja beliebig kompliziert und genestet sein, da kriegt man aber n Überblick, das kann man

schön darstellen. Ja Jason und dann habt ihr jetzt verstanden, wir arbeiten ja ganz vieles ist alles Event getrieben, die gesamte Architektur, das ist glaub ich klar weil ich führ ne Funktion aus ist n Event die die der Executor schickt n Event an die tatsächliche Funktion bitte für aus dann kommt n Event ich hab fertig gemacht zurück oder es kommt ne Promis zurück danach kommt n Event ja mein Versprechen ist fertig und so weiter alles Events.

Das heißt, es fliegen ganz viele Events durch die Gegend.

Was nimmt man dafür? MQTT ja, also wenn du schnelle viele Events und Nachrichten hast, MQTT so und jetzt musst du noch eine Sache verstehen, wir sprechen ja davon, ich hab die ganze Zeit von standardisiert digitaler Zwilling von generisch und so weiter gesprochen, jetzt hör ich auf bei MQTT einfach individuelle Messages zu formulieren, so und also 99% der Welt nutzt MQTT um Nachrichten. An den bestimmten Topic zu schicken mit einem bestimmten Inhalt und jedes Mal wird das

neu beschrieben. Was ist das und da gibt es dann apis auch zu asynchroner apis und so ein Quatsch, ja ist kein Quatsch, Entschuldigung also man hat auch seinen Sinn, seine Verwandtheit, aber bei uns nicht, bei uns schreit das halt nach dem Protokoll ja also nach einer auch auf dem MQTT liegenden Standardisierung diese Adressierung der Funktion, da gibt es adressierungen und die ganzen Events sind alle eingetütet, wir haben quasi strukturiertes Topic Pattern ja

und das Topic Pattern ist genauso organisiert von der Hierarchie wie Gerrit das gesagt hat, vom Blick her so quasi.

Der Agent, also der Prozessname selber dann auf dem nächsten Level ist der Klassenname und auf dem übernächsten Level sind die statischen Funktionsnamen und die Konstruktoren und die Destruktoren. Und dann kommt noch die die Instanz, die Instanz hat n Namen zu haben und da drunter die Funktionen der Instanz, das heißt Wir haben so ne fünfgliedrige Hierarchie wo alles einsortiert ist.

Das das widerspiegelt quasi n Adressraum vor dem MQTT Broker und so werden halt die Nachrichten geroutet, dass die auch richtig ankommen und zurückkommen und so weiter plus x. Das schaff ich nicht in dem Podcast. Das ist wie gesagt 8 Jahre Entwicklung. Auch dass das alles passt mit den ganzen Promises und so weiter aber so grob kann man sich es vorstellen. Ne Pause. Kurz durchatmen, das ist der ganze Werkzeugkoffer, den man den man, den man braucht ja json, amcutity und und VRPC

dann. Ja, für das, was ich jetzt gesagt hab und React ja erstmal ja. Genau. Und jetzt waren wir tief in der Ideen. Also ich hab ich hab jetzt sehr lange gebraucht um diese eine Idee quasi dieses Lego Bausteins

des Backends zu erzielen. Ja jetzt ist unsere heisenware Plattform natürlich noch viel größer und ich glaub wir nehmen uns die Zeit wir wir sind Folge 100 übergeben wir mal die Stunde die wir normalerweise machen, vielleicht noch bei 10 oder 15 Minuten und ich erzähl kurz noch den Rest wie das quasi eingebettet ist in den restlichen in die restliche Architektur und warum das insgesamt n schönes Bild gibt. Und das können wir etwas schneller machen.

Aber mir war es extrem wichtig, dass man einmal dieses fundamentale Prinzip, weil das ist echt n Differentiator zu anderen Plattformen, das muss man mal so sagen, so funktioniert. Na meiner Meinung nach keine andere Plattform, die haben andere architektonische Ideen ja von innen, wie das aufgebaut ist, da sind wir glaub ich unique ja und es ist natürlich auch ne n Risiko wie es so ist wenn man n Unternehmen macht, das ist also quasi unsere

Invention sag ich mal. Aber es scheint ganz gut zu klappen. Ja, also wir wir, wir schaffen es, schöne Apps damit zu bauen, sagen wir es mal so, ja. Wir und unsere Nutzer und Kunden ne. Genau, ja genau. Und es wird immer noch besser, weil es ist halt ne neue Technologie und wir müssen selber auch noch verstehen, wie kann man es noch geschmeidiger und noch schöner machen. Aber ja ich. Glaub man kann auch sagen, wir sind noch immer am Anfang. Ja, alles klar. Gut, Gerrit, wenn du wenn du

bereit bist würd ich versuchen. Jetzt in größeren, gröberen Schritten noch mal das irgendwie zusammenzusetzen zum Gesamtbild. Ich bin immer bereit, auf jeden Fall ja, erwähnen gerne dabei, mal was da noch so für Komponenten drin sind. Also mit der Influx und. Der und so. Ja genau das würde ich jetzt machen.

Ja genau genau, also gut jetzt, also gut dann dann geht es weiter, also jetzt habt ihr verstanden, dass wir so ne Art digitalen Zwilling von der Funktion haben, das löst quasi die den logischen Anteil einer App. Jetzt haben wir ja aber auch bei uns als First Citizen, wie man so schön sagt in unserem Produkt den.

Visuellen Anteil einer App wir können ja auch Front entbauen oder beziehungsweise ihr könnt Front entbauen ganz einfach so n bisschen wie bei powerpoint einfach drauf ziehen, Größe ändern, positionieren und so weiter und sofort ja und das kann man jetzt ganz schnell verstehen, weil was ich nämlich gemacht hab ist ein digitalen Zwilling eines Widgets, muss man einfach wissen so n wenn ich irgendeinen Knopf anzeige oder nen Chart oder nen so n so n Tacho oder irgendsowas, dann ist

das halt nen Baustein, das ist halt n Widget ja. Und jetzt gibt es halt einen digitalen Zwilling von so einem Widget und der lebt auch im Backend krasserweise, das ist auch, muss man auch erstmal machen, das ist alles nicht im Frontend, das lebt alles im Backend.

Wir haben also eine Widget klasse, genauso wie wir ne executor Klasse haben, die n Funktions digitaler Zwilling ist, haben wir ne Widget Klasse das ist ein Widget digitaler Zwilling und die wird halt auch durchkonfiguriert das macht man immer einfach drauf geklickt, da kommt auch n Menü und dann sag ich halt irgendwie breite Höhe und so weiter Farbe tachonade so und so und sofort ja. Ist alles einfach nur json? Konfiguration wird in der Widget Instanz gespeichert.

Jedes einzelne Widget was irgendwo auftaucht, jeder einzelne Knopf ist eine Instanz der Widget Class ja durchkonfiguriert und wenn der wenn die App lädt, dann sagt sie Backend gib ihm mal alle Widgets mit allen Positionen bam bam bam bam bam dann wird das dahin gehingerendert und fertig ja und weil das Widget auch im Backend lebt, neben den Executors und auch IDS hat und so weiter können wir jetzt sagen vermittelt durch die UI. Zieh den Rückgabewert von der

Funktion, zum Beispiel Funktion sag ich mal random integer oder irgendsowas. Das ist die Funktion, die generiert ja einen randomisierten integer Rückgabewert zwischen 0 und 100 oder irgendsowas, weil du im Argument gesagt hast Minimum 0 Maximum 100 und jetzt ziehst du grafisch den Rückgabewert auf ein Widget, was so n Tacho ist. Und was passiert in echt in der UI eigentlich im Frontend gar nichts, im Backend wird jetzt gesagt, OK die ID.

Ich hab gesagt, ID ja die ID von dem executor Instanz Random integer beziehungsweise noch genauer die ID von dem rückgabewert Box von der Funktion Random Integer, die wird jetzt der Instanz von dem Widget Tacho hingegeben als richtig in ne Instanz mit dazugegeben und jetzt kennen die sich und jetzt kann ich wenn wenn sich da der Wert verändert Event getrieben das passiert im Backend. Kann ich sagen, hier alter, du hast einen neuen Wert.

Update das mal und jetzt gibt es ein Event in die UI, das ist wichtig deswegen das ist auch ein Key Concept, da wird nichts

gepolt. Wir haben einen Web Socket, eine stehende Verbindung MQTT ist auch die Verbindung zwischen Frontend und Backend und jetzt sagt das Widget Ich hab vom Executor jetzt gekriegt 88 ja hier 88 ja und jeder der jetzt in die UI kriegt der kriegt halt 88 dahin gemeldet und das Widget der Zeiger geht auf 88 ja. Easy, das heißt, wir haben auch da in so visuellen Blogs komplett generisch gezogen und können im Prinzip beliebige fertige Open Source wieder

Bibliotheken von Widgets nehmen, die da einbetten und mit beliebigen Funktionsrückgabewerten und so weiter verkabeln. Das ist komplett, ich sag mal der der Kreativität komplett freie Bahn gelassen. Ne Mhm, so funktioniert das ja. Das war neu für mich.

Ja cool. Also ich hab schon, ich hab schon häufiger auch die, die die Instanzen quasi von den Widgets ja gesehen, die sind ja auch kannst du sehen, wenn den Resources quasi ne Media Server irgendwo auch ja kannst du drauf zugreifen genau aber dass das wie das funktioniert tatsächlich, das ist bei mir nicht klar.

Ja, so funktioniert das OK und und dann gibt es quasi und jetzt jetzt haben wir schon die 2 wichtigsten Komponenten, nämlich die Widgets und die fürs Frontend und die Executors und AKA Functions fürs Backend. Und jetzt gibt es halt noch die App. Als Instanz, weil wir haben ja verschiedene Apps. Ja, du kannst ja bei uns 12 5070 Apps machen und die Apps beinhalten quasi n Haufen

Widgets und n Haufen executors. Ja und in den Apps sind so Einstellungen drinne wie wie viele Pages hast du, welche Sprache sollst du nehmen und so weiter und sofort hat auch ist auch wieder nur n Haufen Konfiguration ja und wird gespeichert als Instanz einer App klasse ja so rums und jetzt was haben wir jetzt im Backend relativ einfache Klassen und Instanzen davon. Und jetzt kommt noch was. Muss man auch zu sagen, zur Architektur, was macht man jetzt

damit? Ja, das packst du jetzt in Dockercontainer und da schreibst du da dran, App Builder Backend, ja das ist unser App Builder Backend dockercontainer ja darin läuft das alles, dann haben wir haben wir schon das sauber gemacht und jetzt muss man sich aber noch kurz überlegen warte mal wir haben ja ne saas Software also das ist das Kacke wenn wir wenn wir das alles in einem Container haben weil Der Gerrit macht sich bei uns n Account Demo Punkt heisenware

Punkt Cloud und darin sind alle seine Apps und alle seine Haufen Widgets und Executors und so weiter und das gefälligst nur für Gerrit. Ja das ist jetzt wieder encapulation ne eben gerade waren wir noch innerhalb der Instanz, dass wir quasi die die Calls quasi encapulaten, jetzt geht es quasi darum, wer nutzt quasi diese ganze Plattform, wem gehört der Sub Account? Ja und das lösen wir indem wir komplett die Container quasi bauen, es gibt nämlich ein.

Ein App Back End Container nur für den Garet beziehungsweise genauer nur für den Account Demo ja den den der Garet vielleicht

gemacht hat. Ja und für den Account Your Company Punkt Heisen Wer dort Cloud gibt es n komplett eigenen Container. Ja und das ist das nächste architekturelle Ding während wir n paar Container haben die immer da sind für alle die sich quasi Last teilen also zum Beispiel authentification und so weiter entsteht für jeden unseren Accounts garet hat gesagt ihr könnt es ja mal ausprobieren.

Und wenn ihr das ausprobiert, wenn ihr tatsächlich n Account anlegt, dann entsteht im Hintergrund in unserem Backend n ganzer Satz 12345678 vielleicht 8 neue Container ja, und einer davon ist das App Bilder Backend, von dem ich lange gesprochen hab, wo die ganzen Widgets und so weiter drin sind, der entsteht quasi nur für euch an diesem Account. Ja und damit ist alles vollständig isoliert.

Ja und das ist jetzt auch wieder architektonisch, da gehen wir jetzt aber schnell rüber, wir lösen das, dann muss man das Wissen, ist auch wenn man das weiß ist das n cooler Trick. Wie kann man das jetzt machen? Dynamisch Container hä in einer Anwendung die deployed ist? Ich muss da nix neu deployed, ist also Runtime bei uns in der Plattform und wir haben ein Modul das ist wieder nen Container, das ist einer der für der aber immer der gibt es quasi nur einmal.

Das ist der sogenannte Container Manager oder Docker Manager, dessen Aufgabe ist quasi on the Fly on request neue Container herzustellen, sozusagen hab ich noch nie gehört, das kenn ich ja nicht wieso ihr habt doch Docker compost und so weiter ja. Gibt es auch. Das ist der Standardweg. Aber man muss wissen, Docker selber ist halt nen nen Demon, ein ein Demon, also ein eine laufende, ein laufender Server

vom Betriebssystem quasi. Das ist auch wieder nur ein Server mit Rest API und Du kannst halt innerhalb in der Runtime kannst du diese Rest API sagen, zieh mir einen neuen Container hoch, tatsächlich ist es sogar so, dass die Docker Kommandozeile, die man so kennt mit Docker Compose ab oder Docker run und so weiter das kennen alle die ein bisschen Docker machen ist nichts anderes als ein Rapper.

Für einen Klienten, der mit diesem Demon spricht, ja, das ist ne Client Server Rest API Architektur und wir sprechen von innen heraus mit dieser API und können quasi in Runtime unserer Plattform dockercontainer runter und hochfahren wie es uns

beliebt. Ja das löst unsere MIT Tendency quasi auf Account Ebene ja das wird in Dockercontainern quasi abgebildet genau und Gerrit hat schon gesagt Erwähn doch noch mal was sie sonst noch so haben genau dann jetzt haben wir quasi und das das mach ich n bisschen kürzer weil das andere auch so machen das ist Best practice. Wir haben halt n ganzen Satz an Dockercontainern mit verschiedenen Funktionalitäten.

Also wir haben zum Beispiel einen wo ne postpress Datenbank drin läuft, wir haben einen, da läuft ne Influx Time Series Datenbank und auch diese sind quasi pro Account generiert. Ja es gibt ja quasi ganz viele postpress Datenbanken für jeden Account ein und und dann haben wir noch n Container da, da läuft n Media Server drin damit ihr eure Files und so weiter verwalten könnt und so weiter so n ganzes Set ja und die die können alle miteinander sprechen weil die sich ein im Docker ein

Dockernetzwerk quasi teilen. Und die können auch miteinander Files austauschen, weil wir da mit den Volumes arbeiten und man kann nämlich auch wissen, man kann Docker Volumes in verschiedene Container Mountain, die gucken quasi alle auf das gleiche Filesystem. Ja und die Volumes übrigens sind bei uns auch Key um zu persistieren, davon hab ich nämlich noch nicht gesprochen, es muss ja auch so sein, dass wir machen ja ganz ganz viel Updates oder die Maschine geht

mal aus, der Server startet neu und so und dann darf ja nicht alles weg sein, das funktioniert so, dass wir zu jederzeit das auch krass, das sag ich noch mal also. Immer bei der kleinsten Änderung von der UI ist also wenn der Gerrit zum Beispiel sagt Min Doppelpunkt 1 von 0 auf 1 gesetzt das Argument weil er dann ne Rente am Ende das von 1 bis 100 nicht von 0 bis 100 machen will, dann verändert er ja eine eine Konfiguration des unterliegenden executor Instanz.

Und das wird sofort persistiert. Das geht sofort in den Docker Volume auf die Disc, als Jason flach hingedonnert wir haben nutzen keine Datenbank, wir benutzen keine relationale Datenbank, hab ich mich dagegen entschieden, weil die weil die Funktionen sind keine relationalen, ich brauch keine relationalen Anfragen darauf, wir brauchen n extrem hohen Speed und ich Klatsch das einfach auf die Platte, aber nicht einfach irgendwo auf die Platte sondern in ein Docker

Volume was dazu gehört und das Docker Volume, das ist Docker Technologie persistiert mir das schon hin. Und jetzt ist noch einspringender Punkt.

Was wir können ist halt wenn die Plattform unten ist und wenn wir neu starten, das haben wir von vornherein designed, können wir quasi die Instanzen. Ich hab ja gesagt wir können Instanzen auch erzeugen und managen von der persistierten Information auf der Platte erzeugen wir rückwärts beim Starten die Instanzen wieder in die entstehen einfach ja das Macht uns unser unser Backend quasi ihr seht dann einmal kurz grau und dann ist wieder grün alles da und ich hab das ganze

System neu gestartet oder was also? Unglaubliche Vesilient ja, powercycles und so weiter es kann nie irgendwas passieren. Ja es braucht manchmal ab was n

komplexes System ist. Irgendwie ist das nicht aufgehangen an der UI, man kann nicht zu jederzeit irgendwie represh drücken, dann kannst du jederzeit den Computer an und ausschalten, das kannst du Docker Runterschmeißen hochschmeißen kann nie was passieren ne ist alles ist alles in sich flüssig und in Volumes aufgehoben ne die ganzen Datenbanken auch ja die Datenbanken das ist immer n Riesenproblem Migration von Datenbanken haben wir nicht wenn

wir die Datenbanken auch in den Volume persistieren dann gehen die halt runter und dann kommen die wieder hoch und alles ist safe ja da muss man nicht drüber nachdenken. Vielleicht müssen wir noch erwähnen, dass die Datenbanken, die drin sind, nicht für die Heisenware PC benötigt werden, sondern Ressourcen sind, die die Nutzer benutzen können, um wieder abzubauen und und danke die Daten abzulegen. Ja, genau, und dann und dann haben.

Dann haben wir quasi im Backend ganz viele Container jetzt, jetzt würden die, die die Leute die sowas machen, die Fragen jetzt ja hä und wie Teil ich das auf, also wir haben noch n als Komponenten reverse Proxy, das ist quasi daheim da wie. Die Leute, die Tor kennen mit dem Hammer, die wissen, dass der Heim da quasi die Welt schützt, bevor man da hinkommt.

Das ist darüber das Proxy, der der, das ist quasi der Kontakt nach außen, der macht das ganze SSL Termination Krams, das auch nur einmal machen, der hält auch das das SSL Zertifikat von der Heisenware und der hält es auch für unseren internen MQTT Broker ist auch ganz schick und darüber kommt alles rein und raus wir nutzen da Envoy als Technologie. Weil wir da ja auch nicht auf ne Cloud vertrauen können. Das hab ich noch nicht gesagt.

Wir können ja auch komplett on Prem laufen, das heißt wir haben alle Module die wir benötigen für den vollen Betrieb der Plattform in unseren eigenen Docker Containern untergebracht, also auch Authentifizierung. Es hat noch nicht selbst geschrieben, es gibt Fusion Awes oder das erlaubt halt quasi es im Docker Container zu betreiben und und deswegen müssen wir quasi uns auch um unsere Reverse Boxys kümmern. Wer jetzt nicht weiß was Reverse Boxy ist, hört die Folge noch

mal nach. Und und dieser Reverse Proxy ist sehr dynamisch und funktioniert auch wieder über n Volume. Da ist dann quasi n file drin, wo die ganzen Accounts sind und dann macht dann das richtige Routing, das ist nämlich wichtig, dass wenn der wenn wenn da steht Demo Punkt heißen wer dort klaut und der Gerrit Minn auf 1 setzt, dass das alles an der richtigen Stelle im richtigen Container auf der

richtigen Instanz ankommt. Ja und zusammen ist das n ziemlich großes Bild und aber ja beschreibt so n ganz bisschen top Level. Wie unsere Architektur aussieht? Ja, jetzt komm ich so langsam auch zum Ende.

Also man könnte sagen, am Ende des Tages, ich hab sogar hier hingeschrieben auf meinen Spicker am Ende des Tages ja haben wir quasi, bauen wir quasi im App Bilder konfigurieren wir fast noch besser gesagt im App Bilder Instanzen die im Backend entstehen, das heißt durch konfiguriert wird auch nie Code generiert, das muss man auch noch mal sagen. Ja wir haben eine No Code Plattform, die besteht aus.

Fertig geprüften Instanzen, nirgendwo wird irgendwas generiert, da ist alles vorher durchdachter, es wird nur noch durchkonfiguriert, ja dann wird das Persistiert was ich gebaut hab in in Volumes hab ich gesagt und wenn ich deploy drücke passiert eigentlich nichts anderes als dass ich kopiere, ich nehm diese ganzen Jason Files kopier die in den zweiten Container den ich produktionscontainer nenne, der sieht aber eigentlich aus wie der Bildercontainer, ist halt

einfach nur der der geschützt ist für die Produktion ja. Und dann hab ich noch n zweites UI Backend was was nicht das ganze Gebaue macht. Das geht quasi nur.

Zeigt mir an welche Widgets wo sind die und welche Executors werden bedient und los geht es ja, das ist ganz dünn krasserweise ist das da die rect Applikation über alle Apps hinweg die sich alle unsere User ausdecken oder wir selber exakt die gleiche ja ist die gleiche UI Anwendung ja und die ist sehr klein weil der gesamte Inhalt von der UI aus dem Backend geladen wird ja da gibt es n Namen für den ich die gerade nicht auf der Platte hab irgendwie.

Fondant as the backend oder irgendsowas nee, weiß ich nicht, also ja, aber ihr wisst wohl was ich meine, quasi die Ganze, das ganze Rendering und so weiter ist quasi alles nicht das Rendering Rendert, rendert wird tatsächlich noch im Client, aber die Konfiguration und welche Widgets wohin kommen liegt alles im Backend. Ja und das ist dann ziemlich elegant und lässt uns das managen, dass wir quasi ja relativ überschaubaren Code haben bei ganz flexiblen

verschiedenen Apps die unsere User machen können. Ja so funktioniert das ja so, jetzt bin ich irgendwie hab ich mich zu Tode geredet. Ich sag das nochmal. Ich würde sagen, auf jeden Fall eine würdige Folge 100. Ich fand es fast studierend. Ja, jetzt fällt das alles so ineinander. So, das klingt alles sehr schlüssig. War dir das alles vorher klar oder ist das Iterativ entstanden? Nee, tatsächlich war war mir das Recht klar und mir ist auch

relativ klar, wie es weitergeht. Ja, mein Problem ist ja immer, dass ich das zwar im Kopf hab, aber nicht so schnell hinterherkomme mit dem Ganzen entwickeln und so weiter also diese Grundzüge dieser Architektur war mir relativ klar, muss man sagen, ja das. Das kann man auch nicht so oft hin und her düdeln so, ja wie man es dann technisch umsetzt und dass das, wie zum Beispiel die ganze Mandantenfähigkeit,

bis man das so hat, sag ich mal. Ja, das ist n anderes Thema, aber dass ich es so aufsetzen will, das hab ich mir vorher überlegt, aber das ist auch schon mal, muss sagen fairerweise, ich hab das ist schon der dritte Versuch, versuche sie nicht, aber die dritte Realisierung dieses Problems, die ich in meinem Leben geschrieben hab, also ich hab dreimal auf der grünen Wiese.

Die Chance gehabt, das muss man auch sagen, das hat ja, das hat man nicht so oft, ein generisches Softwareprodukt zu schreiben, das hat mit der Promotion angefangen, da haben wir Bildverarbeitung auch mit solchen Dingern gemacht, ist weiter gegangen mit der mit der Anwendung ne Skala Anwendung, die ich geschrieben hab, die sehr flexibel sein musste und ähnliche Features hatte für den für den europäischen Laser und mündet quasi jetzt als mal als mein finales Meisterstück, sag

ich mal in einer Low Code Anwendung, die jetzt tatsächlich versucht auf dem Level. Der Software selber irgendwie n attraktionslevel hochzugeben ja, das hätte ich jetzt im ersten Schuss auch nicht so geschafft. Also ich hab aber diese diese Architektur und diese Probleme hab ich halt schon in meinem Leben Ach 20 Jahre hin und her gewütet und alles Mögliche ausprobiert und das ist jetzt quasi der The Final try aber ich würde sagen hat geklappt da jetzt bin ich relativ zufrieden

mit dem was da rausgekommen ist. Ja Mhm das kann. Ich natürlich streichen, das ist läuft, das funktioniert, man muss gar nicht immer wissen, was alles so drunter steckt, das könnte auch verwirren, aber. Das kann auch dazu führen, dass man nicht so gut schlafen kann manchmal.

Ja, aber es ist beeindruckend. OK, dann, dann lassen wir es dabei Burkhard und würd ich sagen, war ne coole Folge 100 war n richtig tiefer Einblick in die heisenware ich würd sagen wenn wenn irgendwer dazu fragen hat oder tief was in Tasse oder so, dann dann sollen sie dich anhauen oder? Sollen sie mich anhauen? Wir haben auch tatsächlich, also wir sind ja so Bolt ne und ich, ich weiß nicht ob das jede Firma macht die die die innerste Architektur nach außen zu

kehren. Wir machen das, weil ich finde, das das muss man auch mal teilen, auch für andere Architekten. Ich find das immer interessant, wenn ich die Gelegenheit hab, mal große Architekturen zu verstehen, von anderen find ich das auch toll und wir haben es

sogar auch dokumentiert. Also ihr könnt bei uns auf docs.heisenwer.com gehen, da gibt es die Developer section wer da so tief einsteigen will, da steht relativ viel von dem was ich gesagt hab auch noch mal Verschriftlicht und Verbildlicht vor allen Dingen da, da kann man sich noch mal reinziehen, ja und ansonsten natürlich gar nicht bin wenn ich Zeit hab das war n größtes Problem beantworte ich natürlich auch alles mögliche Anfragen ne. Cool, dann möchte ich noch 2

Dinge sagen. Nummer 1 wir suchen einen Solutions engineer das heißt, Wer Lust hat mit uns gemeinsam und unseren Kunden und Partnern gemeinsam ja auch Apps und Lösungen umzusetzen, mit der Heiseware mit unserem Produkt, der darf sich gern bewerben. Die Ausschreibung findet man auf unserer Website unter dem Punkt Karriere oder Jobs, je nachdem auf Deutsch oder Englisch freuen wir uns auf Bewerbungen und ich würde sagen, ich freue mich auf die nächsten 100 folgen.

Dir, Burkhard mit coolen Gästen und ja, bin gespannt, was alles noch so auf uns zukommt. Cool, das war n guter Abschluss Gerd, dazu hab ich nichts hinzuzufügen. Ich freu mich, dass wir schon die Hörer 100 Folgen lang begeistern konnten, dass es immer noch Interesse gibt und es

auch noch wächst. Ja, das ist schön und solange das so ist, hab ich ganz viel Spaß und Motivation daran das weiterzumachen, auch wenn natürlich der Teppich der der Tee n bisschen dünner wird aber und ich mich mehr vorbereiten muss aber well, das nehm ich dann auch in Kauf. Ich bin. Fest davon überzeugt, wir werden

noch viel finden. Ja cool, Leute, dann, wer uns jetzt schon vor Silvester hört dem noch n guten Rutsch und n guten Start ins neue Jahr 2026 sowieso alles Gute für euch und wir hören uns nächstes Jahr wieder bis dann ciao ciao. Wünsch ich auch. Tschüss aus Hamburg. Einfach komplex wird produziert und präsentiert von Heisenware. Heisenware ist deine Low Coop Plattform zur Erstellung und zum Betrieb interaktiver Apps rund um den Shopfloor.

Starte noch heute deinen Free Trial unterheisenware.com slash einfach minus komplex.