WEBVTT

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

00:00:04.400 --> 00:00:05.960
Heute geht es um PyPy.

00:00:06.460 --> 00:00:06.920
Hallo Jochen.

00:00:07.180 --> 00:00:08.100
Ja, hallo Dominik.

00:00:08.320 --> 00:00:08.640
Hallo Karl.

00:00:08.760 --> 00:00:09.060
Herzlich willkommen.

00:00:09.560 --> 00:00:09.960
Hallo Karl.

00:00:10.700 --> 00:00:12.180
Ja, wir wollen wie immer erstmal News machen.

00:00:13.120 --> 00:00:13.820
Was hast du denn da, Jochen?

00:00:14.480 --> 00:00:17.000
Oh, oh, oh, jetzt muss ich mal ein bisschen hochscrollen.

00:00:17.860 --> 00:00:26.140
Ja, also es gab jetzt ein Python Enhancement Proposal tatsächlich, der glaube ich schon,

00:00:26.140 --> 00:00:28.260
also ich meine, das richtig gelesen zu haben, dass das

00:00:28.260 --> 00:00:30.360
jetzt schon für Python 3.12 irgendwie

00:00:30.360 --> 00:00:32.220
einen Compiler-Flag

00:00:32.220 --> 00:00:34.540
einführen soll, das den Global Interpreter

00:00:34.540 --> 00:00:35.740
Log optional macht.

00:00:36.340 --> 00:00:38.240
Also die letzten Woche große Neuigkeit,

00:00:38.380 --> 00:00:39.520
also ich glaube, zwei große Themen,

00:00:39.920 --> 00:00:40.840
Packaging und

00:00:40.840 --> 00:00:43.220
irgendwie diesen

00:00:43.220 --> 00:00:44.760
PEP 703.

00:00:46.000 --> 00:00:48.120
Ja, und ich habe dann auch so ein bisschen reingeguckt, ich bin ja

00:00:48.120 --> 00:00:50.020
immer so ein bisschen der Ansicht, oder ich habe

00:00:50.020 --> 00:00:51.160
dir so ein bisschen vertreten, dass

00:00:51.160 --> 00:00:53.920
ich das eigentlich nicht so ganz nachvollziehen kann, warum das

00:00:53.920 --> 00:00:55.860
nur so ein Riesenthema ist, weil, ehrlich gesagt,

00:00:55.860 --> 00:00:59.300
betrifft es mich meistens nicht, weil ich bin eigentlich bisher kaum je in die Situation gekommen,

00:00:59.920 --> 00:01:03.900
dass dieser Global Interpreter-Log für mich jetzt ein großes Problem gewesen wäre.

00:01:04.900 --> 00:01:08.900
Aber ich habe mir den jetzt nochmal angeguckt und tatsächlich, also es gibt da schon viele Situationen,

00:01:08.960 --> 00:01:12.340
wo einen das halt Ärger machen kann. Also mein Beispiel war, ich hatte ja mal gefragt,

00:01:12.420 --> 00:01:15.260
ob jemand ein anderes Beispiel hatte, also wenn ich jetzt eine Datenbank in Python schreiben will,

00:01:15.300 --> 00:01:19.580
dann könnte einem das Ärger machen. Und es gibt aber noch viel mehr Beispiele

00:01:19.580 --> 00:01:22.960
und da standen auch welche drin, wo ich dann sagen muss, okay, doch, das hat schon,

00:01:22.960 --> 00:01:25.380
Da haben Leute schon Probleme dann eventuell

00:01:25.380 --> 00:01:27.200
Gerade so im Data Science Bereich

00:01:27.200 --> 00:01:29.260
Das war mir gar nicht klar, also ganz wichtig ist

00:01:29.260 --> 00:01:31.060
da wohl, dass man halt nicht von

00:01:31.060 --> 00:01:32.720
unterschiedlichen Prozessen aus auf

00:01:32.720 --> 00:01:35.040
den GPU-Speicher zugreifen kann

00:01:35.040 --> 00:01:36.000
Tatsächlich, so richtig

00:01:36.000 --> 00:01:39.200
Und dann kriegt man natürlich sehr schnell ein Problem, wenn man da nicht

00:01:39.200 --> 00:01:41.200
mehrere Sets auf unterschiedlichen CPUs

00:01:41.200 --> 00:01:42.320
laufen lassen kann

00:01:42.320 --> 00:01:44.440
Ja, genau

00:01:44.440 --> 00:01:46.540
Ja

00:01:46.540 --> 00:01:48.640
Das war so, das ist

00:01:48.640 --> 00:01:50.420
ganz interessant gewesen

00:01:50.420 --> 00:01:52.500
Aber ist noch voll auch in Diskussion, oder?

00:01:52.500 --> 00:01:56.540
so einen klaren Konsens gibt es da noch nicht, oder? Hast du da einen Überblick?

00:01:56.720 --> 00:02:00.180
Ne, genau. Also die Diskussion habe ich mir teilweise angeguckt, aber auch nicht komplett und

00:02:00.180 --> 00:02:04.440
ob es jetzt wirklich kommt oder nicht, keine Ahnung. Es stand auch irgendwann ein Zeitplan in dem

00:02:04.440 --> 00:02:08.340
PEP selber drin, der eher so sagte, ja, also der Plan ist eher,

00:02:08.460 --> 00:02:11.720
das ab 2024 einzuführen und dann 2025,

00:02:12.140 --> 00:02:16.260
26 dann halt irgendwann dazu überzugehen,

00:02:16.340 --> 00:02:20.500
dass halt quasi...

00:02:20.500 --> 00:02:22.640
Ich weiß jetzt gar nicht mehr, welche Relation

00:02:22.640 --> 00:02:24.260
es war, so 13, 14, 15,

00:02:24.380 --> 00:02:26.560
dann irgendwann umzusteigen

00:02:26.560 --> 00:02:28.180
auf per default ist der

00:02:28.180 --> 00:02:30.140
Global Interpreter locker aus und dann

00:02:30.140 --> 00:02:32.580
irgendwann es zu deprecaten

00:02:32.580 --> 00:02:34.700
und dann bis irgendwann 2030 oder so wegfallen zu lassen.

00:02:34.800 --> 00:02:36.300
Aber das ist dann halt sehr weit in der Zukunft.

00:02:36.780 --> 00:02:37.420
Keine Ahnung.

00:02:38.020 --> 00:02:40.640
Und der Plan ist aber erstmal, das quasi hinter einer

00:02:40.640 --> 00:02:43.440
Interpreter-Compile-Time-Flag

00:02:43.440 --> 00:02:44.060
zu verstecken.

00:02:44.060 --> 00:02:44.540
Ja, okay.

00:02:45.980 --> 00:02:47.840
Jetzt haben wir ja direkt am Anfang

00:02:47.840 --> 00:02:48.780
sowas Schwieriges gemacht.

00:02:48.780 --> 00:02:53.140
Können wir vielleicht nochmal ganz kurz erklären, was nochmal ein Gehör ist?

00:02:53.720 --> 00:02:54.700
Ja, soll ich?

00:02:54.980 --> 00:02:55.780
Ja, gerne.

00:02:56.220 --> 00:03:00.460
Also das Problem ist einfach, dass der Python-Interpreter selber nicht Thread-safe ist,

00:03:01.140 --> 00:03:06.620
dass quasi die ganzen Datenstrukturen, die quasi der Interpreter selbst verwendet,

00:03:06.680 --> 00:03:09.120
halt nicht mit irgendwelchen Logs versehen sind,

00:03:09.200 --> 00:03:12.120
sondern es einfach nur davon ausgegangen wird in der Implementierung überall,

00:03:12.440 --> 00:03:18.340
dass zu jedem Zeitpunkt halt nur ein Thread wirklich Python-Code ausführen kann.

00:03:18.780 --> 00:03:22.640
und das führt dazu, dass man halt quasi, wenn man Python-Code schreibt,

00:03:23.440 --> 00:03:30.160
nur von einem Thread aus wirklich gerade ausführen kann.

00:03:31.200 --> 00:03:34.340
Und dazu, das hat halt die Auswirkung, es war lange kein Problem,

00:03:34.440 --> 00:03:37.440
weil halt keiner irgendwie ein Multiprozessor-System hatte,

00:03:37.600 --> 00:03:40.880
aber jetzt, wo es halt Multi-Core gibt seit 20 Jahren oder so,

00:03:42.280 --> 00:03:44.420
ist es halt immer wieder ein großes Diskussionsding,

00:03:44.420 --> 00:03:49.960
dass es halt nicht so toll ist, dass man wirklich Multithread-Algorithmen in Python schreiben kann.

00:03:50.340 --> 00:03:53.260
Ist das brauchbar zusammengefasst?

00:03:53.540 --> 00:03:54.640
Ja, doch, klingt gut.

00:03:55.340 --> 00:03:59.100
Und ich glaube, das Coole an der PEP ist eigentlich, dass halt wirklich eine Firma,

00:03:59.220 --> 00:04:00.980
nämlich Facebook, soweit ich das verstanden habe,

00:04:01.380 --> 00:04:06.000
die den nötigen, nicht ganz kleinen Engineering-Aufwand halt mal investiert hat,

00:04:06.260 --> 00:04:09.180
um sich anzuschauen, wie man den loswerden könnte.

00:04:09.180 --> 00:04:13.920
Also und halt auch, das Loswerden ist jetzt gar nicht so das prinzipielle Problem,

00:04:13.920 --> 00:04:15.940
sondern das Problem ist halt, man will den loswerden

00:04:15.940 --> 00:04:17.980
ohne dass Single-Threaded

00:04:17.980 --> 00:04:20.040
Python viel langsamer wird. Das ist quasi

00:04:20.040 --> 00:04:20.520
das Schwierige.

00:04:21.080 --> 00:04:23.700
Ja, weil es gab ja schon mal, Larry Hastings oder so

00:04:23.700 --> 00:04:25.380
hatte das, das ist jetzt auch fast 10 Jahre her oder so,

00:04:26.140 --> 00:04:27.140
hatte dieses

00:04:27.140 --> 00:04:29.080
Gilectomy-Projekt, wo

00:04:29.080 --> 00:04:31.700
eben halt auch versucht hat, das loszuwerden

00:04:31.700 --> 00:04:33.560
über so Fine-Grained Locking, weil

00:04:33.560 --> 00:04:35.400
normalerweise ist halt

00:04:35.400 --> 00:04:37.480
also für den Garbage-Collector braucht man

00:04:37.480 --> 00:04:40.080
das ganze Reference-Counting

00:04:40.080 --> 00:04:41.880
ist halt hinter dem Gil oder ist halt

00:04:41.880 --> 00:04:43.540
der Grund dafür, warum der Gil

00:04:43.540 --> 00:05:13.520
und Jochen unterhalten sich über die Programmiersprache Python

00:05:13.540 --> 00:05:18.840
und es gibt halt schon ein Ding, das kann man auch über Python installieren, ich habe das mal ausprobiert,

00:05:19.260 --> 00:05:28.920
das nennt sich irgendwie Python Nogil oder so, das macht nur 5% Performance einbußen,

00:05:29.400 --> 00:05:32.520
aber das hat auch noch ein paar Sachen da drin, die jetzt in dem aktuellen PEP nicht drin sind.

00:05:33.860 --> 00:05:38.560
Daher wäre das ein bisschen langsamer, aber 10% ist jetzt noch nicht so allzu viel.

00:05:38.920 --> 00:05:41.960
Es gibt auch noch so ein paar andere Sachen, wie zum Beispiel, man muss jetzt halt da,

00:05:41.960 --> 00:05:44.160
Es gibt dann so ein paar Tricks, die da verwendet werden

00:05:44.160 --> 00:05:45.660
und einer ist halt auch,

00:05:46.700 --> 00:05:47.880
dass es jetzt

00:05:47.880 --> 00:05:49.920
halt immer einen Pointer auf den Thread

00:05:49.920 --> 00:05:51.520
gibt in jedem Python-Objekt,

00:05:52.140 --> 00:05:53.700
der das erzeugt hat,

00:05:53.840 --> 00:05:55.620
weil man, wenn man gar nicht kritisiert hat, zwar kann man nur

00:05:55.620 --> 00:05:58.080
innerhalb von einem Thread erzeugten Sachen aufräumen,

00:05:58.600 --> 00:05:59.800
oder Reference-Counting macht,

00:05:59.900 --> 00:06:01.500
dann muss man das halt vielleicht nicht mehr locken,

00:06:01.960 --> 00:06:03.840
aber dann muss man halt sich merken, welcher Thread das war

00:06:03.840 --> 00:06:05.360
und das sind halt ein 64-Bit-Ding

00:06:05.360 --> 00:06:07.560
und dann hat man noch so

00:06:07.560 --> 00:06:09.260
einen Pointer auf,

00:06:10.060 --> 00:06:11.640
das ist gar nicht mehr genau, das sind insgesamt drei Pointer,

00:06:11.640 --> 00:06:12.820
die jedes Objekt mehr kriegt,

00:06:13.040 --> 00:06:15.740
und das sind halt

00:06:15.740 --> 00:06:16.760
24 Byte

00:06:16.760 --> 00:06:19.840
mehr pro Objekt, das ist schon nicht so ohne.

00:06:20.040 --> 00:06:21.260
Also Speichermess ist auch ganz schön.

00:06:22.400 --> 00:06:23.380
ja,

00:06:24.780 --> 00:06:26.580
ja, also

00:06:26.580 --> 00:06:29.620
es sind halt nur Trade-offs. Wenn man es gebrauchen kann,

00:06:29.760 --> 00:06:31.380
ist es vielleicht gut, aber wenn man es halt

00:06:31.380 --> 00:06:33.220
irgendwie nicht braucht, dann

00:06:33.220 --> 00:06:34.800
kann es auch sehr nervig sein.

00:06:35.360 --> 00:06:36.500
Und deswegen,

00:06:36.800 --> 00:06:38.460
und die C,

00:06:38.460 --> 00:06:39.980
dass dieses

00:06:39.980 --> 00:06:40.740
Application

00:06:40.740 --> 00:06:44.120
Binary Interface ist halt auch nicht mehr kompatibel,

00:06:44.660 --> 00:06:46.000
sodass halt man

00:06:46.000 --> 00:06:47.560
im Grunde halt die

00:06:47.560 --> 00:06:49.700
C-Extensions, also für

00:06:49.700 --> 00:06:50.020
jedes

00:06:50.020 --> 00:06:54.060
Paket, das

00:06:54.060 --> 00:06:55.640
halt eine C-Extension ist,

00:06:56.640 --> 00:06:57.320
muss man halt die

00:06:57.320 --> 00:06:59.620
entsprechend richtige Version installieren,

00:06:59.720 --> 00:07:00.960
für den Interpreter, den man verwendet.

00:07:00.960 --> 00:07:02.620
Also man muss quasi jede C-Extensions

00:07:02.620 --> 00:07:04.640
einmal anfassen und zum Teil die

00:07:04.640 --> 00:07:06.460
C-API

00:07:06.460 --> 00:07:08.240
Usage irgendwie dann

00:07:08.240 --> 00:07:10.520
korrekt machen und die Logs einführen,

00:07:10.580 --> 00:07:11.820
wenn das nicht 3D-safe ist.

00:07:12.560 --> 00:07:14.380
Also das ist halt möglicherweise schon auch Aufwand.

00:07:14.680 --> 00:07:14.920
Ja, ja.

00:07:16.600 --> 00:07:16.800
Ja.

00:07:18.420 --> 00:07:20.940
Also das wird dann tatsächlich ein Breaking Change

00:07:20.940 --> 00:07:22.840
sein, wenn die CX-Expansions

00:07:22.840 --> 00:07:24.280
dann nicht mehr gehen.

00:07:24.280 --> 00:07:25.920
Das ist dann eigentlich Python 4?

00:07:26.640 --> 00:07:28.260
Nee, also sag mal so, du kannst es ja parallel

00:07:28.260 --> 00:07:29.800
verwenden. Also wenn du das nicht nutzen willst...

00:07:29.800 --> 00:07:32.160
Ja, aber wenn der Default sich ändert...

00:07:32.160 --> 00:07:34.040
Ja, aber das ist dann irgendwann, das ist dann in der

00:07:34.040 --> 00:07:35.840
weiteren Zukunft. Also das ist dann noch Jahre heran.

00:07:35.840 --> 00:07:38.300
Ja, aber wenn das Python 3.5 ist, dann ist es Python 4.

00:07:39.080 --> 00:07:40.100
Ja gut, ich meine,

00:07:40.280 --> 00:07:42.200
wenn niemand bis dahin umgestellt hat und es keine

00:07:42.200 --> 00:07:43.880
Pakete gibt, dann wird man das wahrscheinlich einfach nicht machen.

00:07:44.420 --> 00:07:46.180
Wenn es alle schon machen, alle Relevanten,

00:07:46.520 --> 00:07:48.240
dann ist es halt auch nicht mehr so schlimm, wenn man das deflocated

00:07:48.240 --> 00:07:50.160
also, ja, keine Ahnung,

00:07:50.240 --> 00:07:52.360
ist wahrscheinlich jetzt sehr schwer, da irgendwelche Voraussagen zu machen.

00:07:53.280 --> 00:07:54.060
Aber, ja.

00:07:54.100 --> 00:07:56.100
Ich glaube, wir müssen nachher einfach, aber auf jeden Fall

00:07:56.100 --> 00:07:58.240
uns merken, dass wir noch ein bisschen über C-Extensions

00:07:58.240 --> 00:08:00.100
reden müssen. Oh ja, das finden wir.

00:08:00.280 --> 00:08:00.480
Ja.

00:08:01.960 --> 00:08:03.420
Wer war denn da bei Facebook nochmal mit dabei?

00:08:03.420 --> 00:08:04.160
War das Sam Gross?

00:08:04.160 --> 00:08:04.920
auch. Genau.

00:08:06.100 --> 00:08:07.880
Du hattest vielleicht den Vortrag auf der Europe

00:08:07.880 --> 00:08:09.380
halt den letzten Tag gesehen. Ja, ja.

00:08:10.100 --> 00:08:11.760
Ich habe nicht so viel verstanden, aber ich habe mir

00:08:11.760 --> 00:08:13.500
angefühlt. Okay, ja.

00:08:14.700 --> 00:08:15.940
Ja, ja, ist auch ein schwieriges Thema,

00:08:16.060 --> 00:08:16.820
glaube ich. Also

00:08:16.820 --> 00:08:20.260
einige der Ideen

00:08:20.260 --> 00:08:21.840
sind auch schon, also diese Geschichte mit den

00:08:21.840 --> 00:08:24.040
drei Pointern, die es jetzt gibt, es gab ein akademisches

00:08:24.040 --> 00:08:25.600
Paper dazu, wie man das denn bauen kann

00:08:25.600 --> 00:08:28.080
und da wurden diese Informationen,

00:08:28.080 --> 00:08:29.460
die darin stecken, in einen Pointer

00:08:29.460 --> 00:08:32.100
reingefiemelt irgendwie, reinkodiert

00:08:32.100 --> 00:08:34.120
und das war den Leuten aber dann

00:08:34.120 --> 00:08:35.200
jetzt zu heiß.

00:08:36.020 --> 00:08:37.340
Das ist zu gefährlich.

00:08:37.740 --> 00:08:39.320
Was kann da alles bei Overflows passieren?

00:08:41.240 --> 00:08:41.980
Daran sieht man schon,

00:08:42.100 --> 00:08:43.700
dass sie sich das nicht getraut haben,

00:08:43.760 --> 00:08:45.620
das einfach so zu übernehmen. Es ist kompliziert.

00:08:46.260 --> 00:08:47.640
Würdest du das Paper bitte auch verlinken?

00:08:47.700 --> 00:08:48.540
Das klingt eigentlich spannend.

00:08:48.660 --> 00:08:49.640
Ja, kann ich machen.

00:08:50.360 --> 00:08:53.300
Mach auch den Talk von der Europython rein, wenn es den irgendwo schon gibt.

00:08:53.680 --> 00:08:56.080
Okay, ich füge es mal hinzu.

00:08:56.620 --> 00:08:56.920
Alles klar.

00:08:57.340 --> 00:08:59.520
Er hat das nämlich genau erklärt, wie er das so vorhat.

00:09:00.300 --> 00:09:01.900
Und das ist schon...

00:09:01.900 --> 00:09:03.720
Er hat einige clevere Ideen dabei gehabt.

00:09:04.120 --> 00:09:06.260
auch ein spannender Typ, ja

00:09:06.260 --> 00:09:07.600
ja

00:09:07.600 --> 00:09:10.020
okay, habt ihr noch nichts

00:09:10.020 --> 00:09:11.300
du hast gesagt Packaging, ja ich hab noch

00:09:11.300 --> 00:09:12.520
ja Packaging

00:09:12.520 --> 00:09:15.680
ja das war ein anderes großes Thema, auch

00:09:15.680 --> 00:09:17.620
vor zwei Wochen oder so gestartet

00:09:17.620 --> 00:09:19.520
oder noch ein bisschen länger und das

00:09:19.520 --> 00:09:21.920
könnte halt immer noch so passieren, es gibt einen sehr sehr langen

00:09:21.920 --> 00:09:22.160
Thread

00:09:22.160 --> 00:09:26.040
ich weiß gar nicht genau wo war das denn

00:09:26.040 --> 00:09:27.660
das Ding heißt irgendwie

00:09:27.660 --> 00:09:30.080
Packaging Strategy Discussion Teil 1

00:09:30.080 --> 00:09:31.360
das ist auf DiscussPython.org

00:09:31.360 --> 00:09:33.000
ja und

00:09:33.000 --> 00:09:35.260
habe ich nicht ganz gelesen, das war mir dann zu viel,

00:09:35.440 --> 00:09:37.140
aber es gab,

00:09:37.220 --> 00:09:38.360
dann haben auch diverse Leute da

00:09:38.360 --> 00:09:41.180
längere Blogposts geschrieben, was sie denn so denken.

00:09:41.600 --> 00:09:42.980
Also ja, das Problem ist natürlich

00:09:42.980 --> 00:09:45.240
irgendwie bei allen Umfragen, die man zum Thema

00:09:45.240 --> 00:09:46.940
Python macht,

00:09:47.060 --> 00:09:49.140
dann wird das von Leuten, die da nicht

00:09:49.140 --> 00:09:51.000
so erfahren sind, immer als Painpoint Nummer

00:09:51.000 --> 00:09:53.080
eins beschrieben, dass es halt so kompliziert

00:09:53.080 --> 00:09:55.080
ist und dass man nicht weiß, was man

00:09:55.080 --> 00:09:57.040
denn jetzt nehmen soll für welche Tools und

00:09:57.040 --> 00:09:59.060
wie man die denn jetzt, am besten wie rum man die

00:09:59.060 --> 00:10:00.720
hält, damit es nicht irgendwie

00:10:00.720 --> 00:10:02.880
keine furchtbaren Sachen passieren und

00:10:02.880 --> 00:10:05.020
ja, das ist ein Problem und

00:10:05.020 --> 00:10:07.260
aber es gibt auch keine so richtig einfache

00:10:07.260 --> 00:10:07.600
Lösung.

00:10:09.400 --> 00:10:11.060
Ja, und ich weiß es nicht so genau. Ich glaube, das

00:10:11.060 --> 00:10:13.080
Fazit war mehr so, ja, es liegt halt

00:10:13.080 --> 00:10:15.000
vor allen Dingen daran, dass halt auch Python einfach sehr alt ist

00:10:15.000 --> 00:10:17.060
und Leute das auf sehr unterschiedliche Art verwenden und

00:10:17.060 --> 00:10:19.080
man kann es nicht gut lösen, weil

00:10:19.080 --> 00:10:20.980
man kann nicht allen gerecht werden,

00:10:21.340 --> 00:10:23.300
weil manche Leute brauchen halt sehr feingranulare

00:10:23.300 --> 00:10:24.880
Geschichten und andere lieber

00:10:24.880 --> 00:10:26.620
ein Einfaches Interface und das kann man

00:10:26.620 --> 00:10:28.760
ja, wie will man das unter einen Hut bringen?

00:10:28.860 --> 00:10:30.720
Das ist schwierig. Also, auch interessant,

00:10:30.720 --> 00:10:32.780
fand ich genau, ich weiß nicht, ob das in dem Zusammenhang

00:10:32.780 --> 00:10:34.580
aufgetaucht ist, aber das war auch erst wenige Wochen alt, von

00:10:34.580 --> 00:10:36.060
Nathaniel Smith, ein

00:10:36.060 --> 00:10:38.620
neuer Paketspracher, Posey heißt er,

00:10:38.960 --> 00:10:40.440
oder Posey, ich weiß nicht genau, wie man das ausspricht,

00:10:41.280 --> 00:10:42.800
der ist das eine, ein Rust-Binary,

00:10:43.040 --> 00:10:44.760
die quasi das ganze Zeugs von

00:10:44.760 --> 00:10:46.960
Python übernehmen soll, also den Interpreter mit ausliefern

00:10:46.960 --> 00:10:48.840
und Pakete bauen und

00:10:48.840 --> 00:10:50.840
Dependencies bauen und

00:10:50.840 --> 00:10:52.260
deren Graphen bauen und so, und das

00:10:52.260 --> 00:10:54.840
sah, fand ich, relativ interessant aus, weil genau

00:10:54.840 --> 00:10:56.880
das auch eines der Pages, die allen Leuten, mit denen ich

00:10:56.880 --> 00:10:58.000
irgendwas mit Python machen will, erstmal

00:10:58.000 --> 00:11:00.480
erklären muss, hä, wie geht denn das? Oh, das ist aber kompliziert

00:11:00.480 --> 00:11:01.380
und warum ist das denn so?

00:11:02.380 --> 00:11:04.220
Ja, also bald dann halt, also wenn die einen Python machen,

00:11:04.300 --> 00:11:06.360
okay, aber wenn die nochmal eine andere Python-Version, irgendwann habe ich es ja später

00:11:06.360 --> 00:11:08.280
so, geht alles kaputt und Python-Python

00:11:08.280 --> 00:11:10.440
und dies, das ist für einige Menschen gar nicht so einfach

00:11:10.440 --> 00:11:12.240
zu handeln. Ja, und Natalia ist auch jemand,

00:11:12.340 --> 00:11:14.360
der man quasi dem Geschmack zutraut,

00:11:14.460 --> 00:11:15.400
das richtig gut zu machen.

00:11:15.640 --> 00:11:18.380
Ja, ja, ja, also bekannt

00:11:18.380 --> 00:11:20.320
wie, er hat ja Trio

00:11:20.320 --> 00:11:22.380
geschrieben, also eine andere Implementation

00:11:22.380 --> 00:11:24.320
für so Async-Geschichten

00:11:24.320 --> 00:11:26.360
und eine andere

00:11:26.360 --> 00:11:27.720
Art, das zu machen, hat auch einen sehr

00:11:27.720 --> 00:11:29.900
tollen Artikel geschrieben

00:11:29.900 --> 00:11:32.020
irgendwie für Structured Concurrency,

00:11:32.320 --> 00:11:34.220
den verlinke ich auch mal gerne

00:11:34.220 --> 00:11:36.320
oder sage Leuten, dass sie das mal durchlesen sollen.

00:11:37.680 --> 00:11:38.340
Ja, insofern,

00:11:38.580 --> 00:11:39.780
ja genau, das habe ich auch direkt

00:11:39.780 --> 00:11:41.580
aufforschen lassen und nicht gehört, wer das gemacht hat.

00:11:43.600 --> 00:11:43.760
Ja,

00:11:43.980 --> 00:11:45.380
auf der anderen Seite weiß ich jetzt nicht so genau,

00:11:45.960 --> 00:11:47.940
also er schreibt, gut, er macht das jetzt in Rust, weil

00:11:47.940 --> 00:11:49.840
er wollte schon immer mal was für Rust machen.

00:11:50.260 --> 00:11:52.060
Ich weiß nicht genau, wo man das unbedingt, also alle

00:11:52.060 --> 00:11:54.080
Leute machen momentan irgendwie Dinge, Tooling in Rust.

00:11:54.080 --> 00:11:58.180
Bei JavaScript verstehe ich das so ein bisschen, weil

00:11:58.180 --> 00:12:00.260
die haben da, also jede Änderung

00:12:00.260 --> 00:12:02.080
im Code führt halt dazu, dass irgendwie so 20

00:12:02.080 --> 00:12:04.300
Transpiler, irgendwelche

00:12:04.300 --> 00:12:06.040
Linter, sonst was irgendwie loslaufen und Dinge machen

00:12:06.040 --> 00:12:07.240
und

00:12:07.240 --> 00:12:10.000
wenn dann jedes Mal so ein fetter Node.js-Prozess

00:12:10.000 --> 00:12:12.360
gestartet wird, dann

00:12:12.360 --> 00:12:14.040
dauert das, dann addiert sich das

00:12:14.040 --> 00:12:16.060
natürlich irgendwie auf in der Latenz, aber

00:12:16.060 --> 00:12:18.140
Python hat man das ja so eigentlich auch nicht

00:12:18.140 --> 00:12:20.240
Ja, aber immerhin hast du eine vorkompilierte Binary

00:12:20.240 --> 00:12:22.060
die du irgendwie ausliefern kannst und in Rust ist das

00:12:22.060 --> 00:12:24.060
vielleicht so einen Typen sicher und irgendwie ordentlich

00:12:24.060 --> 00:12:26.080
schnell. Und ich glaube, man kann

00:12:26.080 --> 00:12:28.160
die halt auch relativ leicht dann so statisch

00:12:28.160 --> 00:12:30.040
verlinken und hat halt wirklich nur eine

00:12:30.040 --> 00:12:31.940
Datei. Ja, genau. Ja, okay.

00:12:32.020 --> 00:12:33.760
Ansonsten hat man das Bootstrapping-Problem, dass man erstmal

00:12:33.760 --> 00:12:35.700
einen Package-Manager installieren muss, damit man

00:12:35.700 --> 00:12:38.000
sich den richtigen Package-Manager, also das Problem

00:12:38.000 --> 00:12:38.940
das Poetry hat mit dem

00:12:38.940 --> 00:12:41.540
curl und get Poetry

00:12:41.540 --> 00:12:43.800
schrecklich Shell-Skript irgendwie von

00:12:43.800 --> 00:12:44.700
einer Webseite ausführen, ja.

00:12:45.820 --> 00:12:47.540
Ja, okay. Gut, das löst es. Das stimmt.

00:12:48.220 --> 00:12:49.860
Ja. Das sind so ein paar Sachen,

00:12:49.980 --> 00:12:51.680
die glaube ich echt gar nicht schlecht sind. Also ja, aber was das

00:12:51.680 --> 00:12:53.220
Cool, also ich hab's auch mal ein bisschen ausprobiert

00:12:53.220 --> 00:12:54.700
in Advent of Cody, aber

00:12:54.700 --> 00:12:57.260
die Weihnachtszeit ist ja jetzt schon wieder

00:12:57.260 --> 00:12:59.000
vorbei. Ich weiß nicht, was ich

00:12:59.000 --> 00:12:59.960
finde, also ich meine,

00:13:00.760 --> 00:13:03.140
das, was ich meistens verwende, ist halt für Pakete

00:13:03.140 --> 00:13:05.160
bauen, Flit, das macht

00:13:05.160 --> 00:13:07.080
eigentlich nur das, ansonsten verwende ich für Abhängigkeit

00:13:07.080 --> 00:13:07.720
PipTools

00:13:07.720 --> 00:13:10.940
und, ja.

00:13:11.220 --> 00:13:13.080
Ja, PipTools fand ich ja fürchterlich, aber du findest Poetry

00:13:13.080 --> 00:13:15.040
fürchterlich und was Poetry ist auch... Ich hab Poetry lange

00:13:15.040 --> 00:13:17.620
verwendet, also fürchterlich ist...

00:13:17.620 --> 00:13:19.020
Ja, wir hatten uns ja, glaube ich, das war schon

00:13:19.020 --> 00:13:20.280
ein, zwei Folgen her, mal über dieses

00:13:20.280 --> 00:13:22.660
Problem mit den Dependencies

00:13:22.660 --> 00:13:24.060
irgendwie schon auseinandergesetzt.

00:13:26.340 --> 00:13:28.540
Warum das vielleicht blöd ist, aber ich sage mal so,

00:13:28.640 --> 00:13:30.360
theoretisch kann man die ja trotzdem einfach dann

00:13:30.360 --> 00:13:32.360
selber einstellen in der

00:13:32.360 --> 00:13:33.080
PyProject-Hummel.

00:13:34.460 --> 00:13:36.280
Das Problem ist, dass

00:13:36.280 --> 00:13:38.100
Poetry implizit halt,

00:13:39.480 --> 00:13:40.380
wenn man sagt Poetry

00:13:40.380 --> 00:13:41.560
add irgendein Paket,

00:13:42.160 --> 00:13:44.400
irgendwie ein Upper Bound auf die

00:13:44.400 --> 00:13:45.940
Version macht,

00:13:46.560 --> 00:13:48.280
was für, wenn man eine Library schreibt,

00:13:48.280 --> 00:13:49.940
für andere halt sehr blöd ist, weil die dann sofort

00:13:49.940 --> 00:13:52.800
und Dependency-Problemen laufen, Konflikte laufen.

00:13:53.200 --> 00:13:54.940
Man muss ja manuell quasi tatsächlich dann...

00:13:54.940 --> 00:13:56.240
Ja, aber...

00:13:56.240 --> 00:13:57.520
Naja, gut.

00:13:58.320 --> 00:13:59.000
Ach ja, genau.

00:13:59.160 --> 00:14:00.700
Das ist, glaube ich, eine gute Idee.

00:14:00.780 --> 00:14:01.300
Keine Lösung.

00:14:01.640 --> 00:14:02.460
Ich habe letztens gesehen,

00:14:02.520 --> 00:14:05.980
PipTools in PyProject Hummel irgendwie reingemeldet.

00:14:06.480 --> 00:14:10.140
Ja, letzte Woche war PyGDF-Treffen

00:14:10.140 --> 00:14:14.340
und Jens hat mir das mal erzählt,

00:14:14.440 --> 00:14:16.040
dass er das jetzt macht, er benutzt PipTools.

00:14:16.040 --> 00:14:18.500
Ist auch nicht so super, nicht hundertprozentig zufrieden,

00:14:18.500 --> 00:14:20.260
aber irgendwie

00:14:20.260 --> 00:14:23.040
benutzt er das auch häufiger

00:14:23.040 --> 00:14:25.020
und hat einen Weg gefunden, wie man das

00:14:25.020 --> 00:14:27.120
relativ einfach, die Abhängigkeiten auch in

00:14:27.120 --> 00:14:29.060
der PyProject-Tunnel da reinschreiben

00:14:29.060 --> 00:14:31.080
kann und hat mir mal gezeigt, wie man das macht

00:14:31.080 --> 00:14:32.600
das könnte ich auch verlinken, stimmt

00:14:32.600 --> 00:14:34.240
ist natürlich auch nicht so schlecht

00:14:34.240 --> 00:14:36.420
weil dann hat man alles wieder

00:14:36.420 --> 00:14:38.760
im Moment ist das ganze Packaging und

00:14:38.760 --> 00:14:40.940
Dependency-Management-Zeugs irgendwie relativ

00:14:40.940 --> 00:14:41.480
furchtbar

00:14:41.480 --> 00:14:44.620
das funktioniert auch nicht US-übergreifend gut

00:14:44.620 --> 00:14:45.440
und das ist

00:14:45.440 --> 00:14:49.580
ziemlich amiss. Ich hoffe ja wirklich, dass dieses RAS-Paket da einiges

00:14:49.580 --> 00:14:53.200
ändert, weil das will man so alles nicht haben.

00:14:55.000 --> 00:14:57.560
Ja, wird uns noch eine Zeit lang begleiten.

00:14:59.860 --> 00:15:01.220
Okay,

00:15:02.080 --> 00:15:05.660
kommen wir zu erfreulicheren Dingen. Django gibt es jetzt eine neue Alpha-Version,

00:15:05.660 --> 00:15:09.380
also die Django 4.2 kommt im März irgendwann, hoffentlich.

00:15:09.840 --> 00:15:12.680
Ist das wieder die LTS? Ja,

00:15:12.680 --> 00:15:14.740
Ja, genau, wobei das

00:15:14.740 --> 00:15:16.880
nicht so eine große Rolle spielt, die offizielle Empfehlung an der Stelle

00:15:16.880 --> 00:15:19.200
ist immer, die letzte

00:15:19.200 --> 00:15:20.600
Stabile zu nehmen und nicht LTS

00:15:20.600 --> 00:15:22.840
LTS ist mehr so, naja, es gibt halt Firmen, die das

00:15:22.840 --> 00:15:24.820
irgendwie haben wollen oder keine Ahnung, aber das

00:15:24.820 --> 00:15:27.020
ist nicht mehr so, wie man das machen sollte, es wird nicht empfohlen

00:15:27.020 --> 00:15:28.980
immer auf den LTS Version zu bleiben

00:15:28.980 --> 00:15:31.080
dafür verlangt sich auch einfach zu wenig

00:15:31.080 --> 00:15:32.740
also es gibt schon lange nicht mehr

00:15:32.740 --> 00:15:34.660
irgendwie so große Probleme, wenn man

00:15:34.660 --> 00:15:36.720
upgradet, daher braucht man das

00:15:36.720 --> 00:15:37.840
eigentlich nicht mehr so wirklich

00:15:37.840 --> 00:15:40.380
Genau, was dabei ist, ist

00:15:40.380 --> 00:15:43.140
ganz nett, PsychoPG3

00:15:43.140 --> 00:15:44.340
Support, das heißt Async

00:15:44.340 --> 00:15:46.260
Datenbank

00:15:46.260 --> 00:15:48.740
Unterstützung kommt damit halt so rücknäher.

00:15:48.740 --> 00:15:50.540
Es gibt ja jetzt auch ein Interface

00:15:50.540 --> 00:15:51.860
seit Django 4.1

00:15:51.860 --> 00:15:54.780
für Async-Geschichten mit dem

00:15:54.780 --> 00:15:56.980
ORM. Ist alles noch nicht wirklich implementiert,

00:15:57.060 --> 00:15:58.640
aber das Interface ist schon mal da, sodass man das

00:15:58.640 --> 00:16:00.540
halt so verwenden kann, dass wenn irgendwann

00:16:00.540 --> 00:16:02.620
sich unten drunter das mal so verändert, dass halt mehrere

00:16:02.620 --> 00:16:04.700
Sachen gleichzeitig irgendwie an die

00:16:04.700 --> 00:16:05.780
Datenbank geschickt werden und dann

00:16:05.780 --> 00:16:08.720
wieder zurückkommen, dass es einfach so,

00:16:08.720 --> 00:16:38.700
und Jochen unterhalten sich über die Programmiersprache Python

00:16:38.720 --> 00:17:08.700
und Jochen unterhalten sich über die Programmiersprache Python

00:17:08.720 --> 00:17:17.200
Und wie stellt die Datenbank sicher, dass ich jetzt keine Probleme habe festzustellen, dass Dinge auf die gleichen Stellen zugreifen?

00:17:17.520 --> 00:17:18.880
Ja, das ist ja das, was die Datenbank eigentlich...

00:17:18.880 --> 00:17:22.960
Das ist ja so die Kernkompetenz eines Datenbankmanagementsystems sozusagen.

00:17:23.080 --> 00:17:24.180
Ja, aber...

00:17:24.180 --> 00:17:25.380
Wie soll das hängen?

00:17:25.620 --> 00:17:31.220
Ja, 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.220 --> 00:17:37.900
Ja, aber die Datenbank muss ja gucken, dass sie einen Log setzt dann irgendwie und dann muss sie halt irgendwie gucken, ist das Log auch da oder muss halt eins setzen, wenn sie da irgendwie dran rumfuchtelt.

00:17:37.900 --> 00:17:39.000
und dann muss ich es wieder machen.

00:17:39.080 --> 00:17:40.920
Du meinst jetzt so Richtung Right-Zugriff oder was?

00:17:40.920 --> 00:17:43.960
Ja, aber ich meine, dann schaust du an eine Transaktion

00:17:43.960 --> 00:17:44.720
und siehst, dass dann

00:17:44.720 --> 00:17:47.160
eine konsistente Sicht der Dinge

00:17:47.160 --> 00:17:49.360
innerhalb der Transaktion

00:17:49.360 --> 00:17:51.140
oder die wird halt dann committed oder aborted

00:17:51.140 --> 00:17:53.380
und ich glaube,

00:17:53.480 --> 00:17:54.680
ich stimme dir zu,

00:17:55.040 --> 00:17:57.340
Jochen, zu, dass das halt genau das ist, was die Datenbank

00:17:57.340 --> 00:17:59.500
im Prinzip richtig gut können sollte.

00:18:00.620 --> 00:18:03.220
Aber das macht ihr doch eigentlich dann langsam, oder?

00:18:03.960 --> 00:18:05.560
Ja, natürlich macht das alles

00:18:05.560 --> 00:18:07.200
viel langsamer, wenn man Transaktionen ausschaltet

00:18:07.200 --> 00:18:08.740
und F-Sync ausschaltet, dann wird das

00:18:08.740 --> 00:18:09.840
mit der Datenbank viel schneller.

00:18:10.340 --> 00:18:12.860
Aber das Problem ist halt, dann sind deine Daten eventuell auch weg.

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

00:18:14.480 --> 00:18:15.220
Das ist doch wieder doof.

00:18:17.420 --> 00:18:17.820
Aber

00:18:17.820 --> 00:18:21.280
dieses Problem

00:18:21.280 --> 00:18:22.960
hast du auch, wenn du zwei Frontends

00:18:22.960 --> 00:18:25.220
hast, die auf den gleichen Daten arbeiten, hast du das ja auch schon.

00:18:25.520 --> 00:18:27.100
Auch ohne, dass die Frontends

00:18:27.100 --> 00:18:28.600
in sich selber nochmal irgendwie

00:18:28.600 --> 00:18:30.540
Concurrent-Dinge machen. Die machen ja auch

00:18:30.540 --> 00:18:33.160
Sachen Concurrent auf Prozessebene

00:18:33.160 --> 00:18:34.300
oder auf Rechner-Ebene,

00:18:34.300 --> 00:18:36.620
die da auf die gleiche Datenbank zugreifen.

00:18:36.620 --> 00:18:38.080
also das sollten die Daten

00:18:38.080 --> 00:18:39.140
schon können

00:18:39.140 --> 00:18:40.620
ja

00:18:40.620 --> 00:18:44.600
gut, man hat nochmal ein bisschen Probleme

00:18:44.600 --> 00:18:45.680
weil

00:18:45.680 --> 00:18:47.780
zum Beispiel Postgres kann halt nur

00:18:47.780 --> 00:18:50.840
es kommt darauf an, welches Protokoll man verwendet

00:18:50.840 --> 00:18:52.700
aber das Textprotokoll

00:18:52.700 --> 00:18:54.400
von Postgres kann halt nur

00:18:54.400 --> 00:18:56.620
eine Query gleichzeitig

00:18:56.620 --> 00:18:58.240
beantworten, das heißt

00:18:58.240 --> 00:19:00.600
bisher war das kein Problem, weil man kann sowieso immer nur

00:19:00.600 --> 00:19:01.760
im Code

00:19:01.760 --> 00:19:04.300
synchron eins nach dem anderen machen

00:19:04.300 --> 00:19:06.540
aber jetzt kann man ja mehrere, das heißt man muss

00:19:06.540 --> 00:19:08.020
auch mehrere Verbindungen aufmachen,

00:19:08.600 --> 00:19:10.400
weil halt immer nur ein Query pro

00:19:10.400 --> 00:19:11.840
Verbindung geht.

00:19:12.400 --> 00:19:13.260
Das heißt, da muss man dann

00:19:13.260 --> 00:19:16.440
intern poolen oder muss irgendwie

00:19:16.440 --> 00:19:18.540
aus dem Pool

00:19:18.540 --> 00:19:20.620
fallen. Das ist sowieso alles sehr kompliziert.

00:19:20.720 --> 00:19:22.500
Auch die ganze Geschichte im ORM, was man dann umstellen muss,

00:19:22.620 --> 00:19:24.420
das wird noch lange dauern, bis das alles

00:19:24.420 --> 00:19:26.460
richtig funktioniert. Aber wenn es dann mal

00:19:26.460 --> 00:19:27.460
irgendwann funktioniert, ist das ja cool.

00:19:29.100 --> 00:19:30.580
Und das ist jetzt ein Schritt, ein weiterer

00:19:30.580 --> 00:19:32.640
Schritt dahin. Also wir haben jetzt async ORM,

00:19:32.760 --> 00:19:34.300
async Views, async Tests.

00:19:34.300 --> 00:19:36.820
Ja, ja, also ORM haben wir noch nicht

00:19:36.820 --> 00:19:37.840
Wir haben nur die Interfaces

00:19:37.840 --> 00:19:41.480
Jetzt auch den Support für eine Library, die wir dafür brauchen

00:19:41.480 --> 00:19:42.380
um das überhaupt machen zu können

00:19:42.380 --> 00:19:44.480
Das heißt, das letzte was wir anstellen ist ORM

00:19:44.480 --> 00:19:47.460
Genau, das ist halt

00:19:47.460 --> 00:19:48.820
auch noch das komplizierteste Stück Arbeit

00:19:48.820 --> 00:19:50.860
was noch da bevorsteht, genau

00:19:50.860 --> 00:19:53.260
Ja, dann

00:19:53.260 --> 00:19:55.240
es gibt jetzt Unterstützung

00:19:55.240 --> 00:19:57.260
für Kommentare, für Spalten

00:19:57.260 --> 00:19:59.220
und Tabellen, das ist irgendwie

00:19:59.220 --> 00:20:01.320
ein Issue, der ist seit Jahren offen

00:20:01.320 --> 00:20:03.340
und war irgendwie kompliziert zu fixen

00:20:03.340 --> 00:20:05.520
ging nicht so gut, aus welchen Gründen auch immer, ich weiß gar nicht genau.

00:20:05.820 --> 00:20:07.520
Das geht jetzt. Also sie haben irgendwie

00:20:07.520 --> 00:20:09.700
einen Weg gefunden, wie sie das so hinkriegen, dass es kein Problem mehr ist.

00:20:10.740 --> 00:20:11.540
Und das

00:20:11.540 --> 00:20:12.440
ganz nett ist,

00:20:13.060 --> 00:20:15.780
ab dann

00:20:15.780 --> 00:20:16.700
wird man halt eventuell,

00:20:17.060 --> 00:20:19.180
es gibt so Django

00:20:19.180 --> 00:20:20.840
in-memory-storage, ich weiß nicht genau,

00:20:21.660 --> 00:20:23.260
gibt es ein externes Paket, das sie nicht mehr brauchen,

00:20:23.340 --> 00:20:25.320
das ist dann auch in Django selber drin. Das heißt,

00:20:25.380 --> 00:20:26.120
man hat jetzt ein

00:20:26.120 --> 00:20:29.440
in-memory-storage-backend für

00:20:29.440 --> 00:20:31.580
Django mit dabei, das man einfach so verwenden kann

00:20:31.580 --> 00:20:32.300
für Tests zum Beispiel.

00:20:32.300 --> 00:20:34.180
und macht halt Tests einfach schneller.

00:20:35.200 --> 00:20:36.560
Und, das freut mich

00:20:36.560 --> 00:20:38.620
besonders, es gibt jetzt

00:20:38.620 --> 00:20:41.120
eine Streaming-HTTP-Response

00:20:41.120 --> 00:20:42.940
mit Async-Iteratoren

00:20:42.940 --> 00:20:45.120
dran. Das ist im Grunde,

00:20:46.420 --> 00:20:46.940
wenn man jetzt

00:20:46.940 --> 00:20:48.480
zum Beispiel Files ausliefern will,

00:20:49.700 --> 00:20:51.120
ist das halt

00:20:51.120 --> 00:20:52.880
ein Problem. Das ging bisher nicht so gut,

00:20:52.960 --> 00:20:54.980
einfach deswegen, weil man

00:20:54.980 --> 00:20:57.140
da halt über die Blocks

00:20:57.140 --> 00:20:58.660
eines Files, die man rausschicken wollte,

00:20:58.760 --> 00:21:00.760
da so nicht Async drüber

00:21:00.760 --> 00:21:01.300
iteriert hat.

00:21:02.300 --> 00:21:10.500
und genau, ich habe da ja mal auf der Django 2021 einen Vortrag, wie kann man eigentlich Files mit Django

00:21:10.500 --> 00:21:16.720
serven, gehalten, da habe ich das halt, dieses Ding rausgepatcht, irgendwie so per Monkey Patching

00:21:16.720 --> 00:21:21.200
und es gibt auch ein Paket Django File Response, wo ich das so mache, das ist dann nicht mehr nötig,

00:21:21.260 --> 00:21:24.720
weil das macht jetzt also ein Iterator, das heißt, es müsste eigentlich Files serven, müsste jetzt einfach so gehen.

00:21:25.660 --> 00:21:26.820
Ja, das ist natürlich auch sehr cool.

00:21:27.160 --> 00:21:31.860
Wir haben noch ein paar Konferenzen von zweien, weiß ich jetzt schon die Daten,

00:21:32.300 --> 00:21:40.780
DjangoCon EU ist irgendwie 29. Mai bis 2. Juni 2023 in Edinburgh.

00:21:43.180 --> 00:21:44.920
Edinburgh. Ich weiß gar nicht, sprechen wir uns auf?

00:21:44.920 --> 00:21:45.100
Edinburgh.

00:21:45.420 --> 00:21:53.300
Okay. Tja. Und PyCon.de oder PyData ist in Berlin 17. bis 19. April. Da gehe ich wahrscheinlich auch hin.

00:21:53.660 --> 00:21:58.780
Europice ist vom 17. bis zum 23. Juli.

00:21:59.620 --> 00:22:00.060
Okay.

00:22:00.060 --> 00:22:01.180
Aber ich weiß nicht wo.

00:22:01.180 --> 00:22:02.180
Okay.

00:22:02.680 --> 00:22:07.120
Damit auch ja keiner

00:22:07.120 --> 00:22:08.260
einen guten Flug buchen kann.

00:22:09.640 --> 00:22:11.220
Das wird auch in Europa passieren wahrscheinlich.

00:22:11.340 --> 00:22:12.920
Oder das ins Budget fürs Jahr einplanen kann.

00:22:13.860 --> 00:22:15.700
Für was auch immer.

00:22:17.380 --> 00:22:19.100
Ich glaube gerade das Management-Team hat da gewechselt.

00:22:20.560 --> 00:22:20.700
Ja.

00:22:21.720 --> 00:22:23.100
Also die letzte hat noch

00:22:23.100 --> 00:22:25.220
Mark and Re mit organisiert und jetzt machen das

00:22:25.220 --> 00:22:25.900
irgendwie andere Menschen.

00:22:25.900 --> 00:22:26.340
Okay.

00:22:27.140 --> 00:22:29.780
Die haben so eine neue Art und Weise wollen die machen mit

00:22:29.780 --> 00:22:32.740
und wer das wie veranstaltet und sich was Neues Konzepte überlegt.

00:22:33.500 --> 00:22:34.480
Mal gucken, ich bin gespannt.

00:22:35.580 --> 00:22:35.900
Jojo.

00:22:36.560 --> 00:22:41.440
Okay, ja, nee, dann, das wäre ja nach nur fast 20 Minuten mit den News durch,

00:22:41.660 --> 00:22:45.800
diesmal relativ flott, dann kommen wir zum Hauptthema.

00:22:45.800 --> 00:22:46.640
Dann eine ganz schnelle Folge.

00:22:47.120 --> 00:22:47.680
Das glaube ich nicht.

00:22:47.980 --> 00:22:48.660
Wie bei PyPy?

00:22:49.200 --> 00:22:49.420
Ja.

00:22:50.060 --> 00:22:52.060
Warum mal, ja, die Folge ist ja PyPy.

00:22:52.420 --> 00:22:54.240
Macht man damit nicht was schneller oder was ist der Zweck davon?

00:22:54.560 --> 00:22:55.760
Oder weißt du was, womit wir anfangen?

00:22:56.260 --> 00:22:57.240
Karl, wer bist du denn eigentlich?

00:22:57.240 --> 00:22:57.480
Hi.

00:22:57.820 --> 00:22:58.060
Hi.

00:22:58.320 --> 00:22:58.480
Hallo.

00:22:58.600 --> 00:23:00.140
Ich gehe hier schon die ganze Zeit so meinen Senf dazu.

00:23:01.280 --> 00:23:04.980
Aber ja, also ich bin Karl-Friedrich Bolz-Tereik.

00:23:05.060 --> 00:23:11.500
Ich bin hier an der Uni ein wissenschaftlicher Angestellter in Düsseldorf und habe da eine

00:23:11.500 --> 00:23:17.240
halbe Stelle und bin im Prinzip angestellt, um eine Python-Einführung zu halten jedes

00:23:17.240 --> 00:23:20.820
Semester für Leute, die nicht Informatik studieren.

00:23:20.960 --> 00:23:22.820
Also das ist so Studium Universale mäßig.

00:23:22.820 --> 00:23:25.920
und wenn ich die

00:23:25.920 --> 00:23:28.880
gemacht habe, kann ich die restliche Zeit

00:23:28.880 --> 00:23:31.720
so ein bisschen frei einteilen. Das ist eigentlich ein ganz

00:23:31.720 --> 00:23:34.940
angenehmer Deal und ich bin

00:23:34.940 --> 00:23:37.800
seit 2005

00:23:37.800 --> 00:23:40.860
ungefähr einer der Kernentwickler des

00:23:40.860 --> 00:23:44.000
PyPy-Projekts, über das wir jetzt auch dann gleich

00:23:44.000 --> 00:23:46.960
noch mehr reden wollen. Also ich habe da halt irgendwie am Anfang

00:23:46.960 --> 00:23:49.160
von meinem Studium angefangen. Ich war dann auch bei

00:23:49.160 --> 00:23:51.500
den EU-Projekten,

00:23:51.900 --> 00:23:53.780
die da am Anfang eine Zeit lang

00:23:53.780 --> 00:23:56.020
für Finanzierung gesorgt haben,

00:23:56.500 --> 00:23:58.340
recht intensiv

00:23:58.340 --> 00:24:00.220
involviert und bin halt

00:24:00.220 --> 00:24:01.960
so mit mal mehr, mal weniger

00:24:01.960 --> 00:24:03.880
Involvierung seitdem immer wieder

00:24:03.880 --> 00:24:06.040
halt dran beteiligt.

00:24:09.180 --> 00:24:10.420
Also an dem Open Source

00:24:10.420 --> 00:24:11.760
fandet Ding, was dann PyPy

00:24:11.760 --> 00:24:12.900
direkt entwickelt.

00:24:14.080 --> 00:24:15.860
Genau, also ich bin jetzt quasi einfach

00:24:15.860 --> 00:24:17.680
erstmal nur so quasi

00:24:17.680 --> 00:24:19.880
nur einer der Kernentwickler,

00:24:20.060 --> 00:24:21.620
also die halt quasi Commit Rights

00:24:21.620 --> 00:24:23.540
und Zeug machen.

00:24:24.100 --> 00:24:25.480
Ich bin aber halt auch einer der

00:24:25.480 --> 00:24:27.780
recht Aktiven im Moment, also

00:24:27.780 --> 00:24:29.660
das Projekt schrumpft so ein bisschen,

00:24:29.800 --> 00:24:31.180
da können wir vielleicht später auch noch drüber reden

00:24:31.180 --> 00:24:33.560
und ich bin einer

00:24:33.560 --> 00:24:35.500
derjenigen, die jetzt halt gerade noch viel,

00:24:36.220 --> 00:24:36.940
recht viel machen.

00:24:39.860 --> 00:24:41.840
Genau, aber das Projekt

00:24:41.840 --> 00:24:43.680
hatte über seine Lebenszeit halt immer

00:24:43.680 --> 00:24:45.260
wieder auch Phasen, wo das wirklich auch

00:24:45.260 --> 00:24:46.300
viel Geld hatte.

00:24:46.300 --> 00:24:48.580
so EU-Förderung,

00:24:48.940 --> 00:24:49.880
Forschungsförderung,

00:24:50.620 --> 00:24:52.320
immer mal wieder auch Geld von Firmen und

00:24:52.320 --> 00:24:53.720
bei einigen von diesen

00:24:53.720 --> 00:24:56.080
Forschungs-

00:24:56.080 --> 00:24:58.460
oder Förderungsprojekten war ich halt auch dann

00:24:58.460 --> 00:25:00.220
quasi aktiv dabei.

00:25:02.220 --> 00:25:04.300
Da musst du auch mal direkt erzählen, was PyPy

00:25:04.300 --> 00:25:05.500
überhaupt ist. Ja, genau.

00:25:06.100 --> 00:25:08.320
Also genau, das ist quasi

00:25:08.320 --> 00:25:10.360
die andere Frage. Also PyPy ist quasi

00:25:10.360 --> 00:25:11.980
eine Alternative für CPython.

00:25:11.980 --> 00:25:13.400
Wenn man halt irgendwie Python

00:25:13.400 --> 00:25:18.880
in Python seine Programme schreibt, dann geht man halt normalerweise auf python.org

00:25:18.880 --> 00:25:22.800
oder vielleicht kriegt man das auch irgendwann das her, aber man hat halt ein

00:25:22.800 --> 00:25:27.020
Executable, das heißt Python 3 in der Regel oder Python, das führt man

00:25:27.020 --> 00:25:30.820
aus und dann kriegt man halt irgendwie seine Shell und kann da Python-Code angeben oder kann halt damit

00:25:30.820 --> 00:25:34.640
dann auch Python-Dateien ausführen und kann auf diese Art und Weise irgendwie seine

00:25:34.640 --> 00:25:37.380
Programme laufen lassen. Und

00:25:37.380 --> 00:25:42.740
dieses Programm, das wird halt von den Kernentwicklungen

00:25:42.740 --> 00:25:44.800
der Sprache Python

00:25:44.800 --> 00:25:47.380
geschrieben und

00:25:47.380 --> 00:25:49.580
das gibt quasi vor, wie sich die Sprache

00:25:49.580 --> 00:25:50.840
entwickelt und

00:25:50.840 --> 00:25:53.380
dieses Programm ist in C geschrieben

00:25:53.380 --> 00:25:55.480
und deswegen kann man das halt auch,

00:25:55.540 --> 00:25:57.580
um es von der Sprache zu unterscheiden,

00:25:57.980 --> 00:25:59.280
kann man das halt auch C-Python nennen.

00:26:00.180 --> 00:26:02.740
Also das ist quasi so ein bisschen so ein Terminologie-

00:26:02.740 --> 00:26:03.560
Trick, dass man halt

00:26:03.560 --> 00:26:05.800
quasi die Sprache und die Implementierung,

00:26:06.340 --> 00:26:07.560
dass man denen zwei verschiedene Namen gibt.

00:26:07.560 --> 00:26:08.940
Also Python ist halt dann die Sprache

00:26:08.940 --> 00:26:11.140
und das ist quasi erstmal so eine abstrakte

00:26:11.140 --> 00:26:12.920
Entität und dann gibt es aber halt die konkrete

00:26:12.920 --> 00:26:14.920
Implementierung, die man fast immer verwendet und das

00:26:14.920 --> 00:26:16.000
ist halt CPython.

00:26:16.780 --> 00:26:18.860
Und CPython funktioniert jetzt so, dass es halt ein

00:26:18.860 --> 00:26:20.840
Interpreter ist. Also wenn ich jetzt damit irgendwie

00:26:20.840 --> 00:26:23.120
meinen Python-Code ausführen will, dann

00:26:23.120 --> 00:26:24.980
gibt es so ein bisschen so einen

00:26:24.980 --> 00:26:27.080
versteckten Bytecode-Compiler-Schritt.

00:26:27.860 --> 00:26:28.600
Also der

00:26:28.600 --> 00:26:30.640
Python-Code wird dann irgendwie

00:26:30.640 --> 00:26:32.960
analysiert und geparst und in

00:26:32.960 --> 00:26:34.900
so ein Bytecode-Format übersetzt und

00:26:34.900 --> 00:26:37.560
dann werden auch so PYC-Dateien

00:26:37.560 --> 00:26:39.200
irgendwo auf der Festplatte

00:26:39.200 --> 00:26:41.080
auch noch so ein bisschen zwischengespeichert

00:26:41.080 --> 00:26:42.580
damit man das nicht jedes Mal machen muss,

00:26:43.100 --> 00:26:45.200
aber dieser White-Code, der wird halt dann jedes Mal

00:26:45.200 --> 00:26:46.260
von einem Interpreter ausgeführt.

00:26:47.460 --> 00:26:47.780
Und

00:26:47.780 --> 00:26:51.100
was Piper

00:26:51.100 --> 00:26:52.220
jetzt ist, ist quasi

00:26:52.220 --> 00:26:55.220
der Versuch, Python-Code

00:26:55.220 --> 00:26:56.320
schneller zu machen.

00:26:57.820 --> 00:26:59.060
Es ist ja immer so ein bisschen

00:26:59.060 --> 00:27:01.000
so ein Meme, dass Python halt irgendwie besonders

00:27:01.000 --> 00:27:02.920
langsam sein soll und Piper ist halt

00:27:02.920 --> 00:27:05.180
ein Forschungsprojekt oder halt auch ein

00:27:05.180 --> 00:27:09.640
Open-Source-Projekt, mit dem man

00:27:09.640 --> 00:27:10.020
eben

00:27:10.020 --> 00:27:12.340
das Ziel erreichen können möchte,

00:27:12.460 --> 00:27:14.440
dass man den Python-Code einfach unverändert

00:27:14.440 --> 00:27:16.380
viel

00:27:16.380 --> 00:27:18.240
schneller laufen lassen kann. Und das macht man eben so,

00:27:18.320 --> 00:27:20.320
dass man eben sich sein Binary nicht

00:27:20.320 --> 00:27:22.540
von Python.org runterlädt, sondern von PyPy.org.

00:27:23.040 --> 00:27:24.220
Man kriegt dann ein Binary,

00:27:24.340 --> 00:27:26.160
das heißt halt irgendwie PyPy und das

00:27:26.160 --> 00:27:28.260
verhält sich erstmal eigentlich ganz genau so,

00:27:28.380 --> 00:27:30.300
idealerweise quasi ununterscheidbar so,

00:27:30.840 --> 00:27:32.320
wie der Interpreter,

00:27:32.460 --> 00:27:34.120
den man von Python.org kriegt.

00:27:34.420 --> 00:27:36.040
Vielleicht nochmal ganz kurz, PyPy ist nicht

00:27:36.040 --> 00:27:38.460
PyPI. Genau, also Py, Py,

00:27:38.460 --> 00:27:40.140
über die, also

00:27:40.140 --> 00:27:42.600
das ist so ein bisschen doof, dass die

00:27:42.600 --> 00:27:43.680
so ähnlich sind, aber

00:27:43.680 --> 00:27:46.260
Ja, weil man von PyPI ja auch viel runterlädt.

00:27:46.500 --> 00:27:47.700
Genau, ja, ja, absolut.

00:27:49.000 --> 00:27:50.480
Aber PyPI lädt man

00:27:50.480 --> 00:27:52.420
quasi in Python geschriebene

00:27:52.420 --> 00:27:54.300
Bibliotheken runter, die dann auf

00:27:54.300 --> 00:27:56.620
der Python-Implementierung laufen, aber

00:27:56.620 --> 00:27:58.340
PyPy ist eben

00:27:58.340 --> 00:28:00.260
wirklich das Binary, also

00:28:00.260 --> 00:28:02.140
die Exit-Datei sozusagen.

00:28:02.220 --> 00:28:04.460
Du hast nicht mehr erzählt, eigentlich war diese, weil ihr relativ

00:28:04.460 --> 00:28:06.380
gleich alt seid als Projekte, war die

00:28:06.380 --> 00:28:08.000
Unterscheidung früher gar nicht so einfach, weil das

00:28:08.000 --> 00:28:10.160
andere waren die Cheesecakes. Genau, also

00:28:10.160 --> 00:28:11.960
der PyPI hatte halt vorher dieses

00:28:11.960 --> 00:28:14.380
Cheese-Shop-Branding, weil das ist so ein Monty Python-Sketch

00:28:14.380 --> 00:28:15.760
mit dem

00:28:15.760 --> 00:28:18.200
Cheese-Shop, wo man halt keinen Käse

00:28:18.200 --> 00:28:19.620
kaufen kann. Ich weiß nicht, ob du das kennst.

00:28:20.020 --> 00:28:22.120
Ja. Genau, da geht halt der Kunde

00:28:22.120 --> 00:28:24.140
dann so ganz viel Sorten durch und die gibt es aber alle nicht.

00:28:24.640 --> 00:28:26.240
Und kennst du auch das Wortspiel mit den Wheels?

00:28:26.840 --> 00:28:27.080
Ne.

00:28:27.780 --> 00:28:30.160
Naja, im Cheese-Shop gibt es halt Käseräder.

00:28:30.720 --> 00:28:32.140
Ja. Und die Wheels

00:28:32.140 --> 00:28:33.880
sind halt Käse.

00:28:34.060 --> 00:28:35.760
Okay, ah. Also, ja.

00:28:36.020 --> 00:28:37.940
Das heißt, im Käseshop gibt es so Wheels.

00:28:38.000 --> 00:28:40.100
Ja, okay, verstehe. Und deswegen gibt es Reels

00:28:40.100 --> 00:28:41.680
auf PyPI.

00:28:42.060 --> 00:28:43.920
Genau, und irgendwann haben die halt dann aufgehört mit diesem,

00:28:44.120 --> 00:28:45.780
weil Cheese Shop ist halt doch sehr

00:28:45.780 --> 00:28:48.260
idiosynkratisch

00:28:48.260 --> 00:28:49.140
oder verspielt.

00:28:49.980 --> 00:28:52.200
Der erste Draftnamen

00:28:52.200 --> 00:28:53.980
von unserem Podcast war so Ministry of Silly Talk.

00:28:54.040 --> 00:28:55.120
Ja, ist gar nicht schlecht.

00:28:56.060 --> 00:28:58.320
Und also irgendwann wurde halt PyPI

00:28:58.320 --> 00:29:00.360
dann ein bisschen ernsthafter und hat halt angefangen

00:29:00.360 --> 00:29:02.060
dann sich nicht mehr

00:29:02.060 --> 00:29:04.000
das Cheese Shop zu nennen. Und dann wurde halt

00:29:04.000 --> 00:29:06.120
die Verwechslungsgefahr plötzlich dann auch akuter.

00:29:06.120 --> 00:29:08.560
aber weil halt PyPI und PyPi

00:29:08.560 --> 00:29:10.220
ziemlich genau gleich alt sind, also

00:29:10.220 --> 00:29:12.500
PyPI ist ein kleines bisschen älter, so ein paar

00:29:12.500 --> 00:29:13.300
Monate oder so,

00:29:14.180 --> 00:29:16.580
haben halt beide Projekte nicht so richtig eingesehen

00:29:16.580 --> 00:29:17.960
sich jetzt umzubenennen und

00:29:17.960 --> 00:29:20.260
deswegen müssen wir jetzt halt mit dieser

00:29:20.260 --> 00:29:22.140
Verwirrung leben.

00:29:22.800 --> 00:29:24.320
Genau, also wir waren an dem Punkt, man kann von

00:29:24.320 --> 00:29:26.320
PyPi.org sich ein Binary unterladen, das heißt

00:29:26.320 --> 00:29:28.480
PyPi.excel unterbinden oder halt einfach nur

00:29:28.480 --> 00:29:30.800
PyPi und das verhält sich eigentlich

00:29:30.800 --> 00:29:32.460
idealerweise ganz

00:29:32.460 --> 00:29:34.400
genauso wie das Binary, was man

00:29:34.400 --> 00:29:36.540
von Python.org kriegt. Man kann damit

00:29:36.540 --> 00:29:38.200
Python-Code ausführen, man kann damit

00:29:38.200 --> 00:29:40.580
einen interaktiven Interpreter

00:29:40.580 --> 00:29:42.340
kriegen und alle

00:29:42.340 --> 00:29:43.840
Command-Line-Switches sind die gleichen.

00:29:44.060 --> 00:29:46.460
Mit dem einzigen Unterschied, dass

00:29:46.460 --> 00:29:48.900
der Python-Code,

00:29:48.920 --> 00:29:50.760
den man damit ausführt, halt hoffentlich schneller ist.

00:29:51.840 --> 00:29:52.700
Was ist mit Paketen

00:29:52.700 --> 00:29:53.820
und Libraries und so weiter?

00:29:54.120 --> 00:30:05.023
Genau also alles was quasi in Python geschrieben ist sollte halt gehen Wir haben nat ab und zu Bugs Es gibt immer irgendwelche super spezifischen Feinheiten

00:30:05.543 --> 00:30:09.023
wo man dann halt doch so ein bisschen Verhaltensunterschiede finden kann.

00:30:09.743 --> 00:30:11.342
Aber so der Anspruch an uns selber ist halt,

00:30:11.383 --> 00:30:18.043
dass wir quasi wirklich das komplette Verhalten der Sprache eins zu eins nachbauen.

00:30:18.182 --> 00:30:19.562
Und zwar bis in die Bugs rein.

00:30:19.922 --> 00:30:23.102
Also es gibt halt immer wieder so Randfälle, wo man dann anfangen kann zu diskutieren

00:30:23.102 --> 00:30:25.123
und sagen kann, naja, was ist denn jetzt mit diesem

00:30:25.123 --> 00:30:27.003
Randfall, könnte man da nicht argumentieren,

00:30:27.082 --> 00:30:28.543
dass C-Python da halt irgendwas komisches macht.

00:30:29.222 --> 00:30:31.023
Aber das machen wir halt nicht, sondern wir sagen halt

00:30:31.023 --> 00:30:32.982
immer, im Zweifelsfall

00:30:32.982 --> 00:30:35.023
bauen wir halt auch die ganz, ganz komischen Sachen nach,

00:30:35.123 --> 00:30:37.202
weil es stellt sich halt raus, dass

00:30:37.202 --> 00:30:39.202
irgendjemand verlässt

00:30:39.202 --> 00:30:40.422
sich so ein bisschen auf alles.

00:30:41.082 --> 00:30:42.503
Es gibt eigentlich keinen

00:30:42.503 --> 00:30:44.822
Randfall, der so merkwürdig ist,

00:30:44.903 --> 00:30:46.202
dass es nicht eine Bibliothek gibt,

00:30:46.862 --> 00:30:48.123
eine kleine vielleicht,

00:30:48.763 --> 00:30:50.722
die sich dann beschwert, wenn man das kaputt macht.

00:30:51.663 --> 00:30:52.922
Selbst wenn man halt dann sagt,

00:30:52.922 --> 00:30:55.302
Wir sind aber viel konsistenter und das macht ja so viel mehr Sinn.

00:30:56.783 --> 00:30:58.883
Das ist halt doof.

00:30:59.003 --> 00:31:01.042
Für so eine Bibliothek ist das doof, wenn sie

00:31:01.042 --> 00:31:03.182
dann so unterscheiden muss,

00:31:03.403 --> 00:31:05.222
auf welcher Python-Implementierung

00:31:05.222 --> 00:31:05.942
sie jetzt gerade laufen.

00:31:06.163 --> 00:31:08.982
Deswegen versuchen wir da auch nichts mehr

00:31:08.982 --> 00:31:09.802
zu verbessern.

00:31:12.722 --> 00:31:13.903
Es gibt natürlich trotzdem Stellen.

00:31:14.062 --> 00:31:16.643
Wir haben halt dann, was weiß ich, mal eine leicht andere Fehlermeldung.

00:31:17.602 --> 00:31:19.102
So etwas kommt da schon vor.

00:31:21.643 --> 00:31:22.442
Vom Anspruch her

00:31:22.442 --> 00:31:26.263
sollte sich halt genau gleich verhalten und der einzige Unterschied ist quasi wirklich

00:31:26.263 --> 00:31:30.182
idealerweise, dass bei uns die Programme halt viel schneller laufen.

00:31:30.783 --> 00:31:33.903
Und warum macht man das dann nicht direkt immer mit PyPy? Alles?

00:31:34.263 --> 00:31:38.143
Ja, also genau, jetzt können wir so ein bisschen über die Nachteile reden.

00:31:38.462 --> 00:31:42.962
Also das eine ist halt, wir sind halt nicht die maßgebende

00:31:42.962 --> 00:31:46.482
Implementierung, die jetzt die Evolution der

00:31:46.482 --> 00:31:50.503
Sprache selbst vorgibt. Also C-Python hat

00:31:50.503 --> 00:31:52.322
halt so eine Doppelfunktion, dass es

00:31:52.322 --> 00:31:52.722
einmal

00:31:52.722 --> 00:31:56.342
ist das die Default-Implementierung, die

00:31:56.342 --> 00:31:58.403
halt von fast allen verwendet wird, aber auf der

00:31:58.403 --> 00:32:00.462
anderen Seite ist es halt

00:32:00.462 --> 00:32:02.202
auch die Gruppe an Leuten,

00:32:02.942 --> 00:32:04.582
die letztlich darüber entscheiden,

00:32:05.123 --> 00:32:06.182
in welche Richtung sich die Sprache

00:32:06.182 --> 00:32:08.423
weiterentwickelt. Weil in jeder neuen Version

00:32:08.423 --> 00:32:10.403
von C-Python ist es ja so, dass da

00:32:10.403 --> 00:32:12.462
eben nicht nur, jetzt sage ich mal, irgendwie technische

00:32:12.462 --> 00:32:14.322
Verbesserungen an der Implementierung

00:32:14.322 --> 00:32:16.322
gemacht werden. Das kommt natürlich auch mal

00:32:16.322 --> 00:32:18.163
vor, also jetzt in 3F zum Beispiel ganz doll.

00:32:19.003 --> 00:32:20.362
Aber insbesondere gibt es halt

00:32:20.362 --> 00:32:22.322
auch bei jeder Version irgendwelche neuen Sprachfeatures.

00:32:23.042 --> 00:32:23.442
Das heißt,

00:32:24.243 --> 00:32:26.182
Python.org, diese Community, die ist halt

00:32:26.182 --> 00:32:27.602
für zwei Sachen zuständig. Einmal

00:32:27.602 --> 00:32:30.182
dafür, dass das alles funktioniert, aber auf der anderen Seite

00:32:30.182 --> 00:32:31.702
eben auch für so Fragen wie,

00:32:32.082 --> 00:32:33.682
welches Pad nehmen wir an, welches neue

00:32:33.682 --> 00:32:35.962
Language-Feature wollen wir haben, welche neue

00:32:35.962 --> 00:32:37.482
Standard-Bibliothek,

00:32:38.342 --> 00:32:40.202
so Geschichten. Und da, also da

00:32:40.202 --> 00:32:41.802
sind wir halt raus. Also aus diesen ganzen

00:32:41.802 --> 00:32:44.222
Sprachdesign-Fragen, da haben wir keine

00:32:44.222 --> 00:32:45.942
Meinung zu. Ihr nehmt euch dann einfach das

00:32:45.942 --> 00:32:47.743
letzte offizielle Release und dann

00:32:47.743 --> 00:32:50.222
das Prinzip heißt und baut das dann eure Änderungen.

00:32:50.222 --> 00:32:53.123
und es ist schon dann mal so, dass wir bei den

00:32:53.123 --> 00:32:55.102
C-Python-Diskussionen dann auch mitreden und

00:32:55.102 --> 00:32:56.923
sagen, ja aus unserer Sicht hat das die und die,

00:32:58.003 --> 00:32:59.023
also gibt es jetzt hier diese

00:32:59.023 --> 00:33:00.023
Trade-offs oder so, aber

00:33:00.023 --> 00:33:02.783
wir versuchen uns halt so erstmal aus

00:33:02.783 --> 00:33:04.982
Sprach-Design-Fragen auch

00:33:04.982 --> 00:33:06.042
irgendwie erstmal rauszuhalten.

00:33:06.883 --> 00:33:08.962
Also einfach auch, weil das unser Leben so ein bisschen leichter

00:33:08.962 --> 00:33:10.082
macht, dann gibt es halt,

00:33:11.102 --> 00:33:13.003
ich meine, ich habe da natürlich dann quasi so privat

00:33:13.003 --> 00:33:15.163
auch manchmal eine Meinung dazu, was es jetzt an Featuren

00:33:15.163 --> 00:33:16.923
gibt und manche finde ich cool und manche finde ich

00:33:16.923 --> 00:33:19.082
weniger cool, also ich meine, das geht

00:33:19.082 --> 00:33:20.423
ja allen Python-Programmierern so, dass

00:33:20.423 --> 00:33:23.123
man halt eine Meinung hat, aber wenn ich

00:33:23.123 --> 00:33:24.202
dann quasi meinen

00:33:24.202 --> 00:33:26.903
Pipeline-Hut aufhabe, dann versuche ich diese

00:33:26.903 --> 00:33:28.903
private Meinung halt dann auch zurückzunehmen und zu sagen,

00:33:29.783 --> 00:33:31.302
das ist jetzt halt so, das ist Teil der Sprache

00:33:31.302 --> 00:33:32.623
und das implementieren wir jetzt halt.

00:33:32.722 --> 00:33:35.243
Also du bist ja eigentlich gar kein Python-Programmierer, hast du selber gesagt.

00:33:35.562 --> 00:33:37.123
Ja, über die Architektur reden

00:33:37.123 --> 00:33:39.023
wir gleich noch, also irgendwie

00:33:39.023 --> 00:33:40.862
dann schon, aber halt auf ein bisschen

00:33:40.862 --> 00:33:42.802
indirekte Art und Weise. Also ja,

00:33:43.663 --> 00:33:45.003
ich wollte noch was zu den Versionen

00:33:45.003 --> 00:33:46.942
sagen, wir sind immer so ein bisschen hinterher,

00:33:46.942 --> 00:33:49.182
das ist nicht so gut

00:33:49.182 --> 00:33:51.383
eigentlich haben wir immer so ein bisschen den Anspruch

00:33:51.383 --> 00:33:53.542
dass wir quasi eine Major Version hinterher sind

00:33:53.542 --> 00:33:54.442
weil

00:33:54.442 --> 00:33:57.462
also wir können halt nicht Schritt halten

00:33:57.462 --> 00:33:59.362
C-Python hat halt einfach viel mehr Leute

00:33:59.362 --> 00:34:00.743
und die

00:34:00.743 --> 00:34:03.062
die rennen uns halt davon

00:34:03.062 --> 00:34:05.562
und was halt so ein bisschen unser Ziel ist

00:34:05.562 --> 00:34:06.383
ist dass wir quasi

00:34:06.383 --> 00:34:09.463
immer so eine Major Version hinterher sind

00:34:09.463 --> 00:34:10.363
das ist auch immer ganz gut

00:34:10.363 --> 00:34:13.183
wenn dann quasi 3.11 rauskommt

00:34:13.183 --> 00:34:15.062
dann haben so langsam alle Bibliotheken

00:34:15.062 --> 00:34:16.943
sich darauf eingestellt, dass sie 3.10 supporten

00:34:16.943 --> 00:34:19.323
und wenn wir dann auch mit unseren 3.10 rauskommen,

00:34:19.403 --> 00:34:20.423
dann passt das so ganz gut zusammen.

00:34:21.743 --> 00:34:23.183
Gerade sind wir ein bisschen mehr,

00:34:23.302 --> 00:34:24.883
also wir haben jetzt nicht so krass getaktete

00:34:24.883 --> 00:34:26.542
Releases wie C-Python, sondern

00:34:26.542 --> 00:34:29.102
das wird halt, also wir machen

00:34:29.102 --> 00:34:31.062
alle paar Monate Release, aber das heißt nicht unbedingt,

00:34:31.243 --> 00:34:33.183
dass dann auch die neue C-Python-Version

00:34:33.183 --> 00:34:36.262
supported wird.

00:34:36.482 --> 00:34:37.062
Und gerade sind wir

00:34:37.062 --> 00:34:39.143
so ein bisschen hinterher, also 3.9

00:34:39.143 --> 00:34:40.683
ist jetzt eigentlich sehr, sehr stabil

00:34:40.683 --> 00:34:42.282
und 3.10

00:34:42.282 --> 00:34:44.843
ist in der Mache, aber noch nicht released.

00:34:45.062 --> 00:34:47.203
und danach kommt halt dann 3.11.

00:34:47.542 --> 00:34:49.042
Also das ist quasi ein Nachteil,

00:34:49.123 --> 00:34:51.323
warum man PyPy halt nicht nehmen sollte.

00:34:52.323 --> 00:34:53.383
Ist ein bisschen hinterher.

00:34:54.282 --> 00:34:54.703
Und dann

00:34:54.703 --> 00:34:57.183
habe ich vorhin gesagt, naja, jedes Python-Programm

00:34:57.183 --> 00:34:59.302
sollte halt gehen und idealerweise schneller sein.

00:34:59.822 --> 00:35:00.643
Da gibt es jetzt zwei

00:35:00.643 --> 00:35:02.383
Fußnoten an dieser Aussage.

00:35:02.862 --> 00:35:04.923
Die eine Fußnote ist halt C-Extensions.

00:35:05.562 --> 00:35:06.443
Aber Lampai ist kaputt?

00:35:06.862 --> 00:35:08.502
Nee, kaputt halt nicht.

00:35:09.062 --> 00:35:11.042
Also inzwischen ist das so, dass wir so eine

00:35:11.042 --> 00:35:13.102
komplette Kompatibilitätsschicht

00:35:13.102 --> 00:35:14.703
haben, mit der

00:35:14.703 --> 00:35:17.562
80% aller

00:35:17.562 --> 00:35:19.502
in C geschriebenen

00:35:19.502 --> 00:35:21.362
Bibliotheken in PyPy auch gehen.

00:35:22.302 --> 00:35:22.743
Aber

00:35:22.743 --> 00:35:25.243
das ist wirklich, wir emulieren halt

00:35:25.243 --> 00:35:27.302
dieses Interface. Für C-Python ist das

00:35:27.302 --> 00:35:29.203
Interface halt wirklich genau

00:35:29.203 --> 00:35:31.042
so, wie der Interpreter auch wirklich funktioniert.

00:35:31.903 --> 00:35:33.022
Und der Interpreter benutzt halt

00:35:33.022 --> 00:35:34.223
Reference Counting und

00:35:34.223 --> 00:35:36.883
die C-API, die

00:35:36.883 --> 00:35:38.703
hat halt überall

00:35:38.703 --> 00:35:41.183
die Tatsache, dass das Reference Counting ist exposed.

00:35:41.383 --> 00:35:43.423
Es gibt halt ein Increase Reference

00:35:43.423 --> 00:35:47.482
Count Makro und einen Decrease Reference Count Makro und alle

00:35:47.482 --> 00:35:51.542
Libraries, die dann gegen diese API implementiert sind, die müssen das halt überall

00:35:51.542 --> 00:35:55.623
auch korrekt verwenden. Aber bei uns ist es so, dass wir unseren Speicher halt nicht

00:35:55.623 --> 00:35:59.842
mit Reference Counting verwalten. Das heißt, wir müssen dann für die Bibliotheken

00:35:59.842 --> 00:36:03.443
so tun, als hätten wir einen Reference Count. Und das kostet halt so ein bisschen

00:36:03.443 --> 00:36:07.203
Performance. Das heißt, bei uns sind in C-geschriebenen Erweiterungen halt

00:36:07.203 --> 00:36:11.383
quasi, die funktionieren, die können aber halt oft einfach

00:36:11.383 --> 00:36:15.282
langsamer sein. Und das ist natürlich doof, weil...

00:36:15.282 --> 00:36:18.982
Du machst einen Paket, der schneller sein will, aber die Sachen wird langsamer, als wenn du die eigentlich auf normalem Python-Offenheitsfeld

00:36:18.982 --> 00:36:22.982
hast. Genau. Also ich meine, der Grund, warum man... Es gibt ja so ein bisschen zwei Motivationen,

00:36:23.022 --> 00:36:26.762
warum man in C geschrieben die Bibliotheken verwendet. Einmal, weil man halt gerne mit irgendwelchen

00:36:26.762 --> 00:36:30.782
Bibliotheken reden will, die halt in C geschrieben sind. Das ist halt

00:36:30.782 --> 00:36:34.903
ein Ansatz. Aber ein anderer Grund ist halt, wenn man irgendwas schneller machen will, indem man es in C

00:36:34.903 --> 00:36:38.802
schreibt. Und diese Motivation, die funktioniert halt dann auf PyPy

00:36:38.802 --> 00:36:40.822
oft nicht. Und es wäre dann

00:36:40.822 --> 00:36:42.663
zum Teil einfach auch echt besser, wenn man halt einfach

00:36:42.663 --> 00:36:43.903
Python-Code nehmen würde.

00:36:44.663 --> 00:36:46.703
Aber weil halt für C-Python alle jetzt schon

00:36:46.703 --> 00:36:48.562
ihre tollen NC-geschriebenen Optimierungen gemacht haben,

00:36:49.322 --> 00:36:50.322
ist das dann für uns oft

00:36:50.322 --> 00:36:51.663
auch halt eine Verschlechterung.

00:36:53.582 --> 00:36:54.022
Ja.

00:36:54.562 --> 00:36:56.282
Könnte man da nicht vielleicht einfach auch den

00:36:56.282 --> 00:36:58.322
C aus PyPy heraus

00:36:58.322 --> 00:37:00.282
irgendwie einfach den C-Python-Interpreter

00:37:00.282 --> 00:37:01.802
wieder aufrufen und den diesen

00:37:01.802 --> 00:37:03.643
Kram händeln lassen? Ja,

00:37:03.982 --> 00:37:06.423
da gab es auch immer mal wieder so ein paar Experimente.

00:37:06.923 --> 00:37:08.322
Aber dann verliert man halt, also man

00:37:08.322 --> 00:37:12.562
will halt, dann verliert man halt möglicherweise die Vorteile für den Python-Code wieder.

00:37:13.022 --> 00:37:15.782
Also das Problem ist, du willst ja halt beide Seiten auch miteinander reden lassen.

00:37:15.943 --> 00:37:21.143
Wenn du halt nur C-Code hast, dann ist halt eh die Frage, was hast du da noch mit Python

00:37:21.143 --> 00:37:21.463
zu tun.

00:37:22.562 --> 00:37:27.923
Spannend wird es halt dann, wenn dein Programm aus interessanten Teilen auf der Python-Seite

00:37:27.923 --> 00:37:33.342
besteht und interessanten Teilen auf der Bibliotheksseite.

00:37:34.243 --> 00:37:36.463
Die andere Fußnote ist, dass es manchmal nicht klappt.

00:37:36.463 --> 00:37:38.502
also es gibt halt, manchmal

00:37:38.502 --> 00:37:40.262
hat man wirklich einen Python geschriebenen Code

00:37:40.262 --> 00:37:40.743
und

00:37:40.743 --> 00:37:44.542
der wird nicht schneller, also man muss

00:37:44.542 --> 00:37:46.463
halt einfach messen

00:37:46.463 --> 00:37:48.423
und um mal so ein bisschen so eine

00:37:48.423 --> 00:37:50.482
Größenordnung zu nennen, wir haben halt

00:37:50.482 --> 00:37:52.262
so Speedups

00:37:52.262 --> 00:37:54.502
zwischen, so im allerbesten

00:37:54.502 --> 00:37:56.362
Fall, wenn halt alles ganz toll ist und du

00:37:56.362 --> 00:37:58.802
Pure Python Code hast, gar keine Bibliothek, die ins hier geschrieben ist

00:37:58.802 --> 00:38:00.383
und das ist alles

00:38:00.383 --> 00:38:02.322
jetzt sag ich mal sehr numerisch, also hast viele

00:38:02.322 --> 00:38:04.403
Zahlen und irgendwie

00:38:04.403 --> 00:38:06.423
viele Floats oder, aber du machst das auch wirklich alles

00:38:06.423 --> 00:38:10.282
in Python. Dann kannst du halt so Speedups von 50 Mal schneller

00:38:10.282 --> 00:38:14.542
als in Python kriegen. Also das ist schon, also alle Leute, die halt sowas wie

00:38:14.542 --> 00:38:18.223
Advent of Code machen. Advent of Code ist eigentlich so,

00:38:18.703 --> 00:38:22.463
ich scherze, aber ist irgendwie auch was wahres dran. Advent of Code ist halt irgendwie einer der Haupt

00:38:22.463 --> 00:38:26.423
coolen Use Cases für PyPy. Es ist halt

00:38:26.423 --> 00:38:30.263
irgendwie nicht so viel Code, es passt auf ein paar Bildschirme, es ist irgendwie sehr algorithmisch

00:38:30.263 --> 00:38:34.263
und man braucht nicht so viele Bibliotheken und Performance ist irgendwie auch

00:38:34.263 --> 00:38:36.022
wichtig und da ist halt PyPy einfach

00:38:36.022 --> 00:38:36.743
mega gut dafür.

00:38:38.842 --> 00:38:40.322
Genau, also bei Performance

00:38:40.322 --> 00:38:41.683
ist es halt so, man muss halt einfach messen.

00:38:42.923 --> 00:38:44.203
Du kannst halt nicht

00:38:44.203 --> 00:38:46.362
quasi so a priori entscheiden,

00:38:46.502 --> 00:38:48.183
dass es immer jetzt

00:38:48.183 --> 00:38:50.062
Speedup X

00:38:50.062 --> 00:38:52.123
bringt, sondern es führt

00:38:52.123 --> 00:38:54.163
quasi keinen Weg darum, dass du deine konkrete

00:38:54.163 --> 00:38:55.663
Anwendung halt ausprobierst und schaust,

00:38:56.362 --> 00:38:58.062
bringt es was oder halt nicht.

00:38:58.223 --> 00:39:00.102
Habt ihr da irgendwie ein Referenzsystem oder macht ihr das einfach mal

00:39:00.102 --> 00:39:02.123
so objektiv von dem überliegenden Rechner?

00:39:02.123 --> 00:39:05.022
Du meinst jetzt quasi

00:39:05.022 --> 00:39:07.943
inwiefern das von der darunterliegenden Hardware abhängt?

00:39:08.203 --> 00:39:08.862
Ja, zum Beispiel, ja

00:39:08.862 --> 00:39:11.822
Das ist glaube ich nicht so ein Problem

00:39:11.822 --> 00:39:13.923
Wir unterstützen so einen Haufen

00:39:13.923 --> 00:39:15.362
CPU-Architekturen, aber

00:39:15.362 --> 00:39:18.062
da sind wir nicht so sensitiv

00:39:18.062 --> 00:39:20.002
Es geht eigentlich dann eher darum, was für

00:39:20.002 --> 00:39:21.982
Bibliotheken benutzt dein Projekt und sind die eher

00:39:21.982 --> 00:39:23.822
so C-lastig oder was

00:39:23.822 --> 00:39:25.542
Es gibt halt

00:39:25.542 --> 00:39:28.022
Teile der Sprache, wo wir einfach richtig, richtig gut drin

00:39:28.022 --> 00:39:29.443
sind, die schneller zu machen

00:39:29.443 --> 00:39:31.623
und Teile der Sprache, wo wir dann

00:39:31.623 --> 00:39:33.923
nicht ganz so viel rausholen können.

00:39:34.623 --> 00:39:36.163
Wie viel lernt C-Python von euch?

00:39:37.243 --> 00:39:38.362
Das ist eine gute Frage.

00:39:39.782 --> 00:39:40.423
Achso, ich wollte kurz

00:39:40.423 --> 00:39:42.022
die andere Abschätzung. Also im besten Fall so

00:39:42.022 --> 00:39:42.842
30-40x.

00:39:44.223 --> 00:39:46.362
Und im schlechtesten Fall ist man halt auch

00:39:46.362 --> 00:39:48.243
mal 30% langsamer.

00:39:48.362 --> 00:39:50.282
Und das ist halt dann doof. Da will man halt dann nicht sein.

00:39:51.763 --> 00:39:52.562
C-Python,

00:39:53.282 --> 00:39:53.582
also

00:39:53.582 --> 00:39:56.203
ich habe manchmal so

00:39:56.203 --> 00:39:57.602
quasi so Momente

00:39:57.602 --> 00:40:00.362
des Zweifelns. Ich verbringe

00:40:00.362 --> 00:40:01.643
seit 18 Jahren

00:40:01.643 --> 00:40:03.743
ein Teil meiner

00:40:03.743 --> 00:40:06.663
Freizeit und ein Teil meines Berufs

00:40:06.663 --> 00:40:08.123
damit an diesem Projekt zu basteln.

00:40:08.643 --> 00:40:11.042
Und so richtig,

00:40:12.042 --> 00:40:12.163
also

00:40:12.163 --> 00:40:14.683
was weiß ich, 99% von allen

00:40:14.683 --> 00:40:16.282
Deployments sind halt dem C-Python.

00:40:16.542 --> 00:40:17.943
Und man kann sich dann halt die Frage stellen,

00:40:19.223 --> 00:40:20.123
warum macht man das eigentlich?

00:40:20.982 --> 00:40:22.522
Also mir macht das natürlich

00:40:22.522 --> 00:40:23.903
irgendwie einfach unglaublich viel Spaß.

00:40:24.082 --> 00:40:26.403
Ich bastel da gerne dran rum, aber es ist natürlich

00:40:26.403 --> 00:40:28.302
auch schön, dann so ein bisschen so quasi

00:40:28.302 --> 00:40:29.862
externe Motivationen aufzukriegen.

00:40:30.362 --> 00:40:30.883
und

00:40:30.883 --> 00:40:34.562
klar, es gibt immer wieder Leute, die das halt dann benutzen

00:40:34.562 --> 00:40:36.143
und das ist halt auch sehr cool, aber

00:40:36.143 --> 00:40:38.522
es gibt halt immer wieder auch Momente,

00:40:38.643 --> 00:40:39.943
wo wir dann quasi so rück

00:40:39.943 --> 00:40:42.962
so rück

00:40:42.962 --> 00:40:44.562
politische

00:40:44.562 --> 00:40:46.183
Rückauswirkungen auf C-Python haben

00:40:46.183 --> 00:40:48.403
und das ist quasi meiner Ansicht nach

00:40:48.403 --> 00:40:50.542
auch so ein bisschen so ein

00:40:50.542 --> 00:40:52.462
so ein, der zweite Grund, warum ich

00:40:52.462 --> 00:40:54.362
halt der Ansicht bin, dass es eine

00:40:54.362 --> 00:40:55.862
gute Sache ist, dass es eine

00:40:55.862 --> 00:40:58.342
zweite, sehr ernsthafte Implementierung

00:40:58.342 --> 00:41:00.322
der Sprache Python gibt, weil

00:41:00.322 --> 00:41:02.223
wir quasi... Also doch so ein bisschen

00:41:02.223 --> 00:41:04.322
Feature-Entwicklung durch die Hintertür.

00:41:04.423 --> 00:41:06.462
So ein bisschen Feature-Entwicklung durch die Hintertür, ganz genau.

00:41:06.582 --> 00:41:08.282
Und das ist zum Beispiel interessanterweise bei den

00:41:08.282 --> 00:41:09.022
Fehlermeldungen passiert.

00:41:10.082 --> 00:41:12.062
Also so ein paar von den...

00:41:12.062 --> 00:41:12.962
Das war 3.10.

00:41:13.683 --> 00:41:14.822
Ja, 3.10 und 3.11.

00:41:15.243 --> 00:41:19.683
Ja, und bei beiden...

00:41:19.683 --> 00:41:22.643
Also ich will jetzt wirklich nicht...

00:41:22.643 --> 00:41:23.462
Keine Credits claimen.

00:41:23.643 --> 00:41:24.822
Ich will keine Credits claimen.

00:41:25.203 --> 00:41:27.522
Ich will auf gar keinen Fall, also was Pablo und

00:41:27.522 --> 00:41:30.163
Batoan Toskaya und sowas, was die da an Aufwand

00:41:30.163 --> 00:41:32.163
reingesteckt haben. Unglaublich

00:41:32.163 --> 00:41:33.342
nervig

00:41:33.342 --> 00:41:35.903
und auch wirklich sehr, sehr cool.

00:41:36.143 --> 00:41:38.082
Ich bin sehr zufrieden mit der Verbesserung. Wie gesagt,

00:41:38.163 --> 00:41:40.183
ich unterrichte Anfänger. Ich kriege das quasi immer mit,

00:41:40.263 --> 00:41:42.123
wenn das halt mal schief geht mit

00:41:42.123 --> 00:41:43.623
den Fehlermeldungen. Aber

00:41:43.623 --> 00:41:45.903
so ein bisschen, so der

00:41:45.903 --> 00:41:48.102
ursprüngliche Drive kam mal so ein bisschen von PyPy.

00:41:48.203 --> 00:41:49.302
Also zum Beispiel dieses mit den

00:41:49.302 --> 00:41:52.163
nicht gematchten Klammern. Das ist ja so

00:41:52.163 --> 00:41:54.002
einer der neuen Fehlermeldungen, dass es halt steht

00:41:54.002 --> 00:41:56.123
die öffnende Klammer, die öffnende

00:41:56.123 --> 00:41:58.203
Ecke Klammer auf Zeile 5 wird mit einer runden

00:41:58.203 --> 00:41:59.542
schließenden Klammer auf Zeile 9

00:41:59.542 --> 00:42:01.423
geschlossen, da stimmt das nicht.

00:42:02.403 --> 00:42:03.183
Das war halt einfach,

00:42:03.703 --> 00:42:05.302
das habe ich einfach vor ein paar Jahren mal implementiert

00:42:05.302 --> 00:42:07.602
und irgendwann hat es halt in C-Python dann doch

00:42:07.602 --> 00:42:09.462
jemand mal gesehen und fand es cool genug,

00:42:09.582 --> 00:42:10.243
um es halt dann doch

00:42:10.243 --> 00:42:13.582
halt auch dann mal quasi nachzuimplementieren.

00:42:13.962 --> 00:42:15.582
Und jetzt ist es

00:42:15.582 --> 00:42:17.322
so ein bisschen, fast so ein bisschen so ein Race manchmal,

00:42:17.322 --> 00:42:19.302
also gerade sind die,

00:42:19.423 --> 00:42:21.022
haben die ganz schön auch vorgelegt, also

00:42:21.022 --> 00:42:23.082
so ein paar der Fehlermeldungen haben wir

00:42:23.082 --> 00:42:24.542
jetzt noch nicht wieder übernommen,

00:42:25.302 --> 00:42:27.362
aber an ein paar Stellen gibt es halt

00:42:27.362 --> 00:42:29.243
immer noch ein paar, wo ich mit unserem

00:42:29.243 --> 00:42:33.482
dann zufrieden hat. Zum Beispiel so ein absoluter Standard-Anfängerfehler,

00:42:33.582 --> 00:42:37.223
wo man halt echt Riesenprobleme hat, wenn man in Python

00:42:37.223 --> 00:42:41.082
einsteigt, wenn man so Objektorientierung lernt. Man schreibt halt seine ersten Klassen und

00:42:41.082 --> 00:42:45.022
schreibt Methoden und kommt halt vielleicht von Java und vergisst das Self.

00:42:46.143 --> 00:42:48.282
Und dann versucht man, die Methode aufzurufen.

00:42:48.962 --> 00:42:53.243
Erstes Argument fehlt. Und dann stimmt halt die Argumentzahl nicht. Und dann vergleicht man

00:42:53.243 --> 00:42:55.703
halt einfach mal die Aufrufstelle mit

00:42:55.703 --> 00:42:58.062
mit der Funktionsdefinition

00:42:58.062 --> 00:42:59.703
und sagt, was ist denn eigentlich dein Problem?

00:43:00.183 --> 00:43:01.542
Ich habe ja doch drei Argumente, warum

00:43:01.542 --> 00:43:03.282
beschwerst du dich denn, dass ich da nur

00:43:03.282 --> 00:43:04.502
zwei reinreiche?

00:43:05.683 --> 00:43:07.923
Oder ja, das stimmt ja dann immer nicht.

00:43:08.623 --> 00:43:09.183
Und da

00:43:09.183 --> 00:43:11.663
mache ich in PyPy

00:43:11.663 --> 00:43:12.502
einfach nur, wenn

00:43:12.502 --> 00:43:15.443
es quasi einen off-by-one-error bei einem

00:43:15.443 --> 00:43:17.703
Methodenaufruf gibt, genau

00:43:17.703 --> 00:43:19.703
in diese Richtung, dann schaue ich,

00:43:19.903 --> 00:43:21.703
dann schaut der Interpreter nach, ob das erste

00:43:21.703 --> 00:43:22.743
Argument self heißt.

00:43:23.703 --> 00:43:25.683
Und wenn nicht, steht einfach nur

00:43:25.683 --> 00:43:27.643
noch da, did you forget self

00:43:27.643 --> 00:43:28.582
in the method definition?

00:43:28.982 --> 00:43:33.582
Ja, keine Ahnung, das ist natürlich, also

00:43:33.582 --> 00:43:35.763
bei diesen Fehlermeldungen

00:43:35.763 --> 00:43:37.582
ist es halt auch wirklich so, du hast

00:43:37.582 --> 00:43:39.562
halt einfach tausend Fehler, also das ist auch nicht

00:43:39.562 --> 00:43:41.383
übertrieben, es gibt halt ganz viele Stellen im

00:43:41.383 --> 00:43:43.723
Interpreter, wo halt Fehler produziert werden

00:43:43.723 --> 00:43:45.602
und jede einzelne ist

00:43:45.602 --> 00:43:47.462
halt dann irgendwie vielleicht auch gar nicht so wichtig, also

00:43:47.462 --> 00:43:49.743
diese Arbeit an Fehlermeldungen,

00:43:49.822 --> 00:43:51.582
die ist halt wirklich auch in gewisser Weise

00:43:51.582 --> 00:43:53.403
sehr nervig, weil man sich um jede einzelne

00:43:53.403 --> 00:43:54.623
irgendwie halt Gedanken machen muss.

00:43:54.623 --> 00:43:56.962
und da gibt es halt auch keine Shortcuts.

00:43:58.123 --> 00:43:59.062
Aber das ist halt eine,

00:43:59.703 --> 00:44:00.862
wo ich mal dann so einen Tag

00:44:00.862 --> 00:44:02.903
dran Spaß hatte, mir zu überlegen, wie man das halt vielleicht

00:44:02.903 --> 00:44:03.683
verbessern kann.

00:44:05.243 --> 00:44:06.443
Aber ich bin halt,

00:44:06.703 --> 00:44:08.342
ich habe so ein bisschen,

00:44:09.423 --> 00:44:11.022
wie gesagt, ich will keinen Credit klauen, aber ich habe

00:44:11.022 --> 00:44:11.403
so ein bisschen

00:44:11.403 --> 00:44:14.802
das Gefühl, dass wir da einfach so ein bisschen so einen Push

00:44:14.802 --> 00:44:16.782
gegeben haben, so einen Inzial-Push. Wir hatten halt an

00:44:16.782 --> 00:44:17.383
vielen Stellen

00:44:17.383 --> 00:44:20.943
da so ein paar Sachen dann zuerst implementiert

00:44:20.943 --> 00:44:22.883
und das fließt jetzt

00:44:22.883 --> 00:44:25.282
ganz stark in den T-Preisen an, da bin ich einfach mega glücklich drüber.

00:44:25.962 --> 00:44:27.002
Das ist der Forscherdrang,

00:44:27.102 --> 00:44:28.862
der so ein bisschen auch in die richtige Richtung geht.

00:44:29.223 --> 00:44:30.663
Der was? Der Forscherdrang.

00:44:31.703 --> 00:44:32.482
Ja, keine Ahnung,

00:44:32.602 --> 00:44:35.582
eigentlich ist das nicht mein Forschungsgebiet.

00:44:35.763 --> 00:44:36.443
Das war eher so ein bisschen,

00:44:36.822 --> 00:44:38.923
ich habe halt dann wirklich gesehen, dass es für die

00:44:38.923 --> 00:44:40.502
Studenten echt dann zum Teil wirklich blöd ist.

00:44:40.743 --> 00:44:42.663
Das wurde jetzt auch

00:44:42.663 --> 00:44:43.263
abgeschafft.

00:44:45.062 --> 00:44:46.263
Ich glaube jetzt auch in 3.11.

00:44:46.602 --> 00:44:48.362
Oder in 3.10, ich weiß nicht so.

00:44:48.982 --> 00:44:50.383
Zum Teil gab es diese

00:44:50.383 --> 00:44:52.582
Synthex-Fehlermeldung, die echt so ganz

00:44:52.582 --> 00:44:54.602
komische Abkürzungen drin hatten, die halt

00:44:54.602 --> 00:44:55.763
einfach nicht ausgeschrieben waren.

00:44:56.302 --> 00:44:58.042
Insbesondere bei, zum Beispiel, wenn man die

00:44:58.042 --> 00:44:59.743
wenn man die

00:44:59.743 --> 00:45:02.582
die Quotes vergessen hat beim

00:45:02.582 --> 00:45:04.203
String. Du hast einfach nur

00:45:04.203 --> 00:45:06.602
x gleich A, B, C und dann

00:45:06.602 --> 00:45:08.502
hast du hinten die Quotes vergessen. Da war früher

00:45:08.502 --> 00:45:09.223
die Fehlermeldung

00:45:09.223 --> 00:45:12.203
irgendwie EOL

00:45:12.203 --> 00:45:14.183
while scanning string literal.

00:45:14.542 --> 00:45:16.502
Endpalette runter oder sowas auch noch verteilt.

00:45:16.643 --> 00:45:17.903
Genau, ganz genau.

00:45:18.602 --> 00:45:20.362
Und das haben sie jetzt gefixt. Das heißt

00:45:20.362 --> 00:45:22.002
jetzt halt wirklich end of line, weil ich meine,

00:45:22.582 --> 00:45:26.042
Woher soll irgendjemand wissen, was EOL heißt?

00:45:26.263 --> 00:45:27.562
Was Scanning heißt?

00:45:27.763 --> 00:45:28.923
Und auch noch, was String Literal heißt?

00:45:30.302 --> 00:45:31.623
Und das ist jetzt wirklich schöner.

00:45:31.982 --> 00:45:33.522
Und das ist zum Beispiel in Triple Quoted String,

00:45:33.522 --> 00:45:35.022
sagte dir jetzt auch die Fehlermeldung,

00:45:36.582 --> 00:45:36.883
wo

00:45:36.883 --> 00:45:39.102
also

00:45:39.102 --> 00:45:41.243
da war die Fehlermeldung halt immer in der allerletzten

00:45:41.243 --> 00:45:42.542
Zeile der Datei.

00:45:43.062 --> 00:45:44.743
Weil er sucht ja einfach

00:45:44.743 --> 00:45:45.822
immer weiter.

00:45:46.042 --> 00:45:48.223
Bei Triple Quoted String ist es halt einfach dann wahrscheinlich

00:45:48.223 --> 00:45:49.962
der ganze Rest, der darin liegt.

00:45:50.282 --> 00:45:51.723
Und am Schluss fehlt was dann.

00:45:51.723 --> 00:45:54.723
und das wurde in 3.10

00:45:54.723 --> 00:45:56.683
gefixt, ist es jetzt halt so, dass er dir

00:45:56.683 --> 00:45:58.522
wirklich dann die Zeile zeigt, wo die öffnenden

00:45:58.522 --> 00:46:00.643
Glöckelbots sind und das ist natürlich viel schöner

00:46:00.643 --> 00:46:01.822
und die andere

00:46:01.822 --> 00:46:04.522
Zeilennummer kommt aber auch vor in der

00:46:04.522 --> 00:46:06.223
Fehlermeldung, das heißt, du hast dann wirklich beides

00:46:06.223 --> 00:46:07.423
und

00:46:07.423 --> 00:46:10.443
ja, also das ist alles schon

00:46:10.443 --> 00:46:12.943
sehr, sehr cool und ich meine, die

00:46:12.943 --> 00:46:16.802
in 3.11, die Position Informations

00:46:16.802 --> 00:46:18.462
die sind halt auch so ein bisschen

00:46:18.462 --> 00:46:20.582
das war quasi noch ein bisschen

00:46:20.582 --> 00:46:22.623
FISA von mir. Das hatte ich noch nicht mal implementiert.

00:46:23.243 --> 00:46:24.763
Da habe ich nur so ein Screenshot gefakt,

00:46:25.703 --> 00:46:26.623
wo ich halt einfach nur im

00:46:26.623 --> 00:46:28.763
Editor einfach mal

00:46:28.763 --> 00:46:29.982
so diese

00:46:29.982 --> 00:46:32.663
Tilde unter den Teil des Ausdrucks gemacht

00:46:32.663 --> 00:46:34.663
habe, wo der Fehler herkommt. Dann habe ich

00:46:34.663 --> 00:46:36.703
ein Screenshot davon getwittert und

00:46:36.703 --> 00:46:37.082
das hat

00:46:37.082 --> 00:46:40.383
Pablo gesehen und dann

00:46:40.383 --> 00:46:42.203
super auffällig. Es war ja

00:46:42.203 --> 00:46:43.982
ein wirklich sehr nerviges Feature.

00:46:44.342 --> 00:46:46.683
Ja, das glaube ich. Ich habe mich schon gefragt,

00:46:46.802 --> 00:46:48.502
wie das implementiert wurde,

00:46:48.623 --> 00:46:50.223
weil das war ja sehr cool, aber

00:46:50.223 --> 00:46:52.322
Oh mein Gott, wie ist das denn implementiert?

00:46:52.663 --> 00:46:54.243
Wie kriegt man das denn alles raus an den Stellen?

00:46:54.302 --> 00:46:56.062
Man muss halt wirklich einfach die gesamte Information

00:46:56.062 --> 00:46:57.962
durch den gesamten

00:46:57.962 --> 00:46:59.643
Stack so durchfädeln.

00:46:59.862 --> 00:47:01.783
Und das ist an jeder Stelle, da muss man das weiterreichen

00:47:01.783 --> 00:47:03.522
und an jeder Stelle hat man halt

00:47:03.522 --> 00:47:05.322
am Anfang hatten die

00:47:05.322 --> 00:47:07.883
Syntaxbäume halt auch die Informationen

00:47:07.883 --> 00:47:09.962
gar nicht. Am Anfang hatte der Syntaxbaum halt

00:47:09.962 --> 00:47:11.903
nur eine Zeilennummer und dann kam irgendwie noch

00:47:11.903 --> 00:47:14.062
die Spaltnummer dazu, aber halt nur

00:47:14.062 --> 00:47:15.183
den Anfang.

00:47:15.982 --> 00:47:18.042
Also das Ende, bis wohin das dann geht, das war halt

00:47:18.042 --> 00:47:18.822
das kam gar nicht vor.

00:47:18.822 --> 00:47:20.683
Also nochmal für alle, es gibt halt

00:47:20.683 --> 00:47:22.743
Fehlermeldungen, da wird ja jetzt die Position, wo das

00:47:22.743 --> 00:47:24.422
der Fehler passiert ist, mit so

00:47:24.422 --> 00:47:26.903
Dreiecken unterkringelt, quasi unterstrichen

00:47:26.903 --> 00:47:28.383
wo das halt aufgetroffen wird

00:47:28.383 --> 00:47:30.582
Und da hatte ich halt diesen Tweet gefakt und jetzt gibt's das

00:47:30.582 --> 00:47:32.842
Also das ist mega geil, das sollte ich einfach

00:47:32.842 --> 00:47:33.422
öfter machen

00:47:33.422 --> 00:47:36.442
Also ich muss das jetzt

00:47:36.442 --> 00:47:38.703
Das kommt dann wieder zu mir zurück

00:47:38.703 --> 00:47:40.663
weil wenn wir dann 3.11 unterstützen, dann muss ich das ja auch

00:47:40.663 --> 00:47:42.643
implementieren, also insofern

00:47:42.643 --> 00:47:44.723
habe ich jetzt mich da ein Stück weit auch

00:47:44.723 --> 00:47:46.783
selber mit reingelegt, aber dass es jetzt halt in C-Weiten drin ist

00:47:46.783 --> 00:47:47.783
finde ich einfach mega cool

00:47:47.783 --> 00:47:51.422
Dann weiß man halt schon, dass es sich lohnen wird, das zu implementieren

00:47:51.422 --> 00:47:55.002
Und ich meine, das andere große Feature, wo wir halt dann quasi so ein bisschen

00:47:55.002 --> 00:48:00.542
also jetzt nicht Druck ausgeübt, aber halt dann quasi

00:48:00.542 --> 00:48:04.743
Einfluss produziert haben, sind halt die Ordered Dictionaries

00:48:04.743 --> 00:48:08.822
Also das ist ja in 3.6 glaube ich

00:48:08.822 --> 00:48:13.703
Informell, aber 3.7 wird dann auch tatsächlich garantiert

00:48:13.703 --> 00:48:17.042
In 3.6 haben sie halt gesagt, ihr dürft euch nicht darauf verlassen, dass die Dictionaries

00:48:17.042 --> 00:48:19.082
jetzt in der Einführungsreihenfolge

00:48:19.082 --> 00:48:21.163
sind und

00:48:21.163 --> 00:48:23.203
in 3.7 haben sie

00:48:23.203 --> 00:48:25.082
dann gesagt, na, das funktioniert so gut, dass

00:48:25.082 --> 00:48:27.002
wir jetzt halt sagen, wir werden das auch nicht wieder abschaffen

00:48:27.002 --> 00:48:29.102
und man darf sich jetzt darauf verlassen, weil es halt an ganz vielen

00:48:29.102 --> 00:48:30.582
Stellen echt auch viel Vorteil hat.

00:48:31.442 --> 00:48:32.683
Und das ist ein Pi-Pi-Feature.

00:48:33.163 --> 00:48:34.643
Achso, okay, das war gar nicht klar.

00:48:34.842 --> 00:48:37.502
Da gab es halt von Raymond Hettinger, gab es mal so ein

00:48:37.502 --> 00:48:39.082
Prototyp, aber in Python, in Pure

00:48:39.082 --> 00:48:41.123
Python und

00:48:41.123 --> 00:48:42.942
wir haben halt einfach gesagt, das

00:48:42.942 --> 00:48:44.703
sieht halt als Algorithmus echt gut aus

00:48:44.703 --> 00:48:46.643
und wir machen jetzt das Ganze in

00:48:46.643 --> 00:48:49.422
Engineering, was man halt braucht, um

00:48:49.422 --> 00:48:51.422
das dann wirklich quasi in Produktiveinsatz

00:48:51.422 --> 00:48:53.223
in die Implementierung einzubauen.

00:48:53.783 --> 00:48:55.422
Das haben wir halt einfach dann irgendwann mal gemacht.

00:48:56.223 --> 00:48:57.462
Und zwar noch nicht mal

00:48:57.462 --> 00:48:59.383
für unsere 3.6-Version, sondern halt für

00:48:59.383 --> 00:49:00.862
unsere 2.7-Version.

00:49:01.743 --> 00:49:03.183
Also bei uns sind halt Dictionaries schon immer,

00:49:03.283 --> 00:49:04.982
also nicht schon immer, aber jetzt schon seit ungefähr 10 Jahren

00:49:04.982 --> 00:49:07.203
irgendwie geordnet. Und das war auch

00:49:07.203 --> 00:49:09.143
ganz schön, also das war auch dann schon

00:49:09.143 --> 00:49:11.143
nochmal ganz schwierig der Aufwand. Also dieser

00:49:11.143 --> 00:49:13.783
Python-Code war halt so ein

00:49:13.783 --> 00:49:15.362
jetzt Sketch wäre ein bisschen untertrieben.

00:49:15.362 --> 00:49:17.502
hat halt den Algorithmus

00:49:17.502 --> 00:49:19.703
so irgendwie

00:49:19.703 --> 00:49:23.542
präsentiert, aber quasi dann

00:49:23.542 --> 00:49:25.602
das zu nehmen und es dann so weit

00:49:25.602 --> 00:49:27.342
zu pushen, dass es halt so gut ist

00:49:27.342 --> 00:49:29.743
und quasi an allen

00:49:29.743 --> 00:49:31.522
Stellen mit dem

00:49:31.522 --> 00:49:33.562
bisherigen Dictionary-Algorithmus dann auch

00:49:33.562 --> 00:49:35.482
wirklich mithalten kann und

00:49:35.482 --> 00:49:37.502
trotzdem die Insertion-Order halt quasi

00:49:37.502 --> 00:49:39.362
erhalten bleibt, da haben wir halt dann wirklich

00:49:39.362 --> 00:49:41.383
nochmal sehr viel extra Aufwand

00:49:41.383 --> 00:49:42.203
reingesteckt, also

00:49:42.203 --> 00:49:45.643
Maschek Fischakowski und Armin Rigo haben das vor allem gemacht

00:49:45.643 --> 00:49:48.922
und dann hatten wir das halt irgendwie und dann gab es halt einen

00:49:48.922 --> 00:49:50.163
C-Python-Entwickler, der

00:49:50.163 --> 00:49:54.102
der hat das dann quasi wieder

00:49:54.102 --> 00:49:57.703
rückportiert, also hat halt unseren Code genommen

00:49:57.703 --> 00:49:59.223
und hat gesagt, ja cool, wir

00:49:59.223 --> 00:50:03.522
bauen das jetzt in C-Python ein und hat dann die nötige

00:50:03.522 --> 00:50:06.743
ich weiß nicht, ob es da ein PEP für gab oder ob er die nötige Mailing-Listen-Diskussion

00:50:06.743 --> 00:50:09.643
geführt und dann landete das halt in

00:50:09.643 --> 00:50:13.163
3.6 und dann wurde es halt quasi auch offiziell Teil der Semantik.

00:50:15.623 --> 00:50:18.223
Und ich meine, das ist ja eigentlich auch ganz cool, weil es ist halt wirklich,

00:50:20.542 --> 00:50:22.062
ich meine, das ist ja ein extra Feature.

00:50:22.542 --> 00:50:22.903
Intuitiv.

00:50:23.362 --> 00:50:27.562
Das ist intuitiv. Ich finde es auch zum Lehren viel nicer, wenn man halt sagen kann,

00:50:29.203 --> 00:50:32.403
wenn man nicht immer erklären muss, warum beim Printen plötzlich halt einfach die

00:50:32.403 --> 00:50:36.383
Keys halt so durcheinandergewirbelt werden. Das war ja früher so.

00:50:36.383 --> 00:51:06.362
und Jochen unterhalten sich über die Programmiersprache Python

00:51:06.383 --> 00:51:08.562
so eine komische Indirektion jetzt drin,

00:51:08.683 --> 00:51:10.663
dass man quasi einmal die HashMap

00:51:10.663 --> 00:51:12.663
hat und dann aber noch ein zweites Array,

00:51:13.082 --> 00:51:14.582
wo die Sachen in der Insertion Order

00:51:14.582 --> 00:51:16.683
drin sind. Und dann würde

00:51:16.683 --> 00:51:17.763
man halt erstmal denken,

00:51:18.643 --> 00:51:20.283
dass man halt da plötzlich ganz viel Speicher

00:51:20.283 --> 00:51:22.322
irgendwie mehr braucht,

00:51:22.743 --> 00:51:23.942
weil man diese Indirektion hat.

00:51:25.102 --> 00:51:26.502
Und da gibt es halt dann so einen Trick

00:51:26.502 --> 00:51:28.362
und das ist wirklich auch das, was ich nicht

00:51:28.362 --> 00:51:30.302
verstanden hätte vorher, bevor die

00:51:30.302 --> 00:51:32.342
Leute sich halt ausgedacht haben.

00:51:32.723 --> 00:51:34.422
Der Trick ist jetzt, die HashMap,

00:51:34.422 --> 00:51:36.623
die darf ja nicht voll sein, weil du sonst Collisions kriegst.

00:51:37.643 --> 00:51:38.422
Also wenn du

00:51:38.422 --> 00:51:40.422
quasi, wenn

00:51:40.422 --> 00:51:42.442
dein HashMap irgendwie zu voll wird,

00:51:42.522 --> 00:51:44.723
dann musst du halt irgendwie die verdoppeln,

00:51:45.022 --> 00:51:46.002
um sicherzustellen, dass

00:51:46.002 --> 00:51:48.102
du beim nächsten Mal speicherfrei bist, wo du irgendwas reinkriegst.

00:51:48.143 --> 00:51:50.302
Genau, ja. Und der Trick ist jetzt aber,

00:51:50.703 --> 00:51:52.403
dass du

00:51:52.403 --> 00:51:56.102
mit dieser Indirektion jetzt

00:51:56.102 --> 00:51:58.302
den großen Teil

00:51:58.302 --> 00:52:00.442
einfach

00:52:00.442 --> 00:52:01.542
linear speicherst.

00:52:02.842 --> 00:52:03.883
Also du kannst

00:52:03.883 --> 00:52:05.982
diese Lücken fallen dann weg.

00:52:06.783 --> 00:52:07.922
Die Lücken sind nur noch in deiner

00:52:07.922 --> 00:52:10.102
Indirektion drin, aber nicht mehr

00:52:10.102 --> 00:52:12.042
in deinem wirklichen Array, wo

00:52:12.042 --> 00:52:13.982
halt für jeden Eintrag ein

00:52:13.982 --> 00:52:15.802
Hash, ein Key und ein Value gespeichert werden.

00:52:17.143 --> 00:52:18.183
Weil ein Eintrag

00:52:18.183 --> 00:52:20.082
von einem Dictionary besteht ja quasi aus

00:52:20.082 --> 00:52:22.022
drei Maschinenwörtern und

00:52:22.022 --> 00:52:24.062
wenn die dann quasi immer noch so Lücken haben,

00:52:24.623 --> 00:52:25.962
hast du halt ständig Lücken, die

00:52:25.962 --> 00:52:27.522
alle drei Maschinenwörter groß sind.

00:52:28.042 --> 00:52:29.942
Aber wenn du die Indirektion einbaust,

00:52:30.062 --> 00:52:31.743
dann ist quasi ein Eintrag nur noch

00:52:31.743 --> 00:52:33.942
ein Index in den

00:52:33.942 --> 00:52:36.362
dichtgespeicherten

00:52:36.362 --> 00:52:38.082
Insertion Order

00:52:38.082 --> 00:52:38.582
Speicher.

00:52:40.123 --> 00:52:42.022
Jetzt sind wir an dem Punkt, wo wir eigentlich gerne ein Bild

00:52:42.022 --> 00:52:42.582
malen würden.

00:52:43.982 --> 00:52:45.502
Vielleicht ist dann der Blogpost.

00:52:46.263 --> 00:52:48.163
Ich finde den mal und wir verlinken den dann.

00:52:48.403 --> 00:52:50.002
Aber für mich war es halt

00:52:50.002 --> 00:52:51.522
erstmal nicht klar, dass das wirklich

00:52:51.522 --> 00:52:52.982
eine gute Idee ist.

00:52:54.243 --> 00:52:55.942
Ist es aber. Also Schnelligkeit

00:52:55.942 --> 00:52:56.903
raus, es ist es.

00:52:58.263 --> 00:52:58.802
Ja, cool.

00:53:00.102 --> 00:53:00.802
Echt interessant.

00:53:01.743 --> 00:53:03.322
und dann hat man quasi dann

00:53:03.322 --> 00:53:05.703
für drüber iterieren muss man dann einfach nur noch durch die

00:53:05.703 --> 00:53:07.623
echte Liste gehen und es gar nichts mehr macht.

00:53:07.862 --> 00:53:09.283
Das Iterieren ist halt auch besser, weil

00:53:09.283 --> 00:53:11.602
vorher war es halt so, man musste

00:53:11.602 --> 00:53:13.582
quasi über die Hashmap drüber iterieren

00:53:13.582 --> 00:53:15.143
und bei jedem Eintrag gucken,

00:53:15.582 --> 00:53:16.743
ist das überhaupt ein Eintrag oder nicht.

00:53:17.582 --> 00:53:20.263
Jetzt kann man aber quasi über den

00:53:20.263 --> 00:53:21.582
dichten Speicher drüber

00:53:21.582 --> 00:53:23.522
iterieren, wo einfach alle Einträge gültige

00:53:23.522 --> 00:53:24.143
Einträge sind.

00:53:25.342 --> 00:53:27.143
Und man muss halt gar nicht mehr, man hat dann quasi,

00:53:27.422 --> 00:53:29.263
verliert auch ein If in jedem

00:53:29.263 --> 00:53:29.962
Next-Aufruf.

00:53:31.743 --> 00:53:33.883
Also vorher war es so, dass man quasi in einem

00:53:33.883 --> 00:53:35.743
Next aufrufen eine Schleife brauchte, um den nächsten

00:53:35.743 --> 00:53:37.883
gültigen Eintrag zu finden. Und jetzt weiß man

00:53:37.883 --> 00:53:39.183
halt einfach, es ist der nächste Eintrag.

00:53:41.342 --> 00:53:42.163
Ja, schick.

00:53:43.102 --> 00:53:43.442
Ja, genau.

00:53:43.602 --> 00:53:45.743
Das wäre halt auch noch so ein Beispiel, wo wir quasi dann

00:53:45.743 --> 00:53:47.602
die Implementierungsebene so ein bisschen beeinflusst

00:53:47.602 --> 00:53:48.283
haben.

00:53:51.002 --> 00:53:51.783
Aber sonst,

00:53:52.002 --> 00:53:53.703
also so die ganzen Kerntechniken,

00:53:55.462 --> 00:53:56.123
die wir,

00:53:56.283 --> 00:53:57.302
also wir haben jetzt noch gar nicht so,

00:53:57.562 --> 00:53:59.643
bisher haben wir eher so ein bisschen phänomenologisch darüber

00:53:59.643 --> 00:54:01.783
geredet. Wir führen das aus, es wird schneller.

00:54:02.663 --> 00:54:03.002
Und ich glaube,

00:54:03.383 --> 00:54:05.442
jetzt müssen wir vielleicht so ein bisschen anfangen,

00:54:05.482 --> 00:54:06.883
darüber zu reden, wie das eigentlich geht.

00:54:10.243 --> 00:54:11.683
Also die Kern...

00:54:11.683 --> 00:54:13.263
Vielleicht, ich hätte noch ein, zwei Fragen.

00:54:13.263 --> 00:54:13.683
Ja, absolut.

00:54:15.203 --> 00:54:16.842
Werden alle Sachen schneller?

00:54:17.163 --> 00:54:19.302
Was mit anderen Sprachen?

00:54:19.403 --> 00:54:21.302
Also kann da C++ irgendwie, wenn das angebunden ist,

00:54:21.362 --> 00:54:21.862
ein Problem?

00:54:22.643 --> 00:54:25.163
Es wird halt erstmal vor allem

00:54:25.163 --> 00:54:26.602
Python schneller.

00:54:27.123 --> 00:54:29.042
Also wirklich, wenn du Python-Code auswählst, wird das schneller.

00:54:29.042 --> 00:54:30.342
Aber die anderen Sachen laufen noch?

00:54:30.403 --> 00:54:32.903
Die anderen Sachen laufen noch und es kommt so ein bisschen

00:54:32.903 --> 00:54:33.663
drauf an,

00:54:34.942 --> 00:54:36.922
was die genau machen, ob die dann

00:54:36.922 --> 00:54:38.942
vielleicht langsamer werden oder

00:54:38.942 --> 00:54:40.802
halt einfach gleich bleiben oder

00:54:40.802 --> 00:54:42.203
und dann gibt es halt

00:54:42.203 --> 00:54:44.743
so Randfälle, zum Beispiel reguläre Ausdrücke

00:54:44.743 --> 00:54:47.102
sind auch sehr, sehr schnell bei uns in PyPy,

00:54:47.822 --> 00:54:48.862
obwohl die natürlich eigentlich kein

00:54:48.862 --> 00:54:50.703
Python-Code sind, aber da haben wir dann extra

00:54:50.703 --> 00:54:52.102
Optimierung dafür. Das ist ja quasi

00:54:52.102 --> 00:54:53.683
so eine kleine DSL

00:54:53.683 --> 00:54:55.403
in Python.

00:54:55.403 --> 00:54:57.403
Kannst du die DSL nochmal beschreiben,

00:54:57.482 --> 00:54:58.183
weil ich so ein Längenwissen weiß?

00:54:58.183 --> 00:55:00.022
Genau, eine Domain-Specific-Language

00:55:00.022 --> 00:55:01.062
für String-Matching.

00:55:01.783 --> 00:55:03.842
Ich meine, das ist eine sehr häufige, die halt quasi überall

00:55:03.842 --> 00:55:05.842
eingebaut ist, aber es ist ja schon eine andere

00:55:05.842 --> 00:55:07.322
Programmiersprache als Python letztlich.

00:55:08.163 --> 00:55:10.022
Aber wir haben halt dafür auch dann quasi

00:55:10.022 --> 00:55:11.602
ganz viel Optimierung gemacht,

00:55:11.802 --> 00:55:12.663
dass das halt auch schon ist.

00:55:14.183 --> 00:55:15.922
Normalerweise kann ich die per PyEnv einfach

00:55:15.922 --> 00:55:16.903
anzudämmen, dann mein

00:55:16.903 --> 00:55:19.903
PyPy auch? Ich glaube, PyEnv

00:55:19.903 --> 00:55:21.802
unterstützt auch PyPy, ja. Also Otox

00:55:21.802 --> 00:55:24.022
hat eigentlich zum Beispiel PyPy-Support, wenn du das testen willst.

00:55:24.883 --> 00:55:26.002
Das ist schon an vielen

00:55:26.002 --> 00:55:27.922
Stellen quasi so ganz

00:55:27.922 --> 00:55:31.422
gut in die

00:55:31.422 --> 00:55:33.362
Infrastruktur.

00:55:34.802 --> 00:55:36.183
Nach den Semesterferien

00:55:36.183 --> 00:55:38.302
kriegen wir hoffentlich einen Alpha-Release.

00:55:38.982 --> 00:55:40.502
Da arbeite ich gerade dran.

00:55:41.362 --> 00:55:42.342
Heute Morgen habe ich

00:55:42.342 --> 00:55:44.422
zwei Packs gefixt. Das ist das, was ich

00:55:44.422 --> 00:55:46.482
jetzt gerade wirklich konkret mache.

00:55:47.783 --> 00:55:48.582
Die großen

00:55:48.582 --> 00:55:50.223
Features sind halt fast fertig.

00:55:51.283 --> 00:55:52.602
Pattern-Matching ist da

00:55:52.602 --> 00:55:53.783
und

00:55:53.783 --> 00:55:56.062
3.10 hat außer Pattern-Matching

00:55:56.062 --> 00:55:57.802
auch viele mittelgroße Sachen.

00:55:57.922 --> 00:55:58.263
oder so.

00:56:00.542 --> 00:56:01.763
Aber Pattern Matching, das war

00:56:01.763 --> 00:56:03.482
wirklich auch, kann ich mir vorstellen, das

00:56:03.482 --> 00:56:05.743
macht ja beim Parsen

00:56:05.743 --> 00:56:07.703
ein relativ großes... Ich glaube, das konnte ja auch

00:56:07.703 --> 00:56:09.962
nur deswegen in CPython

00:56:09.962 --> 00:56:11.522
irgendwie gemacht werden,

00:56:12.022 --> 00:56:13.562
weil da dann der neue

00:56:13.562 --> 00:56:15.683
Packparser irgendwie verwendet wurde und ich weiß gar nicht,

00:56:15.783 --> 00:56:16.362
bei PyPI

00:56:16.362 --> 00:56:19.042
ist es mir reingefallen.

00:56:20.322 --> 00:56:21.602
Da ist ja,

00:56:21.822 --> 00:56:23.683
da weiß ich gar nicht, was da verwendet wird, aber das

00:56:23.683 --> 00:56:24.542
könnte ja dann auch aussehen.

00:56:24.542 --> 00:56:25.783
Da hatte ich zum Glück sehr gut...

00:56:25.783 --> 00:56:28.143
Vor einem Jahr hatte ich dann 3.9 implementiert

00:56:28.143 --> 00:56:30.163
und da war 3.10 ja schon

00:56:30.163 --> 00:56:31.462
raus und da habe ich halt gesehen,

00:56:31.922 --> 00:56:33.302
der Packparser wird wichtig

00:56:33.302 --> 00:56:36.183
und ich habe dann quasi bei 3.9 schon die ganze

00:56:36.183 --> 00:56:38.283
technische Vorarbeit

00:56:38.283 --> 00:56:39.042
dafür geleistet.

00:56:39.163 --> 00:56:42.042
Wir haben auch einen Packparser, quasi mehr oder weniger

00:56:42.042 --> 00:56:43.862
die gleiche Architektur. Wir können nicht

00:56:43.862 --> 00:56:45.602
ganz das gleiche Input-File nehmen,

00:56:46.223 --> 00:56:47.982
weil, ich weiß nicht, ob du mal in diese Grammatik

00:56:47.982 --> 00:56:48.763
das File reingeschaut hast?

00:56:49.362 --> 00:56:50.062
Nee, nicht wirklich.

00:56:50.362 --> 00:56:53.723
Also das ist halt im Prinzip so ein bisschen so eine kontextfreie Grammatik,

00:56:53.723 --> 00:56:54.643
wie man das halt irgendwie

00:56:54.643 --> 00:56:57.283
aus irgendeiner Informatikvorlesung

00:56:57.283 --> 00:56:58.663
vielleicht mal gesehen hat, aber

00:56:58.663 --> 00:57:01.283
im Unterschied zur alten Grammatik ist das so,

00:57:01.362 --> 00:57:03.263
dass jetzt in der Pack-Grammatik

00:57:03.263 --> 00:57:05.203
da sind halt so Schnipsel an C-Code

00:57:05.203 --> 00:57:05.422
drin.

00:57:06.883 --> 00:57:09.163
Und die wollen wir halt nicht

00:57:09.163 --> 00:57:11.183
haben. Und wir müssen quasi

00:57:11.183 --> 00:57:13.362
die Schnipsel an C-Code, die mussten wir halt quasi von Hand

00:57:13.362 --> 00:57:15.163
einfach einmal überall ersetzen. Und das war

00:57:15.163 --> 00:57:15.763
sehr, sehr nervig.

00:57:16.922 --> 00:57:18.862
Und das ist auch so ein bisschen meine Kritik,

00:57:19.982 --> 00:57:20.862
dass quasi

00:57:20.862 --> 00:57:22.822
die Grammatik der Sprache

00:57:22.822 --> 00:57:25.022
vermischt wird mit den Parsing Actions,

00:57:25.123 --> 00:57:26.482
die in C geschrieben sind, bei C Python.

00:57:27.562 --> 00:57:28.763
Bei uns sind die nicht in C geschrieben,

00:57:28.883 --> 00:57:30.922
wir werden gleich noch darüber sprechen, worin

00:57:30.922 --> 00:57:32.763
die bei uns dann geschrieben sind, aber

00:57:32.763 --> 00:57:34.862
das war halt dann einmal sehr,

00:57:35.002 --> 00:57:36.462
sehr nervig, da drüber zu gehen und alle

00:57:36.462 --> 00:57:38.883
diesen C-Schnipsel dann da auszutauschen.

00:57:39.042 --> 00:57:40.802
Und da gibt es, da habe ich dann auch

00:57:40.802 --> 00:57:42.663
immer mal wieder einen Fehler gemacht, die finde ich dann jetzt

00:57:42.663 --> 00:57:44.383
auch immer mal wieder einen, also

00:57:44.383 --> 00:57:46.263
das war halt einfach Aufwand, aber

00:57:46.263 --> 00:57:48.623
ich habe halt damals quasi schon vor dem Jahr

00:57:48.623 --> 00:57:50.822
dann quasi schon vorgearbeitet und gesagt,

00:57:50.903 --> 00:57:52.703
wenn dann 3.10 kommt, dann

00:57:52.703 --> 00:57:54.703
will ich halt quasi auch schon darauf vorbereitet

00:57:54.703 --> 00:57:56.922
sein, dass das Pattern Matching

00:57:56.922 --> 00:57:58.422
dann in den Parser zumindest einfach

00:57:58.422 --> 00:58:00.643
einzufügen ist. Aber

00:58:00.643 --> 00:58:02.723
es ist halt nicht nur ein Parser, es ist

00:58:02.723 --> 00:58:04.643
ganz viel neues Syntax, aber es sind halt

00:58:04.643 --> 00:58:06.502
auch einiges an neuen Bytecodes und der

00:58:06.502 --> 00:58:08.422
Bytecode-Compiler hat halt

00:58:08.422 --> 00:58:10.322
ganz, ganz viel recht

00:58:10.322 --> 00:58:12.062
komplexe Logik auch gekriegt

00:58:12.062 --> 00:58:14.623
und das habe ich jetzt aber, das ist zum

00:58:14.623 --> 00:58:16.442
größten Teil jetzt halt ziemlich fertig.

00:58:16.683 --> 00:58:18.502
Also da fehlt mir noch so

00:58:18.502 --> 00:58:20.522
einen Randfall, den muss ich jetzt irgendwann noch fixen, der

00:58:20.522 --> 00:58:22.602
hat mich bisher noch zu sehr genervt, aber

00:58:22.602 --> 00:58:24.922
also das ist quasi fast durch

00:58:24.922 --> 00:58:28.482
und dann also jedes

00:58:28.482 --> 00:58:30.223
also jedes Release

00:58:30.223 --> 00:58:31.403
so der

00:58:31.403 --> 00:58:34.822
ich versuche mal so ein bisschen ein Gefühl

00:58:34.822 --> 00:58:36.602
dafür zu vermitteln, wie sich das anfühlt an so einer

00:58:36.602 --> 00:58:38.763
neuen Python Version zu arbeiten, es gibt halt immer

00:58:38.763 --> 00:58:40.862
irgendwie fünf große Features, die man halt auf der

00:58:40.862 --> 00:58:42.743
What's New Seite

00:58:42.743 --> 00:58:44.763
kennt und die implementiert man halt

00:58:44.763 --> 00:58:46.703
das ist dann irgendwie halt auch nice, ja weil

00:58:46.703 --> 00:58:48.763
da ist so ein klar umrissener Task

00:58:48.763 --> 00:58:50.102
und man freut sich vielleicht halt auch über

00:58:50.102 --> 00:58:52.422
vielleicht ist es halt auch ein Feature, was man gut findet

00:58:52.422 --> 00:58:54.922
Ich weiß nicht, wie ist euer Bauchgefühl?

00:58:55.143 --> 00:58:56.562
Wie gefühlt ihr dir Pattern Matching?

00:58:56.942 --> 00:58:57.582
Ich liebe es.

00:58:58.203 --> 00:59:00.243
Ich habe es noch nicht wirklich viel verwendet.

00:59:01.042 --> 00:59:02.143
Ich mag das total gerne.

00:59:02.562 --> 00:59:05.123
Statt if, elif irgendwie einfach schöne Cases zu machen.

00:59:05.562 --> 00:59:07.362
Gerade für so API-Parsing.

00:59:07.522 --> 00:59:08.942
Ich finde, man muss sich ganz...

00:59:08.942 --> 00:59:10.903
Ich verstehe absolut, dass man das

00:59:10.903 --> 00:59:12.883
total cool finden kann. Ich habe es auch noch nicht so

00:59:12.883 --> 00:59:13.942
richtig im Produktiv...

00:59:13.942 --> 00:59:16.942
Irgendwas geschrieben, was halt

00:59:16.942 --> 00:59:19.022
nicht einfach so ein Toy-Beispiel ist.

00:59:19.143 --> 00:59:21.102
Aber man muss sich schon so ein bisschen reindenken.

00:59:21.102 --> 00:59:29.623
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:31.783 --> 00:59:35.922
Ich glaube, wenn man dann da so mal gedanklich drin ist, ist es, glaube ich, wirklich auch sehr, sehr cool.

00:59:36.422 --> 00:59:37.322
Aber man braucht so ein bisschen.

00:59:37.663 --> 00:59:39.362
Oder ich habe das Gefühl, dass ich so noch so ein bisschen brauche.

00:59:39.383 --> 00:59:42.783
Man kann irgendwie so direkte Kommandos geben und man kann da direkt sagen, was das ist.

00:59:42.883 --> 00:59:45.383
Und in Zusammenhang mit den Typen, finde ich, ist das sehr schön.

00:59:45.602 --> 00:59:50.822
Wenn man halt tatsächlich Typen definiert hat, dann kann man halt einfach diesen Typ als Case nehmen.

00:59:51.102 --> 00:59:51.922
und das ist halt

00:59:51.922 --> 00:59:54.462
genau das, was man wahrscheinlich irgendwie...

00:59:54.462 --> 01:00:07.265
Aber was man dann wirklich in die Pythons reinschreibt das ist halt quasi nochmal so ein bisschen so eine Sprache in der Sprache und die ist halt schon so ein bisschen anders halt auch als der Rest von

01:00:07.265 --> 01:00:07.505
Python.

01:00:08.305 --> 01:00:10.345
Du musst vielleicht gleich nochmal so ein bisschen

01:00:10.345 --> 01:00:13.045
ausholen darüber, was eigentlich so eine Sprache aus deiner Sicht

01:00:13.045 --> 01:00:13.425
halt ist.

01:00:14.325 --> 01:00:15.565
Das ist jetzt ziemlich schwammig.

01:00:18.265 --> 01:00:18.665
Genau.

01:00:18.925 --> 01:00:21.085
Aber auf jeden Fall, man hat da so ein großes Feature,

01:00:21.405 --> 01:00:23.005
sowas wie Pattern Matching, das ist halt

01:00:23.005 --> 01:00:24.145
schön, da kann man,

01:00:24.145 --> 01:00:25.825
weiß man, das ist relativ klar umrissen,

01:00:26.425 --> 01:00:28.245
wenn man das Feature cool findet, dann macht es halt

01:00:28.245 --> 01:00:29.545
auch richtig Spaß, das zu implementieren.

01:00:30.205 --> 01:00:32.205
Über ein paar Tage hinweg fängt es halt

01:00:32.205 --> 01:00:34.145
dann an zu funktionieren. Das ist halt einfach immer wieder

01:00:34.145 --> 01:00:36.065
auch sehr cool. Und

01:00:36.065 --> 01:00:38.325
irgendwann ist man halt dann mit allen großen Featuren

01:00:38.325 --> 01:00:39.485
fertig und dann gibt es so ein bisschen

01:00:39.485 --> 01:00:42.245
zu den fünf großen Featuren gibt es

01:00:42.245 --> 01:00:44.145
halt vielleicht 30

01:00:44.145 --> 01:00:45.825
kleinere und mittlere Feature.

01:00:46.905 --> 01:00:48.265
Das ist halt so ein bisschen Fleißarbeit.

01:00:48.945 --> 01:00:50.225
Und dann gibt es aber halt

01:00:50.225 --> 01:00:52.305
einfach tausend Details.

01:00:53.685 --> 01:00:53.805
Und

01:00:53.805 --> 01:00:59.665
Das ist der Teil, der quasi am längsten dauert und ein bisschen am nervigsten ist.

01:00:59.925 --> 01:01:03.585
Also weil man halt jeden Tag einfach fünf kleine Details fixen kann

01:01:03.585 --> 01:01:07.725
und man findet die, indem man halt die Testsuite,

01:01:07.905 --> 01:01:11.865
die Teil der C-Python Standardbibliothek ist, ausführt

01:01:11.865 --> 01:01:15.825
und dann halt die fehlenden Tests nach und nach fixt.

01:01:16.845 --> 01:01:19.985
Und mit den großen Features ist man halt irgendwann durch.

01:01:19.985 --> 01:01:22.285
Also es gibt halt Test-Pepma, das hat man halt irgendwann dann,

01:01:22.425 --> 01:01:23.565
das passt dann, das ist super.

01:01:23.805 --> 01:01:26.085
Aber dann ist halt in allen anderen Dateien

01:01:26.085 --> 01:01:28.145
gibt es halt dann so einen fehlschlagenden

01:01:28.145 --> 01:01:30.085
Test. Und jeder von diesen fehlschlagenden

01:01:30.085 --> 01:01:31.385
Tests dauert halt zwei Stunden.

01:01:32.345 --> 01:01:34.045
Und das ist halt einfach das, was einfach ganz

01:01:34.045 --> 01:01:35.825
ganz...

01:01:35.825 --> 01:01:37.965
Also da gibt es halt quasi dann so einen long tail an irgendwelchen

01:01:37.965 --> 01:01:40.045
Details. Und der

01:01:40.045 --> 01:01:41.445
quasi

01:01:41.445 --> 01:01:43.925
Fortschritt, den man dadurch erzielt, dass man das

01:01:43.925 --> 01:01:45.965
fixt, ist halt auch irgendwann dann nicht mehr so

01:01:45.965 --> 01:01:47.905
groß. Wahrscheinlich denkt man sich dann irgendwann so

01:01:47.905 --> 01:01:49.225
das lohnt sich nicht.

01:01:49.225 --> 01:01:50.425
Wer das irgendwann mal benutzt.

01:01:51.125 --> 01:01:52.945
Aber das ist tatsächlich dann

01:01:52.945 --> 01:01:54.245
TDD auch, was ihr da macht.

01:01:55.245 --> 01:01:56.965
Ja, also Python ist von

01:01:56.965 --> 01:01:58.985
der Entwicklungsphilosophie sehr

01:01:58.985 --> 01:02:00.345
also ich meine,

01:02:01.225 --> 01:02:02.985
wir haben ja vorhin ganz kurz gesagt, dass es

01:02:02.985 --> 01:02:04.685
jetzt irgendwie 20 Jahre altes Projekt ist.

01:02:04.885 --> 01:02:05.165
Also es wurde

01:02:05.165 --> 01:02:08.865
fast genau, also irgendwie 17. Februar

01:02:08.865 --> 01:02:10.065
war das erste Treffen

01:02:10.065 --> 01:02:12.625
von so ein paar Leuten in Hildesheim.

01:02:13.085 --> 01:02:14.945
2003. 2003, genau.

01:02:14.945 --> 01:02:16.945
Also völlig anderes Zeitalter

01:02:16.945 --> 01:02:17.345
so ein bisschen.

01:02:19.025 --> 01:02:20.885
Und damals war das halt irgendwie

01:02:20.885 --> 01:02:22.725
so ein bisschen, hatte das so ein bisschen so

01:02:22.725 --> 01:02:23.825
Extreme Programming

01:02:23.825 --> 01:02:27.225
Kontext auf der Entwicklungsphilosophie

01:02:27.225 --> 01:02:28.365
Seite, also so mit

01:02:28.365 --> 01:02:30.425
Test Driven Development

01:02:30.425 --> 01:02:32.545
und Agile

01:02:32.545 --> 01:02:34.805
bevor das kommerzialisiert

01:02:34.805 --> 01:02:36.605
wurde, so von der Idee her und

01:02:36.605 --> 01:02:40.565
es ist wirklich so, dass

01:02:40.565 --> 01:02:43.005
diese Implementierung von vornherein

01:02:43.005 --> 01:02:44.645
komplett Test Driven

01:02:44.645 --> 01:02:46.845
entwickelt wurde. Das ist halt an vielen Stellen

01:02:46.845 --> 01:02:48.725
auch wirklich ganz tief

01:02:48.725 --> 01:02:49.985
drin in der

01:02:49.985 --> 01:02:52.085
Philosophie des Projekts.

01:02:52.725 --> 01:02:54.345
und es ist auch so, dass PyTest

01:02:54.345 --> 01:02:56.625
aus PyPy hervorgegangen ist.

01:02:57.305 --> 01:02:58.745
Also der Holger Krickel,

01:02:58.805 --> 01:03:00.345
über den haben wir, bevor wir

01:03:00.345 --> 01:03:02.365
anfangen aufzunehmen, kurz schon geredet, der war

01:03:02.365 --> 01:03:07.145
einer der Gründer

01:03:07.145 --> 01:03:08.465
des PyPy-Projekts, also der hat das

01:03:08.465 --> 01:03:10.685
erste Treffen in Hildesheim organisiert und

01:03:10.685 --> 01:03:13.105
am Anfang

01:03:13.105 --> 01:03:14.425
wurde dann

01:03:14.425 --> 01:03:16.485
für die Tests halt einfach Unitest

01:03:16.485 --> 01:03:18.525
genommen und Unitest ist ja

01:03:18.525 --> 01:03:20.465
ein von

01:03:20.465 --> 01:03:21.925
Java portiertes

01:03:21.925 --> 01:03:23.485
an Java

01:03:23.485 --> 01:03:26.145
Architektur angelehntes Testing Framework.

01:03:27.105 --> 01:03:28.445
Ja, JUnit, aber ich glaube

01:03:28.445 --> 01:03:30.245
JUnit ist irgendwie SUnit

01:03:30.245 --> 01:03:31.445
von SmartHawk.

01:03:32.585 --> 01:03:34.365
Aber durch diesen Umweg über Java

01:03:34.365 --> 01:03:35.985
ist es halt irgendwie doch ein bisschen

01:03:35.985 --> 01:03:37.785
ungelenk an vielen Stellen.

01:03:38.585 --> 01:03:40.465
Und weil Holger halt dann

01:03:40.465 --> 01:03:42.205
das alles auch ganz schön doof fand,

01:03:42.645 --> 01:03:44.645
hat er recht früh als Teil

01:03:44.645 --> 01:03:46.205
Projekt von PyPy halt

01:03:46.205 --> 01:03:47.945
angefangen PyTest zu entwickeln.

01:03:47.945 --> 01:03:52.385
und das ging dann quasi

01:03:52.385 --> 01:03:54.385
aus dem PyPy-Projekt

01:03:54.385 --> 01:03:56.125
irgendwie so ein Stück weit hervor und ist jetzt natürlich

01:03:56.125 --> 01:03:57.785
eine Million Mal

01:03:57.785 --> 01:03:59.725
erfolgreicher als alles, was PyPy

01:03:59.725 --> 01:04:01.225
jemals sonst so macht.

01:04:01.865 --> 01:04:04.205
Am Anfang habe ich es gehasst und jetzt finde ich es richtig gut,

01:04:04.285 --> 01:04:06.185
weil es halt echt total gut ist und ich finde es

01:04:06.185 --> 01:04:07.605
sehr PySonic und wenn man einmal so ein bisschen

01:04:07.605 --> 01:04:10.005
verstanden hat, wie das funktioniert, das ist sehr, sehr, sehr schön

01:04:10.005 --> 01:04:11.005
zu nutzen.

01:04:11.485 --> 01:04:14.045
Also ich meine halt einfach so dieses, dass man davon wegkommt,

01:04:14.145 --> 01:04:15.985
dass man diese 97

01:04:15.985 --> 01:04:17.645
Self-Assert irgendwas

01:04:17.645 --> 01:04:20.485
Funktionen braucht, um

01:04:20.485 --> 01:04:22.605
gute Fehlermeldungen zu kriegen. Das ist halt schon

01:04:22.605 --> 01:04:24.465
SafeAssert, Equal, irgendwie CamelCase

01:04:24.465 --> 01:04:25.845
und sowas. Equal oder Equals?

01:04:26.005 --> 01:04:27.065
Genau, ja, ja, genau.

01:04:27.125 --> 01:04:33.565
Ja, und CamelCase natürlich auch mal.

01:04:34.465 --> 01:04:36.325
Ja, und ich finde halt also gerade

01:04:36.325 --> 01:04:38.185
so die Hürde, man schreibt halt einfach eine Funktion,

01:04:38.265 --> 01:04:40.105
die Tests heißt dahin und dann geht halt,

01:04:40.165 --> 01:04:41.365
das ist halt schon sehr, sehr cool.

01:04:42.585 --> 01:04:44.705
Also Test-Driven-Development

01:04:44.705 --> 01:04:45.945
war halt einer der

01:04:45.945 --> 01:04:47.985
Kernideen, so auf der

01:04:47.985 --> 01:04:50.045
wie entwickeln wir dieses Projekt?

01:04:50.725 --> 01:04:51.725
Das andere war halt,

01:04:52.265 --> 01:04:53.945
das ist so ein bisschen verloren gegangen über die Jahre, aber

01:04:53.945 --> 01:04:55.905
einer der Ideen am Anfang war halt wirklich,

01:04:56.485 --> 01:04:57.565
wir wollen eine sehr

01:04:57.565 --> 01:04:59.985
gut verständliche Implementierung der

01:04:59.985 --> 01:05:02.045
Sprache schreiben. Und da

01:05:02.045 --> 01:05:04.005
müssen wir irgendwann jetzt halt dann

01:05:04.005 --> 01:05:05.045
doch mal zur Architektur kommen.

01:05:05.985 --> 01:05:07.085
Warum heißt das Ding eigentlich PyPy?

01:05:09.265 --> 01:05:10.105
Weil es PyPy

01:05:10.105 --> 01:05:10.645
noch nicht gab.

01:05:12.605 --> 01:05:13.365
Nein, Entschuldigung.

01:05:13.545 --> 01:05:15.505
Also das Projekt ist halt entstanden,

01:05:15.945 --> 01:05:18.365
aus Diskussionen auf erst der deutschen

01:05:18.365 --> 01:05:20.265
Python-Mailing-Liste und dann

01:05:20.265 --> 01:05:21.645
irgendwie auch Complaint Python

01:05:21.645 --> 01:05:23.245
von halt

01:05:23.245 --> 01:05:26.185
Python-Fans, also halt so ein paar Leuten, die

01:05:26.185 --> 01:05:27.945
irgendwie Python als Programmiersprache toll fanden

01:05:27.945 --> 01:05:30.425
und die halt gesagt haben, naja, es ist doch philosophisch

01:05:30.425 --> 01:05:31.385
eigentlich irgendwie blöd,

01:05:32.065 --> 01:05:33.805
dass wir alle Python so toll finden,

01:05:34.345 --> 01:05:36.405
aber der Interpreter

01:05:36.405 --> 01:05:38.545
für Python, dass der ja in C geschrieben ist.

01:05:40.045 --> 01:05:40.265
Und

01:05:40.265 --> 01:05:42.345
Piper ist halt wirklich, die Idee war

01:05:42.345 --> 01:05:44.245
wirklich, wir schreiben jetzt eine Implementierung für

01:05:44.245 --> 01:05:46.225
Python, aber wir wollen dafür halt nicht C nehmen,

01:05:46.325 --> 01:05:48.325
weil C so eine blöde Sprache ist, sondern wir wollen dafür halt

01:05:48.325 --> 01:05:50.205
Python nehmen, weil wir ja alle Python-Fans sind.

01:05:51.245 --> 01:05:52.325
Und das war quasi, also

01:05:52.325 --> 01:05:54.325
da kommt der Name her, PyPy ist Python in Python

01:05:54.325 --> 01:05:56.185
und das war halt

01:05:56.185 --> 01:05:57.685
so ein bisschen

01:05:57.685 --> 01:06:00.265
die Ursprungsmodifikation, wir wollen jetzt die

01:06:00.265 --> 01:06:02.105
Sprache nehmen, die wir cool finden, um

01:06:02.105 --> 01:06:04.485
die Sprache selbst zu implementieren.

01:06:04.905 --> 01:06:06.165
Und das klingt halt erstmal ganz

01:06:06.165 --> 01:06:08.245
also nach einem sehr akademischen

01:06:08.245 --> 01:06:10.305
Experiment und

01:06:10.305 --> 01:06:12.185
das war es ein Stück weit, glaube ich, auch erstmal.

01:06:12.185 --> 01:06:13.885
Also erstmal war halt so ein bisschen die Idee auch,

01:06:14.245 --> 01:06:18.185
Wir wollen irgendwie Code schreiben, den man halt einfach erstmal schön lesen kann.

01:06:18.705 --> 01:06:20.865
Und der soll natürlich schon auch irgendwie funktionieren,

01:06:21.525 --> 01:06:26.125
aber insbesondere soll der halt einfach architektonisch toll sein und irgendwie elegant

01:06:26.125 --> 01:06:31.785
und alles schön, diese Sprachsemantik soll irgendwie ganz klar ausgedrückt werden in diesem Python-Code.

01:06:32.065 --> 01:06:33.445
Das war quasi eine der Ideen.

01:06:34.265 --> 01:06:41.125
Und erst später kam es dann hinzu, dass quasi Performance eigentlich ein immer wichtiger Teil der,

01:06:41.125 --> 01:06:46.465
der Projektmotivation war.

01:06:46.885 --> 01:06:48.245
Also irgendwann hat man halt gesagt, naja,

01:06:48.725 --> 01:06:50.605
okay, wir haben das jetzt, aber warum sollte man das machen?

01:06:51.385 --> 01:06:53.545
Und wir machen jetzt halt auch noch ganz, ganz, ganz viel Aufwand,

01:06:53.845 --> 01:06:55.465
um, also welchen Aufwand,

01:06:55.765 --> 01:06:57.865
vielleicht sage ich noch ein bisschen was dazu,

01:06:58.525 --> 01:07:00.025
wir machen halt ganz, ganz viel Aufwand,

01:07:00.205 --> 01:07:01.705
um das dann doch irgendwie auch schnell zu kriegen.

01:07:02.965 --> 01:07:04.985
So, und vielleicht können wir da auch einfach wirklich historisch vorgehen.

01:07:04.985 --> 01:07:08.765
Also die erste Idee, um das jetzt schneller zu kriegen,

01:07:08.845 --> 01:07:10.805
also man hat dann jetzt irgendwie so eine Python-Implementierung,

01:07:10.805 --> 01:07:13.125
und die ist in Python geschrieben und die ist schön und elegant, man kann das lesen,

01:07:13.345 --> 01:07:14.585
aber das bringt einem halt einfach gar nichts.

01:07:15.005 --> 01:07:16.745
Weil man braucht ja einfach immer noch darunter

01:07:16.745 --> 01:07:19.145
einen Python-Interpreter, um das ausführen

01:07:19.145 --> 01:07:20.965
zu können. Und dann ist es halt einfach

01:07:20.965 --> 01:07:22.845
quasi ein Python-Interpreter, der auf

01:07:22.845 --> 01:07:25.085
C-Python läuft, das ist halt

01:07:25.085 --> 01:07:26.005
einfach ganz, ganz langsam.

01:07:26.365 --> 01:07:29.145
Aber man kann natürlich dann viel über die Sprache vielleicht lernen.

01:07:29.225 --> 01:07:31.045
Genau, man kann dann was lernen und man kann da bestimmt

01:07:31.045 --> 01:07:33.145
auch irgendwie dann schön einfach

01:07:33.145 --> 01:07:35.045
Experimente durchführen, aber das

01:07:35.045 --> 01:07:37.385
ist jetzt nichts, was man irgendwie im Produktiv-Einsatz

01:07:37.385 --> 01:07:38.825
haben wollte.

01:07:38.825 --> 01:07:41.385
Es wäre halt dann wirklich einfach eher so ein

01:07:41.385 --> 01:07:44.145
cooler Blogpost oder so, oder? Ein cooles Buch.

01:07:45.085 --> 01:07:46.465
Aber halt viel mehr auch nicht.

01:07:47.045 --> 01:07:48.545
Und die erste Idee ist quasi,

01:07:48.645 --> 01:07:49.425
dass man jetzt sagt,

01:07:51.085 --> 01:07:52.585
wir

01:07:52.585 --> 01:07:54.385
machen einen Prozess, den man halt

01:07:54.385 --> 01:07:56.325
Bootstrapping nennen kann.

01:07:56.945 --> 01:07:58.565
Wir nehmen jetzt diesen

01:07:58.565 --> 01:08:00.345
Python-Interpreter, der in Python geschrieben ist

01:08:00.345 --> 01:08:01.265
und

01:08:01.265 --> 01:08:04.645
übersetzen den, also

01:08:04.645 --> 01:08:06.405
schreiben einen Compiler, der jetzt diesen Code

01:08:06.405 --> 01:08:07.885
nehmen kann und den nach C übersetzen kann.

01:08:08.825 --> 01:08:10.565
und das

01:08:10.565 --> 01:08:13.185
geht halt nicht für allgemeinen

01:08:13.185 --> 01:08:14.745
Python-Code, man kann Python-Code halt nicht

01:08:14.745 --> 01:08:16.965
nach C kompilieren, das bringt nicht viel,

01:08:17.645 --> 01:08:19.045
aber deswegen beschränken

01:08:19.045 --> 01:08:20.565
wir uns auf eine Teilmenge von Python

01:08:20.565 --> 01:08:22.945
in dem Code,

01:08:23.045 --> 01:08:24.925
den wir in der Implementierung des Interpreters

01:08:24.925 --> 01:08:26.925
verwenden. Also der Interpreter ist

01:08:26.925 --> 01:08:28.185
quasi in einer Teilmenge geschrieben

01:08:28.185 --> 01:08:30.985
und die ist so gewählt, dass man diese Teilmenge

01:08:30.985 --> 01:08:32.025
gut nach C übersetzen kann.

01:08:32.705 --> 01:08:33.885
Und dann wird man quasi dieses

01:08:33.885 --> 01:08:36.985
Interpreter-Turm problemlos.

01:08:37.465 --> 01:08:38.205
Also dann kann man quasi

01:08:38.205 --> 01:08:42.205
den Python-Interpreter nehmen. Der ist nicht mehr in Python geschrieben, sondern in

01:08:42.205 --> 01:08:47.265
R-Python. Das ist eine Teilmenge der Sprache

01:08:47.265 --> 01:08:51.365
und die ist so gewählt, dass man sie nach C übersetzen kann. Und R-Python heißt das halt,

01:08:51.425 --> 01:08:55.285
weil das Restricted Python ist, weil man halt einfach so ein bisschen

01:08:55.285 --> 01:08:58.785
die ganz dynamischen Sachen, die man in Python machen kann,

01:08:59.305 --> 01:09:03.325
die macht man halt einfach nicht, um eben das Übersetzen nach C zu ermöglichen.

01:09:03.325 --> 01:09:06.805
Also man nennt keinen Typ einer Variable irgendwie on the fly. Ganz genau.

01:09:06.805 --> 01:09:09.245
Das ist glaube ich sogar noch nicht mal ganz so schlimm.

01:09:09.585 --> 01:09:11.065
Man macht halt so Sachen, man fügt

01:09:11.065 --> 01:09:13.145
einer Klasse keine neuen Methoden zur Laufzeit

01:09:13.145 --> 01:09:14.585
hinzu. Oder

01:09:14.585 --> 01:09:17.185
in Python gilt ja alle möglichen komischen Sachen.

01:09:17.285 --> 01:09:19.165
Man kann halt ja auch bei einer Instanz

01:09:19.165 --> 01:09:21.125
dann da Class zuweisen und so.

01:09:22.065 --> 01:09:23.265
So dieses ganze ganz

01:09:23.265 --> 01:09:25.065
dynamische Metaprogrammierungszeug, das ist halt

01:09:25.065 --> 01:09:26.085
einfach verboten, weil

01:09:26.085 --> 01:09:29.005
da ist halt nicht so klar, wie der C-Code

01:09:29.005 --> 01:09:30.625
dann aussähe, den man da generieren würde.

01:09:31.365 --> 01:09:32.725
Also das ist der erste Schritt. Der erste Schritt ist,

01:09:33.905 --> 01:09:35.265
das ist nicht mehr

01:09:35.265 --> 01:09:37.145
Python in beliebigem Python-Code,

01:09:37.225 --> 01:09:39.445
sondern das ist eine Implementierung

01:09:39.445 --> 01:09:41.345
für die Sprache Python in einer Teilmenge von Python

01:09:41.345 --> 01:09:43.325
und wir haben dazu noch ein anderes Tool,

01:09:43.725 --> 01:09:45.205
was jetzt diese Teilmenge nimmt und daraus

01:09:45.205 --> 01:09:47.325
C-Code erzeugt. Und so wird man C-Python

01:09:47.325 --> 01:09:49.185
erstmal los. Also danach,

01:09:49.685 --> 01:09:51.325
du drückst dann auf den Knopf und

01:09:51.325 --> 01:09:53.145
dann nimmt der halt den Interpreter, der

01:09:53.145 --> 01:09:55.125
in der Teilmenge geschrieben ist, erzeugt C-Code daraus,

01:09:55.645 --> 01:09:57.185
dann startest du den C-Compiler

01:09:57.185 --> 01:09:59.245
und der nimmt den C-Code und macht daraus halt

01:09:59.245 --> 01:10:01.265
eben wieder ein Binary, über das wir

01:10:01.265 --> 01:10:03.245
ja vorhin schon gesprochen haben, dass das

01:10:03.245 --> 01:10:05.205
runtergeladen werden kann. Und das

01:10:05.205 --> 01:10:06.405
ist halt dann quasi einfach

01:10:06.405 --> 01:10:08.405
ein etwas merkwürdiges

01:10:08.405 --> 01:10:10.985
geschriebenes, aber

01:10:10.985 --> 01:10:12.345
das verhält sich jetzt

01:10:12.345 --> 01:10:15.085
quasi noch näher dran an dem, was man von

01:10:15.085 --> 01:10:16.365
Python.org runterladen kann.

01:10:16.945 --> 01:10:19.325
Es ist halt ein nicht in Hand geschriebener

01:10:19.325 --> 01:10:20.945
C-Code, sondern generierter C-Code,

01:10:21.105 --> 01:10:23.085
aber es ist halt einfach dann ein Interpreter für

01:10:23.085 --> 01:10:24.865
Python in C

01:10:24.865 --> 01:10:25.445
letztlich.

01:10:26.805 --> 01:10:28.945
Und das

01:10:28.945 --> 01:10:30.465
bringt halt schon dann mal die ersten

01:10:30.465 --> 01:10:32.405
also vorher

01:10:32.405 --> 01:10:34.745
um mal so eine Größenordnung zu nennen,

01:10:35.205 --> 01:10:37.425
Wenn man dann PyPy auf

01:10:37.425 --> 01:10:39.405
CPython ausführt, dann hat man halt irgendwie so einen Interpreter,

01:10:39.545 --> 01:10:41.365
der vielleicht 2000 Mal langsamer ist als

01:10:41.365 --> 01:10:43.545
CPython. Also dann ist es halt

01:10:43.545 --> 01:10:45.325
wirklich, das ist nur ein Spielzeug.

01:10:45.905 --> 01:10:47.245
Und wenn man dann diesen

01:10:47.245 --> 01:10:49.665
Bootstrapping-Trick macht, dass man eben wieder C-Code erzeugt,

01:10:50.025 --> 01:10:51.345
dann gewinnt man halt von diesen

01:10:51.345 --> 01:10:53.625
2000 Mal

01:10:53.625 --> 01:10:55.385
langsamer, gewinnt man halt 1000 Mal

01:10:55.385 --> 01:10:57.665
zurück. Dann hat man quasi einen Interpreter,

01:10:57.745 --> 01:10:59.125
der ist...

01:10:59.125 --> 01:11:01.005
Nur 2000 Mal langsamer? Nee, nur 2 Mal langsamer.

01:11:01.945 --> 01:11:03.385
Also, Faktor 1000

01:11:03.385 --> 01:11:05.045
kriegt man wieder, aber

01:11:05.045 --> 01:11:06.945
ein Faktor 2 hat man halt immer noch

01:11:06.945 --> 01:11:08.305
und das ist natürlich immer noch nicht gut.

01:11:09.065 --> 01:11:10.845
Also warum sollte man das machen?

01:11:14.845 --> 01:11:17.005
Weil es halt in Python geschrieben ist und wir alle

01:11:17.005 --> 01:11:19.185
Python so toll finden. Das reicht halt irgendwie als Motivation

01:11:19.185 --> 01:11:21.165
nicht. Und jetzt ist so ein bisschen die Frage,

01:11:21.305 --> 01:11:22.625
wo kommt jetzt, wo

01:11:22.625 --> 01:11:25.125
kommt eigentlich wirklich die Speed her?

01:11:25.745 --> 01:11:27.185
Und da wird es halt dann so ein bisschen

01:11:27.185 --> 01:11:28.105
akademisch, also

01:11:28.105 --> 01:11:31.105
das ist quasi

01:11:31.105 --> 01:11:32.465
der Forschungsanteil.

01:11:32.465 --> 01:11:34.785
also ich habe da meine Doktorarbeit

01:11:34.785 --> 01:11:36.085
drüber geschrieben, das ist quasi wirklich

01:11:36.085 --> 01:11:38.685
so ein bisschen

01:11:38.685 --> 01:11:42.665
ein, ja, also war wirklich

01:11:42.665 --> 01:11:44.845
so ein ganz klassisches akademisches

01:11:44.845 --> 01:11:46.805
Forschungsprojekt, da war ja währenddessen auch gar nicht

01:11:46.805 --> 01:11:48.845
so klar, ob das wirklich klappen kann, so von der Idee

01:11:48.845 --> 01:11:50.305
her und hat auch

01:11:50.305 --> 01:11:51.885
sag ich mal vielleicht

01:11:51.885 --> 01:11:54.705
fünf, sechs Jahre gedauert, bis es

01:11:54.705 --> 01:11:56.905
dann klarer wurde, dass es halt wirklich geht

01:11:56.905 --> 01:11:58.825
und die Idee daran ist, dass du

01:11:58.825 --> 01:12:00.065
also

01:12:00.065 --> 01:12:03.725
sagt man ja auch immer so ein bisschen so, wenn man halt

01:12:03.725 --> 01:12:07.005
irgendwie das schnell kriegen will, dann braucht man halt irgendwie einen JIT-Compiler.

01:12:07.305 --> 01:12:09.905
Also wenn man halt irgendwie eine dynamische Programmiersprache

01:12:09.905 --> 01:12:12.705
schnell ausführen will, dann braucht man einen Just-in-Time-Compiler.

01:12:13.145 --> 01:12:15.825
Und was ist das? Ein Just-in-Time-Compiler, also so ein normaler

01:12:15.825 --> 01:12:18.945
Compiler, der funktioniert halt für Python nicht, weil man ja

01:12:18.945 --> 01:12:21.885
gar keine Typen hat. Also das ist jetzt mit Typ-Annotationen heutzutage

01:12:21.885 --> 01:12:24.885
so ein bisschen anders. Aber die Typ-Annotationen, die sind

01:12:24.885 --> 01:12:26.405
ja auch so ein bisschen so eine Fiktion.

01:12:27.345 --> 01:12:28.785
Die dürfen ja auch falsch sein.

01:12:30.065 --> 01:12:32.525
also vergessen wir die erstmal

01:12:32.525 --> 01:12:34.625
also das Problem ist, wenn man einfach Python-Code

01:12:34.625 --> 01:12:36.405
anschaut, dann kann man

01:12:36.405 --> 01:12:38.065
den halt nicht unbedingt

01:12:38.065 --> 01:12:39.985
jetzt kompilieren

01:12:39.985 --> 01:12:42.605
wenn man halt eine Funktion hat, die A und B als

01:12:42.605 --> 01:12:44.325
Argumente nimmt und die Funktion macht irgendwie

01:12:44.325 --> 01:12:46.465
return A mal 2

01:12:46.465 --> 01:12:48.425
plus B, dann

01:12:48.425 --> 01:12:50.005
kann man halt diese Funktion nicht

01:12:50.005 --> 01:12:52.685
nach Machine-Code übersetzen, weil

01:12:52.685 --> 01:12:54.625
man weiß halt gar nicht, was das

01:12:54.625 --> 01:12:56.325
mal macht, also

01:12:56.325 --> 01:12:58.645
man kann die Funktion halt mit ins aufrufen

01:12:58.645 --> 01:13:01.205
man kann die mit Floats aufrufen, man kann die mit Strings aufrufen

01:13:01.205 --> 01:13:02.885
oder man kann die halt

01:13:02.885 --> 01:13:05.365
mit einer Klasse aufrufen, die halt

01:13:05.365 --> 01:13:07.325
ein unterstrich unterstrich Ads Methode

01:13:07.325 --> 01:13:09.185
hat und eine unterstrich unterstrich Mull Methode

01:13:09.185 --> 01:13:11.265
und die halt irgendwas super weirdes

01:13:11.265 --> 01:13:13.025
macht. Das muss quasi

01:13:13.025 --> 01:13:15.065
die Anwendungsfälle kennen, in denen das

01:13:15.065 --> 01:13:17.345
aufgerufen wird, irgendwann in diesem Programmablauf

01:13:17.345 --> 01:13:18.885
und dann daraus jeweils unterschiedliche

01:13:18.885 --> 01:13:21.105
Implementierungen im Machine Code zu

01:13:21.105 --> 01:13:22.225
schreiben, die man dann vermittelt.

01:13:22.745 --> 01:13:25.045
Und das kann man aber halt quasi nicht ohne

01:13:25.045 --> 01:13:26.765
weiteres statisch machen. Also

01:13:26.765 --> 01:13:51.545
Also, man kann jetzt, es ist nicht leicht, sich quasi nur den Quellcode anzuschauen und zu sagen, aha, A und B sind hier immer ins, weil es kann ja sein, dass es halt an sieben verschiedenen Stellen wird die Funktion jetzt aufgerufen und an zwei davon sieht es so aus, als könnten es ins sein, aber an den anderen drei weiß ich nicht so genau und das ist überhaupt in der Bibliothek drin und ich weiß halt überhaupt nicht so genau, wie die Bibliothek jetzt verwendet wird konkret von irgendeiner Anwendung.

01:13:51.545 --> 01:13:53.485
Das heißt, so einfach

01:13:53.485 --> 01:13:55.605
wenn ich mir nur den Quellcode anschaue, kann ich

01:13:55.605 --> 01:13:57.025
für diese Funktion f

01:13:57.025 --> 01:13:59.065
keinen guten Maschinencode erzeugen

01:13:59.065 --> 01:14:00.985
und deswegen braucht man halt quasi

01:14:00.985 --> 01:14:03.105
also ein normaler Compiler geht halt nicht

01:14:03.105 --> 01:14:05.345
und deswegen

01:14:05.345 --> 01:14:07.205
braucht man halt eben den Just-In-Time-Compiler

01:14:07.205 --> 01:14:09.065
und das ist ein Compiler, der

01:14:09.065 --> 01:14:10.905
erzeugt

01:14:10.905 --> 01:14:13.245
zwar schon Maschinencode, aber der macht das nicht

01:14:13.245 --> 01:14:14.185
so

01:14:14.185 --> 01:14:17.205
einmal vor der Ausführung, sondern der

01:14:17.205 --> 01:14:19.165
macht das quasi während

01:14:19.165 --> 01:14:20.025
das Programm schon läuft

01:14:20.025 --> 01:14:21.965
und der Grund, warum

01:14:21.965 --> 01:14:23.365
ein Just-In-Home-Compiler eben

01:14:23.365 --> 01:14:25.965
funktioniert ist, weil der einen

01:14:25.965 --> 01:14:28.265
ganz krassen Informationsvorteil hat.

01:14:29.265 --> 01:14:30.245
Der Just-In-Home-Compiler,

01:14:30.325 --> 01:14:31.725
der kann halt einfach gucken,

01:14:32.385 --> 01:14:34.085
mit was für Typen von Argumenten

01:14:34.085 --> 01:14:34.945
die Funktion aufgerufen wird.

01:14:36.145 --> 01:14:38.025
Also der ist halt einfach quasi,

01:14:38.285 --> 01:14:40.125
der Compiler ist maximal faul und sagt, ich kompiliere

01:14:40.125 --> 01:14:42.225
erstmal gar nichts. Ich führe einfach

01:14:42.225 --> 01:14:43.905
alles ganz normal mit dem Interpreter aus

01:14:43.905 --> 01:14:46.245
und wenn sich

01:14:46.245 --> 01:14:48.125
dann herausstellen sollte, dass F jetzt

01:14:48.125 --> 01:14:49.745
in dem Programm eine wichtige Funktion ist,

01:14:50.025 --> 01:14:51.045
macht man so ein bisschen Profiling,

01:14:51.845 --> 01:14:54.405
dann schaue ich halt mal, was für Typen

01:14:54.405 --> 01:14:55.785
werden jetzt hier konkret verwendet.

01:14:56.825 --> 01:14:58.245
Und dann irgendwann sehe ich halt,

01:14:58.305 --> 01:14:59.305
na gut, das sind immer zwei Floats.

01:15:00.205 --> 01:15:01.565
Und dann kann ich halt

01:15:01.565 --> 01:15:03.725
auch guten Maschinencode erzeugen, weil

01:15:03.725 --> 01:15:06.185
wenn ich weiß, dass es Floats sind, dann kann ich halt

01:15:06.185 --> 01:15:07.305
das mal, also

01:15:07.305 --> 01:15:09.945
ich hatte A mal 2 plus B gesagt,

01:15:10.265 --> 01:15:11.425
dann kann ich halt das mal 2

01:15:11.425 --> 01:15:13.705
durch einen

01:15:13.705 --> 01:15:16.125
durch eine Maschinen

01:15:16.125 --> 01:15:17.565
Instruktion

01:15:17.565 --> 01:15:19.845
darstellen, die halt

01:15:19.845 --> 01:15:22.985
Doubles auf der CPU direkt multipliziert.

01:15:23.665 --> 01:15:26.345
Und das Plus kann ich eben auch dann durch eine Maschineninstruktion

01:15:26.345 --> 01:15:29.445
abbilden, die halt Doubles addiert.

01:15:30.085 --> 01:15:32.325
Und dieser Maschinencode, der funktioniert halt

01:15:32.325 --> 01:15:35.505
genau nur für den Spezialfall, dass A und B halt wirklich auch

01:15:35.505 --> 01:15:38.685
Float sind. Und wenn dann irgendwann

01:15:38.685 --> 01:15:41.525
später im Verlauf des Programms halt diese Funktion jemand mit 2ins

01:15:41.525 --> 01:15:43.765
aufruft, dann ist das kein Problem, weil

01:15:43.765 --> 01:15:47.925
der Code wurde ja sowieso zur Laufzeit erzeugt.

01:15:47.925 --> 01:15:49.285
und dann kann ich halt quasi auch

01:15:49.285 --> 01:15:51.985
neuen Code für diese sich ändernden Situationen

01:15:51.985 --> 01:15:52.605
erzeugen.

01:15:53.805 --> 01:15:55.685
Und diese Flexibilität, die mir die

01:15:55.685 --> 01:15:57.505
Tatsache, dass ich den

01:15:57.505 --> 01:15:59.485
Maschinencode eben erst zur Laufzeit erzeuge,

01:16:00.005 --> 01:16:01.865
dadurch kriege ich halt sehr viel Flexibilität

01:16:01.865 --> 01:16:02.765
und

01:16:02.765 --> 01:16:05.545
kann halt die extra

01:16:05.545 --> 01:16:07.805
Informationen, die ich zur Laufzeit habe, auch benutzen, um

01:16:07.805 --> 01:16:09.525
quasi

01:16:09.525 --> 01:16:11.725
die ganze Dynamizität,

01:16:11.865 --> 01:16:13.785
die man in Python halt theoretisch

01:16:13.785 --> 01:16:15.605
verwenden kann, aber in der Praxis

01:16:15.605 --> 01:16:16.725
nicht unbedingt verwendet,

01:16:16.725 --> 01:16:19.285
die kann ich dann halt auch quasi wieder weg

01:16:19.285 --> 01:16:21.725
optimieren, aber das kann ich eben nur

01:16:21.725 --> 01:16:23.405
weil ich eben das zur Laufzeit mache und

01:16:23.405 --> 01:16:25.485
mir die Typen anschauen kann

01:16:25.485 --> 01:16:27.905
und halt auch reagieren kann, wenn sich dann die

01:16:27.905 --> 01:16:29.085
Umstände ändern

01:16:29.085 --> 01:16:31.325
das ist halt auch so ein bisschen die andere

01:16:31.325 --> 01:16:33.365
Eigenschaft des

01:16:33.365 --> 01:16:35.705
Time Compilers, der kann halt dann auch darauf reagieren

01:16:35.705 --> 01:16:37.745
dass du nach

01:16:37.745 --> 01:16:39.865
einer halben Stunde Programmlaufzeit

01:16:39.865 --> 01:16:41.105
plötzlich den Debugger anmachen willst

01:16:41.105 --> 01:16:41.645
also

01:16:41.645 --> 01:16:45.065
dann muss man nämlich anfangen

01:16:45.065 --> 01:16:46.405
quasi

01:16:46.405 --> 01:16:49.565
wieder alles zurückzupacken

01:16:49.565 --> 01:16:51.385
und das nennt man wirklich Deoptimierung.

01:16:51.905 --> 01:16:53.225
Da muss man wirklich quasi wieder

01:16:53.225 --> 01:16:55.385
die Frame-Objekte erzeugen, die man halt

01:16:55.385 --> 01:16:57.345
braucht, um dann, dass der Debugger

01:16:57.345 --> 01:16:58.865
auch funktioniert. Also der Debugger, der

01:16:58.865 --> 01:17:01.345
introspeziert ja diese Frame-Objekte, die es in Python

01:17:01.345 --> 01:17:02.505
gibt und

01:17:02.505 --> 01:17:05.185
die würde der

01:17:05.185 --> 01:17:07.045
JIT-Compiler natürlich gar nicht benutzen, weil

01:17:07.045 --> 01:17:09.285
der Brauch der nicht. Aber wenn man den Debugger

01:17:09.285 --> 01:17:11.025
anschaltet, dann muss man die halt jederzeit wieder

01:17:11.025 --> 01:17:12.365
herzaubern können.

01:17:13.585 --> 01:17:15.545
Okay, das ist die Idee des JITs.

01:17:16.405 --> 01:17:18.165
Das ist quasi in gewisser Weise

01:17:18.165 --> 01:17:20.025
heutzutage

01:17:20.025 --> 01:17:21.905
relativ akzeptiert, weil jeder

01:17:21.905 --> 01:17:23.765
Browser das halt macht. Also Java

01:17:23.765 --> 01:17:25.805
macht das und insbesondere

01:17:25.805 --> 01:17:27.745
machen das halt die Browser für JavaScript und die

01:17:27.745 --> 01:17:29.925
Browser Wars haben halt dazu

01:17:29.925 --> 01:17:31.885
geführt, dass quasi alle großen Browser

01:17:31.885 --> 01:17:34.065
sehr, sehr,

01:17:34.165 --> 01:17:36.005
sehr, sehr, sehr viel Geld da reingesteckt

01:17:36.005 --> 01:17:36.405
haben,

01:17:37.245 --> 01:17:40.005
halt Just-In-Time-Compiler

01:17:40.005 --> 01:17:40.885
für JavaScript

01:17:40.885 --> 01:17:43.385
zu schreiben, die halt wirklich

01:17:43.385 --> 01:17:45.745
extrem aggressiv zur

01:17:45.745 --> 01:17:47.105
Laufzeit den JavaScript-Code

01:17:47.105 --> 01:17:49.485
optimieren und zur Laufzeit

01:17:49.485 --> 01:17:51.105
nach Maschinencode übersetzen können.

01:17:51.645 --> 01:17:53.725
Und deswegen ist JavaScript halt inzwischen

01:17:53.725 --> 01:17:55.525
jetzt,

01:17:55.745 --> 01:17:57.585
sag ich mal, nicht ganz so schnell wie C, aber halt

01:17:57.585 --> 01:17:59.625
irgendwie vielleicht nur zwei oder dreimal langsamer

01:17:59.625 --> 01:18:01.445
als C. Und einfach weil

01:18:01.445 --> 01:18:03.505
da halt einfach viele

01:18:03.505 --> 01:18:05.625
Millionen Dollar in jeder von

01:18:05.625 --> 01:18:06.825
diesen Implementierungen reingesteckt wurde.

01:18:09.925 --> 01:18:11.445
So, deswegen inzwischen weiß halt jeder

01:18:11.445 --> 01:18:12.565
so ein bisschen, was ein JIT ist.

01:18:13.865 --> 01:18:15.365
Das war aber halt, als das Projekt

01:18:15.365 --> 01:18:17.445
anfingen nicht ganz so

01:18:17.445 --> 01:18:19.465
sehr so. Es gab halt damals

01:18:19.465 --> 01:18:21.425
ich weiß nicht, sagt euch Psycho

01:18:21.425 --> 01:18:22.305
was? Ja.

01:18:24.785 --> 01:18:27.605
Das ist so ein bisschen, jetzt sind wir stark in der

01:18:27.605 --> 01:18:28.985
Ancient Python History drin.

01:18:29.385 --> 01:18:31.225
Also das war so ein Extension Module

01:18:31.225 --> 01:18:32.925
für Python

01:18:32.925 --> 01:18:33.805
2.2.

01:18:35.965 --> 01:18:37.045
Jetzt kommt raus,

01:18:37.045 --> 01:18:38.305
dass ich alt bin.

01:18:40.565 --> 01:18:41.085
Und

01:18:41.085 --> 01:18:43.045
das war quasi ein sehr, sehr

01:18:43.045 --> 01:18:45.025
schlauer, promovierter Mathematiker,

01:18:45.025 --> 01:18:47.205
er hat dieses Extension-Modul geschrieben

01:18:47.205 --> 01:18:48.685
und das war quasi ein

01:18:48.685 --> 01:18:50.785
Dit für CPython

01:18:50.785 --> 01:18:53.445
wenn man das Extension-Modul

01:18:53.445 --> 01:18:54.105
geladen hat

01:18:54.105 --> 01:18:57.185
dann hat halt Zyko angefangen zur Laufzeit

01:18:57.185 --> 01:18:58.725
aus den Python-Funktionen halt irgendwie

01:18:58.725 --> 01:19:00.985
Maschinencode zu erzeugen und das war halt auch

01:19:00.985 --> 01:19:02.605
hat gut funktioniert an vielen Stellen

01:19:02.605 --> 01:19:05.005
und das große Problem von Zyko war jetzt aber

01:19:05.005 --> 01:19:05.965
dass

01:19:05.965 --> 01:19:08.945
jede neue Python-Version, die rauskam

01:19:08.945 --> 01:19:10.025
hat das komplett kaputt gemacht

01:19:10.025 --> 01:19:11.905
also weil

01:19:11.905 --> 01:19:14.805
sobald ein neues Sprachfeature dazu kam

01:19:14.805 --> 01:19:16.645
musste der Armin

01:19:16.645 --> 01:19:18.445
Armin Rego heißt das

01:19:18.445 --> 01:19:20.405
musste dieses Excel-Modul halt wieder

01:19:20.405 --> 01:19:22.505
im Wesentlichen

01:19:22.505 --> 01:19:24.885
jetzt nicht von Null schreiben, aber halt

01:19:24.885 --> 01:19:26.905
quasi jede Zeile

01:19:26.905 --> 01:19:28.845
nochmal neu überdenken, weil das halt

01:19:28.845 --> 01:19:30.625
quasi immer so Interaktionen zwischen den

01:19:30.625 --> 01:19:32.905
neuen Sprachvierteln und den alten Sprachvierteln gibt

01:19:32.905 --> 01:19:34.705
und die waren halt nicht zu übersehen

01:19:34.705 --> 01:19:37.085
also da, ich weiß nicht, was kam

01:19:37.085 --> 01:19:37.905
mit 2.3 dazu?

01:19:38.485 --> 01:19:39.985
Vielleicht Generatoren oder so?

01:19:41.165 --> 01:19:41.965
Gab es da nicht auch irgendwie

01:19:41.965 --> 01:19:43.125
Glaubwink-Änderungen?

01:19:43.125 --> 01:19:45.485
weil es eher kann sein, ich weiß es nicht

01:19:45.485 --> 01:19:46.285
genau, aber

01:19:46.285 --> 01:19:51.365
auf jeden Fall, die haben

01:19:51.365 --> 01:19:52.825
halt immer nicht funktioniert in Psycho

01:19:52.825 --> 01:19:54.985
und Armin hat halt irgendwann auch aufgegeben

01:19:54.985 --> 01:19:56.565
also Psycho ist glaube ich seit 2004

01:19:56.565 --> 01:19:59.065
oder 2005 einfach auch tot

01:19:59.065 --> 01:20:01.125
und

01:20:01.125 --> 01:20:03.145
er hat halt aus

01:20:03.145 --> 01:20:05.365
dieser Frustration raus dann angefangen

01:20:05.365 --> 01:20:07.225
sich in PyPy

01:20:07.225 --> 01:20:09.445
also war einer der Projektgründer von PyPy

01:20:09.445 --> 01:20:11.045
und hat halt

01:20:11.045 --> 01:20:14.165
aus dieser Frustration raus, dass man

01:20:14.165 --> 01:20:16.205
den JIT aus Psycho

01:20:16.205 --> 01:20:18.225
für jede Version von Hand dann anpassen muss,

01:20:19.265 --> 01:20:20.525
sich so eine

01:20:20.525 --> 01:20:22.445
relativ gewagte

01:20:22.445 --> 01:20:24.605
akademische Idee ausgesucht,

01:20:25.065 --> 01:20:26.205
die er gerne auf PyPy

01:20:26.205 --> 01:20:28.305
anwenden wollte. Und das ist eben

01:20:28.305 --> 01:20:29.285
die Idee, dass man den JIT

01:20:29.285 --> 01:20:32.085
also JIT heißt, das ist die Abkürzung

01:20:32.085 --> 01:20:34.205
Justin Time Cobiler, dass man den überhaupt

01:20:34.205 --> 01:20:34.885
nicht von Hand schreibt.

01:20:36.725 --> 01:20:38.245
Eben weil Python

01:20:38.245 --> 01:20:39.825
eine Sprache ist, die sich ständig ändert.

01:20:39.825 --> 01:20:42.505
Also einmal im Jahr oder vielleicht damals

01:20:42.505 --> 01:20:44.725
alle anderthalb Jahre kommt eine neue Python-Version raus

01:20:44.725 --> 01:20:46.085
da gibt es neue Sprachfeature

01:20:46.085 --> 01:20:48.885
und das Anpassen des Dirt-Compilers an die neuen Sprachfeatures

01:20:48.885 --> 01:20:50.445
das ist zu nervig

01:20:50.445 --> 01:20:52.225
Insbesondere wenn man halt nicht

01:20:52.225 --> 01:20:53.485
Google-Geld hat

01:20:53.485 --> 01:20:56.625
Wenn man Google-Geld hat, dann kann man halt einfach 20 Ingenieure

01:20:56.625 --> 01:20:57.085
auf das Problem einhalten

01:20:57.085 --> 01:21:00.745
und die haben dann halt keinen Spaß, die schreiben ganz ganz

01:21:00.745 --> 01:21:02.745
viel kompliziertes C++-Code und sind halt

01:21:02.745 --> 01:21:04.765
jede Woche

01:21:04.765 --> 01:21:05.525
sehr traurig

01:21:05.525 --> 01:21:08.685
Aber wenn man dieses Budget halt nicht hat

01:21:08.685 --> 01:21:10.985
dann ist es einfach zu anstrengend

01:21:10.985 --> 01:21:12.725
mit C-Python mitzuhalten, also mit der

01:21:12.725 --> 01:21:14.665
Sprachentwicklung mitzuhalten und deswegen hatte

01:21:14.665 --> 01:21:16.085
er eben die Idee, dass es

01:21:16.085 --> 01:21:18.485
doch irgendwie möglich sein sollte

01:21:18.485 --> 01:21:21.025
den JIT-Compiler automatisch zu generieren

01:21:21.025 --> 01:21:22.805
und

01:21:22.805 --> 01:21:24.825
das ist so ein

01:21:24.825 --> 01:21:26.105
bisschen so eine alte

01:21:26.105 --> 01:21:28.705
sehr akademische

01:21:28.705 --> 01:21:30.865
Idee, also da gibt's

01:21:30.865 --> 01:21:31.305
halt irgendwie

01:21:31.305 --> 01:21:34.685
ich glaube in den Ende der 70er gab's so einen

01:21:34.685 --> 01:21:36.205
Aufsatz von Futamura

01:21:36.205 --> 01:21:38.665
irgendwie, weiß nicht genau

01:21:38.665 --> 01:21:40.325
wie der Titel ist, Compiler, Compiler.

01:21:40.825 --> 01:21:42.525
Da gab es eben schon mal die Idee, dass

01:21:42.525 --> 01:21:44.625
es theoretisch eben möglich sein sollte,

01:21:45.045 --> 01:21:46.165
einen Compiler für eine Sprache

01:21:46.165 --> 01:21:48.565
automatisch zu erzeugen aus einem

01:21:48.565 --> 01:21:49.625
Interpreter für die Sprache.

01:21:50.945 --> 01:21:52.545
Und das war aber halt ein

01:21:52.545 --> 01:21:54.205
sehr akademischer... Ich meine,

01:21:54.445 --> 01:21:56.365
ein Compiler, Compiler und so, das ist ja

01:21:56.365 --> 01:21:58.525
Jack und so. Ja, aber da

01:21:58.525 --> 01:21:59.925
ist der Input halt kein Interpreter.

01:22:00.105 --> 01:22:01.025
Nee, nee, das ist die Dramatik.

01:22:03.665 --> 01:22:04.325
Aber die

01:22:04.325 --> 01:22:06.465
Idee von der Moira-Projektion ist

01:22:06.465 --> 01:22:07.985
eben wirklich, man hat einen Interpreter für eine Sprache

01:22:07.985 --> 01:22:10.265
und erzeugt mit einem komplizierten Prozess

01:22:10.265 --> 01:22:12.005
aus dem Interpreter automatisch einen Compiler.

01:22:12.885 --> 01:22:14.525
Und das gab es quasi als akademische

01:22:14.525 --> 01:22:16.025
Idee, da gab es auch ein ganzes Forschungsfeld

01:22:16.025 --> 01:22:18.505
und ganz unglaublich

01:22:18.505 --> 01:22:19.225
viele Aufsätze zu.

01:22:20.865 --> 01:22:22.245
Aber das hat sich halt in der Praxis

01:22:22.245 --> 01:22:24.185
nicht so richtig umgesetzt. Und Armin

01:22:24.185 --> 01:22:26.165
hat halt die Idee gehabt, wir machen das jetzt

01:22:26.165 --> 01:22:28.465
einmal richtig.

01:22:29.445 --> 01:22:30.325
Also wir machen das jetzt halt

01:22:30.325 --> 01:22:31.145
also

01:22:31.145 --> 01:22:34.205
da hat sich in gewisser Weise auch sehr viel

01:22:34.205 --> 01:22:35.945
getraut. Er hat gesagt, ich habe jetzt diese Vision,

01:22:35.945 --> 01:22:37.465
das müsste doch irgendwie gehen

01:22:37.465 --> 01:22:39.965
und wir wollen das jetzt für eine echte Sprache halt auch

01:22:39.965 --> 01:22:41.005
wirklich dann mal anwenden

01:22:41.005 --> 01:22:43.945
und in gewisser Weise ist das Problem natürlich auch noch

01:22:43.945 --> 01:22:46.205
erstmal schwieriger, weil er halt nicht nur einen Compiler

01:22:46.205 --> 01:22:47.625
wollte, er wollte halt einen JIT Compiler

01:22:47.625 --> 01:22:49.565
und

01:22:49.565 --> 01:22:51.745
er hatte da so ein paar Ideen, wie man

01:22:51.745 --> 01:22:53.845
diese alte Idee

01:22:53.845 --> 01:22:54.865
der

01:22:54.865 --> 01:22:57.865
Futamora Projektion, wie man die halt wirklich dann mal

01:22:57.865 --> 01:22:59.905
so ganz konkret, nicht für irgendeine akademische

01:22:59.905 --> 01:23:01.925
Minisprache, sondern für so eine richtige

01:23:01.925 --> 01:23:03.045
Programmiersprache

01:23:03.045 --> 01:23:05.925
wie Python halt dann auch anwenden kann

01:23:05.925 --> 01:23:08.465
und das haben wir dann halt

01:23:08.465 --> 01:23:10.565
in den

01:23:10.565 --> 01:23:12.785
verschiedenen PyPy Research Projekten

01:23:12.785 --> 01:23:14.585
auch dann gemacht. Das ging auch

01:23:14.585 --> 01:23:16.605
ganz schön lange nicht. Also es hat halt

01:23:16.605 --> 01:23:18.765
wirklich dann auch ein paar

01:23:18.765 --> 01:23:20.845
Jahre gedauert, bis es dann wirklich auch funktioniert hat.

01:23:20.965 --> 01:23:22.885
Also PyPy ist ein Compiler-Compiler?

01:23:23.585 --> 01:23:24.345
Also PyPy hat

01:23:24.345 --> 01:23:26.505
so ein paar

01:23:26.505 --> 01:23:28.525
Komponenten, aber eine der Komponenten ist wirklich quasi

01:23:28.525 --> 01:23:30.845
ein JIT-Compiler-

01:23:30.845 --> 01:23:31.285
Generator.

01:23:32.225 --> 01:23:34.905
Und du steckst quasi einen Interpreter

01:23:34.905 --> 01:23:36.465
in diesen JIT-Compiler-Generator raus

01:23:36.465 --> 01:23:38.865
und der Output davon ist

01:23:38.865 --> 01:23:41.245
ein JIT-Compiler für die Sprache,

01:23:41.885 --> 01:23:43.405
die von deinem Interpreter

01:23:43.405 --> 01:23:46.785
spezifiziert wird.

01:23:47.785 --> 01:23:49.085
Und das hat riesen Vorteile,

01:23:49.225 --> 01:23:51.165
weil nämlich, wenn

01:23:51.165 --> 01:23:53.085
also

01:23:53.085 --> 01:23:55.165
nehmen wir mal sowas Konkretes wie Pattern Matching.

01:23:55.905 --> 01:23:57.005
Pattern Matching kommt jetzt raus

01:23:57.005 --> 01:23:57.885
in 3.10.

01:23:58.785 --> 01:24:00.985
Dann implementieren wir das in unserem

01:24:00.985 --> 01:24:01.865
Interpreter.

01:24:03.065 --> 01:24:04.665
Also PyPy ist ein Interpreter für Python

01:24:04.665 --> 01:24:07.765
und wir müssen das Feature halt implementieren,

01:24:07.865 --> 01:24:10.365
weil unser Interpreter, der kann das erstmal nicht.

01:24:10.425 --> 01:24:11.705
Also ihr implementiert das aber in C?

01:24:12.345 --> 01:24:12.785
Nee.

01:24:13.325 --> 01:24:13.845
In R-Python.

01:24:13.865 --> 01:24:14.705
In R-Python, genau.

01:24:14.925 --> 01:24:15.465
Das ist alles in R-Python.

01:24:15.965 --> 01:24:20.045
Aber wir interpretieren das quasi in dem in R-Python geschriebenen Interpreter.

01:24:21.065 --> 01:24:22.585
Und dann drücken wir auf den Knopf

01:24:22.585 --> 01:24:25.225
und dann kommt der JIT-Compiler-Generator

01:24:25.225 --> 01:24:26.985
und der nimmt den Interpreter mit dem neuen Feature

01:24:26.985 --> 01:24:29.385
und dann haben wir plötzlich einen JIT-Compiler,

01:24:29.985 --> 01:24:31.505
der quasi Pattern-Matching versteht

01:24:31.505 --> 01:24:34.545
und richtig guten Maschinen-Code für Pattern-Matching erzeugt.

01:24:34.665 --> 01:24:36.625
und

01:24:36.625 --> 01:24:39.805
der JIT-Compiler-Generator,

01:24:39.865 --> 01:24:41.505
der kennt Pattern-Matching halt gar nicht,

01:24:42.225 --> 01:24:43.505
sondern der kriegt quasi

01:24:43.505 --> 01:24:44.345
die, der

01:24:44.345 --> 01:24:47.805
lernt die Semantik von Pattern-Matching

01:24:47.805 --> 01:24:49.745
halt wirklich, indem er sich anschaut, was der Interpreter

01:24:49.745 --> 01:24:51.945
macht, um die Patterns auszuführen.

01:24:53.205 --> 01:24:53.965
Aber das heißt eben,

01:24:53.985 --> 01:24:56.005
wir müssen nicht, wenn so eine neue Version rauskommt,

01:24:56.085 --> 01:24:57.825
müssen wir nicht jedes Mal

01:24:57.825 --> 01:24:58.805
den JIT-Compiler anfassen,

01:24:59.565 --> 01:25:01.905
weil der JIT-Compiler, der kann halt überhaupt kein Python,

01:25:02.525 --> 01:25:03.805
sondern der kriegt halt die Semantik

01:25:03.805 --> 01:25:04.305
von Python

01:25:04.305 --> 01:25:07.685
ab, indem man

01:25:07.685 --> 01:25:09.745
sich diesen Interpreter für Python anschaut und wenn man

01:25:09.745 --> 01:25:11.785
in den Interpreter für Python neue Features

01:25:11.785 --> 01:25:13.465
einbaut, dann hat man immer

01:25:13.465 --> 01:25:15.045
automatisch auch noch,

01:25:15.965 --> 01:25:17.645
kann man eben für diese neuen Features

01:25:17.645 --> 01:25:18.945
dann auch den JIT generieren.

01:25:19.765 --> 01:25:21.705
Aber ein weiterer Vorteil, den man damit

01:25:21.705 --> 01:25:23.765
dann eventuell hätte, ist, man kann dann

01:25:23.765 --> 01:25:25.885
damit ja einen JIT-Compiler für jede Sprache

01:25:25.885 --> 01:25:28.425
erzeugen, für die man

01:25:28.425 --> 01:25:29.905
in R-Python einen Interpreter

01:25:29.905 --> 01:25:31.705
schreiben kann. Das geht ja dann wahrscheinlich für

01:25:31.705 --> 01:25:33.785
viele Sprachen. Ja, zum Beispiel, wir hatten da schon

01:25:33.785 --> 01:25:35.125
Beispiel vorhin für reguläre Ausdrücke.

01:25:36.545 --> 01:25:37.925
Also wir hatten ja vorhin gesagt, dass wir

01:25:37.925 --> 01:25:39.945
halt relativ gut darin sind, reguläre Ausdrücke

01:25:39.945 --> 01:25:41.565
auszuführen und das liegt halt einfach daran, dass

01:25:41.565 --> 01:25:43.765
in Python ist das auch schon so,

01:25:44.105 --> 01:25:45.405
reguläre Ausdrücke, die werden

01:25:45.405 --> 01:25:47.545
in so einen kleinen Bytecode

01:25:47.545 --> 01:25:50.145
erzeugt, der ist übersetzt.

01:25:50.765 --> 01:25:51.805
Das ist ein anderer Bytecode als der

01:25:51.805 --> 01:25:53.705
Python-Bytecode und dafür gibt es dann

01:25:53.705 --> 01:25:55.225
einen Interpreter, der Teil von

01:25:55.225 --> 01:25:57.085
C-Python ist. Also C-Python hat halt

01:25:57.085 --> 01:25:59.685
den Interpreter für Python, aber eben

01:25:59.685 --> 01:26:01.605
auch noch einen anderen Interpreter für die

01:26:01.605 --> 01:26:02.845
regulären Ausdrücke Bytecodes.

01:26:02.845 --> 01:26:05.065
und den haben wir halt auch in R-Python geschrieben

01:26:05.065 --> 01:26:07.345
und das heißt, wir können halt auch zur Laufzeit

01:26:07.345 --> 01:26:09.365
dann die regulären Ausdrücke nach Maschinencode

01:26:09.365 --> 01:26:11.285
übersetzen, weil

01:26:11.285 --> 01:26:12.905
wir halt quasi für diesen

01:26:12.905 --> 01:26:15.185
anderen Interpreter, der auch in R-Python

01:26:15.185 --> 01:26:17.245
geschrieben ist, auch ein JIT erzeugen.

01:26:18.565 --> 01:26:19.205
Und tatsächlich

01:26:19.205 --> 01:26:21.145
gibt es halt so einen ganzen Haufen an

01:26:21.145 --> 01:26:22.925
Research-Quality

01:26:22.925 --> 01:26:25.205
Sprachimplementierung, die halt

01:26:25.205 --> 01:26:27.265
diese ganze Maschinerie auch benutzen, um

01:26:27.265 --> 01:26:28.785
alle möglichen Experimente zu machen.

01:26:29.505 --> 01:26:31.585
Also wir haben halt auch mal eine Ruby-Implementierung

01:26:31.585 --> 01:26:33.545
geschrieben und eine PHP-Implementierung geschrieben

01:26:33.545 --> 01:26:35.725
und eine Prolog

01:26:35.725 --> 01:26:37.385
geschrieben. Das war meine Wäschearbeit.

01:26:38.625 --> 01:26:39.605
Und die sind jetzt alle

01:26:39.605 --> 01:26:40.105
nicht so cool.

01:26:41.165 --> 01:26:43.585
Da wurde halt einfach nicht der Aufwand

01:26:43.585 --> 01:26:45.505
reingesteckt, den man betreiben müsste, um

01:26:45.505 --> 01:26:47.525
da jetzt wirklich,

01:26:47.585 --> 01:26:49.765
sag ich mal, eine Production

01:26:49.765 --> 01:26:51.725
Ruby-Implementierung dann rauszukriegen.

01:26:52.045 --> 01:26:53.585
Aber das

01:26:53.585 --> 01:26:55.765
war halt eher so der Versuch

01:26:55.765 --> 01:26:57.445
zu gucken, ob das mit Ruby

01:26:57.445 --> 01:26:59.145
auch geht oder mit Prolog auch geht.

01:27:00.585 --> 01:27:01.405
Ich habe zum Beispiel

01:27:01.405 --> 01:27:03.565
auch mal, also auch nur Research Quality,

01:27:03.685 --> 01:27:04.345
ich habe zum Beispiel auch mal

01:27:04.345 --> 01:27:07.365
eine Datenbank

01:27:07.365 --> 01:27:09.285
darin implementiert. Also ich habe halt

01:27:09.285 --> 01:27:10.025
eine SQLite

01:27:10.025 --> 01:27:12.285
kompatible,

01:27:14.805 --> 01:27:15.685
also SQLite

01:27:15.685 --> 01:27:17.125
kompiliert halt

01:27:17.125 --> 01:27:19.645
den SQL-Code

01:27:19.645 --> 01:27:21.425
auch in so ein Bytecode. Dafür habe ich halt

01:27:21.425 --> 01:27:22.645
auch einen Interpreter in Python geschrieben.

01:27:23.865 --> 01:27:25.225
Und damit kann man halt dann auch

01:27:25.225 --> 01:27:27.685
ganz interessante Performance-Gewinne

01:27:27.685 --> 01:27:29.125
sich dann irgendwie abholen.

01:27:29.125 --> 01:27:31.685
Ja, die Datenbank muss das ja auch

01:27:31.685 --> 01:27:33.345
interpretieren, was da anfällig zu kommen ist

01:27:33.345 --> 01:27:34.305
Genau, und das ist ja auch

01:27:34.305 --> 01:27:37.445
das weiß man ja auch immer so ein bisschen, dass

01:27:37.445 --> 01:27:39.645
das SQLite mit den

01:27:39.645 --> 01:27:41.545
Typen

01:27:41.545 --> 01:27:42.945
der Spalten auch nicht so ernst nimmt

01:27:42.945 --> 01:27:43.885
Ja, da kann man

01:27:43.885 --> 01:27:47.545
Das heißt, es ist auch noch eine dynamische

01:27:47.545 --> 01:27:49.725
Sprache, eine dynamisch typisierte Programmiersprache

01:27:49.725 --> 01:27:51.645
Also da gibt es halt dann schon ganz schön viele Ähnlichkeiten

01:27:51.645 --> 01:27:52.025
zu

01:27:52.025 --> 01:27:55.005
Ausführungen von Python, in gewisser Weise

01:27:55.005 --> 01:27:57.505
Naja, auf jeden Fall, diese Idee

01:27:57.505 --> 01:27:59.825
dass wir halt quasi einen JIT-Generator

01:27:59.825 --> 01:28:01.405
haben und

01:28:01.405 --> 01:28:03.885
diese Architektur

01:28:03.885 --> 01:28:05.065
sorgt dafür, dass wir halt

01:28:05.065 --> 01:28:07.365
mit einem relativ kleinen Team

01:28:07.365 --> 01:28:09.605
halt mit C-Python

01:28:09.605 --> 01:28:11.365
trotzdem ganz gut mithalten können.

01:28:11.565 --> 01:28:13.625
Weil wir die Features halt eben nicht

01:28:13.625 --> 01:28:15.085
in den JIT-Compiler

01:28:15.085 --> 01:28:17.145
reinprogrammieren müssen,

01:28:17.805 --> 01:28:19.125
sondern halt quasi

01:28:19.125 --> 01:28:21.025
nur in einen Interpreter

01:28:21.025 --> 01:28:23.485
und der JIT-Compiler, der kriegt die Features dann

01:28:23.485 --> 01:28:25.205
automatisch. Das war jetzt

01:28:25.205 --> 01:28:27.025
so ein paar Verallgemeinerungen

01:28:27.025 --> 01:28:29.045
waren jetzt, also so ein paar Ungenauigkeiten

01:28:29.045 --> 01:28:30.305
waren in meiner Story jetzt noch drin.

01:28:31.465 --> 01:28:32.965
Es gibt dann noch so extra

01:28:32.965 --> 01:28:34.985
Annotationen, die nennen wir irgendwie

01:28:34.985 --> 01:28:37.005
Hints. Man kann halt quasi dem

01:28:37.005 --> 01:28:38.785
JIT-Compiler dann noch so ein paar Tipps geben.

01:28:39.205 --> 01:28:40.965
Ja, weil wahrscheinlich manchmal wird das halt dann

01:28:40.965 --> 01:28:42.885
überraschend nicht gut funktionieren.

01:28:43.205 --> 01:28:44.925
Ganz genau. Und man

01:28:44.925 --> 01:28:46.805
kriegt halt dann einen Maschinencode und der ist

01:28:46.805 --> 01:28:48.285
vielleicht noch nicht so gut, wie man den gerne hätte.

01:28:48.545 --> 01:28:50.925
Und dann fügt man halt noch so ein paar Annotationen ein und kann

01:28:50.925 --> 01:28:53.405
dann dem JIT-Compiler-Generator

01:28:53.405 --> 01:28:54.845
helfen, doch noch

01:28:54.845 --> 01:28:56.205
einen besseren JIT zu generieren.

01:28:56.205 --> 01:28:57.825
und das muss man dann

01:28:57.825 --> 01:29:00.125
an vier verschiedenen Stellen auch immer mal machen.

01:29:00.285 --> 01:29:02.285
Also zum Beispiel, ich würde jetzt meine Hand

01:29:02.285 --> 01:29:03.765
nicht ins Feuer legen, dass Pattern Matching halt

01:29:03.765 --> 01:29:05.765
jetzt schon ultra schnell ist.

01:29:06.105 --> 01:29:07.685
Also wir haben halt ein JIT für Pattern Matching,

01:29:08.085 --> 01:29:10.005
aber ich weiß noch nicht, ich habe es noch nicht gemessen,

01:29:10.125 --> 01:29:11.465
ob es wirklich ein ganz toller JIT ist.

01:29:11.645 --> 01:29:12.985
Das ist eh ziemlich langsam.

01:29:14.645 --> 01:29:16.385
In Zebraten ist es nicht so toll,

01:29:16.445 --> 01:29:17.345
oder? Ich weiß nicht, was...

01:29:17.345 --> 01:29:19.045
Ich glaube, also habe ich gehört, dass es nicht so schnell ist.

01:29:19.045 --> 01:29:19.865
Ich weiß nicht.

01:29:20.365 --> 01:29:22.465
Also ob das jetzt bei uns...

01:29:22.465 --> 01:29:25.265
Wir würden halt dann wirklich aus dem Pattern Matching

01:29:25.265 --> 01:29:27.525
Maschinencode erzeugen und ich weiß halt

01:29:27.525 --> 01:29:29.485
noch nicht so richtig, ob das richtig guter Maschinencode ist

01:29:29.485 --> 01:29:31.345
oder ob das halt einfach nur irgendwie so ein bisschen

01:29:31.345 --> 01:29:33.225
leicht schrottiger Maschinencode ist.

01:29:33.805 --> 01:29:35.585
Und wenn man das verbessern will, dann würde man halt

01:29:35.585 --> 01:29:37.305
hergehen und sagen, na gut,

01:29:37.805 --> 01:29:39.405
was für extra Hilfen können wir dem

01:29:39.405 --> 01:29:41.305
JIT noch geben? Das habe ich jetzt halt noch nicht gemacht,

01:29:41.425 --> 01:29:41.585
weil

01:29:41.585 --> 01:29:45.285
ich meine, das ist halt immer so ein bisschen,

01:29:45.825 --> 01:29:46.885
das kommt halt als letztes.

01:29:47.125 --> 01:29:49.325
Du musst halt quasi aber immer den Generator anlehnen, du kannst halt

01:29:49.325 --> 01:29:51.245
quasi nie richtig in der Hand, was wirklich da liegt

01:29:51.245 --> 01:29:53.085
an C-Code, der hinterher ausgeführt wird.

01:29:55.265 --> 01:30:05.087
also indirekt Moment warum C Ja weil du doch dem Generator sagst was er tun soll der den C generiert der dann hinterher ausgef wird

01:30:05.087 --> 01:30:07.007
Ja, der C-Code ist dir eigentlich so ein bisschen egal.

01:30:07.487 --> 01:30:09.047
Also wichtig ist halt, du generierst

01:30:09.047 --> 01:30:10.947
einmal C-Code, aber du generierst halt

01:30:10.947 --> 01:30:12.467
auch noch einen

01:30:12.467 --> 01:30:14.747
JIT

01:30:14.747 --> 01:30:17.107
und der JIT, der übersetzt den Python-Code

01:30:17.107 --> 01:30:18.887
nicht nach C-Code, sondern wirklich direkt nach

01:30:18.887 --> 01:30:20.627
Machine-Code. Also wir

01:30:20.627 --> 01:30:22.847
erzeugen dann wirklich, wir nehmen den Python-Code, führen

01:30:22.847 --> 01:30:24.707
den aus und nach einer Weile sagen wir halt,

01:30:24.707 --> 01:30:34.587
und sagt, oh okay, diese Schleife hier, die scheint irgendwie wichtig zu sein und dann nehmen wir wirklich diese Schleife und erzeugen daraus halt wirklich direkt ins RAM Maschinencode-Instruktionen.

01:30:34.827 --> 01:30:40.007
Und das geht halt nicht mehr den Umweg über C. Den Umweg über C brauchen wir nur, um einmal das Binary zu erzeugen.

01:30:40.707 --> 01:30:49.168
Das machen halt wir einmal auf unserem Server und das passiert aber dann quasi nach dem Deployment auf die Produktivumgebung nicht mehr,

01:30:49.168 --> 01:30:50.387
sondern da wird halt wirklich direkt

01:30:50.387 --> 01:30:53.787
ins RAM, werden halt die Maschineninstruktionen

01:30:53.787 --> 01:30:54.967
für die

01:30:54.967 --> 01:30:56.807
aktuelle CPU-Architektur

01:30:56.807 --> 01:30:59.347
emitted und dann führen wir das

01:30:59.347 --> 01:30:59.827
halt direkt raus.

01:31:01.327 --> 01:31:02.947
Sprich, wenn du das halt auf irgendwie so

01:31:02.947 --> 01:31:04.967
einem x86

01:31:04.967 --> 01:31:06.487
Server laufen lässt, dann

01:31:06.487 --> 01:31:09.067
schnappen wir uns halt einfach vom Betriebssystem

01:31:09.067 --> 01:31:10.427
so einen großen Buffer an

01:31:10.427 --> 01:31:12.707
RAM und

01:31:12.707 --> 01:31:15.007
da kommen halt dann

01:31:15.007 --> 01:31:17.247
Instruktionen rein und dann wird

01:31:17.247 --> 01:31:19.648
als ausführbar markiert

01:31:19.648 --> 01:31:21.668
und dann springen wir einfach hin.

01:31:21.987 --> 01:31:23.527
Und dann von da an läuft

01:31:23.527 --> 01:31:24.648
halt wirklich der Maschinencode und der

01:31:24.648 --> 01:31:27.387
also wenn man Glück hat, ist der halt

01:31:27.387 --> 01:31:28.827
einfach dann auch sehr, sehr schnell, weil

01:31:28.827 --> 01:31:31.207
der das ganze teure Zeug, was

01:31:31.207 --> 01:31:33.587
in Python halt normalerweise die ganze Zeit

01:31:33.587 --> 01:31:35.407
passieren muss, halt nicht mehr macht.

01:31:35.967 --> 01:31:37.247
Und den ganzen Overhead von den ganzen Sachen.

01:31:37.387 --> 01:31:38.967
Ja, also und der Overhead,

01:31:39.427 --> 01:31:41.387
also man hat halt

01:31:41.387 --> 01:31:43.487
die Frame-Objekte nicht mehr, man hat die ganzen

01:31:43.487 --> 01:31:45.587
Typ-Überprüfungen nicht mehr, idealerweise.

01:31:45.587 --> 01:31:48.627
also Python allociert ja auch die ganze Zeit Speicher

01:31:48.627 --> 01:31:49.827
also jeder

01:31:49.827 --> 01:31:52.027
Integer ist ja

01:31:52.027 --> 01:31:54.347
so ein bisschen Heap Memory

01:31:54.347 --> 01:31:56.347
also jede Addition

01:31:56.347 --> 01:31:58.007
macht halt einen Malloc-Aufruf

01:31:58.007 --> 01:32:00.107
und das ist ja eigentlich absurd teuer

01:32:00.107 --> 01:32:02.127
also ein Malloc-Aufruf und

01:32:02.127 --> 01:32:03.947
es wird eben

01:32:03.947 --> 01:32:06.347
der Reference-Count auch noch immer manipuliert

01:32:06.347 --> 01:32:07.507
also

01:32:07.507 --> 01:32:09.887
vielleicht auch nochmal ganz kurz für die Leute, die ja nicht ganz so

01:32:09.887 --> 01:32:11.867
einen Malloc-Aufruf, also eine Memory-Aggregation

01:32:11.867 --> 01:32:13.127
ist ein C, eine Funktion, die

01:32:13.127 --> 01:32:14.967
auf dem Heap. Was macht das?

01:32:14.967 --> 01:32:15.627
Vielleicht nochmal ganz kurz.

01:32:16.587 --> 01:32:18.307
Ganz die freien Hektien, was die versteckt.

01:32:19.668 --> 01:32:21.047
Vielleicht kann man das einfach nochmal so ein bisschen

01:32:21.047 --> 01:32:22.707
den Kontrast herstellen mit

01:32:22.707 --> 01:32:23.987
wir schreiben jetzt wirklich ein Programm in C.

01:32:24.587 --> 01:32:27.367
Und wenn du da halt irgendwie eine Integer-Variable

01:32:27.367 --> 01:32:29.168
also long A und long B

01:32:29.168 --> 01:32:31.188
hast und dann machst du A plus B,

01:32:32.107 --> 01:32:33.047
dann sind A

01:32:33.047 --> 01:32:34.107
und B halt nicht

01:32:34.107 --> 01:32:36.807
auf dem Heap, sondern irgendwie direkt in

01:32:36.807 --> 01:32:38.607
CPU-Registern.

01:32:38.947 --> 01:32:41.127
Und die werden dann direkt von CPU-

01:32:41.867 --> 01:32:42.547
Instruktionen addiert.

01:32:42.547 --> 01:32:44.547
und mit dem Ergebnis wird halt irgendwas gemacht.

01:32:46.247 --> 01:32:46.527
Wenn du

01:32:46.527 --> 01:32:48.668
so einen Ausdruck A und B

01:32:48.668 --> 01:32:50.727
in Python hinschreibst und das

01:32:50.727 --> 01:32:52.168
in C-Python ausführst,

01:32:52.648 --> 01:32:54.668
dann ist das halt nicht, also die

01:32:54.668 --> 01:32:56.727
Integer-Werte, die sind dann nicht in CPU-Registern,

01:32:56.807 --> 01:32:58.867
sondern die sind quasi im RAM.

01:32:59.747 --> 01:33:00.587
Und um dann wirklich

01:33:00.587 --> 01:33:02.547
das Ergebnis berechnen zu können, musst du die

01:33:02.547 --> 01:33:04.307
Werte erstmal aus dem RAM,

01:33:04.668 --> 01:33:05.827
also erstmal musst du gucken,

01:33:06.607 --> 01:33:08.367
sind das überhaupt Integers, die ich da addiere.

01:33:09.247 --> 01:33:10.227
Und dann musst du gucken,

01:33:10.227 --> 01:33:17.847
dann musst du quasi die Werte der Integer aus dem Integer-Objekt vom RAM in CPU-Register laden

01:33:17.847 --> 01:33:20.168
dann machst du wirklich die Addition

01:33:20.168 --> 01:33:26.547
dann musst du gucken, ob das Ergebnis immer noch klein genug ist, um in einen Maschinen-Wort reinzupassen

01:33:26.547 --> 01:33:30.827
das könnte ja auch irgendwie ein Overflow geben, dann brauchst du irgendwie ein kompliziertes Objekt

01:33:30.827 --> 01:33:36.767
und dann brauchst du Speicher für das Ergebnis-Objekt, weil das Ergebnis ist ja auch wieder ein Integer-Objekt

01:33:36.767 --> 01:33:38.067
das heißt, du rufst einmal mal log auf

01:33:38.067 --> 01:33:40.127
dann kriegst du ein neues Stück

01:33:40.127 --> 01:33:42.507
RAM zugewiesen von dem

01:33:42.507 --> 01:33:44.247
in C geschriebenen Allokator

01:33:44.247 --> 01:33:46.127
und dann

01:33:46.127 --> 01:33:47.827
packst du den Ergebnis

01:33:47.827 --> 01:33:49.607
Zahlenwert in dieses neue Stück

01:33:49.607 --> 01:33:52.227
RAM rein, erhöhst den Reference Count

01:33:52.227 --> 01:33:53.347
von diesem Stück RAM

01:33:53.347 --> 01:33:56.247
und das ist dann dein Ergebnisobjekt

01:33:56.247 --> 01:33:58.127
und das passiert aber halt bei

01:33:58.127 --> 01:34:00.127
jeder arithmetischen Operation und deswegen ist

01:34:00.127 --> 01:34:01.648
halt Arithmetik

01:34:01.648 --> 01:34:03.947
und wir haben auch noch so ein paar Schritte weggelassen

01:34:03.947 --> 01:34:06.007
deswegen ist Arithmetik halt

01:34:06.007 --> 01:34:07.607
in Python klassischerweise wirklich

01:34:07.607 --> 01:34:09.267
sehr, sehr ineffizient.

01:34:10.367 --> 01:34:12.148
Weil du halt wirklich ständig

01:34:12.148 --> 01:34:14.267
Melloc aufrufst und auch ständig

01:34:14.267 --> 01:34:16.307
wieder Free aufrufst. Zum Beispiel, wenn du jetzt so einen komplizierteren

01:34:16.307 --> 01:34:18.047
Ausdruck hast, wenn du halt sowas wie

01:34:18.047 --> 01:34:19.507
A mal 2 plus B,

01:34:19.787 --> 01:34:21.407
das war ja unser Standard

01:34:21.407 --> 01:34:24.327
arithmetischer Ausdruck

01:34:24.327 --> 01:34:26.267
schon in der Zeit, dann hast du

01:34:26.267 --> 01:34:28.047
halt das Zwischenergebnis A mal 2.

01:34:29.247 --> 01:34:30.367
Das brauchst du ja gar nicht lang.

01:34:31.587 --> 01:34:32.407
Das brauchst du ja

01:34:32.407 --> 01:34:33.547
quasi nur...

01:34:33.547 --> 01:34:34.907
Das verfällt ja beim nächsten Aufruf.

01:34:35.387 --> 01:34:37.327
Das heißt, beim nächsten Aufruf, wenn du dann

01:34:37.327 --> 01:34:39.387
wenn du dann das Plus rechnest, dann

01:34:39.387 --> 01:34:40.947
verringerst du den

01:34:40.947 --> 01:34:43.327
Reference Count von dem Zwischenergebnis

01:34:43.327 --> 01:34:45.447
und dann sagst du, oh, das ist ja

01:34:45.447 --> 01:34:47.287
jetzt Null, das brauch ich ja gar nicht mehr

01:34:47.287 --> 01:34:49.487
und dann rufst du Free auf, das ist

01:34:49.487 --> 01:34:51.567
wieder quasi so ein teurer Aufruf

01:34:51.567 --> 01:34:53.067
zu dem

01:34:53.067 --> 01:34:54.987
Memory-Subsystem.

01:34:55.247 --> 01:34:57.067
Schreibt der Null den Speicher oder löscht der einfach

01:34:57.067 --> 01:34:59.507
die Speicheradresse aus, dem wir benutzen

01:34:59.507 --> 01:35:01.287
das? Genau, und dann kannst du quasi

01:35:01.287 --> 01:35:03.487
den Speicher wiederverwenden, das nächste Mal, wenn jemand

01:35:03.487 --> 01:35:05.107
mehr da braucht. Aber der schreibt dann nicht vorher irgendwie

01:35:05.107 --> 01:35:05.747
was rein.

01:35:06.587 --> 01:35:07.668
Doch, der muss sich

01:35:07.668 --> 01:35:11.148
schon irgendwie merken, dass der Speicher jetzt verwendet

01:35:11.148 --> 01:35:12.327
werden kann. Also es gibt halt so ein bisschen

01:35:12.327 --> 01:35:14.227
es gibt quasi so ein bisschen

01:35:14.227 --> 01:35:16.967
Overhead-Datenstrukturen, die

01:35:16.967 --> 01:35:18.527
verwendet werden, um

01:35:18.527 --> 01:35:21.067
sich zu merken, dass das

01:35:21.067 --> 01:35:22.387
jetzt ein Stück freier Speicher ist.

01:35:22.747 --> 01:35:24.947
Am Anfang von einem Speicherblock schreibt der irgendwie so

01:35:24.947 --> 01:35:26.487
Das ist

01:35:26.487 --> 01:35:28.967
glaube ich gar nicht so wichtig. Das funktioniert auch sehr

01:35:28.967 --> 01:35:30.607
unterschiedlich, je nach Betriebsthemen und

01:35:30.607 --> 01:35:31.227
je nach

01:35:31.227 --> 01:35:32.567
je nach

01:35:32.567 --> 01:35:35.387
verwendetem Allokator.

01:35:35.827 --> 01:35:36.947
Also da gibt es halt auch verschiedene

01:35:36.947 --> 01:35:38.607
C-Bibliotheken, die man da verwenden kann.

01:35:39.827 --> 01:35:41.547
Python hat da auch so ein bisschen

01:35:41.547 --> 01:35:42.967
seine eigenen Algorithmen, die

01:35:42.967 --> 01:35:45.688
für den typischen

01:35:45.688 --> 01:35:47.227
Use Case, der halt in Python

01:35:47.227 --> 01:35:49.527
besonders oft auftritt, dann optimiert ist.

01:35:50.527 --> 01:35:51.527
Also da ist quasi dann

01:35:51.527 --> 01:35:53.267
ganz, ganz viel Engineering und

01:35:53.267 --> 01:35:55.747
das ist kompliziert und

01:35:55.747 --> 01:35:57.547
wir müssen das hoffentlich nicht verstehen.

01:35:57.787 --> 01:35:59.668
Also das ist

01:35:59.668 --> 01:36:03.087
quasi, da kenne ich mich dann irgendwann ziemlich schnell halt auch nicht aus.

01:36:04.427 --> 01:36:07.327
Ja, aber letztlich das Problem ist halt, dass es halt

01:36:07.327 --> 01:36:11.287
Speicheralluzieren ist halt eine relativ

01:36:11.287 --> 01:36:15.007
komplexe, weil man halt auch das Betriebssystem in den Kernel fragen muss letztlich.

01:36:15.487 --> 01:36:19.327
Am Schluss, ja nicht jedes Mal, aber irgendwann schon letztlich und dann

01:36:19.327 --> 01:36:23.267
das natürlich alles sauteuer ist. Und dieser ganze Overhead fällt halt weg,

01:36:23.267 --> 01:36:27.168
wenn du A plus B mal C mit ins ausführst und der

01:36:27.168 --> 01:36:57.148
und

01:36:57.168 --> 01:36:58.027
dann kann das quasi

01:36:58.027 --> 01:37:01.027
im Return-Register

01:37:01.027 --> 01:37:02.207
der CPU halt auch dann

01:37:02.207 --> 01:37:04.927
einfach weiterverwendet werden vom Aufrufer.

01:37:05.247 --> 01:37:07.087
So ein bisschen, wenn alles

01:37:07.087 --> 01:37:09.127
genau richtig ist, wenn alles genau richtig läuft.

01:37:09.787 --> 01:37:11.107
Und dann fällt halt einfach ganz,

01:37:11.188 --> 01:37:12.007
ganz, ganz viel Arbeit,

01:37:12.007 --> 01:37:14.387
die normale

01:37:14.387 --> 01:37:15.887
Python-Implementierung halt immer

01:37:15.887 --> 01:37:17.047
machen muss, fällt halt weg.

01:37:19.767 --> 01:37:20.247
Ja.

01:37:20.427 --> 01:37:21.987
Und ich meine, so ein bisschen die

01:37:21.987 --> 01:37:23.867
Einsicht, also warum man halt

01:37:23.867 --> 01:37:25.887
Python überhaupt optimieren kann,

01:37:25.887 --> 01:37:28.087
ist. Es ist theoretisch

01:37:28.087 --> 01:37:29.887
alles sehr dynamisch, aber

01:37:29.887 --> 01:37:30.527
in der Praxis nicht.

01:37:31.627 --> 01:37:33.747
Also die dynamischen Möglichkeiten,

01:37:33.867 --> 01:37:35.688
die werden halt... Sehr selten genutzt

01:37:35.688 --> 01:37:37.427
tatsächlich. Ja, jetzt nicht selten,

01:37:38.087 --> 01:37:39.507
aber halt nicht immer.

01:37:40.387 --> 01:37:41.767
Also ich glaube halt,

01:37:41.907 --> 01:37:43.887
jedes Programm ist schon an irgendeiner Stelle dynamisch,

01:37:43.947 --> 01:37:44.727
aber nicht die ganze Zeit.

01:37:47.067 --> 01:37:47.627
Es ist zum Beispiel

01:37:47.627 --> 01:37:49.707
relativ oft so, dass man beim Importen

01:37:49.707 --> 01:37:51.547
halt ganz viel Zeug macht, aber

01:37:51.547 --> 01:37:53.747
danach nicht mehr. Das ist so ein

01:37:53.747 --> 01:37:55.707
Muster an Dynamigkeit.

01:37:55.887 --> 01:38:10.567
Also du importierst halt eine Bibliothek, beim Importieren macht sie 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:10.567 --> 01:38:12.807
und danach ist alles quasi

01:38:12.807 --> 01:38:15.287
harmloser

01:38:15.287 --> 01:38:17.367
Python-Code, wo die Typen relativ fix sind.

01:38:18.148 --> 01:38:18.648
Also das ist so

01:38:18.648 --> 01:38:21.188
eine Sache, die wir immer wieder sehen.

01:38:21.247 --> 01:38:22.627
Da gibt es auch Aufsätze zu, die das studieren.

01:38:22.847 --> 01:38:25.327
Das findet

01:38:25.327 --> 01:38:27.007
sich halt recht häufig wieder, dass man komische,

01:38:27.148 --> 01:38:29.047
dynamische Sachen am Anfang

01:38:29.047 --> 01:38:30.567
des Programms macht, aber dann irgendwann nicht mehr.

01:38:32.047 --> 01:38:32.987
Also so ein

01:38:32.987 --> 01:38:34.247
ORM ist halt auch so ein Beispiel.

01:38:34.867 --> 01:38:36.767
Man generiert halt dann so ein bisschen Klassen,

01:38:37.228 --> 01:38:38.387
aber das macht man halt

01:38:38.387 --> 01:38:40.327
nicht die ganze Zeit, sondern halt

01:38:40.327 --> 01:38:45.807
oder halt so ein Debugger

01:38:45.807 --> 01:38:47.648
ist halt auch ein, also ein Debugger braucht

01:38:47.648 --> 01:38:49.047
quasi ganz, ganz viele dynamische Features,

01:38:49.787 --> 01:38:51.827
aber der ist halt meistens nicht an

01:38:51.827 --> 01:38:53.648
und du musst

01:38:53.648 --> 01:38:55.527
quasi die Möglichkeit haben, dass du den

01:38:55.527 --> 01:38:57.827
zu einem beliebigen Zeitpunkt anschalten

01:38:57.827 --> 01:38:59.387
kannst, aber

01:38:59.387 --> 01:39:01.787
du solltest nicht die ganze Zeit den Preis dafür bezahlen

01:39:01.787 --> 01:39:03.627
müssen, aber du willst dich halt

01:39:03.627 --> 01:39:05.067
auch nicht vorher entscheiden müssen.

01:39:06.467 --> 01:39:07.387
Ja, also du willst halt quasi

01:39:07.387 --> 01:39:09.627
trotzdem immer die Möglichkeit haben zu sagen, jetzt

01:39:09.627 --> 01:39:11.267
brauche ich denn aber? Debuggen, weil

01:39:11.267 --> 01:39:13.747
wenn es zu unterschiedlich ist, dann kann man

01:39:13.747 --> 01:39:14.287
nicht mehr debuggen.

01:39:15.827 --> 01:39:17.807
Man möchte es ja dann machen können,

01:39:17.907 --> 01:39:19.087
wenn es eigentlich normal läuft.

01:39:19.367 --> 01:39:21.487
Und selbst wenn es jetzt nicht um den Debugger geht, also selbst

01:39:21.487 --> 01:39:23.607
sowas wie schöne Tracebacks, die

01:39:23.607 --> 01:39:25.307
halt auch noch die Locals rausschreiben oder so.

01:39:26.067 --> 01:39:27.667
Wenn halt dein Web-Server

01:39:27.667 --> 01:39:29.407
dann wirklich crasht, dann willst du diese

01:39:29.407 --> 01:39:30.367
Informationen halt haben.

01:39:31.267 --> 01:39:33.427
Und dann zu sagen, ja, ups,

01:39:33.927 --> 01:39:35.547
jetzt haben wir das aber so doll optimiert,

01:39:35.667 --> 01:39:37.487
dass wir wissen halt gar nicht mehr, was die

01:39:37.487 --> 01:39:38.047
Locals sind.

01:39:38.047 --> 01:39:40.787
also das kann dir halt passieren in so einem Compiler

01:39:40.787 --> 01:39:43.427
also in T gibt es das ja immer mal

01:39:43.427 --> 01:39:45.027
da musst du ja wirklich sagen, will ich jetzt

01:39:45.027 --> 01:39:46.627
die VG-Informationen haben oder nicht

01:39:46.627 --> 01:39:48.287
und wenn du die nicht hast, dann kriegst du

01:39:48.287 --> 01:39:51.188
dann sagt dir halt keiner mehr, was jetzt gerade

01:39:51.188 --> 01:39:52.407
in deiner Variable drin steht

01:39:52.407 --> 01:39:53.667
und

01:39:53.667 --> 01:39:56.887
also

01:39:56.887 --> 01:39:59.487
meiner Ansicht nach gehört das halt zur Philosophie von Python

01:39:59.487 --> 01:40:01.148
auch dazu, dass man halt

01:40:01.148 --> 01:40:03.507
zu jedem Zeitpunkt das auch dann

01:40:03.507 --> 01:40:05.127
machen kann, wenn man halt

01:40:05.127 --> 01:40:06.867
in einer Situation landet, wo man

01:40:06.867 --> 01:40:08.947
die Information braucht.

01:40:12.167 --> 01:40:17.148
So, jetzt haben wir glaube ich so ein bisschen alle Ideen.

01:40:17.607 --> 01:40:19.307
Also historisch gesehen

01:40:19.307 --> 01:40:20.667
Python, Python, Python

01:40:20.667 --> 01:40:23.087
also historisch

01:40:23.087 --> 01:40:25.467
gab es diese Verständigkeitsidee, die verschwindet

01:40:25.467 --> 01:40:27.627
ein bisschen.

01:40:29.027 --> 01:40:30.887
Es gibt jetzt schon ganz viele Stellen, wo wir

01:40:30.887 --> 01:40:32.887
Sachen halt quasi komplizierter machen, um

01:40:32.887 --> 01:40:35.027
Performance zu kriegen. Also es ist jetzt

01:40:35.027 --> 01:40:36.307
nicht mehr nur so ein

01:40:36.307 --> 01:40:38.487
architektonisch reines Ding,

01:40:38.667 --> 01:40:40.447
womit man halt irgendwie die Sprache

01:40:40.447 --> 01:40:42.027
ganz toll verstehen kann, sondern halt

01:40:42.027 --> 01:40:43.987
wirklich viel pragmatischer und

01:40:43.987 --> 01:40:46.007
wir wollen halt auch wirklich schnell einen Code machen.

01:40:49.148 --> 01:40:50.427
Aber stattdessen kam

01:40:50.427 --> 01:40:52.467
diese andere Idee dazu, wir wollen einen

01:40:52.467 --> 01:40:54.067
Justin-Helm-Copiler für die Sprache haben

01:40:54.067 --> 01:40:56.188
und weil sich die Sprache eben

01:40:56.188 --> 01:40:58.047
einmal im Jahr ändert,

01:40:58.987 --> 01:41:00.387
können wir den nicht von Hand schreiben,

01:41:00.728 --> 01:41:02.467
weil wir halt nicht Google-Geld haben,

01:41:02.607 --> 01:41:04.087
sondern irgendwie ein Open-Source-Projekt sind

01:41:04.087 --> 01:41:07.927
und stattdessen wurde halt dann dieser Forschungsansatz gewählt, wir erzeugen den

01:41:07.927 --> 01:41:11.688
Justin-Tab-Compiler und das hat geklappt.

01:41:12.148 --> 01:41:16.027
Also das hätte auch schief gehen können, aber die Kernidee

01:41:16.027 --> 01:41:19.907
funktioniert ganz gut. Und jetzt sind wir quasi

01:41:19.907 --> 01:41:24.087
so ein bisschen auf dem Plateau der Produktivität, dass die ganze Kerntechnologie

01:41:24.087 --> 01:41:28.228
den JIT-Compiler zu erzeugen, die ist halt relativ stabil.

01:41:28.907 --> 01:41:31.707
Es gibt jetzt schon irgendwie da noch so ein paar Features, die wir gerne

01:41:31.707 --> 01:41:33.767
irgendwie mal machen würden, wenn wir mal

01:41:33.767 --> 01:41:35.947
ganz motiviert sind

01:41:35.947 --> 01:41:37.887
oder ganz viel Zeit haben, aber so die ganzen

01:41:37.887 --> 01:41:39.787
Kernideen sind halt einfach

01:41:39.787 --> 01:41:40.607
jetzt inzwischen auch

01:41:40.607 --> 01:41:43.807
drin und stabil und halt über viele

01:41:43.807 --> 01:41:45.047
Jahre halt auch wirklich

01:41:45.047 --> 01:41:47.747
so ganz

01:41:47.747 --> 01:41:50.327
gut stabilisiert.

01:41:50.867 --> 01:41:51.827
Und jetzt sind wir halt

01:41:51.827 --> 01:41:52.648
an dem Punkt, dass wir

01:41:52.648 --> 01:41:55.787
dass die Hauptarbeit,

01:41:55.887 --> 01:41:57.648
die wir wirklich machen, ist halt zu versuchen

01:41:57.648 --> 01:41:59.847
von C-Python nicht komplett abgehängt

01:41:59.847 --> 01:42:00.167
zu werden.

01:42:00.167 --> 01:42:02.567
Ist R-Python, hat das

01:42:02.567 --> 01:42:03.847
Type Annotations zum Beispiel auch?

01:42:04.047 --> 01:42:07.067
Ja, jetzt kommen wir zu

01:42:07.067 --> 01:42:08.347
ein paar der dunklen Geheimnisse

01:42:08.347 --> 01:42:10.907
Also

01:42:10.907 --> 01:42:13.127
PyPy ist so alt

01:42:13.127 --> 01:42:14.427
dass es gegründet wurde als

01:42:14.427 --> 01:42:17.188
Python 2.2 glaube ich gerade aktuell war

01:42:17.188 --> 01:42:17.827
oder 2.3

01:42:17.827 --> 01:42:19.707
Das heißt

01:42:19.707 --> 01:42:22.667
R-Python ist leider

01:42:22.667 --> 01:42:25.287
tatsächlich noch komplett Python 2 basiert

01:42:25.287 --> 01:42:27.267
Und

01:42:27.267 --> 01:42:29.087
wir haben halt sehr, leider

01:42:29.087 --> 01:42:30.347
auch sehr, sehr wenig

01:42:30.347 --> 01:42:32.887
Motivation, das zu ändern, weil

01:42:32.887 --> 01:42:35.127
wir haben halt leider sowas wie

01:42:35.127 --> 01:42:37.188
eine halbe Million Zeilen

01:42:37.188 --> 01:42:38.087
Code in diesem

01:42:38.087 --> 01:42:41.107
blöden Python 2 Dialekt

01:42:41.107 --> 01:42:43.047
und wir könnten uns jetzt

01:42:43.047 --> 01:42:43.907
hinsetzen und einfach

01:42:43.907 --> 01:42:46.127
eine Schätzung abzugeben,

01:42:47.047 --> 01:42:49.127
zwei Person Years reinstecken,

01:42:49.228 --> 01:42:50.487
das nach Python 3 zu portieren,

01:42:51.567 --> 01:42:52.767
aber das wäre halt wirklich,

01:42:52.967 --> 01:42:54.507
ich denke, wirklich zwei Jahre Arbeit

01:42:54.507 --> 01:42:57.007
und danach hätten wir einfach kein einziges

01:42:57.007 --> 01:42:57.527
neues Feature.

01:42:57.527 --> 01:43:01.387
Das heißt, da hat halt einfach niemand so wirklich Lust drauf

01:43:01.387 --> 01:43:03.648
Und das ist natürlich

01:43:03.648 --> 01:43:05.527
Wir sind da natürlich so ein bisschen in so einer

01:43:05.527 --> 01:43:07.427
Also Falle wäre jetzt viel gesagt, aber

01:43:07.427 --> 01:43:09.767
Ein bisschen in so einer

01:43:09.767 --> 01:43:11.427
Blöden Situation, weil

01:43:11.427 --> 01:43:12.767
Das ist halt nix

01:43:12.767 --> 01:43:15.527
Wofür momentan sind das halt wirklich

01:43:15.527 --> 01:43:16.627
Eher so Open Source

01:43:16.627 --> 01:43:18.747
Modell, da ist jetzt keiner

01:43:18.747 --> 01:43:21.807
Der dafür wirklich jetzt bezahlt wird

01:43:21.807 --> 01:43:22.447
Sag ich mal

01:43:22.447 --> 01:43:25.167
Und jetzt so eine Portierungs

01:43:25.167 --> 01:43:27.127
Aktion zu starten

01:43:27.127 --> 01:43:29.627
ist halt einfach nur so,

01:43:30.867 --> 01:43:31.807
also mir würde das halt

01:43:31.807 --> 01:43:32.527
nicht so viel Spaß machen.

01:43:34.067 --> 01:43:35.767
Aber das ist natürlich trotzdem in gewisser

01:43:35.767 --> 01:43:37.587
Weise auch kein Zustand, weil irgendwie

01:43:37.587 --> 01:43:39.847
also

01:43:39.847 --> 01:43:43.607
man will halt auch

01:43:43.607 --> 01:43:45.807
letztlich dann irgendwie auch nicht komplett abgehängt

01:43:45.807 --> 01:43:46.067
werden.

01:43:47.247 --> 01:43:49.747
Das wird dann wahrscheinlich irgendwann auch ein Problem,

01:43:50.467 --> 01:43:51.207
da neue Leute

01:43:51.207 --> 01:43:53.228
ranzuführen, weil man denen dann ja

01:43:53.228 --> 01:43:53.707
irgendwie...

01:43:53.707 --> 01:43:56.847
Das hast du jetzt schon vergessen.

01:43:56.847 --> 01:43:57.527
in das Github.

01:43:57.887 --> 01:43:59.907
Aber das Print hat keine Klammern.

01:44:00.167 --> 01:44:00.387
So genau.

01:44:02.167 --> 01:44:03.747
Das andere, so ein bisschen

01:44:03.747 --> 01:44:05.627
doofe Problem ist halt, dass

01:44:05.627 --> 01:44:07.887
so ein Interpreter,

01:44:08.007 --> 01:44:09.767
der benutzt halt an keiner Stelle Unicode.

01:44:11.007 --> 01:44:11.607
Das heißt so halt,

01:44:11.667 --> 01:44:13.907
eines der Hauptargumente, wo Python 3

01:44:13.907 --> 01:44:15.688
halt ein paar Sachen so richtig schön gemacht hat,

01:44:16.188 --> 01:44:17.847
die fallen weg, weil wir halt einfach immer nur

01:44:17.847 --> 01:44:18.947
Byte-Strings benutzen.

01:44:20.007 --> 01:44:20.267
Und

01:44:20.267 --> 01:44:23.167
deswegen, das wäre halt,

01:44:23.167 --> 01:44:24.847
das ist halt quasi auch nochmal so ein Grund,

01:44:25.027 --> 01:44:25.287
warum

01:44:25.287 --> 01:44:28.087
Python 3

01:44:28.087 --> 01:44:29.947
jetzt halt auch letztlich

01:44:29.947 --> 01:44:31.927
jetzt nicht so wirklich so eine Verbesserung ist,

01:44:32.047 --> 01:44:33.827
sondern halt, wir würden das wirklich

01:44:33.827 --> 01:44:36.007
machen, um halt nicht abgehängt zu werden, aber nicht,

01:44:36.127 --> 01:44:36.447
weil wir

01:44:36.447 --> 01:44:39.947
jetzt wirklich von den Python 3

01:44:39.947 --> 01:44:41.827
Features so mega motiviert wären.

01:44:42.007 --> 01:44:43.367
Und das ist halt so ein bisschen doof.

01:44:44.947 --> 01:44:45.967
Würde denn irgendwie

01:44:45.967 --> 01:44:48.067
diese, keine Ahnung, TypePins oder andere

01:44:48.067 --> 01:44:50.167
Features von Python 3

01:44:50.167 --> 01:44:51.407
jetzt für die

01:44:51.407 --> 01:44:53.927
Annotation von dem Compiler

01:44:53.927 --> 01:44:54.407
irgendwas bringen?

01:44:55.287 --> 01:44:56.887
nicht so richtig. Also man könnte

01:44:56.887 --> 01:44:58.587
sich, klar, man kann dann so ein paar der

01:44:58.587 --> 01:45:00.167
APIs vielleicht ein bisschen schöner machen,

01:45:00.648 --> 01:45:02.747
aber wir haben jetzt halt Dekoratoren und die sind jetzt auch nicht so

01:45:02.747 --> 01:45:03.667
schrecklich. Ich meine,

01:45:05.228 --> 01:45:06.728
ob du jetzt halt das dann

01:45:06.728 --> 01:45:08.707
mit Doppelpunkt direkt

01:45:08.707 --> 01:45:10.648
hinter die Argumente schreiben kannst oder in der Zeile

01:45:10.648 --> 01:45:12.648
drüber mit dem Dekorator, den wir uns selber

01:45:12.648 --> 01:45:13.228
ausgedacht haben.

01:45:14.767 --> 01:45:16.567
Ja, das wäre schon ein bisschen netter, aber

01:45:16.567 --> 01:45:17.367
das wäre jetzt nicht,

01:45:18.967 --> 01:45:20.667
also das wäre jetzt halt für mich nicht so

01:45:20.667 --> 01:45:22.447
eine ganz ausreichende Motivation, um halt

01:45:22.447 --> 01:45:24.667
so ein riesen Refactoring-Projekt

01:45:24.667 --> 01:45:33.987
zu starten. Also ich denke halt so ein, also das wird halt stattfinden, wenn wir irgendjemand

01:45:33.987 --> 01:45:38.847
finden, der da mega Bock drauf hat oder wenn wir halt Geld finden. Und ich glaube, wenn

01:45:38.847 --> 01:45:45.367
beides nicht stattfindet, dann vielleicht bin ich da zu pessimistisch, aber dann sehe

01:45:45.367 --> 01:45:52.447
ich das im Moment halt nicht. Also ja, also ich persönlich, ich kann nur über mich

01:45:52.447 --> 01:45:54.387
sprechen. Ich persönlich hätte da halt keinen

01:45:54.387 --> 01:45:54.728
Spaß dran.

01:45:56.427 --> 01:45:58.188
Ja, aber ich meine, ist es dann, wenn man

01:45:58.188 --> 01:46:00.267
tatsächlich keinen Unicode hat, sondern nur ByteStrings

01:46:00.267 --> 01:46:02.307
oder... Ich meine, es gibt ja da so

01:46:02.307 --> 01:46:04.387
automatische Geschichten. Könnte man das nicht

01:46:04.387 --> 01:46:06.627
eventuell auch automatisch irgendwie...

01:46:06.627 --> 01:46:08.547
Also, aber...

01:46:08.547 --> 01:46:10.087
Ob man da halt einfach einmal so

01:46:10.087 --> 01:46:12.887
zwei 2-to-3 draufschmeißt...

01:46:12.887 --> 01:46:15.007
Ja, wir müssen halt einfach...

01:46:15.007 --> 01:46:16.807
Irgendwann müssen wir das mal gucken und wir haben

01:46:16.807 --> 01:46:17.667
noch nicht so ganz...

01:46:17.667 --> 01:46:20.148
Wir haben noch nicht so ganz den pragmatischen

01:46:20.148 --> 01:46:22.507
Weg gefunden, den man halt gehen kann.

01:46:22.987 --> 01:46:24.327
Weil es ist halt auch so die Frage,

01:46:24.707 --> 01:46:25.987
macht man dann einmal einen Cut und sagt,

01:46:27.047 --> 01:46:27.747
Leute, halt,

01:46:28.547 --> 01:46:30.728
niemand macht mir neue Features für sechs Monate.

01:46:31.467 --> 01:46:32.567
Das ist halt auch doof.

01:46:32.567 --> 01:46:32.887
Also,

01:46:33.407 --> 01:46:36.547
ja, aber wir sind ja auch nicht

01:46:36.547 --> 01:46:38.547
die Einzigen. Es gibt ja auch wirklich

01:46:38.547 --> 01:46:40.567
leider noch ganz viele Firmen, die

01:46:41.367 --> 01:46:42.587
große Mengen

01:46:42.587 --> 01:46:43.487
an Python 2 gut haben.

01:46:45.047 --> 01:46:46.327
Aber ja, es ist halt,

01:46:46.787 --> 01:46:48.347
also man will das jetzt halt keine zehn Jahre

01:46:48.347 --> 01:46:48.907
so weitermachen.

01:46:50.148 --> 01:46:56.627
Aber so den idealen Weg, wie wir da jetzt wieder rauskommen aus der Geschichte, den wissen wir halt im Moment halt auch nicht.

01:46:56.707 --> 01:47:02.847
Außer wir finden jetzt jemanden, der sagt, hier habt ihr eine Million Dollar, macht doch bitte mal.

01:47:03.188 --> 01:47:04.867
Dann ist sowas halt auch wieder...

01:47:04.867 --> 01:47:05.987
Also ihr könnt hier schreien.

01:47:06.987 --> 01:47:07.387
Ja.

01:47:07.387 --> 01:47:09.767
Ja, ja.

01:47:11.087 --> 01:47:11.287
Also,

01:47:12.087 --> 01:47:12.688
das ist,

01:47:13.127 --> 01:47:15.188
bei Django-Projekten gibt es so etwas ähnliches mit dem

01:47:15.188 --> 01:47:15.627
Admin,

01:47:17.347 --> 01:47:19.327
mit dem

01:47:19.327 --> 01:47:21.307
Django-Admin, das ist halt auch so ein Ding,

01:47:21.427 --> 01:47:23.627
das ist, Django-Projekte sind ja auch alt, 15 Jahre

01:47:23.627 --> 01:47:25.188
oder so, das ist halt über die Zeit gewachsen.

01:47:25.747 --> 01:47:27.487
Teilweise ist da halt auch Geld reingesteckt worden,

01:47:27.487 --> 01:47:29.447
das zu entwickeln und inzwischen ist es halt auch so,

01:47:29.747 --> 01:47:31.167
die Schätzung ist ähnlich,

01:47:31.607 --> 01:47:33.167
etwa Leute, die sich damit auskennen, sagen halt so,

01:47:33.567 --> 01:47:35.447
ja, das jetzt mal so richtig neu zu schreiben und

01:47:35.447 --> 01:47:37.188
natürlich, wir wissen inzwischen, was wir alles gerne

01:47:37.188 --> 01:47:39.327
lieber machen würde. Würde wahrscheinlich so eine Million

01:47:39.327 --> 01:47:41.148
kosten und tja, die haben wir halt nicht.

01:47:41.688 --> 01:47:43.207
So ist es halt ein bisschen auch.

01:47:43.407 --> 01:47:45.027
Und ich meine, das sieht man ja auch wirklich

01:47:45.027 --> 01:47:47.467
ganz konkret bei C-Präsen. Also C-Präsen

01:47:47.467 --> 01:47:49.367
3.11 und 3.10 sind

01:47:49.367 --> 01:47:51.127
halt einfach auch

01:47:51.127 --> 01:47:52.447
wirklich viel schneller geworden.

01:47:52.987 --> 01:47:54.587
Und das ist halt einfach eine Geldfrage.

01:47:55.027 --> 01:47:57.087
Also wenn du halt plötzlich fünf Leute hast, die

01:47:57.087 --> 01:47:58.507
einfach fulltime

01:47:58.507 --> 01:48:01.188
bezahlt werden und das sind ja auch jetzt nicht

01:48:01.188 --> 01:48:03.267
irgendwelche Leute, sondern halt auch gute Leute,

01:48:03.767 --> 01:48:04.867
dann passiert halt auch was.

01:48:05.827 --> 01:48:06.167
Und

01:48:06.167 --> 01:48:10.228
wir können halt quasi so ein bisschen durch

01:48:10.228 --> 01:48:12.087
schlaue Architektur,

01:48:12.167 --> 01:48:13.707
die wir vor

01:48:13.707 --> 01:48:16.087
zehn Jahren halt quasi geschrieben

01:48:16.087 --> 01:48:18.087
haben, dadurch

01:48:18.087 --> 01:48:19.827
können wir halt irgendwie

01:48:19.827 --> 01:48:22.247
ziemlich gut mithalten,

01:48:22.447 --> 01:48:22.728
weil

01:48:22.728 --> 01:48:26.087
der DIT-Generator halt da ist und gut

01:48:26.087 --> 01:48:26.487
funktioniert.

01:48:29.047 --> 01:48:29.967
Aber halt

01:48:29.967 --> 01:48:31.027
alles, was jetzt mal so

01:48:31.027 --> 01:48:33.867
Bonus wäre,

01:48:33.987 --> 01:48:35.887
ist schon zu negativ, aber alles, was

01:48:35.887 --> 01:48:38.307
eine ganz tiefgreifende Veränderung

01:48:38.307 --> 01:48:40.507
bräuchte.

01:48:41.027 --> 01:48:42.127
Das kriegen wir halt

01:48:42.127 --> 01:48:44.007
mit dem jetzigen Fundingstand

01:48:44.007 --> 01:48:45.987
nicht hin.

01:48:46.747 --> 01:48:48.907
Weil das kriegst du halt nicht durch...

01:48:48.907 --> 01:48:50.307
Also wir haben halt auch schon so ein

01:48:50.307 --> 01:48:51.807
Open Collective-Dings und wir kriegen auch

01:48:51.807 --> 01:48:54.407
Donations und wir sind da auch

01:48:54.407 --> 01:48:56.467
super dankbar dafür. Da kommt auf jeden Fall auch

01:48:56.467 --> 01:48:57.627
irgendwie immer wieder

01:48:57.627 --> 01:48:59.787
gut was zusammen.

01:49:00.327 --> 01:49:02.728
Aber es ist halt was anderes, wenn du plötzlich fünf Leute anstellen kannst.

01:49:03.167 --> 01:49:04.087
Und da sind wir halt nicht.

01:49:05.887 --> 01:49:10.148
und da haben wir halt auch gerade nicht so richtig die Person, die da hinterher wäre,

01:49:10.767 --> 01:49:13.567
diese Gelder dann auch zu suchen.

01:49:15.167 --> 01:49:20.148
Also hatten wir ja vorhin schon kurz drüber geredet, wir hatten halt irgendwie zweimal so wirklich große

01:49:20.148 --> 01:49:23.787
Forschungsförderungsprojekte, also beides mal EU-finanziert.

01:49:24.487 --> 01:49:31.067
Das eine war von 2004 bis 2006, das andere von 2008 bis 2010 so ungefähr.

01:49:31.067 --> 01:49:33.707
und da hatten wir halt dann wirklich

01:49:33.707 --> 01:49:35.867
einige Vollzeitleute, die da einfach

01:49:35.867 --> 01:49:37.907
wirklich dann über diese Zeiträume halt auch wirklich immer

01:49:37.907 --> 01:49:39.967
nur an diesem ganzen Zeug gearbeitet haben

01:49:39.967 --> 01:49:42.107
und da kam halt dann auch

01:49:42.107 --> 01:49:43.587
wirklich was raus.

01:49:45.127 --> 01:49:45.807
Und dann

01:49:45.807 --> 01:49:47.947
danach hatten wir halt viel so

01:49:47.947 --> 01:49:49.987
immer wieder

01:49:49.987 --> 01:49:51.807
Funding auch von Firmen, die halt dann bestimmte

01:49:51.807 --> 01:49:52.847
Features gern haben wollten,

01:49:54.127 --> 01:49:54.287
aber

01:49:54.287 --> 01:49:57.247
seit

01:49:57.247 --> 01:50:00.007
einer Weile gibt es halt niemand,

01:50:00.007 --> 01:50:01.847
der jetzt Bock auf...

01:50:01.847 --> 01:50:03.587
Es ist halt nochmal so ein ganz eigener Task

01:50:03.587 --> 01:50:05.228
für Open Source Geld zu finden.

01:50:06.107 --> 01:50:08.107
Und man braucht halt da so ein bisschen

01:50:08.107 --> 01:50:08.927
ganz

01:50:08.927 --> 01:50:11.107
eigene Skills auch.

01:50:11.667 --> 01:50:13.967
Und so eine Person haben wir jetzt nicht mehr.

01:50:14.667 --> 01:50:16.167
Und das ist in gewisser

01:50:16.167 --> 01:50:17.607
Weise nicht so ein

01:50:17.607 --> 01:50:18.747
perfekter Zustand.

01:50:19.907 --> 01:50:21.327
Ich meine, selbst für

01:50:21.327 --> 01:50:24.027
Projekte, die halt sehr viel

01:50:24.027 --> 01:50:25.987
genutzt werden, also sowas wie Pandas, mich wundert das immer,

01:50:26.107 --> 01:50:27.767
es gibt ja ganz viele,

01:50:27.767 --> 01:50:29.648
wo die Basis für

01:50:29.648 --> 01:50:31.107
für viel Menge.

01:50:31.407 --> 01:50:31.787
Ja, ja, und NumPy.

01:50:33.167 --> 01:50:35.507
Genau, das ist die Basis für Milliarden

01:50:35.507 --> 01:50:37.327
Umsätze irgendwie in der Industrie, aber

01:50:37.327 --> 01:50:39.547
trotzdem gibt es

01:50:39.547 --> 01:50:41.587
da eigentlich für die Entwicklung nicht so richtig viel Geld.

01:50:42.587 --> 01:50:43.267
Also der andere

01:50:43.267 --> 01:50:45.827
momentan sehr aktive

01:50:45.827 --> 01:50:47.467
PyPy-Entwickler, der Matipikus,

01:50:48.107 --> 01:50:49.267
der ist tatsächlich bei

01:50:49.267 --> 01:50:51.627
einer Firma angestellt,

01:50:51.728 --> 01:50:53.228
die darauf spezialisiert ist, halt

01:50:53.228 --> 01:50:55.947
NumPy voranzubringen

01:50:55.947 --> 01:50:56.807
und halt dann da

01:50:56.807 --> 01:50:59.447
einer der Leute, die halt wirklich

01:50:59.447 --> 01:51:00.987
auch quasi finanziert

01:51:00.987 --> 01:51:03.507
NumPy Bugs Fix.

01:51:03.627 --> 01:51:05.648
Das ist auch Teil, heißt das auch Steering Council

01:51:05.648 --> 01:51:06.747
bei NumPy, weißt du das so richtig?

01:51:07.188 --> 01:51:09.167
Nee, keine Ahnung. Also das ist auch quasi Teil

01:51:09.167 --> 01:51:11.027
des Komitees, das halt NumPy

01:51:11.027 --> 01:51:13.547
verwaltet und ist da

01:51:13.547 --> 01:51:15.387
sehr aktiv. Deswegen geht NumPy auch

01:51:15.387 --> 01:51:17.447
gut auf PyPy, weil er sich halt da drauf kümmert.

01:51:17.847 --> 01:51:18.367
Achso, genau.

01:51:18.527 --> 01:51:21.987
Ja, also

01:51:21.987 --> 01:51:23.427
bei NumPy passiert

01:51:23.427 --> 01:51:25.347
es langsam eben schon. Also sowas wie Jupyter hat

01:51:25.347 --> 01:51:27.447
halt auch Funding und da gibt's

01:51:27.447 --> 01:51:28.688
halt inzwischen in den USA

01:51:28.688 --> 01:51:30.067
schon auch halt

01:51:30.067 --> 01:51:32.547
Firmen und Foundations,

01:51:32.947 --> 01:51:34.967
die halt erkannt haben, dass es einfach

01:51:34.967 --> 01:51:36.907
so ein wichtiges

01:51:36.907 --> 01:51:39.047
Stück Infrastruktur ist, dass es halt

01:51:39.047 --> 01:51:40.487
vielleicht doch auch eine gute Idee ist.

01:51:40.487 --> 01:51:42.427
Da würde das ganze Internet an so einem kleinen Faden aufhängen.

01:51:42.567 --> 01:51:44.947
Ja, also die Idee fand ich auch ganz charmant,

01:51:45.107 --> 01:51:46.867
dass man sagt, ja, also eigentlich

01:51:46.867 --> 01:51:48.907
müsste man das Firmen so verkaufen, dass es

01:51:48.907 --> 01:51:50.467
halt eine Versicherung ist.

01:51:51.327 --> 01:51:52.747
Wenn sie da nichts,

01:51:53.387 --> 01:51:54.688
also sie zahlen sozusagen eine Art

01:51:54.688 --> 01:51:56.967
Versicherungspolizei dafür, dass es das halt auch in Zukunft

01:51:56.967 --> 01:51:58.467
gibt, weil wenn es das nicht mehr geben sollte,

01:51:58.688 --> 01:51:59.587
Haben sie ein großes Problem.

01:52:00.207 --> 01:52:01.427
Ich weiß nicht, was da die Antwort ist.

01:52:02.347 --> 01:52:03.907
Ich finde halt auch letztlich,

01:52:04.487 --> 01:52:06.387
in gewisser Weise ist das wirklich auch was, was man

01:52:06.387 --> 01:52:07.827
über Steuern machen könnte.

01:52:08.407 --> 01:52:10.648
Und passiert ja ein Stück weit auch.

01:52:11.327 --> 01:52:12.188
Also halt sowas wie die,

01:52:12.507 --> 01:52:14.728
ich glaube es ist ja...

01:52:14.728 --> 01:52:15.707
Man muss halt Projektanträge schreiben.

01:52:16.327 --> 01:52:17.867
Müsste man halt Projektanträge schreiben, ja.

01:52:18.287 --> 01:52:19.827
Und da ist es halt dann so ein bisschen so,

01:52:20.087 --> 01:52:22.148
da ist halt PyPy dann letztlich

01:52:22.148 --> 01:52:23.547
auch vielleicht nicht wichtig genug.

01:52:24.267 --> 01:52:26.188
Also bei PyPy kann man halt nicht sagen,

01:52:26.188 --> 01:52:28.067
dass es jetzt eine absolut die

01:52:28.067 --> 01:52:30.728
grundlegende Technologie wie NumPy,

01:52:31.047 --> 01:52:31.307
weil

01:52:31.307 --> 01:52:34.688
so viele Leute benutzen es

01:52:34.688 --> 01:52:35.648
halt dann irgendwie doch nicht.

01:52:36.228 --> 01:52:38.527
Und klar, wir finden halt auch immer ganz

01:52:38.527 --> 01:52:40.467
tolle Bugs in C-Python und ich glaube schon,

01:52:40.567 --> 01:52:42.567
dass jetzt unser Wert halt jetzt

01:52:42.567 --> 01:52:43.867
auch, selbst wenn man das nicht

01:52:43.867 --> 01:52:46.267
einsetzt, es ist halt nicht null, da haben wir ja vorhin

01:52:46.267 --> 01:52:48.228
über ein paar Beispiele geredet, aber

01:52:48.228 --> 01:52:50.427
es ist halt auch nicht klar, ob wir jetzt

01:52:50.427 --> 01:52:51.207
das Projekt sind,

01:52:52.007 --> 01:52:54.327
für das irgendjemand ein paar

01:52:54.327 --> 01:52:55.887
Vollzeitentwickler dann bezahlen sollte.

01:52:56.167 --> 01:52:57.587
Also ich meine, klar, wir könnten die

01:52:57.587 --> 01:53:00.228
und wenn wir die hätten, dann könnten wir ganz tolle Sachen machen.

01:53:00.747 --> 01:53:02.607
Auf jeden Fall, ich habe eine ganz lange Liste.

01:53:03.887 --> 01:53:09.987
Also schickt das gerne zu mir, aber wenn man dann so einen Antrag schreibt,

01:53:10.067 --> 01:53:14.387
ist mir halt nicht so klar, ob man sagen kann, wir sind so wichtig wie OpenSSL.

01:53:14.507 --> 01:53:16.067
Sind wir halt nicht, offensichtlich nicht.

01:53:18.067 --> 01:53:21.507
Aber das viel grundlegende Problem ist halt, wir haben im Moment keinen, der da Lust drauf hat

01:53:21.507 --> 01:53:25.387
oder in dessen Expertise das halt liegt.

01:53:25.387 --> 01:53:27.867
und das ist nicht so gut.

01:53:28.228 --> 01:53:29.367
Und es kann schon sein, dass ich da auch

01:53:29.367 --> 01:53:31.847
vielleicht irgendwann dann auch nochmal drin besser werden muss.

01:53:32.307 --> 01:53:33.567
Wenn ihr Lust drauf habt,

01:53:33.728 --> 01:53:34.587
dann sagt Bescheid.

01:53:36.007 --> 01:53:37.587
Wir nehmen gerne

01:53:37.587 --> 01:53:38.387
Freiwillige an.

01:53:38.807 --> 01:53:41.767
Ich finde zum Beispiel Read the Logs auch ein sehr interessanter Fall,

01:53:42.267 --> 01:53:43.167
weil

01:53:43.167 --> 01:53:45.467
das ja auch letztlich

01:53:45.467 --> 01:53:46.047
halt

01:53:46.047 --> 01:53:49.527
einen sehr guten

01:53:49.527 --> 01:53:51.188
Weg gefunden hat für ein

01:53:51.188 --> 01:53:53.007
für die Community

01:53:53.007 --> 01:53:55.188
ultra wichtiges Problem, nämlich wo

01:53:55.188 --> 01:53:56.787
wird eigentlich die Dokumentation gehostet

01:53:56.787 --> 01:53:59.447
und wer bezahlt dafür, halt eine Lösung zu finden.

01:54:00.107 --> 01:54:01.007
Und die Lösung ist halt,

01:54:01.648 --> 01:54:03.188
wir finanzieren das einmal durch

01:54:03.188 --> 01:54:05.347
akzeptable Werbung und eben

01:54:05.347 --> 01:54:07.627
durch Firmen, die dann damit selber ihre Dokumentation

01:54:07.627 --> 01:54:09.287
hosten. Und da gibt es auch coole

01:54:09.287 --> 01:54:11.447
Podcasts, ich muss mal gucken, ob mir die

01:54:11.447 --> 01:54:13.067
Folge einfällt, wo der

01:54:13.067 --> 01:54:15.447
ReadTheDocs-Gründer halt auch so ein bisschen

01:54:15.447 --> 01:54:16.787
über seine Philosophie von

01:54:16.787 --> 01:54:17.907
Software-Funding redet.

01:54:18.967 --> 01:54:21.127
Und ja, ich finde das auch

01:54:21.127 --> 01:54:23.407
einen ganz coolen

01:54:23.407 --> 01:54:24.747
Weg eigentlich, also weil

01:54:24.747 --> 01:54:26.648
weil die haben ja wirklich jetzt auch

01:54:26.648 --> 01:54:28.688
einige Entwickler, die halt

01:54:28.688 --> 01:54:29.807
da an der Infrastruktur arbeiten,

01:54:30.447 --> 01:54:31.747
die Sphinx voranbringen,

01:54:32.047 --> 01:54:34.707
die Docutales-Patches schicken

01:54:34.707 --> 01:54:35.967
und

01:54:35.967 --> 01:54:37.567
da ist ja wirklich, also

01:54:37.567 --> 01:54:40.347
da ist die Python-Community ja auch wirklich

01:54:40.347 --> 01:54:41.167
ziemlich gut aufgestellt.

01:54:43.148 --> 01:54:44.267
Ich finde es auch sehr interessant,

01:54:44.387 --> 01:54:46.487
es gibt wirklich auch an einigen Stellen halt

01:54:46.487 --> 01:54:48.728
dann Projekte in ganz anderen Sprachen,

01:54:49.267 --> 01:54:50.207
die halt dann trotzdem

01:54:50.207 --> 01:54:52.767
Read the Docs nehmen, weil es halt einfach wirklich auch cool ist.

01:54:52.767 --> 01:54:53.287
Naja.

01:54:53.287 --> 01:55:09.287
und

01:55:09.287 --> 01:55:10.127
ein großartiges Beispiel.

01:55:12.688 --> 01:55:13.648
Ansonsten ist es halt so,

01:55:14.487 --> 01:55:15.188
ich habe jetzt halt,

01:55:15.587 --> 01:55:18.047
wir haben halt in gewisser Weise einen ganz guten Vorteil,

01:55:18.127 --> 01:55:19.847
weil ich kann das halt

01:55:19.847 --> 01:55:21.228
als Teil meiner Arbeit machen. Ich bin

01:55:21.228 --> 01:55:22.587
an der Uni angestellt,

01:55:22.807 --> 01:55:26.067
bin für die Lehre bezahlt, aber wenn die Lehre

01:55:26.067 --> 01:55:27.887
zu Ende ist, dann darf ich quasi

01:55:27.887 --> 01:55:28.767
forschen, was ich will.

01:55:30.347 --> 01:55:31.767
Ich bin in eine Forschungsgruppe

01:55:31.767 --> 01:55:33.567
eingebettet, die zumindest irgendwie

01:55:33.567 --> 01:55:36.107
was mit Compilern

01:55:36.107 --> 01:55:37.947
zu tun auch hat. Insofern bin ich da

01:55:37.947 --> 01:55:40.188
jetzt auch nicht. Ich bin da so ein bisschen der Einzige,

01:55:40.367 --> 01:55:41.847
der ganz konkret was mit

01:55:41.847 --> 01:55:43.107
JetComputer macht im Moment, aber

01:55:43.107 --> 01:55:45.787
ich bin da jetzt quasi thematisch auch nicht

01:55:45.787 --> 01:55:47.847
fehl am Platz und mein Chef freut sich da auch, wenn ich da

01:55:47.847 --> 01:55:49.867
dann was von mache. Insofern passieren

01:55:49.867 --> 01:55:51.627
halt durch das Level, was

01:55:51.627 --> 01:55:53.267
durch meine halbe Stelle,

01:55:53.587 --> 01:55:54.307
das sind jetzt nicht

01:55:54.307 --> 01:55:57.728
ultra viele Stunden, aber halt zumindest schon so

01:55:57.728 --> 01:55:59.927
ein paar Stunden, die sind halt da und

01:55:59.927 --> 01:56:01.307
die werden halt auch

01:56:01.307 --> 01:56:03.967
solange, aus meiner Ansicht nach,

01:56:04.087 --> 01:56:05.847
da halt es interessante Forschungsfragen gibt,

01:56:06.287 --> 01:56:07.767
werden die halt auch für das Projekt auch

01:56:07.767 --> 01:56:09.207
weiterverwendet werden.

01:56:10.247 --> 01:56:11.807
Und das ist halt so ein Basislevel.

01:56:13.627 --> 01:56:13.847
Naja,

01:56:13.927 --> 01:56:14.967
das muss man halt auch erstmal haben.

01:56:17.867 --> 01:56:18.307
Aber

01:56:18.307 --> 01:56:21.767
das reicht halt nicht, um jetzt

01:56:21.767 --> 01:56:23.867
das reicht

01:56:23.867 --> 01:56:25.967
jetzt nicht, um jetzt halt irgendwie so eine ganz krasse

01:56:25.967 --> 01:56:27.228
neue Idee für

01:56:27.228 --> 01:56:29.947
eine neue DIT-Optimierung

01:56:29.947 --> 01:56:31.267
sich auszudenken.

01:56:31.767 --> 01:56:33.467
Also manchmal

01:56:33.467 --> 01:56:35.487
läuft es dann über Abschlussarbeiten ganz gut.

01:56:35.487 --> 01:56:37.827
also ich hatte gerade eine unglaublich

01:56:37.827 --> 01:56:39.427
coole Wettarbeit betreut

01:56:39.427 --> 01:56:41.587
das ist jetzt noch nicht gemerged, aber der hat echt eine

01:56:41.587 --> 01:56:43.747
eine sehr interessante

01:56:43.747 --> 01:56:45.627
neue Optimierung für den DitCompiler auch geschrieben

01:56:45.627 --> 01:56:47.627
wie auch gerade bei Programmen

01:56:47.627 --> 01:56:49.127
die viel mit Integer machen, wirklich

01:56:49.127 --> 01:56:51.567
nochmal ganz anders Sachen optimieren kann

01:56:51.567 --> 01:56:53.947
also echt

01:56:53.947 --> 01:56:54.927
ein super Student

01:56:54.927 --> 01:56:57.688
Nico Rittinghaus

01:56:57.688 --> 01:56:58.367
heißt der, der hat

01:56:58.367 --> 01:57:01.427
der hat dann auch so die Originalliteratur aus den

01:57:01.427 --> 01:57:03.707
70ern gelesen und meinte so, hier in diesem Paper

01:57:03.707 --> 01:57:06.087
was mit Schreibmaschine geschrieben wurde

01:57:06.087 --> 01:57:07.707
steht das hier drin

01:57:07.707 --> 01:57:10.087
in eurem Code ist das doch ganz anders

01:57:10.087 --> 01:57:11.347
sag doch mal

01:57:11.347 --> 01:57:13.927
genau so

01:57:13.927 --> 01:57:17.707
und er hat dann

01:57:17.707 --> 01:57:19.547
auch immer recht

01:57:19.547 --> 01:57:22.487
das war sehr sehr cool

01:57:22.487 --> 01:57:24.307
mit dem, ich hoffe auch, dass er quasi weitermacht

01:57:24.307 --> 01:57:26.247
und vielleicht

01:57:26.247 --> 01:57:28.228
auch noch eine Masterarbeit schreibt

01:57:28.228 --> 01:57:30.087
aber manchmal passieren dann so Sachen

01:57:30.087 --> 01:57:30.427
aber

01:57:30.427 --> 01:57:33.307
bei so Abschlussarbeiten ist das halt

01:57:33.307 --> 01:57:35.427
schon so, dass die Leute dann tendenziell auch wieder weg sind.

01:57:35.747 --> 01:57:37.467
Ja, und dann muss man das maintaen, was sie gemacht haben.

01:57:37.467 --> 01:57:38.487
Ne, das ist eigentlich okay.

01:57:39.728 --> 01:57:40.087
Ja, stimmt.

01:57:40.987 --> 01:57:42.747
Die schreiben ja dann auch...

01:57:42.747 --> 01:57:45.247
Die schreiben halt Tests und ich bin halt dann schon...

01:57:45.247 --> 01:57:47.287
Ich gehe dann dann schon auf die Nerven, dass sie jetzt halt auch

01:57:47.287 --> 01:57:49.367
keinen Scheiß schreiben. Also so qualitätsmäßig.

01:57:51.987 --> 01:57:53.347
Ja, also wir stecken schon

01:57:53.347 --> 01:57:54.847
auch...

01:57:54.847 --> 01:57:55.728
Ich meine...

01:57:55.728 --> 01:57:56.947
Review und Kultur.

01:57:58.367 --> 01:57:59.667
Und wir wollen halt schon

01:57:59.667 --> 01:58:03.067
Wir sind halt jetzt nicht so ein normales Forschungsprojekt, was halt eigentlich

01:58:03.067 --> 01:58:06.607
Code zum Weg, also viele Forschungsprojekte sind halt so Code zum Wegschmeißen.

01:58:07.047 --> 01:58:08.867
Man schreibt Code, man schreibt ein Paper und dann ist man

01:58:08.867 --> 01:58:12.148
damit mit dem Thema durch. Sondern wir sind halt so ein bisschen

01:58:12.148 --> 01:58:15.027
in gewisser Weise so ein bisschen ein schlechtes Forschungsprojekt

01:58:15.027 --> 01:58:18.148
in dem Sinne, dass wir halt versuchen, auch Code zu schreiben,

01:58:18.148 --> 01:58:21.087
den Leute benutzen können. Und deswegen haben wir halt Aufwand,

01:58:21.188 --> 01:58:23.407
der sich aus Forschungssicht halt irgendwie auch nicht lohnt.

01:58:24.307 --> 01:58:26.567
Deswegen bin ich halt vielleicht auch kein Professor.

01:58:26.567 --> 01:58:29.127
sondern weil mein Forschungsoutput

01:58:29.127 --> 01:58:29.847
halt auch nicht

01:58:29.847 --> 01:58:32.807
also weil ich diesen Job auch gar nicht

01:58:32.807 --> 01:58:33.327
haben wollte

01:58:33.327 --> 01:58:36.807
aber weil halt so der Output

01:58:36.807 --> 01:58:38.667
an Aufsätzen bei mir vielleicht

01:58:38.667 --> 01:58:40.327
halt nicht so ganz stimmt

01:58:40.327 --> 01:58:42.747
also ich schreibe schon

01:58:42.747 --> 01:58:44.807
Aufsätze und die sind halt zum Teil dann auch ganz gut

01:58:44.807 --> 01:58:46.787
rezipiert und werden zitiert

01:58:46.787 --> 01:58:48.648
und so aber vielleicht jetzt nicht

01:58:48.648 --> 01:58:50.867
mit dem Nachdruck den man

01:58:50.867 --> 01:58:52.867
bräuchte wenn man jetzt halt so ein

01:58:52.867 --> 01:58:54.707
so ein reiner

01:58:54.707 --> 01:58:55.648
Akademiker sein wollte

01:58:55.648 --> 01:58:57.688
Naja

01:58:57.688 --> 01:59:00.648
das ist auch eine faszinierende Geschichte

01:59:00.648 --> 01:59:02.447
ich meine tatsächlich ist es ja dann doch oft so

01:59:02.447 --> 01:59:03.887
dass dann Sachen wiederverwendet werden

01:59:03.887 --> 01:59:05.728
also wenn man

01:59:05.728 --> 01:59:07.667
also in der Physik

01:59:07.667 --> 01:59:10.127
sieht man das dann häufig

01:59:10.127 --> 01:59:11.567
dass dann doch irgendwie so

01:59:11.567 --> 01:59:13.347
sich Sachen aufeinandertürmen

01:59:13.347 --> 01:59:15.247
die halt man vielleicht dann doch mal

01:59:15.247 --> 01:59:16.027
wenn man gewusst hätte

01:59:16.027 --> 01:59:17.767
wo man hinterher rauskommt

01:59:17.767 --> 01:59:21.707
hätte man das vielleicht anders bauen können

01:59:21.707 --> 01:59:22.467
aber

01:59:22.467 --> 01:59:24.507
meine absolute Lieblingsgeschichte

01:59:24.507 --> 01:59:25.507
die werde ich jetzt hier noch anbringen

01:59:25.507 --> 01:59:27.367
Oh ja, sehr gerne. Ich habe tatsächlich

01:59:27.367 --> 01:59:29.327
also ursprünglich habe ich mal

01:59:29.327 --> 01:59:31.547
Mathe und Physik studiert und dann habe ich das abgebrochen

01:59:31.547 --> 01:59:33.407
um bei einem

01:59:33.407 --> 01:59:35.267
der PyPy-Firmen, die halt

01:59:35.267 --> 01:59:36.467
von der EU Geld gekriegt haben

01:59:36.467 --> 01:59:38.627
mitzuarbeiten für eine Weile

01:59:38.627 --> 01:59:41.367
aber vorher habe ich quasi bei

01:59:41.367 --> 01:59:43.207
den Teilchenphysikern halt immer so

01:59:43.207 --> 01:59:45.387
Semesterferien, Hiwi

01:59:45.387 --> 01:59:46.287
Jobs gehabt

01:59:46.287 --> 01:59:49.167
und die Teilchenphysiker, die haben

01:59:49.167 --> 01:59:50.807
so CERN und so, die haben halt

01:59:50.807 --> 01:59:53.307
ein ganz interessantes Stück Technologie

01:59:53.307 --> 01:59:59.887
und Jochen unterhalten sich über die Programmiersprache Python

01:59:59.887 --> 02:00:00.747
Sprache lernen.

02:00:02.927 --> 02:00:05.047
Die Physiker, die müssen ja eh

02:00:05.047 --> 02:00:07.367
C++ lernen, um halt schnell einen Code zu schreiben,

02:00:07.447 --> 02:00:09.007
aber die wollen ja auch Scripting machen

02:00:09.007 --> 02:00:11.147
und wenn wir jetzt halt so einen C++

02:00:11.147 --> 02:00:13.447
Interpreter haben, dann können die ja

02:00:13.447 --> 02:00:15.307
mit der Sprache, die die eh schon können,

02:00:15.907 --> 02:00:16.987
halt auch ihre Skripte schreiben.

02:00:18.187 --> 02:00:19.467
Und das war

02:00:19.467 --> 02:00:21.587
halt so, 2003 rum

02:00:21.587 --> 02:00:22.967
war das halt echt noch

02:00:22.967 --> 02:00:25.347
irgendwie so ein Stück Technologie, was die halt einfach

02:00:25.347 --> 02:00:26.207
wirklich benutzt haben

02:00:26.207 --> 02:00:28.407
in der Teilchenphysik.

02:00:28.407 --> 02:00:30.347
und so nach und nach

02:00:30.347 --> 02:00:32.407
kam halt dann die Erkenntnis, dass das doch

02:00:32.407 --> 02:00:33.227
irgendwie vielleicht

02:00:33.227 --> 02:00:36.887
halt so ein bisschen so eine merkwürdige Idee ist

02:00:36.887 --> 02:00:38.607
und inzwischen

02:00:38.607 --> 02:00:40.567
nehmen die halt auch einfach Python für Skripting,

02:00:40.647 --> 02:00:42.247
ja, aber

02:00:42.247 --> 02:00:44.227
das ist halt für mich immer so ein Beispiel, wenn man

02:00:44.227 --> 02:00:45.647
also einer,

02:00:46.347 --> 02:00:48.387
so ein Lieblingsaufreger von mir ist,

02:00:48.507 --> 02:00:50.347
wenn Leute halt von interpretierten Sprachen reden.

02:00:50.747 --> 02:00:52.367
Man sagt halt gerne, Python ist eine interpretierte

02:00:52.367 --> 02:00:54.607
Sprache und das ist halt eigentlich eine Aussage,

02:00:54.707 --> 02:00:56.427
die meiner Ansicht nach semantisch keinen Sinn

02:00:56.427 --> 02:00:58.107
macht, also Sinn leer, weil

02:00:58.107 --> 02:01:02.507
es ist halt eine Eigenschaft einer Implementierung, ob sie interpretiert ist oder nicht.

02:01:03.287 --> 02:01:06.887
Also C-Python ist ein Interpreter, das stimmt, und PyPy ist halt ein

02:01:06.887 --> 02:01:10.827
JIT-Compiler, das stimmt. Aber man kann jetzt eben nicht sagen, dass

02:01:10.827 --> 02:01:14.827
C++ eine kompilierte Sprache ist, weil es gibt ja Cint und das ist halt

02:01:14.827 --> 02:01:18.267
eine Implementierung von C++, die das interpretiert.

02:01:19.207 --> 02:01:22.747
Und deswegen kann man halt nur sagen, na gut, wenn man halt GCC benutzt,

02:01:22.747 --> 02:01:25.507
dann hat man eine kompilierte Implementierung von C++.

02:01:25.507 --> 02:01:35.327
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.127 --> 02:01:38.927
Naja, also zum Glück ist das Ding inzwischen, glaube ich, tot.

02:01:38.927 --> 02:01:40.007
Also ich, ja.

02:01:43.447 --> 02:01:44.827
Naja, interessant.

02:01:44.827 --> 02:01:46.807
Ja

02:01:46.807 --> 02:01:49.087
Tja, ich weiß nicht

02:01:49.087 --> 02:01:50.687
spielt eigentlich diese

02:01:50.687 --> 02:01:53.127
da gab es ja auch so Geschichten mit

02:01:53.127 --> 02:01:55.747
Software Transactional Memory und so

02:01:55.747 --> 02:01:57.487
spielt das noch eine Rolle?

02:01:57.847 --> 02:01:59.827
Also da gab es halt ein relativ langjähriges

02:01:59.827 --> 02:02:01.807
Forschungsprojekt auch von dem Armin Rigo und einem

02:02:01.807 --> 02:02:03.347
Doktoranden, der

02:02:03.347 --> 02:02:05.767
in der ETH Zürich, glaube ich, promoviert hat

02:02:05.767 --> 02:02:07.867
und die hatten halt diese Idee, dass

02:02:07.867 --> 02:02:08.767
man halt irgendwie

02:02:08.767 --> 02:02:11.827
Software Transactional Memory benutzen

02:02:11.827 --> 02:02:13.287
können sollte, um

02:02:13.287 --> 02:02:16.167
den Overhead von

02:02:16.167 --> 02:02:18.187
einem Jill,

02:02:18.647 --> 02:02:20.047
also Global Interpreter Log Free

02:02:20.047 --> 02:02:22.227
Multithreading für Python

02:02:22.227 --> 02:02:23.227
sehr klein zu halten.

02:02:24.747 --> 02:02:26.027
Und dieses

02:02:26.027 --> 02:02:27.247
Forschungsprojekt hat halt,

02:02:28.407 --> 02:02:29.427
also die haben da auch wirklich

02:02:29.427 --> 02:02:32.007
viele Jahre dran geforscht

02:02:32.007 --> 02:02:34.267
und rein in Zeit investiert.

02:02:35.087 --> 02:02:35.947
Das hat halt am Schluss

02:02:35.947 --> 02:02:37.807
nicht so gut geklappt, wie sie sich erhofft hatten.

02:02:38.407 --> 02:02:39.127
Was ist das überhaupt?

02:02:39.327 --> 02:02:42.127
Also ich bin da sehr schnell

02:02:42.127 --> 02:02:42.487
raus.

02:02:43.287 --> 02:02:48.627
Ich habe das halt immer so

02:02:48.627 --> 02:02:50.907
interessiert verfolgt und die hatten halt dann so ein Branch

02:02:50.907 --> 02:02:52.607
und haben da auch jahrelang auch

02:02:52.607 --> 02:02:54.687
wirklich sehr viel Aufwand

02:02:54.687 --> 02:02:56.827
reingesteckt, aber am Schluss

02:02:56.827 --> 02:02:58.607
waren sie halt irgendwie mit den Ergebnissen

02:02:58.607 --> 02:03:00.967
nicht so zufrieden und halt auch

02:03:00.967 --> 02:03:04.627
also technische Details, wie gesagt,

02:03:04.747 --> 02:03:05.487
ist nicht so mein Ding

02:03:05.487 --> 02:03:08.727
Was soll das denn theoretisch sein? Also ich habe gar nicht

02:03:08.727 --> 02:03:10.447
verstanden, wo es da gehen soll

02:03:10.447 --> 02:03:12.787
Also die Idee von Soft Trace Action

02:03:12.787 --> 02:03:14.127
Memory ist, dass du quasi

02:03:14.127 --> 02:03:17.067
also

02:03:17.067 --> 02:03:19.047
du kannst halt dann mehrere Threads starten,

02:03:19.127 --> 02:03:20.447
die alle Python-Code ausführen

02:03:20.447 --> 02:03:22.887
und du machst so einen

02:03:22.887 --> 02:03:25.107
optimistischen Ansatz, so einen Datenbank-Ansatz.

02:03:25.887 --> 02:03:26.867
Jeder Thread hat

02:03:26.867 --> 02:03:28.027
eine eigene Transaktion

02:03:28.027 --> 02:03:30.707
und der Thread,

02:03:30.747 --> 02:03:32.927
der läuft so ein bisschen und dann versucht er zu committen.

02:03:33.447 --> 02:03:34.887
Committen heißt, dass

02:03:34.887 --> 02:03:36.947
seine Sicht der Welt, also seine

02:03:36.947 --> 02:03:38.607
Sicht des Zustands des Programms

02:03:38.607 --> 02:03:40.667
mit der Sicht

02:03:40.667 --> 02:03:43.847
der Welt der anderen Threads

02:03:43.847 --> 02:03:45.407
gemerged werden muss.

02:03:46.607 --> 02:03:47.707
Das ist die Transaction.

02:03:48.527 --> 02:03:49.707
Und das macht man aber nicht

02:03:49.707 --> 02:03:52.027
auf der Datenbank-Ebene, sondern wirklich auf der Sprachebene.

02:03:52.387 --> 02:03:53.667
Also das ist die Idee von Software

02:03:53.667 --> 02:03:54.667
Transaction Memory.

02:03:55.367 --> 02:03:57.687
Und da gibt es halt dann Techniken, um das

02:03:57.687 --> 02:04:00.147
effizient hinzukriegen.

02:04:01.027 --> 02:04:01.387
Und

02:04:01.387 --> 02:04:03.807
wenn das alles gut geht, also wenn die

02:04:03.807 --> 02:04:05.607
verschiedenen Threads sich nicht

02:04:05.607 --> 02:04:07.167
gegenseitig auf die Füße rumtrampeln,

02:04:07.967 --> 02:04:09.787
dann führt das halt dazu, dass du

02:04:09.787 --> 02:04:11.847
wirklich sehr gut skalierenden Python-Code

02:04:11.847 --> 02:04:13.347
schreiben kannst. Also skalierend heißt,

02:04:13.907 --> 02:04:15.807
wenn du 16 Cores hast, dann kannst

02:04:15.807 --> 02:04:17.607
du halt dann auch 16 Mal schneller

02:04:17.607 --> 02:04:19.787
einen Code schreiben. Das Problem ist

02:04:19.787 --> 02:04:21.727
jetzt, was machst du, wenn das

02:04:21.727 --> 02:04:23.627
nicht so gut klappt mit den Transaktionen und du hast halt

02:04:23.627 --> 02:04:25.067
einen Thread, der versucht, seine

02:04:25.067 --> 02:04:27.707
Transaktion zu committen und einen anderen Thread

02:04:27.707 --> 02:04:29.727
und da gibt es einen Konflikt. Dann bedeutet

02:04:29.727 --> 02:04:31.647
das immer, der eine Thread, der

02:04:31.647 --> 02:04:33.147
wirft die ganze Arbeit dir gemacht weg

02:04:33.147 --> 02:04:35.867
und fängt halt nochmal ein bisschen weiter hinten an.

02:04:36.307 --> 02:04:37.727
Wer ist denn der eine? Wer wirft den weg?

02:04:38.347 --> 02:04:39.407
Es gewinnt halt einer von denen.

02:04:39.407 --> 02:04:41.347
zufällig. Nee, nicht so richtig zufällig. Du musst

02:04:41.347 --> 02:04:43.427
natürlich schon dann nach außen hin

02:04:43.427 --> 02:04:45.187
die Python-Semantik dann

02:04:45.187 --> 02:04:46.847
bewahren. Das

02:04:46.847 --> 02:04:48.707
darf quasi nicht beobachtbar sein.

02:04:49.907 --> 02:04:51.467
Und da wird es halt dann auch technisch sehr kompliziert.

02:04:51.607 --> 02:04:52.467
Da weiß ich auch nichts zu.

02:04:54.147 --> 02:04:54.467
Aber

02:04:54.467 --> 02:04:56.507
von außen ist halt die Idee,

02:04:57.167 --> 02:04:58.627
es gewinnt einer

02:04:58.627 --> 02:05:01.027
und die Semantik ist erhalten.

02:05:02.467 --> 02:05:03.267
Das Problem ist jetzt

02:05:03.267 --> 02:05:05.187
nicht, dass sich das merkwürdig

02:05:05.187 --> 02:05:07.247
verhält. Das Problem ist halt, wenn du Pech

02:05:07.247 --> 02:05:08.507
hast, dann

02:05:08.507 --> 02:05:10.967
ist dein,

02:05:11.687 --> 02:05:13.167
dann sind alle deine 16 Cores

02:05:13.167 --> 02:05:15.167
irgendwie busy, aber dein

02:05:15.167 --> 02:05:16.407
Programm ist nur zweimal so schnell.

02:05:17.907 --> 02:05:19.107
Und das ist quasi so ein

02:05:19.107 --> 02:05:21.187
Performance-Bug und

02:05:21.187 --> 02:05:23.207
die haben halt einfach,

02:05:23.907 --> 02:05:25.287
ich glaube letztlich war das Problem, dass sie

02:05:25.287 --> 02:05:27.287
nicht so richtig die Werkzeuge gefunden

02:05:27.287 --> 02:05:29.307
haben, um an dieser

02:05:29.307 --> 02:05:31.087
Stelle dann weiterzukommen. Du hast halt

02:05:31.087 --> 02:05:32.347
diesen Performance-Bug, irgendwo

02:05:32.347 --> 02:05:35.127
gibt es einen Konflikt zwischen den Threads, aber

02:05:35.127 --> 02:05:36.327
was machst du jetzt als Programmierer?

02:05:36.327 --> 02:05:38.647
wenn du halt Performanceprobleme in Python

02:05:38.647 --> 02:05:40.467
hast, dann gibt es halt Tools, so Profiler und so

02:05:40.467 --> 02:05:42.867
und dann kannst du die benutzen, um rauszufinden

02:05:42.867 --> 02:05:44.127
wo du vielleicht was optimieren könntest

02:05:44.127 --> 02:05:45.227
aber für dieses

02:05:45.227 --> 02:05:48.747
wir haben jetzt zu viele Konflikte, Probleme, da gibt es halt

02:05:48.747 --> 02:05:49.387
keine Tools

02:05:49.387 --> 02:05:52.647
und da wussten sie halt zum Teil dann auch selber nicht

02:05:52.647 --> 02:05:54.267
wo jetzt die Zeit bleibt

02:05:54.267 --> 02:05:55.867
und die sind halt dann

02:05:55.867 --> 02:05:58.447
ich habe so ein bisschen das Gefühl

02:05:58.447 --> 02:05:59.947
irgendwann ist ihnen so dann

02:05:59.947 --> 02:06:02.267
die Prüste ausgegangen vielleicht

02:06:02.267 --> 02:06:04.647
also nach 6, 7 Jahren

02:06:04.647 --> 02:06:06.307
Ja

02:06:06.307 --> 02:06:11.387
Und es ist ja jetzt auch ganz interessant

02:06:11.387 --> 02:06:13.247
Ich finde es halt interessant, dass es jetzt

02:06:13.247 --> 02:06:13.947
diesen

02:06:13.947 --> 02:06:17.407
diesen Prototypen von Facebook

02:06:17.407 --> 02:06:19.467
gibt, wo halt in gewisser Weise

02:06:19.467 --> 02:06:20.827
so ein ganz klassischer Ansatz

02:06:20.827 --> 02:06:23.427
Also das ist halt immer

02:06:23.427 --> 02:06:25.447
Amins Idee. Amins Ansatz war ja

02:06:25.447 --> 02:06:26.587
mit dem Budgetgenerator auch schon so

02:06:26.587 --> 02:06:29.127
Der hat eine Vision, die ist technisch irgendwie

02:06:29.127 --> 02:06:30.907
elegant

02:06:30.907 --> 02:06:32.827
und dann versucht er das umzusetzen

02:06:32.827 --> 02:06:34.367
und bei Budgetgenerator hat es geklappt

02:06:34.367 --> 02:06:36.867
und bei Software Transactional Memory hat es halt leider nicht geklappt.

02:06:37.407 --> 02:06:38.947
Und vielleicht, wenn er noch ein paar Jahre weitergemacht hätte,

02:06:39.007 --> 02:06:39.967
hätte es auch irgendwann geklappt, aber

02:06:39.967 --> 02:06:42.967
momentan arbeitet er halt nicht mehr

02:06:42.967 --> 02:06:43.307
daran weiter.

02:06:45.007 --> 02:06:46.867
Aber jetzt, der Facebook-Code, der ist ja quasi

02:06:46.867 --> 02:06:48.427
in gewisser Weise ganz klassisches

02:06:48.427 --> 02:06:51.147
Engineering. Also die haben halt quasi

02:06:51.147 --> 02:06:53.067
wirklich

02:06:53.067 --> 02:06:54.747
ganz klassisch, so wie man halt

02:06:54.747 --> 02:06:56.867
irgendwie Shared Memory Multiprocessing

02:06:57.407 --> 02:06:58.807
macht, das

02:06:58.807 --> 02:07:00.387
implementiert mit einer

02:07:00.387 --> 02:07:02.567
sehr coolen neuen Einsicht.

02:07:02.567 --> 02:07:04.747
und da haben wir vorhin auch schon ganz kurz drüber gesprochen,

02:07:05.247 --> 02:07:07.127
nämlich, also wie gesagt,

02:07:07.307 --> 02:07:09.207
das ist überhaupt nicht mein Gebiet, ich kenne mich da nur

02:07:09.207 --> 02:07:11.087
sehr schlecht aus, aber die Idee ist glaube ich dieses

02:07:11.087 --> 02:07:11.907
Bias Locking, oder?

02:07:13.847 --> 02:07:15.327
Genau, Bias Reference

02:07:15.327 --> 02:07:17.247
Counting. Genau, also die Idee ist

02:07:17.247 --> 02:07:18.727
quasi, dass ein Objekt

02:07:18.727 --> 02:07:21.367
meistens in dem Thread benutzt

02:07:21.367 --> 02:07:23.147
wird, in dem es auch erzeugt wurde.

02:07:23.807 --> 02:07:25.247
Und es gibt halt dann

02:07:25.247 --> 02:07:27.307
so ein Fast Path, solange das Objekt

02:07:27.307 --> 02:07:28.767
nur in diesem Thread benutzt wird,

02:07:29.247 --> 02:07:31.207
sind die Zugriffe auf dieses Objekt

02:07:31.207 --> 02:07:33.807
sehr schnell. Also da ist die

02:07:33.807 --> 02:07:36.207
Synchronisierung zwischen den Threads

02:07:36.207 --> 02:07:37.207
quasi umsonst.

02:07:38.567 --> 02:07:39.887
Und erst wenn man das wirklich

02:07:39.887 --> 02:07:41.987
dann in einem anderen Thread auch benutzen

02:07:41.987 --> 02:07:43.987
will, wird es halt dann

02:07:43.987 --> 02:07:45.227
performance-mäßig teurer.

02:07:46.567 --> 02:07:46.587
Und

02:07:46.587 --> 02:07:49.747
das ist quasi eine neue Einsicht. Die kommt

02:07:49.747 --> 02:07:51.767
jetzt in diesen klassischen Ansatz

02:07:51.767 --> 02:07:54.027
Shared Memory Multiprocessing mit Logs und so zu machen,

02:07:54.187 --> 02:07:55.887
kommt das dazu. Und es hat sich

02:07:55.887 --> 02:07:57.647
herausgestellt, dass das quasi der richtige ist,

02:07:58.247 --> 02:07:59.487
um den Overhead für

02:07:59.487 --> 02:08:01.427
Single Threaded Code

02:08:01.427 --> 02:08:02.907
klein zu kriegen.

02:08:04.367 --> 02:08:16.479
Es gibt auch so ein paar Tricks also ein interessanter Trick ist weil es gibt dann ja deutlich viele Sachen die halt schon in allen Strats verwendet werden also alles was irgendwie globale Geschichten Imports und so Zeug Nun zum Beispiel Ja Nun

02:08:17.099 --> 02:08:20.539
True, False, sowas, genau. Und die erklärt man dann

02:08:20.539 --> 02:08:24.319
einfach zu unsterblichen Objekten, sozusagen macht kein

02:08:24.319 --> 02:08:28.459
Reference Counting, weil man sagt, das wird sowieso nie differenziert. Ja, aber was mir zum Beispiel noch nicht so ganz klar ist,

02:08:28.979 --> 02:08:31.979
man hat ja dann eigentlich oft auch

02:08:31.979 --> 02:08:33.819
an irgendeiner Stelle doch eine gesharete

02:08:33.819 --> 02:08:35.059
Datenstruktur. Also wenn du halt zum Beispiel

02:08:35.059 --> 02:08:37.359
so ein Workstealing implementieren willst

02:08:37.359 --> 02:08:38.979
und du nimmst halt einfach eine Liste,

02:08:40.640 --> 02:08:41.859
geht das dann noch?

02:08:42.059 --> 02:08:43.839
Oder ist dann zu viel Contention

02:08:43.839 --> 02:08:44.459
auf dieser Liste?

02:08:45.759 --> 02:08:46.999
Also diese Feinheiten,

02:08:47.479 --> 02:08:49.759
wie sich die Performance dann in der Praxis

02:08:49.759 --> 02:08:50.379
wirklich verhält.

02:08:50.539 --> 02:08:51.559
Was ist ein Workstealing?

02:08:51.799 --> 02:08:52.639
Ich glaube, das weiß halt keiner.

02:08:54.599 --> 02:08:55.959
Also bei Workstealing ist halt quasi,

02:08:56.279 --> 02:08:58.179
du hast verschiedene Arbeitspakete

02:08:58.179 --> 02:09:01.019
und verschiedene Threads, die die abarbeiten

02:09:01.019 --> 02:09:02.319
und

02:09:02.319 --> 02:09:05.139
du koordinierst

02:09:05.139 --> 02:09:07.339
diese Threads halt über irgendeine

02:09:07.339 --> 02:09:09.299
Queue. Und die Frage ist jetzt,

02:09:09.819 --> 02:09:11.099
welche Datenstruktur benutzt du, um diese

02:09:11.099 --> 02:09:13.179
Queue

02:09:14.379 --> 02:09:15.239
zu

02:09:15.239 --> 02:09:15.959
repräsentieren?

02:09:16.999 --> 02:09:18.919
Und Work-Sealing ist einer, da hat

02:09:18.919 --> 02:09:21.299
jeder Thread seinen eigenen Queue, glaube ich.

02:09:21.419 --> 02:09:23.279
Und wenn ein Thread nichts mehr

02:09:23.279 --> 02:09:25.319
in seiner eigenen Queue hat, dann klaut er was aus den Queues.

02:09:25.319 --> 02:09:26.859
Also ich stelle mir jetzt immer so ein bisschen vor, wie

02:09:26.859 --> 02:09:29.039
so eine Bank, wo irgendwelche Leute am Schalter stehen und warten,

02:09:29.159 --> 02:09:30.899
bis sie dran können. Und dann sind bestimmte Schalter

02:09:30.899 --> 02:09:32.959
halt auf, ein bestimmter Schalter halt nicht und da kann halt

02:09:32.959 --> 02:09:34.859
irgendwie sich Leute anstellen an verschiedenen

02:09:34.859 --> 02:09:35.879
Schaltern und wenn irgendwie

02:09:35.879 --> 02:09:38.779
gerade keine Kunden

02:09:38.779 --> 02:09:40.499
mehr sind, dann geht halt jemand drüber.

02:09:41.439 --> 02:09:42.819
Aber ich glaube, also wie da

02:09:42.819 --> 02:09:44.659
so, ich habe da kein gutes Metall, also

02:09:44.659 --> 02:09:46.759
ich bin wirklich ein sehr single

02:09:46.759 --> 02:09:48.879
threaded Mensch. Ich kann

02:09:48.879 --> 02:09:50.119
das auch nicht, aber

02:09:50.119 --> 02:09:52.439
ich habe mein metallisches Modell,

02:09:53.079 --> 02:09:54.899
das existiert einfach noch

02:09:54.899 --> 02:09:57.019
nicht. Ich weiß halt nicht, was passiert

02:09:57.019 --> 02:09:58.619
mit der Performance, wenn man halt

02:09:58.619 --> 02:10:00.879
17 Threads hat, die auf 17

02:10:00.879 --> 02:10:02.839
Kurs laufen und die wollen alle auf eine Liste

02:10:02.839 --> 02:10:04.659
zugreifen. Also das ist auch etwas, was irgendwie

02:10:04.659 --> 02:10:06.859
sehr schlecht, also immer wenn ich mit sowas

02:10:06.859 --> 02:10:09.119
zu tun hatte, musste ich feststellen,

02:10:09.199 --> 02:10:10.959
wenn ich vorher nicht schon auch das Gefühl hatte,

02:10:11.059 --> 02:10:12.699
ich kann das gar nicht, dass ich es dann

02:10:12.699 --> 02:10:14.799
dachte, ich kann es theoretisch

02:10:14.799 --> 02:10:16.859
und dann praktisch aber feststellen muss ich ganz nicht, weil es ist

02:10:16.859 --> 02:10:17.899
wirklich,

02:10:18.539 --> 02:10:20.879
es netzt halt nicht auf die Art, wie Menschen denken gut.

02:10:21.559 --> 02:10:22.879
Und es ist auch ganz interessant, also es

02:10:22.879 --> 02:10:24.939
gibt ja zwei, mindestens zwei

02:10:24.939 --> 02:10:26.759
Implementierungen von Python, die halt auch

02:10:26.759 --> 02:10:28.239
keinen Dill haben, nämlich Jython.

02:10:29.259 --> 02:10:30.759
Jython ist, soweit ich

02:10:30.759 --> 02:10:31.939
sehen kann, relativ tot, aber

02:10:31.939 --> 02:10:34.559
so in der 2.7 ist es ein sehr guter

02:10:34.559 --> 02:10:35.979
2.7 Interpreter der halt

02:10:35.979 --> 02:10:37.799
Implementierung, der halt

02:10:37.799 --> 02:10:40.599
keinen Jail hat, der halt wirklich Multithreading kann.

02:10:41.539 --> 02:10:42.539
Das ist auch eine ganz, ganz

02:10:42.539 --> 02:10:44.619
das war etwas, was ich jetzt bei dem

02:10:44.619 --> 02:10:46.739
Durchführen der Folgen, eine der Neuigkeiten

02:10:46.739 --> 02:10:48.659
die ich da mitgenommen habe, die ich vorher echt gar nicht

02:10:48.659 --> 02:10:50.679
wusste und mich fragen, wie mir das entgegen konnte, aber

02:10:50.679 --> 02:10:52.479
dass halt wohl, wenn man

02:10:52.479 --> 02:10:54.559
einen JIT-Compiler hat, das viel besser geht mit dem

02:10:54.559 --> 02:10:56.339
Fine-Grain-Blocking sozusagen,

02:10:56.659 --> 02:10:57.939
dass man gar nicht unbedingt einen Jail braucht,

02:10:58.539 --> 02:10:59.399
dass es halt mit einem

02:10:59.399 --> 02:11:02.819
Interpreter, der NC geschrieben ist und der statisch

02:11:02.819 --> 02:11:04.459
kompiliert ist, geht das gar nicht richtig.

02:11:04.899 --> 02:11:06.679
Aber Java, wenn er

02:11:06.679 --> 02:11:07.979
das von einem JIT

02:11:07.979 --> 02:11:11.059
Compiler verwandelt, ist das kein Problem

02:11:11.059 --> 02:11:12.799
sozusagen und da kann man das dann ohne

02:11:12.799 --> 02:11:14.839
JIL mit Filing, Rant, Locking machen und es wird halt nicht langsam

02:11:14.839 --> 02:11:15.199
dadurch.

02:11:16.599 --> 02:11:18.819
Das ist nicht so

02:11:18.819 --> 02:11:20.779
leicht, aber der JIT kann halt dann quasi

02:11:20.779 --> 02:11:22.799
der JIT macht dann

02:11:22.799 --> 02:11:24.599
so Reasoning über

02:11:24.599 --> 02:11:26.839
darüber, ob man gerade von einem

02:11:26.839 --> 02:11:28.379
Objekt den Lock schon hat und dann

02:11:28.379 --> 02:11:30.259
muss man halt nicht bei jeder Operation

02:11:30.259 --> 02:11:32.539
versuchen, sich das Log zu holen, sondern macht das

02:11:32.539 --> 02:11:34.679
nur einmal in der

02:11:34.679 --> 02:11:36.159
Funktion oder nur an bestimmten Punkten.

02:11:37.079 --> 02:11:38.479
Und man macht halt dann nicht

02:11:38.479 --> 02:11:40.639
bei jedem Fieldread muss man sich das Log

02:11:40.639 --> 02:11:42.599
holen, sondern kann sagen, wir lesen hier

02:11:42.599 --> 02:11:44.379
17 verschiedene Felder und wir holen uns das nur einmal.

02:11:45.299 --> 02:11:46.639
Und das kann der JIT halt machen, das kann

02:11:46.639 --> 02:11:47.399
der Interpreter nicht machen.

02:11:49.659 --> 02:11:50.659
Aber ja, also

02:11:50.659 --> 02:11:51.639
da sind wir noch nicht in Python.

02:11:52.439 --> 02:11:53.939
Aber Python konnte das halt.

02:11:54.239 --> 02:11:56.459
Und da hat sich aber interessanterweise halt dann rausgestellt,

02:11:56.459 --> 02:11:58.299
dass es halt

02:11:58.299 --> 02:12:00.579
unglaublich viele Bibliotheken gibt in Python

02:12:00.579 --> 02:12:02.399
die halt einfach natürlich

02:12:02.399 --> 02:12:03.539
überhaupt nicht thread-safe sind

02:12:03.539 --> 02:12:06.199
natürlich nicht, weil wie soll denn

02:12:06.199 --> 02:12:08.479
die Bugs gefunden werden, wenn halt

02:12:08.479 --> 02:12:09.499
die Standard-Invalidierung

02:12:09.499 --> 02:12:11.779
halt einfach immer Single-Threaded ist

02:12:11.779 --> 02:12:12.959
und

02:12:12.959 --> 02:12:16.779
selbst in der Standard-Bibliothek

02:12:16.779 --> 02:12:17.539
hat halt Jython

02:12:17.539 --> 02:12:20.439
damals quasi einiges an Bugs gefunden

02:12:20.439 --> 02:12:22.439
wo es halt Deadlocks

02:12:22.439 --> 02:12:23.359
und alles mögliche gab

02:12:23.359 --> 02:12:25.679
weil der Code in der

02:12:25.679 --> 02:12:27.579
Standardbibliothek von C. Weitem

02:12:27.579 --> 02:12:28.399
halt einfach

02:12:28.399 --> 02:12:31.359
den Gill präsent

02:12:31.359 --> 02:12:33.259
poniert und ich denke

02:12:33.259 --> 02:12:34.539
das wird halt schon dann auch nochmal

02:12:34.539 --> 02:12:36.699
für die Community auch ein ganz schön

02:12:36.699 --> 02:12:39.399
langwieriger Prozess, bis man halt

02:12:39.399 --> 02:12:41.259
wirklich an dem Punkt ist, dass alle Bibliotheken dann auch

02:12:41.259 --> 02:12:41.699
gehen

02:12:41.699 --> 02:12:47.019
Ich wollte übrigens noch

02:12:47.019 --> 02:12:49.219
eine Sache erwähnen, das kam noch gar nicht

02:12:49.219 --> 02:12:49.879
vor in unserer Geschichte

02:12:49.879 --> 02:12:53.099
Es gibt tatsächlich noch einen Bereich, wo

02:12:53.099 --> 02:12:55.379
sehr, sehr viel Aktivität gerade noch stattfindet

02:12:55.379 --> 02:12:57.499
im so weiteren PyPy-Umfeld.

02:12:58.359 --> 02:12:59.439
Und da bin ich

02:12:59.439 --> 02:13:01.359
auch nicht so ganz direkt beteiligt, aber der ist meiner Ansicht nach

02:13:01.359 --> 02:13:03.299
auch schon sehr interessant. Und das ist nämlich genau

02:13:03.299 --> 02:13:05.659
die Frage nach NC-geschriebenen

02:13:05.659 --> 02:13:06.579
Bibliotheken.

02:13:07.699 --> 02:13:08.819
Und das Projekt heißt

02:13:08.819 --> 02:13:11.099
H-Py und das ist

02:13:11.099 --> 02:13:13.059
ein relativ gut

02:13:13.059 --> 02:13:13.979
finanziertes

02:13:13.979 --> 02:13:17.159
eigenes Open-Source-Projekt, was quasi

02:13:17.159 --> 02:13:19.199
als Idee hat, dass sie

02:13:19.199 --> 02:13:20.639
eine Next-Generation

02:13:20.639 --> 02:13:22.879
C-API für Python

02:13:22.879 --> 02:13:24.479
entwickeln.

02:13:25.759 --> 02:13:27.099
Und die

02:13:27.099 --> 02:13:29.259
CLPI, die es eben jetzt bisher gibt,

02:13:29.979 --> 02:13:30.739
die ist halt

02:13:30.739 --> 02:13:33.239
in gewisser Weise so organisch

02:13:33.239 --> 02:13:35.199
gewachsen aus C-Python

02:13:35.199 --> 02:13:37.019
heraus. Weil das ist ja einfach,

02:13:37.999 --> 02:13:38.839
wenn man die

02:13:38.839 --> 02:13:40.679
CLPI benutzt, dann

02:13:40.679 --> 02:13:43.119
greift man einfach direkt auf

02:13:43.119 --> 02:13:45.039
die Datenstrukturen zu, die C-Python

02:13:45.039 --> 02:13:47.159
halt einfach zufällig hat. Und wenn man eine andere

02:13:47.159 --> 02:13:48.979
Implementierung schreiben will und die ist anders,

02:13:49.619 --> 02:13:51.079
dann hat man ein Problem, weil dann passt

02:13:51.079 --> 02:13:57.259
halt nicht zusammen. Und HPA ist halt die Idee, wir fangen einfach so nicht ganz auf dem Reißfaden, aber wir

02:13:57.259 --> 02:14:01.159
machen einfach nochmal drei Schritte zurück und wir überlegen uns, wie würde denn eine

02:14:01.159 --> 02:14:07.479
API in C aussehen, wenn man sie jetzt nochmal neu machen würde. Und da gibt es schon auch

02:14:07.479 --> 02:14:15.419
dann, also das ist jetzt quasi noch in der Mache, es ist irgendwie Version 0,04 raus

02:14:15.419 --> 02:14:20.259
oder so, die wollen jetzt irgendwann bald mal zu einem 1.0 kommen, aber da ist halt wirklich

02:14:20.259 --> 02:14:22.499
die Idee, wie würde man eine API designen,

02:14:22.559 --> 02:14:24.319
die für alle Implementierungen für

02:14:24.319 --> 02:14:26.179
Python gleichermaßen funktioniert.

02:14:27.079 --> 02:14:28.439
Und die hat ein paar sehr interessante

02:14:28.439 --> 02:14:29.379
Eigenschaften. Zum Beispiel,

02:14:30.119 --> 02:14:32.239
die ist halt absolut

02:14:32.239 --> 02:14:33.359
AVI-kompatibel.

02:14:33.919 --> 02:14:35.559
Du musst, vorwärtskompatibel,

02:14:35.979 --> 02:14:37.799
du musst niemals neue

02:14:37.799 --> 02:14:39.839
Shared Libraries kompilieren.

02:14:40.739 --> 02:14:42.299
Du kannst die, die Idee ist, dass man

02:14:42.299 --> 02:14:44.699
quasi so ein bisschen Windows-mäßig

02:14:44.699 --> 02:14:46.539
unendlich lange in die Zukunft

02:14:46.539 --> 02:14:48.439
alle alten

02:14:48.439 --> 02:14:49.599
Shared Libraries weiter benutzen kann.

02:14:49.599 --> 02:14:51.839
Das ist eines der Designziele

02:14:51.839 --> 02:14:53.879
Ein anderes Designziel ist, dass man

02:14:53.879 --> 02:14:56.359
den Debugging-Mode

02:14:56.359 --> 02:14:57.199
anschalten kann

02:14:57.199 --> 02:14:58.739
für den C-Code

02:14:58.739 --> 02:15:01.399
ohne, dass man neu kompilieren muss

02:15:01.399 --> 02:15:04.039
Sondern quasi zur Importzeit

02:15:04.039 --> 02:15:05.959
kannst du sagen, hier ist irgendein komischer

02:15:05.959 --> 02:15:07.819
Crash, mach mal bitte den

02:15:07.819 --> 02:15:08.719
Debugging-Mode an

02:15:08.719 --> 02:15:12.119
und dann findet er zum Beispiel Reference-Counting-Probleme

02:15:12.119 --> 02:15:14.039
in der

02:15:14.039 --> 02:15:15.579
C-Bibliothek, ohne dass man die neu

02:15:15.579 --> 02:15:17.519
kompilieren muss. Das ist ein anderes, finde ich

02:15:17.519 --> 02:15:18.559
sehr interessante Eigenschaft

02:15:18.559 --> 02:15:21.179
und das Coole ist, dass

02:15:21.179 --> 02:15:24.119
Oracle hat auch eine Python-Implementierung,

02:15:24.219 --> 02:15:25.279
die heißt GraalPy

02:15:25.279 --> 02:15:28.079
und die haben jetzt quasi zwei ihrer Entwickler

02:15:28.079 --> 02:15:29.659
oder zweieinhalb ihrer Entwickler

02:15:29.659 --> 02:15:31.639
dafür angestellt, sich eben

02:15:31.639 --> 02:15:34.039
zu überlegen, wie man dieses HPy-Ding designt

02:15:34.039 --> 02:15:36.199
und da passiert also quasi so richtig was

02:15:36.199 --> 02:15:37.879
und ich habe halt die Hoffnung,

02:15:38.079 --> 02:15:39.919
dass jetzt irgendwann in diesem 2023

02:15:39.919 --> 02:15:42.119
es da die ersten Releases gibt

02:15:42.119 --> 02:15:43.919
und das ist schon

02:15:43.919 --> 02:15:46.039
auch so, dass es quasi jetzt

02:15:46.039 --> 02:15:48.079
das Portieren von der existierenden

02:15:48.079 --> 02:15:49.679
API auf Hby

02:15:49.679 --> 02:15:52.339
nicht ganz

02:15:52.339 --> 02:15:54.279
automatisiert werden kann, aber vielleicht so ein bisschen.

02:15:54.579 --> 02:15:56.139
Also das ist jetzt auch an allen

02:15:56.139 --> 02:15:58.079
Stellen, wo man quasi an der alten API

02:15:58.079 --> 02:16:00.139
dranbleiben kann, haben sie

02:16:00.139 --> 02:16:02.399
versucht, sich an der existierenden API zu orientieren,

02:16:02.979 --> 02:16:04.079
um das Portieren eben möglich

02:16:04.079 --> 02:16:06.159
zu machen. Und nur an den Stellen, wo

02:16:06.159 --> 02:16:07.199
das eben nicht ging,

02:16:08.279 --> 02:16:10.259
ohne

02:16:10.259 --> 02:16:11.579
die Ziele zu gefährden,

02:16:12.079 --> 02:16:14.199
haben sie dann eben sich entschieden, davon abzuweichen.

02:16:15.299 --> 02:16:34.632
Naja also auf jeden Fall wie gesagt ich bin da nicht mit involviert ich rede manchmal mit denen das ist einer der GraalPy der GraalPy ist ein guter Freund von mir wir telefonieren dann ab und zu aber ich bin halt sehr hoffnungsvoll dass das bald mal ein Release gibt und vielleicht auch vielleicht in Python Support reingebaut wird das w sehr cool

02:16:34.632 --> 02:16:36.652
und das würde eben dazu führen, dass

02:16:36.652 --> 02:16:39.032
in Zukunft Extensions,

02:16:39.312 --> 02:16:40.172
die H-Py benutzen,

02:16:41.092 --> 02:16:42.692
halt auch wirklich schnell auf PyPy sind.

02:16:43.592 --> 02:16:44.452
Und dann hätten wir unser,

02:16:45.232 --> 02:16:45.532
also da,

02:16:46.012 --> 02:16:48.952
es gibt dann ganz, ganz viele Fliegen, die mit einer

02:16:48.952 --> 02:16:50.212
Klappe geschlagen würden,

02:16:50.852 --> 02:16:52.452
unter anderem eben möglicherweise,

02:16:53.052 --> 02:16:54.572
dass es effizient in PyPy ist,

02:16:54.672 --> 02:16:55.952
dass es effizient in GraalPy ist,

02:16:56.432 --> 02:16:58.432
trotzdem nicht langsamer ist auf C-Python

02:16:58.432 --> 02:16:59.432
und

02:16:59.432 --> 02:17:02.712
der Übergang zum vorigen

02:17:02.712 --> 02:17:03.792
Thema ist jetzt, dass

02:17:03.792 --> 02:17:06.712
dass sie gerade auch, soweit ich das verstehen kann,

02:17:07.172 --> 02:17:08.712
so ein bisschen anfangen darüber nachzudenken,

02:17:09.232 --> 02:17:14.052
ob man denn da auch die Jail-Änderungen, die nötig würden für die C-Extension,

02:17:14.692 --> 02:17:16.292
auch noch mit unterbringen könnte.

02:17:17.452 --> 02:17:18.892
Und das wäre halt sehr, sehr cool.

02:17:19.552 --> 02:17:22.472
Weil das würde dann direkt funktionieren, ohne dass man da nochmal was ändern müsste.

02:17:23.032 --> 02:17:26.592
Und wenn dann eine Extension quasi in der Situation kommt,

02:17:26.652 --> 02:17:30.372
dass sie jetzt ganz viel anpassen müsste, um mit dem Jail zu funktionieren,

02:17:30.372 --> 02:17:32.592
dann könnte die halt sagen, na gut

02:17:32.592 --> 02:17:34.472
dann gehen wir halt vielleicht gleich zu dieser neuen API

02:17:34.472 --> 02:17:36.612
nehmen noch einen ganzen Haufen andere

02:17:36.612 --> 02:17:38.772
Benefits mit und sind aber trotzdem

02:17:38.772 --> 02:17:40.132
auch kompatibel zu den neuen

02:17:40.132 --> 02:17:42.492
Jail Features. Also das

02:17:42.492 --> 02:17:44.652
ich bin mir nicht sicher, ob die das schaffen und

02:17:44.652 --> 02:17:45.312
ich weiß auch nicht

02:17:45.312 --> 02:17:47.512
also bei so Firmen

02:17:47.512 --> 02:17:50.212
Funding durch Firmen, da kann halt auch mal

02:17:50.212 --> 02:17:51.932
passieren, dass ein Manager sagt, so

02:17:51.932 --> 02:17:53.752
brauchen wir nicht mehr, so genau

02:17:53.752 --> 02:17:56.272
aber das wäre halt cool

02:17:56.272 --> 02:17:58.452
also das ist ein Projekt, was ich sehr

02:17:58.452 --> 02:17:59.912
exciting finde und wo ich hoffe, dass

02:17:59.912 --> 02:18:03.532
dass da in diesem Jahr halt noch viel passieren wird.

02:18:03.692 --> 02:18:04.172
Wir haben leider

02:18:04.172 --> 02:18:06.072
kein

02:18:06.072 --> 02:18:09.172
offizielles Buy-in von

02:18:09.172 --> 02:18:11.232
C-Python. Also es gibt einige

02:18:11.232 --> 02:18:12.492
C-Python-Entwickler, die quasi

02:18:12.492 --> 02:18:14.952
sehr wohlwollend sind,

02:18:15.472 --> 02:18:17.352
aber wir haben quasi

02:18:17.352 --> 02:18:19.192
kein offizielles Endorsement.

02:18:21.372 --> 02:18:23.132
Wir sind immer mal ein bisschen am überlegen,

02:18:23.772 --> 02:18:25.132
ob es ein sinnvolles PEP

02:18:25.132 --> 02:18:26.852
also ich habe jetzt viel gesagt, ich bin

02:18:26.852 --> 02:18:29.552
ich als interessierter Beobachter

02:18:29.552 --> 02:18:31.432
bin nicht wirklich, also ich schreibe keinen Code dafür,

02:18:31.752 --> 02:18:33.432
aber ja, also die HHP-Leute denken

02:18:33.432 --> 02:18:35.792
auch immer mal darüber nach, was man für ein

02:18:35.792 --> 02:18:37.352
Pep schreiben könnte und was da

02:18:37.352 --> 02:18:39.332
ist halt gar nicht so ganz klar, was man

02:18:39.332 --> 02:18:40.692
von T-Python wollen würde.

02:18:41.672 --> 02:18:43.412
Weil es ist jetzt,

02:18:43.492 --> 02:18:45.492
die wollen halt nicht sagen, die wollen

02:18:45.492 --> 02:18:47.272
nicht die Designverantwortung wieder an T-Python

02:18:47.272 --> 02:18:49.172
zurückgeben. Also eines der

02:18:49.172 --> 02:18:51.372
Vorteile ist eben

02:18:51.372 --> 02:18:53.292
gerade, dass es ein externes Team ist, was

02:18:53.292 --> 02:18:55.072
das komplett unabhängig von T-Python macht.

02:18:56.072 --> 02:18:57.252
Und deswegen, das soll

02:18:57.252 --> 02:18:58.032
jetzt nicht irgendwie

02:18:58.032 --> 02:19:01.572
wieder C-Python untergeordnet werden

02:19:01.572 --> 02:19:03.092
so als Projekt. Aber

02:19:03.092 --> 02:19:04.792
deswegen ist halt auch gar nicht so klar, was

02:19:04.792 --> 02:19:06.772
ist das Ergebnis dieses Peps?

02:19:06.972 --> 02:19:09.132
Ist das irgendwie ein reines, also

02:19:09.132 --> 02:19:11.192
dieses hypothetische noch nicht geschriebenes Peps, ist das ein

02:19:11.192 --> 02:19:13.472
reines Informationspapier? Wir arbeiten daran.

02:19:14.092 --> 02:19:14.952
Nehmt uns wahr.

02:19:16.172 --> 02:19:16.792
Also ja,

02:19:16.792 --> 02:19:18.352
da denken wir halt

02:19:18.352 --> 02:19:19.952
ein bisschen drüber nach. Also es gibt den

02:19:19.952 --> 02:19:22.652
Lukas Langer, der auch

02:19:22.652 --> 02:19:23.452
von

02:19:23.452 --> 02:19:26.452
Vollzeit an über die PSF

02:19:26.452 --> 02:19:28.012
an, teilweise arbeitet.

02:19:28.952 --> 02:19:29.972
Der war auch bei dem

02:19:29.972 --> 02:19:31.432
8-Pile-Sprint im

02:19:31.432 --> 02:19:33.392
September hier in Düsseldorf.

02:19:34.172 --> 02:19:35.612
Also der ist auch ein Core-Dev, der

02:19:35.612 --> 02:19:38.492
informiert

02:19:38.492 --> 02:19:40.352
und involviert und wohlwollend

02:19:40.352 --> 02:19:40.592
ist.

02:19:42.552 --> 02:19:43.832
Aber so von den

02:19:43.832 --> 02:19:47.032
Hardcore-Performance-Leuten

02:19:47.032 --> 02:19:50.092
gibt es jetzt quasi keine

02:19:50.092 --> 02:19:51.932
offizielle Aussage, dass sie das irgendwie toll finden.

02:19:51.932 --> 02:19:52.592
Aber ja.

02:19:53.672 --> 02:19:55.992
Aber ich hoffe halt, dass da jetzt in diesem Jahr

02:19:55.992 --> 02:19:57.512
halt noch ein paar interessante Sachen passieren.

02:19:59.192 --> 02:19:59.432
Naja,

02:19:59.812 --> 02:20:00.832
interessant, ja.

02:20:02.072 --> 02:20:02.452
Ja, ich meine,

02:20:02.952 --> 02:20:05.452
mir sagt das gar nicht so viel, ich weiß nicht,

02:20:05.452 --> 02:20:07.372
ich glaube, ich habe es nicht mal gehört,

02:20:07.492 --> 02:20:08.592
dass es da noch einen Interpreter

02:20:08.592 --> 02:20:10.192
für Python gibt.

02:20:11.012 --> 02:20:12.532
So viele sind ja auch nicht mehr übrig, ne?

02:20:12.552 --> 02:20:14.112
Jyton, Iron Python,

02:20:14.772 --> 02:20:17.392
sind nicht mehr so richtig da.

02:20:17.812 --> 02:20:19.412
Unladen Swallow gab es auch.

02:20:19.792 --> 02:20:20.712
Ja, das ist lange tot.

02:20:22.172 --> 02:20:23.052
Ja, PyPhy

02:20:23.052 --> 02:20:24.872
ist so eine der ganz

02:20:24.872 --> 02:20:27.092
wenigen überleben.

02:20:27.832 --> 02:20:29.132
Also GraalPy halt auch.

02:20:29.452 --> 02:20:31.472
GraalPy hat halt wirklich ein Team, die sind auch bezahlt

02:20:31.472 --> 02:20:33.512
und von der Funding-Situation

02:20:33.512 --> 02:20:34.452
sind die ziemlich gut.

02:20:35.452 --> 02:20:37.292
Die haben so ein paar, deren JIT ist auch

02:20:37.292 --> 02:20:39.552
ziemlich gut, die können wirklich schnell

02:20:39.552 --> 02:20:40.552
einen Python-Code ausführen.

02:20:41.352 --> 02:20:43.352
Die haben so ein bisschen das Problem, dass das nur

02:20:43.352 --> 02:20:45.132
also dass

02:20:45.132 --> 02:20:47.472
ihre Warm-Up-Zeit sehr lange

02:20:47.472 --> 02:20:49.352
dauert. Also der Code wird halt erst

02:20:49.352 --> 02:20:50.612
nach vielen Minuten schnell.

02:20:51.392 --> 02:20:52.452
Und das heißt, du brauchst halt

02:20:52.452 --> 02:20:54.892
die richtige Art von Anwendung.

02:20:55.012 --> 02:20:56.612
Also so Long-Running-Server-Processes

02:20:56.612 --> 02:20:58.512
funktionieren super, aber wenn du alle

02:20:58.512 --> 02:21:00.772
fünf Minuten deployst, dann

02:21:00.772 --> 02:21:01.632
halt nicht mehr.

02:21:03.532 --> 02:21:04.712
Aber da kommen die auch noch hin.

02:21:04.832 --> 02:21:06.252
Die haben halt Geld, im Moment.

02:21:06.612 --> 02:21:08.852
Das ist halt für eine Implementierung

02:21:08.852 --> 02:21:10.692
eine sehr angenehme Situation und der Tim weiß auch,

02:21:10.792 --> 02:21:11.092
was er tut.

02:21:12.672 --> 02:21:13.832
Ist sehr, sehr gut.

02:21:15.372 --> 02:21:16.932
Tim Felgengriff heißt der

02:21:16.932 --> 02:21:18.392
Taglet und

02:21:18.392 --> 02:21:20.592
die sind, glaube ich, auch

02:21:20.592 --> 02:21:22.252
3.10 kompatibel

02:21:22.252 --> 02:21:22.692
und

02:21:22.692 --> 02:21:26.212
supporten C-Extensions und

02:21:26.212 --> 02:21:27.892
also das ist schon eine sehr ernstzunehmende

02:21:27.892 --> 02:21:28.332
Empfehlung.

02:21:30.032 --> 02:21:30.532
Ja, cool.

02:21:32.312 --> 02:21:34.172
Warum schreibt man sich sowas dann direkt in Rust,

02:21:34.252 --> 02:21:35.672
wenn man das eh statt in C neu zu schreiben?

02:21:36.092 --> 02:21:37.152
Die schreiben das in Java neu.

02:21:37.912 --> 02:21:40.172
Also gerade, wir wollen da,

02:21:40.232 --> 02:21:42.132
ich glaube, da steigen wir jetzt nicht ein, aber gerade

02:21:42.132 --> 02:21:43.972
ist so ein bisschen die Piper-Idee

02:21:43.972 --> 02:21:46.312
nochmal in

02:21:46.312 --> 02:21:47.272
mit Geld.

02:21:47.992 --> 02:21:49.552
Also halt von Oracle,

02:21:49.552 --> 02:21:51.612
deswegen haben die, die haben einen R-Java,

02:21:51.612 --> 02:21:53.632
also sie können quasi ihren Java-Code nach C

02:21:53.632 --> 02:21:55.352
übersetzen und

02:21:55.352 --> 02:21:57.412
haben den JIT-Compiler in C geschrieben und die haben auch

02:21:57.412 --> 02:21:59.732
diesen selben, technisch funktioniert

02:21:59.732 --> 02:22:01.752
das ein bisschen anders, aber die haben auch so eine ähnliche Motivation

02:22:01.752 --> 02:22:03.172
die haben so einen Meta-JIT-Ansatz

02:22:03.172 --> 02:22:05.512
dass sie quasi keinen JIT schreiben, sondern

02:22:05.512 --> 02:22:07.352
den JIT auch generieren

02:22:07.352 --> 02:22:08.872
aus einem Interpreter

02:22:08.872 --> 02:22:11.032
mit einer anderen Technik, aber

02:22:11.032 --> 02:22:13.532
von der Motivation her ist das recht ähnlich

02:22:13.532 --> 02:22:14.772
und

02:22:14.772 --> 02:22:17.232
die benutzen das, also die haben irgendwie einen schnellen

02:22:17.232 --> 02:22:19.072
JavaScript-Implementierung und

02:22:19.072 --> 02:22:20.292
ein schnelles Python und

02:22:20.292 --> 02:22:22.792
natürlich irgendwie auch ein schnelles Java

02:22:22.792 --> 02:22:23.712
und

02:22:23.712 --> 02:22:26.412
ja, und das ist

02:22:26.412 --> 02:22:28.612
ein riesen Team, das muss man halt auch, also die haben halt

02:22:28.612 --> 02:22:31.032
eine

02:22:31.032 --> 02:22:32.632
zweistellige Anzahl an Leuten, die halt

02:22:32.632 --> 02:22:34.192
an diesem Zeug arbeiten und

02:22:34.192 --> 02:22:36.692
ist in gewisser Weise auch

02:22:36.692 --> 02:22:37.172
irgendwie

02:22:37.172 --> 02:22:40.452
sehr erforschungslastig das Projekt, es ist auch eine

02:22:40.452 --> 02:22:42.432
große, also ich würde sagen, es ist von Oracle eine große

02:22:42.432 --> 02:22:44.472
Wette, also mir ist

02:22:44.472 --> 02:22:46.452
nicht so, also ich glaube im Moment

02:22:46.452 --> 02:22:48.592
verdient das Team halt kein Geld

02:22:48.592 --> 02:22:50.232
ja, also das ist halt die Hoffnung, dass

02:22:50.232 --> 02:22:51.012
das irgendwann mal

02:22:51.012 --> 02:22:54.132
dann vielleicht doch Geld verdient, aber ich glaube

02:22:54.132 --> 02:22:56.372
im Moment ist das halt wirklich eine Wette

02:22:56.372 --> 02:22:58.252
und die läuft auch schon lang, also

02:22:58.252 --> 02:22:59.612
das Projekt ist irgendwie 10 Jahre alt oder so

02:22:59.612 --> 02:23:02.252
so irgendwie 30 Leute

02:23:02.252 --> 02:23:03.852
über 10 Jahre anzustellen, das ist halt

02:23:03.852 --> 02:23:05.392
das ist halt richtig teuer

02:23:05.392 --> 02:23:09.332
naja, aber also da

02:23:09.332 --> 02:23:12.292
weiß ich, also

02:23:12.292 --> 02:23:14.192
was da die

02:23:14.192 --> 02:23:16.332
Motivationen von so einer Firma sind, das weiß man

02:23:16.332 --> 02:23:16.852
halt immer nicht

02:23:16.852 --> 02:23:18.832
kann man halt dann

02:23:18.832 --> 02:23:21.212
munter spekulieren, das mache ich natürlich auch immer gern

02:23:21.212 --> 02:23:21.692
aber ja

02:23:21.692 --> 02:23:21.992
also

02:23:21.992 --> 02:23:25.772
das ist quasi so ein bisschen

02:23:25.772 --> 02:23:26.832
Friendly Competition, aber

02:23:26.832 --> 02:23:28.712
mit Betonung auf Friendly

02:23:28.712 --> 02:23:31.572
aber nochmal die Frage

02:23:31.572 --> 02:23:33.332
warum sowas nicht in Rust geschrieben wird

02:23:33.332 --> 02:23:34.012
so ein neuer Link?

02:23:34.792 --> 02:23:36.592
Mir ist noch nicht so ganz klar

02:23:36.592 --> 02:23:39.632
also es ist so ein bisschen so eine grundsätzliche

02:23:39.632 --> 02:23:41.632
Frage, in welcher Sprache

02:23:41.632 --> 02:23:42.572
implementiert man

02:23:42.572 --> 02:23:44.732
sein JIT

02:23:44.732 --> 02:23:48.632
und die klassische Antwort ist halt C oder C++.

02:23:50.212 --> 02:23:53.032
Und es gibt jetzt verschiedene

02:23:53.032 --> 02:23:56.032
so forschungsaffine Projekte wie

02:23:56.032 --> 02:23:59.872
Squeak ganz klassischerweise oder eben PyPy

02:23:59.872 --> 02:24:04.112
oder GraalPy, die halt sagen, es ist doch eigentlich viel cooler,

02:24:04.592 --> 02:24:06.972
wenn man eine Implementierungssprache nimmt, die halt irgendwie

02:24:06.972 --> 02:24:11.852
ein höheres Abstraktionslevel hat als C, weil C ist halt doof und nicht memory safe

02:24:11.852 --> 02:24:13.852
und stürzt die ganze Zeit ab und man kann

02:24:13.852 --> 02:24:15.772
auch nicht schön abstrahieren und deswegen ist C

02:24:15.772 --> 02:24:16.872
halt keine schöne Sprache.

02:24:18.172 --> 02:24:20.032
Und genau,

02:24:20.152 --> 02:24:21.772
das sind dann die genannten Projekte. Und jetzt ist so ein bisschen

02:24:21.772 --> 02:24:23.312
die Frage, ob Rust

02:24:23.312 --> 02:24:35.865
eine gut geeignete Sprache ist um den Compiler zu schreiben Und ich glaube das wei einfach noch keiner Also es gibt genau ein gro JIT

02:24:36.025 --> 02:24:36.745
was Rust benutzt.

02:24:36.745 --> 02:24:38.785
Das habt ihr auch, glaube ich, in einer Folge

02:24:38.785 --> 02:24:40.665
darüber geredet. Das ist der neue

02:24:40.665 --> 02:24:42.385
JIT für Ruby, der von Shopify

02:24:42.385 --> 02:24:43.165
finanziert ist.

02:24:44.485 --> 02:24:46.325
Es gibt übrigens auch ein großes

02:24:46.325 --> 02:24:47.585
Graal

02:24:47.585 --> 02:24:50.625
Ruby-Projekt, also das heißt

02:24:50.625 --> 02:24:52.645
TruffleRuby, das auch von

02:24:52.645 --> 02:24:54.085
Shopify zum Teil finanziert wird.

02:24:54.085 --> 02:24:56.045
also die leisten sich mehrere

02:24:56.045 --> 02:24:58.185
eigene Roof-Inflationen

02:24:58.185 --> 02:25:02.305
und

02:25:02.305 --> 02:25:04.405
das eben, heißt das

02:25:04.405 --> 02:25:05.925
YGIT? YGIT heißt es, ne?

02:25:06.105 --> 02:25:08.385
Ja, genau. Und der ist eben

02:25:08.385 --> 02:25:10.025
in Rust geschrieben und ich glaube

02:25:10.025 --> 02:25:12.125
die Jury ist halt noch so ein bisschen

02:25:12.125 --> 02:25:13.525
out, ob das

02:25:13.525 --> 02:25:16.365
ob das wirklich die richtige Sprache

02:25:16.365 --> 02:25:18.045
für ein JIT ist und mit der

02:25:18.045 --> 02:25:19.805
also die Maxime Chevalier

02:25:19.805 --> 02:25:22.645
die das gestartet hat

02:25:22.645 --> 02:25:23.425
YGIT bei Shopify

02:25:23.425 --> 02:25:25.685
mit der zoome ich auch auf und zu.

02:25:26.305 --> 02:25:27.825
Die ist auch extrem gut

02:25:27.825 --> 02:25:28.925
und

02:25:28.925 --> 02:25:31.705
aber was da

02:25:31.705 --> 02:25:33.745
also was da ihre Conclusion wäre,

02:25:33.945 --> 02:25:35.725
ist Rust die richtige Sprache, um so einen

02:25:35.725 --> 02:25:36.465
JIT-Compiler zu schreiben?

02:25:37.825 --> 02:25:39.725
Das weiß ich jetzt. Also das

02:25:39.725 --> 02:25:41.845
weiß ich noch nicht. Ich glaube, das weiß man

02:25:41.845 --> 02:25:43.485
dann, das kann man erst so ein bisschen

02:25:43.485 --> 02:25:45.525
abschließen, beurteilen nach dem dritten JIT

02:25:45.525 --> 02:25:45.885
vielleicht.

02:25:49.265 --> 02:25:51.445
Also wenn man halt dann Rust nimmt, dann muss man

02:25:51.445 --> 02:25:52.445
sich halt klar machen, dass man

02:25:52.445 --> 02:25:55.145
dass man sich da

02:25:55.145 --> 02:25:57.485
auf noch nicht ganz verstandenes

02:25:57.485 --> 02:25:59.325
Terrain bewegt

02:25:59.325 --> 02:26:00.645
ich meine

02:26:00.645 --> 02:26:03.305
C++ ist halt

02:26:03.305 --> 02:26:04.845
so die akzeptierteste Sprache um

02:26:04.845 --> 02:26:06.725
virtuelle Maschinen zu schreiben

02:26:06.725 --> 02:26:08.765
und das muss man jetzt nicht gut finden

02:26:08.765 --> 02:26:10.865
also ich persönlich finde es halt vielleicht nicht so gut

02:26:10.865 --> 02:26:12.725
aber das ist halt die Sprache

02:26:12.725 --> 02:26:14.805
ich meine das ist auch die Sprache in der man halt in der Regel

02:26:14.805 --> 02:26:16.185
einen Compiler schreibt

02:26:16.185 --> 02:26:19.185
und

02:26:19.185 --> 02:26:19.465
und

02:26:19.465 --> 02:26:23.085
wenn man irgendwas anderes nimmt, dann muss man sich halt

02:26:23.085 --> 02:26:23.625
klar machen, dass

02:26:23.625 --> 02:26:27.105
dann ist man plötzlich für sich selbst

02:26:27.105 --> 02:26:27.645
verantwortlich.

02:26:28.785 --> 02:26:31.205
Da muss man mit seinen eigenen Konsequenzen leben.

02:26:34.625 --> 02:26:35.185
Also ja,

02:26:35.285 --> 02:26:35.705
ich weiß es nicht.

02:26:37.465 --> 02:26:38.825
Es ist halt so ein bisschen die Frage,

02:26:39.465 --> 02:26:40.405
an welcher Stelle

02:26:40.405 --> 02:26:44.845
würde die Extra Safety

02:26:44.845 --> 02:26:45.685
von Rust

02:26:45.685 --> 02:26:49.165
wäre die Gewinnbringend,

02:26:49.185 --> 02:26:49.785
im Compiler.

02:26:50.945 --> 02:26:53.225
Weil das, was halt an so einem

02:26:53.225 --> 02:26:53.845
JIT-Compiler

02:26:53.845 --> 02:26:57.265
dangerous und scary

02:26:57.265 --> 02:26:59.025
ist, ist halt nicht,

02:26:59.605 --> 02:27:01.145
dass der selber in der Unsafe-Sprache

02:27:01.145 --> 02:27:03.145
geschrieben ist. Das ist natürlich auch ein Problem.

02:27:03.505 --> 02:27:04.785
Und das ist nicht das primäre Problem.

02:27:05.105 --> 02:27:07.065
Das primäre Problem ist, dass man selber Maschinencode

02:27:07.065 --> 02:27:08.585
erzeugt. Und der darf halt nicht falsch sein.

02:27:08.605 --> 02:27:10.665
Der darf halt nicht falsch sein. Aber bei diesem Problem

02:27:10.665 --> 02:27:12.245
bringt einmal Rust auch nichts.

02:27:12.245 --> 02:27:14.165
Ja, weil Rust, dann ist der

02:27:14.165 --> 02:27:15.425
Compiler, dann ist der

02:27:15.425 --> 02:27:18.365
das Ding,

02:27:18.365 --> 02:27:19.885
indem man den JIT-Compiler schreibt, ist dann halt,

02:27:20.065 --> 02:27:22.445
das geht halt nicht kaputt. Genau. Beim Interpretieren

02:27:22.445 --> 02:27:24.025
deines Interpreters, wenn etwas anderes geschrieben ist,

02:27:24.365 --> 02:27:26.345
aber wenn der falschen Code erzeugt, dann ist

02:27:26.345 --> 02:27:27.285
er immer noch schlecht. Genau.

02:27:28.145 --> 02:27:30.065
Das ist halt gewisserweise ein Logik-Bug

02:27:30.065 --> 02:27:31.085
und kein

02:27:31.085 --> 02:27:34.145
Memory-Safety-Bug. Ja. Testen.

02:27:35.105 --> 02:27:36.005
Genau. Es gibt also,

02:27:37.245 --> 02:27:38.345
irgendwann werde ich den Teil

02:27:38.345 --> 02:27:40.125
2-Blogpost zu How is Python Fyte-Tested

02:27:40.125 --> 02:27:41.945
schreiben. Der ist auch deutlich länger.

02:27:42.525 --> 02:27:43.525
How is Blitztestet?

02:27:44.005 --> 02:27:45.705
Das ist nämlich wirklich auch nochmal

02:27:45.705 --> 02:27:48.065
so ein bisschen so ein, das ist ein richtig

02:27:48.065 --> 02:28:18.045
und Jochen unterhalten sich über die Programmiersprache Python

02:28:18.065 --> 02:28:48.045
und

02:28:48.065 --> 02:29:18.045
und Jochen unterhalten sich über die Programmiersprache Python

02:29:18.065 --> 02:29:20.085
dass das da ganz viel

02:29:20.085 --> 02:29:22.365
Also falls ihr mitmachen wollt, wie gesagt.

02:29:22.705 --> 02:29:23.385
Ja, also

02:29:23.385 --> 02:29:26.105
ich mache jetzt hier mal so einen allgemeinen

02:29:26.105 --> 02:29:27.225
Aufruf. Es ist

02:29:27.225 --> 02:29:30.405
also es gibt natürlich schon so ein paar

02:29:30.405 --> 02:29:32.045
ich will es jetzt nicht zu schlecht reden,

02:29:32.105 --> 02:29:33.585
es gibt so ein paar Hürden. Wir haben Python 2,

02:29:33.925 --> 02:29:35.385
wir sind in Mercurial, wir sind nicht auf GitHub,

02:29:35.605 --> 02:29:37.785
wir sind am Fork von GitLab,

02:29:37.885 --> 02:29:39.125
der auch mit Mercurial geht.

02:29:39.765 --> 02:29:41.865
Also es gibt so ein paar Nervigkeiten beim

02:29:41.865 --> 02:29:42.765
Einstieg, aber

02:29:42.765 --> 02:29:45.905
es ist in gewisser Weise

02:29:45.905 --> 02:29:47.005
halt so ein bisschen auch

02:29:47.005 --> 02:29:51.545
die netteste Python-Implementierung, bei der man einsteigen kann, weil man halt Python schreibt.

02:29:52.165 --> 02:29:55.765
Und man nimmt halt PyTest und man schreibt PyTest und man kann halt

02:29:55.765 --> 02:29:59.325
irgendwie seinen Debugger nehmen und man kann halt die ganzen Tools, die man

02:29:59.325 --> 02:30:03.385
kennt, Python 2 ist da so ein bisschen doof, aber also die ganze

02:30:03.385 --> 02:30:07.825
Arbeitsweise, die man halt kennt, wenn man sowieso schon Python kann, die kann man benutzen, um

02:30:07.825 --> 02:30:11.605
da drin rumzuhacken. Und das macht halt auch ein Stück weit

02:30:11.605 --> 02:30:15.285
einfach Spaß. Also man ist halt nicht in GDB

02:30:15.285 --> 02:30:17.525
und man hat halt keinen Stack-Fault, sondern man kriegt

02:30:17.525 --> 02:30:19.605
halt erstmal einfach einen ganz normalen Python

02:30:19.605 --> 02:30:21.645
Stacktrace, der einem sagt, in deinem

02:30:21.645 --> 02:30:23.185
Interpreter hast du jetzt hier einen Fehler gemacht.

02:30:23.665 --> 02:30:25.785
Und man schreibt halt einen Unit-Test einfach in Python,

02:30:26.005 --> 02:30:27.605
der die Datenstruktur des Interpreters halt auch

02:30:27.605 --> 02:30:29.765
einfach testen kann. Und das ist halt

02:30:29.765 --> 02:30:31.665
auch, also ich finde das

02:30:31.665 --> 02:30:33.625
immer noch auch sehr, sehr

02:30:33.625 --> 02:30:35.625
cool. Und deswegen, ich glaube so,

02:30:35.665 --> 02:30:37.545
wenn man sich halt für das Gebiet

02:30:37.545 --> 02:30:39.345
überhaupt so ein bisschen grob interessiert,

02:30:39.985 --> 02:30:41.425
wie funktioniert eine Programmiersprache

02:30:41.425 --> 02:30:43.925
oder wie funktioniert so ein Bytecode-Interpreter

02:30:43.925 --> 02:30:45.945
oder irgendwann dann auch

02:30:45.945 --> 02:30:47.905
wie funktioniert so ein JIT, ist das schon

02:30:47.905 --> 02:30:49.905
auch ein Projekt, wo man

02:30:49.905 --> 02:30:51.865
halt im Vergleich zu, ich lerne jetzt

02:30:51.865 --> 02:30:53.065
erstmal C++ für ein Jahr

02:30:53.065 --> 02:30:55.945
und es ist ja dann auch vielleicht in so einer

02:30:55.945 --> 02:30:57.425
virtuellen Maschine auch komisches C++,

02:30:58.425 --> 02:30:59.785
wo man dann doch auch recht leicht

02:30:59.785 --> 02:31:00.565
irgendwie reinkommen kann.

02:31:01.725 --> 02:31:03.185
Und ich

02:31:03.185 --> 02:31:05.945
also ich sage das auch

02:31:05.945 --> 02:31:07.825
immer mal wieder, wenn sich da jemand für

02:31:07.825 --> 02:31:09.165
interessiert und dann da gerne

02:31:09.165 --> 02:31:11.905
was machen möchte, ich mache da auch gerne

02:31:11.905 --> 02:31:13.605
immer Mentoring, das ist halt auch

02:31:13.605 --> 02:31:15.925
Teil meines Jobs, da ich betreue halt irgendwie

02:31:15.925 --> 02:31:17.725
Studenten, die da dann auch

02:31:17.725 --> 02:31:19.605
drin arbeiten, als Teil ihrer Arbeiten.

02:31:19.845 --> 02:31:21.445
Insofern weiß ich halt dann,

02:31:22.125 --> 02:31:23.925
also habe ich quasi viel Übung in Onboarding

02:31:23.925 --> 02:31:25.925
und das ist auch was,

02:31:25.985 --> 02:31:27.905
was mir Spaß macht. Also wenn sich jemand jetzt für irgendwas

02:31:27.905 --> 02:31:29.285
konkret interessiert, es gibt

02:31:29.285 --> 02:31:32.185
Themen verschiedenster

02:31:32.185 --> 02:31:33.685
Art, dann

02:31:33.685 --> 02:31:36.065
kann man sich

02:31:36.065 --> 02:31:37.385
immer gerne bei uns melden und

02:31:37.385 --> 02:31:39.945
ich zoome dann immer gerne auch

02:31:39.945 --> 02:31:41.485
mit Leuten und mache so ein bisschen Pair-Programming

02:31:41.485 --> 02:31:43.645
beim Einstieg, damit man halt

02:31:43.645 --> 02:31:46.485
einfach so ein bisschen...

02:31:46.485 --> 02:31:48.385
Also die erste Stunde in einem neuen Projekt

02:31:48.385 --> 02:31:49.285
ist ja immer die schlimmste.

02:31:49.525 --> 02:31:51.825
Man weiß halt nicht, man findet halt nichts.

02:31:52.005 --> 02:31:53.225
Wo ist man da jetzt gelandet?

02:31:53.465 --> 02:31:55.085
Was ist denn das hier für ein Ordner?

02:31:55.285 --> 02:31:56.485
Und wie startet das eigentlich?

02:31:56.585 --> 02:31:59.005
Wo kriege ich eigentlich das Python 2 her, was ich brauche?

02:31:59.105 --> 02:31:59.805
Und wo geht es mit Tech-Essen?

02:32:01.005 --> 02:32:03.585
Da versuche ich dann immer auf jeden Fall

02:32:03.585 --> 02:32:05.505
deutlich den Leuten zu helfen.

02:32:06.705 --> 02:32:07.745
Und das ist auch was,

02:32:07.825 --> 02:32:09.145
was mir wirklich Spaß macht.

02:32:09.725 --> 02:32:10.725
Meldet euch und

02:32:10.725 --> 02:32:12.725
Ja

02:32:12.725 --> 02:32:15.845
Ja, klingt auf jeden Fall sehr gut

02:32:15.845 --> 02:32:16.385
Ja, vielen Dank

02:32:16.385 --> 02:32:18.665
Wollen wir vielleicht noch Pics machen?

02:32:19.605 --> 02:32:21.305
Ich hatte jetzt nur einen kleinen

02:32:21.305 --> 02:32:23.885
der gar nichts mit sonst

02:32:23.885 --> 02:32:25.825
die Dingen zu tun hat, über die wir gerade

02:32:25.825 --> 02:32:26.345
geredet haben

02:32:26.345 --> 02:32:27.485
Dann lassen wir es weg

02:32:27.485 --> 02:32:30.985
Ja, dann vielen Dank, dass ihr eingeschaltet habt

02:32:30.985 --> 02:32:33.885
Ja, sehr interessant diesmal

02:32:33.885 --> 02:32:34.525
Danke sehr

02:32:34.525 --> 02:32:35.725
Danke für die Einladung

02:32:35.725 --> 02:32:38.785
Okay, dann bis zum nächsten Mal

02:32:38.785 --> 02:32:39.585
Tschüss, bis dann