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.