WEBVTT

00:00:00.000 --> 00:00:04.400
<v Dominik>Ja, hallo liebe Hörer und Hörer, willkommen beim Python Podcast, Episode 48.

00:00:04.400 --> 00:00:06.320
<v Dominik>Heute geht es um PiPe.

00:00:06.320 --> 00:00:07.120
<v Dominik>Hallo Jochen.

00:00:07.120 --> 00:00:08.240
<v Jochen>Ja, hallo Dominik.

00:00:08.240 --> 00:00:08.720
<v Jochen>Hallo Karl.

00:00:09.040 --> 00:00:09.600
Willkommen.

00:00:09.600 --> 00:00:10.560
Hallo Karl.

00:00:10.720 --> 00:00:12.880
<v Dominik>Ja, wir wollen erstmal News machen.

00:00:12.880 --> 00:00:14.400
<v Dominik>Was hast du denn da, Jochen?

00:00:15.360 --> 00:00:17.440
<v Jochen>Jetzt muss ich mal ein bisschen hochscrollen.

00:00:18.000 --> 00:00:36.160
<v Jochen>Ja, also es gab jetzt einen Python Enhancement Proposal tatsächlich, der glaube ich schon, also ich meine, das richtig gelesen zu haben, dass das jetzt schon für Python 3.12 irgendwie ein Compiler-Flag einführen soll, das den Global Interpreter-Log optional macht.

00:00:36.480 --> 00:00:38.320
<v Jochen>Also die letzte Woche große Neuigkeit.

00:00:38.320 --> 00:00:45.840
<v Jochen>Also ich glaube, es gibt zwei große Themen, Packaging und irgendwie diesen PEP 703.

00:00:45.840 --> 00:00:47.840
<v Jochen>Ja, und ich habe dann auch so ein bisschen reingeguckt.

00:00:47.840 --> 00:01:04.640
<v Jochen>Ich bin ja immer so ein bisschen der Ansicht oder ich habe dir so ein bisschen vertreten, dass ich das eigentlich nicht so ganz nachvollziehen kann, warum das so ein Riesenthema ist, weil ehrlich gesagt betrifft es mich meistens nicht und ich bin eigentlich bisher kaum je in die Situation gekommen, dass dieser Global Interpreter-Log für mich jetzt ein großes Problem gewesen wäre.

00:01:04.880 --> 00:01:10.400
<v Jochen>Aber ich habe mir den jetzt nochmal angeguckt und tatsächlich, also es gibt da schon viele Situationen, wo einen das halt Ärger machen kann.

00:01:10.400 --> 00:01:13.520
<v Jochen>Also mein Beispiel war, ich hätte ja mal gefragt, ob jemand ein anderes Beispiel hat.

00:01:13.520 --> 00:01:17.120
<v Jochen>Also wenn jetzt eine Datenbank in Python schreiben will, dann könnte einem das Ärger machen.

00:01:17.360 --> 00:01:26.000
<v Jochen>Und es gibt aber noch viel mehr Beispiele und da standen auch welche drin, wo ich dann sagen muss, okay, doch, das hat schon, da haben Leute schon ein Problem dann eventuell.

00:01:26.000 --> 00:01:28.160
<v Jochen>Gerade so im Data Science-Bereich, das war mir gar nicht klar.

00:01:28.160 --> 00:01:36.720
<v Jochen>Also ganz wichtig ist da wohl, dass man halt nicht von unterschiedlichen Prozessen aus auf den GPU-Speicher zugreifen kann, tatsächlich so richtig.

00:01:36.720 --> 00:01:42.800
<v Jochen>Und dann kriegt man natürlich sehr schnell ein Problem, wenn man da nicht mehrere Sets auf unterschiedlichen CPUs laufen lassen kann.

00:01:43.040 --> 00:01:44.960
<v Jochen>Ja, genau.

00:01:46.240 --> 00:01:50.640
<v Jochen>Ja, das war so, das ist ganz interessant gewesen.

00:01:50.640 --> 00:01:52.640
<v Carl Friedrich>Aber ist noch voll auch in Diskussion, oder?

00:01:52.640 --> 00:01:55.840
<v Carl Friedrich>So ein richtiges, so einen klaren Konsens gibt es da noch nicht, oder?

00:01:55.840 --> 00:01:56.880
<v Carl Friedrich>Hast du da einen Überblick?

00:01:56.880 --> 00:01:57.680
Nee, genau.

00:01:57.680 --> 00:02:00.080
<v Jochen>Also die Diskussion habe ich mir teilweise angeguckt, aber auch nicht komplett.

00:02:00.080 --> 00:02:02.480
<v Jochen>Und ob es jetzt wirklich kommt oder nicht, keine Ahnung.

00:02:02.480 --> 00:02:18.800
<v Jochen>Es stand auch irgendwann ein Zeitplan in dem Pep selber drin, der eher so sagte, ja, also der Plan ist eher, das ab 2024 einzuführen und dann 25, 26 dann halt irgendwann dazu überzugehen, dass halt quasi.

00:02:21.280 --> 00:02:23.360
<v Jochen>Ich weiß jetzt gar nicht mehr, welche Versionsmad das dann ist.

00:02:23.360 --> 00:02:36.640
<v Jochen>So 13, 14, 15, ja, 15, dann irgendwann umzusteigen auf per Default ist der Global Interpreter locker aus und dann irgendwann es zu deprecaten und bis irgendwann 2030 oder so wegfallen zu lassen, aber das ist dann halt sehr weit in der Zukunft.

00:02:37.040 --> 00:02:37.760
<v Jochen>Keine Ahnung.

00:02:38.080 --> 00:02:44.240
<v Carl Friedrich>Und der Plan ist aber erstmal, das quasi hinter einer Interpreter-Compile-Time-Flag zu verstecken.

00:02:44.240 --> 00:02:44.880
<v Carl Friedrich>Ja, okay.

00:02:44.880 --> 00:02:46.160
Alles klar.

00:02:46.800 --> 00:02:49.040
<v Dominik>Das haben wir ja gleich am Anfang so was Schwieriges gemacht.

00:02:49.600 --> 00:02:53.760
<v Dominik>Vielleicht können wir ja vielleicht nochmal ganz kurz erklären, was nochmal ein G ist.

00:02:53.760 --> 00:02:56.000
Ja, soll ich gerne.

00:02:56.240 --> 00:03:01.040
<v Carl Friedrich>Also das Problem ist einfach, dass der Python-Interpreter selber nicht Thread-Safe ist.

00:03:01.040 --> 00:03:18.960
<v Carl Friedrich>Dass quasi die ganzen Datenstrukturen, die quasi der Interpreter selbst verwendet, halt nicht mit irgendwelchen Logs versehen sind, sondern es einfach nur davon ausgegangen wird, in der Implementierung überall, dass zu jedem Zeitpunkt halt nur ein Python-Thread, äh ein Thread wirklich Python-Code ausführen kann.

00:03:18.960 --> 00:03:30.960
<v Carl Friedrich>Und das führt dazu, dass man halt quasi, wenn man Python-Code schreibt, nur von einem Thread aus wirklich gerade ausführt, ausführen kann.

00:03:30.960 --> 00:03:37.600
<v Carl Friedrich>Und dazu, das hat halt die Auswirkung, also es war lange kein Problem, weil halt keiner irgendwie ein Multi-Prozessorsystem hatte.

00:03:37.600 --> 00:03:50.160
<v Carl Friedrich>Aber jetzt, wo es halt Multi-Oc-Core gibt seit 20 Jahren oder so, ist es halt immer wieder ein großes Diskussionsding, dass es halt nicht so toll ist, dass man wirklich Multithreaded-Algorithmen in Python schreiben kann.

00:03:50.400 --> 00:03:53.440
<v Carl Friedrich>Ist das brauchbar zusammengefasst?

00:03:53.520 --> 00:03:54.880
<v Jochen>Ja, ja, doch, nee, klingt gut.

00:03:55.200 --> 00:04:09.520
<v Carl Friedrich>Und ich glaube, das coole an der PEP ist eigentlich, dass halt wirklich eine Firma, nämlich Facebook, soweit ich das verstanden habe, die den nötigen nicht ganz kleinen Engineering-Aufwand halt mal investiert hat, um sich anzuschauen, wie man denen loswerden könnte.

00:04:09.520 --> 00:04:19.600
<v Carl Friedrich>Also und halt auch das Loswerden ist jetzt gar nicht so das prinzipielle Problem, sondern das Problem ist halt, man will den loswerden, ohne dass Single-Threaded Python viel langsamer wird.

00:04:19.600 --> 00:04:20.960
<v Carl Friedrich>Das ist quasi das Schwierige.

00:04:20.960 --> 00:04:47.440
<v Jochen>Jaja, weil es gab ja schon mal von Larry Hastings oder so, hatte das, was er jetzt auch fast zehn Jahre her oder so da dieses Gelectomy-Projekt, wo eben halt auch versucht hat, das loszuwerden über so Fine-Grained Locking, weil normalerweise ist halt, also für den Garbage Collector braucht man, also das ganze Reference-Counting ist halt hinter dem Gill oder ist halt der Grund dafür, warum das, warum der Gill das halt schneller macht, als wenn man es halt einzeln locken würde.

00:04:47.440 --> 00:04:57.360
<v Jochen>Und ja, da war, das war halt immer so, das war die erste naive Implementation war irgendwie so 40 Mal langsamer als mit Gill und dann ist es im Verlauf der Zeit auf 20 mal langsamer runter oder so.

00:04:57.360 --> 00:05:02.000
<v Jochen>Aber das war halt immer noch nicht wirklich so, dass man das halt verwenden kann.

00:05:02.320 --> 00:05:10.000
<v Jochen>Und jetzt die aktuelle Geschichte hat angeblich irgendwie so, wie es dann implementiert werden soll in den PEP.

00:05:10.000 --> 00:05:21.920
<v Jochen>10% Kosten in Single Thread Performance, was ja so, und es gibt halt schon einen Ding, das kann man auch über PyEnv zum Beispiel installieren, ich habe das mal ausprobiert, das nennt sich irgendwie Python Nogil oder so.

00:05:22.560 --> 00:05:32.720
<v Jochen>Das macht nur 5% quasi Performance einbußen, aber das hat noch ein paar Sachen da drin, die jetzt in dem aktuellen Pap nicht drin sind.

00:05:32.720 --> 00:05:38.720
<v Jochen>Also und daher wäre das ein bisschen langsamer, aber ja, also so, bei 10% ist jetzt noch nicht so allzu viel.

00:05:38.960 --> 00:05:44.640
<v Jochen>Es gibt auch noch so ein paar andere Sachen, wie zum Beispiel, man muss jetzt halt da, es gibt dann so ein paar Tricks, die da verwendet werden.

00:05:44.640 --> 00:06:01.920
<v Jochen>Und einer ist halt auch, dass es jetzt halt immer einen Pointer auf den Thread gibt in jedem Python-Objekt, der das erzeugt hat, weil man, da gab es Köln, zwar sie nur innerhalb der von einem Thread erzeugten Sachen aufräumt oder Reference-Counting macht und dann muss man das dann halt vielleicht nicht mehr locken.

00:06:01.920 --> 00:06:03.920
<v Jochen>Aber dann muss man halt sich merken, welcher Thread das war.

00:06:03.920 --> 00:06:06.000
<v Jochen>Und das sind halt ein 64-Bit-Ding.

00:06:06.000 --> 00:06:09.760
<v Jochen>Und dann hat man noch so einen Pointer auf.

00:06:09.760 --> 00:06:10.720
<v Jochen>Ich weiß gar nicht mehr genau.

00:06:10.720 --> 00:06:12.880
<v Jochen>Das sind insgesamt drei Pointer, die jedes Objekt mehr kriegt.

00:06:12.880 --> 00:06:18.880
<v Jochen>364-Bit-Pointer und das ist natürlich schon irgendwie, das sind halt 24-Byte mehr pro Objekt.

00:06:18.880 --> 00:06:19.840
Das ist schon nicht so ohne.

00:06:19.840 --> 00:06:22.160
<v Jochen>Also speichermäßig ist es auch ganz schön.

00:06:22.160 --> 00:06:28.880
<v Jochen>Und ja, ja, also es sind halt nur Trade-Offs, ne?

00:06:28.880 --> 00:06:33.920
<v Jochen>Wenn man es gebrauchen kann, ist es vielleicht gut, aber wenn man es halt irgendwie nicht braucht, dann

00:06:33.920 --> 00:06:35.040
kann es auch sehr nervig sein.

00:06:37.040 --> 00:07:01.280
<v Jochen>Und dieses Application Binary Interface ist halt auch nicht mehr kompatibel, sodass halt man im Grunde halt die C-Extensions, also für jede C oder für jedes Paket, das halt eine C-Extension ist, muss man halt die entsprechend richtige Version installieren für den Interpreter, den man verwendet.

00:07:01.280 --> 00:07:12.400
<v Carl Friedrich>Also man muss quasi jede C-Extensions einmal anfassen und halt zum Teil die C-API-Usage irgendwie dann korrekt machen und die Logs einführen, wenn das nicht Thread-Safe ist.

00:07:12.400 --> 00:07:14.560
<v Carl Friedrich>Also das ist halt möglicherweise schon auch Aufwand.

00:07:18.960 --> 00:07:24.480
<v Dominik>Okay, also das wird dann tatsächlich ein Breaking Change sein, dann, wenn ich es hier nicht mehr geben.

00:07:24.480 --> 00:07:26.400
<v Dominik>Das ist dann eigentlich Python 4?

00:07:26.640 --> 00:07:28.720
<v Jochen>Nee, also sagen wir so, du kannst ja parallel verwenden.

00:07:32.480 --> 00:07:34.720
<v Jochen>Ja, aber das ist dann irgendwann, das ist in der weiteren Zukunft.

00:07:34.720 --> 00:07:35.920
<v Jochen>Also das ist halt noch Jahre.

00:07:36.320 --> 00:07:38.960
<v Dominik>Ja, aber wenn das Python 3.5 ist, das ist Python 4.

00:07:38.960 --> 00:07:44.320
<v Jochen>Ja gut, ich meine, wenn niemand bis dahin umgestellt hat und es keine Pakete gibt, dann wird man das wahrscheinlich einfach nicht machen.

00:07:44.640 --> 00:07:48.640
<v Jochen>Wenn es alle schon machen, alle relevanten, dann ist es halt auch nicht mehr so schlimm, wenn man das deprecated.

00:07:48.720 --> 00:07:52.560
<v Jochen>Also ja, keine Ahnung, ist wahrscheinlich jetzt sehr schwer, da irgendwelche Voraussagen zu machen.

00:07:54.080 --> 00:07:58.800
<v Carl Friedrich>Ich glaube, wir müssen uns nachher einfach aber auf jeden Fall uns merken, dass wir noch ein bisschen über C-Extensions reden müssen.

00:07:59.040 --> 00:08:00.000
Oh ja, ich glaube, das

00:08:00.000 --> 00:08:00.480
werden wir.

00:08:01.920 --> 00:08:03.520
<v Dominik>Wer war denn aber bei Facebook nochmal mit dabei?

00:08:03.520 --> 00:08:03.760
<v Dominik>War das?

00:08:03.840 --> 00:08:04.320
<v Dominik>Sam Gross oder?

00:08:04.480 --> 00:08:05.280
Sam Gross, genau.

00:08:05.680 --> 00:08:08.880
<v Jochen>Kann es sein, dass du, du hattest vielleicht den Vortrag auf der Europäischen letztes Jahr gesehen?

00:08:09.040 --> 00:08:09.600
<v Dominik>Ja, ja.

00:08:10.160 --> 00:08:12.720
<v Dominik>Ich habe nicht so viel verstanden, aber ich habe mir angeguckt.

00:08:12.960 --> 00:08:13.360
<v Jochen>Okay.

00:08:14.640 --> 00:08:16.720
<v Jochen>Ja, ja, ist auch ein schwieriges Thema, glaube ich.

00:08:16.720 --> 00:08:26.000
<v Jochen>Also der, der, der, also einige der Ideen sind auch schon, also diese Geschichte mit den drei Pointern, die es jetzt gibt, es gab ein akademisches Paper dazu, wie man das denn bauen kann.

00:08:26.000 --> 00:08:32.880
<v Jochen>Und da wurden die diese Informationen, die da drin stecken, in einen Pointer reingefriemelt irgendwie, reinkodiert.

00:08:32.880 --> 00:08:37.600
<v Jochen>Und das war den Leuten aber dann jetzt hier zu heiß und sagen so, nee, nehmen wir lieber rein, das ist zu gefährlich.

00:08:37.920 --> 00:08:39.520
<v Jochen>Was können da alles bei Overflows passieren?

00:08:39.600 --> 00:08:40.160
<v Jochen>Hilfe!

00:08:40.320 --> 00:08:45.840
<v Jochen>Und also daran sieht man schon, dass es halt, dass sie sich das nicht getraut haben, das einfach so zu übernehmen, es ist kompliziert.

00:08:45.840 --> 00:08:47.840
<v Carl Friedrich>Also, würdest du das Paper bitte auch verlinken?

00:08:47.840 --> 00:08:48.160
<v Carl Friedrich>Das klingt

00:08:48.160 --> 00:08:48.720
eigentlich spannend.

00:08:48.720 --> 00:08:50.000
<v Jochen>Ja, ja, kann ich machen.

00:08:50.400 --> 00:08:53.520
<v Dominik>Mach auch den Talk von Some Grass von der EuroPython rein, wenn es denn irgendwas schon gibt.

00:08:53.840 --> 00:08:55.280
<v Dominik>Weiß ich nicht weiß, aber

00:08:55.280 --> 00:08:56.480
<v Jochen>ich füge das mal hinzu.

00:08:56.480 --> 00:08:57.280
<v Jochen>Alles klar, mache ich.

00:08:57.440 --> 00:09:01.440
<v Dominik>Weil er hat das nämlich genau erklärt, wie er das irgendwie so vorhat und dass das schon.

00:09:04.720 --> 00:09:05.920
Auch ein spannender Typ.

00:09:07.360 --> 00:09:08.400
<v Jochen>Ja.

00:09:08.400 --> 00:09:08.800
<v Jochen>Okay.

00:09:09.040 --> 00:09:10.800
<v Dominik>Ja, habt ihr noch nicht sowas gesagt, Packaging?

00:09:10.880 --> 00:09:11.520
<v Jochen>Ja, ich hab noch.

00:09:11.920 --> 00:09:13.280
<v Jochen>Ja, Packaging.

00:09:13.840 --> 00:09:19.040
<v Jochen>Ja, das war ein anderes großes Thema, auch so vor zwei Wochen oder so gestartet oder noch ein bisschen länger.

00:09:19.040 --> 00:09:21.120
<v Jochen>Und das köchelt immer noch so vor sich.

00:09:21.200 --> 00:09:23.120
<v Jochen>Es gibt einen sehr, sehr langen Thread.

00:09:23.840 --> 00:09:26.400
<v Jochen>Ich weiß gar nicht genau, wo war das denn.

00:09:26.720 --> 00:09:30.160
<v Jochen>Das Ding heißt irgendwie Python Packaging Strategy Discussion Teil 1.

00:09:30.160 --> 00:09:31.600
<v Jochen>Das ist auf Discuss Python-Ralk.

00:09:31.600 --> 00:09:32.400
<v Jochen>Ah, okay.

00:09:32.400 --> 00:09:41.520
<v Jochen>Ja, und habe ich nicht ganz gelesen, das war mir dann zu viel, aber es gab, dann haben auch diverse Leute da längere Blogposts drüber geschrieben, was sie denn so denken.

00:09:41.520 --> 00:10:04.880
<v Jochen>Also ja, das Problem ist natürlich, irgendwie bei allen Umfragen, die man zum Thema Python macht, dann wird das von Leuten, die da nicht so erfahren sind, immer als Painpoint Nummer 1 beschrieben, dass es halt so kompliziert ist und dass man nicht weiß, welchen, was man denn jetzt nehmen soll für welche Tools und wie man die denn jetzt am besten, wie rum man die hält, damit es nicht irgendwie keine furchtbaren Sachen passieren und ja, das ist ein Problem.

00:10:05.760 --> 00:10:08.800
<v Jochen>Aber es gibt auch keine so richtig einfache Lösung.

00:10:09.360 --> 00:10:10.800
<v Jochen>Ja, und ich weiß es nicht so genau.

00:10:10.800 --> 00:10:21.360
<v Jochen>Ich glaube, das Fazit war mehr so, ja, es liegt halt vor allen Dingen daran, dass halt auch Python einfach sehr alt ist und Leute das auf sehr unterschiedliche Art verwenden und man kann es nicht gut lösen, weil man kann nicht allen gerecht werden.

00:10:21.360 --> 00:10:28.880
<v Jochen>Weil manche Leute brauchen halt sehr feingranulare Geschichten und andere lieber ein Interface und das kann man, ja, wie will man das unter einen Hut bringen?

00:10:28.960 --> 00:10:29.680
<v Jochen>Das ist schwierig.

00:10:29.680 --> 00:10:38.960
<v Dominik>Also auch interessant, fand ich genau, ich weiß nicht, ob das in dem Zusammenhang aufgetaucht ist, aber auch jetzt wenige Wochen alt von Nathaniel Smith, ein neuer Paketforscher, Posey heißt er.

00:10:38.960 --> 00:10:40.720
<v Dominik>Oder Posey, ich weiß nicht genau, wie man es ausspricht.

00:10:41.120 --> 00:10:45.520
<v Dominik>Das ist eine Rust-Binary, die quasi das ganze Zeugs von Python übernehmen soll.

00:10:45.600 --> 00:10:52.160
<v Dominik>Also den Interpreter mit ausliefern und Pakete bauen und Dependencies bauen und deren Graphen bauen und so.

00:10:52.160 --> 00:10:59.680
<v Dominik>Und das sah, fand ich, relativ interessant aus, weil genau das auch eins der Paces, die allen Leuten, mit denen ich irgendwas in Python machen will, erstmal erklären muss, hä, wie geht das?

00:10:59.760 --> 00:11:01.680
<v Dominik>Oh, das ist aber kompliziert und warum ist das denn so?

00:11:01.680 --> 00:11:11.040
<v Dominik>Und ja, sobald dann halt, also wenn die einen Python machen, okay, aber wenn die nochmal eine andere Python-Version irgendwann, habe ich es ja später so, geht alles kaputt und Pfad anpassen und ich sag, das ist für einige Menschen gar nicht so einfach zu handeln.

00:11:11.040 --> 00:11:15.520
<v Carl Friedrich>Ja, und Natalia ist auch jemand, dem man quasi den Geschmack zutraut, das richtig gut zu machen.

00:11:15.600 --> 00:11:36.960
<v Jochen>Also das ist ja also bekannt wie er hat ja Trio geschrieben, also eine andere Implementation für so Async-Geschichten und eine andere Art, das zu machen, er hat auch einen sehr tollen Artikel geschrieben, irgendwie für Structured Concurrency, den verlinke ich auch mal gerne oder Sachleuten, dass sich das mal durchlesen sollen.

00:11:37.440 --> 00:11:42.480
<v Jochen>Ja, insofern, ja genau, das habe ich auch da direkt aufhorchen, dass man sich gehört hat, wer das gemacht hat.

00:11:43.360 --> 00:11:45.760
<v Jochen>Ja, auf der anderen Seite weiß ich jetzt nicht so genau.

00:11:45.760 --> 00:11:50.080
<v Jochen>Also er schreibt, gut, er macht das jetzt in Rust, weil er wollte schon immer mal was für Rust machen.

00:11:50.080 --> 00:11:51.760
<v Jochen>Ich weiß nicht genau, wo man das unbedingt.

00:11:51.840 --> 00:11:55.280
<v Jochen>Also alle Leute machen momentan irgendwie Dinge, Tooling in Rust.

00:11:56.240 --> 00:12:06.960
<v Jochen>Bei JavaScript verstehe ich das so ein bisschen, weil die haben da, also jede Änderung im Code führt halt dazu, dass irgendwie so 20 Transpiler, irgendwelche Linter, sonst was irgendwie loslaufen und Dinge machen.

00:12:06.960 --> 00:12:15.680
<v Jochen>Und wenn dann jedes Mal so ein fetter Node.js-Prozess gestartet wird, dann dauert das dann, addiert sich das natürlich irgendwie auf in der Latenz.

00:12:15.680 --> 00:12:17.920
<v Jochen>Aber Python hat man das ja jetzt so eigentlich auch nicht.

00:12:18.080 --> 00:12:24.640
<v Dominik>Naja, bei MN hast du eine vorkompilierte Binary, die du irgendwie ausliefern kannst und in Rust ist das vielleicht so ein Typensicher und irgendwie ordentlich schnell und verpasst.

00:12:24.800 --> 00:12:30.480
<v Carl Friedrich>Okay, ich glaube, man kann die halt auch relativ leicht dann so statisch verlinken und hat halt wirklich halt nur eine Datei.

00:12:30.640 --> 00:12:31.200
Ja, genau.

00:12:31.520 --> 00:12:44.800
<v Jochen>Ja, okay, ansonsten hat man das Bootstrapping-Problem, dass man erstmal einen Package Manager installieren muss, damit man sich den richtigen Package Manager, also das Problem, was Poetry hat mit dem Curl und Get Poetry schrecklich Shell-Skript irgendwie von der Webseite ausführen.

00:12:45.680 --> 00:12:48.160
<v Jochen>Ja, okay, gut, das löst es, das stimmt.

00:12:49.040 --> 00:12:50.880
<v Dominik>Das sind so ein paar Sachen, die glaube ich echt gar nicht schlecht haben.

00:12:50.960 --> 00:12:51.920
<v Dominik>Also ja, aber Rust ist cool.

00:12:52.080 --> 00:12:58.240
<v Dominik>Ich habe es auch mal ein bisschen ausprobiert in Advent of Code, aber die Weihnachtszeit ist ja jetzt schon wieder vorbei.

00:12:58.240 --> 00:13:04.640
<v Jochen>Ich weiß nicht, was wir finde, also ich meine, mein, das, was ich meistens verwende, ist halt für Pakete bauen Flit.

00:13:04.640 --> 00:13:05.920
<v Jochen>Das macht eigentlich nur das.

00:13:05.920 --> 00:13:10.800
<v Jochen>Ansonsten verwende ich für Abhängigkeit Pip-Tools und ja.

00:13:11.040 --> 00:13:13.600
<v Dominik>Ja, Piptools fand ich ja fürchterlich, aber du findest Poetry fürchterlich.

00:13:13.600 --> 00:13:14.400
<v Dominik>Und was Poetry ist auch für die Fahrt.

00:13:14.560 --> 00:13:14.960
Ja, Poetry

00:13:14.960 --> 00:13:17.280
<v Jochen>länger verwendet, also fürchterlich ist ja.

00:13:17.520 --> 00:13:24.240
<v Dominik>Der hat Wertness ja, glaube ich, das war schon ein, zwei Folgen her mal über dieses Problem mit den Pint-Dependencies irgendwie schon auseinandergesetzt.

00:13:26.640 --> 00:13:33.920
<v Dominik>Warum das vielleicht blöd ist, aber ich sag mal so, theoretisch kann man die ja trotzdem einfach dann selber einstellen in der Pi-Project Hummel.

00:13:34.560 --> 00:13:46.160
<v Jochen>Ja, ja, das Problem ist, dass das Poetry implizit halt, wenn man sagt, Poetry Add irgendein Paket, irgendwie ein Upperbound auf die Version macht.

00:13:46.160 --> 00:13:47.040
Ja, das verwendet.

00:13:47.520 --> 00:13:53.120
<v Jochen>Wenn man eine Library schreibt, für andere halt sehr blöd ist, weil die dann sofort in Dependency-Probleme laufen, Konflikte laufen.

00:13:53.280 --> 00:13:56.960
Muss man manuell quasi tatsächlich dann wegnehmen.

00:13:57.120 --> 00:13:58.000
Naja, gut.

00:13:58.000 --> 00:14:00.800
<v Dominik>Ach ja, genau, also mit Pit, ist glaube ich eine gute Idee.

00:14:00.960 --> 00:14:01.600
<v Jochen>Keine Lösung ist.

00:14:01.840 --> 00:14:06.160
<v Dominik>Ich habe letztens gesehen, Piptools in PiProject Hummel irgendwie reingemelt.

00:14:06.400 --> 00:14:15.120
<v Jochen>Ja, jetzt letzte Woche war PyDDF-Treffen und Jans hatte da irgendwie das mal irgendwie erzählt, dass er das jetzt macht.

00:14:15.120 --> 00:14:31.280
<v Jochen>Er benutzt Piptools, ist auch nicht so super zu, nicht hundertprozentig zufrieden, aber irgendwie das auch häufiger und hat einen Weg gefunden, wie man das relativ einfach, die Einfänglichkeiten auch in der Pi-Project-Tunnel da reinschreiben kann und hat mir mal gezeigt, wie man das macht.

00:14:31.280 --> 00:14:33.040
<v Jochen>Das könnte ich auch verlinken, stimmt.

00:14:33.040 --> 00:14:34.720
<v Jochen>Das wird auch nicht so schlecht.

00:14:35.600 --> 00:14:37.120
<v Jochen>Weil dann hat man alles wieder, weil das ist natürlich.

00:14:37.280 --> 00:14:42.400
<v Dominik>Also im Moment ist das ganze Packaging und Dependency-Management-Zeugs irgendwie relativ furchtbar.

00:14:42.400 --> 00:14:47.360
<v Dominik>Das funktioniert auch nicht OS-übergreifend gut und das ist ziemlich ermissen.

00:14:47.440 --> 00:14:54.320
<v Dominik>Ich hoffe ja wirklich, dass dieses Raspberry einiges ändert, weil das will man so alles nicht haben.

00:14:54.960 --> 00:14:56.160
<v Jochen>Ja.

00:14:56.160 --> 00:14:58.880
<v Jochen>Wird uns noch eine Zeit lang begleiten, das sehen wir doch nicht.

00:15:00.080 --> 00:15:00.640
<v Jochen>Ja.

00:15:00.960 --> 00:15:03.680
<v Jochen>Okay, kommen wir zu erfreulicheren Ding.

00:15:04.080 --> 00:15:09.760
<v Jochen>Django gibt es jetzt eine neue Alpha-Version, also die Django 4.2 kommt im März irgendwann, hoffentlich.

00:15:09.760 --> 00:15:11.280
<v Dominik>Ist das wieder die LTS?

00:15:12.480 --> 00:15:12.880
<v Jochen>Ja.

00:15:12.880 --> 00:15:13.280
<v Jochen>Ja.

00:15:13.760 --> 00:15:15.760
<v Jochen>Genau, wobei das nicht so eine große Rolle spielt.

00:15:15.760 --> 00:15:18.400
<v Jochen>Die offizielle Empfehlung an der Stelle ist immer, die neueste zu nehmen.

00:15:18.560 --> 00:15:20.800
<v Jochen>Die letzte Stabile zu nehmen und nicht LTS.

00:15:20.800 --> 00:15:24.560
<v Jochen>LTS ist mehr so, naja, es gibt halt Firmen, die das irgendwie haben wollen oder keine Ahnung.

00:15:24.560 --> 00:15:26.320
<v Jochen>Aber das ist nicht mehr so, wie man das machen sollte.

00:15:26.320 --> 00:15:29.280
<v Jochen>Es wird nicht empfohlen, immer auf eine LTS-Version zu bleiben.

00:15:29.280 --> 00:15:31.280
<v Jochen>Dafür verdernt sich auch einfach zu wenig.

00:15:31.280 --> 00:15:35.680
<v Jochen>Also es gibt schon lange nicht mehr irgendwie so große Probleme, wenn man upgradet.

00:15:35.920 --> 00:15:38.640
<v Jochen>Daher braucht man das eigentlich nicht mehr so wirklich.

00:15:38.800 --> 00:15:48.960
<v Jochen>Genau, was dabei ist, ist ganz nett Psycho PG3-Support, das heißt Async-Datenbank-Unterstützung kommt damit halt so rückt näher.

00:15:48.960 --> 00:15:55.680
<v Jochen>Es ist halt, es gibt ja jetzt auch ein Interface, seit Django 4.1 für Async-Geschichten mit dem ORM.

00:15:55.680 --> 00:16:11.680
<v Jochen>Ist alles noch nicht wirklich implementiert, aber das Interface ist schon mal da, sodass man das halt so verwenden kann, dass wenn irgendwann sich unten drunter das mal so verändert, dass halt mehrere Sachen gleichzeitig irgendwie an die Datenbank geschickt werden und dann also concurrent und dann wieder zurückkommen, das ist einfach so, dass man einfach so davon profitiert ohne dass man selber nochmal was ändern muss.

00:16:11.680 --> 00:16:14.720
<v Dominik>Das muss ich auch schon mal irgendwann verstehen, wie das mit der Datenbank funktionieren soll.

00:16:14.960 --> 00:16:28.640
<v Jochen>Naja, du kannst, also im Grunde, der OM weiß ja, was er an Queries an die Datenbank schickt und der schickt dann halt, also was momentan, so der übliche Weg ist halt, dass er halt ein Query nach dem anderen an die Datenbank schickt und die Latenzen sich alle aufaddieren.

00:16:28.640 --> 00:16:34.800
<v Jochen>Das ist halt so, wie es, was jetzt, wenn man nicht so viele Querys macht und wenn man ein bisschen aufpasst, dann ist es auch nicht so schlimm.

00:16:34.800 --> 00:16:42.480
<v Jochen>Aber kann natürlich schon sein, wenn man jetzt 50 Queries hat und jede dauert 10 Millisekunden, dann ist man natürlich bei einer halben Sekunde allein Datenbank, Latenz.

00:16:42.480 --> 00:16:45.680
<v Jochen>Besser wäre es ja, wenn man alle gleichzeitig an die Datenbank schickt.

00:16:45.680 --> 00:16:49.200
<v Jochen>Oder alle, die nicht voneinander abhängen, kann man gleichzeitig in die Datenbanken schicken.

00:16:49.200 --> 00:16:56.720
<v Jochen>Und dann hat man, ist die Gesamtlatenz, nur die Latenz von dem Query, was am längsten dauert, sozusagen.

00:16:56.720 --> 00:16:59.920
<v Jochen>Und das könnte natürlich die Gesamtlatenz deutlich reduzieren.

00:16:59.920 --> 00:17:02.000
<v Jochen>Also es wäre sehr nett, wenn das irgendwie ginge.

00:17:02.240 --> 00:17:04.160
<v Jochen>Ja, aber es ist natürlich sehr komplizierte Änderungen.

00:17:04.320 --> 00:17:06.800
<v Dominik>Aber dann musste die Datenbank ja natürlich schon parallel auch rechnen können.

00:17:07.120 --> 00:17:09.440
<v Jochen>Ja, das können die, das machen die, das können die alle.

00:17:09.440 --> 00:17:17.360
<v Dominik>Und wie stellt die Datenbank sicher, dass ich jetzt keine Probleme habe, festzustellen, dass Dinge auf die gleichen Stellen zugreifen?

00:17:17.440 --> 00:17:23.120
<v Jochen>Ja, das ist ja das, was die Datenbank eigentlich oder das ist ja so die Kernkompetenz eines Datenbankmanagementsystems sozusagen.

00:17:23.120 --> 00:17:25.280
<v Dominik>Ja, aber das Problem hast du jetzt.

00:17:25.840 --> 00:17:31.040
<v Jochen>Aber das Problem hast du jetzt ja auch schon, wenn du mehrere Frontends hast oder mehrere Prozesse auf deinem Frontend, die gleichzeitig alle irgendwie.

00:17:31.200 --> 00:17:38.560
<v Dominik>Ja, aber man muss ja gucken, dass sie ein Lok setzt dann irgendwie und dann muss sie irgendwie gucken, ist das Lock auch da oder muss halt einsetzen, wenn sie da irgendwie dran rumfuchtelt und dann muss ich jetzt wieder.

00:17:38.720 --> 00:17:41.120
<v Carl Friedrich>Also wenn du meinst jetzt so Richtung Write-Zugriff oder was?

