WEBVTT

00:00:00.000 --> 00:00:05.960
Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Peißen-Podcast. Heute Episode 59. Hi Jochen.

00:00:07.040 --> 00:00:09.160
Herzlich willkommen Dominik. 59, meine Güte.

00:00:09.300 --> 00:00:10.060
Ja, hi Johannes.

00:00:10.820 --> 00:00:12.000
Und hallo Johannes.

00:00:12.680 --> 00:00:15.080
Wir machen heute weiter mit dem Flunen-Peißen-Buch, haben wir uns gedacht.

00:00:15.760 --> 00:00:17.920
Ja, genau. So, hat sich bewährt.

00:00:18.180 --> 00:00:19.180
Ja, ich fand das ganz gut.

00:00:19.240 --> 00:00:21.660
Bleiben wir jetzt. Machen nur noch das.

00:00:21.720 --> 00:00:22.240
Es ist ja auch lang.

00:00:22.260 --> 00:00:24.620
Wenn wir hinten angekommen sind, dann machen wir es nochmal rückwärts.

00:00:25.000 --> 00:00:28.000
Dann haben wir es schon vergessen, dann müssen wir es von vorne direkt wieder vorlesen.

00:00:28.000 --> 00:00:33.460
Ja, wir hatten, also das Kapitel 2 hat was mit Sequenzen und Listen und sowas zu tun, da hatten wir ja schon mal eine Folge, ne, erinnert ihr euch?

00:00:33.900 --> 00:00:37.360
Ja, aber da gibt es einfach immer noch mehr zu sagen.

00:00:37.780 --> 00:00:51.860
Genau, ich hatte da auch nochmal reingeguckt kurz und wir haben da, also das ist ein bisschen orthogonal, das ist gut, also es ist halt von der anderen Seite nochmal angegangen und da das Thema sowieso irgendwie wichtig ist, dann kann man das auch von mehreren Seiten mal irgendwie angehen, das ist eigentlich ganz gut.

00:00:52.600 --> 00:00:52.880
Okay.

00:00:53.060 --> 00:00:53.280
Ja.

00:00:54.140 --> 00:00:55.100
Haben wir denn News?

00:00:55.940 --> 00:01:08.480
Ja, so ein bisschen, ich habe jetzt, ja, ist halt die Frage, was da alles so drunter fällt, Python 3.13, das machen wir jetzt nicht, aber das kommt jetzt ganz bald.

00:01:09.600 --> 00:01:11.540
Ja, also ich finde ja den REPL so schön.

00:01:12.160 --> 00:01:15.700
Ja, genau, habt ihr euch alle schon so ein bisschen damit beschäftigt oder gar nicht?

00:01:16.220 --> 00:01:16.760
Nee, gar nicht.

00:01:16.780 --> 00:01:17.160
Auch gar nicht?

00:01:17.180 --> 00:01:18.220
So ein ganz kleines bisschen.

00:01:18.980 --> 00:01:21.160
Ja, also genau, also ja.

00:01:21.160 --> 00:01:25.860
Der REPL ist total toll, du kannst einfach Defaults jetzt eintragen, den er automatisch lädt, Pakete in deinem REPL.

00:01:25.940 --> 00:01:27.820
Das heißt, wenn du den Interpreter aufmachst, dann hat der

00:01:27.820 --> 00:01:29.940
Pakete schon geladen. Oder damit

00:01:29.940 --> 00:01:31.980
kannst du halt auch Sachen dann überschreiben, weil er dann die Pakete

00:01:31.980 --> 00:01:33.860
lädt, die er laden soll. Und du hast

00:01:33.860 --> 00:01:36.040
einen Befehlssatz drin direkt, den du möchtest.

00:01:36.200 --> 00:01:37.700
Also eine eigene Konfiguration für deinen

00:01:37.700 --> 00:01:38.460
Ripple direkt haben.

00:01:38.720 --> 00:01:41.700
Man kann einfach Exit eingeben und ist draußen und Multiline

00:01:41.700 --> 00:01:43.940
Editing und die History ist ordentlich

00:01:43.940 --> 00:01:45.920
und so. Das finde ich jetzt alles nicht so

00:01:45.920 --> 00:01:47.580
beeindruckend, weil ich habe eh immer

00:01:47.580 --> 00:01:48.900
einen IPython überall.

00:01:49.620 --> 00:01:51.660
Ja, aber rate mal, wer das nicht hat.

00:01:52.980 --> 00:01:53.880
Der Dominik.

00:01:54.280 --> 00:01:56.300
Nee, die Python-Ur-Entwickler.

00:01:56.940 --> 00:01:57.320
Deswegen alle

00:01:57.320 --> 00:01:59.640
mit allen neuen...

00:01:59.640 --> 00:02:01.420
Die schauen dann mit Neid, schauen die so...

00:02:01.420 --> 00:02:03.680
Ja, aber iPad ist so cool.

00:02:03.980 --> 00:02:04.820
Oder Beep-Python.

00:02:05.800 --> 00:02:07.720
Genau, und das geht alles nicht, weil das läuft ja mit der neuen

00:02:07.720 --> 00:02:09.480
und in der Entwicklung befindlichen

00:02:09.480 --> 00:02:11.480
Python-Version funktioniert das halt nicht.

00:02:11.560 --> 00:02:13.500
Das heißt, die müssen immer die Python-Rapid verwenden und die

00:02:13.500 --> 00:02:15.340
sagen alle,

00:02:15.440 --> 00:02:17.320
das ist so viel besser jetzt, das ist so cool.

00:02:18.560 --> 00:02:18.680
Ja.

00:02:20.480 --> 00:02:22.080
Ja, das ist typischer

00:02:22.080 --> 00:02:24.200
Software-Entwicklungsmechanismus.

00:02:24.280 --> 00:02:26.040
oder Softwareentwicklung durch Neid.

00:02:26.520 --> 00:02:28.400
Ja. Ja, erstmal bitte ein bisschen

00:02:28.400 --> 00:02:30.120
Rennbogenfarben irgendwie in der Konsole,

00:02:30.220 --> 00:02:31.860
dann macht das Spaß. Ja.

00:02:32.340 --> 00:02:34.080
Und ein großer Teil davon kommt halt auch,

00:02:34.200 --> 00:02:36.260
oder kam, also Anregungen dafür

00:02:36.260 --> 00:02:37.060
kamen aus PyPy.

00:02:38.360 --> 00:02:40.240
Und dann haben sie es jetzt aber nochmal durch die Mangel

00:02:40.240 --> 00:02:42.220
gedreht und alle möglichen Sachen gefunden, die man irgendwie

00:02:42.220 --> 00:02:44.320
besser machen soll. Jetzt überlegen sie, ob der Kram,

00:02:44.360 --> 00:02:46.180
den sie in Seapython jetzt gemacht haben, nicht zurückgeht nach

00:02:46.180 --> 00:02:46.740
PyPy wieder.

00:02:48.960 --> 00:02:50.320
Aber das ist cool. Also das ist

00:02:50.320 --> 00:02:52.240
auf jeden Fall, das sind einige

00:02:52.240 --> 00:02:54.180
Sachen, die jetzt auch da immer wieder

00:02:54.180 --> 00:02:55.860
zwischen den Leuten dann diskutiert werden und so.

00:02:55.960 --> 00:02:58.200
Und da ist auf jeden Fall eine fruchtbare Diskussion

00:02:58.200 --> 00:02:59.740
immer so im Stande. Ich höre ja diesen

00:02:59.740 --> 00:03:01.900
Copy-By-Podcast und da ist eigentlich

00:03:01.900 --> 00:03:04.100
PiPi immer mit dabei oder

00:03:04.100 --> 00:03:05.460
ja,

00:03:06.740 --> 00:03:07.620
Karl Friedrich

00:03:07.620 --> 00:03:09.600
bei Band als

00:03:09.600 --> 00:03:11.320
irgendwas, das hat er dazu gesagt.

00:03:12.380 --> 00:03:13.980
Ja, also das ist auf jeden Fall cool.

00:03:15.400 --> 00:03:16.240
Genau, Python 3.3,

00:03:16.420 --> 00:03:17.620
die Repel-Geschichten.

00:03:18.240 --> 00:03:19.580
Ja, es gibt halt, also das größte,

00:03:19.680 --> 00:03:21.200
das dickste Feature, was immer alle

00:03:21.940 --> 00:03:22.960
nennen, ist halt

00:03:22.960 --> 00:03:24.740
Free Threading, also

00:03:24.740 --> 00:03:26.500
man kann den GIL

00:03:26.500 --> 00:03:27.560
abschalten.

00:03:29.240 --> 00:03:31.140
Ja, also... Das sind schon, das würde ich

00:03:31.140 --> 00:03:32.840
schon sagen, das sind schon nennenswerte News.

00:03:32.980 --> 00:03:35.040
Ja, ja, schon, schon, klar, und also

00:03:35.040 --> 00:03:37.120
in gewissen Fällen bringt das sicherlich

00:03:37.120 --> 00:03:39.000
auch viel, aber... Die auch vielleicht eine eigene

00:03:39.000 --> 00:03:41.000
Episode brauchen. Ja, genau, da müsste man auch mal

00:03:41.000 --> 00:03:42.740
äh... No-Gay.

00:03:43.400 --> 00:03:43.720
Genau.

00:03:44.920 --> 00:03:47.200
Ja, das ist halt auch mit drin. Hashtag, Hashtag No-Gay.

00:03:47.200 --> 00:03:49.240
Ja, überhaupt

00:03:49.240 --> 00:03:51.540
dieser ganze, der, äh,

00:03:51.820 --> 00:03:54.060
Es gibt

00:03:54.060 --> 00:03:56.520
einen Just-in-Time-Compiler, der jetzt mit dabei ist.

00:03:56.560 --> 00:03:58.500
Der macht zwar noch nicht viel, aber er ist auf jeden Fall

00:03:58.500 --> 00:04:00.600
jetzt drin. Das heißt, da könnte

00:04:00.600 --> 00:04:02.500
man in Zukunft auch irgendwie einige

00:04:02.500 --> 00:04:04.420
coole Performance-Verbesserungen

00:04:04.420 --> 00:04:06.040
erwarten. So ein

00:04:06.040 --> 00:04:08.340
Copy-and-Patch-Jit

00:04:08.340 --> 00:04:09.580
ist jetzt tatsächlich

00:04:09.580 --> 00:04:12.060
in Python-Interpreter mit drin.

00:04:14.140 --> 00:04:14.580
Ja,

00:04:14.680 --> 00:04:15.420
was haben wir noch alles?

00:04:19.900 --> 00:04:20.340
Genau,

00:04:20.480 --> 00:04:21.620
es gibt jetzt farbige Phrase-Bags.

00:04:21.820 --> 00:04:23.740
auch wieder so ein, ja,

00:04:23.760 --> 00:04:25.040
für den Alltag irgendwie ein bisschen besser.

00:04:26.100 --> 00:04:27.140
Ja gut, das sind natürlich schon alles.

00:04:27.780 --> 00:04:29.340
Also er hat auch immer einen guten Hint, er

00:04:29.340 --> 00:04:31.860
racet jetzt nicht einfach irgendwas und denkt sich so, oh ja,

00:04:32.720 --> 00:04:33.780
komisches Straightback, so weiß ich nicht wo,

00:04:33.860 --> 00:04:35.740
sondern er hat oft schon eine gute Intuition, was das

00:04:35.740 --> 00:04:37.700
sein könnte. Ja, genau.

00:04:37.700 --> 00:04:39.880
Da ist jetzt auch eine...

00:04:39.880 --> 00:04:41.600
Also da sind jetzt Dinge

00:04:41.600 --> 00:04:43.700
verschieden große Signifikanz

00:04:43.700 --> 00:04:44.760
dabei, würde ich sagen. Ja.

00:04:46.040 --> 00:04:47.340
Ja, aber tatsächlich für Anfänger,

00:04:47.720 --> 00:04:48.960
also was die oft irgendwie,

00:04:48.960 --> 00:04:50.560
ein Problem, das sie hatten, ist,

00:04:51.480 --> 00:04:52.860
du nennst

00:04:52.860 --> 00:04:55.160
dein Python-Modul

00:04:55.160 --> 00:04:56.460
oder Skript, das du gerade schreibst,

00:04:56.920 --> 00:04:58.900
nennst du halt genauso wie ein Standard-Lib-Modul

00:04:58.900 --> 00:05:00.460
und

00:05:00.460 --> 00:05:03.680
wenn das Versuch auszuprobiert

00:05:03.680 --> 00:05:04.760
passiert, kriegst du eine total

00:05:04.760 --> 00:05:06.780
kryptische Fehlermeldung, die dir echt gar nicht

00:05:06.780 --> 00:05:07.920
weiterhilft. Und

00:05:07.920 --> 00:05:10.420
da gibt es jetzt eine Fehlermeldung, die sagt,

00:05:10.500 --> 00:05:12.920
kann es sein, dass du das genannt hast wie ein Standard-Library-Modul?

00:05:12.920 --> 00:05:14.800
Das ist aber nicht gut. Mach das mal anders.

00:05:15.340 --> 00:05:16.680
Und das ist natürlich hilfreicher irgendwie.

00:05:17.480 --> 00:05:18.820
Ja, das ist tatsächlich was, was in

00:05:18.820 --> 00:05:20.900
Python-Kursen oft vorkommt, weil man halt irgendwie

00:05:20.900 --> 00:05:23.000
haben naheliegende Namen und wenn du

00:05:23.000 --> 00:05:25.020
deine Funktionalität schreibst, die

00:05:25.020 --> 00:05:27.000
sich mit einem Thema beschäftigt, dann wählst du

00:05:27.000 --> 00:05:28.980
den naheliegenden Namen für deine

00:05:28.980 --> 00:05:30.800
Python-Partei und schon hast du das Modul

00:05:30.800 --> 00:05:32.460
überschrieben. Deshalb, das ist

00:05:32.460 --> 00:05:34.900
schon gut, aber ich würde sagen,

00:05:35.060 --> 00:05:37.140
es ist, sagen wir mal, technologisch

00:05:37.140 --> 00:05:38.840
weniger fortschrittlich

00:05:38.840 --> 00:05:41.140
oder weniger kompliziert

00:05:41.140 --> 00:05:42.660
als Hashtag NoGill.

00:05:43.020 --> 00:05:44.680
Ja, das ist richtig. Da ist eine ganze Menge

00:05:44.680 --> 00:05:46.500
Enttäuschung und Aufwand drin gewesen, glaube ich.

00:05:47.420 --> 00:05:47.580
Ja.

00:05:48.680 --> 00:05:50.840
Ja, ansonsten, genau.

00:05:50.900 --> 00:05:52.740
Ich weiß gar nicht, ich habe noch irgendwas zu lesen.

00:05:53.000 --> 00:05:55.120
Wir machen zu 3.13 auf jeden Fall

00:05:55.120 --> 00:05:56.960
auch noch eine Episode, denke ich, dann können wir das mal

00:05:56.960 --> 00:05:57.680
alles zusammentragen.

00:05:59.140 --> 00:06:01.480
Ja, ansonsten,

00:06:01.620 --> 00:06:02.140
was war noch?

00:06:03.800 --> 00:06:05.200
Django 5.1 gibt es auch

00:06:05.200 --> 00:06:06.060
irgendwie jetzt.

00:06:06.820 --> 00:06:08.600
Ja, aber ändert sich da irgendwas?

00:06:09.600 --> 00:06:11.300
Da war auch nichts,

00:06:11.300 --> 00:06:13.180
was ich mir jetzt so spontan in Erinnerung geblieben wäre.

00:06:13.400 --> 00:06:15.200
Ja, also diese Django-Releases,

00:06:15.340 --> 00:06:16.360
da gibt es ja sehr viele immer.

00:06:17.520 --> 00:06:19.160
Und ich habe das Gefühl, also klar,

00:06:19.220 --> 00:06:20.920
die machen Sicherheit, die machen so Verbesserungen

00:06:20.920 --> 00:06:22.440
und dann machen sie schon immer mal wieder

00:06:22.440 --> 00:06:24.980
coole Sachen, da mit

00:06:24.980 --> 00:06:26.920
diesem Postgres-JSON ändern sich ja schon schöne

00:06:26.920 --> 00:06:27.500
Dinge, aber

00:06:27.500 --> 00:06:30.980
so richtig...

00:06:30.980 --> 00:06:32.620
Oh, wir haben da schon drüber gesprochen, glaube ich.

00:06:32.760 --> 00:06:34.820
Wir haben schon drüber gesprochen, diese Query-String-Geschichten

00:06:34.820 --> 00:06:36.860
und so, brauchen wir nicht nochmal. Ja, ich hätte, ich habe mir

00:06:36.860 --> 00:06:39.020
die Videos nicht aufgeschrieben, aber ich...

00:06:39.020 --> 00:06:40.540
Ja, aber ich meine, Django

00:06:40.540 --> 00:06:43.140
fühlt sich an, als ob es so stabil ist, dass es

00:06:43.140 --> 00:06:44.680
sehr inkrementelle Verbesserungen sind.

00:06:44.680 --> 00:06:45.340
Ja, ja.

00:06:45.620 --> 00:06:49.180
Das ist ja auch was Gutes, würde ich auch sagen.

00:06:49.220 --> 00:06:51.380
darauf verlassen kann, dass das halt, was man

00:06:51.380 --> 00:06:53.060
jetzt weiß, wie es funktioniert, dass es auch so bleibt.

00:06:54.920 --> 00:06:55.440
Ja, aber

00:06:55.440 --> 00:06:57.260
ich hätte noch eine Überleitung zu einer ganz

00:06:57.260 --> 00:06:59.340
interessanten Frage vielleicht, wenn wir jetzt hier

00:06:59.340 --> 00:07:01.380
schon eigentlich mit den News mehr oder weniger am Ende sind. Also ich weiß

00:07:01.380 --> 00:07:03.160
nicht, ob ihr noch was habt. Ich hätte jetzt nur noch irgendwie, es gibt

00:07:03.160 --> 00:07:04.820
neue LLM-Modelle, sowas wie

00:07:04.820 --> 00:07:07.420
O1 oder... Kann man jedes

00:07:07.420 --> 00:07:09.580
Mal als News sagen. Genau, also es gibt

00:07:09.580 --> 00:07:11.160
neue, probiert es mal wieder aus. Es gibt

00:07:11.160 --> 00:07:13.320
ein 700 Milliarden Parameter-Modell

00:07:13.320 --> 00:07:15.040
von Lama.

00:07:15.120 --> 00:07:16.920
Lama 3.1 700B.

00:07:17.220 --> 00:07:17.420
Ja.

00:07:18.760 --> 00:07:19.840
Das, ja.

00:07:20.100 --> 00:07:20.960
Brauchst den größeren Rechner.

00:07:21.880 --> 00:07:23.620
Also O1-Preview ist ja aber trotzdem auch noch new.

00:07:24.560 --> 00:07:25.440
Und das ist, also

00:07:25.440 --> 00:07:27.700
ich höre, das ist besser als Cloud wieder.

00:07:28.500 --> 00:07:29.780
Ja, also bisher, also genau,

00:07:29.900 --> 00:07:31.940
ich würde sagen, also diese ganze

00:07:31.940 --> 00:07:34.000
Artefaktsnummer,

00:07:34.120 --> 00:07:35.260
ich habe jetzt in letzter Zeit häufig

00:07:35.260 --> 00:07:36.760
Cloud, also

00:07:36.760 --> 00:07:39.400
das Chat-Interface von

00:07:39.400 --> 00:07:41.120
Anthropic

00:07:41.120 --> 00:07:43.700
verwendet, weil das halt einfach für Code-Geschichten

00:07:43.700 --> 00:07:45.200
oft ein bisschen besser war als

00:07:45.200 --> 00:07:46.640
als

00:07:46.640 --> 00:07:49.020
GPT-4O.

00:07:50.420 --> 00:07:50.780
Und

00:07:50.780 --> 00:07:52.020
ja,

00:07:52.660 --> 00:07:55.160
aber jetzt inzwischen, also ich weiß nicht genau,

00:07:55.240 --> 00:07:57.040
ich habe es noch nicht wirklich ausprobiert, ehrlich gesagt,

00:07:57.120 --> 00:07:58.860
weil es ja auch gerade erst rausgekommen ist, aber

00:07:58.860 --> 00:08:00.940
das soll halt sich dann auch noch mal wieder

00:08:00.940 --> 00:08:01.280
ein bisschen

00:08:01.280 --> 00:08:04.060
besser drüber sein.

00:08:04.320 --> 00:08:06.700
Also ich finde es jetzt schon super alles.

00:08:06.900 --> 00:08:08.860
Also das ist auch, das ganz normale

00:08:08.860 --> 00:08:10.520
GPT-4O und so war auch schon super

00:08:10.520 --> 00:08:12.700
und die Anthropic-Dinger fand ich auch total klasse.

00:08:12.700 --> 00:08:14.260
Also ich bin eigentlich sehr zufrieden.

00:08:14.900 --> 00:08:16.240
Es ist ein gutes Zeichen, wenn

00:08:16.240 --> 00:08:19.120
einen Chief Machine Learning Engineer

00:08:19.120 --> 00:08:20.360
Mensch Anthropic nicht kennt?

00:08:21.340 --> 00:08:23.120
Das wäre ein schlechtes Zeichen, würde ich

00:08:23.120 --> 00:08:24.580
meinen. Ja, wie kann das denn sein?

00:08:24.860 --> 00:08:26.940
Also gut, Machine Learning ist halt ein großes

00:08:26.940 --> 00:08:27.200
Feld.

00:08:28.020 --> 00:08:30.800
Ja, du kannst dich auch in irgendwas

00:08:30.800 --> 00:08:32.780
spezialisieren oder in einem ganz anderen Feld irgendwas

00:08:32.780 --> 00:08:34.820
machen, mit LLMs nie irgendwas zu tun haben.

00:08:35.240 --> 00:08:36.340
Aber ja, gut.

00:08:36.940 --> 00:08:37.860
Ja, also es war schon gut.

00:08:37.860 --> 00:08:39.840
Also die großen Namen musst du ja schon

00:08:39.840 --> 00:08:40.240
wissen, oder?

00:08:41.760 --> 00:08:42.420
Ja, gut.

00:08:43.660 --> 00:08:45.900
Aber ja, jetzt haben wir

00:08:45.900 --> 00:08:47.520
jetzt gerade eben hier mit dem die Karriere versaut.

00:08:48.180 --> 00:08:49.440
War eigentlich eine gute Alternative, ich bin gespannt.

00:08:49.640 --> 00:08:51.920
Also O1, ich finde es echt very nice.

00:08:52.540 --> 00:08:53.780
Hilft, also es ist so ein bisschen

00:08:53.780 --> 00:08:55.780
fehlerfreier

00:08:55.780 --> 00:08:57.680
bei Coding-Ding

00:08:57.680 --> 00:08:59.800
und so ein bisschen deeperes

00:08:59.800 --> 00:09:01.520
Knowledge und es macht sehr viel Spaß, diesen

00:09:01.520 --> 00:09:03.400
Gedankengang zuzugucken.

00:09:03.800 --> 00:09:05.580
Und das, was ja auch neu ist,

00:09:05.580 --> 00:09:07.460
das ist aber schon bei 4.0 drin,

00:09:07.580 --> 00:09:09.460
ist halt, dass du ein Gedächtnis hast

00:09:09.460 --> 00:09:11.060
jetzt auch. Ja,

00:09:11.320 --> 00:09:12.940
was sie da so nennen.

00:09:13.560 --> 00:09:15.460
Doch, doch, das ist schon, das funktioniert auch.

00:09:15.600 --> 00:09:17.560
man muss sich halt überlegen, ob man möchte,

