WEBVTT

00:00:00.000 --> 00:00:05.240
Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python-Podcast, Episode 53 mit PyTest.

00:00:05.240 --> 00:00:06.200
Hi Jochen.

00:00:06.200 --> 00:00:08.060
Ja, hallo Dominik, willkommen.

00:00:08.060 --> 00:00:11.000
Ja, mein Gast dabei, und zwar den Florian. Hey Florian.

00:00:11.000 --> 00:00:11.420
Hallo.

00:00:11.420 --> 00:00:12.700
Ja, hallo zusammen.

00:00:12.700 --> 00:00:16.280
Ja, wir haben gehört, du machst ja öfter mal was mit PyTest und dann haben wir gedacht,

00:00:16.280 --> 00:00:18.960
dann fragen wir dich doch einfach mal, ob du mich was darüber erzählen magst.

00:00:18.960 --> 00:00:22.920
Genau. Ich weiß nicht, vielleicht magst du ja einfach mal so ein bisschen erzählen,

00:00:22.920 --> 00:00:28.520
was du so tust oder irgendwie, warum PyTest da ein ganz gutes Thema wäre.

00:00:30.000 --> 00:00:33.580
Was ich so tue, ist schon eine Frage, da kann ich wahrscheinlich fünf Minuten dazu reden.

00:00:33.580 --> 00:00:35.960
Geh los.

00:00:35.960 --> 00:00:45.380
Ich mache tatsächlich so fast Vollzeit-Open-Source, und zwar kam das nicht von PyTest ursprünglich,

00:00:45.380 --> 00:00:51.520
sondern von einem anderen Projekt von mir, von Qt-Browser, da kann ich vielleicht später noch mal mehr dazu sagen.

00:00:51.520 --> 00:00:58.320
Über das Projekt bin ich dann auch zu PyTest gekommen, und was ich jetzt eigentlich mache,

00:00:58.320 --> 00:00:59.520
ist zum einen...

00:01:00.000 --> 00:01:03.500
Ich arbeite an Qt-Browser und PyTest, durch Spenden finanziert,

00:01:03.500 --> 00:01:10.500
und zum anderen gebe ich im Herbst jeweils hier an der Fachhochschule Python-Unterricht für Erstsemester-Studierende,

00:01:10.500 --> 00:01:13.320
also Bachelor-Informatik-Studierende.

00:01:13.320 --> 00:01:20.820
Also ja, ganz viel Open-Source, ganz viel auch Freiheit, sage ich mal, wann ich was mache,

00:01:20.820 --> 00:01:22.160
und eben auch viel PyTest.

00:01:22.160 --> 00:01:25.700
Ja, genau. Du bist einer der PyTest-Maintainer auch, ne?

00:01:25.700 --> 00:01:29.880
Genau. Das hat auch ganz lustig schon angefangen.

00:01:30.000 --> 00:01:34.880
Ich habe da halt eben durch Qt-Browser, durch dieses Projekt reingekommen,

00:01:34.880 --> 00:01:40.580
weil ich da Tests geschrieben hatte dafür, damals noch mit Unitest-Framework von Python,

00:01:40.580 --> 00:01:49.800
was mit Python mitkommt, und da gab es dann so ein Adopt-Pytest-Month, April 15, glaube ich, sowas.

00:01:49.800 --> 00:01:53.520
Also doch schon eine Weile her, ja.

00:01:53.520 --> 00:01:54.160
Also ein bisschen, ja.

00:01:54.160 --> 00:01:59.420
Wo dann Leute hinter PyTest, anderen Open-Source-Maintainern,

00:01:59.420 --> 00:01:59.860
anderen Projekten...

00:01:59.860 --> 00:02:02.560
anderen Projekten geholfen haben, auf PyTest umzusteigen.

00:02:02.560 --> 00:02:08.120
Da habe ich eben mitgemacht mit Qt-Browser und bin dann ziemlich schnell zu PyTest gekommen

00:02:08.120 --> 00:02:12.820
und habe angefangen, da Dinge zu verbessern, an Plugins Dinge zu implementieren,

00:02:12.820 --> 00:02:17.140
die ich halt haben wollte oder die mir aufgefallen sind.

00:02:17.140 --> 00:02:21.260
Und dann hieß es irgendwann, ja, willst du nicht das nächste Release machen?

00:02:21.260 --> 00:02:25.180
Und ich fand halt, ja, Moment mal, ich habe ja noch nicht mal irgendwie Commit-Rechte.

00:02:25.180 --> 00:02:29.060
Und wie es halt so läuft bei Open-Source, da habe ich sie eben.

00:02:29.720 --> 00:02:31.520
Ja, cool.

00:02:31.520 --> 00:02:32.700
Ja, das klingt gut.

00:02:32.700 --> 00:02:37.320
Über die ganzen Sachen müssen wir gleich nochmal besonders reden, auch über die Plugins und so, das klingt spannend.

00:02:37.320 --> 00:02:40.980
Ich würde aber sagen, Jochen, wir fangen wie immer einmal mit den News an.

00:02:40.980 --> 00:02:42.360
News, okay, alles klar.

00:02:42.360 --> 00:02:47.540
Ja, ist auch ein bisschen was wieder zusammengekommen, weil jetzt die letzte Episode auch schon wieder ein bisschen was her ist.

00:02:47.540 --> 00:02:50.200
Und genau, ja, was haben wir denn so?

00:02:50.200 --> 00:02:51.900
Django 5.

00:02:51.900 --> 00:02:54.640
Django 5 ist jetzt gerade letzte Woche rausgekommen.

00:02:54.640 --> 00:02:58.560
Genau, das ist ja immer so, das kriege ich halt immer mit, weil ich muss dann immer alles umstellen.

00:02:59.580 --> 00:03:03.900
Ja, Django im Einsatz und ja, war aber diesmal sehr entspanntes Update, hat alles gut funktioniert.

00:03:03.900 --> 00:03:05.100
Ging gut, nicht wie Deprecated.

00:03:05.100 --> 00:03:10.980
Nee, also was die Verbesserung angeht, es ist auch, also es gibt ein tolles neues Ding, was halt irgendwie,

00:03:10.980 --> 00:03:15.320
ein Bug, der seit 18 Jahren offen war, ein Issue, der seit 18 Jahren offen war, der jetzt geschlossen wurde.

00:03:15.320 --> 00:03:22.080
Nämlich, da ging es darum, dass er eigentlich blöd ist, wenn man bei einem Model-Field irgendwie Default angibt,

00:03:22.080 --> 00:03:28.800
dass das halt nur dann ausgefüllt wird, wenn man irgendwie eine Zeile über, also das Modell tatsächlich über Django,

00:03:29.440 --> 00:03:33.400
baut und auch da ist es halt nicht immer so klar, dass das wirklich dann passiert,

00:03:33.400 --> 00:03:38.840
weil es gibt ja auch noch Bulk Create und man kann halt auf verschlungenen Wegen irgendwie Dinge erzeugen in der Datenbank.

00:03:38.840 --> 00:03:40.620
Bulk Create macht Defaults nicht rein?

00:03:40.620 --> 00:03:45.140
Nicht unbedingt, also es kann sein, dass wenn du das jetzt einfach so verwendest, dass es dann klappt.

00:03:45.140 --> 00:03:46.400
Das war mir tatsächlich neu.

00:03:46.400 --> 00:03:52.120
Aber wenn du das halt irgendwie so ein bisschen avancierter verwendest und wirklich schnell sein willst,

00:03:52.120 --> 00:03:56.680
dann kann es gut sein, dass das nicht passiert, weil ja, und das ist natürlich doof.

00:03:56.680 --> 00:03:59.340
Das hat wahrscheinlich auch mit der Funktionalität zu tun, dass man jetzt,

00:03:59.340 --> 00:04:03.000
dass man jetzt so Felder haben kann, die von anderen Feldern abhängig sind und zwar direkt im Feld

00:04:03.000 --> 00:04:05.080
und ohne das halt über die Save-Methode zu machen.

00:04:05.080 --> 00:04:10.240
Ja, nee, das weiß ich gar nicht, ob die direkt zusammenhängen, das geht jetzt auch, genau.

00:04:10.240 --> 00:04:13.300
Die Sarah hat einen tollen Blog-Antrag zugeschrieben, vielleicht kennst du den auch.

00:04:13.300 --> 00:04:15.440
Ja, gibt's auch ein Video, hat sie dazu gemacht.

00:04:15.440 --> 00:04:20.780
Genau, die macht ja hier auch die PyCologne-Meetup-Gruppe, organisiert sie mit.

00:04:20.780 --> 00:04:27.240
Ja, genau, also was jetzt geht, ist halt, dass man nicht sagt Default in einem Model-Field,

00:04:27.240 --> 00:04:29.280
sondern DB, Underscore.

00:04:29.280 --> 00:04:29.320
Ja, genau, also was jetzt geht, ist halt, dass man nicht sagt Default in einem Model-Field, sondern DB, Underscore.

00:04:29.320 --> 00:04:35.540
Default, und dann wird das halt nicht nur gesetzt, wenn man halt irgendwie über Django das Ding baut,

00:04:35.540 --> 00:04:39.820
sondern halt in die Datenbank mit reingeschrieben, dass das so ist.

00:04:39.820 --> 00:04:42.160
Und ja, das ist ja schon mal ziemlich großartig.

00:04:42.160 --> 00:04:45.980
Man kann es halt auch jetzt sehen, welche Defaults es gibt, wenn man einfach nur sich das Schema anguckt

00:04:45.980 --> 00:04:49.240
und nicht irgendwie den Applikationscode dazu hat, was ja auch so ein Ding ist,

00:04:49.240 --> 00:04:51.580
dass es halt blöd ist, wenn man ein Datenbankschema hat,

00:04:51.580 --> 00:04:54.080
dass man nur verstehen kann, wenn man einen Applikationscode auch dazu legt,

00:04:54.080 --> 00:04:58.320
weil Applikationscode halt deutlich volatiler ist oft als Datenbankschema.

00:04:59.260 --> 00:05:01.260
Ja, aber also das ist jetzt ziemlich cool.

00:05:01.260 --> 00:05:05.500
Und genau, so viele haben, also ich habe immer verwendet sowas wie Timestamp-Model

00:05:05.500 --> 00:05:09.300
aus den Django-Extensions oder halt aus Django-Model-Utils,

00:05:09.300 --> 00:05:14.860
um zum Beispiel sowas wie Created-Zeitstempel oder Modified-Updated dran zu bauen.

00:05:14.860 --> 00:05:16.960
Das kann man ja jetzt halt auf eine deutlich elegantere Art machen.

00:05:16.960 --> 00:05:19.260
Ja, dann genau diese...

00:05:19.260 --> 00:05:22.420
Generated-Field heißt das, glaube ich, ne? Einfach Models, Generated-Field und dann...

00:05:22.420 --> 00:05:24.500
Generated-Field ist jetzt diese andere Geschichte, genau.

00:05:24.500 --> 00:05:29.120
Genau, da kann man dann halt auch so Dinge, manchmal möchte man ja auch irgendwas indizieren,

00:05:29.200 --> 00:05:30.460
was halt irgendwie...

00:05:30.460 --> 00:05:31.040
Ein Suchindex.

00:05:31.040 --> 00:05:35.840
Ja, was halt auf irgendwas basiert, was halt berechnet wird aus unterschiedlichen Spalten,

00:05:35.840 --> 00:05:39.860
die man halt in der Datenbank hat und nicht direkt irgendwie eine Spalte selber ist.

00:05:39.860 --> 00:05:42.740
Und das geht jetzt halt auch relativ einfach.

00:05:42.740 --> 00:05:48.100
Ja, dann gab es noch, ich habe jetzt aber ganz ehrlich gesagt vergessen, was es genau war.

00:05:48.100 --> 00:05:51.000
Es gab einige Verbesserungen an den Formularen.

00:05:51.000 --> 00:05:58.220
Also man kann jetzt irgendwie Help-Text und Label und Dinge irgendwie einfacher benutzen,

00:05:59.140 --> 00:06:00.880
dass einzelne Felder als Field-Set einfach verwendet.

00:06:00.880 --> 00:06:02.280
Dann sind die automatisch, glaube ich, mit dabei.

00:06:02.280 --> 00:06:05.060
Genau, das muss man vorher mal ganz umständlich auseinanderproben.

00:06:05.060 --> 00:06:09.360
Ja, und ja, ehrlich gesagt, mehr kann ich mich nicht erinnern.

00:06:09.360 --> 00:06:12.560
Aber ja, es ist auf jeden Fall eine coole neue Release.

00:06:12.560 --> 00:06:14.980
Ja...

00:06:14.980 --> 00:06:17.960
Du wolltest, wenn ich das richtig sehe, über diesen OpenAI...

00:06:17.960 --> 00:06:21.780
Ich weiß nicht genau, ob euch das irgendwie tangiert oder ob ihr das davon mitbekommen habt,

00:06:21.780 --> 00:06:26.660
ob ich das nur mitbekommen habe, weil ich das halt zufällig irgendwie alle immer verfolge, aber...

00:06:26.660 --> 00:06:29.060
Ja, erzähl doch erstmal, von was du da genau erzählst.

00:06:29.060 --> 00:06:29.080
Ja, ja, ja.

00:06:29.080 --> 00:06:29.440
Was du da sagen möchtest.

00:06:29.440 --> 00:06:34.320
Naja, es gab ja so leichte irgendwie Schwankungen im OpenAI-Management.

00:06:34.320 --> 00:06:35.060
Im Management, ja.

00:06:35.060 --> 00:06:37.580
Ich bin hier, ich bin doch nicht hier, ich bin wieder da, hurra.

00:06:37.580 --> 00:06:39.500
Genau, und ja.

00:06:39.500 --> 00:06:42.840
Was da so der Hintergrund ist, ich weiß es nicht.

00:06:42.840 --> 00:06:44.940
Vielleicht ist es auch etwas, wo man eigentlich gar nichts zu sagen sollte,

00:06:44.940 --> 00:06:48.740
weil es ist halt halt einen bestimmten Unterhaltungswert und das kann man...

00:06:48.740 --> 00:06:52.160
Ja, dann lass uns doch ein bisschen leichte Unterhaltung vorweg dort machen,

00:06:52.160 --> 00:06:53.700
weil man hört ja so ein paar Gerüchte.

00:06:53.700 --> 00:06:54.980
Ja, was hast du denn gehört?

00:06:54.980 --> 00:06:56.740
Ja, ich erzähl mal, ich bin erstmal gespannt.

00:06:56.740 --> 00:06:58.180
Also man hört ja immer...

00:06:58.180 --> 00:06:59.020
Ich...

00:06:59.020 --> 00:07:00.680
Ich hab ganz viel gehört, ich weiß es aber nicht.

00:07:00.680 --> 00:07:03.140
Also ich würde denken, dass die...

00:07:03.140 --> 00:07:06.300
Ja, dass der Hauptgrund halt irgendwie daran besteht,

00:07:06.300 --> 00:07:08.560
dass es halt diese komische Konstruktion gibt,

00:07:08.560 --> 00:07:12.740
dass OpenAI ja eigentlich eine Non-Profit-Organisation ist

00:07:12.740 --> 00:07:16.240
und die kontrolliert halt die kommerzielle Entität,

00:07:16.240 --> 00:07:18.140
die halt nur deswegen gegründet worden ist,

00:07:18.140 --> 00:07:22.380
weil man halt diese JetGPT-Geschichte auch als Produkt irgendwie rausbringen wollte

00:07:22.380 --> 00:07:25.780
und dann gesagt hat, okay, das können wir nicht im Rahmen von diesem Non-Profit machen,

00:07:25.780 --> 00:07:28.960
weil das wird einfach zu teuer und wir müssen da...

00:07:28.960 --> 00:07:30.600
irgendwie auch Fremdkapital haben,

00:07:30.600 --> 00:07:34.220
um das halt irgendwie alles brechen zu können und so.

00:07:34.220 --> 00:07:36.860
Und ja, im Vorfeld davon ist jetzt...

00:07:36.860 --> 00:07:38.100
Ja, der Name fällt mir nicht mehr ein.

00:07:38.100 --> 00:07:42.500
Der Gründer von Anthropic,

00:07:42.500 --> 00:07:45.220
also der Firma, die jetzt auch Claude irgendwie gebaut hat,

00:07:45.220 --> 00:07:47.440
ist also quasi ein ähnliches Ding wie JetGPT,

00:07:47.440 --> 00:07:49.780
bloß halt sozusagen von einer anderen Firma.

00:07:49.780 --> 00:07:51.440
Der war vorher bei OpenAI

00:07:51.440 --> 00:07:53.260
und der hat auch schon mal versucht,

00:07:53.260 --> 00:07:56.700
Sam Oldman vom Board feuern zu lassen.

00:07:56.700 --> 00:07:58.520
Also der hat zuerst gesagt so,

00:07:58.520 --> 00:07:58.900
hey, das ist...

00:07:58.900 --> 00:08:00.000
Das ist nicht okay, so geht das nicht.

00:08:00.000 --> 00:08:01.820
Und wenn...

00:08:01.820 --> 00:08:02.920
Das könnt ihr ja so nicht machen.

00:08:02.920 --> 00:08:04.580
Und dann hieß es so, ach doch, geht doch.

00:08:04.580 --> 00:08:06.840
Und dann hat er sich ans Board gewendet und gesagt,

00:08:06.840 --> 00:08:08.940
feuert den CEO mal,

00:08:08.940 --> 00:08:10.340
das ist irgendwie nicht okay.

00:08:10.340 --> 00:08:12.560
Und dann hat das Board drüber nachgedacht

00:08:12.560 --> 00:08:13.800
und dann haben sie gesagt, nee.

00:08:13.800 --> 00:08:15.540
Und dann hat er gesagt, gut, dann gehe ich jetzt halt.

00:08:15.540 --> 00:08:16.720
Und hat ein paar Leute mitgenommen

00:08:16.720 --> 00:08:17.900
und dann halt eine neue Firma aufgemacht.

00:08:17.900 --> 00:08:20.780
Und ja, aber das ist jetzt noch gar nicht so lange her.

00:08:20.780 --> 00:08:23.620
Ich meine, da überschlagen sich natürlich so ein bisschen die Ereignisse irgendwie.

00:08:23.620 --> 00:08:25.740
Aber das ist jetzt auch erst knapp über ein Jahr her.

00:08:25.740 --> 00:08:28.840
Und ja, offenbar...

00:08:28.840 --> 00:08:30.900
Der Rest, die neuen Sachen sind alle ziemlich closed,

00:08:30.900 --> 00:08:32.460
wenn man so ein bisschen genauer hinguckt.

00:08:32.460 --> 00:08:34.980
Ja, das ist natürlich immer so ein bisschen...

00:08:34.980 --> 00:08:37.640
Also Open AI, ich meine, der Name ist so ein bisschen...

00:08:37.640 --> 00:08:37.820
Ja.

00:08:37.820 --> 00:08:40.880
Die Proprietäre, das ist die Proprietäre und so, genau.

00:08:40.880 --> 00:08:43.280
Ja, und natürlich ist halt auch die Frage...

00:08:43.280 --> 00:08:45.280
Die Papers sind geschlossen, da sind nur noch Zusammenfassungen drin

00:08:45.280 --> 00:08:47.500
und keine richtig guten Erkenntnisse mehr und so.

00:08:47.500 --> 00:08:49.400
Ja, ja, das sind nur noch so Technical Reports.

00:08:49.400 --> 00:08:54.300
Und natürlich, also Open AI macht keine Open-Source-Modelle oder sowas.

00:08:54.300 --> 00:08:55.780
Die haben überhaupt nie irgendwas released.

00:08:55.780 --> 00:08:58.780
Und eigentlich ist ja die Mission von...

00:08:58.780 --> 00:09:03.300
dem Non-Profit sozusagen der Allgemeinheit irgendwie zu nutzen.

00:09:03.300 --> 00:09:06.120
Ja, wäre mal schön.

00:09:06.120 --> 00:09:08.420
Und dann ist halt die Frage, wie lässt sich das vereinbaren?

00:09:08.420 --> 00:09:12.140
Wenn man auf der einen Seite halt irgendwie jede Menge Risikokapital nimmt

00:09:12.140 --> 00:09:14.920
und irgendwie dann Produkte baut und dann Geld dafür einnimmt

00:09:14.920 --> 00:09:19.760
und sich im Grunde in Konkurrenz sieht mit den großen Tech-Giganten

00:09:19.760 --> 00:09:22.760
und halt auch ja von einem von denen halt ja massiv finanziert wird.

00:09:22.760 --> 00:09:26.080
Irgendwie, ich weiß nicht, Microsoft hat da irgendwie eine Milliarde reingesteckt oder so.

00:09:26.080 --> 00:09:28.720
Und halt auch eine Bewertung hat inzwischen von...

00:09:28.720 --> 00:09:31.940
weiß ich nicht, 80 Milliarden oder irgendwie ganz unglaubliche Beträge.

00:09:31.940 --> 00:09:36.920
Und ja, und dann halt auch nichts mehr in der Richtung tut,

00:09:36.920 --> 00:09:38.480
was halt die Mission eigentlich vorgibt,

00:09:38.480 --> 00:09:40.820
dann kann ich mir schon vorstellen, dass das Spannung macht

00:09:40.820 --> 00:09:42.920
und dass die Leute dann halt auch irgendwann sagen,

00:09:42.920 --> 00:09:44.280
so jetzt reicht's aber und...

00:09:44.280 --> 00:09:47.920
Also das, was ich so unter der Hand höre, ist natürlich Bullshit, wissen wir alle.

00:09:47.920 --> 00:09:49.960
Aber Q-Star haben sie gefragt und hat gesagt,

00:09:49.960 --> 00:09:50.860
vorher, ihn schmeißen raus.

00:09:50.860 --> 00:09:52.060
Bitte?

00:09:52.060 --> 00:09:54.800
Sie haben Q-Star gefragt und Q-Star hat gesagt,

00:09:54.800 --> 00:09:56.340
schmeißen raus.

00:09:56.340 --> 00:09:58.000
Das ist die nächste...

00:09:58.000 --> 00:09:58.240
Ach so.

00:09:58.660 --> 00:10:01.440
Ja, das kann man natürlich, ja.

00:10:01.440 --> 00:10:03.300
Ja, ich weiß auch nicht.

00:10:03.300 --> 00:10:04.200
Also, ja.

00:10:04.200 --> 00:10:08.120
Ja, dann gab's ja auch diese ganzen komischen Lobby-Aktivitäten,

00:10:08.120 --> 00:10:12.420
irgendwie jetzt auch was AI-Act, was sich nicht in Europa angeht und so,

00:10:12.420 --> 00:10:13.280
wo man ja auch sagen muss,

00:10:13.280 --> 00:10:17.340
Wir sind für eine AI-Regulierung, sagte der Minister.

00:10:17.340 --> 00:10:19.420
Nein, nein, ich meine, Regulierung ist ja vielleicht gar nicht so schlecht,

00:10:19.420 --> 00:10:22.200
aber sozusagen die Konkurrenz von Open AI zu regulieren,

00:10:22.200 --> 00:10:24.240
sodass man da die Regulierung um Erlaubnis fragen muss,

00:10:24.240 --> 00:10:26.520
bevor man da irgendwas machen darf, ist vielleicht...

00:10:26.520 --> 00:10:27.780
Also, ich bin...

00:10:27.780 --> 00:10:28.600
Also, Uwe...

00:10:28.600 --> 00:10:29.720
Das ist ja schon wieder ein ganz neues Fass.

00:10:29.720 --> 00:10:31.940
Das Fass will man vielleicht nicht aufmachen,

00:10:31.940 --> 00:10:34.520
aber dass man das regulieren will,

00:10:34.520 --> 00:10:35.780
dass Leute da nicht zu Schaden kommen,

00:10:35.780 --> 00:10:37.020
das kann ich durchaus nachvollziehen.

00:10:37.020 --> 00:10:38.140
Ja, und nein.

00:10:38.140 --> 00:10:40.440
Ja, also, ich finde, das ist...

00:10:40.440 --> 00:10:41.160
Aber das ist ja...

00:10:41.160 --> 00:10:42.200
Da kann man wenig gegen sagen.

00:10:42.200 --> 00:10:42.760
Also, man sagt...

00:10:42.760 --> 00:10:44.200
Nein, nein, der Wunsch ist richtig, würde ich sagen.

00:10:44.200 --> 00:10:44.540
Ja.

00:10:44.540 --> 00:10:47.980
Also, aber dass man jetzt die Technik selber reguliert,

00:10:47.980 --> 00:10:48.800
das finde ich halt komisch.

00:10:48.800 --> 00:10:49.100
Ja, genau.

00:10:49.100 --> 00:10:50.820
Weil das ist halt irgendwie...

00:10:50.820 --> 00:10:53.300
Und, ja, da gab's halt diverse Lobby-Beschreibungen.

00:10:53.300 --> 00:10:54.920
Ja, die Frage ist halt, wie das halt überhaupt geht,

00:10:54.920 --> 00:10:56.720
ohne dass man jetzt den Stecker zieht oder so.

00:10:56.720 --> 00:10:57.000
Ja.

00:10:57.000 --> 00:10:58.540
Naja.

00:10:58.540 --> 00:11:00.220
Ja, jedenfalls ist es ja jetzt auch nicht so gekommen.

00:11:00.220 --> 00:11:01.980
Es ist jetzt die Richtlinie...

00:11:01.980 --> 00:11:05.220
Das ist ja noch nicht unter Dach und Fach.

00:11:05.220 --> 00:11:06.600
Es ist ja bloß irgendwie sozusagen...

00:11:06.600 --> 00:11:07.660
Es gibt ein Verhaltensergebnis,

00:11:07.660 --> 00:11:09.940
auch irgendwie seit letzter Woche oder so was.

00:11:09.940 --> 00:11:12.060
Das sagt ja auch im Grunde, ja, im Wesentlichen,

00:11:12.060 --> 00:11:14.160
wir regulieren halt die Anwendung,

00:11:14.160 --> 00:11:15.300
aber nicht die Technik selber.

00:11:15.300 --> 00:11:17.280
Ja, Transparenz regeln wir halt ganz gut, ne?

00:11:17.280 --> 00:11:18.800
Nach dem Motto, du musst das Modell halt irgendwie...

00:11:18.800 --> 00:11:20.860
Ja, Open Source ist halt explizit ausgenommen.

00:11:20.860 --> 00:11:21.920
Das ist halt schon mal großartig.

00:11:21.920 --> 00:11:25.080
Was halt bedeutet, okay, wenn ich jetzt hingehen will

00:11:25.080 --> 00:11:28.480
und sage, okay, ich mache hier meine eigene Suchmaschine

00:11:28.480 --> 00:11:30.040
oder so auf internen Dokumenten,

00:11:30.040 --> 00:11:31.680
die halt irgendwie besser funktionieren soll,

00:11:31.680 --> 00:11:34.420
dann muss ich nicht OpenAI fragen,

00:11:34.420 --> 00:11:36.180
sondern dann kann ich das halt irgendwie selber machen.

00:11:36.180 --> 00:11:37.700
Kann ich mir in Lama feintunen oder was auch immer,

00:11:37.700 --> 00:11:38.740
Mistral oder was auch immer

00:11:38.740 --> 00:11:40.760
und kann das halt einfach machen

00:11:40.760 --> 00:11:43.200
und es ist nicht verboten, einfach so.

00:11:43.200 --> 00:11:45.800
Ja, also genau.

00:11:45.800 --> 00:11:46.760
Also schon mal...

00:11:46.760 --> 00:11:48.560
Also im Grunde ist eigentlich alles halbwegs okay.

00:11:48.560 --> 00:11:51.220
Und Sam Altman ist ja auch wieder zurück zu OpenAI,

00:11:51.220 --> 00:11:52.120
heißt ja auch wieder alles okay.

00:11:52.120 --> 00:11:55.420
Und ich glaube, das mit dem...

00:11:55.420 --> 00:11:58.040
mit der...

00:11:58.040 --> 00:11:58.420
mit dem Nutzen für die Gesellschaft

00:11:58.420 --> 00:11:59.600
das kriegen sie bestimmt auch noch hin.

00:11:59.600 --> 00:12:02.600
Ich glaube nicht, dass ihnen da das Geld zu Kopf steigt

00:12:02.600 --> 00:12:04.660
oder da irgendwie das irgendwas dran machen kann,

00:12:04.660 --> 00:12:05.780
wenn da jemand eine Milliarde investiert.

00:12:05.780 --> 00:12:06.880
Nein, nein, das ist überhaupt gar keine Gefahr.

00:12:06.880 --> 00:12:08.980
Das ist, glaube ich, kein Problem für die.

00:12:08.980 --> 00:12:10.380
Nein, niemals.

00:12:10.380 --> 00:12:12.840
Warum sollte denn niemals irgendwie sich jemand korrumpieren lassen?

00:12:12.840 --> 00:12:14.500
Ja, also, nee, nee.

00:12:14.500 --> 00:12:15.740
Ja.

00:12:15.740 --> 00:12:17.240
Ja.

00:12:17.240 --> 00:12:19.840
Und ich meine, das Board hat ja schon gezeigt,

00:12:19.840 --> 00:12:21.520
dass sie da irgendwie absolut in der Lage sind,

00:12:21.520 --> 00:12:23.140
auch das zu kontrollieren und durchzusetzen,

00:12:23.140 --> 00:12:24.820
wenn sie finden, dass das nicht okay ist.

00:12:28.360 --> 00:12:30.040
Daher, ich habe da überhaupt gar keine Bedingungen.

00:12:30.040 --> 00:12:31.400
Ja, okay.

00:12:31.400 --> 00:12:33.640
Also, das war sozusagen die leichte Unterhaltung zum Thema.

00:12:33.640 --> 00:12:34.960
Ja, das war die leichte Unterhaltung zum Thema.

00:12:34.960 --> 00:12:37.100
Kurz vor Weihnachten noch mal ein bisschen Advent.

00:12:37.100 --> 00:12:37.920
Ja.

00:12:37.920 --> 00:12:41.160
Advent of God und was kann man auch wieder spielen?

00:12:41.160 --> 00:12:43.880
Ja, genau.

00:12:43.880 --> 00:12:44.580
Was hatten wir noch so?

00:12:44.580 --> 00:12:46.120
News.

00:12:46.120 --> 00:12:47.960
Du hast noch eine wichtige News.

00:12:47.960 --> 00:12:48.960
Naja, wichtig.

00:12:48.960 --> 00:12:50.140
Für Python.

00:12:50.140 --> 00:12:50.540
Ja.

00:12:50.540 --> 00:12:51.360
Ja.

00:12:51.360 --> 00:12:52.040
Gill Removal.

00:12:52.040 --> 00:12:54.360
Genau, Gill Removal ist beschlossene Sache.

00:12:54.360 --> 00:12:56.000
Wer sich dafür interessiert,

00:12:56.000 --> 00:12:56.780
es gibt da einen schönen...

00:12:56.780 --> 00:12:57.700
Es gibt einen neuen Podcast.

00:12:58.360 --> 00:12:59.620
Ich weiß auch nicht, ob wir den schon erwähnt hatten.

00:12:59.620 --> 00:13:01.140
Core-PY heißt der.

00:13:01.140 --> 00:13:07.280
Ist irgendwie von Lukas Langer und Pablo Galindo Salgado.

00:13:07.280 --> 00:13:12.060
Irgendwie den Release-Managern für die letzten beiden Versionen.

00:13:12.060 --> 00:13:19.540
Die machen den und reden halt über so CPython-interne Geschichten.

00:13:19.540 --> 00:13:21.560
Zum Beispiel war das die erste Episode,

00:13:21.560 --> 00:13:26.800
war über den CPython-Core-Dev-Sprint oder halt andere Themen,