00:17:41.120 --> 00:17:59.920
<v Carl Friedrich>Ja, ja, aber ich meine, dann schadest du halt eine Transaktion und siehst, dass dann, du hast eine konsistente Sicht der Dinge innerhalb der Transaktion oder die wird halt dann committed oder abortet und das, das ist, also ich glaube, ich stimme dir zu, dass wir machen zu, dass das halt genau das ist, was die Datenbank halt im Prinzip richtig gut können sollte.

00:17:59.920 --> 00:18:00.400
Also so.

00:18:01.840 --> 00:18:03.440
<v Dominik>Aber das macht ihr doch eigentlich dann langsamer, oder?

00:18:03.440 --> 00:18:03.920
Wenn ich halt dann.

00:18:04.080 --> 00:18:05.120
<v Jochen>Ja, natürlich macht das alles.

00:18:05.200 --> 00:18:06.080
Das macht alles viel langsamer.

00:18:06.080 --> 00:18:10.240
<v Jochen>Wenn man Transaktionen ausschaltet und F-Sync ausschaltet, dann wird das eine Datenbank viel schneller.

00:18:10.240 --> 00:18:13.200
<v Jochen>Also, aber das Problem ist halt, dann sind halt deine Daten eventuell auch weg.

00:18:13.200 --> 00:18:14.400
Das ist ja doof.

00:18:14.480 --> 00:18:15.280
<v Jochen>Das ist auch wieder doof.

00:18:15.520 --> 00:18:17.360
<v Dominik>Wieder so ein Trail auf der Arten.

00:18:17.680 --> 00:18:25.600
<v Jochen>Also dieses Problem hast du auch, wenn du zwei Frontends hast, die auf den gleichen Daten arbeiten, hast du das ja auch schon.

00:18:25.600 --> 00:18:29.840
<v Jochen>Auch ohne, dass die Frontends in sich selber nochmal irgendwie Concurrent-Dinge machen.

00:18:30.080 --> 00:18:36.880
<v Jochen>Die machen ja auch Sachen concurrent auf Prozessebene oder auf Rechnerebene, die da auf die gleiche Datenbank zugreifen.

00:18:36.880 --> 00:18:40.080
<v Jochen>Also das sollten die Daten, das sollte eine Datenbank schon können.

00:18:40.320 --> 00:18:41.280
Ja.

00:18:42.080 --> 00:18:57.680
<v Jochen>Also das ist gut, man hat nochmal ein bisschen Probleme, weil zum Beispiel Postgres kann halt nur, oder dieses, es kommt darauf an, welches Protokoll man verwendet, aber das Textprotokoll von Postgres kann halt nur eine Query gleichzeitig beantworten.

00:18:58.000 --> 00:19:04.960
<v Jochen>Das heißt, bisher war das kein Problem, weil man kann sowieso immer nur Imput synchron eins nach dem anderen machen.

00:19:04.960 --> 00:19:12.240
<v Jochen>Aber jetzt kann man ja mehrere, das heißt, man muss auch mehrere Verbindungen aufmachen, weil halt immer nur ein Query pro Verbindung geht.

00:19:12.240 --> 00:19:18.800
<v Jochen>Das heißt, da muss man dann, Django muss dann halt intern poolen oder muss irgendwie ein Außenpool verändern.

00:19:19.520 --> 00:19:20.720
<v Jochen>Es ist sowieso alles sehr kompliziert.

00:19:20.720 --> 00:19:25.520
<v Jochen>Auch die ganze Geschichte im ORM, was man dann umstellen muss, ist alles noch, das wird noch lange dauern, bis das alles richtig funktioniert.

00:19:25.520 --> 00:19:28.080
<v Jochen>Aber wenn es dann mal irgendwann funktioniert, sehr cool.

00:19:29.040 --> 00:19:31.360
<v Jochen>Und es ist jetzt ein weiterer Schritt dahin.

00:19:31.360 --> 00:19:34.800
<v Dominik>Also wir haben jetzt also in URM, Async Views, Async Tests.

00:19:34.800 --> 00:19:37.040
<v Jochen>Jaja, also in ORM haben wir noch nicht.

00:19:37.040 --> 00:19:38.000
<v Jochen>Wir haben nur die Interfaces.

00:19:39.040 --> 00:19:42.400
<v Jochen>Jetzt auch den Support für eine Library, die man dafür braucht, um das überhaupt machen zu können.

00:19:42.400 --> 00:19:45.040
Das heißt, das letzte, was dann für UM dann.

00:19:45.680 --> 00:19:51.680
<v Jochen>Genau, aber das ist halt auch noch das komplizierteste Stück Arbeit, was noch da bevorsteht, genau.

00:19:52.240 --> 00:19:58.560
<v Jochen>Ja, dann gibt jetzt Unterstützung für Kommentare, für Spalten und Tabellen.

00:19:58.560 --> 00:20:04.160
<v Jochen>Das ist irgendwie ein Issue, der ist seit Jahren offen und war irgendwie kompliziert zu fixen, ging nicht so gut.

00:20:04.160 --> 00:20:05.920
<v Jochen>Aus welchen Gründen auch immer, ich weiß gar nicht genau.

00:20:05.920 --> 00:20:06.720
<v Jochen>Das geht jetzt.

00:20:06.720 --> 00:20:10.640
<v Jochen>Also sie haben irgendwie einen Weg gefunden, wie sie das so hinkriegen, dass es kein Problem mehr ist.

00:20:10.640 --> 00:20:12.880
<v Jochen>Und das ist was ganz nettes.

00:20:13.200 --> 00:20:25.120
<v Jochen>Dann früher oder ab dann wird man halt eventuell das, es gibt so Django In-Memory Storage, ich weiß es nicht genau, gibt es ein externes Paket nicht mehr brauchen, das ist dann auch in Django selber drin.

00:20:25.120 --> 00:20:32.960
<v Jochen>Das heißt, man hat jetzt ein In-Memory Storage Backend für Django mit dabei, das man einfach so verwenden kann für Tests zum Beispiel.

00:20:33.120 --> 00:20:34.960
<v Jochen>Macht halt Tests einfach schneller.

00:20:35.120 --> 00:20:43.840
<v Jochen>Und, das freut mich besonders, es gibt jetzt eine Streaming-HTTP-Response mit Async-Iteratoren dran.

00:20:44.080 --> 00:20:51.760
<v Jochen>Das ist im Grunde, wenn man jetzt zum Beispiel Files ausliefern will, ist das halt ein Problem.

00:20:51.760 --> 00:21:02.160
<v Jochen>Das ging bisher nicht so gut, einfach deswegen, weil man da halt über die Blocks eines Files, die man rausschicken wollte, halt da so in nicht Async drüber iteriert hat.

00:21:02.720 --> 00:21:12.880
<v Jochen>Und genau, ich habe da ja mal auf der Django 2021 einen Vortrag, wie kann man eigentlich Files mit Django Serven gehalten.

00:21:12.880 --> 00:21:17.120
<v Jochen>Da habe ich das halt, dieses Ding rausgepatcht, irgendwie so per Monkey-Patching.

00:21:17.600 --> 00:21:20.240
<v Jochen>Es gibt noch ein Paket Django File-Response, wo ich das so mache.

00:21:20.240 --> 00:21:22.640
<v Jochen>Das ist dann nicht mehr nötig, weil das macht jetzt ASOG-Iterator.

00:21:22.640 --> 00:21:25.440
<v Jochen>Das heißt, es müsste eigentlich File-Surven müsste jetzt einfach so gehen.

00:21:25.440 --> 00:21:27.440
<v Jochen>Ja, das ist natürlich auch sehr cool.

00:21:28.240 --> 00:21:29.840
<v Jochen>Wir haben noch ein paar Konferenzen.

00:21:29.840 --> 00:21:32.560
<v Jochen>Von zwei weiß ich jetzt schon die Daten.

00:21:33.040 --> 00:21:37.840
<v Jochen>DjangoCon EU ist irgendwie 29.

00:21:37.840 --> 00:21:38.480
<v Jochen>Mai bis 2.

00:21:38.480 --> 00:21:42.720
<v Jochen>Juni 2023 in Edinburgh.

00:21:43.040 --> 00:21:45.040
<v Jochen>Edinburgh, ich weiß gar nicht, sprechen wir es auf.

00:21:45.120 --> 00:21:45.520
Edinburgh.

00:21:46.720 --> 00:21:47.440
<v Jochen>Tja.

00:21:47.840 --> 00:21:51.360
<v Jochen>Und PyCon.de PyData ist in Berlin.

00:21:51.360 --> 00:21:51.840
<v Jochen>17.

00:21:51.840 --> 00:21:52.240
<v Jochen>bis 19.

00:21:52.320 --> 00:21:53.520
<v Jochen>April, da gehe ich wahrscheinlich auch hin.

00:21:53.840 --> 00:21:55.760
<v Dominik>Europeißen es vom 17.

00:21:55.760 --> 00:21:58.320
<v Dominik>bis zum 23.

00:21:58.560 --> 00:21:59.200
Juli.

00:21:59.760 --> 00:21:59.920
Okay.

00:22:00.400 --> 00:22:01.600
<v Dominik>Aber ich weiß nicht wo.

00:22:01.840 --> 00:22:04.160
Okay, ja, Top Secret.

00:22:06.000 --> 00:22:08.720
<v Carl Friedrich>Damit auch ja keiner einen guten Flug buchen kann.

00:22:08.720 --> 00:22:09.360
Genau.

00:22:09.360 --> 00:22:11.360
<v Jochen>Das wird in Europa passieren wahrscheinlich.

00:22:11.360 --> 00:22:13.680
<v Dominik>Oder das ins Budget fürs Jahr einplanen kann.

00:22:13.680 --> 00:22:16.560
<v Dominik>Für was auch immer.

00:22:17.440 --> 00:22:19.680
<v Dominik>Ich habe gerade das Management Team hat da gewechselt.

00:22:20.400 --> 00:22:20.800
Ja?

00:22:21.040 --> 00:22:26.240
<v Dominik>Ja, also die letzte hat noch Markandrie mit organisiert und jetzt machen das irgendwie andere Menschen.

00:22:26.240 --> 00:22:27.280
Okay, was ist.

00:22:28.000 --> 00:22:33.280
<v Dominik>Die haben so eine neue Art und Weise, wollen die machen, mit wer das wie veranstaltet und sich was ein neues Konzept da überlegt.

00:22:33.520 --> 00:22:35.440
Mal gucken, ich bin gespannt.

00:22:35.440 --> 00:22:36.480
<v Jochen>Jojo.

00:22:36.480 --> 00:22:41.680
<v Jochen>Okay, ja, nee, dann, äh, da sind wir ja nach nur fast 20 Minuten mit den News durch.

00:22:42.000 --> 00:22:43.760
<v Jochen>Diesmal relativ flott.

00:22:43.760 --> 00:22:45.440
<v Jochen>Dann kommen wir zum Punkt.

00:22:45.520 --> 00:22:47.040
Das ist eine ganz schnelle Folge.

00:22:47.040 --> 00:22:47.840
<v Jochen>Das glaube ich nicht.

00:22:48.400 --> 00:22:49.120
<v Dominik>PiPi?

00:22:49.120 --> 00:22:49.280
Ja.

00:22:50.240 --> 00:22:50.720
<v Dominik>Warum macht.

00:22:51.040 --> 00:22:52.320
<v Dominik>Ja, die Folge ist ja PiPi.

00:22:52.400 --> 00:22:54.560
<v Dominik>Mach mal damit nicht was schneller oder was ist der Zweck davon?

00:22:54.560 --> 00:22:56.080
<v Dominik>Oder weißt du was, womit wir anfangen?

00:22:56.080 --> 00:22:57.360
<v Dominik>Karl, wer bist du denn eigentlich?

00:22:57.360 --> 00:22:57.680
Hi.

00:22:57.920 --> 00:22:58.080
<v Carl Friedrich>Hi.

00:22:58.320 --> 00:23:01.120
<v Carl Friedrich>Hallo, ich gebe mir schon die ganze Zeit so meinen Senf dazu.

00:23:01.280 --> 00:23:02.560
<v Carl Friedrich>Aber ja.

00:23:02.800 --> 00:23:05.280
<v Carl Friedrich>Also ich bin Karl Friedrich Bolz der Eck.

00:23:05.280 --> 00:23:10.320
<v Carl Friedrich>Ich bin hier an der Uni, ein wissenschaftlicher Angestellter in Düsseldorf.

00:23:10.320 --> 00:23:20.880
<v Carl Friedrich>Und habe da eine halbe Stelle und bin im Prinzip angestellt, um eine Python-Einführung zu erhalten jedes Semester für Leute, die nicht Informatik studieren.

00:23:20.880 --> 00:23:24.160
<v Carl Friedrich>Also das ist so Studium Universal-mäßig.

00:23:24.480 --> 00:23:30.800
<v Carl Friedrich>Und wenn ich die mache, gemacht habe, kann ich die restliche Zeit so ein bisschen frei einteilen.

00:23:30.800 --> 00:23:34.160
<v Carl Friedrich>Das ist eigentlich ein ganz angenehmer Deal.

00:23:34.160 --> 00:23:45.440
<v Carl Friedrich>Und ich bin seit irgendwie 2005 ungefähr einer der Kernentwickler des Piper-Projekts, über das wir jetzt auch dann gleich noch mehr reden wollen.

00:23:45.440 --> 00:23:48.240
<v Carl Friedrich>Also ich habe da halt irgendwie am Anfang vor meinem Studium angefangen.

00:23:48.240 --> 00:24:06.320
<v Carl Friedrich>Ich war dann auch bei den EU-Projekten, die da am Anfang eine Zeit lang für Finanzierung gesorgt haben, recht intensiv involviert und bin halt so mit mal mehr, mal weniger Involvierung seitdem immer wieder halt daran beteiligt.

00:24:06.320 --> 00:24:07.680
<v Carl Friedrich>Und ja.

00:24:09.280 --> 00:24:13.680
<v Dominik>Also an dem Open Source Fund-Ding, was dann PiPy direkt entwickelt.

00:24:14.160 --> 00:24:24.160
<v Carl Friedrich>Genau, also ich bin jetzt quasi einfach erstmal nur so quasi in Anführungszeichen, also nur einer der Kernentwickler, also die halt quasi Commit Rights und Zeug machen.

00:24:24.240 --> 00:24:27.600
<v Carl Friedrich>Ich bin aber halt auch einer der recht aktiven im Moment.

00:24:27.600 --> 00:24:32.160
<v Carl Friedrich>Also das Projekt schrumpft so ein bisschen, da können wir vielleicht später auch noch drüber reden.

00:24:32.160 --> 00:24:37.440
<v Carl Friedrich>Und ich bin einer derjenigen, die jetzt halt gerade noch recht viel machen.

00:24:39.920 --> 00:24:47.120
<v Carl Friedrich>Genau, aber das Projekt hatte über seine Lebenszeit halt immer wieder auch Phasen, wo das wirklich auch viel Geld hatte.

00:24:47.120 --> 00:25:00.400
<v Carl Friedrich>So EU-Förderung, Forschungsförderung, immer mal wieder auch Geld von Firmen und bei einigen von diesen Forschungs oder Förderungsprojekten war ich halt auch dann quasi aktiv dabei.

00:25:02.400 --> 00:25:04.960
<v Dominik>Da musste auch mal direkt erzählen, was PyPy überhaupt ist.

00:25:05.200 --> 00:25:06.160
<v Carl Friedrich>Ja, genau.

00:25:06.320 --> 00:25:09.120
<v Carl Friedrich>Also da genau, das ist jetzt quasi die andere Frage.

00:25:09.120 --> 00:25:12.240
<v Carl Friedrich>Also PyPy ist quasi eine Alternative für CPython.

00:25:12.480 --> 00:25:26.480
<v Carl Friedrich>Wenn man halt irgendwie Python in Python seine Programme schreibt, dann geht man halt normalerweise auf Python.org und oder vielleicht kriegt man das auch irgendwo anders her, aber man hat halt ein Executable, das heißt Python 3 in der Regel oder Python.

00:25:26.480 --> 00:25:37.120
<v Carl Friedrich>Das führt man aus und dann kriegt man halt irgendwie seine Shell und kann da Python-Code eingeben oder kann halt damit dann auch Python-Dateien ausführen und kann auf diese Art und Weise irgendwie seine Programme laufen lassen.

00:25:37.120 --> 00:25:50.560
<v Carl Friedrich>Und dieses Programm, das wird halt von den Kernentwicklern der Sprache Python geschrieben und das gibt quasi vor, wie sich die Sprache entwickelt.

00:25:50.560 --> 00:25:59.920
<v Carl Friedrich>Und das ist in C geschrieben, also dieses Programm ist in C geschrieben und deswegen kann man das halt auch, um es von der Sprache zu unterscheiden, kann man das halt auch C-Python nennen.

00:25:59.920 --> 00:26:07.680
<v Carl Friedrich>Also das ist quasi so ein bisschen so ein Terminologiet, dass man halt quasi die Sprache und die Implementierung, dass man denen zwei verschiedene Namen gibt.

00:26:07.680 --> 00:26:16.640
<v Carl Friedrich>Also Python ist halt dann die Sprache und das ist quasi erstmal so eine abstrakte Entität und dann gibt es aber halt die konkrete Implementierung, die man fast immer verwendet und das ist halt CPython.

00:26:16.640 --> 00:26:19.680
<v Carl Friedrich>Und C-Python funktioniert jetzt so, dass es halt ein Interpreter ist.

00:26:19.680 --> 00:26:27.840
<v Carl Friedrich>Also wenn ich jetzt damit irgendwie meinen Python-Code ausführen will, dann gibt es so ein bisschen so einen versteckten Bytecode-Compiler-Schritt.

00:26:27.840 --> 00:26:43.040
<v Carl Friedrich>Also der Python-Code wird dann irgendwie analysiert und geparst und in so ein Bytecode-Format übersetzt und dann werden auch so PY-C-Dateien irgendwo auf der Festplatte auch noch so ein bisschen zwischengespeichert, damit man das nicht jedes Mal machen muss.

00:26:43.040 --> 00:26:47.440
<v Carl Friedrich>Aber dieser Bytecode, der wird halt dann jedes Mal von einem Interpreter ausgeführt.

00:26:47.440 --> 00:26:56.800
<v Carl Friedrich>Und was Pyper jetzt ist, ist quasi der Versuch, Python-Code schneller zu machen.

00:26:56.800 --> 00:27:01.920
<v Carl Friedrich>Also es ist ja immer so ein bisschen so ein Meme, dass Python halt irgendwie besonders langsam sein soll.

00:27:01.920 --> 00:27:17.440
<v Carl Friedrich>Und PyPy ist halt ein Forschungsprojekt oder halt auch ein Open Source-Projekt, mit dem man eben das Ziel erreichen können möchte, dass man den Python-Code einfach unverändert viel schneller laufen lassen kann.

00:27:17.440 --> 00:27:23.040
<v Carl Friedrich>Und das macht man eben so, dass man eben sich sein Binary nicht von Python.org runterläddt, sondern von PyPy.org.

00:27:23.040 --> 00:27:25.840
<v Carl Friedrich>Man kriegt dann ein Binary, das heißt halt irgendwie PyPy.

00:27:25.840 --> 00:27:34.320
<v Carl Friedrich>Und das verhält sich erstmal eigentlich ganz genau so, idealerweise quasi ununterscheidbar so, wie der Interpreter, den man von Python.org kriegt.

00:27:34.560 --> 00:27:37.200
<v Dominik>Vielleicht nochmal ganz kurz, PyPy ist nicht PyPI?

00:27:37.200 --> 00:27:39.200
<v Carl Friedrich>Genau, also PY, PY.

00:27:40.160 --> 00:27:44.000
<v Carl Friedrich>Also das ist so ein bisschen doof, dass die so ähnlich sind, aber.

00:27:44.240 --> 00:27:46.800
<v Dominik>Ja, weil man von PyPI ja auch viel runterlädt, man das irgendwie.

00:27:46.960 --> 00:27:48.160
<v Carl Friedrich>Genau, ja, ja, absolut.

00:27:48.160 --> 00:28:02.080
<v Carl Friedrich>Also aber PyPI lädt man quasi in Python geschriebene Bibliotheken runter, die dann auf der Python-Implementierung laufen, aber PyPy ist eben wirklich das Binary, also die Excel-Datei sozusagen.

00:28:02.240 --> 00:28:09.760
<v Dominik>Also was ich mir erzählt, eigentlich war diese, weil ihr relativ gleich alt seid als Projekte, war die Unterscheidung früher gar nicht so einfach, weil das andere waren die Cheesecakes.

00:28:09.760 --> 00:28:18.800
<v Carl Friedrich>Genau, also der PyPI hatte halt vorher dieses Cheese Shop-Bringing, weil das ist so ein Monty-Python-Sketch mit dem Cheese Shop, wo man halt keinen Käse kaufen kann.

00:28:18.800 --> 00:28:20.160
<v Carl Friedrich>Ich weiß nicht, ob du das kennst.

00:28:20.160 --> 00:28:20.560
<v Carl Friedrich>Ja.

00:28:21.280 --> 00:28:24.400
<v Carl Friedrich>Da geht halt der Kunde dann so ganz viele Sorten durch und die gibt es aber alle nicht.

00:28:24.400 --> 00:28:26.960
<v Carl Friedrich>Und kennst du auch das Wortspiel mit den Wheels?

00:28:26.960 --> 00:28:27.680
Nee.

00:28:27.680 --> 00:28:30.720
<v Carl Friedrich>Naja, im Cheese Shop gibt es halt Käseräder.

00:28:30.720 --> 00:28:31.120
Ja.

00:28:31.280 --> 00:28:34.160
<v Carl Friedrich>Und die Wheels sind halt Käse.

00:28:34.160 --> 00:28:35.120
Okay, ah.

00:28:35.120 --> 00:28:35.840
Also, ja.

00:28:35.840 --> 00:28:38.160
<v Dominik>Okay, das heißt, im Käse-Shop gibt es die Wheels.

00:28:38.160 --> 00:28:39.040
Ja, okay, verstehe.

00:28:39.040 --> 00:28:41.760
<v Dominik>Und deswegen gibt es Wheels auf Pipe PI.

00:28:42.000 --> 00:28:42.400
Genau, und

00:28:42.400 --> 00:28:50.400
<v Carl Friedrich>irgendwann haben die halt dann aufgehört mit diesem, weil Cheese Shop ist halt doch sehr idiosynkratisch oder verspielt, ist vielleicht eine positive.

00:28:50.800 --> 00:28:54.160
<v Dominik>Der erste Draft-Name von unserem Podcast war The Ministry of Silly Talks.

00:28:54.160 --> 00:28:55.440
<v Carl Friedrich>Ah ja, alles klar, nicht schlecht.

00:28:56.720 --> 00:29:03.120
<v Carl Friedrich>Also irgendwann wurde halt Pipe PI dann ein bisschen ernsthafter und hat halt angefangen, dann sich nicht mehr The Cheese Shop zu nennen.

00:29:03.120 --> 00:29:06.240
<v Carl Friedrich>Und dann wurde halt die Verwechslungsgefahr plötzlich dann auch akuter.

00:29:06.640 --> 00:29:17.920
<v Carl Friedrich>Aber weil halt PiPI und PyPy ziemlich genau gleich alt sind, also PiPI ist ein kleines bisschen älter, so ein paar Monate oder so, hat man halt beide Projekte nicht so richtig eingesehen, sich jetzt umzubenennen.

00:29:17.920 --> 00:29:22.640
<v Carl Friedrich>Und deswegen müssen wir dann jetzt halt mit dieser Verwirrung leben.

00:29:22.640 --> 00:29:29.360
<v Carl Friedrich>Genau, also wir waren an dem Punkt, man kann von PyPy.org sich ein Binary runterladen, das heißt PyPy.exe unterwinteres oder halt einfach nur PyPy.

00:29:29.360 --> 00:29:36.000
<v Carl Friedrich>Und das verhält sich eigentlich idealerweise ganz genau so wie das Binary, was man von Python.org kriegt.

00:29:36.000 --> 00:29:43.920
<v Carl Friedrich>Man kann damit Python-Code ausführen, man kann damit einen interaktiven Interpreter kriegen und alle Command-Line-Switches sind die gleichen.

00:29:43.920 --> 00:29:45.120
<v Carl Friedrich>Und es verhält sich genau gleich.

00:29:45.120 --> 00:29:50.400
<v Carl Friedrich>Mit dem einzigen Unterschied, dass der Python-Code, den man damit ausführt, halt hoffentlich

00:29:50.400 --> 00:29:51.680
schneller ist.

00:29:51.680 --> 00:29:54.320
<v Dominik>Was ist mit Paketen und Libraries und so weiter?

00:29:54.320 --> 00:29:58.960
<v Carl Friedrich>Genau, also alles, was quasi in Python geschrieben ist, sollte halt gehen.

00:29:58.960 --> 00:30:00.640
<v Carl Friedrich>Wir haben natürlich ab und zu Bugs.

00:30:00.640 --> 00:30:09.600
<v Carl Friedrich>Also irgendwie, es gibt immer irgendwelche super spezifischen Feinheiten, wo man dann halt doch so ein bisschen Verhaltensunterschiede finden kann.

00:30:09.600 --> 00:30:18.160
<v Carl Friedrich>Aber so der Anspruch an uns selber ist halt, dass wir quasi wirklich das komplette Verhalten der Sprache eins zu eins nachbauen.

00:30:18.160 --> 00:30:19.920
<v Carl Friedrich>Und zwar bis in die Bugs rein.

00:30:19.920 --> 00:30:25.840
<v Carl Friedrich>Also es gibt halt immer wieder so Randfälle, wo man dann anfangen kann zu diskutieren und sagen kann, naja, was ist denn jetzt mit diesem Randfall?

00:30:25.840 --> 00:30:29.280
<v Carl Friedrich>Könnte man dann nicht argumentieren, dass CPython da halt irgendwas komisches macht?

00:30:29.280 --> 00:30:40.800
<v Carl Friedrich>Aber das machen wir halt nicht, sondern wir sagen halt immer, im Zweifelsfall bauen wir halt auch die ganz, ganz komischen Sachen nach, weil es stellt sich halt raus, dass irgendjemand verlässt sich so ein bisschen auf alles.

00:30:40.800 --> 00:30:51.040
<v Carl Friedrich>Also es gibt eigentlich keinen Randfall, der so merkwürdig ist, dass es nicht eine Bibliothek gibt, irgendwie eine kleine vielleicht, die halt sich dann beschwert, wenn man das kaputt macht.

00:30:51.040 --> 00:30:56.480
<v Carl Friedrich>Also selbst wenn man halt dann sagt, na, wir sind aber viel konsistenter und das macht ja so viel mehr Sinn, nee.

00:30:58.000 --> 00:30:58.880
Das ist halt doof.

00:30:58.880 --> 00:31:06.240
<v Carl Friedrich>Für so eine Bibliothek ist es doof, wenn sie halt dann so unterscheiden muss, auf welcher Python-Implementierung sie jetzt gerade laufen.

00:31:06.240 --> 00:31:12.480
<v Carl Friedrich>Und deswegen versuchen wir da halt auch nichts mehr zu verbessern oder irgendwie.

00:31:12.480 --> 00:31:14.080
Ja, es gibt natürlich trotzdem Stellen.

00:31:14.080 --> 00:31:17.680
<v Carl Friedrich>Also wir haben halt dann, was weiß ich, mal eine leicht andere Federmeldung in irgendeinem Fall oder so.

00:31:18.240 --> 00:31:20.000
<v Carl Friedrich>Sowas kommt halt schon vor.

00:31:21.200 --> 00:31:24.320
<v Carl Friedrich>Aber vom Anspruch her sollte sich halt genau gleich verhalten.

00:31:24.320 --> 00:31:30.720
<v Carl Friedrich>Und der einzige Unterschied ist quasi wirklich idealerweise, dass bei uns die Programme halt viel schneller laufen.

00:31:30.720 --> 00:31:34.160
<v Dominik>Und warum macht man das dann nicht direkt immer mit PiPy alles?

00:31:34.480 --> 00:31:38.480
<v Carl Friedrich>Ja, also genau, jetzt können wir so ein bisschen über die Nachteile reden.

00:31:38.480 --> 00:31:49.040
<v Carl Friedrich>Also das eine ist halt, wir sind halt nicht die maßgebende Implementierung, die jetzt die Evolution der Sprache selbst vorgibt.

00:31:49.280 --> 00:31:52.080
<v Carl Friedrich>Also C-Python hat halt so eine Doppelfunktion.

00:31:52.080 --> 00:31:58.000
<v Carl Friedrich>Das ist einmal die Default-Implementierung, die halt von fast allen verwendet wird.

00:31:58.000 --> 00:32:07.280
<v Carl Friedrich>Aber auf der anderen Seite ist es halt auch die Gruppe an Leuten, die letztlich darüber entscheiden, in welche Richtung sich die Sprache weiterentwickelt.

00:32:07.280 --> 00:32:15.200
<v Carl Friedrich>Weil in jeder neuen Version von C-Python ist es ja so, dass da eben nicht nur irgendwie technische Verbesserungen an der Implementierung gemacht werden.

00:32:15.200 --> 00:32:19.120
<v Carl Friedrich>Das kommt natürlich auch mal vor, also jetzt sind drei Elf zum Beispiel ganz toll.

00:32:19.120 --> 00:32:23.040
<v Carl Friedrich>Aber insbesondere gibt es da halt auch bei jeder Version irgendwelche neuen Sprachfeatures.

00:32:23.040 --> 00:32:27.440
<v Carl Friedrich>Das heißt, python.org, diese Community, die ist halt für zwei Sachen zuständig.

00:32:27.440 --> 00:32:39.120
<v Carl Friedrich>Einmal dafür, dass das alles funktioniert, aber auf der anderen Seite eben auch für so Fragen wie, welches Pab nehmen wir an, welches neue Language-Feature wollen wir haben, welche neue Stahlbibliothek, so Geschichten.

00:32:39.120 --> 00:32:40.960
<v Carl Friedrich>Und da, also da sind wir halt raus.

00:32:40.960 --> 00:32:45.040
<v Carl Friedrich>Also aus diesen ganzen Sprachdesign-Fragen, da haben wir keine Meinung zu.

00:32:45.040 --> 00:32:50.560
<v Dominik>Ihr nehmt euch dann einfach das letzte Office-ZBDs und dann ist das ein C-Python und baut das dann eure Änderungen ein.

00:32:50.640 --> 00:32:50.880
Genau.

00:32:51.200 --> 00:33:00.160
<v Carl Friedrich>Und es ist schon dann mal so, dass wir bei den C-Python-Diskussionen dann auch mitreden und sagen, ja, aus unserer Sicht hat das DD, also gibt es jetzt hier diese Trade-Offs oder so.

00:33:00.160 --> 00:33:06.320
<v Carl Friedrich>Aber also wir versuchen uns halt so erstmal aus Sprachdesign-Fragen auch irgendwie erstmal rauszuhalten.

00:33:06.960 --> 00:33:18.400
<v Carl Friedrich>Also einfach auch, weil das unser Leben so ein bisschen leichter macht, dann gibt es halt, ich meine, ich habe da natürlich dann quasi so privat auch manchmal eine Meinung dazu, was es jetzt an Featern gibt und manche finde ich cool und manche finde ich weniger cool.

00:33:18.400 --> 00:33:22.320
<v Carl Friedrich>Also ich meine, das geht ja allen Python-Programmierern so, dass man halt eine Meinung hat.

00:33:22.320 --> 00:33:32.720
<v Carl Friedrich>Aber wenn ich dann quasi meinen PiPy-Hut auf habe, dann versuche ich diese private Meinung halt dann auch zurückzunehmen und zu sagen, das ist jetzt halt so, das ist Teil der Sprache und das implementieren wir jetzt halt.

00:33:32.720 --> 00:33:35.520
<v Dominik>Also du bist ja eigentlich gar kein Dann Python-Programmiere, hast du selber gesagt.

00:33:35.680 --> 00:33:38.400
<v Carl Friedrich>Ja, über die Architektur reden wir gleich noch.

00:33:38.400 --> 00:33:42.400
<v Carl Friedrich>Also irgendwie dann schon, aber halt auf eine bisschen indirekte Art und Weise, genau.

00:33:42.400 --> 00:33:45.520
<v Carl Friedrich>Also ja, ich wollte noch was zu den Versionen sagen.

00:33:45.520 --> 00:33:48.160
<v Carl Friedrich>Wir sind immer so ein bisschen hinterher.

00:33:48.160 --> 00:33:49.360
Das ist nicht so gut.

00:33:49.360 --> 00:33:54.400
<v Carl Friedrich>Also eigentlich haben wir so ein bisschen den Anspruch, dass wir quasi eine Major-Version hinterher sind.

00:33:54.400 --> 00:33:57.440
<v Carl Friedrich>Weil, also wir können halt nicht Schritt halten.

00:33:57.520 --> 00:34:03.680
<v Carl Friedrich>C-Python hat halt einfach viel mehr Leute und die rennen uns halt davon.

00:34:03.680 --> 00:34:09.600
<v Carl Friedrich>Und was halt so ein bisschen unser Ziel ist, ist, dass wir quasi immer so eine Major-Version hinterher sind.

00:34:09.600 --> 00:34:17.440
<v Carl Friedrich>Das ist auch immer ganz gut, wenn dann quasi 3.11 rauskommt, dann haben so langsam alle Bibliotheken sich darauf eingestellt, dass die 3.10 supporten.

00:34:17.440 --> 00:34:21.360
<v Carl Friedrich>Und wenn wir dann auch mit unserer 3.10 rauskommen, dann passt das so ganz gut zusammen.

00:34:21.600 --> 00:34:36.400
<v Carl Friedrich>Gerade sind wir ein bisschen mehr, also wir haben jetzt nicht so krass getaktete Releases wie C-Python, sondern das wird halt, also wir machen alle paar Monate ein Release, aber das heißt nicht unbedingt, dass dann auch die neue C-Python-Version supportet wird.

00:34:36.560 --> 00:34:45.120
<v Carl Friedrich>Und gerade sind wir so ein bisschen hinterher, also 3.9 ist jetzt eigentlich sehr, sehr stabil und 3.10 ist in der Mache, aber noch nicht released.

00:34:45.120 --> 00:34:47.600
<v Carl Friedrich>Und danach kommt halt dann 3.111.

00:34:47.600 --> 00:34:54.160
<v Carl Friedrich>Also das ist quasi ein Nachteil, warum man PiPy halt nicht nehmen sollte, ist ein bisschen hinterher.

00:34:54.160 --> 00:34:59.840
<v Carl Friedrich>Und dann habe ich vorhin gesagt, naja, jedes Python-Programm sollte halt gehen und idealerweise schneller sein.

00:34:59.840 --> 00:35:02.800
<v Carl Friedrich>Da gibt es jetzt zwei Fußnoten an dieser Aussage.

00:35:02.800 --> 00:35:05.360
<v Carl Friedrich>Die eine Fußnote ist halt C-Extensions.

00:35:05.440 --> 00:35:07.040
<v Dominik>Aber NumPy ist kaputt?

00:35:07.040 --> 00:35:08.960
<v Carl Friedrich>Nee, kaputt halt nicht.

00:35:08.960 --> 00:35:22.160
<v Carl Friedrich>Also inzwischen ist das so, dass wir so eine komplette Kompatibilitätsschicht haben, mit der, sag ich mal, 80% aller in C geschriebenen Bibliotheken in Pipeline auch gehen.

00:35:22.480 --> 00:35:26.320
Aber das ist wirklich, wir emulieren halt dieses Interface.

00:35:26.320 --> 00:35:31.760
<v Carl Friedrich>Für C Python ist das Interface halt wirklich genau so, wie der Interpreter auch wirklich funktioniert.

00:35:31.760 --> 00:35:41.360
<v Carl Friedrich>Und der Interpreter benutzt halt Reference Counting und die C-API, die hat halt überall die Tatsache, dass das Reference Counting ist, exposed.

00:35:41.600 --> 00:35:47.040
<v Carl Friedrich>Es gibt halt ein Increase-Reference Count-Makro und ein Decrease-Reference-Count Makro.

00:35:47.040 --> 00:35:53.120
<v Carl Friedrich>Und alle Libraries, die dann gegen diese API implementiert sind, die müssen das halt überall auch korrekt verwenden.