00:09:17.680 --> 00:09:20.380
da hast du es gespeichert, was man da bespricht.

00:09:20.460 --> 00:09:22.240
Bitte merkt ihr alles, was ich hier gesagt habe.

00:09:22.500 --> 00:09:22.660
Ja.

00:09:23.940 --> 00:09:25.680
Aber vor allen Dingen ist das gar nicht so schlecht, weil, also,

00:09:26.360 --> 00:09:26.500
ja,

00:09:27.720 --> 00:09:29.740
interesting. Ja, ich meine,

00:09:30.340 --> 00:09:32.140
also, wenn man jetzt LLMs über die

00:09:32.140 --> 00:09:34.160
Kommandorenzahler mit dem LLM-Tool zum Beispiel

00:09:34.160 --> 00:09:35.220
benutzt, dann hat man das ja auch irgendwie,

00:09:35.540 --> 00:09:37.660
man ist ja lokal in der SQLite, ich weiß nicht,

00:09:38.520 --> 00:09:39.960
ja, ist auch immer die Frage, wie möchte man

00:09:39.960 --> 00:09:41.020
dieses hier eigentlich zeigen?

00:09:41.640 --> 00:09:43.740
Ja, also, ich frage tatsächlich so nach

00:09:43.740 --> 00:09:45.620
nach so Morgenroutinen oder sowas und sagt dann halt so, hey,

00:09:45.680 --> 00:09:47.740
was ich denn so mache und dann schlägt das Ding mir halt so Dinge

00:09:47.740 --> 00:09:49.800
vor, als dass es so, äh, macht mit mir

00:09:49.800 --> 00:09:51.580
so Rituale und so. Ich find's sehr lustig und das

00:09:51.580 --> 00:09:53.700
funktioniert toll. Und, ähm, das

00:09:53.700 --> 00:09:54.620
ist, glaub ich, gar nicht so blöd.

00:09:55.640 --> 00:09:57.880
Weil's einen so dabei hält, sich so selber

00:09:57.880 --> 00:09:59.580
zu entwickeln.

00:09:59.900 --> 00:10:01.620
Ja, cool. Das kann man natürlich auch mit anderen Quellen

00:10:01.620 --> 00:10:03.260
machen, dass nicht, dass man jetzt irgendwie so ein

00:10:03.260 --> 00:10:05.560
Eifer bräuchte, aber es geht damit sogar

00:10:05.560 --> 00:10:06.240
relativ gut.

00:10:07.620 --> 00:10:09.660
Ja, genau. Ansonsten würd ich nämlich Django

00:10:09.660 --> 00:10:11.820
irgendwie mal kurz zu der Überleitung nutzen,

00:10:11.920 --> 00:10:13.260
da wir jetzt sowieso nicht so viel News haben.

00:10:13.420 --> 00:10:14.640
ich habe, und

00:10:14.640 --> 00:10:17.040
ich mache gerade ein neues Projekt, weil

00:10:17.040 --> 00:10:19.220
irgendwie ich prokrastiniere so gerade die Dinge, die ich eigentlich

00:10:19.220 --> 00:10:21.300
machen sollte und, naja,

00:10:21.440 --> 00:10:21.960
wer kennt das nicht?

00:10:23.100 --> 00:10:24.580
Ja, sinnvolles Prokrastinieren.

00:10:25.860 --> 00:10:26.220
Produktives.

00:10:27.020 --> 00:10:29.580
Genau, der New Repository

00:10:29.580 --> 00:10:31.400
Button bei GitHub, der wird immer so

00:10:31.400 --> 00:10:33.260
shiny und fängt dann zu leuchten

00:10:33.260 --> 00:10:35.120
und dann denkt man sich, ah, es geht nicht anders,

00:10:35.180 --> 00:10:36.940
ich muss draufdrücken und dann habe ich das halt

00:10:36.940 --> 00:10:37.700
mal wieder gemacht.

00:10:39.540 --> 00:10:41.120
Genau, ich bin nämlich gerade dabei,

00:10:41.960 --> 00:10:42.400
irgendwie

00:10:42.400 --> 00:10:43.440
mal

00:10:43.440 --> 00:10:47.060
meine Bewerbungsunterlagen

00:10:47.060 --> 00:10:48.860
beziehungsweise so CV

00:10:48.860 --> 00:10:50.900
und so Zeugs irgendwie auf einer Webseite zu,

00:10:51.020 --> 00:10:52.460
weil ich hätte das immer so in einem Textpfeil,

00:10:52.580 --> 00:10:55.060
aber dann habe ich fünf unterschiedliche Varianten, die alle nicht aktuell

00:10:55.060 --> 00:10:56.140
sind und irgendwie

00:10:56.140 --> 00:10:58.620
für unterschiedliche Zwecke gebraucht wurden

00:10:58.620 --> 00:11:00.260
und dann denke ich mir so, naja gut, welches nehme ich denn jetzt?

00:11:00.320 --> 00:11:02.180
Und dann weiß ich es nicht und dann denke ich mir, ah, ich müsste mal

00:11:02.180 --> 00:11:04.660
und ah, alles schrecklich und warum packe ich das nicht einfach

00:11:04.660 --> 00:11:05.620
auf eine Webseite? Das ist doch eigentlich ganz gut.

00:11:05.640 --> 00:11:08.500
Ja, ich habe auch mal ein paar gute gesehen, wo ich mir noch eine To-Do-Liste

00:11:08.500 --> 00:11:10.480
habe, wo draufsteht, dass ich mir ein Vorbild daran nehmen wollte.

00:11:10.760 --> 00:11:11.580
Vielleicht ist es ja jetzt dein Zug.

00:11:11.680 --> 00:11:13.400
Ich habe auch schon mal so ein Projekt angefangen, Jochen.

00:11:13.560 --> 00:11:16.680
Ja, gut, dann jeder muss sowas.

00:11:17.060 --> 00:11:19.400
Ich habe meine Sachen immerhin schon mal in Markdown stehen.

00:11:19.500 --> 00:11:20.320
Das ist schon mal ein Fortschritt.

00:11:20.580 --> 00:11:22.580
Ja, Markdown ist schon mal nicht so schlecht.

00:11:23.220 --> 00:11:24.160
Jochen, guck, an der Stelle,

00:11:24.280 --> 00:11:25.480
wir haben uns ja kürzlich darüber unterhalten,

00:11:25.560 --> 00:11:26.460
an der Stelle muss man jetzt sagen,

00:11:26.620 --> 00:11:30.240
jeder Softwareentwickler, den man beauftragen kann,

00:11:30.680 --> 00:11:33.400
muss immer wieder sowas machen.

00:11:33.640 --> 00:11:34.680
Also, falls jemand zuhört,

00:11:34.800 --> 00:11:36.100
der den Jochen oder mich beauftragen möchte.

00:11:36.100 --> 00:11:36.420
Ja, oder mich.

00:11:36.800 --> 00:11:37.660
Also, das ist ja genau der Punkt.

00:11:37.660 --> 00:11:38.340
Ja, den Dominik auch.

00:11:38.340 --> 00:11:39.340
Ja, wir wollten halt so ein bisschen,

00:11:39.660 --> 00:11:41.600
vielleicht heute mal Werbung in eigener Sachen machen, oder?

00:11:41.700 --> 00:11:43.120
Können wir ja auch. Können wir ja gerne machen.

00:11:43.700 --> 00:11:45.980
Also ihr könnt uns mieten, buchen oder sowas,

00:11:46.060 --> 00:11:48.200
wenn ihr wollt. Wir sind prinzipiell

00:11:48.200 --> 00:11:49.920
käuflich. Ja, also für

00:11:49.920 --> 00:11:52.020
Projekte. Wie machen, glaube ich,

00:11:52.060 --> 00:11:53.820
Peißen? Das ist alles eine Frage des Preises.

00:11:54.460 --> 00:11:55.920
Nein, bei interessanten Sachen sind wir

00:11:55.920 --> 00:11:57.420
auch zur Diskussion bereit, oder? Genau.

00:11:58.240 --> 00:11:59.800
Von ein bis drei Leuten könnt ihr da

00:11:59.800 --> 00:12:01.880
relativ viel Kappa bekommen, die auch gute Sachen

00:12:01.880 --> 00:12:02.120
machen.

00:12:03.640 --> 00:12:05.960
Ich habe gehört, wir haben alle ein Buch

00:12:05.960 --> 00:12:07.800
gelesen. Oh ja, genau. Wir könnten

00:12:07.800 --> 00:12:09.980
eigentlich mal mit dem Thema anfangen?

00:12:11.020 --> 00:12:11.860
Ja, listen.

00:12:13.480 --> 00:12:13.920
Sequenzen.

00:12:14.820 --> 00:12:15.560
Sequenzen, genau.

00:12:15.560 --> 00:12:16.380
Ja, Sequenzen.

00:12:17.360 --> 00:12:19.560
Das zweite Kapitel ist deutlich länger

00:12:19.560 --> 00:12:21.460
als das erste Kapitel. Das erste Kapitel war

00:12:21.460 --> 00:12:22.920
so ein Häppchen.

00:12:23.740 --> 00:12:25.440
Und das zweite Kapitel ist

00:12:25.440 --> 00:12:26.540
schon ein Brocken.

00:12:27.040 --> 00:12:28.500
Wie weit hast du denn gelesen?

00:12:29.360 --> 00:12:31.320
Bis zum Ende des zweiten Kapitels.

00:12:32.340 --> 00:12:33.380
Seite 39.

00:12:34.340 --> 00:12:35.260
Ja, sowas ungefähr.

00:12:35.620 --> 00:12:36.340
Keine Ahnung, wie weit.

00:12:37.040 --> 00:12:38.180
Das muss ich jetzt nachgucken.

00:12:39.440 --> 00:12:40.500
Seite 58.

00:12:41.280 --> 00:12:42.560
Dann hast du wesentlich weiter gelesen.

00:12:43.720 --> 00:12:45.000
Das ist Chapter 2,

00:12:45.120 --> 00:12:46.400
An Array of Sequences.

00:12:46.860 --> 00:12:49.180
Das mit 59 geht auch weiter bei List is not

00:12:49.180 --> 00:12:50.980
Seance. Und dann geht es so ein bisschen

00:12:50.980 --> 00:12:52.800
in die Diskussion darüber, wann man was machen möchte.

00:12:53.060 --> 00:12:54.940
Ja, genau. Das ist tatsächlich, das habe ich mir extra

00:12:54.940 --> 00:12:56.320
markiert, es geht bis Seite 77.

00:12:57.100 --> 00:12:59.060
Und Seite 59 ist nämlich das, worüber

00:12:59.060 --> 00:13:00.720
ich mit euch dann gleich sprechen möchte.

00:13:01.020 --> 00:13:03.140
Ich bin so schlecht. Das ist ja erst am Ende des Kapitels.

00:13:03.140 --> 00:13:05.100
Ja, also wir müssen auf jeden Fall diese Trade-offs

00:13:05.100 --> 00:13:07.200
finde ich, glaube ich, ganz gut, weil man was für eine Art

00:13:07.200 --> 00:13:07.960
und Weise von

00:13:07.960 --> 00:13:10.580
Sequenz haben möchte,

00:13:10.840 --> 00:13:12.160
vielleicht gar nicht so uninteressant.

00:13:12.600 --> 00:13:14.360
Ja, also ich finde auch genau

00:13:14.360 --> 00:13:17.200
der grundsätzliche

00:13:17.200 --> 00:13:18.900
Blickwinkel drauf, den finde ich ganz interessant, weil

00:13:18.900 --> 00:13:20.820
wir hatten ja schon mal darüber geredet und da hatten wir

00:13:20.820 --> 00:13:23.040
eher den so, ja, wie implementiert

00:13:23.040 --> 00:13:24.800
man das eigentlich oder was sind so die algorithmischen

00:13:24.800 --> 00:13:26.700
Geschichten, die man damit machen kann und

00:13:26.700 --> 00:13:28.860
hier sind so die grundsätzlichen

00:13:28.860 --> 00:13:30.840
Unterschiede zwischen den Dingen halt

00:13:30.840 --> 00:13:33.040
eher sowas wie, ist es ein Container

00:13:33.040 --> 00:13:36.240
oder ist es irgendwie flach oder

00:13:36.240 --> 00:13:37.260
ist es irgendwie

00:13:37.260 --> 00:13:40.760
mutable oder immutable

00:13:40.760 --> 00:13:42.540
sozusagen. An den Achsen

00:13:42.540 --> 00:13:44.280
orientiert sich das Ganze irgendwie und das ist

00:13:44.280 --> 00:13:46.640
einfach ein anderer Blickwinkel und das fand ich eigentlich auch ganz interessant.

00:13:48.060 --> 00:13:48.140
Ja.

00:13:49.280 --> 00:13:50.680
Jedenfalls, genau.

00:13:51.280 --> 00:13:51.420
Also

00:13:51.420 --> 00:13:54.600
das ist halt irgendwie eine ganz

00:13:54.600 --> 00:13:56.320
fundamentale Geschichte und

00:13:56.320 --> 00:13:59.080
der Unterschied

00:13:59.080 --> 00:14:00.780
zwischen zum Beispiel Container und Flat ist halt einfach,

00:14:01.040 --> 00:14:02.840
dass in einem Container sind halt

00:14:02.840 --> 00:14:04.700
Referenzen auf Objekte drin und da kann halt alles

00:14:04.700 --> 00:14:06.680
mögliche drin sein. Da kann ganzer Zoo,

00:14:06.820 --> 00:14:08.360
Baum, sonst was, Dings von

00:14:08.360 --> 00:14:10.880
irgendwie anderen Sachen, die da noch drin liegen, sein.

00:14:11.540 --> 00:14:11.880
Während,

00:14:12.820 --> 00:14:14.660
also, und das geht natürlich mit Liste, also

00:14:14.660 --> 00:14:15.940
Python List geht das.

00:14:16.600 --> 00:14:18.660
Während jetzt sowas wie, was halt auch eine

00:14:18.660 --> 00:14:19.280
Sequence ist,

00:14:20.380 --> 00:14:22.840
Array enthält halt flach einfach nur

00:14:22.840 --> 00:14:24.600
die entsprechenden

00:14:24.600 --> 00:14:25.700
Werte.

00:14:26.800 --> 00:14:28.740
Halt ein Header mit irgendwie, wie sind die

00:14:28.740 --> 00:14:30.700
Daten dahinter jetzt strukturiert und dann kommen halt

00:14:30.700 --> 00:14:31.440
einfach nur die Daten.

00:14:32.840 --> 00:14:35.040
Und genau, das ist halt

00:14:35.040 --> 00:14:37.100
schon mal ein großer Unterschied. Das fand ich übrigens auch interessant,

00:14:37.280 --> 00:14:38.600
das habe ich nicht gewusst, dass

00:14:38.600 --> 00:14:41.360
Tuppel halt auch

00:14:41.360 --> 00:14:43.440
weniger Hauptspeicher

00:14:43.440 --> 00:14:44.900
belegen als die, also

00:14:44.900 --> 00:14:46.560
Tuppel sind immer ein bisschen schneller als Listen,

00:14:47.340 --> 00:14:49.160
weil das ist bei Listen halt so

00:14:49.160 --> 00:14:49.960
doppelt indirekt,

00:14:50.660 --> 00:14:53.080
weil es sich ja auch ändern kann und bei

00:14:53.080 --> 00:14:54.400
Tuppel nur einmal indirekt.

00:14:54.400 --> 00:14:56.180
Jetzt habe ich die Stelle nicht mehr.

00:14:57.360 --> 00:14:58.340
Also, aber

00:14:58.340 --> 00:14:59.800
das ist vielleicht auch was, was man erwähnen kann.

00:15:00.000 --> 00:15:02.280
So eine Liste verbraucht a priori schon mal mehr

00:15:02.280 --> 00:15:08.580
speicher weil es platz haben muss für zukünftiges wachstum und wenn ich das

00:15:08.580 --> 00:15:11.220
richtig erinnerung gehabt dann machen listen so ein exponentielles wachstum

00:15:11.220 --> 00:15:15.660
das heißt die haben wir mal eine gewisse menge lehrer elemente im hintergrund und

00:15:15.660 --> 00:15:19.460
ich glaube das sind zwei potenzen das heißt wenn man diese größe überschreitet

00:15:19.460 --> 00:15:26.520
dann passiert also ein riesig und dann verdoppelt sich diese liste das heißt in

00:15:26.520 --> 00:15:32.080
dem moment hat man dann etwa 50 prozent des potenziellen speichers einfach

00:15:32.080 --> 00:15:34.800
verschenkt, weil da keine Referenzen

00:15:34.800 --> 00:15:35.240
drin sind.

00:15:37.120 --> 00:15:38.980
Wobei Referenzen natürlich relativ

00:15:38.980 --> 00:15:40.400
klein sind. Also die sind jetzt nicht

00:15:40.400 --> 00:15:42.920
im Kilobyte-Bereich, sondern die sind

00:15:42.920 --> 00:15:45.080
natürlich nur im Pointer-Plus.

00:15:45.200 --> 00:15:47.320
Ja, also normalerweise. Die sind im Pi-Object-Bereich.

00:15:47.540 --> 00:15:48.200
Genau, 8-Byte.

00:15:49.220 --> 00:15:50.960
Ich glaube, es sind mehr, Jochen, oder?

00:15:51.020 --> 00:15:53.020
Das sind doch Pi-Objects, die da drin sind.

00:15:53.040 --> 00:15:54.800
Achso, wenn du das in Python-Objects,

00:15:54.800 --> 00:15:56.920
ja, da hast du normalerweise, du hast einmal

00:15:56.920 --> 00:15:59.260
einen Ref-Count.

00:15:59.280 --> 00:16:00.880
Du hast so einen Tag drin und so einen

00:16:00.880 --> 00:16:02.620
Typ. Und

00:16:02.620 --> 00:16:05.080
die Speicheradresse

00:16:05.080 --> 00:16:06.720
oder sowas. Genau, also den

00:16:06.720 --> 00:16:08.480
Point. Hast du nicht auch noch einen Reference-Count drin?

00:16:08.980 --> 00:16:10.920
Ja, genau. Also ich meine, das minimale

00:16:10.920 --> 00:16:13.540
Python-Objekt

00:16:13.540 --> 00:16:14.180
ist ein Float.

00:16:15.100 --> 00:16:16.540
Ich weiß nicht, ob es genau gleich ist.

00:16:16.960 --> 00:16:18.940
Float, da bin ich mir aber ziemlich sicher, dass es das kleinste

00:16:18.940 --> 00:16:21.080
mögliche

00:16:21.080 --> 00:16:22.940
Python-Objekt ist. Und das hat, glaube ich, 24 Byte,

00:16:23.020 --> 00:16:24.800
weil das ist halt genau irgendwie

00:16:24.800 --> 00:16:25.380
der Wert.

00:16:27.800 --> 00:16:28.980
Das ist sogar inline, oder?

00:16:30.600 --> 00:16:35.240
Ja, du meinst bei kleinen Werten?

00:16:35.920 --> 00:16:37.480
Bei Float ist es sogar inline, oder?

00:16:37.520 --> 00:16:39.600
Da hast du keine Referenz auf irgendeine andere Speicherzelle.

00:16:39.660 --> 00:16:41.000
Nein, das ist einfach direkt drin.

00:16:41.000 --> 00:16:41.980
Das ist einfach direkt, genau.

00:16:42.100 --> 00:16:45.100
Das ist nur der Wert direkt, der RefCount und der Typ.

00:16:45.820 --> 00:16:48.400
Aber auch das sind schon 24 Byte.

00:16:48.420 --> 00:16:48.720
Ja, klar.

00:16:49.040 --> 00:16:52.640
Für im Grunde nur 8 Byte Speicher hast du schon 24 Byte Speicher gebraucht.

00:16:52.660 --> 00:16:52.900
Genau.

00:16:54.420 --> 00:16:57.260
Aber die Größe ist ja gleich, egal ob du einen Tube-Loader in der Liste hast.

00:16:58.640 --> 00:16:59.520
Ja, das ist richtig.

00:17:00.600 --> 00:17:04.020
die freien Elemente, das hast du

00:17:04.020 --> 00:17:05.500
beim Tuple natürlich nicht. Beim Tuple

00:17:05.500 --> 00:17:08.040
sagst du, hier, ich brauche sieben Stück

00:17:08.040 --> 00:17:09.980
und dann kriegst du sieben Stück und nicht acht und nicht

00:17:09.980 --> 00:17:11.520
sechzehn und auch nicht eine andere Anzahl.

00:17:11.900 --> 00:17:13.940
Ja, und du kannst halt vielleicht bessere Optimierung

00:17:13.940 --> 00:17:15.940
machen, weil du immer genau weißt, wie lange ist das, weil du ja schon

00:17:15.940 --> 00:17:17.960
weißt, was so steht, weil du das nicht mehr verändern kannst. Und du kannst

00:17:17.960 --> 00:17:19.940
diese ganzen Methodendinger weg

00:17:19.940 --> 00:17:21.900
und den Overhead weglassen für, ich muss da

00:17:21.900 --> 00:17:23.620
was reinbasteln oder rausnehmen.

00:17:23.820 --> 00:17:25.960
Ja, okay, aber du hast natürlich

00:17:25.960 --> 00:17:27.960
einen Virtual Table, hast du immer

00:17:27.960 --> 00:17:28.220
noch.

00:17:30.040 --> 00:17:33.420
Ja, aber ich weiß nicht, ob das der große Unterschied ist.

00:17:34.000 --> 00:17:35.200
Ja, man darf ja nicht so viel ausmachen.

00:17:37.000 --> 00:17:38.800
Ha! Okay, ich habe es doch gefunden.

00:17:39.040 --> 00:17:39.840
Ja, okay, dann bitte.

00:17:40.760 --> 00:17:41.120
Kompliziert.

00:17:42.380 --> 00:17:44.520
Ich dachte gerade schon, ich habe schon irgendwie,

00:17:44.720 --> 00:17:45.920
ich dachte schon, wahrscheinlich habe ich einfach

00:17:45.920 --> 00:17:49.760
Dinge haluziniert und...

00:17:49.760 --> 00:17:50.760
Oh, oh, Jochen.

00:17:51.480 --> 00:17:52.180
Aber nein.

00:17:53.320 --> 00:17:53.960
Also, genau.

00:17:54.160 --> 00:17:54.680
LLM, Jochen.

00:17:54.680 --> 00:17:55.540
Ja, ja.

00:17:56.940 --> 00:17:58.760
Manchmal, man weiß es nicht so genau.

00:17:59.000 --> 00:18:02.020
genau, die Referenzen

00:18:02.020 --> 00:18:03.960
zu den Items in einem

00:18:03.960 --> 00:18:05.860
Tuppel sind halt in einem Array,

00:18:06.440 --> 00:18:07.660
die sind halt in einem Array in dem

00:18:07.660 --> 00:18:08.660
Tuppelsdruck halt drin,

00:18:09.860 --> 00:18:11.680
aber in der Liste sind

00:18:11.680 --> 00:18:14.080
quasi,

00:18:14.820 --> 00:18:16.060
also die Liste hält

00:18:16.060 --> 00:18:17.760
einen Pointer zu einem Array

00:18:17.760 --> 00:18:18.940
von Referenzen,

00:18:19.260 --> 00:18:21.400
die irgendwo anders sind, weil das

00:18:21.400 --> 00:18:23.680
Problem ist halt, wenn

00:18:23.680 --> 00:18:25.800
die Liste größer wird, als sie

00:18:25.800 --> 00:18:27.720
eigentlich quasi als momentan

00:18:27.720 --> 00:18:29.820
alloziert ist an Aufsprecher, dann

00:18:29.820 --> 00:18:31.600
muss man den ganzen Kram Rea allozieren können.