00:13:26.800 --> 00:13:27.560
wie zum Beispiel jetzt, dass es dann...

00:13:28.300 --> 00:13:28.400
Ja.

00:13:28.400 --> 00:13:32.120
Just-in-Time-Compiler irgendwie für 3.13 wohl geben soll

00:13:32.120 --> 00:13:33.260
und solche Dinge.

00:13:33.260 --> 00:13:37.820
Und da gab es jetzt auch eine Episode über das Entfernen von Gill,

00:13:37.820 --> 00:13:40.500
was halt eine komplizierte Geschichte ist und viel Arbeit wird.

00:13:40.500 --> 00:13:42.580
Aber ja, jetzt wird das Ganze wohl angegangen

00:13:42.580 --> 00:13:44.900
und bin gespannt.

00:13:44.900 --> 00:13:49.020
Ich fand halt die Tagline ganz lustig vom Podcast.

00:13:49.020 --> 00:13:53.000
One talks like a Mexican, the other like a Russian.

00:13:53.000 --> 00:13:54.480
Both hate the comparison.

00:13:54.480 --> 00:13:56.520
Das ist mir gar nicht aufgefallen.

00:13:56.520 --> 00:13:57.380
Aber ja, stimmt, das ist gut.

00:13:57.380 --> 00:13:58.060
Ja.

00:13:58.300 --> 00:13:58.340
Ja.

00:13:58.340 --> 00:14:03.200
War das CinderX, das ist die letzte Folge?

00:14:03.200 --> 00:14:06.360
Die letzte habe ich, glaube ich, noch nicht gehört, ja.

00:14:06.360 --> 00:14:08.380
Da haben sie, ah, da haben sie mit,

00:14:08.380 --> 00:14:10.180
haben sie da nicht mit Karl Mayer geredet?

00:14:10.180 --> 00:14:10.600
Jep.

00:14:10.600 --> 00:14:12.520
Karl Mayer, ganz interessanter Typ.

00:14:12.520 --> 00:14:13.040
Von Meta.

00:14:13.040 --> 00:14:13.980
Ja, genau.

00:14:13.980 --> 00:14:17.420
Der hat, ja, Meta, aber der ist einer der Hauptentwickler

00:14:17.420 --> 00:14:21.900
hinter dem Django-Python-Kern von Instagram.

00:14:21.900 --> 00:14:22.900
Mhm, klar.

00:14:22.900 --> 00:14:25.500
Und er hat, da gab es mal eine sehr interessante Episode,

00:14:25.500 --> 00:14:27.400
ich habe jetzt wieder vergessen, wo und wann,

00:14:27.400 --> 00:14:27.900
aber...

00:14:27.900 --> 00:14:29.080
wo er darüber geredet hat,

00:14:29.080 --> 00:14:30.780
das, was man so vor Probleme kriegt,

00:14:30.780 --> 00:14:32.340
wenn man halt irgendwie mehr als,

00:14:32.340 --> 00:14:34.980
deutlich mehr als eine Million Zeilen Python irgendwie hat,

00:14:34.980 --> 00:14:38.400
die, und dann eine Anwendung, die darauf basiert,

00:14:38.400 --> 00:14:39.020
dass man halt so...

00:14:39.020 --> 00:14:40.700
Ich glaube, den Artikel hatten wir auch schon das eine oder andere Mal

00:14:40.700 --> 00:14:42.320
irgendwo in den Shownotes gelinkt, wenn ich mich recht erinnere.

00:14:42.320 --> 00:14:43.420
Kann sein, ja.

00:14:43.420 --> 00:14:46.320
Also, genau, das kann man, also, ja, ich habe es noch nicht gehört.

00:14:46.320 --> 00:14:47.680
Ja, Kopf EYF, das war ein guter Podcast.

00:14:47.680 --> 00:14:51.000
Ja, genau.

00:14:51.000 --> 00:14:52.640
Und dann erinnere ich mich noch,

00:14:52.640 --> 00:14:56.020
letztes Jahr hatten wir darüber geredet,

00:14:56.020 --> 00:14:57.740
dass es da so gewisse Sicherheitsstrategien gibt,

00:14:57.740 --> 00:14:57.880
dass es da so gewisse Sicherheitsstrategien gibt,

00:14:57.900 --> 00:14:59.160
dass es da so gewisse Sicherheitsstrategien bei LastPass gab.

00:14:59.160 --> 00:14:59.760
Ja.

00:14:59.760 --> 00:15:01.920
Und da dachte ich, okay, muss ich diesmal auch...

00:15:01.920 --> 00:15:03.300
Ich kann mich an den Januar und den Februar erinnern,

00:15:03.300 --> 00:15:04.780
wo ich 1.000 Passwörter umstellen musste.

00:15:04.780 --> 00:15:05.240
War super.

00:15:05.240 --> 00:15:09.920
Wo ich dann gesagt habe, ja, okay, so prinzipiell ist OnePassword

00:15:09.920 --> 00:15:11.240
jetzt auch nicht so viel besser zum Beispiel.

00:15:11.240 --> 00:15:15.680
Aber zum Glück sind sie noch nicht irgendwie hopsgenommen worden.

00:15:15.680 --> 00:15:16.700
Ja, das hat sich jetzt geändert.

00:15:16.700 --> 00:15:18.920
Jetzt ist auch OnePassword hopsgenommen worden.

00:15:18.920 --> 00:15:20.540
Und zwar über Okta.

00:15:20.540 --> 00:15:23.100
Also, ich manchmal denke so, okay, Okta ist auch so ein...

00:15:23.100 --> 00:15:25.100
Also, ich verstehe nicht genau, warum Unternehmen sowas verwenden,

00:15:25.100 --> 00:15:25.700
aber okay.

00:15:25.700 --> 00:15:27.880
Ja, ist ja total super, SSO und so.

00:15:27.900 --> 00:15:29.680
Muss man alles über so einen Anbieter machen.

00:15:29.680 --> 00:15:31.780
Ist Okta nicht auch in Zero aus?

00:15:31.780 --> 00:15:33.840
Ja, aus Zero, ja.

00:15:33.840 --> 00:15:36.160
Ja, der Dömm.

00:15:36.160 --> 00:15:40.120
Ja, also, ich glaube, es war nicht so ganz super schlimm,

00:15:40.120 --> 00:15:44.260
aber dazu gab es auch ein Postmortem, was wir veröffentlicht haben.

00:15:44.260 --> 00:15:45.620
Und das war einfach nur, wenn man sich das anguckt,

00:15:45.620 --> 00:15:46.660
das war einfach nur total schrecklich.

00:15:46.660 --> 00:15:47.500
Wie der Markt klingt peinlich.

00:15:47.500 --> 00:15:50.720
Oh ja, wir versprechen euch, es ist gar nichts geleakt worden

00:15:50.720 --> 00:15:52.060
und es ist auch nichts kaputt gegangen.

00:15:52.060 --> 00:15:54.280
Es sind jetzt so ein paar Dokumente verloren gegangen.

00:15:54.280 --> 00:15:56.300
Ja, aber, ja.

00:15:56.300 --> 00:15:57.880
Also, Zugriff auf die Datenbank oder so.

00:15:57.900 --> 00:16:01.560
Ja, ich habe auch keine gute Lösung dafür.

00:16:01.560 --> 00:16:03.320
Ich weiß nicht, wenn es das...

00:16:03.320 --> 00:16:04.860
Ich finde es schwierig, tatsächlich.

00:16:04.860 --> 00:16:06.540
Wir hatten ja letztes Jahr schon mal das Thema.

00:16:06.540 --> 00:16:07.480
Ja, das Thema hatten wir schon mal.

00:16:07.480 --> 00:16:08.600
Es kommt irgendwie immer wieder.

00:16:08.600 --> 00:16:10.280
Verrätst du, wie du das machst, Florian?

00:16:10.280 --> 00:16:11.500
Passwörter?

00:16:11.500 --> 00:16:15.300
Ja, tatsächlich ganz langweilig lokal bisher.

00:16:15.300 --> 00:16:19.760
Mit KeyPassXC ist es, glaube ich, inzwischen.

00:16:19.760 --> 00:16:22.800
Ich bin da mal irgendwie gewechselt von einem Volk zum anderen.

00:16:22.800 --> 00:16:27.420
Das und dann so ein minimales Frontend darüber,

00:16:27.420 --> 00:16:30.420
namens KeepMenu, was dann auf Rofi aufsetzt.

00:16:30.420 --> 00:16:33.480
Also so ein Keyboard-Menü.

00:16:33.480 --> 00:16:38.880
Und dann, ja, wenn ich mal irgendwie was brauche,

00:16:38.880 --> 00:16:42.220
was editieren muss oder so, mache ich halt dieses KeyPassXC auf

00:16:42.220 --> 00:16:45.440
und sonst einfach alles mit Tastaturkürzel und Autotype.

00:16:45.440 --> 00:16:47.600
Aber du kommst halt auch von dem Rechner nicht runter, ne?

00:16:47.600 --> 00:16:50.040
Und wenn der Rechner irgendwie dein Backup-Problem hat,

00:16:50.040 --> 00:16:51.440
dann ist es blöd.

00:16:51.440 --> 00:16:53.600
Das ist so, ja.

00:16:53.600 --> 00:16:55.560
Ich habe tatsächlich dann teilweise das Problem,

00:16:55.560 --> 00:16:56.560
dass ich halt irgendwo am Handy mal...

00:16:57.420 --> 00:16:58.980
Irgendwo ein Passwort brauche oder so.

00:16:58.980 --> 00:16:59.380
Ja.

00:16:59.380 --> 00:17:03.060
Aber ich bin eh so der Mensch, der fast immer sein Laptop dabei hat.

00:17:03.060 --> 00:17:05.960
Zum einen, und was Backups angeht,

00:17:05.960 --> 00:17:08.000
habe ich das tatsächlich dann alles mal ausgedrückt

00:17:08.000 --> 00:17:11.460
und in ein Bankschließfach gelegt.

00:17:11.460 --> 00:17:12.120
Ja, das glaube ich auch.

00:17:12.120 --> 00:17:13.820
Das ist keine so schlechte Idee, ja.

00:17:13.820 --> 00:17:16.940
Weil ich halt doch fand, ja, wenn das weg ist,

00:17:16.940 --> 00:17:18.240
habe ich echt ein gröberes Problem.

00:17:18.240 --> 00:17:19.040
Ja, ja.

00:17:19.040 --> 00:17:22.400
Ja, also ich finde auch für mich alleine oder so,

00:17:22.400 --> 00:17:24.020
da bin ich auch KeyPassXC oder so.

00:17:24.020 --> 00:17:25.860
Das war, das klingt, sah schon gut aus,

00:17:25.860 --> 00:17:27.320
aber das Problem für mich ist halt,

00:17:27.340 --> 00:17:29.500
auch der Support von irgendwie so

00:17:29.500 --> 00:17:31.480
Familie und Verwandten.

00:17:31.480 --> 00:17:31.940
Ja, und Sharing.

00:17:31.940 --> 00:17:34.980
Das und Sharing und mal irgendwie für jemanden was freischalten und so.

00:17:34.980 --> 00:17:38.820
Und das, da habe ich bisher noch keine gute Geschichte gefunden.

00:17:38.820 --> 00:17:41.100
Ja, also ich finde 2FA tatsächlich gar nicht so schlecht.

00:17:41.100 --> 00:17:43.760
Dann, und dann halt immer irgendwie so ein Key mitnehmen,

00:17:43.760 --> 00:17:45.860
wo ich halt auch, dann geht es halt nur zweimal oder sowas.

00:17:45.860 --> 00:17:47.000
Einer ist dann halt im Bankschließfach

00:17:47.000 --> 00:17:49.400
und den brauchst du halt dann und so.

00:17:49.400 --> 00:17:50.940
Das ist auch keine schlechte Idee, finde ich.

00:17:50.940 --> 00:17:53.220
Ja, also...

00:17:53.220 --> 00:17:55.360
Was ich mir wahrscheinlich anschauen würde,

00:17:55.360 --> 00:17:57.260
wenn ich jetzt was wähle, was ein bisschen mehr,

00:17:57.260 --> 00:17:58.900
was ein bisschen mehr Cloud dran hat, sage ich mal.

00:17:58.900 --> 00:18:00.600
Spitwarden.

00:18:00.600 --> 00:18:02.100
Habe ich wieder.

00:18:02.100 --> 00:18:04.680
Weil das ist, glaube ich, größtenteils Open Source.

00:18:04.680 --> 00:18:07.260
Und es gibt, glaube ich, auch eine alternative Server-Implementation,

00:18:07.260 --> 00:18:09.700
die man dann irgendwie selber hosten kann.

00:18:09.700 --> 00:18:11.640
Ja, also ich habe es mir angeguckt.

00:18:11.640 --> 00:18:12.860
Ich wollte auch erst als Umstände.

00:18:12.860 --> 00:18:14.460
Ich habe damit angefangen und ich weiß nicht.

00:18:14.460 --> 00:18:16.560
Also ich bin so ein Usability.

00:18:16.560 --> 00:18:18.780
Ich möchte das immer einfach und schnell und so haben.

00:18:18.780 --> 00:18:19.720
Und irgendwie nervt es mich.

00:18:19.720 --> 00:18:22.040
Kann sein, dass das technisch die sauberste Lösung ist.

00:18:22.040 --> 00:18:25.180
Aber ich fand es irgendwie total anstrengend.

00:18:25.180 --> 00:18:26.320
Ja.

00:18:26.320 --> 00:18:27.180
Naja.

00:18:27.180 --> 00:18:27.640
Ja, okay.

00:18:27.640 --> 00:18:29.820
Also vielleicht müssen wir einfach nächstes Jahr nochmal drüber reden.

00:18:29.820 --> 00:18:31.240
Ja, vielleicht ist da irgendwas.

00:18:31.240 --> 00:18:33.060
Also mir fällt aber auch nichts ein,

00:18:33.060 --> 00:18:34.380
was man irgendwie so architektonisch hat.

00:18:34.380 --> 00:18:35.800
Man muss, irgendeinen Tod muss man immer sterben.

00:18:35.800 --> 00:18:37.700
Also zum Beispiel, wie teile ich auch,

00:18:37.700 --> 00:18:39.640
jetzt hatten wir auch letztes Mal, glaube ich,

00:18:39.640 --> 00:18:42.500
irgendwie Geheimnisse durch Entwicklungsteams irgendwie.

00:18:42.500 --> 00:18:44.380
Auch nicht so einfach.

00:18:44.380 --> 00:18:44.680
Ja.

00:18:44.680 --> 00:18:45.720
Ja.

00:18:45.720 --> 00:18:48.400
Also ich benutze jetzt tatsächlich so einen Service,

00:18:48.400 --> 00:18:52.360
wo halt die Entwickler gar nicht mehr die Geheimnisse kennen müssen,

00:18:52.360 --> 00:18:54.520
die halt autogeneriert werden.

00:18:54.520 --> 00:18:55.420
Das heißt, ich kenne die selber nicht.

00:18:55.420 --> 00:18:56.940
Aber man muss sich halt mit der API dahin verbinden.

00:18:57.100 --> 00:18:58.080
Dieser Service kennt die halt alle.

00:18:58.080 --> 00:18:59.100
Also, ne?

00:18:59.100 --> 00:19:00.140
Ja.

00:19:00.140 --> 00:19:01.700
Ist halt auch dann wieder irgendeine Party,

00:19:01.700 --> 00:19:02.760
die dann halt Zugriff darauf hat.

00:19:02.760 --> 00:19:04.340
Aber gut, dass da jetzt nichts kritisch ist und so.

00:19:04.340 --> 00:19:05.360
Und ja, gut.

00:19:05.360 --> 00:19:08.020
Aber immerhin läuft der Rest dann so.

00:19:08.020 --> 00:19:09.660
Naja.

00:19:09.660 --> 00:19:10.540
Ja, das ist schwierig.

00:19:10.540 --> 00:19:11.400
Okay, ja.

00:19:11.400 --> 00:19:11.720
Ich weiß nicht.

00:19:11.720 --> 00:19:13.600
Ansonsten habe ich jetzt keine News mehr, glaube ich.

00:19:13.600 --> 00:19:15.000
Vielleicht bräuchte man einfach ordentliche Tests

00:19:15.000 --> 00:19:17.540
für diese wundervollen Passwort-Manager.

00:19:17.540 --> 00:19:19.100
Tja.

00:19:19.100 --> 00:19:23.600
Ja, also die Überleitung war jetzt ein bisschen hakelig.

00:19:23.600 --> 00:19:25.660
Vielleicht reden wir ja über das Thema.

00:19:25.660 --> 00:19:26.900
Dann haben wir heute noch News.

00:19:27.020 --> 00:19:27.180
Fertig?

00:19:27.180 --> 00:19:27.700
Ja, genau.

00:19:27.700 --> 00:19:32.920
Und dann können wir eigentlich mal hier mit PyTest starten.

00:19:32.920 --> 00:19:35.380
Ja, ich glaube, die meisten Menschen wissen, was PyTest ist.

00:19:35.380 --> 00:19:37.820
Also das Test-Framework, was man oft benutzt,

00:19:37.820 --> 00:19:39.520
wenn man Tests in Python schreiben möchte.

00:19:39.520 --> 00:19:41.540
Würde ich auch empfehlen, ehrlicherweise.

00:19:41.540 --> 00:19:43.260
Ihr wahrscheinlich auch.

00:19:43.260 --> 00:19:43.480
Ich auch.

00:19:43.480 --> 00:19:46.020
Alleinig.

00:19:46.020 --> 00:19:46.500
Ja.

00:19:46.500 --> 00:19:47.860
Keine Überraschung soweit.

00:19:47.860 --> 00:19:51.040
Aber dann überlasse ich einfach mal dem Florian vielleicht das Wort

00:19:51.040 --> 00:19:53.500
und den Einstieg in das Thema vielleicht auch.

00:19:53.500 --> 00:19:56.120
Das erzählst du ja vielleicht auch öfter.

00:19:56.940 --> 00:19:58.520
Also ich fand auf jeden Fall den Vortrag,

00:19:58.520 --> 00:20:00.200
den auf der letzten EuroPython darüber gehalten,

00:20:00.200 --> 00:20:00.860
das war schon ziemlich gut.

00:20:00.860 --> 00:20:02.360
Der war spannend.

00:20:02.360 --> 00:20:05.860
Ja, erzähl ich tatsächlich öfter,

00:20:05.860 --> 00:20:08.060
weil ich ja auch Firmenkurse mache zu PyTest.

00:20:08.060 --> 00:20:10.480
Das wären so die Einzelfirma-Schiene,

00:20:10.480 --> 00:20:12.840
die ich eben neben den Open-Source-Dingen noch fahre.

00:20:12.840 --> 00:20:17.460
Und da mache ich halt auch erstmal ein bisschen Werbung für PyTest.

00:20:17.460 --> 00:20:20.640
Gerade früher war das vielleicht noch ein bisschen wichtiger,

00:20:20.640 --> 00:20:22.960
weil da gab es oft echt noch Firmen,

00:20:22.960 --> 00:20:25.920
die umgestiegen sind von Unitest oder von Nose.

00:20:26.860 --> 00:20:27.720
Nose-Test-Framework.

00:20:27.720 --> 00:20:30.200
Inzwischen muss man sagen,

00:20:30.200 --> 00:20:33.020
dass wirklich so das Default eigentlich PyTest ist.

00:20:33.020 --> 00:20:34.720
Also Nose-Test ist sogar deprecated, oder?

00:20:34.720 --> 00:20:36.240
Nose, ja, ja.

00:20:36.240 --> 00:20:36.520
Ne, ne.

00:20:36.520 --> 00:20:37.660
Nose-Test gibt es auch noch.

00:20:37.660 --> 00:20:38.340
Ah, Nose-Test.

00:20:38.340 --> 00:20:39.080
Ja, Nose-Test.

00:20:39.080 --> 00:20:40.640
Jetzt habe ich es falsch verstanden.

00:20:40.640 --> 00:20:44.180
Da stand schon seit Jahren, steht in der Dokumentation,

00:20:44.180 --> 00:20:46.360
man soll bitte kein Nose verwenden.

00:20:46.360 --> 00:20:48.640
Es gibt irgendwie ein Nose 2,

00:20:48.640 --> 00:20:50.400
aber ich habe noch kein Projekt gefunden,

00:20:50.400 --> 00:20:51.720
was das nutzt so effektiv.

00:20:51.720 --> 00:20:55.860
Und wenn man sich halt dann so anschaut,

00:20:55.860 --> 00:20:56.840
wie die User zahlen,

00:20:56.840 --> 00:21:00.240
es gibt jeweils jährlich so eine Umfrage,

00:21:00.240 --> 00:21:02.200
die Python Developer Survey

00:21:02.200 --> 00:21:06.020
von der Python Software Foundation und JetBrains.

00:21:06.020 --> 00:21:09.620
Und da hat PyTest, ich glaube,

00:21:09.620 --> 00:21:13.840
vorletztes Jahr oder so die 50%-Marke geknackt.

00:21:13.840 --> 00:21:14.700
Okay.

00:21:14.700 --> 00:21:17.280
Ich hätte sogar mehr geschätzt, ehrlicherweise.

00:21:17.280 --> 00:21:20.540
Ja, wobei irgendwie 30% halt sagen,

00:21:20.540 --> 00:21:22.260
sie nutzen gar kein Test-Framework.

00:21:22.260 --> 00:21:23.360
Okay.

00:21:23.360 --> 00:21:25.000
Ja.

00:21:25.000 --> 00:21:25.840
Ja.

00:21:26.760 --> 00:21:28.120
Also würdet ihr denn Tests benutzen

00:21:28.120 --> 00:21:29.520
oder wann würdet ihr denn Tests benutzen?

00:21:29.520 --> 00:21:30.860
Das ist vielleicht auch eine spannende Frage.

00:21:30.860 --> 00:21:31.420
Oder wofür?

00:21:31.420 --> 00:21:34.020
Alles 100% Covered.

00:21:34.020 --> 00:21:36.720
Jeder Commit, der die Coverage reduziert,

00:21:36.720 --> 00:21:39.280
wird automatisch nicht durch die Committung durchgelassen?

00:21:39.280 --> 00:21:42.260
Oder gibt es da unterschiedliche Ansichten?

00:21:42.260 --> 00:21:45.460
Ich habe tatsächlich ein Projekt jetzt,

00:21:45.460 --> 00:21:46.320
wo ich das versuche,

00:21:46.320 --> 00:21:49.100
für das Modul,

00:21:49.100 --> 00:21:50.980
was ich eben an der Fachhochschule unterrichte.

00:21:50.980 --> 00:21:54.160
Da habe ich pro Jahr irgendwo 100 Studierende

00:21:54.160 --> 00:21:56.740
und das Modul heißt Automatisierung mit Python.

00:21:56.800 --> 00:22:01.000
Und ich habe dann eben halt auch meine Arbeit hinter dem Modul

00:22:01.000 --> 00:22:02.300
so ein bisschen automatisiert.

00:22:02.300 --> 00:22:04.520
Zumindest so der langweilige Teil.

00:22:04.520 --> 00:22:08.320
Also irgendwie Noten dann ausrechnen und E-Mails verschicken

00:22:08.320 --> 00:22:10.520
mit der Noten-Aufschlüsselung und so was.

00:22:10.520 --> 00:22:15.200
Und da bin ich jetzt dran, das alles ein bisschen zu refacturen

00:22:15.200 --> 00:22:17.940
und für den neuen Teil quasi, was refactured ist,

00:22:17.940 --> 00:22:20.640
auch wirklich 100% Test-Coverage zu haben.

00:22:20.640 --> 00:22:24.300
Weil ich halt finde, ja, ich berechne da irgendwie Zeugnisnoten

00:22:24.300 --> 00:22:26.400
und so, das muss halt schon irgendwie

00:22:26.660 --> 00:22:28.960
keine Box haben, in irgendeiner Weise.

00:22:28.960 --> 00:22:31.200
Also ich finde auch, also so kritische Teile der Infrastruktur

00:22:31.200 --> 00:22:32.700
sind ganz gut, wenn man die testet.

00:22:32.700 --> 00:22:35.400
Also sowas wie Authentifizierung, Autorisierung oder sowas,

00:22:35.400 --> 00:22:38.900
sollte man schon irgendwo mal gucken, dass das stimmt.

00:22:38.900 --> 00:22:41.000
So die kritische Business-Logik.

00:22:41.000 --> 00:22:45.160
Weiß nicht, also jede Einzeiler-Funktion weiß ich jetzt nicht.

00:22:45.160 --> 00:22:48.020
Ja, es gibt ja Leute, die diesen Standpunkt vertreten und sagen:

00:22:48.020 --> 00:22:51.560
"Na ja, gut, wenn man anfängt, über solche Zahlen zu diskutieren,

00:22:51.560 --> 00:22:54.060
dann macht das eigentlich nur 100% Sinn."

00:22:54.060 --> 00:22:56.480
Aber ich weiß auch nicht, ob das jetzt optimal ist für alle,

00:22:56.580 --> 00:22:59.580
also ich hab's für ein Projekt, hab ich das auch gemacht,

00:22:59.580 --> 00:23:01.440
weil einfach ich das mal machen wollte.

00:23:01.440 --> 00:23:05.380
Ob das jetzt nötig wäre, weiß ich nicht.

00:23:05.380 --> 00:23:07.700
Ja, und es wird schon anstrengend,

00:23:07.700 --> 00:23:10.340
also gerade, wenn man dann externe Komponenten drin hat.

00:23:10.340 --> 00:23:11.440
Ja, ja.

00:23:11.440 --> 00:23:14.420
Irgendwie eine GUI-Applikation schreibt oder so,

00:23:14.420 --> 00:23:16.100
dann wird's schon schwierig irgendwann.

00:23:16.100 --> 00:23:18.760
Ja, genau, also welche Enden muss man danach testen, ne?

00:23:18.760 --> 00:23:22.000
Also ich finde ja da tatsächlich auch vielleicht jetzt direkt

00:23:22.000 --> 00:23:23.700
an dem Zeitpunkt TDD ganz interessant,

00:23:23.700 --> 00:23:26.400
also dass man mit den Tests anfängt, die zu schreiben.

00:23:26.500 --> 00:23:28.160
Das ist ja auch immer ganz einfach,

00:23:28.160 --> 00:23:30.960
weil man muss dann schon relativ genau wissen, was man machen will.

00:23:30.960 --> 00:23:33.200
Und wenn man das nicht weiß, dann baut man halt Tests,

00:23:33.200 --> 00:23:34.960
die man hinterher wieder wegschmeißen kann,

00:23:34.960 --> 00:23:37.120
was dann die doppelt- und dreifache Arbeit macht.

00:23:37.120 --> 00:23:39.380
Aber wenn man halt irgendwie schon ein gutes Konzept hat,

00:23:39.380 --> 00:23:41.900
dann erst Tests dafür zu schreiben, wie das aussehen sollte,

00:23:41.900 --> 00:23:43.400
und dann die Implementierung.

00:23:43.400 --> 00:23:46.480
Das führt halt dazu, dass die dann auch tatsächlich funktioniert, ja?

00:23:46.480 --> 00:23:48.320
Wenn man sich so Gedanken dazu gemacht hat,

00:23:48.320 --> 00:23:51.360
wo so die Haken und Stellen sind, die ineinandergreifen sollen.

00:23:51.360 --> 00:23:53.420
Ja.

00:23:53.420 --> 00:23:56.320
Macht ihr das auch mal manchmal?

00:23:56.420 --> 00:23:59.640
Ich mache das gerne bei Bugs, wenn ich halt irgendeinen Bug-Report kriege,

00:23:59.640 --> 00:24:01.880
dass ich erst mal einen Test dafür schreibe.

00:24:01.880 --> 00:24:06.260
Zumindest so ab dem Punkt, wo ich das einmal manuell reproduziert habe.

00:24:06.260 --> 00:24:10.860
Weil wenn ich den Bug fixe, werde ich das eh schon ein paar Mal reproduzieren müssen.

00:24:10.860 --> 00:24:13.940
Und dann mache ich mir halt effektiv das Leben leichter.

00:24:13.940 --> 00:24:18.700
Ja, genau. Also ich würde auch sagen, fix ist immer Test, ja.

00:24:18.700 --> 00:24:22.180
Genau. So bei einer Library kann ich es mir auch noch vorstellen.

00:24:22.180 --> 00:24:24.440
Und wenn es dann eher Richtung Applikation geht,

00:24:24.440 --> 00:24:26.240
finde ich, wird es schon schwieriger.

00:24:26.340 --> 00:24:28.960
Aber jetzt wieder bei einer GUI-Applikation,

00:24:28.960 --> 00:24:31.300
da muss ich das Feature irgendwie erst mal implementieren

00:24:31.300 --> 00:24:35.740
und erst mal sehen, wie das aussieht aus User-Sicht, aus Code-Sicht auch,

00:24:35.740 --> 00:24:37.530
ja irgendwie sinnvoll Tests dafür schreiben kann,

00:24:37.530 --> 00:24:37.930
finde ich.

00:24:37.930 --> 00:24:41.470
Klingt sehr vernünftig, würde ich

00:24:41.470 --> 00:24:43.470
ganz genau so sehen. Also ich mache auch

00:24:43.470 --> 00:24:45.130
TDD manchmal, aber

00:24:45.130 --> 00:24:47.470
gerade eben auch so bei Web-Applikationen

00:24:47.470 --> 00:24:49.710
entwickle ich

00:24:49.710 --> 00:24:51.430
oft, also oft ist es ja so, man fängt mit irgendwas

00:24:51.430 --> 00:24:53.230
an oder mir geht das halt so und dann

00:24:53.230 --> 00:24:55.510
denkt man sich irgendwann, ah nee, das ist einfach keine gute Idee

00:24:55.510 --> 00:24:57.290
und ich mache das auch oft

00:24:57.290 --> 00:24:58.510
in Notebooks am Anfang.

00:24:58.510 --> 00:25:01.290
Einfach nur, um zu sehen, ob irgendwas geht

00:25:01.290 --> 00:25:03.410
oder elegant geht und wenn es dann nicht geht, dann sage ich so

00:25:03.410 --> 00:25:05.370
okay, pff, ne, dann mache ich doch

00:25:05.370 --> 00:25:06.870
lieber was anderes und

00:25:06.870 --> 00:25:09.310
wenn man da zuerst die Tests schreibt,

00:25:09.310 --> 00:25:10.770
dann schmeißt man die Tests ja mit weg.

00:25:10.770 --> 00:25:13.250
Ich habe dann mal, es gab

00:25:13.250 --> 00:25:14.990
auf Twitter irgendwie einen Thread, wo dann

00:25:14.990 --> 00:25:17.410
weiß ich nicht, Harry Percival,

00:25:17.410 --> 00:25:18.370
der auch dieses

00:25:18.370 --> 00:25:20.730
Obey the Testing Go, der

00:25:20.730 --> 00:25:22.910
ein Testbuch geschrieben hat für Python,

00:25:22.910 --> 00:25:25.090
meinte, dass Leute doch bitte mal

00:25:25.090 --> 00:25:27.270
TDD verwenden sollen und sich mal ein Brief reißen

00:25:27.270 --> 00:25:29.150
wollen, dann werde ich so, ich mache das mal so.

00:25:29.150 --> 00:25:31.210
Ich weiß nicht, ich habe so das Gefühl, wenn ich

00:25:31.210 --> 00:25:33.130
zuerst Tests schreibe, dann ist das eine totale Verschwendung, weil

00:25:33.130 --> 00:25:34.910
wenn ich schmeiße, dann oft Sachen wieder weg

00:25:35.010 --> 00:25:36.830
und warum sollte ich da Tests für Sachen schreiben,

00:25:36.830 --> 00:25:38.990
nicht wieder? Nee, nee, das ist ein Spike, das ist auch