00:35:53.120 --> 00:35:57.200
<v Carl Friedrich>Aber bei uns ist es so, dass wir unseren Speicher halt nicht mit Reference-Counting verwalten.

00:35:57.200 --> 00:36:02.000
<v Carl Friedrich>Das heißt, wir müssen dann für die Bibliotheken so tun, als hätten wir einen Reference-Count.

00:36:02.000 --> 00:36:04.240
<v Carl Friedrich>Und das ist halt, das kostet halt so ein bisschen Performance.

00:36:04.240 --> 00:36:12.800
<v Carl Friedrich>Das heißt, bei uns sind in C geschriebene Erweiterungen halt quasi, die funktionieren, die können aber halt oft einfach langsamer sein.

00:36:12.800 --> 00:36:15.200
<v Carl Friedrich>Und das ist natürlich doof, weil

00:36:15.200 --> 00:36:19.200
<v Dominik>ein Massenpaket, der schneller sein will, aber die Sachen sind langsamer als würde die eigentlich auf normalen Python auf das Bildung.

00:36:19.280 --> 00:36:19.680
Genau.

00:36:19.680 --> 00:36:20.000
<v Carl Friedrich>Ja, ja.

00:36:20.000 --> 00:36:21.200
<v Carl Friedrich>Also ich meine, der Grund, warum man.

00:36:21.520 --> 00:36:25.280
<v Carl Friedrich>Es gibt ja so ein bisschen zwei Motivationen, warum man in C geschriebene Bibliotheken verwendet.

00:36:25.280 --> 00:36:30.400
<v Carl Friedrich>Einmal, weil man halt gerne mit irgendwelchen Bibliotheken geschrieben reden will, die halt in C geschrieben sind.

00:36:30.400 --> 00:36:35.840
<v Carl Friedrich>Das ist halt ein Ansatz, aber ein anderer Grund ist halt, weil man irgendwas schneller machen will, indem man es in C schreibt.

00:36:35.840 --> 00:36:40.000
<v Carl Friedrich>Und diese Motivation, die funktioniert halt dann auf PyPy oft nicht.

00:36:40.000 --> 00:36:44.720
<v Carl Friedrich>Und es wäre dann zum Teil einfach auch echt besser, wenn man halt einfach Python-Code nehmen würde.

00:36:44.720 --> 00:36:52.080
<v Carl Friedrich>Aber weil halt für C-Python alle jetzt schon ihre tollen in C-geschriebenen Optimierungen gemacht haben, ist das dann für uns oft auch halt eine Verschlechterung.

00:36:54.720 --> 00:37:03.360
<v Jochen>Könnte man da nicht vielleicht einfach auch den C aus PyPy heraus irgendwie, einfach den C-Python-Interpreter wieder aufrufen und diesen Kram händeln lassen?

00:37:03.600 --> 00:37:12.880
<v Carl Friedrich>Ja, da gab es auch immer mal wieder so ein paar Experimente, aber dann verliert man halt, also man will halt, dann verliert man halt möglicherweise die Vorteile für den Python-Code wieder.

00:37:12.880 --> 00:37:15.920
<v Carl Friedrich>Also, weil das Problem ist, du willst ja halt beide Seiten auch miteinander reden lassen.

00:37:16.080 --> 00:37:21.760
<v Carl Friedrich>Wenn du halt nur C-Code hast, dann ist halt eh die Frage, warum du eigentlich, was hast du da noch mit Python zu tun.

00:37:22.000 --> 00:37:33.680
<v Carl Friedrich>Also spannend wird es halt dann, wenn du quasi Python, also wenn dein Programm halt wirklich aus interessanten Teilen auf der Python-Seite besteht und interessanten Teilen auf der auf der Bibliotheksseite.

00:37:34.480 --> 00:37:36.640
<v Carl Friedrich>Die andere Fußnote ist, dass es manchmal nicht klappt.

00:37:36.640 --> 00:37:44.000
<v Carl Friedrich>Also man gibt halt, manchmal hat man wirklich einen Python geschriebenen Code und wir, der wird nicht schneller.

00:37:44.160 --> 00:37:46.640
<v Carl Friedrich>Also man muss halt einfach, man muss halt einfach messen.

00:37:46.800 --> 00:38:01.760
<v Carl Friedrich>Und um mal so ein bisschen so eine Größenordnung zu nennen, wir haben halt so Speedups zwischen so im allerbesten Fall, wenn halt alles ganz toll ist und du Pure Python-Code hast, gar keine Bibliothek, die in C geschrieben ist, und das ist alles jetzt, sag ich mal, sehr numerisch.

00:38:01.760 --> 00:38:07.280
<v Carl Friedrich>Also du hast viele Zahlen und irgendwie viele Floats oder, aber du machst das auch wirklich alles in Python.

00:38:07.280 --> 00:38:11.280
<v Carl Friedrich>Dann kannst du halt so Speedups von 50 Mal schneller als C Python kriegen.

00:38:11.280 --> 00:38:16.160
<v Carl Friedrich>Also das ist halt, das ist schon, also alle Leute, die halt sowas wie Advent of Code machen, ja.

00:38:16.640 --> 00:38:20.720
<v Carl Friedrich>Advent of Code ist so, ich scherze, aber ist irgendwie auch was wahrs dran.

00:38:20.720 --> 00:38:25.040
<v Carl Friedrich>Advent of Code ist halt irgendwie einer der hauptcoolen Use Cases für PyPy.

00:38:25.440 --> 00:38:32.240
<v Carl Friedrich>Da sind halt, es ist halt irgendwie nicht so viel Code, es passt auf ein paar Bildschirme, es ist irgendwie sehr algorithmisch und man braucht nicht so viele Bibliotheken.

00:38:32.240 --> 00:38:37.680
<v Carl Friedrich>Und das wird halt dann, und Performance ist irgendwie auch wichtig und da ist halt PyPi einfach mega gut dafür.

00:38:38.640 --> 00:38:41.920
<v Carl Friedrich>Genau, und bei Performance ist es halt so, man muss halt einfach messen.

00:38:42.000 --> 00:38:57.920
<v Carl Friedrich>Also du kannst halt nicht quasi so a priori entscheiden, dass es immer jetzt Speedup X bringt, sondern es führt quasi keinen Weg darum, dass du deine konkrete Anwendung halt ausprobierst und schaust, bringt es was oder halt nicht.

00:38:58.080 --> 00:39:02.960
<v Dominik>Habt ihr irgendwie ein Referenzsystem oder macht das einfach immer so objektiv von dem über den Richter?

00:39:03.840 --> 00:39:08.080
<v Carl Friedrich>Du meinst jetzt quasi, inwiefern das von der darunterliegenden Hardware abhängt?

00:39:08.320 --> 00:39:09.520
Ja, zum Beispiel, ja.

00:39:10.480 --> 00:39:12.000
Das ist, glaube ich, nicht so ein Problem.

00:39:12.000 --> 00:39:18.160
<v Carl Friedrich>Also wir unterstützen so einen Haufen CBU-Architekturen, aber da ist jetzt, da sind wir nicht so sensitiv.

00:39:18.160 --> 00:39:34.320
<v Carl Friedrich>Es geht eigentlich dann eher darum, was für Bibliotheken benutzt dein Projekt und sind die eher so C-lastig oder was es gibt halt Teile der Sprache, wo wir einfach richtig, richtig gut drin sind, die schneller zu machen und Teile der Sprache, wo wir dann nicht ganz so viel rausholen können.

00:39:34.560 --> 00:39:36.880
<v Dominik>Wie viel lernt C-Python von euch?

00:39:37.200 --> 00:39:39.200
<v Carl Friedrich>Das ist eine gute Frage.

00:39:39.440 --> 00:39:41.280
<v Carl Friedrich>Achso, ich wollte kurz die andere Abschließung.

00:39:41.280 --> 00:39:43.120
<v Carl Friedrich>Also im besten Fall so 30, 40X.

00:39:43.120 --> 00:39:44.560
<v Jochen>Ich antworte gleich noch nicht.

00:39:44.560 --> 00:39:49.200
<v Carl Friedrich>Und im schlechtesten Fall ist man halt auch mal 30% langsamer und das ist halt dann doof.

00:39:49.360 --> 00:39:50.880
<v Carl Friedrich>Da will man halt dann nicht sein.

00:39:51.840 --> 00:39:59.680
<v Carl Friedrich>C-Python, also ich habe manchmal so quasi so Momente des Zweifels.

00:39:59.680 --> 00:40:08.560
<v Carl Friedrich>Ich verbringe seit irgendwie 18 Jahren einen Teil meiner Freizeit und irgendwie einen Teil meines Berufs damit, an diesem Projekt zu basteln.

00:40:08.560 --> 00:40:16.480
<v Carl Friedrich>Und so richtig, also was weiß ich, 99% von allen Deployments sind halt neben C-Balten.

00:40:16.720 --> 00:40:20.320
<v Carl Friedrich>Und man kann sich dann halt die Frage stellen: warum macht man das eigentlich?

00:40:21.280 --> 00:40:24.080
<v Carl Friedrich>Also mir macht das natürlich irgendwie einfach unglaublich viel Spaß.

00:40:24.080 --> 00:40:30.400
<v Carl Friedrich>Also ich bastel da gern dran rum, aber es ist natürlich auch schön, dann so ein bisschen so quasi externe Motivation aufzukriegen.

00:40:30.640 --> 00:40:46.720
<v Carl Friedrich>Und klar, es gibt immer wieder Leute, die das halt dann benutzen und das ist halt auch sehr cool, aber es gibt halt immer wieder auch Momente, wo wir dann quasi so rück, politische Rückauswirkungen auf C-Python haben.

00:40:46.720 --> 00:41:00.080
<v Carl Friedrich>Und das ist quasi meiner Ansicht nach auch so ein bisschen so ein zweite Grund, warum ich halt der Ansicht bin, dass es eine gute Sache ist, dass es eine zweite, sehr ernsthafte Implementierung der Sprache Python gibt.

00:41:00.080 --> 00:41:01.200
<v Carl Friedrich>Weil wir quasi.

00:41:01.520 --> 00:41:04.480
<v Dominik>Ja, dann doch so ein bisschen Feature-Entwicklung durch die Hintertür.

00:41:04.480 --> 00:41:04.800
So ein bisschen

00:41:04.800 --> 00:41:06.640
<v Carl Friedrich>Feature-Entwicklung durch die Hintertür, ganz genau.

00:41:06.640 --> 00:41:10.080
<v Carl Friedrich>Und das ist zum Beispiel interessanterweise bei den Fehlermeldungen passiert.

00:41:10.320 --> 00:41:11.920
<v Carl Friedrich>Also so ein paar von den.

00:41:12.000 --> 00:41:13.760
<v Carl Friedrich>War das, das war 3.10 als 3.10.

00:41:14.000 --> 00:41:15.200
<v Dominik>Ja, 3.10 und 3.11, glaube ich.

00:41:15.840 --> 00:41:17.760
Ja, das ist Verbesserungen.

00:41:18.320 --> 00:41:22.560
Und bei beiden, also ich will jetzt wirklich nicht.

00:41:22.560 --> 00:41:23.760
<v Dominik>Keine Credits claimen.

00:41:23.760 --> 00:41:25.200
<v Carl Friedrich>Ich will keine Credits claimen.

00:41:25.200 --> 00:41:34.240
<v Carl Friedrich>Ich will auf gar keinen Fall, also was Pablo und Batuan Taskaya und sowas, was die da an den Aufwand reingesteckt haben, unglaublich nervig.

00:41:34.240 --> 00:41:36.160
<v Carl Friedrich>Und auch wirklich sehr, sehr cool.

00:41:36.480 --> 00:41:37.920
<v Carl Friedrich>Ich bin sehr zufrieden mit den Verbesserungen.

00:41:37.920 --> 00:41:39.280
<v Carl Friedrich>Wie gesagt, ich unterrichte Anfänger.

00:41:39.280 --> 00:41:43.520
<v Carl Friedrich>Ich kriege das quasi immer mit, wenn das halt mal schief liege mit den Fehlermeldungen.

00:41:43.520 --> 00:41:48.240
<v Carl Friedrich>Aber so ein bisschen, so der ursprüngliche Drive kam halt so ein bisschen von Pipe.

00:41:48.320 --> 00:41:51.760
<v Carl Friedrich>Also zum Beispiel dieses mit den nicht gematchten Klammern.

00:41:51.760 --> 00:41:54.560
<v Carl Friedrich>Das ist ja so eine der neuen Fehlermeldungen, dass es halt steht.

00:41:54.560 --> 00:42:00.720
<v Carl Friedrich>Die öffnende Klammer, die öffnete eckige Klammer auf Zeile 5 wird mit einer runden schließenden Klammer auf Zeile 9 geschlossen.

00:42:00.720 --> 00:42:02.000
<v Carl Friedrich>Da stimmt das nicht.

00:42:02.240 --> 00:42:05.840
<v Carl Friedrich>Das war halt einfach, das haben wir halt, das habe ich einfach vor ein paar Jahren mal implementiert.

00:42:05.840 --> 00:42:14.080
<v Carl Friedrich>Und irgendwann hat es halt in C-Python dann doch jemand mal gesehen und fand es cool genug, um es halt dann doch halt auch dann mal quasi nachzuimplementieren.

00:42:14.080 --> 00:42:17.680
<v Carl Friedrich>Und jetzt ist es so ein bisschen, fast so ein bisschen so ein Race manchmal.

00:42:17.680 --> 00:42:21.040
<v Carl Friedrich>Also gerade sind die, haben die ganz schön auch vorgelegt.

00:42:21.040 --> 00:42:25.200
<v Carl Friedrich>Also so ein paar der Fehlermeldungen haben wir jetzt noch nicht wieder übernommen.

00:42:25.200 --> 00:42:45.440
<v Carl Friedrich>Aber an ein paar Stellen gibt es halt immer noch ein paar, wo ich mit unseren dann zufrieden habe, zum Beispiel so ein absoluter Standard-Anfänger-Fehler, wo man halt echt Riesenprobleme hat, wenn man in Python einsteigt, wenn man so Objektorientierung lernt und man schreibt halt seine ersten Klassen und schreibt Methoden und kommt halt vielleicht von Java und vergisst das Self.

00:42:46.160 --> 00:42:48.640
<v Carl Friedrich>Und dann ruft man, versucht man die Methode aufzurufen.

00:42:49.120 --> 00:42:50.240
<v Dominik>Es ist Argument fehlt.

00:42:50.240 --> 00:42:52.400
<v Carl Friedrich>Und dann stimmt halt die Argumentzahl nicht.

00:42:52.400 --> 00:43:00.080
<v Carl Friedrich>Und dann vergleicht man halt einfach mal die Aufrufstelle mit der Funktionsdefinition und sagt, was ist denn eigentlich dein Problem?

00:43:00.080 --> 00:43:05.280
<v Carl Friedrich>Ich habe ja doch drei Argumente, warum beschwerst du dich denn, dass ich da nur, dass ich nur zwei reinreiche?

00:43:05.520 --> 00:43:08.640
<v Carl Friedrich>Oder ja, so, das ist ja, das stimmt ja dann immer nicht.

00:43:08.640 --> 00:43:23.600
<v Carl Friedrich>Und da mache ich in PiPy einfach nur, wenn es quasi ein Off-by-One-Error bei einem Methodenaufruf gibt, genau in diese Richtung, dann schaue ich, dann schaut der Interpreter nach, ob das erste Argument self heißt.

00:43:23.840 --> 00:43:28.720
<v Carl Friedrich>Und wenn nicht, steht einfach nur noch da, did you forget self in the method definition?

00:43:28.960 --> 00:43:31.120
<v Jochen>Ja, das ist wahrscheinlich eine gute Idee.

00:43:32.000 --> 00:43:32.800
Ja, keine Ahnung.

00:43:32.800 --> 00:43:38.960
<v Carl Friedrich>Das ist natürlich, also bei diesen Fehlermeldungen ist es halt auch wirklich so, du hast halt einfach tausend Fehler.

00:43:38.960 --> 00:43:40.080
<v Carl Friedrich>Also das ist auch nicht übertrieben.

00:43:40.080 --> 00:43:44.240
<v Carl Friedrich>Es gibt halt ganz, ganz viele Stellen im Interpreter, wo halt Fehler produziert werden.

00:43:44.240 --> 00:43:47.280
<v Carl Friedrich>Und jede einzelne ist halt dann irgendwie vielleicht auch gar nicht so wichtig.

00:43:47.520 --> 00:43:55.280
<v Carl Friedrich>Also so diese Arbeit an Fehlermeldungen, die ist halt wirklich auch in gewisser Weise sehr nervig, weil man sich um jede einzelne irgendwie halt Gedanken machen muss.

00:43:55.440 --> 00:43:57.360
<v Carl Friedrich>Und da gibt es halt auch keine Shortcuts so.

00:43:58.240 --> 00:44:03.840
<v Carl Friedrich>Aber das ist halt eine, wo ich mal dann so einen Tag dran Spaß hatte, mir zu überlegen, wie man das halt vielleicht verbessern kann.

00:44:05.280 --> 00:44:16.400
<v Carl Friedrich>Aber ich bin halt so ein bisschen, wie gesagt, ich will keinen Credit clown, aber ich habe so ein bisschen das Gefühl, dass wir da einfach so ein bisschen so einen Push gegeben haben, so einen Initial-Push.

00:44:16.400 --> 00:44:25.760
<v Carl Friedrich>Wir hatten halt an vielen Stellen da so ein paar Sachen dann zuerst implementiert und das fließt jetzt ganz stark ins C-Python an, da bin ich einfach mega glücklich drüber.

00:44:26.320 --> 00:44:27.280
<v Dominik>Das ist der Forscher Drang, ne?

00:44:27.280 --> 00:44:29.280
<v Dominik>Der so ein bisschen auch in die richtige Richtung, dann geht fein.

00:44:29.440 --> 00:44:29.840
<v Dominik>Der was?

00:44:30.000 --> 00:44:31.360
<v Dominik>Der Forscherdrang?

00:44:31.680 --> 00:44:35.840
<v Carl Friedrich>Ja, keine Ahnung, es ist jetzt nicht mein, eigentlich ist das nicht mein Forschungsgebiet, ne?

00:44:35.840 --> 00:44:40.800
<v Carl Friedrich>Das war eher so ein bisschen, ich habe halt dann wirklich gesehen, dass es für die Studenten echt dann zum Teil wirklich blöd ist.

00:44:40.800 --> 00:44:48.800
<v Carl Friedrich>Zum Beispiel auch mit diesen, das wurde jetzt auch abgeschafft, ich glaube jetzt auch in 3.11, also oder in 3.10, ich weiß nicht so.

00:44:48.800 --> 00:44:56.240
<v Carl Friedrich>Also zum Teil gab es diese Fehlermeldung, diese Syntax-Fehlermeldungen, die echt so ganz komische Abkürzungen drin hatten, die halt einfach nicht ausgeschrieben waren.

00:44:56.240 --> 00:45:03.520
<v Carl Friedrich>Insbesondere bei, zum Beispiel, wenn man die, wenn man die Quotes vergessen hat beim String.

00:45:03.520 --> 00:45:08.000
<v Carl Friedrich>Also einfach nur X gleich Anführungszeichen A, B, C und dann hast du hinten die Quotes vergessen.

00:45:08.000 --> 00:45:14.560
<v Carl Friedrich>Da war früher die Fehlermeldung, irgendwie EOL while scanning String Literal.

00:45:16.880 --> 00:45:18.880
Genau, auch noch ganz genau, ganz genau.

00:45:18.880 --> 00:45:20.080
Und das haben sie jetzt gefixt.

00:45:20.080 --> 00:45:26.480
<v Carl Friedrich>Das heißt, es ist halt wirklich end of line, weil ich meine, woher soll irgendjemand wissen, was EOL heißt?

00:45:26.640 --> 00:45:29.200
<v Carl Friedrich>Was Scanning heißt und auch noch was String Literal heißt.

00:45:29.200 --> 00:45:31.840
<v Carl Friedrich>Also das ist halt wirklich, und das ist jetzt wirklich schöner.

00:45:31.840 --> 00:45:43.040
<v Carl Friedrich>Und das ist zum Beispiel eine Triple Quoted String, sagt er dir jetzt auch die Fehlermeldung, wo die, also da war die Fehlermeldung halt immer in der allerletzten Zeile der Datei.

00:45:43.040 --> 00:45:45.360
<v Carl Friedrich>Weil er sucht ja einfach

00:45:45.360 --> 00:45:45.840
immer weiter.

00:45:46.400 --> 00:45:50.240
<v Jochen>Triple Quoted String ist es halt einfach dann wahrscheinlich der ganze Rest quasi, der da drin liegt.

00:45:50.240 --> 00:45:51.760
<v Jochen>Und am Schluss ist halt, da fehlt was dann.

00:45:52.080 --> 00:45:52.320
Genau.

00:45:52.480 --> 00:45:55.600
<v Carl Friedrich>Und jetzt, das ist jetzt wirklich in das wurde in drei Zehen gefixt.

00:45:55.600 --> 00:46:01.280
<v Carl Friedrich>Es ist jetzt halt so, dass er dir wirklich dann die Zeile zeigt, wo die öffnenden Triple-Boot sind und das ist natürlich viel schöner.

00:46:01.280 --> 00:46:07.200
<v Carl Friedrich>Und die andere Zeilennummer kommt aber auch vor in der Fehlermeldung, das heißt, du hast dann wirklich beides.

00:46:07.200 --> 00:46:11.120
<v Carl Friedrich>Und ja, also das ist alles schon sehr, sehr cool.

00:46:11.120 --> 00:46:23.120
<v Carl Friedrich>Und ich meine, die in 3.11, die Position Informations, die sind halt auch so ein bisschen, das war quasi noch ein bisschen fieser von mir, das hatte ich noch nicht mal implementiert.

00:46:23.120 --> 00:46:34.240
<v Carl Friedrich>Da habe ich nur so ein Screenshot gefaked, wo ich halt einfach nur im Editor einfach mal so diese Tilde unter den Teil des Ausdrucks gemacht habe, wo der Fehler herkommt.

00:46:34.240 --> 00:46:36.560
<v Carl Friedrich>Dann habe ich einen Screenshot davon getwittert.

00:46:36.560 --> 00:46:41.920
<v Carl Friedrich>Und das hat halt Pablo gesehen und dann super aufwendig.

00:46:42.320 --> 00:46:44.080
<v Carl Friedrich>Es ist ein wirklich sehr nerviges Feature.

00:46:44.560 --> 00:46:45.520
<v Jochen>Ja, das glaube ich.

00:46:46.080 --> 00:46:52.480
<v Jochen>Ich hab mich schon gefragt, wie das implementiert wurde, weil das ist natürlich so, oh ja, sehr cool, aber oh mein Gott, wie ist das denn implementiert?

00:46:52.480 --> 00:46:54.320
<v Jochen>Wie kriegt man das denn alles raus an den Stellen?

00:46:54.480 --> 00:46:59.760
Man muss halt wirklich einfach die gesamte Information durch den gesamten Stack so durchfädeln.

00:46:59.760 --> 00:47:08.640
<v Carl Friedrich>Und das ist an jeder Stelle, da muss man das weiterreichen und an jeder Stelle hat man halt, am Anfang hatten die Syntaxbäume halt auch die Information gar nicht.

00:47:08.640 --> 00:47:15.840
<v Carl Friedrich>Am Anfang hatte der Syntaxbäum halt nur eine Zeilennummer und dann kam irgendwie noch die Spaltnummer dazu, aber halt nur den Anfang.

00:47:15.840 --> 00:47:18.880
<v Carl Friedrich>Also das Ende, bis wohin das dann geht, das war halt, das kann man nicht vor.

00:47:18.960 --> 00:47:28.640
<v Dominik>Also nochmal für einen hätten sich das noch nicht genannt, es gibt halt viele Männer, da wird ja jetzt eine Position, wo das der Fehler passiert ist, mit so Dreiecken unter Kringelt quasi unterstrichen, wo das halt auch getroffen sein könnte.

00:47:28.720 --> 00:47:29.360
Und da hatte ich halt diesen

00:47:29.360 --> 00:47:30.720
Tweet gefaked und jetzt gibt's das.

00:47:30.720 --> 00:47:32.320
<v Carl Friedrich>Also, das ist mega geil.

00:47:32.320 --> 00:47:33.600
<v Carl Friedrich>Das sollte ich einfach öfter machen.

00:47:34.720 --> 00:47:41.680
<v Carl Friedrich>Und also ich muss das jetzt, das kommt dann wieder zu mir zurück, weil wenn wir eine 3-11 unterstützen, dann muss ich das ja auch implementieren.

00:47:41.680 --> 00:47:48.080
<v Carl Friedrich>Also insofern habe ich mich jetzt da ein Stück weit auch selber mit reingelegt, aber dass es jetzt halt in C-Balten drin ist, finde ich einfach mega cool.

00:47:48.080 --> 00:47:48.560
<v Jochen>Ja.

00:47:48.720 --> 00:47:51.600
<v Jochen>Dann weiß man halt schon, dass es sich lohnen wird, das zu implementieren.

00:47:52.240 --> 00:48:05.120
<v Carl Friedrich>Und ich meine, das andere große Feature, wo wir halt dann quasi so ein bisschen, also jetzt nicht Druck ausgeübt, aber halt dann quasi Einfluss produziert haben, sind halt die Order Dictionaries.

00:48:06.720 --> 00:48:08.960
<v Carl Friedrich>Also das ist ja in 3.6, glaube ich.

00:48:08.960 --> 00:48:10.880
<v Jochen>Ja, informellt.

00:48:11.520 --> 00:48:13.920
<v Jochen>Aber ab 3.7 wird dann auch tatsächlich garantiert, dass es.

00:48:14.080 --> 00:48:20.960
<v Carl Friedrich>In 3.6 haben sie halt gesagt, ihr dürft euch nicht drauf verlassen, dass die Dictionaries jetzt in der Einführungsreihenfolge sind.

00:48:20.960 --> 00:48:27.200
<v Carl Friedrich>Und in 3.7 haben sie dann gesagt, na, das funktioniert so gut, dass wir jetzt halt sagen, wir werden das auch nicht wieder abschaffen.

00:48:27.200 --> 00:48:31.200
<v Carl Friedrich>Und man darf sich jetzt drauf verlassen, weil es halt an ganz vielen Stellen echt auch viele Vorteile hat.

00:48:31.440 --> 00:48:33.040
<v Carl Friedrich>Und das ist ein Pipe-Feature.

00:48:33.040 --> 00:48:33.840
Achso, okay, dann ist es.

00:48:33.920 --> 00:48:34.800
Also gar nicht klar, ja.

00:48:34.880 --> 00:48:40.560
<v Carl Friedrich>Da gab es halt von Raymond Hattinger Prototyp, aber in Python, in Pure Python.

00:48:40.800 --> 00:48:45.200
<v Carl Friedrich>Und wir haben halt einfach gesagt, das sieht halt als Algorithmus echt gut aus.

00:48:45.200 --> 00:48:53.760
<v Carl Friedrich>Und wir machen jetzt das ganze Engineering, was man halt braucht, um das dann wirklich quasi in Produktiveinsatz in die Implementierung einzubauen.

00:48:53.760 --> 00:48:56.320
<v Carl Friedrich>Das haben wir halt einfach dann irgendwann mal gemacht.

00:48:56.320 --> 00:49:01.600
<v Carl Friedrich>Und zwar noch nicht mal für unsere 3.6-Versionen, sondern halt für unsere 2.7-Versionen.

00:49:01.600 --> 00:49:06.480
<v Carl Friedrich>Also bei uns sind halt Dictionaries schon immer, also nicht schon immer, jetzt schon seit ungefähr zehn Jahren irgendwie geordnet.

00:49:06.480 --> 00:49:10.400
<v Carl Friedrich>Und das war auch ganz schön, also dann, das war auch dann schon noch ganz schön viel Aufwand.

00:49:10.400 --> 00:49:38.560
<v Carl Friedrich>Also dieser Python-Code war halt so ein, jetzt Sketch wäre ein bisschen untertrieben, hat halt den Algorithmen so, den Algorithmus so irgendwie präsentiert, aber quasi dann das zu nehmen und es dann so weit zu pushen, dass es halt so gut ist und quasi an allen Stellen mit dem bisherigen Dictionary-Algorithmus dann auch wirklich mithalten kann und trotzdem die Insertion Order halt quasi erhalten bleibt.

00:49:38.560 --> 00:49:42.160
<v Carl Friedrich>Da haben wir halt dann wirklich nochmal sehr viel extra Aufwand reingesteckt.

00:49:42.160 --> 00:49:46.320
<v Carl Friedrich>Also Maschek Fischakovki und Armin Rigo haben das vor allem gemacht.

00:49:46.320 --> 00:49:56.160
<v Carl Friedrich>Und dann hatten wir das halt irgendwie und dann gab es halt einen C-Balton-Entwickler, der Name fällt mir gleich auch wieder ein, der hat das dann quasi wieder rückportiert.

00:49:56.400 --> 00:50:14.000
<v Carl Friedrich>Also hat halt unseren Code genommen und hat gesagt, ja cool, wir bauen das jetzt in C-Breiten ein, hat dann das irgendwie die nötige, ich weiß nicht, ob es da ein PEP für gab oder ob er die nötige Mailinglistendiskussion geführt und dann landete das halt in 3.6 und dann wurde es halt quasi auch offiziell Teil der Semantik.

00:50:15.680 --> 00:50:22.320
<v Carl Friedrich>Und ich meine, es ist halt eigentlich auch ganz cool, weil es ist halt wirklich, ich meine, das ist ja ein extra Feature und es ist.

00:50:22.400 --> 00:50:23.440
Das ist intuitiv irgendwie trotzdem.

00:50:23.520 --> 00:50:35.600
<v Carl Friedrich>Das ist intuitiv, ich finde es auch zum Lehren viel nicer, wenn man halt sagen kann, wenn man nicht immer erklären muss, warum beim Printen plötzlich halt einfach die Keys halt so durcheinander gewirbelt werden.

00:50:35.840 --> 00:50:36.560
<v Carl Friedrich>Das war ja früher so.

00:50:36.560 --> 00:50:44.720
<v Carl Friedrich>Also früher war es halt irgendwie, hing es von den Hash-Werten ab, das war halt komplett intransparent, warum halt dann die Sachen plötzlich ganz anders dastehen.

00:50:46.240 --> 00:50:54.560
<v Carl Friedrich>Und es ist halt auch gar nicht so, es ist halt auch a priori gar nicht so klar, dass das wirklich effizient geht.

00:50:54.560 --> 00:50:56.720
<v Carl Friedrich>Weil man könnte ja halt auch denken.

00:50:56.880 --> 00:50:57.840
Wie machen wir das jetzt?

00:50:58.080 --> 00:51:01.840
<v Dominik>Macht man quasi so ein Extra dazu, das immer noch von den Hashwerten abhängt?

00:51:03.440 --> 00:51:04.640
<v Carl Friedrich>Das ist gar nicht so einfach.

00:51:04.640 --> 00:51:15.920
<v Carl Friedrich>Also so, da gibt es halt so eine komische Indirektion jetzt drin, dass man quasi einmal die Hash Map hat und dann aber noch ein zweites Array, wo die Sachen in der Insertion Order drin sind.

00:51:15.920 --> 00:51:24.800
<v Carl Friedrich>Und dann würde man halt erstmal denken, dass man halt da plötzlich ganz viel Speicher irgendwie mehr braucht, weil man diese Indirektion hat.

00:51:25.120 --> 00:51:36.800
<v Carl Friedrich>Und da gibt es halt dann so einen Trick, und das ist wirklich auch das, was ich nicht verstanden hätte vorher, bevor die Leute das an sich halt ausgedacht haben, der Trick ist jetzt, die Hash Map, die darf ja nicht voll sein, weil du sonst Collisions kriegst.

00:51:36.800 --> 00:51:46.080
<v Carl Friedrich>Ich weiß, also wenn du quasi, wenn deine Hash Map irgendwie zu voll wird, dann musst du halt irgendwie die verdoppeln, um sicherzustellen, dass.

00:51:46.480 --> 00:51:48.240
<v Dominik>Beim nächsten Mal speicherfreis oder irgendwas reinkriegst.

00:51:48.400 --> 00:51:49.120
<v Carl Friedrich>Genau, ja.

00:51:49.120 --> 00:52:02.720
<v Carl Friedrich>Und der Trick ist jetzt aber, dass du mit dieser Indirektion jetzt den großen Teil einfach linear speicherst.

00:52:02.960 --> 00:52:06.720
<v Carl Friedrich>Also du kannst dann, diese Lücken fallen dann weg.

00:52:06.720 --> 00:52:16.640
<v Carl Friedrich>Die Lücken sind nur noch in deiner Indirektion drin, aber nicht mehr in deinem wirklichen Array, wo halt für jeden Eintrag ein Hash, ein Key und ein Value gespeichert werden.

00:52:17.280 --> 00:52:21.840
<v Carl Friedrich>Weil ein Eintrag von einem Dictionary besteht ja quasi aus drei Maschinenwörtern.

00:52:21.840 --> 00:52:28.080
<v Carl Friedrich>Und wenn die dann quasi immer noch so Lücken haben, hast du halt ständig Lücken, die alle drei Maschinenwörter groß sind.

00:52:28.080 --> 00:52:39.440
<v Carl Friedrich>Aber wenn du die in Direktion einbaust, dann ist quasi ein Eintrag nur noch ein Index in den dicht gespeicherten Insertion-Order-Speicher.

00:52:40.320 --> 00:52:42.960
<v Carl Friedrich>Jetzt sind wir an dem Punkt, wo wir eigentlich gerne ein Bild malen würden.

00:52:42.960 --> 00:52:43.920
<v Jochen>Ja, ja, aber das geht

00:52:43.920 --> 00:52:44.240
natürlich im Plan.

00:52:44.400 --> 00:52:53.920
<v Carl Friedrich>Vielleicht ist dann der Blogpost, ich finde den mal und wir verlinken den dann, aber für mich war es halt erstmal nicht klar, dass es wirklich auch wirklich eine gute Idee ist, das so zu machen.

00:52:53.920 --> 00:52:55.200
<v Carl Friedrich>Also ist es aber.

00:52:55.200 --> 00:52:57.920
<v Carl Friedrich>Also stellt sich halt raus, es ist es.

00:52:58.240 --> 00:52:59.360
<v Jochen>Ja, cool.

00:53:02.000 --> 00:53:07.680
<v Jochen>Dann hat man quasi dann für drüber iterieren, muss man dann einfach nur noch durch die echte Liste gehen und ganz genau gar nichts drum macht.

00:53:07.920 --> 00:53:17.360
<v Carl Friedrich>Das iterieren ist halt auch besser, weil vorher war es halt so, man musste quasi über die Hashmap drüber iterieren und bei jedem Eintrag gucken, ist das überhaupt ein Eintrag oder nicht.

00:53:17.520 --> 00:53:24.880
<v Carl Friedrich>Jetzt kann man aber quasi über den dichten Speicher drüber iterieren, wo einfach alle Einträge gültige Einträge sind.

00:53:25.120 --> 00:53:30.880
<v Carl Friedrich>Und man muss halt gar nicht mehr, man hat dann quasi, verliert auch ein If in jedem Next-Aufruf.

00:53:31.680 --> 00:53:37.200
<v Carl Friedrich>Also vorher war es so, dass man quasi in einem Next-Aufruf eine Schleife brauchte, um den nächsten gültigen Eintrag zu finden.

00:53:37.200 --> 00:53:39.680
<v Carl Friedrich>Und jetzt weiß man halt einfach, es ist der nächste Eintrag.

00:53:41.920 --> 00:53:42.640
<v Jochen>Schick.

00:53:42.960 --> 00:53:43.520
<v Carl Friedrich>Ja, genau.

00:53:43.520 --> 00:53:48.640
<v Carl Friedrich>Also das wäre halt auch noch so ein Beispiel, wo wir quasi dann die Implementierungsebene so ein bisschen beeinflusst haben.

00:53:51.040 --> 00:54:00.560
<v Carl Friedrich>Aber sonst, also so die ganzen Kerntechniken, die wir, also wir haben jetzt noch gar nicht so, bisher haben wir eher so ein bisschen phänomenologisch darüber geredet.