00:18:31.720 --> 00:18:33.720
Und das geht halt nur, wenn du...

00:18:33.720 --> 00:18:35.740
Ja, das ist dieses Resizing. Genau, genau.

00:18:36.120 --> 00:18:37.960
Und das macht halt nochmal einen Interaktionsschritt

00:18:37.960 --> 00:18:39.840
erforderlich. Und bei einem Tuple weißt du halt,

00:18:39.980 --> 00:18:41.940
ja, das passiert halt nie. Ich kann einfach

00:18:41.940 --> 00:18:43.080
ein Array von den Werten nehmen.

00:18:44.240 --> 00:18:45.480
Also vor dem... Okay, das ist quasi so

00:18:45.480 --> 00:18:47.700
ein bisschen wie das, was wir eben auch schon

00:18:47.700 --> 00:18:48.980
beim Float angesprochen haben, oder?

00:18:49.640 --> 00:18:51.860
Bei einem PyObject kann ein Float direkt

00:18:51.860 --> 00:18:54.080
drin sein und dann hast du keine Referenz

00:18:54.080 --> 00:18:55.960
auf irgendwas. Bei einem String

00:18:55.960 --> 00:18:57.660
zum Beispiel geht es nicht. Bei einem String, das

00:18:57.660 --> 00:18:59.700
PyObject ist halt der Tag und der

00:18:59.700 --> 00:19:01.280
Typ und der RefCount und

00:19:01.280 --> 00:19:03.900
die Referenz auf die tatsächlichen

00:19:03.900 --> 00:19:04.160
Daten.

00:19:04.950 --> 00:19:07.210
Und hier ist es genauso, oder? In einem Tuple kannst du es direkt

00:19:07.210 --> 00:19:09.150
drin haben und

00:19:09.150 --> 00:19:11.410
in einer Liste brauchst du erst noch eine Referenz

00:19:11.410 --> 00:19:13.050
auf die tatsächlichen Daten.

00:19:13.670 --> 00:19:15.070
Genau. Die dann wiederum halt

00:19:15.070 --> 00:19:17.070
in dem Fall eine Sequenz von

00:19:17.070 --> 00:19:19.350
Sachen sind, im Tuple-Fall

00:19:19.350 --> 00:19:20.850
direkt die Sequenz der Sachen und

00:19:20.850 --> 00:19:23.290
im Listen-Fall eine Referenz

00:19:23.290 --> 00:19:24.910
auf eine Sequenz von Sachen. Ja. Okay.

00:19:25.970 --> 00:19:27.250
Ja, okay, gut, das verstehe ich

00:19:27.250 --> 00:19:29.110
natürlich. Das ist ein Pointeraufruf mehr und

00:19:29.110 --> 00:19:31.350
Pointeraufrufe sind ja bei modernen Prozessoren

00:19:31.350 --> 00:19:32.410
so das Schlimmste,

00:19:32.950 --> 00:19:34.030
was du machen kannst.

00:19:34.750 --> 00:19:36.750
Ja, es ist alles kein großer Unterschied

00:19:36.750 --> 00:19:37.910
wahrscheinlich, faktisch.

00:19:38.650 --> 00:19:39.190
Aber ja.

00:19:40.290 --> 00:19:42.530
Müsste man mal einen Test machen.

00:19:43.350 --> 00:19:43.510
Ja.

00:19:44.710 --> 00:19:46.510
Es gibt ja durchaus Menschen, die

00:19:46.510 --> 00:19:46.930
sagen,

00:19:48.670 --> 00:19:50.750
nur High-Performance-Computing ist sinnvolles

00:19:50.750 --> 00:19:51.230
Computing.

00:19:52.130 --> 00:19:54.570
Das ist ja generell so, oder? Nur High-Performance

00:19:54.570 --> 00:19:55.030
ist sinnvoll.

00:19:56.450 --> 00:19:58.330
Dieses Casual, irgendwie

00:19:58.330 --> 00:20:00.130
Slow-Food, irgendwie

00:20:00.130 --> 00:20:01.930
ich schreibe meinen eigenen

00:20:01.930 --> 00:20:04.570
Algorithmus, das ist ja nicht gut.

00:20:04.750 --> 00:20:06.030
richtig sinnvoll, wenn das

00:20:06.030 --> 00:20:07.230
richtig machst.

00:20:08.110 --> 00:20:09.410
Also ich meine,

00:20:11.070 --> 00:20:12.590
es gibt

00:20:12.590 --> 00:20:14.110
ja so Leute, es gibt diesen Casey

00:20:14.110 --> 00:20:16.330
Muratory, der ist relativ bekannt,

00:20:17.110 --> 00:20:18.450
der schlägt immer wieder

00:20:18.450 --> 00:20:20.350
auf mit solchen, der ist halt,

00:20:20.730 --> 00:20:22.630
der vertritt quasi diese extreme Position.

00:20:22.890 --> 00:20:24.390
Wenn du es nicht

00:20:24.390 --> 00:20:26.010
richtig machst und dann auch

00:20:26.010 --> 00:20:27.910
hier die

00:20:27.910 --> 00:20:30.430
SIMD-Inlines von den verschiedenen Prozessoren

00:20:30.430 --> 00:20:32.230
benutzt, dann hast du es eigentlich gar nicht richtig gemacht.

00:20:32.330 --> 00:20:34.050
Und das ist die Ursache allen Übels.

00:20:34.210 --> 00:20:35.750
Deshalb ist ein Computer heute so scheiße.

00:20:37.090 --> 00:20:38.050
Und das ist natürlich das

00:20:38.050 --> 00:20:39.970
eine Extrem und das andere Extrem sind

00:20:39.970 --> 00:20:42.010
halt, naja, so Menschen wie

00:20:42.010 --> 00:20:43.990
wir, die Python und JavaScript

00:20:43.990 --> 00:20:45.590
benutzen und sagen, komm,

00:20:45.750 --> 00:20:47.790
Skriptsprache, Hauptsache das

00:20:47.790 --> 00:20:49.390
Entwickeln ist angenehm.

00:20:51.150 --> 00:20:52.090
Und irgendwo dazwischen,

00:20:52.090 --> 00:20:54.110
ich meine, gelegentlich machen

00:20:54.110 --> 00:20:55.470
wir ja auch High-Performance.

00:20:56.870 --> 00:20:58.030
Da muss man dann halt zu

00:20:58.030 --> 00:20:58.770
Techniken greifen.

00:20:59.510 --> 00:21:01.810
Die Frage ist, was High-Performance eigentlich ist. Da gibt es ja vielleicht

00:21:01.810 --> 00:21:03.990
verschiedene Blickwinkel drauf. Ja, gibt es auch

00:21:03.990 --> 00:21:06.030
verschiedene Blickwinkel, wobei, sobald

00:21:06.030 --> 00:21:08.030
du halt in so Data-Bereiche reingehst,

00:21:08.130 --> 00:21:09.890
ja, und sobald es mehr als ein Megabyte ist,

00:21:10.050 --> 00:21:11.710
musst du schon dir zumindest

00:21:11.710 --> 00:21:14.070
Gedanken drüber machen, ob das sinnvoll

00:21:14.070 --> 00:21:15.910
ist, das einzelne

00:21:15.910 --> 00:21:17.870
Elementweise zu verarbeiten oder ob du da nicht

00:21:17.870 --> 00:21:19.770
zumindest ein bisschen Batch-Verarbeitung machen kannst.

00:21:19.870 --> 00:21:21.790
Und je mehr es wird, umso mehr

00:21:21.790 --> 00:21:22.550
musst du drüber nachdenken.

00:21:23.910 --> 00:21:25.810
Aber in so einem Fall würde natürlich auch keiner

00:21:25.810 --> 00:21:27.670
von uns eine Python-Liste verwenden, oder?

00:21:27.810 --> 00:21:30.010
Also ich meine, für numerische

00:21:30.010 --> 00:21:31.950
Daten oder für High-Performance-Daten würde

00:21:31.950 --> 00:21:33.690
ich nicht eine Python-Liste verwenden.

00:21:33.710 --> 00:21:34.570
Was denn dann?

00:21:36.270 --> 00:21:37.770
Das ist ja eine sehr gute Frage,

00:21:37.870 --> 00:21:39.670
zum Beispiel, der Jochen hat es schon angesprochen, Array.

00:21:39.870 --> 00:21:41.610
Aha. Das ist der erste Schritt

00:21:41.610 --> 00:21:43.590
auf den Weg zur Effizienz und ist

00:21:43.590 --> 00:21:45.810
sogar in Python und pures Python und so weiter

00:21:45.810 --> 00:21:47.930
und so fort. Also Import Array, Array.Array.

00:21:48.250 --> 00:21:49.730
Ja, genau. Genau, richtig.

00:21:52.430 --> 00:21:53.450
Die generelle

00:21:53.450 --> 00:21:55.650
Eigenschaft von so High-Performance-Sachen ist

00:21:55.650 --> 00:21:57.050
ja immer, dass man

00:21:57.050 --> 00:21:59.370
Komfort aufgibt für

00:21:59.370 --> 00:22:00.190
Geschwindigkeit.

00:22:01.810 --> 00:22:03.530
Und das ist generell so, ja, und man kann das

00:22:03.530 --> 00:22:05.430
in beide Richtungen beliebig weit treiben.

00:22:05.590 --> 00:22:07.810
Man kann den Komfort komplett aufdrehen

00:22:07.810 --> 00:22:09.110
und dann halt

00:22:09.110 --> 00:22:11.550
sagen hier, Typen sind egal

00:22:11.550 --> 00:22:13.610
und ein Container

00:22:13.610 --> 00:22:15.290
kann alles enthalten und auch nix

00:22:15.290 --> 00:22:17.590
und verschiedene Dinge und so weiter

00:22:17.590 --> 00:22:19.330
und so fort, so wie wir es in Python bei Listen haben.

00:22:19.890 --> 00:22:21.490
Und du kannst aber auch ganz ans andere

00:22:21.490 --> 00:22:22.930
Ende gehen und sagen, okay, SimD

00:22:22.930 --> 00:22:25.190
und das muss im Speicher in der richtigen Stelle liegen

00:22:25.190 --> 00:22:27.510
und es muss byte-aligned sein

00:22:27.510 --> 00:22:29.470
und es muss so aufgebaut sein, dass die

00:22:29.470 --> 00:22:31.510
Cache-Lines zusammenpassen.

00:22:32.290 --> 00:22:33.250
Und das ist aber

00:22:33.250 --> 00:22:35.370
eine Skala dazwischen, so eine Sliding Scale

00:22:35.370 --> 00:22:37.390
dazwischen. Du kannst das ein bisschen

00:22:37.390 --> 00:22:39.270
mal weiter in die eine Richtung drehen oder ein bisschen

00:22:39.270 --> 00:22:40.390
weiter in die andere Richtung drehen.

00:22:41.130 --> 00:22:42.730
Und der erste Schritt, den du von

00:22:42.730 --> 00:22:44.390
Python-Listen

00:22:44.390 --> 00:22:46.710
wegmachen kannst, ist halt Array.

00:22:46.950 --> 00:22:47.650
Array.Array.

00:22:49.850 --> 00:22:50.330
Weil

00:22:50.330 --> 00:22:53.170
das ist dann nicht mehr diese Indirektion, sondern es ist

00:22:53.170 --> 00:22:54.830
direkt eine

00:22:54.830 --> 00:22:57.430
Auflistung

00:22:57.430 --> 00:22:59.090
von Dingen, also eine Abfolge

00:22:59.090 --> 00:23:00.530
von Dingen, die auch direkt

00:23:00.530 --> 00:23:01.950
da drin gespeichert werden.

00:23:03.010 --> 00:23:04.850
Das bedeutet aber halt, dass die alle gleich

00:23:04.850 --> 00:23:07.010
sein müssen. Und da fällt schon der erste Komfortteil

00:23:07.010 --> 00:23:08.850
weg. Du musst vorher wissen, was du da rein

00:23:08.850 --> 00:23:09.070
tust.

00:23:11.550 --> 00:23:12.790
Vielleicht kannst du mal kurz, was ist

00:23:12.790 --> 00:23:13.710
Cash-in-Line?

00:23:17.030 --> 00:23:17.890
Cash-in-Line.

00:23:18.310 --> 00:23:20.530
Das braucht, glaube ich, auch eine eigene Episode,

00:23:20.750 --> 00:23:22.590
aber es ist eine Eigenschaft von Prozessoren.

00:23:23.430 --> 00:23:24.270
Wir haben ja eben schon gesagt,

00:23:24.390 --> 00:23:26.710
wenn du irgendwie einen Pointer aufrufst, dann ist das

00:23:26.710 --> 00:23:27.990
das Schlimmste, was du machen kannst,

00:23:28.630 --> 00:23:31.010
weil der Hauptspeicher eines Computers

00:23:31.010 --> 00:23:32.930
wesentlich langsamer ist als der Prozessor

00:23:32.930 --> 00:23:34.670
eines Computers. Das hat sich

00:23:34.670 --> 00:23:36.890
so entwickelt. In den 80ern

00:23:36.890 --> 00:23:38.950
und 90ern war es noch nicht so. Da waren die irgendwie gleich

00:23:38.950 --> 00:23:40.850
schnell. Und dann sind die Prozessoren

00:23:40.850 --> 00:23:43.070
exponentiell schneller geworden und der Speicher

00:23:43.070 --> 00:23:45.170
ist halt nur quadratisch

00:23:45.170 --> 00:23:46.430
schneller geworden. Und dann

00:23:46.430 --> 00:23:48.170
waren die Prozessoren auf einmal

00:23:48.170 --> 00:23:51.090
eine Million Mal schneller als der Speicher und deshalb

00:23:51.090 --> 00:23:52.950
ist das das Problem,

00:23:53.090 --> 00:23:53.510
in dem wir leben.

00:23:54.610 --> 00:23:56.650
Da kommen jetzt Worte, die hat sicherlich jeder schon mal gehört.

00:23:56.810 --> 00:23:58.910
Jeder Prozessor hat irgendwie so einen

00:23:58.910 --> 00:23:59.830
L1-Cache.

00:24:00.530 --> 00:24:02.790
Das ist der Hauptspeicher, der ganz nah

00:24:02.790 --> 00:24:04.750
am Prozessor ist, der ist noch fast genauso

00:24:04.750 --> 00:24:06.830
schnell wie der Prozessor selbst, dann gibt es den L2

00:24:06.830 --> 00:24:08.730
Cache, der ist auf dem gleichen

00:24:08.730 --> 00:24:10.670
Prozessor die drauf, aber daneben

00:24:10.670 --> 00:24:12.710
und ist deshalb

00:24:12.710 --> 00:24:14.730
nicht mehr ganz so schnell, also nur

00:24:14.730 --> 00:24:16.970
noch, nur ein Zehntel

00:24:16.970 --> 00:24:18.190
so schnell wie der Prozessor

00:24:18.190 --> 00:24:20.510
und dann gibt es den L3 Cache bei den neuen

00:24:20.510 --> 00:24:22.730
Prozessoren, der ist vielleicht

00:24:22.730 --> 00:24:24.870
auf dem gleichen Chip, aber nicht mehr auf dem gleichen

00:24:24.870 --> 00:24:26.630
die und deshalb ist es nochmal 10

00:24:26.630 --> 00:24:27.910
mal langsamer

00:24:27.910 --> 00:24:30.590
und dann gibt es den Hauptspeicher und der ist nochmal

00:24:30.590 --> 00:24:32.050
1000 mal langsamer und

00:24:32.050 --> 00:24:38.230
Und das ist eben so ein Trick, weil man weiß, es gibt was, das heißt Data Locality.

00:24:39.070 --> 00:24:42.690
Wenn ich mit einem Datum, mit einem Datenpunkt gearbeitet habe,

00:24:42.750 --> 00:24:47.290
dann werde ich vielleicht mit Datenpunkten, die in der Nähe gespeichert sind, arbeiten.

00:24:48.090 --> 00:24:49.450
So funktionieren diese Caches.

00:24:49.450 --> 00:24:57.430
Das heißt, die speichern eine kleine Speichermenge aus dem Hauptspeicher in den Prozessor rein.

00:24:58.610 --> 00:25:02.690
Und wenn ich dann tatsächlich mit dem daneben liegenden Datenpunkt arbeiten möchte,

00:25:03.170 --> 00:25:06.170
dann habe ich da den schnelleren Zugriff, weil der schon gecached ist.

00:25:07.650 --> 00:25:11.610
Und prinzipiell, wenn man alle Leistungen aus einem Prozessor rausholen möchte,

00:25:12.090 --> 00:25:15.650
dann muss man dafür sorgen, dass der Prozessor immer nur solche Sachen bearbeitet,

00:25:15.910 --> 00:25:16.950
die schon im Cache sind.

00:25:16.970 --> 00:25:18.970
Da muss man quasi an die richtige Stelle hüpfen vorher.

00:25:19.790 --> 00:25:22.850
Da muss man, genau, da gibt es Techniken, wie du dafür sorgen kannst,

00:25:22.850 --> 00:25:27.950
dass bestimmte von diesen Cache-Lines, diese Caches sind in sogenannte Lines aufgeteilt.

00:25:28.070 --> 00:25:32.990
Das heißt, da sind immer 16 Byte drin oder 64 Byte.

00:25:33.530 --> 00:25:37.250
Also die werden natürlich größer, je weiter du nach draußen gehst.

00:25:37.270 --> 00:25:39.230
Kurz vor das Passwort, was da irgendwo im Speicher steht,

00:25:39.310 --> 00:25:40.590
möchte ich gerne springen oder kurz danach.

00:25:41.070 --> 00:25:43.970
Ja, wenn du das versehentlich in den Cache lernst, ist auch schlecht.

00:25:45.290 --> 00:25:47.950
Wenn du diese Cache-Lines immer wieder überschreibst,

00:25:47.990 --> 00:25:49.470
ist schlecht, wenn du immer über die gleiche Cache-Line.

00:25:49.770 --> 00:25:51.690
Aber da sind wir jetzt natürlich wesentlich näher am Prozessor,

00:25:51.750 --> 00:25:53.110
als wir mit Python je hinkommen.

00:25:55.510 --> 00:26:13.530
Das Wichtige an der Stelle zu wissen ist, dass wenn wir im Hauptspeicher hin und her springen, dann ist das potenziell was sehr Langsames, weil dieser Hauptspeicher erst in den Prozessor reingeholt werden muss, damit er da verarbeitet werden kann. Und das ist in Prozessorzeiten eine Ewigkeit.

00:26:13.670 --> 00:26:17.850
Also das ist das, was Assembler macht, wenn es irgendwas in den Register reinlädt.

00:26:17.850 --> 00:26:32.210
Genau, wenn du es in den Register reinleitest, das ist quasi das, was im Prozessor ganz innen drin ist, das Register-File, das ist das Schnellste, das ist in den Prozessor eingebaut und danach werden die Hierarchien, wird es in der Hierarchie immer um Faktor 10 oder 100 oder 1000 langsamer.

00:26:32.990 --> 00:26:51.230
Wenn du es jetzt also schaffst, dafür zu sorgen, dass deine Daten möglichst nah beieinander liegen, dann bedeutet das, dass wenn du die sequenziell verarbeitest, dass die dann schon näher am Prozessor dran sind und entsprechend schneller verarbeitet werden können, als wenn du für jeden Eintrag einmal in den Hauptspeicher springen musst und das komplett nah reinholen musst.

00:26:51.470 --> 00:27:13.610
Und das ist ja üblicherweise die Situation, die du hast, wenn du eine Python-Liste hast. Das ist das, weshalb diese doppelte Indirektion so langsam ist, weil du einmal zuerst die Liste der Referenzen abholen musst und dann nochmal die Referenz selbst. Und selbst wenn du da sequentiell durchgehst, können diese Second-Level-Referenzen, die können ja irgendwo liegen, wo halt gerade der Speicher hin alloziert wurde.

00:27:13.970 --> 00:27:32.610
Bei einem Array ist das aber anders. Bei einem Array liegen die Werte alle hintereinander direkt aneinander gereiht im Speicher. Das heißt, wenn du durch einen Array, durch einen Array.Array durchgehst, das sind, man muss ja auch ein bisschen vorsichtig sein, dieses Wort Array hat ja in jeder Sprache eine andere Bedeutung als in der Sprache.

00:27:32.890 --> 00:27:35.010
Wir sprechen hier jetzt von Python-Arrays.

00:27:37.890 --> 00:27:39.370
Also in Python, das Modul

00:27:39.370 --> 00:27:40.290
Array.Array

00:27:40.290 --> 00:27:43.590
enthält so eine Implementierung

00:27:43.590 --> 00:27:45.730
von einem

00:27:45.730 --> 00:27:46.950
Container, der

00:27:46.950 --> 00:27:49.230
Daten des gleichen Typs

00:27:49.230 --> 00:27:51.270
im Speicher sequenziell gepackt

00:27:51.270 --> 00:27:53.350
speichern kann. Also zum Beispiel

00:27:53.350 --> 00:27:55.090
Floats oder Integers oder

00:27:55.090 --> 00:27:56.810
andere Dinge, die man

00:27:56.810 --> 00:27:59.210
da reintun möchte. Und das

00:27:59.210 --> 00:28:01.270
hat den Vorteil, dass wenn ich da sequenziell durchgehe,

00:28:01.790 --> 00:28:05.510
dass die dann prinzipiell mehr der Prozessorarchitektur entsprechen,

00:28:06.290 --> 00:28:07.990
dass ich nichts Interaktionslevel habe,

00:28:08.150 --> 00:28:11.070
dass ich die eventuell schon im Cache bereitliegen habe,

00:28:11.130 --> 00:28:11.930
wenn ich sie verarbeite.

00:28:12.510 --> 00:28:17.790
Und so, wenn ich eben numerische Datenverarbeitung machen möchte,

00:28:17.790 --> 00:28:20.250
kann das sein, dass das ein extremer Speed-Up ist.

00:28:20.750 --> 00:28:22.970
Aber es geht nur für numerische Daten?

00:28:23.810 --> 00:28:27.130
Nö, aber was letztlich da drin ist, das weißt du ja nicht.

00:28:27.390 --> 00:28:28.690
Also was heißt numerische Daten?

00:28:28.990 --> 00:28:29.990
Das muss eine feste Größe sein.

00:28:30.990 --> 00:28:34.510
Ja, aber auch wenn jetzt da, gut, kommt halt drauf an, was,

00:28:34.570 --> 00:28:36.070
aber das kann ja auch irgendwas anderes bedeuten.

00:28:36.170 --> 00:28:39.110
Das kann ja Text sein oder, also, hm.

00:28:41.270 --> 00:28:43.930
Okay, aber bei Text bedeutet das dann halt Immutability.

00:28:45.810 --> 00:28:47.670
Also, weil die Repräsentation des Textes halt Zahlen,

00:28:47.770 --> 00:28:49.070
immer derselbe Text ist.

00:28:49.070 --> 00:28:53.070
Sie sind auch immutable, aber ich würde mal, zum Beispiel,

00:28:53.170 --> 00:28:54.710
Ich habe mal eine

00:28:54.710 --> 00:28:56.170
Array

00:28:56.170 --> 00:29:00.430
Geschichte benutzt in

00:29:00.430 --> 00:29:01.490
Cyclet Learn bei dem

00:29:01.490 --> 00:29:02.890
Tokenizer,

00:29:04.530 --> 00:29:05.610
also bei dem

00:29:05.610 --> 00:29:07.490
TF-IDF-Vectorizer

00:29:07.490 --> 00:29:09.890
und da waren es dann halt

00:29:09.890 --> 00:29:11.870
IDs von, also die

00:29:11.870 --> 00:29:14.250
Nummer

00:29:14.250 --> 00:29:15.210
von einem Token.