00:25:38.990 --> 00:25:40.030
TDD, das ist schon okay.

00:25:40.030 --> 00:25:42.590
Na gut, ja, aber

00:25:42.590 --> 00:25:44.950
oft muss man erstmal sehen, ob irgendwas so

00:25:44.950 --> 00:25:46.650
funktioniert, wie man denkt und dann...

00:25:46.650 --> 00:25:49.010
Wenn man zum Beispiel die Modelle jetzt noch nicht hat von so einem Problem

00:25:49.010 --> 00:25:50.870
oder die einfach definieren muss, also manchmal muss man ja

00:25:50.870 --> 00:25:53.010
irgendwie Fixes schreiben dann erstmal, um zu gucken,

00:25:53.010 --> 00:25:54.950
was denn überhaupt an Datenmodellen, wie die

00:25:54.950 --> 00:25:56.930
aussehen sollen und so. Oft lasse ich die Modelle weg

00:25:56.930 --> 00:25:58.950
und schreibe gar keine Modelle, sondern

00:25:58.950 --> 00:26:00.690
ich schreibe erstmal so, um

00:26:00.690 --> 00:26:02.670
zu sehen, ob das in der UI funktioniert.

00:26:02.670 --> 00:26:04.870
Das wäre dann Integration Test?

00:26:05.010 --> 00:26:06.910
Nee, ich schreibe da gar keine...

00:26:06.910 --> 00:26:08.970
Wie gesagt, an der Stelle kann man noch nicht so gut Text schreiben.

00:26:08.970 --> 00:26:10.890
Also wenn ich mit Tests anfangen würde, würde ich ja

00:26:10.890 --> 00:26:12.750
mit den Tests vielleicht für das Modell anfangen oder so,

00:26:12.750 --> 00:26:14.490
aber wenn ich kein Modell habe, ist es halt ein bisschen...

00:26:14.490 --> 00:26:14.790
Ja, okay.

00:26:14.790 --> 00:26:18.710
Ich will noch kurz nochmal beim Testing Goat

00:26:18.710 --> 00:26:20.970
anknüpfen. Da hat

00:26:20.970 --> 00:26:22.710
jemand letztens ganz einen lustigen Thread

00:26:22.710 --> 00:26:24.670
aufgemacht, wo er fand, ja, er hat mal

00:26:24.670 --> 00:26:27.130
ChatGPT gefragt, wo das PyTest-Logo

00:26:27.130 --> 00:26:27.890
herkommt

00:26:27.890 --> 00:26:30.810
und ChatGPT meinte dann, ja, ich hätte

00:26:30.810 --> 00:26:31.510
das designt.

00:26:31.510 --> 00:26:33.650
Ist Quatsch.

00:26:33.650 --> 00:26:34.950
Ist völliger.

00:26:35.010 --> 00:26:36.790
Ist Quatsch. Das Logo

00:26:36.790 --> 00:26:38.710
gibt es nämlich schon irgendwie seit 2014

00:26:38.710 --> 00:26:40.830
und ich bin ja erst ein Jahr später zu PyTest

00:26:40.830 --> 00:26:41.430
dazugekommen.

00:26:41.430 --> 00:26:44.610
Also, ja, GPT lügt bei Python

00:26:44.610 --> 00:26:46.670
regelmäßig. Ich denke zum Beispiel auch, dass irgendwelche

00:26:46.670 --> 00:26:48.730
anderen Menschen den Python-Podcast machen würden, die ich noch nicht

00:26:48.730 --> 00:26:49.890
gehört habe. Aber hey.

00:26:49.890 --> 00:26:52.930
Ja, ich habe da tatsächlich

00:26:52.930 --> 00:26:54.950
mal rumgegraben in den Mailing-List-

00:26:54.950 --> 00:26:56.610
Archiven und rausgefunden,

00:26:56.610 --> 00:26:58.430
warum das so eine Pornflöte ist.

00:26:58.430 --> 00:26:59.610
Ach, okay. Das ist was.

00:26:59.610 --> 00:27:02.510
Ich soll nämlich tatsächlich an diesem Testing Goat

00:27:02.510 --> 00:27:04.570
als Maskottchen auf diesem Buch

00:27:05.010 --> 00:27:06.310
anknüpfen, weil

00:27:06.310 --> 00:27:08.630
Pornflöten eben genutzt wurden

00:27:08.630 --> 00:27:09.470
wohl, um

00:27:09.470 --> 00:27:12.710
Ziegen zu herden.

00:27:12.710 --> 00:27:14.490
Wie sagt man denn noch in Deutsch?

00:27:14.490 --> 00:27:15.950
Zu hüten.

00:27:15.950 --> 00:27:16.910
Zu hüten, ja, ja.

00:27:16.910 --> 00:27:20.130
Hm. Ja.

00:27:20.130 --> 00:27:22.930
Ja, ich fand das mit dem ChatGPT

00:27:22.930 --> 00:27:24.710
dann ganz witzig. Ich habe danach noch mal so ein bisschen

00:27:24.710 --> 00:27:26.870
nachgehakt und finde so, nö, das war nicht ich.

00:27:26.870 --> 00:27:28.410
Und dann meint es, ja, nee,

00:27:28.410 --> 00:27:30.770
es tut mir leid, es war Armin Ronacher.

00:27:30.770 --> 00:27:31.710
Ach so.

00:27:31.710 --> 00:27:34.990
Und da fand ich,

00:27:35.010 --> 00:27:36.110
da fand ich halt auch, äh, nö.

00:27:36.110 --> 00:27:38.830
Und da meinte er irgendwas von einem Daniel

00:27:38.830 --> 00:27:40.710
Urstöger, auch bekannt als

00:27:40.710 --> 00:27:43.050
Blue-Logo, habe ich gesucht, nichts gefunden

00:27:43.050 --> 00:27:44.610
zu der Person und fand immer noch,

00:27:44.610 --> 00:27:46.970
nee, kann nicht sein. Und dann fand

00:27:46.970 --> 00:27:48.930
er immer noch, ja, tut mir wirklich leid und so.

00:27:48.930 --> 00:27:50.950
Es war von Daniel Haller

00:27:50.950 --> 00:27:52.450
gemacht, was halt auch nicht stimmt.

00:27:52.450 --> 00:27:54.890
Mir, ich habe

00:27:54.890 --> 00:27:56.910
gerade auch noch mal gefragt, und mir sagt

00:27:56.910 --> 00:27:58.470
es, dass es nicht genau weiß, weil es von einem

00:27:58.470 --> 00:28:00.270
Community-Wettbewerb stammen würde.

00:28:00.270 --> 00:28:02.890
Ja,

00:28:02.890 --> 00:28:04.890
dann hast du wahrscheinlich dieses GPT-4-Modell,

00:28:05.010 --> 00:28:06.970
ein nächstes Mal mit dem GPT

00:28:06.970 --> 00:28:08.990
das 3.5, okay, interessant.

00:28:08.990 --> 00:28:10.850
Ja, also, ja, das ist halt, weil

00:28:10.850 --> 00:28:12.550
er sich irgendwie manchmal aus der Fantasie teilt.

00:28:12.550 --> 00:28:13.530
Ja, gut.

00:28:13.530 --> 00:28:17.090
Sicheres Auftreten bei vollkommener

00:28:17.090 --> 00:28:18.990
Ahnungstätigkeit, Jochen. Was fällt dir

00:28:18.990 --> 00:28:19.390
dazu ein?

00:28:19.390 --> 00:28:22.770
Dass mir auf jeden Fall die Panfurte besser gefällt,

00:28:22.770 --> 00:28:24.630
als ein Schäferhund als Logo für Pytas.

00:28:24.630 --> 00:28:28.730
Ja, die Panfurte ist super.

00:28:28.730 --> 00:28:30.530
Ja, was

00:28:30.530 --> 00:28:32.750
haben wir denn, was haben wir denn so an Dingen,

00:28:32.750 --> 00:28:34.870
die man da, über die man mal, ja, das wird

00:28:34.870 --> 00:28:36.370
mich auch mal interessieren, genau, du machst viele

00:28:36.370 --> 00:28:38.690
Pytas-Schulungen, geht das

00:28:38.690 --> 00:28:40.470
überhaupt, also ich habe irgendwie so ein bisschen, ich mache

00:28:40.470 --> 00:28:42.570
auch manchmal Schulungen, auch so Python-Einführungen,

00:28:42.570 --> 00:28:44.770
oder halt auch mal zu speziellen Themen,

00:28:44.770 --> 00:28:46.710
und ich habe immer so das Gefühl,

00:28:46.710 --> 00:28:48.530
ich weiß nicht so genau, ob ich, ob das,

00:28:48.530 --> 00:28:50.610
wie ich da, wie man da am besten

00:28:50.610 --> 00:28:52.510
Wert

00:28:52.510 --> 00:28:54.610
irgendwie schafft für die Leute, die darin teilnehmen,

00:28:54.610 --> 00:28:56.690
weil ich habe manchmal so das Gefühl, die sind

00:28:56.690 --> 00:28:58.350
dann halt dann zwei Tage oder drei Tage da,

00:28:58.350 --> 00:29:00.630
und dann

00:29:00.630 --> 00:29:02.770
machen sie das dann aber doch wieder so, wie sie das kennen,

00:29:02.770 --> 00:29:04.790
irgendwie, wenn sie wieder da weg sind, und

00:29:04.790 --> 00:29:06.530
gerade bei so Test-Driven Development

00:29:06.530 --> 00:29:08.130
ist es halt, habe ich das Gefühl,

00:29:08.130 --> 00:29:10.590
oder überhaupt beim Testen, so ein Ding,

00:29:10.590 --> 00:29:12.550
wo sich das erst so über die Zeit

00:29:12.550 --> 00:29:14.150
irgendwie einstellt,

00:29:14.150 --> 00:29:16.470
wo man das schlecht irgendwie so einmal

00:29:16.470 --> 00:29:18.470
in, so musst du das halt machen,

00:29:18.470 --> 00:29:20.430
und dann, sondern es ist mehr so ein Ding, so ein, so ein,

00:29:20.430 --> 00:29:22.550
wegschmeißen, nochmal machen, wegschmeißen, nochmal machen,

00:29:22.550 --> 00:29:24.590
wegschmeißen, nochmal machen, ja, oder man muss sich halt da so ein bisschen dran gewöhnen,

00:29:24.590 --> 00:29:26.630
und das muss halt über eine längere Zeit irgendwie

00:29:26.630 --> 00:29:28.630
passieren, und ich habe da noch nicht so einen Dreh gefunden,

00:29:28.630 --> 00:29:29.590
wie man das am besten vermitteln kann.

00:29:29.590 --> 00:29:31.830
Ja, ich sage,

00:29:31.830 --> 00:29:33.910
ich sage das den Leuten schon auch so,

00:29:34.710 --> 00:29:36.490
es ist auch irgendwie viel Erfahrung

00:29:36.490 --> 00:29:38.150
dahinter, die kann ich euch nicht abnehmen,

00:29:38.150 --> 00:29:40.490
aber ich kann euch halt erstmal die Werkzeuge

00:29:40.490 --> 00:29:42.570
in die Hand geben, und euch

00:29:42.570 --> 00:29:44.330
einfach mal zeigen, was kann man an sich

00:29:44.330 --> 00:29:46.470
vielleicht eher ein bisschen abstrakter mit

00:29:46.470 --> 00:29:48.830
PyTest überhaupt machen, was sind so die Möglichkeiten,

00:29:48.830 --> 00:29:50.630
wie man die dann

00:29:50.630 --> 00:29:52.450
anwendet auf die konkrete Fälle,

00:29:52.450 --> 00:29:54.590
die die Leute da haben, steht dann teilweise schon

00:29:54.590 --> 00:29:56.030
nochmal ein bisschen auf einem anderen Blatt,

00:29:56.030 --> 00:29:58.290
aber ich finde es schon ganz nützlich,

00:29:58.290 --> 00:30:00.270
dass die Leute halt sehen, was gibt es denn überhaupt.

00:30:00.270 --> 00:30:01.950
Ja.

00:30:01.950 --> 00:30:04.630
Da habe ich vielleicht noch eine kurze

00:30:04.630 --> 00:30:06.410
Geschichte auch, wie das mit

00:30:06.410 --> 00:30:07.670
diesen Trainings angefangen hat.

00:30:07.670 --> 00:30:10.470
Das war nämlich auch ganz

00:30:10.470 --> 00:30:12.450
witzig, das war, als ich PyTest

00:30:12.450 --> 00:30:14.330
erst ein paar Monate gebraucht habe, auch noch

00:30:14.330 --> 00:30:15.530
irgendwie im 2015,

00:30:15.530 --> 00:30:18.670
und zwar zu Europython

00:30:18.670 --> 00:30:19.990
da in Bilbao,

00:30:19.990 --> 00:30:21.390
also Spanien,

00:30:21.390 --> 00:30:24.590
da wurde ich von Holger

00:30:24.590 --> 00:30:26.510
Krekel, also nicht ich, aber Holger

00:30:26.510 --> 00:30:28.610
Krekel, also so der Vater

00:30:28.610 --> 00:30:30.470
von PyTest, der hat

00:30:30.470 --> 00:30:32.370
halt auf der Mailingliste gefragt, ob

00:30:32.370 --> 00:30:34.410
jemand dieses Training übernehmen kann an der

00:30:34.410 --> 00:30:36.330
Europython, weil er war irgendwie

00:30:36.330 --> 00:30:37.510
verhindert kurzfristig

00:30:37.510 --> 00:30:40.210
und es hat sich dann niemand gemeldet und ich fand

00:30:40.210 --> 00:30:42.330
halt so, ja, hm, das ist

00:30:42.330 --> 00:30:44.370
irgendwie Material da, Spanien klingt

00:30:44.370 --> 00:30:46.270
auch irgendwie toll, ich war noch nie auf

00:30:46.270 --> 00:30:47.590
irgendwie einer Python-Konferenz.

00:30:47.590 --> 00:30:49.270
Ja, machen wir.

00:30:49.270 --> 00:30:52.250
Dann im gleichen Jahr noch auch

00:30:52.250 --> 00:30:54.090
das erste Firmentraining dann von ihm

00:30:54.090 --> 00:30:56.350
übernommen, weil er eh langsam aufgehört hat

00:30:56.350 --> 00:30:58.210
mit PyTest und zu anderen Projekten

00:30:58.210 --> 00:30:59.310
übergegangen ist

00:30:59.310 --> 00:31:02.130
und seit da dann basierend auf

00:31:02.130 --> 00:31:04.330
seinen Materialien das halt immer weiterentwickelt,

00:31:04.330 --> 00:31:06.370
das klingt aber gut.

00:31:06.370 --> 00:31:08.110
Das klingt gut. Ja, also da sind auch

00:31:08.110 --> 00:31:10.030
viele interessante Sachen und ich würde auch die

00:31:10.030 --> 00:31:12.090
einzelnen auch nochmal vielleicht kurz anschneiden, dass man

00:31:12.090 --> 00:31:14.170
so ein bisschen drüber erklärt, für die Menschen, die

00:31:14.170 --> 00:31:15.590
das noch nicht so kennen.

00:31:15.590 --> 00:31:18.210
Wollen wir uns dann eine Struktur geben, wie wir

00:31:18.210 --> 00:31:20.110
anfangen, weil sie nochmal reden, wie man vielleicht

00:31:20.110 --> 00:31:22.050
Pictures am besten macht oder was das überhaupt ist

00:31:22.050 --> 00:31:24.170
oder ob man die braucht oder wie

00:31:24.170 --> 00:31:25.910
man die baut oder

00:31:25.910 --> 00:31:28.150
und dann irgendwann vielleicht über diese

00:31:28.150 --> 00:31:29.950
ganzen Plugins oder so

00:31:29.950 --> 00:31:32.270
ein paar

00:31:32.270 --> 00:31:34.090
extra Sachen geht. Es gibt ja wunderschöne Sachen,

00:31:34.250 --> 00:31:36.170
die ich auch am Anfang nicht kannte.

00:31:36.170 --> 00:31:38.150
Das letzte, wo ich erst mich

00:31:38.150 --> 00:31:40.090
so ein bisschen gesträubt hatte, war irgendwie Hypothesis.

00:31:40.090 --> 00:31:42.250
Das habe ich dann durch deine Veranstaltung

00:31:42.250 --> 00:31:44.030
lieber Florian nochmal dann

00:31:44.030 --> 00:31:46.130
eingebaut und war überrascht, dass ich, also was

00:31:46.130 --> 00:31:47.990
heißt überrascht, aber ich habe noch so ein paar

00:31:47.990 --> 00:31:49.130
Bugs angefressen und so, oh,

00:31:49.130 --> 00:31:51.950
die habe ich jetzt noch nicht gesehen und ja,

00:31:51.950 --> 00:31:54.250
da kommt man so ein bisschen

00:31:54.250 --> 00:31:55.910
auch an die Grenzen dessen, was

00:31:55.910 --> 00:31:57.610
Python so kann und

00:31:57.610 --> 00:31:59.770
ja, ich weiß nicht, wo würdest du denn anfangen

00:31:59.770 --> 00:32:01.610
bei PyTest?

00:32:01.610 --> 00:32:04.170
Ich würde glaube ich jetzt tatsächlich

00:32:04.170 --> 00:32:05.830
nicht generell

00:32:05.830 --> 00:32:07.770
bei PyTest, aber ich würde nochmal kurz gerne bei

00:32:07.770 --> 00:32:09.630
Coverage einhaken, weil

00:32:09.630 --> 00:32:11.690
das Thema schon gehabt haben und

00:32:11.690 --> 00:32:13.410
vielleicht nicht alle wissen, was das eigentlich ist.

00:32:13.410 --> 00:32:15.690
Da freue ich mich jeweils

00:32:15.690 --> 00:32:17.890
auch so rum bei den Firmenkursen und

00:32:17.890 --> 00:32:19.650
oft so viele Leute

00:32:19.650 --> 00:32:21.750
fanden, ja, nee, das machen sie eigentlich nicht,

00:32:21.750 --> 00:32:23.490
dass sie irgendwie Coverage messen.

00:32:23.490 --> 00:32:25.870
Da geht's

00:32:25.870 --> 00:32:27.630
darum, dass man sich

00:32:27.630 --> 00:32:29.430
ganz einfach anschaut, welche

00:32:29.430 --> 00:32:31.550
Zeilen von meinem Code wurden von

00:32:31.550 --> 00:32:32.730
meinen Tests ausgeführt.

00:32:34.090 --> 00:32:36.110
Was einem dann einen Eindruck zumindest

00:32:36.110 --> 00:32:38.350
geben kann, was ist getestet

00:32:38.350 --> 00:32:40.150
oder was wird zumindest ausgeführt

00:32:40.150 --> 00:32:42.210
von den Tests, muss nicht zwingend

00:32:42.210 --> 00:32:44.050
dann heißen, dass die Tests auch gut sind oder

00:32:44.050 --> 00:32:46.090
wirklich was testen, aber es wird zumindest mal

00:32:46.090 --> 00:32:48.050
ausgeführt. Ja, das Blöde ist halt dann,

00:32:48.050 --> 00:32:50.070
wenn wir 100% Coverage, also der ganze

00:32:50.070 --> 00:32:51.870
Code ist durchgelaufen, aber ist trotzdem irgendwas kaputt.

00:32:51.870 --> 00:32:54.190
Genau. Kann einem halt

00:32:54.190 --> 00:32:54.830
auch passieren, ja.

00:32:54.830 --> 00:32:58.010
Auch schwierig, da Prozent

00:32:58.010 --> 00:32:59.930
Coverage gerade in einem Team sich

00:32:59.930 --> 00:33:01.590
irgendwie als Ziel zu setzen, weil dann

00:33:01.590 --> 00:33:04.010
wird es bestimmt Leute geben, die dann einfach

00:33:04.010 --> 00:33:05.850
diese Zahl hochtreiben, ohne wirklich noch

00:33:05.850 --> 00:33:07.850
gute Tests zu schreiben. Ja, ja, genau, weil

00:33:07.850 --> 00:33:09.950
ja, das würde ich auch sagen, wenn man es halt nur macht, um irgendwie

00:33:09.950 --> 00:33:11.630
irgendeinen Ast nochmal zu

00:33:11.630 --> 00:33:13.990
durchzuwandern, ohne

00:33:13.990 --> 00:33:15.270
dass es halt irgendwas bringt, ist halt blöd.

00:33:15.270 --> 00:33:17.950
Aber gibt es da sowas, wo ihr sagen würdet,

00:33:17.950 --> 00:33:19.850
so aus euren Eigenprojekten, so Pi mal

00:33:19.850 --> 00:33:21.450
Daumen, so eine Coverage ist okay?

00:33:21.450 --> 00:33:25.470
Hm, nee, ich würde,

00:33:25.470 --> 00:33:27.850
also ich weiß nicht, also meistens, wenn ich nicht

00:33:27.850 --> 00:33:29.630
drauf achte, lande ich irgendwo so bei

00:33:29.630 --> 00:33:31.870
irgendwie ein bisschen über 80% oder sowas.

00:33:31.870 --> 00:33:33.930
Ja. Aber...

00:33:33.930 --> 00:33:35.950
70 war jetzt auch so meine erste Reaktion

00:33:35.950 --> 00:33:37.730
gewesen. Also ich würde sagen, wenn man schon

00:33:37.730 --> 00:33:39.870
zwei Tests schreibt oder so, die so ein bisschen das machen, was man

00:33:39.870 --> 00:33:41.830
testen, was man macht, dann sind die ja schon mal über 60,

00:33:41.830 --> 00:33:42.730
70 meistens drüber.

00:33:42.730 --> 00:33:45.790
Das weiß ich nicht, aber... Ja, je nachdem, wie groß das

00:33:45.790 --> 00:33:46.530
Projekt ist natürlich. Ja, ja.

00:33:46.530 --> 00:33:49.710
Also klar, am Anfang hast du einfach viel mehr

00:33:49.710 --> 00:33:51.790
Gewinn, also so ein paar Tests, die

00:33:51.790 --> 00:33:53.870
halt bei der Web-Applikation jetzt die Views

00:33:53.870 --> 00:33:55.530
einfach nur durchgehen und gucken, ob ein Okay zurückkommt,

00:33:55.530 --> 00:33:57.650
irgendwie in den Standardfällen, da hast du halt

00:33:57.650 --> 00:33:59.550
sehr wenig Tests geschrieben und viel Gewinn,

00:33:59.550 --> 00:34:01.770
quasi, weil wenn das kaputt geht...

00:34:01.770 --> 00:34:03.850
Und das wird dann halt immer weniger irgendwann

00:34:03.850 --> 00:34:05.550
und irgendwann ist man natürlich am Punkt erreicht, wo es halt

00:34:05.550 --> 00:34:07.710
eigentlich keinen Sinn mehr macht und man aufhören kann,

00:34:07.710 --> 00:34:09.590
aber wann der erreicht ist,

00:34:09.590 --> 00:34:11.330
keine Ahnung, schwer zu sagen.

00:34:11.330 --> 00:34:12.790
Also, ja.

00:34:12.790 --> 00:34:15.770
Ja. Ja, am Schluss muss

00:34:15.770 --> 00:34:17.150
man sich danach einfach mal so

00:34:17.150 --> 00:34:19.670
die Daten dahinter anschauen und

00:34:19.670 --> 00:34:21.810
mal schauen, was habe ich denn noch nicht getestet?

00:34:21.810 --> 00:34:23.690
Ja, da... Da kann's

00:34:23.690 --> 00:34:25.670
eben sein, es wurde einfach vergessen, das ist

00:34:25.670 --> 00:34:27.590
irgendwie eine Fehler-Condition, die

00:34:27.590 --> 00:34:29.690
vielleicht ganz gut ist, die zu testen.

00:34:29.690 --> 00:34:31.530
Oder es kann halt sein, es ist eben

00:34:31.530 --> 00:34:33.770
ein Code, der nicht einfach testbar ist und da

00:34:33.770 --> 00:34:35.770
muss man sich überlegen, ist es davon wert?

00:34:35.770 --> 00:34:37.430
Es gibt halt so zwei, ich würde sagen,

00:34:37.430 --> 00:34:39.670
Dinge, die es ein bisschen schwierig machen. Und zwar, klar,

00:34:39.670 --> 00:34:41.710
also, man kann jetzt natürlich sehr viel einfacher

00:34:41.710 --> 00:34:43.630
Tests schreiben, wenn man ganz klar weiß,

00:34:43.630 --> 00:34:45.890
wie jetzt von einer kleinen Funktion, von irgendeiner

00:34:45.890 --> 00:34:47.610
Code irgendwie der Contract ist halt. Ja, also,

00:34:47.610 --> 00:34:49.350
wenn man weiß, was reingehen, was rausgehen muss,

00:34:49.350 --> 00:34:51.690
was halt auch bedeutet, dass man dazu

00:34:51.690 --> 00:34:53.610
tendiert, die relativ statisch zum Beispiel zu

00:34:53.610 --> 00:34:55.610
typisieren oder zumindest die Type-Annotations dann

00:34:55.610 --> 00:34:57.210
nochmal abzufangen oder irgendwie sowas.

00:34:57.210 --> 00:34:59.450
Naja, gut, das macht ja jetzt wenig Sinn, würde ich sagen, wenn du die

00:34:59.450 --> 00:35:01.610
Type-Annotations dann nochmal testest, das ist irgendwie...

00:35:01.610 --> 00:35:03.610
Ja, nein, aber du brauchst halt, dass das, was rein...

00:35:03.610 --> 00:35:05.490
reinkommt, dann auch dem entspricht vielleicht, ne?

00:35:05.490 --> 00:35:07.350
Oder dass man halt das eng zogert.

00:35:07.350 --> 00:35:09.450
Das bedeutet aber halt, dass man auch die Dynamik verliert

00:35:09.450 --> 00:35:11.570
oder die Flexibilität. Auch jetzt

00:35:11.570 --> 00:35:13.370
irgendwie, wenn man jetzt API schreibt und dann irgendwie

00:35:13.370 --> 00:35:15.530
die Daten validieren möchte, klar, kann man jetzt ganz

00:35:15.530 --> 00:35:17.630
streng sein und jedes Mal dann, wenn es nicht passt,

00:35:17.630 --> 00:35:19.890
einfach zurückgeben, okay, danke,

00:35:19.890 --> 00:35:21.270
du darfst nicht oder so.

00:35:21.270 --> 00:35:23.490
Ich glaube, ich glaube, ich glaube, das läuft jetzt

00:35:23.490 --> 00:35:25.530
quasi darauf hinaus, wie sollte so eine Test...

00:35:25.530 --> 00:35:27.310
Es gibt ja diese

00:35:27.310 --> 00:35:29.090
Testpyramide, wie sollte die aussehen?

00:35:29.090 --> 00:35:31.070
Quasi, ja.

00:35:31.070 --> 00:35:33.350
Weil sozusagen, also,

00:35:33.450 --> 00:35:35.250
ja, dass man halt viele

00:35:35.250 --> 00:35:36.970
Unit-Tests hat, irgendwie dann

00:35:36.970 --> 00:35:39.310
weniger irgendwie Tests, die

00:35:39.310 --> 00:35:41.270
halt irgendwie größere Sachen testen und dann halt

00:35:41.270 --> 00:35:43.330
nur ganz wenige irgendwie

00:35:43.330 --> 00:35:45.030
so End-to-End-Tests oder so.

00:35:45.030 --> 00:35:47.370
Man kann natürlich jetzt sicher auch mit sowas wie

00:35:47.370 --> 00:35:49.430
Playwright oder sowas eine komplette Frontend-

00:35:49.430 --> 00:35:51.390
Integrationsstrecke bauen, die jedes Mal dann testet,

00:35:51.390 --> 00:35:53.290
ob die Farbe bei dem Button sich geändert

00:35:53.290 --> 00:35:55.410
hat und ob weiße Zentimeter links oder

00:35:55.410 --> 00:35:57.150
rechts sind, aber wenn halt irgendeine Änderung von irgendeinem

00:35:57.150 --> 00:35:59.210
Designer kommt, dann dann die ganze Pipeline sieht jetzt mal auseinanderfliegen,

00:35:59.210 --> 00:36:00.970
ist wahrscheinlich eher zu viel.

00:36:00.970 --> 00:36:03.290
Genau. So, aber

00:36:03.290 --> 00:36:05.310
also ich glaube, man muss

00:36:05.310 --> 00:36:07.150
halt irgendwie so sich überlegen, was der Anwendungsfall,

00:36:07.150 --> 00:36:09.190
ob der sinnvoll ist halt auch, ne? Also ob es halt

00:36:09.190 --> 00:36:10.890
einen Sinn hat, dass man

00:36:10.890 --> 00:36:13.270
eine breite Anwendungsfall hat oder ob man das so enger

00:36:13.270 --> 00:36:15.050
scopen möchte. Und

00:36:15.050 --> 00:36:17.130
das würdet ihr wahrscheinlich am besten wissen, wenn

00:36:17.130 --> 00:36:19.130
ihr Anwendungen baut, an welchen Stellen die nicht

00:36:19.130 --> 00:36:20.990
auseinanderfliegen sollte. Also wenn ihr irgendwas macht, was

00:36:20.990 --> 00:36:23.210
wichtig ist, irgendwie wo Leben dran

00:36:23.210 --> 00:36:25.170
hängt oder was teuer ist oder sowas, dann sollte man da

00:36:25.170 --> 00:36:27.470
vielleicht ein bisschen mehr Hirnschmalz reinstecken,

00:36:27.470 --> 00:36:29.470
das so ein bisschen sauberer

00:36:29.470 --> 00:36:30.650
zu programmieren. Und

00:36:30.650 --> 00:36:33.130
ich habe immer das Gefühl, also Tests haben mir auch

00:36:33.130 --> 00:36:35.050
sehr geholfen, so die Architektur, mit der ich irgendwie

00:36:35.050 --> 00:36:36.810
überhaupt Programme schreibe, so ein bisschen zu überdenken,

00:36:36.810 --> 00:36:38.970
weil man halt merkt, dass man halt

00:36:38.970 --> 00:36:41.250
so große Module oder sowas oder Dinge,

00:36:41.250 --> 00:36:43.110
die viel machen, dass die schwierig

00:36:43.110 --> 00:36:45.030
halt werden. Also A, zu testen, aber was vielleicht auch

00:36:45.030 --> 00:36:47.210
eine doofe Idee ist, wenn in einer Methode

00:36:47.210 --> 00:36:48.850
oder in einer Funktion nur super viele Sachen

00:36:48.850 --> 00:36:50.930
gleichzeitig passieren und solche Dinge.

00:36:50.930 --> 00:36:52.710
Und ja,

00:36:52.710 --> 00:36:55.010
und da kommen wir halt auch wieder

00:36:55.010 --> 00:36:56.990
zu Coverage, ne? Wenn man halt so viel Zeugs hat,

00:36:56.990 --> 00:36:58.910
was passiert, auf einmal passiert,

00:36:58.910 --> 00:37:00.910
so ein bisschen sich so von diesem ein Ding für

00:37:00.910 --> 00:37:02.530
eine Sache Prinzip verabschiedet,

00:37:02.970 --> 00:37:04.790
dann wird das halt auch relativ schwierig

00:37:04.790 --> 00:37:06.770
zu testen dann, ja? Oder

00:37:06.770 --> 00:37:08.890
überhaupt dann so hinzukommen, dass die Sachen so passieren

00:37:08.890 --> 00:37:10.410
oder dass man die Bugs dann findet oder

00:37:10.410 --> 00:37:12.950
Ja, aber

00:37:12.950 --> 00:37:14.870
ich fürchte, man kann nicht einfach

00:37:14.870 --> 00:37:16.910
sagen, man muss das jetzt so machen und dann