00:54:00.560 --> 00:54:02.480
<v Carl Friedrich>Wir führen das aus, es wird schneller.

00:54:02.480 --> 00:54:07.280
<v Carl Friedrich>Und ich glaube, irgendwie jetzt müssen wir vielleicht so ein bisschen anfangen darüber zu reden, wie das eigentlich geht.

00:54:10.240 --> 00:54:11.760
Also die Kern, ja.

00:54:12.320 --> 00:54:14.240
<v Dominik>Ich hätte noch ein, zwei Fragen vorher.

00:54:15.200 --> 00:54:18.560
<v Dominik>Also wenn das ja, werden alle Sachen schneller, du hast gesagt, okay, C-Extension nicht so schnell.

00:54:18.560 --> 00:54:22.400
<v Dominik>Was mit anderen Sprachen, also kann er C&lt;unk&gt; irgendwie, wenn das irgendwie angebunden ist, ein Problem?

00:54:22.640 --> 00:54:26.960
<v Carl Friedrich>Also weil das halt es wird halt erstmal vor allem Python schneller.

00:54:26.960 --> 00:54:28.880
<v Carl Friedrich>Also wirklich, wenn du Python-Code ausführen würdest, wird

00:54:28.880 --> 00:54:29.280
<v Dominik>er schneller.

00:54:29.280 --> 00:54:30.640
<v Dominik>Aber die anderen Sachen laufen noch?

00:54:30.640 --> 00:54:51.600
<v Carl Friedrich>Die anderen Sachen laufen noch und es kommt so ein bisschen drauf an, was die genau machen, ob die dann vielleicht langsamer werden oder halt einfach gleich bleiben oder und dann gibt es halt auch noch so Randfälle, zum Beispiel reguläre Ausdrücke sind auch sehr, sehr schnell bei uns in PyPy, obwohl die natürlich eigentlich kein Python-Code sind, aber da haben wir dann eine extra Optimierung dafür.

00:54:51.600 --> 00:54:55.920
<v Carl Friedrich>Es ist ja quasi so eine kleine DSL in Python, in gewisser.

00:54:56.400 --> 00:54:58.400
<v Dominik>Also du musst ja DSL nochmal beschreiben, welche Länge bist du meinst.

00:54:58.480 --> 00:55:01.440
<v Carl Friedrich>Genau, eine Domain-Specific Language für String-Matching.

00:55:01.440 --> 00:55:07.840
<v Carl Friedrich>Also ich meine, das ist eine sehr häufige, die halt quasi überall eingebaut ist, aber es ist ja schon eine andere Programmiersprache als Python letztlich.

00:55:08.320 --> 00:55:13.200
<v Carl Friedrich>Aber wir haben halt dafür auch dann quasi ganz viel Optimierung gemacht, dass das halt auch schon alles.

00:55:14.160 --> 00:55:18.880
<v Dominik>Normalerweise kann ich die per Pi-Env einfach installieren, dann mein PyPy auch?

00:55:19.120 --> 00:55:21.200
<v Carl Friedrich>Ich glaube, Pienv unterstützt auch PyPy, ja.

00:55:21.200 --> 00:55:24.880
<v Carl Friedrich>Also auch Talks hat eigentlich zum Beispiel PyPy-Support, wenn du das testen willst.

00:55:24.880 --> 00:55:34.000
Das ist schon an vielen Stellen quasi so ganz gut in die Infrastruktur.

00:55:34.960 --> 00:55:38.560
<v Carl Friedrich>Nach den Semesterferien kriegen wir hoffentlich einen Alpha-Release.

00:55:38.560 --> 00:55:40.800
<v Carl Friedrich>Und ja, also ich, da arbeite ich gerade halt dran.

00:55:41.520 --> 00:55:43.360
<v Carl Friedrich>Heute Morgen habe ich zwei Bugs gefixt.

00:55:43.360 --> 00:55:46.880
<v Carl Friedrich>Also das ist das, was ich jetzt gerade so halt wirklich konkret mache.

00:55:46.880 --> 00:55:50.560
<v Carl Friedrich>Und also die großen Features sind halt fast fertig.

00:55:50.560 --> 00:55:58.160
<v Carl Friedrich>Also Patternmatching ist da und 3.10 hatte, also außer Patternmatching halt auch viele so mittelgroße Sachen.

00:56:00.560 --> 00:56:02.400
<v Carl Friedrich>Aber Patternmatching, das war wirklich auch.

00:56:02.560 --> 00:56:06.800
<v Jochen>Kann ich mir vorstellen, das macht der beim Parsen ein relativ großes.

00:56:06.960 --> 00:56:15.120
<v Jochen>Ich glaube, das konnte ja auch nur deswegen in C Python irgendwie gemacht werden, weil da dann der neue Pack-Parser irgendwie verwendet wurde.

00:56:15.120 --> 00:56:17.360
<v Jochen>Und ich weiß gar nicht, bei PyPy, äh, Pipey.

00:56:17.600 --> 00:56:19.520
<v Jochen>Pipe Pipe ist eigentlich reingefallen.

00:56:21.840 --> 00:56:24.640
<v Jochen>Da weiß ich gar nicht, was da verwendet wird, aber das könnte ja dann auch auswählen.

00:56:24.880 --> 00:56:26.000
<v Carl Friedrich>Da hatte ich zum Glück sehr gut vor.

00:56:26.000 --> 00:56:33.760
<v Carl Friedrich>Also vor einem Jahr hatte ich dann 3.9 implementiert und da war 3.10 ja schon raus und da habe ich halt so gesehen, der Packparser wird wichtig.

00:56:33.760 --> 00:56:39.120
<v Carl Friedrich>Und ich habe dann quasi bei 3.9 schon die ganze technische Vorarbeit dafür geleistet.

00:56:39.120 --> 00:56:43.360
<v Carl Friedrich>Also wir haben halt, wir haben auch einen Pack-Parser, quasi mehr oder weniger die gleiche Architektur.

00:56:43.360 --> 00:56:49.360
<v Carl Friedrich>Wir können nicht ganz das gleiche Input-File nehmen, weil ich weiß nicht, ob du mal in diese Grammatikdatei reingeschaut hast.

00:56:49.360 --> 00:56:50.240
Nee, nicht wirklich.

00:56:50.400 --> 00:56:58.720
<v Carl Friedrich>Also es ist halt im Prinzip so ein bisschen so ein Kontext von freier Grammatik, wie man das halt irgendwie aus irgendeiner Informatikvorlesung vielleicht mal gesehen hat.

00:56:58.720 --> 00:57:06.960
<v Carl Friedrich>Aber im Unterschied zur alten Grammatik ist das so, dass jetzt in dem, in der Pack-Grammatik, da sind halt so Schnipsel an C-Code drin.

00:57:06.960 --> 00:57:10.160
<v Carl Friedrich>Und die können wir halt, die wollen wir halt nicht haben.

00:57:10.160 --> 00:57:14.880
<v Carl Friedrich>Und wir müssen quasi die Schnipsel an C-Code, die mussten wir halt quasi von Hand einfach einmal überall ersetzen.

00:57:14.880 --> 00:57:16.320
<v Carl Friedrich>Und das war sehr, sehr nervig.

00:57:16.960 --> 00:57:27.360
<v Carl Friedrich>Und das ist auch so ein bisschen meine Kritik, dass quasi die Grammatik der Sprache vermischt wird mit den Parsing-Actions, die in C geschrieben sind bei C-Python.

00:57:27.360 --> 00:57:32.640
<v Carl Friedrich>Bei uns sind die nicht in C geschrieben, wir werden gleich noch darüber sprechen, worin die bei uns dann geschrieben sind.

00:57:32.640 --> 00:57:39.040
<v Carl Friedrich>Aber das war halt dann einmal sehr, sehr nervig, da drüber zu gehen und alle diesen C-Schnipsel dann da auszutauschen.

00:57:39.040 --> 00:57:43.920
<v Carl Friedrich>Und da gibt's, da habe ich dann auch immer mal wieder einen Fehler gemacht, die finde ich dann jetzt auch immer mal wieder einen.

00:57:44.400 --> 00:57:46.400
<v Carl Friedrich>Also das war halt einfach Aufwand.

00:57:46.400 --> 00:58:00.320
<v Carl Friedrich>Aber ich habe halt damals quasi schon, vor dem Jahr dann quasi schon vorgearbeitet und gesagt, wenn dann 3.10 kommt, dann will ich halt quasi auch schon darauf vorbereitet sein, dass das Patternmatching dann in den Parser zumindest einfach einzufügen ist.

00:58:00.320 --> 00:58:12.720
<v Carl Friedrich>Aber es ist halt nicht nur ein Parser, es ist ganz viel neue Syntax, aber es sind halt auch einiges an neuen Bytecodes und der Bytecode-Compiler hat halt ganz, ganz viel recht komplexe Logik auch gekriegt.

00:58:13.040 --> 00:58:16.640
<v Carl Friedrich>Und das habe ich jetzt aber, das ist zum größten Teil jetzt halt ziemlich fertig.

00:58:16.640 --> 00:58:26.000
<v Carl Friedrich>Also da fehlt mir noch so ein, so ein Randfall, der muss ich jetzt irgendwann noch fixen, der hat mich bisher noch zu sehr genervt, aber das ist quasi fast durch.

00:58:27.120 --> 00:58:38.160
<v Carl Friedrich>Und dann, also jedes Release, so der, ich versuche mal so ein bisschen ein Gefühl dafür zu vermitteln, wie sich das anfühlt, an so einer neuen Python-Version zu arbeiten.

00:58:38.160 --> 00:58:43.440
<v Carl Friedrich>Es gibt halt immer irgendwie fünf große Features, die man halt auf der What's New Seite kennt.

00:58:43.440 --> 00:58:44.880
<v Carl Friedrich>Und die implementiert man halt.

00:58:44.880 --> 00:58:52.640
<v Carl Friedrich>Das ist dann irgendwie halt auch nice, ja, weil das ist so ein klar umrissener Task und man freut sich vielleicht halt auch über, vielleicht ist es halt auch ein Feature, was man gut findet.

00:58:52.880 --> 00:58:56.720
<v Carl Friedrich>Ich weiß nicht, wie ist euer Bauchgefühl, wie findet ihr Pattern Matching?

00:58:57.120 --> 00:58:57.840
<v Dominik>Ich liebe es.

00:58:58.320 --> 00:59:00.880
<v Jochen>Okay, ich habe es noch nicht wirklich viel verwendet, weil.

00:59:01.040 --> 00:59:02.320
<v Dominik>Also ich mag das total gerne nicht.

00:59:02.720 --> 00:59:05.520
<v Dominik>Statt if Elif irgendwie einfach schöne Case zu machen.

00:59:05.520 --> 00:59:07.520
<v Dominik>Gerade für so API-Parsing oder.

00:59:07.680 --> 00:59:08.640
Also ich finde, man muss sich

00:59:08.640 --> 00:59:12.080
<v Carl Friedrich>ganz, also ich verstehe absolut, dass man das total cool finden kann.

00:59:12.080 --> 00:59:21.280
<v Carl Friedrich>Ich habe es auch noch nicht so richtig im Produktiv, also noch nicht wirklich irgendwas geschrieben, was halt nicht einfach so ein tolles Beispiel ist, aber man muss sich schon so ein bisschen reindenken.

00:59:21.440 --> 00:59:30.080
<v Carl Friedrich>Also ich finde, es unterscheidet sich halt in mancher Hinsicht schon so ein bisschen von dem Feeling von Python an so ein paar anderen Stellen.

00:59:30.080 --> 00:59:36.480
<v Carl Friedrich>Also ich glaube, wenn man dann da so mal gedanklich drin ist, ist es, glaube ich, wirklich auch sehr, sehr cool.

00:59:36.480 --> 00:59:37.520
Aber man braucht so ein bisschen.

00:59:37.520 --> 00:59:38.960
<v Carl Friedrich>Oder ich habe das Gefühl, dass ich so noch so ein

00:59:38.960 --> 00:59:39.280
bisschen brauche.

00:59:39.520 --> 00:59:42.880
<v Dominik>Man kann irgendwie so direkte Kommandos geben und man kann da direkt sagen, was das ist.

00:59:42.880 --> 00:59:45.840
<v Dominik>Und in Zusammenhang mit den Typen, finde ich, ist das sehr schön.

00:59:45.840 --> 00:59:51.200
<v Dominik>Weil man, wenn man halt tatsächlich Typen definiert hat irgendwie, dann kann man halt einfach diesen Typ als Case nehmen.

00:59:51.200 --> 00:59:54.400
<v Dominik>Und das ist halt genau das, was man wahrscheinlich irgendwie.

00:59:54.960 --> 01:00:01.680
<v Carl Friedrich>Aber also was man dann wirklich in die Patterns reinschreibt, das ist halt quasi nochmal so ein bisschen so eine Sprache in der Sprache.

01:00:01.680 --> 01:00:07.680
Und die ist halt schon so ein bisschen anders halt auch als der Rest von Python.

01:00:08.720 --> 01:00:13.520
<v Dominik>Ja, aber jetzt, ich glaube, du musst vielleicht gleich nochmal so ein bisschen ausholen darüber, was eigentlich so eine Sprache aus deiner Sicht halt ist.

01:00:13.520 --> 01:00:14.000
<v Dominik>Und ausmachen.

01:00:14.560 --> 01:00:15.680
<v Carl Friedrich>Das ist jetzt ziemlich schwammig.

01:00:18.400 --> 01:00:18.800
<v Carl Friedrich>Genau.

01:00:18.800 --> 01:00:22.720
<v Carl Friedrich>Aber auf jeden Fall, also man hat halt so ein großes Feature, sowas wie Patamatching.

01:00:22.720 --> 01:00:23.600
Das ist halt schön.

01:00:23.600 --> 01:00:26.400
<v Carl Friedrich>Da kann man, weiß, man hat, das ist relativ klar umrissen.

01:00:26.400 --> 01:00:29.760
<v Carl Friedrich>Wenn man das Feature cool findet, dann macht es halt auch richtig Spaß, das zu implementieren.

01:00:29.760 --> 01:00:33.200
<v Carl Friedrich>Ja, dann so über ein paar Tage hinweg fängt das halt dann an zu funktionieren.

01:00:33.200 --> 01:00:35.680
<v Carl Friedrich>Das ist halt einfach immer wieder auch sehr cool.

01:00:35.680 --> 01:00:46.800
<v Carl Friedrich>Und irgendwann ist man halt dann mit allen großen Feature fertig und dann gibt es so ein bisschen, zusätzlich zu den fünf großen Feature, gibt es halt vielleicht 30 kleinere und mittlere Feature.

01:00:46.880 --> 01:00:49.040
<v Carl Friedrich>Das ist halt so ein bisschen Fleißarbeit.

01:00:49.040 --> 01:00:53.040
<v Carl Friedrich>Und dann gibt es aber halt einfach 1000 Details.

01:00:53.680 --> 01:00:59.920
<v Carl Friedrich>Und das sind halt, das ist der Teil, der quasi am längsten dauert und ein bisschen am nervigsten ist.

01:00:59.920 --> 01:01:04.240
<v Carl Friedrich>Also weil man halt jeden Tag einfach fünf kleine Details fixen kann.

01:01:04.480 --> 01:01:13.120
<v Carl Friedrich>Und man findet die, indem man halt die Test Suite, die Teil der C-Python-Standardbibliothek ist, ausführt.

01:01:13.120 --> 01:01:16.640
<v Carl Friedrich>Und dann halt die fehlenden Tests nach und nach fixt.

01:01:16.960 --> 01:01:20.080
<v Carl Friedrich>Und mit den großen Features ist man halt irgendwann durch.

01:01:20.080 --> 01:01:24.160
<v Carl Friedrich>Also es gibt halt Test Padma, das hat man halt irgendwann dann, das passt dann, dann ist es alles super.

01:01:24.160 --> 01:01:28.880
<v Carl Friedrich>Aber dann ist halt in allen anderen Dateien gibt es halt dann so einen fehlschlagenden Test.

01:01:28.880 --> 01:01:32.240
<v Carl Friedrich>Und jeder von diesen fehlsteiligen Tests dauert halt zwei Stunden.

01:01:32.240 --> 01:01:38.880
<v Carl Friedrich>Und das ist halt einfach das, was einfach ganz, ganz, also da gibt es halt quasi dann so ein Long Tail an irgendwelchen Details.

01:01:39.360 --> 01:01:46.320
<v Jochen>Und der quasi Fortschritt, den man dadurch erzielt, dass man das fixt, ist halt auch irgendwann dann nicht mehr so groß.

01:01:46.880 --> 01:01:48.960
<v Jochen>Wahrscheinlich denkt man sich dann irgendwann so, das lohnt

01:01:48.960 --> 01:01:49.280
<v Dominik>sich halt.

01:01:50.960 --> 01:01:51.200
Genau.

01:01:51.920 --> 01:01:54.880
<v Dominik>Okay, aber das ist halt tatsächlich dann TDD auch, was ihr da macht.

01:01:55.200 --> 01:02:04.880
<v Carl Friedrich>Ja, also Piper ist von der Entwicklungsphilosophie sehr, also ich meine, wir haben ja vorhin ganz kurz gesagt, dass es jetzt irgendwie 20 Jahre altes Projekt ist.

01:02:04.880 --> 01:02:08.640
<v Carl Friedrich>Also es wurde jetzt fast genau, also irgendwie 17.

01:02:08.640 --> 01:02:13.040
<v Carl Friedrich>Februar war das erste Treffen von so ein paar Leuten in Hildesheim.

01:02:13.040 --> 01:02:13.840
2003.

01:02:14.080 --> 01:02:15.280
<v Carl Friedrich>2003, genau.

01:02:15.280 --> 01:02:18.080
<v Carl Friedrich>Also völlig anderes Zeitalter so ein bisschen.

01:02:18.960 --> 01:02:36.560
<v Carl Friedrich>Und damals war das halt irgendwie so ein bisschen, hatte das so ein bisschen so ein Extreme-Programm-Kontext auf der Entwicklungsphilosophie-Seite, also so mit Test-Driven Development und Agile before das kommerzialisiert wurde, so in der Idee her.

01:02:39.600 --> 01:02:45.440
<v Carl Friedrich>Es ist wirklich so, dass diese Implementierung von vornherein komplett test-driven entwickelt wurde.

01:02:45.600 --> 01:02:52.640
<v Carl Friedrich>Das ist halt an vielen Stellen auch wirklich ganz tief drin in der Philosophie des Projekts.

01:02:52.640 --> 01:02:57.200
<v Carl Friedrich>Und das ist auch so, dass PiTest aus Piper hervorgegangen ist.

01:02:57.440 --> 01:03:02.880
<v Carl Friedrich>Also der Holger Krickel, über den haben wir, bevor wir auffangen aufzunehmen, kurz schon geredet, der war halt einer der.

01:03:03.040 --> 01:03:03.760
Der ist Holger.

01:03:03.760 --> 01:03:04.720
Ja, ich erinnere mich.

01:03:05.680 --> 01:03:17.440
<v Carl Friedrich>Der war halt einer der Gründer des PyPy-Projekts, also der hat das erste Treffen in Hildesheim organisiert und am Anfang wurde dann für die Tests halt einfach Unitest genommen.

01:03:17.440 --> 01:03:26.720
<v Carl Friedrich>Und Unitest ist ja ein von Java portiertes, an Java-Architektur angelehntes Testing-Framework.

01:03:28.160 --> 01:03:31.760
<v Jochen>Aber ich glaube, JUnit ist irgendwie S-Unit von Smart Talk.

01:03:32.880 --> 01:03:38.400
<v Carl Friedrich>Aber durch diesen Umweg über Java ist es halt irgendwie doch ein bisschen Ungelenk an vielen Stellen.

01:03:38.960 --> 01:03:48.960
<v Carl Friedrich>Und weil Holger halt dann das alles auch ganz schön doof fand, hat er recht früh als Teilprojekt von PyPy halt angefangen, PyTests zu entwickeln.

01:03:50.800 --> 01:04:01.440
<v Carl Friedrich>Und das ging dann quasi aus dem PyPy-Projekt irgendwie so ein Stück weiter vor und ist jetzt natürlich eine Million Mal erfolgreicher als alles, was PiPi irgendwie jemals sonst so gemacht hat.

01:04:01.600 --> 01:04:11.200
<v Dominik>Pipei spannend, also am Anfang habe ich es gehasst und jetzt finde ich es richtig gut, weil das halt echt total gut ist und ich finde es sehr Pythonic und wenn man einmal so ein bisschen vielleicht verstanden hat, wie das funktioniert, das ist sehr, sehr, sehr schön zu nutzen.

01:04:11.680 --> 01:04:21.840
<v Carl Friedrich>Also ich meine halt einfach so dieses, dass man davon wegkommt, dass man diese 97 Self-Assert irgendwas Funktion braucht, um gute Fehlermeldung zu kriegen.

01:04:21.840 --> 01:04:22.560
<v Carl Friedrich>Das ist halt schon.

01:04:22.800 --> 01:04:24.880
<v Dominik>Self-Assert-Equal irgendwie Camel-Case und sowas.

01:04:25.120 --> 01:04:26.080
Equal oder Equals?

01:04:26.240 --> 01:04:26.960
Genau, ja, ja, genau.

01:04:27.280 --> 01:04:29.200
<v Jochen>Das macht bloß kann nichts Falsches sein.

01:04:32.000 --> 01:04:34.160
<v Jochen>Ja, und Camel-Case natürlich auch mal.

01:04:34.880 --> 01:04:41.680
<v Carl Friedrich>Ja, und ich finde halt also gerade so die Hürde, man schreibt halt einfach eine Funktion, die Test heißt, dahin und dann geht halt, das ist halt schon sehr, sehr cool.

01:04:42.480 --> 01:04:50.720
<v Carl Friedrich>Ne, genau, also Test-Driven Development war halt einer der Kernideen so auf der, wie entwickeln wir dieses Projekt.

01:04:50.720 --> 01:05:01.520
<v Carl Friedrich>Das andere war halt, das ist so ein bisschen verloren gegangen über die Jahre, aber einer der Ideen am Anfang war halt wirklich, wir wollen eine sehr gut verständliche Implementierung der Sprache schreiben.

01:05:01.520 --> 01:05:05.760
<v Carl Friedrich>Und da müssen wir irgendwann jetzt halt dann doch mal zur Architektur kommen.

01:05:05.760 --> 01:05:08.160
<v Carl Friedrich>Warum heißt das Ding eigentlich PyPy?

01:05:09.520 --> 01:05:10.880
Weil es PyPy noch nicht gab.

01:05:11.280 --> 01:05:12.240
<v Carl Friedrich>Ja.

01:05:12.640 --> 01:05:13.520
Nein, Entschuldigung.

01:05:13.760 --> 01:05:39.360
<v Carl Friedrich>Also das Projekt ist halt entstanden aus Diskussionen auf erst der deutschen Python-Mailing-Liste und dann irgendwie auch Complang Python von halt Python-Fans, also halt so ein paar Leuten, die irgendwie Python als Programmiersprache toll fanden und die halt gesagt haben, naja, es ist doch philosophisch eigentlich irgendwie blöd, dass wir alle Python so toll finden, aber der Interpreter für Python, dass der ja in C geschrieben ist.

01:05:39.840 --> 01:05:50.800
<v Carl Friedrich>Und PyPy ist halt wirklich, die Idee war wirklich, wir schreiben jetzt eine Implementierung für Python, aber wir wollen dafür halt nicht C nehmen, weil C so eine blöde Sprache ist, sondern wir wollen dafür halt Python nehmen, weil wir alle Python-Fans sind.

01:05:51.120 --> 01:05:55.120
<v Carl Friedrich>Und das war quasi, also da kommt der Name her, PyPy ist Python in Python.

01:05:55.120 --> 01:06:04.800
<v Carl Friedrich>Und das war halt so ein bisschen die Ursprungsmotivation, wir wollen jetzt die Sprache nehmen, die wir cool finden, um die Sprache selbst zu implementieren.

01:06:04.800 --> 01:06:10.160
<v Carl Friedrich>Und das klingt halt erstmal ganz, also nach einem sehr akademischen Experiment.

01:06:10.160 --> 01:06:12.320
<v Carl Friedrich>Und das war es ein Stück weit, glaube ich, auch erstmal.

01:06:12.320 --> 01:06:18.560
<v Carl Friedrich>Also erstmal war halt so ein bisschen die Idee auch, wir wollen irgendwie Code schreiben, den man halt einfach erstmal schön lesen kann.

01:06:18.560 --> 01:06:21.680
<v Carl Friedrich>Und der soll natürlich schon auch irgendwie funktionieren.

01:06:21.680 --> 01:06:32.160
<v Carl Friedrich>Aber insbesondere soll der halt einfach architektonisch toll sein und irgendwie elegant und alles schön, diese Sprachsemantik soll irgendwie ganz klar ausgedrückt werden in diesem Python-Code.

01:06:32.160 --> 01:06:34.160
<v Carl Friedrich>Das war quasi eine der Ideen.

01:06:34.160 --> 01:06:46.880
<v Carl Friedrich>Und erst später kam es dann hinzu, dass quasi Performance eigentlich ein immer wichtiger Teil der Projekt der Projektmotivation war.

01:06:46.880 --> 01:06:51.200
<v Carl Friedrich>Also irgendwann hat man halt gesagt, naja, okay, wir haben das jetzt, aber warum sollte man das machen?

01:06:51.200 --> 01:06:58.640
<v Carl Friedrich>Und wir machen jetzt halt auch noch ganz, ganz, ganz viel Aufwand, um, also welchen Aufwand da rede ich vielleicht gleich noch ein bisschen was dazu.

01:06:58.640 --> 01:07:02.800
<v Carl Friedrich>Wir machen halt ganz, ganz viel Aufwand, um das dann doch irgendwie auch schnell zu kriegen.

01:07:02.800 --> 01:07:05.360
<v Carl Friedrich>So, und vielleicht können wir da auch einfach wirklich historisch vorgehen.

01:07:05.360 --> 01:07:14.880
<v Carl Friedrich>Also die erste Idee, um das jetzt schneller zu kriegen, also man hat dann jetzt irgendwie so eine Python-Implementierung, die ist in Python geschrieben und die ist schön und elegant, man kann das lesen, aber das bringt einem halt einfach gar nichts.

01:07:15.040 --> 01:07:19.920
<v Carl Friedrich>Weil man braucht ja einfach immer noch darunter einen Python-Interpreter, um das ausführen zu können.

01:07:20.080 --> 01:07:24.720
<v Carl Friedrich>Und dann ist es halt einfach quasi ein Python-Interpreter, der auf einem, der auf C-Python läuft.

01:07:24.720 --> 01:07:26.480
<v Carl Friedrich>Das ist halt einfach ganz, ganz langsam.

01:07:26.480 --> 01:07:29.200
<v Dominik>Aber man kann natürlich dann viel über die Sprache vielleicht lernen.

01:07:29.520 --> 01:07:34.800
<v Carl Friedrich>Genau, man kann dann was lernen und man kann da bestimmt auch irgendwie dann schön einfach irgendwie Experimente durchführen.

01:07:34.800 --> 01:07:39.200
<v Carl Friedrich>Aber das ist jetzt nichts, was man irgendwie im Produktiveinsatz haben wollte.

01:07:39.200 --> 01:07:43.680
<v Carl Friedrich>Es wäre halt dann wirklich einfach eher so ein, es wäre halt vielleicht so ein cooler Blogpost oder so, oder?

01:07:43.680 --> 01:07:44.320
Ein cooles Buch.

01:07:44.320 --> 01:07:47.040
Okay, aber halt viel mehr auch nicht.

01:07:47.040 --> 01:07:57.040
<v Carl Friedrich>Und die erste Idee ist quasi, dass man jetzt sagt, wir machen einen Prozess, den man halt irgendwie Bootstrapping nennen kann.

01:07:57.040 --> 01:08:09.040
<v Carl Friedrich>Wir nehmen jetzt diesen Python-Interpreter, der in Python geschrieben ist, und übersetzen den, also schreiben einen Compiler, der jetzt diesen Code nehmen kann und den nach C übersetzen kann.

01:08:09.440 --> 01:08:13.680
<v Carl Friedrich>Und das geht halt nicht für allgemeinen Python-Code.

01:08:13.680 --> 01:08:17.760
<v Carl Friedrich>Also man kann Python-Code halt nicht nach C kompilieren, das bringt nicht viel.

01:08:17.760 --> 01:08:26.000
<v Carl Friedrich>Aber deswegen beschränken wir uns auf eine Teilmenge von Python in dem Code, den wir in der Implementierung des Interpreters verwenden.

01:08:26.000 --> 01:08:32.560
<v Carl Friedrich>Also der Interpreter ist quasi in einer Teilmenge geschrieben und die ist so gewählt, dass man diese Teilmenge gut nach C übersetzen kann.

01:08:32.560 --> 01:08:37.360
<v Carl Friedrich>Und dann wird man quasi dieses Interpreterturm problemlos.

01:08:37.360 --> 01:08:45.280
<v Carl Friedrich>Also dann kann man quasi den Python-Interpreter nehmen, der ist nicht mehr in Python geschrieben, sondern in, ich sage jetzt gleich den Namen, in RPython.

01:08:45.280 --> 01:08:50.000
<v Carl Friedrich>Das ist eine Teilmenge der Sprache und die ist so gewählt, dass man sie nach C übersetzen kann.

01:08:50.000 --> 01:09:01.120
<v Carl Friedrich>Und RPython heißt es halt, weil es restricted Python ist, weil man halt einfach so ein bisschen die ganz dynamischen Sachen, die man in Python machen kann, die macht man halt einfach nicht.

01:09:01.120 --> 01:09:03.360
<v Carl Friedrich>Um eben das Übersetzen nach C zu ermöglichen.

01:09:03.360 --> 01:09:06.400
<v Dominik>Also man ändert keinen Typ einer Variable irgendwie on the fly.

01:09:06.400 --> 01:09:06.960
Ganz genau.

01:09:06.960 --> 01:09:09.680
<v Carl Friedrich>Also das ist, glaube ich, sogar noch nicht mal ganz so schlimm.

01:09:09.680 --> 01:09:14.080
<v Carl Friedrich>Also man macht halt so Sachen, man fügt einer Klasse keine neuen Methoden zur Laufzeit hinzu.

01:09:14.400 --> 01:09:17.440
<v Carl Friedrich>Oder in Python gehen ja alle möglichen komischen Sachen.

01:09:17.440 --> 01:09:21.360
<v Carl Friedrich>Man kann halt ja auch bei einer Instanz dann da Class zuweisen und so.

01:09:21.600 --> 01:09:31.200
<v Carl Friedrich>Also so dieses ganze, ganz dynamische Metaprogrammierungszeug, das ist halt einfach verboten, weil da ist halt nicht so klar, wie der C-Code dann aussä, den man da generieren würde.

01:09:31.200 --> 01:09:32.320
<v Carl Friedrich>Also das ist der erste Schritt.

01:09:32.320 --> 01:09:46.320
<v Carl Friedrich>Der erste Schritt ist, das ist nicht mehr Python in beliebigem Python-Code, sondern das ist Python eine Implementierung für die Sprache Python in einer Timenge von Python und wir haben dazu noch ein anderes Tool, was jetzt diese Teilmenge nimmt und daraus C-Code erzeugt.

01:09:46.320 --> 01:09:48.480
<v Carl Friedrich>Und so wird man C-Python erstmal los.

01:09:48.480 --> 01:10:04.720
<v Carl Friedrich>Also danach, du drückst dann auf den Knopf und dann nimmt der halt den Interpreter, der in der Tilmenge geschrieben ist, erzeugt C-Code daraus, dann startest du den C-Compiler und der nimmt den C-Code und macht daraus halt eben wieder ein Binary, über das wir ja vorhin schon gesprochen haben, dass das runtergeladen werden kann.

01:10:04.720 --> 01:10:16.880
<v Carl Friedrich>Und das ist halt dann quasi einfach ein etwas merkwürdiges, also geschriebenes, aber das verhält sich jetzt, also es ist quasi noch näher dran an dem, was man von Python.org runterladen kann.

01:10:16.880 --> 01:10:26.000
<v Carl Friedrich>Es ist halt ein nicht in hand geschriebener C-Code, sondern generierter C-Code, aber es ist halt einfach dann ein Interpreter für Python in C, letztlich.

01:10:26.800 --> 01:10:43.040
<v Carl Friedrich>Und das bringt halt schon dann mal die ersten, also vorher, so um mal so eine Größenordnung zu nennen, wenn man das, wenn man dann PyPy auf C-Python ausführt, dann hat man halt irgendwie so einen Interpreter, der vielleicht 2000 Mal langsamer ist als C-Python.

01:10:43.040 --> 01:10:45.840
<v Carl Friedrich>Also dann ist es halt wirklich, das ist nur ein Spielzeug.

01:10:45.840 --> 01:10:56.400
<v Carl Friedrich>Und wenn man dann diesen Bootstrapping-Trick macht, dass man eben wieder C-Kode erzeugt, dann gewinnt man halt von diesen 2000 Mal langsamer, gewinnt man halt 1000 Mal zurück.

01:10:56.400 --> 01:10:59.040
<v Carl Friedrich>Dann hat man quasi einen Interpreter, der ist

01:10:59.040 --> 01:11:00.160
<v Dominik>nur tausendmal langsamer.

01:11:00.160 --> 01:11:01.360
Nee, nee, nur zweimal langsamer.

01:11:01.440 --> 01:11:02.240
Achso, okay.

01:11:02.240 --> 01:11:04.000
<v Carl Friedrich>Also Faktor 1000 kriegt man wieder.

01:11:05.200 --> 01:11:07.120
<v Carl Friedrich>Aber einen Faktor 2 hat man halt immer noch.

01:11:07.120 --> 01:11:08.560
Und das ist natürlich immer noch nicht gut.

01:11:09.120 --> 01:11:11.040
<v Carl Friedrich>Also warum sollte man das machen?

01:11:11.840 --> 01:11:17.840
<v Carl Friedrich>Man, weil es halt in Python geschrieben ist und wir alle Python so toll finden.

01:11:18.160 --> 01:11:20.000
<v Carl Friedrich>Das reicht halt irgendwie als Motivation nicht.

01:11:20.000 --> 01:11:25.760
<v Carl Friedrich>Und jetzt ist so ein bisschen die Frage, wo kommt jetzt, wo kommt eigentlich wirklich das Speed her?

01:11:25.760 --> 01:11:32.800
<v Carl Friedrich>Und da wird es halt dann so ein bisschen akademisch, also das ist quasi der Forschungsanteil.

01:11:33.280 --> 01:11:49.680
<v Carl Friedrich>Also ich habe da meine Doktorarbeit drüber geschrieben, das ist quasi wirklich so ein bisschen ein, ja, also war wirklich so ein bisschen ein ganz klassisches akademisches Forschungsprojekt, da war ja währenddessen auch gar nicht so klar, ob das wirklich klappen kann, so von der Idee her.

01:11:49.680 --> 01:11:57.040
<v Carl Friedrich>Und hat auch, sag ich mal, vielleicht fünf, sechs Jahre gedauert, bis es dann klarer wurde, dass es halt wirklich geht.

01:11:57.040 --> 01:12:07.360
<v Carl Friedrich>Und die Idee daran ist, dass du, also sagt man ja auch immer so ein bisschen so, wenn man halt irgendwie das schnell kriegen will, dann braucht man halt irgendwie einen Jet-Compiler.

01:12:07.360 --> 01:12:13.120
<v Carl Friedrich>Also wenn man halt irgendwie eine dynamische Programmiersprache schnell ausführen will, dann braucht man einen Just-in-Time-Compiler.

01:12:13.120 --> 01:12:13.760
<v Carl Friedrich>Und was ist das?

01:12:13.760 --> 01:12:20.000
<v Carl Friedrich>Ein Justin-Time-Compiler, also so ein normaler Compiler, der funktioniert halt für Python nicht, weil man ja gar keine Typen hat.

01:12:20.000 --> 01:12:23.200
<v Carl Friedrich>Also das ist jetzt mit Typen-Annotation heutzutage so ein bisschen anders.

01:12:23.200 --> 01:12:26.640
<v Carl Friedrich>Aber die Typ-Annotationen, die sind ja auch so ein bisschen so eine Fiktion.