00:29:15.870 --> 00:29:16.890
Das ist ja dann nur eine Nummer.

00:29:18.130 --> 00:29:20.610
Und die kann man ja auch in Arrays packen.

00:29:21.290 --> 00:29:22.050
Ja, oder Booleans,

00:29:22.190 --> 00:29:23.950
Arrays von Booleans. Ja, das geht ja auch.

00:29:24.790 --> 00:29:26.170
Also die Frage ist, sind das jetzt

00:29:26.170 --> 00:29:27.550
numerische Daten? Ich weiß nicht, also

00:29:27.550 --> 00:29:30.150
was die Daten bedeuten. Also klar,

00:29:30.230 --> 00:29:32.230
es muss natürlich irgendwie was Fixes

00:29:32.230 --> 00:29:34.130
sein, aber, und ach so, das kann

00:29:34.130 --> 00:29:35.890
auch anders strukturiert sein. Das ist jetzt,

00:29:36.370 --> 00:29:37.610
weiß ich gar nicht, ob das mit

00:29:37.610 --> 00:29:40.050
Array-Array geht, ob das

00:29:40.050 --> 00:29:41.350
sehr viele kompliziertere

00:29:41.350 --> 00:29:43.950
Struktur haben kann, aber

00:29:43.950 --> 00:29:46.170
es gibt allgemein Memory Views

00:29:46.170 --> 00:29:48.090
und die sind halt dafür da, dass

00:29:48.090 --> 00:29:49.950
du halt diese Daten irgendwie

00:29:49.950 --> 00:29:52.230
rumschieben kannst und

00:29:52.230 --> 00:29:54.310
du kannst da halt einen anderen Header davor

00:29:54.310 --> 00:29:56.550
setzen, zum Beispiel mit einem NumPy

00:29:56.550 --> 00:29:58.910
oder so und dann ist das plötzlich ein mehrdimensionales

00:29:58.910 --> 00:30:00.470
Array oder halt irgendwie eine Matrix

00:30:00.470 --> 00:30:02.390
oder sowas. Oder du kannst halt

00:30:02.390 --> 00:30:04.150
und Transformationen,

00:30:04.630 --> 00:30:06.530
wenn du jetzt sagst, okay, ich möchte das jetzt einmal

00:30:06.530 --> 00:30:09.010
kippen

00:30:09.010 --> 00:30:10.170
oder irgendwie

00:30:10.170 --> 00:30:12.630
transposen

00:30:12.630 --> 00:30:14.430
oder was auch immer, dann sind das

00:30:14.430 --> 00:30:16.570
Operationen, die nur den Header betreffen, aber nicht

00:30:16.570 --> 00:30:18.470
die Daten selber. Also die Daten bleiben halt so liegen,

00:30:18.610 --> 00:30:20.370
wie sie da so sind, halt im Hauptspeicher.

00:30:21.190 --> 00:30:22.450
Ja. Wobei Transposition,

00:30:22.670 --> 00:30:24.550
Jochen, ist ja auch sowas Gefährliches. Dann hast du wieder,

00:30:25.870 --> 00:30:26.450
wenn du den

00:30:26.450 --> 00:30:28.410
Speicher dann nicht auch transponierst, dann hast du

00:30:28.410 --> 00:30:30.590
wieder schlechte Speicherzugriffspattern.

00:30:30.670 --> 00:30:32.270
Ja, ja, das kann natürlich dann

00:30:32.270 --> 00:30:34.290
blöde Konsequenzen haben, wenn man dann halt

00:30:34.290 --> 00:30:35.790
irgendwas Blödes damit macht, dann ja.

00:30:36.890 --> 00:30:38.590
Ja, gut, ich kann mit jeder Programmiersprache

00:30:38.590 --> 00:30:40.210
schlechte Programme schreiben, das ist gar kein Problem.

00:30:40.470 --> 00:30:40.570
Ja.

00:30:42.490 --> 00:30:44.450
Nee, ich meine, okay, aber da bist du

00:30:44.450 --> 00:30:46.010
jetzt schon einen Schritt weiter, ja. Also Array

00:30:46.010 --> 00:30:48.490
ist das schon, ist ja noch

00:30:48.490 --> 00:30:50.490
da übernimmt Python noch so ein bisschen das Management für dich,

00:30:50.570 --> 00:30:51.950
aber bei MemoryView ist ja hier

00:30:51.950 --> 00:30:54.790
eine Sequenz von Bytes, die im Hauptspeicher

00:30:54.790 --> 00:30:55.430
liegen. Genau.

00:30:56.170 --> 00:30:57.190
Mach damit, was du willst.

00:30:58.510 --> 00:31:00.430
Und da bist du wieder direkt einen Schritt

00:31:00.430 --> 00:31:02.070
weiter in Richtung Performance.

00:31:02.710 --> 00:31:03.350
Potenziell, ja.

00:31:04.030 --> 00:31:06.470
Man kann alle Werkzeuge wenden, um langsame Programme zu

00:31:06.470 --> 00:31:06.690
schreiben.

00:31:08.310 --> 00:31:10.370
Bist du einen Schritt weiter in Richtung Performance

00:31:10.370 --> 00:31:12.670
und einen Schritt weiter weg von Komfort.

00:31:13.650 --> 00:31:14.490
Weil du dich halt

00:31:14.490 --> 00:31:15.270
selber drum kümmern musst.

00:31:16.750 --> 00:31:18.190
Aber dafür kannst du prinzipiell so

00:31:18.190 --> 00:31:20.310
Tricks malen, dass du den Header veränderst oder

00:31:20.310 --> 00:31:22.330
dass du nur irgendwelche Sachen

00:31:22.330 --> 00:31:24.230
innen drin veränderst oder dass du, keine Ahnung,

00:31:24.690 --> 00:31:26.190
je nachdem, was das Problem halt erfordert.

00:31:27.550 --> 00:31:27.870
Machst.

00:31:28.730 --> 00:31:30.070
Ja, jetzt sind wir wirklich schon ganz tief

00:31:30.070 --> 00:31:32.250
in dem Abschluss des Kapitels,

00:31:32.430 --> 00:31:33.890
nämlich der Abschluss des Kapitels heißt

00:31:33.890 --> 00:31:36.370
When a list

00:31:36.370 --> 00:31:37.390
is not the answer.

00:31:38.390 --> 00:31:40.410
Der Hauptteil des Kapitels

00:31:40.410 --> 00:31:42.350
beschäftigt

00:31:42.350 --> 00:31:44.170
sich ja schon mit Listen, ja, und da gibt's,

00:31:44.250 --> 00:31:45.610
also es sind wirklich schöne Sachen drin.

00:31:46.230 --> 00:31:47.510
Wusstet ihr das mal auf Slices?

00:31:48.190 --> 00:31:50.410
assignen kann. Oh ja, ja, das ist cool.

00:31:50.890 --> 00:31:51.890
Das ist ein Trick, den ich

00:31:51.890 --> 00:31:52.970
nicht so, also

00:31:52.970 --> 00:31:56.090
den ich nicht kannte, den ich nicht wusste, dass das geht.

00:31:56.810 --> 00:31:57.930
Was meinst du mit nice assign?

00:31:58.170 --> 00:31:59.170
Vielleicht müssen wir das kurz erklären.

00:32:00.030 --> 00:32:01.110
Ja, also wenn ich eine Liste habe,

00:32:02.150 --> 00:32:03.810
dann kann ich mir da ja einen Slice rausholen.

00:32:03.930 --> 00:32:05.830
Also wenn ich eine Liste mit zehn Elementen habe, kann ich sagen, ich möchte

00:32:05.830 --> 00:32:07.470
Element drei bis vier.

00:32:08.810 --> 00:32:10.170
Das ist dann diese Doppelpunkt

00:32:10.170 --> 00:32:12.030
Notation und dann kriege ich da eben so eine

00:32:12.030 --> 00:32:12.750
Subliste raus.

00:32:14.430 --> 00:32:14.910
Und

00:32:14.910 --> 00:32:16.270
diese Subliste

00:32:16.270 --> 00:32:26.390
Die ist mutable. Und die bezieht sich auf die Elemente, die in dieser ursprünglichen Liste drin waren.

00:32:26.410 --> 00:32:29.250
Also wie ein View auf diese Liste an der Stelle.

00:32:29.710 --> 00:32:34.190
Ja, so ein bisschen, aber noch mehr.

00:32:37.910 --> 00:32:45.590
Also wenn ich jetzt hier so einen Slice raushole aus dieser Liste. Nehmen wir mal an, ich habe eine Liste, das ist jetzt hier im Beispiel drin, Seite 50, falls jemand mitlesen möchte.

00:32:46.270 --> 00:32:48.930
da ist eine Liste,

00:32:49.410 --> 00:32:50.970
das ist eine Liste von Range von 10, also es sind

00:32:50.970 --> 00:32:52.950
Elemente 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

00:32:52.950 --> 00:32:55.010
drin. Und da hole ich

00:32:55.010 --> 00:32:57.230
mir jetzt einen Slice raus,

00:32:58.290 --> 00:32:58.910
Index 2,

00:32:58.990 --> 00:32:59.650
Doppelpunkt 5.

00:33:00.690 --> 00:33:02.830
Das sind drei Elemente, die ich hier raushole,

00:33:02.950 --> 00:33:04.770
2, 3 und 4. Und

00:33:04.770 --> 00:33:06.950
da mache ich jetzt eine

00:33:06.950 --> 00:33:08.530
Zuweisung auf diesen Slice. Also ich sage

00:33:08.530 --> 00:33:11.010
L Slice

00:33:11.010 --> 00:33:12.490
2 bis 5 ist gleich

00:33:12.490 --> 00:33:14.710
und hier in dem Beispiel ist es jetzt

00:33:14.710 --> 00:33:17.030
20,30, also eine Liste mit nur

00:33:17.030 --> 00:33:17.950
zwei Elementen.

00:33:18.790 --> 00:33:19.970
Dann habe ich

00:33:19.970 --> 00:33:22.930
aus dieser Liste was rausgeschnitten und dann

00:33:22.930 --> 00:33:24.790
die Stelle, an der das vorher drin stand,

00:33:24.870 --> 00:33:25.710
was anderes reingeschrieben.

00:33:26.910 --> 00:33:28.890
Und das wusste ich nicht, dass es geht. Das wusste ich

00:33:28.890 --> 00:33:31.050
nicht, dass man da so

00:33:31.050 --> 00:33:32.390
Operationen drauf machen kann.

00:33:32.770 --> 00:33:33.590
Slices quasi,

00:33:35.350 --> 00:33:36.950
also ganze Slices

00:33:36.950 --> 00:33:38.930
ersetzen kann. Man kann es aber rückwärts machen.

00:33:39.950 --> 00:33:40.910
Man kann auch einen Slice

00:33:40.910 --> 00:33:42.730
löschen. Das nächste Beispiel ist Dell

00:33:42.730 --> 00:33:45.430
und dann hast du in der Mitte was rausgelöscht.

00:33:46.290 --> 00:33:47.030
Super interessant.

00:33:47.030 --> 00:33:49.150
Tatsächlich, da wäre ich auch nie auf die Idee

00:33:49.150 --> 00:33:50.670
gekommen, das zu machen.

00:33:51.410 --> 00:33:53.090
Aber es wird noch schlimmer, Jochen, es wird noch schlimmer.

00:33:53.530 --> 00:33:54.910
Das nächste Beispiel ist ein Slice,

00:33:55.530 --> 00:33:56.350
der einen Step hat.

00:33:56.630 --> 00:33:57.890
Oh Gott, oh Gott, oh Gott.

00:33:58.770 --> 00:34:00.610
Und wenn du auch den zuweist,

00:34:00.930 --> 00:34:02.730
dann werden halt die Elemente ersetzt,

00:34:03.390 --> 00:34:04.110
die diesen Step

00:34:04.110 --> 00:34:05.850
abbilden.

00:34:08.230 --> 00:34:09.230
Also jedes

00:34:09.230 --> 00:34:10.670
gerade Element kannst du ersetzen.

00:34:11.190 --> 00:34:12.110
Mit einer Zuweisung.

00:34:12.730 --> 00:34:13.170
Ja.

00:34:13.950 --> 00:34:14.650
Wusste ich nicht.

00:34:15.490 --> 00:34:17.370
Okay, nee, das war mir jetzt auch nicht, dass das,

00:34:18.230 --> 00:34:19.370
da kann man auch, also

00:34:19.370 --> 00:34:21.210
da, also

00:34:21.210 --> 00:34:22.930
ja.

00:34:23.170 --> 00:34:25.110
Wo wir bei Dingen, die wusste ich nicht waren, da habe ich ja auch

00:34:25.110 --> 00:34:27.330
irgendwas rausgefunden, zwar, dass man halt Dinge direkt

00:34:27.330 --> 00:34:29.390
assignen kann, wenn zum Beispiel eine Liste mit einem Element

00:34:29.390 --> 00:34:31.410
rumkommt, hat Jochen

00:34:31.410 --> 00:34:32.410
gesagt, der benutzt das ständig,

00:34:33.610 --> 00:34:35.050
aber wenn irgendwo eine Liste,

00:34:35.170 --> 00:34:37.330
man will das an den Event haben, dann machen

00:34:37.330 --> 00:34:39.290
oft ja die Leute Index 0, aber man kann einfach

00:34:39.290 --> 00:34:41.430
das assignen zu einem Ding, was in der Gegend dransteht.

00:34:41.810 --> 00:34:43.510
Genau, man macht vorher RG-Klammer auf,

00:34:43.630 --> 00:34:45.810
irgendwie das Element, gibt dem Namen RG-Klammer

00:34:45.810 --> 00:34:47.770
wieder zu. Ich habe das oft in Tests

00:34:47.770 --> 00:34:49.590
oder so, wenn ich weiß, also da kann halt

00:34:49.590 --> 00:34:51.550
nicht mehr drin sein als dieses eine Ding,

00:34:52.270 --> 00:34:53.950
dann mache ich das halt so.

00:34:54.890 --> 00:34:55.150
Okay.

00:34:55.410 --> 00:34:56.790
Das mache ich immer mit Index 0.

00:34:57.170 --> 00:34:58.290
Ja, aber

00:34:58.290 --> 00:35:00.570
das Problem ist,

00:35:01.030 --> 00:35:03.750
wenn das jetzt unerwarteterweise

00:35:03.750 --> 00:35:05.750
aber was anderes zurückgeben sollte,

00:35:05.870 --> 00:35:07.710
was nicht nur dieses eine Ding hat, sondern halt

00:35:07.710 --> 00:35:09.850
vielleicht 5, dann fällt das bei dir halt

00:35:09.850 --> 00:35:11.610
sind, dann kriegst du da... Ich krieg keine

00:35:11.610 --> 00:35:13.510
Fehlermente. Du kriegst einen Index-Error, aber ich krieg

00:35:13.510 --> 00:35:15.570
einen Value-Error. Nee, ich krieg keinen Index-Error. Ich krieg

00:35:15.570 --> 00:35:17.610
nur einen... Es kann halt sein,

00:35:17.690 --> 00:35:19.550
dass es weiter funktioniert. Ja, nur wenn es die 0 nicht gibt.

00:35:19.730 --> 00:35:21.550
Okay, ja. Genau. Du kriegst nur einen Fehler, wenn

00:35:21.550 --> 00:35:23.410
es die 0 nicht gibt. Und die 0 gibt es ja eigentlich immer.

00:35:24.110 --> 00:35:25.610
Genau, aber unter anderem ist es halt Value-Error,

00:35:25.690 --> 00:35:28.030
weil das Element irgendwie nicht...

00:35:28.030 --> 00:35:29.550
Die Liste nicht das eine Element nur enthält,

00:35:29.610 --> 00:35:30.970
sondern irgendwas anderes. Ja.

00:35:31.850 --> 00:35:33.830
Ein Unpacking-Error, das ist doch

00:35:33.830 --> 00:35:35.050
schön, oder? Ja.

00:35:36.310 --> 00:35:37.610
Ja, also dieses

00:35:37.610 --> 00:35:39.610
Kapitel, wie gesagt, das ganze

00:35:39.610 --> 00:35:41.550
Buch ist ja tatsächlich so, dass es sich nicht direkt

00:35:41.550 --> 00:35:42.550
an, sag ich mal,

00:35:43.370 --> 00:35:45.430
blutige Einsteiger

00:35:45.430 --> 00:35:47.490
richtet, sondern es ist schon so, du hast die

00:35:47.490 --> 00:35:49.290
Basics drauf, hier sind so ein paar Kniffe,

00:35:49.470 --> 00:35:50.450
jetzt hier so geht es auch.

00:35:51.310 --> 00:35:52.650
Und das ist doch schön,

00:35:53.110 --> 00:35:55.310
dass man auch hier so Veteranen wie uns noch

00:35:55.310 --> 00:35:57.150
damit überraschen kann.

00:35:57.150 --> 00:36:01.450
Mit Sachen aus dem

00:36:01.450 --> 00:36:02.030
puren Standard,

00:36:02.150 --> 00:36:03.650
aus dem puren Python-Standard.

00:36:04.190 --> 00:36:04.870
Hier übrigens,

00:36:05.190 --> 00:36:07.110
Assigning to Slices. Was?

00:36:08.690 --> 00:36:08.890
Ja.

00:36:09.610 --> 00:36:19.350
Ne, gut, vielleicht mag das auch der Grund sein, warum ich das Buch echt gerne lese, weil man kann kaum irgendwie eine Seite oder zwei lesen, ohne dass man sich denkt, ach, echt interessant, das wusste ich jetzt gar nicht.

00:36:20.090 --> 00:36:22.010
Und ja, das ist halt, das macht es irgendwie.

00:36:22.010 --> 00:36:24.550
Ja, dann guckt er sich den Bytecode an und sagt, ja, ha, ha, ha.

00:36:27.850 --> 00:36:29.750
auch was ich auch gut, das ist jetzt nochmal ganz am Anfang

00:36:29.750 --> 00:36:31.950
von dem Kapitel, was ich auch super fand, ist, dass er

00:36:31.950 --> 00:36:33.350
halt, das ist auch so etwas,

00:36:34.250 --> 00:36:35.030
wo ich denke,

00:36:35.410 --> 00:36:37.890
ja, das ist so, aber ich traue mich

00:36:37.890 --> 00:36:39.590
manchmal nicht so richtig, das laut zu sagen, weil

00:36:39.590 --> 00:36:40.110
irgendwie

00:36:40.110 --> 00:36:43.850
die Prophezeiung

00:36:43.850 --> 00:36:45.290
irgendwie vorsieht, dass

00:36:45.290 --> 00:36:47.470
Vorschleifen lesbarer sind als

00:36:47.470 --> 00:36:49.830
List-Comprehensions, aber ich denke gerade bei einfachen

00:36:49.830 --> 00:36:51.510
Fällen sind List-Comprehensions tatsächlich

00:36:51.510 --> 00:36:53.670
besser lesbar und hier hat er halt ein

00:36:53.670 --> 00:36:55.750
schönes Beispiel, wo er halt quasi

00:36:55.750 --> 00:36:57.190
den, die

00:36:57.190 --> 00:36:59.150
die den Zahlenwert

00:36:59.150 --> 00:37:00.850
von einem ASCII-Zeichen

00:37:00.850 --> 00:37:03.090
aus einem String halt

00:37:03.090 --> 00:37:05.030
rausnimmt. Und wenn du das halt

00:37:05.030 --> 00:37:06.990
in der Vorschleife machst, also einmal sind halt doppelt

00:37:06.990 --> 00:37:08.670
so viele Zeilen und dann ist es halt so, dass

00:37:08.670 --> 00:37:10.230
irgendwie der

00:37:10.230 --> 00:37:12.710
entscheidende Aufruf, der dir sagt, was passiert, der ist

00:37:12.710 --> 00:37:15.030
halt irgendwie relativ weit irgendwie reingenestet

00:37:15.030 --> 00:37:17.110
und der fällt dir stichend nicht sofort ins Auge.

00:37:17.470 --> 00:37:19.010
Während die List Comprehension, da siehst du

00:37:19.010 --> 00:37:20.990
halt sofort, was passiert. Ja, also ich bin auch

00:37:20.990 --> 00:37:22.810
ein großer Fan von schönen Comprehensions.

00:37:23.270 --> 00:37:24.930
Ja, klar, man kann damit natürlich böses

00:37:24.930 --> 00:37:26.970
Wir hatten schon mal eine Unterhaltung, Jochen,

00:37:27.070 --> 00:37:28.910
wo du die anderen Meinungen warst, aber

00:37:28.910 --> 00:37:30.570
es kommt halt drauf an.

00:37:30.650 --> 00:37:31.310
Es kommt drauf an, genau.

00:37:33.310 --> 00:37:35.310
Hohoho, sind wir hier unter die Juristen

00:37:35.310 --> 00:37:36.370
gegangen, es kommt drauf an.

00:37:37.670 --> 00:37:38.730
Es ist aber doch wirklich so.

00:37:39.250 --> 00:37:40.930
Wir wollen definitive Antworten.

00:37:41.190 --> 00:37:42.830
Comprehensions sind schön peisonic,

00:37:42.930 --> 00:37:45.010
in vielen Fällen sind sie einfach das Syntax

00:37:45.010 --> 00:37:47.010
sogar schönere, als jetzt

00:37:47.010 --> 00:37:48.890
eine Vorschleife zu machen, es sei denn,

00:37:48.950 --> 00:37:50.670
man möchte bestimmte Dinge tun, wo dann

00:37:50.670 --> 00:37:52.470
Vorloop explizit angebracht ist.

00:37:53.210 --> 00:37:54.790
Das ist eins, was normalerweise ein bisschen komisch ist.

00:37:54.930 --> 00:37:57.870
Nicht nur List Comprehensions, auch Dict Comprehensions

00:37:57.870 --> 00:37:58.870
und Set Comprehensions.

00:37:58.990 --> 00:38:01.570
Ja, aber auch da, manchmal ist es ein bisschen so,

00:38:03.250 --> 00:38:04.830
manchmal, gerade dann, wenn man gucken will,

00:38:04.850 --> 00:38:06.070
wie langsam irgendwas werden kann,

00:38:06.070 --> 00:38:08.250
wenn man solche Sachen nestet hat oder sowas,

00:38:08.770 --> 00:38:09.910
dann könnte es sein, dass das so

00:38:09.910 --> 00:38:11.770
ein bisschen Sachen versteckt, weil er nicht explizit fünfmal

00:38:11.770 --> 00:38:13.830
vorsteht und man fünfmal vorzählt oder

00:38:13.830 --> 00:38:15.910
die nested levels und

00:38:15.910 --> 00:38:17.950
dann sieht man, da könnte irgendwas kaputt sein

00:38:17.950 --> 00:38:18.270
oder so.

00:38:19.710 --> 00:38:21.770
Ja, wobei ich versuche ja so nested

00:38:21.770 --> 00:38:23.770
Comprehensions versuche ich eigentlich zu vermeiden. Die mache ich dann

00:38:23.770 --> 00:38:25.450
lieber untereinander, wenn es geht.

00:38:26.510 --> 00:38:27.750
Ja, wobei er hat hier auch

00:38:27.750 --> 00:38:29.930
ein schönes Beispiel für ein Ding, wo man

00:38:29.930 --> 00:38:31.830
das nesten will und

00:38:31.830 --> 00:38:33.750
wo es Sinn macht, das so

00:38:33.750 --> 00:38:35.970
hinzuschreiben, weil bei der List Comprehension

00:38:35.970 --> 00:38:37.610
hast du ja immer, also naja,

00:38:37.730 --> 00:38:39.210
das ist Fluch und Segen zugleich.

00:38:39.730 --> 00:38:41.190
es baut dir halt eine Liste zusammen.