00:37:16.910 --> 00:37:19.310
ist es halt, weil das sind so widerstreitende

00:37:19.310 --> 00:37:20.630
Dinge und so Trade-offs.

00:37:20.630 --> 00:37:22.690
Also ich würde ja auch

00:37:22.690 --> 00:37:24.810
genau, das ist halt, also das ist auch etwas, was

00:37:24.810 --> 00:37:26.330
beim Testen, was ich gut finde,

00:37:26.330 --> 00:37:28.930
dass man halt irgendwie so ein bisschen in die Richtung

00:37:28.930 --> 00:37:30.790
gedrängt wird, sich darüber Gedanken zu machen, wie man

00:37:30.790 --> 00:37:32.810
Sachen halt so hinschreibt, dass man sie

00:37:32.810 --> 00:37:34.710
gut testen kann und irgendwann hat man das dann

00:37:34.710 --> 00:37:36.690
halt auch so ein bisschen verinnerlicht, dass man, weiß man schon,

00:37:36.690 --> 00:37:38.670
wie man am besten Dinge so hinschreibt,

00:37:38.670 --> 00:37:40.530
dass hinterher die Tests sehr, sehr, sehr

00:37:40.530 --> 00:37:42.690
einfach hinzuschreiben sind und wenn das nicht

00:37:42.690 --> 00:37:44.630
geht, dann ist das halt auch einfach nichts, was man

00:37:44.630 --> 00:37:46.510
halt so schreiben sollte wahrscheinlich.

00:37:46.510 --> 00:37:48.050
Auf der anderen Seite, also

00:37:48.050 --> 00:37:50.650
ist es halt auch so, ist es halt,

00:37:50.650 --> 00:37:52.670
wäre es halt schön oder elegant

00:37:52.670 --> 00:37:54.550
von der Architektur her, wenn man

00:37:54.550 --> 00:37:55.390
jetzt halt eher

00:37:55.390 --> 00:37:58.130
schmale und tiefe Funktionen hat.

00:37:58.130 --> 00:38:00.590
Ja, also

00:38:00.590 --> 00:38:02.650
sozusagen, aber die sind halt

00:38:02.650 --> 00:38:04.350
schwer zu testen, auch unter Umständen, also

00:38:04.350 --> 00:38:06.570
es ist nicht unbedingt, also du kannst natürlich auch

00:38:06.570 --> 00:38:09.150
viele Funktionen,

00:38:09.150 --> 00:38:09.410
also,

00:38:09.410 --> 00:38:12.590
dass es etwas super zu testen ist, muss jetzt nicht unbedingt

00:38:12.590 --> 00:38:14.450
bedeuten, dass es halt auch total

00:38:14.450 --> 00:38:15.890
elegant ist, zum Beispiel

00:38:15.890 --> 00:38:18.410
zu verwenden. Also

00:38:18.410 --> 00:38:20.570
es kann sein, dass zum Beispiel, nehmen wir mal ein Beispiel

00:38:20.570 --> 00:38:21.910
für eine sehr schlechte API,

00:38:21.910 --> 00:38:24.210
die ganze Java-File

00:38:24.210 --> 00:38:26.550
irgendwie buffert, reader, irgendwas

00:38:26.550 --> 00:38:28.490
sonst was, API, also ich könnte mir

00:38:28.490 --> 00:38:30.070
vorstellen, dass es relativ einfach zu testen ist,

00:38:30.070 --> 00:38:31.970
aber es ist halt ein Albtraum, das zu benutzen.

00:38:32.490 --> 00:38:34.070
Und die, nehmen wir an,

00:38:34.070 --> 00:38:36.070
ja, Unix-File-API oder halt auch irgendwie,

00:38:36.070 --> 00:38:37.930
keine Ahnung, Requests-API in Python,

00:38:37.930 --> 00:38:40.110
die ist halt schön, weil die ist

00:38:40.110 --> 00:38:42.190
halt schmal und tief, aber

00:38:42.190 --> 00:38:44.290
ich könnte mir vorstellen, dass Request zu testen eventuell

00:38:44.290 --> 00:38:46.050
ziemlicher Schmerz ist.

00:38:46.050 --> 00:38:48.190
Es hängt halt davon

00:38:48.190 --> 00:38:50.050
ab, was sein

00:38:50.050 --> 00:38:51.990
Anwendungsfall ist, ob das jetzt, also

00:38:51.990 --> 00:38:54.250
wenn du sagst jetzt irgendwie, das ist eine interne Funktion

00:38:54.250 --> 00:38:56.290
und da ist es schön,

00:38:56.290 --> 00:38:58.090
wenn man die einfach testen kann, dann

00:38:58.090 --> 00:38:59.890
macht es halt Sinn, das vielleicht so zu machen, aber wenn

00:38:59.890 --> 00:39:02.010
das jetzt was ist, was nach außen geht,

00:39:02.330 --> 00:39:04.370
wo User dann halt den Schmerz

00:39:04.370 --> 00:39:06.090
haben, dass du es einfach zu testen hast,

00:39:06.090 --> 00:39:07.350
dann muss man sagen, naja, nee,

00:39:07.350 --> 00:39:10.050
dann muss es halt für User einfach zu verwenden sein und wenn das

00:39:10.050 --> 00:39:12.070
halt bedeutet, dass es schmerzhaft ist, das zu

00:39:12.070 --> 00:39:14.090
testen, dann ist das halt so, weil

00:39:14.090 --> 00:39:15.770
wichtiger ist an der Stelle die User-Experience.

00:39:15.770 --> 00:39:18.330
Also es kommt halt drauf an, denke ich.

00:39:18.330 --> 00:39:23.990
Ja, um auch vielleicht

00:39:23.990 --> 00:39:26.030
nochmal bei dieser Testing-Pyramid einzuhängen,

00:39:26.030 --> 00:39:28.050
ich finde da

00:39:28.050 --> 00:39:30.030
immer so, ich finde das

00:39:30.030 --> 00:39:32.090
ein bisschen zu kurz gedacht. Es kommt halt immer

00:39:32.170 --> 00:39:34.090
sehr darauf an, was man testet

00:39:34.090 --> 00:39:35.870
und man soll sich halt zu den

00:39:35.870 --> 00:39:37.370
Vor- und Nachteilen von diesen

00:39:37.370 --> 00:39:39.330
Größen, sage ich mal, von Tests

00:39:39.330 --> 00:39:41.870
bewusst sein, aber ich finde zunächst,

00:39:41.870 --> 00:39:44.030
man kann immer sagen,

00:39:44.030 --> 00:39:46.290
dass die eine Art ist besser wie die andere Art.

00:39:46.290 --> 00:39:46.890
Ja.

00:39:46.890 --> 00:39:50.310
Wenn ich jetzt ein Command-Line-Tool teste,

00:39:50.310 --> 00:39:52.150
bietet es sich vielleicht

00:39:52.150 --> 00:39:54.190
an, da eher End-to-End-Tests zu schreiben,

00:39:54.190 --> 00:39:55.910
weil ich dann wirklich auch den Output und so

00:39:55.910 --> 00:39:56.630
testen kann

00:39:56.630 --> 00:39:59.790
und eher sparsam,

00:39:59.790 --> 00:40:01.910
so wie für einzelne Funktionen,

00:40:02.010 --> 00:40:02.930
die Tests zu schreiben.

00:40:02.930 --> 00:40:05.130
Oder auch, ich

00:40:05.130 --> 00:40:07.750
bin viel auch jetzt bei Firmen

00:40:07.750 --> 00:40:09.810
für die Kurse, die eigentlich gar

00:40:09.810 --> 00:40:11.590
keinen Python-Code mit PyTest testen.

00:40:11.590 --> 00:40:12.650
Das fand ich auch ganz spannend.

00:40:12.650 --> 00:40:14.170
Ja, das ist auch total interessant.

00:40:14.170 --> 00:40:17.650
Sondern die beispielsweise Waschmaschinen

00:40:17.650 --> 00:40:19.090
mit PyTest testen.

00:40:19.090 --> 00:40:21.850
Also da halt eine Waschmaschine

00:40:21.850 --> 00:40:23.970
haben, wo dann ein Firmware drauf läuft

00:40:23.970 --> 00:40:25.030
und

00:40:25.030 --> 00:40:27.010
die wollen sie halt testen.

00:40:27.010 --> 00:40:29.950
Und wollen halt dazu

00:40:29.950 --> 00:40:31.850
PyTest nutzen, weil es eben

00:40:31.850 --> 00:40:33.990
zusammen mit Python ein relativ einfaches

00:40:33.990 --> 00:40:36.050
und flexibles Werkzeug darstellt.

00:40:36.050 --> 00:40:37.850
Gucken, ob noch alles geht.

00:40:37.850 --> 00:40:40.030
Wenn man die richtigen

00:40:40.030 --> 00:40:41.670
Knöpfe drückt und das richtige Programm läuft.

00:40:41.670 --> 00:40:43.870
Ja, und die Tests sind halt einfach zu schreiben.

00:40:43.870 --> 00:40:45.950
Ja, das ist eine gute Idee.

00:40:45.950 --> 00:40:48.150
Oder bei einem Kunden von mir,

00:40:48.150 --> 00:40:50.070
um vielleicht

00:40:50.070 --> 00:40:52.030
dann gleich die Überleitung zu den Fixtures zu machen

00:40:52.030 --> 00:40:54.130
an der Stelle, die nutzen

00:40:54.130 --> 00:40:55.910
eine PyTest-Fixture, um

00:40:55.910 --> 00:40:57.770
eine Klimakammer anzusteuern.

00:40:57.770 --> 00:41:00.290
Wir haben so eine Klimakammer

00:41:00.290 --> 00:41:01.690
mit Elektronik drin

00:41:01.690 --> 00:41:03.590
und sagen dann halt über eine

00:41:03.590 --> 00:41:05.750
PyTest-Fixture, heiz mir das

00:41:05.750 --> 00:41:07.590
jetzt auf auf 30 Grad und dann

00:41:07.590 --> 00:41:09.750
lasse ich da meine System-Tests

00:41:09.750 --> 00:41:11.030
für dieses Gerät laufen.

00:41:11.030 --> 00:41:13.390
Wo auch wieder halt

00:41:13.390 --> 00:41:15.490
alles andere als Python-Code getestet wird.

00:41:15.490 --> 00:41:19.550
Ja, spannend, ne?

00:41:19.550 --> 00:41:21.670
Wenn man halt wirklich das mit in die Realität überträgt

00:41:21.670 --> 00:41:23.030
und quasi auch seine Hardware damit

00:41:23.030 --> 00:41:25.790
steuert, um die Testumgebung

00:41:25.790 --> 00:41:27.570
außerhalb des Rechners

00:41:27.570 --> 00:41:29.210
aufzubauen oder halt aufzuheizen.

00:41:29.210 --> 00:41:31.590
Bestimmen die Parameter, machen die das,

00:41:31.610 --> 00:41:32.030
was sie sollen.

00:41:32.030 --> 00:41:33.750
Das ist, ja.

00:41:33.750 --> 00:41:37.090
Und jetzt habe ich das vergessen, was ich eigentlich sagen wollte.

00:41:37.090 --> 00:41:39.130
Ja, Fixtures, Überleitung zu Fixtures.

00:41:39.130 --> 00:41:41.490
Das auch, aber vorher noch.

00:41:41.490 --> 00:41:43.450
Was eigentlich mein Punkt war,

00:41:43.450 --> 00:41:45.750
da hat man ja dann gar keine

00:41:45.750 --> 00:41:47.530
Wahl, welche Größen von Tests

00:41:47.530 --> 00:41:49.570
man schreiben will. Also da schreibt man fast

00:41:49.570 --> 00:41:51.610
gezwungenermaßen dann eben System-Tests

00:41:51.610 --> 00:41:52.930
oder so End-to-End-Tests

00:41:52.930 --> 00:41:54.930
und kann ja nicht mehr wirklich

00:41:54.930 --> 00:41:57.990
einzelne Funktionen dieses Geräts

00:41:57.990 --> 00:41:59.850
also jetzt im Sinne eines Unitests

00:41:59.850 --> 00:42:01.050
testen.

00:42:01.450 --> 00:42:03.370
Mhm. Ja, im Grunde ist das ja

00:42:03.370 --> 00:42:04.910
auch schon so, wenn man Pi-Tests

00:42:04.910 --> 00:42:07.270
zum Schreiben von End-to-End-Tests, was man ja auch machen kann,

00:42:07.270 --> 00:42:08.270
verwendet, wie zum Beispiel mit

00:42:08.270 --> 00:42:11.330
Pi-Test Playwright oder so, dann da ist ja

00:42:11.330 --> 00:42:12.990
auch eigentlich jeder Test im Grunde

00:42:12.990 --> 00:42:15.450
weniger. Man muss halt den Browser aufmachen

00:42:15.450 --> 00:42:16.830
und dann da überhin und dann...

00:42:16.830 --> 00:42:17.370
Ja.

00:42:17.370 --> 00:42:19.550
Ja.

00:42:19.550 --> 00:42:22.950
Ja, von da finde ich so dieses Testing-Pyramid,

00:42:22.950 --> 00:42:24.650
ich meine, die Idee ist ja auch steinalt,

00:42:24.650 --> 00:42:25.570
muss man dazu sagen.

00:42:25.570 --> 00:42:28.990
Bin ich mit Vorsicht zu genießen.

00:42:28.990 --> 00:42:31.430
Dann aber,

00:42:31.430 --> 00:42:33.050
vielleicht tatsächlich dazu, zu Figures

00:42:33.050 --> 00:42:35.330
und was Figures sind und wie man die baut oder

00:42:35.330 --> 00:42:37.750
macht ihr das mit Factories

00:42:37.750 --> 00:42:39.270
oder macht ihr das ohne Factories

00:42:39.270 --> 00:42:41.550
oder sind Factories doof oder

00:42:41.550 --> 00:42:43.290
gibt es da so verschiedene Sachen und

00:42:43.290 --> 00:42:45.090
was sind überhaupt Figures und

00:42:45.090 --> 00:42:47.550
ja, also vielleicht so fertige

00:42:47.550 --> 00:42:49.190
Dinge, die

00:42:49.190 --> 00:42:51.330
so tun, als wären sie etwas, was das

00:42:51.330 --> 00:42:53.450
Programm normalerweise kann. Das war jetzt ein bisschen

00:42:53.450 --> 00:42:55.210
abstrakt. Ich weiß nicht, gibt es da ein einfaches Beispiel?

00:42:55.210 --> 00:42:57.450
Also wenn

00:42:57.450 --> 00:42:59.230
wir mit einem normalen Web-Client zum Beispiel

00:42:59.230 --> 00:43:01.170
arbeiten würden, dann würde halt eine Figur werden, der User und

00:43:01.170 --> 00:43:03.010
einen Client und dann guckt man, wie das

00:43:03.010 --> 00:43:03.750
interagiert oder

00:43:03.750 --> 00:43:06.410
wie baut man das?

00:43:06.410 --> 00:43:07.790
Ja, am Schluss ist eine Fixture

00:43:07.790 --> 00:43:10.930
im Prinzip einfach eine Funktion, die

00:43:10.930 --> 00:43:12.210
als PyTest-Fixture

00:43:12.210 --> 00:43:14.810
markiert ist oder

00:43:14.810 --> 00:43:15.730
dekoriert ist

00:43:15.730 --> 00:43:18.850
und diese Fixture kann

00:43:18.850 --> 00:43:21.550
entweder irgendwelche Setup-

00:43:21.550 --> 00:43:23.090
Schritte vornehmen für einen Test

00:43:23.090 --> 00:43:24.530
und oder

00:43:24.530 --> 00:43:27.070
irgendwelche Objekte für den Test bereitstellen.

00:43:27.070 --> 00:43:29.230
Das heißt,

00:43:29.230 --> 00:43:31.030
das kann jetzt sein, wenn ich

00:43:31.030 --> 00:43:32.890
irgendwo eine Config-Klasse habe,

00:43:32.890 --> 00:43:35.130
vielleicht in meinem Code,

00:43:35.130 --> 00:43:36.790
dann habe ich vielleicht in meinen Tests eben

00:43:36.790 --> 00:43:37.830
eine Config-Fixture,

00:43:37.830 --> 00:43:40.430
was mir eine sinnvoll

00:43:40.430 --> 00:43:42.810
konfigurierte Instanz

00:43:42.810 --> 00:43:44.330
gibt von dieser Config-Klasse.

00:43:44.330 --> 00:43:46.970
Oder in den Trainings

00:43:46.970 --> 00:43:48.410
habe ich das Beispiel von so einem

00:43:48.410 --> 00:43:50.750
R-Pan-Calculator, den ich testen will,

00:43:50.750 --> 00:43:52.750
der nimmt dann auch eine Config als Argument

00:43:52.750 --> 00:43:54.750
und sowas und damit ich

00:43:54.750 --> 00:43:56.670
einfach nur die Instanzierung

00:43:56.670 --> 00:43:58.730
von diesem R-Pan-Calculator,

00:43:58.730 --> 00:44:00.990
also einfach ein Taschenrechner im Prinzip,

00:44:01.030 --> 00:44:02.030
in Python geschrieben,

00:44:02.030 --> 00:44:05.030
damit ich das nicht copy-pasten muss in jedem

00:44:05.030 --> 00:44:07.310
Test, mache ich mir eben so eine Fixture-Funktion,

00:44:07.310 --> 00:44:09.370
wo ich das alles aufsetze,

00:44:09.370 --> 00:44:10.390
zurückgebe

00:44:10.390 --> 00:44:12.870
und Tests können dann diese Fixture

00:44:12.870 --> 00:44:15.110
eben nutzen. Mit dem Ziel

00:44:15.110 --> 00:44:16.650
eben so diese Setup-Schritte

00:44:16.650 --> 00:44:18.970
schön zu isolieren aus

00:44:18.970 --> 00:44:20.950
den Testfunktionen. Also man baut sich quasi das Objekt,

00:44:20.950 --> 00:44:22.970
das die API bereitstellt, einmal irgendwie

00:44:22.970 --> 00:44:24.950
mit den Parametern nach, wie man sie in echt auch gerne

00:44:24.950 --> 00:44:27.050
hätte, um die dann in dem Test benutzen

00:44:27.050 --> 00:44:29.110
zu können, zu gucken, ob die Ergebnisse, die man erwartet,

00:44:29.110 --> 00:44:30.850
dem entsprechen, was man möchte.

00:44:31.030 --> 00:44:32.050
Genau.

00:44:32.050 --> 00:44:35.010
Ja, schwierig, das jetzt so

00:44:35.010 --> 00:44:36.190
in ein paar Sätze zu fassen.

00:44:36.190 --> 00:44:38.930
Ja, ich finde das auch sehr abstrakt halt. Also wenn man das nicht gut sieht,

00:44:38.930 --> 00:44:39.990
dann wird das relativ klar.

00:44:39.990 --> 00:44:42.850
Die Spezialität bei PyTest-Fixers ist halt, dass die so

00:44:42.850 --> 00:44:44.530
diese magische

00:44:44.530 --> 00:44:46.870
Dependency-Injection gibt, sodass man halt

00:44:46.870 --> 00:44:49.210
einfach nur den Namen der Fixer

00:44:49.210 --> 00:44:51.030
in die Parameter

00:44:51.030 --> 00:44:52.410
vom Test schreibt und dann

00:44:52.410 --> 00:44:53.910
das automatisch ausgeführt wird.

00:44:53.910 --> 00:44:56.650
Genau, dafür schreibt man die Funktion ja quasi in den Conv-Test einfach rein.

00:44:56.650 --> 00:44:58.310
Ja, nö, musst du nicht.

00:44:58.310 --> 00:45:00.350
Ja, aber auch das ist schon, ja genau, aber auch gute Frage,

00:45:00.350 --> 00:45:01.010
ist das eine gute Idee?

00:45:01.030 --> 00:45:01.610
Ja, das ist eine gute Idee und so.

00:45:01.610 --> 00:45:03.070
Hängt davon ab.

00:45:03.070 --> 00:45:06.890
Aber es ist halt, also

00:45:06.890 --> 00:45:08.950
ich weiß auch nicht, ob man das heute nochmal machen würde,

00:45:08.950 --> 00:45:11.170
wenn man das nochmal designt, weil das ist schon sehr magisch.

00:45:11.170 --> 00:45:12.630
Und ich meine,

00:45:12.630 --> 00:45:14.870
ansonsten hat man ja, wenn man jetzt eine Funktion einfach

00:45:14.870 --> 00:45:16.770
aufrufen würde oder so, haben ja auch Support in der IDE,

00:45:16.770 --> 00:45:18.250
dass man draufklicken kann und landet dann da.

00:45:18.250 --> 00:45:20.990
Also bei PyCharm geht das zum Beispiel, dass man halt

00:45:20.990 --> 00:45:21.670
auf einfach eine

00:45:21.670 --> 00:45:24.530
Fixture in PyTest klickt und dann halt

00:45:24.530 --> 00:45:25.970
im richtigen Code landet.

00:45:25.970 --> 00:45:28.970
Aber das ist halt natürlich irgendwie nur

00:45:28.970 --> 00:45:30.930
dadurch, dass da jemand die Arbeit investiert

00:45:30.930 --> 00:45:31.010
hat.

00:45:31.030 --> 00:45:32.690
Irgendwie das

00:45:32.690 --> 00:45:34.770
parsen zu können und so. Also

00:45:34.770 --> 00:45:36.370
das wird wahrscheinlich nicht überall funktionieren.

00:45:36.370 --> 00:45:38.670
Es gibt auch eine Extension für andere Editoren.

00:45:38.670 --> 00:45:38.990
Ja.

00:45:38.990 --> 00:45:42.590
Es ist schon eigenartig, ja.

00:45:42.590 --> 00:45:43.530
Also ich sag so, dass

00:45:43.530 --> 00:45:46.750
inzwischen habe ich es glaube ich raus, wie ich das den Leuten

00:45:46.750 --> 00:45:48.470
erkläre, dass das passt.

00:45:48.470 --> 00:45:51.150
Aber gerade am Anfang mit den Trainings

00:45:51.150 --> 00:45:52.930
war das so der Punkt, wo ich sagen musste,

00:45:52.930 --> 00:45:55.210
ja, ich werde auch jetzt erstmal verwirren

00:45:55.210 --> 00:45:56.810
und irgendwann werde ich es verstehen.

00:45:56.810 --> 00:45:58.690
Aber nicht gerade vom ersten Satz.

00:45:58.690 --> 00:46:00.650
Ja, ich fand das auch sehr, sehr schwierig, also vor allen Dingen

00:46:00.650 --> 00:46:02.510
diesen Unterschied zwischen Modulscope,

00:46:02.510 --> 00:46:04.550
Class-based Scope und Function-based Scope

00:46:04.550 --> 00:46:06.670
Fixtures und sowas. Und erstmal

00:46:06.670 --> 00:46:08.430
zu verstehen, dass halt eine Fixture irgendwie eigentlich ein

00:46:08.430 --> 00:46:10.550
Generator ist, der irgendwie halt dieses Setup und Teardown

00:46:10.550 --> 00:46:11.850
vorher und nachher macht und eigentlich nicht

00:46:11.850 --> 00:46:14.090
Returns, sondern eher was Yielded und dann

00:46:14.090 --> 00:46:16.530
was da so passiert, das war schwer zu verstehen. Also auch

00:46:16.530 --> 00:46:18.490
diese, dass die Fixtures alle immer neu

00:46:18.490 --> 00:46:20.590
gebaut werden, dann für jeden Test

00:46:20.590 --> 00:46:22.150
atomar und so, das war alles so ein bisschen

00:46:22.150 --> 00:46:24.850
ja, das hat ein bisschen gebraucht,

00:46:24.850 --> 00:46:25.310
würde ich sagen.

00:46:25.310 --> 00:46:28.490
Gut, das sind jetzt ja alles Dinge mit diesem Caching

00:46:28.490 --> 00:46:30.450
Scope und Yield und Teardown

00:46:30.450 --> 00:46:32.490
und so, das kommt ja dann erstmal obendrauf

00:46:32.490 --> 00:46:33.430
auf das Grundkonzept.

00:46:33.430 --> 00:46:36.330
Also um Fixtures an sich erstmal

00:46:36.330 --> 00:46:38.290
zu verstehen, kann man das, glaube ich, das meiste

00:46:38.290 --> 00:46:40.310
davon weglassen. Ja, ich glaube, meistens fällt man halt irgendwie

00:46:40.310 --> 00:46:42.250
direkt rüber und die machen halt dann irgendwelche Dinge,

00:46:42.250 --> 00:46:44.330
die man nicht erwartet und da kann man sich also schon

00:46:44.330 --> 00:46:46.210
ein bisschen mit in den Fuß schießen. Also ich würde

00:46:46.210 --> 00:46:48.230
auch empfehlen, also nicht am Anfang zu viel

00:46:48.230 --> 00:46:50.310
komplexe Tests darzuschreiben, nur vielleicht erstmal

00:46:50.310 --> 00:46:51.910
ein klein oder ein, zwei kleine

00:46:51.910 --> 00:46:54.090
und halt einfache Objekte einzugeben,

00:46:54.090 --> 00:46:55.430
wo man halt guckt, wie die

00:46:55.430 --> 00:46:57.590
zusammenhängen zum Beispiel oder was die tun.

00:47:00.250 --> 00:47:02.510
Also was ich halt

00:47:02.510 --> 00:47:04.430
hinterher wirklich schwierig finde, ist dann Objekte

00:47:04.430 --> 00:47:06.250
zu erzeugen oder viele Objekte oder halt dann

00:47:06.250 --> 00:47:08.290
man kann, was halt auch sehr schön ist,

00:47:08.290 --> 00:47:09.990
was Florian auch gut gezeigt hat, ist irgendwie

00:47:09.990 --> 00:47:11.950
Parametrisierung mit beispielsweise

00:47:11.950 --> 00:47:14.350
Data Classes oder sowas, dass man

00:47:14.350 --> 00:47:16.290
halt tatsächlich eine Plethora

00:47:16.290 --> 00:47:18.290
hundert verschiedene Dinge

00:47:18.290 --> 00:47:20.170
erstellt, automatisiert erzeugt an

00:47:20.170 --> 00:47:22.330
Tests, die die verschiedenen Edge Cases

00:47:22.330 --> 00:47:24.350
seiner Fälle dann halt auch beinhalten

00:47:24.350 --> 00:47:26.150
und man halt dann die Logik testen kann,

00:47:26.150 --> 00:47:28.190
ob sie da halt dann auch reißt, ohne

00:47:28.190 --> 00:47:29.950
jetzt direkt auf Hypotheses zu gehen,

00:47:30.050 --> 00:47:31.730
also mit

00:47:31.730 --> 00:47:33.930
zufälligen Figures, wenn ich das richtig verstehe, ja?

00:47:33.930 --> 00:47:35.550
Oder Zufallswerten für

00:47:35.550 --> 00:47:37.190
Dinge in den Figures.

00:47:37.190 --> 00:47:40.230
Ja, vielleicht noch kurz zur Parametrisierung.

00:47:40.230 --> 00:47:41.850
Wenn ich mir jetzt PyTest

00:47:41.850 --> 00:47:43.990
anschauen würde und mal so die erste Testfunktion

00:47:43.990 --> 00:47:46.110
geschrieben habe, wäre das

00:47:46.110 --> 00:47:47.830
sicherlich so eines der ersten Dinge,

00:47:47.830 --> 00:47:49.970
das ich anschauen würde, ist auch eines

00:47:49.970 --> 00:47:51.750
der ersten Dinge dann in meinem Training,

00:47:51.750 --> 00:47:53.630
weil

00:47:53.630 --> 00:47:55.970
das, finde ich, es halt echt einfach macht,

00:47:55.970 --> 00:47:57.570
ziemlich viel abzudecken.

00:47:57.570 --> 00:47:59.850
Wenn man jetzt irgendeine Funktion testet

00:47:59.850 --> 00:48:01.890
um halt eben nicht einen Input und einen

00:48:01.890 --> 00:48:03.910
Output nur zu testen,

00:48:03.910 --> 00:48:05.570
jetzt mal bei irgendeiner

00:48:05.570 --> 00:48:07.890
langweiligen Utility-Funktion,

00:48:07.890 --> 00:48:09.550
ich habe bei mir zum Beispiel so ein

00:48:09.550 --> 00:48:11.210
Format Seconds, wo ich einfach

00:48:11.210 --> 00:48:13.690
Sekunden übergebe und das dann schön

00:48:13.690 --> 00:48:16.070
formatiere in halt Stunden, Minuten, Sekunden

00:48:16.070 --> 00:48:16.750
beispielsweise.

00:48:16.750 --> 00:48:19.770
Oder hast du auch eine Seite übrigens,

00:48:19.770 --> 00:48:21.650
kurzer Exkurs, F-String irgendwie

00:48:21.650 --> 00:48:22.410
Docs, kann das sein?

00:48:22.410 --> 00:48:24.370
F-String.help, genau.

00:48:24.370 --> 00:48:26.410
Oh ja, die habe ich auch schon oft

00:48:26.410 --> 00:48:27.950
angeguckt.

00:48:27.950 --> 00:48:29.330
Eine Webseite von mir,

00:48:29.650 --> 00:48:31.650
habe ich mal irgendwo

00:48:31.650 --> 00:48:33.630
an der PyCon Germany, ich wollte

00:48:33.630 --> 00:48:35.610
schon seit Jahren machen und dann kamen da

00:48:35.610 --> 00:48:37.490
die Lightning Talks an der PyCon Germany

00:48:37.490 --> 00:48:39.530
und abends vor den Lightning Talks

00:48:39.530 --> 00:48:40.570
habe ich die noch kurz gemacht,

00:48:40.570 --> 00:48:43.890
um sie dann eben da vorstellen zu können.

00:48:43.890 --> 00:48:45.290
Ja, aber die ist echt super, weil sowas hat echt

00:48:45.290 --> 00:48:47.130
gefehlt, wenn ich zwischendurch da reingucke, das ist echt gut.

00:48:47.130 --> 00:48:48.930
Habe ich gerne.

00:48:48.930 --> 00:48:51.050
Ja, Parameterization

00:48:51.050 --> 00:48:53.890
macht es einem eben einfach,

00:48:53.890 --> 00:48:55.650
um dann aus einer Testfunktion,

00:48:55.650 --> 00:48:57.250
die nur einen Wert testet,

00:48:57.250 --> 00:48:59.350
den so zu erweitern,

00:48:59.450 --> 00:49:01.190
um zum Beispiel 10 oder 20

00:49:01.190 --> 00:49:02.590
Werte zu testen,

00:49:02.590 --> 00:49:05.450
ohne 10 oder 20 separate Funktionen

00:49:05.450 --> 00:49:06.630
dafür schreiben zu müssen.

00:49:06.630 --> 00:49:09.530
Und das ist sowas, das vermisse

00:49:09.530 --> 00:49:11.470
ich dann sehr schnell in anderen Testframes,

00:49:11.470 --> 00:49:13.210
Merks. Meistens geht das schon irgendwie,

00:49:13.210 --> 00:49:15.650
aber halt mit einer aufwendigeren Syntax

00:49:15.650 --> 00:49:17.690
als in Python oder als mit PyTest.

00:49:17.690 --> 00:49:21.310
Ja, genau.

00:49:21.310 --> 00:49:23.590
Also PyTest Parameterize ist halt

00:49:23.590 --> 00:49:25.410
irgendwie dann der Dekorator, den man da

00:49:25.410 --> 00:49:27.290
verwendet. Den benutze ich auch ständig.

00:49:27.290 --> 00:49:29.550
Aber es gibt auch noch eine andere Möglichkeit.

00:49:29.550 --> 00:49:31.010
Man kann auch irgendwie Fixtures,

00:49:31.010 --> 00:49:33.330
die können irgendwie mehrere

