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
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.
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
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
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
ü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
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.
Ü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
deinfeedbackanpodcast@heiseware.com vielen Dank fürs Hören dieser
Folge bis Dienstag in 2 Wochen und Tschüss aus Hamburg.