00:38:42.130 --> 00:38:43.390
Und der

00:38:43.390 --> 00:38:45.510
Nachteil bei einer Liste ist, sie muss halt

00:38:45.510 --> 00:38:47.370
irgendwie da sein, sie muss halt irgendwie

00:38:47.370 --> 00:38:49.530
materialisiert sein. Und jetzt hat er hier

00:38:49.530 --> 00:38:51.610
zum Beispiel diese, was ist das eigentlich?

00:38:51.610 --> 00:38:53.330
Den Trick, Moment, ganz, ganz kurz, den Trick, den du gerade

00:38:53.330 --> 00:38:55.490
überflogen hast, den fand ich auch sehr, sehr schön, wo er

00:38:55.490 --> 00:38:57.450
innerhalb von der List Comprehension noch eine

00:38:57.450 --> 00:38:59.510
Assignment Expression baut, die

00:38:59.510 --> 00:39:01.310
dann tatsächlich genau dem letzten

00:39:01.310 --> 00:39:03.550
Element spricht, wenn

00:39:03.550 --> 00:39:05.510
du da irgendwas berechnest. Ja, das ist auch so ein

00:39:05.510 --> 00:39:07.510
Quirk, also normalerweise

00:39:07.510 --> 00:39:09.670
haben die ihren eigenen Scope, das heißt, wenn du halt da

00:39:09.670 --> 00:39:12.170
irgendwie so einen lokalen Namen für irgendwas

00:39:12.170 --> 00:39:13.750
hast. Da wird halt jedes Mal wieder überschrieben bei jedem.

00:39:14.010 --> 00:39:16.290
Nee, da passiert normalerweise gar nichts.

00:39:16.310 --> 00:39:17.330
Da gab es doch auch einen Bug, oder? In der Python-Version.

00:39:17.410 --> 00:39:19.950
Ich weiß nicht, ob das ein Bug ist oder nicht,

00:39:19.950 --> 00:39:22.330
aber normalerweise

00:39:22.330 --> 00:39:24.230
ist alles so, wie man das erwarten würde.

00:39:24.830 --> 00:39:26.010
Aber wenn man jetzt nicht

00:39:26.010 --> 00:39:27.290
irgendwie gleich sagt oder

00:39:27.290 --> 00:39:29.830
nicht einfach nur die Variable

00:39:29.830 --> 00:39:31.390
verwendet, sondern man sagt halt

00:39:31.390 --> 00:39:33.210
Doppelpunkt gleich irgendwas,

00:39:34.370 --> 00:39:35.970
dann ist man aus dem Scope raus

00:39:35.970 --> 00:39:38.030
und dann ist man in dem Scope von dem

00:39:38.030 --> 00:39:40.590
von dem Ding drum rum und dann

00:39:40.590 --> 00:39:42.590
passieren unerwartete Sachen, weil dann überschreibt das

00:39:42.590 --> 00:39:44.690
halt eventuell Sachen, die halt im Scope außenrum sind

00:39:44.690 --> 00:39:45.710
und ja.

00:39:47.250 --> 00:39:48.590
Naja, aber vielleicht will man das ja machen.

00:39:49.190 --> 00:39:50.390
Ja, vielleicht muss man.

00:39:51.470 --> 00:39:51.830
Vielleicht.

00:39:52.150 --> 00:39:53.650
Ja, aber das Beispiel da ist zum Beispiel super.

00:39:53.970 --> 00:39:55.830
Dominik schreibt kein Python, sondern obfuscated Python.

00:39:56.250 --> 00:39:58.450
Nein, aber das Letzte, was da steht,

00:39:58.550 --> 00:40:00.290
das ist da zum Beispiel ein total tolles Beispiel,

00:40:00.430 --> 00:40:01.710
weil du hast so irgendwie so eine Disconvention,

00:40:01.850 --> 00:40:03.770
du wirst wissen, war das die letzte Addition davon,

00:40:03.770 --> 00:40:05.650
war der letzte Aufwand der Funktion und

00:40:05.650 --> 00:40:07.750
dann kannst du halt einfach dann Assignment Expression und dann hast

00:40:07.750 --> 00:40:09.510
du den einfach direkt und kannst den Slot schreiben

00:40:09.510 --> 00:40:12.030
oder so, oder was du auch immer damit machen willst.

00:40:12.110 --> 00:40:13.710
Ja, okay. Assignment Expression

00:40:13.710 --> 00:40:15.450
ist Walrus-Operator, oder?

00:40:15.450 --> 00:40:17.690
Ja, genau. Ja, klar, das kannst

00:40:17.690 --> 00:40:19.550
du natürlich schon so machen, aber du hast dann

00:40:19.550 --> 00:40:21.770
hoffentlich keine Variable im Code

00:40:21.770 --> 00:40:23.450
vorher verwendet, die irgendwie Last heißt, ansonsten

00:40:23.450 --> 00:40:25.530
hast du den Fuß geschossen. Ja, das sollte man

00:40:25.530 --> 00:40:28.010
da tatsächlich eh nicht tun, oder? Also

00:40:28.010 --> 00:40:29.630
dass man davon ausgeht,

00:40:29.690 --> 00:40:31.590
dass dann irgendeine Variable in der Lisk-Comprehension

00:40:31.590 --> 00:40:33.550
die Sachen alle wieder vergessen werden,

00:40:33.710 --> 00:40:35.590
ja, naja. Ja, normalerweise ist

00:40:35.590 --> 00:40:37.590
das so. Ja, aber gut, aber da steht halt auch dann gleich drin.

00:40:37.750 --> 00:40:41.510
Ja, aber da geht es aber auch

00:40:41.510 --> 00:40:43.470
relativ lange drum in dem Kapitel, dass man da hier

00:40:43.470 --> 00:40:45.630
diese Reihenfolge, dass das manchmal überraschend ist

00:40:45.630 --> 00:40:48.030
und dass die manchmal...

00:40:48.030 --> 00:40:49.550
Also ja, genau, ich mag auch dann so

00:40:49.550 --> 00:40:51.390
Bedingungen, die können wir auch untereinander schreiben,

00:40:51.490 --> 00:40:52.050
wie fest dies, das.

00:40:53.750 --> 00:40:55.250
Aber ja, schönes

00:40:55.250 --> 00:40:56.830
Peißen, würde ich sagen.

00:40:57.350 --> 00:40:59.210
Genau, ich wollte nochmal kurz zurück zu dem,

00:40:59.670 --> 00:41:01.350
also wo braucht man eventuell so

00:41:01.350 --> 00:41:03.130
eine nested, also doppelt

00:41:03.130 --> 00:41:04.590
Vorloop irgendwie Geschichte

00:41:04.590 --> 00:41:07.230
und wo kann es Sinn machen, da

00:41:07.230 --> 00:41:09.390
eben das halt so

00:41:09.390 --> 00:41:10.670
hinzuschreiben und nicht in den For-Loop.

00:41:11.470 --> 00:41:13.290
Wenn die Dimensionalität der Daten

00:41:13.290 --> 00:41:15.150
das übersteigt, was man in einer

00:41:15.150 --> 00:41:16.630
einzigen Spalte darstellen kann?

00:41:17.110 --> 00:41:18.250
Also wenn man Relations hat?

00:41:19.030 --> 00:41:20.570
Ja, oder er nimmt hier als Beispiel

00:41:20.570 --> 00:41:22.810
ein kathesisches Produkt von irgendwie zwei

00:41:22.810 --> 00:41:25.310
Iterables oder Sequences vielleicht

00:41:25.310 --> 00:41:27.210
und wenn

00:41:27.210 --> 00:41:29.010
du das halt in der Vorschleife machen willst, dann brauchst du

00:41:29.010 --> 00:41:31.010
ja was, das du iterieren kannst und dann

00:41:31.010 --> 00:41:33.050
musst du das halt in eine Liste packen und wenn

00:41:33.050 --> 00:41:35.050
das halt fünf Zeilen, fünf Spalten

00:41:35.050 --> 00:41:36.890
sind, dann ist das halt wenig, aber

00:41:36.890 --> 00:41:39.210
wenn du jetzt tausend Zeilen und tausend

00:41:39.210 --> 00:41:40.470
Spalten hast, dann ist das plötzlich

00:41:40.470 --> 00:41:43.290
wahnsinnig viel und dann willst du das halt nicht

00:41:43.290 --> 00:41:45.250
irgendwo hinspeichern.

00:41:45.530 --> 00:41:47.070
Also gerade wenn du dich eigentlich nur diese

00:41:47.070 --> 00:41:49.310
du hast jetzt tausend von der Sorte und tausend von der Sorte

00:41:49.310 --> 00:41:51.290
das ist das, was dich eigentlich interessiert. Das musst du

00:41:51.290 --> 00:41:53.310
auch irgendwo speichern, aber das kathesische Produkt

00:41:53.310 --> 00:41:55.390
davon eigentlich nicht. Dann geht

00:41:55.390 --> 00:41:57.290
das mit einer Vorschleife eigentlich gar nicht so gut, wenn

00:41:57.290 --> 00:41:59.270
du nicht dieses Produkt

00:41:59.270 --> 00:42:01.250
materialisiert irgendwie rumliegen haben willst.

00:42:02.170 --> 00:42:03.230
Und was er dann

00:42:03.230 --> 00:42:05.150
macht, ist eine Generator Expression, die

00:42:05.150 --> 00:42:06.910
halt so eine doppelte Vorschleife drin hat

00:42:06.910 --> 00:42:09.190
und das ist natürlich cool, weil

00:42:09.190 --> 00:42:11.290
die erzeugt nämlich, das verbraucht gar kein

00:42:11.290 --> 00:42:13.230
Hauptspeicher, sondern das generiert ja einfach

00:42:13.230 --> 00:42:14.370
nur das synthetische Produkt.

00:42:14.410 --> 00:42:16.330
Wenn du einen Generator halt hast. Genau, genau.

00:42:16.870 --> 00:42:19.030
Und den kannst du ja den Generator dann als

00:42:19.030 --> 00:42:21.050
Generator-Expression schreiben und dann

00:42:21.050 --> 00:42:25.030
Was ist denn der Unterschied, Jochen? Wie schreibt man denn

00:42:25.030 --> 00:42:27.170
eine Generator-Expression im Vergleich zu einer List-Compressor?

00:42:27.170 --> 00:42:28.890
Das muss doch was ganz anderes sein, oder?

00:42:28.910 --> 00:42:31.050
Runde-Klammern. Das Gleiche ist halt bloß eine Runde-Klammer, genau.

00:42:31.810 --> 00:42:33.130
Ja. Das ist auch eine Falle,

00:42:33.190 --> 00:42:34.710
in die man leicht tappen kann.

00:42:35.150 --> 00:42:37.250
dass man runde Klammer

00:42:37.250 --> 00:42:39.110
macht und das sieht erstmal so aus

00:42:39.110 --> 00:42:40.990
und das funktioniert auch in vielen Fällen so ähnlich.

00:42:41.650 --> 00:42:43.270
Nur wenn man es dann nochmal verwenden möchte,

00:42:43.390 --> 00:42:43.950
ist es leider weg.

00:42:45.650 --> 00:42:46.490
Genau, das ist

00:42:46.490 --> 00:42:49.070
ein überraschender Anlass. Also ich meine, meistens ist wahrscheinlich

00:42:49.070 --> 00:42:51.030
List Comprehension auch tatsächlich das, was man haben möchte.

00:42:51.770 --> 00:42:52.610
Aber ja.

00:42:53.130 --> 00:42:55.270
Ich würde gerne noch da ein paar Fragen

00:42:55.270 --> 00:42:56.630
zu stellen und so ein bisschen zu wissen,

00:42:57.090 --> 00:42:59.050
wann man welche Dinge denn benutzt. Und ich würde sagen,

00:42:59.150 --> 00:43:01.210
Generator Expression im Vergleich

00:43:01.210 --> 00:43:02.910
zu List Comprehension, wann ich eine Liste nehme,

00:43:03.030 --> 00:43:04.950
wann nehme ich ein Array, wann nehme ich

00:43:04.950 --> 00:43:07.050
Collections DQ, diese ganzen Dinge

00:43:07.050 --> 00:43:09.250
so ein bisschen auseinanderzuhalten mit ihren Trade-Offs

00:43:09.250 --> 00:43:11.190
wäre vielleicht nicht ganz uninteressant

00:43:11.190 --> 00:43:12.810
in dieser Folge heute.

00:43:12.990 --> 00:43:15.030
Oh, ja, okay, also. Ja, weiß nicht.

00:43:15.710 --> 00:43:17.170
Das sind viele

00:43:17.170 --> 00:43:19.390
tiefgehende Fragen, die du da gestellt hast.

00:43:19.390 --> 00:43:21.070
Ja. Also die

00:43:21.070 --> 00:43:23.050
eine Frage kann man leicht beantworten.

00:43:23.210 --> 00:43:25.110
Du brauchst eine List Comprehension, wenn

00:43:25.110 --> 00:43:27.250
du die Daten materialisiert brauchst, also

00:43:27.250 --> 00:43:29.170
wenn du sie, wenn du drauf zugreifen willst

00:43:29.170 --> 00:43:31.130
und mehrmals drauf zugreifen willst. Und kostet aber viel

00:43:31.130 --> 00:43:33.130
Speicher. Autosequence und Indexzugriff

00:43:33.130 --> 00:43:34.930
kostet halt Speicher. Du brauchst eine

00:43:34.930 --> 00:43:36.850
Generator-Expression, wenn du sie nur einmal brauchst

00:43:36.850 --> 00:43:38.650
und nur in Reihenfolge und

00:43:38.650 --> 00:43:40.970
nicht, wenn es vielleicht zu viel ist,

00:43:41.030 --> 00:43:42.790
um es am Hauptspeicher zu halten, nicht nochmal darauf zu griffen.

00:43:42.950 --> 00:43:44.110
Und genau, wenn es zu viel ist.

00:43:44.170 --> 00:43:46.130
Dann zum Beispiel mache ich sowas wie das kathetische Produkt,

00:43:46.210 --> 00:43:49.010
dass ich die Kombination von allen Faktoren von zwei Vektoren

00:43:49.010 --> 00:43:50.770
miteinander in Beziehung setzen kann.

00:43:51.470 --> 00:43:52.850
Genau, also wenn es quasi

00:43:52.850 --> 00:43:54.250
eine Prozedur ist, die du da machst.

00:43:55.890 --> 00:43:56.890
Ja, das ist relativ

00:43:56.890 --> 00:43:58.650
leicht zu verwenden. Aber jetzt die Frage, wo

00:43:58.650 --> 00:44:00.750
benutzt du List versus Array versus

00:44:00.750 --> 00:44:02.890
Memory View? Das kann man so allgemein.

00:44:03.030 --> 00:44:05.050
Ah, da müssen wir

00:44:05.050 --> 00:44:06.950
länger drüber sprechen. Und wenn du dann noch andere

00:44:06.950 --> 00:44:08.830
Sachen reintust, wie Deck oder

00:44:08.830 --> 00:44:11.230
Deck-Q oder eine Q oder wie auch immer du sie nennen möchtest.

00:44:11.250 --> 00:44:13.050
Also ich meine, die Q, also der Vorteil

00:44:13.050 --> 00:44:15.210
bei diesen Datenstrukturen ist halt... Wie spricht man denn Deck aus?

00:44:15.270 --> 00:44:17.030
Deck-Q? Deck-Tück-Tick?

00:44:17.750 --> 00:44:19.170
Deck. Ich habe schon mal Deck genannt,

00:44:19.270 --> 00:44:20.870
aber ich weiß nicht genau, ob es richtig ist. Ich nenne es auch immer Deck,

00:44:20.990 --> 00:44:22.130
aber keine Ahnung.

00:44:22.850 --> 00:44:24.470
Die Q, warte mal hier,

00:44:24.790 --> 00:44:26.610
hier gibt es Aussprache, warte mal.

00:44:26.850 --> 00:44:28.030
Bitte lesen Sie diesen Begriff vor.

00:44:28.030 --> 00:44:29.530
Der Deck,

00:44:29.730 --> 00:44:32.310
sagt Leo.

00:44:32.850 --> 00:44:34.490
Ich benutze immer Leo für sowas.

00:44:34.950 --> 00:44:37.270
Dict.leo.org, wichtigstes Werkzeug.

00:44:37.890 --> 00:44:39.110
Der sagt Deck

00:44:39.110 --> 00:44:40.750
in schönem, feinem britischen Englisch.

00:44:41.510 --> 00:44:41.630
Aha.

00:44:43.550 --> 00:44:45.350
Ja, also sowas hat man halt vor allen Dingen

00:44:45.350 --> 00:44:47.190
dann, wenn du möchtest, dass die

00:44:47.190 --> 00:44:49.370
Sortierreihenfolge halt irgendwie

00:44:49.370 --> 00:44:50.730
gleich bleibt. Nee, halt, warte mal.

00:44:51.070 --> 00:44:52.510
Erstmal musst du erklären, was ein Deck ist.

00:44:52.510 --> 00:44:53.070
Oh Gott.

00:44:55.250 --> 00:44:56.590
Also, ich weiß

00:44:56.590 --> 00:44:58.510
jetzt auch gar nicht, wie die...

00:44:59.230 --> 00:45:00.750
Double-Ended-Queue.

00:45:00.950 --> 00:45:00.970
Ja.

00:45:02.450 --> 00:45:04.310
Ich weiß jetzt auch gar nicht, wie genau die Implementation

00:45:04.310 --> 00:45:05.410
in Python da aussieht.

00:45:05.930 --> 00:45:06.710
Spielt keine Rolle.

00:45:08.610 --> 00:45:09.490
Ja, also

00:45:09.490 --> 00:45:11.690
der Witz an dem Ding ist halt,

00:45:12.210 --> 00:45:14.350
dass du sozusagen Sachen

00:45:14.350 --> 00:45:16.170
rausnehmen kannst, reinnehmen kannst und trotzdem ist es halt

00:45:16.170 --> 00:45:17.910
immer sortiert und du kannst halt...

00:45:17.910 --> 00:45:20.010
Weil du einen Follower und einen

00:45:20.010 --> 00:45:21.070
Processor hast.

00:45:22.450 --> 00:45:24.270
Also eine Queue ist eine

00:45:24.270 --> 00:45:24.910
Warteschlange.

00:45:26.170 --> 00:45:28.110
Und eine Double-Ended Queue heißt,

00:45:28.250 --> 00:45:30.370
du kannst auf der einen Seite was reinschieben

00:45:30.370 --> 00:45:32.270
und auf der anderen Seite kannst du

00:45:32.270 --> 00:45:33.430
was rausnehmen.

00:45:34.310 --> 00:45:35.970
Und die bleiben in der Reihenfolge.

00:45:36.490 --> 00:45:37.530
Also das heißt, ich habe beide Enden.

00:45:37.790 --> 00:45:39.050
Das ist doch das, was eine Deck ist, oder?

00:45:39.110 --> 00:45:41.370
Ja, genau.

00:45:42.150 --> 00:45:44.090
Und das ist, da gibt es so ein Pattern,

00:45:44.530 --> 00:45:46.590
das Producer-Consumer-Pattern,

00:45:46.690 --> 00:45:48.190
wo du sagst, du hast halt eine

00:45:48.190 --> 00:45:50.110
Prozedur, die erzeugt Datenpunkte

00:45:50.110 --> 00:45:51.390
und du hast eine Prozedur, die

00:45:51.390 --> 00:45:54.130
verbraucht Datenpunkte und dann

00:45:54.130 --> 00:45:56.150
ist die Deck genau das, was

00:45:56.150 --> 00:45:57.970
da dazwischen ist. Der eine tut sie eben

00:45:57.970 --> 00:45:58.870
auf der einen Seite

00:45:58.870 --> 00:46:02.130
in das Deck rein oder in die

00:46:02.130 --> 00:46:04.250
Deck und der andere,

00:46:04.610 --> 00:46:06.210
der sie verbraucht, der nimmt sie auf der anderen

00:46:06.210 --> 00:46:07.890
Seite raus. Und

00:46:07.890 --> 00:46:09.790
das kannst du prinzipiell mit einer Liste machen.

00:46:10.350 --> 00:46:12.310
Du kannst eine Python-List als

00:46:12.310 --> 00:46:14.090
Deck verwenden, indem du halt

00:46:14.090 --> 00:46:16.150
.append machst, das ist das

00:46:16.150 --> 00:46:18.190
Einfügen, und indem du halt .pop0

00:46:18.190 --> 00:46:20.070
machst. Das Problem da drin ist,

00:46:20.950 --> 00:46:21.690
dass .pop0

00:46:21.690 --> 00:46:24.050
teuer ist, weil

00:46:24.050 --> 00:46:26.130
das bedeutet, das erste Element der Liste wird

00:46:26.130 --> 00:46:28.290
entfernt, das heißt, alle Elemente,

00:46:28.350 --> 00:46:30.170
die in der Liste drin sind, müssen um 1 verschoben

00:46:30.170 --> 00:46:32.330
werden und

00:46:32.330 --> 00:46:34.270
das hört man jetzt schon,

00:46:34.490 --> 00:46:36.150
dass wenn du das

00:46:36.150 --> 00:46:38.250
erste Element rausnehmen willst, musst du sie alle einmal

00:46:38.250 --> 00:46:39.990
anfassen. Und das

00:46:39.990 --> 00:46:42.050
ist natürlich für eine Operation,

00:46:42.270 --> 00:46:43.590
die sich so anhört wie

00:46:43.590 --> 00:46:45.890
das erste wegnehmen,

00:46:46.090 --> 00:46:48.250
einfach teuer.

00:46:49.190 --> 00:46:50.090
Das hat diese

00:46:50.090 --> 00:46:51.350
Spezialimplementierung,

00:46:52.170 --> 00:46:54.090
der DEC, der Double Ended

00:46:54.090 --> 00:46:56.090
Queue, wo das beides

00:46:56.090 --> 00:46:57.970
nicht viel kostet. Das Einfügen am Ende

00:46:57.970 --> 00:46:59.910
kostet nicht viel und das

00:46:59.910 --> 00:47:01.370
vorne wegnehmen, kostet nicht viel.

00:47:01.970 --> 00:47:04.010
Dafür gibt es halt andere Operationen, die dann viel kosten.

00:47:04.190 --> 00:47:06.130
Dafür gibt es andere, dafür kannst du in der Mitte,

00:47:06.210 --> 00:47:07.430
wenn du in der Mitte was einfügen willst,

00:47:07.750 --> 00:47:09.950
entweder geht es gar nicht oder es ist extrem langsam

00:47:09.950 --> 00:47:12.410
oder irgendwie solche Eigenschaften

00:47:12.410 --> 00:47:13.610
hast du dann da halt verloren.

00:47:14.850 --> 00:47:16.090
Die Sache an diesen

00:47:16.090 --> 00:47:17.290
Datenstrukturen ist halt,

00:47:18.110 --> 00:47:19.910
du kannst erstmal eine Liste verwenden

00:47:19.910 --> 00:47:21.950
und wenn das zu langsam wird oder wenn das

00:47:21.950 --> 00:47:23.690
Eigenschaften hat, wenn die Python-Liste

00:47:23.690 --> 00:47:25.410
Eigenschaften hat, die nicht gut genug sind,

00:47:26.090 --> 00:47:27.690
dann musst du dir was anderes suchen.

00:47:28.790 --> 00:47:30.610
Und das ist eigentlich dann die Antwort auf deine Frage.

00:47:30.790 --> 00:47:33.010
Ja, also wann merkt man denn überhaupt,

00:47:33.550 --> 00:47:34.950
dass die Liste nicht gut genug ist?

00:47:35.130 --> 00:47:37.970
Also weil es zu langsam wird, weil es oben gibt?