00:49:33.330 --> 00:49:35.550
Dinge zurückgeben und dann werden auch

00:49:35.550 --> 00:49:37.430
quasi

00:49:37.430 --> 00:49:39.090
sozusagen wie unterschiedliche Parameter,

00:49:39.090 --> 00:49:41.370
also wird der Test auch mehrfach ausgeführt mit den

00:49:41.370 --> 00:49:43.270
unterschiedlichen Parameter. Also du meinst, wenn du mehrfach hintereinander yieldest,

00:49:43.270 --> 00:49:45.190
weil das beim ersten Aufbruch, beim zweiten Aufbruch

00:49:45.190 --> 00:49:46.210
und beim dritten Aufbruch passiert?

00:49:46.210 --> 00:49:48.730
Ich weiß es gar nicht mehr genau.

00:49:48.730 --> 00:49:51.110
Nee, du kannst im

00:49:51.110 --> 00:49:53.170
Fixture Decorator kannst du dann nochmal eine

00:49:53.170 --> 00:49:54.830
Liste von Params angeben.

00:49:54.830 --> 00:49:57.050
Genau. Und dann wird jeder

00:49:57.050 --> 00:49:59.190
Test, der die Fixture nutzt, wird halt mehrmals

00:49:59.190 --> 00:50:00.590
ausgeführt. Ja, genau.

00:50:00.590 --> 00:50:02.890
Mit der Idee, wenn du irgendwie mehrere

00:50:02.890 --> 00:50:05.770
Backends hast oder mehrere Implementationen,

00:50:05.770 --> 00:50:07.070
die sich aber eigentlich gleich verhalten

00:50:07.070 --> 00:50:09.090
sollen, dass dann halt eine ganze

00:50:09.090 --> 00:50:11.270
Batterie von Tests über beide beispielsweise

00:50:11.270 --> 00:50:12.470
Eislaufen lassen kannst.

00:50:12.470 --> 00:50:14.970
Ja. Genau, mir war das nur

00:50:14.970 --> 00:50:17.010
in Erinnerung geblieben, als das auch eine Art, wie man

00:50:17.010 --> 00:50:18.930
Parametrisierung machen könnte, aber

00:50:18.930 --> 00:50:21.070
tatsächlich sehe ich eigentlich auch immer eher

00:50:21.070 --> 00:50:22.990
nur PyTest, Parameterize und den anderen Weg

00:50:22.990 --> 00:50:24.770
eigentlich selten. Genau, du kannst halt beide Sachen gehen,

00:50:24.770 --> 00:50:26.850
entweder direkt an den Testrandschreiben oder halt an die Fixture.

00:50:26.850 --> 00:50:29.050
Genau, aber jetzt sicherlich ein bisschen

00:50:29.050 --> 00:50:29.770
exotischer.

00:50:29.770 --> 00:50:34.750
Ja, das ist halt ganz nützlich,

00:50:34.750 --> 00:50:36.810
gerade für das Teardown. Also die Frage ist halt,

00:50:36.810 --> 00:50:38.950
nutzt ihr irgendwie sowas wie Factories oder

00:50:38.950 --> 00:50:40.570
sowas? Also, dass man dann

00:50:40.570 --> 00:50:43.030
Objekte zusammenbaut, ja, man könnte

00:50:43.030 --> 00:50:45.070
ja eine Factory schreiben, um einen User

00:50:45.070 --> 00:50:46.790
zu erzeugen, was da alles rein muss, der dann

00:50:46.790 --> 00:50:48.810
zum Beispiel Defaults enthält. Da habe ich einen

00:50:48.810 --> 00:50:51.030
schönen Blog-Eintrag zugesehen, wie

00:50:51.030 --> 00:50:53.070
man das ordentlich machen

00:50:53.070 --> 00:50:55.110
soll, irgendwie. Ja, weil es gab

00:50:55.110 --> 00:50:56.530
zwischendurch mal so eine Bibliothek, die

00:50:56.530 --> 00:50:58.910
hieß Factory Boy, die habe ich dann irgendwann

00:50:58.910 --> 00:51:01.010
wieder rausgeschmissen, die dann solche Sachen machte,

00:51:01.010 --> 00:51:02.750
aber nicht so wie das,

00:51:02.750 --> 00:51:04.890
wie ich das schön fand. Also

00:51:04.890 --> 00:51:06.850
mittlerweile glaube ich, man nimmt halt irgendwie

00:51:06.850 --> 00:51:09.110
dann einzelne Dinge von Faker vielleicht,

00:51:09.110 --> 00:51:10.550
um sich Zufallssachen,

00:51:10.570 --> 00:51:12.470
auch erstellen zu lassen und

00:51:12.470 --> 00:51:14.470
Ja, denke ich, ist aber ein anderes Problem, also

00:51:14.470 --> 00:51:16.510
ja. Und dann baut halt dann

00:51:16.510 --> 00:51:18.470
diese Funktion halt dann zufällig Objekte

00:51:18.470 --> 00:51:20.670
zusammen und dann könnte man zum Beispiel sagen, parametrisiere

00:51:20.670 --> 00:51:22.630
das mal für, keine Ahnung, 10 oder 20

00:51:22.630 --> 00:51:24.510
zufällige Nutzer

00:51:24.510 --> 00:51:25.970
aus so einer

00:51:25.970 --> 00:51:28.530
Factory heraus und benutze die halt einfach mal.

00:51:28.530 --> 00:51:30.670
Was die Tests natürlich nicht ganz

00:51:30.670 --> 00:51:32.390
so reproduzierbar macht

00:51:32.390 --> 00:51:33.850
vielleicht, aber vielleicht dann halt auch doch.

00:51:33.850 --> 00:51:36.110
Je nachdem, wie man das halt festgelegt hat.

00:51:36.110 --> 00:51:37.710
Wäre halt dann interessant,

00:51:37.710 --> 00:51:39.670
wie oft man das laufen lässt,

00:51:39.670 --> 00:51:40.350
um zu gucken,

00:51:40.570 --> 00:51:41.950
das Ergebnis immer gleich,

00:51:41.950 --> 00:51:44.110
ob man einen Spezialfall, wo es nicht passt,

00:51:44.110 --> 00:51:46.270
hat man einen Fehler in der Factory gebaut,

00:51:46.270 --> 00:51:48.330
nimmt man vielleicht sogar die Factory

00:51:48.330 --> 00:51:50.530
später auch für den eigentlichen Programmcode,

00:51:50.530 --> 00:51:52.450
um dann wirklich was Neues zu erzeugen?

00:51:52.450 --> 00:51:54.310
Ja,

00:51:54.310 --> 00:51:56.330
ich weiß jetzt nicht, wie sinnvoll

00:51:56.330 --> 00:51:57.290
ich das halte, also

00:51:57.290 --> 00:52:00.190
so gezielt sowas zu nutzen, wäre

00:52:00.190 --> 00:52:02.270
jetzt auch Hypothesis, was wir sicherlich

00:52:02.270 --> 00:52:04.030
noch darauf sprechen werden.

00:52:04.030 --> 00:52:06.110
Also Jochen, uns wird auch kurz nicht stören.

00:52:06.110 --> 00:52:07.870
Ja, ich habe sowas

00:52:07.870 --> 00:52:09.770
so was, Factory-Boys,

00:52:09.810 --> 00:52:11.850
sowas früher mal verwendet, aber ich mache das eigentlich

00:52:11.850 --> 00:52:12.590
inzwischen nicht mehr.

00:52:12.590 --> 00:52:14.190
Ich habe...

00:52:14.190 --> 00:52:17.310
Mach doch kurz fertig.

00:52:17.310 --> 00:52:19.830
Ja, also einfach deswegen, weil ich

00:52:19.830 --> 00:52:21.570
finde, das macht einfach zu viel Magie

00:52:21.570 --> 00:52:24.010
mit irgendwelchen, da hast du dann auch wieder so Dekoratoren

00:52:24.010 --> 00:52:25.750
für die...

00:52:25.750 --> 00:52:27.970
Also, und ich weiß

00:52:27.970 --> 00:52:29.450
gar nicht, ob diese Magie so viel bringt.

00:52:29.450 --> 00:52:31.850
Also, das ist immer so, das Verhältnis von wie viel Magie

00:52:31.850 --> 00:52:33.790
ist da und wie schwer ist das zu verstehen im Verhältnis zu wie viel

00:52:33.790 --> 00:52:35.790
Nutzen bringt, das ist für mich jetzt inzwischen

00:52:35.790 --> 00:52:37.390
nicht mehr so...

00:52:37.390 --> 00:52:39.630
Also diese Relation ist nicht so, dass ich sagen würde,

00:52:39.630 --> 00:52:41.470
das ist total sinnvoll, das zu verwenden, sondern ich denke mir

00:52:41.470 --> 00:52:43.670
eher so, inzwischen ist

00:52:43.670 --> 00:52:45.750
halt auch irgendwie, wenn man

00:52:45.750 --> 00:52:47.770
halt ordentliche Funktionen, die solche Daten generieren,

00:52:47.770 --> 00:52:49.270
schreibt, halt auch mit entsprechend

00:52:49.270 --> 00:52:51.910
benannten, weiß ich nicht, Keyword-Only-

00:52:51.910 --> 00:52:53.630
Argumenten oder so, dann ist das eigentlich mal

00:52:53.630 --> 00:52:55.610
die bessere Variante. Und ich

00:52:55.610 --> 00:52:57.630
habe auch oft jetzt in Projekten inzwischen

00:52:57.630 --> 00:52:59.890
sowas wie so ein DevData-

00:52:59.890 --> 00:53:01.570
Modul oder so, wo ich mir halt Daten

00:53:01.570 --> 00:53:03.610
für bestimmte... Und das brauche

00:53:03.610 --> 00:53:05.610
ich halt nicht nur für Tests, sondern halt auch einfach, um

00:53:05.610 --> 00:53:07.770
Applikationen gezielt in bestimmte Zustände

00:53:07.770 --> 00:53:09.590
versetzen zu können, um halt zum Beispiel,

00:53:09.590 --> 00:53:11.550
irgendwas zeigen zu können oder so, dass ich

00:53:11.550 --> 00:53:13.610
halt mir für diese Fälle, die ich dann habe,

00:53:13.610 --> 00:53:15.570
halt immer irgendwie sowas schreibe, wo

00:53:15.570 --> 00:53:17.170
ich dann einfach nur eine Funktion aufrufe,

00:53:17.170 --> 00:53:19.910
wo ich sagen kann, okay, versetz meinen Applikationszustand

00:53:19.910 --> 00:53:21.530
mal in dieses... Also meine

00:53:21.530 --> 00:53:23.250
Applikation mal in diesen Zustand, wenn ich irgendwas

00:53:23.250 --> 00:53:25.430
demonstrieren kann. Und das kann ich dann halt auch für

00:53:25.430 --> 00:53:27.510
Tests verwenden. Das heißt, sozusagen

00:53:27.510 --> 00:53:29.490
dieses Generieren von diesen Daten oder so ist schon

00:53:29.490 --> 00:53:31.410
in meiner Applikation drin und das benutze ich dann

00:53:31.410 --> 00:53:33.570
in den Tests halt auch. Und ich benutze

00:53:33.570 --> 00:53:35.510
eigentlich sowas wie Factory Boy und sowas gar nicht mehr.

00:53:35.510 --> 00:53:37.350
Ich habe gerade den Bockartikel gefunden,

00:53:37.350 --> 00:53:39.510
den ich meinte. Zu dem von Luke Plant?

00:53:39.550 --> 00:53:41.390
Luke Plant, genau. Ja, okay. Ja, der ist gut.

00:53:41.390 --> 00:53:43.710
Ja, und so ähnlich habe ich das auch dann, glaube ich,

00:53:43.710 --> 00:53:44.470
versucht umzubauen.

00:53:44.470 --> 00:53:47.870
Genau, weil der macht dann quasi ja auch so ein...

00:53:47.870 --> 00:53:49.210
Das ist halt quasi das, was ich meinte, ne?

00:53:49.210 --> 00:53:51.490
Default Keyword Arguments mit vielleicht einem Faker dazu

00:53:51.490 --> 00:53:53.870
und dann hast du halt eine parametrisierbare

00:53:53.870 --> 00:53:55.570
Art und Weise. Ja, und Faker ist halt noch mal

00:53:55.570 --> 00:53:57.550
eine andere Geschichte, wo es einfach darum geht,

00:53:57.550 --> 00:53:59.050
dass man halt, wenn man jetzt,

00:53:59.050 --> 00:54:01.270
dass man sich nicht als Faker selber ausdenken muss,

00:54:01.270 --> 00:54:03.510
dass man plausible Daten hat. Okay, ja.

00:54:03.510 --> 00:54:05.750
Du kannst Faker auch den Seed mitgeben

00:54:05.750 --> 00:54:07.010
zum Beispiel, ja? Und dann kannst du halt...

00:54:07.010 --> 00:54:08.150
Dann ist es immer gleich. Genau.

00:54:09.510 --> 00:54:11.730
Ja, genau.

00:54:11.730 --> 00:54:13.870
Ja, vielleicht

00:54:13.870 --> 00:54:15.630
wäre das jetzt gerade der Punkt, um noch was

00:54:15.630 --> 00:54:17.290
zur Hypothesis zu sagen.

00:54:17.290 --> 00:54:18.430
Ja, klingt gut.

00:54:18.430 --> 00:54:21.690
Das ist ein Projekt, was erstmal nicht viel

00:54:21.690 --> 00:54:23.770
mit PyTest zu tun hat, aber sich

00:54:23.770 --> 00:54:25.670
halt doch gut im PyTest integriert

00:54:25.670 --> 00:54:28.050
zu sogenannten

00:54:28.050 --> 00:54:29.910
Property-Based Testing.

00:54:29.910 --> 00:54:31.710
Man kann sich das so ein bisschen

00:54:31.710 --> 00:54:33.590
wie ein Fuzzer vorstellen,

00:54:33.590 --> 00:54:35.790
was also Zufallsdaten generiert.

00:54:35.790 --> 00:54:37.830
Ja, man kann mir zum Beispiel sagen,

00:54:37.830 --> 00:54:39.330
gib mir irgendeinen Integer, ne? Und dann

00:54:39.470 --> 00:54:41.370
nimmt der alle, die er finden kann.

00:54:41.370 --> 00:54:43.690
Ja, jetzt nicht alle. Ich glaube, standardmäßig

00:54:43.690 --> 00:54:45.550
führt es dann halt 200 Mal oder so

00:54:45.550 --> 00:54:47.510
die Testfunktion aus. Also

00:54:47.510 --> 00:54:49.310
nicht so viel. Gut.

00:54:49.310 --> 00:54:51.690
Und alle Integer wird eh schwierig.

00:54:51.690 --> 00:54:53.970
Also,

00:54:53.970 --> 00:54:55.590
das kann auch sehr langsam werden.

00:54:55.590 --> 00:54:57.690
Wenn man das so findet.

00:54:57.690 --> 00:55:01.410
Aber halt mit der Idee, dass man sich

00:55:01.410 --> 00:55:03.390
eben so Strategien zusammenbauen kann,

00:55:03.390 --> 00:55:05.550
also auch sagen kann, ich will

00:55:05.550 --> 00:55:07.630
jetzt gerne irgendwie Dictionaries

00:55:07.630 --> 00:55:09.430
und die Keys sollen Strings

00:55:09.430 --> 00:55:11.410
sein, aber nur mit ASCII-Zeichen

00:55:11.410 --> 00:55:13.490
und die Values sollen

00:55:13.490 --> 00:55:15.130
dann irgendwie Listen sein

00:55:15.130 --> 00:55:17.430
und die Elemente darin sollen dann irgendwie

00:55:17.430 --> 00:55:19.030
das und das sein.

00:55:19.030 --> 00:55:21.450
Oder auch passend

00:55:21.450 --> 00:55:23.290
beispielsweise auch auf ein Django-Model

00:55:23.290 --> 00:55:23.770
und sowas.

00:55:23.770 --> 00:55:27.290
Und dann kann man sich mit diesen Strategien

00:55:27.290 --> 00:55:29.250
halt ein bisschen gezielter Daten

00:55:29.250 --> 00:55:30.690
generieren

00:55:30.690 --> 00:55:33.450
und dann halt eben auf seine Funktionen loslassen.

00:55:33.450 --> 00:55:35.530
Und gerade bei so

00:55:35.530 --> 00:55:37.330
bestimmten Arten von Code,

00:55:37.330 --> 00:55:39.350
gerade wenn es darum geht, irgendwo Dinge

00:55:39.350 --> 00:55:41.190
aus einem String zu parsen oder so,

00:55:41.190 --> 00:55:43.550
ist das relativ einfach,

00:55:43.550 --> 00:55:44.810
sich da so eine Strategie

00:55:44.810 --> 00:55:46.910
auszudenken oder auch einfach zu sagen,

00:55:46.910 --> 00:55:48.890
schmeiß da bitte mal Zufallsdaten hin.

00:55:48.890 --> 00:55:51.130
Einfach zufällige Strings.

00:55:51.130 --> 00:55:53.350
Und dann, wenn es geht,

00:55:53.350 --> 00:55:55.270
noch irgendwelche Invariants

00:55:55.270 --> 00:55:57.350
zu testen. Also Dinge, die immer wahr sein

00:55:57.350 --> 00:55:59.190
sollen, egal was der Input ist.

00:55:59.190 --> 00:56:00.630
Also wenn man irgendwas

00:56:00.630 --> 00:56:03.270
Compressed und Decompressed hat,

00:56:03.270 --> 00:56:05.250
dann kann man das einmal durchlassen, einmal sagen

00:56:05.250 --> 00:56:07.230
Compressed, einmal Decompressed

00:56:07.230 --> 00:56:09.070
und es soll das Gleiche wieder rauskommen.

00:56:09.310 --> 00:56:11.950
Oder Decrypt, Encrypt,

00:56:11.950 --> 00:56:13.590
Encode, Decode, alles so diese

00:56:13.590 --> 00:56:15.710
Paare, die sich halt umkehren

00:56:15.710 --> 00:56:16.230
sollten.

00:56:16.230 --> 00:56:18.650
Ja, dann merkt man ja relativ schnell, ob man irgendwo

00:56:18.650 --> 00:56:19.610
eine Case hat, wo, ups.

00:56:19.610 --> 00:56:23.470
Genau, dann lässt man das mal laufen und dann

00:56:23.470 --> 00:56:25.530
ist die Chance relativ groß,

00:56:25.530 --> 00:56:27.250
dass eine Hypothesis halt mit irgendeinem

00:56:27.250 --> 00:56:29.210
komischen Corner Case kommt, den man echt

00:56:29.210 --> 00:56:30.030
nicht bedacht hatte.

00:56:30.030 --> 00:56:33.450
Ja, das ist mir auch schon öfters auf die Füße gefallen.

00:56:33.450 --> 00:56:35.270
Hat mir dann die Augen geöffnet,

00:56:35.270 --> 00:56:37.110
warum zwischendurch irgendwas Komisches passierte, was man

00:56:37.110 --> 00:56:39.270
irgendwie nicht erwartet hätte, ja. Muss man nochmal drüber

00:56:39.270 --> 00:56:40.630
nachdenken, was mache ich denn da überhaupt eigentlich?

00:56:40.630 --> 00:56:43.210
Irgendwann was kaputt ist,

00:56:43.210 --> 00:56:44.610
das ist schon immer so ein bisschen, hm.

00:56:44.610 --> 00:56:46.790
Ja, ich glaube, das muss ich mir mal, ich habe das

00:56:46.790 --> 00:56:48.850
schon mal ausprobiert, aber ich habe es noch nicht wirklich

00:56:48.850 --> 00:56:51.290
häufig irgendwie in den

00:56:51.290 --> 00:56:52.610
Dingen so verwendet, die ich so mache.

00:56:52.610 --> 00:56:55.310
Ja. Also ich hatte das Gefühl

00:56:55.310 --> 00:56:57.110
tatsächlich, dass es so ein bisschen langsam ist, aber

00:56:57.110 --> 00:56:59.270
dann kann man das ja auch, glaube ich, aufzeichnen,

00:56:59.270 --> 00:57:01.050
glaube ich. Aber, ähm.

00:57:01.050 --> 00:57:03.270
Ja, die Idee davon ist

00:57:03.270 --> 00:57:05.270
eigentlich, dass es eben nicht langsam ist.

00:57:05.270 --> 00:57:06.810
Das ist halt

00:57:06.810 --> 00:57:09.230
als Teil seinen normalen Test

00:57:09.230 --> 00:57:11.090
laufen lassen kann. Aber also für mich war das

00:57:11.090 --> 00:57:13.290
immer so ein Punkt, wo ich dann angefangen

00:57:13.290 --> 00:57:15.170
habe, tatsächlich die Sachen einzuschränken, ja. Also wenn ich

00:57:15.170 --> 00:57:17.050
halt gemerkt habe, okay, Herr Passus, jetzt langsam halt eine

00:57:17.050 --> 00:57:19.410
eine Unit dann laufen lassen mit maximal

00:57:19.410 --> 00:57:20.670
möglichen Parametern.

00:57:20.670 --> 00:57:23.050
Und dann war es halt natürlich langsam, hat der Test

00:57:23.050 --> 00:57:24.770
dann vielleicht auch mal fast eine Minute gedauert oder so.

00:57:24.770 --> 00:57:26.930
Aber dann habe ich halt tatsächlich X-Cases gefunden, die ich

00:57:26.930 --> 00:57:29.230
rausschmeißen konnte und konnte dann mir sinnvoll

00:57:29.230 --> 00:57:31.090
überlegen, okay, der Eingabewert ist jetzt

00:57:31.090 --> 00:57:33.110
vielleicht doch nur maximal, weiß nicht, siebenstellig oder

00:57:33.110 --> 00:57:34.930
so, ja. Und nicht noch mehr.

00:57:34.930 --> 00:57:37.070
Und dann wurde dann der Test natürlich dann viel schneller.

00:57:37.070 --> 00:57:39.190
Und dann habe ich halt gesagt, ja, sorry, aber mehr

00:57:39.190 --> 00:57:40.610
ist jetzt hier einfach nicht erlaubt.

00:57:40.610 --> 00:57:42.490
Und das halt direkt mit abgefangen.

00:57:42.490 --> 00:57:44.790
Und so. Das war, glaube ich, ja,

00:57:44.790 --> 00:57:46.990
an der Stelle eine gute Strategie, um mal so ein bisschen

00:57:46.990 --> 00:57:48.730
so die Grenzen zu gucken, was überhaupt an

00:57:48.730 --> 00:57:50.310
I.O. da sinnvoll ist auch.

00:57:50.310 --> 00:57:53.190
Oder so eine Sanitization zu machen an zwei Stellen

00:57:53.190 --> 00:57:53.970
oder so, was gut ist.

00:57:53.970 --> 00:57:57.030
Ja, und am Schluss muss halt auch der Code, der

00:57:57.030 --> 00:57:59.030
dann irgendwas testet, genug schnell sein,

00:57:59.030 --> 00:58:01.070
dass man den 200 Mal laufen lassen kann

00:58:01.070 --> 00:58:02.850
und es dann halt trotzdem nur idealerweise

00:58:02.850 --> 00:58:04.230
in Bruchteilen eine Sekunde geht.

00:58:04.230 --> 00:58:06.830
Das ist nicht immer der Fall.

00:58:06.830 --> 00:58:08.550
Ja.

00:58:09.150 --> 00:58:11.410
Ja, das ist auch so ein interessantes

00:58:11.410 --> 00:58:13.630
Thema, finde ich. Also ich mag

00:58:13.630 --> 00:58:15.290
das sehr gerne, wenn Tests halbwegs schnell

00:58:15.290 --> 00:58:17.150
durchlaufen. Ich finde das immer sehr frustrierend,

00:58:17.150 --> 00:58:19.290
wenn Projekte so, wenn die

00:58:19.290 --> 00:58:21.330
Tests so ewig brauchen, weil das halt auch

00:58:21.330 --> 00:58:23.270
macht das Entwickeln irgendwie echt langsam.

00:58:23.270 --> 00:58:25.270
Ja, also idealerweise halt ein, zwei Sekunden

00:58:25.270 --> 00:58:27.050
nebenbei in der Idee, dann kann man sie dann

00:58:27.050 --> 00:58:29.250
parallel laufen lassen und sieht direkt, wenn man irgendwas kaputt

00:58:29.250 --> 00:58:30.690
gemacht hat. Ja.

00:58:30.690 --> 00:58:33.430
Das ist auch gut. Ja, wäre

00:58:33.430 --> 00:58:35.390
schön, aber ist dann halt bei größeren Projekten

00:58:35.390 --> 00:58:36.450
schwierig, ja.

00:58:36.450 --> 00:58:39.030
Irgendwann nicht mehr realistisch.

00:58:39.110 --> 00:58:43.110
Aber dafür gibt es ja Testmarker.

00:58:43.110 --> 00:58:46.970
Man könnte jetzt hingehen, könnte alle Tests,

00:58:46.970 --> 00:58:49.110
die nicht so schnell gehen, als langsam markieren

00:58:49.110 --> 00:58:50.890
oder sowas und die halt nicht immer parallel laufen

00:58:50.890 --> 00:58:52.830
lassen, sondern nur dann, wenn man es explizit möchte

00:58:52.830 --> 00:58:54.890
oder in der Pipeline oder so und nur

00:58:54.890 --> 00:58:56.990
die schnellen standardmäßig nebenbei

00:58:56.990 --> 00:58:58.110
von der IDE prüfen lassen.

00:58:58.110 --> 00:59:01.010
Ja, kommt halt auch ein bisschen

00:59:01.010 --> 00:59:02.690
darauf an, wie viele Tests man da hat.

00:59:02.690 --> 00:59:04.990
Ja. Also wenn ich mir jetzt

00:59:04.990 --> 00:59:07.090
PyTest selbst anschaue, wenn ich mir Cube Browser

00:59:07.090 --> 00:59:09.070
anschaue, dann ist das irgendwas vierstellig

00:59:09.070 --> 00:59:11.030
ist. Und

00:59:11.030 --> 00:59:13.030
dann wird es zeitlich halt einfach knapp,

00:59:13.030 --> 00:59:15.310
auch wenn die Tests selbst relativ schnell sind.

00:59:15.310 --> 00:59:17.030
Das ist jetzt bei Cube Browser nicht der Fall.

00:59:17.030 --> 00:59:19.030
Da sind es relativ viele End-to-End-Tests

00:59:19.030 --> 00:59:20.790
und halt GUI-Applikationen und so.

00:59:20.790 --> 00:59:23.090
Aber selbst wenn die Tests

00:59:23.090 --> 00:59:24.910
schnell sind, wenn es dann halt ein paar Tausende

00:59:24.910 --> 00:59:26.990
sind sogar in einem größeren Projekt,

00:59:26.990 --> 00:59:29.210
dann ist das Endergebnis halt nicht mehr so schnell.

00:59:29.210 --> 00:59:30.190
Ja.

00:59:30.190 --> 00:59:32.490
Ja, irgendwann

00:59:32.490 --> 00:59:33.910
kann man halt nichts mehr machen.

00:59:33.910 --> 00:59:39.010
Was man ja eventuell machen könnte,

00:59:39.030 --> 00:59:41.030
aber meistens, das hat man ja vielleicht auch nicht

00:59:41.030 --> 00:59:42.370
immer, was Tests dann letztlich,

00:59:42.370 --> 00:59:44.650
gut, ich meine, ich bin jetzt da eher

00:59:44.650 --> 00:59:47.250
im Web-Anwendungsumfeld unterwegs,

00:59:47.250 --> 00:59:48.990
was da die Tests langsam macht, ist halt immer, wenn man

00:59:48.990 --> 00:59:50.550
irgendwie Datenbank-Zugriffe macht oder so,

00:59:50.550 --> 00:59:52.370
dann ist halt das halt mal langsam.

00:59:52.370 --> 00:59:54.550
Jetzt könnte man natürlich,

00:59:54.550 --> 00:59:56.690
das weiß ich nicht, ich habe das ehrlich gesagt noch nie,

00:59:56.690 --> 00:59:59.090
ich habe es einmal selber gemacht, auch um es auszuprobieren.

00:59:59.090 --> 01:00:01.010
Was man da ja tun könnte, ist

01:00:01.010 --> 01:00:03.070
halt so Repository-Pattern oder so verwenden

01:00:03.070 --> 01:00:04.790
und dann halt quasi die Datenbank

01:00:04.790 --> 01:00:06.890
wegabstrahieren und dann für die Tests halt durch

01:00:06.890 --> 01:00:08.990
irgendwie eine Dummy-Datenbank ersetzen, die halt dann schnell ist

01:00:08.990 --> 01:00:10.330
und dann sind die nicht mehr langsam.

01:00:10.330 --> 01:00:12.650
Hast du schon mal gesehen, dass das jemand

01:00:12.650 --> 01:00:14.990
erfolgreich gemacht hat und dass es in einem größeren Projekt

01:00:14.990 --> 01:00:15.970
dann wirklich gut funktioniert hat?

01:00:15.970 --> 01:00:18.550
Ja, das könnte ja ein Weg sein.

01:00:18.550 --> 01:00:20.410
Ja, ich

01:00:20.410 --> 01:00:22.090
bin jetzt nicht so

01:00:22.090 --> 01:00:24.510
viel im Web-Umfeld unterwegs.

01:00:24.510 --> 01:00:26.790
Ich habe ein Projekt, was ich maintaine,

01:00:26.790 --> 01:00:28.390
Studentenportal.

01:00:28.390 --> 01:00:30.770
So ein Portal für

01:00:30.770 --> 01:00:32.750
Lernhilfen und

01:00:32.750 --> 01:00:34.750
Zitate von Dozierenden

01:00:34.750 --> 01:00:37.050
und sowas, halt von Studierenden für Studierende.

01:00:37.050 --> 01:00:38.950
Und das

01:00:38.950 --> 01:00:40.850
ist eine Django-Applikation und da hatten wir

01:00:40.850 --> 01:00:41.770
das mal diskutiert

01:00:41.770 --> 01:00:44.890
und sind dann zum Schluss gekommen, dass wir einfach

01:00:44.890 --> 01:00:47.270
zu viele datenbankspezifische

01:00:47.270 --> 01:00:48.510
Kleinigkeiten haben.

01:00:48.510 --> 01:00:50.990
Also spätestens, wo du

01:00:50.990 --> 01:00:52.950
halt irgendeine Volltext-Suche verwendest

01:00:52.950 --> 01:00:55.030
und das halt dann so PostgreSQL

01:00:55.030 --> 01:00:56.530
Fulltext-Search nutzt,

01:00:56.530 --> 01:00:58.930
dann kannst du das nicht mal so auf die

01:00:58.930 --> 01:01:00.370
Schnelle ersetzen.

01:01:00.370 --> 01:01:02.770
Oder wenn du es kannst, läufst du

01:01:02.770 --> 01:01:04.910
also in die Gefahr, dass die Tests dann überhaupt

01:01:04.910 --> 01:01:07.010
nicht mehr das testen, was eigentlich in der Realität

01:01:07.010 --> 01:01:08.410
läuft. Ja, klar.

01:01:08.410 --> 01:01:10.010
Ja, das ist natürlich das Problem dabei.

01:01:10.010 --> 01:01:12.590
Ja.

01:01:12.590 --> 01:01:14.490
Ja, ich finde es auch schwierig.

01:01:14.490 --> 01:01:15.750
Also so Datenbank-Sachen testen,

01:01:15.750 --> 01:01:18.150
muss man sich oft darauf verlassen, dass das irgendwie geht.

01:01:18.150 --> 01:01:20.410
Und dass das andere Menschen

01:01:20.410 --> 01:01:21.150
schon getestet haben.