01:12:27.440 --> 01:12:29.200
<v Carl Friedrich>Die dürfen ja auch falsch sein.

01:12:31.360 --> 01:12:32.880
<v Carl Friedrich>Also vergessen wir die erstmal.

01:12:32.880 --> 01:12:40.560
<v Carl Friedrich>Also das Problem ist, wenn man einfach Python-Code anschaut, dann kann man den halt nicht unbedingt jetzt kompilieren.

01:12:40.560 --> 01:12:56.080
<v Carl Friedrich>Wenn man halt eine Funktion hat, die A und B als Argumente nimmt und die Funktion macht irgendwie Return A mal 2 plus B, dann kann man halt diese Funktion nicht nach Maschinencode übersetzen, weil man weiß halt gar nicht, was das mal macht.

01:12:56.080 --> 01:13:11.760
<v Carl Friedrich>Also man kann die Funktion halt mit ins aufrufen, man kann die mit Floats aufrufen, man kann die mit Strings aufrufen oder man kann die halt mit einer Klasse aufrufen, die halt einen Unterstrich-unterstrich-Ad-Methode hat und eine Unterstrich-Mull-Methode und die halt irgendwas super Weirdes macht.

01:13:12.160 --> 01:13:22.640
<v Dominik>Das heißt, man muss quasi die Anwendungsfälle kennen, in denen das aufgerufen wird, irgendwann in diesem Programmablauf und dann daraus jeweils unterschiedliche Implementierungen im Zinkencode zu schreiben, die man dann falsch hat.

01:13:22.880 --> 01:13:23.360
Ganz genau.

01:13:23.360 --> 01:13:26.640
<v Carl Friedrich>Und das kann man aber halt quasi nicht ohne weiteres statisch machen.

01:13:26.640 --> 01:13:36.720
<v Carl Friedrich>Also man kann jetzt, es ist nicht leicht, sich quasi nur den Quellcode anzuschauen und zu sagen, aha, A und B sind ja immer Inns.

01:13:36.720 --> 01:13:52.400
<v Carl Friedrich>Weil es kann ja sein, dass es halt an sieben verschiedenen Stellen wird die Funktion jetzt aufgerufen wird und an zwei davon sieht es so aus, als könnten das Ins sein, aber an den anderen drei weiß ich nicht so genau und das ist überhaupt eine Bibliothek drin und ich weiß halt überhaupt nicht so genau, wie die Bibliothek jetzt verwendet wird, konkret von irgendeiner Anwendung.

01:13:52.400 --> 01:13:59.280
<v Carl Friedrich>Das heißt, so einfach, wenn ich mir nur den Quellcode anschaue, kann ich für diese Funktion F keinen guten Maschinencode erzeugen.

01:13:59.280 --> 01:14:04.320
<v Carl Friedrich>Und deswegen braucht man halt quasi, also ein normaler Compiler geht halt nicht.

01:14:04.720 --> 01:14:20.880
<v Carl Friedrich>Und deswegen braucht man halt eben den Justin-Time-Compiler und das ist ein Compiler, der erzeugt zwar schon Maschinencode, aber der macht das nicht so einmal vor der Ausführung, sondern der macht das quasi während das Programm schon läuft.

01:14:20.880 --> 01:14:29.120
<v Carl Friedrich>Und der Grund, warum ein Dustin-Time-Compiler eben funktioniert, ist, weil er einen ganz krassen Informationsvorteil hat.

01:14:29.120 --> 01:14:35.680
<v Carl Friedrich>Der Dustin-Time-Compiler, der kann halt einfach gucken, mit was für Typen von Argumenten die Funktion aufgerufen wird.

01:14:35.920 --> 01:14:41.440
<v Carl Friedrich>Also der ist halt einfach quasi, der Compiler ist maximal faul und sagt, ich kompiliere erstmal gar nichts.

01:14:41.440 --> 01:14:44.640
<v Carl Friedrich>Ich führe einfach alles ganz normal mit dem Interpreter aus.

01:14:44.640 --> 01:14:56.640
<v Carl Friedrich>Und wenn sich dann herausstellen sollte, dass F jetzt in dem Programm eine wichtige Funktion ist, macht man so ein bisschen Profiling, dann schaue ich halt mal, was für Typen werden jetzt hier konkret verwendet.

01:14:56.640 --> 01:15:00.320
<v Carl Friedrich>Und wenn, dann irgendwann sehe ich halt, na gut, es sind immer zwei Floats.

01:15:00.320 --> 01:15:23.600
<v Carl Friedrich>Und dann kann ich halt auch guten Maschinencode erzeugen, weil wenn ich weiß, dass es Floats sind, dann kann ich halt das Mal, also ich hatte A mal 2 plus B gesagt, dann kann ich halt das Mal 2 durch eine Maschineninstruktion darstellen, die halt Doubles auf der CPU direkt multipliziert.

01:15:23.600 --> 01:15:30.160
<v Carl Friedrich>Und das Plus kann ich eben auch dann durch eine Maschineninstruktion abbilden, die halt Doubles addiert.

01:15:30.160 --> 01:15:36.800
<v Carl Friedrich>Und dieser Maschinencode, der funktioniert halt dann genau nur für den Spezialfall, dass A und B halt wirklich auch float sind.

01:15:37.040 --> 01:15:53.360
<v Carl Friedrich>Und wenn dann irgendwann später im Verlauf des Programms halt diese Funktion jemand mit zwei Ints aufruft, dann ist das kein Problem, weil der Code wurde ja sowieso zur Laufzeit erzeugt und dann kann ich halt quasi auch neuen Code für diese sich ändernde Situation erzeugen.

01:15:53.600 --> 01:16:17.680
<v Carl Friedrich>Und diese Flexibilität, die mir die Tatsache, dass ich den Maschinencode eben erst zur Laufzeit erzeugt, dadurch kriege ich halt sehr viel Flexibilität und kann halt die extra Informationen, die ich zur Laufzeit habe, auch benutzen, um quasi die ganze Dynamizität, die man in Python halt theoretisch verwenden kann, aber in der Praxis nicht unbedingt verwendet.

01:16:17.680 --> 01:16:20.800
<v Carl Friedrich>Die kann ich dann halt auch quasi wieder wegoptimieren.

01:16:20.800 --> 01:16:29.600
<v Carl Friedrich>Aber das kann ich eben nur, weil ich eben das zur Laufzeit mache und mir die Typen anschauen kann und halt auch reagieren kann, wenn sich dann die Umstände ändern.

01:16:29.600 --> 01:16:34.480
<v Carl Friedrich>Das ist halt auch so ein bisschen die andere Eigenschaft des Time-Compilers.

01:16:34.480 --> 01:16:41.520
<v Carl Friedrich>Der kann halt dann auch darauf reagieren, dass du nach einer halben Stunde Programmlaufzeit plötzlich den Debugger anmachen willst.

01:16:43.760 --> 01:16:51.920
<v Carl Friedrich>Dann muss man nämlich anfangen, quasi wieder alles zurückzupacken und das nennt man wirklich Deoptimierung.

01:16:51.920 --> 01:16:58.160
<v Carl Friedrich>Da muss man wirklich quasi wieder die Frame-Objekte erzeugen, die man halt braucht, um dann, dass der Debugger funktioniert.

01:16:58.160 --> 01:17:02.080
<v Carl Friedrich>Also der Debugger, der introspiziert ja diese Frame-Objekte, die es in Python gibt.

01:17:02.080 --> 01:17:08.240
<v Carl Friedrich>Und die würde der JIT-Compiler natürlich gar nicht benutzen, weil die braucht er nicht.

01:17:08.400 --> 01:17:12.960
<v Carl Friedrich>Aber wenn man die Debugger anschaltet, dann muss man die halt jederzeit wieder herzaubern können.

01:17:13.600 --> 01:17:16.640
<v Carl Friedrich>Okay, also das ist die Idee des Jits.

01:17:16.640 --> 01:17:23.360
<v Carl Friedrich>Das ist quasi in gewisser Weise heutzutage relativ akzeptiert, weil jeder Browser das halt macht.

01:17:23.360 --> 01:17:27.680
<v Carl Friedrich>Also Java macht das und insbesondere machen das halt die Browser für JavaScript.

01:17:27.680 --> 01:17:51.520
<v Carl Friedrich>Und die Browser Wars haben halt dazu geführt, dass quasi alle großen Browser sehr, sehr, sehr, sehr, sehr viel Geld da reingesteckt haben, halt Justin-Time-Compiler für JavaScript zu schreiben, die halt wirklich extrem aggressiv zur Laufzeit den JavaScript-Code optimieren und zur Laufzeit nach Maschinencode übersetzen können.

01:17:51.520 --> 01:18:00.560
<v Carl Friedrich>Und deswegen ist JavaScript halt inzwischen, jetzt sag ich mal, nicht ganz so schnell wie C, aber halt irgendwie vielleicht nur zwei oder dreimal langsamer als C.

01:18:00.800 --> 01:18:08.000
<v Carl Friedrich>Und einfach, weil da halt einfach viele Millionen Dollar in jede von dieser Implementierung reingesteckt wurde.

01:18:09.680 --> 01:18:13.440
<v Carl Friedrich>So, deswegen inzwischen weiß halt jeder so ein bisschen, was ein JIT ist.

01:18:14.000 --> 01:18:18.560
<v Carl Friedrich>Das war aber halt, als das Projekt anfing, nicht ganz so sehr so.

01:18:18.560 --> 01:18:22.160
<v Carl Friedrich>Es gab halt damals, ich weiß nicht, sagt euch, Psycho was.

01:18:22.160 --> 01:18:23.760
<v Jochen>Ja, klar.

01:18:24.960 --> 01:18:29.440
<v Carl Friedrich>Und das ist so ein bisschen, jetzt sind wir stark in der Ancient Python History drin.

01:18:29.440 --> 01:18:34.240
<v Carl Friedrich>Also das war so ein Extension-Module für Python 2.2.

01:18:36.160 --> 01:18:38.800
<v Carl Friedrich>Jetzt kommt raus, dass ich alt bin.

01:18:40.880 --> 01:18:47.600
<v Carl Friedrich>Und das war quasi ein sehr, sehr schlauer, promovierter Mathematiker, der hat dieses Extension-Module geschrieben.

01:18:47.600 --> 01:18:51.680
<v Carl Friedrich>Und das war quasi ein DID für C Python.

01:18:52.000 --> 01:19:00.240
<v Carl Friedrich>Wenn man das Extension-Module geladen hat, dann hat halt Psycho angefangen, zur Laufzeit aus den Python-Funktionen halt irgendwie Maschinencode zu erzeugen.

01:19:00.240 --> 01:19:03.200
<v Carl Friedrich>Und das hat gut funktioniert, an vielen Stellen.

01:19:03.200 --> 01:19:10.880
<v Carl Friedrich>Und das große Problem von Psycho war jetzt aber, dass jede neue Python-Version, die rauskam, hat das komplett kaputt gemacht.

01:19:11.280 --> 01:19:28.320
<v Carl Friedrich>Also weil wenn es halt, sobald es ein neues Sprachfeature dazu kam, musste der Armin, Armin Rigo heißt das, musste dieses Extension-Modul halt wieder im Wesentlichen jetzt nicht von Null schreiben, aber halt quasi jede Zeile nochmal neu überdenken.

01:19:28.320 --> 01:19:35.520
<v Carl Friedrich>Weil es halt quasi immer so Interaktionen zwischen den neuen Sprachfeatern und den alten Sprachfeatern gibt und die waren halt nicht zu übersehen.

01:19:35.520 --> 01:19:38.400
<v Carl Friedrich>Also da, ich weiß nicht, was war mit 2.3 dazu?

01:19:38.400 --> 01:19:40.480
<v Carl Friedrich>Vielleicht Generatoren oder so?

01:19:41.040 --> 01:19:43.760
Gab es da nicht auch irgendwelche Stoping-Änderungen?

01:19:44.240 --> 01:19:46.320
<v Jochen>Ja, kann sein, ich weiß es nicht mehr genau, ja, aber.

01:19:46.800 --> 01:19:49.520
Long time and sowas.

01:19:49.840 --> 01:19:55.120
<v Carl Friedrich>Auf jeden Fall, die haben halt dann immer nicht funktioniert in Psycho und Armin hat halt irgendwann auch aufgegeben.

01:19:55.120 --> 01:19:59.360
<v Carl Friedrich>Also Psycho ist, glaube ich, seit 2.4 oder 2.5 einfach auch tot.

01:20:00.880 --> 01:20:27.600
<v Carl Friedrich>Und er hat halt aus dieser Frustration raus dann angefangen, sich in PyPy, also war einer der Projektgründer von PiPy, und hat halt aus dieser Frustration raus, dass man den JIT aus Psycho für jede Version von Hand dann anpassen muss, sich so eine, sag ich mal, relativ gewagte akademische Idee ausgesucht, die er gerne auf PyPy anwenden wollte.

01:20:27.600 --> 01:20:35.680
<v Carl Friedrich>Und das ist eben die Idee, dass man den JIT überhaupt, also JIT heißt, das ist die Abkürzung Justin-Time-Compiler, dass man den überhaupt nicht von Hand schreibt.

01:20:35.920 --> 01:20:40.720
<v Carl Friedrich>Und statt der eben weil Python eine Sprache ist, die sich ständig ändert.

01:20:40.720 --> 01:20:46.640
<v Carl Friedrich>Also einmal im Jahr oder vielleicht damals war es alle anderthalb Jahre, kommt eine neue Python-Version raus, da gibt es neue Sprachfeature.

01:20:46.640 --> 01:20:50.720
<v Carl Friedrich>Und das Anpassen des JIT-Compilers an die neuen Sprachfeatures, das ist zu nervig.

01:20:50.720 --> 01:20:53.920
<v Carl Friedrich>Insbesondere wenn man halt nicht irgendwie Google-Geld hat.

01:20:53.920 --> 01:20:57.200
<v Carl Friedrich>Wenn man Google Geld hat, dann kann man halt einfach 20 Ingenieure auf das Problem.

01:20:58.400 --> 01:21:06.320
<v Carl Friedrich>Und die haben dann halt keinen Spaß, die schreiben ganz, ganz viel komplizierten C&lt;unk&gt;-Code und sind halt jede Woche sehr traurig.

01:21:06.880 --> 01:21:14.160
<v Carl Friedrich>Aber wenn man dieses Budget halt nicht hat, dann ist es einfach zu anstrengend, mit C Python mitzuhalten, also mit der Sprachenklickung mitzuhalten.

01:21:14.160 --> 01:21:22.240
<v Carl Friedrich>Und deswegen hatte er eben die Idee, dass es doch irgendwie möglich sein sollte, den JIT-Compiler automatisch zu generieren.

01:21:22.560 --> 01:21:29.520
<v Carl Friedrich>Und das ist so ein bisschen so eine alte, sehr akademische Idee.

01:21:29.520 --> 01:21:40.880
<v Carl Friedrich>Also da gibt es halt irgendwie in den, ich glaube in den Ende der 70er gab es so einen Aufsatz von Futamura, irgendwie, weiß nicht genau, wie der Titel ist, ein Compiler-Compiler.

01:21:40.880 --> 01:21:50.560
<v Carl Friedrich>Da gab es eben schon mal die Idee, dass es theoretisch eben sein sollte, möglich sein sollte, einen Compiler für eine Sprache automatisch zu erzeugen aus einem Interpreter für die Sprache.

01:21:50.800 --> 01:21:53.680
<v Carl Friedrich>Und das war aber halt ein sehr akademischer Anwendung.

01:21:54.080 --> 01:21:57.520
<v Jochen>Ich meine, ein Compiler-Compiler und so, das ist ja Jack und so.

01:21:58.080 --> 01:22:00.080
<v Carl Friedrich>Ja, aber da ist der Input halt kein Interpreter, sondern nein.

01:22:00.240 --> 01:22:01.440
<v Jochen>Nee, nee, das ist Grammatik, ja.

01:22:03.840 --> 01:22:12.800
<v Carl Friedrich>Aber die Idee von der Mura-Projektion ist eben wirklich, man hat einen Interpreter für eine Sprache und erzeugt mit einem komplizierten Prozess aus dem Interpreter automatisch einen Compiler.

01:22:12.800 --> 01:22:20.080
<v Carl Friedrich>Und das gab es quasi als akademische Idee, da gab es auch ein ganzes Forschungsfeld und ganz unglaublich viele Aufsätze zu.

01:22:20.880 --> 01:22:23.600
<v Carl Friedrich>Aber das hat sich halt in der Praxis nicht so richtig umgesetzt.

01:22:23.600 --> 01:22:28.880
<v Carl Friedrich>Und Armin hat halt die Idee gehabt, wir machen das jetzt, wir machen das jetzt einmal richtig.

01:22:29.280 --> 01:22:31.040
<v Carl Friedrich>Also wir machen das jetzt halt.

01:22:32.000 --> 01:22:34.560
<v Carl Friedrich>Also der hat sich in gewisser Weise auch sehr viel getraut.

01:22:34.560 --> 01:22:37.840
<v Carl Friedrich>Er hat gesagt, ich habe jetzt diese Vision, das müsste doch irgendwie gehen.

01:22:37.840 --> 01:22:41.680
<v Carl Friedrich>Und wir wollen das jetzt für eine echte Sprache halt auch wirklich dann mal anwenden.

01:22:41.680 --> 01:22:48.160
<v Carl Friedrich>Und in gewisser Weise ist das Problem natürlich auch noch erstmal schwieriger, weil er nicht nur einen Compiler wollte, er wollte halt einen JIT-Compiler.

01:22:49.200 --> 01:23:06.560
<v Carl Friedrich>Und er hatte da so ein paar Ideen, wie man diese alte Idee der Futamora-Projektion, wie man die halt wirklich dann mal so ganz konkret, nicht für irgendeine akademische Minisprache, sondern für so eine richtige Programmiersprache, wie Python halt dann auch anwenden kann.

01:23:06.560 --> 01:23:14.160
<v Carl Friedrich>Und das haben wir dann halt in den verschiedenen PyPy-Research-Projekten auch dann gemacht.

01:23:14.160 --> 01:23:15.760
<v Carl Friedrich>Das ging auch ganz schön lange nicht.

01:23:15.760 --> 01:23:20.880
<v Carl Friedrich>Also es hat halt wirklich dann auch ein paar Jahre gedauert, bis es dann wirklich auch funktioniert hat.

01:23:21.120 --> 01:23:23.520
<v Dominik>Also PyPy ist ein Compiler-Compiler.

01:23:23.520 --> 01:23:32.080
<v Carl Friedrich>Also PyPy hat PyPy hat so ein paar Komponenten, aber eine der Komponenten ist wirklich quasi ein JIT-Compiler-Generator.

01:23:32.320 --> 01:23:47.760
<v Carl Friedrich>Und du steckst quasi einen Interpreter in diesen JIT-Compiler-Generator raus und der Output davon ist ein JIT-Compiler für die Sprache, die von deinem Interpreter spezifiziert wird.

01:23:47.760 --> 01:23:55.760
<v Carl Friedrich>Und das hat Riesenvorteile, weil nämlich, wenn, also nehmen wir mal so was Konkretes wie Pattern Matching.

01:23:55.760 --> 01:23:59.120
<v Carl Friedrich>Pattern Matching kommt jetzt raus in 3C.

01:23:59.120 --> 01:24:02.800
<v Carl Friedrich>Dann implementieren wir das in unserem Interpreter.

01:24:02.800 --> 01:24:05.760
<v Carl Friedrich>Also Piper ist ein Interpreter für Python.

01:24:05.760 --> 01:24:10.400
<v Carl Friedrich>Und wir müssen das Feature halt implementieren, weil unser Interpreter, der kann das erstmal nicht.

01:24:10.480 --> 01:24:12.080
<v Dominik>Also ihr implementiert das aber in C?

01:24:12.400 --> 01:24:13.920
Nein, nein, in R Python.

01:24:14.000 --> 01:24:14.880
In R Python, genau.

01:24:14.880 --> 01:24:16.080
<v Carl Friedrich>Das ist alles in R Python.

01:24:16.080 --> 01:24:21.120
<v Carl Friedrich>Aber wir interpretieren das quasi in dem in AirPython geschriebenen Interpreter.

01:24:21.120 --> 01:24:35.520
<v Carl Friedrich>Und dann drücken wir auf den Knopf und dann kommt der JIT-Compiler-Generator und der nimmt den Interpreter mit dem neuen Feature und dann haben wir plötzlich einen JIT-Compiler, der quasi Patternmatching versteht und richtig guten Maschinencode für Patternmatching erzeugt.

01:24:36.320 --> 01:24:42.160
<v Carl Friedrich>Und der JIT-Compiler-Generator, der kennt Pattern Matching halt gar nicht.

01:24:42.160 --> 01:24:52.720
<v Carl Friedrich>Sondern der lernt die Semantik von Pattern Matching halt wirklich, indem man sich anschaut, was der Interpreter macht, um die Patterns auszuführen.

01:24:53.040 --> 01:24:59.680
<v Carl Friedrich>Aber das heißt eben, wir müssen nicht, wenn so eine neue Version rauskommt, müssen wir nicht jedes Mal den JIT-Compiler anfassen.

01:24:59.680 --> 01:25:02.560
<v Carl Friedrich>Weil der JIT-Compiler, der kann halt überhaupt keinen Python.

01:25:02.560 --> 01:25:09.440
<v Carl Friedrich>Sondern der kriegt halt die Semantik von Python ab, also indem man sich diesen Interpreter für Python anschaut.

01:25:09.440 --> 01:25:19.440
<v Carl Friedrich>Und wenn man den Interpreter für Python neue Features einbaut, dann hat man immer automatisch auch noch, kann man eben für diese neuen Features dann auch den JIT generieren.

01:25:20.080 --> 01:25:30.480
<v Jochen>Aber ein weiterer Vorteil, den man damit eventuell hätte, ist, man kann dann damit ja einen JIT-Compiler für jede Sprache erzeugen, für die man in App einen Interpreter schreiben kann.

01:25:30.560 --> 01:25:30.720
Genau.

01:25:30.800 --> 01:25:32.240
<v Jochen>Das geht ja dann wahrscheinlich für viele Sprachen.

01:25:32.400 --> 01:25:36.080
<v Carl Friedrich>Ja, zum Beispiel, wir hatten da schon ein Beispiel vorhin für reguläre Ausdrücke.

01:25:36.080 --> 01:25:36.640
<v Jochen>Ach, ja.

01:25:36.800 --> 01:25:40.560
<v Carl Friedrich>Also wir hatten ja vorhin gesagt, dass wir halt relativ gut darin sind, reguläre Ausdrücke auszuführen.

01:25:40.560 --> 01:25:44.080
<v Carl Friedrich>Und das liegt halt einfach daran, dass in Python ist das auch schon so.

01:25:44.080 --> 01:25:50.560
<v Carl Friedrich>Reguläre Ausdrücke, die werden in so einen kleinen Bytecode erzeugt, der übersetzt.

01:25:50.560 --> 01:25:52.880
<v Carl Friedrich>Das ist ein anderer Bytecode als der Python-Bytecode.

01:25:52.880 --> 01:25:56.240
<v Carl Friedrich>Und dafür gibt es dann einen Interpreter, der Teil von C Python ist.

01:25:56.240 --> 01:26:03.440
<v Carl Friedrich>Also C Python hat halt den Interpreter für Python, aber eben auch noch einen anderen Interpreter für die regulären Ausdrücke Bytecodes.

01:26:03.440 --> 01:26:05.600
Und den haben wir halt auch in AirPython geschrieben.

01:26:05.600 --> 01:26:10.720
<v Carl Friedrich>Und das heißt, wir können halt auch zur Laufzeit dann die regulären Ausdrücke nach Maschinencode übersetzen.

01:26:11.040 --> 01:26:17.600
<v Carl Friedrich>Weil wir halt quasi für diesen anderen Interpreter, der auch in AirPython geschrieben ist, auch ein JIT erzeugen.

01:26:18.400 --> 01:26:29.440
<v Carl Friedrich>Und tatsächlich gibt es halt so einen ganzen Haufen an Research-Quality, Sprachimplementierungen, die halt diese ganze Maschinerie auch benutzen, um alle möglichen Experimente zu machen.

01:26:29.440 --> 01:26:38.000
<v Carl Friedrich>Also wir haben halt auch mal eine Ruby-Implementierung geschrieben und eine PHP-Implementierung geschrieben und eine Prolog geschrieben, das war meine Bachelorarbeit.

01:26:38.720 --> 01:26:40.560
<v Carl Friedrich>Und die sind jetzt alle nicht so cool, ja.

01:26:40.560 --> 01:26:52.000
<v Carl Friedrich>Also da wurde halt einfach nicht der Aufwand reingesteckt, den man betreiben müsste, um da jetzt wirklich, sag ich mal, eine Production-Ruby-Implementierung dann rauszukriegen.

01:26:52.320 --> 01:26:59.840
<v Carl Friedrich>Aber also das waren halt eher so dann der Versuch zu gucken, ob das mit Ruby auch geht oder mit Prolog auch geht.

01:27:00.720 --> 01:27:08.800
<v Carl Friedrich>Ich habe zum Beispiel auch mal, also auch nur Research Quality, ich habe zum Beispiel auch mal eine Datenbank darin implementiert.

01:27:08.800 --> 01:27:20.880
<v Carl Friedrich>Also ich habe halt eine SQLite kompatible, also SQLite kompiliert halt die den SQL-Code auch in so einen Bytecode.

01:27:20.880 --> 01:27:23.760
<v Carl Friedrich>Dafür habe ich halt auch einen Interpreter an Appwitzen geschrieben.

01:27:23.760 --> 01:27:29.360
<v Carl Friedrich>Und damit kann man halt dann auch ganz interessante Performance Gewinne sich dann irgendwie abholen.

01:27:30.160 --> 01:27:33.360
<v Jochen>Ja, die Datenbank muss das ja auch interpretieren, was da anfährlich so kommt.

01:27:33.520 --> 01:27:33.840
Genau.

01:27:33.840 --> 01:27:43.200
<v Carl Friedrich>Und das ist ja auch, ich meine, das weiß man ja auch immer so ein bisschen, dass das SQLite mit den Typen der Spalten auch nicht so ernst nimmt.

01:27:43.200 --> 01:27:46.080
<v Jochen>Ja, ja, da kann man, ja, oder Swing beides.

01:27:46.240 --> 01:27:46.560
<v Jochen>Das heißt,

01:27:46.560 --> 01:27:48.160
es ist auch noch eine dynamische Sprache.

01:27:48.480 --> 01:27:50.000
<v Carl Friedrich>Dynamischierte Programmiersprache.

01:27:50.000 --> 01:27:55.440
<v Carl Friedrich>Also da gibt es halt dann schon ganz schön viele Ähnlichkeiten zur Ausführung von Python in gewisser Weise.

01:27:56.080 --> 01:28:11.920
<v Carl Friedrich>Naja, auf jeden Fall so diese Idee, dass wir halt quasi einen JIT-Generator haben und diese Architektur sorgt dafür, dass wir halt mit einem relativ kleinen Team halt mit C-Python trotzdem ganz gut mithalten können.

01:28:11.920 --> 01:28:24.640
<v Carl Friedrich>Weil wir die Features halt eben nicht in den JIT-Compiler einschreiben, reinprogrammieren müssen, sondern halt quasi nur in einen Interpreter und der JIT-Compiler, der kriegt die Features dann automatisch.

01:28:24.640 --> 01:28:31.200
<v Carl Friedrich>Das war jetzt so ein paar Verallgemeinerungen waren jetzt, also so ein paar Ungenauigkeiten waren in meiner Story jetzt noch drin.

01:28:31.520 --> 01:28:35.840
<v Carl Friedrich>Es gibt dann noch so extra Annotationen, die nennen wir ja irgendwie Hints.

01:28:35.840 --> 01:28:39.120
<v Carl Friedrich>Man kann halt quasi dem JIT-Compiler da noch so ein paar Tipps geben.

01:28:39.120 --> 01:28:43.440
<v Jochen>Ja, weil wahrscheinlich manchmal wird das halt dann überraschend nicht gut funktionieren.

01:28:43.760 --> 01:28:48.800
<v Carl Friedrich>Und man kriegt halt dann Maschinencode und der ist vielleicht noch nicht so gut, wie man den gern hätte.

01:28:48.800 --> 01:28:56.960
<v Carl Friedrich>Und dann fügt man halt noch so ein paar Annotationen ein und kann dann dem JIT-Compiler-Generator helfen, doch noch einen besseren JIT zu generieren.

01:28:56.960 --> 01:29:00.320
Und das muss man dann für verschiedenen Stellen auch immer mal machen.

01:29:00.320 --> 01:29:06.160
<v Carl Friedrich>Also zum Beispiel, ich würde jetzt meine Hand nicht ins Feuer legen, dass Pattern Matching halt jetzt schon ultra schnell ist.

01:29:06.160 --> 01:29:11.680
<v Carl Friedrich>Also wir haben halt ein JIT für Pattern Matching, aber ich weiß noch nicht, ich habe es noch nicht gemessen, ob es wirklich ein ganz toller JIT ist.

01:29:11.920 --> 01:29:13.920
<v Dominik>Das ist eh ziemlich langsam, ne?

01:29:14.640 --> 01:29:16.640
<v Carl Friedrich>In T-Baden ist das nicht so toll, oder?

01:29:16.640 --> 01:29:17.280
<v Carl Friedrich>Ich weiß nicht, was.

01:29:17.440 --> 01:29:18.880
<v Dominik>Ich glaube, also habe ich gehört, dass es nicht so

01:29:18.880 --> 01:29:19.200
schnell ist.

01:29:19.440 --> 01:29:20.400
<v Jochen>Ich weiß nicht.

01:29:20.720 --> 01:29:26.800
<v Carl Friedrich>Also ob das jetzt bei uns, also wir würden halt dann wirklich aus dem Patternmatching Maschinencode erzeugen.

01:29:26.800 --> 01:29:33.760
<v Carl Friedrich>Und ich weiß halt noch nicht so richtig, ob das richtig guter Maschinencode ist oder ob das halt einfach nur irgendwie so ein bisschen leicht schrottiger Maschinencode ist.

01:29:33.760 --> 01:29:40.240
<v Carl Friedrich>Und wenn man das verbessern will, dann würde man halt halt hergehen und sagen, na gut, was für extra Hilfen können wir dem JIT noch geben.

01:29:40.320 --> 01:29:46.800
<v Carl Friedrich>Das habe ich jetzt halt noch nicht gemacht, weil ich meine, das ist halt immer so ein bisschen, das kommt halt als letztes.

01:29:47.360 --> 01:29:49.120
<v Dominik>Du musst halt quasi aber immer den Generator anlernen.

01:29:49.120 --> 01:29:55.120
<v Dominik>Du kannst halt quasi nie richtig in der Hand, was wirklich da liegt an C-Code, der hinterher ausgeführt wird.

01:29:55.120 --> 01:29:57.920
Also indirekt

01:29:57.920 --> 01:29:59.680
<v Carl Friedrich>Moment, warum C-Code?

01:29:59.920 --> 01:30:05.200
<v Dominik>Ja, weil du doch dem Generator sagst, was er tun soll, der den C-Code generiert, der dann hinterher ausgeführt wird.

01:30:05.280 --> 01:30:07.360
<v Carl Friedrich>Ja, der C-Code ist dir eigentlich so ein bisschen egal.

01:30:07.360 --> 01:30:20.160
<v Carl Friedrich>Also wichtig ist halt, du generierst einmal C-Code, aber du generierst halt auch noch einen JIT und der JIT, der übersetzt es halt den Python-Code nicht nach C-Code, sondern wirklich direkt nach Maschinencode.

01:30:20.160 --> 01:30:27.840
<v Carl Friedrich>Also wir erzeugen dann wirklich, wir nehmen den Python-Code, führen den aus und nach einer Weile sagen wir halt, oh, okay, diese Schleife hier, die scheint irgendwie wichtig zu sein.

01:30:27.840 --> 01:30:34.720
<v Carl Friedrich>Und dann nehmen wir wirklich diese Schleife und erzeugen daraus halt wirklich direkt ins RAM Maschinencode-Instruktionen.

01:30:34.720 --> 01:30:36.880
<v Carl Friedrich>Und das geht halt nicht mehr den Umweg über C.

01:30:36.880 --> 01:30:40.560
<v Carl Friedrich>Den Umweg über C brauchen wir nur, um einmal das Binary zu erzeugen.

01:30:40.560 --> 01:31:00.640
<v Carl Friedrich>Das machen halt wir einmal auf unserem Server und das passiert aber dann quasi nach dem Deployment auf die Produktivunktewegung nicht mehr, sondern da wird halt wirklich direkt direkt ins RAM werden halt die Maschineninstruktionen für die aktuelle CPU-Architektur emittet und dann führen wir das halt direkt aus.

01:31:01.120 --> 01:31:21.920
<v Carl Friedrich>Also sprich, wenn du das halt auf irgendwie so auf so einem X86-Server laufen lässt, dann schnappen wir uns halt einfach vom Betriebssystem so einen großen Buffer an RAM und da kommen halt dann irgendwelche Instruktionen rein und dann wird der Buffer als ausführbar markiert und dann springen wir da einfach hin.

01:31:21.920 --> 01:31:28.800
<v Carl Friedrich>Und dann von da an läuft halt wirklich der Maschinencode und der, also wenn man Glück hat, ist er halt einfach dann auch sehr, sehr schnell.

01:31:29.360 --> 01:31:35.840
<v Carl Friedrich>Weil der das ganze teure Zeug, was in Python halt normalerweise die ganze Zeit passieren muss, halt nicht mehr macht.

01:31:35.840 --> 01:31:37.840
<v Dominik>In den ganzen Overhead von den ganzen Sachen, finde ich.

01:31:38.080 --> 01:31:46.160
<v Carl Friedrich>Also und der Overhead, also man hat halt dann die Frame-Objekte nicht mehr, man hat die ganzen Typüberprüfungen nicht mehr, idealerweise.

01:31:46.160 --> 01:31:49.200
<v Carl Friedrich>Man hat, also Python alloziert ja auch die ganze Zeit Speicher.

01:31:49.200 --> 01:31:55.120
<v Carl Friedrich>Also jeder Integer ist ja so ein bisschen Heap-Memory.

01:31:55.280 --> 01:31:58.560
<v Carl Friedrich>Also jede Addition macht halt einen Merlog-Aufruf.

01:31:58.560 --> 01:32:00.640
<v Carl Friedrich>Und das ist ja eigentlich absurd teuer.

01:32:00.640 --> 01:32:06.720
<v Carl Friedrich>Also ein Mallog-Aufruf und es wird eben der Reference-Count auch noch immer manipuliert.

01:32:08.240 --> 01:32:10.240
<v Dominik>Vielleicht auch nochmal ganz kurz für die Leute, die ja nicht ganz so tief tun.

01:32:10.320 --> 01:32:14.960
<v Dominik>Ein Mallog-Aufruf, also eine Memory-Agglocation ist in C eine Funktion, die auf dem Heap, was macht?

01:32:14.960 --> 01:32:15.840
Vielleicht nochmal ganz kurz.

01:32:16.560 --> 01:32:18.640
<v Dominik>Ganz tief rein, erklär mir, was Heap steckt.

01:32:19.680 --> 01:32:24.640
<v Carl Friedrich>Vielleicht kann man das einfach nochmal so ein bisschen den Kontrast herstellen mit, wir schreiben jetzt wirklich ein Programm in C.

01:32:24.640 --> 01:32:38.880
<v Carl Friedrich>Und wenn du da halt irgendwie eine Integer-Variable, also Long A und Long B hast und dann machst du A plus B, dann sind A und B halt nicht auf dem Heap, sondern irgendwie direkt in CPU-Registern.

01:32:38.960 --> 01:32:45.600
<v Carl Friedrich>Und die werden dann direkt von CPU-Instruktionen addiert und mit dem Ergebnis wird halt irgendwas gemacht.

01:32:47.120 --> 01:32:59.680
<v Carl Friedrich>Wenn du irgendwie so einen Ausdruck wie A und B in Python hinschreibst und das in C-Python ausführst, dann ist das halt nicht, also die Integer-Werte, die sind dann nicht in CPU-Registern, sondern die sind quasi im RAM.