00:47:39.570 --> 00:47:42.010
Wenn dein Programm zu langsam ist und nicht mehr in den Speicher passt.

00:47:43.030 --> 00:47:43.810
Ja, okay, also genau.

00:47:44.410 --> 00:47:46.170
Wenn dein Swap-Laufwerk anfängt zu arbeiten.

00:47:47.730 --> 00:47:51.170
Ja, oder die Anwendung Crash-Wahl oben kickt.

00:47:52.050 --> 00:47:52.510
Ja, genau.

00:47:53.750 --> 00:47:54.930
Ja, oder wenn es halt zu langsam ist.

00:47:54.930 --> 00:47:56.630
Ja, also es gibt Fälle.

00:47:57.630 --> 00:48:02.050
Ich habe mit Leuten Sachen optimiert,

00:48:02.230 --> 00:48:04.310
die halt eine Liste wie ein Set verwendet haben

00:48:04.310 --> 00:48:05.130
und dann halt geguckt haben,

00:48:05.190 --> 00:48:06.510
ist dieses Objekt in dieser Liste drin?

00:48:06.570 --> 00:48:06.950
Kannst du machen?

00:48:07.110 --> 00:48:07.590
Oh ja, kannst du.

00:48:07.870 --> 00:48:11.250
Die heißt in und ist aber linear, ist O von N.

00:48:11.630 --> 00:48:13.110
Das heißt, du musst gucken,

00:48:13.330 --> 00:48:15.570
ist das erste Objekt mein gesuchtes Objekt

00:48:15.570 --> 00:48:17.050
oder das zweite oder das dritte oder das vierte?

00:48:17.110 --> 00:48:18.290
Das heißt, jede dieser Abfragen

00:48:18.290 --> 00:48:21.090
muss einmal potenziell alle Elemente anfassen.

00:48:21.990 --> 00:48:23.550
Und da gibt es eine Datenstruktur, das Set.

00:48:24.130 --> 00:48:25.130
Da ist es halt O von 1.

00:48:25.210 --> 00:48:26.270
Da kostet es immer gleich viel,

00:48:26.350 --> 00:48:28.290
egal wie groß es ist, egal was du suchst,

00:48:28.370 --> 00:48:29.250
egal ob es drin ist oder nicht,

00:48:29.890 --> 00:48:32.610
kostet immer amortisiert gleich viel.

00:48:33.130 --> 00:48:34.290
Und wenn du so einen

00:48:34.290 --> 00:48:35.830
Algorithmus hast, der

00:48:35.830 --> 00:48:37.730
viele von diesen Operationen macht,

00:48:38.370 --> 00:48:40.090
dann hast du da eine Möglichkeit,

00:48:40.470 --> 00:48:42.130
den deutlich schneller zu machen. Und zwar

00:48:42.130 --> 00:48:43.970
richtig um Klassenschnellheit. Also mache ich einfach

00:48:43.970 --> 00:48:45.870
ein Z aus der Liste und dann mache ich das N,

00:48:45.970 --> 00:48:47.510
den In-Test? Ja.

00:48:48.610 --> 00:48:49.890
In dem spezifischen Fall, genau.

00:48:50.890 --> 00:48:52.270
Hat das ausgereicht, aus einer Liste

00:48:52.270 --> 00:48:53.930
ein Z zu machen und das hat schon,

00:48:54.430 --> 00:48:56.190
wenn du von O von N Quadrat auf O von

00:48:56.190 --> 00:48:57.710
N runtergehst, das macht

00:48:57.710 --> 00:49:00.090
Problemklassen bearbeitbar,

00:49:00.170 --> 00:49:01.430
die vorher nicht bearbeitbar waren.

00:49:02.490 --> 00:49:04.090
Vorher konnte man irgendwie 15

00:49:04.090 --> 00:49:04.910
15

00:49:04.910 --> 00:49:08.150
Elemente da drin haben

00:49:08.150 --> 00:49:10.190
und hinterher konntest du 15.000

00:49:10.190 --> 00:49:12.070
Elemente drin haben. Also das ist einfach

00:49:12.070 --> 00:49:13.990
ein massiver Unterschied in der Performance.

00:49:14.770 --> 00:49:16.030
Aber vorher zu sagen, was

00:49:16.030 --> 00:49:18.130
du brauchst und an welchen Stellen

00:49:18.130 --> 00:49:20.110
das das Richtige ist, fällt mir

00:49:20.110 --> 00:49:20.790
sehr schwer.

00:49:23.110 --> 00:49:23.550
Okay.

00:49:24.210 --> 00:49:26.030
Das heißt, man muss immer tatsächlich

00:49:26.030 --> 00:49:28.250
bei dem Problem gucken, was das

00:49:28.250 --> 00:49:29.170
jetzt bringt. Genau.

00:49:29.610 --> 00:49:31.790
Du musst bei dem Problem diese Abwägung machen zwischen

00:49:31.790 --> 00:49:33.690
Komfort und Geschwindigkeit.

00:49:34.210 --> 00:49:36.130
Und im ersten Schritt, das ist

00:49:36.130 --> 00:49:37.990
ja auch das, was wir vorhin angesprochen haben, wir machen ja

00:49:37.990 --> 00:49:40.570
in erster Linie erstmal so einen

00:49:40.570 --> 00:49:42.090
Rapid-Prototype, einfach um zu sehen,

00:49:42.130 --> 00:49:43.210
was überhaupt. Ein Komfort-Check, ja.

00:49:44.130 --> 00:49:45.890
Und da wähle ich immer,

00:49:45.930 --> 00:49:48.130
wählst du immer die komfortabelste Lösung, die erste

00:49:48.130 --> 00:49:49.590
Lösung, weil erst musst du wissen, ob

00:49:49.590 --> 00:49:51.970
das korrekt hinkriegst und dann kannst du gucken,

00:49:52.070 --> 00:49:53.970
ob das schnell hinkriegst. Ich kann

00:49:53.970 --> 00:49:55.870
sehr, sehr, sehr schnelle Programme schreiben,

00:49:56.030 --> 00:49:57.850
die nicht die richtige Antwort liefern. Das ist überhaupt

00:49:57.850 --> 00:49:59.710
gar kein Problem. Ja, wobei dann der,

00:50:00.030 --> 00:50:01.670
wenn ich jetzt mal meinen

00:50:01.670 --> 00:50:03.990
inneren Casey channelen darf,

00:50:05.070 --> 00:50:05.910
der würde natürlich

00:50:05.910 --> 00:50:07.790
sagen, ja gut, also wenn du das jetzt so machst

00:50:07.790 --> 00:50:09.770
und wenn du halt implizit die Annahme

00:50:09.770 --> 00:50:11.750
triffst, dass du hinterher deine

00:50:11.750 --> 00:50:13.750
Hotspots, wo die Performance halt kritisch ist,

00:50:13.810 --> 00:50:15.770
halt optimieren kannst, dann kann es halt

00:50:15.770 --> 00:50:17.750
sein, dass du in einer Situation landest, wo du halt mit dem

00:50:17.750 --> 00:50:19.930
Profiler deinen Code anguckst

00:50:19.930 --> 00:50:22.270
und der sagt dir halt, ja, also die ganze

00:50:22.270 --> 00:50:24.250
Performance geht drauf bei Funktionsaufrufen

00:50:24.250 --> 00:50:26.950
und bei Memory-Allotierungen.

00:50:27.490 --> 00:50:29.970
Und du denkst dann, ja, wie soll ich den jetzt noch optimieren?

00:50:30.310 --> 00:50:32.510
Dann wird er sagen, ha, siehste, das geht doch nicht.

00:50:32.510 --> 00:50:39.370
Aber, das ist richtig, aber Schritt 0 im Knuth-Optimization-Process

00:50:39.370 --> 00:50:40.990
ist die Wahl des richtigen Algorithmus.

00:50:41.250 --> 00:50:44.910
Das heißt, gucken, ob du den Algorithmus gewählt hast,

00:50:45.090 --> 00:50:46.090
der die richtigen Eigenschaften hat.

00:50:47.010 --> 00:50:49.190
Und das ist natürlich was,

00:50:49.470 --> 00:50:52.890
auch das ist schwierig jetzt so konkret zu beantworten.

00:50:53.010 --> 00:50:54.870
das ist halt was, was mit Erfahrung kommt, dass du weißt,

00:50:54.970 --> 00:50:57.090
welche Algorithmen gibt es und welche Sortenalgorithmen

00:50:57.090 --> 00:50:59.070
gibt es. Und das ist gerade ein Knuth-Optimation-Prozess

00:50:59.070 --> 00:51:01.050
gesagt. Ja, das

00:51:01.050 --> 00:51:01.970
ist so ein,

00:51:02.510 --> 00:51:05.090
die witzige Umdrehung dieses

00:51:05.090 --> 00:51:06.510
Knuth-Zitats.

00:51:07.870 --> 00:51:08.490
Sag ich gleich.

00:51:09.830 --> 00:51:10.310
Das ist das,

00:51:11.130 --> 00:51:13.010
genau, das ist das, was mit der Erfahrung kommt, ja, dass du

00:51:13.010 --> 00:51:14.990
weißt, welche Algorithmen gibt es, welche

00:51:14.990 --> 00:51:16.990
Alternativen gibt es, welche

00:51:16.990 --> 00:51:19.130
Datenstrukturen gibt es, was ist wo angebracht.

00:51:19.570 --> 00:51:20.970
Wenn du jetzt irgendwie was

00:51:20.970 --> 00:51:22.910
anpassen musst oder wenn du jetzt irgendwas hast,

00:51:22.950 --> 00:51:24.730
das nicht auf ein Standardproblem passt,

00:51:25.190 --> 00:51:26.950
dass du es dir trotzdem aus den Bauteilen zusammen

00:51:26.950 --> 00:51:28.970
suchen kannst. Und der erste

00:51:28.970 --> 00:51:30.770
Schritt in diesem Prozess ist, den richtigen

00:51:30.770 --> 00:51:32.910
Algorithmus auszuwählen. Und das alles andere

00:51:32.910 --> 00:51:34.070
ist untergeordnet.

00:51:34.490 --> 00:51:36.290
Wenn du den falschen Algorithmus auswählst,

00:51:36.770 --> 00:51:37.950
hast du schon verloren.

00:51:38.950 --> 00:51:40.810
Genau. Das bezieht sich auf

00:51:40.810 --> 00:51:42.090
dieses Zitat von Knuth,

00:51:42.190 --> 00:51:44.510
Premature Optimization is the root of all evil.

00:51:45.510 --> 00:51:46.910
Wann weiß ich denn, ob der Algorithmus

00:51:46.910 --> 00:51:47.430
richtig ist?

00:51:48.770 --> 00:51:50.110
Wobei, weißt du nicht.

00:51:50.490 --> 00:51:52.650
Wobei man auch dazu sagen muss,

00:51:52.770 --> 00:51:54.630
Knuth sagt ja im nächsten Satz,

00:51:55.450 --> 00:51:59.430
10% Geschwindigkeitszuwachs lohnt sich schon zu optimieren.

00:52:00.590 --> 00:52:04.430
Und da sind wir natürlich auch hier auf der Python-Ebene schon verloren,

00:52:05.430 --> 00:52:08.790
weil wir akzeptieren, dass unsere Programme langsamer sind

00:52:08.790 --> 00:52:12.450
als das 10% Optimale.

00:52:13.850 --> 00:52:15.430
Auch da gibt es natürlich Ebenen.

00:52:15.610 --> 00:52:17.890
Knuth kommt ja aus einer ganz anderen Welt,

00:52:18.070 --> 00:52:20.370
wo die Prozessoren noch in Kilohertz gemessen wurden

00:52:20.370 --> 00:52:21.230
und nicht in Gigahertz.

00:52:22.070 --> 00:52:27.510
Und auch die, sag ich mal, die algorithmischen Probleme anders waren.

00:52:27.510 --> 00:52:36.310
Du kannst bei einem Sortieralgorithmus beweisen, was das Maximum ist und du kannst beweisen, dass dein Algorithmus das Maximum für eine gewisse Datenklasse erreicht.

00:52:37.510 --> 00:52:47.470
Würde ich sagen, ist bei den meisten Sachen, die wir so bearbeiten heutzutage, hier CV-Erstellung für den Jochen, kannst du nicht beweisen, dass du den optimalen Algorithmus ausgewählt hast.

00:52:48.210 --> 00:53:16.470
Du weißt, dass du einen Algorithmus ausgewählt hast, der passend ist für das Problem, wenn es deinen Anforderungen entspricht, wenn du dein Problem lösen kannst in einer Zeit, die akzeptabel ist. Und das ist jetzt natürlich wieder so eine Stelle, wo der interne Casey sagt, ja, aber Moment mal, ich will einfach, dass das hier viel schneller wird und ich habe ausgerechnet, der Prozessor kann so und so viele Operationen pro Sekunde machen, also reicht es aus, um das 30 Mal pro Sekunde zu machen, also kannst du es in Realtime machen und dann mach es auch bitte in Realtime.

00:53:18.210 --> 00:53:33.890
Und mein interner Nicht-Casey, der sagt dann halt, ja, aber einmal pro Sekunde reicht ja auch oder einmal pro fünf Sekunden reicht auch. So schnell muss man das gar nicht aktualisieren. Und das ist eine Frage der Anforderungen, welche Anforderungen du hast und welche Vorstellungen du hast und wie schnell du es haben willst.

00:53:33.890 --> 00:53:48.550
Und da pauschal zu sagen, was ist der richtige Rhythmus oder wie wählst du den aus? Keine Ahnung, ich weiß es nicht. Mit Erfahrung, mit Gefühl, mit, ich weiß nicht, mit dem Benutzer sprechen.

00:53:50.450 --> 00:53:55.710
Oh, User Experience, jetzt weiß ich aber welchen.

00:53:57.390 --> 00:54:00.890
Ja gut, okay, also in Projekten natürlich nicht mit dem Benutzer, sondern mit dem, der es bezahlt.

00:54:01.250 --> 00:54:02.990
Ja, ja, okay, ist schlimm genug.

00:54:03.430 --> 00:54:04.010
Also, naja, gut.

00:54:06.870 --> 00:54:08.830
Oft ist es auch so, dass man gerne mal

00:54:08.830 --> 00:54:10.750
mit dem Nutzer sprechen würde, aber tatsächlich

00:54:10.750 --> 00:54:12.490
dann immer nur mit den Bezahlern,

00:54:12.710 --> 00:54:13.670
mit den Hippos.

00:54:15.670 --> 00:54:16.030
Ja.

00:54:18.230 --> 00:54:18.990
Oft gibt es ja auch

00:54:18.990 --> 00:54:20.950
gar nicht den Benutzer. Oft gibt es ja nur

00:54:20.950 --> 00:54:22.630
eine Klasse von Benutzern.

00:54:22.850 --> 00:54:24.710
Oft findest du ja gar nicht den Benutzer, sondern

00:54:24.710 --> 00:54:25.810
ja.

00:54:26.390 --> 00:54:28.590
Ja, oder vielleicht soll man gar nicht mit denen reden.

00:54:28.590 --> 00:54:30.170
Oder die Benutzer sind doof und verstehen es nicht.

00:54:30.250 --> 00:54:31.170
Das ist ja auch so manchmal.

00:54:31.250 --> 00:54:55.010
Ja, was aber auch, also ich muss das jetzt gleich wieder zurücknehmen. Ich meine, wir arbeiten ja oft in so einem Corporate-Umfeld und da sind die Benutzer halt, das ist auch sowas, was Softwareentwickler oft sagen, das wäre alles so einfach, wenn die Benutzer nicht wären, wenn die nicht das falsch benutzen würden, wenn die das nicht so benutzen würden, wie sie es benutzen wollen.

00:54:55.430 --> 00:55:12.690
Das ist aber, das ist lustig, sowas im Bekanntenkreis zu sagen, aber wenn wir hier im Podcast sind, müssen wir das klarstellen, das ist nicht ein Fehler des Benutzers, wenn er die Software falsch benutzt, sondern es ist ein Fehler der Software, wenn die Software falsch benutzbar ist und wenn sie anders eingesetzt wird, als sie gedacht war.

00:55:13.050 --> 00:55:20.590
Deswegen fühle ich mich übrigens im Eurorex wohl, weil wenn man da das Kabel in die falsche Öse reinsteckt, dann kommen lustige Sachen raus und es gibt immer noch Musik.

00:55:22.850 --> 00:55:25.250
Also für dich ist das ein Feature, für dich soll das so sein.

00:55:25.430 --> 00:55:27.370
Ja, also ich würde mich aber auch nicht darüber

00:55:27.370 --> 00:55:29.250
beschweren, dass die Nutzer doof sind, sondern ich würde tatsächlich sagen,

00:55:29.350 --> 00:55:31.130
hey, super wichtig und toll, dass

00:55:31.130 --> 00:55:33.330
Videosoftware benutzt und hey, wenn dieser Bug für dich

00:55:33.330 --> 00:55:35.430
ein Feature ist, perfekt, I won't fix it.

00:55:36.430 --> 00:55:37.450
Ja, oft

00:55:37.450 --> 00:55:39.410
ist es ja andersrum. Oft ist es ja so, dass du Feature

00:55:39.410 --> 00:55:41.050
kompliziert einbaust und dann sagen die Leute,

00:55:41.330 --> 00:55:43.370
ja, das geht aber nicht

00:55:43.370 --> 00:55:45.110
so, wie ich mir das vorstelle. Und dann

00:55:45.110 --> 00:55:47.430
liegt es halt nahe zu sagen, ach, das liegt an dir,

00:55:47.430 --> 00:55:48.670
du doofer Benutzer. Ja, man sollte halt

00:55:48.670 --> 00:55:51.290
vorher mal die Leute fragen, die es halt auch benutzen wollen,

00:55:51.810 --> 00:55:53.390
ob das halt wirklich das ist, was sie brauchen.

00:55:54.430 --> 00:55:55.270
Ja, und wenn

00:55:55.270 --> 00:55:57.050
eine Fehlbenutzung auftritt, also wenn tatsächlich

00:55:57.050 --> 00:55:59.250
Fehler auftreten, dadurch, dass

00:55:59.250 --> 00:56:00.770
die Benutzer irgendwas damit machen,

00:56:01.290 --> 00:56:03.230
dann muss die Software das halt entweder abkönnen

00:56:03.230 --> 00:56:05.110
oder korrigieren können oder

00:56:05.110 --> 00:56:07.150
die Software muss die Benutzer so steuern, dass das

00:56:07.150 --> 00:56:09.230
nicht passiert. Die Benutzer können da nichts

00:56:09.230 --> 00:56:11.090
dafür, dass sie Anforderungen haben und dass sie Wünsche

00:56:11.090 --> 00:56:12.870
haben und dass sie...

00:56:12.870 --> 00:56:14.170
Das ist so eine generelle

00:56:14.170 --> 00:56:17.150
Einstellung, die man oft halt sieht in der Software

00:56:17.150 --> 00:56:19.030
Welt, der Computer hat Recht und der Benutzer hat

00:56:19.030 --> 00:56:20.810
nicht Recht, aber es ist tatsächlich

00:56:20.810 --> 00:56:22.990
dealen wir ja nicht den Computern,

00:56:23.090 --> 00:56:25.190
sondern es soll ja eigentlich schon andersrum sein.

00:56:25.270 --> 00:56:26.290
Mal gucken, wie lange noch.

00:56:29.050 --> 00:56:30.790
Deshalb sage ich, es soll andersrum sein.

00:56:31.190 --> 00:56:33.230
Aber auch ich freue mich

00:56:33.230 --> 00:56:34.670
auf unsere Robotic Overlords.

00:56:35.790 --> 00:56:36.750
I for one.

00:56:37.230 --> 00:56:39.510
Ich möchte an der Stelle den Robotic Overlords

00:56:39.510 --> 00:56:40.670
sagen, ich bin ein guter Diener.

00:56:41.550 --> 00:56:41.810
Genau.

00:56:42.530 --> 00:56:44.690
Schreibt doch mal schon Danke bei, wenn GPD uns geschrieben hat.

00:56:45.430 --> 00:56:46.250
Ja, natürlich.

00:56:47.150 --> 00:56:48.470
Bedankt ihr euch nicht bei ChatGPD.

00:56:48.470 --> 00:56:50.110
Das ist reiner

00:56:50.110 --> 00:56:51.590
Selbsterhaltungstrieb, wenn die

00:56:51.590 --> 00:56:54.410
Zukunft kommt. Dann werden die Protokolle gelesen

00:56:54.410 --> 00:56:56.350
und dann...

00:56:56.350 --> 00:56:58.250
Ausgewertet. Wer war denn nützlich?

00:57:00.170 --> 00:57:01.110
Wer war freundlich?

00:57:01.730 --> 00:57:02.770
Wie viel Freundlichkeit

00:57:02.770 --> 00:57:04.310
haben die verdient, diese Affen?

00:57:07.490 --> 00:57:07.790
Tja.

00:57:08.810 --> 00:57:10.710
Ja, okay.

00:57:10.850 --> 00:57:12.050
Aber jetzt haben wir hier schon tatsächlich,

00:57:12.050 --> 00:57:13.890
sind wir schon relativ gut am Ende

00:57:13.890 --> 00:57:14.870
des Kapitels angekommen.

00:57:14.870 --> 00:57:16.280
hier, Memory Views.

00:57:16.800 --> 00:57:18.520
NumPy wird hier noch erwähnt. NumPy

00:57:18.520 --> 00:57:20.820
finde ich ganz interessant, dass das hier

00:57:20.820 --> 00:57:22.580
in dem Kapitel über Sequences drin ist,

00:57:23.180 --> 00:57:24.920
weil NumPy selber ist ja keine Sequence.

00:57:25.920 --> 00:57:26.360
An Array?

00:57:28.180 --> 00:57:28.920
NumPy ist ja

00:57:28.920 --> 00:57:30.520
eine Riesenbibliothek mit ganz vielen

00:57:30.520 --> 00:57:32.480
numerischen...

00:57:32.480 --> 00:57:34.040
Ach so, du meinst, ja, okay. Gut.

00:57:34.540 --> 00:57:36.380
Aber die Datentypen, die da drin sind,

00:57:36.520 --> 00:57:38.760
die sind ja schon

00:57:38.760 --> 00:57:40.740
auf eine gewisse Art und Weise auch

00:57:40.740 --> 00:57:43.040
Sequences. Also die halten sich auch an das Sequence-Protokoll

00:57:43.040 --> 00:57:44.780
und da kannst du ganz viele, kannst du Slicing machen

00:57:44.780 --> 00:57:45.860
drauf und so weiter und so fort.

00:57:46.060 --> 00:57:48.520
Die sind halt optimiert dann direkt auf Speicher und so.

00:57:49.720 --> 00:57:50.680
Was macht ManPy eigentlich

00:57:50.680 --> 00:57:51.660
so genau so besonders?

00:57:52.760 --> 00:57:54.760
Man kann mit ManPy auch was kaputt

00:57:54.760 --> 00:57:56.360
machen. Also wirklich

00:57:56.360 --> 00:57:57.820
im Vergleich zu normalen Listen.

00:57:58.240 --> 00:58:00.540
Wenn du so eine Liste zu groß machst, dann passiert nicht so viel. Aber wenn du

00:58:00.540 --> 00:58:02.480
in ManPy eine Liste zu groß machst,

00:58:02.540 --> 00:58:03.840
dann kannst du ja unten damit ansteigen.

00:58:04.000 --> 00:58:05.980
Du bist halt näher am

00:58:05.980 --> 00:58:08.600
Hauptspeicher dran. Dafür sind

00:58:08.600 --> 00:58:10.480
sie auch deutlich schneller. Also wenn du

00:58:10.480 --> 00:58:12.500
viele Einträge hast, musst du dich allerdings wieder