01:01:21.150 --> 01:01:24.370
Und ja, das fällt dann halt auch tatsächlich

01:01:24.370 --> 01:01:26.070
oft runter, weil das so ein bisschen

01:01:26.070 --> 01:01:28.350
nervig sein kann.

01:01:28.350 --> 01:01:30.430
Also, ne, weil das halt so langsam

01:01:30.430 --> 01:01:32.370
wird dann im Entwickeln und wenn man das alles

01:01:32.370 --> 01:01:34.110
aufsetzen muss, dann muss ja auch die Datenbank laufen.

01:01:34.110 --> 01:01:36.490
Also ganz ehrlich, also alleine eine Datenbank laufen zu lassen

01:01:36.490 --> 01:01:38.390
auf einem Dev-Rechner ist manchmal schon eine Herausforderung.

01:01:38.390 --> 01:01:40.290
Je nachdem, was man alles draufhaben muss.

01:01:40.290 --> 01:01:42.370
Ja gut, man muss ja auch den Website

01:01:42.370 --> 01:01:43.990
angucken können auf dem Dev-System.

01:01:43.990 --> 01:01:46.730
Ja, aber wenn dann halt

01:01:46.730 --> 01:01:48.530
Menschen drei oder vier oder fünf verschiedene

01:01:48.530 --> 01:01:50.350
Projekte gleichzeitig machen müssen und dann

01:01:50.350 --> 01:01:52.290
haben die nur irgendwie einen Rechner mit 80 Gramm

01:01:52.290 --> 01:01:54.290
oder sowas, muss dann irgendwie da mal einen Docker draufhaben und dann müssen

01:01:54.290 --> 01:01:56.390
die Container aber irgendwie alle gleichzeitig anleihen, weil die schnell wechseln

01:01:56.390 --> 01:01:58.350
müssen, dann macht es dann bei fünf verschiedenen

01:01:58.350 --> 01:02:00.290
Datenbanken schon bumm. Dann musst du dann irgendwie gucken, dass du vielleicht

01:02:00.290 --> 01:02:02.250
eine hast, die dann irgendwie weg abstrahiert ist, wo dann

01:02:02.250 --> 01:02:04.250
aber auch die Klientel stimmen und dann musst du, wenn du eine abreißt,

01:02:04.250 --> 01:02:06.090
nicht alle abreißen, weil du den Container nicht einfach kaputt machen kannst.

01:02:06.090 --> 01:02:07.750
Und ja,

01:02:08.390 --> 01:02:10.950
dann rennen wir schnell schon wieder

01:02:10.950 --> 01:02:11.850
mit dem Kopf gegen eine Wand.

01:02:11.850 --> 01:02:14.510
Da wäre so eine Softwareentwicklung

01:02:14.510 --> 01:02:16.650
mit 8 GB RAM

01:02:16.650 --> 01:02:18.130
finde ich halt auch so ein bisschen kritisch.

01:02:18.130 --> 01:02:20.610
Ja, ist eine Katastrophe, ist das. Also Gott sei Dank muss ich sowas nicht tun.

01:02:20.610 --> 01:02:22.970
Also Apple macht das ja,

01:02:22.970 --> 01:02:24.910
dass sie ihre neuen MacBook Pros

01:02:24.910 --> 01:02:27.090
haben im Standardmodell mit 8 GB

01:02:27.090 --> 01:02:28.590
für tausend

01:02:28.590 --> 01:02:30.770
noch was Euro. Ja, das ist eine Gemeinheit,

01:02:30.770 --> 01:02:31.770
aber ja, so ist es.

01:02:31.770 --> 01:02:34.550
Ja. Aber ja,

01:02:34.550 --> 01:02:36.550
ich meine, ich mit Qt-Browser,

01:02:36.550 --> 01:02:38.190
vielleicht soll ich da ja dann auch mal

01:02:38.190 --> 01:02:38.370
nochmal

01:02:38.370 --> 01:02:39.590
ein paar Worte dazu sagen.

01:02:39.590 --> 01:02:42.270
Da muss ich halt ab und zu auch

01:02:42.270 --> 01:02:44.470
Chromium kompilieren, also der Code

01:02:44.470 --> 01:02:45.510
hinter Google Chrome.

01:02:45.510 --> 01:02:48.470
Und das

01:02:48.470 --> 01:02:50.770
braucht so mit einem Developer-Build,

01:02:50.770 --> 01:02:52.430
also mit Debug-Symbolen und so

01:02:52.430 --> 01:02:54.390
braucht das halt mal so irgendwie um die

01:02:54.390 --> 01:02:55.470
30 GB RAM.

01:02:55.470 --> 01:02:57.930
Wow, allein das Kompilieren von dem,

01:02:57.930 --> 01:02:59.150
okay, das...

01:02:59.150 --> 01:03:02.350
Wenn ich es halt parallel machen würde, nur mit so einem

01:03:02.350 --> 01:03:04.550
Build-Job würde es mir wahrscheinlich auch weniger reichen.

01:03:04.550 --> 01:03:06.710
Aber ja,

01:03:06.710 --> 01:03:08.350
wir haben dann 32 GB

01:03:08.350 --> 01:03:10.090
tatsächlich nicht mehr ausgereicht.

01:03:10.090 --> 01:03:12.590
Ich bin jetzt

01:03:12.590 --> 01:03:14.610
auf 48, was halt das Maximale

01:03:14.610 --> 01:03:16.130
ist, was in den Laptop passt überhaupt.

01:03:16.130 --> 01:03:18.310
Weil 16, glaube ich, fix

01:03:18.310 --> 01:03:19.130
eingelötet sind.

01:03:19.130 --> 01:03:22.650
Aber das fand ich

01:03:22.650 --> 01:03:24.610
schon heftig. Also Chromium

01:03:24.610 --> 01:03:25.930
ist ein riesiges Projekt.

01:03:25.930 --> 01:03:28.470
Aber wenn es so

01:03:28.470 --> 01:03:30.430
weitergeht, das wird dann nur noch komplexer,

01:03:30.430 --> 01:03:32.310
wie es bei Software halt oft so ist,

01:03:32.310 --> 01:03:34.590
habe ich echt irgendwann ein Problem.

01:03:34.590 --> 01:03:36.430
Ja.

01:03:36.430 --> 01:03:38.270
Habt ihr schon mal Tests irgendwo auf

01:03:38.270 --> 01:03:40.470
anderen Rechnern laufen lassen, einfach nur? Also, das habe ich auch schon mal

01:03:40.470 --> 01:03:42.330
gehört, dass Leute das gar nicht bei sich mehr laufen lassen,

01:03:42.330 --> 01:03:43.710
sondern irgendwo nur in der Pipeline?

01:03:43.710 --> 01:03:46.290
Mache ich

01:03:46.290 --> 01:03:47.750
ganz oft, aus Feilheit.

01:03:47.750 --> 01:03:50.490
Also, bei mir gehen die

01:03:50.490 --> 01:03:52.450
Tests dann halt auch eine Weile und oft

01:03:52.450 --> 01:03:54.370
lasse ich die dann lokal

01:03:54.370 --> 01:03:56.530
halt gar nicht mehr laufen. Das ist eine gefährliche

01:03:56.530 --> 01:03:57.610
Angewohnheit. Ja.

01:03:57.610 --> 01:03:59.830
Ich pushe das halt mal,

01:03:59.830 --> 01:04:02.530
wenn ich noch vernünftig bin in den Branch

01:04:02.530 --> 01:04:03.650
und nicht gleich nach Main

01:04:03.650 --> 01:04:06.530
und schaue dann halt mal, was da

01:04:06.530 --> 01:04:07.810
zurückkommt von

01:04:07.810 --> 01:04:08.910
GitHub-Actions.

01:04:08.910 --> 01:04:10.990
Dadum.

01:04:10.990 --> 01:04:12.950
Dieser Test ist fehlgeschlagen.

01:04:12.950 --> 01:04:14.230
Oh, ja, okay. Meistens nicht.

01:04:14.230 --> 01:04:17.010
Manchmal gelingt es einem halt, das durchzukriegen,

01:04:17.010 --> 01:04:18.110
aber, ja.

01:04:18.110 --> 01:04:19.690
Ja, okay.

01:04:19.690 --> 01:04:21.750
Muss das aber halt, ja.

01:04:21.750 --> 01:04:24.970
Was auch super ist, wenn man dann gar keine Testumgebung hat,

01:04:24.970 --> 01:04:27.210
sondern es halt direkt durchgeht.

01:04:27.210 --> 01:04:28.610
Du brauchst halt auch keine Entwicklungsumgebung.

01:04:28.610 --> 01:04:31.070
Du machst halt alles bei GitHub. Ist das da Codespaces

01:04:31.070 --> 01:04:32.890
oder so? Und dann ist das alles

01:04:32.890 --> 01:04:34.470
nur noch in der Cloud.

01:04:34.470 --> 01:04:35.650
Wunderbar.

01:04:35.650 --> 01:04:37.530
Jemand anderes Problem.

01:04:37.730 --> 01:04:40.690
Lass ich dann halt so die Tests für das, was ich

01:04:40.690 --> 01:04:42.870
gerade daran arbeite, die lasse ich lokal laufen.

01:04:42.870 --> 01:04:45.010
Aber so eine volle Testbatterie

01:04:45.010 --> 01:04:46.370
soll woanders laufen.

01:04:46.370 --> 01:04:48.530
Ja, aber auch das ist vielleicht ein guter

01:04:48.530 --> 01:04:50.130
Punkt für Max.

01:04:50.130 --> 01:04:52.270
Also, um Tests zu markieren nach verschiedenen

01:04:52.270 --> 01:04:54.450
Themen oder sowas, dann kann man halt nur Tests laufen

01:04:54.450 --> 01:04:56.190
lassen für das einzelne Topic oder

01:04:56.190 --> 01:04:58.170
das Backend. Ja, aber ich meine, wenn du Entwickler hast,

01:04:58.170 --> 01:05:00.210
machst du das ja meistens, dass du einfach sozusagen

01:05:00.210 --> 01:05:02.210
entweder nur den einen Test, von dem du weißt,

01:05:02.210 --> 01:05:04.570
dass der halt betroffen ist, irgendwie laufen lässt

01:05:04.570 --> 01:05:06.510
oder halt eine Gruppe von Tests, die da

01:05:06.510 --> 01:05:07.650
außenrum sind. Ja, genau. Aber

01:05:07.650 --> 01:05:10.350
die Frage ist halt diese Gruppe, weil wenn du die thematisch

01:05:10.350 --> 01:05:12.170
gruppierst und die vielleicht nicht an demselben Ort

01:05:12.170 --> 01:05:14.210
liegen irgendwie, wenn man halt da, man kann ja die

01:05:14.210 --> 01:05:16.050
Tests, das ist auch eine Frage der Philosophie, ob man

01:05:16.050 --> 01:05:18.010
ein Testfahrzeichen schreibt oder an die

01:05:18.010 --> 01:05:20.090
Applikationen oder an die ganzen Apps, wo die zugehören

01:05:20.090 --> 01:05:22.150
oder so. Ja. Und wenn

01:05:22.150 --> 01:05:24.070
die dann halt so distributed sind und dann

01:05:24.070 --> 01:05:26.150
willst du aber trotzdem viele verschiedene davon zusammen

01:05:26.150 --> 01:05:28.090
laufen lassen, weil die mit der Funktionalität dann doch irgendwie

01:05:28.090 --> 01:05:30.110
zusammenhängen. Also, ja, also auch da eine Frage.

01:05:30.110 --> 01:05:31.850
Kann man sich über die Architektur

01:05:31.850 --> 01:05:34.030
Gedanken machen? Gibt es vielleicht doch Gründe, das dann so zu

01:05:34.030 --> 01:05:35.110
machen oder, ne?

01:05:35.110 --> 01:05:37.570
Und mit diesen Markern, die man da bei Python

01:05:37.570 --> 01:05:39.650
erst rübersetzen kann, dann kann man ja einfach, die gruppieren

01:05:39.650 --> 01:05:41.830
recht einfach. Finde ich gar nicht so

01:05:41.830 --> 01:05:42.530
schlecht für diese Fälle.

01:05:42.530 --> 01:05:45.810
Ja, mache

01:05:45.810 --> 01:05:48.050
ich jetzt weniger. Ich habe einen Marker

01:05:48.050 --> 01:05:49.370
einfach für alle GUI-Tests.

01:05:49.370 --> 01:05:51.790
Sowas halt, weil

01:05:51.790 --> 01:05:53.750
das halt wirklich projektübergreifend sind

01:05:53.750 --> 01:05:55.870
Tests, die nutzen irgendwelche GUI-Dinge

01:05:55.870 --> 01:05:58.130
und die testen einfach nur Python-Code.

01:05:58.130 --> 01:06:00.270
Aber ansonsten,

01:06:00.270 --> 01:06:00.630
ja,

01:06:00.630 --> 01:06:04.050
ich kann mir jetzt vorstellen, so bei einem Enterprise-Projekt

01:06:04.050 --> 01:06:05.730
können auch Kunden, die das so machen,

01:06:05.730 --> 01:06:07.490
da dann wirklich so eine Use-Case

01:06:07.490 --> 01:06:09.130
Nummer oder so noch dranhängen

01:06:09.130 --> 01:06:11.690
und dann sagen, alle Tests irgendwie zu diesem

01:06:11.690 --> 01:06:12.950
Use-Case laufen lassen.

01:06:12.950 --> 01:06:15.650
Aber ansonsten, finde ich,

01:06:15.650 --> 01:06:17.750
reicht eigentlich diese Unterteilung in Module.

01:06:17.750 --> 01:06:19.670
Ja, also je modularer man

01:06:19.670 --> 01:06:21.690
ist oder je modulitischer man so eine Anwendung baut,

01:06:21.690 --> 01:06:23.750
dann müsste man vielleicht tatsächlich diese einzelnen

01:06:23.750 --> 01:06:24.750
Funktionalitäten so ein bisschen

01:06:24.750 --> 01:06:27.310
so ein Multilead voneinander

01:06:27.310 --> 01:06:29.710
Ich weiß nicht, also bei mir reicht

01:06:29.710 --> 01:06:31.550
auch diese Trennung in Dateien

01:06:31.550 --> 01:06:33.170
eigentlich, ehrlich gesagt, aus.

01:06:33.170 --> 01:06:34.750
Ich habe dafür den Marker

01:06:34.750 --> 01:06:36.930
schon verwendet, aber nicht dafür.

01:06:37.490 --> 01:06:39.250
Ja, aber genau, das

01:06:39.250 --> 01:06:41.270
ist eine interessante Frage, was ich jetzt auch, also

01:06:41.270 --> 01:06:42.690
einfach alles Teste in einem

01:06:42.690 --> 01:06:45.250
Tests-Directory drin haben oder halt

01:06:45.250 --> 01:06:47.310
neben die Module

01:06:47.310 --> 01:06:49.370
im Code legen. Das sind ja auch zwei unterschiedliche Möglichkeiten.

01:06:49.370 --> 01:06:51.330
Ich habe beides auch schon gesehen und

01:06:51.330 --> 01:06:53.290
ich persönlich mag es lieber, irgendwie das

01:06:53.290 --> 01:06:54.930
alles in einem Tests-Verzeichnis zu haben.

01:06:54.930 --> 01:06:56.690
Ich mache tatsächlich beides.

01:06:56.690 --> 01:06:59.190
Also ich habe einen Tests-Verzeichnis, wo

01:06:59.190 --> 01:07:00.790
so die grundlegenden Sachen drin sind, wie

01:07:00.790 --> 01:07:03.310
Kernfunktionalität, die Clients für

01:07:03.310 --> 01:07:05.270
Authentication, die Nutzer

01:07:05.270 --> 01:07:07.290
und sowas. Und

01:07:07.290 --> 01:07:07.470
der

01:07:07.470 --> 01:07:09.090
Testswanderer und diese ganzen Sachen und

01:07:09.090 --> 01:07:11.270
die Haupt-Fictures oder auch

01:07:11.270 --> 01:07:12.190
witzig, manchmal auch

01:07:12.190 --> 01:07:14.890
meist einen anderen Fixtures schon. Das heißt,

01:07:14.890 --> 01:07:16.970
Fixtures für Modelle lege ich mit in das Hauptverzeichnis rein,

01:07:16.970 --> 01:07:19.330
aber die Tests selber, also

01:07:19.330 --> 01:07:21.090
die einzelnen Units für Routen zum Beispiel,

01:07:21.090 --> 01:07:23.050
die sind mit in dem API-Verzeichnis

01:07:23.050 --> 01:07:25.230
zum Beispiel oder in der

01:07:25.230 --> 01:07:26.610
App von Dango oder so.

01:07:26.610 --> 01:07:29.210
Da muss man

01:07:29.210 --> 01:07:31.210
die halt importieren, einfach

01:07:31.210 --> 01:07:33.070
in den Konftest, die man halt da nutzt und dann kann man

01:07:33.070 --> 01:07:35.250
aber direkt da die Tests schreiben, wo

01:07:35.250 --> 01:07:37.310
die Anwendung quasi liegt. Man muss nicht die ganze Zeit

01:07:37.310 --> 01:07:39.210
durch das ganze Directory so hin und her traversen.

01:07:39.210 --> 01:07:40.270
Okay.

01:07:40.270 --> 01:07:43.210
Und man kann halt auch modulär

01:07:43.210 --> 01:07:45.050
arbeiten und die Leute wissen halt direkt, dass die Tests

01:07:45.050 --> 01:07:47.070
da dazugehören und man vergisst dann nicht

01:07:47.070 --> 01:07:49.010
welche für welche Module. Man kann halt auch einmal direkt sehen,

01:07:49.010 --> 01:07:51.070
sind die Tests für die Module jetzt schon da drin oder welche

01:07:51.070 --> 01:07:52.970
Tests für die Module gibt es denn da? Manchmal

01:07:52.970 --> 01:07:55.110
finde ich sind Tests auch sehr nützlich sowas als

01:07:55.110 --> 01:07:57.130
wie Dokumentation für

01:07:57.130 --> 01:07:59.070
den Code. Wenn ich manchmal nicht mehr so

01:07:59.070 --> 01:08:00.890
genau weiß, was passiert denn da jetzt eigentlich oder

01:08:00.890 --> 01:08:02.930
was sollte da passieren, gucke ich mir den Test an und wenn der gut

01:08:02.930 --> 01:08:05.090
geschrieben ist, sagt der Test, testet ja die Logik,

01:08:05.090 --> 01:08:07.190
was da passieren sollte. Und dann lese ich den Test,

01:08:07.270 --> 01:08:08.650
ah, so war das. Und dann,

01:08:08.650 --> 01:08:09.910
das macht viel Sinn.

01:08:09.910 --> 01:08:12.470
Das mache ich tatsächlich auch ganz oft.

01:08:12.470 --> 01:08:14.870
Oft, wenn ich halt irgendwo einen Bug in einem

01:08:14.870 --> 01:08:17.050
Python-Projekt finde, der sich nutzt, dann versuche

01:08:17.050 --> 01:08:18.290
ich den halt mal kurz zu beheben.

01:08:18.290 --> 01:08:21.310
Und dann schaue ich mir oft auch mal

01:08:21.310 --> 01:08:22.830
irgendwie jetzt bei einem fremden

01:08:22.830 --> 01:08:25.210
Open-Source-Projekt erstmal die Tests ein bisschen an,

01:08:25.210 --> 01:08:27.070
um mehr ein Gefühl zu kriegen,

01:08:27.070 --> 01:08:27.890
was da passiert.

01:08:27.890 --> 01:08:30.170
Wenn es dann welche gibt.

01:08:30.170 --> 01:08:31.970
Ja, gut.

01:08:31.970 --> 01:08:35.330
Ja, das ist tatsächlich auch eine der Sachen, die oft runterfällt.

01:08:37.230 --> 01:08:38.730
Ich mache das tatsächlich aber auch so,

01:08:38.730 --> 01:08:40.990
wie das die PyTest-Dokumentation, glaube ich,

01:08:40.990 --> 01:08:43.230
auch empfiehlt, dass ich einfach ein Testverzeichnis

01:08:43.230 --> 01:08:44.850
habe und dann da quasi so

01:08:44.850 --> 01:08:46.110
eins zu eins das

01:08:46.110 --> 01:08:48.230
Python-Package gespiegelt.

01:08:48.230 --> 01:08:50.430
PyTest-Dokumentation

01:08:50.430 --> 01:08:52.610
ist auch noch so eine, ich fand

01:08:52.610 --> 01:08:55.110
PyTest-Dokumentation war eine der schwierigeren Dokumentationen,

01:08:55.110 --> 01:08:55.970
die ich lesen durfte.

01:08:55.970 --> 01:08:58.130
Im Laufe der,

01:08:58.130 --> 01:09:00.090
wenn er so Python kriegt.

01:09:00.090 --> 01:09:02.670
Ja gut, ja, es ist halt auch kompliziert.

01:09:02.670 --> 01:09:04.590
Ja, aber gerade.

01:09:04.590 --> 01:09:07.110
Ich habe da so diesen

01:09:07.110 --> 01:09:08.410
Curse of Knowledge halt.

01:09:08.410 --> 01:09:10.350
Ich kenne das so unter diesem Begriff,

01:09:10.350 --> 01:09:12.850
dass es halt echt schwierig ist, wenn man das alles schon

01:09:12.850 --> 01:09:14.450
verinnerlicht hat. Ja, ich verstehe das.

01:09:14.450 --> 01:09:16.830
Das nochmal so in den Augen eines Neulings

01:09:16.830 --> 01:09:17.390
anzuschauen.

01:09:17.390 --> 01:09:20.670
Also, dass man wirklich einfach verstehen kann, was denn da passiert.

01:09:20.670 --> 01:09:22.650
Das ist so eine hohe Kunst, glaube ich.

01:09:22.650 --> 01:09:25.030
Und das war also bei PyTest,

01:09:25.030 --> 01:09:26.690
ich muss auch sagen, mittlerweile ist es einfacher,

01:09:26.690 --> 01:09:28.790
also die Doku zu lesen, aber

01:09:28.790 --> 01:09:30.870
manchmal ist es, hä, was wollen die denn jetzt und warum?

01:09:30.870 --> 01:09:33.010
Und dann waren auch so ganz viele Fragen offen.

01:09:33.010 --> 01:09:34.970
Die haben dann irgendwie ganz viel Knowledge halt auch tatsächlich

01:09:34.970 --> 01:09:36.990
vorausgesetzt, dass man sich

01:09:36.990 --> 01:09:38.930
halt irgendwo an irgendwelchen anderen Stellen so zusammenklauben

01:09:38.930 --> 01:09:40.850
musste und wo musste man dann selber

01:09:40.850 --> 01:09:43.010
finden und so und das war schon, war steil.

01:09:43.010 --> 01:09:46.650
Aber ja, also was

01:09:46.650 --> 01:09:48.870
noch vielleicht so eine coole Funktionalitäten

01:09:48.870 --> 01:09:50.690
von PyTest, ich glaube, es gibt noch jede Menge Plugins,

01:09:50.690 --> 01:09:52.070
die wir noch vielleicht erwähnen können.

01:09:52.070 --> 01:09:54.690
Ich würde eins gerne herausfinden, VCR,

01:09:54.690 --> 01:09:56.750
also irgendwie so Videorecording auch noch.

01:09:56.750 --> 01:09:58.770
Das ist auch sehr cool, das, ja.

01:09:58.770 --> 01:10:00.490
Was macht das denn?

01:10:00.490 --> 01:10:02.530
VCR stellt quasi,

01:10:02.530 --> 01:10:05.030
wenn du jetzt eine API nutzt und zum Beispiel ein Request,

01:10:05.030 --> 01:10:06.870
zeichnet das quasi die

01:10:06.870 --> 01:10:08.710
echten Antworten auf und

01:10:08.710 --> 01:10:10.350
macht halt quasi einen echten API-Call

01:10:10.350 --> 01:10:12.910
und schreibt das Ergebnis inklusive

01:10:12.910 --> 01:10:14.770
aller Header und allem Content und so weiter

01:10:14.770 --> 01:10:17.190
in Jamil-Files rein, automatisch

01:10:17.190 --> 01:10:19.010
und beim nächsten

01:10:19.010 --> 01:10:20.770
Call nimmt es einfach die und tut halt so,

01:10:20.770 --> 01:10:22.590
als wäre die echte API-Antwort quasi

01:10:22.590 --> 01:10:24.670
in der File drin und dann hast du quasi

01:10:24.670 --> 01:10:26.670
die echte API-Antwort gemockt, quasi genauso

01:10:26.670 --> 01:10:28.510
wie sie kommt und du kannst halt

01:10:28.510 --> 01:10:30.470
PyTest immer sagen, okay, zieh jetzt mal neu,

01:10:30.470 --> 01:10:32.430
also du bist gerade in einer Umgebung, wo du das ausprobieren kannst,

01:10:32.430 --> 01:10:34.730
aber du willst ja die APIs auch wegen Quotas und so weiter

01:10:34.730 --> 01:10:36.210
halt auch nicht ständig fragen zum Beispiel.

01:10:36.750 --> 01:10:38.090
Oder halt auch

01:10:38.090 --> 01:10:40.270
nur selten oder halt, wenn sich was aktualisiert

01:10:40.270 --> 01:10:42.290
und kannst aber so halt dann schon gucken,

01:10:42.290 --> 01:10:44.150
ob die API nach draußen halt auch funktioniert und

01:10:44.150 --> 01:10:46.190
halt nicht nur so tun, als hast du die API nachgebaut,

01:10:46.190 --> 01:10:48.210
sondern kannst ja tatsächlich direkt

01:10:48.210 --> 01:10:50.330
benutzen. Ja, ich weiß nicht, ich mach

01:10:50.330 --> 01:10:51.770
sowas ungern, also

01:10:51.770 --> 01:10:54.270
da gibt es ja auch immer diesen

01:10:54.270 --> 01:10:55.710
Spruch, ich weiß nicht, vielleicht

01:10:55.710 --> 01:10:57.930
don't mock what you don't own,

01:10:57.930 --> 01:11:00.110
also ich mock lieber meine eigenen Sachen als

01:11:00.110 --> 01:11:02.030
das externe Geschichten, weil ich

01:11:02.030 --> 01:11:04.350
weiß nicht. Ja, aber es ist ja eben vielleicht nicht gemockt.

01:11:06.630 --> 01:11:07.270
Just record it.

01:11:07.270 --> 01:11:10.150
Ja, aber das, ja gut, das ist ein bisschen

01:11:10.150 --> 01:11:11.870
Convenience, aber du mockst es im Grunde schon.

01:11:11.870 --> 01:11:15.290
Ja, ich weiß nicht, aber

01:11:15.290 --> 01:11:17.810
Du willst ja nicht, dass

01:11:17.810 --> 01:11:20.190
deine Tests wirklich auf die API

01:11:20.190 --> 01:11:21.530
zugreifen im Normalfall.

01:11:21.530 --> 01:11:24.130
Also gerade wenn du da irgendwie einen API-Key

01:11:24.130 --> 01:11:26.170
brauchst, irgendwelche Credits hast oder

01:11:26.170 --> 01:11:27.690
die API was ganz Schlimmes macht,

01:11:27.690 --> 01:11:30.250
dann musst du die ja irgendwie mocken.

01:11:30.250 --> 01:11:32.290
Ja, aber ich würde sie an der Stelle

01:11:32.290 --> 01:11:34.190
mocken an der internen, sozusagen

01:11:34.190 --> 01:11:35.610
bevor ich das aufrufe.

01:11:36.510 --> 01:11:37.750
Die dann gar nicht aufrufen.

01:11:37.750 --> 01:11:40.450
Ach so meinst du. An der Stelle, wo ich halt noch weiß,

01:11:40.450 --> 01:11:42.670
was das ist, sodass ich halt auch weiß, wenn ich das

01:11:42.670 --> 01:11:44.510
ändere, dass ich dann auch den Mock

01:11:44.510 --> 01:11:46.530
ändern muss. Aber bei einem externen, wenn ich das einfach

01:11:46.530 --> 01:11:48.610
nur automatisch mogge, dann weiß ich ja gar nicht,

01:11:48.610 --> 01:11:50.530
wenn sich da jetzt irgendwas geändert hat, okay,

01:11:50.530 --> 01:11:52.370
muss ich meine Mocks anpassen irgendwie, das

01:11:52.370 --> 01:11:54.050
kriege ich ja nicht sozusagen direkt mit.

01:11:54.050 --> 01:11:56.530
Ja. Gut, am Schluss

01:11:56.530 --> 01:11:58.630
ist dein Code

01:11:58.630 --> 01:12:00.550
ja sowieso kaputt, wenn sich an der API

01:12:00.550 --> 01:12:02.350
wirklich was ändert. Ja, das, ja.

01:12:02.350 --> 01:12:04.710
Da, was ich

01:12:04.710 --> 01:12:06.090
einen schönen Ansatz finde da,

01:12:06.390 --> 01:12:07.710
ist, dass man,

01:12:07.710 --> 01:12:10.610
um vielleicht auch nochmal bei den Plugins einzuhängen,

01:12:10.610 --> 01:12:12.690
es ist sehr einfach

01:12:12.690 --> 01:12:14.670
PyTest halt eben irgendwie zu erweitern

01:12:14.670 --> 01:12:16.590
und unter anderem auch ein eigenes

01:12:16.590 --> 01:12:18.490
Kommandozeilen-Argument zu PyTest

01:12:18.490 --> 01:12:19.230
hinzuzufügen.

01:12:19.230 --> 01:12:22.010
Und was man dann machen kann,

01:12:22.010 --> 01:12:24.490
ist theoretisch zumindest, ich habe jetzt

01:12:24.490 --> 01:12:26.090
nicht ein Projekt, wo ich das effektiv mache,

01:12:26.090 --> 01:12:26.730
tatsächlich,

01:12:26.730 --> 01:12:29.430
eine Kommandozeilen-Option,

01:12:29.430 --> 01:12:32.190
Real API oder sowas hinzuzufügen

01:12:32.190 --> 01:12:34.330
und dann halt zu sagen, wenn ich das mitgebe,

01:12:34.330 --> 01:12:36.190
laufen einmal meine Tests gegen die

01:12:36.270 --> 01:12:37.310
richtige API durch,

01:12:37.310 --> 01:12:39.310
anstatt gegen meine

01:12:39.310 --> 01:12:41.690
recordeten Antworten.

01:12:41.690 --> 01:12:44.150
Ja, das könnte man natürlich machen, ja.

01:12:44.150 --> 01:12:48.090
Dann je nach API halt sagen,

01:12:48.090 --> 01:12:50.150
das können wir nach, auf einer CI irgendwie

01:12:50.150 --> 01:12:52.170
wöchentlich oder monatlich oder sowas mal

01:12:52.170 --> 01:12:54.190
ausführen. Ja, also ich finde

01:12:54.190 --> 01:12:56.170
es super spannend, also das macht halt echt

01:12:56.170 --> 01:12:57.630
coole Sachen möglich.

01:12:57.630 --> 01:13:00.370
Man kann ja auch seine eigene API quasi mit aufnehmen

01:13:00.370 --> 01:13:01.850
oder sowas, wenn man das möchte und dann hat man

01:13:01.850 --> 01:13:04.330
auch schnell so Mock-Fictures da, die man halt

01:13:04.330 --> 01:13:06.150
nicht selber bauen möchte, selbst wenn du

01:13:06.150 --> 01:13:08.070
sagst, okay, du möchtest gerne vorher das Mocken, aber

01:13:08.070 --> 01:13:09.470
ich finde das schon ziemlich gut.

01:13:09.470 --> 01:13:13.630
Ja gut, nee, kann ich auch gar nicht.

01:13:13.630 --> 01:13:15.070
Man kann das sogar abusen,