01:32:59.680 --> 01:33:09.200
<v Carl Friedrich>Und um dann wirklich das Ergebnis berechnen zu können, musst du die Werte erstmal aus dem RAM, also erstmal musst du gucken, sind das überhaupt Integers, die ich da addiere?

01:33:09.200 --> 01:33:18.640
<v Carl Friedrich>Und dann musst du gucken, dann musst du quasi die Werte der Integer aus dem Integer-Objekt vom RAM in CPU-Register laden.

01:33:18.640 --> 01:33:20.960
<v Carl Friedrich>Dann machst du wirklich die Addition.

01:33:20.960 --> 01:33:26.720
<v Carl Friedrich>Dann musst du gucken, ob das Ergebnis immer noch klein genug ist, um in einen Maschinenwort reinzupassen.

01:33:26.720 --> 01:33:31.520
<v Carl Friedrich>Das könnte ja auch irgendwie einen Overflow geben und dann brauchst du irgendwie ein komplizierteres Objekt.

01:33:31.520 --> 01:33:36.880
<v Carl Friedrich>Und dann brauchst du Speicher für das Ergebnis-Objekt, weil das Ergebnis ist ja auch wieder ein Integer-Ojekt.

01:33:36.880 --> 01:33:38.720
<v Carl Friedrich>Das heißt, du rufst einmal einen Mellog auf.

01:33:38.720 --> 01:33:45.520
<v Carl Friedrich>Dann kriegst du ein neues Stück RAM zugewiesen von dem in C geschriebenen Allokator.

01:33:45.520 --> 01:33:56.880
<v Carl Friedrich>Und dann packst du den Ergebnis-Zahlenwert in dieses neue Stück RAM rein, erhöhst den Reference-Count von diesem Stück RAM und das ist dann dein Ergebnisobjekt.

01:33:56.880 --> 01:33:59.680
<v Carl Friedrich>Und das passiert aber halt bei jeder arithmetischen Operation.

01:33:59.680 --> 01:34:04.240
<v Carl Friedrich>Und deswegen ist halt Arithmetik, und wir haben auch noch so ein paar Schritte weggelassen.

01:34:04.800 --> 01:34:10.480
<v Carl Friedrich>Deswegen ist Arithmetik halt in Python klassischerweise wirklich sehr, sehr ineffizient.

01:34:10.480 --> 01:34:15.120
<v Carl Friedrich>Weil du halt wirklich ständig Mellog aufrufst und auch ständig wieder Free aufrufst.

01:34:15.120 --> 01:34:31.360
<v Carl Friedrich>Zum Beispiel, wenn du jetzt so einen komplizierteren Ausdruck hast, wenn du halt sowas wie A mal 2 plus B, das war ja unser standardarithmetischer Ausdruck schon in der Zeit, dann hast du halt das Zwischenergebnis A mal 2, das brauchst du ja gar nicht lang.

01:34:31.600 --> 01:34:33.360
<v Carl Friedrich>Das brauchst du ja quasi nur.

01:34:33.680 --> 01:34:35.040
<v Dominik>Das verfällt ja beim nächsten Mal.

01:34:35.600 --> 01:34:46.240
<v Carl Friedrich>Das heißt, beim nächsten Aufruf, wenn du dann das Plus rechnest, dann verringerst du den Reference-Count von dem Zwischenergebnis und dann sagst du, oh, das ist ja jetzt null.

01:34:46.240 --> 01:34:47.440
<v Carl Friedrich>Das brauche ich ja gar nicht mehr.

01:34:47.440 --> 01:34:49.200
<v Carl Friedrich>Und dann rufst du Free auf.

01:34:49.200 --> 01:34:55.040
<v Carl Friedrich>Das ist wieder quasi so ein teurer Aufruf zu dem Memory-Substant-Programm.

01:34:55.600 --> 01:35:00.000
<v Dominik>Schreibt der Null den Speicher oder löscht er einfach die Speicheradresse, aus dem wir benutzen das?

01:35:00.000 --> 01:35:04.000
<v Carl Friedrich>Genau, und dann kannst du quasi den Speicher wiederverwenden, das nächste Mal, wenn jemand Melod aufkommt.

01:35:04.080 --> 01:35:06.400
<v Dominik>Aber der schreibt dann nicht vorher irgendwie was rein.

01:35:06.640 --> 01:35:11.520
<v Carl Friedrich>Doch, der muss das dann schon halt, der muss sich schon irgendwie merken, dass der Speicher jetzt verwendet werden kann.

01:35:11.520 --> 01:35:22.480
<v Carl Friedrich>Also es gibt halt so ein bisschen, es gibt quasi so ein bisschen Overhead-Datenstrukturen, die verwendet werden, um sich zu merken, dass das jetzt ein Stück freier Speicher ist.

01:35:22.480 --> 01:35:25.200
<v Dominik>Der schreibt ja am Anfang von einem Speicherblock schreibt er irgendwie so ein.

01:35:26.160 --> 01:35:28.240
<v Carl Friedrich>Das ist, glaube ich, gar nicht so wichtig.

01:35:28.240 --> 01:35:35.760
<v Carl Friedrich>Das funktioniert auch sehr unterschiedlich, je nach Betriebsthemen und je nach verwendetem Allokator.

01:35:35.760 --> 01:35:39.120
<v Carl Friedrich>Also da gibt es halt auch verschiedene C-Bibliotheken, die man ja verwenden kann.

01:35:40.480 --> 01:35:50.240
<v Carl Friedrich>C-Python hat da auch so ein bisschen so seine eigenen Algorithmen, die für den typischen Use Case, der halt in Python besonders oft auftritt, dann optimiert ist.

01:35:50.400 --> 01:35:57.760
<v Carl Friedrich>Also da ist quasi dann ganz, ganz viel Engineering und es ist kompliziert und wir müssen das hoffentlich nicht verstehen.

01:35:57.760 --> 01:36:03.360
<v Carl Friedrich>Also das, ja, das ist quasi, da kenne ich mich dann irgendwann auch ziemlich schnell halt auch nicht aus.

01:36:04.720 --> 01:36:15.040
<v Jochen>Ja, aber letztlich, das Problem ist halt, dass es halt, ja, Speicheraluzin ist halt eine relativ komplexe, weil man halt auch das Betriebssystem den Kernel fragen muss, letztlich.

01:36:15.040 --> 01:36:15.440
<v Jochen>Also natürlich.

01:36:15.600 --> 01:36:15.920
Am Schluss

01:36:15.920 --> 01:36:16.800
dann, nicht jedes Mal, aber nicht.

01:36:16.960 --> 01:36:17.440
<v Carl Friedrich>Nichtes Mal,

01:36:17.440 --> 01:36:19.040
aber irgendwann schon, ganz nicht.

01:36:19.040 --> 01:36:20.800
<v Jochen>Und dann, dass natürlich alles sauteuer ist.

01:36:21.440 --> 01:36:32.960
<v Carl Friedrich>Und dieser ganze Oberhead fällt halt weg, wenn du A plus B mal C mit ausführst und Dagit ging darüber, dann hast du halt wirklich auch, dann adnotizierst du dieses Zwischenergebnis auch nicht.

01:36:33.200 --> 01:36:48.320
<v Carl Friedrich>Sondern dann sagst du halt einfach, na gut, A kommt in ein Maschinenregister, das mal 2 ist halt irgendwie so ein Intermediate in deiner Maschinen-Instruction und dann hast du noch eine zweite Maschinen-Instruction, um die Addition zu machen.

01:36:48.320 --> 01:36:53.520
<v Carl Friedrich>Und das Ergebnis ist auch in einem Register, je nachdem, was mit dem Ergebnis passiert, kann es da auch bleiben.

01:36:53.520 --> 01:37:05.280
<v Carl Friedrich>Ja, also wenn du dann einen Return hast, dann kann das quasi im Return-Register der CPU halt auch dann einfach weiterverwendet werden vom Aufrufer.

01:37:05.280 --> 01:37:09.680
<v Carl Friedrich>So ein bisschen, wenn alles genau richtig ist, wenn alles genau richtig läuft.

01:37:09.680 --> 01:37:17.680
<v Carl Friedrich>Und dann fällt halt einfach ganz, ganz, ganz viel Overhead, den die normale Python-Implementierung halt immer machen muss, fällt halt weg.

01:37:19.920 --> 01:37:20.320
<v Carl Friedrich>Ja.

01:37:20.560 --> 01:37:31.280
<v Carl Friedrich>Und ich meine, so ein bisschen die Einsicht, warum man halt Python überhaupt optimieren kann, ist, es ist theoretisch alles sehr dynamisch, aber in der Praxis nicht.

01:37:31.600 --> 01:37:34.640
<v Carl Friedrich>Also die dynamischen Möglichkeiten, die werden halt.

01:37:34.960 --> 01:37:36.480
<v Dominik>Sehr selten genutzt tatsächlich.

01:37:36.480 --> 01:37:38.640
<v Carl Friedrich>Ja, jetzt nicht selten.

01:37:38.640 --> 01:37:39.920
<v Carl Friedrich>Aber halt nicht immer.

01:37:40.720 --> 01:37:45.840
<v Carl Friedrich>Also ich glaube halt, jedes Programm ist schon an irgendeiner Stelle dynamisch, aber nicht die ganze Zeit.

01:37:46.800 --> 01:37:52.960
<v Carl Friedrich>Es ist zum Beispiel relativ oft so, dass man beim Importen halt ganz viel Zeug macht, aber danach nicht mehr.

01:37:52.960 --> 01:37:56.320
<v Carl Friedrich>Das ist so ein Muster an Dynamischkeit.

01:37:56.320 --> 01:38:11.040
<v Carl Friedrich>Also du importierst halt eine Bibliothek, beim Importieren macht die ganz merkwürdige Sachen und macht halt so ein bisschen Metaprogrammierung und schreibt irgendwelche Sachen in das Globals Dictionary mit einem Globals Aufruf oder sowas, schreibt es da rein, aber dann ist fertig.

01:38:11.040 --> 01:38:18.080
<v Carl Friedrich>Und danach ist alles quasi harmloser Python-Code, wo die Typen relativ fix sind.

01:38:18.080 --> 01:38:21.280
<v Carl Friedrich>Also das ist so eine Sache, die wir immer wieder sehen.

01:38:21.280 --> 01:38:22.880
<v Carl Friedrich>Da gibt es auch Aufsätze dazu, die das studieren.

01:38:22.880 --> 01:38:31.440
<v Carl Friedrich>Also das findet sich halt recht häufig wieder, dass man komische, dynamische Sachen am Anfang des Programms macht, aber dann irgendwann nicht mehr.

01:38:31.840 --> 01:38:34.560
<v Carl Friedrich>Also so ein ORM ist halt auch so ein Beispiel.

01:38:34.960 --> 01:38:40.320
<v Carl Friedrich>Man generiert halt dann so ein bisschen Klassen, aber das macht man halt nicht die ganze Zeit, sondern halt.

01:38:41.280 --> 01:38:42.400
Genau, ja.

01:38:44.480 --> 01:38:46.720
<v Carl Friedrich>Ja, oder halt so ein Debugger ist halt auch ein Stand.

01:38:46.800 --> 01:38:50.320
<v Carl Friedrich>Also ein Debugger braucht quasi ganz, ganz viele dynamische Features.

01:38:50.320 --> 01:38:52.560
<v Carl Friedrich>Aber der ist halt meistens nicht an.

01:38:52.800 --> 01:38:59.200
<v Carl Friedrich>Und du musst quasi die Möglichkeit haben, dass du den zu einem beliebigen Zeitpunkt anschalten kannst.

01:38:59.200 --> 01:39:02.800
<v Carl Friedrich>Aber du solltest nicht die ganze Zeit den Preis dafür bezahlen müssen.

01:39:02.800 --> 01:39:06.160
Aber du willst dich halt auch nicht vorher entscheiden müssen.

01:39:06.160 --> 01:39:10.160
<v Carl Friedrich>Ja, also du willst halt quasi trotzdem immer die Möglichkeit haben zu sagen, jetzt brauche ich den

01:39:10.160 --> 01:39:14.720
<v Jochen>aber debuggen, weil wenn es zu unterschiedlich ist, dann kann man nicht mehr debuggen halt.

01:39:14.880 --> 01:39:15.440
Ja, ja, genau.

01:39:16.160 --> 01:39:19.040
<v Jochen>Man möchte es ja dann machen können, wenn es eigentlich normal läuft.

01:39:19.280 --> 01:39:25.840
<v Carl Friedrich>Und selbst wenn es jetzt halt nicht um den Debugger geht, also selbst halt sowas wie schöne Tracebacks, die dir halt auch noch die Locals rausschreiben oder so.

01:39:26.080 --> 01:39:30.960
<v Carl Friedrich>Wenn halt dann, wenn halt dein Webserver dann wirklich crasht, dann willst du diese Information halt haben.

01:39:31.280 --> 01:39:38.880
<v Carl Friedrich>Und dann zu sagen, ja, hm, ups, jetzt haben wir das aber so doll optimiert, dass wir, wir wissen halt gar nicht mehr, was die Locals sind.

01:39:39.200 --> 01:39:41.520
<v Carl Friedrich>Also das kann dir halt passieren in so einem Compiler.

01:39:41.520 --> 01:39:43.600
<v Carl Friedrich>Also in C gibt es es ja immer mal.

01:39:43.600 --> 01:39:46.960
<v Carl Friedrich>Da musst du ja wirklich sagen, will ich jetzt die Buggy-Informationen haben oder nicht.

01:39:46.960 --> 01:39:53.440
<v Carl Friedrich>Und wenn du die nicht hast, dann kriegst du, dann kriegst du, dann sagt dir halt keiner mehr, was jetzt gerade in deiner Variable drin steht.

01:39:53.440 --> 01:40:00.560
<v Carl Friedrich>Und meiner Einsicht nach gehört das halt zur Philosophie von Python auch dazu.

01:40:00.560 --> 01:40:09.360
<v Carl Friedrich>Dass man halt zu jedem Zeitpunkt das auch dann machen kann, wenn man halt in einer Situation landet, wo man die Informationen braucht.

01:40:12.400 --> 01:40:13.520
Genau.

01:40:14.960 --> 01:40:17.520
<v Carl Friedrich>So, jetzt haben wir glaube ich so ein bisschen alle Ideen.

01:40:17.520 --> 01:40:28.080
<v Carl Friedrich>Also historisch gesehen, PyPy, Python &lt;unk&gt; Python, also historisch gab es diese Verständlichkeitsidee, die verschwindet ein bisschen.

01:40:28.080 --> 01:40:34.320
<v Carl Friedrich>Also es gibt jetzt schon ganz viele Stellen, wo wir Sachen halt quasi komplizierter machen, um Performance zu kriegen.

01:40:34.320 --> 01:40:46.960
<v Carl Friedrich>Also es ist jetzt nicht mehr nur so ein architektonisch reines Ding, womit man halt irgendwie die Sprache ganz toll verstehen kann, sondern halt wirklich viel pragmatischer und wir wollen halt auch wirklich schnellen Code machen.

01:40:49.200 --> 01:40:54.560
<v Carl Friedrich>Aber stattdessen kam halt diese andere Idee dazu, wir wollen einen Just-in-Time-Compiler für die Sprache haben.

01:40:54.560 --> 01:41:04.560
<v Carl Friedrich>Und weil sich die Sprache eben einmal im Jahr ändert, können wir den nicht von Hand schreiben, weil wir halt nicht Google-Geld haben, sondern irgendwie ein Open-Source-Projekt sind.

01:41:04.560 --> 01:41:09.280
<v Carl Friedrich>Und stattdessen wurde halt dann dieser Forschungsansatz gewählt, wir erzeugen den Justin-Time-Compiler.

01:41:09.520 --> 01:41:12.080
<v Carl Friedrich>Und das hat geklappt.

01:41:12.080 --> 01:41:17.520
<v Carl Friedrich>Also das hätte auch schief gehen können, aber die Kernidee funktioniert ganz gut.

01:41:17.520 --> 01:41:28.800
<v Carl Friedrich>Und jetzt sind wir quasi so ein bisschen auf dem Plateau der Produktivität, dass die so die ganze Kerntechnologie, den DIT-Compiler zu erzeugen, die ist halt relativ stabil.

01:41:28.800 --> 01:41:37.120
<v Carl Friedrich>Es gibt jetzt schon irgendwie da noch so ein paar Features, die wir gerne irgendwie mal machen würden, wenn wir mal ganz motiviert sind oder ganz viel Zeit haben.

01:41:37.120 --> 01:41:50.560
<v Carl Friedrich>Aber so die ganzen Kernideen sind, die sind halt einfach jetzt inzwischen auch drin und stabil und halt über viele Jahre halt auch wirklich so ganz gut stabilisiert.

01:41:51.120 --> 01:42:00.880
<v Carl Friedrich>Und jetzt sind wir halt an dem Punkt, dass wir Hauptarbeit, die wir wirklich machen, ist halt zu versuchen, von C-Python nicht komplett abgehängt zu werden.

01:42:01.440 --> 01:42:04.160
<v Dominik>Ist R-Python hat das Type-Annotation zum Beispiel auch?

01:42:04.160 --> 01:42:09.440
<v Carl Friedrich>Ja, jetzt kommen wir so, jetzt kommen wir zu ein paar der dunklen Geheimnisse.

01:42:10.640 --> 01:42:18.880
<v Carl Friedrich>Also, PyPy ist so alt, dass es gegründet wurde, als Python 2.2, glaube ich, gerade aktuell war oder 2.3.

01:42:19.120 --> 01:42:26.240
<v Carl Friedrich>Das heißt, RPython ist leider tatsächlich noch komplett Python 2 basiert.

01:42:26.880 --> 01:42:42.000
<v Carl Friedrich>Und wir haben halt sehr leider auch sehr, sehr wenig Motivation, das zu ändern, weil wir haben halt leider sowas wie, sag ich mal, eine halbe Million Zeilen Code in dieser blöden, in diesem blöden Python 2-Dialekt.

01:42:42.000 --> 01:42:51.520
<v Carl Friedrich>Und wir könnten uns jetzt hinsetzen und einfach, um jetzt mal eine Schätzung abzugeben, zwei Person-Yars reinstecken, das nach Python 3 zu portieren.

01:42:51.520 --> 01:42:54.960
<v Carl Friedrich>Aber das wäre halt wirklich, ich denke, wirklich zwei Jahre Arbeit.

01:42:54.960 --> 01:42:58.400
<v Carl Friedrich>Und danach hätten wir einfach kein einziges neues Feature.

01:42:58.640 --> 01:43:02.320
<v Carl Friedrich>Das heißt, da hat halt einfach niemand so wirklich Lust drauf.

01:43:02.560 --> 01:43:11.360
<v Carl Friedrich>Und das ist natürlich, wir sind da natürlich so ein bisschen in so einer, also Falle wäre jetzt viel gesagt, aber ein bisschen in so einer blöden Situation.

01:43:11.360 --> 01:43:18.000
<v Carl Friedrich>Weil das ist halt nix, wofür momentan sind das halt wirklich eher so Open Source-Modell.

01:43:18.000 --> 01:43:23.200
<v Carl Friedrich>Da ist jetzt keiner, der dafür wirklich jetzt bezahlt wird, sag ich mal.

01:43:23.200 --> 01:43:32.640
<v Carl Friedrich>Und jetzt so eine Portierungsaktion zu starten, ist halt einfach nur so, also mir würde das halt nicht so viel Spaß machen.

01:43:32.640 --> 01:43:33.120
Ja, ja, klar.

01:43:33.280 --> 01:43:34.320
Sag ich halt mal so.

01:43:34.320 --> 01:43:36.960
<v Carl Friedrich>Aber das ist natürlich trotzdem in gewisser Weise auch kein Zustand, ja.

01:43:36.960 --> 01:43:46.240
<v Carl Friedrich>Also weil irgendwie, also man will halt auch letztlich dann irgendwie auch nicht komplett abgehängt werden.

01:43:47.600 --> 01:43:53.840
<v Jochen>Das wird dann wahrscheinlich irgendwann auch ein Problem, da neue Leute ranzuführen, weil man denen dann ja irgendwie erklärt.

01:43:55.040 --> 01:43:55.760
Ja, genau,

01:43:55.760 --> 01:43:56.960
<v Jochen>das hast du jetzt schon vergessen.

01:43:58.640 --> 01:44:00.160
Das Print hat keine Klammern.

01:44:01.760 --> 01:44:02.400
<v Carl Friedrich>Ja, okay.

01:44:02.560 --> 01:44:10.800
<v Carl Friedrich>Ich meine, das andere, so ein bisschen Doppelproblem, ist halt, dass so ein Interpreter, der benutzt halt an keiner Stelle Unicode.

01:44:10.800 --> 01:44:19.680
<v Carl Friedrich>Das heißt, so halt eines der Hauptargumente, warum, wo Python 3 halt ein paar Sachen so richtig schön gemacht hat, die fallen weg, weil wir halt einfach immer nur ByteStrings benutzen.

01:44:20.000 --> 01:44:42.240
<v Carl Friedrich>Und deswegen, das wäre halt, das ist halt quasi auch nochmal so ein Grund, warum Python 3 jetzt halt auch letztlich jetzt nicht so wirklich so eine Verbesserung ist, sondern halt, wir würden das wirklich machen, um halt nicht abgehängt zu werden, aber nicht, weil wir, weil wir jetzt wirklich von den Python 3-Features so mega motiviert werden.

01:44:42.240 --> 01:44:43.600
<v Carl Friedrich>Und das ist halt ein bisschen doof.

01:44:43.600 --> 01:44:44.720
<v Carl Friedrich>Also, und irgend, also.

01:44:45.120 --> 01:44:55.200
<v Dominik>Würde denn irgendwie diese, keine Ahnung, Type Hins oder andere Features von Python 3 jetzt für die Annotation von dem Compiler irgendwas bringen?

01:44:55.520 --> 01:44:56.400
Nicht so richtig.

01:44:56.400 --> 01:45:03.360
<v Carl Friedrich>Also man könnte sich, klar, man kann dann so ein paar der APIs vielleicht ein bisschen schöner machen, aber wir haben jetzt halt Dekoratoren und die sind jetzt auch nicht so schrecklich.

01:45:03.600 --> 01:45:13.600
<v Carl Friedrich>Ich meine, ob du jetzt halt das dann mit Doppelpunkt direkt hinter die Argumente schreiben kannst oder in der Zeile drüber mit dem Dekorator, den wir halt uns selber ausgedacht haben.

01:45:14.640 --> 01:45:25.600
<v Carl Friedrich>Ja, das wäre schon ein bisschen netter, aber das wäre jetzt nicht, also das wäre jetzt halt für mich nicht so eine ganz ausreichende Motivation, um halt irgendwie so ein riesen Refactoring-Projekt zu starten.

01:45:25.600 --> 01:45:37.360
<v Carl Friedrich>Also ich denke halt, so ein, also das wird halt stattfinden, wenn wir irgendjemanden finden, der da mega Bock drauf hat, oder wenn wir halt Geld finden.

01:45:37.600 --> 01:45:46.640
<v Carl Friedrich>Und ich glaube, wenn beides nicht stattfindet, dann vielleicht bin ich dazu pessimistisch, aber dann sehe ich das im Moment halt nicht.

01:45:47.440 --> 01:45:48.480
Ja gut, klar.

01:45:49.440 --> 01:45:55.120
<v Carl Friedrich>Also ja, also ich persönlich, ich kann nur über mich sprechen, ich persönlich würde es, hätte da halt keinen Spaß dran.

01:45:56.480 --> 01:46:06.640
<v Jochen>Ja, aber ich meine, ist es dann, wenn man tatsächlich kein Unicode hat, sondern nur bei Swings, ich meine, es gibt ja da so automatische Geschichten, könnte man das nicht eventuell auch automatisch.

01:46:06.800 --> 01:46:11.520
Also ob man da halt einfach einmal so zwei Two to three

01:46:11.520 --> 01:46:13.920
<v Jochen>draußen meistens lassen und

01:46:13.920 --> 01:46:22.720
<v Carl Friedrich>wir müssen halt einfach, irgendwann müssen wir das mal gucken und wir haben noch nicht so ganz, wir haben noch nicht so ganz den pragmatischen Weg gefunden, den man halt gehen kann.

01:46:23.120 --> 01:46:31.040
<v Carl Friedrich>Weil es ist halt auch so die Frage, macht man dann einmal einen Cut und sagt, Leute, halt, niemand macht mir neue Features für sechs Monate.

01:46:31.760 --> 01:46:32.960
<v Carl Friedrich>Das ist halt auch doof, ne?

01:46:32.960 --> 01:46:34.560
<v Carl Friedrich>Also.

01:46:34.560 --> 01:46:35.440
<v Carl Friedrich>Ja.

01:46:35.440 --> 01:46:37.280
Aber wir sind ja auch nicht die einzigen.

01:46:37.280 --> 01:46:43.840
Also es gibt ja auch wirklich leider noch ganz viele Firmen, die große Mengen an Python 2 guckt haben.

01:46:45.200 --> 01:46:49.200
<v Carl Friedrich>Aber ja, es ist halt, also man will das jetzt halt keine zehn Jahre so weitermachen.

01:46:49.200 --> 01:46:51.200
<v Carl Friedrich>Das ist, ja, also.

01:46:51.200 --> 01:46:56.800
<v Carl Friedrich>Aber so den idealen Weg, wie wir da jetzt wieder rauskommen aus der Geschichte, den, den haben wir, den wissen wir halt im Moment halt auch nicht.

01:46:56.800 --> 01:47:04.800
<v Carl Friedrich>Außer wir finden jetzt jemanden, der sagt, hier habt ihr eine Million Dollar und macht doch bitte mal, dann ist sowas halt auch wieder.

01:47:04.880 --> 01:47:07.040
<v Dominik>Also ihr könnt hier schreien direkt.

01:47:11.120 --> 01:47:21.440
<v Jochen>Also das ist, das ist bei dem Django-Projekt gibt es sowas ähnliches mit dem Admin mit dem Django-Admin, das ist halt auch so ein Ding.

01:47:21.440 --> 01:47:25.600
<v Jochen>Das ist über Django-Projekts ja auch halt 15 Jahre oder so, das ist halt in die Zeit gewachsen.

01:47:25.600 --> 01:47:41.280
<v Jochen>Teilweise ist da halt auch Geld reingesteckt worden, das zu entwickeln und inzwischen ist es halt auch so, die Schätzung ist ähnlich etwa, also Leute, die sich damit auskennt, sagen halt so, ja, also das jetzt mal so richtig neu zu schreiben und natürlich, wir wissen inzwischen, was wir alles gerne lieber machen würden, würde wahrscheinlich so eine Million kosten und tja, die haben wir halt nicht.

01:47:41.840 --> 01:47:43.440
<v Carl Friedrich>So ist es halt so ein bisschen auch.

01:47:43.440 --> 01:47:46.800
<v Carl Friedrich>Und ich meine, das sieht man ja auch wirklich ganz konkret bei C-Preisen.

01:47:46.800 --> 01:47:53.120
<v Carl Friedrich>Also C-Preiten 3.11 und 3.10 sind halt einfach auch wirklich viel schneller geworden.

01:47:53.120 --> 01:47:54.960
<v Carl Friedrich>Und das ist halt einfach eine Geldfrage.

01:47:55.280 --> 01:48:05.600
<v Carl Friedrich>Also wenn du halt plötzlich fünf Leute hast, die einfach fulltime bezahlt werden und das sind ja auch jetzt nicht irgendwelche Leute, sondern halt auch gute Leute, dann passiert halt auch was.

01:48:05.920 --> 01:48:27.280
<v Carl Friedrich>Und wir können halt quasi so ein bisschen durch schlaue Architektur, die wir vor zehn Jahren halt quasi geschrieben haben, dadurch können wir halt irgendwie ziemlich gut mithalten, weil der TIT-Generator halt da ist und gut funktioniert.

01:48:29.360 --> 01:48:35.280
<v Carl Friedrich>Aber halt alles, was jetzt mal so irgendwie so Big, also Bonus Weights, ist schon zu negativ.

01:48:35.280 --> 01:48:46.320
<v Carl Friedrich>Aber alles, was jetzt halt irgendwie so eine ganz tiefgreifende Veränderung bräuchte, das kriegen wir halt mit dem jetzigen Funningstand nicht hin.

01:48:46.800 --> 01:48:48.640
<v Carl Friedrich>Weil das kriegst du halt nicht durch.

01:48:48.800 --> 01:48:55.520
<v Carl Friedrich>Also wir haben wir haben halt auch schon so ein Open Collective Dings und wir kriegen auch Donations und da wir sind da auch super dankbar dafür.

01:48:55.520 --> 01:49:00.320
<v Carl Friedrich>Da kommt auf jeden Fall auch irgendwie immer wieder gut was zusammen.

01:49:00.320 --> 01:49:03.280
<v Carl Friedrich>Aber es ist halt was anderes, wenn du plötzlich fünf Leute anstellen kannst.

01:49:03.280 --> 01:49:04.480
<v Carl Friedrich>Und da sind wir halt nicht.

01:49:05.920 --> 01:49:14.000
<v Carl Friedrich>Und da haben wir halt auch gerade nicht so richtig die Person, die da hinterher wäre, diese Gelder dann auch zu suchen.

01:49:14.000 --> 01:49:24.400
<v Carl Friedrich>Also wir hatten ja vorhin schon kurz drüber geredet, wir hatten halt irgendwie zweimal so wirklich große Forschungsförderungsprojekte, einmal, also beides mal EU-finanziert.

01:49:24.400 --> 01:49:32.080
<v Carl Friedrich>Das eine war von 2004 bis 2006, das andere von 2008 bis 2010 so ungefähr.

01:49:32.080 --> 01:49:40.960
<v Carl Friedrich>Und da hatten wir halt dann wirklich einige Vollzeitleute, die da einfach wirklich dann über diese Zeiträume halt auch wirklich immer nur an diesem ganzen Zeug gearbeitet haben.

01:49:40.960 --> 01:49:44.000
<v Carl Friedrich>Und da kam halt dann auch wirklich was raus.

01:49:45.360 --> 01:49:53.760
<v Carl Friedrich>Und dann danach hatten wir halt viel so immer wieder Funding auch von Firmen, die halt dann bestimmte Features gerne haben wollen.

01:49:54.080 --> 01:50:01.600
<v Carl Friedrich>Aber seit einer Weile gibt es halt niemanden, der jetzt Bock auf.

01:50:01.840 --> 01:50:06.080
<v Carl Friedrich>Es ist halt nochmal so ein ganz eigener Task, für Open Source Geld zu finden.

01:50:06.320 --> 01:50:11.520
<v Carl Friedrich>Und man braucht halt da so ein bisschen ganz eigene Skills auch.

01:50:11.920 --> 01:50:14.720
<v Carl Friedrich>Und so eine Person haben wir jetzt nicht mehr.

01:50:14.960 --> 01:50:19.440
<v Carl Friedrich>Und das ist in gewisser Weise nicht so ein perfekter Zustand.

01:50:19.840 --> 01:50:31.200
<v Jochen>Ja, und ich meine, selbst für Projekte, die halt sehr viel genutzt werden, also sowas wie Pandas, mich wundert das immer, oder es gibt ja die diverse, es gibt ja ganz viele, wo die Basis für jede Menge.

01:50:33.600 --> 01:50:42.080
<v Jochen>Genau, das ist Basis für Milliardenumsätze irgendwie in der Industrie, aber trotzdem gibt es da eigentlich für die Entwicklung nicht so richtig viel Geld.

01:50:42.640 --> 01:51:06.320
<v Carl Friedrich>Also der andere sehr aktive, momentan sehr aktive PiPi-Entwickler, der Mathi Picos, der ist tatsächlich bei einer Firma angestellt, die darauf spezialisiert ist, halt NumPy voranzubringen und halt dann da einer der Leute, die halt wirklich auch quasi finanziert, NumPy-Bugs fixt, das ist auch Teil, heißt das auch Steering Council bei NumPy?

01:51:06.320 --> 01:51:07.200
<v Carl Friedrich>Was hast du für dich?

01:51:07.200 --> 01:51:07.920
Nee, keine Ahnung.

01:51:08.080 --> 01:51:14.080
<v Carl Friedrich>Also der ist auch quasi Teil des Komitees, das halt Numpai verwaltet und ist da sehr aktiv.

01:51:14.080 --> 01:51:18.080
<v Carl Friedrich>Deswegen geht Numpai auch gut auf PiPai, weil er sich halt da darum auch kümmert.

01:51:21.120 --> 01:51:24.320
<v Carl Friedrich>Ja, also bei Numpai passiert es langsam eben schon.

01:51:24.320 --> 01:51:40.400
<v Carl Friedrich>Also sowas wie Jupyter hat halt auch Funding und da gibt es halt inzwischen in den USA schon auch halt Firmen und Foundations, die halt erkannt haben, dass es einfach so ein wichtiges Stück Infrastruktur ist, dass es halt vielleicht doch auch eine gute Idee ist.

01:51:40.960 --> 01:51:42.480
<v Dominik>Das ganze Internet an so einem kleinen Faden aufhängt.

01:51:42.640 --> 01:51:50.960
<v Jochen>Ja, ja, also die Idee fand ich auch ganz, ganz charmant, dass man sagt, ja, also eigentlich müsste man das Firmen so verkaufen, dass es halt eine Versicherung ist.

01:51:52.160 --> 01:51:59.920
<v Jochen>Wenn sie da nichts, also sie zahlen sozusagen eine Art Versicherungspoliz dafür, dass es das halt auch in Zukunft gibt, weil wenn sie es das nicht mehr geben sollte, haben sie ein großes Problem.

01:52:00.240 --> 01:52:01.680
<v Carl Friedrich>Ich weiß nicht, was da die Antwort ist.

01:52:02.560 --> 01:52:08.080
<v Carl Friedrich>Ich finde halt auch letztlich, in gewisser Weise ist das wirklich auch was, was man über Steuern machen könnte.

01:52:08.080 --> 01:52:08.640
Ja, natürlich.

01:52:08.960 --> 01:52:11.120
<v Carl Friedrich>Und passiert ja ein Stück weit auch.

01:52:11.120 --> 01:52:14.480
<v Carl Friedrich>Also halt sowas wie die, wie, wie, ich glaube, es ist ja.

01:52:14.960 --> 01:52:16.160
<v Dominik>Projektanträge schreiben, ne?

01:52:16.480 --> 01:52:18.400
<v Carl Friedrich>Müsste man halt Projektanträge schreiben haben.

01:52:18.400 --> 01:52:23.840
<v Carl Friedrich>Und da ist es halt dann so ein bisschen so, da ist halt PiPy dann letztlich auch vielleicht nicht wichtig genug.

01:52:24.400 --> 01:52:31.280
<v Carl Friedrich>Also bei Piper kann man halt nicht sagen, dass es jetzt eine absolut grundlegende Technologie wie NumPy.

01:52:31.280 --> 01:52:35.920
<v Carl Friedrich>Weil so viele Leute benutzen es halt dann irgendwie doch nicht.

01:52:36.320 --> 01:52:48.080
<v Carl Friedrich>Und klar, wir finden halt auch immer ganz tolle Bugs in C-Python und ich glaube schon, dass jetzt unser Wert halt jetzt auch, selbst wenn man das nicht einsetzt, ist es halt nicht null, da haben wir vorhin über ein paar Beispiele geredet.

01:52:48.080 --> 01:52:56.160
<v Carl Friedrich>Aber es ist halt auch nicht klar, ob wir jetzt das Projekt sind, für das irgendjemand ein paar Vollzeitentwickler dann bezahlen sollte.

01:52:56.160 --> 01:53:00.640
<v Carl Friedrich>Also ich meine, klar, wir könnten die, wenn wir die hätten, dann könnten wir ganz, ganz tolle Sachen machen.

01:53:00.640 --> 01:53:03.440
<v Carl Friedrich>Auf jeden Fall, ich habe eine ganz lange Liste.

01:53:03.680 --> 01:53:14.640
<v Carl Friedrich>Also schickt das gerne zu mir, aber wenn man dann so einen Antrag schreibt, ist mir halt nicht so klar, ob man sagen kann, wir sind so wichtig wie, was weiß ich, OpenSSL.

