Oh, hört man gut? Ja. Okay.
Läuft ja. Ton funktioniert. Ja. Ja,
dann kommen wir zum zweiten Programmpunkt heute. Und zwar,
mein Name ist Richard Stück und ich bin ganz neu bei Infinite,
habe im Februar dort erst angefangen,
bin also noch ein Rookie auf dem ganzen Gebiet und hoffe trotzdem,
dass der Vortrag heute ein bisschen das Interesse weckt und nicht so hart mit mir ins Gericht gegangen wird.
Und zwar geht es heute um die Funktion der statischen Kompilierung,
die seit Grails 2.2 jetzt eingebastelt ist.
Ja, kurz halt zum Inhalt. Also ich werde
eine kurze Einleitung geben, worum es überhaupt geht.
Und dann die zwei Hauptfunktionen, die jetzt neu sind,
einmal das Static Type Checking und die Static Compilation erklären,
auch an so ein paar Beispielen.
Und am Schluss anhand von Benchmarks, die wir durchgeführt haben,
zeigen, ja, ob das jetzt alles besser ist und
um welchen Faktor es besser ist und so weiter.
Okay, zur Einleitung kurz. Also diese beiden,
das Static-Type-Checking und die statische Kompilierung wurden entwickelt von Cedric Jean-Poe.
Ich hoffe, das ist richtig ausgesprochen. Mein Französisch ist
ein bisschen eingerostet. Ja, wie gesagt, ist Sidegrades 2.2 integriert,
also mit der Version Groovy 2.0 und kann optional eingesetzt werden.
Das heißt, es gibt Enotations,
die einfach über entweder eine Klasse oder auch einzelne Methoden geschrieben werden,
wodurch dann diese Methoden oder eben die Klassen kompiliert werden.
Ihr wisst sicher alle, dass ja Grails eigentlich eher dynamisch ist.
Und ja, manche möchten das eben nicht,
möchten lieber statisch kompilierten Code haben, aus verschiedensten Gründen.
Da kommen wir auch später noch zu. Und somit kann
man eben einzelne Teile seines Codes statisch kompilieren lassen.
Ja, genau, das erklärt das ja alles schon.
Warum macht man das? Ist auch jetzt unten einmal
die Performance-Steigerung oder eben auch die frühe Fehlererkennung,
also gerade das Static Type Checking,
kontrolliert natürlich während des Kompilierungsvorgangs schon jetzt die Datentypen vernünftig zugewiesen wurden oder ob es dann später plötzlich kracht.
Denn wenn man mit Grails was programmiert, was dynamisch ist,
dann läuft der Compiler meistens dann erstmal durch und plötzlich ist dann
irgendwo ein falscher Datentyp und zur Laufzeit gibt es dann Fehler,
die man nicht haben möchte.
Dafür ist das eben da. So,
dann kommen wir zum ersten Teil, dem Static Type Checking.
Ja, wie gesagt, Groovy verwendet ja eigentlich Dynamic Typing.
Das heißt, man kann einzelnen Variablen zum Beispiel erstmal mit
nur Dev und den Variablen Namen keinen richtigen variablen Typen zuweisen.
Der wird dann eben dynamisch zur Laufzeit, je nachdem,
was man für einen Wert da reinspeichert, hat dann die Variable eben diesen Typen.
Und das wird auch alles vom Compiler akzeptiert.
Also hier sieht man die drei Punkte,
das sind so die Hauptdinge, unterschiedliche Datentypen,
dann kann man Methoden aufrufen, die gibt es eigentlich überhaupt nicht.
Das passiert natürlich oft, wenn man ein Taipo irgendwo einbaut,
dass es die Methode ja eigentlich dann nicht gibt.
Wird aber während des Kompilierungsvorgangs erstmal akzeptiert Und dann kann man natürlich
eine Methode auch jetzt entweder keinen Rückgabetypen geben oder irgendwie,
man sagt, die Methode gibt einen Intager-Wert zurück und plötzlich gibt sie einen String zurück und alles kracht.
Ja, ähm, Java-Entwickler, ich denke,
viele oder die meisten oder sogar alle von euch kommen ja
so ein bisschen aus der Java-Welt.
Das ist halt Static-Typing. Also ich sage am Anfang,
ich deklariere die Variable, das ist jetzt ein Intager,
das ist jetzt ein String und so weiter.
Ähm, ja, genau. So,
dann steht da unten noch, dass das Ganze
mit dieser AST-Transformation arbeitet
Da sieht man mal so einen abstrakten Syntaxbaum,
der ist jetzt wahrscheinlich ein bisschen klein,
aber das ist jetzt, glaube ich, der eukletische Algorithmus,
der da einfach als AST mal dargestellt wird.
Dazu muss man jetzt sagen, dass dieser Type-Check, der benutzt zwar diese AST-Transformation,
aber nur an jedem Knoten bestimmte Metadaten, über die er arbeitet.
Also er macht sozusagen nur so eine halbe AST-Transformation. So,
jetzt sieht man hier mal ein Beispiel, was mit Groovy möglich ist,
was aber ganz und gar nicht schön ist.
Und zwar definieren wir hier einfach irgendeine Methode,
die erwartet einen Integer und gibt den dann zurück. Ja,
jetzt definieren wir da drunter, diesen String B,
da schreiben wir String rein und rufen die Methode, das ist extra ein Taipo,
also rufen quasi eine Methode auf, die es nicht gibt.
Das soll so sein, ja, das ist durchaus so.
Und geben jetzt diesen String in die Methode,
also sollte sie jetzt richtig heißen, würde der String in die Methode gegeben werden,
die eigentlich einen Integer erwartet, was ja nicht sein sollte.
Der Compiler sagt, Also, wenn man das jetzt kompilieren
würde mit Grails, passiert da gar nichts, alles okay.
Kommt dann zur Laufzeit das Ganze an diese Codestelle, ja,
dann kracht es. Und das ist jetzt natürlich ein extremes Beispiel,
das würde jedem sofort ins Auge stechen,
aber es kann ja doch mal irgendwo passieren,
man macht da ein Taipo rein, man übersieht vielleicht,
dass die IDE gerade meckert oder schreibt das Ganze noch in Nano oder VI oder solchen Dingen.
Gibt ja so Leute, dann merkt man das vielleicht nicht
und dann passiert halt sowas
Was überprüft dieser Static-Type-Checker jetzt eigentlich alles?
Also das ist jetzt erstmal nur ein Auszug aus dem,
der macht noch viel, viel mehr,
aber ich denke, das sind so die wichtigsten Sachen.
Hier haben wir als erstes wieder das Beispiel mit dem Taipo,
also das wird irgendwie falsch aufgerufen,
wird vom Static-Type-Checker dann während des Kompiliervorgangs überprüft und sofort gewarnt,
dass das eben nicht passiert.
Dann ist hier noch ein Beispiel, da wird in einer Klasse,
die Klassenvariable X definiert und dann eben ein Objekt der Klasse
A erstellt und plötzlich Y als Klassenvariable aufgerufen,
die es natürlich nicht gibt.
Mit dem Static-Type-Checking würde da auch gemeckert werden. Hier haben wir nochmal dieses Beispiel,
man definiert quasi, da ist mein Schatten,
hier ein Int und packt dann in den String rein.
Das wird abgefangen. Ja, man kann auch die,
also man probiert jetzt quasi hier einen String zu addieren, offenen Int.
Oder das, ja genau, das ist der,
also hier hat man jetzt einen Rückgabetyp String und will ein Integrer sich definieren,
wo man den Rückgabetypen, also diesen String reinpackt,
geht auch nicht mehr dann.
Hier passt der Rückgabetyp nicht zum definierten Rückgabetypen. Und hier unten,
das soll jetzt quasi nochmal zeigen, wie das Ganze überprüft wird.
Und zwar gibt es ja diesen sogenannten Typeflow. Also wir
erstellen hier quasi ein Objekt, das ist erstmal nur ein Objekt.
Hier ist es ein Integrer. Hier ist es dann plötzlich ein String.
Und da es jetzt hier ein String ist, Funktioniert dieses Two-Upper-Case auch.
Das heißt, es wird quasi dieser komplette Typeflow durchgeprüft.
Also ja, wie dieser variablen Fluss dann eben ist.
Soviel zum Type-Checking. Schön, ganz kurz. Ja,
das funktioniert nicht. Grantic Type-Checking oder funktionieren nicht. Das
hier? Das funktioniert, ja. Das geht nur darum,
also damit wollte ich nur zeigen,
dass dieser Static Type-Checker quasi den kompletten Flow hier durchgeht.
Und nicht zum Beispiel bei dieser Zuweisung hier schon irgendwas meckert,
sondern eben dann später sagt, das to upper case funktioniert,
weil jetzt ist es ja dann ein String und dann ist es möglich.
Also er geht quasi, ja, diesen Lauf einmal durch.
Genau. Das wird aber nur bei Dynamik disierten,
bei der, dass jetzt das Step entscheidet.
Genau, ja, richtig. Ja, ja. Ja,
macht der, wenn er das so gut entscheiden kann,
weil man deswegen da ein bisschen helfen,
das Tor gleich einzeln um gleich Halloween runter.
Wenn ein F&Ls drum steht, meinst du? Naja,
wenn ich jetzt hier einen If, keine Ahnung,
mit irgendwas Rennen habe und einen Elf, das heißt,
er weiß nicht wirklich, ist das nur ein If?
Es werden auch solche If- und Els-Knoten werden auch mitgecheckt.
Aber wenn das froh dann nachhalb, also das Tour-Up-Case außerhalb kommt,
ich wusste, dann weiß er ja nicht.
Ja, genau, dann würde er wahrscheinlich auch,
dann würde er wahrscheinlich auch schimpfen, man soll es irgendwie ausbessern.
Ja. Und wie das, ähm, Quiz und als Letztes.
Nur so, wenn man einen Dave benutzt oder auch wenn
du sagst, Objecto, gleich den Ort schenken.
Naja, wenn du jetzt, ach so, Objecto.
Also, ja, die Frage ist mir dahinter. Also,
wenn man das als Objectopisiert, ob dann auch dieses ganze Meta-Objecto-Ranning-Zeug dann.
Meinst du, dieser Static-Type-Check, ob der, Ja,
also klar, der läuft dann da auch durch und probiert es halt aus, ja.
Ja, das mag sich in Kontrollflussgraf eingeben. Ja,
die Kontrollflussgraf lang gehst, hat sehr gut, was der Kind ja aktuell ist.
Da kannst du natürlich wissen, das würde ja auch überblicken. Aber natürlich,
wenn jetzt, dass du upper gehst,
in dipsonelles Reifenpreis und die hier ist Bedingung,
das ist etwas, was nur zur Laufzeit auswertbar ist,
weil das bei wegen kommt, ein Funktionsparameter abhängt,
dann teilt es natürlich,
das kann ja nicht wissen.
Also alles, was der Kompeiler sozusagen hinbekommt, geht da quasi.
Aber wenn es unsere Laufzeit entscheidbar ist, eben nicht.
Und Beta-Wert-Programmierung ist dann zur Laufzeit entscheidbar,
ist,
ich glaube das nicht
Ja. Sorry. Genau, so zur Static Compilation,
also dem zweiten Teil, diese ganzen dynamischen Features.
Also ich sage jetzt, ich lege erst mal irgendeine Variable
an und gucke dann mal später, was passiert.
Dadurch werden natürlich die dynamischen Features von Groovy weitestgehend ausgehebelt.
Also kann ich doch eigentlich auch gleich statisch kompilieren. Ja,
wenn ich jetzt sowieso sage, ich mache diesen Type-Check,
warum dann nicht gleich statisch kompilieren?
Dadurch habe ich bessere Performance. Also machen wir das doch
So, jetzt hat der Herr Cedric Jean-Paul eine Umfrage an
ein paar Entwickler gestartet und hat eben gefragt,
warum wollen die denn überhaupt statische Kompilierung haben?
Man sieht, ganz weit vorne ist die Performance. Ja,
dann eben die Type Safety, die wir eben besprochen haben.
Better Java und so weiter. Also den Rest seht ihr
ja, aber wichtig ist eben die Performance ganz vorne.
Und da gibt es jetzt natürlich pro und contra.
Erstmal hier nur pro von der Static Compilation.
Die Steadic Compilation basiert erst mal auf dem Static Type Check.
Also es läuft erst mal ein Static Type Check
quasi durch
Und erst dann kann ja statisch kompiliert werden, auch.
Ja, wie gesagt, man hat eine verbesserte Performance,
weil eben nichts mehr dynamisch irgendwo hin und her gebaut werden muss.
Und jetzt steht hier, es ist auch unter JDK7 einsetzbar.
Es gab mal, oder gibt es auch noch,
etwas, es nennt sich in Vogue Dynamic.
Und dadurch war es möglich, sogenanntes DuckTaping, DuckTyping,
sorry, DuckTyping, zu implementieren.
Also eben, dass man sagt, ich weiß nicht,
was das für ein Objekt ist.
Also ich habe jetzt einen
Und ich sehe durch das Verhalten, also durch die Methoden,
die das Objekt hat und durch die Attribute,
die das Objekt hat, was für ein Typ es ist.
Und zwar heißt das so, weil der amerikanische Poet James Witcom Briley,
der hat mal gesagt, when I see a bird,
that walks, like a duck,
and swims like a duck, and quacks like a duck,
I call that word a duck.
Ja, also ich denke, das hat jeder verstanden, was damit gemeint ist.
Und das wurde eben durch dieses Invogue Dynamic aktiviert,
ist aber eben erst ab JDK 7 und höher einsetzbar.
Und dieses Static Compilation ist eben auch jetzt mit niedrigeren Versionen zu verwenden.
Auch wenn das Ganze noch sehr in der Beta-Phase steckt.
Ja, man hat eben einen kompakteren Whitecode,
weil ich nicht diese ganzen dynamischen Sachen irgendwo noch beachten muss,
sondern so, wie es da steht, wird das halt in Whitecode umgewandelt.
Der ist fast so kompakt wie ein JavaByte-Code,
also der Programmierer versucht sich, also der Herr Schempo hat eben versucht,
das so weit wie möglich an JavaByte-Code wirklich anzunähern.
Ja, und jetzt steht da noch,
dass kein Monkey Patching möglich ist.
Das war so ein Begriff,
den musste ich auch
erstmal nachschlagen
Und zwar sind das einfach Änderungen am Metacode, die zur Laufzeit irgendwie passieren.
Das nennt man wohl im Fachshargon Monkey Patching.
Ich weiß nicht, war das schon mal jemand ein Begriff?
Ja. Was ist das für ein Vorteil, dass du das
nicht möglichst? Also das kann man so und so sehen.
Ja. Entscheidend würde ich jetzt, wenn ich jetzt Meta-Objects-Punktbrille,
würde ich sagen, zur Entscheidung. Genau,
also die Entscheidung liegt im Endeffekt dann immer beim Entwickler irgendwo,
ob er das jetzt einsetzt oder nicht.
Deswegen ist es ja jetzt auch nicht aufgezwungen,
sondern halt mit einer Annotation einfach, wenn ich jetzt sage,
ich benutze in der Methode sowieso keine dynamischen Features,
aber die rechnet eben super viele Sachen,
dann annotiere ich das und dann,
So, ja, die Kontras sind, denke ich,
schon so ein bisschen klar geworden.
Die ganzen Dynamic-Features von Grails fallen dann so ein bisschen weg.
Hier steht noch keine dynamische Bindung,
da würde ich auf der nächsten Folie dann zukommen.
Und ja, eben auch diese ganze dynamische Semantik,
die Grouvie halt mitliefert, ist nicht mehr so ganz,
wie sie eigentlich sein sollte.
Das heißt, so programmiertechnisch geht man irgendwie auch einen Schritt zurück.
So, jetzt hier zur dynamischen Bindung, da habe ich
immer ein kleines Beispiel hier aufgeschrieben.
Also hier oben sieht man jetzt diese Enotation für Compile Static
Sodass eben diese Klasse einfach statisch kompiliert wird. Und jetzt
haben wir hier drei Versionen dieser Methode Fu, die eine erwarteten Object,
die anderen Streamen und die anderen Date und je nachdem,
was sie halt kriegen, geben sie einen Stream zurück.
Und dann haben wir hier noch eine Methode Bar,
die kriegt ein Object und ruft einfach Fu mit diesem Object auf.
Der Type-Checker, der ja durch die Static-Compilation hier aufgerufen wird,
geht jetzt folgendermaßen vor, also es wird halt Fu Also quasi Fu,
die eine dieser drei hier oben mit einem String aufgerufen und dann Bar mit diesem String,
also erst quasi das Object hier rein, so aufgerufen und dann hier irgendwo rein.
Der Type-Checker würde jetzt hier natürlich erst mal String ausgeben.
Klar, er ruft das Fu mit dem String auf, kommt hier raus.
Hier allerdings wird er quasi Bar mit diesem String aufrufen als Object,
sodass hier ein Object drin ist und das aufgerufen wird und
Object am Ende rauskommt.
Zur Laufzeit passiert das jetzt aber andersrum.
Also nicht andersrum,
sondern anders
Der String ruft immer noch das auf, aber bar ist nun,
ja, wird nun eben trotzdem als String behandelt und ruft
damit dann das hier auf und nicht diese Object-Methode.
Und das heißt, wir haben ein anderes Verhalten zur Laufzeit,
als wir vorher vom Type-Checker sozusagen getestet kriegen.
Da muss man halt irgendwie dann auch ein bisschen aufpassen,
was in solchen Fällen ist, ob das dann sinnvoll wäre.
Du guckst so ungläubig. Nee, das würde ja eigentlich
mit Java auch nochmal arbeiten
Ende fühlt völlig reinschmeißen, sonst wäre auch dann zur Laufzeit,
dass er kennt. Und wenn es jetzt aber
... Wahrscheinlich ist das nur vom Typ vor der Vergangenheit.
Ja, und ich habe ja auch gleich überrascht.
Genau, das meine ich ja. Er würde dann ja primär
das passende machen, der will ja ausbringen dann letztendlich zurück.
Wenn Barbell gerufen wird, ruft, kommt in Java-Object,
weil es rausgegangen ist. Ja. 7 Javaisierst du,
du wieder mit. Also das ist für mehrere Jahre.
Okay. Aber du meintest gerade, dass der Typenchecker was anderes sagt,
ist dann tatsächlich Na, er sagt nichts anderes, er macht was anderes.
Also der Type-Checker geht ja quasi diesen Flow wieder durch,
er testet jetzt, wir rufen das so auf, ist das alles in Ordnung?
Und er testet es quasi so, dass er diesen String
dann als Object weitergibt und ruft die Methode auf.
Und somit prüft er gar nicht den Weg über Bar
hier und dann quasi in diese String-Methode rein.
Das heißt, er sieht jemals so sein Level. Ja,
er, ja, genau, also er sieht,
also der Type-Checker sagt, es ist in Ordnung,
man vertraut dem Ganzen und zur Laufzeit passiert dann was völlig anderes,
was man ja vielleicht nicht will.
Der Kontext fehlt.
Genau, ja
Also da ist der im Grunde genommen nutzlos,
weil ja... Ja, was heißt nutzlos?
Also eine Methode da, die fuchst nachher,
die funktionieren zu 100 Prozent. Es ist auch,
also da hat der Herr Shampoo auch ganz großen Wert drauf gelegt.
Das Ganze ist noch in einem Frühstadium. Also es ist immer noch,
die Community diskutiert noch mit, wie wollen die Leute das am liebsten?
Soll sich das eher wie Java verhalten oder eher noch dynamischer
in Richtung Groovy werden und so weiter? Also das ist jetzt,
ja, es ist noch alles so ein bisschen in den Kinderschuhen.
Aber er warnt halt davor, dass man in solchen Fällen aufpassen muss.
Also da muss man als Programmierer jetzt leider noch ein bisschen drauf achten.
In dem Fall Ja, wie sinnvoll es dann natürlich
ist dann, das jetzt zu annotieren. Ja,
genauso in der Geschichte bin ich nämlich in der Breakdown Stil gescheitert.
Weil da auch solche Effekte auftreten und diese Warnings,
die ich gerade gedacht habe, macht ja auch so ein,
versucht auch so ein Zettel-Type-Janging.
Hab mir hier Warning-Warnings gegeben, die keinen Sinn machten.
Und bis ich das dort irgendwann in die Ecke geworfen habe.
Ja. Ja, also manchmal... Flache, also ein Dachtreibing.
Ja, das macht er ja, also genau,
das später zur Laufzeit funktioniert das ja über das Duck-Typing dann, genau.
Ja, du sagtest ja auch,
dass man das ausschalten kann,
indem man auch
den Staat jongliert
Ja, richtig, genau. Und wenn man das dann,
das ist wahrscheinlich noch eine andere Annotation.
Achso, das machen wir. Also so wird es,
genau, so wird es. Wenn man dann ein Preiser-Ding
da machen würde, dann hat es denselben, denselben Effekt.
Zum Fakt zur Geschenkung. Naja, das Compile Static macht ja
einen Type-Check im Grunde. Das ist dieser Method, dieser Bandscheiß.
Bei dem normalen Ufi ist, das funktioniert das Method Dispension,
also sprich, welche Runde spricht er mit Frei zur Laufzeit?
Ja, er kommt an mit irgendwelchen Typen, keine Ahnung,
okay, was ist das für ein Typ,
dann entscheidet er sich erst,
wo er hinspringt,
weil er auch keins hätte
Kontaktzeit schon festgelegt. Und er ist im Kopf anseite festlegt an der Stelle,
da musst du ja jetzt sagen, okay,
das springt definitiv in Folge mit so einer anderen Latte noch und Jack über,
aber du weißt ja nicht, warum,
mit welchem Typen wir das aufrufen.
Du kannst dich dann nicht mehr so laufen zu der Entscheidung,
die vielleicht hat im Prinzip, das kommt schon über.
Okay, also Kompile Sketting macht das, was Clauva machen würde.
Ja, nicht mehr das, was Gute machen würde.
Das ist ein Augesverhalten. Aber dann macht das ja das,
dann macht Kompile Sketting, kommt der Werfluss raus,
den der Type Checker auch vielleicht überlegt hat.
Aber das will ich ja in dem Fall nicht haben.
Ja, das weiß man halt auch. Die Frage ist,
bei uns am Clauva hinschreiben, das ist halt auch wichtig.
Ja, aber das ist jetzt, das ist schon dann
eine witzige Sache, also darum geht es dann eigentlich,
Also dieses Komp-Eis-Sättig, das Verhalten, das bekommst du.
Das ist so, ja. Das ist was neue Wahl
. Ja, ja, ja, stimmt.
Also das passiert da ja so Laufzeit, das,
was der Typ da gerade sich überlegt hat.
Nur, eventuell ist es nicht mehr das,
was man wegbehaben sollte. Ja, richtig, genau.
So ist es. Versteht ihr nicht, was man macht?
Wo steht da, was man haben wollte? Also wenn
ich das jetzt lese irgendwo, weil ich bei einem Kunden bin,
dann lese ich das, weiß ich gerade nicht.
Wollten die das oder wollten die das nicht?
Ja, das ist sicher. Also das wäre zum Beispiel
eine Stelle,
wo man kommentieren kann
Was du erlebst. Allein das Ziel ist, dass das
mir sehr gut aufgefallen ist. Wenn ihr Flugsubie geschrieben habt
und ihr habt es sicherlich vorher beim Glauben vor mir,
ist das wahrscheinlich doch keiner so richtig aufgefallen.
Also guck mal, Stefan, ich war da mal
drüber und danach war das ganz gut. Aber meistens,
das sind schon so ein bisschen, naja, extra variante Geschichten.
Guck mal, Kommentare sind der Tag wahrscheinlich früher.
Gut, ja, dann würde ich sagen,
gehen wir erst mal weiter in unserem, in unserer Geschichte hier.
Und zwar kommen wir dann jetzt noch zu den Benchmarks.
Also man macht ja dieses ganze statische Kompilieren damit eben
die Performance gesteigert wird, wird sie wirklich gesteigert?
Ist jetzt die große Frage? Und dafür gibt es halt
so schöne Tests, und zwar die Berechnung dieser Fibonacci-Reihe,
die ist eben einmal hier Static mit so einem Teneer ein Ausdruck.
Dann gibt es die einmal Static mit einer IF-Abfrage.
Dann haben wir die Nicht-Static der Nähe und nochmal hier Instance mit IF-Abfrage.
Das Ganze wurde jetzt einmal von mir in Groovy geschrieben und probiert,
dann Groovy mit dieser Compile Static Annotation und einmal noch in Java,
um es zu vergleichen.
Und ja, ich denke gerade hier an der Linie sieht man einen ganz schönen Unterschied.
Das waren jetzt 40 Zahlen, die da berechnet wurden.
Also das ist jetzt nicht sonderlich groß das Beispiel,
aber da macht es halt schon, naja,
sagen wir mal, die Hälfte oder ja,
sogar ein bisschen weniger als die Hälfte noch aus.
40 Zahlen,
400 Millisekunden
So ist es, ja. Nein, nein, nein.
Also jetzt mit Parameter 40. Da kann doch die Ziele lesen,
gut, dass es nicht reicht, wenn man braucht,
das glaube ich schon nicht.
Das kann man auch im Kopf produzieren.
Wir können das gerne live durchgehen. Also ich habe das
heute erst durchlaufen lassen. Ich bin das auch,
da kommt ja auch nur das nur auf einen.
Genau. Ja, okay. Aber da lassen wir
mehr als 40 Projekte. Genau. Ja, okay,
es sind mehr als 40 Berechnungen, ja.
Aber das läuft ja rekursiv, also hat man hier ja
quasi auch gesehen, das wird ja alles rekursiv dann aufgerufen.
Also es sind 40 Zahlen, die reingegeben werden,
klar, Aufrufe sind es dann irgendwo mehr,
Wenn man um 40 Prozent teilt, sodass Kaufen 2,
das ist also schon 240 Methoden aufnehmen.
Okay, dann, dann muss man es verstehen, ziemlich viel.
Ja, das ist ja nicht so der beste Album-System.
Interessant, ist ja, dass hier zum Beispiel ein VPS-Zettel
nach Java das passt, das gleiche ist nur beim ersten.
Das ist auch ein großer Unterschied. Ja, habe ich
ehrlich gesagt keine Erklärung. Nee. Bitte? Nee,
Warm-Up hatte ich auch drinnen und habe es quasi ewig,
ich glaube, 50 Mal durchs Warm-Up geschickt,
hat überhaupt nichts dran geändert.
Also es ist alles
so geblieben
Das ist wahr. Habt ihr recht?
Vielleicht ist es bei euch dann noch besser als ich.
So wie ihr fällt. Könnte sein, ja. Ja,
also ich habe keine Erklärung dafür,
warum das jetzt ein paar Millisekunden langsamer ist, der erste Wert,
aber also mit dem Warm-Up hat es nichts zu tun und ja,
wir nehmen es jetzt einfach mal so hin, sage ich.
Okay, ja, ich denke,
Fragen wurden ja größtenteils zwischendurch gestellt,
gibt es trotzdem noch Unklarheiten oder
Dass die Stadt ist schon kompliziert. Wenn man eine Closure hat und
dann dieses Static-Compile-Static annotiert, muss man auf jeden Fall,
also kann man nicht mehr einfach mit It sowieso was machen,
sondern muss wirklich vorher sagen, in I und Pfeilchen und so weiter,
das auf jeden Fall.
Und diese ganzen dynamischen Methoden, wie wir vorhin auch gesehen haben,
dieses Find All und so weiter, fällt eben auch weg.
Wie ist das mit der Erweiterung der Standardklassen?
Also zum Beispiel ein bisschen Beach oder Find
Also einen, ich habe es vorhin ausprobiert mit, ach,
irgendwas hatte ich ausprobiert, wo es auf jeden Fall noch funktioniert hat.
Aber es gibt eben, also die meisten dieser dynamischen Features,
ich kann nicht genau sagen, welche jetzt rausfallen.
Es gibt hunderttausende davon. Aber es bleiben nur noch wenige übrig.
Ja. Ich halt überlege. Boah, spüre ich diesen Performance-Buster,
setze ich es ein und die Anstände ewig auf aufgerufen werden.
Und ich glaube, wir haben schon viele Stellen,
keinen so performance-kritisch oder dann,
es gibt ja auch 100 Linie Cash oder so, Angst.
Man kann sich ja ablegen,
wo an welchen Stellen setzt man das rein,
Gerade verkämpft, weil sie noch die pünktlich-spezifischen Features einletzten,
die sehr gut starten, wenn ich das mache.
Ja, sie hat Studessen geschafft. Also ein bisschen Bilders oder sowas
, das muss ja der Buch, ich weiß nicht.
Also alles gut, dann Gelder. Das Intercept machst du
bei den Methoden im Militär, aber ich bin dort,
das ging halt gar nicht. Also wir haben so ein
bisschen rumexperimentiert. Nein, ich elektrosass da lernen machen.
Man muss sich da so ein bisschen dran gewöhnen, suchen,
weißt du, als wenn man da naiv dran geht,
dann haut alle Bürger und alle anderen Leuten klauen die Ohren und denkst,
ich will das jetzt nicht,
das,
was wir einlegen
Die Generics-Highlight-Unfall zugebucht hat. Ja. Das war echt...
Ja, schlimmer ist klar, weil dann halt einfach...
Ja, du hattest ja auch mal diesen Invoker-Helper benutzt,
um quasi irgendwie diese dynamischen Methoden wieder rein zu invoken,
oder wie genau das ist.
Das ist ja nie das, weil er nicht mal der
Sauer ausgenutzt ist. Da gibt es Forgrades und Invoker-Elfer,
wo du dann sagst, wie heißt der,
der da im Finanzamt alle begrüßt willst, und so.
Also wenn du jetzt in Ruhe bekommst, ein Setting machst,
dann bleibt dir nichts anderes für höher, jetzt diesen Invoker-Elfer zu begrüßen.
Das heißt, im Ende ist ja ein Rupel-Code.
Im Endeffekt verzweigt er dann wieder in Dimiko, der,
glaube ich, zusammengewortet,
was natürlich dann eher ein bisschen das ganze Leben ist
Das WL, das macht ja jetzt einzeln mehr.
Aber wenn wir jetzt zum Teufel kommen raus,
hängen wir die Services, da trifft man ja sehr viel Kanten,
du kannst das ja auf die Glas geben an und klären und auf die Boden leben.
Das ist doch eine sauere Separation of Funktions betreibst,
kannst du sagen, okay, ich habe jetzt hier meinen
Elborhythmus und bleibe in einem guten Fall, aber im Prinzip Avenger.
Das wird halt sehr ähnlich wie Klarwerte.
Im Bordermon könnte man dann auch einfach auf den Jabba,
dass er zurückgreift und sagen, das ist auch egal,
aber in meinem Brett auch Rains mit Jabba,
das ist ja das, was ich wüsste,
das ist das Lustige.
Also da gibt es Elbo.
Aber dann Lobplastik damals.
Also auch heilbar hinter mir. Ich meine nur,
wenn dieses Compile Stetty quasi alle Comedy Fitchers de FCViert,
da kann ich mir das mal vorstellen.
Aber du musst dich ein bisschen leiden, obwohl wieder
der schreien muss. Also es ist noch Plot,
dass zum Beispiel ein paar Meter oder so,
das kann es ja nicht mehr einfach ähnlich machen.
Das ist eigentlich schwer. Du musst quasi,
würde dich da ein bisschen reinfließen und erst mal lernen,
was kann ich da auch machen, das kann ich nicht machen.
Also meinen dafür ist das momentan noch so ein bisschen,
also wie du sagtest, Liefer.
Also fühlt sich zumindest der Meta an, fährt sich eine Geschichte.
Ich hätte da erst auch schon mal benutzt und habe
immer doch mal die tolle Compile hat
Ich glaube, der größte Funzen, den man daraus ziehen kann,
ist, wenn man, wie gesagt, solche Alkoholatmen,
die seid viel mit total Plastik und Akkussion zu tun haben,
anwenden möchte, dann kann man natürlich eben den Service als Java-Klasse schreiben.
Man weiß, dass es sich so bald davon erwartet und dann muss man da auch beiden raus.
Ja, genau. Und dann kann man das machen, aber der Weg war Javas vermutlich immer noch der Eindruck. Ja,
und die Kreisklasse hingeht da, ich meine,
das Thema kannst du auch die dynamischen Feindes,
momentan sind ja so die menschlichen zur Laufzeit dann Ich habe etwas für einen Esprays,
der gewusst hat, ich glaube gelaufen wird,
mit dem Verlauf der Getründe implementiert,
der dann die Klassen dann, danach ging es dann,
die sowieso, das ist schon gefahren, aber alles zur Laufzeit,
das könnte man theoretisch schon für eine Fallzeit machen.
Über Eisding-Kransformation, aber daran ist ja noch keiner gebracht,
die Geschmecker, die ich jetzt nicht sehe.
Aber du weißt, was ich meine, ich kann euch
das ja später alles noch alles sehr gut beladen.
Das Schönste wäre ja zu sagen, okay,
ich kann meine Algorithmen so schön expressiv schreiben mit Kuchen.
Und es wird aber statisch kompiliert, das heißt,
es ist genauso schnell. Ja gut, das geht halt
schon nicht mehr. Also wenn du jetzt so weiter,
also kontrolllos Entscheidungen zur Laufzeit, als erste Firma ein bisschen drauf andere.
Also ich meine, Skala geht ja da auch einen ganzen Schritt bei.
Aber die hatten die nächstes Wochen nicht, da hat sie Frankfurt.
Also da ist es ja so, dass du heimzukommen hast und sagen,
der Scheiß, aber das ist vom Freien anders.
Und das hat halt dieses Java-Verhalten, nicht gegenüber Umwiegen.
Wahrscheinlich muss man dann mal abwarten,
wenn man das Lehrer aus dem Beta-Schmieden raus,
wo das hängt, die Fehlermeldungen auch wirklich ausrufstark sind.
Also im Moment habe ich dann auch eher sagen,
wenn das irgendwie Performance gibt, ist das eher ein Nachverschneiden.
Ja, ich glaube, genau, das ist so der Ansatz,
den man sich vorher beilegen muss, habe ich,
also wo ist meine Anwendung,
wenn es denn in Grades an Helmut ist
Tatsächlich zu langsam. Da gibt es ja sehr,
sehr viele Quellen, wie wir wissen.
Und häufig ist es dann die Datenwanne.
Jetzt war ich dann auch so ein... Okay.
Ja, wenn es weiter keine Fragen gibt,
dann vielen Dank