00:58:12.500 --> 00:58:14.700
auf den Datentyp festlegen. Da kannst du nicht gemischte Daten

00:58:14.700 --> 00:58:16.440
Typen haben. Dafür kannst du

00:58:16.440 --> 00:58:17.600
mehrdimensionale haben.

00:58:19.060 --> 00:58:20.660
Also es ist wieder so eine Abwägung.

00:58:21.300 --> 00:58:22.700
Aber auch das ist

00:58:22.700 --> 00:58:24.260
natürlich eine Möglichkeit,

00:58:24.520 --> 00:58:26.600
dass du sagst, hier, wir haben irgendwelche Daten, die wir

00:58:26.600 --> 00:58:28.660
verarbeiten müssen, dann nehmen wir doch

00:58:28.660 --> 00:58:30.000
NumPy-Datentypen.

00:58:30.400 --> 00:58:32.440
Und ganz viele Bibliotheken integrieren das ja auch.

00:58:32.660 --> 00:58:34.420
Also zum Beispiel bei Pillow kannst du einfach sagen,

00:58:34.500 --> 00:58:36.540
hier, er ist irgendwas. Und dann kriegst du

00:58:36.540 --> 00:58:38.440
eine NumPy-Array raus, wenn du

00:58:38.440 --> 00:58:40.420
irgendwelche Bildfilter selber schreiben willst

00:58:40.420 --> 00:58:42.120
oder wenn du irgendwelche...

00:58:42.120 --> 00:58:43.800
Ich habe mal Dithering gemacht.

00:58:44.700 --> 00:58:47.240
ein Privatprojekt. Und das habe ich halt auf den

00:58:47.240 --> 00:58:49.020
NumPyArray. Was ist Dithering?

00:58:50.020 --> 00:58:51.340
Das ist das Schönste, was

00:58:51.340 --> 00:58:53.440
du da machen kannst. Kanten finden.

00:58:54.340 --> 00:58:54.780
Dithering

00:58:54.780 --> 00:58:57.360
ist, wenn du von

00:58:57.360 --> 00:58:59.300
einem Bildformat mit vielen

00:58:59.300 --> 00:59:01.400
Farben dich

00:59:01.400 --> 00:59:03.380
bewegst auf ein Bildformat mit wenigen

00:59:03.380 --> 00:59:05.500
Farben, dann hast du üblicherweise Fehler

00:59:05.500 --> 00:59:07.160
in deinem Bild. Ja, da musst du immer

00:59:07.160 --> 00:59:09.140
Zusammenfassung machen. Da musst du mit so einem Raster

00:59:09.140 --> 00:59:11.020
drüberlaufen und das dann irgendwie mitteln oder so.

00:59:11.020 --> 00:59:12.240
Genau, und das heißt Dithering.

00:59:12.640 --> 00:59:14.460
Das heißt, du hast den Fehler nicht

00:59:14.460 --> 00:59:16.460
an dieser einen Stelle, sondern du verteilst

00:59:16.460 --> 00:59:18.360
den und dann wirkt das Bild

00:59:18.360 --> 00:59:19.600
besser auf

00:59:19.600 --> 00:59:22.300
Menschen. Das sieht

00:59:22.300 --> 00:59:24.000
besser aus und

00:59:24.000 --> 00:59:28.360
macht halt, verteilt

00:59:28.360 --> 00:59:29.840
so ein bisschen die, also du hast dann bessere,

00:59:30.140 --> 00:59:32.260
das Bild sieht besser aus mit weniger Farben.

00:59:33.240 --> 00:59:33.920
Und ich habe das,

00:59:34.460 --> 00:59:36.280
ich mag ja E-Paper-Screens sehr gerne und ich

00:59:36.280 --> 00:59:38.700
habe mir eben so eine Anwendung gemacht, wo ich Bilder auf E-Paper-Screens

00:59:38.700 --> 00:59:40.360
machen kann und da musste Dithering machen, weil die haben

00:59:40.360 --> 00:59:42.680
üblicherweise vier Graustufen

00:59:42.680 --> 00:59:44.420
oder acht Graustufen oder

00:59:44.420 --> 00:59:46.240
16 Graustufen. Und da kommst du nicht drum rum, da musst du

00:59:46.240 --> 00:59:48.340
Disney-Wing machen. Sonst hast du so ganz

00:59:48.340 --> 00:59:50.380
blockige Bilder mit harten Kanten

00:59:50.380 --> 00:59:52.700
drin, die bescheuert ausschauen.

00:59:54.120 --> 00:59:54.420
Ja, aber

00:59:54.420 --> 00:59:56.220
wie gesagt, also NumPy integriert sich da ja

00:59:56.220 --> 00:59:57.860
in ganz viele Sachen rein und

00:59:57.860 --> 01:00:00.360
ist halt

01:00:00.360 --> 01:00:02.380
einfach, man kann ja

01:00:02.380 --> 01:00:04.240
diese zusätzliche Funktionalität, kannst du einfach

01:00:04.240 --> 01:00:06.280
ignorieren, kannst aber sagen, okay, ja, die gibt's, aber brauche

01:00:06.280 --> 01:00:06.880
ich jetzt gerade nicht.

01:00:08.820 --> 01:00:08.960
Ja.

01:00:09.840 --> 01:00:11.920
Ja, voll gut, voll gut.

01:00:14.260 --> 01:00:15.700
Ich überlege, ob ich noch irgendwie

01:00:15.700 --> 01:00:17.660
was hatte, was

01:00:17.660 --> 01:00:19.520
irgendwie unbedingt drin, aber ich glaube,

01:00:19.740 --> 01:00:19.920
nee.

01:00:21.600 --> 01:00:23.840
Naja, dann sind wir ja quasi tatsächlich mit dem

01:00:23.840 --> 01:00:25.900
Thema Listen durch, dann können wir das nächste Mal

01:00:25.900 --> 01:00:27.640
ja weitermachen, wir werden sehen.

01:00:27.960 --> 01:00:29.660
Wir wollten ganz normal, oder ich weiß nicht,

01:00:29.740 --> 01:00:31.840
vielleicht mal noch diese...

01:00:31.840 --> 01:00:33.820
Wir wollten aber auch noch 3.13

01:00:33.820 --> 01:00:35.640
machen und wir wollten Pattern Matching machen und

01:00:35.640 --> 01:00:36.660
wir wollten Machine Learning machen.

01:00:38.980 --> 01:00:40.780
Schreibt in den Kommentaren, was ihr habt wollt.

01:00:41.200 --> 01:00:41.580
Ja, genau.

01:00:44.580 --> 01:00:45.800
Ja, ja, ja, ja.

01:00:46.980 --> 01:00:47.820
Oh, genau.

01:00:48.100 --> 01:00:49.300
Und vielleicht haben wir auch noch Pics.

01:00:50.400 --> 01:00:51.320
Natürlich haben wir Pics.

01:00:52.020 --> 01:00:53.520
Du hast einen, Jochen. Ich habe den gleichen wie du.

01:00:54.120 --> 01:00:54.560
Bist du sicher?

01:00:55.300 --> 01:00:56.000
Ja, sag du mal.

01:00:56.540 --> 01:00:58.740
Also, wenn man sich, ich meine,

01:00:59.640 --> 01:01:01.600
genau, in letzter Zeit

01:01:01.600 --> 01:01:03.600
immer mehr mit LLMs unterhält

01:01:03.600 --> 01:01:05.320
und so, dann manchmal

01:01:05.320 --> 01:01:08.360
stellt man sich

01:01:08.360 --> 01:01:10.320
ja manchmal die Frage so, irgendwie ist das, was ich

01:01:10.320 --> 01:01:12.360
hier mache, eigentlich totaler Blödsinn oder geht das irgendwie

01:01:12.360 --> 01:01:13.720
schon okay? Und

01:01:13.720 --> 01:01:16.380
da war das hilfreichste

01:01:16.380 --> 01:01:18.420
Dokument, was ich bisher so dazu gelesen habe,

01:01:18.560 --> 01:01:20.420
ob jetzt, was so Prompt-Techniken

01:01:20.420 --> 01:01:22.320
und so angeht und was man da so

01:01:22.320 --> 01:01:23.960
machen kann, ist tatsächlich das

01:01:23.960 --> 01:01:26.640
der Entropic Prompting

01:01:26.640 --> 01:01:27.640
Guide, der ist wirklich gut.

01:01:28.760 --> 01:01:30.340
Tatsächlich, da fand ich aber auch

01:01:30.340 --> 01:01:32.220
gut, dass jemand für Entropic seinen

01:01:32.220 --> 01:01:34.180
eigenen Guide dazu public rausgibt, das

01:01:34.180 --> 01:01:36.300
fand ich so ein bemerkenswertes.

01:01:36.740 --> 01:01:38.220
Ja, den wollte ich mal

01:01:38.220 --> 01:01:40.520
ging. Also ich

01:01:40.520 --> 01:01:41.940
sehe das manchmal, wenn ich dann irgendwie

01:01:41.940 --> 01:01:46.440
wie wird es jetzt immer genannt, irgendwie die Nazi-Bar

01:01:46.440 --> 01:01:48.280
oder die Hellzeit oder

01:01:48.280 --> 01:01:50.180
weiß ich nicht, wie Twitter gucke, dann

01:01:50.180 --> 01:01:52.060
wird immer mein Timeline überschwemmt von

01:01:52.060 --> 01:01:54.060
die zehn besten Prompting-Tipps und

01:01:54.060 --> 01:01:55.840
sieben Dinge, die du nicht

01:01:55.840 --> 01:01:58.000
gewusst hast, dass du das einfach nur machen musst.

01:01:58.220 --> 01:01:59.580
You won't believe what happens next.

01:02:01.440 --> 01:02:02.180
Gut, da sind

01:02:02.180 --> 01:02:04.140
manchmal auch brauchbare Tipps dabei, aber man muss halt auch

01:02:04.140 --> 01:02:05.380
viel Müll lesen und

01:02:05.380 --> 01:02:08.840
Entropic Prompting Guide viel besser.

01:02:10.100 --> 01:02:10.340
Okay.

01:02:10.980 --> 01:02:13.020
Cool. Jochen, ich dachte, du pickst

01:02:13.020 --> 01:02:14.660
UV. Das ist nämlich mein

01:02:14.660 --> 01:02:16.320
erster Pick, diese Episode.

01:02:17.520 --> 01:02:19.140
UV ist was ganz, ganz

01:02:19.140 --> 01:02:21.000
komisches. UV ist ein Package

01:02:21.000 --> 01:02:22.880
Manager für Python, aber geschrieben in

01:02:22.880 --> 01:02:25.020
Rust. Haben wir UV nicht schon fünfmal gepickt?

01:02:25.340 --> 01:02:26.940
Nee, gepickt weiß ich nicht, aber

01:02:26.940 --> 01:02:28.920
wir haben auf jeden Fall schon mal drüber geredet, aber gepickt noch

01:02:28.920 --> 01:02:29.980
nicht, glaube ich. Wirklich nicht?

01:02:30.460 --> 01:02:33.740
Ich pick das heute, weil es ist mir

01:02:33.740 --> 01:02:34.900
wieder begegnet und ich

01:02:34.900 --> 01:02:36.700
muss es jetzt endlich mal ausprobieren. Und tatsächlich,

01:02:36.880 --> 01:02:38.800
also ich bin auch kurz vor, das wirklich einzuführen,

01:02:38.860 --> 01:02:40.740
weil ich habe es jetzt noch ein bisschen ausprobiert. Es haben die

01:02:40.740 --> 01:02:42.880
Features, die vor einem Jahr mir noch gefehlt haben,

01:02:42.920 --> 01:02:44.560
die sind jetzt drin, es funktioniert, es läuft.

01:02:44.880 --> 01:02:46.560
Es läuft mit der PyProject, so wie ich es mir vorstelle,

01:02:46.640 --> 01:02:48.320
und ich werde Pultree rausschmeißen, wie einführen.

01:02:49.420 --> 01:02:50.480
Wahrscheinlich. Und es ist schneller.

01:02:51.160 --> 01:02:52.620
Ja, genau, das ist tatsächlich

01:02:52.620 --> 01:02:54.700
also wirklich schneller, also

01:02:54.700 --> 01:02:56.720
viel schneller. Da freut sich der interne

01:02:56.720 --> 01:02:58.400
Casey Moritore. Ja.

01:02:59.080 --> 01:03:00.720
Also ich habe auch jetzt zum ersten Mal

01:03:00.720 --> 01:03:01.960
das verwendet, um

01:03:01.960 --> 01:03:04.700
jetzt bei dem, wo ich es nicht vermeiden konnte,

01:03:04.760 --> 01:03:06.640
auf New Project zu klicken,

01:03:06.720 --> 01:03:08.360
habe ich gesagt, dann nehme ich doch mal ein UV, weil ich es mal

01:03:08.360 --> 01:03:10.560
ausprobieren will. Ja, ist doch auch eine Gelegenheit. Genau, ist immer

01:03:10.560 --> 01:03:12.640
eine Gelegenheit und ja,

01:03:12.800 --> 01:03:14.500
ich bin auch, vor allen Dingen ist es in den letzten

01:03:14.500 --> 01:03:16.520
Zeit, also in den letzten zwei Monaten sind dann eine Menge neue

01:03:16.520 --> 01:03:18.520
Features gekommen, sozusagen, die man tatsächlich

01:03:18.520 --> 01:03:20.640
brauchen kann und die halt

01:03:20.640 --> 01:03:22.440
auch diese ganzen Sachen abdecken, die vorher, wo ich mir

01:03:22.440 --> 01:03:24.520
dachte, ah nee, so ganz geht's

01:03:24.520 --> 01:03:26.500
noch nicht und es gab jetzt

01:03:26.500 --> 01:03:28.720
auch einen langen Thread, den verlinke ich auch mal

01:03:28.720 --> 01:03:30.580
auf im Fidiverse,

01:03:31.320 --> 01:03:32.720
wo sich so die Leute, die sich mit Packaging

01:03:32.720 --> 01:03:34.480
beschäftigen, einmal drüber unterhalten und wo auch

01:03:34.480 --> 01:03:49.660
Diese große Frage, ich sage so, naja gut, also ich meine Venture Capital ist halt so ein Problem. Was passiert jetzt eigentlich, wenn die Investoren halt sagen so, okay, jetzt haben wir schon die ganze Zeit so viel Geld gegeben. Jetzt würden wir auch mal wieder gerne welches Geld geben.

01:03:49.660 --> 01:03:50.500
Jetzt wollen wir auch mal wieder welches.

01:03:51.140 --> 01:03:52.740
Und was passiert denn eigentlich?

01:03:53.240 --> 01:03:55.100
Und ja, also

01:03:55.100 --> 01:03:56.860
dieser Shirt ist da sehr aufschlussreich, auch

01:03:56.860 --> 01:03:58.900
also, was mich

01:03:58.900 --> 01:04:01.100
zum Beispiel tatsächlich gefreut hat, ist, dass da viele

01:04:01.100 --> 01:04:02.860
Leute geschrieben haben, so, ja gut, okay, dann

01:04:02.860 --> 01:04:05.020
forken wir das halt, ne? Und wenn sie jetzt immer die Bedenken

01:04:05.020 --> 01:04:06.960
kommen, das wird dann nicht gemaintained oder so,

01:04:07.360 --> 01:04:09.120
also ehrlich gesagt, das irgendwie

01:04:09.120 --> 01:04:10.860
weiter zu maintainen, ich hab mir den Code angeguckt,

01:04:11.000 --> 01:04:13.140
dass weiter zu maintainen ist weniger Arbeit, als

01:04:13.140 --> 01:04:14.880
irgendwie, weiß ich nicht, den PIP-Code

01:04:14.880 --> 01:04:17.100
irgendwie zu maintainen, den ich sowieso

01:04:17.100 --> 01:04:18.920
schon maintainde und das ist irgendwie doof, also

01:04:18.920 --> 01:04:21.120
das ist schon okay. Und also

01:04:21.120 --> 01:04:22.900
wenn dann ein paar Leute sagen, okay, nee, das ist schon gut

01:04:22.900 --> 01:04:25.100
und wir würden das auch weiter maintainen,

01:04:25.220 --> 01:04:26.820
wenn das irgendwie dem Bach runter geht,

01:04:26.920 --> 01:04:28.380
sonst business-seitig, dann

01:04:28.380 --> 01:04:30.740
habe ich da auch schon mehr Hoffnung, dass das vielleicht auch

01:04:30.740 --> 01:04:31.660
bleibt.

01:04:33.800 --> 01:04:34.380
Hat UV

01:04:34.380 --> 01:04:36.480
Venture Capital genommen?

01:04:36.600 --> 01:04:36.780
Ja.

01:04:38.980 --> 01:04:40.860
Das ist ja witzig, in den letzten Jahren gab es

01:04:40.860 --> 01:04:42.860
so ein paar Pro-Projekte,

01:04:42.960 --> 01:04:44.740
von denen ich gedacht habe, das ist ja weird.

01:04:45.460 --> 01:04:47.140
Jetzt UV ist so eins, wo ich mir denke,

01:04:47.140 --> 01:04:49.400
ist das wirklich was, womit du Venture Capitalists

01:04:49.400 --> 01:04:50.100
ansprichst?

01:04:50.200 --> 01:04:51.660
Ja, aber weißt du, also das Pitch Deck

01:04:51.660 --> 01:04:53.900
und so hat der auch funktioniert, das ist ja dieselbe Firma.

01:04:54.180 --> 01:04:55.040
Ja, dieselbe Firma, genau.

01:04:55.840 --> 01:04:57.480
Es gibt noch so einen Terminal.

01:04:57.540 --> 01:04:59.400
Und dann der Armin Ronacher macht da auch einen, ne?

01:05:00.000 --> 01:05:01.700
Der arbeitet fest

01:05:01.700 --> 01:05:03.480
bei Sunfree.

01:05:04.020 --> 01:05:05.600
Ja, aber trotzdem, also macht

01:05:05.600 --> 01:05:07.540
er viele Sachen da geteilt

01:05:07.540 --> 01:05:08.800
mit den Leuten von EWI.

01:05:09.040 --> 01:05:09.640
Genau, genau.

01:05:10.220 --> 01:05:11.760
Evangelist, oder? Der darf doch machen, was er will.

01:05:12.880 --> 01:05:14.640
Kann sein. Aber nee,

01:05:14.920 --> 01:05:16.560
das war auch einer von den Leuten, der hat auch

01:05:16.560 --> 01:05:18.540
in dem Sweat da mitgeschrieben und meinte so, ja, also

01:05:18.540 --> 01:05:20.860
Rai hat ja vorher geschrieben,

01:05:21.580 --> 01:05:23.480
nee, die sollen das ruhig mal machen, die machen das schon

01:05:23.480 --> 01:05:25.000
besser und das ist wunderbar alles.

01:05:25.660 --> 01:05:26.920
Und ich dachte, ja gut, okay, wenn der das sagt.

01:05:27.540 --> 01:05:28.720
Aber, ähm,

01:05:29.220 --> 01:05:31.420
nee, genau, also das Textual

01:05:31.420 --> 01:05:33.320
oder der, wie heißt er, Will

01:05:33.320 --> 01:05:34.780
Mack, äh,

01:05:35.300 --> 01:05:37.180
der Rich geschrieben hat, der hat auch

01:05:37.180 --> 01:05:38.920
ein Benchmark-Viertel genommen für,

01:05:39.160 --> 01:05:40.180
ähm, ja.

01:05:41.240 --> 01:05:43.460
Also das ist tatsächlich gar nicht so schlecht, in der CLI

01:05:43.460 --> 01:05:45.420
so ein Maus-Clickable

01:05:45.420 --> 01:05:47.480
und, also mit Tastatur-UI

01:05:47.480 --> 01:05:49.560
hat zu haben. Das sieht halt so ein bisschen aus wie so ein richtiges

01:05:49.560 --> 01:05:50.700
Interface in der C-Line.

01:05:51.700 --> 01:05:52.800
Ja, genau.

01:05:53.300 --> 01:05:54.280
Und ja.

01:05:55.000 --> 01:05:56.780
Und Pidentic hat halt auch je eine Menge

01:05:56.780 --> 01:05:58.320
Venture Capital genommen.

01:05:58.960 --> 01:06:01.440
Ja gut, würde ich aber gerne die, würde ich gerne mal

01:06:01.440 --> 01:06:03.360
sehen, wie das wieder raus wird. Aber gut, das werden wir ja dann

01:06:03.360 --> 01:06:05.260
alle sehen. Das werden wir alle sehen, das werden wir alle spüren.

01:06:05.380 --> 01:06:07.020
Das werden wir alle an unseren Daumen spüren.

01:06:07.780 --> 01:06:09.260
Hoffentlich werden die Schrauben

01:06:09.260 --> 01:06:10.900
nicht zu spitz sein, die sie uns da reindrehen.

01:06:11.020 --> 01:06:12.880
Aber es ist mit, ich höre,

01:06:13.100 --> 01:06:14.880
es klingt, also ich, ja.

01:06:15.380 --> 01:06:17.080
Ja, Juvie, also gut, kann ich auch

01:06:17.080 --> 01:06:18.980
durchaus sofort nicht. Ich würde sagen, das ist tatsächlich

01:06:18.980 --> 01:06:21.080
so die Lösung für Python-Packaging-Probleme,

01:06:21.160 --> 01:06:22.860
auf die wir lange gewartet haben.

01:06:23.360 --> 01:06:24.780
Also jetzt ohne mich so weit aus dem Fenster zu treiben.

01:06:24.940 --> 01:06:26.420
Sieht ein bisschen danach aus. Auch für mich ist

01:06:26.420 --> 01:06:28.520
das jetzt tatsächlich alles das, was

01:06:28.520 --> 01:06:30.740
PipTools sonst macht. Und ja, wenn es

01:06:30.740 --> 01:06:32.680
das gleiche macht wie PipTools und es schneller, naja gut,

01:06:32.820 --> 01:06:34.080
dann... Ja, genau. Bei mir ist halt

01:06:34.080 --> 01:06:36.960
Pultree ist weg. Gekauft.

01:06:37.060 --> 01:06:38.880
Kommt UV rein und dann musst du

01:06:38.880 --> 01:06:40.700
noch in die gleichen...

01:06:40.700 --> 01:06:42.880
Genau, dann ist es doch ein guter Pick. Aber ich habe noch einen zweiten.

01:06:43.240 --> 01:06:44.860
Noch einen. Ich halte das mal hier in die Kamera.

01:06:44.860 --> 01:06:46.560
aber ihr Zuhörer könnt das nicht sehen.

01:06:46.560 --> 01:06:47.600
Oh, The Nature of Code.

01:06:48.000 --> 01:06:49.540
Ich habe hier The Nature of Code.

01:06:50.740 --> 01:06:52.560
Simulating Natural Systems with JavaScript.

01:06:52.840 --> 01:06:54.740
Ich weiß, es ist JavaScript und es ist schade,

01:06:54.860 --> 01:06:56.480
dass es JavaScript ist, aber es gibt

01:06:56.480 --> 01:06:58.700
eine Python-Adaptierung

01:06:58.700 --> 01:06:59.760
davon von Daniel Schiffman.

01:07:00.300 --> 01:07:02.900
Da ist jetzt am 3. September

01:07:02.900 --> 01:07:04.700
die zweite Auflage herausgekommen

01:07:04.700 --> 01:07:05.800
und

01:07:05.800 --> 01:07:08.300
da gibt es auch eine Videoserie dazu.

01:07:08.420 --> 01:07:10.600
Der Daniel Schiffman, der ist Professor, ich glaube,

01:07:10.600 --> 01:07:12.460
in New York an irgendeiner Universität