01:53:14.640 --> 01:53:15.440
Sind wir halt nicht.

01:53:15.440 --> 01:53:16.800
Offensichtlich nicht.

01:53:17.040 --> 01:53:22.080
<v Carl Friedrich>Und ja, aber das viel grundlegende Problem ist halt, wir haben im Moment keinen, der da Lust drauf hat.

01:53:22.240 --> 01:53:25.600
<v Carl Friedrich>Oder in dessen Expertise das halt liegt.

01:53:25.680 --> 01:53:27.920
Und das ist nicht so gut.

01:53:27.920 --> 01:53:32.320
<v Carl Friedrich>Und es kann schon sein, dass ich da auch vielleicht irgendwann dann auch nochmal drin besser werden muss.

01:53:32.640 --> 01:53:34.720
<v Dominik>Wenn ihr Lust drauf habt, dann sagt Bescheid.

01:53:36.880 --> 01:53:38.480
<v Carl Friedrich>Wir nehmen gerne Freiwillige an.

01:53:38.720 --> 01:54:00.000
<v Carl Friedrich>Also zum Beispiel zum Beispiel Read the Docs finde ich auch einen sehr interessanten Fall, weil das ja auch letztlich halt einen sehr guten Weg gefunden hat für ein für die Community ultra wichtiges Problem, nämlich wo wird eigentlich die Dokumentation gehostet und wer bezahlt dafür, halt eine Lösung zu finden.

01:54:00.000 --> 01:54:08.400
<v Carl Friedrich>Und die Lösung ist halt, wir finanzieren das einmal durch akzeptable Werbung und eben durch Firmen, die dann damit selber ihre Dokumentation hosten.

01:54:08.400 --> 01:54:19.040
<v Carl Friedrich>Und da gibt es auch coole Podcasts, so ich muss mal gucken, ob mir die Folge einfällt, wo der Read the Docs-Gründer halt dann auch so ein bisschen über seine Philosophie von Outsource Funding redet.

01:54:19.040 --> 01:54:24.320
<v Carl Friedrich>Und ja, ich finde das auch einen ganz coolen Weg eigentlich.

01:54:24.320 --> 01:54:41.520
<v Carl Friedrich>Also, weil die haben ja wirklich jetzt auch einige Entwickler, die halt da an der Infrastruktur arbeiten, die Sphinx vor allem sind, die Dock-Hit Hills-Patches schicken und da ist ja wirklich, also da sind wir ja, da ist die Python-Community ja auch wirklich ziemlich gut aufgestellt.

01:54:41.520 --> 01:54:44.480
<v Carl Friedrich>Also ich finde es auch sehr interessant.

01:54:44.480 --> 01:54:53.200
<v Carl Friedrich>Es gibt wirklich auch an einigen Stellen halt dann Projekte in ganz anderen Sprachen, die halt dann trotzdem Read the Docs nehmen, weil es halt einfach wirklich auch cool ist.

01:54:54.720 --> 01:54:55.280
<v Jochen>Wer heißt da?

01:54:55.280 --> 01:54:56.320
<v Jochen>Ist das Eric Holt?

01:54:56.560 --> 01:54:57.520
<v Jochen>Ja, genau.

01:54:57.760 --> 01:55:03.280
<v Jochen>Ich glaube, da gab es einen Django Chat-Episode, die gar nicht so lange her ist, vor ein paar Monaten, wo er zu Gast war und da hat er da einige.

01:55:03.360 --> 01:55:05.440
<v Jochen>Ich packe die auch mal in die Show Notes und nichts mich dran.

01:55:06.000 --> 01:55:06.400
Ja.

01:55:06.720 --> 01:55:07.280
Ja.

01:55:07.600 --> 01:55:10.720
<v Jochen>Und ja, ja, nee, das ist ein großartiges Beispiel da.

01:55:11.680 --> 01:55:21.040
<v Carl Friedrich>Naja, und ansonsten ist es halt so, ich habe jetzt halt, also wir haben halt in gewisser Weise einen ganz guten Vorteil, weil ich kann das halt als Teil meiner Arbeit machen.

01:55:21.040 --> 01:55:29.520
<v Carl Friedrich>Ich bin an der Uni eingestellt, ich bin für die Lehre bezahlt, aber wenn die Lehre zu Ende ist, dann darf ich quasi forschen, was ich will.

01:55:30.400 --> 01:55:37.200
<v Carl Friedrich>Ich bin in eine Forschungsgruppe eingebettet, die zumindest irgendwie irgendwie was mit Compilern zu tun auch hat.

01:55:37.200 --> 01:55:48.800
<v Carl Friedrich>Insofern bin ich da jetzt auch nicht, bin da so ein bisschen der Einzige, der ganz konkret was mit Jitcompilern macht im Moment, aber ich bin da jetzt quasi thematisch auch nicht fehl am Platz und mein Chef freut sich da auch, wenn ich da dann was dann mache.

01:55:48.800 --> 01:56:09.840
<v Carl Friedrich>Insofern passieren halt durch das Level, was durch meine halbe Stelle, das ist jetzt nicht, das sind jetzt nicht ultra viele Stunden, aber halt zumindest schon so ein paar Stunden, die sind halt da und die werden halt auch, solange es aus meiner Ansicht nach da halt interessante Forschungsfragen gibt, werden die halt auch für das Projekt auch weiter verwendet werden.

01:56:10.240 --> 01:56:15.280
<v Carl Friedrich>Und das ist halt so ein Basislevel, naja, das muss man halt auch erstmal haben, ja.

01:56:18.320 --> 01:56:31.760
<v Carl Friedrich>Aber das reicht halt nicht, um jetzt reicht jetzt nicht, um jetzt halt irgendwie so eine ganz krasse neue Idee für eine neue DIT-Optimierung sich auszudenken.

01:56:31.760 --> 01:56:35.680
<v Carl Friedrich>Also manchmal, manchmal läuft es dann über Abschlussarbeiten ganz gut.

01:56:35.680 --> 01:56:52.400
<v Carl Friedrich>Also ich hatte gerade eine unglaublich coole Bachelorbeit betreut, das ist jetzt noch nicht gemerkt, aber der hat echt eine sehr interessante neue Optimierung für den DIT-Compiler auch geschrieben, wie auch gerade bei Programmen, die viel mit Integer machen, wirklich nochmal ganz anders Sachen optimieren kann.

01:56:53.360 --> 01:56:55.520
<v Carl Friedrich>Also echt super Student.

01:56:56.400 --> 01:56:58.240
<v Carl Friedrich>Nico Rittinghaus heißt der.

01:56:59.360 --> 01:57:07.840
<v Carl Friedrich>Der hat dann auch so die Originalliteratur aus den 70ern gelesen und meinte so, hier in diesem Paper, was mit Schreibmaschine geschrieben wurde, steht das hier drin.

01:57:07.840 --> 01:57:10.320
<v Carl Friedrich>Da ist doch bei in eurem Code ist das doch ganz anders.

01:57:10.640 --> 01:57:11.600
Sag doch mal.

01:57:13.280 --> 01:57:14.720
<v Carl Friedrich>Genau, so, ja.

01:57:16.320 --> 01:57:19.680
<v Carl Friedrich>Und ja, er hat dann, aber er hat auch immer recht.

01:57:19.680 --> 01:57:22.880
<v Carl Friedrich>Also das war sehr, sehr cool mit dem.

01:57:22.880 --> 01:57:28.560
<v Carl Friedrich>Ich hoffe auch, dass er quasi weitermacht und vielleicht irgendwie auch noch eine Bachelorarbeit, äh, eine Masterarbeit schreibt.

01:57:28.560 --> 01:57:35.760
<v Carl Friedrich>Aber manchmal passieren halt dann so dann Sachen, aber bei so Abschlussarbeiten ist das halt schon so, dass die Leute halt dann tendenziell auch wieder weg sind.

01:57:35.760 --> 01:57:37.520
<v Jochen>Ja, und dann muss man das mal entenden, was ihr gefragt hat.

01:57:37.680 --> 01:57:38.800
<v Carl Friedrich>Nee, das ist eigentlich okay.

01:57:39.840 --> 01:57:43.200
<v Jochen>Das stimmt, wenn es

01:57:43.200 --> 01:57:48.400
<v Carl Friedrich>schreiben halt Tests und ich bin halt dann schon, ich gehe dann schon auf die Nerven, dass sie jetzt halt auch keinen Scheiß schreiben.

01:57:48.400 --> 01:57:49.760
<v Carl Friedrich>Also so qualitätsmäßig.

01:57:55.760 --> 01:57:57.600
<v Dominik>Macht ein bisschen Review und Kultur.

01:57:57.600 --> 01:58:04.480
<v Carl Friedrich>Review und Kultur und wir wollen halt schon, wir sind halt jetzt nicht so ein normales Forschungsprojekt, was halt eigentlich Code zum Wegschmeißen.

01:58:04.560 --> 01:58:07.040
<v Carl Friedrich>Also viele Forschungsprojekte sind halt so Code zum Wegschmeißen.

01:58:07.040 --> 01:58:11.120
<v Carl Friedrich>Man schreibt Code, man schreibt einen Paper und dann ist man damit mit dem Thema durch.

01:58:11.120 --> 01:58:19.440
<v Carl Friedrich>Sondern wir sind halt so ein bisschen, in gewisser Weise so ein bisschen ein schlechtes Forschungsprojekt, in dem Sinne, dass wir halt versuchen halt auch Code zu schreiben, wenn Leute benutzen können.

01:58:19.440 --> 01:58:24.000
<v Carl Friedrich>Und deswegen haben wir halt Aufwand, der sich aus Forschungssicht halt irgendwie auch nicht lohnt.

01:58:24.320 --> 01:58:27.200
<v Carl Friedrich>Deswegen bin ich halt vielleicht auch kein Professor.

01:58:27.200 --> 01:58:33.680
<v Carl Friedrich>Sondern weil mein Forschungsoutput halt auch nicht, also weil ich diesen Job auch gar nicht haben wollte, ne?

01:58:33.680 --> 01:58:40.800
<v Carl Friedrich>Also das, aber weil halt so der Output an Aufsätzen bei mir vielleicht halt nicht so ganz stimmt.

01:58:40.800 --> 01:58:56.560
<v Carl Friedrich>Also ich schreibe jetzt schon Aufsätze und die sind halt zum Teil dann auch ganz gut rezipiert und werden zitiert und so, aber vielleicht jetzt nicht mit dem Nachdruck, den man bräuchte, wenn man jetzt halt so ein reiner Akademiker sein wollte.

01:58:57.360 --> 01:59:00.880
<v Jochen>Naja, ja, das ist auch eine faszinierende Geschichte.

01:59:00.880 --> 01:59:04.560
<v Jochen>Ich meine, tatsächlich ist es ja dann doch oft so, dass dann Sachen wiederverwendet werden.

01:59:04.560 --> 01:59:22.000
<v Jochen>Also wenn man dann und dann, also in der Physik, so manche Leute kommen, sieht man das dann häufig, dass dann doch irgendwie so sich Sachen aufeinander türmen, die halt irgendwie man vielleicht dann doch mal, wenn man gewusst hätte, wo man Hintergrund rausgekommen hat, hätte man das doch mal hätte man das vielleicht anders bauen können.

01:59:22.960 --> 01:59:25.760
<v Carl Friedrich>Das ist meine absolute Lieblingsgeschichte, die werde ich jetzt hier noch anbringen.

01:59:25.760 --> 01:59:26.720
Oh ja, sehr gerne.

01:59:26.720 --> 01:59:39.600
<v Carl Friedrich>Ich habe tatsächlich, also ursprünglich habe ich mal Mathe und Physik studiert und dann habe ich das abgebrochen, um bei einem der Pipei-Firmen, die halt von der EU Geld gekriegt haben, mitzuarbeiten für eine Weile.

01:59:39.600 --> 01:59:47.280
<v Carl Friedrich>Aber vorher habe ich quasi bei den Teilchenphysikern halt immer so semesterferien, Hiwi-Jobs gehabt.

01:59:47.280 --> 01:59:56.640
<v Carl Friedrich>Und die Teilchenphysiker, die haben so Zern und so, die haben halt ein ganz interessantes Stück Technologie, nämlich die haben einen C&lt;unk&gt; Interpreter.

01:59:57.040 --> 02:00:02.000
<v Carl Friedrich>Ach, weil dann muss man ja nur eine Sprache lernen.

02:00:02.640 --> 02:00:10.000
<v Carl Friedrich>Also wir müssen ja, die Physiker, die müssen ja eh zu C&lt;unk&gt; lernen, um halt schnell einen Code zu schreiben, aber die wollen ja auch Scripting machen.

02:00:10.000 --> 02:00:17.920
<v Carl Friedrich>Und wenn wir jetzt halt so einen C&lt;unk&gt;-Interpreter haben, dann können die ja mit der Sprache, die die E schon können, halt auch ihre Skripte schreiben.

02:00:18.720 --> 02:00:29.280
<v Carl Friedrich>Und das war halt so um 2003 rum war das halt echt noch irgendwie so ein Stück Technologie, was die halt einfach wirklich benutzt haben in der Teilchenphysik.

02:00:29.440 --> 02:00:37.760
<v Carl Friedrich>Und so nach und nach kam halt dann die Erkenntnis, dass das doch irgendwie vielleicht halt so ein bisschen so eine merkwürdige Idee ist.

02:00:38.080 --> 02:00:41.440
<v Carl Friedrich>Und inzwischen nehmen die halt auch einfach Python für Scripting, ja.

02:00:42.320 --> 02:00:50.960
<v Carl Friedrich>Aber das ist halt für mich immer so ein Beispiel, wenn man, also einer, eine so ein Lieblingsaufreger von mir ist, wenn Leute halt von interpretierten Sprachen reden.

02:00:50.960 --> 02:00:53.600
<v Carl Friedrich>Man sagt halt gerne, Python ist eine interpretierte Sprache.

02:00:53.600 --> 02:00:57.200
<v Carl Friedrich>Und das ist halt eigentlich eine Aussage, die meiner Ansicht nach semantisch keinen Sinn macht.

02:00:57.200 --> 02:01:03.440
<v Carl Friedrich>Also es ist sinnleer, weil es ist halt eine Eigenschaft einer Implementierung, ob sie interpretiert ist oder nicht.

02:01:03.440 --> 02:01:08.800
<v Carl Friedrich>Also C-Python ist ein Interpreter, das stimmt, und PyPy ist halt ein JIT-Compiler, das stimmt.

02:01:09.600 --> 02:01:14.560
<v Carl Friedrich>Aber man kann jetzt eben nicht sagen, dass C&lt;unk&gt; eine kompilierte Sprache ist, weil es gibt ja C-Int.

02:01:14.560 --> 02:01:19.280
<v Carl Friedrich>Und das ist halt eine Implementierung von C&lt;unk&gt;, die das interpretiert.

02:01:19.520 --> 02:01:26.640
<v Carl Friedrich>Und deswegen kann man halt nur sagen, na gut, wenn man halt GCC benutzt, dann hat man eine kompilierte Implementierung von C&lt;unk&gt;.

02:01:26.640 --> 02:01:36.320
<v Carl Friedrich>Das ist quasi so ein Randfall, den ich dann gerne anbringe, um zu demonstrieren, dass es halt ein Konzept ist, das keinen Sinn macht, von einer kompilierten Sprache zu sprechen.

02:01:36.320 --> 02:01:39.600
<v Carl Friedrich>Naja, also zum Glück ist das Ding inzwischen, glaube ich, tot.

02:01:39.600 --> 02:01:40.960
<v Carl Friedrich>Also ich, ja.

02:01:43.920 --> 02:01:46.240
<v Jochen>Ja, interessant.

02:01:48.480 --> 02:01:57.040
<v Jochen>Tja, ich weiß nicht, spielt eigentlich diese auch so Geschichten mit Software Transactional Memory und so.

02:01:57.120 --> 02:01:58.000
Spielt das noch eine Rolle?

02:01:58.080 --> 02:02:06.800
<v Carl Friedrich>Also da gab es halt ein relativ langjähriges Forschungsprojekt, auch von dem Armin Rigo und einem Doktoranden, der in der ETH Zürich, glaube ich, promoviert hat.

02:02:06.800 --> 02:02:24.560
<v Carl Friedrich>Und die hatten halt diese Idee, dass man halt irgendwie Software Transactional Memory benutzen können sollte, um den Overhead von einem DIL, also Global Interpreter Log-Free Multithreading für Python sehr klein zu halten.

02:02:25.040 --> 02:02:35.360
<v Carl Friedrich>Und dieses Forschungsprojekt hat halt, also die haben da auch wirklich viele Jahre dran geforscht und reinzeit investiert.

02:02:35.360 --> 02:02:38.240
<v Carl Friedrich>Das hat halt am Schluss nicht so gut geklappt, wie sie sicherhauptplatten.

02:02:38.880 --> 02:02:39.840
Was ist das überhaupt noch?

02:02:39.840 --> 02:02:40.800
<v Dominik>Vielleicht nochmal.

02:02:41.040 --> 02:02:43.040
<v Carl Friedrich>Also ich bin da sehr schnell raus.

02:02:48.160 --> 02:02:56.400
<v Carl Friedrich>Ich habe das halt immer so interessiert verfolgt und die hatten halt dann so ein Branch und haben da auch jahrelang auch wirklich sehr viel Aufwand reingesteckt.

02:02:56.400 --> 02:03:00.480
<v Carl Friedrich>Aber am Schluss waren sie halt irgendwie mit den Ergebnissen nicht so zufrieden.

02:03:00.480 --> 02:03:06.560
<v Carl Friedrich>Und halt auch, also technische Details, wie gesagt, ist nicht so mein Ding.

02:03:07.200 --> 02:03:08.400
<v Dominik>Was sollte das denn theoretisch sein?

02:03:08.400 --> 02:03:11.280
<v Dominik>Also ich habe gar nicht verstanden, was worauf es da gehen soll.

02:03:11.280 --> 02:03:21.920
<v Carl Friedrich>Also die Idee von Software Transactional Memory ist, dass du quasi, also du kannst halt dann mehrere Threads starten, die alle Python-Code ausführen.

02:03:21.920 --> 02:03:25.760
Und du machst so einen optimistischen Ansatz, so einen Datenbankansatz.

02:03:26.240 --> 02:03:33.600
<v Carl Friedrich>Jeder Thread hat eine eigene Transaktion und der Thread, der läuft so ein bisschen und dann versucht er zu committen.

02:03:33.600 --> 02:03:46.320
<v Carl Friedrich>Und committen heißt, dass seine Sicht der Welt, also seine Sicht des Zustand des Programms, mit der Sicht der Welt der anderen Threads irgendwie gemerkt werden muss.

02:03:47.040 --> 02:03:48.800
<v Carl Friedrich>Das ist die Transaction.

02:03:48.800 --> 02:03:52.720
<v Carl Friedrich>Und das macht man aber nicht auf der Datenbank-Ebene, sondern wirklich auf der Sprachebene.

02:03:52.720 --> 02:03:55.760
<v Carl Friedrich>Also das ist die Idee von Software Transactional Memory.

02:03:55.760 --> 02:04:01.360
<v Carl Friedrich>Und da gibt es halt dann Techniken, um das effizient hinzukriegen.

02:04:01.360 --> 02:04:12.720
<v Carl Friedrich>Und wenn das alles gut geht, also wenn die verschiedenen Threads sich nicht gegenseitig auf die Füße rumtrampeln, dann führt es halt dazu, dass du wirklich sehr gut skalierenden Python-Code schreiben kannst.

02:04:12.800 --> 02:04:19.360
<v Carl Friedrich>Also skalierend heißt, wenn du 16 Cores hast, dann kannst du halt dann auch 16 mal schnelleren Code schreiben.

02:04:19.360 --> 02:04:23.520
<v Carl Friedrich>Das Problem ist jetzt, was machst du, wenn das nicht so gut klappt mit den Transaktionen?

02:04:23.520 --> 02:04:29.520
<v Carl Friedrich>Und du hast halt einen Thread, der versucht, seine Transaktion zu committen und einen anderen Thread und da gibt es einen Konflikt.

02:04:29.520 --> 02:04:36.560
<v Carl Friedrich>Dann bedeutet das immer, der eine Thread, der wirft die ganze Arbeit, die er gemacht hat, weg und fängt halt nochmal ein bisschen weiter hinten an.

02:04:36.560 --> 02:04:37.520
<v Dominik>Wer ist denn der eine?

02:04:37.520 --> 02:04:38.400
<v Dominik>Wer wirft denn weg?

02:04:38.720 --> 02:04:39.680
Es gewinnt halt einer von den.

02:04:40.000 --> 02:04:40.320
<v Carl Friedrich>Zufällig.

02:04:40.400 --> 02:04:41.600
Nee, nicht so richtig zufällig.

02:04:41.600 --> 02:04:46.960
<v Carl Friedrich>Du musst natürlich schon dann nach außen hin die Python-Semantik dann bewahren.

02:04:47.600 --> 02:04:49.920
<v Carl Friedrich>Das darf quasi nicht beobachtbar sein.

02:04:49.920 --> 02:04:53.440
<v Carl Friedrich>Und da wird es halt dann auch technisch sehr komplizierter, da weiß ich auch nichts zu.

02:04:54.640 --> 02:05:02.240
<v Carl Friedrich>Aber also so von außen ist halt die Idee, es gewinnt einer und die Semantik ist erhalten.

02:05:02.720 --> 02:05:05.920
<v Carl Friedrich>Das Problem ist jetzt nicht, dass sich das merkwürdig verhält.

02:05:06.000 --> 02:05:17.760
<v Carl Friedrich>Das Problem ist halt, wenn du Pech hast, dann ist dein, dann sind alle deine 16 Cores irgendwie busy, aber dein Programm ist nur zweimal so schnell.

02:05:18.320 --> 02:05:21.280
<v Carl Friedrich>Und das ist quasi so ein Performance-Bug.

02:05:21.280 --> 02:05:30.960
<v Carl Friedrich>Und die haben halt einfach, ich glaube letztlich war das Problem, dass sie nicht so richtig die Werkzeuge gefunden haben, um an dieser Stelle dann weiterzukommen.

02:05:30.960 --> 02:05:37.280
<v Carl Friedrich>Du hast halt diesen Performance-Bug, irgendwo gibt es einen Konflikt zwischen den Threads, aber was machst du jetzt als Programmierer?

02:05:37.280 --> 02:05:41.520
<v Carl Friedrich>Wenn du halt Performance-Probleme in Python-Code hast, dann gibt es halt Tools, so Profiler und so.

02:05:41.520 --> 02:05:44.880
<v Carl Friedrich>Und dann kannst du die benutzen, um rauszufinden, wo du vielleicht was optimieren könntest.

02:05:44.880 --> 02:05:50.640
<v Carl Friedrich>Aber für dieses, für dieses, wir haben jetzt zu viele Konflikteprobleme, da gibt es halt keine Tools.

02:05:50.640 --> 02:05:55.200
<v Carl Friedrich>Und da wussten die halt zum Teil dann auch selber nicht, wo jetzt die Zeit bleibt.

02:05:55.200 --> 02:06:02.800
<v Carl Friedrich>Und die sind halt dann, ich habe so ein bisschen das Gefühl, irgendwann ist ihnen so dann die Prüfung ausgegangen, vielleicht.

02:06:02.800 --> 02:06:05.920
<v Carl Friedrich>Also nach sechs, sieben Jahren.

02:06:09.840 --> 02:06:11.840
<v Carl Friedrich>Naja, gut, und es ist ja jetzt auch ganz interessant.

02:06:11.920 --> 02:06:24.560
<v Carl Friedrich>Ich finde es halt interessant, dass es jetzt diesen Prototypen von Facebook gibt, wo halt in gewisser Weise so ein ganz klassischer Ansatz, also das ist halt immer Armin's idee.

02:06:24.560 --> 02:06:37.600
<v Carl Friedrich>Arins Ansatz war ja mit dem Budget-Generator auch schon so, der hat eine Vision, die ist technisch irgendwie elegant und dann versucht er das umzusetzen und bei Budget-Generator hat es geklappt und bei Software Transactional Memory hat es halt leider nicht geklappt.

02:06:37.600 --> 02:06:44.320
<v Carl Friedrich>Und vielleicht, wenn er noch ein paar Jahre weiter gemacht hätte, hätte es auch irgendwann geklappt, aber momentan macht er da halt, da wird er arbeitet halt nicht mehr daran weiter.

02:06:45.360 --> 02:06:50.160
<v Carl Friedrich>Aber jetzt der Facebook-Code, der ist ja quasi in gewisser Weise ganz klassisches Engineering.

02:06:50.320 --> 02:07:03.280
<v Carl Friedrich>Also, die haben halt quasi wirklich ganz klassisch, so wie man halt irgendwie Shared Memory Multiprocessing macht, das implementiert mit einer sehr coolen neuen Einsicht.

02:07:03.440 --> 02:07:05.600
<v Carl Friedrich>Da haben wir vorhin auch schon ganz kurz drüber gesprochen.

02:07:05.600 --> 02:07:10.320
<v Carl Friedrich>Nämlich, also wie gesagt, this is überhaupt nicht mein Gebiet, ich kann mich da nur sehr schlecht aus.

02:07:10.400 --> 02:07:12.960
<v Carl Friedrich>Aber die Idee ist, glaube ich, dieses Biased Locking, oder?

02:07:14.320 --> 02:07:16.560
<v Jochen>Genau, Biased Reference Counting.

02:07:16.720 --> 02:07:24.240
<v Carl Friedrich>Genau, also die Idee ist quasi, dass ein Objekt meistens in dem Thread benutzt wird, in dem es auch erzeugt wurde.

02:07:24.240 --> 02:07:33.520
<v Carl Friedrich>Und es gibt halt dann so ein Fast Path, solange das Objekt nur in diesem Thread benutzt wird, sind die Zugriffe auf dieses Objekt sehr schnell.

02:07:33.520 --> 02:07:38.640
<v Carl Friedrich>Also da ist die Synchronisierung zwischen den Threads quasi umsonst.

02:07:38.960 --> 02:07:46.640
<v Carl Friedrich>Und erst wenn man das wirklich dann in einen anderen Thread auch benutzen will, wird es halt dann performancemäßig teurer.

02:07:47.840 --> 02:07:49.840
<v Carl Friedrich>Und das ist quasi eine neue Einsicht.

02:07:49.840 --> 02:07:55.600
<v Carl Friedrich>Die kommt jetzt in diesen klassischen Ansatz, Shared Memory Multi-Processing mit Logs und so zu machen, kommt das dazu.

02:07:55.600 --> 02:08:03.600
<v Carl Friedrich>Und es hat sich halt herausgestellt, dass das quasi der richtige ist, um den Overhead für Single-Threaded Code klein zu kriegen.

02:08:05.280 --> 02:08:15.360
<v Jochen>Es gibt auch so ein paar Tricks, also ein interessanter Trick ist, weil es gibt dann ja durchaus so viele Sachen, die halt schon in allen Threads verwendet werden, also alles, was irgendwie globale Supports und so Zeugs.

02:08:15.520 --> 02:08:19.120
<v Jochen>None zum Beispiel True, False, sowas.

02:08:19.120 --> 02:08:26.960
<v Jochen>Genau, und die erklärt man dann einfach zu unsterblichen Objekten sozusagen, macht kein Reference-Counting, weil man sagt, das wird sowieso nie differenziert.

02:08:27.440 --> 02:08:34.720
<v Carl Friedrich>Also was mir zum Beispiel noch nicht so ganz klar ist, man hat ja dann eigentlich oft auch an irgendeiner Stelle doch eine gescherte Datenstruktur.

02:08:34.720 --> 02:08:42.320
<v Carl Friedrich>Also wenn du halt zum Beispiel irgendwie so ein Work-Stealing implementieren willst und du nimmst halt einfach eine Liste, geht das dann noch?

02:08:42.320 --> 02:08:45.120
<v Carl Friedrich>Oder ist halt diese ist dann zu viel Contention auf dieser Liste?

02:08:45.120 --> 02:08:51.120
<v Carl Friedrich>Oder diese Feinheiten, also wie da dann wirklich sich die Performance sich dann in der Praxis wirklich verhält,

02:08:51.120 --> 02:08:52.160
<v Dominik>was ist ein Work-Sealing.

02:08:52.160 --> 02:08:53.440
<v Carl Friedrich>Ich glaube, das weiß halt keiner.

02:08:53.440 --> 02:08:54.000
<v Dominik>Sorry?

02:08:54.000 --> 02:08:55.040
<v Dominik>Was ist ein Work-Stealing?

02:08:55.120 --> 02:09:08.640
<v Carl Friedrich>Also bei Work-Stealing ist halt quasi, du hast irgendwie verschiedene Arbeitspakete und verschiedene Threads, die die abarbeiten, und du koordinierst diese Threads halt über irgendeinen so eine Que.

02:09:08.640 --> 02:09:16.960
<v Carl Friedrich>Und die Frage ist jetzt, welche Datenstruktur benutzt du, um diese Queue zu repräsentieren?

02:09:16.960 --> 02:09:25.680
<v Carl Friedrich>Und Workseating ist Einsatz, dass da hat jeder Thread seinen eigenen Queue, glaube ich, und wenn ein Thread nichts mehr in seiner eigenen Queue hat, dann klaut er was aus den Ques.

02:09:25.840 --> 02:09:30.240
<v Dominik>Also ich stelle mir das immer so ein bisschen vor, wie so eine Bank, wo irgendwelche Leute am Schalter stehen und warten, bis sie dran können.

02:09:30.240 --> 02:09:32.800
<v Dominik>Und dann sind bestimmte Schalter halt auf, ein bestimmter Schalter halt nicht.

02:09:32.800 --> 02:09:39.200
<v Dominik>Und dann kann halt irgendwie sich Leute anstellen an verschiedenen Schaltern und wenn irgendwie eine gerade keine Kunde hat.

02:09:39.280 --> 02:09:41.120
<v Dominik>Dann geht halt jemand mal so schnell jemand drüber.

02:09:42.000 --> 02:09:44.880
<v Carl Friedrich>Aber ich glaube, also wie da halt so, ich habe da kein gutes Mentales.

02:09:45.040 --> 02:09:48.640
<v Carl Friedrich>Also ich bin wirklich ein sehr single-threaded Mensch.

02:09:48.880 --> 02:09:50.400
<v Carl Friedrich>Ich kann das auch nicht.

02:09:50.400 --> 02:09:55.520
<v Carl Friedrich>Aber ich habe halt mein mentales Modell, das existiert einfach noch nicht.

02:09:55.520 --> 02:10:03.840
<v Carl Friedrich>Ich weiß halt nicht, was passiert mit der Performance, wenn man halt irgendwie 17 Threads hat, die auf 17 Cores laufen und die wollen alle auf eine Liste zugreifen.

02:10:03.840 --> 02:10:06.080
<v Jochen>Also das ist auch etwas, was irgendwie sehr schlecht ist.

02:10:06.080 --> 02:10:21.360
<v Jochen>Also immer wenn ich mit sowas zu tun hatte, musste ich feststellen, wenn ich vorher nicht schon auch das Gefühl hatte, ich kann das gar nicht, dass ich es dann, wenn, dachte ich, ich kann es theoretisch und dann praktisch aber feststellen muss, ich kann es nicht, weil es ist, es ist wirklich, und das map halt nicht auf die Art, wie Menschen denken gut.

02:10:21.920 --> 02:10:29.200
<v Carl Friedrich>Und es ist auch ganz interessant, also es gibt ja zwei, mindestens zwei Implementierungen von Python, die halt auch keinen Dill haben, nämlich Jitan.

02:10:29.520 --> 02:10:41.680
<v Carl Friedrich>Jitan ist, soweit ich das sehen kann, relativ tot, aber so in der 2.7 ist ein sehr guter 2-7-Interpreter, der halt Implementierung, der halt keinen Jill hat, der halt wirklich Multithreading kann.

02:10:41.760 --> 02:11:05.360
<v Jochen>Das ist auch eine ganz, ganz, das war etwas, was ich jetzt bei dem Durchhören da folgenden, eine der Neuigkeiten, die ich da mitgenommen habe, die ich vorher echt gar nicht wusste und mich frage, wie mir das entgegen konnte, aber dass halt, wohl wenn man einen JIT-Compiler hat, das viel besser geht mit dem Fine-Grained Blocking, also sozusagen, dass man gar nicht unbedingt einen Jill braucht, dass es halt mit einem Interpreter, der NC geschrieben ist und der statisch kompiliert ist, geht das gar nicht, richtig.

02:11:05.360 --> 02:11:11.920
<v Jochen>Aber Java, da das von einem JIT-Compiler verwandelt wird, ist das kein Problem sozusagen.

02:11:11.920 --> 02:11:16.000
<v Jochen>Und da kann man das dann ohne Jill mit Fine-Graned Locking machen, es wird halt nicht langsam dadurch.

02:11:16.880 --> 02:11:28.480
<v Carl Friedrich>Da gibt es halt, also das ist nicht so leicht, aber der JIT kann halt dann quasi, der JIT macht dann so Reasoning über darüber, ob man gerade von einem Objekt den Log schon hat.

02:11:28.480 --> 02:11:36.720
<v Carl Friedrich>Und dann muss man halt nicht bei jeder Operation versuchen, sich das Log zu holen, sondern macht das nur einmal in der Funktion oder nur an bestimmten Punkten.

02:11:37.600 --> 02:11:45.360
<v Carl Friedrich>Und man macht halt dann nicht bei jedem Field-Read muss man dann irgendwie das Lok holen, sondern kann sagen, wir lesen hier 17 verschiedene Felder und wir holen uns das nur einmal.

02:11:45.360 --> 02:11:48.400
<v Carl Friedrich>Und das kann der Jill halt machen, das kann der Interpreter nicht machen.

02:11:49.920 --> 02:11:52.160
<v Carl Friedrich>Aber ja, also da sind wir noch nicht in Python.

02:11:52.960 --> 02:11:54.560
<v Carl Friedrich>Aber Jython konnte das halt.

02:11:54.560 --> 02:12:04.400
<v Carl Friedrich>Und da hat sich aber interessanterweise halt dann rausgestellt, dass es halt unglaublich viele Bibliotheken gibt in Python, die halt einfach natürlich überhaupt nicht Thread-Safe sind.

02:12:04.640 --> 02:12:05.520
Natürlich nicht.

02:12:05.520 --> 02:12:12.640
<v Carl Friedrich>Weil wie soll denn die Bugs gefunden werden, wenn halt die Standardimplementierung halt einfach immer single-threaded ist?

02:12:13.040 --> 02:12:24.720
<v Carl Friedrich>Und selbst in der Standardbibliothek hat halt Jython damals quasi einiges an Bugs gefunden, wo es halt Deadlocks und alles Mögliche gab.

02:12:24.720 --> 02:12:32.640
<v Carl Friedrich>Weil der Code in der Standardbibliothek von C Python halt einfach den Gill präsuponiert.

02:12:32.640 --> 02:12:42.800
<v Carl Friedrich>Und ich denke, das wird halt schon dann auch nochmal für die Community auch einen ganz schön langwierigen Prozess, bis man halt wirklich an den Punkt ist, dass alle Bibliotheken dann auch gehen.

02:12:46.720 --> 02:12:51.200
<v Carl Friedrich>Ich wollte noch eine Sache erwähnen, das kam noch gar nicht vor in unserer Geschichte.

02:12:51.200 --> 02:12:58.640
<v Carl Friedrich>Es gibt tatsächlich noch einen Bereich, wo sehr, sehr viel Aktivität gerade noch stattfindet im so weiteren PiPi-Umfeld.

02:12:58.640 --> 02:13:02.800
<v Carl Friedrich>Und da bin ich auch nicht so ganz direkt beteiligt, aber das ist meiner Ansicht nach auch schon sehr interessant.

02:13:02.800 --> 02:13:07.760
<v Carl Friedrich>Und das ist nämlich genau die Frage nach in C geschriebenen Bibliotheken.

02:13:07.760 --> 02:13:10.640
<v Carl Friedrich>Und das Projekt heißt HPy.

02:13:10.800 --> 02:13:25.440
<v Carl Friedrich>Und das ist ein relativ gut finanziertes, eigenes Open Source-Projekt, was quasi als Idee hat, dass sie eine Next Generation C-API für Python entwickeln.