01:13:15.070 --> 01:13:16.990
wenn man sich viele

01:13:16.990 --> 01:13:20.110
Zeugs irgendwie abspeichern will von

01:13:20.110 --> 01:13:22.310
irgendwelchen Scrapern oder sowas, könnte man das tatsächlich

01:13:22.310 --> 01:13:24.130
einfach einsetzen, um sich

01:13:24.130 --> 01:13:26.350
die API-Calls einfach mal wegzuschapen

01:13:26.350 --> 01:13:27.170
und das relativ easy.

01:13:27.170 --> 01:13:30.250
Ja, ich

01:13:30.250 --> 01:13:31.490
weiß nicht, also genau,

01:13:31.490 --> 01:13:34.330
ich beurteile gerade, was ich

01:13:34.330 --> 01:13:36.110
an Plugins normalerweise verwende,

01:13:36.110 --> 01:13:38.290
weil X-Test verwende ich

01:13:38.290 --> 01:13:40.170
tatsächlich irgendwie, aber

01:13:40.170 --> 01:13:42.090
das muss man ja, wenn man irgendwie Tests parallel

01:13:42.090 --> 01:13:43.930
ausführen lassen möchte.

01:13:43.930 --> 01:13:45.870
Da kommt aber noch viel mehr

01:13:45.870 --> 01:13:47.210
Zeug mit dabei, ich will manchmal

01:13:47.210 --> 01:13:49.330
nicht so ganz sicher, ob ich das alles

01:13:49.330 --> 01:13:50.990
haben will, aber was ich

01:13:50.990 --> 01:13:53.270
auch oft benutze, also was ich total super finde,

01:13:53.270 --> 01:13:54.870
ist PyTestMock zum Beispiel, finde ich super.

01:13:54.870 --> 01:13:57.190
Ich bin mit Unitests, immer wenn ich

01:13:57.190 --> 01:13:59.090
Unitests-Geschichten irgendwo mache und dann

01:13:59.090 --> 01:14:01.450
türmen sich so die Patch-Dekoratoren

01:14:01.450 --> 01:14:03.290
oder ganz viele Context-Manager

01:14:03.290 --> 01:14:04.910
und dann ist PyTestMock echt total

01:14:04.910 --> 01:14:06.210
also sehr angenehm.

01:14:06.210 --> 01:14:09.030
Was macht das? Das übernimmt,

01:14:09.030 --> 01:14:11.230
das macht das halt automatisch.

01:14:11.230 --> 01:14:12.610
Du kriegst halt einen Mocker

01:14:12.610 --> 01:14:14.450
und schreibst als Fixture sozusagen

01:14:14.450 --> 01:14:16.370
in deinen Text-Test und dann

01:14:16.370 --> 01:14:18.510
rufst du halt Mocker.patch irgendwie

01:14:18.510 --> 01:14:20.650
einfach auf, musst aber da nicht

01:14:20.650 --> 01:14:22.650
einen Context-Manager drum rum machen oder

01:14:22.650 --> 01:14:24.810
irgendwie das Integriator verwenden und kannst das halt

01:14:24.810 --> 01:14:26.710
auch mehrfach aufrufen, ohne

01:14:26.710 --> 01:14:28.610
dass du da halt irgendwie dann eine Verschachtelung von

01:14:28.610 --> 01:14:30.510
Context-Managern hast und

01:14:30.510 --> 01:14:32.450
das wird halt hinterher auch wieder alles

01:14:32.450 --> 01:14:33.530
entmockt sozusagen,

01:14:33.530 --> 01:14:36.850
entgepatcht, wenn der Test vorbei ist und so.

01:14:36.850 --> 01:14:37.910
Also ich finde es immer so,

01:14:37.910 --> 01:14:40.790
ja, du hast recht, das ist für viele Sachen

01:14:40.790 --> 01:14:42.830
ganz nett, aber ich finde es auch irgendwie hässlich, ich weiß nicht mehr genau

01:14:42.830 --> 01:14:44.410
warum, was ist da so?

01:14:45.530 --> 01:14:47.470
Ja, diese API halt von

01:14:47.470 --> 01:14:49.710
unitest.mock, die macht schon irgendwie

01:14:49.710 --> 01:14:51.690
ganz viel Magic, also da bin ich

01:14:51.690 --> 01:14:53.790
auch nicht so wirklich zufrieden damit irgendwie.

01:14:53.790 --> 01:14:57.830
Und ja, das Plugin ist eigentlich nur ein relativ dünner

01:14:57.830 --> 01:14:59.530
Layer darum, um das halt

01:14:59.530 --> 01:15:01.870
zu einer PyTest-Fixture zu machen, zum einen

01:15:01.870 --> 01:15:03.650
und zum anderen,

01:15:03.650 --> 01:15:05.550
wenn dann was schief geht, man kann

01:15:05.550 --> 01:15:07.510
diese Mock-Objekte ja dann

01:15:07.510 --> 01:15:09.530
im Nachhinein fragen, wurdest du jetzt so

01:15:09.530 --> 01:15:10.370
und so aufgerufen?

01:15:10.370 --> 01:15:13.370
Und wenn was schief geht, nochmal

01:15:13.370 --> 01:15:15.330
PyTest einzuhängen, dass man halt

01:15:15.330 --> 01:15:17.230
diese, den schöneren

01:15:17.230 --> 01:15:19.130
Output von PyTest kriegt, der dann auch

01:15:19.130 --> 01:15:20.730
die Werte vergleicht und sowas.

01:15:20.730 --> 01:15:23.110
Aber viel

01:15:23.110 --> 01:15:25.010
mehr als das macht das Plugin eigentlich nicht.

01:15:25.010 --> 01:15:27.210
Apropos schöner Output, PyTest-Witch

01:15:27.210 --> 01:15:27.630
natürlich.

01:15:27.630 --> 01:15:29.870
Ah, okay, ja.

01:15:29.870 --> 01:15:33.130
Ja, das hier überhaupt, das hat man noch gar nicht

01:15:33.130 --> 01:15:34.770
so richtig, finde ich, ist eigentlich fast der Haupt,

01:15:34.770 --> 01:15:37.070
das Hauptfeature von PyTest

01:15:37.070 --> 01:15:38.370
für mich jedenfalls, dass halt die,

01:15:38.370 --> 01:15:40.810
dass man einfach so Assertion schreiben kann

01:15:40.810 --> 01:15:42.870
und das halt funktioniert und man halt trotzdem

01:15:42.870 --> 01:15:44.610
sehr schöne Ausgabe kriegt irgendwie,

01:15:45.130 --> 01:15:46.950
dann zeigt, wo ist genau was unterschiedlich

01:15:46.950 --> 01:15:48.670
und so. Das ist

01:15:48.670 --> 01:15:49.950
halt sehr, sehr angenehm.

01:15:49.950 --> 01:15:52.030
Nicht so komisch, dass du sagst, ich will den Camel-Case.

01:15:52.030 --> 01:15:56.950
Das ist aber auch übrigens eine

01:15:56.950 --> 01:15:58.250
ordentliche Portion Magie.

01:15:58.250 --> 01:15:59.990
Ja, ich fürchte auch irgendwie, ja.

01:15:59.990 --> 01:16:03.310
Weil an sich dieses Assert-Keyword

01:16:03.310 --> 01:16:05.010
von Python, das macht einfach nur

01:16:05.010 --> 01:16:07.110
einen Assertion-Error, also ohne

01:16:07.110 --> 01:16:08.650
jetzt, dass man irgendwie Zugriff hat

01:16:08.650 --> 01:16:10.710
auf Infos, was da passiert ist.

01:16:10.710 --> 01:16:13.110
PyTest macht

01:16:13.110 --> 01:16:15.110
da eben sein Rewriting,

01:16:15.130 --> 01:16:16.670
ja, durch den Dekorator.

01:16:16.670 --> 01:16:19.410
Das ist den Abstract-Syntax-Tree,

01:16:19.410 --> 01:16:21.150
was Python

01:16:21.150 --> 01:16:22.850
aus so einem Modul generiert, intern,

01:16:22.850 --> 01:16:25.270
bevor das wirklich dann zu Python-Byte-Code

01:16:25.270 --> 01:16:27.070
wird. Das wird, passiert das

01:16:27.070 --> 01:16:28.950
beim Import der Test-Module irgendwie, ne?

01:16:28.950 --> 01:16:30.070
Da wird der Byte-Code dann

01:16:30.070 --> 01:16:32.470
gedruckt. Ja, ja.

01:16:32.470 --> 01:16:34.970
Nicht der Byte-Code, sondern halt ein Level vorher,

01:16:34.970 --> 01:16:36.490
der Abstract-Syntax-Tree,

01:16:36.490 --> 01:16:39.090
da injectet dann PyTest noch seine

01:16:39.090 --> 01:16:40.570
eigenen Calls,

01:16:40.570 --> 01:16:43.170
um da quasi einmal festzuhalten,

01:16:43.170 --> 01:16:44.890
was ist da eigentlich drin in dieser,

01:16:44.930 --> 01:16:45.430
in dieser Assertion.

01:16:45.430 --> 01:16:47.190
Ja.

01:16:47.190 --> 01:16:51.090
Ja, PyTest macht

01:16:51.090 --> 01:16:52.490
viele Dinge, wo ich sagen muss,

01:16:52.490 --> 01:16:54.710
genau, ist sehr viel Magie,

01:16:54.710 --> 01:16:56.730
aber irgendwie so unterm Strich halt auch sehr

01:16:56.730 --> 01:16:58.770
angenehm. Ja. Also hat

01:16:58.770 --> 01:17:00.150
sich irgendwo bewährt.

01:17:00.150 --> 01:17:02.910
Entspricht diesem Pythonic-ästhetischen

01:17:02.910 --> 01:17:04.910
Ansatz irgendwie, das in klarer

01:17:04.910 --> 01:17:07.090
Sprache hinzuschreiben, was das machen soll, und

01:17:07.090 --> 01:17:08.830
das Assert ist da für Tests, glaube ich,

01:17:08.830 --> 01:17:10.070
sieht einfach schick aus.

01:17:10.070 --> 01:17:12.790
Ja, aber wäre das jetzt nicht auch schick,

01:17:12.790 --> 01:17:14.790
wenn man, wenn ein Assert in einen anderen

01:17:14.790 --> 01:17:16.070
Stellen genauso funktionieren würde?

01:17:16.070 --> 01:17:18.650
Vielleicht denken ja Leute, wenn sie das

01:17:18.650 --> 01:17:20.650
in PyTest verwendet haben, ah, das funktioniert ja

01:17:20.650 --> 01:17:22.730
immer so, und machen das dann irgendwann anders, und dann

01:17:22.730 --> 01:17:24.630
verhält sich das plötzlich ganz anders, als wir gedacht haben.

01:17:24.630 --> 01:17:26.690
Ja, aber, also man kann ja zwar

01:17:26.690 --> 01:17:28.550
Asserts ausschalten, ne, wenn man das

01:17:28.550 --> 01:17:30.150
richtig aufruft, den Interpreter,

01:17:30.150 --> 01:17:32.690
aber normalerweise macht man das ja nicht, und normalerweise fährt Assert

01:17:32.690 --> 01:17:34.490
dann einfach mit einem Assertion-Error auf die

01:17:34.490 --> 01:17:35.490
Nase. Ja, ja.

01:17:35.490 --> 01:17:38.250
Aber in PyTest sieht das dann ja anders aus.

01:17:38.250 --> 01:17:40.430
Na ja, aber das ist eigentlich

01:17:40.430 --> 01:17:42.470
relativ klar, oder, dass halt, wenn ein Test

01:17:42.470 --> 01:17:44.630
fehlt, dass der Assertion-Error dann mit mehr

01:17:44.630 --> 01:17:46.110
Informationen auch zurückgegeben wird, also

01:17:46.110 --> 01:17:48.310
das macht der ja schon, also der im Prinzip

01:17:48.310 --> 01:17:50.710
ein fehlender Python-Test heißt, du hast ein Assertion-Error.

01:17:50.710 --> 01:17:52.610
Ne, ne, ne,

01:17:52.610 --> 01:17:54.230
das, ja, aber, also

01:17:54.230 --> 01:17:56.330
Python-Test macht dann halt eine Menge Dinge.

01:17:56.330 --> 01:17:58.450
Ja gut, aber das ist ja, dafür ist ja das Framework

01:17:58.450 --> 01:17:59.690
ja da, das glaube ich, glaube ich, dass das ist. Ja.

01:17:59.690 --> 01:18:02.450
Da wollte Ronny Pfandschmid, auch

01:18:02.450 --> 01:18:04.330
einer der Maintainer, wollte da auch mal

01:18:04.330 --> 01:18:06.330
irgendeinen Pip schreiben, oder sowas, dass man

01:18:06.330 --> 01:18:07.790
sich eben bei Python grad

01:18:07.790 --> 01:18:10.370
schöner reinhängen kann in diese Assertions.

01:18:10.370 --> 01:18:11.350
Ja, das wäre, also,

01:18:11.350 --> 01:18:14.610
das wäre schon ganz nützlich,

01:18:14.610 --> 01:18:16.570
für irgendwie so eine Assertion-Lib, oder sowas,

01:18:16.570 --> 01:18:18.570
die man einfach importiert, und dann hat man schönere Assertions,

01:18:18.570 --> 01:18:20.430
oder so, das wäre doch cool, aber, ja,

01:18:20.430 --> 01:18:22.590
wahrscheinlich ist es nicht so einfach. Genau, aber ich glaube, da ist es leider

01:18:22.590 --> 01:18:23.310
nie was geworden.

01:18:23.310 --> 01:18:26.690
Was es

01:18:26.690 --> 01:18:28.390
gibt für Notebooks, vielleicht noch ganz

01:18:28.390 --> 01:18:30.350
interessant, ein Ding namens

01:18:30.350 --> 01:18:31.370
IPyTest,

01:18:31.370 --> 01:18:34.450
was eben PyTest in diese Notebooks

01:18:34.450 --> 01:18:36.370
integriert, also man kann da einfach mit

01:18:36.370 --> 01:18:38.290
Prozent-Prozent IPyTest,

01:18:38.290 --> 01:18:39.730
kann man halt PyTest ausführen,

01:18:39.730 --> 01:18:42.650
und hat dann auch Zugriff gleich auf die lokalen

01:18:42.650 --> 01:18:44.550
Variablen aus dem Notebook und sowas,

01:18:44.590 --> 01:18:46.710
und das, wenn man

01:18:46.710 --> 01:18:48.810
das einmal einrichtet in einem Notebook,

01:18:48.810 --> 01:18:50.730
dann kriegt man auch in diesem Notebook

01:18:50.730 --> 01:18:52.650
global quasi

01:18:52.650 --> 01:18:53.910
geschenkt die

01:18:53.910 --> 01:18:56.890
Assertion-Infos, wenn eine Assertion fehlschlägt.

01:18:56.890 --> 01:18:58.150
Ach, und das geht dann auch an anderen Stellen,

01:18:58.150 --> 01:18:59.790
sozusagen, dann, ah ja.

01:18:59.790 --> 01:19:02.510
Genau, das hängt sich dann halt da irgendwie ein.

01:19:02.510 --> 01:19:04.830
Ach, cool, das kann ich auch noch nicht.

01:19:04.830 --> 01:19:06.750
Ja.

01:19:06.750 --> 01:19:08.650
Und noch mehr Plugins

01:19:08.650 --> 01:19:09.190
hier benutzt?

01:19:09.190 --> 01:19:12.770
Wollte ich nochmal freescannen,

01:19:12.770 --> 01:19:14.430
wenn ich irgendwie so Zeit sagen will,

01:19:14.570 --> 01:19:16.550
also zu der und der Zeit, oder die Zeit muss ich jetzt um

01:19:16.550 --> 01:19:18.630
zwei Stunden verschieben, zwischen zwei Tests

01:19:18.630 --> 01:19:19.990
oder sowas, das ist ganz nett,

01:19:19.990 --> 01:19:22.170
mit Context-Manager oder so,

01:19:22.170 --> 01:19:23.490
das ist cool.

01:19:23.490 --> 01:19:25.950
Ja, das habe ich schon genutzt, Responses.

01:19:25.950 --> 01:19:28.690
Das ist Mocking

01:19:28.690 --> 01:19:30.330
halt für Requests, man

01:19:30.330 --> 01:19:32.830
ruft eigentlich, wie man Requests abruft,

01:19:32.830 --> 01:19:34.470
ruft man halt erstmal Responses auf,

01:19:34.470 --> 01:19:35.530
und das mockt einem das weg.

01:19:35.530 --> 01:19:37.990
Ich glaube, das gibt auch für HTTPX, wenn ich das richtig gesehen habe.

01:19:37.990 --> 01:19:40.330
Und da,

01:19:40.330 --> 01:19:42.410
ich fände es eigentlich schön, wenn es

01:19:42.410 --> 01:19:44.550
mehr so Mocking-Libraries

01:19:44.550 --> 01:19:45.730
gibt, also sowas wie jetzt eben

01:19:45.730 --> 01:19:48.490
freescannen, VCR, Responses

01:19:48.490 --> 01:19:49.870
oder diesen HTTPX-Mock.

01:19:49.870 --> 01:19:51.990
Ich bin eigentlich der Meinung,

01:19:51.990 --> 01:19:54.610
jede Python-Library, die irgendwas macht

01:19:54.610 --> 01:19:56.350
mit externen Systemen,

01:19:56.350 --> 01:19:58.670
also auch sowas wie PySerial beispielsweise,

01:19:58.670 --> 01:20:00.410
sollte halt

01:20:00.410 --> 01:20:02.470
gerade auch irgendwie so Testsupport

01:20:02.470 --> 01:20:04.150
oder so Mocks gleich mitliefern,

01:20:04.150 --> 01:20:06.630
und dann auch schöne, maintained, getestete

01:20:06.630 --> 01:20:06.990
Mocks.

01:20:06.990 --> 01:20:10.390
Mocking ist immer noch sowas, das macht man irgendwie so

01:20:10.390 --> 01:20:12.490
ad hoc in jeder Testsuite wieder neu

01:20:12.490 --> 01:20:13.490
das Rad erfunden.

01:20:13.490 --> 01:20:14.390
Ja, ist das nett.

01:20:14.390 --> 01:20:16.530
Stimmt, da ist relativ viel Zeit

01:20:16.530 --> 01:20:18.050
immer dann, bis man das richtig läuft.

01:20:18.050 --> 01:20:19.850
Das ist wahrscheinlich sogar der Hauptteil,

01:20:19.850 --> 01:20:21.690
den man braucht für Testschreiben.

01:20:21.690 --> 01:20:24.270
Nö, das würde ich jetzt auch nicht sagen.

01:20:24.270 --> 01:20:26.410
Aber es ist halt immer wieder

01:20:26.410 --> 01:20:27.090
das.

01:20:27.090 --> 01:20:30.130
Was ich noch gerne mache, ist

01:20:30.130 --> 01:20:30.730
Insta-Fail.

01:20:30.730 --> 01:20:34.230
Und dann sieht man halt direkt, wenn die Tests

01:20:34.230 --> 01:20:35.910
ein bisschen länger laufen und die Tests, die fehlen schon mal,

01:20:35.910 --> 01:20:37.950
kann man daran schon mal dann werkeln, weil man

01:20:37.950 --> 01:20:40.130
einfach nur, keine Ahnung, sich verschrieben hat, vertippt hat oder so.

01:20:40.130 --> 01:20:42.190
Hat man den schon mal dann drauf und das läuft dann

01:20:42.190 --> 01:20:43.490
trotzdem noch.

01:20:44.390 --> 01:20:46.390
Mhm. Ich nutze noch, da bin ich jetzt

01:20:46.390 --> 01:20:48.110
nicht so stolz drauf, aber ich nutze noch

01:20:48.110 --> 01:20:49.930
PyTest-Rerun-Failures,

01:20:49.930 --> 01:20:52.650
wo man Tests halt als flaky markieren

01:20:52.650 --> 01:20:54.350
kann und wenn sie fehlschlagen, werden sie halt

01:20:54.350 --> 01:20:55.210
nochmal ausgeführt.

01:20:55.210 --> 01:20:58.410
Weil ich bei Qt-Browser halt

01:20:58.410 --> 01:21:00.350
wirklich aus GUI-Applikationen mit so

01:21:00.350 --> 01:21:02.070
vielen externen Komponenten

01:21:02.070 --> 01:21:04.330
dieses Problem mit flaky

01:21:04.330 --> 01:21:05.950
Tests fast nicht in den Griff kriege.

01:21:05.950 --> 01:21:07.990
Ah ja. Okay.

01:21:07.990 --> 01:21:09.930
Und dann bis zu irgendwie eine

01:21:09.930 --> 01:21:12.050
Assertion-Failure in der libc,

01:21:12.050 --> 01:21:14.190
also so die Library-C selbst,

01:21:14.230 --> 01:21:16.190
implementiert, wo ich sagen muss, dass

01:21:16.190 --> 01:21:18.270
ich mir jetzt so viele Labels darunter, da kann

01:21:18.270 --> 01:21:19.870
ich jetzt echt nichts daran ändern.

01:21:19.870 --> 01:21:21.310
Also, was will ich machen?

01:21:21.310 --> 01:21:23.250
Ja.

01:21:23.250 --> 01:21:26.130
Aber natürlich nur so jedes tausendste Mal.

01:21:26.130 --> 01:21:28.270
Ja.

01:21:28.270 --> 01:21:30.150
Das ist ja ganz mies, wenn irgendwie so

01:21:30.150 --> 01:21:32.230
ein Test nur jedes hundertste oder so

01:21:32.230 --> 01:21:34.090
Mal-Fail schlägt, das ist ja ganz

01:21:34.090 --> 01:21:35.970
eklig. Irgendwie so

01:21:35.970 --> 01:21:37.830
das rauszufinden, bläh.

01:21:37.830 --> 01:21:39.610
Das ist immer...

01:21:39.610 --> 01:21:42.050
Ist das ein Plugin oder kann das Plug-Test, das weiß ich

01:21:42.050 --> 01:21:44.070
gar nicht, aber dass man die Reihenfolge

01:21:44.070 --> 01:21:45.290
irgendwie zufällig macht.

01:21:45.290 --> 01:21:46.030
Random?

01:21:46.030 --> 01:21:49.650
Ja, da gibt es ein paar.

01:21:49.650 --> 01:21:50.350
Randomly.

01:21:50.350 --> 01:21:54.330
Ja.

01:21:54.330 --> 01:21:57.990
Ja, macht eigentlich Sinn, weil eben

01:21:57.990 --> 01:21:59.990
Tests voneinander unabhängig sein sollten.

01:21:59.990 --> 01:22:01.970
Und

01:22:01.970 --> 01:22:03.970
andersrum gibt es PyTest-Order,

01:22:03.970 --> 01:22:05.990
wo man sagen kann, Tests sollen halt voneinander

01:22:05.990 --> 01:22:07.950
abhängig sein in einer bestimmten Reihenfolge.

01:22:07.950 --> 01:22:09.990
Wie heißt das? Kannst du nochmal

01:22:09.990 --> 01:22:11.990
betonen, bitte? PyTest-Order.

01:22:11.990 --> 01:22:12.490
Ah.

01:22:13.910 --> 01:22:17.490
Da kommt oft die Frage dann eben von

01:22:17.490 --> 01:22:19.590
Kunden von mir, die dann

01:22:19.590 --> 01:22:21.470
irgendwie Elektronik mit PyTest testen.

01:22:21.470 --> 01:22:24.030
Weil da natürlich,

01:22:24.030 --> 01:22:25.970
wenn man jetzt eine Klimakammer

01:22:25.970 --> 01:22:27.790
hat oder so, dann ist das halt

01:22:27.790 --> 01:22:29.710
nun mal so, dass die Dinge voneinander abhängen.

01:22:29.710 --> 01:22:31.710
Oder dass man vielleicht

01:22:31.710 --> 01:22:33.810
alle Tests irgendwie bei 30 Grad

01:22:33.810 --> 01:22:35.630
laufen sollen, dass man

01:22:35.630 --> 01:22:37.390
die erstmal laufen lassen will, anstatt

01:22:37.390 --> 01:22:39.470
jedes Mal auf minus 10 Grad runter zu kühlen

01:22:39.470 --> 01:22:41.770
und wieder hoch auf 30. Oder wie auch immer.

01:22:41.770 --> 01:22:42.350
Ja.

01:22:43.750 --> 01:22:44.150
Schlecht Sinn.

01:22:44.150 --> 01:22:46.470
Ja.

01:22:46.470 --> 01:22:49.510
Ja, PyTest-BDD nutze ich noch.

01:22:49.510 --> 01:22:51.210
Ah, okay. Das ist interessant.

01:22:51.210 --> 01:22:52.770
Ja, da habe ich auch schon häufiger was gehört.

01:22:52.770 --> 01:22:53.250
Ja.

01:22:53.250 --> 01:22:56.050
Ich habe es auch mal versucht zu nutzen.

01:22:56.050 --> 01:22:59.330
Also, vielleicht nochmal kurz der Behavior-Driven

01:22:59.330 --> 01:23:01.570
Development-Test.

01:23:01.570 --> 01:23:02.090
Genau.

01:23:02.090 --> 01:23:04.810
Man kann so Logik, so Business-Logik schreiben,

01:23:04.810 --> 01:23:06.230
so für den PO oder so.

01:23:06.230 --> 01:23:08.330
Und der kann dann so Sätze

01:23:08.330 --> 01:23:10.850
formulieren in seiner eigenen Sprache

01:23:10.850 --> 01:23:12.950
und dann guckt PyTest-BDD, ob es geht

01:23:12.950 --> 01:23:13.230
oder nicht.

01:23:13.590 --> 01:23:15.330
Aber so tief reinzukriegen...

01:23:15.330 --> 01:23:16.930
Das ist im Prinzip einfach nochmal eine

01:23:16.930 --> 01:23:19.710
kleine Abstraktion, dass man sagen kann,

01:23:19.710 --> 01:23:21.770
given I have

01:23:21.770 --> 01:23:23.030
an author user,

01:23:23.030 --> 01:23:26.070
when I do this and that,

01:23:26.070 --> 01:23:27.530
then this and that should happen.

01:23:27.530 --> 01:23:29.710
Also mit diesem given, when, then.

01:23:29.710 --> 01:23:32.090
Das halt wirklich als Testsprache

01:23:32.090 --> 01:23:33.550
hat und dann die Implementation

01:23:33.550 --> 01:23:35.490
der Tests

01:23:35.490 --> 01:23:38.190
eigentlich nochmal abgekapselt

01:23:38.190 --> 01:23:39.850
hat von den Test-Cases.

01:23:39.850 --> 01:23:41.650
Also quasi so diese User-Story

01:23:41.650 --> 01:23:42.770
reingießen, ja.

01:23:43.430 --> 01:23:45.270
Genau.

01:23:45.270 --> 01:23:47.270
Also ich hab's wieder rausgeschmissen, ich hab's ausprobiert,

01:23:47.270 --> 01:23:49.170
aber irgendwie... Wahrscheinlich lag's aber auch

01:23:49.170 --> 01:23:50.890
an einem Projekt halt, wo das halt nicht so wirklich

01:23:50.890 --> 01:23:51.750
dazu gepasst hat.

01:23:51.750 --> 01:23:53.850
Wofür verwendest du das?

01:23:53.850 --> 01:23:56.650
Ich nutze halt ganz stark für die

01:23:56.650 --> 01:23:58.230
End-to-End-Tests für Cube-Browser.

01:23:58.230 --> 01:24:01.230
Jetzt müsste ich da vielleicht nochmal kurz einhaken,

01:24:01.230 --> 01:24:02.670
was Cube-Browser denn überhaupt ist.

01:24:02.670 --> 01:24:03.770
Jetzt hab ich's schon ein paar Mal erwähnt.

01:24:03.770 --> 01:24:07.170
Das ist so mein Hauptprojekt

01:24:07.170 --> 01:24:08.970
seit ziemlich genau

01:24:08.970 --> 01:24:10.570
zehn Jahren. Ich glaub in

01:24:10.570 --> 01:24:12.710
drei Tagen oder so sind's zehn Jahre.

01:24:13.270 --> 01:24:15.070
Und zwar

01:24:15.070 --> 01:24:16.910
ein Web-Browser, der

01:24:16.910 --> 01:24:18.850
sehr stark auf Tastaturbedienung

01:24:18.850 --> 01:24:20.890
ausgelegt ist, so inspiriert

01:24:20.890 --> 01:24:22.910
von VI beziehungsweise WIM,

01:24:22.910 --> 01:24:24.850
eben auf

01:24:24.850 --> 01:24:26.930
Chromium aufsetzt und in Python

01:24:26.930 --> 01:24:28.950
geschrieben ist. Und darüber

01:24:28.950 --> 01:24:30.490
bin ich dann auch zu PyTest gekommen.

01:24:30.490 --> 01:24:33.110
Und

01:24:33.110 --> 01:24:35.290
das hat halt dann so

01:24:35.290 --> 01:24:36.990
ein Interface

01:24:36.990 --> 01:24:39.070
mit einer Command-Line quasi

01:24:39.070 --> 01:24:39.630
eingebaut.

01:24:39.630 --> 01:24:43.110
Und da hab ich dann halt auch viele End-to-End-Tests

01:24:43.110 --> 01:24:44.870
wo ich halt einfach irgendwo ein Kommando

01:24:44.870 --> 01:24:46.870
hinschicke zu einem laufenden Browser

01:24:46.870 --> 01:24:49.170
und dann erstmal schaue

01:24:49.170 --> 01:24:50.910
mit einem Web-Server, der direkt

01:24:50.910 --> 01:24:52.670
im PyTest-Prozess läuft,

01:24:52.670 --> 01:24:54.650
wurde dann das

01:24:54.650 --> 01:24:56.790
die und die Seite aufgerufen oder ist

01:24:56.790 --> 01:24:57.790
das und das passiert.

01:24:57.790 --> 01:25:00.870
Und so diese End-to-End-Tests hab ich dann

01:25:00.870 --> 01:25:02.970
halt eben mit diesem PyTest-BDD geschrieben,

01:25:02.970 --> 01:25:05.190
dass ich sage, when I run

01:25:05.190 --> 01:25:07.010
open und irgendwie

01:25:07.010 --> 01:25:08.350
ein Pfad,

01:25:08.350 --> 01:25:11.030
then this and that page should be loaded.

01:25:11.030 --> 01:25:12.110
Hm.

01:25:12.950 --> 01:25:13.390
Ja.

01:25:13.390 --> 01:25:16.370
Ja, an der Stelle

01:25:16.370 --> 01:25:18.250
klingt das durchaus sinnvoll, weil wahrscheinlich

01:25:18.250 --> 01:25:20.290
hat man dann ganz viele davon und da will man ja

01:25:20.290 --> 01:25:22.490
wahrscheinlich dann sozusagen nicht immer

01:25:22.490 --> 01:25:24.230
das ganze Boilerplate

01:25:24.230 --> 01:25:26.270
hinschreiben.

01:25:26.270 --> 01:25:30.150
Ja, ich weiß auch nicht, ob ich es

01:25:30.150 --> 01:25:31.550
nochmal so machen würde, weil

01:25:31.550 --> 01:25:34.170
es sind jetzt halt doch sehr viele so End-to-End-Tests

01:25:34.170 --> 01:25:35.010
geworden und da

01:25:35.010 --> 01:25:38.430
ein einziges Problem mit flaky Tests

01:25:38.430 --> 01:25:39.430
und mit langsamen Tests.

01:25:42.790 --> 01:25:45.330
Aber ich glaube, für so gewisse Dinge

01:25:45.330 --> 01:25:47.350
lohnt sich das schon. Also ich fand es auch ganz

01:25:47.350 --> 01:25:49.350
angenehm, wenn halt neue Leute