01:07:12.460 --> 01:07:14.600
und der macht auch regelmäßige Videostreams.

01:07:14.860 --> 01:07:17.500
der benutzt p5.js

01:07:17.500 --> 01:07:18.920
das ist eine Variante von

01:07:18.920 --> 01:07:21.200
Processing, also es ist quasi

01:07:21.200 --> 01:07:22.840
Processing in Javascript

01:07:22.840 --> 01:07:25.220
da gibt es auch tatsächlich

01:07:25.220 --> 01:07:27.460
es gibt auch pi5 heißt es glaube ich

01:07:27.460 --> 01:07:28.940
das ist die Python Variante

01:07:28.940 --> 01:07:30.240
die genauso ist

01:07:30.240 --> 01:07:33.100
und er

01:07:33.100 --> 01:07:35.540
erklärt einfach Javascript Programmierung

01:07:35.540 --> 01:07:36.900
anhand von so

01:07:36.900 --> 01:07:38.620
Simulationsbeispielen, anhand von

01:07:38.620 --> 01:07:41.140
hier ist jetzt mal ein Punkt

01:07:41.140 --> 01:07:43.340
wie können wir dafür sorgen, dass der sich bewegt

01:07:43.340 --> 01:07:44.780
und wie können wir dafür sorgen, dass der sich

01:07:44.780 --> 01:07:46.720
hübsch bewegt und wie können wir dafür sorgen, dass

01:07:46.720 --> 01:07:48.820
der irgendwie lustige Bewegungen

01:07:48.820 --> 01:07:50.500
macht und am Ende von jedem Kapitel ist noch eine

01:07:50.500 --> 01:07:52.920
Aufforderung, hier probier doch mal

01:07:52.920 --> 01:07:54.660
hier folgende Dinge damit zu simulieren

01:07:54.660 --> 01:07:56.660
und probier doch mal was aus, probier was passiert

01:07:56.660 --> 01:07:58.540
wenn du diesen, das und jenes

01:07:58.540 --> 01:08:00.440
veränderst. Das ist

01:08:00.440 --> 01:08:02.400
in den ersten Kapiteln, also ich hab jetzt hier so

01:08:02.400 --> 01:08:04.780
ungefähr ein Sechstel

01:08:04.780 --> 01:08:05.640
durch,

01:08:06.380 --> 01:08:07.680
ist es sehr basic,

01:08:08.840 --> 01:08:10.880
sehr, ja das hier ist eine Variable

01:08:10.880 --> 01:08:12.500
und das hier ist ein Array und das ist

01:08:12.500 --> 01:08:14.520
eine, und hier kannst du

01:08:14.520 --> 01:08:16.480
eine Methode aufrufen. Was ist überhaupt eine Methode?

01:08:16.560 --> 01:08:18.620
Und nicht vergessen, this bedeutet immer das aktuelle Objekt

01:08:18.620 --> 01:08:18.860
und so.

01:08:21.140 --> 01:08:22.500
Das wird, glaube ich, in den

01:08:22.500 --> 01:08:24.680
späteren Kapiteln noch deutlich interessanter,

01:08:24.800 --> 01:08:26.680
weil da habt ihr Videos gesehen

01:08:26.680 --> 01:08:28.640
und da kommen doch

01:08:28.640 --> 01:08:30.460
spannende Dinge zutage, die man

01:08:30.460 --> 01:08:32.380
damit machen kann. Aber es ist

01:08:32.380 --> 01:08:34.640
eben sehr spielerisch. Es ist sehr, du siehst

01:08:34.640 --> 01:08:36.200
immer was. Es bewegt sich immer was.

01:08:36.400 --> 01:08:38.720
Es ist immer mausklickbar

01:08:38.720 --> 01:08:40.440
und es ist immer irgendwie

01:08:40.440 --> 01:08:42.720
anschaubar.

01:08:44.520 --> 01:08:46.060
Das gefällt mir sehr gut.

01:08:46.140 --> 01:08:47.340
Das ist eine sehr gute Technik,

01:08:47.940 --> 01:08:50.240
wie man immer was hat, was interessant ist.

01:08:50.760 --> 01:08:51.880
Und nicht nur...

01:08:51.880 --> 01:08:52.960
Ich erinnere mich an die Steuerung.

01:08:53.220 --> 01:08:55.940
Die im Weltraum steuern sollen und sowas.

01:08:57.480 --> 01:08:58.320
Das klingt danach

01:08:58.320 --> 01:08:58.960
als wenn ich schon an Punkte bin.

01:08:58.960 --> 01:09:00.020
Deshalb ist das mein zweiter Pick.

01:09:00.080 --> 01:09:01.620
The Nature of Code von Daniel Schiffman.

01:09:02.020 --> 01:09:04.420
Gerade neu rausgekommen, auch wundervolles Cover

01:09:04.420 --> 01:09:06.520
mit einer brillanten

01:09:06.520 --> 01:09:09.600
rosafarbenen

01:09:09.600 --> 01:09:10.960
Simulation.

01:09:12.440 --> 01:09:13.760
Und auch innen drin,

01:09:13.980 --> 01:09:16.280
sehr schön hier, dass die Innenseite des Einbands

01:09:16.280 --> 01:09:18.160
führt dieses Muster fort. Das finde ich

01:09:18.160 --> 01:09:19.740
sehr schön. Ah, hervorragend.

01:09:20.220 --> 01:09:21.960
Ja, was mir da noch ganz kurz

01:09:21.960 --> 01:09:23.740
zu einfällt, ist, ich habe letztens

01:09:23.740 --> 01:09:26.080
eine Podcast-Episode gehört mit

01:09:26.080 --> 01:09:28.040
na, wie heißt

01:09:28.040 --> 01:09:29.380
er noch? David Crockford,

01:09:30.700 --> 01:09:31.840
der, also

01:09:31.840 --> 01:09:34.080
JavaScript. Der Urvater des

01:09:34.080 --> 01:09:36.000
JavaScript. Ja, viel mit JavaScript gemacht hat

01:09:36.000 --> 01:09:37.800
und auch da irgendwie, das ist eines der besten

01:09:37.800 --> 01:09:39.960
Bücher, der geschrieben hat, das irgendwie relativ

01:09:39.960 --> 01:09:41.500
knackig und kurz ist.

01:09:42.460 --> 01:09:43.880
Und der

01:09:43.880 --> 01:09:46.260
Ach genau, der auch sich den Jason-Standard

01:09:46.260 --> 01:09:47.200
ausgedacht hat und so.

01:09:50.600 --> 01:09:51.940
Ich wusste gar nicht, wie hartnäckig

01:09:51.940 --> 01:09:54.220
die XML-Crowd

01:09:54.220 --> 01:09:55.520
an der Stelle irgendwie

01:09:55.520 --> 01:09:58.100
angepisst war davon. Aber er meinte,

01:09:58.260 --> 01:09:59.740
er hätte wirklich Todesdrogen gekriegt

01:09:59.740 --> 01:10:01.740
von Leuten aus der XML-Community.

01:10:02.920 --> 01:10:03.300
Und

01:10:03.300 --> 01:10:05.660
war da auch nicht so richtig amüsiert drüber.

01:10:06.140 --> 01:10:06.940
Links, links bitte.

01:10:08.560 --> 01:10:09.980
Den Podcast verlinke ich mal.

01:10:10.340 --> 01:10:11.940
Aber der hat nämlich dann nebenher

01:10:11.940 --> 01:10:13.480
noch was anderes Interessantes gemacht, nämlich

01:10:13.480 --> 01:10:15.040
dann, also einmal, also

01:10:15.040 --> 01:10:16.920
ansonsten waren so ein paar sehr coole

01:10:16.920 --> 01:10:19.380
Aussagen dabei, sowas wie, naja,

01:10:19.520 --> 01:10:21.220
also wurde dann gefragt,

01:10:21.340 --> 01:10:23.700
wie ist ein TypeScript, ist das irgendwie eine sinnvolle Weiterentwicklung

01:10:23.700 --> 01:10:25.540
von, und ist das gut und so?

01:10:26.040 --> 01:10:26.940
Und dann war ich so, ja,

01:10:27.600 --> 01:10:29.480
also wenn es irgendwie den .NET-Entwicklern

01:10:29.480 --> 01:10:31.420
das irgendwie einfacher macht, irgendwie,

01:10:31.600 --> 01:10:33.260
dass sie da jetzt JavaScript schreiben müssen,

01:10:33.800 --> 01:10:35.480
dann ist das wohl okay, also ich brauche

01:10:35.480 --> 01:10:37.300
das jetzt nicht, aber so.

01:10:38.520 --> 01:10:38.960
Okay.

01:10:40.300 --> 01:10:40.740
Naja.

01:10:42.000 --> 01:10:42.920
Der hatte

01:10:42.920 --> 01:10:44.860
so eine interessante

01:10:44.860 --> 01:10:46.680
Hobbygeschichte. Und zwar meinte er,

01:10:46.680 --> 01:10:48.420
er interessiert sich eigentlich sehr stark für Mathematik und so.

01:10:49.320 --> 01:10:50.820
Aber jetzt nicht so für die komplizierten Sachen,

01:10:50.960 --> 01:10:52.700
sondern so die einfachen, basic

01:10:52.700 --> 01:10:53.900
Geschichten. Der findet die voll toll.

01:10:54.560 --> 01:10:56.680
Und deswegen, weil er findet, diese Teile

01:10:56.680 --> 01:10:58.660
der Mathematik kriegen immer irgendwie zu wenig Liebe

01:10:58.660 --> 01:11:00.580
ab. Und es gibt da so

01:11:00.580 --> 01:11:02.020
komische Sachen, wie zum Beispiel meinte er,

01:11:02.660 --> 01:11:04.560
also wisst ihr eigentlich, was eine Hypotenuse

01:11:04.560 --> 01:11:05.860
ist oder so?

01:11:06.580 --> 01:11:07.620
Wisst ihr, wie man das schreibt?

01:11:08.360 --> 01:11:10.680
Und so, also, keine Ahnung.

01:11:10.840 --> 01:11:12.620
Ja, also, das war es

01:11:12.620 --> 01:11:14.220
tatsächlich kaum jemand, aber dabei ist das

01:11:14.220 --> 01:11:16.340
total wichtig, also auch so gerade für so ganz einfache

01:11:16.340 --> 01:11:17.980
Sachen. Das ist halt die

01:11:17.980 --> 01:11:19.760
lange Seite in einem Dreieck.

01:11:20.540 --> 01:11:21.500
Ja, warum nennen wir das nicht einfach...

01:11:21.500 --> 01:11:23.880
Ja, also ich meine,

01:11:24.120 --> 01:11:26.180
natürlich gibt es auch Dreiecke,

01:11:26.320 --> 01:11:28.220
die haben, das sind die Seiten gleich lang und so, aber

01:11:28.220 --> 01:11:30.380
warum nennen wir das nicht einfach die lange Seite?

01:11:31.080 --> 01:11:31.780
Das wäre viel einfacher.

01:11:32.180 --> 01:11:34.240
Wenn wir das immer Hypotenuse nennen, das ist einfach...

01:11:34.240 --> 01:11:35.940
Weil es nicht griechisch ist, ist nicht cool genug.

01:11:36.100 --> 01:11:38.020
Ja, genau, ist nicht cool genug, aber es verwirrt halt

01:11:38.020 --> 01:11:40.060
viele Leute und schreckt halt ab

01:11:40.060 --> 01:11:42.260
und eigentlich ist es aber irgendwie gar nicht so schwierig.

01:11:42.620 --> 01:11:44.400
Ja, und er nannte

01:11:44.400 --> 01:11:45.940
dieses Gebiet, was er da

01:11:45.940 --> 01:11:49.100
beschäftigt hat, Lower Mathematics.

01:11:49.780 --> 01:11:50.640
Im Gegensatz zu den

01:11:50.640 --> 01:11:52.020
Zweier Mathematics.

01:11:52.380 --> 01:11:53.120
So großartig.

01:11:53.980 --> 01:11:56.480
Da gibt es ganz viel Kraft, der sich so über die Jahrhunderte

01:11:56.480 --> 01:11:58.380
angesammelt hat. Das kann man eigentlich alles mal wegmachen.

01:11:58.840 --> 01:12:00.620
Endlich. Nieder mit den Griechen.

01:12:00.860 --> 01:12:01.020
Das stimmt.

01:12:02.480 --> 01:12:04.200
Ja, und es gibt auch ganz viele

01:12:04.200 --> 01:12:06.120
Notationssachen und ganz viele so

01:12:06.120 --> 01:12:08.080
Benennungssachen, die einfach so wildkürlich sind.

01:12:08.080 --> 01:12:08.480
Latein.

01:12:09.880 --> 01:12:11.260
Ja, und die auch die

01:12:11.260 --> 01:12:13.540
die Didaktik einfach kaputt

01:12:13.540 --> 01:12:15.560
machen, wo du halt durch musst.

01:12:16.020 --> 01:12:17.360
Nur weil du den höheren Sinn davon noch nicht

01:12:17.360 --> 01:12:19.300
verstanden hast, Johannes. Genau, weil

01:12:19.300 --> 01:12:20.780
die Higher Mathematics, weil wir

01:12:20.780 --> 01:12:23.340
haben das lernen müssen. Dann müssen

01:12:23.340 --> 01:12:25.020
die jungen Leute das heute auch lernen und so

01:12:25.020 --> 01:12:26.620
scheißigen alle, ob das richtig ist oder nicht.

01:12:28.360 --> 01:12:29.440
Okay, na gut.

01:12:29.720 --> 01:12:31.080
Also ich tippe natürlich wieder was

01:12:31.080 --> 01:12:32.340
Unsinniges und zwar

01:12:32.340 --> 01:12:34.420
einen schönen Tipp bekommen. Ihr wisst ja, ich mache Musik.

01:12:35.100 --> 01:12:36.680
Ich mache eine Rechnung mit der

01:12:36.680 --> 01:12:38.540
BESPOKE geschickt.

01:12:39.920 --> 01:12:40.960
BESPOKE sind, so kommt das.

01:12:41.260 --> 01:12:42.420
ein kommerzielles Produkt auch.

01:12:43.080 --> 01:12:45.200
Also eine DAW, also eine digitale

01:12:45.200 --> 01:12:46.700
Audio-Workstation, mit der man

01:12:46.700 --> 01:12:49.060
Live-Coding machen kann für Musik.

01:12:50.200 --> 01:12:51.440
Was Python

01:12:51.440 --> 01:12:53.540
Live-Coding-Access

01:12:53.540 --> 01:12:55.220
so gibt, was eigentlich sehr nice ist,

01:12:55.260 --> 01:12:57.080
wenn man so ein bisschen modular mag

01:12:57.080 --> 01:12:59.000
oder Musik machen mag, da kann man seine einzelnen

01:12:59.000 --> 01:13:00.680
Instrumente und Filter und sowas

01:13:00.680 --> 01:13:03.080
in Kette schalten, die alle über den Interpreter

01:13:03.080 --> 01:13:05.180
coden und sich da Funktionen für bauen

01:13:05.180 --> 01:13:07.220
und so. Sieht ganz nice aus, finde ich.

01:13:07.760 --> 01:13:09.100
Ah, hast du eigentlich den

01:13:09.100 --> 01:13:11.000
Vortrag von

01:13:11.000 --> 01:13:13.220
Lukas Schlanger auf der EuroPython.

01:13:13.400 --> 01:13:15.520
Ja, ich war live da, weil das natürlich geil war, weil er hat auch

01:13:15.520 --> 01:13:17.540
sein Modular-Ding mitgenommen. Ich habe ihn da vorher ein bisschen

01:13:17.540 --> 01:13:19.520
belästigt, habe mir das ein bisschen angeguckt, habe ihn bequatscht

01:13:19.520 --> 01:13:21.700
und er hatte noch einige andere nette Sachen da rumstehen,

01:13:21.840 --> 01:13:22.700
die Spaß gemacht haben.

01:13:22.880 --> 01:13:25.420
Was viele Leute nicht verstanden haben, ist, dass das

01:13:25.420 --> 01:13:27.360
auch nur funktioniert hat, so wie das

01:13:27.360 --> 01:13:29.660
mit quasi

01:13:29.660 --> 01:13:31.440
Nogel Free Threading

01:13:31.440 --> 01:13:33.440
und dass es halt ein Showcase dafür war, aber dass

01:13:33.440 --> 01:13:35.480
das irgendwie keiner verstanden hat und er war so ein bisschen enttäuscht,

01:13:35.480 --> 01:13:36.940
dass das irgendwie nicht so richtig angekommen ist.

01:13:36.940 --> 01:13:39.280
Ja, die Leute haben einfach gedacht, das macht halt irgendwie Musik, aber das

01:13:39.280 --> 01:13:41.260
war tatsächlich, ja, deswegen

01:13:41.260 --> 01:13:42.080
ganz gut möglich. Aber

01:13:42.080 --> 01:13:45.320
ja, das war tatsächlich einer der Punkte, wo ich

01:13:45.320 --> 01:13:47.180
auch sagen würde, ey, das ist so, Live-Coding macht damit

01:13:47.180 --> 01:13:49.400
schon sehr viel Spaß. Er hat halt dann die Sachen auch alle vorbereitet,

01:13:49.480 --> 01:13:51.080
ne, das war mit dem neuen Rappel von 3.13

01:13:51.080 --> 01:13:53.340
auch möglich. Genau, er hatte auch die neue Rappel und

01:13:53.340 --> 01:13:55.180
hatte da so lustige Dinge, dass er

01:13:55.180 --> 01:13:55.460
halt

01:13:55.460 --> 01:13:58.240
dieses, na,

01:13:59.160 --> 01:14:01.140
er konnte

01:14:01.140 --> 01:14:02.520
auf einen Knopfdruck das Bild von

01:14:02.520 --> 01:14:04.660
Cormac einbilden, das war auch sehr geil.

01:14:05.380 --> 01:14:06.940
Dem du Menschen, von dem du auch schon ein paar Mal

01:14:06.940 --> 01:14:08.800
geschrieben hast. Genau. Ja, es war

01:14:08.800 --> 01:14:11.440
ziemlich lustig und ja, aber er hat mit dem

01:14:11.440 --> 01:14:13.180
Euroreg, also für meine Fälle ist er relativ wenig gemacht,

01:14:13.240 --> 01:14:14.960
er hat halt einmal seine Synth-Stimme vorher eingestellt,

01:14:15.460 --> 01:14:17.320
out of theater

01:14:17.320 --> 01:14:19.440
und das hat halt schöne Musik gemacht

01:14:19.440 --> 01:14:20.680
und er hat halt ein bisschen getriggert,

01:14:21.080 --> 01:14:22.360
war halt eigentlich nur ein

01:14:22.360 --> 01:14:25.200
Instrument, was dann ein paar Töne gespielt hat und die Töne

01:14:25.200 --> 01:14:27.120
hat er aber halt dann gar nicht mehr, also er hat

01:14:27.120 --> 01:14:29.020
ein bisschen generieren lassen aus seiner Tonleiter, aus dem

01:14:29.020 --> 01:14:31.180
Python-Interpreter, ich glaube er hat, ja,

01:14:31.560 --> 01:14:32.640
welches, ich weiß gar nicht mehr, welche

01:14:32.640 --> 01:14:33.900
Lip er genommen hat,

01:14:35.540 --> 01:14:37.080
irgendwas Cooles mit MIDI-Access

01:14:37.080 --> 01:14:38.980
und der hat über MIDI-Daten halt angesteuert,

01:14:39.060 --> 01:14:39.920
über so ein MIDI-Gate.

01:14:41.920 --> 01:14:43.100
Naja, aber es gibt dieses

01:14:43.100 --> 01:14:43.740
andere

01:14:43.740 --> 01:14:46.280
Bespoke-Synth.

01:14:47.640 --> 01:14:48.420
Sieht ganz gut aus.

01:14:49.400 --> 01:14:51.340
Ich habe es aber noch nicht selber ausprobiert, aber das steht auf meiner Liste

01:14:51.340 --> 01:14:52.780
und ich muss das unbedingt gerne tun, weil

01:14:52.780 --> 01:14:55.280
Synthesizer

01:14:55.280 --> 01:14:57.080
und so gibt es auch.

01:14:57.720 --> 01:14:59.140
Ja, das ist auch ein tiefes Feld.

01:15:00.140 --> 01:15:01.160
Ich weiß nicht, wer ein Morgenbord

01:15:01.160 --> 01:15:02.580
auf Löten hat, wenn ich den Morgen löten

01:15:02.580 --> 01:15:04.660
Module bauen.

01:15:04.940 --> 01:15:05.520
Was lötest du?

01:15:07.080 --> 01:15:09.980
tatsächlich ein USB-Modul

01:15:09.980 --> 01:15:10.540
von

01:15:10.540 --> 01:15:12.720
dem Stefan.

01:15:14.240 --> 01:15:14.380
Egal.

01:15:14.380 --> 01:15:15.380
Ein USB-Modul vom Stefan.

01:15:15.520 --> 01:15:16.880
Ja, SC-Modular.

01:15:19.380 --> 01:15:20.420
Wo gehst du löten?

01:15:21.140 --> 01:15:22.240
Bei so einer,

01:15:22.920 --> 01:15:24.020
wie nennt man das, Kollektiv?

01:15:25.660 --> 01:15:26.280
Es gibt ja so

01:15:26.280 --> 01:15:27.980
Hacker-Kollektive, es gibt so Musik-Kollektive

01:15:27.980 --> 01:15:29.380
und so und ja,

01:15:29.800 --> 01:15:31.760
machen wir ein bisschen Musik und hören modulare Sachen.

01:15:31.860 --> 01:15:32.580
Und dann wird gelötet.

01:15:33.080 --> 01:15:34.660
Genau, weil ich habe so ein paar Module

01:15:34.660 --> 01:15:36.860
und bei so einem Elektronik, das ist fürchterlich,

01:15:36.920 --> 01:15:38.460
wenn man einmal anfängt mit diesem ganzen Quatsch und dann

01:15:38.460 --> 01:15:40.620
Widerstände in

01:15:40.620 --> 01:15:41.680
tausender Packs und so.

01:15:43.540 --> 01:15:43.900
Ja.

01:15:45.480 --> 01:15:45.840
Schön.

01:15:46.440 --> 01:15:48.800
Man kann die auch in den hunderter Packs kaufen, die kosten genauso viel

01:15:48.800 --> 01:15:49.640
wie die tausend. Ja, genau.

01:15:51.140 --> 01:15:52.860
Ich glaube, ich brauche sie auch in zehner Packs kaufen.

01:15:53.000 --> 01:15:54.220
Die kosten so viel wie die hunderter Packs.

01:15:55.520 --> 01:15:56.560
Ja, du kennst dich aus.

01:15:56.980 --> 01:15:57.080
Ja.

01:15:58.300 --> 01:16:00.660
Ja, tatsächlich. Ja, okay. Ich wollte nur

01:16:00.660 --> 01:16:01.460
kurz abschweifen.

01:16:02.720 --> 01:16:04.640
Ja, voll gut. Ja, also herzlichen Dank fürs Zuhören

01:16:04.640 --> 01:16:05.980
und dafür, dass ihr dabei wart.

01:16:06.360 --> 01:16:08.760
Schreibt mal ein bisschen wieder rein, Feedback und Kritik

01:16:08.760 --> 01:16:09.960
und Liebe und so alles an

01:16:09.960 --> 01:16:11.480
hallo-at-peisen-podcast.de

01:16:11.480 --> 01:16:13.700
Vielen Dank, Johannes.

01:16:14.820 --> 01:16:15.820
Danke euch allen.

01:16:16.420 --> 01:16:17.760
Vielen Dank. Bis bald.

01:16:17.940 --> 01:16:18.600
Bis zum nächsten Mal.