02:13:26.000 --> 02:13:36.400
<v Carl Friedrich>Und die C-API, die es eben jetzt bisher gibt, die ist halt in gewisser Weise so organisch gewachsen aus C-Python raus.

02:13:36.400 --> 02:13:46.720
<v Carl Friedrich>Weil das ist ja einfach, wenn man die CAPI benutzt, dann greift man einfach direkt auf die Datenstrukturen zu, die C-Python halt einfach zufällig hat.

02:13:46.720 --> 02:13:52.560
<v Carl Friedrich>Und wenn man eine andere Implementierung schreiben will und die ist anders, dann hat man ein Problem, weil dann passt es halt nicht zusammen.

02:13:52.800 --> 02:14:06.800
<v Carl Friedrich>Und HPA ist halt die Idee, wir fangen einfach so einem nicht ganz auf dem Reißfall, aber wir machen einfach nochmal drei Schritte zurück und wir überlegen uns, wie würde denn eine API in C aussehen, wenn man sie jetzt nochmal neu machen würde.

02:14:06.800 --> 02:14:12.960
<v Carl Friedrich>Und da gibt es schon auch dann, also das ist jetzt, das ist quasi noch in der Mache.

02:14:12.960 --> 02:14:19.600
<v Carl Friedrich>Es gibt quasi, es ist irgendwie Version 0,04 raus oder so oder die wollen jetzt irgendwann bald mal zu M1.0 kommen.

02:14:19.600 --> 02:14:27.360
<v Carl Friedrich>Aber da ist halt wirklich die Idee, wie würde man eine API designen, die für alle Implementierungen für Python gleichermaßen funktioniert.

02:14:27.360 --> 02:14:29.360
<v Carl Friedrich>Und die hat ein paar sehr interessante Eigenschaften.

02:14:29.360 --> 02:14:34.240
<v Carl Friedrich>Zum Beispiel, die ist halt absolut ABI-kompatibel.

02:14:34.240 --> 02:14:36.480
<v Carl Friedrich>Du musst vorwärts kompatibel.

02:14:36.480 --> 02:14:40.880
<v Carl Friedrich>Du musst niemals neue Share-Libraries kompilieren.

02:14:40.880 --> 02:14:50.720
<v Carl Friedrich>Du kannst die, die Idee ist, dass man quasi so ein bisschen Windows-mäßig unendlich lange in die Zukunft alle alten Share-Libraries weiterbenutzen kann.

02:14:50.720 --> 02:14:52.720
<v Carl Friedrich>Das ist eines der Design-Ziele.

02:14:52.720 --> 02:15:02.480
<v Carl Friedrich>Ein anderes Design-Ziel ist, dass man den Debugging-Mode anschalten kann für den C-Code, ohne dass man neu kompilieren muss.

02:15:02.480 --> 02:15:09.600
<v Carl Friedrich>Sondern quasi zur Import-Zeit kannst du sagen, hier ist irgendein komischer Crash, mach mal bitte den Debugging-Mode an.

02:15:09.600 --> 02:15:16.800
<v Carl Friedrich>Und dann findet er zum Beispiel ein Reference-Counting-Probleme in der C-Bibliothek, ohne dass man die neu kompilieren muss.

02:15:16.800 --> 02:15:19.360
<v Carl Friedrich>Das ist ein anderes, finde ich, sehr interessante Eigenschaft.

02:15:19.600 --> 02:15:26.240
<v Carl Friedrich>Und also die, das Coole ist, dass Oracle hat auch eine Python-Implementierung, die heißt GralPy.

02:15:26.240 --> 02:15:34.640
<v Carl Friedrich>Und die haben jetzt quasi zwei ihrer Entwickler oder zweieinhalb ihrer Entwickler dafür angestellt, sich eben zu überlegen, wie man dieses HPy-Ding designt.

02:15:34.640 --> 02:15:37.120
<v Carl Friedrich>Und da passiert also quasi so richtig was.

02:15:37.120 --> 02:15:42.960
<v Carl Friedrich>Und ich habe halt die Hoffnung, dass es jetzt irgendwann in diesem 2023 da die ersten Releases gibt.

02:15:42.960 --> 02:15:54.800
<v Carl Friedrich>Und das ist schon auch so, dass es quasi jetzt das Portieren von der existierenden API auf HPI nicht ganz automatisiert werden kann, aber vielleicht so ein bisschen.

02:15:54.800 --> 02:16:05.360
<v Carl Friedrich>Also das ist jetzt auch an allen Stellen, wo man quasi an der alten API dranbleiben kann, haben sie versucht, sich an der existierenden API zu orientieren, um das Portieren eben möglich zu machen.

02:16:05.360 --> 02:16:15.440
<v Carl Friedrich>Und nur an den Stellen, wo das eben nicht ging, ohne die Ziele zu gefährden, haben sie dann eben sich in Team davon abzuweichen.

02:16:15.440 --> 02:16:19.280
<v Carl Friedrich>Naja, also auf jeden Fall, wie gesagt, ich bin da nicht mit involviert.

02:16:19.280 --> 02:16:20.480
<v Carl Friedrich>Ich rede manchmal mit denen.

02:16:20.480 --> 02:16:25.760
<v Carl Friedrich>Einer der GalPi-Tech-Lead ist ein guter Freund von mir, wir telefonieren dann ab und zu.

02:16:25.920 --> 02:16:34.160
<v Carl Friedrich>Aber ich bin halt sehr hoffnungsvoll, dass das bald mal ein Release gibt und vielleicht auch vielleicht in Scythe Supporter eingebaut wird.

02:16:34.160 --> 02:16:35.600
<v Carl Friedrich>Das wäre sehr, sehr cool.

02:16:35.600 --> 02:16:43.680
<v Carl Friedrich>Und das würde eben dazu führen, dass in Zukunft Extensions, die HPI benutzen, halt auch wirklich schnell auf PyPy sind.

02:16:43.680 --> 02:16:51.200
<v Carl Friedrich>Und dann hätten wir unser, also es gibt dann ganz, ganz viele Fliegen, die mit einer Klappe geschlagen würden.

02:16:51.200 --> 02:16:59.600
<v Carl Friedrich>Unter anderem eben möglicherweise, dass es effizient in PiPy ist, dass es effizient in GradPy ist, trotzdem nicht langsamer ist auf C-Python.

02:16:59.600 --> 02:17:17.760
<v Carl Friedrich>Und der Übergang zum vorigen Thema ist jetzt, dass ich gerade auch, soweit ich das verstehen kann, so ein bisschen anfangen darüber nachzudenken, ob man denn da auch die Jill-Änderungen, die nötig würden für die C-Extensions, auch noch mit unterbringen könnte.

02:17:17.760 --> 02:17:19.760
<v Carl Friedrich>Und das wäre halt sehr, sehr cool.

02:17:19.760 --> 02:17:22.800
<v Jochen>Weil das würde dann direkt funktionieren, ohne dass man da nochmal was ändern müsste.

02:17:22.880 --> 02:17:23.360
<v Carl Friedrich>Ganz genau.

02:17:23.360 --> 02:17:42.160
<v Carl Friedrich>Und dann, wenn dann eine Extension quasi in der Situation kommt, dass sie jetzt ganz viel anpassen müsste, um mit dem Jill zu funktionieren, dann könnte die halt sagen, na gut, dann gehen wir halt vielleicht gleich zu dieser neuen API, nehmen noch einen ganzen Haufen andere Benefits mit und sind aber trotzdem auch kompatibel zu den neuen Jill-Features.

02:17:42.160 --> 02:17:53.760
<v Carl Friedrich>Also das, ich bin mir nicht sicher, ob die das schaffen und ich weiß auch nicht, also bei so Funding durch Firmen, da kann halt auch mal passieren, dass ein Manager sagt, so brauchen wir nicht mehr.

02:17:53.760 --> 02:17:54.880
<v Carl Friedrich>So genau.

02:17:55.200 --> 02:17:56.720
<v Carl Friedrich>Aber das wäre halt cool.

02:17:57.360 --> 02:18:04.080
<v Carl Friedrich>Also das ist ein Projekt, was ich sehr exciting finde und wo ich hoffe, dass da in diesem Jahr halt noch viel passieren wird.

02:18:04.080 --> 02:18:10.640
<v Carl Friedrich>Wir haben leider, also wir haben kein offizielles Buy-In von C-Python.

02:18:10.640 --> 02:18:20.640
<v Carl Friedrich>Also es gibt einige C-Python-Entwickler, die quasi sehr wohlwollend sind, aber wir haben quasi kein offizielles Endorsement.

02:18:21.920 --> 02:18:32.400
<v Carl Friedrich>Sind immer mal ein bisschen am überlegen, ob es ein sinnvolles PEP gibt, also ich habe jetzt wie gesagt, ich bin ich als interessierter Beobachter bin nicht wirklich, also ich schreibe kein Counter für, aber ja.

02:18:32.400 --> 02:18:38.160
<v Carl Friedrich>Also die AP-Leute denken auch immer mal darüber nach, was man für ein PEP schreiben könnte und was da.

02:18:38.160 --> 02:18:41.840
<v Carl Friedrich>Es ist halt gar nicht so ganz klar, was man von C-Python wollen würde.

02:18:42.160 --> 02:18:48.800
<v Carl Friedrich>Weil es ist jetzt, die wollen halt nicht sagen, die wollen nicht die Designverantwortung wieder an C-Python zurückgeben.

02:18:48.800 --> 02:18:55.760
<v Carl Friedrich>Also eines der Vorteile ist eben gerade, dass es ein externes Team ist, was das komplett unabhängig von C-Python macht.

02:18:55.760 --> 02:19:03.200
<v Carl Friedrich>Und deswegen, das soll jetzt nicht irgendwie wieder C-Python untergeordnet werden, so als Projekt.

02:19:03.200 --> 02:19:07.360
<v Carl Friedrich>Aber deswegen ist halt auch gar nicht so klar, was ist das Ergebnis dieses PEPs.

02:19:07.360 --> 02:19:13.040
<v Carl Friedrich>Ist das irgendwie ein reines, also dieses hypothetisch noch nicht geschriebene Pap, ist es ein reines Informations-PEP hier?

02:19:13.040 --> 02:19:19.360
<v Carl Friedrich>Wir arbeiten daran, nehmt uns wahr und also ja, da denken wir halt wissen.

02:19:19.440 --> 02:19:29.280
<v Carl Friedrich>Also es gibt den Wukash Langer, der auch von Vollzeit an über die PSF an TWAS arbeitet.

02:19:29.280 --> 02:19:34.320
<v Carl Friedrich>Der war auch bei dem HP Sprint im September hier in Düsseldorf.

02:19:34.320 --> 02:19:41.440
<v Carl Friedrich>Also der ist auch ein Core Dev, der informiert und involviert und wohlwollend ist.

02:19:43.040 --> 02:19:52.720
<v Carl Friedrich>Aber so von den Hardcore-Performance-Leuten gibt es jetzt quasi keine offizielle Aussage, dass sie das irgendwie toll finden wollen.

02:19:52.720 --> 02:19:53.840
Aber ja, also.

02:19:53.840 --> 02:19:54.400
<v Carl Friedrich>Na genau.

02:19:54.400 --> 02:19:58.880
<v Carl Friedrich>Aber ich hoffe halt, dass da jetzt in diesem Jahr halt noch ein paar interessante Sachen passieren.

02:19:59.520 --> 02:20:01.680
<v Jochen>Oh, interessant, ja.

02:20:02.080 --> 02:20:05.360
<v Jochen>Ja, ich meine, gerade mir sagt das gar nicht so viel.

02:20:05.360 --> 02:20:11.040
<v Jochen>Ich weiß nicht, ob ich, ich glaube, ich habe es nicht mal gehört, dass es da noch einen Interpreter für Python gibt.

02:20:11.280 --> 02:20:12.720
<v Jochen>So viele sind ja auch nicht mehr übrig.

02:20:12.960 --> 02:20:18.080
<v Jochen>Joton, Iron Python ist alles nicht mehr so nicht mehr so richtig da.

02:20:18.160 --> 02:20:20.160
<v Jochen>An Laden Swallow gab es auch besonders.

02:20:20.320 --> 02:20:21.360
Ah, das ist lange tot.

02:20:22.560 --> 02:20:27.760
<v Jochen>Ja, äh, PiPi ist so eine der ganz wenigen, die überleben kriegt.

02:20:28.080 --> 02:20:28.480
<v Carl Friedrich>Ja, genau.

02:20:28.480 --> 02:20:29.520
<v Carl Friedrich>Also CalPy halt auch.

02:20:29.520 --> 02:20:35.360
<v Carl Friedrich>Also Cradfy hat halt wirklich ein Team, die sind auch bezahlt und die haben da von der Funding-Situation sind die ziemlich gut.

02:20:35.600 --> 02:20:41.520
<v Carl Friedrich>Die haben so ein paar, deren JIT ist auch ziemlich gut, die können wirklich schnell einen Python-Code ausführen.

02:20:41.520 --> 02:20:48.400
<v Carl Friedrich>Die haben so ein bisschen das Problem, dass es nur, also dass ihre Warm-up-Zeit sehr lange dauert.

02:20:48.400 --> 02:20:51.440
<v Carl Friedrich>Also der Code wird halt erst nach vielen Minuten schnell.

02:20:51.600 --> 02:20:55.280
<v Carl Friedrich>Und das heißt, du brauchst halt die richtige Art von Anwendung.

02:20:55.280 --> 02:20:58.160
<v Carl Friedrich>Also so Longrunning Server Processes funktionieren super.

02:20:58.160 --> 02:21:02.320
<v Carl Friedrich>Aber wenn du alle fünf Minuten deployst, dann halt nicht mehr.

02:21:03.840 --> 02:21:05.120
<v Carl Friedrich>Aber da kommen die auch noch hin.

02:21:05.120 --> 02:21:06.000
Also die haben halt Geld.

02:21:06.000 --> 02:21:07.040
Das im Moment.

02:21:07.040 --> 02:21:10.320
<v Carl Friedrich>Das ist halt für eine Implementierung eine sehr angenehme Situation.

02:21:10.320 --> 02:21:11.760
<v Carl Friedrich>Und der Tim weiß auch, was er tut.

02:21:11.760 --> 02:21:14.560
<v Carl Friedrich>Er ist sehr, sehr gut.

02:21:14.560 --> 02:21:18.480
<v Carl Friedrich>Also Tim Felgengraff heißt der Tech-Lied.

02:21:18.480 --> 02:21:29.200
<v Carl Friedrich>Und die sind, glaube ich, auch 31 kompatibel und supporten C-Extensions und also das ist schon eine sehr ernstzunehmende Implementierung.

02:21:30.160 --> 02:21:31.360
<v Jochen>Ja, cool.

02:21:32.560 --> 02:21:35.600
<v Dominik>Warum schreibt man sich sowas dann direkt in Rust E, statt in C

02:21:35.600 --> 02:21:36.400
neu zu schreiben?

02:21:36.400 --> 02:21:38.320
<v Carl Friedrich>Die schreiben das in Java neu.

02:21:38.480 --> 02:21:48.080
<v Carl Friedrich>Also gerade, wir wollen da, ich glaube, da steigen wir jetzt nicht ein, aber gerade ist so ein bisschen die Piper-Idee nochmal in mit Geld.

02:21:48.480 --> 02:22:14.480
<v Carl Friedrich>Also halt von Oracle, deswegen haben die, die haben einen R-Java, also die können quasi ihren Java-Code nach C übersetzen und haben den JIT-Compiler in C geschrieben und die haben auch diesen selben, technisch funktioniert das ein bisschen anders, aber die haben ja auch so eine ähnliche Motivation, die haben so einen Meta-JIT-Ansatz, dass sie quasi kein JIT schreiben, sondern den JIT auch generieren aus einem Interpreter mit einer anderen Technik, aber halt so von der Motivation her ist das recht ähnlich.

02:22:14.880 --> 02:22:28.480
<v Carl Friedrich>Und die benutzen das halt, also die haben halt irgendwie einen schnellen JavaScript-Implementierung und ein schnelles Python und natürlich irgendwie auch ein schnelles Java und ja, und das ist ein riesen Team, das muss man halt auch.

02:22:28.480 --> 02:22:34.320
<v Carl Friedrich>Also die haben halt eine zweistellige Anzahl an Leuten, die halt an diesem Zeug arbeiten.

02:22:34.480 --> 02:22:40.400
<v Carl Friedrich>Und ist in gewisser Weise auch irgendwie sehr forschungslastig, das Projekt.

02:22:40.400 --> 02:22:43.680
<v Carl Friedrich>Das ist auch eine große, also ich würde sagen, es ist von Oracle eine große Wette.

02:22:43.680 --> 02:22:49.040
<v Carl Friedrich>Also mir ist nicht so, also ich glaube, im Moment verdient das Team halt kein Geld.

02:22:49.280 --> 02:22:57.120
<v Carl Friedrich>Also das ist halt die Hoffnung, dass es irgendwann mal dann vielleicht doch Geld verdient, aber ich glaube, im Moment ist das halt wirklich eine Wette.

02:22:57.120 --> 02:22:58.480
<v Carl Friedrich>Und auch, die läuft auch schon lang.

02:22:58.480 --> 02:23:00.160
<v Carl Friedrich>Also das Projekt ist irgendwie zehn Jahre alt oder so.

02:23:00.160 --> 02:23:05.760
<v Carl Friedrich>Also so irgendwie 30 Leute über zehn Jahre anzustellen, das ist halt, das ist halt richtig teuer.

02:23:08.400 --> 02:23:17.520
<v Carl Friedrich>Naja, aber also da weiß ich, also was da die Motivationen von so einer Firma sind, das weiß man halt immer nicht.

02:23:18.320 --> 02:23:20.560
<v Carl Friedrich>Kann man halt dann munter spekulieren.

02:23:20.560 --> 02:23:23.200
Das mache ich natürlich auch immer gern, aber ja, also ja.

02:23:24.880 --> 02:23:29.680
<v Carl Friedrich>Also das ist quasi so ein bisschen friendly competition, aber also mit Betonung auf friendly.

02:23:31.200 --> 02:23:34.480
<v Dominik>Aber nochmal die Frage, warum sowas nicht in Rust irgendwie geschrieben wird, jetzt so ein neuer Link?

02:23:35.520 --> 02:23:45.920
<v Carl Friedrich>Mir ist noch nicht so ganz klar, also es ist so ein bisschen so eine grundsätzliche Frage, in welcher Sprache implementiert man seinen Jit?

02:23:46.240 --> 02:23:50.160
<v Carl Friedrich>Und die klassische Antwort ist halt C oder C&lt;unk&gt;.

02:23:50.480 --> 02:24:10.480
<v Carl Friedrich>Und es gibt jetzt verschiedene so forschungsaffine Projekte, wie Squeak, ganz klassischerweise, oder eben PyPy oder GralPy, die halt sagen, es ist doch eigentlich viel cooler, wenn man eine Sprache, eine Implementierungssprache nimmt, die halt irgendwie ein höheres Abstraktionslevel hat als C.

02:24:10.480 --> 02:24:18.080
<v Carl Friedrich>Weil C ist halt doof und nicht Memory-Safe und stürzt die ganze Zeit ab und man kann auch nicht schön abstrahieren und deswegen ist C halt keine schöne Sprache.

02:24:18.400 --> 02:24:21.600
<v Carl Friedrich>Und genau, das sind dann die genannten Projekte.

02:24:21.600 --> 02:24:29.120
<v Carl Friedrich>Und jetzt ist so ein bisschen die Frage, ob Rust eine gut geeignete Sprache ist, um JIT-Compiler zu schreiben.

02:24:29.120 --> 02:24:31.280
<v Carl Friedrich>Und ich glaube, das weiß einfach noch keiner.

02:24:31.600 --> 02:24:37.520
<v Carl Friedrich>Also es gibt genau ein großes JIT-Projekt, was Rust benutzt.

02:24:37.520 --> 02:24:44.400
<v Carl Friedrich>Das ist, habt ihr auch, glaube ich, in einer Folge darüber geredet, das ist dieses der neue JIT für Ruby, der von Shopify finanziert ist.

02:24:45.040 --> 02:24:55.200
<v Carl Friedrich>Es gibt übrigens auch ein großes Gral Ruby-Projekt, also das heißt Truffle Ruby, das auch von Shopify zum Teil finanziert wird.

02:24:55.200 --> 02:24:59.120
<v Carl Friedrich>Also die leisten sich mehrere eigene Ruby-Information.

02:25:02.640 --> 02:25:05.520
<v Carl Friedrich>Und das eben, heißt es YJIT?

02:25:06.800 --> 02:25:07.920
<v Jochen>Ja, ich

02:25:07.920 --> 02:25:17.760
<v Carl Friedrich>bin der ist eben in Rust geschrieben und ich glaube, die Jury ist halt noch so ein bisschen out, ob das wirklich die richtige Sprache für den JIT ist.

02:25:17.760 --> 02:25:26.880
<v Carl Friedrich>Und mit der, also die Maxim Chevalier Vois, die das gestartet hat, Wiget bei Shopify, mit der zoome ich auch auf und zu.

02:25:26.880 --> 02:25:28.960
<v Carl Friedrich>Die ist auch extrem gut.

02:25:31.440 --> 02:25:39.440
<v Carl Friedrich>Aber was da, also was da ihre Conclusion wäre, ist Rust die richtige Sprache, um so einen JIT-Compiler zu schreiben, das weiß ich jetzt.

02:25:39.440 --> 02:25:40.880
Also das weiß ich noch nicht.

02:25:40.880 --> 02:25:46.560
<v Carl Friedrich>Ich glaube, das weiß halt, das weiß man dann, das kann man erst so ein bisschen abschließen, beurteilen nach dem dritten JIT vielleicht.

02:25:46.560 --> 02:25:49.760
<v Carl Friedrich>Oder ja, also das.

02:25:49.760 --> 02:26:00.240
<v Carl Friedrich>Also wenn man halt dann Rust nimmt, dann muss man sich halt klar machen, dass man sich da auf noch nicht ganz verstandenes Terrain bewegt.

02:26:00.240 --> 02:26:07.760
<v Carl Friedrich>Also ich meine, C&lt;unk&gt; ist halt so die akzeptierteste Sprache, um virtuelle Maschinen zu schreiben.

02:26:07.760 --> 02:26:09.440
<v Carl Friedrich>Und das muss man jetzt nicht gut finden.

02:26:09.440 --> 02:26:12.080
<v Carl Friedrich>Also ich persönlich finde es halt vielleicht nicht so gut.

02:26:12.080 --> 02:26:17.040
<v Carl Friedrich>Aber das ist halt die Sprache, ich meine, das ist auch die Sprache, in der man halt in der Regel einen Compiler schreibt.

02:26:19.520 --> 02:26:28.400
<v Carl Friedrich>Und wenn man irgendwas anderes nimmt, dann muss man sich halt klar machen, dass man, dann ist man plötzlich für sich selbst verantwortlich.

02:26:28.400 --> 02:26:32.000
<v Carl Friedrich>Also da muss man mit seinen eigenen Konsequenzen leben.

02:26:35.120 --> 02:26:36.320
<v Carl Friedrich>Also ja, ich weiß es nicht.

02:26:36.320 --> 02:26:51.440
<v Carl Friedrich>Ich habe keine, ich ist halt so ein bisschen die Frage, an welcher Stelle, an welcher Stelle würde die extra Safety von Rust, wäre die gewinnbringend im Compiler.

02:26:51.440 --> 02:27:02.560
<v Carl Friedrich>Weil das, was halt an einem so einem Divid Compiler dangerous und scary ist, ist halt nicht, dass der selber in einer Unsafe-Sprache geschrieben ist.

02:27:02.560 --> 02:27:03.840
<v Carl Friedrich>Das ist natürlich auch ein Problem.

02:27:04.080 --> 02:27:05.600
<v Carl Friedrich>Das ist nicht das primäre Problem.

02:27:05.600 --> 02:27:08.160
<v Carl Friedrich>Das primäre Problem ist, dass man selber Maschinencode erzeugt.

02:27:08.160 --> 02:27:09.120
Und der darf halt nicht falsch sein.

02:27:09.200 --> 02:27:10.320
Der darf halt nicht falsch sein.

02:27:10.320 --> 02:27:13.120
<v Carl Friedrich>Aber bei diesem Problem nützt, bringt einmal Rust auch nichts.

02:27:13.120 --> 02:27:21.680
<v Jochen>Ja, weil Rust dann ist der Compiler, dann ist der Ding, in dem man den JIT-Compiler schreibt, ist dann halt, das geht halt nicht kaputt.

02:27:21.760 --> 02:27:27.520
<v Jochen>Genau, die beim Interpretieren deines Interpreters ja irgendwas anderem geschrieben ist, aber wenn der falschen Code erzeugt, dann ist er immer noch schlecht.

02:27:28.720 --> 02:27:33.760
<v Carl Friedrich>Das ist halt gewisserweise ein Logik-Bug und kein Memory Safety-Bug.

02:27:33.760 --> 02:27:34.320
<v Jochen>Ja.

02:27:34.320 --> 02:27:35.200
<v Jochen>Testen.

02:27:35.440 --> 02:27:35.920
Genau.

02:27:35.920 --> 02:27:41.520
<v Carl Friedrich>Es gibt, also irgendwann werde ich den Teil 2-Blogpost zu How is Panfi-Testet schreiben.

02:27:41.520 --> 02:27:42.880
<v Carl Friedrich>Der ist auch deutlich länger.

02:27:42.880 --> 02:27:44.480
<v Carl Friedrich>How is the Jit Tested?

02:27:44.720 --> 02:27:49.760
<v Carl Friedrich>Das ist nämlich wirklich auch nochmal so ein bisschen so ein richtig eigenes Forschungsfeld.

02:27:49.760 --> 02:27:52.320
<v Carl Friedrich>Und ich lerne da auch immer mal wieder was dazu.

02:27:52.320 --> 02:28:00.640
<v Carl Friedrich>Also gerade so im LFVM-Bereich, da wird ja auch dann unglaublich viel Fuzzing gemacht und da werden auf interessante Art und Weise Theorienbeweise eingesetzt.

02:28:00.640 --> 02:28:06.560
<v Carl Friedrich>Und da gibt es halt wirklich dann Forschungsgruppen, die nichts anderes machen, als sich darüber Gedanken zu machen, wie man so einen Compiler testet.

02:28:06.560 --> 02:28:12.480
<v Carl Friedrich>Und im Herbst habe ich halt dann wirklich so eine neue Technik dann mal ausprobiert, wie man mit so einem Theorienbeweiser halt Bugs findet.

02:28:12.480 --> 02:28:15.680
<v Carl Friedrich>Und ja, da haben wir halt auch dann drei Jitbugs gefunden.

02:28:15.680 --> 02:28:18.000
<v Carl Friedrich>Also das war echt ganz interessant.

02:28:18.000 --> 02:28:21.680
<v Carl Friedrich>Und da gibt es halt so einen Prof in Utah, John Drigger heißt er, der schreibt da Paper drüber.

02:28:21.680 --> 02:28:32.720
<v Carl Friedrich>Und nachdem ich genügend Paper von dem gelesen und mit ihm lang genug auf Twitter geschrieben hatte, habe ich dann halt mal das auch selber ausprobiert und das hat halt wirklich dann Bugs gefunden.

02:28:36.720 --> 02:28:37.760
<v Jochen>Cool.

02:28:37.760 --> 02:28:39.200
Interessant.

02:28:39.200 --> 02:28:39.920
<v Jochen>Jo.

02:28:39.920 --> 02:28:40.880
Pi Pi.

02:28:41.200 --> 02:28:41.760
Ja, sorry.

02:28:42.000 --> 02:28:42.880
Das texte euch zu.

02:28:43.120 --> 02:28:46.240
<v Jochen>Nee, das ist voll, das ist, genau, deswegen sind wir ja da.

02:28:48.080 --> 02:28:50.080
<v Carl Friedrich>Können wir jetzt bitte endlich schlafen gehen.

02:28:51.440 --> 02:28:52.640
Nein, so stimmt es noch.

02:28:53.360 --> 02:28:55.840
<v Carl Friedrich>Naja, reden ist halt auch Teil meines Jobs.

02:28:56.400 --> 02:28:56.960
<v Jochen>Ja, ja, nee.

02:28:57.040 --> 02:28:58.320
<v Jochen>Also ich finde das total interessant.

02:29:00.640 --> 02:29:05.200
<v Jochen>Ja, ich überlege nur gerade, ob wir noch irgendwo ein großes Thema vergessen haben, aber ich glaube nicht.

02:29:05.360 --> 02:29:07.040
<v Dominik>Ich glaube, wir haben tatsächlich das meiste so durch.

02:29:07.280 --> 02:29:10.160
<v Carl Friedrich>Ich habe auch einen guten, ich habe das Gefühl, wir haben ja einen guten Rundumschlag gemacht.

02:29:10.880 --> 02:29:12.800
<v Dominik>Ja, vielen Dank, Kai, dass du da warst.

02:29:13.440 --> 02:29:15.280
<v Carl Friedrich>Es macht natürlich auch wirklich Spaß.

02:29:16.240 --> 02:29:21.280
<v Jochen>Ja, merkt man auch, merkt man sofort, dass das da ganz viel.

02:29:21.360 --> 02:29:23.040
<v Dominik>Also falls ihr mitmachen wollt, wie gesagt.

02:29:29.360 --> 02:29:33.440
<v Carl Friedrich>Also es gibt natürlich schon so ein paar, ich will es jetzt nicht zu schlecht reden, es gibt so ein paar Hürden.

02:29:33.520 --> 02:29:40.240
<v Carl Friedrich>Wir haben Python 2, wir sind in Mercurial, wir sind nicht auf GitHub, wir sind auf so einem, wir sind einem Fork von GitLab, der auch mit Mercurial geht.

02:29:40.240 --> 02:29:52.640
<v Carl Friedrich>Also es gibt so ein paar Nervigkeiten beim Einstieg, aber es ist in gewisser Weise halt so ein bisschen auch die netteste Python-Implementierung, bei der man einsteigen kann, weil man halt Python schreibt.

02:29:52.800 --> 02:29:58.080
<v Carl Friedrich>Und man nimmt halt Pytest und man schreibt PiTest und man kann halt irgendwie seinen Debugger nehmen.

02:29:58.080 --> 02:30:10.480
<v Carl Friedrich>Und man kann halt die ganzen Tools, die man kennt, Python 2 ist da so ein bisschen doof, aber also die ganze Arbeitsweise, die man halt kennt, wenn man sowieso schon Python kann, die kann man benutzen, um da drin rumzuhacken.

02:30:10.480 --> 02:30:12.880
<v Carl Friedrich>Und das macht halt auch ein Stück weit einfach Spaß.

02:30:13.040 --> 02:30:24.000
<v Carl Friedrich>Also man ist halt nicht in GDB und man hat halt keinen Stackfault, sondern man kriegt halt erstmal einfach einen ganz normalen Python-Stack-Trace, der einem sagt, in deinem Interpreter hast du jetzt hier einen Fehler gemacht.

02:30:24.000 --> 02:30:29.520
<v Carl Friedrich>Und man schreibt halt einen Unit-Test einfach in Python, der die Datenstrukturen des Interpreters halt auch einfach testen kann.

02:30:29.520 --> 02:30:34.960
<v Carl Friedrich>Und das ist halt auch, also ich finde das immer noch auch sehr, sehr cool.

02:30:34.960 --> 02:31:02.000
<v Carl Friedrich>Und deswegen, ich glaube, so, wenn man sich halt für das Gebiet überhaupt so ein bisschen grob interessiert, wie funktioniert eine Programmiersprache oder wie funktioniert so ein Bytecode-Interpreter oder irgendwann dann auch, wie funktioniert so ein JIT, ist das schon auch ein Projekt, wo man halt im Vergleich zu, ich lerne jetzt erstmal C&lt;unk&gt; für ein Jahr, und es ist ja dann auch vielleicht in so einer virtuellen Maschine auch komisches C&lt;unk&gt;, wo man dann doch auch recht leicht irgendwie reinkommen kann.

02:31:02.000 --> 02:31:13.360
<v Carl Friedrich>Und ich, also ich sag das auch immer mal wieder, wenn sich da halt jemand für interessiert und dann da gerne was machen möchte, ich mache da auch gerne immer Mentoring.

02:31:13.600 --> 02:31:15.520
<v Carl Friedrich>Das ist halt auch Teil meines Jobs.

02:31:15.680 --> 02:31:20.320
<v Carl Friedrich>Ich betreue halt irgendwie Studenten, die da dann auch drin arbeiten als Teil ihrer Arbeiten.

02:31:20.320 --> 02:31:27.360
<v Carl Friedrich>Also insofern weise ich halt dann, also habe ich quasi viel Übung in Onboarding und das ist auch was, was mir Spaß macht.

02:31:27.360 --> 02:31:50.000
<v Carl Friedrich>Also wenn sich jemand jetzt für irgendwas konkret interessiert, also es gibt Themen verschiedenster Art, dann kann man sich immer gerne bei uns melden und ich zoome dann immer gerne auch mit Leuten und mache so ein bisschen Pair-Programming beim Einstieg, damit man halt einfach so ein bisschen, also so die erste Stunde in einem neuen Projekt ist ja immer die schlimmste.

02:31:50.160 --> 02:31:52.320
<v Carl Friedrich>Also man weiß halt nicht, man findet halt nichts.

02:31:52.560 --> 02:31:53.920
<v Dominik>Wo ist man da jetzt gelandet?

02:31:53.920 --> 02:31:54.320
<v Carl Friedrich>Ja, genau.

02:31:54.320 --> 02:31:55.840
<v Carl Friedrich>Was ist denn das hier für ein Ordner?

02:31:55.840 --> 02:31:57.440
<v Carl Friedrich>Und wie startet das eigentlich?

02:31:57.440 --> 02:31:59.440
<v Carl Friedrich>Wo kriege ich eigentlich das Python 2 her, was ich brauche?

02:31:59.520 --> 02:32:00.880
Und wo geht es bei Tag essen?

02:32:00.880 --> 02:32:01.520
<v Carl Friedrich>Genau, ja.

02:32:01.520 --> 02:32:07.120
<v Carl Friedrich>Und das ist halt, also da versuche ich halt dann immer auf jeden Fall dann deutlich den Leuten halt auch zu helfen.

02:32:07.120 --> 02:32:10.000
<v Carl Friedrich>Und das ist auch was, was mir wirklich Spaß macht.

02:32:10.000 --> 02:32:13.360
<v Carl Friedrich>Also meldet euch und ja.

02:32:14.560 --> 02:32:15.200
<v Dominik>Ja, super.

02:32:15.200 --> 02:32:16.480
<v Jochen>Ja, klingt auf jeden Fall sehr gut.

02:32:16.480 --> 02:32:17.600
<v Dominik>Ja, vielen Dank.

02:32:17.600 --> 02:32:19.200
<v Jochen>Ja, wollen wir vielleicht noch Picks machen?

02:32:20.400 --> 02:32:27.280
<v Jochen>Ich hätte jetzt nur einen kleinen, der gar nicht, gar nichts mit sonst wie Dingen zu tun hat, über die wir gerade geredet haben.

02:32:27.280 --> 02:32:28.160
<v Dominik>Dann lassen wir es weiter weg.

02:32:28.160 --> 02:32:28.880
<v Jochen>Dann lassen wir es weg.

02:32:28.880 --> 02:32:29.600
<v Jochen>Okay, alles klar.

02:32:30.160 --> 02:32:31.760
<v Dominik>Ja, dann vielen Dank, dass ihr eingeschaltet habt.

02:32:31.760 --> 02:32:32.080
Ja.

02:32:34.000 --> 02:32:34.640
<v Jochen>Interessant diesmal.

02:32:34.640 --> 02:32:35.120
Danke sehr weiter.

02:32:35.520 --> 02:32:36.480
Danke für die Einladung.

02:32:36.480 --> 02:32:37.440
<v Dominik>Ja, danke.

02:32:37.600 --> 02:32:38.080
<v Jochen>Okay.

02:32:38.880 --> 02:32:39.440
Bis zum nächsten Mal.

02:32:39.440 --> 02:32:40.400
Tschüss, bis dann.