01:25:49.350 --> 01:25:51.070
dazukommen, die noch nie was mit PyTest

01:25:51.070 --> 01:25:53.510
gemacht haben, dass du denen sagen kannst,

01:25:53.510 --> 01:25:54.990
guck, schau dir das mal an,

01:25:54.990 --> 01:25:56.650
das ist eine schöne,

01:25:56.650 --> 01:25:59.130
eine hohe Abstraktion, nochmal höher als

01:25:59.130 --> 01:26:01.070
Python-Code und schau mal, ob du so einen Test

01:26:01.070 --> 01:26:01.750
schreiben kannst.

01:26:01.750 --> 01:26:03.010
Ja.

01:26:03.010 --> 01:26:06.850
An der Stelle ist es vielleicht auch noch ganz interessant, genau,

01:26:06.850 --> 01:26:08.750
das ist ja auch, selbst wenn man jetzt nicht BDD

01:26:08.750 --> 01:26:11.190
Tests sozusagen

01:26:11.190 --> 01:26:11.970
so hinschreibt, sondern

01:26:11.970 --> 01:26:14.910
normale Tests, dann empfiehlt es sich

01:26:14.910 --> 01:26:16.730
da ja auch vielleicht, sich im Grunde an

01:26:16.730 --> 01:26:18.750
dieses Pattern zu halten. Also

01:26:18.750 --> 01:26:20.850
genau, Given-When-Then ist halt die eine

01:26:20.850 --> 01:26:22.110
Formulierung, wie man das halt

01:26:22.110 --> 01:26:24.890
ausdrücken kann. Es gibt noch eine andere,

01:26:24.890 --> 01:26:25.670
die nennt sich irgendwie

01:26:25.670 --> 01:26:28.190
Arrange-Act-Assert,

01:26:28.190 --> 01:26:30.330
aber es ist im Grunde beides das Gleiche.

01:26:30.330 --> 01:26:32.850
Es ist halt immer irgendwie, man baut sich zuerst irgendwie

01:26:32.850 --> 01:26:34.410
einen

01:26:34.410 --> 01:26:36.810
State zusammen, der halt irgendwie ist

01:26:36.810 --> 01:26:38.670
und dann macht man

01:26:38.670 --> 01:26:40.810
irgendwas drauf und dann guckt man hinterher, ist das rausgekommen,

01:26:40.810 --> 01:26:41.810
was man sich irgendwie

01:26:41.810 --> 01:26:44.610
was man erwartet hat und wenn nicht, ist halt

01:26:44.610 --> 01:26:45.970
schlecht. Aber es macht halt

01:26:45.970 --> 01:26:48.770
ja Sinn,

01:26:48.770 --> 01:26:50.710
Tests immer so zu strukturieren, dass man

01:26:50.710 --> 01:26:52.270
halt auch, wenn man jetzt auf den Test guckt,

01:26:52.270 --> 01:26:54.530
sofort weiß, okay, ach, an der Stelle wird nur

01:26:54.530 --> 01:26:56.550
irgendwas zusammengebaut, an der Stelle wird jetzt der eigentliche

01:26:56.550 --> 01:26:58.610
Aufruf gemacht und hier assorten wir irgendwelche Dinge,

01:26:58.610 --> 01:27:00.610
wo wir dachten, das müsste jetzt

01:27:00.610 --> 01:27:01.390
da rauskommen, ja.

01:27:01.390 --> 01:27:04.670
Das BDD, das klingt auch so ein bisschen

01:27:04.670 --> 01:27:06.350
nach, als könnte man das mit Playwright machen.

01:27:06.350 --> 01:27:08.090
Ich weiß nicht, ob das dieses Pattern auch ist.

01:27:08.090 --> 01:27:11.650
Die Playwright-Tests,

01:27:11.650 --> 01:27:12.970
die ich bisher gemacht habe,

01:27:12.970 --> 01:27:15.610
ne, die waren halt einfach, da habe ich das alles immer von Hand hingeschrieben.

01:27:15.610 --> 01:27:16.330
Ja.

01:27:16.330 --> 01:27:19.190
Es ist halt, ja,

01:27:19.190 --> 01:27:21.470
das macht aber so ein bisschen BDD auch, oder? Also es gibt halt

01:27:21.470 --> 01:27:23.210
so einen Browser und sagt halt, okay, geh auf diese

01:27:23.210 --> 01:27:24.810
Seite und drück mal so einen Knopf

01:27:24.810 --> 01:27:27.210
und erwarte das. Ja, aber es sind schon

01:27:27.210 --> 01:27:29.410
einfach Funktionsaufrufe, ist nicht irgendwie

01:27:29.410 --> 01:27:31.190
Text, den man hinschreibt. Ja, okay, stimmt.

01:27:31.190 --> 01:27:33.470
Ich wache es halt an, dass die es halt direkt abheißen, ja.

01:27:33.470 --> 01:27:34.770
Ja.

01:27:34.770 --> 01:27:37.510
Ja, ich glaube, ich, also mir fällt kein

01:27:37.510 --> 01:27:39.470
Plugin mehr ein, was ich jetzt empfehlen wollen

01:27:39.470 --> 01:27:41.490
würde. Welche hatten wir ja schon?

01:27:41.490 --> 01:27:43.110
Ähm, was

01:27:43.110 --> 01:27:45.430
muss ich mich fragen, ob sowas gibt, ich weiß

01:27:45.430 --> 01:27:47.450
nicht, in der JavaScript-Welt, das sehe ich halt ab und zu

01:27:47.450 --> 01:27:49.070
mal, gibt es halt auch so Dinge,

01:27:49.070 --> 01:27:51.110
da läuft halt einfach immer irgendwie

01:27:51.110 --> 01:27:53.350
oder da wird halt geguckt,

01:27:53.350 --> 01:27:54.910
ob sich irgendwas an den Files geändert hat und wenn,

01:27:54.910 --> 01:27:57.270
dann läuft halt da irgendwie der Testrunner

01:27:57.270 --> 01:27:58.630
quasi die ganze Zeit und läuft

01:27:58.630 --> 01:28:01.210
alle Tests, die dann halt sozusagen davon

01:28:01.210 --> 01:28:03.250
beeinflusst sein könnten von irgendeiner Änderung, werden dann

01:28:03.250 --> 01:28:05.210
halt nochmal ausgeführt und das gibt dann einem

01:28:05.210 --> 01:28:07.250
so eine Art Dashboard, was halt gerade nicht funktioniert

01:28:07.250 --> 01:28:09.290
oder was funktioniert, gibt es das

01:28:09.290 --> 01:28:11.330
für PyTest eigentlich auch, weil ich glaube, sowas habe ich noch nicht

01:28:11.330 --> 01:28:11.710
gesehen.

01:28:11.710 --> 01:28:13.790
Ja, es gibt

01:28:13.790 --> 01:28:14.470
Testmon.

01:28:14.470 --> 01:28:16.490
Ah, okay, cool.

01:28:16.490 --> 01:28:19.290
Ein größeres Projekt,

01:28:19.290 --> 01:28:20.850
Testmon.org,

01:28:20.850 --> 01:28:23.530
hatte ich mir mal angeschaut, aber jetzt auch schon

01:28:23.530 --> 01:28:24.350
länger nicht mehr.

01:28:24.350 --> 01:28:27.750
Ein paar Linken, guck mal nochmal rein.

01:28:27.750 --> 01:28:29.690
Ich weiß, dass es auch

01:28:29.690 --> 01:28:31.510
ein, zwei Leute gibt, die jetzt da so ein bisschen

01:28:31.510 --> 01:28:33.510
noch schauen, wie

01:28:33.510 --> 01:28:35.610
kann ich mit Coverage

01:28:35.610 --> 01:28:37.790
halt auch dann schauen, welche Tests wirklich

01:28:37.790 --> 01:28:39.570
beeinflusst sind von

01:28:39.570 --> 01:28:40.550
einer Änderung und sowas.

01:28:41.170 --> 01:28:43.150
Aber es ist schon noch so etwas, was

01:28:43.150 --> 01:28:45.010
jetzt nicht so

01:28:45.010 --> 01:28:47.010
in fix fertig, jetzt eben aus der

01:28:47.010 --> 01:28:49.090
Testmon, also es gibt schon in fix fertig, aber

01:28:49.090 --> 01:28:50.910
jetzt auch noch was, was ich weiß, dass Leute

01:28:50.910 --> 01:28:51.770
dann arbeiten.

01:28:51.770 --> 01:28:55.350
Ja.

01:28:55.350 --> 01:28:59.150
Ja, ansonsten, ich weiß nicht, was haben wir denn noch

01:28:59.150 --> 01:28:59.890
so für Themen?

01:28:59.890 --> 01:29:02.610
Noch irgendwie größere Dinge

01:29:02.610 --> 01:29:04.290
gar nicht besprochen oder?

01:29:04.290 --> 01:29:08.950
Ja, vielleicht noch den

01:29:08.950 --> 01:29:10.370
Development Sprint.

01:29:11.010 --> 01:29:12.690
Naja, und zwar

01:29:12.690 --> 01:29:16.850
gab es im 2016

01:29:16.850 --> 01:29:18.830
glaube ich mal einen Development Sprint,

01:29:18.830 --> 01:29:21.110
wo wir uns alle mal getroffen hatten

01:29:21.110 --> 01:29:22.730
in Freiburg im Breisgau

01:29:22.730 --> 01:29:24.630
und halt mal zusammen

01:29:24.630 --> 01:29:26.530
rumgehackt haben an PyTest.

01:29:26.530 --> 01:29:29.090
Zum einen halt eben so die

01:29:29.090 --> 01:29:30.710
wirklichen Verdächtigen, die

01:29:30.710 --> 01:29:32.950
Core-Entwickler, zum anderen aber auch

01:29:32.950 --> 01:29:34.970
ganz viele Leute von irgendwelchen Plugins

01:29:34.970 --> 01:29:36.870
oder auch einfach Leute, die mal was an PyTest

01:29:36.870 --> 01:29:38.770
machen wollten. Und

01:29:38.770 --> 01:29:40.750
ich bin gerade daran, fürs

01:29:40.850 --> 01:29:42.970
24 sowas wieder zu

01:29:42.970 --> 01:29:43.610
organisieren,

01:29:43.610 --> 01:29:46.910
müsst ihr wahrscheinlich mal noch schauen, dass ich das auf die

01:29:46.910 --> 01:29:48.770
PyTest-Webseite auch mache, weil

01:29:48.770 --> 01:29:50.190
bisher war die Resonanz

01:29:50.190 --> 01:29:52.890
nicht so

01:29:52.890 --> 01:29:53.290
viel.

01:29:53.290 --> 01:29:56.730
Ich hab da halt mal

01:29:56.730 --> 01:29:58.810
von einem Kunden von mir das Angebot

01:29:58.810 --> 01:30:00.170
bekommen, dass die

01:30:00.170 --> 01:30:01.910
uns da

01:30:01.910 --> 01:30:04.790
hosten bei sich in Vorarlberg,

01:30:04.790 --> 01:30:06.950
was erstmal so

01:30:06.950 --> 01:30:08.190
eben nirgendwo ist.

01:30:08.190 --> 01:30:10.690
Vorarlberg klingt nach Alpen

01:30:10.690 --> 01:30:11.070
irgendwo.

01:30:11.070 --> 01:30:14.510
Ja, das ist tatsächlich ziemlich nah

01:30:14.510 --> 01:30:16.670
als Österreich, aber

01:30:16.670 --> 01:30:17.910
gerade an der Schweizer Grenze.

01:30:17.910 --> 01:30:20.530
In einem Dorf mit irgendwie

01:30:20.530 --> 01:30:21.930
3000 Leuten oder so

01:30:21.930 --> 01:30:24.550
sind die zu Hause.

01:30:24.550 --> 01:30:25.730
Omikron

01:30:25.730 --> 01:30:28.670
heißen die und die hatten

01:30:28.670 --> 01:30:30.630
mir angeboten, das halt

01:30:30.630 --> 01:30:31.930
da zu hosten und

01:30:31.930 --> 01:30:34.230
meinten noch, ja, wir können da

01:30:34.230 --> 01:30:36.690
gratis essen und so und haben Sitzungsräume

01:30:36.690 --> 01:30:37.150
und sowas.

01:30:37.150 --> 01:30:40.530
Und da

01:30:40.530 --> 01:30:42.010
hatte ich jetzt mal so eine Umfrage

01:30:42.010 --> 01:30:44.350
gemacht, wer dann so kommen will und

01:30:44.350 --> 01:30:46.490
es haben sich halt irgendwie fünf Leute oder so gemeldet.

01:30:46.490 --> 01:30:48.630
Ich würde

01:30:48.630 --> 01:30:50.610
da eigentlich ganz gerne ein paar mehr Leute noch haben.

01:30:50.610 --> 01:30:52.110
Also eben in

01:30:52.110 --> 01:30:54.370
2016 waren es 27

01:30:54.370 --> 01:30:54.970
Leute.

01:30:54.970 --> 01:30:58.410
Diesmal könnten wir schon

01:30:58.410 --> 01:31:00.230
so 30, 35 oder so

01:31:00.230 --> 01:31:01.210
könnten wir hosten.

01:31:01.210 --> 01:31:04.250
Wahrscheinlich dann auch mit

01:31:04.250 --> 01:31:06.310
Preise teilweise bezahlt und sowas

01:31:06.310 --> 01:31:08.230
Unterkunft teilweise bezahlt. Müsste man sich

01:31:08.230 --> 01:31:09.490
alles im Detail mal anschauen.

01:31:10.370 --> 01:31:12.450
Wenn wirklich die Resonanz auch da ist.

01:31:12.450 --> 01:31:14.550
Ja, cool. Also da kann man sich

01:31:14.550 --> 01:31:16.430
auf jeden Fall mal melden, wenn man da Interesse hat.

01:31:16.430 --> 01:31:18.230
Wann wäre das denn ungefähr

01:31:18.230 --> 01:31:20.190
im Sommer oder?

01:31:20.190 --> 01:31:22.190
Genau im Juni.

01:31:22.190 --> 01:31:23.870
Dann ist noch ein bisschen Zeit.

01:31:23.870 --> 01:31:26.330
Genau, Mitte,

01:31:26.330 --> 01:31:28.450
Ende Juni, sowas. Müssen noch schauen,

01:31:28.450 --> 01:31:29.490
welche Woche das wird.

01:31:29.490 --> 01:31:32.210
Und dann

01:31:32.210 --> 01:31:33.510
wäre eben so die Hoffnung,

01:31:33.510 --> 01:31:36.710
dass wir da Leute zusammenkriegen,

01:31:36.710 --> 01:31:38.210
die irgendwas machen wollen. Jetzt ohne

01:31:38.210 --> 01:31:40.330
eine fixe Idee zu haben, was genau ist,

01:31:40.330 --> 01:31:41.470
kommt dann mal alles noch.

01:31:41.470 --> 01:31:44.150
Aber halt einfach so ein Development Sprint

01:31:44.150 --> 01:31:46.130
wieder mal zu haben und sich mal wieder in Person

01:31:46.130 --> 01:31:46.930
zu sehen auch.

01:31:46.930 --> 01:31:48.410
Gute Sache.

01:31:48.410 --> 01:31:53.410
Ja, was gibt's noch?

01:31:53.410 --> 01:31:56.430
Ich würde sagen, mit Pytest sind wir glaube ich

01:31:56.430 --> 01:31:58.230
mit den Themen, die ich zumindest auf der

01:31:58.230 --> 01:31:59.250
Liste hatte, soweit.

01:31:59.250 --> 01:32:01.890
Dann können wir vielleicht zu den Pics

01:32:01.890 --> 01:32:04.350
der Woche des Monats der Folge

01:32:04.350 --> 01:32:05.930
übergehen. Ja, können wir gerne machen.

01:32:05.930 --> 01:32:08.250
Alles klar, dann mache ich

01:32:08.250 --> 01:32:10.050
mal Kapitelmarke, Pics,

01:32:10.170 --> 01:32:11.010
Upsi.

01:32:11.010 --> 01:32:13.810
Also ich picke

01:32:13.810 --> 01:32:14.750
fstring.help.

01:32:14.750 --> 01:32:17.430
Aha, mich geehrt.

01:32:17.430 --> 01:32:20.230
Ich glaube, ich hatte das auch schon

01:32:20.230 --> 01:32:22.150
mal irgendwann gepickt, meine ich. Aber wir müssen mal

01:32:22.150 --> 01:32:24.050
gucken. Wir picken immer nur noch Sachen,

01:32:24.050 --> 01:32:24.510
die wir schon mal gepickt haben.

01:32:24.510 --> 01:32:28.110
Ja, ist mir jetzt

01:32:28.110 --> 01:32:29.530
letztens auch passiert, da habe ich es genau

01:32:29.530 --> 01:32:31.770
in der nächsten Episode noch mal gepickt,

01:32:31.770 --> 01:32:32.730
was ich schon mal gepickt hatte.

01:32:32.730 --> 01:32:36.210
Ja, lass mal überlegen, was würde

01:32:36.210 --> 01:32:38.010
ich denn picken? Ah, ich glaube, ich mache mal irgendwas aus dem

01:32:38.010 --> 01:32:40.050
Data-Science-Bereich. Jetzt hat man das am Anfang schon,

01:32:40.130 --> 01:32:40.550
so ein bisschen

01:32:40.550 --> 01:32:43.630
den Mund wässrig gemacht mit dem

01:32:43.630 --> 01:32:46.130
OpenAI-Thema und dann kam

01:32:46.130 --> 01:32:47.030
aber überhaupt gar nichts mehr.

01:32:47.030 --> 01:32:49.970
Ich versuche mich da wieder so ein bisschen reinzufuchsen. Ich mache das

01:32:49.970 --> 01:32:52.010
ja auch, aber in letzter Zeit viel mehr Web-Entwicklungen

01:32:52.010 --> 01:32:53.750
gemacht aus, weiß gar nicht, warum.

01:32:53.750 --> 01:32:56.030
Eigentlich ist ja auch das große Thema

01:32:56.030 --> 01:32:56.610
gerade, aber

01:32:56.610 --> 01:33:00.010
und deswegen habe ich mir

01:33:00.010 --> 01:33:02.030
auch mal geguckt, was gibt es denn da so an Kursen,

01:33:02.030 --> 01:33:04.050
wenn man sich jetzt für diese ganzen Geschichten

01:33:04.050 --> 01:33:06.310
LLM-Deployment-Kram

01:33:06.310 --> 01:33:08.310
interessiert. Und da gibt es einen

01:33:08.310 --> 01:33:09.610
Fast-Kurs von Fast.ai.

01:33:10.090 --> 01:33:11.770
Jeremy Howard macht das, das ist super.

01:33:11.770 --> 01:33:13.750
Den verlinke ich dann auch mal in den

01:33:13.750 --> 01:33:14.170
Shownotes.

01:33:14.170 --> 01:33:17.730
2022 und 23, ich weiß nicht,

01:33:17.730 --> 01:33:19.450
ob es die 23 schon gibt,

01:33:19.450 --> 01:33:21.550
aber die 22 ist auf jeden Fall, ich glaube, die habe ich,

01:33:21.550 --> 01:33:23.250
das Ding ist echt.

01:33:23.250 --> 01:33:25.950
Eigentlich müssten wir dazu eh noch mal eine Folge machen. Ich würde sagen, der Einstiegskurs

01:33:25.950 --> 01:33:28.030
ist vielleicht sogar CS50

01:33:28.030 --> 01:33:29.710
AI with Python für die Leute, die

01:33:29.710 --> 01:33:31.990
so ein bisschen mehr anfangen, die Grundlagen

01:33:31.990 --> 01:33:33.150
irgendwie. Und dann

01:33:33.150 --> 01:33:35.550
parallel mit der

01:33:35.550 --> 01:33:37.750
Video-Tutorial-Serie von Andrew Capaci

01:33:37.750 --> 01:33:38.990
ein Fast.ai.

01:33:40.050 --> 01:33:41.610
Ja. Würde ich sagen, dann ist

01:33:41.610 --> 01:33:43.550
mein Datasign schon mit der Nase

01:33:43.550 --> 01:33:44.370
ganz schön tief drin.

01:33:44.370 --> 01:33:47.390
Wenn man so ein bisschen noch Statistik macht, vielleicht dann.

01:33:47.390 --> 01:33:49.470
Oh, und dann picke ich vielleicht die andere

01:33:49.470 --> 01:33:51.510
Geschichte, die ich mir auch aufgeschrieben hatte, gleich mit.

01:33:51.510 --> 01:33:53.130
Es gibt eine super schöne

01:33:53.130 --> 01:33:55.390
Visualisierung von, wie funktionieren

01:33:55.390 --> 01:33:57.430
diese LLMs eigentlich, wo man halt sieht, wie ein

01:33:57.430 --> 01:33:59.350
Token irgendwie oben so grafisch

01:33:59.350 --> 01:34:01.370
irgendwo reinfällt und dann halt

01:34:01.370 --> 01:34:03.470
irgendwie in Embeddings umgewandelt

01:34:03.470 --> 01:34:05.430
wird und dann durch diese ganze Maschinerie durchläuft.

01:34:05.430 --> 01:34:07.450
Dann kann man auch noch auswählen, welches Modell hätte man gerne.

01:34:07.450 --> 01:34:09.910
Und wenn man das

01:34:10.010 --> 01:34:11.910
natürlich, oh, das ist aber eine beeindruckende Visualisierung

01:34:11.910 --> 01:34:13.690
und naja, das ist ja bestimmt alles irgendwie nur so,

01:34:13.690 --> 01:34:15.890
hat sich jemand halt, ein Grafiker halt hingemalt

01:34:15.890 --> 01:34:17.650
oder sowas. Nein, es ist tatsächlich, sind die

01:34:17.650 --> 01:34:19.690
echten mehr oder weniger, also gut,

01:34:19.690 --> 01:34:21.770
vielleicht nicht in jedem letzten Detail, aber es sind schon fast

01:34:21.770 --> 01:34:23.690
die, schon quasi die echten Modelle

01:34:23.690 --> 01:34:25.590
und da hat jemand sich echt Mühe gegeben

01:34:25.590 --> 01:34:27.770
und in WebAssembly die ganzen

01:34:27.770 --> 01:34:29.930
Operationen

01:34:29.930 --> 01:34:31.310
alle nachimplementiert und

01:34:31.310 --> 01:34:33.690
das ist schon großartig. Es gibt auch

01:34:33.690 --> 01:34:34.770
den Source dazu.

01:34:34.770 --> 01:34:37.470
Ja, es ist halt hauptsächlich

01:34:37.470 --> 01:34:39.710
TypeScript und WebAssembly, aber

01:34:39.970 --> 01:34:41.470
das ist aber nicht ManimaML.

01:34:41.470 --> 01:34:42.870
ManimML.

01:34:42.870 --> 01:34:45.790
Ne, wüsste ich jetzt nicht. Also, das ist halt einfach so

01:34:45.790 --> 01:34:47.830
grafisch, man sieht halt quasi

01:34:47.830 --> 01:34:49.750
wie so ein Ergebnis von

01:34:49.750 --> 01:34:51.790
so einem Modell berechnet wird, halt grafisch.

01:34:51.790 --> 01:34:52.750
Und wie heißt das?

01:34:52.750 --> 01:34:56.090
Also, ich kenne ManimML.

01:34:56.090 --> 01:34:56.950
ManimML.

01:34:56.950 --> 01:34:58.310
Da muss ich mal grad nachgucken,

01:34:58.310 --> 01:35:01.710
ob das genau so

01:35:01.710 --> 01:35:03.370
heißt.

01:35:03.370 --> 01:35:07.330
Das heißt einfach nur

01:35:07.330 --> 01:35:08.770
LLM Visualization.

01:35:08.770 --> 01:35:09.550
Ah, cool.

01:35:09.930 --> 01:35:11.450
Also, bbcroft.net

01:35:11.450 --> 01:35:13.830
Also, was man mit ManimML kann man

01:35:13.830 --> 01:35:15.590
quasi seine eigenen Sachen auch bauen, weil man

01:35:15.590 --> 01:35:17.690
da kann man sich auswählen, welche Layer man in sein

01:35:17.690 --> 01:35:19.430
Neural-Network reinsteckt und dann

01:35:19.430 --> 01:35:21.870
sowas bauen. Oh, das sieht aber auch

01:35:21.870 --> 01:35:23.810
schick aus. Ja, gut, kann man jetzt nicht sehen, wenn man

01:35:23.810 --> 01:35:25.850
es nur hört, aber... Ja, ja, Jochen hat es gerade aufgemacht

01:35:25.850 --> 01:35:27.750
auf dem Screen. Das sieht sehr nice aus.

01:35:27.750 --> 01:35:28.930
Das bitte auch einmal linken.

01:35:28.930 --> 01:35:31.510
Genau, das hätte ich dann halt auch nochmal verlinken.

01:35:31.510 --> 01:35:33.850
Ja, dann machst du ManimML direkt noch dazu.

01:35:33.850 --> 01:35:35.210
Dann haben wir beide. Okay.

01:35:35.210 --> 01:35:36.330
Mach ich dann auch.

01:35:36.330 --> 01:35:37.730
Ja.

01:35:39.890 --> 01:35:40.750
Florian, hast du auch einen Pick?

01:35:40.750 --> 01:35:44.030
Ja, ich hatte erst mal gar nichts

01:35:44.030 --> 01:35:45.830
und jetzt sind mir da gleich zwei Dinge eingefallen.

01:35:45.830 --> 01:35:46.970
Ja, sehr gut.

01:35:46.970 --> 01:35:50.390
Zum einen, als du Data Visualization

01:35:50.390 --> 01:35:51.450
erwähnt hattest,

01:35:51.450 --> 01:35:54.170
eine Webseite, die ich letztens

01:35:54.170 --> 01:35:56.050
von einem Kollegen

01:35:56.050 --> 01:35:58.470
gekriegt habe, datatowith.com,

01:35:58.470 --> 01:35:59.950
was

01:35:59.950 --> 01:36:01.990
einem so durchleitet, wenn ich eine gewisse

01:36:01.990 --> 01:36:03.870
Art von Daten habe, also

01:36:03.870 --> 01:36:05.370
jetzt irgendwie numerische Daten,

01:36:05.370 --> 01:36:07.850
zwei Variablen, ordered,

01:36:07.850 --> 01:36:09.750
was mir dann anzeigt,

01:36:09.850 --> 01:36:11.190
wie plotte ich das am schönsten.

01:36:11.190 --> 01:36:14.350
Mit dann auch gerade Links

01:36:14.350 --> 01:36:16.170
zu irgendwie Python-Example-Code

01:36:16.170 --> 01:36:17.430
und sowas. Ja, schick.

01:36:17.430 --> 01:36:19.530
Das war das eine.

01:36:19.530 --> 01:36:21.430
Das andere ist

01:36:21.430 --> 01:36:22.790
die Evol-Game.

01:36:22.790 --> 01:36:25.010
Weiß nicht, ob ihr das mitbekommen habt mit

01:36:25.010 --> 01:36:26.130
The Password Game.

01:36:26.130 --> 01:36:29.750
Eine Webseite, wo man halt ein Passwort eingeben soll

01:36:29.750 --> 01:36:31.710
und dann kommen mehr und mehr

01:36:31.710 --> 01:36:33.090
Regeln dazu, das irgendwie

01:36:33.090 --> 01:36:35.730
um es dann dann

01:36:35.730 --> 01:36:36.610
unmöglich zu machen.

01:36:36.610 --> 01:36:39.810
Und basierend darauf,

01:36:39.810 --> 01:36:42.630
Das Passwort-Game will ich auch.

01:36:42.630 --> 01:36:45.370
Und basierend darauf hat jemand halt

01:36:45.370 --> 01:36:48.090
The Evol-Game gemacht, wo man eine Python-Expression

01:36:48.090 --> 01:36:49.950
eingeben muss, die dann immer mehr und mehr

01:36:49.950 --> 01:36:51.010
Regeln folgen.

01:36:51.010 --> 01:36:53.910
Okay, interessant. Das klingt gut.

01:36:53.910 --> 01:36:58.310
The digits in your password

01:36:58.310 --> 01:36:59.730
must add up to 25.

01:36:59.730 --> 01:37:01.810
Großartig.

01:37:01.810 --> 01:37:02.910
Sehr gute Idee.

01:37:02.910 --> 01:37:06.170
Ganz so ähnlich sieht es dann auch beim Evol-Game aus.

01:37:06.170 --> 01:37:09.590
Ja, nee.

01:37:09.770 --> 01:37:10.790
Vielen Dank. Das klingt doch super.

01:37:10.790 --> 01:37:11.710
Ja.

01:37:11.710 --> 01:37:14.390
Ja.

01:37:14.390 --> 01:37:17.550
Ja, ich glaube, dann sind wir

01:37:17.550 --> 01:37:18.130
heute durch.

01:37:18.130 --> 01:37:21.450
Vielen Dank, dass du da warst, Florian. Ich fand's

01:37:21.450 --> 01:37:22.130
sehr schön.

01:37:22.130 --> 01:37:24.930
Ja, danke euch.

01:37:24.930 --> 01:37:26.410
Viele Dinge, die ich noch nicht wusste.

01:37:26.410 --> 01:37:29.650
Ja, Python ist ein ganz essentieller

01:37:29.650 --> 01:37:31.270
Teil, glaube ich, von dem, was wir so machen.

01:37:31.270 --> 01:37:33.170
Auf jeden Fall.

01:37:33.170 --> 01:37:35.150
Ja, dann danke, Florian.

01:37:35.150 --> 01:37:37.090
Bleibt uns alle gewogen. Danke, Jochen.

01:37:37.090 --> 01:37:39.730
Schreibt ein, wenn ihr wollt, wenn ihr irgendwas noch wissen

01:37:39.730 --> 01:37:41.830
wollt, Fragen habt, Anregungen, Kommentare.

01:37:41.830 --> 01:37:43.850
Vielen Dank auch von unseren lieben Hörerinnen und Hörern,

01:37:43.850 --> 01:37:45.730
die uns Fanpost schicken oder

01:37:45.730 --> 01:37:47.410
Fragen stellen und so. Das ist immer sehr nett.

01:37:47.410 --> 01:37:49.550
Hallo at pythonpodcast.de

01:37:49.550 --> 01:37:51.170
könnt ihr uns erreichen.

01:37:51.170 --> 01:37:53.570
Dann bis bald und ein

01:37:53.570 --> 01:37:55.530
gutes Jahresende, kann man ja fast schon sagen.

01:37:55.530 --> 01:37:57.510
Wir sind ja bald schon im sechsten Podcast. Ja, Jochen.

01:37:57.510 --> 01:37:59.670
Ach du jemine. Echt? Ist das schon so lang?

01:37:59.670 --> 01:37:59.990
Ja.

01:37:59.990 --> 01:38:03.490
Ui. Jetzt fühle ich mich ja noch älter als

01:38:03.490 --> 01:38:04.590
normalerweise schon fühle. Aber gut.

01:38:04.590 --> 01:38:07.630
Heißt also, die Folge muss jetzt noch

01:38:07.630 --> 01:38:09.690
dieses Jahr rauskommen. Das wird aber auch noch nicht.

01:38:09.690 --> 01:38:11.390
Ja, hier denke ich. Ja. Gut, gut.

01:38:11.390 --> 01:38:11.870
Heute Abend.

01:38:11.870 --> 01:38:15.770
Ja, schauen wir mal.

01:38:15.770 --> 01:38:16.570
Also,

01:38:16.570 --> 01:38:19.530
vielen Dank für eure Aufmerksamkeit. Ja, ebenso.

01:38:19.530 --> 01:38:21.530
Ciao, Jochen. Tschüss.

01:38:21.530 --> 01:38:22.550
Tschüss.