Jochen: Oh, Jubiläum!
Johannes: Hallo zusammen und herzlichen Glückwunsch zur 60.
CF: Ja, vielen Dank, Hallo! Januar 23 haben wir gerade rekonstruiert.
Dominik: Ja, hallo liebe Hörerinnen und Hörer, willkommen im Python Podcast. Heute Jubiläumsepisode 60. Hi Jochen!
Dominik: Ja, hi auch an unsere Gäste. Lieber Johannes, dich kennt man schon.
Jochen: Herzlichen Glückwunsch und auch herzlich willkommen, Dominik!
Jochen: Ja, und auch, genau, ja, beziehungsweise, was ich, ja, genau, das, ja.
Dominik: Danke. Und lieber TF, auch dir. Hallo. Du warst ja auch schon mal da, habe ich noch in Erinnerung.
Johannes: Episode.
Johannes: Ich habe mich schon vor der Folge auf die 30.000 Abonnenten eingeladen.
Jochen: Ja.
Jochen: Genau.
Jochen: Ja.
Dominik: Ja, wir sprechen heute über Python 3.13. Und ich würde sagen, da legen wir auch direkt los.
CF: Wir haben ein paar Sachen vorgestellt, die wir noch nicht haben.
CF: Aber ich hoffe, es wird ein bisschen besser.
CF: Und ich hoffe, dass ihr euch auch ein bisschen mehr Zeit verbringt.
Dominik: Ich wollte gerade sagen, mit den News.
Jochen: Ja, wollen wir nicht, wollen wir noch News machen oder nicht?
Jochen: Also Python 3.13 ist, genau, das ist natürlich irgendwie schon ein wesentlicher News-Teil.
Dominik: Ja, das ist ein bisschen her, wir sind ein bisschen spät dran. Aber es ist vielleicht
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
Jochen: Ja, ansonsten.
Dominik: auch noch interessant. Es gibt ein paar schöne Sachen, die man darüber erzählen kann, oder?
Jochen: Ja, also wollen wir direkt Python 3.13, können wir auch direkt, weil so...
Dominik: Es war gar nicht so viel los, oder?
Jochen: Nee, sonst war auch nicht so viel los, stimmt.
Dominik: Ja.
Jochen: Na, dann machen wir das doch direkt, ja.
Jochen: Okay.
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
Jochen: Ich hab's jetzt auch schon überall irgendwie installiert, wo ich irgendwie Projekte angefasst habe und es funktioniert super.
Jochen: Und genau, ja, jetzt haben wir da so einige Dinge, vielleicht fangen wir einfach tatsächlich mit der neuen REPL an.
CF: Und ich hoffe, dass ihr euch ein bisschen mehr Zeit verbringt.
Jochen: Irgendwie, die halt aus dem PyPry-Projekt übernommen wurde und, ja.
Dominik: Ja, also nutzt ihr schon 3.13? Alle? Außer Jochen? Das ist natürlich ein Spezialfall.
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
Jochen: Ja, so eine Read-Eval-Print-Loop, irgendwie das, was man bekommt, wenn man einfach nur Python eingibt und unterdrückt.
Jochen: Ah.
Jochen: [Lachen]
Dominik: Warum nicht Beep heißen?
Jochen: [Lachen]
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
Dominik: Vielen Dank.
Jochen: Ressourcen sinken in den Sinn der��men.
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
Dominik: Also ich find's auch toll, weil ich bin ja zu faul für iPricen und ich mach das eigentlich
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
Jochen: Ressourcen sinken in den Sinn der Massen.
Dominik: sonst nochmal klassisch und toll, endlich, bunt.
Jochen: Ressourcen sinken in den Sinn der Massen.
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
Jochen: [kein Ton]
Dominik: Ja, Back to the Future, das ist schon ein bisschen wie damals, ja.
Dominik: Aber schade, dass es nicht früher noch grün war oder so, aber, naja, ein echter Hacker
Dominik: und so.
Dominik: Ja, ich hab's auch.
Jochen: [kein Ton]
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
Dominik: Ja, ich hab's auch.
Jochen: [kein Ton]
Dominik: Ja, ich hab's auch.
Dominik: Ja.
Dominik: Ja, ich hab's auch.
Dominik: Cool, reicht, glaube ich, auch.
Dominik: Nicht? Warum steht denn das da?
Dominik: Für den Headmode.
Dominik: Schade.
Dominik: Adidas Qoocoo, den können wir direkt wieder in das Skript reinschreiben.
Dominik: Wie sagt man Dächle, Johannes?
CF: Genau. Es wird jetzt quasi nicht mehr nur gesagt, das ist in Zeile 5 der Fehler,
CF: sondern auch noch dieser Teil des Ausdrucks ist der Teil, der die Exception hervorgerufen hat.
CF: Und das wird jetzt auch noch farbig irgendwie anders dargestellt als der Rest der Zeile.
Dominik: Ja, auch sehr nützlich.
Dominik: Tatsächlich so ein bisschen readable und man muss sich erstmal gucken, wo ist denn jetzt der richtige Teil vom Traceback, sondern es ist irgendwie fürs Auge schneller.
CF: Das mit den Positionen, da habe ich das Feature quasi durch einen geschickten Tweet provoziert.
CF: Da habe ich nämlich einen Screenshot gefälscht, wo wir, also den hat es nie,
CF: das Feature hat es bei uns nicht gegeben, aber ich habe quasi einen fiktiven Traceback auf Twitter fingiert.
Dominik: Ja, ich glaube, das ist jetzt das richtige Teil.
CF: Und das hat dann dazu geführt, dass CYTN das wirklich entwickelt hat.
CF: Das fand ich etwas.
Dominik: Ja, ich glaube, das ist jetzt das richtige Teil.
CF: Also ich hatte schon so einen Plan, wie ich das irgendwann mal, wir haben das ja dann auch irgendwann gekriegt.
Dominik: Ja, ich glaube, das ist jetzt das richtige Teil.
CF: Aber CYTN hat uns dann halt einfach ganz schnell überholt und viel mehr Leute benutzen CYTN als auch anders.
Dominik: Ja, wo, wo, wo, Jochen?
CF: [Abspann]
Dominik: Ja.
CF: [Abspann]
Dominik: Ja, wo, wo, wo, Jochen?
CF: [Abspann]
Dominik: Er macht das Vorschlag, er versucht sich dran zu erinnern, was denn der Fehler schon sein könnte und versucht einen kleinen Hinweis dazu zu geben.
CF: Ich meine das wird halt in jeder Version jetzt gerade so ein bisschen verbessert.
CF: Es gibt schon über einige Versionen so ein festes Bestandteil von jedem C-Python Release,
CF: dass sie sich echt Mühe geben, noch so ein paar der schlechten Fehlermeldungen zu verbessern.
CF: Und ich unterrichte halt Python-Anfänger jedes Semester.
CF: Das macht schon echt einen Unterschied, ob da dann irgendwie halt Abkürzungen vorkommen,
Dominik: Ja, wo, wo, wo, wo, Jochen?
CF: die wir noch nie gehört haben oder einfach nur Syntax Error ohne irgendwas anderes steht
CF: und wir so ein bisschen raten müssen, was das Problem gewesen sein könnte.
CF: Und das mit den Vorschlägen, also wenn man sich halt vertippt, wenn man irgendwie einen Namen vertippt,
CF: das ist jetzt schon seit ein, zwei Versionen, dass sie da dann Vorschläge machen könnten,
CF: was halt der existierende Name mit der kleinsten Edit Distance ist.
CF: Und jetzt haben sie es eben noch zusätzlich hinzugefügt, dass es auch bei Keyword-Argumenten geht.
Dominik: Ja, wo, wo, wo, wo, Jochen?
CF: [KEYBOARD SPIELT]
Dominik: Ja, ich würde auch sagen, wenn die ganzen Bibliotheken umgezogen sind, die man sonst so nutzt, dann direkt kann nicht mehr so lange dauern.
Dominik: Wann zieht denn immer um, bei der 3.1 oder bei der Punkt 1 oder Punkt 3?
CF: [KEYBOARD SPIELT]
CF: Also du bist dann einer von denen, die dann die Bug-Reports machen, wenn was nicht geht.
CF: [KEYBOARD SPIELT]
Dominik: Ja, bei der Rest-Test-Software, den hast du ja noch nicht alles umgezogen.
Dominik: Hast du zumindest, ja.
Dominik: Ja, die Data-Transfer geht immer so ein bisschen langsam. Dann haben die immer diese Upper Boundaries in ihren Versionen drin und das nervt immer so ein bisschen.
CF: [KEYBOARD SPIELT]
CF: Weil ich auch da das Gefühl habe, dass eigentlich viele Bibliotheken sich da jetzt inzwischen echt Mühe geben
CF: und halt schon bei den Betas und Release Candidates gucken, ob es geht und dann schon.
Dominik: Ja.
CF: Also es ist jetzt nicht mehr so, dass es ein halbes Jahr dauert oder so.
CF: [KEYBOARD SPIELT]
Dominik: Ja, ich bin gespannt, wie lange es diesmal dauert, tatsächlich, ja.
CF: Wollen wir mit den großen Blöcken weitermachen oder willst du so ein paar der kleinen Sachen sammeln?
CF: [KEYBOARD SPIELT]
CF: Es gibt zwei Riesenblöcke.
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
CF: [KEYBOARD SPIELT]
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
Dominik: Ist das auch persistent?
Dominik: Oh, da muss man jetzt aufpassen, was man da jetzt eintippt.
CF: War da noch "Prince" ohne Klammern?
CF: [KEYBOARD SPIELT]
Dominik: Du meinst ja Snoogle.
CF: Erst JIT oder erst Threads? Dann machen wir JIT. Da habe ich mir Notizen.
CF: [KEYBOARD SPIELT]
CF: Also beides sind ja eigentlich Sachen, die ihr so im Hinblick habt.
Dominik: Vielleicht nochmal für alle Leute, die einsteigen, die noch gar keine Ahnung von Python haben, just in time. Was ist denn das und warum ist das interessant und warum ist das wichtig?
CF: [KEYBOARD SPIELT]
Dominik: Vielleicht nochmal so einen kurzen Aufzug lang und dann...
Dominik: Ja, das ist interessant.
CF: Also CPython ist ein Interpreter.
Jochen: [kein Ton]
Dominik: Ja, das ist interessant.
CF: Also der Python-Code, der ausgeführt wird, der wird erst nach Bytecode übersetzt.
CF: Und der Bytecode wird aber dann von einem in C geschriebenen Interpreter ausgeführt.
Dominik: Ja, das ist interessant.
CF: Und das gilt als nicht so schnell.
CF: Das ist einer der Gründe, warum Python den Ruf hat, nicht so super schnell zu sein.
Jochen: [kein Ton]
CF: Und seit ein paar Versionen gibt es da einiges an Arbeiten vom Fasta-Python-Team,
CF: was zum guten Teil von Microsoft bezahlt wird, das zu verbessern.
CF: Und was die machen, ist ein, immer noch auf dem Interpreter,
CF: aber sie verändern quasi die Bytecodes zur Laufzeit,
CF: in Abhängigkeit von den Typen, die in den Funktionen verwendet werden.
CF: Was dazu führt, dass, wenn ich an irgendeiner Stelle vor allem Integers benutze,
CF: dass dann für Integers angepasster Bytecode verwendet wird,
CF: was die Ausführung schneller macht.
CF: Und dieser Prozess hat in Reihe 11 angefangen.
CF: Und in jeder Version gibt es da eben so ein paar Verbesserungen.
CF: Und wenn man dann aber darüber noch hinaus will, dann muss man eben,
CF: oder was man dann eben machen kann, ist, nochmal zu einer anderen Technik greifen.
CF: Das ist der sogenannte Just-in-Time-Compiler.
CF: Und das ist eine Technik, die von allen schnellen JavaScript-Implementierungen
CF: oder auch von Java verwendet wird.
CF: Und da ist die Idee, dass man zur Laufzeit eben Maschinencode erzeugt
CF: für die Funktionen, die man gerade ausführen möchte.
CF: Und das hat den Vorteil, dass man, also der Grund, warum man das zur Laufzeit macht,
CF: ist, weil man erst zur Laufzeit die Typen weiß,
CF: die in der Python-Funktion gerade verwendet werden.
CF: Und dann kann man eben Code erzeugen, der dann speziell angepasst ist
Dominik: Ja, das ist interessant.
CF: auf die Arten und Weisen, wie die Funktionen, die man gerade ausführt,
CF: eben verwendet werden.
CF: [Stille]
CF: Genau. Also das ist der grundsätzliche Ansatz.
Dominik: Ja, das ist interessant.
CF: Man fängt eben an, das erstmal so mit dem Interpreter auszuführen
CF: und dabei macht man so ein bisschen Beobachtungen,
CF: was für Typen eben konkret verwendet werden,
CF: führt so ein paar Statistiken mit.
CF: Und nur wenn die Funktion besonders oft ausgeführt wird
CF: und man dann eben mit der Zeit so ein paar Informationen zusammen hat,
CF: wie die Typen so sind, dann fängt es sich an, quasi das so ein bisschen zu stabilisieren.
CF: Und das ist auch dann der Zeitpunkt, wo eben die Bytecodes umgeschrieben werden,
CF: quasi jetzt seit Version 3.11.
CF: Und jetzt, was jetzt neu ist in 3.13, ist, dass dann eben dieser zweite Schritt hinzukommt,
Dominik: Ja, das ist interessant.
CF: wo man dann eben nicht nur Bytecodes umschreibt
CF: und so dann für die Situation effizientere Bytecodes,
CF: sondern eben auch noch, und das ist komplett optional,
CF: also bisher in den Standard-Builds ist das Feature nicht drin,
CF: das ist eher so ein Feature-Outlook für zukünftige Versionen,
Dominik: Ja, das ist interessant.
CF: dass man eben CPython auch neu bauen kann
CF: mit so einem speziellen experimentellen Build-Time-Flag,
CF: was eben sagt, ich möchte jetzt gerne einen JIT-Compiler einbauen.
CF: Und dann wird eben zur Laufzeit dieser spezialisierte Bytecode genommen
CF: und daraus Maschinencode erzeugt.
CF: Und die Hoffnung ist, dass es dann eben noch schneller wird.
CF: In 3.13 ist das aber leider noch nicht der Fall.
CF: Also sie erzeugen quasi Maschinencode,
CF: aber der macht es halt nicht wirklich, das macht es doch ziemlich schneller.
CF: Das ist so ein bisschen die schlechte Nachricht.
CF: Aber das ist trotzdem okay, weil das Ziel ist quasi,
CF: das Fundament zu legen für Verbesserungen,
CF: die dann in den nächsten Versionen hoffentlich auch wirklich dazu führen,
Jochen: [kein Ton]
CF: dass halt dann CPython das Sachen schneller ausführen kann.
Jochen: [kein Ton]
CF: [kein Ton]
CF: Genau. Also so ganz kann man das nicht sagen.
CF: Also die Idee gibt es schon sehr lang.
CF: Also das ist ein sogenannter Template-JIT.
CF: Und da ist die Idee, dass man,
CF: also man hat ja dann diese spezialisierten Bytecodes,
CF: also sowas wie "add two integers" oder sowas.
CF: Und die Idee ist, dass man quasi für alle diese Bytecodes
CF: so ein bisschen Maschinencode vorbereitet,
CF: also zu dem Zeitpunkt, wo man CPython baut.
CF: Und das dann, den vorbereiteten Maschinencode, also diese Templates,
CF: die werden dann so zusammengruppiert.
CF: Und die Idee von einem Template-JIT, die ist relativ alt.
CF: Aber was jetzt neu ist, und das ist eben dieser Copy-and-Patch-Ansatz,
CF: ist die Art und Weise, wie diese Templates hergestellt werden.
CF: Und das ist eben die Einsicht von dem Copy-and-Patch-Ansatz.
CF: Das ist ein Doktorand in Kalifornien, glaube ich, Haurang-Zu.
CF: Und die Idee davon ist, dass man eben den C-Compiler benutzen kann,
CF: um diese Templates vorzubereiten.
CF: Und das hat viele Vorteile.
CF: Also man benutzt den C-Compiler,
CF: man hat so kleine Funktionen in C geschrieben,
CF: benutzt den C-Compiler, um die dann nach Maschinencode zu übersetzen.
CF: Und das bedeutet insbesondere, dass normalerweise,
CF: wenn man einen JIT schreibt, dann muss man halt anfangen,
CF: für verschiedene Maschinenarchitekturen,
CF: so ein Backend quasi von Null auf, erstmal zu bauen.
CF: Und das ist halt super aufwendig,
CF: gerade wenn man viele Architekturen unterstützen will,
CF: wie das ja bei C-Partien der Fall ist.
CF: Und die Idee von dem Copy-and-Patch-Ansatz ist,
CF: man benutzt den C-Compiler,
CF: um sich den Maschinencode erzeugen zu lassen
CF: und kopiert den dann so mit Memcopy quasi an die richtige Stelle,
CF: und patcht dann eben noch so ein paar Stellen,
CF: wo man dann irgendwelche Konstanten noch so
CF: in den erzeugten Maschinencode so reinpatchen kann.
CF: Und das so benutzt man linker Information.
CF: Das ist wirklich so ein relativ kreativer Ansatz,
CF: um halt mit vergleichsweise wenig Aufwand,
CF: also ohne so ein komplettes Backend schreiben zu müssen,
CF: trotzdem relativ schnell, relativ gut Maschinencode erzeugen kann.
CF: Genau, das ist auch so ein bisschen das Problem.
CF: Also man braucht dann genau die richtige LVM-Version.
CF: Und wenn man die nicht installiert hat,
CF: dann bringt einem auch die die Flag nicht.
Dominik: Ja, das ist interessant.
CF: Man kann es dann trotzdem nicht bauen.
CF: Ich habe es tatsächlich noch nicht geschafft, das zu bauen,
CF: weil ich irgendwie das richtige LVM noch nicht hatte oder was.
CF: Aber ich glaube, die arbeiten da jetzt,
CF: also ich glaube, auf dem C-Partien-Main-Branch
CF: ist das jetzt auch irgendwie gelöst.
Dominik: Ja, das ist interessant.
CF: Da werden halt dann Sachen schon eingecheckt,
CF: oder also man muss dann nicht mehr genau
CF: die richtige Point-Version von der LVM installieren.
CF: Aber habe ich jetzt noch nicht ausprobiert.
CF: Ja, also im Prinzip haben das die meisten optimierenden Compiler.
Dominik: Ja, das ist interessant.
CF: Die haben halt irgendwie so eine Zwischendarstellung,
CF: wo sie halt quasi diese benutzen, um Code zu optimieren.
CF: Und bei LVM ist die deswegen relativ sichtbar,
CF: weil sie halt gute Tools haben,
CF: um die dann in so eine ASCII-Syntax zu printen
CF: und auch wieder zu parsen und weiter zu verarbeiten.
CF: Ja, es ist schon, also es ist jetzt schon so ein bisschen legit in 3.13.
Dominik: Ja, das ist interessant.
CF: Das ist schon wirklich eher so, das sind so vorbereitende Arbeiten.
CF: Also die Hoffnung ist eben, dass das dann so in den nächsten Versionen,
CF: also ich meine, bisher ist das relativ unbefähigend.
CF: Wir haben einen JIT, der erzeugt ganz tollen Maschinencode,
CF: aber es wird halt nicht schneller.
CF: Also und es ist ja cool, aber halt irgendwie auch nutzlos.
Dominik: Ja, das ist interessant.
CF: Also warum sollte man es machen,
CF: wenn sich die Performance halt dadurch gar nicht ändert.
CF: Aber die Hoffnung ist eben,
CF: dass sie dann, wenn sie jetzt weitere Optimierungen einbauen
CF: und bei diesem Patching,
CF: da kann man noch so ein paar extra Instruktionen dann wegoptimieren.
CF: Das haben sie, glaube ich, jetzt auch im Main Repository
CF: auch schon gemacht und die Hoffnung ist,
CF: dass dann eben, wenn 3.14 dann da ist,
CF: dass erstens eben dann, dass sie so ein paar Bugs gefixt haben,
CF: weil hoffentlich eben ein paar Leute trotzdem
CF: den experimentellen JIT halt mal ausprobieren
CF: und dann vielleicht Bug Reports schicken
CF: und dass sie dann halt in der nächsten Version
CF: dann auch die Performance noch ein bisschen verbessern können.
CF: Und insgesamt finde ich den Antrag cool,
CF: weil er in Anbetracht der Tatsache,
CF: dass das T-Python-Team halt jetzt nicht so groß ist,
CF: was bezahlte Entwickler angeht.
CF: Ich finde es halt einen relativ pragmatischen Ansatz,
CF: wo sie ohne jetzt irgendwie,
CF: also was ich Google V8 hat,
CF: hat halt irgendwie, weiß nicht, 80 Leute oder so.
Dominik: Ja, das ist interessant.
CF: Und also dass sie halt quasi mit der kleinen Anzahl an Festangestellten
CF: halt trotzdem mit diesem Ansatz
CF: vielleicht irgendwie recht pragmatisch irgendwo hinkommen können.
CF: Vielen Dank.
CF: [Musik]
Dominik: Ja, das ist interessant.
CF: Untertitel der Amara.org-Community
CF: * Musik *
CF: Sehr viel kompliziert.
Dominik: Ja, das ist interessant.
CF: Nicht nur einen JIT, sondern drei oder vier.
CF: Also dann erstmal einen, der quasi schlechten Code sehr schnell erzeugt
CF: und dann etwas besser optimiert, sehr gut optimiert.
CF: Dann haben Sie noch einen komplett getrennten JIT für WebAssembly.
Dominik: Ja, das ist interessant.
CF: Das ist schon, und dann natürlich auch wirklich dann
CF: quasi richtige Backends für ganz viele verschiedene
CF: Hardware-Architekturen.
CF: Also das ist schon ein Aufwand, den meiner Ansicht nach
CF: mit dem jetzigen Funding das C Python Team erstmal so nicht
CF: hinkriegen kann.
CF: Ja, genau, das stimmt.
Dominik: Ja, das ist interessant.
CF: Das ist so ein kleines Ding. Es gibt drei neue Plattformen in 3.13.
CF: Ich glaube, irgendwie, die machen Aussagen darüber,
Dominik: Ja, das ist interessant.
CF: wie viele Buildboards sie haben und was sie so versprechen
CF: an Support genau über die Version.
CF: Da gibt es irgendwie ein PEP dazu.
CF: Ich glaube, eins ist am besten.
Dominik: Ja, das ist interessant.
CF: Ja.
CF: Ja, das stimmt.
Dominik: Ja, das ist interessant.
CF: * Titelsong *
CF: Was ist genau die Regel, die ...
Dominik: Ja, das ist interessant.
CF: * Titelsong *
Dominik: Ja, das ist interessant.
CF: Ja, das kann ...
Dominik: Ja, das ist interessant.
CF: Ja, das kann ...
CF: * Titelsong *
CF: Ja, aber ich glaube, deswegen ist es schon noch ...
CF: Ja, genau, das ist schon noch wichtig,
CF: dass es jetzt halt quasi von den C-Python-Entwicklern
CF: halt mit versorgt wird.
CF: Ich habe jetzt noch mal nachgeschaut,
CF: was genau die Tiers bedeuten.
CF: Also, Tiers 1 und 2 sind halt so ein bisschen wie
CF: Mac, also so macOS, Windows, Linux.
CF: Tier 2 braucht man halt irgendwie Buildboards
CF: und mindestens zwei C-Python-Core-Developer,
CF: die eben die Plattform unterstützen.
CF: Und wenn es da Buildboard-Failures gibt,
CF: dann werden C-Python-Releases dadurch blockiert.
CF: Und Tier 3 heißt eben Buildboard einen Core-Entwickler,
Jochen: [kein Ton]
CF: aber wenn es da Bugs gibt,
CF: dann kann C-Python trotzdem released werden.
CF: Also, das ist quasi so ein "Wir geben uns Mühe",
Jochen: [kein Ton]
CF: aber wenn es jetzt irgendwie nur noch einen
CF: bekannten Bug auf Android gibt,
CF: dann releasen wir halt möglicherweise trotzdem.
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
CF: [Siehe vor]
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
CF: [Kein Ton]
Dominik: Ja, das ist interessant.
CF: Ja, ich habe das bei meinen Studenten echt.
CF: Also ich mache eine Python-Einführung für alle,
CF: da dürfen Informatiker nicht hin.
CF: Das heißt, ich habe auch wirklich Studierende aus allen Fächern.
CF: Jetzt nicht viele, aber da gibt es dann immer wieder Teilnehmer,
CF: die dann halt einfach auch nur ein Tablet haben.
CF: Und ja, also da sind wir noch.
Dominik: Ja, das ist interessant.
CF: Die haben kein Tier 1 Gerät, genau.
CF: Und die haben dann halt entweder die Möglichkeit,
Dominik: Ja, das ist interessant.
CF: das irgendwie über Google Collab zu machen.
CF: Also ich mache alles mit Jupyter Notebooks,
CF: aber das ist halt dann immer so ein bisschen nervig
Dominik: Ja, das ist interessant.
CF: mit die Inputdateien hochladen und so Zeug.
CF: Und dann können die sich ins Rechenzentrum setzen,
CF: da ist das auch installiert, aber das ist natürlich auch total nervig.
CF: Du musst immer deine Übungsaufgaben dann machen.
CF: Und so einen richtig guten Jupyter Support auf so einem iPad
CF: gibt es halt einfach auch noch nicht.
CF: Also das ist schon einfach im Vergleich zu installiert an der Konda,
CF: da ist alles in Ordnung, ist das halt schon einfach sehr frickelig.
CF: [kein Ton]
Dominik: Ja, das ist interessant.
CF: Der einer von den drei Developers in Residence ist.
CF: [kein Ton]
Dominik: Ja, das ist interessant.
CF: [kein Ton]
CF: Also ich glaube, man kann die verkaufen.
CF: Also ich vermute, dass das wirklich die Art und Weise ist,
CF: wie man endlich mal gutes Funding für ZBiten findet.
CF: [kein Ton]
Dominik: Ja, das ist interessant.
CF: Der einzige Vorteil von AI ist, dass sie die LFTs verdrängt haben.
CF: [kein Ton]
Dominik: Ja, das ist interessant.
CF: Und er war besser im Leben.
CF: [kein Ton]
CF: Wir müssen noch über den anderen JIT reden.
CF: Es gibt nämlich zwei JITs in 3.13 und der eine ist der coole,
Dominik: Ja, das ist interessant.
CF: der quasi das irgendwann mal schneller machen soll,
CF: der aber quasi standardmäßig gar nicht eingebaut ist.
CF: Und dann gibt es aber den anderen, der quasi standardmäßig eingebaut ist,
CF: aber für einen ganz anderen Zweck.
CF: Ich glaube, in einer der Core.py Folgen ist Pablo Gallino-Sagado,
CF: über den wir gerade auch schon geredet haben, sehr stolz darauf,
CF: dass er quasi den ersten C-Typen JIT gemerged hat und geschrieben hat.
Dominik: Ja, das ist interessant.
CF: Und das ist nämlich der JIT, der benutzt wird,
CF: um besseres Profiling machen zu können.
CF: Und das funktioniert mit dem Linux Perf Profiler.
CF: Und das Problem, wenn man jetzt so ein, also der Perf Profiler
CF: ist eigentlich so ein Profiler für C.
CF: Also man kann halt sehen, was macht der Kernel,
CF: was macht der Linux Kernel oder was machen eben auch die C-Programme,
Dominik: Ja, das ist interessant.
CF: die im User Space laufen und man kann eben sehen,
CF: die und die C-Funktionen werden jetzt gerade so und so oft ausgeführt.
CF: Das ist so ein Sampling Profiler, also der Profiling-Umwelt ist sehr gering.
CF: Das Problem ist jetzt aber, dass wenn man quasi Python-Programme profilt,
CF: dann sieht man natürlich jetzt gar nicht, welche Python-Funktionen
CF: wie viel Zeit verbrauchen, sondern man sieht dann die ganze Zeit nur,
CF: dass halt irgendwelche Interpreter-Funktionen ausgeführt werden.
CF: Und da gibt es jetzt eben dieses neue Feature, den Perf JIT.
CF: Und da ist die Idee, dass man so eine ganz, ganz kleine,
Dominik: Ja, das ist interessant.
CF: irgendwie ein paar wenige Maschinencode-Instruktionen
CF: lange Funktionen generiert zur Laufzeit.
CF: Und für jede Python-Funktion eben genau eine solcher Funktion.
CF: Und das hat dann den Vorteil, dass Perf eben die ganzen Python-Funktionen
CF: voneinander unterscheiden kann.
Dominik: Ja, das ist interessant.
CF: Wenn man eben nicht nur eine interpretierige Python-Code-Funktion
CF: dann sieht in Perf, sondern man sieht dann eben diese neu generierten
CF: Assembly-Funktionen an Adresse sowieso.
Dominik: Ja, das ist interessant.
CF: Die entspricht eben der Python-Funktion F, wie auch immer.
CF: Und so kann man dann eben mit Perf sehen, in welcher Python-Funktion
CF: man lange Zeit verbraucht hat.
CF: Es ist erstaunlich umständlich, aber Profiling ist auch echt
Dominik: Ja, das ist interessant.
Jochen: [kein Ton]
CF: einfach ultra kompliziert.
CF: Also, man hat jetzt hier so eine ganze Menge,
CF: die man einfach einfach einfach einfach einfach einfach einfach
Jochen: [kein Ton]
CF: einfach ultra kompliziert.
CF: Also es gibt ja es gibt ja irgendwie so eine große Sammlung an Profilern
Dominik: Ja, das ist interessant.
CF: für Python für andere Sprachen, aber cProfile hat halt einfach
CF: einen riesen Overhead.
CF: Dann gibt es verschiedene Sampling-Profiler für Python.
CF: Wie heißt dieser? PySpy oder so? Der funktioniert, glaube ich, ziemlich gut.
Jochen: [kein Ton]
Dominik: Ja, das ist interessant.
CF: Habt ihr den mal benutzt?
Jochen: [kein Ton]
CF: Aber heute war das, glaube ich, eine UI nur, oder?
CF: Wo die Samples herkommen, weiß ich nicht so genau.
CF: Ja, und dann gibt es also unseren quasi, WMProf, der ist aber nicht mehr
CF: so richtig maintained. Also auch PyPy schon, aber CPython nicht so richtig.
CF: Ist auch Sampling. Also Sampling heißt halt, dass man quasi nicht
CF: jeden Funktionsaufruf mitschreibt, was halt sehr sehr hohen Overhead hat,
CF: sondern einfach nur so tausendmal pro Sekunde halt guckt, welche Funktionen
Dominik: Ja, das ist interessant.
CF: gerade auf dem Stack sind und dann sagt, so statistisch gesehen,
CF: sind das die Funktionen, die dann viel Zeit brauchen.
CF: Und Perf ist halt auch so einer und der Vorteil von diesem Sampling-Ansatz
CF: ist, dass man den Profiling-Overhead eben beliebig klein machen kann.
CF: Man kann halt die Anzahl der Samples immer kleiner machen.
CF: Und wenn es dann nur noch zehn Samples sind, dann ist es halt quasi
CF: genauso schnell, wie es vorher auch war.
CF: Man hat aber auch schlechtere Informationen dann sozusagen.
CF: Also man kann dann quasi die Abwägung zwischen Genauigkeit der Informationen,
CF: die man hat, und Overhead beliebig ausbalancieren.
CF: Und Perf funktioniert halt sehr gut, wenn man da gute Informationen
CF: darüber kriegt, was auf dem C-Level funktioniert.
CF: Aber die Information, welche Python-Funktion da jetzt gerade involviert ist,
CF: die geht halt verloren. Und die kann man dann eben wieder zurückkriegen
CF: mit diesem neuen Perf-Integration-Feature, das jetzt in 3.13 released wurde.
CF: Aber es ist auf jeden Fall frickelig. Also ich glaube, auf Mac ist es ja auch
CF: total schwierig, weil man braucht halt so ausführbare Blöcke von Maschinen-Code.
CF: Und Apple hat da halt auch einiges an Security-Features.
CF: Man muss dann quasi sicherstellen, dass man so einen Codeblock eben
CF: so hin und her wechselt zwischen "Ich kann den Codeblock schreiben
CF: und ich kann ihn ausführen." Also man kann ihn nie gleichzeitig
CF: schreibbar und ausführbar haben, um eben so Security-Exploits
CF: unwahrscheinlicher zu machen. Und bis man das ganz genau richtig hingekriegt hat,
Jochen: [kein Ton]
CF: das ist tricky. Wobei Perf ist eigentlich nur ein Ledungsprojekt.
CF: Insofern habe ich, glaube ich, gerade Quatsch gesagt.
Jochen: [kein Ton]
CF: Ah ja.
CF: Unbedankt haben. Von einer Mac-Version zur nächsten.
CF: Ja, ich finde es cool, dass es Leute gibt, die sich dann wirklich mit den Linkern
CF: auf allen Plattformen herumschlagen, um dieses Problem zu lösen.
CF: Ja.
Dominik: Ja, das ist interessant.
CF: Ja.
Dominik: Was macht das denn überhaupt, der G...
Dominik: Ja.
CF: Ja.
Dominik: Ja.
CF: Ja.
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
CF: Ja.
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
CF: Also ganz allgemein, die ganzen Darmstrukturen sind halt erstmal nicht
CF: Threat-safe. Also wird alles kaputt gehen.
Dominik: Ja.
CF: Es gab noch ein älteres, aber ja. Also alle paar Jahre kommt mal jemand
CF: und baut den Deal aus. Ja.
Dominik: Ja.
CF: Ja, genau. Also es war wirklich so 1.6. oder irgendwie so was ganz frühes,
CF: wo das dann die ersten ... Also die Single-Core-Performance, genau.
CF: Genau.
Dominik: Ja.
CF: Also an dem GARBIS-Projekt hatten die quasi bei diesen Gilectomy-Versuchen
CF: auch nichts geändert. Was sie gemacht haben, ist jedem Objekt einen Lock zu geben.
Dominik: Ja.
CF: Und immer, wenn ein Threat mit dem Objekt eben interagieren wollte,
CF: insbesondere wenn eben der Reference-Count verändert wird,
CF: musst du halt dir erstmal das Lock holen für das Objekt.
CF: Und weil halt ständig, um irgendeine Operation mit dem Objekt machen zu können,
CF: du halt ständig an dem Reference-Count herumoperierst,
Dominik: Ja.
CF: musst du halt ständig auf das Lock warten.
CF: Und das hat halt die bisherigen Versuche, den GIL zu entfernen,
CF: einfach sehr, sehr teuer gemacht.
CF: Also die Single-Threat-Performance eben komplett ruiniert.
CF: Ja, jetzt wird es super kompliziert.
Dominik: Ja.
CF: Also wir haben jetzt ... Genau. Es gibt den GIL.
CF: Der GIL verhindert, dass mehr als ein Threat-Python-Call ausführen kann.
CF: Also gleichzeitig auf einem Core.
CF: Jetzt kommt eben der nächste Versuch.
CF: Und das ist von Sam Gross bei MITHA über viele Jahre lang eben probiert worden.
CF: Und der hat einige sehr clevere neue Ideen da reingebracht,
CF: um zu versuchen, eben die Verlangsamung für Single-Threat-Performance,
CF: so weit es geht, zu minimieren.
CF: Und da gibt es eben so eine ganze Bandbreite an Optimierungen,
CF: womit er dann eben versucht, genau die Probleme in den Griff zu kriegen.
CF: Und eine davon ist eben die Beobachtung,
CF: dass die allermeisten Objekte, die werden halt trotzdem nur von einem Threat benutzt.
CF: Also wenn ich halt eine Funktion habe, die irgendwie eine Liste erstellt
CF: und da was reinappendet und so weiter,
CF: selbst wenn auf ganz vielen anderen Threats halt noch Sachen laufen,
CF: kommt halt kein anderer Threat erstmal standardmäßig an diese Liste ran.
CF: Das heißt, die erste Optimierung ist zu sagen,
CF: für die ganzen lokalen Objekte, die ich also nur von einem Threat überhaupt jemals anfasse,
CF: muss ich für das Updaten der Reference Counts eben nicht locken.
CF: Also das ist quasi die wichtigste Optimierung.
CF: Genau, das heißt Biased Reference Counting,
CF: weil quasi dafür gesorgt wird, dass man eben nicht geshared Objekte,
CF: die nur von einem Threat eben erreichbar sind,
CF: dass man da eben das Locking quasi sein lassen kann.
CF: Jetzt gibt es aber natürlich eine ganze andere Klasse an Objekten,
CF: die werden halt von ganz vielen verschiedenen Threats angefasst.
CF: Also halt alles, was die ganzen Buildings, also NUN, die ganzen Typen.
CF: Und dafür gibt es dann also wieder einen ganz anderen Ansatz.
CF: Und da ist nämlich die Idee, dass man da halt sagt,
CF: diese Objekte, die können eh nicht sterben.
CF: Also so was wie NUN, NUN gibt es halt einfach immer.
CF: Und das gilt halt für ganz, ganz viele andere Arten von Objekten auch.
CF: Die meisten Typen gibt es halt immer.
CF: Und die werden dann so unsterblich gemacht.
Dominik: Ist das dann ein Singleton?
Dominik: [Aufnahmellärm]
CF: Also NUN ist auch ein Singleton, ja, aber das ist nicht das einzige Kriterium.
CF: Man kann sich schon vorstellen, dass es Singletons gibt,
CF: die halt vielleicht auch sterben könnten,
CF: also die man vielleicht wegräumen will.
CF: Aber es gibt also die ganzen eingebauten Sachen,
CF: die werden einfach nie garbage collected.
CF: Und deswegen kann man da eben auch sagen,
CF: da kriegt jetzt der Reference Count irgendwie so einen speziellen Flag.
CF: Und dann erhöht und senkt man den Reference Count eben auch nicht.
CF: Und dann muss man die auch wieder nicht locken.
CF: Und dann gibt es noch den dritten Ansatz.
Dominik: [Aufnahmellärm]
CF: Und das ist das sogenannte Deferred Reference Counting.
CF: Und da verstehe ich die ganzen Details auch nicht komplett.
CF: Aber da ist eben die Idee, dass man eben das Erhöhen und Senken
CF: des Reference Count nicht mehr die ganze Zeit up-to-date macht,
CF: um eben zu ver- also da geht es um Objekte, die so dazwischen sind,
CF: also die von einem, mehr als einem Thread erreicht werden können.
Dominik: Also man erhöht, aber man reduziert das nicht oder beides nicht?
CF: Ich glaube beides nicht.
Dominik: [Aufnahmellärm]
CF: Also, und dann, das sorgt aber dafür, dass wenn der Reference Count null wird,
CF: dann kann man die auch nicht sofort einsammeln,
CF: sondern da muss man eben warten.
CF: Und dann warten, bis alle Threads zu irgendeinem wohl definierten Punkt kommen.
CF: Und dann kann man schauen,
CF: ob es nicht noch irgendwelche References in den Stack Frames gibt oder so,
CF: die dann noch dazu gezählt werden müssen.
CF: Deswegen eben deferred.
CF: Und nur wenn man da dann eben überall nachgeschaut hat und feststellt,
CF: oh, okay, das Objekt, das ist jetzt wirklich auch von keinem Frame-Objekt mehr erreichbar,
CF: dann kann ich das wirklich wegräumen.
Dominik: [Aufnahmellärm]
CF: Und das hat auch komplizierte Interaktionen mit dem Memory Allocator.
Dominik: [Aufnahmellärm]
CF: Da wechselt nämlich die freethreading-Version auch zu Mimalock.
CF: Das ist so ein von Microsoft geschriebener C-Memory Allocator,
CF: der eben auch besonders gut mit Multithreading interagiert.
CF: Und da wird auf eine für mich noch nicht ganz verständliche Art und Weise
CF: eben mit besonderen Mimalock-Features dann erreicht,
CF: dass genau das Richtige passiert.
Jochen: [kein Ton]
CF: Aber also da bin ich noch nicht, ja.
Dominik: Das ist immer genau das richtige, was hier, das ist immer toll.
Dominik: [Aufnahmellärm]
CF: Ja, ich glaube, das ist genau.
Jochen: [kein Ton]
CF: Also Vorbemerkung ist, das gilt alles nur für Objekte,
CF: die eben von mehr als einem Thread erreicht werden können.
CF: Also genau, aber für die hast du absolut recht.
CF: Da ist eben eine Zahl drin, die nicht unbedingt wirklich alle References
Dominik: [Aufnahmellärm]
CF: von allen Threads dann widerspiegelt.
CF: Und um das Objekt dann wirklich wegräumen zu können,
Dominik: [Aufnahmellärm]
CF: muss man halt nochmal nachschauen, ob das wirklich alles so gestimmt hat.
CF: Ja, absolut.
Dominik: Also so ein bisschen so, als wenn du die Box aufmachst und guckst, ob die Katze noch lebt.
Dominik: [Aufnahmellärm]
CF: Ja.
Dominik: [Aufnahmellärm]
CF: Ich glaube, Eventual Consistency ist auf jeden Fall ein super Gedankenmodell,
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
CF: weil, also Eventual Consistency wird ja auch quasi aus den gleichen Gründen eingeführt.
Dominik: [Aufnahmellärm]
CF: Also natürlich kann ich, will ich, eigentlich ist es besser,
CF: wenn meine Information halt die ganze Zeit consistent ist.
CF: Aber das hat halt im Datenbankbereich dann auch entsprechende Nachteile,
Dominik: [Aufnahmellärm]
CF: Performance-Nachteile.
CF: Genau.
Johannes: Ich hoffe, dass ihr mich nicht vergessen habt.
CF: Und quasi aus den gleichen Gründen führe ich halt quasi im Field,
CF: also auf einem ganz anderen Maßstab natürlich,
CF: aber werden die Deferred Reference Counts verwendet.
Johannes: Ja, cool. Super coole Sache.
CF: Ja, genau.
Johannes: Ja, cool. Super cool.
CF: Aber es ist halt wie gesagt auch bisher noch experimentell und standardmäßig nicht eingebaut.
Dominik: [Aufnahmellärm]
CF: Da gibt es auch noch so ein paar Nachteile.
CF: Die Single Thread Performance ist auch quasi in der Free Threading Version schlechter im Moment.
CF: Ich glaube vor allem, weil sie im Moment eben noch dieses Bytecode-Rewriting,
CF: wo wir vorhin in der JIT-Sektion drüber gesprochen haben,
CF: noch abschalten müssen, eben aus dem Grund, dass wenn ich quasi mehr als einen Thread habe,
Johannes: Ja, cool. Super cool.
CF: der die gleiche Python-Version ausführt und alle wollen jetzt den Bytecode umschreiben,
Dominik: [Aufnahmellärm]
CF: dann habe ich da eben auch wieder quasi Mutationen derselben Datenstruktur von einem Thread.
CF: Und da will ich das nicht immer locken.
CF: Und deswegen haben sie das bisher einfach abgeschaltet in der Free Threading Version.
CF: Und das sorgt dann eben für, weiß ich nicht, 10 Prozent, 20 Prozent Verschlechterung
CF: der Single Threading Performance.
CF: Oder es gibt eben, ein anderes Problem ist, es gibt eben einfach ganz, ganz viel Python-Code,
CF: der so in der Welt ist, in irgendwelchen Bibliotheken, der einfach nicht Thread-safe ist.
Dominik: [Aufnahmellärm]
CF: Weil bisher konnte man sich halt so ein bisschen immer so durchmogeln mit der Tatsache,
CF: dass meistens ist man halt vom Gil geschützt.
Johannes: Ja, cool. Super cool.
CF: Und so viel Multi-Threaded Python-Code gibt es halt auch oft nicht.
CF: Und deswegen finden wir jetzt wahrscheinlich die nächsten 10 Jahre Locking-Bugs in allen PyPI-Bibliotheken.
CF: Und für die C-Extensions gilt das natürlich erst recht.
CF: Ja, sobald ich quasi was mache, was dann wirklich weit weg von jedem Python-Objekt, ja.
Johannes: Ja, aber die C-Extensions hatten ja vorher schon die Möglichkeit, den GIL freizugeben. Also NumPy zum Beispiel.
Johannes: Genau, was aus dem Python Memory Management rausgeht, dann kann ich sagen, ah, das brauche ich gerade gar nicht.
CF: Also die große Matrix-Multiplikation, die NumPy macht, die hat halt mit Python dann nichts mehr zu tun.
Johannes: Ja, gut, okay, FootGuns, ich meine ...
CF: Und die konnte halt dann auch schon auf dem extra Core dann den Lüfter heißlaufen lassen.
Johannes: Genau.
CF: Aber genau.
Johannes: Ja, das sind die wenigsten Operationen, das ist mir schon klar.
CF: [kein Ton]
Johannes: Die prinzipielle Möglichkeit gab es vorher schon. Wenn ich mein eigenes Memory Management mache, brauche ich auch, bin ich nicht auf den GIL angewiesen.
Johannes: Okay, cool.
CF: Ja, also das ist auch in der Standard-Bibliothek, gibt es einfach ganz viele solche Stellen.
Johannes: Ja.
CF: Wir hatten heute so einen Bug-Report.
CF: Es gibt das Line-Cache-Modul, das kennt keiner, weil man das quasi selber nie benutzt.
CF: Das ist quasi dafür da, dass wenn ich Tracebacks kriege, dass die Source-Code-Zeilen halt quasi aus den Python-Dateien geladen werden zum Anzeigen.
CF: Und das wird gecached, damit ich nicht jedes Mal die Dateien eröffnen muss.
CF: Und wenn ich jetzt aber quasi Python-Code zu Laufzeiten erzeugt mit exec oder so,
CF: dann kann ich quasi auch da dann in den Line-Cache so Sachen reinschreiben.
Johannes: Ja.
CF: Und die will ich aber vielleicht auch wieder löschen, damit eben der Cache nicht mehr und mehr Speicher verwendet.
CF: Und dann hatten wir einen Bug von Sympy oder so, die schreiben da eben so Sachen in den Line-Cache rein und löschen die dann auch wieder.
CF: Und dann stellt sich halt raus, dass der Line-Cache nicht thread-safe ist.
CF: Also wenn ich das quasi von mehreren Threads mache, dann kriege ich halt irgendwelche komischen Exceptions von irgendwelchen internen Line-Cache-Funktionen, von denen ich noch nie gehört habe.
Johannes: Ja.
CF: Und ja, also wenn, klar, das ist jetzt alles schon extra ultra speziell, aber so Stellen wird es halt in der Standardbibliothek auch noch an anderen Plätzen geben,
CF: dass man halt dann feststellt, oh, okay, es gibt hier Python-Code.
CF: Da hat halt noch nie jemand drüber nachgedacht, was passiert eigentlich, wenn ich das auf vier Threads gleichzeitig ausführe.
Johannes: Ja, und eigentlich sollte man sich ja da auch keine Gedanken, beziehungsweise das ist ja der Ansatz, dass man sich keine Gedanken darüber machen soll.
CF: Also man wird da in Python schon drüber nachdenken müssen.
Johannes: Viele andere Sprachen lösen das Problem halt auf eine andere Art und Weise, indem sie sagen, da musst du jetzt halt selber explizit darüber nachdenken.
CF: Also wenn du halt so was hast, wie du hast irgendein globales Dictionary und das wird jetzt von zwei Threads mutiert und ich habe aber in beiden eine Iteration darüber,
Johannes: Ist ja der Ansatz, dass man es in Python nicht machen muss.
CF: dann sind halt wahrscheinlich die Varianten der Schleife kaputt, die ich dann auch noch mal nachdenken muss.
CF: Egal, ob die Datenstruktur jetzt, also klar, die Datenstruktur soll nicht kaputt gehen, aber ich kann ja trotzdem dann plötzlich den Key verlieren, den ich erwarte, dass er noch in dem Dictionary drin ist.
Johannes: Ja.
CF: Das ist, das ist ja auch so ein bisschen ein Problem, dass man da so ein bisschen auf den Weg geht.
Johannes: Ja, oder auch ...
CF: Also ich habe da jetzt einen anderen Punkt, der ist ja auch ein bisschen anders, aber ich glaube, das ist auch so ein bisschen ein Problem, dass man da so ein bisschen auf den Weg geht.
CF: Also ich habe da jetzt einen anderen Punkt, der ist ja auch ein bisschen anders, aber ich glaube, das ist ja auch so ein bisschen ein Problem, dass man da so ein bisschen auf den Weg geht.
Johannes: Ja, auch diese ganzen Probleme, die bei Multithreaded Programming auftreten, also allein, wenn ich irgendeine Variable habe, die ich inkrementieren möchte, dann da muss ich ja schon irgendwie einen Mechanismus haben, der Multithreading ermöglicht, aber das ist ja nochmal eine ganz andere Ebene.
CF: [Stille]
CF: Ja, klar, solche Bugs haben wir definitiv auch schon gesehen.
Johannes: Ja, die sind ja auch leicht. Also ich meine, die hat man ja sofort.
CF: Also sowas wie self.counter=1, das ist halt nicht atomic in der Freethreading-Version.
CF: Also wenn ich da mehrere Files habe, die das machen, dann könnten halt komische Sachen passieren.
CF: [Stille]
Johannes: Aber da gab es auch früher schon so Stolperfallen, wo manche Sachen in Python Atomic aussahen und es dann aber irgendwie doch nicht waren.
Jochen: [kein Ton]
CF: Genau, also viele von diesen Bugs, die sind quasi bisher auch schon, das sind jetzt quasi keine Bugs, die nur in Freethreading wirklich vorhanden sind.
Johannes: Ja.
CF: Das sind quasi latente Bugs, die es schon immer gibt, die auch quasi in der ganz normalen GIL-Version von Python Bugs sind und Crashes verursachen können.
Jochen: [kein Ton]
CF: Nur bisher waren die quasi einfach viel unwahrscheinlicher, dass man die wirklich dann auch trifft, diese Bugs.
CF: Aber dadurch, dass jetzt eben mehr Leute versuchen werden, mit Multithreading in der Freethreading-Version Programme dann schneller laufen zu lassen,
Johannes: Ja.
CF: wird die Wahrscheinlichkeit, dass man diese Bugs halt dann auch quasi in echt sieht, die geht halt hoch.
CF: Das heißt, also ja, ich meine das ernst. Wir werden jetzt wahrscheinlich zehn Jahre lang Bugs in allen Bibliotheken finden, die irgendwas mit Threading zu tun haben.
Johannes: Ja.
CF: [Stille]
CF: Ja, genau, also das ist ja auch eine der großen Schwierigkeiten des Freethreading-Projekts.
Johannes: Und woran erkennt man das?
CF: Das ist sich quasi bei allen eingebauten Containern, also wie Listen und Dictionaries und so weiter, jetzt überlegen müssen,
CF: welche der Methoden wollen wir eigentlich als atomar verstanden haben und welche halt dann auch nicht.
CF: Also sowas wie, das erkennt man nicht. Ich glaube, das wird dann dokumentiert.
Johannes: Ja, genau, erkennt man das. Ja, gut, klar, also das muss man nachlesen, aber ja.
CF: Aber die Entwickler, die quasi Freethreading implementieren, die müssen sich eben bei jeder Methode Gedanken darüber machen.
CF: Also List.append ist halt atomic, aber List.extend bin ich mir schon mal nicht mehr so sicher.
CF: Wenn das, was ich dann als Argument von Extend reinreiche, wenn das selber ein Iterator ist und da halt dann mit einem Generator irgendwie Python-Code ausgeführt wird,
CF: dann kann das halt auch eine Weile dauern, bis ich da durch bin.
Johannes: Ja, und jetzt machen wir uns auf einmal Gedanken über Transaktionen und über Transaktionsmanagement und das ist dann schon auf Sprachebene was sehr Spezifisches.
CF: Und in der Zwischenzeit können natürlich andere Threads da laufen und irgendwelchen Quatsch produzieren.
CF: [Stille]
CF: Ja, genau. Übrigens, um die Frage zu beantworten, was für einen atomaren Counter ich benutzen kann,
CF: da gibt es irgendwie itertools.counter oder so heißt es, glaube ich.
CF: Und das gilt wirklich als, also das ist die Thread-Safe-Variante, um einen atomaren Counter in Python zu haben.
Johannes: Okay.
CF: [Stille]
Johannes: Also hätte ich jetzt nicht gewusst. Und ja. Ja, okay, klar. Ja, genau, ich erinnere mich noch, das habe ich vor Jahren mal diese Meinung vertreten, dass der Slobal Interpreter Log mich davor schützt, dass ich x plus gleich eins machen kann, so viel ich will.
CF: Ich auch nicht, aber wir hatten halt Bug-Reports, die gesagt haben, self.x+=1 geht halt nicht.
CF: [Stille]
Johannes: Und dann haben wir im Chaoslauf an einem Abend das einfach mal ausprobiert und es stellte sich als falsch raus, die Annahme, weil man eben sehr schnell falsche Zahlen rauskriegen kann.
CF: Darf ich kurz ranten?
Johannes: Ja, selbstverständlich. Da sind wir ja.
CF: Okay, also das komplette, wie heißt das, Insider-Baseball, also das hat sich geändert in den letzten Python-Versionen, also in den letzten C-Python-Versionen.
Johannes: Ja.
CF: Du hast absolut recht, dass quasi, also ursprünglich war die Regel, ein Bytecode ist atomar,
CF: aber so theoretisch kann ich nach jedem Bytecode eben einen Thread-Switch haben.
CF: Und sowas wie das erwähnte Beispiel self.x+=1, das sind eben mehrere Bytecodes, das heißt da kann ich dazwischen einen Thread-Switch haben und entsprechend ist das nicht atomar.
CF: In einer der letzten Versionen, ich weiß nicht, 3.12 vielleicht oder so, haben sie quasi in C-Python die Bytecodes, wo man Thread-Switches machen kann,
Johannes: Ja.
CF: also in der regulären GIL-Version, stark reduziert.
CF: Und es gibt jetzt eben nur noch ganz, ganz wenige Bytecodes, wo wirklich dann Switches stattfinden können.
CF: Das sorgt dafür, dass die quasi beobachtbare Atomarität zunimmt.
CF: Das heißt plötzlich in 3.12 war dieses Counter-Beispiel atomar.
CF: Und das ist natürlich total schlecht, weil wenn man die Community darauf vorbereiten will, dass jetzt irgendwann mal der GIL entfernt wird
Johannes: Okay. Ja.
CF: und man quasi mit Thread-Switches an viel mehr Stellen rechnen muss, ist es halt schlecht, wenn man in der Version davor dafür sorgt,
CF: dass viel weniger Thread-Switches an viel vorhersagbaren Stellen, nämlich nur am Ende von der Schleife oder sowas stattfinden kann.
CF: Also das finde ich, also ich meine klar, dieses Reduzieren der Thread-Switches, das erhöht halt wieder die Single-Threading-Performance,
Johannes: Ja, klar.
CF: das war der Grund, warum sie das gemacht haben, aber ich finde es halt unstrategisch.
CF: Also ich glaube, wenn du in 3.12 das mit dem Counter nochmal ausprobieren würdest,
CF: dann wäre es quasi nicht mehr beobachtbar, dass man dazwischen...
Johannes: Dann mache ich das jetzt mal nicht, zur Sicherheit.
CF: Nee, mach es lieber gleich in der No-GIL-Version.
CF: Damit würdest du es kaputt kriegen können, würde ich hoffen.
Johannes: Ja gut, aber damit muss es ja gehen.
Johannes: Ja gut, ja, kaputt kriegen.
CF: Ja, also...
CF: Aber ich glaube, da gibt es auch zum Beispiel so... also es gibt Packages davon.
Johannes: Ich habe jetzt leider keine Nokia Version hier kompiliert, deshalb muss ich leider dieses Experiment.
CF: Genau. Und in... in... in... bei Env weiß ich nicht, aber in Ubuntu, in dem DeadSnake PPA gibt es das auch.
Johannes: Ja, bei Pans.
CF: Ich glaube, es liegt aber halt vor allem auch daran, dass wir daran gewöhnt sind, es nicht zu brauchen, weil wir es halt nie hatten.
Johannes: Ja.
CF: Also ich glaube schon, dass es dann einiges gibt, wo das halt schon irgendwie auch...
CF: Klar, man muss dann sich irgendwie umgewöhnen und vielleicht gibt es auch ein paar schöne Bibliotheken,
CF: die das halt alles ein bisschen weniger gefährlich machen, dass man so ein paar schöne Abstraktionen auf jeden Fall hat.
CF: Aber ich denke schon, dass wir an einen Punkt kommen können, wo man dann eben sagen kann...
CF: Ja, also früher hätten wir vielleicht Multiprocessing genommen und es wäre nervig und...
Johannes: Ja, das ist halt auch mit Threads programmieren, ist halt auch was gefährliches.
CF: also frickelig gewesen, das dann gut hinzukriegen und jetzt nehmen wir es halt plötzlich und es funktioniert gut.
Johannes: Da gibt es ja, also ich meine, selbst wenn diese Operationen alle atomar sind und selbst wenn das so ist, dann gibt es ja immer noch diese ganzen Probleme und Deadlocks und Race Conditions und all das Zeugs und das ist einfach eine schwierige Sache.
CF: Ja, ja, absolut.
CF: Ja, das ist die Freethreading.
Jochen: [kein Ton]
Johannes: Ich habe kurz, ich habe eben nachgeguckt, es gibt in PyEnv, gibt es eine 3.13.0 Version und es gibt eine 3.13.0t Version und das werden die beiden unterschiedlichen sein.
Jochen: [kein Ton]
CF: Genau, und dann muss man ein altes Skript vom Chaosdorf finden und dann...
Johannes: Gut, dann muss ich jetzt Boomer installieren.
Jochen: [kein Ton]
Johannes: Es war nicht so ein beeindruckendes Testharness, es war einfach nur zwei Threads, die eine Variable gleichzeitig erhöht haben.
CF: Ja, klar.
CF: Ja, ich sehe das auch so. Also jetzt...
Johannes: Also das kann man relativ leicht wieder rekonstruieren.
CF: Ich habe so sehr gemischte Gefühle, was das Freethreading angeht.
CF: Einerseits ist es halt cool, weil endlich diese endlose Diskussion aufhört auf der einen Seite
Jochen: [kein Ton]
CF: und weil halt auch wirklich jemand mal Geld in die Hand genommen hat und das richtig gut macht.
Johannes: Ja, das ist ja auch ein bisschen schwierig.
CF: Also richtig gut, klar, da kann man dann auch Details kritisieren, aber die Tatsache,
CF: dass jetzt eben irgendwie einige Leute von Meta dafür bezahlt werden, das halt wirklich zu machen
CF: und auch quasi den Aufwand betreiben, das in C-Python reinzukriegen, was ja auch wirklich immer viele Diskussionen
CF: und viel Überzeugungsarbeit und viel Debugging und sehr, sehr viel Aufwand sind dafür nötig.
CF: Und ich finde es erst mal gut, dass das halt jetzt passiert und dass quasi auch die Community mitgenommen wird
CF: und irgendwie verschiedene... Also es gibt ja jetzt wirklich auch schon einige an Bibliotheken,
CF: die jetzt mitziehen und gucken, dass sie halt auch Freethreading-Versionen dann binaries auf PyPI releasen usw.
CF: Und das ist schon wirklich gut.
CF: Klar, auf der anderen Seite sehe ich das... Ich denke wirklich, das wird eine Riesenumstellung
CF: und das wird schon auch, was die Bugs angeht und was die Eingewöhnungszeit angeht
CF: sowohl in den Bibliotheken als auch in der Sprache selbst.
CF: Ich habe mal so einen... Das ist schon ewig her, aber ich habe mal einen Vortrag gehört von einem der SunJVM-JIT-Entwickler,
CF: der auch an dem ganzen Laufzeitsystem und dem Multithreaded-Garbage-Collector und so gearbeitet hat.
CF: Und der meinte so, im Garbage-Collector findet man halt zehn Jahre lang Multithreading-Bugs.
CF: Und die werden halt immer schwieriger, die zu finden.
CF: Und ich weiß halt nicht so genau, ob wir darauf so richtig gefasst sind.
CF: Also das... Ja.
CF: [kein Ton]
CF: *Wir werden alt. Das ist ein amischer Geheimnis. *
CF: *Aber economistisch genutzt worden ist das. *
CF: *Also, Andere machen immer alles nahe.*
Dominik: Spiele wollte ich bauen.
Dominik: [Aufnahmellärm]
CF: *Aber ich mag keine Frage. *
CF: Mmh.
CF: *Wir sind alle einig. *
CF: Die Zustande kann man als Apron sozusagen annehmen und dann zu seinem eigenen bestimmten
Johannes: Ja, genau, aber das ist eben diese Klasse von Problemen, die ich meinte vorhin.
CF: Grund zu kommen. Aber das ist nicht so einfach. Und das ist auch nicht so einfach, dass man,
Johannes: Und früher waren es halt Telefonverteiler oder Netzwerkinterfaces oder, keine Ahnung, Paketquellen oder ...
Johannes: Ja, genau, aber das ist eben diese Klasse von Problemen, die ich meinte vorhin.
Johannes: Und früher waren es halt Telefonverteiler oder Netzwerkinterfaces oder, keine Ahnung, Paketquellen oder ...
Johannes: Ja, genau, aber das ist eben diese Klasse von Problemen, die ich meinte vorhin.
CF: wie man es so nennt, eine Art "Die Zukunft" zu finden. Und das ist ein ganz wichtiger Punkt.
CF: [Musik]
CF: das ist ultraliebend.
CF: Ja unglaublich.
CF: Dann kommen wir zu dem Sicherlibar.
CF: Wir haben hier eine Schweizer Versorgebehörde.
CF: Und dabei sind wir an einem Regelet подум geht.
CF: Und dann, in dieser английschlössigen Gregory
Johannes: Ja, genau, aber das ist eben diese Klasse von Problemen, die ich meinte vorhin.
CF: Erhed
Johannes: Schreib' mal.
CF: Es ist ja jetzt auch so,
CF: dass wir eigentlich letztlich in einer sehr pragmatischen Situation sind.
CF: Also es ist standardmäßig nicht an.
CF: Und wir gucken, wir haben jetzt Zeit, als Community rauszufinden,
Johannes: Untertitel der Amara.org-Community
Johannes: Diese Sendung wurde vom NDR live untertitelt (02.02.2020)
CF: gibt es Anwendungsfälle dafür, finden wir Anwendungsfälle dafür,
Johannes: Die Sendung wurde vom NDR live untertitelt (02.02.2020)
CF: wird es stabil genug,
CF: ist die Single-Threading-Performance akzeptabel, schlechter
CF: und ziehen die ganzen Bibliotheken mit.
CF: Und im Moment ist das Risiko halt nicht so hoch.
CF: Also quasi der absolute Worst-Case, der passieren könnte,
CF: ist halt, wir finden in zwei Jahren raus, niemand benutzt es,
CF: es stürzt die ganze Zeit ab und Sam Gross hat keine Lust mehr.
CF: Und dann kann man es halt auch einfach wieder weglassen.
CF: Also was ich, würde ich nicht von ausgehen,
CF: aber also die Möglichkeit besteht halt sozusagen.
CF: *Pause*
CF: Klar, auf jeden Fall ist es auf jeden Fall ein langfristiges Projekt.
CF: Das ist jetzt nichts, was wir jetzt in einer Version mal irgendwie so ein bisschen reinbasteln,
CF: dann ist das Problem gelöst.
CF: *Pause*
CF: Klar, und also ob es dann wirklich klappt,
CF: klappt.
CF: >> Schnelles Telefonieren.
Dominik: Ich erwarte nur darauf, dass du es sehr klar hast, Jonas.
CF: >>
Dominik: [Aufnahmellärm]
Dominik: Spaghetti ist Dining.
Dominik: Feindeining. Ja, okay.
Dominik: Ja, Zeigabeln. Ja.
Dominik: Mit Zeigabeln. Ja.
Dominik: [Aufnahmellärm]
Dominik: Also sitzen da irgendwelche Leute, die haben alle eine Gabel in der Hand und warten darauf, dass sie eine zweite bekommen.
Dominik: [Aufnahmellärm]
Dominik: Deadlock quasi.
Dominik: [Aufnahmellärm]
Dominik: Du meinst, die müssen miteinander reden und sagen "Gib mir mal eine Gabel, bitte".
Dominik: [Aufnahmellärm]
Dominik: Hmm, das ist im Blut. Hat der Mund schon voll.
Dominik: [Aufnahmellärm]
Dominik: Mehr Gaben in Parteien?
Dominik: [Aufnahmellärm]
CF: {unverständlich}
Dominik: Goldene Gaben, ja, ich wollte gerade sagen.
Dominik: [Aufnahmellärm]
CF: ... ja, es ist ja auch ...
CF: Also schon allein die Tatsache, dass quasi
CF: einer der schwierigsten Probleme bei verteilten Systemen ein Counter ist,
CF: das ist ja eigentlich auch schon relativ lustig.
CF: Genau, eine Zahl aufzählen, aber so global konsistent und so, das ist wirklich ...
CF: Auch schon das ist nicht so einfach.
CF: {unverständlich}
Jochen: [kein Ton]
CF: Und wenn das dann 18 Eingänge sind, dann finden die dann raus,
CF: jetzt sind gerade minus 10 Leute bei uns auf dem Festival.
Jochen: [kein Ton]
CF: Genau.
CF: {unverständlich}
CF: Man kann es ja mal positiv ausdrücken.
CF: Die Hoffnung ist, dass es jetzt eben ganz, ganz tolle Abstraktionen geben wird,
CF: die dann auf der quasi Low-Level-Basis von Threats und Logs und was weiß ich,
CF: was es dann eben an Infrastruktur gibt oder geben wird,
CF: die das unwahrscheinlicher machen, dass wir Deadlocks produzieren.
CF: Das ist die positive Sicht.
CF: Also macht mal.
CF: War das jetzt sarkastisch oder nicht?
CF: Das war's.
CF: {unverständlich}
Dominik: Du wolltest gerade picken, hast du damit gesagt schon.
CF: {unverständlich}
Dominik: [Aufnahmellärm]
Dominik: Oh, kein Pfeifen.
Dominik: [Aufnahmellärm]
CF: {unverständlich}
CF: Das ist übrigens auch da wieder so ein bisschen Geschichte. Das ist ein gefühlt jahrzehntelanges
CF: Projekt, so ein paar von diesen Sachen. Das wurde mal auf einem CPython Core-Developer-Treffen in
CF: einem Vortrag empfohlen, der damals mit sehr gemischten Reaktionen aufgenommen wurde. Und es
CF: hat ewig gedauert, bis das jetzt wirklich passiert ist, dass die Bibliotheken jetzt entfernt wurden.
CF: Die Motivation ist, dass es halt quasi so ein bisschen Code in der Standardbibliothek gab,
CF: der einfach sehr veraltet ist und nicht mehr so richtig für aktuelle Probleme zu benutzen ist.
CF: Und die wurden dann eben zuerst deprecated und jetzt, seit ein paar Versionen,
Jochen: [kein Ton]
CF: jetzt eben wirklich wurden ein paar entfernt.
CF: [Abspann]
Jochen: [kein Ton]
CF: [Abspann]
Jochen: [kein Ton]
CF: [Abspann]
Dominik: Falls ihr jetzt kurz auf den Tisch gefallen seid, weil euer Paket auf einmal weg ist, dann
Dominik: solltet ihr auffassen mit dem Update.
Dominik: [Aufnahmellärm]
CF: [Abspann]
CF: [Aspann]
Jochen: [kein Ton]
CF: [Aspann]
Johannes: Die Sendung wurde vom NDR live untertitelt (02.02.2020)
CF: [Aspann]
CF: die es noch gibt. Aber ja, also ich kenne auf jeden Fall auch in Python Leute, die sich das
Jochen: [kein Ton]
CF: so angewöhnt haben, dass sie halt im Test schreiben, die Bagger anmachen und dann kann
CF: man erst mal so gucken, was hat man denn eigentlich für Objekte, was haben die für Methoden und was
Jochen: [kein Ton]
CF: macht man denn da eigentlich so.
CF: Na.
CF: Verändern könnte, ja genau. Das wäre schön. Aber ich glaube, PDB ist eine der Sachen, wo ich das
CF: Gefühl habe, dass das auch so ein bisschen revitalisiert ist. Also dass es da jetzt Core-Devs
CF: gibt, die sich dafür interessieren und eben hoffen, da in den nächsten Versionen auch ein paar neue
CF: Features reinzukriegen. Ich glaube auch in 3.13 ist schon die erste Version. Zum Beispiel, dass
CF: wenn man so einen Breakpoint macht, dass man dann nicht erst in der nächsten Zeile dann wirklich
CF: anhält im Debugger, sondern schon in der Zeile selber, wo der Breakpoint ist. Im Coder erst den
CF: Breakpoint gekriegt hat. Ja genau.
Johannes: Um jetzt meinen Einwurf noch kurz zu retten.
Johannes: Das war eine Präsentation von einem Spieleentwickler,
Johannes: die sich selber so ein System gebaut hat.
Johannes: Die Tomorrow Corporation.
Johannes: Die haben sich genau so einen Debugger gebaut,
Johannes: der vorwärts und rückwärts steppen kann
CF: Ja echt, also.
Johannes: und wo ich zwischendurch Code verändern kann
Johannes: und dann trotzdem die Auswirkungen alle sehe.
Johannes: Und dann am offenen Herzen ohne Angst haben zu müssen,
Johannes: dass der Patient jetzt abstürzt.
Johannes: Das ist schon sehr beeindruckend.
Johannes: Grafisch.
Johannes: Dann schreibe ich hier mal die Funktionen um
CF: Findet mal bitte diesen Vortrag. Aber ich glaube, die Free-Threading-Leute, die müssen solche Tools
Johannes: und lasse das mal wieder laufen von hier aus.
Johannes: Und jetzt ist auch der Sebranche da drin.
Johannes: Ja, dem tut ihr auch in die Shownotes rein.
Johannes: Kein Problem.
Johannes: Danke.
CF: auch benutzen, weil es ansonsten einfach echt zu schwierig ist. Und da gibt es halt auch für C so
Johannes: [Musik]
CF: einen Back-in-Time-Debugger, der, wie heißt der nochmal? Anfang des Jahres war ich zum ersten Mal
CF: in der Situation, dass ich mich genötigt gesehen habe, auch so einen zu benutzen, weil wir so einen
CF: nur sehr selten stattfindenden Garbage-Collector-Bug hatten. Und mit so einem Back-in-Time-Debugger
CF: kann man halt dann solche Probleme auch richtig gut lösen. Also das ist quasi so ein Tracing-Debugger,
CF: der macht so eine Aufzeichnung der gesamten Prozessausführung. Das kann man einfach 100 Mal
CF: machen, bis der Crash stattfindet. Und dann kann man sich die Ausführungen beliebig oft wieder
Johannes: [Musik]
CF: anschauen. Und das Interface ist quasi so wie so ein normaler Debugger. Ich kann halt Next machen und
CF: Sachen printen. Aber der Prozess wird nicht wirklich neu ausgeführt, sondern das ist quasi
CF: "nur" ein Replay von dem, was eben bei der crashenden Ausführung wirklich passiert ist.
Johannes: [Musik]
CF: Und da kann ich dann wirklich auch ein Backward Next machen und dann bin ich wieder eine Zeit
CF: davor. Oder ein Backward Finish und dann bin ich eben am Anfang der Funktion nicht gerade ausführend.
Johannes: Ja, das ist schon ziemlich cool, so was.
Johannes: [Musik]
CF: Oder halt auch so Sachen wie ich mache ein Hardware Watchpoint. Also das war wirklich
Johannes: [Musik]
CF: Memory Corruption, die ich da debuggt habe. Und wenn du halt einen kaputten Speicher hast,
Johannes: [Musik]
CF: dann kannst du dir so ein Watchpoint setzen, wo du sagst, wer hat diesen... Also wenn dieser
CF: Speicher verändert wird, dann halt an. Und dann kann man quasi vom Crash sagen, man macht
Johannes: [Musik]
CF: so ein Watchpoint für den kaputten Speicher und dann lässt man rückwärts laufen. Weil dann
Johannes: Das ist schon ziemlich magisch, Cam.
CF: findet man quasi, wenn man rückwärts läuft, findet man den Code, der den Speicher wirklich
CF: kaputt geschrieben hat. Und das war wirklich richtig gut. Aber das war wirklich auch...
CF: Es ist sehr magisch. Es funktioniert übrigens auch nicht... Also technisch ist das nicht so
Johannes: Ja, klar. Das läuft nochmal von vorne nach hinten durch.
CF: implementiert, dass es wirklich rückwärts läuft. Weil es ist ja Maschinencode. Es geht
CF: von beliebigen Code. Stattdessen macht er so Snapshots. Der geht dann zum letzten Snapshot
Johannes: Ja, gut genug.
CF: und läuft von da vorwärts. Aber es fühlt sich halt trotzdem so an. Gut genug.
Johannes: Okay, ich habe hier noch den wichtigsten,
Johannes: die wichtigste Änderung
CF: Warum? Wo wirst du da?
Johannes: in Python 3.13.
Johannes: Bei Docstrings werden jetzt die
Johannes: führenden Leerzeichen entfernt.
Johannes: [Musik]
Johannes: Weil
CF: Da müsste man jetzt mal... Na ja, 5% finde ich ganz schön krass. Also 5% sind Leerzeichen
Johannes: 5 Prozent weniger.
Johannes: Aber also,
Johannes: einfach, weil es korrekt ist, oder?
Johannes: Du brauchst niemals den Docstring mit der Einrückung.
Johannes: [Musik]
Johannes: Ja, spannend.
CF: von eingerückten Logstrings in unseren PYC-Dateien. Das würde man jetzt erstmal so nicht erwarten.
Johannes: Ne.
CF: Na ja gut, wenn ich halt Klasten habe und Methoden-Logstrings, dann sind die ja schon
Dominik: Ich sehe "Green Development" danach.
Dominik: [Aufnahmellärm]
Johannes: Das liegt halt daran, dass wir alle so viele
Johannes: gute und ausführliche Docstrings schreiben und
Johannes: ganz viel Text da reinschreiben.
Johannes: Bei mir ist 0 Prozent.
Dominik: Jochen schreibt keine Drucker, deswegen passiert sowas nicht.
Dominik: [Aufnahmellärm]
Johannes: [Musik]
CF: immer 8 Bytes eingerückt pro Zeile Logstring.
Johannes: Und es müsste dann eigentlich 10 Prozent sein, weil wir
Johannes: gehen ja nur bis 80 Zeichen pro Zeile.
Johannes: 72.
Dominik: Ist das nicht 79?
Dominik: [Aufnahmellärm]
Dominik: 79, 79.
Dominik: [Aufnahmellärm]
Johannes: Was habt ihr denn für moderne Displays?
CF: Wenn du Python-Code auf deinem C64 schreibst.
Johannes: 80 mal 25, so.
Johannes: Modus 4, oder wie war es?
Dominik: Es gibt Leute, die müssen auf ihrem Handy entwickeln.
Johannes: C64 ist keine supported Plattform mehr.
Dominik: [Aufnahmellärm]
CF: Ich habe PyPy auf meinem Handy. Da bin ich sehr stolz drauf. PyPy ist tatsächlich ein
Johannes: [Musik]
CF: Paket auf Thermux. PyPy hat eine ARM-Version und dann kann man das einfach laufen lassen.
Johannes: [Musik]
CF: Manchmal ist es auch nett, dann kann ich in der Bahn irgendwie... Es ist halt so ein bisschen
Johannes: [Musik]
CF: nervig zu tippen. Aber man kann auch den JIT laufen lassen. Man kann sich dann auch auf
CF: dem Handy anzeigen lassen, welchen Maschinen-Code der PyPy-JIT jetzt gerade für den Python-Code,
CF: den man auf dem Handy laufen ließ, erzeugt wurde. Wenn man die richtigen Umgebungsvariablen
Johannes: [Musik]
CF: weiß.
CF: In der Konsole, nee, glaube ich nicht. Jedenfalls zu dem Thermux, weiß ich nicht, wie lustig
Johannes: [Musik]
CF: die für andere ist. Ich fand die lustig. Ist mir was auf einer Konferenz im Sommer
Johannes: [Musik]
CF: passiert. Ich war auf so einer akademischen Programmiersprachen-Konferenz mit Forschern
Johannes: [Musik]
CF: und Forscherinnen, die sich mit Compilern und Optimierung und Programmiersprachen auseinandersetzen.
CF: Da war ich dann mit einem relativ bekannten C-Compiler-Prof, John Regge, auf so einem
CF: Boot in Kopenhagen Bier trinken. Das Boot lag am Hafen, man konnte auf Deck Bier trinken.
Johannes: [Musik]
CF: Ich habe ihm dann auf dem Handy so eine Optimierung gezeigt, die wir in PyPy machen. Er hat mit
CF: PyPy noch nie irgendwas zu tun gehabt und schaut sich das an, so in ganz, ganz kleinem
Johannes: [Musik]
CF: Font und meinte so, warum ist denn da diese extra Operation? Die braucht er doch gar nicht.
CF: Und das war absolut richtig. Und der Grund war, dass die Divisionen in C und in Python
Johannes: [Musik]
Johannes: Tja, so Leute, gibt's
CF: halt sich unterschiedlich verhalten, wenn die Zahlen negativ sind. Und dafür braucht
CF: man halt in Python so ein extra XOR. Aber die Tatsache, dass er das quasi so mit dem
CF: Achtpunkt-Font über einem Bier, so auf dem Handy mal eben so gesehen hat, quasi in einem
CF: ASCII-Format, was er noch nie gesehen hatte, das fand ich dann doch relativ krass.
CF: Das war's.
CF: [Musik]
Dominik: Ich würde sogar fast sagen, das ist fast der Schluss von
Johannes: noch ein paar Ideen, die ich euch noch mal
Dominik: dem Thema 2013.
Dominik: [Aufnahmellärm]
Johannes: vorstellen kann.
Johannes: Ich würde sagen, wir machen das jetzt mal
Johannes: mit dem, was ich euch vorgestellt habe,
Johannes: mit dem, was ich euch vorgestellt habe.
Johannes: Mit dem, was ich euch vorgestellt habe,
Johannes: mit dem, was ich euch vorgestellt habe.
Johannes: Mit dem, was ich euch vorgestellt habe.
Dominik: Kriegen wir auch an.
Dominik: [Aufnahmellärm]
Dominik: Ja, genau.
Dominik: [Aufnahmellärm]
Dominik: Genau.
Dominik: [Aufnahmellärm]
CF: Wer den Spiel noch nicht gesehen hat, der wird es dann auch nicht mehr sehen.
Johannes: Aber ich würde das gerne noch erweitern,
Johannes: also falls da fünf Mails kommen, die sich im
CF: Ich habe das Video noch nicht gesehen.
CF: Ja, wir haben es noch nicht gesehen.
Johannes: Stuttgarter Raum treffen wollen.
CF: Ja, wir haben es noch nicht gesehen.
Dominik: Was ein Ableger.
Johannes: Ah, in Frankfurt?
CF: Wir haben es noch nicht gesehen.
Dominik: [Aufnahmellärm]
CF: Wir haben es noch nicht gesehen.
CF: Ja, wir haben es noch nicht gesehen.
Johannes: Das ist bimodal, oder?
Dominik: Ja, ja, der Duck hat auch Anfang.
CF: Wir haben es noch nicht gesehen.
Dominik: [Aufnahmellärm]
Johannes: Das ist Düsseldorf oder Stuttgart und dann kriegt man das hin.
Johannes: Die Frankfurter müssen halt dann sich einen raussuchen.
Dominik: Marburg, Marburg.
Dominik: [Aufnahmellärm]
Johannes: Da ist zuerst.
CF: Wir haben es noch nicht gesehen.
Dominik: Aha.
Johannes: Das war's.
Dominik: [Aufnahmellärm]
CF: Wir haben es noch nicht gesehen.
Johannes: [Abspann]
Dominik: Soll noch ein T-Shirt machen, Jürgen?
Dominik: [Aufnahmellärm]
Dominik: Das kriegen wir hin.
Dominik: [Aufnahmellärm]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Dominik: Ja, haben wir.
Dominik: [Aufnahmellärm]
Johannes: [Abspann]
Dominik: Ja, kann ja gerne zu Besuch kommen.
Dominik: [Aufnahmellärm]
Dominik: Wie ist es eigentlich mit den
Dominik: tollen Transkripten
Dominik: von unserem Podcast, lieber Jochen?
Dominik: [Aufnahmellärm]
Johannes: [Abspann]
Dominik: Also, falls ihr taub seid und es
Dominik: trotzdem hören wollt, könnt ihr uns jetzt auch alles lesen.
Dominik: [Aufnahmellärm]
Johannes: [Abspann]
Johannes: [Aspann]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Johannes: [Aspann]
Dominik: Wahrscheinlich kann man es nicht einfach mit selber multiplizieren
Dominik: und dann nochmal wieder eins abziehen und dann hat man das schon.
Dominik: [Aufnahmellärm]
Dominik: Fast.
Dominik: [Aufnahmellärm]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Dominik: Wie lange braucht man eine Zahl zu sagen?
Dominik: 41 Millionen?
Johannes: [Aspann]
Dominik: [Aufnahmellärm]
Johannes: [Aspann]
Dominik: Oh, da muss ich nicht runter regeln.
Dominik: [Aufnahmellärm]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Johannes: [Aspann]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Dominik: Wir können jedes Mal jetzt in einer Episode
Dominik: so eine kleine Episode von dieser Primzah mit sehen.
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Dominik: [Aufnahmellärm]
Johannes: [Aspann]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Johannes: [Aspann]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Johannes: [Aspann]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Jochen: [kein Ton]
Johannes: [Aspann]
Jochen: [kein Ton]
Johannes: [Aspann]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Johannes: [Aspann]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Johannes: [Aspann]
Dominik: Du meinst in den nächsten fünf Jahren?
Dominik: [Aufnahmellärm]
Johannes: [Aspann]
CF: Ich finde es ja total lustig. Also man gewöhnt sich ja wirklich total dran.
CF: Ich bin nicht so extrem, ich höre vielleicht 1,2 oder 1,5 oder so.
Johannes: [Aspann]
CF: Und an das Sprechen gewöhnt man sich total. Aber wenn man so eine Zeit lang
Johannes: [Aspann]
CF: irgendwas mit normaler Geschwindigkeit und dann erhöht gehört hat,
CF: die Jingle klingt immer falsch. Also selbst Jahre, ich höre jetzt,
CF: was weiß ich, wie heißt der Microsoft C#-Tipp?
CF: Ähm, Äh, Hansel Minutes.
CF: Höre ich seit Jahren 20% schneller, die Jingle klingt immer noch falsch.
CF: Also das...
Johannes: [Aspann]
CF: (Siehe Untertitelung aufgrund der Audioqualität nicht möglich)
Johannes: [Aspann]
Dominik: Es gibt gute Jingles, die hören sich auf unterschiedlichen Geschwindigkeiten ähnlich interessant an.
CF: Ich habe einen Python-Pick.
Dominik: Und ha!
CF: Es gibt eine super kleine Studie von Erid Katriel,
Dominik: [Aufnahmellärm]
CF: das ist eine CPython-Core-Entwicklerin, die eine Studie darüber gemacht hat,
CF: wie viel PyPI-Pakete Return, Break oder Continue-Anweisungen
CF: in Finally-Blöcken machen. Weil es gab nämlich so eine kleine Diskussion darüber,
CF: dass man, ob man vielleicht, also Except-Doppelpunkt,
Johannes: [Aspann]
CF: also ohne Angabe einer Exception-Typ abschaffen sollte,
Johannes: [Aspann]
CF: irgendwann in einer der nächsten Versionen.
CF: Da gab es total viel Gegenmeinung und dann haben sie das Vorhaben
CF: auch wieder aufgegeben. Aber eine der Ergebnisse von der Diskussion war eben,
CF: einfach mal zu gucken, wie sieht das denn mit Finally aus? Und Return, Break und Continue
CF: in Finally haben ja so ein bisschen so komische Effekte. Wenn man Return macht,
CF: dann ist das ein bisschen wie ein Code. Also wenn ich quasi
Johannes: [Aspann]
CF: Try-Finally habe und der Code wirft eine Exception und in dem
Johannes: [Aspann]
CF: Finally-Block mache ich dann Return, dann returne ich halt einfach von der Funktion
CF: und die Exception verschwindet. Und deswegen hat Erid eben gesagt,
CF: sie schaut mal, wie das in, hier steht irgendwo, wie viele Pakete
CF: sie angeschaut hat, die 8000 beliebtesten PyPI-Pakete
CF: analysiert, eben ein Skript geschrieben, was
CF: sollte, ob eben das Finally-Block mit Break, Continue und Return
Johannes: [Aspann]
CF: drin vorkommen und dann von Hand analysiert, wie viele
Johannes: [Aspann]
CF: von denen quasi wirklich so sein sollen und
CF: wie viele von denen Bugs sind. Also es waren 120 Millionen Zeilen Python
CF: und darin waren 200 Fälle von
CF: Kontrollflussinstruktionen in Finally-Blocken.
CF: Davon waren 46 korrekt, aber diese 46
CF: waren lauter Tests in irgendwelchen Lintern, die eben
Johannes: [Aspann]
CF: sicherstellen wollten, dass der Linter sagt, bitte verwende kein Return in Finally.
Johannes: [Aspann]
CF: Acht Fälle waren wirklich korrekt, also wirklich, wo das
CF: quasi gewollt ist, dass die Exception dann gestuckt wird. Und 149
CF: waren dann eben Bugs, die Erid Katrin dann auch immer
CF: bei den entsprechenden GitHub-Repositories gemeldet hat und die meisten dieser Bugs
CF: werden jetzt gefixt. Also sieht schon so ein bisschen aus, als wäre das jetzt nicht
CF: so das wichtige Feature und auch ein Feature, was vielleicht eher zu
Johannes: [Aspann]
CF: Missanwendungen
Johannes: [Aspann]
CF: als zu korrekten Anwendungen führt.
CF: Und wenn ihr wollt, habe ich noch einen mega nerdy Pick.
CF: Es gibt ein Paper, was einen C-Compiler für eine sehr
CF: kleine Timing von C nach Shell übersetzt.
CF: Und das ist vollständig genug,
CF: dass der C-Compiler sich dann, wenn er sich selbst nach Shell übersetzen kann
Johannes: [Aspann]
CF: und dann kann ich quasi, wenn ich nur irgendeine beliebige Unix-Scherle
Johannes: [Aspann]
CF: habe, kann ich einen sehr kleinen C-Compiler bootstraten.
CF: Und also die haben auch Gründe,
CF: das sind irgendwelche Forscher, die gute Gründe dafür haben, warum sie das machen.
CF: Also die haben so Trusting-Trust-Gründe.
CF: Also damit kann man halt sicherstellen, dass man keine langlebigen Backdoors
CF: in Compilern hat. Aber die Gründe sind mir egal, warum ich das toll finde,
Johannes: [Aspann]
CF: es gibt ja immer diese Argumente, C ist eine schnelle Sprache, weil die ist
Johannes: [Aspann]
CF: compiled und Python ist eine langsame Sprache, die ist interpretiert.
CF: Und von solchen Argumenten halte ich gar nichts, weil das ist halt eine Eigenschaft der Implementierung,
CF: ob was compiled oder interpretiert ist. Ich kann halt kompilierte Python-Implementierung
CF: haben und interpretierte. Das ist keine inhärente Eigenschaft der Sprache.
CF: Und das ist einfach so ein schönes Gegenbeispiel, dass ich
CF: eine kompilierte Version von C habe, die halt trotzdem ultra langsam ist.
Johannes: [Aspann]
CF: Das war's.
Johannes: [Aspann]
Dominik: Okay, sehr schön.
CF: Tschüss!
Dominik: Ja, ich würde sagen,
Dominik: das war ein passender Schlusswort für das.
Dominik: Jetzt könnt ihr auch wieder runterdrehen,
Dominik: eure Geschwindigkeit beim Hören.
Dominik: Und wünschen euch
Dominik: einen wunderschönen Tag,
Dominik: wunderschöne Nacht, wunderschönen Morgen,
Dominik: wunderschönen Aufstehen. Bleibt uns gewogen,
Dominik: hallo@pythonpodcast.de für alles Feedback und so weiter.
Dominik: Bis bald. Tschüss.
Jochen: [kein Ton]
Dominik: [Aufnahmellärm]
Jochen: [kein Ton]
Jochen: [ENDE]
Johannes: Tschau.