¶ Intro und Rückblick 2024
Moin und ein frohes neues Jahr noch von einfach komplex. Hier sind Gerrit und der Burkhard Hallo zusammen. Moin von der Ostsee. Mal wieder gab es schon mal eine Folge glaube ich, die wir an Ostsee aufgenommen haben wir mal nicht in Hamburg. Dafür bin ich in Hamburg. Einer muss ja die Stellung halten, bevor wir in unser Thema zu folge 75 gehen ja erstmal noch Dankeschön, dass ihr uns in
2024 so treu wart. Ich habe ein paar Zahlen auch schon bei bei linkedin gepostet, aber ich wollte es euch mal eben sagen. Ja, was wir so letztes Jahr geschafft haben. Dank euch. Also vielen Dank schon mal vorweg, 70000 Streams von
ungefähr 100000 insgesamt. Also ja, man sieht schon letztes Jahr war eigentlich unser von den 2 Jahren unser erfolgreichstes, insgesamt etwa 24000 Stunden hörzeit, also die Menschen mit diesem Podcast verbracht haben, das ist schon ziemlich krass irgendwie insgesamt Follower sind wir glaube ich bei 300000 oder so, davon haben wir letztes Jahr knapp 2400 gewonnen und. Aufgenommen habe letztes Jahr 27 folgen. Dabei belasse ich es jetzt auch.
Dieses Jahr planen wir natürlich wieder ungefähr 27 folgen vielleicht bei 26 habe ich noch nicht ausgerechnet bei so einem Jahr alle 2 Wochen kommt man ungefähr aufs Gleiche raus und wir freuen uns drauf, sagen Dankeschön, dass ihr uns so treu seid und bleibt und freuen uns eben auf ein cooles neues Podcast. Ja und Burkhard, Ich freue mich auf ein Podcast. Ja, mit dir. Ja klar, ich mich auch. Und mal gucken.
Die Herausforderung ist ja, wir haben ja tatsächlich schon ein paar Folgen in den Knochen, sage ich mal.
Und unsere Zuhörer ja auch, und wir freuen uns natürlich auch, und das passiert schon oft, wenn ihr Vorschläge habt, über was wir uns noch mal auslassen könnten, finde ich alles, bin ich Experte, manche Sachen können wir nicht ganz so schnell machen, weil das dann doch lange dauert, dass ich mich auch tief einlesen muss, aber irgendwie finden wir doch immer noch ein Thema, Gerrit oder was wir noch nicht besprochen haben, heute haben wir glaube ich auch ein Spannendes mitgebracht.
In der Tat, ja. Irgendwie findet sich dann doch immer noch was, manchmal spontan aus dem Tagesgeschäft, so, ah, jetzt muss man sich oder insbesondere du mit irgendwas beschäftigen und dann holen wir es halt raus für für n Podcast jetzt haben wir n Thema, das beschäftigt uns sowieso immer so n bisschen glaub ich ja und das ist das Thema Code Generation habt ihr wahrscheinlich auch schon im Titel gesehen was das genau bedeutet Burkhard würd ich dir jetzt einfach mal kurz
überlassen das mal aufzudröseln ja was ist eigentlich Code Generation und warum ist es wert darüber ne Podcast folge zu
machen? Ich sag noch mal kurz, eigentlich sogar Gerrit auf das Thema gekommen dieser Folge, weil wir uns mal näher angeguckt hatten, die ganzen Low und No Code Plattformen, da gibt es nämlich 2 im Prinzip 2 grobe Sorten sag ich mal, wenn wenn man es an an der Stelle mal auseinandernehmen möchte, es gibt nämlich solche wo irgendwie das Ergebnis im Prinzip generierter Code ist, wie man es so kennt, irgendeine Programmiersprache kommt halt
raus oder es gibt halt solche wo tatsächlich eigentlich gar kein Code generiert wird, wo irgendwie die Logik. Innerhalb des Tools aufgeht und man das Tool halt selber und und und die Infrastruktur des des Low Coat Tools selber braucht um die Apps auszuführen. Wir gehören zu dieser zweiteren Variante, es gibt aber durchaus andere Frameworks die das wo halt irgendwie ein Code rauskommt.
Ja und das hatten wir sowieso irgendwie uns mal besprochen, Gerrit und ich und dann haben wir gedacht OK da müsste man eigentlich grundsätzlich mal drüber sprechen, ja was ist überhaupt Code Generation und auf welchen Levels gibt es das? Und so nur mal so als Aufhänger. Damit ihr wisst, wo es über die Reise so ein bisschen hingeht auch und warum wir darüber sprechen, was du jetzt gerade gesagt hast. Jetzt sind mir gerade die sprichwörtlichen Schuppen von
den Augen gefallen. Es geht darum, wo kann ich das Ausführen, am Ende auch voll auch, ja, das ist ein riesen Unterschied dann genau ja, wenn du nämlich, wenn du nämlich einfach ein Stück Code in die Hand bekommst, dann bist du relativ frei den irgendwo hinzunehmen und den Ausführen zu lassen innerhalb deiner Tools da.
Deiner deiner Infrastruktur. Wenn das aber nicht so ist, dann musst du irgendwie was mitnehmen von dem von der Plattform, die dir das anbietet, dass irgendwie höhere, höhere Konzepte irgendwie automatisch funktionieren. Ne, das ist einer der ganz krassen Unterschiede, den kann man gleich vorweg schon mal sagen. Ja, ich merke schon gut, das kann ein vor und Nachteil sein, je nach eh noch was, Leber ne. Und da müssen wir mal gucken, ich bleibe da heute ein bisschen vorsichtig, weil vor und
nachteilig ich will. Also es ist wie immer im Leben.
Ja, es kommt halt, es kommt halt immer drauf an, das sagen die Juristen zum Beispiel auch ja, wenn man die fragt, darf ich das dann sagen, die immer kommt drauf an ja also sag ich auch ich find es aber n bisschen blöd das zu sagen, aber es kommt wirklich drauf an, wir müssen halt gucken was für n genauer Fall ist es und dann gibt es halt für die und die Fälle die und die Vorteile, die können wir ja aber n bisschen ausarbeiten fangen wir mal an wie immer wollen wir es ja n bisschen
technisch machen und. Und es auch so n bisschen, wie soll ich sagen, wissenschaftlich n bisschen aufgliedern und das will ich gleich als erstes Mal voraussetzen, denn Code Generation, was heißt das? Also ich generiere irgendwie auf, also mit irgendwas generiere ich irgendwie Code der
dann irgendwie ne Software wird. Ja ne Anwendung mal so ganz grob gesprochen, ja das ist es ja und wenn man sich das anguckt, dann kann man dieses riesen Feld. Bisschen aufteilen, das habe ich mal versucht, und zwar ich habe es jetzt mal Dimensionen genannt, man könnte es auch sagen, Blickwinkel, Perspektiven oder Irgendsowas ja, diese Dimensionen sind gleichzeitig anzuwenden, also wieso ein wieso ein Koordinatensystem kennt ihr
ja so eine Box mit 3 Dimensionen XYZ Achse und ich habe aber noch eine vierte gefunden, das ist dann vielleicht die Farbe oder irgendsowas ja das könnt ihr euch dann vorstellen, Dimension 1 ist die Abstraktionsebene und zwar die Abstraktionsebene dessen was da rauskommt des generierten Codes ja. Das kann nämlich relativ unterschiedlich sein, da geh da geh ich nachher gleich Schritt für Schritt durch.
Das ist die Dimension, durch die wir durchloupen so würde der Informatiker sagen, ja, also unsere tiefste, unsere tiefste Schleife quasi, da gucken wir zuerst drauf. Abstraktionsebene heißt, ist das jetzt hier ganz nah an der Maschine, ist es ne Art Maschinencode oder ist das total hochsprachig das was da rauskommt ist quasi schon ne Website oder irgend so was das mal nicht damit Dimension 2 Bild Time versus Runtime sind die englischen Worte, also wann wird
der Code generiert und zwar. Bevor ich irgendwie die Anwendung in der Hand hab. Das wäre also quasi zur Bauzeit auf Deutsch in die Engländer dann das Bild Time oder oder aber wird der Code quasi generiert, während die Anwendung läuft als Teil der als Teil dieser Anwendung.
Ja das wäre dann die Runtime, das ist die zweite Dimension, die dritte Dimension ist die Komplexität dessen, was da rauskommt, ja hat so ist so ein bisschen eine Linearkombination, wie der Mathematiker sagen würde, mit der Abstraktionsebene, aber mit Komplexität meine ich noch. Kommt da jetzt quasi nur eine einzelne Funktion raus?
Also ist sage ich mal die Anzahl der Zeilen Code die generiert werden überschaubar ist das irgendwie nur eine Funktion, löst das irgendwie was weiß ich, ich drehe ein Bild auf der Grafikkarte oder Irgendsowas das wird halt generiert oder ist die Abstraktion entschuldigung ist die Komplexität so hoch, dass ich sage okay was da raus generiert wurde ist eine ganze Anwendung wo ich mehrere Seiten habe wo ich hin steuern kann, so eine kleine Mini App wo ich irgendwie Tabellen habe die ich
filtern kann und so weiter ja. Das ist Dimension 3. Komplexität und Dimension 4. Was man auch angucken muss, ist die ja die Nutzergruppe, sage ich mal. Also wer hat überhaupt was davon Code generieren zu lassen?
Es kann nämlich sehr das können 2 ganz unterschiedliche Personen sein, das kann nämlich der Entwickler sein, der Halt quasi durch generierten Code schneller entwickelt, weil weil halt große Teile seiner Anwendung durch ein cooles Tool schon generiert werden, da muss es nicht mehr einzeln hintippen im Detail.
Oder aber es ist vielleicht jemand, der hat überhaupt gar keine Ahnung vom Coden, sondern ist ein Anwender und lässt halt sehr komplexen Code dann an der Stelle wahrscheinlich generieren und ist aber jemand, der eigentlich von Informatik keine Ahnung hat und auch nie verstehen will, was da rausgekommen ist. Er will es einfach anwenden und es ist vielleicht schick so und mit den vielen Dimensionen würde ich jetzt mal ins Spiel gehen und dann einfach mal so ein paar
Sachen beleuchten. Hast du dir diese Dimension jetzt überlegt? Im Rahmen deiner Recherche oder ist das etwas? Wo es auch, weiß ich nicht. Ich will nicht sagen Literatur gibt aber irgendwelche Meinungen und und entwicklerkreise. Nee, Klara Disclaimer also es kommt alles aus meinem kranken Hirn. Ne hab ich mir, hab ich mir mal schnell vorher überlegt, kann man so nicht nachlesen, gibt es also hab jetzt keinen Artikel gefunden der das so auseinander nimmt, könnt mir aber mal einen
¶ Compiler: Maschinencode generieren
schreiben, vielleicht am Nachgang wenn es gut war das werden wir sehen am Ende der Folge. Also gehen wir mal durch, Gerrit. Ich habe ja gesagt abstraktionsebene Dimension 1 will ich als erstes mal nehmen und dann gucken wir mal was da was da geht. Ja und man also wenn man über Code Generation spricht, dann bin ich ja als Informatiker muss halt sagen da müssen wir schon die Compiler mitnehmen ja was
ist ein Compiler? Ein Compiler ist ein ein Tool was Code erstellt gegeben meinen Eingaben und die Eingaben sind in dem Fall aber auch schon wieder. Code und Compiler gibt es gar nicht so viele für so viele Sprachen, der der bekannteste ist halt der C Compiler und der C Plus plus Compiler haben zum Beispiel von GNU, der GNU C Plus plus Compiler ist der bei Linux immer unterwegs ist. Ein bisschen moderneres Tool ist der Klang oder silang Compiler.
Also was man da macht ist, man tippt quasi C plus Plus als Programmiersprache und der Compiler generiert Code und der Code der da generiert wird ist auf der niedrigsten Abstraktionsebene ist n Maschinencode also. Da daran hab ich schon mal überhaupt nicht gedacht im Vorfeld. Ja, aber ich dachte, der kommt. Der der, der, der der Vormalber müssten wir den eigentlich auch mitnehmen? Ja, ja, völlig richtig.
Klar ist ja, Eingabe ist also ist halt einfach Eingabe und Ausgabecode, aber eben n anderer dann ja. Genau und kurz die anderen Dimension angeguckt, der ist ganz klar Build Time. Ja, also.
Ich Tipp halt meine mein C plus plus dahin was die Anwendung wird denk ich ja und dann drück ich auf kompilieren passiert noch nichts so ja und wenn das dann geklappt hat dann kommt irgendwie was ausführbares raus und das ist dann die Anwendung ne also jetzt hier mal kurz verstanden was ich meine mit Zeit wann das passiert wann der Code generiert wird.
Kurze Anekdote viele Jahre zurück gab es eigentlich ja nicht viel andere Sprachen als C und C plus Plus und so weiter C plus Plus war damals ja schon, man nannte das Hochsprache.
Das, was wir heute mit Python und ja, was gibt so haben, gab es halt noch nicht so richtig, war noch nicht so im Feld, weil da hat man halt C plus Plus genommen und ich war ja mal bei den Physikern unterwegs, also auch bei den Teilchenphysikern und das sind ja krasse Leute und die haben damals schon ganz viel Data Science gemacht, hatten aber kein Python. Und dann hast du ja immer den Nachteil, dass du in C plus plus ja erst tippen musst. Dann wird der kompiliert.
Ja, und dann kannst du erst auswerten, ja, dann merkst du erst, ob das geklappt hat oder nicht. Ja, aber die brauchten damals halt schon so was, wie es heute dieses Jupiter Notebook gibt. Du kennst das die Data Science da wo du im Prinzip du Tippst einen Schluck Python rein, ja einen Befehl ja und hast dann irgendwie hast dann irgendwie eine Datenstruktur und dann tippst einen Schluck Python rein und das verwaltet dir die macht irgendeine Statistik da drauf
oder irgendsowas. Und das haben die damals schon gebaut mit C plus plus völlig krass und ein also das war so ein Physiker Framework, das hieß Ruth, Ich würde das mal, würde ich mal in die Runde schmeißen, und das war tatsächlich interpretiertes C plus plus, da hast du also eine Konsolenaufforderung, also hier die Anwendung war halt einfach so eine Cle hatte Cursor geblinkt und da konntest du dann live C plus plus Reintippen hast auf Return gedrückt und hat das
quasi im Hintergrund kompiliert, Code Generation und. Schwupp und dann die Daten die du da hattest irgendwie gleich verwertet und dir die Ausgabe hingepackt. Ja, so ein bisschen wie heute Jupiter Notebook natürlich, also halt so vor 20 Jahren sage ich mal.
Also auch mit natürlich, der wird ja entsprechend weiß ich nicht magnitudes of Orders, weniger Power und so weiter was heute so geht, da konntest du auch keine Bilder anzeigen und so, aber haben die benutzt ja und ich glaube ist sogar heute noch in Benutzung, ja. Ja, ist ein maximaler Effizienzgewinn dann an der Stelle gewesen? Genau, weil auf einmal, auf einmal kannst du halt direkt was machen und hat auch was mit Coach Generation zu tun.
Okay verlieren wir nicht so viel Zeit oder haben noch ein paar andere Tools vor uns. Auf dieser Ebene kann man dann auch mal sagen, kann man dann mal die just in Time Compilers nehmen, also JIT ist da das Stichwort JIT JIT sagt man oft und zum Beispiel Java, also die Sprache Java die eine kompilierte Sprache ist. Die kann unter anderem just in
Time kompilieren. Ja, das heißt, hier ist es ein bisschen anders als ein C plus plus, da hast du ja den Code getippt, dann drückst du auf kompilieren, da hat es geklappt oder nicht und dann hast du deine Anwendung, die verteilen
kannst. Bei Java ist es eher so, du hast den Code getippt und dann kannst du ihn quasi schon ausführen, es ist aber nicht so, dass dieser Code selber ausführbar ist, sondern da gibt es jetzt halt quasi einen Compiler, der während der Laufzeit jetzt haben wir wieder Dimensionen, wann war es ja, aber jetzt ist es quasi während er läuft kompiliert er und führt es aus, ja. Das ist ein ganz interessantes Konzept. Übrigens muss man mal wissen, es
gibt nicht viele, aber es gibt so ein paar Tools, die die quasi während das Programm genutzt wird, erst kompilieren ja und optimieren, das hat natürlich ein paar krasse Sachen, ja, das manchmal sagt man okay das das kann, das ist dann blöd wenn es das erste Mal, wenn der erste Nutzer quasi das erste Mal an diesen Codestellen vorbeikommt, dann muss es quasi noch übersetzt werden und so weiter und das ist besonders langsam sag ich mal. Es kann aber auch Vorteile
haben, dass wenn. Sich zeigt in der Nutzung dieser Software, wenn die zum Beispiel lange läuft, dass es eine Art Service ist. Ja, und immer viele Nutzer einen bestimmten Aspekt dieser Anwendung benutzen, dann wird er halt immer wieder optimiert. Ja, es ist nicht nur just in Time compiling, es gibt sogar just in Time Optimization und so weiter wo halt diese Stelle Co da merkt quasi der das Programm
selber. Oh ich werde hier oft genutzt, ich optimiere das hier noch mal krasser an der Stelle, ja. Das ist jetzt bei Java insbesondere. So, das ist bei Java so genau. Kannst du mich nicht?
Also da gibt es andere Experten, die wissen ganz genau, wie das läuft, aber da, also da gibt es extrem viel Forschung, da passiert immer wieder mehr, dass Java noch schneller wird, das Licht an diesen Hinterliegenden just in Time Compilers und wie gesagt, es gibt auch Head of Time, Compiler und so weiter und Optimizer, die die Ahnen schon voraus was passieren wird, da passiert viel, ja das kann man schon machen und eine wichtige
Anekdote will ich hier erzählen, oder was heißt Anekdote was ich mal gesehen habe, ich habe selber dann nie so genutzt, ich habe in meinem Leben mal grafikkartencode geschrieben.
Da ist die Programmiersprache, die der Wahl, wenn man, wenn man denn mit den Nvidias geht, ist kuda Nvidia kuda Kuda ist sowas wie C mit wilden extra Symbolen, weil Grafikkarten Programmierung auf einem ganz anderen Level stattfindet als normale CPU Programmierung. Ich habe ja diese ganz hochparallelen Ansprüche und so weiter und da habe ich ganz viele extra Anweisungen im Code wie ich dann quasi der Grafikkarte sage wieviel Threads also. Die nehmen soll und so weiter und sofort.
Man schreibt also grafikkartencode und das ist sehr low levelig und es ist es hängt immer ziemlich stark davon ab was für eine Grafikkarte ich habe, während während so ein CPU so ein normaler Computer ja fast immer gleich ist. Und dann ist es auch egal für die Software was ich tippe ist so eine Grafikkarte je nachdem was ich für ein Ding einbaue ob ich mir eine für 200 gekauft habe oder für 2000€ können die halt verschiedene Dinge so nenne ich jetzt.
Wenn ich jetzt zum Beispiel Grafikkartencode machen will, ganz aktuell ist das ja ki oder irgendsowas ja, ich will halt irgendwie was ich will, die Grafikkarte auslasten und wenn ich das jetzt quasi im Vorhinein machen muss, ja da muss ich dann, da muss eigentlich extrem viel optimiert werden.
Im Prinzip muss andauernd Code generiert werden für alle Sorten von diesen Grafikkarten und so weiter das ist halt irgendwie Mist. Ja da kommt man nicht lang, ja, deswegen gibt es in Python ein cooles Ding, das heißt numba, Numba vielleicht und dann tippe ich quasi Python Code.
Und dann sage ich, so, jetzt und jetzt kommt ein Stück Grafikkarten, Krams, jetzt kommt was, was ich auf der Graf, also ich bin in Python, und das ist ja schon cool für Data Science und so weiter und jetzt sage ich okay jetzt kommt eine massive Berechnung, weil ich 1000000 von den gleichen Daten habe, Bilder zum Beispiel, ja, und da will ich jetzt irgendwie Facebook Commission drauf machen, ja, und jetzt schreibe ich quasi in Python ein Stück Kuder Code in Python hin, der das ausrechnet,
also der, der der Algorithmus dafür ist und. Und das wird durch dieses Number quasi gerappt oder angezeigt. Und was dann passiert ist, dass in während der Laufzeit krasserweise Python kommt an an diese Stelle, dann sieht es oha, jetzt kommt Grafikkarten Code, dann guckt Python live. Was ist denn das für eine Grafikkarte die ich jetzt hier gerade unterm Hintern habe, je nachdem bei wem das ausführt und generiert kompiliert hochgradig performanten GPU Code hin Code
Generation in Python und. Da generiert Python quasi Low Level qder Code und dann wird er eingesetzt und läuft.
Ja, das heißt das erste Bild was da bearbeitet wird dauert unglaublich lang, das wäre schneller gegangen als du mit Python selber geschrieben hättest oder mit Java Script sogar ja weil da muss erst mal gucken, was habe ich da bin ich Grafikkarte und so weiter rechnet das hin guckt das und dann geht es aber ab ja dann hast du nämlich dann hast du vielleicht 2 Sekunden gebraucht sag ich mal für das Kompilieren von dem Kram und dann kriegst du auf einmal eine Performance von
der Grafikkarte. Wo du das, wenn du das nur im Python geschrieben hättest, in 10 kalten Winter nicht gerechnet
hättest? Ja, das ist auch für mich Co Generation auf auf eine krasse Weise, das ist ich glaube ich bin nicht mehr so im Python Welt und im Data Science unterwegs zurzeit, ich glaube das ist Standard wird überall eingesetzt ja weil du hast nämlich auch keine Lust dann nur weil es irgendwie mal kuda Code gibt alles in C zu schreiben, den ganzen Rest der Anwendung, du bist ja auch irre, du willst dann halt beide Welten ja du willst schnell sehr komplexe
Anwendungen schreiben und dann aber hochperformant Stücke irgendwie. In dem Fall generieren lassen und einbetten. Also ändert sich dann dieses Stück Cuda oder könnte man das nicht einmal auch einfach schreiben? Tust du auch im Code bleibt das
gleiche. Du schreibst quasi den Grafikalgorithmus hin, erkenne mir das Gesicht und das ist ein festes Programm, das kannst du überall verteilen, aber der generierte Code, der sieht halt immer unterschiedlich aus, je nachdem bei wem dieses Programm ausführt. Der guckt halt zur Ausführungszeit.
Das ist ja die Dimension 2, die ich gesagt hatte, während das Programm läuft, guckt er gerade, was ist denn was habe ich unterm Hintern, eine Grafikkarte 23 und welche Sorten und dann wird quasi aufgrund dieser Erfahrung, die während die Anwendung läuft wird dann hochoptimiert nur für diesen für dieses Hardware Setup cooler Code generiert, das ist halt extrem cool.
Ja, das war das, was mir fehlte. Also das heißt die Infrastruktur. Also beziehungsweise mein Code ist bereit für sich verändernde Infrastruktur darunter. Genau das ist Code Generation at Runtime. Das ist, das ist das High Level, finde ich. Also ich finde es cool, das funktioniert aber.
¶ Build-Time-Optimierung
Ja, sehr cool. Das war ebene 1 tiefste Ebene. Jetzt fahren wir im Fahrstuhl ein bisschen höher, mittlere Ebene von Code Generation Abstraktionsebene, da würde ich sagen, sind wir so bei den Optimizern Minimizern und Obsfocatern weißt du was ein Obsfocator ist, Gerrit. Natürlich nicht. Kennst du das Wort obsfocation? Obsfocation ehrlich gesagt nicht.
Nein, das. Ist, wenn du was unleserlich machst kurzer kurzer Seitenaustritt wenn du, wenn du jetzt eine kompilierte Sprache hast wie C plus plus, dann erhältst du ja Maschinencode als das Stück was du verteilst. Also eine Punkt exe sage ich mal für alle Windows ja eine Punkt exe, da kannst erstmal nicht reingucken.
Ja das heißt du kannst halt quasi closed Source verteilen, ne also dein dein Sourcecode bleibt halt quasi dein Geheimnis, vielleicht sogar patentrechtlich geschützt und wenn du ihn kompilierst in der exe. Da musst du schon ziemlicher Experte sein, um da wieder auf den Source Code zurückzuschließen. Der ist quasi in sich geschlüsselt, weil das
Maschinencode ist. Das ist aber dann nicht mehr so, wenn du den Maschinencode Ebene verlässt, wo wir in die interpretierten Sprachen gehen, da bleibt ja quasi der Quelltext erhalten, den brauchst du und dein Programm verteilst du quasi mehr oder weniger im Quelltext, weil der quasi interpretiert wird und das ist ein Problem, wenn du eigentlich deinen deinen Quelltext schützen möchtest. Weil dann kann ja jeder, der das Programm hat, der macht es halt auf.
Ja, also der, der klickt es quasi nicht doppelt, dass es ausführt, sondern der macht es halt quasi im Editor auf und dann sieht er halt den Quelltext ja so n bisschen wie wir im Browser sagen, ganz rechts Klick zeigt mir den Quelltext von der Webseite an und nicht die Webseite, sondern das HTML
dahinter. Ja das kannst du halt machen, ja. Und n Obstfucator der Macht nichts anderes als der lässt im Prinzip die Logik von dem Code, aber der der schreibt den Quelltext halt so hart um, dass keiner mehr das verstehen kann, heißen die Variablen halt AZY so ganz komisch also die Ganze die ganze Formatierung wird aufgehoben und die ganzen Variablennamen werden randomisiert, da raffst du nichts mehr das gleiche die gleiche Logik, aber mit mit so hart verschiedenen Namen und so
hart verdreht, dass du das halt eigentlich auch nicht mehr schnallen kannst. Ja und das ist auch ne Wissenschaft für sich, dieser Obstfucator.
Sind aber auch Teil von Co Generation ne und die anderen die ich gesagt habe gerade Optimizer und Minimizer die sind die sind andauernd im Einsatz, denn wenn du heute webtechnologie hinschreibst, also wenn du zum Beispiel ne Rack Seite programmierst Dann wird die, bevor die losgeht, also so eine Reg Anwendung wird, die hart durchoptimiert, dass die auf allen Browsern läuft, über alle Zeiten hinweg und dass die möglichst schnell und performant ist, weil du hast das
vielleicht noch nicht so toll aufgeschrieben als Softwareentwickler und das ist ja unglaublich schwierig. Ja, und dann kommt so eine Art Code Generation an den Start, zum Beispiel durch Tools nenn mal 2 Webpack ist 1 der wichtigsten größten, die nimmt halt quasi deinen Java Script Code. Und Bandelt es in ein kleines File. Das wird dann ganz klein
minimiert. Ja und Hochoptimiert es dauert auch lang dieser Prozess, wenn du eine große Anwendung hast, dauert das ja, dann braucht Webpack richtig lang um daraus ein schmales statisches Javascript Bundle zu machen, was dann auf allen möglichen Browsern richtig cool läuft und so weiter ja veed ist ein neueres Tool was das was auch in
diese Richtung geht. Ja und gerade so für für React und Swelte und wie sie alle sind, diese ganzen Dinger ist das halt das unterliegende Tool bevor du quasi das irgendwo. Deploys oder Hostist läuft erst mal Webpack und wie drüber und generieren dir hochoptimierten Webcode an der Stelle. Das hab ich glaub ich noch nicht ganz verstanden.
Also deinen Code, den schreibst schon du oder je nachdem kommen wir wahrscheinlich noch drauf, kann ja sonst wie generiert werden aber gehen wir mal von aus ist vom Entwickler erst mal geschrieben und das bleibt dann der gleiche also also der wird eigentlich eher optimiert, aber dabei wird gegebenenfalls neuer Code generiert letzten Endes das ist. Die nicht nur optimiert ne es wird halt wirklich viel
generiert, weil. Weil du schreibst quasi auf einer anderen Attraktionsebene. Wenn du direkt heute hinschreibst, dann hast du ein modernes Java Script mit bestimmten Syntaxen, also mit Modulen, laden und so weiter das funktioniert aber mitnichten auf allen Plattformen und auf allen Browsern, das heißt, es wird für alle Browser, die zum Beispiel das nicht unterstützen, das direkte Laden von bestimmten Paketen und so weiter wird dann quasi geweichter Code extra Code
hingeschrieben, weil die Tools das können, so dass dieser Browser mit deren Technologie das versteht. Also sind Abhängigkeiten dann auch reduziert. Auch das. Ja genau, und die Abhängigkeiten werden eingebaut und angeguckt und so weiter und Duplikate werden weggelöscht und und und und ja also da passiert also da verschwimmen verschwimmen die Welten zwischen Optimierung und Generierung ja also Generierung um quasi noch den den alten
Internet Explorer mitzunehmen. Du musst das übrigens auch ausdrücken, ja du kannst ihn beim Webpack angeben, in Prozent machen wir das meistens wieviel wieviel Prozent der aktuellen Browser noch unterstützt werden sollen.
Ja und wenn du das. Wenn du, wenn du sagst, ich will ganz viel unterstützen, also ganz breit und ganz weit nach hinten über die Zeitleiste, dann erhältst du viel größere Pakete, weil viel mehr Code generiert werden muss, um dann noch die ältesten, den ältesten Scheiß quasi auch noch zu workarounden sage ich mal. Damit es noch im alten Browser arbeitet, da ist ganz ganz viel Code Generation dabei kriegst du
nicht mit. Zielgruppe ist hier Entwickler, aber stell dir vor, sowas wie Webpack wird es nicht geben, dann wären wir in der Webentwicklung, dann bräuchten wir. 50 mal so lange, bis wir ein Produkt raus haben. Wenn das reicht. Faktor 50 ja. Webpack und und wie sind die dann integriert in deine Idee oder lädst du da irgendwas manuell noch rein?
Wahrscheinlich auch nicht. Nein, die Idee an der Stelle ist es tatsächlich nicht integriert, sondern wenn du jetzt quasi direktanwendungen Programmierst, dann musst du dich eigentlich am Anfang entscheiden. Also keiner macht das mehr per Hand dann. Auf welcher Basis du das machst.
Und dann installierst du Abhängigkeiten, also also Webpack und Viet kommen quasi als Abhängigkeiten mit dazu und die kennen React und Felte und die ganzen ganzen guten Frameworks. Und dann gibt es eine Anleitung, dann sagst du quasi, dann tippst du quasi deinen React Code hin und dann sagst du npm, also notepackage Manager run, dann läuft erstmal der Development Server, der wird auch leicht optimiert, aber wenn du jetzt quasi das. Als Produktivanwendung raushauen willst, dann musst du das
richtig bauen. Das heißt dann ein Bild und dann dann kommt Webpack an, das ist ein Tool, das ist dann aktiviert, das hat dann Zugriff auf deinen Source Code, guckt
den an und und und. Paketisiert den optimiert den quasi hin und das das Ergebnis davon ist ein Bundle, ein sogenanntes Bundle Java Script Bundle und das kannst musst du dann wieder in die Hand nehmen weil deswegen generiert der Code ja das ist schon ein Java Script, das ist fertig und das ist lauffähig auf allen möglichen Browsern und das kannst du quasi dann einfach statisch hinterlegen an irgendeinem Webserver zum Beispiel Patchy oder Irgendsowas. Ja was du halt Bock hast oder
einen Engine X oder irgendsowas ja und der Browser ruft dann auf und dann sagst du, hier hast du dein Java Script gestirbt wird glücklich, ja und das funktioniert meistens hundertprozentig, weil halt webkit eine gute Arbeit Entschuldigung nicht webkit sondern Webpack eine gute Arbeit. Gemacht hat okay krass, ja. Das ist ebene Ebene 2. Ja, hast schon recht, auch wieder nicht auf dem auf dem Schirm gehabt.
Natürlich als nicht Entwickler. Ja, ich glaub du willst, du willst natürlich auf die Folgenmäßig, auf die höheren Ebenen, da hängen wir uns auch gleich hin, aber ich wollte sagen, wir haben alcedo ja das ist irgendwie, weil weil es ist überall co Generation ne weil wir wir wollen uns natürlich das Leben einfacher machen ja wir schrauben ja auch ein Auto nicht mehr irgendwie bei den Muttern und bei den Schrauben zusammen, sondern werden auch da immer modularer ja und die gibt es,
die Abstraktionsleben gibt es halt überall ja. Nein, ich will. Also ich will, ich will nirgendwo hin, Lukas, ich, ich find genau das tatsächlich ja spannend, weil das ist ja halt einem nicht klar, aber das ist auch wahrscheinlich anderen nicht so klar, wie du schon sagst, gibt es das nicht, müsstest du dafür sorgen, dass was weiß ich der Edge Browser noch unterstützt wird und womöglich noch der Internet Explorer irgendein Scheiß ja jetzt wahrscheinlich nicht mehr ne aber.
Das ist manchmal auch, das ist vielleicht dann auch nicht so ganz klar, aber das sind manchmal so diese Probleme, die man nicht versteht, wenn auf einmal alle gleichzeitig irgendein Schmerz haben, ja, wenn irgendwie alle Web Tools n Schmerz haben. Dann dann kann, dann liegt das manchmal daran, dass zum Beispiel bei Webpack irgendein Problem war. Jetzt muss man mal sehen, was
für ein Marktanteil da ist. Ja, das sind halt irgendwie so 90% oder Irgendsowas alle modernen Webseiten gehen halt durch sowas durch, ja wie Webpack oder wie ja so und wenn die einen kleinen Schmerz haben und wenn die halt quasi systematisch immer irgendwas falsch machen, dann hast du halt systematisch im ganzen Internet irgendeinen Schmerz, ja der ist dann auch schnell wieder weg, weil weil du weißt ja die die
¶ Hochsprache generiert Hochsprache
die Time ist ja nicht so wie früher, dass du einmal pro Jahr irgendwie Release raushaust, sondern eher einmal pro Woche oder irgendsowas ja. Insofern kannst du das auch schnell wieder weg haben, aber da kriegst du manchmal so so krasse Effekte hin, dass irgendwie das halbe Internet
kaputt ist oder irgendwie? Das liegt doch manchmal dabei, dass da solche solche Tools, die Halt in so einer Tool Chain so einer Co Generation Tool Chain zum Beispiel mitlaufen, dass die vielleicht mal ein Problem haben oder der Browser irgendwas inkompatibeler, die wissen sehr genau was diese ganzen Browserhersteller machen, so, das ist echt krass das Hightech
dahinter. OK, das war für mich ebene 2 nach den nach den Compilern war jetzt quasi so Optimizer Minimizer und Obst focators wie ich sie genannt hab, ebene 2 Ebene 3. Ich hab sie mal hohe Ebene genannt ist wenn ich jetzt sage Hochsprache generiert Hochsprache ja also jetzt kommen wir so eher, dass in das, was man vielleicht normalerweise über Co Generation denkt, also wenn ich zum Beispiel in der Programmiersprache jetzt noch ein bisschen ältere wie Pearl ja Pearl generiere, ja, also ich
benutze eine Programmiersprache. Und programmiere damit, dass quasi mit ihr selber wieder ein Programm entsteht. Klingt ein bisschen irre, kann man ja aber machen, man kann ja einfach String generieren lassen von der Programmiersprache und dass das Sinn macht und wo das Sinn macht.
Kurze Anekdote auch aus meinem eigenen Leben ist ja immer am besten, dann erzähle ich wenigstens kein Quatsch, weil ich es selber schon probiert habe und es funktioniert hat, das war damals, das ist jetzt auch glaube ich schon locker 10 Jahre her, ja vielleicht schon 15, da durfte ich mal in Stockholm. Die ersten Einblicke haben in künstliche Intelligenz haben sie haben sie es damals schon genannt hatte, mit dem, was wir da heute machen, nichts zu tun.
Es war eher so eine Art, dass man Evolution nachgebaut hat, und da hatten wir ein großes Pearl Programm, also der Professor hatte das, ich war da Student, und ich durfte da mitmachen und dieses Pearl Programm hat ganz viele kleine Mini Pearl Programme hergestellt, die am Anfang total randomisiert waren, ja das konnte quasi.
Also dieses Oberliegende Pearl Programm wusste quasi von der Syntax wie man Pearl Programme zu schreiben hat und grundsätzlich so, dass die sind taktisch richtig waren aber inhaltlich völliger Gammel. Ja und dann hat es quasi 20000 kleine Programme geschrieben, die hat man losgelassen auf eine auf eine sogenannte Fitnessfunktion, die sollten irgendwas machen, ja zum Beispiel Pi ausrechnen, so habe ich das gelernt, habe ich es beigebracht bekommen ja, alle
diese Programme wurden wurden dafür gecheckt wie genau jetzt pi ausgerechnet wurde. Ja von manchen kam halt irgendwie 42 raus, bei den anderen 3480 und so, dann kannst du ja messen. Der war am dichtesten dran.
Ja, und dann wurden diese Programme durch diese große Plattform quasi, die wurden unterzogen wie Population, ja die hatten dann die besten hatten, dann durften sich dann vermehren, also die hatten Sex miteinander, da hat man quasi Programmteile wild ausgetauscht, ja n bisschen rummotiert, also wie das auch im Leben ist so und dann hat man das simuliert ja über Generationen lang ja 100000 Jahre ja.
Und dann hast du quasi also so ne Art Population von Pearl Programmen geschaffen und ne Engine gehabt. Immer wieder Pearl Programme hergestellt hat und zum Schluss hattest du nen Programm was irgendwie kannst du reingucken war generierter Code ja völliger Wahnsinn, hat aber auf 120 stellen pi akkurat ausgerechnet. Ja ist ziemlich erstaunlich, ja es funktioniert so n bisschen bisschen fast der Computernachweis, dass die dawinsche Theorie auch nicht
kompletter Quatsch ist. So ja du kannst also aus kompletten randomisierten Kram. Wenn du einen Selektionsdruck von außen hast, nämlich rechne genau pi aus. Du bist der Beste, wenn du ganz nah pi ausrechnest. Ja kriegst du durch Codenervation tatsächlich
erstaunliche Sachen hin? Ne, das war meine Anekdote zu Hochsprache, macht Hochsprache und zwar in der Dimension Runtime. Ja zur Laufzeit passiert das alles ja und da wird also das Programm läuft, generiert Code und läuft und läuft und läuft und das lief auch tatsächlich ziemlich lange auf dieser Ebene. Hochsprache generiert Hochsprache würdest du da auch sowas wie wie Flatter oder so einordnen, mit dem man ja quasi. Meine dart Anwendungen schafft
oder so wenn ich es richtig. Verstanden habe ja ja, auf jeden Fall würde ich schon auch flatter und auch diese, das sind dann diese bildtime Sachen ne also genau du hast dann quasi eine Hochsprache, die generiert dann wieder einen Java Code oder irgendsowas jetzt sind wir da wo du Gerrit wo du sagtest ist das in der IDE eingebaut, ganz oft sind erst auf diesem Level hast du das in den IDES also in Integrated Development environments drin. Und ich nenne jetzt mal in die
¶ Grafische Programmierung
in die Vergangenheit gesehen. Früher gab es das auch schon, zum Beispiel bei Windows gab es mal diese ATL und com ist gerade wieder hochaktuell bei uns, weil wir eine alte Maschinenanbindung machen müssen und da gibt es auch wieder dieses atl.com Krams, dieses C plus plus Zeug, das kannst du im Leben nicht mehr programmieren, da drückst du auf den Knopf und dann generiert dir Visual Studio in dem Fall erstmal ganz viel C plus plus Code. Ja und dann füllst du das quasi
aus ja und dart ist nichts anderes, da hast du recht, ja und? Dann ist die Frage, wo man da
hingeht. Ich würde sagen, da ist man ja immer noch beim Tipsen, so noch beim Entwickeln und jetzt kommt man nämlich auf die höchste Ebene, dann mache ich jetzt mal den Übergang, die höchste Ebene, der der Code Generation und halt diese Tools ja wie du gesagt hast dart, da hast du noch visuelle Hilfsmittel ja Visual Studio zum Beispiel wenn du Windows Anwendungen machen möchtest, da gibt es dieses Wpf Windows Presentation Foundation. Und dann hast du so Drag and
Drop Elemente schon in der Idee, also im Visual Studio Code kannst du quasi schon die Fenster anlegen und siehst die schon vor dir und verbindest die mit Code, Logik und so weiter per Drag and Drop, das ist schon high levelig ja und gleichzeitig siehst du quasi wie im Visual Studio der Code generiert wird.
Ja das ist jetzt also Perspektive noch für den Entwickler aber schon richtig high Level, du machst quasi UI Programming, bastelst quasi die UI und der Code für die UI die du dann gerne hättest entsteht quasi unter deinen Händen ja so funktioniert halt auch dart ja. Das war jetzt dein Hauptunterscheidungsmerkmal, dass du wirklich grafisch schon Dinge tun kannst, auf dieser höchsten Ebene, die du jetzt genannt hast, während auf der hohen Ebene du immer noch Code
hast, der dann wieder Code generiert. Genau so habe ich das jetzt mal in meiner schnellen, in meiner schnellen Kategorisierung so gemacht. Aber ich glaube, das macht auch Sinn. Ja, weil auf dieser hohen Ebene, sage ich mal, noch nicht die höchste auf der hohen Ebene kannst du auch schon Code generieren lassen, der schon hochsprachig ist.
Der bleibt aber quasi, deine Generierung bleibt quasi immer noch so Ausfüllen von Templates oder klicken von ich brauche jetzt eine RTL Klasse und so weiter und dann wird dir was hingeschwubst ja während du dann auf dem höchsten Ebene tatsächlich sehr dynamisch auch vorwärts und rückwärts quasi dann mit UI Elementen und Drag and Drop wird dann wichtig ja also wirklich Ui, wo du dann richtig quasi was designen
kannst, was du schon siehst. Ja und da kommt dann die ganze grafische Programmierung, hält er auch rein und wenn wir da auch mal ein bisschen kurz zurückgucken so in die Anfänge. Da gibt es auch so so Tools, die kennt man vielleicht, wenn man
aus der Welt kommt. Ja so zum Beispiel die ganzen PLC Entwickler, die haben jetzt jetzt gucken wir mal, also Code ist ja an wir, wir denken immer anwendercode so ja Code der irgendwie auf dem Telefon läuft oder auf dem Desktop oder sowas ja aber es gibt ja auch Code der auf der Maschine läuft PLC Code ja da ist ja die Zeit jetzt auch nicht stehen geblieben ja die tippen jetzt auch nicht mehr PLC Code hin ne?
Sondern da gibt es zum Beispiel von Siemens, das die Simatic ja ist, auch ne krasse Idee. Ich glaub die ist mittlerweile in Visual Studio angedockt oder von Beckhoff auch ne große Automatisierer, das Twin Cut. Ja das sind also in sich selbst krasse Toolkits. Ja richtig krass, also voll mit Grafikelementen und so und da machst du grafische Programmierung ja, da sagst du IF LS so mit so mit so Flow Chart, Diagramm und so weiter und sofort, ja machst quasi dann
Algorithmus grafisch hin mit Patrick and Drop und drückst auf den Knopf und dann dann sagst du hier ich muss jetzt Code generiert haben für. Für meine SPS ja so und dann wird das auch Hochoptimierter rausgelassen, so ja das kaum noch jemand schreibt quasi SPS Code per Hand hin. Was was ist ein SPS Code? Ist das auch eine eigene Programmiersprache oder gibt es da eine pro Hersteller? Wie kann man sich das in der Welt vorstellen?
Ja, da gibt es. Im Prinzip gibt es da auch eine, also es gibt auch eine Art Programmiersprache, die ist aber anders jetzt als so eine normale Software Sprache, das ist viel limitierter, was du da machen kannst und so im Prinzip kann man sich das vorstellen wie eine sehr gute. Wieso eine sehr basale Programmiersprache so früher?
Vielleicht wäre jemand noch so ein bisschen Basic kennt, da gibt es auch noch Nummerierung und so weiter und Go Tools und so das genau das gibt es da schon, das ist aber auch nicht vereinheitlicht, das hat ein bisschen, also das ist alles viel Hardware nachher, das ist nicht so standardisiert und da helfen dir halt auch die Tools so ein bisschen.
Die Analogie ist so ein bisschen wie du die verschiedenen Browser hast, dass du da halt die verschiedenen Spsen und die Hardwares und da kommen halt auch die Tools und kennen die und wissen dann schon was du da für einen optimalen Code
rauslassen musst. Und wenn man da ein bisschen weiter in der Zeit geht, dann dann kann man noch die, dann verlässt man diese Maschinenebene wieder und dann geht man so in die Data Science. Da gibt es dann die Tools Smart Lab und Lab View. Kennt man auch, Lab View ist auch so ein grafisches Programmierding ja und wenn du dann noch eine Ebene höher gehst, dann bist du bei Mendigs oder Irgendsowas jetzt auch von Siemens zum Beispiel ein Tool.
Ja Mendigs ist dann schon richtig krass während also während du bei Twin Cut und Simatic da machst du ja quasi noch so kleine jetzt kommen wir jetzt wird die Ebene der Komplexität total wichtig, die Dimension die ich am Anfang sagte, Ja. Denn das kommt jetzt dazu.
Wir generieren jetzt hier nicht nur mal noch eine Funktion, ne wir überlegen, gucken wir gerade noch mal was ich bei Python gesagt hatte, da generierst du quasi n Algorithmus, der zum Beispiel irgendwie ne Bilderkennung macht oder irgendsowas ja das das bleibt also in der Komplexität relativ klein so, das hat ein Funktionsaspekt innerhalb deiner Business Logik. Ja und jetzt auf dieser höchsten Ebene jetzt fangen wir halt ab an die Komplexitätsdimension
Aufzupusten ne, jetzt entsteht hier schon auch Code, der quasi grafisch angelegt wird und dann vielleicht sogar weil es jetzt auch wo wir quasi diese. Programmierebene verlassen und wo wir in UI Designs kommen grafische Programmierung verlassen wir jetzt auch bei der Dimension Zielgruppe den Entwickler so ein bisschen und werden zugänglich für nicht Entwickler oder technikaffine sage ich mal, die dann auf
einmal, die können das ja auch. Ja, also grafisch programmieren und hin und herziehen von Elementen und einfach logisches Verstehen von einem Algorithmus. Das ist ja auch, sag ich mal,
nicht Entwicklern inhärent. Ja, das wenn man da, wenn man dann Fable für hat, kann man das schon können und da muss ich aber mich nicht auskennen wie schreibt welche Klammern muss ich setzen und ist das away oder irgend so ne Scheiße sondern ich sag halt das und das will ich haben ja wenn dann Beziehung und so weiter ja und und und dieses also Code auf dem Level ist ja dann auch schon viel Fluss ja wenn wenn der auf den Knopf drückt dann schickt ne e Mail dahin und wenn das geklappt hat
machst du noch das und das und so weiter also auf dem Level ja und? Das ist die krasseste Abstraktionsebene und der ganze Code dahinter wird dann halt durchgeneriert und dann erreichen wir halt auch die ganz aktuellen Systeme, so wie Out Systems und so weiter.
Wenn ich jetzt MATLAB oder labview benutze, ich benutze das und baue aus 34 Modulen da irgendwas auf und dann machst du das gleiche aus den gleichen 34 Modulen kommt dann da genau der gleiche Code bei uns beiden hinten raus oder ist da eine gewisse Flexibilität drin? Weißt du was ich meine? Ja, ich weiß was du meinst. Das ist eine sehr gute Frage und ich würde sagen, ich würde mal ein vorsichtiges Nein sagen bei Lev View. Das ist schon.
Also du kannst ja auch grafisch sehr unterschiedlich programmieren, ne und Sachen elegant lösen oder nicht so elegant irgendwie und ja ich weiß nicht, MATLAB ist ein ganz krasses Tool, vielleicht optimiert das das auch noch hin und weiß das alles so ja und sieht irgendwie sieht irgendwie das was du tun willst. Und versteht noch mal mehr. Und aber das wär, das ist dann schon noch n krasseres Level.
Ja OK. Also jetzt so angenommen man würde wirklich das exakt gleiche tun, du und ich, dann käme auch das exakt gleiche ein Code. Das ist richtig, das ist so. Ja genau das. Was ja bei KI nicht zwingend so zum einen wäre. Nicht, ja. Ja, aber da dort schon. Aber du meintest jetzt, wenn wir. Das gleiche Ergebnis erreicht mit unserem Code aber der jetzt vielleicht nicht genau baugleich ist, also der grafische Code, dann in dem Fall.
Ja, genau, genau, ganz genau. Also wenn du, wenn du, wenn du auch grafisch leichte Unterschiede hast, dann wird also quasi auch der Code der generiert wird leicht
unterschiedlich sein. Das schätze ich schon bei den meisten Tools, die Code generieren, aber wenn du natürlich die gleiche grafische Grundlage hast, kommt dann auch das ist solange die nicht KI mit drin haben, heute wird das ja immer mehr mit KI und so weiter also solange KI nicht im Spiel ist, kommt dann auch exakt der baugleiche Code wieder raus, ja.
So, ja genau, und du hast gesagt, KI Gerrit, das brauch ich nicht sagen, aber das ist also jetzt kann man entweder in die höchste Ebene packen oder in ins Penthouse sag ich mal. Ja, das ist ja noch mal ne ganz neue Schiene wie wir Code generieren lassen können, aber und jetzt sag ich das auch gleich hier und da gibt es noch ganz andere, da gibt es ja Leute die schreiben darüber Bücher ist jetzt KI die Zukunft, müssen wir
¶ Code Generation mit KI und ihre Grenzen
überhaupt gar keine Software mehr schreiben, weil KI ja irgendwie in der Lage ist ganz krass Code zu generieren und das stimmt ist es auch. Und auch auf allen möglichen, auf allen möglichen Sprachen und so weiter aber in der Dimension 3 Komplexität würde ich sagen, kann KI überhaupt noch nicht
liefern. Also KI kann genauso wie ich das jetzt bei den Python im Beispiel gesagt habe, es kann mal eine Funktion machen oder eine Klasse oder vielleicht auch ein bisschen mehr, ja irgendwie, aber es hört auf zu funktionieren, wenn du sagst, ich will komplett irgendwie eine ganze Anwendung mit richtig viel Business Logik. Durchschreiben lassen als Code schreiben lassen von KI.
Ja, das habe ich noch nicht gesehen, den den möchte ich sehen, der soll mich anrufen, ja der der sagt, er hat das ja und weil da musst du ja auch über andere Sachen noch Gedanken machen, dann musst ja also wie sagen wir denn heute KI, dass es Code generieren soll, das mache ich ja meistens, indem wir irgendwie prompten noch ja, und ob du jetzt prompt ist, indem du reinlaberst oder tippst, das sei ja mal, sei ja mal gerade da
hingestellt, ist egal. Aber du musst ja der KI quasi dann durch dann die humane Sprache. Das ist jetzt die Hochsprache oder die höchste Sprache, musst du aber trotzdem sehr akkurat sagen, was deine Anwendung können soll und da sind wir bei den Problemen, die alle Softwarefirmen haben, die mit Kunden zu tun haben.
Du versuchst ja als Softwarefirma dem Kunden zu extrahieren in der Hochsprache der Menschen, was sie überhaupt genau haben wollen, das ist ja schon gar nicht so einfach, also also du musst ja erst mal in der Lage sein, mit normaler Sprache, und die ist da vielleicht gar nicht so geeignet für sogar. Die ganze Logik aufzudröseln, die dann die KI machen soll. Ja, und jetzt betreten wir ein neues Thema, Gerrit, das kannst du dann gleich anmoderieren, denn das ist nämlich das krasse.
Jetzt haben wir nämlich finde ich jetzt also jetzt mal die Gedankenwelt von mir, versuche ich euch mal auf der Audiospur wiederzugeben, wir haben jetzt ein unglaublich krasses Tool der Code Generierung, aber wir wir verbinden jetzt Welten die halt irgendwie so was sind wie ich bin im Satellit ja. Und und bei den Regenwürmern. Ich bin im Satellit und spreche
¶ Software-Erstellung "code-frei"
mit der menschlichen Sprache und lass dann was generieren, was irgendwie auf Regenwürmerniveau ist. Weißt du was ich meine, also das, was entsteht, was die KI macht, das ist ja, das ist ja schrauben, Nägel und so weiter Muttern, das ist das Zusammenzimmern von einem Auto aus Einzelteilen, nicht aus Blöcken, aber die Anweisung gebe ich quasi aus dem Satelliten, also Hochsprachiger geht es ja nicht. Das macht keinen Sinn.
Ja, wir brauchen was dazwischen, ja, viel sinnvoller wäre es quasi nicht, überhaupt gar nicht mehr über Code Generierung nachzudenken auf dem Level des Codes der Programmiersprachen, sondern wir brauchen was blockartigeres, was schon aus Code gemacht wurde, Blöcke ja wie beim Auto sage ich mal es gibt es gibt irgendwie schon Fensterheber, Türen.
Knöpfe und so weiter ich muss die nicht erst noch 3 d drucken und irgendwie die und irgendwie die die Cut den Cut Zeichnung von dem Knopf an Radio irgendwie noch irgendwie definieren, sondern es gibt halt den verdammten Knopf. Ja dann gibt es halt nicht jeden Knopf sondern halt ne Palette von Knöpfen und da ist dann gleich schon mal die Einschränkung, aber halt so what? Ja gibt es halt ne Best Practice wie die Scheiße halt auszusehen
hat. Ja und das macht du kannst ja auch bei deinem Audi nicht sagen mein Radio. Volume Knopf sieht halt so aus in meinem Audio in meinem Audi. Ja, das ist nicht drin. Ja also sagen die kannst du vergessen. Ja selbst wenn du 10000€ extra zahlst kriegst du das halt nicht, ja kannst halt, kannst halt irgendwie das High End Radio nehmen, da sieht es halt so aus das Mittelgute oder das billige ja ist halt modular ja.
OK, das müssen wir uns jetzt noch mal kurz auf der Zunge vergänzen ja, du wirst da emotional sehr emotional. Also du sagst KI kann super Code generieren. So das steht glaub ich außer Frage. Solange das Problem klein genug ist und gut genug beschrieben
werden kann. Je größer das Problem wird oder das Thema was ich eigentlich lösen will mit diesem Stück Code, desto schwieriger wird es eigentlich zu beschreiben, vor allem mit unserer Hochsprache, die wir nun nun mal sprechen als Menschen, ja, und deshalb müssen wir dafür sorgen, dass es irgendwelche Blöcke gibt, die ein bisschen kleiner sind als die als die Schrauben und Muttern, sondern die dann halt schon fertige Blöcke sind, die ich.
Mit meiner Hochsprache aber viel besser dann beschreiben kann oder deren Zusammensetzung ich besser beschreiben kann. Ne oder beziehungsweise irgendwas wo ich was ich reingebe wo dann die KI weiß oder wer auch immer. Wie setze ich das eigentlich richtig zusammen? Ne OK, das war jetzt vielleicht auch n bisschen verwirrend, aber. Nee, nee, aber das ist schon gut. Du hast in eigenen Worten schon genau das wiedergeben, was ich gesagt hab.
Ja so, das heißt Code Generation sagst du ist in auf dieser Ebene gar nicht so sinnvoll vielleicht. Nee, überhaupt nicht. Ja, Code Generation ist sinnvoll, wenn ich quasi. Wenn ich die Module baue, ja.
Wenn ich zum Beispiel tatsächlich, und da bin ich nicht auf dem Level des Endanwenders, ja, wenn ich als Entwickler zum Beispiel jetzt gerade diese Blöcke bauen möchte, ja und will quasi eine Bibliothek von konfigurierbaren Möglichkeiten, ich nehme mal jetzt was, ja, was man anfassen kann, Buttons zum Beispiel, ich, ich, ich baue jetzt einen einen Low coat Toolkit, das machen wir, deswegen kenne ich da aus, ja. So, und jetzt will ich meinem
meinem Nutzer, der später eine Anwendung dem Endnutzer, der eine Anwendung da rein no coden will, dem will ich jetzt quasi eine Auswahl von Knöpfen zur Verfügung stellen. Buttons die ich andrücken kann, dann würde ich sagen lass nicht den Button auch noch generieren, sondern nimm halt zum Beispiel KI und sag der generieren wir mal 10 verschiedene 10, möglichst unterschiedliche Knöpfe. Und unter den 10 kann dann der Endwender ausblenden.
Ja, so und dann, und da bin ich auf dem Level, dass ich tatsächlich CSS javascript Code irgendwie generieren muss oder sogar SVG grafikelemente. Ja und dann kriege ich sehr schöne Buttons so, aber dann dann bleibe ich auf der Ebene des Knopfes wenigstens mal ja. Und dann später die die die die Low Code Logik ja da sage ich dann ich brauche den Knopf, den
wähle ich mir aus. Ja und das ist dann aber da hat es nicht mit Code Generierung bin ich dann nicht mehr da bin ich bei Code konfigurierung ja indem ich sage nimm den ja oder den oder den, die haben halt eine Idee, davon bin ich fest überzeugt und ich glaube das hebelt alle diese Diskussionen aus, die würde ich immer ganz gerne. Es gibt bei linkedin so viele Diskussionen, macht Ki jetzt so ist jetzt KI gibt es jetzt bald keine Softwareentwickler mehr?
Ja weil wir haben ja jetzt KI. Also jedenfalls nicht, wenn wir KI zum Code generaten benutzen, dann wird es nie so sein.
Das würde ich mal so, das würde ich jetzt mal frei rauslassen, nie, nie das Wort, nie ist zu stark, ja, aber das wird in den nächsten Jahren nicht so sein und ich glaube wir sollten die KI dann lieber einsetzen um komplexe Sachen zu bedienen oder zu konfigurieren, also die KI kann ja alles mögliche, die kann ja nicht nur coden, die kann ja auch Sachen aufrufen, Funktionen aufrufen und auch Sachen konfigurieren, ne? Die dann muss die KI eher lernen. Was gibt es denn für Möglichkeiten?
Ich sag mal jetzt Photoshop zum Beispiel, weil das jeder kennt, ja, ist ja total kompliziert, wenn du keine Ahnung hast von Photoshop, da alleine nur mal einen Kreis zu malen im Schatten oder irgendwas, ja so das kann ja aber die KI wissen und die KI muss ja dann nicht den Kreis mit dem Schatten und den ganze Photoshop Hincoden und generieren, sondern die muss wissen wie welche Funktion muss ich im Photoshop aufrufen von der API jetzt programmatisch damit da ein Kreis und ein
Schatten entsteht, ja. Und dann fängt die KI an, eigentlich nur ein Tool zu verstehen und sich zu konfigurieren und die Funktionen, die da sind, die Blockartigen schon, ja, die auf dem Abstraktionslevel höher sind, auszuführen und dann kommen wir zusammen. Das heißt, wir suchen hier eigentlich den perfekten Punkt, wo sich also die möglichen Freiheitsgrade mit der Komplexität der Bedienung sozusagen treffen. Also du schränkst du schränkst Freiheitsgrade ein, ja, erstmal.
Also du lässt jetzt der Button der Button ist jetzt ein Button und nicht mehr. Ich weiß nicht 10 zahlen Code oder was der halt richtig eigentlich ist. So ja und eine KI oder auch ein Mensch dem fällt das jetzt also zumindest wahrscheinlich für 90 oder 95% der Anwendungen viel leichter diese Dinge dann zusammenzusetzen. Button mit einer Tabelle und mit einem mit einem Hintergrund und mit einem Bild oder was auch immer, was man dann alles zusammensetzt. Ja, das ist meine feste
Überzeugung. Genau, ich finde halt. Ich glaube nicht, dass wir, also ich glaube, dass Code Generation total sinnvoll ist, wenn die Dimension 3, die ich genannt habe, die Komplexitätsebene eine gewisse Komplexität nicht überschreitet. Man muss ja noch ne Sache sehen, generierter Code ist halt generierter Code, ist halt Quellcode und der steht ja nicht zeitlos, richtig irgendwie für immer da, sondern. Der hat ja total viele Dependencies, auch wenn die KI das macht.
Ja, also die KI sagt ja auch, ja, dann nimm doch irgendwie, dann lade ich hier noch die, die das Open Source Tool so und so dahin ja, also wenn man mit das weiß man vielleicht auch nicht, aber wenn man sagt KI ich brauch irgendwie ein Tool das ich will irgendwie quasi aus einer HTML Seite ein PDF machen oder irgend so was kann man schon machen programmatisch dann sagte die KI auch ja da gibt es schon das und das Open Source Tool, das nehme ich und damit programmiert ihr das hin.
So jetzt hast du generierten Code, der ist aber jetzt gerade nur ausführbar. Heute vielleicht noch morgen und vielleicht noch in einer Woche, aber in 2 Wochen hat vielleicht der Autor von der PDF Library, die jetzt ne relevante Abhängigkeit von dem generierten KI Code ist, hat der vielleicht ne neue Version rausgebracht und sagt die Alte gibt es nicht mehr. So schlimm ist es nicht.
Ja ich übertreib n bisschen, aber im Prinzip ist es das Problem ja und dann ist dein KI generierter Code schon wieder Käse. Ja so also insofern ist das ja nicht. Also du bist ja nicht fertig, nur weil du irgendwie. 500000 Zeilen selbst wenn die KI das könnte Code generiert hat, ja dann muss es, dann muss es auch noch aware sein, die quasi durch die ganzen Zeiten der ganzen Abhängigkeiten immer weiter zu schaffen.
Ja das ist ja das das Schlimme was eine Softwarefirma leider immer zu tun hat ist, du stehst ja nicht ohne ohne Abhängigkeiten da. Ja du hast das ist wie die Lieferketten ja Beispiel ja also. Vw kann auch nichts machen, wenn irgendwie der Panamakanal zu ist. So, ja, so kann eine Softwarefirma auch nichts machen, wenn irgendein Entwickler an seiner Abhängigkeit einen Bug drin hat, dann bist du halt erstmal angeschmiert, weil du halt nicht
alles selber gemacht hast. Selbst wenn du Code schreibst, wirst du immer Coach Stücke Bibliotheken haben wir erste oder 2. Folge darüber gesprochen wirst du da anbinden müssen, eine KI macht das Halt auch. Ja das sind so ein bisschen die Sachen wo man aufpassen muss wenn man. Nur krass über K.
¶ Unterschiede der Low-Code/No-Code-Tools
Über absolut generierten Code nachdenkt, ohne dass der irgendwie in Modulen, Modulen oder Module unterstützt, die schon da sind. Noch mal ganz kurz entheddern damit werde ich zu viel durcheinander schmeißen. Wir haben das Thema Ja, Ki kann Code generieren, ist aber vielleicht nur im ganz unkomplexen Rahmen sinnvoll. Jetzt lass uns noch mal gegenüberstellen loco und noco Tools, die einerseits Code generieren, andererseits vielleicht auch wie bei uns das nicht tun.
Noch mal, um das ganz klar zu machen, wenn ich NN Low Coat Tool habe, was was ich zwar grafisch bediene, wo am Ende aber Code rauskommt, hab ich dann Code den ich dann trotzdem noch irgendwo ausführen muss den ich pflegen muss, den ich wie du sagst über die Zeit mich kümmern muss, dass der auch immer wieder weiter funktioniert, während das wenn ich das nicht wenn ich ne Plattform habe die mir quasi codefreie Software am Ende kann man das so sagen weiß ich nicht, erstellt hab ich das nicht,
sondern es muss einfach nur diese Umgebung. In der diese Software läuft gepflegt werden vom Anbieter zum Beispiel. Oder gibt es da. Hast du Beispiele welche welche welche generierender Code und welche tun das nicht? Ja, Gerrit ist richtig.
Also es gibt beide Welten, beide Tools und ohne Gewähr, weil ich die Tools selber nicht inhaltlich genau kenne, ist es so, dass zum Beispiel Out Systems kennt man auch ein bisschen älterer Kandidat, schon ein bisschen länger im Game, sage ich mal out Systems generiert Code.
Der quasi grafisch entworfen wurde, sage ich mal soweit ich weiß Mendigs auch ein anderes Tool was ich noch so vom Namen her wenigstens auch ganz gut kenne und auch schon ein paar Podcasts drüber geholt habe, was glaube ich ziemlich cool ist. Ich muss mal ausprobieren, habe ich zu mir noch nicht gekommen.
Retool kennst du auch Geld? Das sind zum Beispiel bei Retool kannst du das glaube ich sogar einstellen, ob du das möchtest oder nicht, dass der Code exportiert wird, aber ich glaube in den funktioniert so, dass tatsächlich Code generiert wird. Frag mich jetzt nicht in welcher Sprache.
Ja und im Java Script oder irgendwie, aber ja genau und und den und den den der kann dann entweder ausführen noch innerhalb dieser Plattform, das machen die oft bei Retrool zum Beispiel ist es so. Ja da kannst du sagen OK interessiert mich nicht was du da generiert hast, Hauptsache der Kram läuft so ja aber wenn du jetzt zum Beispiel sagst ah ich muss on premise hosten, ich hab hier irgendwie krasse private Cloud oder was ich brauch den Code, ja ich will
dann bei Retrool nicht abmelden sag ich mal ja nehm den Code rüber, die App kann man machen glaub ich ja.
Aber um das noch mal zu sagen, und das ist ja wichtig, ja, also wenn du, wenn du den Code generiert hast, dann kannst du dich zwar eigentlich von dem ursprünglichen, von der ursprünglichen Plattform dann wieder lösen, die dir den Mal erstellt hat, aber das hast du ja gesagt, das Wort maintainance ja, der wird halt nicht, der wird halt laufen, wenn wenn wenn du Glück hast für ein Vierteljahr, vielleicht für ein halbes Jahr, ja wenn es webcode ist, moderner Maximum ein halbes
Jahr und dann fängt er an, dann fängt das an die Warnung zu schmeißen, ja, hier und hier hatten wir schon mal eine Security Flow und so weiter ja. Jetzt musst du den weiter warten und wenn du das Tool nicht mehr hast, was es generiert hat, dann muss es jetzt einen jemanden geben, der diesen Code versteht. Also wenn du den nicht verstehst, dann kannst du den
auch nicht warten. Ja und und den weiter pflegen ja pfleg pfleg mal autogenerierten Code weiter ja nicht so einfach würde ich sagen ja, aber ist ja nicht schlimm, du kannst, du musst ja nicht aus dem Tool komplett lösen und dann sagst du halt, dann gibst du halt eine grafische Eingabe die du hast, die wirst du ja gespeichert haben können ja dann sagst du generieren wir ihn dann halt noch mal neu ja und?
Und das Framework generiert dann quasi anderen Code, also die gleiche, den gleiche inhaltliche, den gleichen inhaltliche Anwendung. Es wird aber ein halbes Jahr später anderer Code generiert werden, der Halt moderner ist und den ganzen Sicherheitspatches mit drin hat als der, den nur ein halbes Jahr davor generiert hast.
Also bleibt es sowieso eigentlich, ich sag mal, wenn du dir Zeit sparen willst und nicht selber entwickeln willst, bleibt ja eigentlich nichts anderes übrig, so oder so, ob du Code generieren lässt oder ob du eine Plattform hast, die den, wo du das nicht siehst, wo quasi einfach nur Blöcke konfiguriert werden, sage ich mal. Als Alternative bleibt dir eigentlich im Prinzip nichts anderes übrig, wenn du es irgendwie wirklich professionell einsetzen willst.
Als an dem Tool kleben zu bleiben, weil sonst kriegst du den einfach nicht durch die Zeit gewartet. Ja, es sei denn du hast so ein One Shot Ding irgendwie wo du sagst okay ich mach mal Spaß, ich mach mal so ein online Game, das soll irgendwie ein Vierteljahr online sein, dann dürfen sich da alle mal registrieren, dann schalten die das wieder ab, ja dann dann ja Code generated aber wenn du irgendwas haben willst was irgendwie.
Mal länger als irgendwie ein Vierteljahr läuft, würde ich sagen, bist du sowieso an Getackert, an das, an das, an das Tool, an die Plattform. Gut, das ist das Thema okay immer noch höchste Ebene. Ich erstelle komplexe Anwendungen oder komplette Anwendungen, die richten sich wahrscheinlich auch dann eher auch wirklich an Softwareentwickler, sage ich mal.
Ausgebildete Softwareentwickler diese Plattform, weil also das sagen die auch ganz offen bei Retail Vices, bei Mendex und Outsystems ist es glaube ich auch so. Weil am Ende doch Code rauskommt, den man dann auch wieder anfassen könnte. Abändern, erweitern, aber das kann man ja auch immer hören, ist natürlich auch immer mit Gewissen gefahren verbunden, sobald man sich aus der
Plattform raus begibt. Gut, die Alternative fasst du noch mal kurz zusammen, wie sieht es da aus und welche Nachteile gibt es dann natürlich dann auch und welche Einschränkungen müsste man vielleicht eher sagen?
Ja, die Alternative ist halt, dass quasi der der Low Code Hersteller oder Low Code Hersteller der Plattform Hersteller. Überhaupt gar nicht erst anlegt, auf irgendwelche Code generierungen, sondern ja, ist jetzt vielleicht schwer zu beschreiben für den, für den nicht Softwareentwickler, aber ich versuche es mal.
Also man hat halt quasi als Plattform Entwickler schon Code generiert, der Blöcke auf und das ist das ist der springende Punkt, Blöcke auf einem gewissen abstraktions Level was von Plattform zu Plattform unterschiedlich sein kann, hat man quasi schon vorgebaut, das nennt sich dann. Ganz klassische Objekte. Man kann ja mit mit mit Code modular arbeiten, also du kannst Code Reingießen in Klassen und du kannst Software wiederverwendbar aufschreiben.
Ja, das ist wichtig, ja, es ist ja nicht so, dass Code immer nur einmal funktioniert, sondern du kannst. Du kannst Code quasi in Module packen und diese Module, das kannst du von einer Sorte mehrere haben, dass die Leute Auswahl haben und am Ende werden eigentlich nur Module zusammengesteckt und die können ja auch dynamisch Beziehungen untereinander aufbauen, du kannst sagen.
Der Output vom Modul 1 fließt jetzt ein Modul 2 und das kennen wir gerät von ganz vielen von diesen Low Coat tools.
Da gibt es immer diese Nodes und die Edges, die ist irgendwie verbunden und irgendwie fließt immer irgendwie ein Ergebnis von dem einen Knoten in den nächsten Reihen und dabei müssen dann diese Knoten nicht neu generiert werden vom Code her, die können schon vorher da gewesen sein und die können quasi auch vorher schon wissen, dass sie mit bestimmten anderen Knoten irgendwelche Ergebnisse aufnehmen können oder an andere Knoten weitergeben können und dann bleibt am Ende der.
Am Ende ist dann was du was passiert. Um das tatsächlich eine neue Anwendung entsteht, die richtig individuell ist, ist aber nichts anderes als ein ein starkes Konfigurieren, Parametrisieren von diesen vorgefertigten Modulen und jetzt um das jetzt mal in ein in ein Bild zu setzen, bei uns sind diese Module quasi tatsächlich Funktionen, das ist immer noch jetzt würde man sagen okay wir sind total low levelig ist es aber eigentlich nicht, weil diese Funktionen sind halt fertig.
Und ich muss diese Funktion nur konfigurieren, indem ich sage, was geht rein und wie wird das, was rauskommt, noch mal modifiziert, um es zum nächsten, der reingeht passend zu machen.
Ja, dafür muss ich aber nicht die Funktion Co generaten lassen, sondern die haben wir sehr gepflegt aufgeschrieben oder und jetzt kommt es durch KI generieren lassen, ja, weil da ist jetzt die KI stark, weil ich ich jetzt sage ich der KI nur ich brauche eine Funktion die die dreht mein pdf um 45 Grad oder irgend so was ja macht jetzt nicht großartig Sinn ja aber so und dann habe ich eine Funktion, die macht das ja und die muss ich mal schreiben, weil das machen dann entweder wir
oder könnte man durch KI generieren lassen, aber die quasi jetzt in einen Kontext zu setzen in einer App wo ich das jetzt brauche, dafür muss ich es ja nur noch konfigurieren wenn ich das ein bisschen genereller mache, dann sage ich okay ich kann irgendwas drehen, ein Medium drehen und dann sage ich irgendwie wieviel Grad das ist der Input. Und dann kommt irgendwie das PDF raus, was gedreht ist. Und das kann ich dann in den nächsten.
Das kann ich dann in pdf senden. Reinschicken ja, dabei muss ich auch die senden Funktion nicht mehr wieder hin generieren, die ist schon fertig, die kann halt e Mails versenden und beliebige Attachments aufnehmen. Ja und in dem Fall klatsche ich halt mein vorher gedrehtes PDF als Attachment rein und schick es ab. Ja und so kann ich tatsächlich auch quasi eine Anwendung erschaffen, die aber eigentlich schon aufgeschrieben war vorher die halt einfach nur modular ist
indem ich. Module zusammensetze ja so ein bisschen, wie wenn ich, als würde ich ein Auto neu bauen, was halt wo ich halt ganz viele Module habe und die sind alle da, so dass ich quasi am Ende tatsächlich ein fertiges Auto habe. Ja, so kann man sich ein
bisschen vorstellen. An der Stelle wäre für mich der Begriff No Code Plattform eigentlich oder No Code Tool viel sinnvoller, weil wirklich ja kein Code entsteht, sondern ja. Das ist dann, das ist über diese Frage, was ist No Code und No Code? Ja, also da kannst du natürlich auch gucken, also. Das kann man jetzt aus 2 Perspektiven sehen, so hab ich
es auch noch nie gesehen. Das find ich eigentlich ganz schick in dieser Folge. Man kann gucken was kommt, raus ist es Code oder No Code, man könnte das definieren, man könnte aber auch sagen was geb ich rein, es ist nie Code, also schieb ich quasi nur boxen durch die Gegend und Dreck mit der Maus irgendwelche Kanten auf irgendwelche Notes, dann ist es no code oder muss ich als Eingabe vielleicht auch mal n kleines Stückchen Code schreiben, Java Script
Expression oder irgendsowas um mein Jason irgendwie zu verdrehen ja wird es dann low Code oder sowas ja also. Man kann viele Perspektiven einnehmen und dann, ich glaube, man muss es einmal für sich definieren, ab wann ist irgendwas no Code und ab wann ist irgendwas no Code, da gibt es keine. Ich habe immer noch keine keine verfassungsmäßige Definition von dem Gramkäsen so was. Ja, aber die die Unterscheidung zwischen Input und Output finde
ich gut. Ja, also bei vielen Tools ist Input No Code Output Code, bei anderen Tools ist Input No Code potenziell auch ein bisschen Code und Output ist eben aber no Code, ja. Einschränkungen noch an dem Thema damit was abrunden können, ist natürlich, das hattest du eingangs noch mal kurz erwähnt, die, dass ich dann an die Plattform gebunden bin, in der ich diese Anwendung auch entwickelt habe zum Ausführen. Ja, weil diese, weil diese
Module, und das ist dann so, ja, diese Module machen natürlich nur Sinn im Zusammenspiel dieser Plattform, die sind ja für diese Plattform gebaut und diese Plattform kann muss diese Module konfigurieren können, das kannst du dann halt nicht einfach mit nach Hause nehmen und. Irgendwo anders, irgendwie anders, ohne halt, ohne diese Plattform dann irgendwie in Betrieb nehmen. Du bist dann halt quasi
angebunden. Der Vorteil ist, dass du jedes Mal, wenn du auf die Ploy drückst, wieder das aktuellste kriegst. Also der Code, der darunter geschrieben wird, wird quasi von der Plattform herausgebenden Firma für dich gepflegt und du weißt halt, dass deine, dass deine App da irgendwie den modernsten Standards entspricht, muss sich halt nicht selber drum kümmern. So, und wenn Ihr wissen wollt, wie das bei uns genau aussieht.
Steilvorlage. Laden wir euch hiermit also die, die jetzt noch zu hören, die die haben vielleicht auch Lust, dann sich tatsächlich mal heisenware genauer anzugucken. Wir machen ein Webinar, das muss ich lügen, ich glaube, am 12 Februar kann man auf unserer Website aber einfach guckenheisenware.com, da gibt es Webinar anmelden, Button 12 Februar 15:00 Uhr, da machen wir ein bisschen Demo binden.
Opcoa an Mqtt verarbeiten Daten ein bisschen visualisieren 60 Minuten das Ganze also genauso lange, wieso eine Folge hier ja so viel Werbung muss sein, also wer Lust hat, meldet sich da an Bock hat, gibt es noch was hinzuzufügen zum Thema Coach Generation, sonst machen wir Deckel drauf. Nee, ich glaube, ich habe jetzt die Zeit nicht im Kopf, aber es fühlt sich so an, als hätten wir schon ein bisschen geredet und ich glaube, wir machen lieber einen Deckel drauf.
Ja, es ist Sonntagabend. Wir haben 60 Minuten voll also. Dann reicht es vielleicht. Ich glaube, wir machen Deckel drauf. Es gibt bestimmt noch ganz viel zu erzählen zu dem Thema, das macht aber nichts, wenn wir nicht alles abgreifen, man kann ja sich auch selber noch weiter informieren, ich glaube wir haben erst mal einen guten Rundumschlag abgegeben und ja, ich bin ganz zufrieden.
Ja, ich auch. Danke dir und danke euch fürs Zuhören. Wie gesagt, 12 Februar meldet euch an über unsere Website und dann hören wir uns in 2 Wochen wieder bis dann ciao Tschüss aus Klüz. Einfach komplex wird präsentiert und produziert von Heiseware. Wir freuen uns auf deine Fragen und [email protected] vielen Dank fürs Hören dieser Folge bis Dienstag in 2 Wochen und Tschüss aus Hamburg.