WEBVTT

00:00:00.000 --> 00:00:04.040
Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python Podcast, 25. Episode.

00:00:05.280 --> 00:00:09.340
Heute geht es um Patterns, Software-Patterns, Design-Patterns, Architektur-Patterns.

00:00:10.020 --> 00:00:12.200
Wir haben einen Gast dabei, der Herr Toini, hallo.

00:00:12.800 --> 00:00:13.480
Hallo immer wieder.

00:00:13.900 --> 00:00:14.220
Hallihallo.

00:00:14.460 --> 00:00:15.680
Ich bin der Dominik, Jochen ist auch da.

00:00:15.940 --> 00:00:16.320
Hoi ho.

00:00:16.600 --> 00:00:20.780
Wir sind im Wintergarten, beziehungsweise remote, wie es halt sich für die Pandemie so gehört.

00:00:21.560 --> 00:00:23.900
Wir wollten noch sagen, wenn wir aufnehmen, heute ist der 20. Oktober.

00:00:25.080 --> 00:00:25.480
2020.

00:00:25.800 --> 00:00:27.760
20, 20, 20, 20, 20.

00:00:27.760 --> 00:00:29.100
Immer noch 2020.

00:00:30.000 --> 00:00:30.200
Ja.

00:00:30.920 --> 00:00:34.060
Es zieht sich ein bisschen, finde ich, in letzter Zeit.

00:00:34.180 --> 00:00:35.960
Ich erinnere den XKACD, wo

00:00:35.960 --> 00:00:37.780
ein Zeitreiser nach 2020 kommt

00:00:37.780 --> 00:00:40.080
und fragt, welches Jahr

00:00:40.080 --> 00:00:41.660
es ist und er sagt 2020.

00:00:42.340 --> 00:00:43.400
Ja, aber das wievielte.

00:00:48.280 --> 00:00:49.820
Das ist mir auch nicht so ganz genau.

00:00:52.300 --> 00:00:52.700
Ja.

00:00:53.280 --> 00:00:55.160
Vielleicht noch ein paar News aus der Szene vorweg.

00:00:55.160 --> 00:00:55.560
Genau.

00:00:55.860 --> 00:00:59.800
Am 5. Oktober kam Python 3.9

00:00:59.800 --> 00:01:02.480
0. Oder war das am 6.?

00:01:02.480 --> 00:01:03.380
Ich weiß gar nicht mehr genau.

00:01:03.820 --> 00:01:04.820
Ich glaube an dem Montag irgendwie.

00:01:05.880 --> 00:01:06.020
Ja.

00:01:08.480 --> 00:01:10.060
Watch released on October 5th.

00:01:10.340 --> 00:01:10.860
Oh, okay.

00:01:12.900 --> 00:01:14.060
Habt ihr alles schon geupdatet?

00:01:14.640 --> 00:01:16.300
Nein. Ich habe mich diesmal nicht getraut,

00:01:16.380 --> 00:01:18.540
weil letztes Mal mir bei 3.8.0

00:01:18.540 --> 00:01:20.260
so ein paar Sachen wie Jupiter auseinander

00:01:20.260 --> 00:01:22.200
geflogen sind und ich diesmal darauf

00:01:22.200 --> 00:01:22.840
keine Lust hatte.

00:01:24.920 --> 00:01:26.320
Ich glaube, ich habe es auch noch nicht

00:01:26.320 --> 00:01:28.240
bei uns in die

00:01:28.240 --> 00:01:30.200
auswahl mit reingenommen, aber wir haben eh immer

00:01:30.200 --> 00:01:31.960
sozusagen das komplette Portfolio von allem

00:01:31.960 --> 00:01:33.200
verfügbar.

00:01:35.940 --> 00:01:37.760
Ja, ich würde gerne machen, dass bei 1 dann

00:01:37.760 --> 00:01:38.840
3, 9, 1.

00:01:39.540 --> 00:01:42.000
Ich bin tatsächlich schon quasi zumindest

00:01:42.000 --> 00:01:43.360
mit den privaten Sachen umgestiegen, aber

00:01:43.360 --> 00:01:45.960
ja, so, das wird

00:01:45.960 --> 00:01:47.620
natürlich noch ein bisschen brauchen, bis sich das komplett

00:01:47.620 --> 00:01:50.800
durchgesetzt hat,

00:01:50.840 --> 00:01:51.780
sodass man es halt auch verwenden kann.

00:01:51.820 --> 00:01:53.760
Zum Beispiel Pandas gibt es halt noch keine

00:01:53.760 --> 00:01:55.840
Binarys und da ist es natürlich

00:01:55.840 --> 00:01:57.840
ein bisschen hässlich, wenn man das irgendwie dann

00:01:57.840 --> 00:01:58.620
selber konfigurieren muss.

00:01:59.420 --> 00:02:01.280
Das heißt doch, im Bateau habe ich tatsächlich das

00:02:01.280 --> 00:02:03.500
in die Travels-Liste

00:02:03.500 --> 00:02:04.240
schon mit aufgenommen.

00:02:05.500 --> 00:02:05.980
Da kam auch

00:02:05.980 --> 00:02:09.440
jemand vorbei, der sich gleich sofort beschwert hatte,

00:02:09.560 --> 00:02:10.680
dass es unter 3.9 nicht ging,

00:02:11.480 --> 00:02:13.880
weil irgendwas ist rausgeflogen.

00:02:14.320 --> 00:02:15.420
Achso, die haben im Async

00:02:15.420 --> 00:02:17.300
irgendeine

00:02:17.300 --> 00:02:19.440
API, die deprecated war,

00:02:19.440 --> 00:02:20.560
tatsächlich gestrichen gehabt.

00:02:20.680 --> 00:02:23.060
Ich glaube, in 3.7 hatten sie irgendeine neue API,

00:02:23.240 --> 00:02:25.460
um alle Pending-Tasks abzufragen,

00:02:26.020 --> 00:02:26.680
eingeführt

00:02:26.680 --> 00:02:28.620
und die glaube ich in irgendein

00:02:28.620 --> 00:02:30.760
Untermodul verschoben oder so, statt im direkten

00:02:30.760 --> 00:02:32.900
Async-Modul. Das war was,

00:02:32.960 --> 00:02:34.680
da musste ich dann irgendwie hinterher und in 3.9 war dann

00:02:34.680 --> 00:02:36.620
irgendwie die Abletzkompatibilität von der API

00:02:36.620 --> 00:02:38.460
jetzt weg. Da

00:02:38.460 --> 00:02:39.540
flog es dann auseinander.

00:02:41.680 --> 00:02:42.680
Insofern, ja, ich habe es schon

00:02:42.680 --> 00:02:43.260
in der Hand gehabt.

00:02:44.560 --> 00:02:45.480
Was gibt es denn Neues?

00:02:47.080 --> 00:02:48.080
Ganz viele spannende Sachen.

00:02:48.360 --> 00:02:49.180
Union Operators.

00:02:50.300 --> 00:02:52.060
Was ist das? Was macht man damit?

00:02:54.780 --> 00:02:56.480
Ja, zum Beispiel ein Dictionary ist zusammen

00:02:56.680 --> 00:02:59.000
schütteln. Ja, ich glaube also wirklich

00:02:59.000 --> 00:03:01.240
mehr als

00:03:01.240 --> 00:03:02.720
das, was man vorher auch schon mit

00:03:02.720 --> 00:03:04.540
Tuple-Unpacking machen konnte. Also

00:03:04.540 --> 00:03:06.120
man schreibt halt irgendwie

00:03:06.120 --> 00:03:09.040
neuer Key, neuer Value

00:03:09.040 --> 00:03:10.580
und dann sagt dann hinten der Sternstern

00:03:10.580 --> 00:03:12.220
irgendwie das andere Dict, was man merchen will.

00:03:13.760 --> 00:03:14.820
Ich glaube, wenn man jetzt

00:03:14.820 --> 00:03:16.880
den Pipe-Operator verwendet, macht es so mehr oder weniger

00:03:16.880 --> 00:03:18.500
genau das Gleiche. Ja, aber warum?

00:03:18.940 --> 00:03:20.380
Also ich habe es nicht genau verstanden. Ich finde es irgendwie,

00:03:20.540 --> 00:03:22.680
das Erste, was ich Python so richtig hässlich fand.

00:03:22.920 --> 00:03:24.900
Naja, was fandst du hässlich?

00:03:25.100 --> 00:03:26.620
Ja, diesen Operator, diesen Pipe-Operator,

00:03:26.680 --> 00:03:28.880
stehen zu haben auf einmal für so eine Operatoren-Urgie?

00:03:29.400 --> 00:03:30.400
Ich weiß nicht.

00:03:30.540 --> 00:03:33.140
Es wäre halt Mengen-Operations-

00:03:33.140 --> 00:03:34.420
Operator an der Stelle.

00:03:35.880 --> 00:03:36.800
Es ist halt ein Oder.

00:03:37.120 --> 00:03:37.920
Ja, das passt schon.

00:03:38.700 --> 00:03:40.940
Das war ja vorher schon immer das Oder

00:03:40.940 --> 00:03:42.720
und wenn ich halt über die mengentheoretische

00:03:42.720 --> 00:03:44.600
Definition nachdenke,

00:03:44.820 --> 00:03:46.700
dann ist das halt genau das, was passiert,

00:03:46.820 --> 00:03:48.640
wenn ich halt die Oder-Verknüpfung von

00:03:48.640 --> 00:03:50.060
zwei Mengen definieren möchte.

00:03:51.040 --> 00:03:52.060
Oder gleich

00:03:52.060 --> 00:03:54.700
dieses Assignment, irgendwie ist das komisch.

00:03:55.300 --> 00:03:56.460
Naja, das ist halt so wie plusgleich

00:03:56.460 --> 00:03:57.220
oder mal gleich.

00:03:58.820 --> 00:04:00.440
Das habe ich tatsächlich in Bateau

00:04:00.440 --> 00:04:02.060
benutzt oder gleich tatsächlich.

00:04:02.200 --> 00:04:03.860
Auch Bateau hat ja so eine komische Syntax, wo wir

00:04:03.860 --> 00:04:05.480
plusgleich benutzen.

00:04:06.300 --> 00:04:08.380
Wo du so einen Baum aufbaust

00:04:08.380 --> 00:04:10.180
mit self plusgleich und dann den

00:04:10.180 --> 00:04:12.200
Kindknoten. Und da gibt es nochmal

00:04:12.200 --> 00:04:14.400
ein Overloading für die

00:04:14.400 --> 00:04:16.200
Pipe, wo man dann sozusagen

00:04:16.200 --> 00:04:17.920
eine spezielle Form von Verkettung hat.

00:04:18.360 --> 00:04:20.260
Insofern finde ich das ganz cool, dass die jetzt auch die Pipe

00:04:20.260 --> 00:04:22.120
genommen haben. Da fühle ich mich in meiner Wahl

00:04:22.120 --> 00:04:23.580
von vor sechs Jahren bestätigt.

00:04:24.820 --> 00:04:25.600
Ja, okay.

00:04:26.460 --> 00:04:43.640
Ja, also ich glaube also so, was es halt, es sieht halt, ich finde es sieht schon besser aus, als wenn man jetzt immer mit den Sternen, Sternsteinen, da muss man mal so ein bisschen nachdenken, was man jetzt eigentlich genau machen wollte, ist ein bisschen hübscher, aber ist jetzt keine so weltbewegende Änderung.

00:04:43.640 --> 00:04:48.440
und es ist vor allem, es erzeugt halt ja ein neues Dict

00:04:48.440 --> 00:04:51.260
also ganz klassisch

00:04:51.260 --> 00:04:52.660
war ja immer das Thema, dass du

00:04:52.660 --> 00:04:55.040
Dict Update sagst

00:04:55.040 --> 00:04:57.140
ja und dann macht das was anderes

00:04:57.140 --> 00:04:58.500
als man denkt, das modifiziert

00:04:58.500 --> 00:04:59.460
dein Original Dict

00:04:59.460 --> 00:05:01.640
ja

00:05:01.640 --> 00:05:01.680
ja

00:05:01.680 --> 00:05:05.740
insofern ist vielleicht ein bisschen

00:05:05.740 --> 00:05:06.640
eindeutiger, was es macht

00:05:06.640 --> 00:05:09.540
ja also mein Lieblingsfeature

00:05:09.540 --> 00:05:11.640
tatsächlich oder meine Lieblingsneuerung

00:05:11.640 --> 00:05:13.500
Meine Lieblingsneuerung ist der Packparser.

00:05:13.620 --> 00:05:14.720
Ehrlich gesagt bin ich jetzt kein

00:05:14.720 --> 00:05:17.520
Experte für so Parser-Geschichten, aber

00:05:17.520 --> 00:05:18.980
ich fand das schon eigentlich ganz

00:05:18.980 --> 00:05:21.660
nett, was man damit dann eventuell

00:05:21.660 --> 00:05:23.140
alles dann zusätzlich so machen kann.

00:05:23.920 --> 00:05:25.540
Also es hieß irgendwie so, ja,

00:05:26.300 --> 00:05:27.380
das macht dann irgendwie neue

00:05:27.380 --> 00:05:29.520
Sprachfeatures einfacher oder so. Das stimmt

00:05:29.520 --> 00:05:30.640
nicht so ganz. Also

00:05:30.640 --> 00:05:33.560
so wirklich viel einfacher

00:05:33.560 --> 00:05:35.460
wird dadurch nicht, aber es macht halt so ein paar Sachen,

00:05:35.580 --> 00:05:37.560
die bisher sehr hässlich waren. Du musst dann den Hörer noch mal

00:05:37.560 --> 00:05:39.260
kurz erklären, was überhaupt ein Packparser ist, bitte.

00:05:39.260 --> 00:05:40.860
Oh nein! Das wollte ich

00:05:40.860 --> 00:06:03.000
Das wollte ich eigentlich vermeiden. Das kann ich ehrlich gesagt nicht wirklich. Also es gibt halt diese Standard-Parser für so Programmiersprachen. Die meisten Programmiersprachen sind halt, oh je, jetzt muss ich tief in die Informatik hinabsteigen. Da gibt es halt so, Programmiersprachen sind meistens, die Grammatiken dafür sind so kontextfreie Sprachen. Also, oh je.

00:06:03.000 --> 00:06:05.000
Ja, genau.

00:06:05.000 --> 00:06:08.660
und sogar eine bestimmte

00:06:08.660 --> 00:06:11.020
Form davon,

00:06:11.300 --> 00:06:12.900
so LR1 Grammatiken oder so,

00:06:12.960 --> 00:06:13.420
das ist halt

00:06:13.420 --> 00:06:15.360
LR1

00:06:15.360 --> 00:06:17.560
Grammatik zum Beispiel.

00:06:18.660 --> 00:06:20.360
In dieser Form ist auch zum Beispiel

00:06:20.360 --> 00:06:22.620
die Java Sprachspezifikation, das ist also das erste,

00:06:22.740 --> 00:06:24.100
was ich, sollte man sich im Studium,

00:06:24.180 --> 00:06:26.600
als ich mal angefangen habe, irgendwie sollte man sich

00:06:26.600 --> 00:06:29.000
das mal kaufen. Habe ich dann gemacht, fand ich sehr langweilig,

00:06:29.060 --> 00:06:30.720
ehrlich gesagt. Das war ein sehr dickes Buch,

00:06:31.400 --> 00:06:32.160
in dem stand halt die

00:06:32.160 --> 00:06:34.720
komplette Sprache

00:06:34.720 --> 00:06:37.000
und halt Grammatik drin und da lasse ich schon so was

00:06:37.000 --> 00:06:38.880
in komische Abkürzungen und das ist halt genau die,

00:06:39.040 --> 00:06:40.580
die halt beschreibt, ja,

00:06:41.000 --> 00:06:42.980
wie die Grammatik für diese Sprache aussieht

00:06:42.980 --> 00:06:44.480
und wenn man

00:06:44.480 --> 00:06:46.840
das sozusagen in dieser Form notiert hat, dann kann man

00:06:46.840 --> 00:06:48.600
das in einen Parser-Generator werfen

00:06:48.600 --> 00:06:51.080
und dann... Der liest die Sprache

00:06:51.080 --> 00:06:51.920
und weiß, was der machen muss.

00:06:51.920 --> 00:06:54.000
Der gibt einem dann einen Parser,

00:06:54.100 --> 00:06:55.820
der genau diese Sprache akzeptiert.

00:06:57.900 --> 00:06:59.020
Und das sind dann so Dinge wie...

00:06:59.020 --> 00:07:01.500
In letzter Zeit habe ich da wenig mit zu tun gehabt.

00:07:01.780 --> 00:07:03.300
Früher ganz mehr

00:07:03.300 --> 00:07:05.240
sowas wie YAK zum Beispiel

00:07:05.240 --> 00:07:06.260
gibt es da

00:07:06.260 --> 00:07:09.360
auch so ein rekursives Akronym

00:07:09.360 --> 00:07:11.140
Justiner sagt Compiler Compiler

00:07:11.140 --> 00:07:13.920
dem kann man sowas vorwerfen

00:07:13.920 --> 00:07:15.860
und der spuckt dann halt ein Parser aus

00:07:15.860 --> 00:07:17.700
und das gab es dann noch mit Lex

00:07:17.700 --> 00:07:18.800
und Bison und

00:07:18.800 --> 00:07:21.080
ich weiß gar nicht mehr so genau

00:07:21.080 --> 00:07:24.040
und genau, damit kann man Parser generieren

00:07:24.040 --> 00:07:25.820
und die akzeptieren dann solche Sprachen

00:07:25.820 --> 00:07:27.860
und die meisten Programmiersprachen sind halt

00:07:27.860 --> 00:07:28.780
so irgendwie diese

00:07:28.780 --> 00:07:32.040
Geschmacksrichtung von kontextfreier Sprache

00:07:32.040 --> 00:07:33.600
und

00:07:33.600 --> 00:07:36.300
Python Parser war halt auch sowas

00:07:36.300 --> 00:07:38.000
aber

00:07:38.000 --> 00:07:40.460
das Problem ist, es gibt halt so ein paar

00:07:40.460 --> 00:07:42.400
Features, die passen da nicht so richtig rein

00:07:42.400 --> 00:07:44.340
oder ein paar Dinge in der Sprache

00:07:44.340 --> 00:07:46.280
die funktionieren damit halt nicht so richtig

00:07:46.280 --> 00:07:48.460
und deswegen gab es da sowieso

00:07:48.460 --> 00:07:49.660
schon immer so Ausnahmen

00:07:49.660 --> 00:07:52.580
und deswegen ist es halt bisher so ein bisschen hässlich gewesen

00:07:52.580 --> 00:07:54.520
also es gibt zum Beispiel

00:07:54.520 --> 00:07:56.560
es gibt halt, ich kriege das auch nicht alles auf die Reihe

00:07:56.560 --> 00:07:57.860
aber es gibt halt

00:07:57.860 --> 00:08:00.600
der Parser nimmt halt sozusagen den Text

00:08:00.600 --> 00:08:03.300
also irgendwie ein Python-Programm

00:08:03.300 --> 00:08:04.820
und gibt dann halt

00:08:04.820 --> 00:08:06.740
ein Abstract Syntax Tree aus

00:08:06.740 --> 00:08:08.960
und der wird dann von dem Compiler

00:08:08.960 --> 00:08:10.980
verwandelt in Bytecode

00:08:10.980 --> 00:08:13.140
oder so und da wird dann halt irgendwie interpretiert

00:08:13.140 --> 00:08:14.480
und das gibt dann halt so diverse Teile

00:08:14.480 --> 00:08:15.680
und

00:08:15.680 --> 00:08:19.100
das Problem ist irgendwie, dass manche

00:08:19.100 --> 00:08:21.100
Sachen halt

00:08:21.100 --> 00:08:23.140
verteilt sind auf unterschiedliche Teile

00:08:23.140 --> 00:08:24.580
also dass es halt nicht so ist, dass es

00:08:24.580 --> 00:08:26.800
oder der Parser bisher

00:08:26.800 --> 00:08:29.220
bestimmte Sachen halt nicht so einfach damit parsbar waren

00:08:29.220 --> 00:08:31.360
und der ist auch handgeschrieben, also das ist halt irgendwie,

00:08:31.520 --> 00:08:33.280
wenn man sich das angucken will, gibt es

00:08:33.280 --> 00:08:34.460
ein Modul, das nennt sich

00:08:34.460 --> 00:08:37.200
ast.c oder so

00:08:37.200 --> 00:08:39.200
in Python-Source-Code, das ist der

00:08:39.200 --> 00:08:41.100
alte Parser,

00:08:41.980 --> 00:08:43.180
paar tausend Zeilen handgeschriebenes

00:08:43.180 --> 00:08:45.180
c, ziemlich fies, also

00:08:45.180 --> 00:08:47.040
genau, und

00:08:47.040 --> 00:08:49.320
der ist halt nicht automatisch

00:08:49.320 --> 00:08:50.940
generiert, was halt schon mal nicht so schön ist,

00:08:51.300 --> 00:08:52.820
weil das halt dazu führt, dass er nicht so richtig

00:08:52.820 --> 00:08:55.140
konsistent ist und so und sich

00:08:55.140 --> 00:08:57.320
manchmal komisch verhält und

00:08:57.320 --> 00:09:01.480
das Problem eigentlich dabei ist, wenn man jetzt sozusagen

00:09:01.480 --> 00:09:04.860
teilweise sind halt Sachen, ich kriege das nicht mehr richtig auf die Reihe,

00:09:05.160 --> 00:09:09.680
wenn man zum Beispiel rechts neben dem Gleichheitszeichen,

00:09:09.720 --> 00:09:13.320
weil das Gleichheitszeichen ist irgendwie ein Problem und wenn man da mehrere Sachen stehen hat, also mehrere

00:09:13.320 --> 00:09:17.760
Dinge, die addiert werden oder so, dann muss das hinterher nochmal im Compiler

00:09:17.760 --> 00:09:21.460
umsortiert werden, weil der Parser noch nicht

00:09:21.460 --> 00:09:25.540
irgendwie ordentlich gemacht hat. Und das heißt, wenn man jetzt irgendwie so ein Problem hat,

00:09:25.540 --> 00:09:26.500
auch ein Syntaxproblem.

00:09:27.440 --> 00:09:29.840
Funktion A plus Funktion B

00:09:29.840 --> 00:09:31.220
rechts von einem Gleichheitszeichen,

00:09:31.720 --> 00:09:33.680
dann ist halt komplett unklar,

00:09:33.840 --> 00:09:35.460
wenn jetzt da irgendwo ein Syntaxfehler ist, wo der eigentlich

00:09:35.460 --> 00:09:36.960
passiert. Weil

00:09:36.960 --> 00:09:39.560
das ja dann schon einem erst

00:09:39.560 --> 00:09:41.280
im Compiler irgendwie um die Ohren fliegt oder so.

00:09:41.900 --> 00:09:42.840
Sodass halt

00:09:42.840 --> 00:09:45.480
der Python-Grafiker auch gar nicht

00:09:45.480 --> 00:09:47.420
sagen kann, wo der Syntaxfehler ist, was

00:09:47.420 --> 00:09:48.880
halt eventuell ein Problem sein könnte.

00:09:49.400 --> 00:09:51.380
Wenn man nicht mehr weiß, wo der Fehler ist, dann ist es halt schwer, den

00:09:51.380 --> 00:09:53.840
zu fixen. Und das sind halt so Hässlichkeiten.

00:09:53.840 --> 00:09:55.300
Sodass man halt da diese

00:09:55.300 --> 00:09:57.600
diese Überprüfung, ist das jetzt korrekter

00:09:57.600 --> 00:09:59.540
Python-Code oder nicht, halt nicht an einer Stelle

00:09:59.540 --> 00:10:01.580
passiert, sondern halt über ganz viele Teile

00:10:01.580 --> 00:10:03.620
verteilt ist, ist das halt, sind manche

00:10:03.620 --> 00:10:05.620
Sachen halt einfach total hässlich und

00:10:05.620 --> 00:10:07.540
ich habe

00:10:07.540 --> 00:10:09.120
da so ein

00:10:09.120 --> 00:10:11.540
Podcast

00:10:11.540 --> 00:10:13.000
Podcast-Init

00:10:13.000 --> 00:10:15.440
da waren die beiden, die

00:10:15.440 --> 00:10:17.640
den Pack-Baser hauptsächlich gebaut haben

00:10:17.640 --> 00:10:19.620
jetzt in Python 3.9 zu Gast

00:10:19.620 --> 00:10:21.580
und haben da halt so ein bisschen was erzählt, was sie da gemacht

00:10:21.580 --> 00:10:21.820
haben.

00:10:23.320 --> 00:10:24.860
Einer von denen meinte so, also

00:10:24.860 --> 00:10:25.420
und

00:10:25.420 --> 00:10:28.280
eine User-Anfrage war halt so,

00:10:28.340 --> 00:10:29.980
warum können wir das in RIS

00:10:29.980 --> 00:10:32.280
Context Manager mit diesem

00:10:32.280 --> 00:10:34.220
RIS-Statement nicht einfach so machen

00:10:34.220 --> 00:10:35.740
wie bei Imports oder halt mit

00:10:35.740 --> 00:10:38.360
bei Strings, dass wir da

00:10:38.360 --> 00:10:40.080
Klammern drumherum machen und dann haben wir mehrzeilige

00:10:40.080 --> 00:10:42.240
Dinger, weil mehrzeilige RIS-Statements geht halt

00:10:42.240 --> 00:10:42.700
einfach nicht.

00:10:44.380 --> 00:10:46.120
Und das hat er dann versucht umzusetzen

00:10:46.120 --> 00:10:48.120
im alten Parser und das ging halt überhaupt

00:10:48.120 --> 00:10:49.860
gar nicht. Also er hat da irgendwie

00:10:49.860 --> 00:10:51.840
wohl eine Menge Sachen probiert und es ging einfach nicht.

00:10:52.480 --> 00:10:53.680
Und er meinte so,

00:10:53.680 --> 00:11:23.660
und Jochen unterhalten sich über die Programmiersprache Python

00:11:23.680 --> 00:11:25.760
Er braucht sogar mehr RAM.

00:11:26.080 --> 00:11:27.760
Ja, genau. Also das war der Grund, warum man das

00:11:27.760 --> 00:11:29.620
früher nicht gemacht hat, weil man

00:11:29.620 --> 00:11:31.620
muss jetzt alle Tokens im Hauptspeicher halten und das

00:11:31.620 --> 00:11:33.600
war halt früher ein Problem, heute

00:11:33.600 --> 00:11:35.640
nicht mehr so. Also genau,

00:11:35.760 --> 00:11:37.380
er braucht einfach mehr RAM.

00:11:38.080 --> 00:11:39.740
Irgendwer hatte auch was

00:11:39.740 --> 00:11:41.660
erzählt von, dass sie jetzt per Default sagen,

00:11:41.780 --> 00:11:43.060
also mehr als eine Million Zeilen

00:11:43.060 --> 00:11:45.680
in eine Python-Datei wollen sie

00:11:45.680 --> 00:11:46.540
jetzt bitte nicht mehr sehen.

00:11:47.040 --> 00:11:49.400
Ja, okay, aus dem Kreise.

00:11:49.660 --> 00:11:50.960
Oh Mist, was war ich denn jetzt?

00:11:50.960 --> 00:11:53.420
Da habe ich eine ganze Firma

00:11:53.420 --> 00:11:54.220
drauf aufgebaut

00:11:54.220 --> 00:11:57.400
Ja, also

00:11:57.400 --> 00:11:59.640
von der Performance her ist kein großer

00:11:59.640 --> 00:12:01.400
Unterschied, wohl von der Laufzeit und Hauptsprecher

00:12:01.400 --> 00:12:02.840
braucht es ein bisschen mehr, aber

00:12:02.840 --> 00:12:05.780
genau, das ist das tolle Ding, was man eventuell jetzt damit machen kann

00:12:05.780 --> 00:12:09.620
Was sonst sehr schwer geworden wäre

00:12:09.620 --> 00:12:11.660
ist, da gibt es

00:12:11.660 --> 00:12:13.320
auch ein PEP jetzt, weiß ich nicht welche Nummer

00:12:13.320 --> 00:12:15.220
Pattern Matching

00:12:15.220 --> 00:12:17.340
Bin mal gespannt, ob das

00:12:17.340 --> 00:12:19.640
angenommen wird für Python 3.10

00:12:19.640 --> 00:12:22.160
dass man halt so

00:12:22.160 --> 00:12:24.440
Lisp-Style-Makros hat, beziehungsweise

00:12:24.440 --> 00:12:26.220
halt in funktionalen Programmiersprachen ist das schon länger

00:12:26.220 --> 00:12:28.200
oder das ist halt ja so eins der grundlegenden

00:12:28.200 --> 00:12:29.840
Geschichten und

00:12:29.840 --> 00:12:32.340
ja, in Python ging das halt

00:12:32.340 --> 00:12:34.000
auch vor allen Dingen wegen dem Parser

00:12:34.000 --> 00:12:36.280
bisher nicht und das

00:12:36.280 --> 00:12:38.300
geht dann eventuell und wenn man das darin hat, ist

00:12:38.300 --> 00:12:40.180
natürlich schon nett, hat man so eines der zentralen Features

00:12:40.180 --> 00:12:42.300
von funktionalen Programmiersprachen auch mit drin

00:12:42.300 --> 00:12:44.140
Was sind denn Lisp-like-Makros?

00:12:44.160 --> 00:12:46.200
Ja, das

00:12:46.200 --> 00:12:48.100
müssen wir mal irgendwann machen, wenn wir irgendwie auch

00:12:48.100 --> 00:12:49.100
so ein bisschen, so ja, noch mal funktionale Programmiersprache und und und und und und und und und und und und und und und und und und und und

00:13:18.100 --> 00:13:20.420
Ja, ein Bug ist auch schon aufgefallen wohl.

00:13:20.740 --> 00:13:22.040
Also Match war,

00:13:22.100 --> 00:13:23.880
achso, ja, vielleicht tatsächlich,

00:13:24.600 --> 00:13:25.780
das ist

00:13:25.780 --> 00:13:28.100
eine bessere Variante

00:13:28.100 --> 00:13:30.100
dessen, was sonst in anderen Sprachen das Case

00:13:30.100 --> 00:13:30.840
gewesen wäre.

00:13:32.860 --> 00:13:33.800
Nur mal so als

00:13:33.800 --> 00:13:35.940
zur groben Einordnung. Also

00:13:35.940 --> 00:13:37.980
mit dem Match geht es dann am Ende

00:13:37.980 --> 00:13:39.940
tatsächlich darum, die, wenn man sehr

00:13:39.940 --> 00:13:41.420
komplexe If-Else

00:13:41.420 --> 00:13:43.480
Zweige hat,

00:13:44.100 --> 00:13:46.020
dann kann man die damit ein bisschen hübscher abbilden.

00:13:46.020 --> 00:13:48.140
also substanziell

00:13:48.140 --> 00:13:48.480
schon

00:13:48.480 --> 00:13:51.860
Warum hat man das nicht Case genannt?

00:13:56.240 --> 00:13:58.000
Das müsste ich jetzt nachlesen

00:13:58.000 --> 00:14:00.100
Also es macht

00:14:00.100 --> 00:14:01.040
schon glaube ich noch ein bisschen mehr

00:14:01.040 --> 00:14:04.740
Ach, keine Ahnung

00:14:04.740 --> 00:14:09.780
Genau, einen Bug gab es auch schon

00:14:09.780 --> 00:14:12.000
da wird jetzt dann wahrscheinlich in 3.9.1

00:14:12.000 --> 00:14:13.740
gefixt und zwar

00:14:13.740 --> 00:14:15.960
was der alte

00:14:15.960 --> 00:14:17.960
Parser konnte und was jetzt halt mit dem neuen

00:14:17.960 --> 00:14:18.860
nicht mehr geht, ist,

00:14:20.020 --> 00:14:20.600
wenn man

00:14:20.600 --> 00:14:24.020
Tupple Unpacking, halt auch so Stern

00:14:24.020 --> 00:14:25.520
irgendwas in, with

00:14:25.520 --> 00:14:27.880
so Context Managern verwendet,

00:14:27.940 --> 00:14:29.640
dann funktioniert das nicht.

00:14:31.480 --> 00:14:31.920
Tja,

00:14:32.320 --> 00:14:34.100
aber es ist halt bisher niemandem aufgefallen, also so häufig

00:14:34.100 --> 00:14:35.460
scheint es nicht verwendet zu werden, aber

00:14:35.460 --> 00:14:37.840
das klappt schon irgendwie nicht. Achso, das ist auch vielleicht ganz

00:14:37.840 --> 00:14:39.560
interessant, also in 3.9

00:14:39.560 --> 00:14:42.000
sind beide Parser drin, man kann auch

00:14:42.000 --> 00:14:44.000
irgendwie per Kommandozeilenoptionen sagen

00:14:44.000 --> 00:14:46.200
minus x irgendwas, Old Parser oder so,

00:14:46.900 --> 00:14:48.280
verwendet doch bitte den alten, wenn man

00:14:48.280 --> 00:14:50.340
irgendwie mit dem neuen ein Problem hat. Der neue ist

00:14:50.340 --> 00:14:51.480
defaultmäßig aktiv

00:14:51.480 --> 00:14:54.380
und der alte ist aber halt

00:14:54.380 --> 00:14:55.260
noch drin und

00:14:55.260 --> 00:14:58.540
mit Python 3.10 wird es dann halt so sein,

00:14:58.640 --> 00:15:00.400
dann wird der alte Parser komplett rausfliegen und nur noch

00:15:00.400 --> 00:15:01.020
der neue drin sein.

00:15:02.540 --> 00:15:02.900
Okay.

00:15:04.120 --> 00:15:06.340
Was mit Tablet Unpacking in Context Managern, das habe ich jetzt

00:15:06.340 --> 00:15:08.260
nicht so ganz verstanden. Warum geht das nicht oder ging das

00:15:08.260 --> 00:15:10.060
vorher auch nicht? Doch, das ging vorher schon.

00:15:10.240 --> 00:15:12.180
Das hat bloß keiner gemacht. Warum auch?

00:15:13.360 --> 00:15:13.720
Aber

00:15:13.720 --> 00:15:15.200
aber ja, jetzt geht es nicht mehr.

00:15:15.500 --> 00:15:17.000
Also warum will er das denn nicht machen?

00:15:18.900 --> 00:15:20.680
Naja, also warum, also

00:15:20.680 --> 00:15:23.360
das ist halt,

00:15:23.980 --> 00:15:27.140
niemand versteht dann, was du tun willst, wahrscheinlich.

00:15:28.060 --> 00:15:31.040
Ich überlege gerade, wie die genaue Syntax ist, was da kaputt geht.

00:15:31.500 --> 00:15:32.500
Hast du den Bug irgendwo da?

00:15:34.360 --> 00:15:36.240
Naja, momentan müsste ich auch gerade suchen.

00:15:36.240 --> 00:15:44.460
Ich versuche so leise wie möglich zu tippen.

00:15:45.800 --> 00:15:46.860
Also ich kann mir schon vorstellen,

00:15:46.980 --> 00:15:48.760
warum nicht im Contact Manager einfach irgendeinen Tupel

00:15:48.760 --> 00:15:50.180
anpacken, was das doch durchhört.

00:15:51.240 --> 00:15:52.640
Nee, nee, die Frage meint

00:15:52.640 --> 00:15:54.000
wahrscheinlich oben in der Riff-Expression.

00:15:54.000 --> 00:15:55.780
Ja, in der Expression selber.

00:15:56.280 --> 00:15:58.220
Und dann irgendwas mit Tupel-Unpacking machen.

00:15:58.740 --> 00:16:00.380
Also ich sehe da echt keinen Anwendungsfall für.

00:16:00.760 --> 00:16:02.520
Und es ist glaube ich, also die haben da ja die komplette

00:16:02.520 --> 00:16:04.120
Standard-Bibliothek durchgejagt und noch viele

00:16:04.120 --> 00:16:07.820
PyPI-Fakete und sie haben es nie aufgetreten.

00:16:08.060 --> 00:16:12.360
Also das ist nicht so, dass das irgendwie dauernd gemacht wurde, sondern das hat bisher wohl noch nie jemand gemacht.

00:16:13.160 --> 00:16:16.840
Quasi. Also jedenfalls nicht ein Code, der irgendwie häufiger verwendet worden wäre.

00:16:17.960 --> 00:16:18.540
Also, ja.

00:16:19.580 --> 00:16:23.180
Es war nur, das ist halt schon mal aufgefallen, dass da ein Unterschied zwischen den beiden Passern gab.

00:16:25.700 --> 00:16:26.100
Ja.

00:16:28.140 --> 00:16:29.420
Tja, was haben wir denn noch so?

00:16:59.420 --> 00:17:29.400
und Jochen unterhalten sich über die Programmiersprache Python

00:17:29.420 --> 00:17:32.400
Ja, das ist schon hilfreich

00:17:32.400 --> 00:17:34.340
Ja, ansonsten

00:17:34.340 --> 00:17:36.920
Zeitzonen-Handling

00:17:36.920 --> 00:17:37.960
ist jetzt irgendwie mit drin

00:17:37.960 --> 00:17:40.820
Das habe ich noch nicht angeguckt

00:17:40.820 --> 00:17:42.960
weil ich bin seit irgendwie 15 Jahren

00:17:42.960 --> 00:17:44.160
mit PyTZ unterwegs

00:17:44.160 --> 00:17:47.040
und PyTZ hat halt den Vorteil

00:17:47.040 --> 00:17:48.520
das ist unabhängig, das ist halt so ein Ding

00:17:48.520 --> 00:17:51.140
die Zeitzonen-Datenbanken werden halt ständig

00:17:51.140 --> 00:17:52.780
aktualisiert und geändert

00:17:52.780 --> 00:17:54.820
und ich bin mir gerade nicht sicher

00:17:54.820 --> 00:17:55.380
haben die

00:17:55.380 --> 00:17:58.820
da irgendwie die Datenbanken mit dabei

00:17:58.820 --> 00:18:00.240
oder ist das eine API?

00:18:00.580 --> 00:18:01.900
Genau, das ist halt auch der Grund, warum

00:18:01.900 --> 00:18:05.440
im DateTime-Modul

00:18:05.440 --> 00:18:06.720
in der Standardbibliothek

00:18:06.720 --> 00:18:08.460
waren diese

00:18:08.460 --> 00:18:10.500
Zeitzonen-Datenbanken auch nie drin, wohl aber

00:18:10.500 --> 00:18:12.680
eine API dafür, wie man da seine eigene Datenbank

00:18:12.680 --> 00:18:14.560
oder sein eigenes Objekt, das halt implementiert,

00:18:14.800 --> 00:18:16.080
Zeitzonen-Objekt irgendwie

00:18:16.080 --> 00:18:18.200
reintun kann, weil sich die Leute gesagt haben,

00:18:18.260 --> 00:18:20.340
Python-Release-Zyklus, viel zu lang für diese

00:18:20.340 --> 00:18:22.300
Updates und dann wollen die Leute das mal selber machen

00:18:22.300 --> 00:18:24.860
und dann haben es die Leute natürlich nicht selber gemacht,

00:18:25.620 --> 00:18:26.700
weil keiner Bock hatte,

00:18:26.700 --> 00:18:27.660
das zu machen und

00:18:27.660 --> 00:18:27.660


00:18:27.660 --> 00:18:32.420
und ja, wie es jetzt wohl ist, ist, dass...

00:18:32.420 --> 00:18:36.500
Ja, die nehmen die System Time so, weil sie haben eine API dafür, um das reinzuziehen.

00:18:36.640 --> 00:18:40.560
Ja, und genau, auf Windows gibt es noch eine komische Geschichte,

00:18:40.860 --> 00:18:45.380
da gibt es dann ein First-Party-Package, was man dann noch installieren muss,

00:18:45.480 --> 00:18:46.600
TZ-Data oder sowas.

00:18:46.640 --> 00:18:47.360
TZ-Data, ja.

00:18:48.940 --> 00:18:51.740
Dann geht das da wohl irgendwie auch, ja.

00:18:52.660 --> 00:18:54.320
Aber genau, so ist das dann.

00:18:54.320 --> 00:18:57.060
Ja, das ist so als Fallback gedacht, für wenn das andere nicht da ist.

00:18:57.060 --> 00:18:59.180
Und die intern

00:18:59.180 --> 00:18:59.900
funktioniert das wohl

00:18:59.900 --> 00:19:02.760
mehr oder weniger genauso wie

00:19:02.760 --> 00:19:05.000
DateUtil oder sagen wir so, das ist auch

00:19:05.000 --> 00:19:06.900
also wie

00:19:06.900 --> 00:19:09.160
DateUtil das macht, also ich glaube

00:19:09.160 --> 00:19:10.620
das ist auch von dem Autor von

00:19:10.620 --> 00:19:12.600
von DateUtil irgendwie

00:19:12.600 --> 00:19:15.200
meine ich jedenfalls gehört zu haben

00:19:15.200 --> 00:19:17.160
dass der das von dem das ist und das

00:19:17.160 --> 00:19:19.020
es implementiert halt so die Kerngeschichten

00:19:19.020 --> 00:19:21.080
aber viele von den fancy Features von DateUtil

00:19:21.080 --> 00:19:22.080
sind halt nicht drin, aber

00:19:22.080 --> 00:19:24.940
so die Kerndinge, ja

00:19:24.940 --> 00:19:28.000
Ja

00:19:28.000 --> 00:19:32.080
Noch was?

00:19:32.440 --> 00:19:33.080
Noch irgendwas

00:19:33.080 --> 00:19:39.840
Naja gut, da gab es noch irgendwas mit Dekoratoren

00:19:39.840 --> 00:19:41.420
und Syntax, dass man da

00:19:41.420 --> 00:19:42.580
konnte man früher immer nur

00:19:42.580 --> 00:19:45.120
bis jetzt halt immer nur Funktionen verwenden

00:19:45.120 --> 00:19:46.820
und jetzt kann man halt auch irgendwie

00:19:46.820 --> 00:19:49.260
ein Dikt nehmen und dann eckige Klammern oder so

00:19:49.260 --> 00:19:50.580
das ging vorher auch nicht so richtig

00:19:50.580 --> 00:19:52.080
und das geht jetzt

00:19:52.080 --> 00:19:54.040
das wird wahrscheinlich auch kaum jemand machen

00:19:54.040 --> 00:19:54.700
in der Sperre.

00:19:56.000 --> 00:19:57.680
Jawohl, da kann ich mir das KMR vorstellen.

00:19:58.220 --> 00:19:59.960
Man könnte sich vorstellen, man hatte

00:19:59.960 --> 00:20:02.060
irgendwie ein Dikt von Dekoratoren oder so, wo die

00:20:02.060 --> 00:20:04.100
Values halt irgendwie Funktionen sind

00:20:04.100 --> 00:20:06.020
und dann wählt man halt das Ding aus,

00:20:06.100 --> 00:20:08.260
was man halt, und da hätte man halt

00:20:08.260 --> 00:20:10.340
bisher immer irgendwie eine Extra-Funktion

00:20:10.340 --> 00:20:11.840
haben müssen, die dann halt

00:20:11.840 --> 00:20:13.960
die richtige Funktion, innere Funktion auswählt

00:20:13.960 --> 00:20:15.100
und jetzt geht es halt direkt.

00:20:16.060 --> 00:20:16.660
Auch nicht so schlecht.

00:20:17.720 --> 00:20:19.980
Es ist ja eine Frage von, in solchen

00:20:19.980 --> 00:20:21.260
Momenten immer bei diesen

00:20:21.260 --> 00:20:23.080
syntaktischen Kleinheiten,

00:20:24.040 --> 00:20:33.220
und dann kann man ja immer dieses berühmte Dokument des PHP a fractal of bad design rausholen,

00:20:33.880 --> 00:20:37.960
dass du dich halt irgendwie darauf verlassen können möchtest, wenn gesagt wird,

00:20:38.040 --> 00:20:44.820
okay, hier hinter dem Ad kommt halt eine Expression, dann kann ich hier auch bitte alles machen, was eine Expression halt kann.

00:20:45.560 --> 00:20:50.000
Und wenn das halt nicht geht, dann steht man immer traurig da und fragt sich, was soll denn der Quatsch eigentlich.

00:20:50.000 --> 00:21:20.000
insofern, ich finde das einfach das ist halt so das Thema, wenn das auch gerade was ist, was der neue Parser vielleicht besser unterstützt dann all for it Was ist PHP a fractal of bad design? Also, um nicht auf anderen Sprachen rumzuhauen gibt es aber ein wirklich berühmtes Dokument zum Thema, warum PHP so ein massives Problem im Sprachdesign hat und da gibt es in dieser Blogpost, der ist jetzt auch

00:21:20.000 --> 00:21:22.140
schon 10 Jahre alt oder so. 2012.

00:21:23.520 --> 00:21:24.260
8 Jahre.

00:21:25.920 --> 00:21:26.360
Und

00:21:26.360 --> 00:21:28.340
da geht es sozusagen darum,

00:21:28.480 --> 00:21:30.200
dass diese Herangehensweise

00:21:30.200 --> 00:21:32.180
des Sprachdesigns, und da ist Python ja

00:21:32.180 --> 00:21:33.980
schon lange ein Vorreiter gewesen, dass es halt eine

00:21:33.980 --> 00:21:36.300
explizite Sprachdefinition gibt,

00:21:36.400 --> 00:21:38.020
aus der dann halt das C-Python

00:21:38.020 --> 00:21:39.900
nur in Anführungszeichen

00:21:39.900 --> 00:21:41.320
die eine Implementation ist.

00:21:41.480 --> 00:21:43.300
Und es ist klar, es kann auch andere

00:21:43.300 --> 00:21:44.480
Implementationen geben.

00:21:45.800 --> 00:21:47.820
Und hier

00:21:47.820 --> 00:21:49.520
nämlich an mindestens ein Thema

00:21:49.520 --> 00:22:16.500
und die Funktionen, die er in den Parseur integriert hat, mit einem Variablen-Namen aufgerufen werden, aber niemals mit einer Expression, wo du dann von dem Ergebnis den Typen haben möchtest.

00:22:16.500 --> 00:22:20.100
weil halt jemand das in den Parser so reingestrickt hat

00:22:20.100 --> 00:22:24.100
und dieser Artikel geht das sozusagen in

00:22:24.100 --> 00:22:29.120
arg detaillierter Form durch und nimmt da irgendwie tausend von den Sachen auseinander

00:22:29.120 --> 00:22:34.900
und sagt halt hier, was willst du jetzt noch sagen, wenn du irgendwie nur noch von einem zum anderen stolperst dabei

00:22:34.900 --> 00:22:38.740
ja, der wäre jetzt mal ganz interessant zu lesen

00:22:38.740 --> 00:22:42.500
zum Thema irgendwie ein bisschen analytisch auseinander genommen

00:22:42.500 --> 00:22:45.140
was das liebe PHP da so ein bisschen

00:22:45.140 --> 00:22:47.400
auf die schiefe Bahn geraten lässt

00:22:47.400 --> 00:22:49.580
Ja, müssen wir mal in die Shownotes packen

00:22:49.580 --> 00:22:51.560
Ja

00:22:51.560 --> 00:22:53.620
III.II

00:22:53.620 --> 00:22:54.200
oder sowas

00:22:54.200 --> 00:22:57.700
Ja

00:22:57.700 --> 00:22:59.800
aber ich glaube

00:22:59.800 --> 00:23:01.680
das war es dann auch schon mehr oder

00:23:01.680 --> 00:23:02.160
weniger, ne?

00:23:02.360 --> 00:23:05.020
Ich glaube sonst war da eigentlich nichts drin

00:23:05.020 --> 00:23:07.100
Ja, ich glaube irgendwie noch was zu typen oder sowas

00:23:07.100 --> 00:23:09.160
Oh ja, stimmt, man kann jetzt irgendwie

00:23:09.160 --> 00:23:10.760
man muss nicht mehr

00:23:10.760 --> 00:23:12.680
diese List mit Großbuchstaben

00:23:12.680 --> 00:23:14.140
vom Typing importieren.

00:23:14.960 --> 00:23:16.320
Wahrscheinlich war das halt auch so gedacht,

00:23:16.500 --> 00:23:19.080
wer weiß, wie lange, ob die Leute das gut finden

00:23:19.080 --> 00:23:20.780
mit dem Typing, Typings und so.

00:23:22.460 --> 00:23:23.020
Nehmen wir mal

00:23:23.020 --> 00:23:25.080
nicht, irgendwie machen wir nicht den Aufwand,

00:23:25.180 --> 00:23:26.380
das direkt so zu ändern.

00:23:26.660 --> 00:23:28.420
Und jetzt muss man das halt nicht mehr aus Typing

00:23:28.420 --> 00:23:29.500
irgendwie

00:23:29.500 --> 00:23:32.560
List mit großem L importieren, sondern kann halt

00:23:32.560 --> 00:23:34.660
die Build-ins verwenden und das funktioniert

00:23:34.660 --> 00:23:35.740
dann halt auch in den Typings.

00:23:37.640 --> 00:23:39.000
Genau, das ist ganz nett.

00:23:39.360 --> 00:23:39.880
Das macht es ein bisschen

00:23:39.880 --> 00:23:43.120
einfacher das zu schreiben und muss nicht mal nachgucken, welche Impost das jetzt waren.

00:23:44.400 --> 00:23:48.460
Ja, was steht an Veranstaltungen an?

00:23:48.900 --> 00:23:49.580
Habt ihr irgendwelche?

00:23:49.600 --> 00:23:52.280
Oh, hab ich jetzt dummerweise gar nicht so richtig nachgeschaut.

00:23:52.560 --> 00:23:53.940
Die DjangoCon ist gerade vorbei.

00:23:54.460 --> 00:23:56.020
Ja, gab es eigentlich die PyCon auch jetzt?

00:23:57.260 --> 00:24:01.500
Oder war die PyCon dieses Jahr virtuell? Ich weiß gar nicht.

00:24:02.080 --> 00:24:03.140
Welche meinst du, die deutsche?

00:24:03.140 --> 00:24:03.880
Ja, die G.

00:24:04.980 --> 00:24:06.960
Ne, die haben wir tatsächlich verschoben.

00:24:06.960 --> 00:24:08.840
Also wir hatten relativ

00:24:08.840 --> 00:24:10.860
zeitig im Jahr mit den, also es wäre

00:24:10.860 --> 00:24:12.980
jetzt wieder in Berlin gewesen. Genau, letzte Woche

00:24:12.980 --> 00:24:13.700
war es gewesen eigentlich.

00:24:14.480 --> 00:24:17.000
Genau, und wir haben aber relativ frühzeitig

00:24:17.000 --> 00:24:19.080
mit dem Veranstaltungsort

00:24:19.080 --> 00:24:20.460
wie Wärm gewesen im

00:24:20.460 --> 00:24:23.000
Haus des, nicht Haus des Lehrers, hier daneben

00:24:23.000 --> 00:24:23.320
an.

00:24:28.560 --> 00:24:30.120
In Berlin? Genau.

00:24:30.760 --> 00:24:32.600
Ach, wie heißt denn das noch? Da wo immer der

00:24:32.600 --> 00:24:35.060
Zivilkongress war. Da wo immer der Kongress war, genau.

00:24:35.840 --> 00:24:36.600
Dieses UFO.

00:24:36.960 --> 00:25:06.940
Ja, da wären wir gewesen eigentlich und wir haben mit denen dann halt, das war halt so ein bisschen schwierig, weil im Januar ja wirklich, im Februar, März war das, März, März, nicht klar war, wie wird denn das jetzt sich über das Jahr eigentlich entwickeln und tatsächlich jetzt sehen wir ja gerade auch, dass die Zahlen schon wieder schwierig sind und Massenveranstaltungen sind ja eh abgesagt bis mindestens Ende 2020 und wir hätten gerechnet, also in einem regulären Jahr wäre unsere Hochrechnung glaube ich bei knapp 2.000 Euro,

00:25:36.960 --> 00:25:39.080
22 schon rausgehandelt. Die haben ja auch das Problem.

00:25:39.580 --> 00:25:41.040
Auf der einen Seite müssen sie irgendwie sehen, wo sie

00:25:41.040 --> 00:25:43.080
bleiben und auf der anderen Seite wollen sich natürlich auch nicht

00:25:43.080 --> 00:25:44.660
alle Leute verbrennen, die eigentlich jetzt

00:25:44.660 --> 00:25:46.800
regelmäßig Veranstaltungen mit ihnen machen.

00:25:47.640 --> 00:25:49.120
Ich bin ein bisschen froh, dass wir halt jetzt

00:25:49.120 --> 00:25:51.060
irgendwie planmäßig schon für Berlin

00:25:51.060 --> 00:25:52.860
geplant hatten und nicht für

00:25:52.860 --> 00:25:54.180
Hinterpose Muckel,

00:25:54.960 --> 00:25:56.900
um dann sagen zu müssen, so auf die nächsten

00:25:56.900 --> 00:25:59.020
x Jahre müssen wir nach Hinterpose Muckel

00:25:59.020 --> 00:26:00.480
ansonsten

00:26:00.480 --> 00:26:03.020
pleite,

00:26:03.140 --> 00:26:04.680
wären wir nicht pleite, aber

00:26:04.680 --> 00:26:06.900
ansonsten müssen

00:26:36.900 --> 00:26:38.740
im November.

00:26:39.120 --> 00:26:41.120
Da gehen demnächst noch Einladungen raus,

00:26:41.560 --> 00:26:43.440
wer beim Python-Verband Mitglied werden will.

00:26:43.880 --> 00:26:44.220
Stimmt.

00:26:44.460 --> 00:26:47.560
Dafür muss er tatsächlich noch mal kurz Werbung machen.

00:26:48.360 --> 00:26:49.420
Die Webseite kurz nennen.

00:26:50.320 --> 00:26:51.800
Genau, das wäre der

00:26:51.800 --> 00:26:53.620
python-verband.org

00:26:53.620 --> 00:26:55.780
der Python Software Verband

00:26:55.780 --> 00:26:57.380
als die deutsche Interessenvorredung.

00:26:58.680 --> 00:26:59.740
Und eine unserer

00:26:59.740 --> 00:27:01.400
Hauptaktionen, das war dieses Jahr

00:27:01.400 --> 00:27:02.460
leider auch ein bisschen

00:27:02.460 --> 00:27:04.980
wenig durch Corona,

00:27:04.980 --> 00:27:09.760
und was wir in der Webseite sehen, ist, dass wir alle möglichen Community-Aktionen fördern.

00:27:10.680 --> 00:27:13.080
Sowohl organisatorisch als auch mit Geld.

00:27:13.220 --> 00:27:17.120
Das heißt, wir verstehen uns da ein bisschen als eine Drehscheibe.

00:27:17.920 --> 00:27:21.640
Python selber ist ja gut bekannt, aber was wir stark unterstützen wollen,

00:27:21.760 --> 00:27:25.780
ist halt Python noch in Communities zu tragen, die es vielleicht nicht so kennen

00:27:25.780 --> 00:27:27.840
und aber auch Veranstaltungen zu fördern.

00:27:27.940 --> 00:27:30.780
Das heißt, man kann da auf der Webseite unser Förderprogramm nachschlagen

00:27:30.780 --> 00:27:35.280
und dann kann man sich relativ unkompliziert Geld für Ideen abholen,

00:27:35.340 --> 00:27:39.780
die man mal mit, wie man Python an andere Leute ranbringen will, mal was coden möchte, etc.

00:27:41.240 --> 00:27:41.680
Genau.

00:27:42.560 --> 00:27:48.140
Und im Corona-Jahr war es jetzt auch so, dass wir tatsächlich ein, zwei schon länger bekannte Partner,

00:27:49.420 --> 00:27:52.040
da gibt es die TechKids zum Beispiel im Schwäbischen,

00:27:52.640 --> 00:27:55.940
die haben jetzt auch ganz schön duttel gelitten, weil denen die ganzen Veranstaltungen weggebrochen sind,

00:27:56.020 --> 00:27:59.480
mit denen sie normalerweise dann ja auch wieder Teilnahmegebühren reinholen

00:27:59.480 --> 00:28:01.580
und haben da jetzt dieses Jahr im Fördertopf

00:28:01.580 --> 00:28:03.480
tatsächlich dann auch eher mal großzügig

00:28:03.480 --> 00:28:05.460
gesagt, okay, wir sponsern euch jetzt auch mal, wenn gerade

00:28:05.460 --> 00:28:07.540
nichts los ist, damit das jetzt hier

00:28:07.540 --> 00:28:09.500
über die Corona-Zeit

00:28:09.500 --> 00:28:11.420
nicht alles zerbricht einfach, was die Leute

00:28:11.420 --> 00:28:12.120
aufgebaut haben.

00:28:13.440 --> 00:28:15.360
Ja, das ist tatsächlich viel

00:28:15.360 --> 00:28:16.760
Ort sein, größeres Problem, ja.

00:28:19.820 --> 00:28:20.460
Tja, ja.

00:28:21.240 --> 00:28:23.240
Sonst ist dann demnächst Weihnachten. Ich habe heute die erste

00:28:23.240 --> 00:28:24.620
Weihnachtswärmung gekriegt.

00:28:25.060 --> 00:28:25.960
Ja, tatsächlich.

00:28:25.960 --> 00:28:26.780
Weihnachtswünsche.

00:28:26.780 --> 00:28:31.600
Ja, geht schnell vorbei mit so einer Pandemie

00:28:31.600 --> 00:28:32.800
Ja

00:28:32.800 --> 00:28:35.800
So oder so

00:28:35.800 --> 00:28:37.580
Ja, also genau

00:28:37.580 --> 00:28:39.380
Ich weiß nur, EuroPython

00:28:39.380 --> 00:28:41.080
war jetzt auch vor kurz

00:28:41.080 --> 00:28:43.100
Die Vorträge sind irgendwie da

00:28:43.100 --> 00:28:45.660
und DjangoCon, das wollte ich mir auf jeden Fall

00:28:45.660 --> 00:28:47.520
angucken, aber habe ich noch nicht geschafft

00:28:47.520 --> 00:28:49.120
Gibt es auch die ganzen Vorträge

00:28:49.120 --> 00:28:51.560
online und was jetzt in Zukunft

00:28:51.560 --> 00:28:53.540
kommt, weiß ich gar nicht, weil ich es nicht

00:28:53.540 --> 00:28:54.240
nachgeguckt habe

00:28:54.240 --> 00:28:57.000
Ja, wir verpassen übrigens gerade wieder das Django Meetup Cologne.

00:28:57.280 --> 00:28:59.060
Ja, ich weiß, aber das ist halt dann blöd.

00:29:01.000 --> 00:29:03.980
Die Frostcon war auch noch, das ist jetzt auch so fünf, sechs Wochen her, glaube ich.

00:29:04.160 --> 00:29:09.020
Da hat es ein bisschen gedauert, die haben jetzt auch erst vor, glaube ich, zwei, drei Wochen dann die Videos online gehabt.

00:29:11.420 --> 00:29:16.840
Es gibt, glaube ich, noch wieder so eine neue Anmeldung für das nächste Jahr, die 21, die auch online statt sein wird.

00:29:16.940 --> 00:29:17.920
Äh, Forstdem, diesmal.

00:29:18.480 --> 00:29:21.540
Forstdem, achso, das ist dann Februar, Januar, Februar, die Forstdem.

00:29:21.540 --> 00:29:21.740
Genau.

00:29:22.100 --> 00:29:23.200
Nee, ich meinte die Frostcon.

00:29:23.200 --> 00:29:24.740
Genau, die ist normalerweise

00:29:24.740 --> 00:29:26.200
Sankt Augustin

00:29:26.200 --> 00:29:27.560
Genau, ja

00:29:27.560 --> 00:29:31.140
Ja, ansonsten

00:29:31.140 --> 00:29:33.340
was mir noch so eingefallen ist, was jetzt geht

00:29:33.340 --> 00:29:34.340
was früher nicht ging

00:29:34.340 --> 00:29:37.520
iSort und Black sind kompatibel

00:29:37.520 --> 00:29:39.080
Ja

00:29:39.080 --> 00:29:40.700
das ist auch nett

00:29:40.700 --> 00:29:43.040
Wie kam es?

00:29:43.960 --> 00:29:45.640
Ich weiß es nicht genau

00:29:45.640 --> 00:29:46.220
also

00:29:46.220 --> 00:29:49.540
mit irgendeinem

00:29:49.540 --> 00:29:51.060
Update von iSort ist das jetzt

00:29:51.060 --> 00:29:54.060
und das war dann irgendwie erledigt.

00:29:54.060 --> 00:30:06.883
Also iSort hat was gemacht damit Black nicht mehr dazwischen punktet Ja irgendwie so genau und ja jetzt geht es halt man kann es halt beides verwenden und hat dann da kein nicht mehr so

00:30:06.883 --> 00:30:08.623
dass das eine immer die Sachen vom anderen umsortiert

00:30:08.623 --> 00:30:10.722
was ja irgendwie ein bisschen doof ist. Jetzt müsste man das nur noch in

00:30:10.722 --> 00:30:12.802
PyProjectHumil konfigurierbar machen, genau wie

00:30:12.802 --> 00:30:13.503
PyTest und

00:30:13.503 --> 00:30:16.503
Lake8 und dann... PyTest ist das?

00:30:17.743 --> 00:30:18.403
Ist das schon?

00:30:18.663 --> 00:30:20.222
Ja, aber mit so einem komischen

00:30:20.222 --> 00:30:22.842
Ja gut, der Key

00:30:22.842 --> 00:30:24.342
ist so ein bisschen komisch. Genau, PyTest

00:30:24.342 --> 00:30:26.182
Ini Options oder so so ein Quatsch.

00:30:27.543 --> 00:30:27.722
Ja.

00:30:29.263 --> 00:30:30.403
Wobei ich sagen muss,

00:30:30.482 --> 00:30:32.342
wir haben jetzt tatsächlich Black an ein paar

00:30:32.342 --> 00:30:33.403
Stellen wieder zurückgebaut

00:30:33.403 --> 00:30:36.283
und ich breche noch eine Lanze für alle

00:30:36.283 --> 00:30:38.202
Leute, die sozusagen neben Schwarz

00:30:38.202 --> 00:30:39.362
noch ein bisschen Grau haben wollen.

00:30:40.263 --> 00:30:40.482
Ja.

00:30:41.602 --> 00:30:43.883
Und empfehlen mal noch ins Japf reinzuschauen.

00:30:44.003 --> 00:30:44.743
Japf, okay.

00:30:45.822 --> 00:30:48.263
Ja, Black wird auch ein Problem kriegen.

00:30:48.562 --> 00:30:49.663
Black verwendet auch den

00:30:49.663 --> 00:30:50.942
alten Parser

00:30:50.942 --> 00:30:54.222
und spart es uns ab Python 3.10,

00:30:54.222 --> 00:30:55.023
und wird es dann halt

00:30:55.023 --> 00:30:58.802
einfallen lassen, weil das geht dann nicht mehr.

00:31:01.923 --> 00:31:03.403
Kannst du kurz was zu JAPF noch sagen?

00:31:04.342 --> 00:31:05.602
Ja, JAPF ist so ein,

00:31:05.883 --> 00:31:07.542
wir waren ja vorhin schon beim JAK,

00:31:08.503 --> 00:31:10.442
der Yet Another Compiler Compiler

00:31:10.442 --> 00:31:12.623
und JAPF ist der Yet Another Python

00:31:12.623 --> 00:31:14.263
Formatter und

00:31:14.263 --> 00:31:16.582
die haben sich tatsächlich eher auf die Fahnen geschrieben,

00:31:16.802 --> 00:31:17.423
dass das Ding ein bisschen

00:31:17.423 --> 00:31:19.423
konfigurierbarer ist.

00:31:19.423 --> 00:31:21.263
Auch mit einer JAPF-Ignore, ich hab's gerade gesehen.

00:31:21.263 --> 00:31:23.523
und

00:31:23.523 --> 00:31:25.602
der erzeugt für mich,

00:31:25.822 --> 00:31:27.763
finde ich, deutlich lesbareren

00:31:27.763 --> 00:31:29.342
Code. Also das ist die,

00:31:29.702 --> 00:31:31.403
ich komme persönlich mit der

00:31:31.403 --> 00:31:33.763
Blackformatierung an vielen Stellen so richtig

00:31:33.763 --> 00:31:35.743
gar nicht klar und

00:31:35.743 --> 00:31:36.942
finde sie einfach

00:31:36.942 --> 00:31:39.562
urpot hässlich. Ich fand sie auch sehr

00:31:39.562 --> 00:31:41.023
agil, aber Jochen hat sie mir immer aufgezogen.

00:31:41.802 --> 00:31:42.202
Ja, sorry.

00:31:43.123 --> 00:31:45.822
Also ich unterstütze volle Kanne

00:31:45.822 --> 00:31:47.163
das Thema, einen

00:31:47.163 --> 00:31:48.743
Autoformatter einzusetzen,

00:31:48.743 --> 00:31:52.602
Aber ich finde, Beck ist halt nicht der weiße Westerfluss

00:31:52.602 --> 00:31:55.842
Ja, das mag, also ich verstehe das durchaus

00:31:55.842 --> 00:31:57.923
Ich finde auch, ich habe so ein bisschen Schwierigkeiten mit den

00:31:57.923 --> 00:32:00.263
Anführungszeichen, ich habe auch vorher immer Single-Codes

00:32:00.263 --> 00:32:01.542
verwendet und da so, ah

00:32:01.542 --> 00:32:04.202
das ist schon so ein bisschen, auf der anderen Seite würde ich sagen, naja gut

00:32:04.202 --> 00:32:04.982
also

00:32:04.982 --> 00:32:08.302
selbst wenn man es nicht so hübsch

00:32:08.302 --> 00:32:08.883
empfindet

00:32:08.883 --> 00:32:12.042
wenn alle den gleichen Autoformatter verwenden

00:32:12.042 --> 00:32:14.023
ist das ein so viel größerer Gewinn

00:32:14.023 --> 00:32:15.982
als, dass ich dann sage

00:32:15.982 --> 00:32:18.023
nur gut, dann gebe ich dafür die persönlichen

00:32:18.023 --> 00:32:20.042
Referenzen auf. Aber ja, ich kann auch

00:32:20.042 --> 00:32:21.523
verstehen, dass man das...

00:32:21.523 --> 00:32:23.883
Weil mein Streit sozusagen schon

00:32:23.883 --> 00:32:25.962
über das, was ich als persönliche Präferenz

00:32:25.962 --> 00:32:28.143
empfinde, rausgeht,

00:32:28.243 --> 00:32:30.243
weil es verletzt mein ästhetisches

00:32:30.243 --> 00:32:32.123
Gefühl so, dass ich wirklich daneben

00:32:32.123 --> 00:32:33.802
stehe und sage, nee, das ist

00:32:33.802 --> 00:32:35.763
volle Kanne gegen

00:32:35.763 --> 00:32:38.202
die Designziele von Python

00:32:38.202 --> 00:32:38.842
als Sprache.

00:32:40.783 --> 00:32:41.342
Ja.

00:32:41.682 --> 00:32:43.942
Also das ganze Thema, dass die Indentation mir Dinge

00:32:43.942 --> 00:32:45.883
sagt und dann irgendwie

00:32:45.883 --> 00:32:48.003
über x Dutzend Zeilen hinweg wieder schließende

00:32:48.003 --> 00:32:52.023
Klammerorgien zu sehen, dafür brauche ich kein Python. Also dann brauche ich kein Python,

00:32:52.102 --> 00:32:52.903
kann ich da was Skript schreiben.

00:32:56.102 --> 00:32:59.903
Ich verstehe ja, warum das passiert.

00:33:00.442 --> 00:33:03.542
Sie versuchen ja eine Formatierung zu machen,

00:33:03.822 --> 00:33:07.942
die möglichst wenig Diff erzeugt. Wobei ich das bisher

00:33:07.942 --> 00:33:11.942
auch nicht gesehen habe. Da hätte ich gerne mal tatsächlich noch eine

00:33:11.942 --> 00:33:15.923
Metrik gesehen. Und ich muss aber sagen, das verletzt dann so ganz

00:33:45.923 --> 00:33:48.023
für mich jetzt halt an und wir haben jetzt tatsächlich

00:33:48.023 --> 00:33:49.722
in einem Projekt, einem größeren Projekt,

00:33:49.822 --> 00:33:51.942
das eben nochmal umgestellt von Black auf einen

00:33:51.942 --> 00:33:53.182
anderen Formatter. Auf Japf.

00:33:53.842 --> 00:33:55.982
Auf Japf halt mit entsprechenden anderen Optionen

00:33:56.623 --> 00:33:57.082
und

00:33:57.082 --> 00:33:59.923
siehe da, plötzlich hat man wieder so ein, ah stimmt,

00:34:00.023 --> 00:34:01.643
so muss das aussehen, danke, das ist Python.

00:34:02.462 --> 00:34:03.923
Kannst du dafür mal die

00:34:03.923 --> 00:34:05.883
Config irgendwie teilen

00:34:05.883 --> 00:34:06.783
mit uns in den Show Notes?

00:34:07.503 --> 00:34:09.683
Na klar. Das wäre super, weil das da finde ich

00:34:09.683 --> 00:34:11.502
sehr spannend, weil ich finde Black auch

00:34:11.502 --> 00:34:13.723
mega ultra hässlich und genau das, was du sagtest,

00:34:13.823 --> 00:34:15.782
also ein paar Sachen, wo ich dachte, wieso macht das

00:34:15.782 --> 00:34:16.802
und das ist auch eklig.

00:34:18.042 --> 00:34:19.343
Ja, naja, gut.

00:34:19.703 --> 00:34:22.423
Ja, ist schon

00:34:22.423 --> 00:34:24.243
was dran. Dazu fällt mir gerade noch ein,

00:34:24.302 --> 00:34:26.183
ich habe letztens einen Podcast gehört,

00:34:26.502 --> 00:34:27.782
also ich höre den ab und zu,

00:34:28.982 --> 00:34:30.302
gefällt mir eigentlich, also mir

00:34:30.302 --> 00:34:32.302
gefallen ja auch so Formate, die so ultra lang sind und das

00:34:32.302 --> 00:34:33.762
ist halt auch so einer schön lang,

00:34:34.762 --> 00:34:36.323
der heißt irgendwie Lex Friedman

00:34:36.323 --> 00:34:38.302
und der spricht so mit

00:34:38.302 --> 00:34:39.463
allen möglichen Leuten und halt

00:34:39.463 --> 00:34:41.863
darunter sind halt auch viele der so

00:34:41.863 --> 00:34:42.443
Korriphäen.

00:34:42.443 --> 00:34:45.282
zum Beispiel hatte er letztens

00:34:45.282 --> 00:34:47.102
ein Interview mit

00:34:47.102 --> 00:34:48.042
James Gosling

00:34:48.042 --> 00:34:49.643
zu dem

00:34:49.643 --> 00:34:52.982
quasi Entwickler

00:34:52.982 --> 00:34:54.262
von Java

00:34:54.262 --> 00:34:57.362
und das fand ich

00:34:57.362 --> 00:34:58.002
ganz interessant

00:34:58.002 --> 00:35:01.223
und der erzählte dann halt

00:35:01.223 --> 00:35:02.822
auch so, ja also

00:35:02.822 --> 00:35:04.502
was ihn dann dazu gebracht hat, Java

00:35:04.502 --> 00:35:07.542
sich auszudenken war halt

00:35:07.542 --> 00:35:09.342
seine lange Erfahrung mit C

00:35:09.342 --> 00:35:11.062
auch sowas was ich nicht wusste, der hat

00:35:11.062 --> 00:35:12.683
und Emex irgendwie geschrieben

00:35:12.683 --> 00:35:14.282
in C oder die erste

00:35:14.282 --> 00:35:15.883
ordentliche Version von Emex

00:35:15.883 --> 00:35:18.723
und stand dann irgendwann vor der Entscheidung, okay, ich mache

00:35:18.723 --> 00:35:20.262
jetzt entweder den Rest meines Lebens Emex

00:35:20.262 --> 00:35:22.683
oder halt nochmal was anderes und dann

00:35:22.683 --> 00:35:24.602
dachte ich so, naja, Emex, so geil ist es dann, also

00:35:24.602 --> 00:35:25.862
weiß nicht, muss auch nicht sein.

00:35:26.362 --> 00:35:28.683
Dann hat er lieber was anderes gemacht und das abgegeben irgendwie.

00:35:29.762 --> 00:35:30.842
Also Emex und Java

00:35:30.842 --> 00:35:31.883
sind eng verwandt, interessant.

00:35:32.383 --> 00:35:33.683
Naja, also

00:35:33.683 --> 00:35:35.243
in gewisser Weise.

00:35:36.243 --> 00:35:38.163
Aber er hat halt auf jeden Fall sehr, sehr viel C geschrieben.

00:35:38.163 --> 00:35:39.663
Die ungleichen Zwillinge.

00:35:39.663 --> 00:35:41.302
und dann auch

00:35:41.302 --> 00:35:43.562
größeren Projekten und dann sind

00:35:43.562 --> 00:35:45.342
ihm halt so Dinge aufgefallen, die immer wieder schief gehen

00:35:45.342 --> 00:35:47.362
in C und dann Java war halt sozusagen der Ansatz

00:35:47.362 --> 00:35:49.623
also mit diesen großen Fehlerklassen

00:35:49.623 --> 00:35:51.463
die halt C immer wieder

00:35:51.463 --> 00:35:52.822
ganz böse Probleme machen

00:35:52.822 --> 00:35:55.703
aufzuräumen und das ist ja auch dann irgendwie gelungen

00:35:55.703 --> 00:35:57.562
aber

00:35:57.562 --> 00:35:59.423
der sagte dann etwas, als es

00:35:59.423 --> 00:36:01.082
darum ging, wie das dann

00:36:01.082 --> 00:36:02.403
so ästhetisch aussieht

00:36:02.403 --> 00:36:03.943
daher die

00:36:03.943 --> 00:36:07.102
Anknüpfung sozusagen

00:36:07.102 --> 00:36:09.163
und er meinte so, ja, also wenn ich irgendwie

00:36:09.163 --> 00:36:11.143
Code lese, es gibt ja immer so Leute, die sagen dann so

00:36:11.143 --> 00:36:12.982
oh, ich finde das ästhetisch ist aber nicht so

00:36:12.982 --> 00:36:14.802
hm, gefällt mir nicht so richtig

00:36:14.802 --> 00:36:16.963
und er so, mir war das immer alles total egal

00:36:16.963 --> 00:36:19.223
ich habe da nie den Code gesehen

00:36:19.223 --> 00:36:21.102
wenn ich irgendwie so eine Funktion angucke

00:36:21.102 --> 00:36:23.203
dann sehe ich immer nur so, dann habe ich da

00:36:23.203 --> 00:36:25.322
so eine visuelle, so eine Bildvorstellung von

00:36:25.322 --> 00:36:26.842
so wie so Zahnräder von einer Maschine

00:36:26.842 --> 00:36:28.982
und dann sehe ich, ob das das Richtige tut oder nicht

00:36:28.982 --> 00:36:31.243
und wie die Syntax von der Sprache ist und wie die

00:36:31.243 --> 00:36:33.262
Sprache aussieht, das sehe ich gar nicht

00:36:33.262 --> 00:36:34.203
das ist mir auch total egal

00:36:34.203 --> 00:36:36.562
und dann dachte ich so, okay

00:36:36.562 --> 00:36:38.342
Ja, das erklärt natürlich einiges.

00:36:39.042 --> 00:36:39.223
Aber

00:36:39.223 --> 00:36:41.822
das ist aber halt, da ist er halt noch

00:36:41.822 --> 00:36:44.562
auch schwierigen Positionen, weil er hat den Quatsch halt erfunden

00:36:44.562 --> 00:36:46.322
und

00:36:46.322 --> 00:36:48.203
mir geht es halt auch so, wenn ich irgendwelche

00:36:48.203 --> 00:36:49.502
Tools baue und erfinde,

00:36:50.282 --> 00:36:52.322
dann sehe ich da, wenn jemand die Tools

00:36:52.322 --> 00:36:54.203
verwendet, halt auch mit einem Schlag die

00:36:54.203 --> 00:36:56.203
Zahnräder. Das ist aber halt

00:36:56.203 --> 00:36:58.163
kognitiv ein völlig anderer Prozess, als

00:36:58.163 --> 00:36:59.802
wenn ich das halt nicht erfunden habe

00:36:59.802 --> 00:37:02.062
und ich das

00:37:02.062 --> 00:37:04.062
verarbeiten muss, was da steht. Und das ist

00:37:04.062 --> 00:37:05.982
sozusagen, und da gibt es, jetzt habe ich

00:37:05.982 --> 00:37:35.963
und die Programmiersprache Python

00:37:35.982 --> 00:37:37.903
oder vielleicht sind unterschiedliche Leute da halt auch

00:37:37.903 --> 00:37:39.123
einfach unterschiedlich, vielleicht gibt es Leute,

00:37:39.683 --> 00:37:41.723
denen ist das halt egal, die sehen halt wie

00:37:41.723 --> 00:37:44.022
die Mechanik dahinter

00:37:44.022 --> 00:37:45.302
direkt aussieht und

00:37:45.302 --> 00:37:47.762
können sozusagen an dem Code vorbeigucken, aber

00:37:47.762 --> 00:37:48.663
mir geht das auch nicht so.

00:37:49.302 --> 00:37:52.143
Ich bin sehr an der ästhetischen...

00:37:52.143 --> 00:37:53.923
Es ist viel schöner, wenn man die ästhetischen Patterns

00:37:53.923 --> 00:37:56.243
direkt sehen kann und die einem klar ins Auge springen.

00:37:56.302 --> 00:37:56.482
Ja.

00:37:58.883 --> 00:38:00.102
Willst du ein anderes Thema

00:38:00.102 --> 00:38:01.862
einleiten? Ich habe gerade versucht, einen kleinen

00:38:01.862 --> 00:38:02.562
Übergang zu finden.

00:38:04.062 --> 00:38:05.482
Ich weiß nicht, ob es mir geglückt ist.

00:38:05.482 --> 00:38:06.183
wie geschickt.

00:38:07.102 --> 00:38:09.062
Ja, aber es war wirklich so. Wenn man das sehen kann,

00:38:09.243 --> 00:38:11.203
dann kann man doch auch diese Patterns auch mit einer gewissen

00:38:11.203 --> 00:38:12.203
Ästhetik betrachten.

00:38:13.383 --> 00:38:15.302
Und deswegen ist vielleicht diese Ästhetik der Sprache

00:38:15.302 --> 00:38:17.443
für

00:38:17.443 --> 00:38:19.002
manche wichtiger, vielleicht für einige

00:38:19.002 --> 00:38:21.102
unwichtiger, aber ich finde, es ist ein sehr essentieller Teil.

00:38:21.262 --> 00:38:23.022
Also gerade, weil auch die Hürde dadurch

00:38:23.022 --> 00:38:24.943
deutlich gesenkt wird. Selbst wenn es jetzt

00:38:24.943 --> 00:38:26.963
ein sehr hochentwickeltes Feature ist,

00:38:27.143 --> 00:38:29.022
ermöglicht es halt auch einen deutlich einfacheren

00:38:29.022 --> 00:38:31.082
Einstieg, weil durch diese ästhetische

00:38:31.082 --> 00:38:33.022
Klarheit man das Konzept auch

00:38:33.022 --> 00:38:35.002
deutlich einfacher verstehen kann.

00:38:35.482 --> 00:38:51.923
Man kann ja auch tatsächlich Ästhetik mal zur Seite legen und an der Stelle einfach, also es gibt ja mehrere andere Kriterien, die man ansetzen könnte, eben zum Thema Lesbarkeit, Menge der Zeichen auf dem Bildschirm, Menge an Noise, an syntaktischem Drumherum und so.

00:38:51.923 --> 00:38:57.243
und es gibt auch bestimmte Sprachen, bei denen ich halt sage, da ist es mir wieder zu wenig.

00:38:57.443 --> 00:39:01.203
Also Python ist halt tatsächlich für mich so die Sweet-Spot-Sprache,

00:39:01.322 --> 00:39:05.822
da ist mein Gehirn super drauf angesprungen damals und extrem gut drin.

00:39:06.462 --> 00:39:08.282
Mit Ruby tue ich mich zum Beispiel extrem schwer.

00:39:08.403 --> 00:39:11.403
Ruby hat halt dieses Thema, dass sie sehr viel metasyntaktisch arbeiten

00:39:11.403 --> 00:39:14.203
und das heißt aber, du musst teilweise schon überlegen,

00:39:15.282 --> 00:39:18.102
hier ist ein Leerzeichen, deswegen bedeutet jetzt gerade,

00:39:18.102 --> 00:39:20.302
und wenn das da hinter der Funktion ist, dann

00:39:20.302 --> 00:39:22.423
da musst du schon auch

00:39:22.423 --> 00:39:24.383
in diesen Mustern ganz schön

00:39:24.383 --> 00:39:26.502
ganz schön arg drin stecken, um das halt

00:39:26.502 --> 00:39:28.562
wirklich lesen zu können und ich habe bei Python

00:39:28.562 --> 00:39:30.522
halt immer das Gefühl, egal

00:39:30.522 --> 00:39:32.643
wie es geschrieben ist, irgendwie

00:39:32.643 --> 00:39:34.482
kriege ich es dann schon auch wieder relativ schnell

00:39:34.482 --> 00:39:35.723
auseinanderklamüsert

00:39:35.723 --> 00:39:38.542
aber ich merke auch, oh, jetzt ist es

00:39:38.542 --> 00:39:40.183
auf eine Art geschrieben, die ist irgendwie von

00:39:40.183 --> 00:39:41.982
durch die Brust ins Auge und

00:39:41.982 --> 00:39:43.883
war irgendwie nicht zum Lesen gedacht

00:39:43.883 --> 00:39:45.943
Ja

00:39:45.943 --> 00:39:47.502
Ja, man muss ja schon irgendwie

00:39:47.502 --> 00:39:49.502
Methode relativ schnell begreifen können irgendwie,

00:39:49.643 --> 00:39:51.723
als ein Ziel, wenn man das so vernünftig

00:39:51.723 --> 00:39:52.203
machen möchte.

00:39:53.263 --> 00:39:55.582
Ich glaube auch da wieder,

00:39:55.842 --> 00:39:57.322
dass halt für unterschiedliche Leute

00:39:57.322 --> 00:39:58.562
vielleicht da unterschiedliche

00:39:58.562 --> 00:40:01.743
Trade-offs besser funktionieren oder schlechter

00:40:01.743 --> 00:40:03.602
und irgendwie so

00:40:03.602 --> 00:40:05.263
wie sieht das aus oder wie kann man,

00:40:05.802 --> 00:40:07.302
wie schreibt man Dinge dran, ist halt irgendwie so das

00:40:07.302 --> 00:40:08.982
User-Interface der Sprache,

00:40:09.502 --> 00:40:11.342
was ich auch letztens noch gehört habe,

00:40:11.342 --> 00:40:13.362
was ich ganz interessanten Ansatz fand,

00:40:13.362 --> 00:40:14.482
das war, wo habe ich das hin

00:40:14.482 --> 00:40:16.183
gehört,

00:40:16.423 --> 00:40:18.522
dass es ja auch noch andere Aspekte gibt.

00:40:19.062 --> 00:40:20.143
Also genau, das war auch in einem

00:40:20.143 --> 00:40:22.443
Interview-Podcast mit, glaube ich, Chris Lettner,

00:40:22.903 --> 00:40:24.403
der Swift

00:40:24.403 --> 00:40:26.223
und Clang und so

00:40:26.223 --> 00:40:28.203
gebaut hat. Und

00:40:28.203 --> 00:40:30.123
das hatte ich vorher noch nicht so richtig auf dem

00:40:30.123 --> 00:40:31.923
Schirm, weil ich dachte immer so,

00:40:32.263 --> 00:40:34.362
was halt dann an Code dasteht, ist halt das

00:40:34.362 --> 00:40:36.462
Entscheidende. Und der meinte dann halt auch so, ja,

00:40:36.643 --> 00:40:38.423
also User-Interface der Sprache ist sehr wichtig und

00:40:38.423 --> 00:40:40.663
Python voll gut. Wusste ich auch gar nicht, dass er da so

00:40:40.663 --> 00:40:42.022
meinte, das ist total super.

00:40:42.443 --> 00:40:44.443
Das Problem ist nur, es gibt halt auch noch andere

00:40:44.443 --> 00:40:48.582
andere Dinge, die halt auch eventuell wichtig sind, wie zum Beispiel so etwas wie

00:40:48.582 --> 00:40:52.602
wie gut ist das denn jetzt nicht, wenn ich da drin irgendwas programmieren will,

00:40:52.683 --> 00:40:56.423
was dann irgendwie mein Problem löst, sondern wie ist das eigentlich, wenn ich jetzt

00:40:56.423 --> 00:41:00.423
ein Framework da drin entwickeln will oder irgendeine Library, ist das denn dann

00:41:00.423 --> 00:41:04.383
immer noch gut, weil bei Python hat man dann zum Beispiel das Problem

00:41:04.383 --> 00:41:07.322
okay, wenn das jetzt irgendwas ist, was

00:41:07.322 --> 00:41:12.383
CPU-bound ist sozusagen, dann hat man wahrscheinlich, wenn man

00:41:12.383 --> 00:41:42.362
und Jochen unterhalten sich über die Programmiersprache Python

00:41:42.383 --> 00:41:45.502
gibt es keine konsistente Art mehr, das so richtig zu debuggen.

00:41:47.502 --> 00:41:49.302
Und das ist natürlich schon so ein Punkt.

00:41:49.522 --> 00:41:51.302
Oder was er auch meinte, ist dann halt sowas wie,

00:41:51.562 --> 00:41:52.362
ja, also

00:41:52.362 --> 00:41:55.282
was ist eigentlich, kann ich sowas

00:41:55.282 --> 00:41:57.502
wie ein Int-Typ überhaupt

00:41:57.502 --> 00:41:59.282
irgendwie selber basteln?

00:41:59.383 --> 00:42:01.282
Das geht ja jetzt in Python nicht, geht auch

00:42:01.282 --> 00:42:03.302
in Java nicht. Aber in Swift

00:42:03.302 --> 00:42:05.002
ging das natürlich, deswegen Swift, voll gut.

00:42:07.263 --> 00:42:09.243
Da könnte man halt, kann man solche Typen halt tatsächlich

00:42:09.243 --> 00:42:10.683
bis ganz runter selber

00:42:10.683 --> 00:42:13.002
sozusagen als Library-Autor

00:42:13.002 --> 00:42:15.042
halt auch haben und

00:42:15.042 --> 00:42:16.203
selber definieren.

00:42:17.302 --> 00:42:19.143
Und natürlich, also in gewisser Weise, da ist

00:42:19.143 --> 00:42:21.123
schon das auch ein Punkt dabei. Und das ist

00:42:21.123 --> 00:42:23.022
natürlich in Python vielleicht jetzt nicht so

00:42:23.022 --> 00:42:24.302
einfach wie in anderen Sprachen.

00:42:25.263 --> 00:42:27.183
Ja, das...

00:42:27.183 --> 00:42:28.943
Aber so zum

00:42:28.943 --> 00:42:30.663
Lösen von Problemen finde ich das auch

00:42:30.663 --> 00:42:33.183
irgendwie schon sehr, sehr angenehm

00:42:33.183 --> 00:42:34.862
im Vergleich zu allem anderen. Aber

00:42:34.862 --> 00:42:36.962
kann auch sein, dass ich da einfach nur komisch bin und

00:42:36.962 --> 00:42:37.782
das halt für mich funktioniert.

00:42:37.782 --> 00:42:43.482
Die Interviewreihe, die du da gerade aufgemacht hast, die kann ich auch allgemein empfehlen

00:42:43.482 --> 00:42:46.683
Da hatte ich letztens nämlich jemanden

00:42:46.683 --> 00:42:48.462
Wie hieß der noch mal? Wie hieß der Interviewer?

00:42:49.123 --> 00:42:49.723
Lex Friedman

00:42:49.723 --> 00:42:51.143
Lex Friedman, genau

00:42:51.143 --> 00:42:54.923
Und da hatten wir diesen einen Chip-Designer

00:42:54.923 --> 00:42:59.183
Der ist auch extrem spannend, den sich anzunehmen

00:42:59.183 --> 00:43:01.383
Das ist gerade so ein thematischer Querschlag

00:43:01.383 --> 00:43:05.763
Aber ich glaube, die muss ich einfach mal loswerden

00:43:05.763 --> 00:43:09.582
weil der hat mich dermaßen begeistert

00:43:09.582 --> 00:43:11.562
wie hieß er denn

00:43:11.562 --> 00:43:13.243
Lex

00:43:13.243 --> 00:43:15.542
Friedman mit

00:43:15.542 --> 00:43:23.822
er hat zu viele Sachen gemacht

00:43:23.822 --> 00:43:24.862
oh ja

00:43:24.862 --> 00:43:26.602
der macht eine ganze Menge

00:43:26.602 --> 00:43:28.203
genau

00:43:28.203 --> 00:43:30.883
wo ist er, wo ist er, wo ist er

00:43:30.883 --> 00:43:32.822
Chipdesigner, Chipdesigner, Chipdesigner

00:43:32.822 --> 00:43:34.822
Namen sind

00:43:34.822 --> 00:43:35.842
Schall und Rauch.

00:43:38.462 --> 00:43:39.903
Ja, manchmal macht er auch so ein bisschen komisch.

00:43:40.002 --> 00:43:42.082
Also manchmal ist mir das auch, ich weiß nicht, es gibt ja so eine,

00:43:42.403 --> 00:43:44.342
also ich würde das mal, also wenn man das so

00:43:44.342 --> 00:43:46.223
versteht, also es ist halt auch

00:43:46.223 --> 00:43:47.802
sehr amerikanisch, muss man sagen.

00:43:48.263 --> 00:43:50.223
Und manchmal macht er auch einfach so etwas

00:43:50.223 --> 00:43:51.522
seltsame Dinge, irgendwie so,

00:43:52.243 --> 00:43:54.123
sagt dann, dass er jetzt nur noch Fleisch isst oder

00:43:54.123 --> 00:43:55.862
keine Ahnung oder macht ganz viel mit

00:43:55.862 --> 00:43:57.602
Cryptocurrency-Zeugs, was ja auch irgendwie

00:43:57.602 --> 00:43:59.062
ein bisschen ist, aber

00:43:59.062 --> 00:44:01.982
ja, aber es sind auch auf jeden Fall

00:44:01.982 --> 00:44:02.962
super interessante Sachen dabei.

00:44:02.962 --> 00:44:06.802
Genau, also hier Lex Friedman Nummer 70, Jim Keller

00:44:06.802 --> 00:44:08.263
Ah, okay, gut

00:44:08.263 --> 00:44:10.782
Jim Keller ist tatsächlich

00:44:10.782 --> 00:44:11.763
einer der

00:44:11.763 --> 00:44:14.542
also ich hab da gleich nach 10 Minuten

00:44:14.542 --> 00:44:16.203
so ein bisschen so einen Man-Crush entwickelt

00:44:16.203 --> 00:44:19.322
der ist so

00:44:19.322 --> 00:44:21.163
intense

00:44:21.163 --> 00:44:23.163
wie der da sitzt

00:44:23.163 --> 00:44:24.862
und denkt und redet

00:44:24.862 --> 00:44:26.982
und sein Minenspiel eigentlich gar nicht so richtig

00:44:26.982 --> 00:44:28.923
präsent ist so richtig und dann doch so

00:44:28.923 --> 00:44:30.403
ganz kleine Nuancen und

00:44:30.403 --> 00:44:32.862
haut da Sachen raus zum Thema

00:44:32.862 --> 00:44:34.602
Chip Design und der ist halt sozusagen

00:44:34.602 --> 00:44:36.802
in den 80ern

00:44:36.802 --> 00:44:38.243
ist der ins Chip Design eingestiegen

00:44:38.243 --> 00:44:41.102
und hat so alles mitgemacht.

00:44:41.203 --> 00:44:42.903
Der hat halt bei AMD und bei Apple und bei

00:44:42.903 --> 00:44:44.143
Tesla und bei Intel gearbeitet

00:44:44.143 --> 00:44:46.002
und ich habe jetzt so ein bisschen so persönlich

00:44:46.002 --> 00:44:48.223
dieses Gefühl von

00:44:48.223 --> 00:44:50.782
dieser Kampf zwischen AMD

00:44:50.782 --> 00:44:52.763
und Intel, der wird

00:44:52.763 --> 00:44:54.683
eigentlich nicht irgendwie da weit oben ausgetragen,

00:44:54.822 --> 00:44:56.782
sondern die Frage ist nur, ob Jim gerade bei

00:44:56.782 --> 00:44:58.082
AMD oder bei Intel ist.

00:44:58.723 --> 00:45:00.282
Die Folge heißt übrigens Moore's Law.

00:45:00.782 --> 00:45:02.542
Ja, genau.

00:45:02.862 --> 00:45:06.723
Ja, also der war, der ist schon krass, der ist schon, der war richtig gut.

00:45:08.683 --> 00:45:16.163
Ja, also ne, der Podcast kann man tatsächlich empfehlen, es gibt auch andere tolle Folgen, die man hören kann, mit Donald Knus oder Paul Krugmann sogar mal dabei gewesen und und und.

00:45:16.763 --> 00:45:21.582
Es lohnt sich die auch auf YouTube zu gucken, es gibt Videos davon mit den Interviews, nicht nur als Podcast.

00:45:22.183 --> 00:45:26.322
Und da ist, ja, die Niemieg ist, ja.

00:45:26.443 --> 00:45:27.183
Die geht nach Norwegen.

00:45:28.383 --> 00:45:28.782
Ja, ja.

00:45:29.062 --> 00:45:30.002
Wenn man mal so durchscrollt.

00:45:30.002 --> 00:45:33.562
Ja genau

00:45:33.562 --> 00:45:35.362
Wo waren wir denn jetzt?

00:45:35.923 --> 00:45:37.683
Wir wollten eigentlich ein Petra-Fall machen

00:45:37.683 --> 00:45:39.923
Ja genau

00:45:39.923 --> 00:45:43.423
Ja und

00:45:43.423 --> 00:45:45.082
irgendwie gewisserweise

00:45:45.082 --> 00:45:47.962
auch zu

00:45:47.962 --> 00:45:48.822
Patterns hatte

00:45:48.822 --> 00:45:50.703
was zu sagen und so

00:45:50.703 --> 00:45:53.143
also Patterns sind ja auch immer so

00:45:53.143 --> 00:45:54.302
es wird halt gesagt

00:45:54.302 --> 00:45:57.663
wenn man Patterns braucht, dann hat die Sprache

00:45:57.663 --> 00:45:59.683
eventuell einfach nicht

00:45:59.683 --> 00:46:00.842
genug, also hat,

00:46:01.482 --> 00:46:02.143
was ist das eigentlich?

00:46:03.842 --> 00:46:05.883
Man zeichnet dafür, dass die Sprache halt etwas nicht kann,

00:46:05.923 --> 00:46:07.743
was sie vielleicht können sollte und deswegen muss man halt

00:46:07.743 --> 00:46:09.302
einen Pattern machen und

00:46:09.302 --> 00:46:11.802
das kenne ich auch schon lange und

00:46:11.802 --> 00:46:13.822
er fügte halt dann noch was

00:46:13.822 --> 00:46:15.683
hinzu, was mir dann, wo ich dachte so,

00:46:15.703 --> 00:46:17.822
oh ja, das stimmt, das ist ja auch eigentlich

00:46:17.822 --> 00:46:19.782
so ein Problem, das ist nicht nur bei Patterns so,

00:46:19.782 --> 00:46:21.183
sondern halt auch bei sowas wie,

00:46:21.743 --> 00:46:23.782
gibt es eigentlich sowas wie eine Standardbibliothek

00:46:24.443 --> 00:46:25.743
und das ist halt immer, das ist ein

00:46:25.743 --> 00:46:27.582
ähnlicher Trade-off, also wenn du jetzt

00:46:27.582 --> 00:46:31.102
irgendwie bei Python eine relativ große Standardbibliothek

00:46:31.102 --> 00:46:33.923
hast, dann hat das natürlich eventuell den Vorteil,

00:46:34.022 --> 00:46:36.903
dass du dir so etwas ersparst wie JavaScript, ja, die haben das

00:46:36.903 --> 00:46:39.102
da halt nicht und dann kriegst du halt ein Pern.

00:46:39.663 --> 00:46:42.602
Und das ist halt sozusagen ein Pattern, um halt

00:46:42.602 --> 00:46:45.462
diese fehlende Standardbibliothek irgendwie

00:46:45.462 --> 00:46:48.943
dann aufzufangen, sozusagen außerhalb von dem,

00:46:49.062 --> 00:46:51.743
was die Sprache tatsächlich macht und das ist halt

00:46:51.743 --> 00:46:54.703
so ein bisschen fies dann unter Umständen. Auf der anderen

00:46:54.703 --> 00:46:58.462
Seite ist es natürlich auch so, dass es wieder ein Vorteil sein kann, weil wenn man jetzt

00:46:58.462 --> 00:47:02.502
sich TypeScript anguckt oder so, wenn sich so ein

00:47:02.502 --> 00:47:06.542
Type-System halt außerhalb der Sprache entwickeln kann, kannst du das natürlich deutlich

00:47:06.542 --> 00:47:10.462
schneller tun, als wenn das immer nur alle 18 Monate oder jetzt alle

00:47:10.462 --> 00:47:13.962
12 Monate updatable ist

00:47:13.962 --> 00:47:18.042
mit dem Gedächtniskzyklus der Sprache. Also es ist nicht so einfach.

00:47:20.643 --> 00:47:22.643
Und mit Patterns ist es halt irgendwie

00:47:22.643 --> 00:47:23.502
ähnlich.

00:47:24.183 --> 00:47:26.602
Wenn eine Sprache halt sehr, sehr viel kann, dann

00:47:26.602 --> 00:47:28.542
braucht man eigentlich nicht so viele Patterns, weil

00:47:28.542 --> 00:47:30.183
dann hat man einfach diese Probleme nicht.

00:47:30.862 --> 00:47:32.062
Und auf der anderen Seite, wenn

00:47:32.062 --> 00:47:33.203
ja,

00:47:34.462 --> 00:47:36.723
gibt es einen Nachteil, wenn eine Sprache zu viele Features hat?

00:47:38.203 --> 00:47:38.822
Naja gut,

00:47:38.942 --> 00:47:40.763
dann ist man halt auch an die Sprache sehr

00:47:40.763 --> 00:47:41.522
gebunden.

00:47:42.802 --> 00:47:44.042
Eigentlich hat das keinen Nachteil.

00:47:44.582 --> 00:47:46.022
Ich glaube, Patterns ist sozusagen

00:47:46.022 --> 00:47:50.783
das war gerade aufgekommen,

00:47:50.783 --> 00:47:52.022
da war ich glaube ich im Studium,

00:48:22.643 --> 00:48:28.822
in die Hand nimmt, ist das in der IT sozusagen das, wo es alles mit angefangen hatte.

00:48:30.022 --> 00:48:37.862
Und vielleicht kann man da noch kurz den einen Umweg gehen zu, Name, wie hieß er,

00:48:37.922 --> 00:48:38.602
Steve Alexander?

00:48:39.602 --> 00:48:39.802
Nee.

00:48:40.462 --> 00:48:41.602
Alexander war Alexander.

00:48:41.623 --> 00:48:42.462
Christopher Alexander.

00:48:42.822 --> 00:48:44.442
Christopher Alexander war das, genau.

00:48:44.522 --> 00:48:49.643
Er war ein Architekt und der hatte dieses Thema Python-Sprachen halt mal aufgegriffen

00:48:49.643 --> 00:48:57.942
aufgegriffen und bzw. entwickelt, um sich städtebaulich so einem Gesamtkunstwerk anzunähern.

00:48:59.082 --> 00:49:05.783
Um halt auf der einen Seite zu sagen, okay, Patterns sind Dinge, die immer wieder auftauchen,

00:49:05.862 --> 00:49:08.802
die halt in leichten Variationen anwendbar sein müssen.

00:49:09.743 --> 00:49:14.602
Und es ging ja nicht darum, dass Patterns, es sind ja Patterns und nicht Templates.

00:49:14.842 --> 00:49:19.183
Also was ist das denn? Ist das sowas wie ein Mosaikbaustein-Ding, das man irgendwo reinstecken kann

00:49:19.183 --> 00:49:19.183


00:49:19.183 --> 00:49:21.143
und dann in alle Richtungen funktioniert?

00:49:22.582 --> 00:49:23.763
Nee, eigentlich nicht.

00:49:23.903 --> 00:49:27.842
Eigentlich ist es halt tatsächlich ein Entwurfsmuster,

00:49:28.643 --> 00:49:33.302
wo du mehrere Dinge genannt bekommst drumherum.

00:49:34.942 --> 00:49:37.442
Also sie haben da ein gewisses formales Schema aufgebaut.

00:49:37.842 --> 00:49:42.502
Es ist ein Name und Klassifikation und Zweck und Synonyme und Motivation.

00:49:43.183 --> 00:49:44.922
Und aber was eben tatsächlich interessant ist,

00:49:44.922 --> 00:49:48.183
sind halt dann immer Hinweise zur Anwendbarkeit,

00:49:48.183 --> 00:49:48.183


00:49:53.183 --> 00:49:54.183
und

00:50:18.183 --> 00:50:34.442
und der hat so ein ähnlicher Einsatz wie von diesem Muster und dann liefert dir das Muster zumindest schon mal einen Design Input von, also wenn du jetzt sowas in dieser Art machst, dann solltest du auf x, y, z achten und dann hängt da noch das und das und das dran.

00:50:34.442 --> 00:50:43.002
und es ging nicht darum, sozusagen ein fertiges Stück Code, was man nur noch copy-pasted irgendwo reinzusetzen,

00:50:43.862 --> 00:50:51.942
sondern zu sagen, na guck mal, es gibt zum Beispiel, wenn du das Problem hast, dass du Code dynamisiert auswählen können möchtest,

00:50:52.342 --> 00:50:55.802
dann ist zum Beispiel das Strategy-Pattern eine mögliche Variante, das zu tun.

00:50:56.462 --> 00:51:02.022
Das sieht dann so und so und so aus und da muss man auf das und das und das aufpassen und den Rest baust du dir jetzt selber zusammen.

00:51:02.022 --> 00:51:12.342
Ja, das ist ein bisschen wie wenn ich sage, ich setze mich hin und schneide mir ein Kleid, dann habe ich da Entwurfsmuster, aber ich muss natürlich trotzdem noch messen, ob mein Bauch ein bisschen dicker ist, meine Beine ein bisschen länger und muss das dann halt anpassen.

00:51:14.623 --> 00:51:26.502
Und da ging es tatsächlich dann darum, und das ist auch das, was der Christopher Alexander an der Stelle wollte, er wollte ja damit Leuten eine Auswahl von Mustern an die Hand geben, wo die Muster auch ineinander greifen und zusammenspielen.

00:51:26.502 --> 00:51:40.502
und die Sprache der Verknüpfungen.

00:51:56.502 --> 00:51:58.822
dieses, man muss es sich selber zurechtschneiden

00:51:58.822 --> 00:52:00.302
für den eigenen Anwendungsfall.

00:52:00.442 --> 00:52:02.422
Ansonsten hätte man das ja auch in der Library kippen können.

00:52:02.522 --> 00:52:04.602
Das hätte man sagen können, das ist jetzt der einmal

00:52:04.602 --> 00:52:06.442
fertige Code und

00:52:06.442 --> 00:52:08.783
der Trick ist aber, das Muster auf einer Ebene

00:52:08.783 --> 00:52:10.383
greifen, wo ich nicht vorher sagen kann,

00:52:10.723 --> 00:52:12.302
ah, da braucht man eine Funktion für

00:52:12.302 --> 00:52:14.542
oder da braucht man dieses Ding oder eine Klasse

00:52:14.542 --> 00:52:16.422
oder sowas, sondern es ist häufig auch ein,

00:52:16.822 --> 00:52:18.502
ja, wenn du folgende sieben Zeilen

00:52:18.502 --> 00:52:20.602
dreimal geschrieben hast, dann sollst du mal darüber nachdenken,

00:52:20.703 --> 00:52:22.442
ob du das vielleicht anders anordnen möchtest.

00:52:22.582 --> 00:52:24.743
Aber das ist jetzt ja vielleicht nochmal interessant

00:52:24.743 --> 00:52:26.962
für alle unsere Hörer, weil wir haben jetzt ja abstrakt

00:52:26.962 --> 00:52:29.123
vielleicht irgendwie da mit angefangen,

00:52:29.243 --> 00:52:30.883
was so Patterns vielleicht

00:52:30.883 --> 00:52:31.362
so

00:52:31.362 --> 00:52:34.802
konzeptuell sein sollten und vielleicht gehen wir

00:52:34.802 --> 00:52:36.542
noch so ein bisschen in die konkretere Implementierung,

00:52:37.403 --> 00:52:38.462
was es denn so gibt an

00:52:38.462 --> 00:52:40.903
Sprachpatterns überhaupt und dass wir vielleicht die mal

00:52:40.903 --> 00:52:43.022
erklären und ein bisschen

00:52:43.022 --> 00:52:44.862
versuchen, wie man

00:52:44.862 --> 00:52:46.263
das in Python vielleicht macht,

00:52:47.042 --> 00:52:48.623
wenn man das macht,

00:52:48.903 --> 00:52:49.743
wenn man die überhaupt braucht.

00:52:52.383 --> 00:52:52.802
Ja genau,

00:52:52.942 --> 00:52:54.542
also ich meine, die Muster, die sind ja

00:52:54.542 --> 00:52:56.442
sozusagen allgemeingültig.

00:52:56.582 --> 00:52:57.822
Das sind ja tatsächlich

00:52:57.822 --> 00:53:00.462
sehr abstrakte Ideen,

00:53:00.542 --> 00:53:01.302
die da existieren.

00:53:01.322 --> 00:53:04.383
Fangen wir vielleicht mal mit Anfang an, was ist denn Strategie gesagt?

00:53:04.562 --> 00:53:06.422
Ja, ich würde woanders anfangen, ich würde beim Singleton

00:53:06.422 --> 00:53:08.022
anfangen. Ja, okay, fangen wir beim Singleton an.

00:53:08.022 --> 00:53:08.743
Was ist denn Singleton?

00:53:09.342 --> 00:53:12.383
Die mäßige, schöne Übersetzung ist das Einzelstück.

00:53:13.542 --> 00:53:14.422
Ich mag es

00:53:14.422 --> 00:53:15.082
einfach nicht, wenn.

00:53:16.462 --> 00:53:18.522
Es gibt ja so ein paar Kategorien,

00:53:18.522 --> 00:53:19.942
also Singleton gehört zu

00:53:19.942 --> 00:53:22.143
den Mustern aus dem Bereich

00:53:22.143 --> 00:53:24.462
Creational Patterns,

00:53:24.542 --> 00:53:29.982
Also wie werden in einer objektorientierten Sprache Objekte erzeugt?

00:53:29.982 --> 00:53:36.982
Da gibt es verschiedene Muster. Es gibt manchmal den Effekt, und gerade in Java ist das halt noch ein stärkerer Fall,

00:53:36.982 --> 00:53:39.982
dass ja alles als alles muss eine Klasse sein.

00:53:39.982 --> 00:53:46.982
Und manchmal brauchst du aber Code, wo es nur ein einziges Objekt zu geben darf.

00:53:46.982 --> 00:53:52.982
Und dieses Objekt soll aber auch gut zugänglich sein.

00:53:52.982 --> 00:54:03.522
und das kann zum Beispiel so was sein wie das Objekt, es gibt ein Python-Analogum dazu tatsächlich sogar,

00:54:04.482 --> 00:54:08.903
das ist nämlich das Objekt, was den Logger in dieser Anwendung zum Beispiel repräsentiert.

00:54:10.362 --> 00:54:16.002
Davon willst du nicht fünf Logger haben nachher, sondern willst halt irgendwie, wo ist denn hier die Log-Konfiguration,

00:54:16.123 --> 00:54:18.822
mit dem Ding möchte ich jetzt reden, da soll jetzt bitte Log-Output rausgehen.

00:54:18.822 --> 00:54:36.183
und da gibt es dann halt entsprechende Muster, wo man sagen kann, okay, wenn irgendwer die Klasse in die Hand kriegt und die nochmal neu instanziiert, dann dreht die sich um und gibt einfach statt ein neues Objekt zu machen, dir das eine erzeugte Objekt schon wieder zurück.

00:54:36.183 --> 00:54:43.962
und dieses konkrete Singleton lässt sich aus Java so auf Python, du kannst es glaube ich

00:54:43.962 --> 00:54:51.623
Codemäßig sogar so bauen, das hat aber nicht die gleichen Eigenschaften, weil die Sprache ja eine andere ist

00:54:51.623 --> 00:54:57.522
und in Python gibt es dafür halt andere Möglichkeiten sowas zu machen, dass du zum Beispiel sagst, du hast einen Namespace

00:54:57.522 --> 00:55:05.322
bei dir in deiner Anwendung, ein Modul, das heißt dann Log, man sollte es nicht Logging nennen, das geht gerne schief

00:55:05.322 --> 00:55:11.982
wenn man die Standardbibliothek startiert. Das heißt vielleicht log und da drin gibt es eine

00:55:11.982 --> 00:55:17.683
Klasse, das ist dann dein Logger und nach der Definition der Klasse würdest du gleich dieses

00:55:17.683 --> 00:55:24.203
Objekt instanziieren. Wenn du willst, löscht du danach diese Klasse einfach aus dem Namespace

00:55:24.203 --> 00:55:31.362
von dem Modul wieder raus. Dann kann auch keiner aus Versehen so eine zweite Instanz machen und

00:55:31.362 --> 00:55:34.883
dann muss man wieder dazu sagen, naja Python als Sprache für Erwachsene, das stimmt halt so auch

00:55:34.883 --> 00:55:40.082
und die Klasse aus dem Modul löscht, dann ist der Name zwar nicht mehr ansprechbar,

00:55:40.163 --> 00:55:44.663
aber du kannst natürlich auf diesem singleton-Objekt wieder nach under underclass fragen,

00:55:44.743 --> 00:55:47.542
dann hast du das Klassenobjekt, dann kannst du da wieder eine neue Instanz von machen.

00:55:48.042 --> 00:55:50.683
So, jetzt kannst du halt hergehen und kannst, wenn du willst, in Python sagen,

00:55:50.683 --> 00:55:58.243
also der, jetzt muss ich selber überlegen, welche Doppel-Unterscore-Methode da die richtige war,

00:55:59.342 --> 00:56:01.302
nicht init, sondern was?

00:56:01.322 --> 00:56:01.582
Create?

00:56:02.102 --> 00:56:02.283
Nee.

00:56:02.502 --> 00:56:03.243
New, genau.

00:56:03.243 --> 00:56:04.903
Ich habe es zu lange nicht mehr in der Hand gehabt.

00:56:05.643 --> 00:56:07.802
Ich merke, ich mache in letzter Zeit zu wenig Metaprogrammierung

00:56:07.802 --> 00:56:08.163
in Python.

00:56:09.482 --> 00:56:11.042
Du könntest aber under under new nehmen

00:56:11.042 --> 00:56:13.383
und könntest dort sowas machen wie

00:56:13.383 --> 00:56:15.183
wenn es

00:56:15.183 --> 00:56:17.542
auf dem Klassenobjekt

00:56:17.542 --> 00:56:19.663
schon ein bestimmtes Attribut gibt,

00:56:20.243 --> 00:56:21.582
nämlich die Instanz selber

00:56:21.582 --> 00:56:23.542
von dem Objekt, was du mit der Klasse erzeugt hast,

00:56:23.643 --> 00:56:25.462
dann liefer einfach das zurück und ansonsten

00:56:25.462 --> 00:56:27.562
mach einmal ein neues und ansonsten nie wieder.

00:56:28.082 --> 00:56:29.442
Solche Meta-Aktionen kann man

00:56:29.442 --> 00:56:31.643
damit machen. Die Frage ist nur immer

00:56:31.643 --> 00:56:39.183
und was hat das Pattern für einen Kontext?

00:56:39.763 --> 00:56:46.542
Es gab eine ganze Zeit lang, und das wurde so ein bisschen diesen Java-Programmierer-Schmieden,

00:56:46.683 --> 00:56:50.322
die halt so viele Leute, wie möglich, die Java programmieren können sollten, rausgespuckt hatten,

00:56:50.422 --> 00:56:54.763
so Ende der 90er und Anfang der Nullerjahre, die sind immer rausgekommen mit,

00:56:54.822 --> 00:56:57.163
ich kann die Patterns, ich muss alles in Patterns denken.

00:56:57.163 --> 00:57:03.462
und das ist aber in der Informatikausbildung selber ein Pattern, was immer wieder kommt,

00:57:04.002 --> 00:57:09.802
dass die Leute irgendwie Werkzeuge in die Hand gedrückt kriegen und dann denken, ich muss alles mit diesen Werkzeugen ausdrücken.

00:57:10.783 --> 00:57:16.643
Und eigentlich ist es aber umgekehrt, eigentlich ist es halt, du schreibst halt Code und wenn du die Patterns kennst,

00:57:16.643 --> 00:57:21.783
dann merkst du vor deinem Auge plötzlich, ich baue hier etwas auf, das riecht wie so ein Singleton.

00:57:22.783 --> 00:57:26.862
Dann sollte ich mir jetzt nochmal kurz Gedanken machen, was wir alles wissen über diese Form von Pattern

00:57:26.862 --> 00:57:34.362
und ob ich jetzt bestimmte Dinge von Fehlerbehandlung, von bestimmten Edge Cases etc. nicht einfach alle gleich glatt ziehe,

00:57:34.422 --> 00:57:38.123
weil ich weiß, wenn ich das jetzt so und so mache, dann habe ich das hier alles handwerklich ordentlich gemacht.

00:57:38.802 --> 00:57:43.723
Und es ist aber ein Bottom-Up-Approach und gelehrt wird das Ganze häufig halt als Top-Down-Approach,

00:57:43.883 --> 00:57:48.542
im Sinne von, du baust deine Anwendung nur noch aus Dingen zusammen, die diese Patterns sind.

00:57:49.163 --> 00:57:53.203
Und das ist halt Quatsch. Du baust halt die Anwendung erstmal, wie du sie willst und wenn du feststellst,

00:57:53.203 --> 00:58:23.183
und Jochen unterhalten sich über die Programmiersprache Python

00:58:23.203 --> 00:58:25.042
das ist halt irgendwie fehlende Sprachfeatures

00:58:25.042 --> 00:58:27.383
so ein bisschen relevant

00:58:27.383 --> 00:58:28.822
weil tatsächlich

00:58:28.822 --> 00:58:31.542
braucht man diese Patterns

00:58:31.542 --> 00:58:32.582
vor allen Dingen in Sprachen

00:58:32.582 --> 00:58:35.183
wo halt das

00:58:35.183 --> 00:58:37.022
syntaktisch einen Unterschied macht, also wenn ich

00:58:37.022 --> 00:58:38.602
zum Beispiel in C++ oder auch in Java

00:58:38.602 --> 00:58:41.062
oder selbst in JavaScript

00:58:41.062 --> 00:58:42.982
wenn ich da new sage, um ein neues

00:58:42.982 --> 00:58:45.342
Objekt irgendwie

00:58:45.342 --> 00:58:47.203
zu erzeugen

00:58:47.203 --> 00:58:49.102
dann habe ich halt das Problem

00:58:49.102 --> 00:58:51.283
also in Python ist es halt

00:58:51.283 --> 00:58:53.643
ist ja sozusagen neues Objekt erzeugen

00:58:53.643 --> 00:58:55.403
gar nicht syntaktisch zu unterscheiden von

00:58:55.403 --> 00:58:57.403
einem Funktionsaufruf. Das sieht halt einfach genauso auf.

00:58:57.862 --> 00:58:59.342
Und ich kann ja irgendwas zurückgeben.

00:58:59.542 --> 00:59:01.322
Also ich muss ja jetzt, wenn ich ein neues Objekt

00:59:01.322 --> 00:59:03.383
erzeuge, nicht irgendwie irgendwas new sagen,

00:59:03.462 --> 00:59:05.383
sondern ich rufe halt eine Funktion auf

00:59:05.383 --> 00:59:07.283
und dann habe ich halt ein neues Objekt. Aber die

00:59:07.283 --> 00:59:08.802
könnte da halt auch was ganz anderes machen.

00:59:09.102 --> 00:59:10.562
Auch ein Objekt von einer anderen

00:59:10.562 --> 00:59:12.982
Klasse zurückgeben oder so.

00:59:13.342 --> 00:59:15.123
Das geht halt in C++ nicht.

00:59:15.243 --> 00:59:17.163
Wenn ich da sage new irgendwie diese Klasse,

00:59:17.283 --> 00:59:18.643
dann kriege ich halt ein Objekt von dieser Klasse.

00:59:19.022 --> 00:59:21.203
Also muss ich mir, wenn dann was anderes rauskommen soll,

00:59:21.203 --> 00:59:22.842
halt überlegen, wie gehe ich denn jetzt damit um?

00:59:23.002 --> 00:59:24.763
Und dann kriege ich halt irgendwie

00:59:24.763 --> 00:59:27.163
FLs-Kaskaden in Konstruktoren und dann

00:59:27.163 --> 00:59:29.403
irgendwann denke ich mir so, das sieht aber hässlich aus, was mache ich denn jetzt?

00:59:30.342 --> 00:59:31.183
Und dann brauche ich halt Python.

00:59:31.302 --> 00:59:31.922
Oder ein bisschen Gagge-Pile um die Ohren.

00:59:34.703 --> 00:59:35.062
Und

00:59:35.062 --> 00:59:36.982
das hat man in Python so

00:59:36.982 --> 00:59:39.283
eigentlich, würde ich sagen, so viele der braucht man so nicht.

00:59:39.422 --> 00:59:41.002
Also es gibt vielleicht, ich würde sagen, Ausnahme ist vielleicht

00:59:41.002 --> 00:59:42.643
das Bilder-Pattern, das man halt auch in Python

00:59:42.643 --> 00:59:44.403
vielleicht ganz gut verwenden kann.

00:59:44.703 --> 00:59:46.462
Bitte noch erklären, was ist das Bilder-Pattern?

00:59:46.462 --> 00:59:46.783
Bitte?

00:59:48.342 --> 00:59:50.302
Also das Bilder-Pattern ist halt sozusagen, wenn man jetzt

00:59:50.302 --> 00:59:52.942
nicht nur ein Objekt bauen möchte, sondern halt

00:59:52.942 --> 01:00:06.725
eine ganze Menge von Objekten dann wird das halt unter Umst un Wenn ich das jetzt irgendwie muss ich halt einen Konstruktor machen der irgendwie riesig wird und ganz viele Argumente

01:00:06.725 --> 01:00:08.845
oder so, das ist halt eventuell nicht so schön

01:00:08.845 --> 01:00:10.745
ein gutes Beispiel dafür

01:00:10.745 --> 01:00:11.425
ist halt

01:00:11.425 --> 01:00:14.705
LXML hat da so

01:00:14.705 --> 01:00:16.585
ein Ding, wie man sozusagen

01:00:16.585 --> 01:00:18.785
XML-Dokumente zusammenbauen

01:00:18.785 --> 01:00:20.885
kann, das ist halt quasi Bilderpattern

01:00:20.885 --> 01:00:22.745
kann man sagen, also wenn man sich das mal angucken

01:00:22.745 --> 01:00:24.605
will, da gibt es dann halt für jedes Tag

01:00:24.605 --> 01:00:28.285
gibt es halt ein Objekt und dann kann man das halt ineinander schachteln und dann hat man

01:00:28.285 --> 01:00:32.445
quasi, sieht das syntaktisch so ein bisschen aus, als würde man XML zusammenbauen und

01:00:32.445 --> 01:00:36.065
hat dann aber tatsächlich eigentlich quasi

01:00:36.065 --> 01:00:40.265
halt eine Reihe von Objekten zusammengebastelt.

01:00:41.265 --> 01:00:44.365
Meistens reicht es aber, also das, wofür dann das Bilderpattern verwendet wird

01:00:44.365 --> 01:00:48.345
in anderen Sprachen, in Python reicht es dann meistens irgendwie einfach

01:00:48.345 --> 01:00:52.045
eine neue Klassenmethode an ein Objekt dran zu machen, die halt dann irgendwie Sachen zusammenbaut.

01:00:52.045 --> 01:00:53.905
Das geht halt

01:00:53.905 --> 01:00:55.465
Anderswo geht das halt nicht so gut

01:00:55.465 --> 01:00:57.245
Dann muss man halt das

01:00:57.245 --> 01:00:59.785
ein bisschen komplizierter machen, aber es gibt auch in Python Fälle

01:00:59.785 --> 01:01:01.805
wo man das Pattern tatsächlich braucht

01:01:01.805 --> 01:01:03.985
Und es ist halt schön das Pattern zu

01:01:03.985 --> 01:01:05.865
kennen, auch wenn es halt nicht primär um

01:01:05.865 --> 01:01:07.205
komplizierte Syntax geht

01:01:07.205 --> 01:01:09.865
Hat das was mit Factory zu tun, weil das

01:01:09.865 --> 01:01:10.605
Builder Pattern heißt?

01:01:11.225 --> 01:01:13.785
Ja, also Factory Pattern würde ich sagen, braucht man fast nicht

01:01:13.785 --> 01:01:14.885
Das ist genau so etwas

01:01:14.885 --> 01:01:17.405
Da das irgendwie da

01:01:17.405 --> 01:01:19.645
Funktionen First Class

01:01:19.645 --> 01:01:21.165
Dinger sind in Python

01:01:21.165 --> 01:01:22.865
gibt es eigentlich gar keine andere Zweifel.

01:01:22.865 --> 01:01:24.325
Was ist denn das Factory Blatt? Dann fangen wir wieder so an.

01:01:24.405 --> 01:01:25.205
Wir wollen ja auch ein bisschen erklären.

01:01:30.625 --> 01:01:32.505
Ich weiß gar nicht,

01:01:32.565 --> 01:01:35.145
ob ich das genau gut erklärt kriege.

01:01:41.605 --> 01:01:42.765
Guckt irgendwas aus,

01:01:42.885 --> 01:01:44.805
wird irgendwas fabriziert auf eine ähnliche Art

01:01:44.805 --> 01:01:46.585
und Weise, irgendwas

01:01:46.585 --> 01:01:48.865
generiert, was ähnliche Eigenschaften besitzt?

01:01:48.965 --> 01:01:49.205
Ich weiß nicht.

01:01:49.205 --> 01:01:55.585
Nee, es geht eigentlich eher darum, dass du deine Objektkonstruktion konfigurierbar machen möchtest.

01:01:56.165 --> 01:02:01.225
Dass du nicht sagen möchtest, du hast halt nicht irgendwie einen Hammer und ich mache jetzt irgendwie einen New Hammer,

01:02:01.725 --> 01:02:06.325
sondern du hättest gerne jetzt einen sehr speziellen Hammer mit einem möglichen, keine Ahnung,

01:02:06.445 --> 01:02:12.305
so einem Stil, der so und so lang ist und keine Ahnung, der soll so und so schwer sein und weiß ich nicht.

01:02:12.305 --> 01:02:12.645
und

01:02:12.645 --> 01:02:14.725
ja,

01:02:15.005 --> 01:02:18.245
jetzt ist halt die Frage, wie konfigurierst

01:02:18.245 --> 01:02:20.145
du dieses Ding halt und wo man in Python halt

01:02:20.145 --> 01:02:22.245
eine Funktion verwenden würde, musst du halt

01:02:22.245 --> 01:02:23.845
in anderen Sprachen jetzt anfangen

01:02:23.845 --> 01:02:26.065
sozusagen da Objekte ineinander

01:02:26.065 --> 01:02:26.685
zu stapseln.

01:02:28.665 --> 01:02:30.245
Und ja, aber ich kriege es jetzt auch,

01:02:30.345 --> 01:02:31.985
weiß ich nicht genau, ob ich das so super erklärt kriege.

01:02:32.245 --> 01:02:33.705
Ich habe mir das auch schon lange nicht mehr angeguckt.

01:02:34.525 --> 01:02:36.125
Ja, man muss an der Stelle halt

01:02:36.125 --> 01:02:36.545
auch

01:02:36.545 --> 01:02:40.205
gucken, es geht

01:02:40.205 --> 01:02:41.745
wieder um Syntax halt auch an der Stelle.

01:02:42.305 --> 01:03:03.085
Das eine ist, du benutzt halt plötzlich keinen new operator mehr an der Stelle. Das geht weg, sondern du änderst halt den Aufruf eines traditionellen Konstruktors in halt eine ganz normale Funktion oder Methode und kannst halt tatsächlich auch unterschiedliche Semantiken haben.

01:03:03.085 --> 01:03:05.685
also hier wird zum Beispiel gerade ein Beispiel aufgeführt von

01:03:05.685 --> 01:03:09.365
hab eine Farbklasse und du willst jetzt eine neue Farbinstanz haben

01:03:09.365 --> 01:03:14.345
und sagst einmal create from RGB oder create from HSV oder solche Sachen

01:03:14.345 --> 01:03:17.225
das kannst du damit ein bisschen expliziter machen

01:03:17.225 --> 01:03:21.925
speziell wenn du dann halt wirklich unterschiedliche Semantiken haben willst

01:03:21.925 --> 01:03:24.705
oder das Ding noch 13 andere Dinge tun soll

01:03:24.705 --> 01:03:28.805
oder eben gar kein new aufruft, sondern das Ding von woanders heranzerrt

01:03:28.805 --> 01:03:35.425
Da sind Konstruktoren halt häufig einfach extrem begrenzt, was die Flexibilität angeht.

01:03:35.965 --> 01:03:41.685
Und das ist tatsächlich in Python halt ein, naja, Init und Usen sind halt auch nur ganz normale Funktionen,

01:03:41.725 --> 01:03:46.005
die kannst du parametrisieren und benutzen, wie du willst. Da ist Python halt einfach eine Ecke voraus gewesen.

01:03:47.545 --> 01:03:51.825
Nichtsdestotrotz kann man halt noch was daraus lernen. Ich mache das auch gerne manchmal, dass ich Konstruktoren habe,

01:03:51.825 --> 01:04:00.505
oder solche Factories haben, die eben dieses aus unterschiedlichen Kontexten rausinitialisieren.

01:04:00.585 --> 01:04:04.305
Es ist in der Python-Bibliothek selber auch drin, wenn man sich DateTime zum Beispiel anguckt,

01:04:04.785 --> 01:04:08.225
dann gibt es da mehrere, das sind dann entweder Klassen- oder Statischulmethoden,

01:04:08.545 --> 01:04:14.385
die heißen dann irgendwie fromTimestamp oder from was auch immer,

01:04:15.125 --> 01:04:17.965
um dann halt ein Objekt dieser Klasse zu erzeugen,

01:04:17.965 --> 01:04:19.665
aber eben mit völlig anderen

01:04:19.665 --> 01:04:22.065
Ansätzen

01:04:22.065 --> 01:04:24.005
und der Code ist natürlich leichter zu strukturieren

01:04:24.005 --> 01:04:25.565
als wenn du nur einen Konstruktor hättest

01:04:25.565 --> 01:04:27.905
wo 23 Parameter drin sind, die sich

01:04:27.905 --> 01:04:29.325
alle nicht auf den Füßen rumtreten dürfen

01:04:29.325 --> 01:04:31.025
Ja

01:04:31.025 --> 01:04:37.965
Ja, dann machen wir doch weiter

01:04:37.965 --> 01:04:39.725
mit was für, würde ich sagen, Snickers

01:04:39.725 --> 01:04:42.065
eigentlich hatten wir ja mit dem Singleton angefangen und mit den

01:04:42.065 --> 01:04:43.025
verschiedenen Arten

01:04:43.025 --> 01:04:45.565
Achso, ja, ja, genau, auch zu Singleton wollte ich auch noch kurz, genau

01:04:45.565 --> 01:04:47.705
was ich meistens verwende oder was für meine

01:04:47.705 --> 01:04:50.245
Anwendungsfälle, wo ich sowas habe, wie den Singleton,

01:04:51.565 --> 01:04:54.045
meistens reicht es tatsächlich irgendwie

01:04:54.045 --> 01:04:55.325
eine Variable in einem Modul.

01:04:56.425 --> 01:04:58.025
Weil das ist ja, das Modul ist schon

01:04:58.025 --> 01:04:59.305
Singleton irgendwie und wenn ich da halt

01:04:59.305 --> 01:05:02.025
irgendwas anpacke, dann ist das halt überall

01:05:02.025 --> 01:05:03.945
gleich, wenn ich das irgendwo

01:05:03.945 --> 01:05:06.165
importiere. Es gibt

01:05:06.165 --> 01:05:08.065
da so einen Pattern von

01:05:08.065 --> 01:05:09.965
Alex Martley, wenn man tatsächlich sowas

01:05:09.965 --> 01:05:10.885
braucht wie SharedState,

01:05:11.385 --> 01:05:14.145
aber manchmal braucht man nicht unbedingt

01:05:14.145 --> 01:05:15.905
immer die gleiche Instanz, sondern nur, dass sich alles

01:05:15.905 --> 01:05:17.445
immer gleich irgendwie verhält und die gleichen

01:05:17.445 --> 01:05:20.065
den gleichen State hält, da kann man das Borg-Pattern

01:05:20.065 --> 01:05:21.885
verwenden. Das ist so ein bisschen ähnlich wie

01:05:21.885 --> 01:05:23.105
ein Singleton. Wie das Borg-Pattern?

01:05:24.005 --> 01:05:25.685
Das ist kein originales Gang of Four.

01:05:25.825 --> 01:05:27.825
Nein, aber das ist halt sozusagen

01:05:27.825 --> 01:05:29.585
irgendwie eine etwas Pythonischere Variante.

01:05:31.825 --> 01:05:33.485
Ja, und es gibt dann natürlich auch noch die,

01:05:33.605 --> 01:05:35.825
man kann tatsächlich auch so machen, dass es halt so

01:05:35.825 --> 01:05:37.745
ist wie Singleton in anderen Sprachen, dann meistens

01:05:37.745 --> 01:05:39.685
irgendwie muss man dann so Metaprogrammierung mit New

01:05:39.685 --> 01:05:41.765
und keine Ahnung, ist aber dann schon nicht mehr so richtig einfach

01:05:41.765 --> 01:05:43.325
und meistens, wie gesagt, also

01:05:43.325 --> 01:05:45.365
meiner Erfahrung nach braucht man es eigentlich nicht.

01:05:46.825 --> 01:05:47.225
Ja.

01:05:47.445 --> 01:05:57.745
Ja, okay. Also was für Paths haben wir denn noch? Also ich kann jetzt natürlich die Liste hernehmen, aber wir haben jetzt Single-Ding gehabt, wir haben kurz Factory.

01:05:57.745 --> 01:06:11.505
Es gibt noch zwei, die jetzt aus meiner Historie immer relevant waren. Das waren Proxys und Adapter. Da muss ich mal die ganz ollen Gammellen rausholen.

01:06:11.505 --> 01:06:19.665
also SOAP 3 war damals tatsächlich also SOAP 2 und deren Nachfolger SOAP 4 und SOAP 5.

01:06:20.065 --> 01:06:20.845
Wie bitte was?

01:06:20.845 --> 01:06:21.525
Da gab es auch einen.

01:06:22.005 --> 01:06:22.265
Bitte?

01:06:23.225 --> 01:06:24.425
SOAP, genau.

01:06:24.585 --> 01:06:29.505
Das ist der Open Source Urgroßvater der Applikationsserver.

01:06:31.205 --> 01:06:32.365
Z-O-P-E, SOAP.

01:06:32.485 --> 01:06:32.965
Achso, SOAP.

01:06:33.085 --> 01:06:33.665
Ja, okay.

01:06:33.665 --> 01:06:49.745
Ja, genau. Und das war ursprünglich ja so ein Through-the-Web-Entwicklungsumgebungstool, wo man halt nur durch einen Browser mit Python und so ein paar HTML-Template-Sprachen sich extrem schnell Webanwendungen zusammenbauen konnte.

01:07:19.745 --> 01:07:24.925
Es hat einfach nichts, so richtig gar nichts mehr mit dem vorherigen Ding zu tun gehabt

01:07:24.925 --> 01:07:31.965
Da war halt eine der Grundideen, dass es möglich sein sollte

01:07:31.965 --> 01:07:38.185
Libraries und Anwendung oder Anwendungskomponenten, das nannte sich dann auch Komponentenarchitektur

01:07:38.185 --> 01:07:45.605
So miteinander zu verheiraten, dass es eine zentrale Registry gibt, in der aufgezeichnet wird

01:07:45.605 --> 01:07:48.665
wie man Dinge miteinander verbinden kann

01:07:48.665 --> 01:07:50.565
also das war dann sehr stark Interface basiert

01:07:50.565 --> 01:07:52.345
das ist jetzt auch was was in anderen Sprachen

01:07:52.345 --> 01:07:54.685
stärker verankert ist als Python

01:07:54.685 --> 01:07:56.685
und da hatten wir

01:07:56.685 --> 01:07:58.445
extra eine Interface

01:07:58.445 --> 01:08:00.125
Typ für entwickelt

01:08:00.125 --> 01:08:01.805
mit dem du dann deklarieren konntest

01:08:01.805 --> 01:08:04.745
das hier ist ein formales Interface, es muss folgende Methoden haben

01:08:04.745 --> 01:08:06.345
die Methoden müssen folgende Parameter haben

01:08:06.345 --> 01:08:09.065
also Interface ist ja ein anderes Designpattern

01:08:09.065 --> 01:08:10.885
ne Interface ist noch nicht mal so richtig

01:08:10.885 --> 01:08:12.465
ein Designpattern, Interface ist

01:08:12.465 --> 01:08:15.025
kommt eher aus dem

01:08:45.025 --> 01:08:46.945
aufrufst, wenn du dir irgendwas

01:08:46.945 --> 01:08:48.905
übergibst, musst du dir halt sagen, was das denn ist.

01:08:49.485 --> 01:08:50.985
Du kannst dir nicht einfach irgendwas übergeben.

01:08:51.805 --> 01:08:53.185
Und wenn du jetzt

01:08:53.185 --> 01:08:54.705
Objekte

01:08:54.705 --> 01:08:56.625
unterschiedlicher Art da reintun willst,

01:08:57.165 --> 01:08:58.225
dann müssen sie zumindest

01:08:58.225 --> 01:09:00.845
vom gleichen Interface erben, sonst geht das

01:09:00.845 --> 01:09:02.765
halt einfach nicht. Du kannst halt, du könntest

01:09:02.765 --> 01:09:03.145
zum Beispiel

01:09:03.145 --> 01:09:05.985
sagen,

01:09:06.425 --> 01:09:08.725
okay, ich habe hier irgendwie eine Methode, die

01:09:08.725 --> 01:09:10.685
schreibt irgendwie, zum Beispiel, die lockt irgendwas

01:09:10.685 --> 01:09:11.345
weg oder so.

01:09:12.545 --> 01:09:14.065
Und ich gebe da jetzt irgendwas rein, aber

01:09:14.065 --> 01:09:16.125
was du jetzt reingeben möchtest, ist einmal

01:09:16.125 --> 01:09:18.185
vielleicht irgendein Log-File, in das reingeschrieben wird,

01:09:18.265 --> 01:09:19.685
aber du möchtest vielleicht auch, dass das irgendwie

01:09:19.685 --> 01:09:21.985
übers Netz in irgendein Socket geschrieben wird.

01:09:22.365 --> 01:09:24.025
Und dann kannst du sagen, okay, Socket und mein

01:09:24.025 --> 01:09:26.125
File haben beide ein File-like Interface

01:09:26.125 --> 01:09:27.885
sozusagen, das sie implementieren

01:09:27.885 --> 01:09:30.045
oder dann halt auch explizit davon erben,

01:09:30.125 --> 01:09:31.885
wenn du das halt irgendwie so machen willst und

01:09:31.885 --> 01:09:33.905
dann kannst du das halt dann

01:09:33.905 --> 01:09:36.105
sozusagen, sagst du in der Methode

01:09:36.105 --> 01:09:37.945
also ich habe hier, hätte

01:09:37.945 --> 01:09:39.985
gern ein Ding, dass

01:09:39.985 --> 01:09:40.765
das File-Interface

01:09:40.765 --> 01:09:42.165
sozusagen

01:09:42.165 --> 01:09:44.125
implementiert und

01:09:44.125 --> 01:09:46.325
kannst dann sozusagen

01:09:46.325 --> 01:09:48.105
darauf dann irgendwie write aufrufen oder so.

01:09:48.805 --> 01:09:50.785
Die Menge der Methoden,

01:09:50.885 --> 01:09:52.585
sozusagen, die man

01:09:52.585 --> 01:09:54.505
da aufrufen kann, das ist halt das Interface.

01:09:55.105 --> 01:09:56.325
Also die Idee ist,

01:09:56.685 --> 01:09:58.285
der wichtige Unterschied ist, dass du

01:09:58.285 --> 01:10:00.305
mit Interfaces halt

01:10:00.305 --> 01:10:02.485
Implementation und Spezifikation voneinander

01:10:02.485 --> 01:10:04.105
halt trennst.

01:10:04.145 --> 01:10:06.705
Das heißt, ich habe eine abstrakte Vordefinition.

01:10:07.685 --> 01:10:08.245
Ja, also

01:10:08.245 --> 01:10:10.445
wir hatten es damals so gemacht, es gab einen speziellen

01:10:10.445 --> 01:10:11.645
Klassentyp,

01:10:12.165 --> 01:10:13.825
und die

01:10:13.825 --> 01:10:15.825
Programmiersprache Python

01:10:15.825 --> 01:10:15.865
und die

01:10:15.865 --> 01:10:15.905
Programmiersprache Python

01:10:15.905 --> 01:10:15.945
und die

01:10:15.945 --> 01:10:15.985
Programmiersprache Python

01:10:15.985 --> 01:10:16.025
und die

01:10:16.025 --> 01:10:16.105
Programmiersprache Python

01:10:16.105 --> 01:10:16.125
und die

01:10:16.125 --> 01:10:16.205
Programmiersprache Python

01:10:16.205 --> 01:10:16.225
und die

01:10:16.225 --> 01:10:16.265
Programmiersprache Python

01:10:16.265 --> 01:10:16.285
und die

01:10:16.285 --> 01:10:16.345
Programmiersprache Python

01:10:16.345 --> 01:10:16.365
und die

01:10:16.365 --> 01:10:16.385
Programmiersprache Python

01:10:16.385 --> 01:10:16.405
und die

01:10:16.405 --> 01:10:16.465
Programmiersprache Python

01:10:16.465 --> 01:10:16.485
und die

01:10:16.485 --> 01:10:16.505
Programmiersprache Python

01:10:16.505 --> 01:10:16.525
und die

01:10:16.525 --> 01:10:16.545
Programmiersprache Python

01:10:16.545 --> 01:10:16.565
und die

01:10:16.565 --> 01:10:16.625
Programmiersprache Python

01:10:16.625 --> 01:10:16.645
und die

01:10:16.645 --> 01:10:16.705
Programmiersprache Python

01:10:16.705 --> 01:10:16.725
und die

01:10:16.725 --> 01:10:16.825
Programmiersprache Python

01:10:16.825 --> 01:10:16.945
und die

01:10:16.945 --> 01:10:17.065
Programmiersprache Python

01:10:17.065 --> 01:10:17.085
und die

01:10:17.085 --> 01:10:17.145
Programmiersprache Python

01:10:17.145 --> 01:10:17.185
und die

01:10:17.185 --> 01:10:17.225
Programmiersprache Python

01:10:17.225 --> 01:10:17.245
und die

01:10:17.245 --> 01:10:17.305
Programmiersprache Python

01:10:17.305 --> 01:10:17.325
und die

01:10:17.325 --> 01:10:17.385
Programmiersprache Python

01:10:17.385 --> 01:10:17.405
und die

01:10:17.405 --> 01:10:17.465
Programmiersprache Python

01:10:17.465 --> 01:10:17.505
und die

01:10:17.505 --> 01:10:17.545
Programmiersprache Python

01:10:17.545 --> 01:10:17.565
und die

01:10:17.565 --> 01:10:17.625
Programmiersprache Python

01:10:17.625 --> 01:10:17.665
und die

01:10:17.665 --> 01:10:17.705
Programmiersprache Python

01:10:17.705 --> 01:10:17.725
und die

01:10:17.725 --> 01:10:17.785
Programmiersprache Python

01:10:17.785 --> 01:10:17.825
und die

01:10:17.825 --> 01:10:17.865
Programmiersprache Python

01:10:17.865 --> 01:10:17.885
und die

01:10:17.885 --> 01:10:17.985
Programmiersprache Python

01:10:17.985 --> 01:10:18.025
und die

01:10:18.025 --> 01:10:18.065
Programmiersprache Python

01:10:18.065 --> 01:10:18.105
und die

01:10:18.105 --> 01:10:18.125
Programmiersprache Python

01:10:18.125 --> 01:10:18.185
und die

01:10:18.185 --> 01:10:18.225
Programmiersprache Python

01:10:18.225 --> 01:10:18.265
und die

01:10:18.265 --> 01:10:18.325
Programmiersprache Python

01:10:18.325 --> 01:10:18.385
und die

01:10:18.385 --> 01:10:18.425
Programmiersprache Python

01:10:18.425 --> 01:10:18.485
und die

01:10:18.485 --> 01:10:18.545
Programmiersprache Python

01:10:18.545 --> 01:10:18.565
und die

01:10:18.565 --> 01:10:18.625
Programmiersprache Python

01:10:18.625 --> 01:10:18.865
und die

01:10:18.865 --> 01:10:18.925
Programmiersprache Python

01:10:18.925 --> 01:10:18.945
und die

01:10:18.945 --> 01:10:18.985
Programmiersprache Python

01:10:18.985 --> 01:10:19.025
und die

01:10:42.025 --> 01:10:42.025


01:10:47.025 --> 01:10:48.025
Ducktyping

01:10:49.025 --> 01:11:03.725
Das heißt, solange es sich so verhält, wie es soll, ist mir als Laufzeitumgebung völlig egal, was du reinstopfst. Das ist ja dann jetzt mit den Type Annotations kannst du da jetzt Laufzeitumgebungen nehmen, die das halt ein bisschen strenger behandeln und auch mit statischer Analyse schon mal versehen.

01:11:03.725 --> 01:11:28.265
Aber da ging es uns tatsächlich mehr darum, wenn man solche Annotationen hat, dass man daraus dann auch den Vorteil zieht, dass ich sage, okay, ich definiere ein Interface für etwas und wenn ein Objekt ein Parameter eines bestimmten Typs erwartet oder ein Objekt erwartet, das ein bestimmtes Interface erfüllt,

01:11:28.265 --> 01:11:58.245
und die Funktionen.

01:11:58.265 --> 01:12:09.805
und dann konntest du in der Laufzeitumgebung vorher registrieren und sagen, ah, also, wenn jemand einen ILogger braucht und einen String bekommen hat, dann mach bitte folgendes und dann kommt da dieses Objekt raus.

01:12:10.865 --> 01:12:20.725
Oder wenn eine Methode einen ILogger braucht und da kommt ein Socket raus, da wurde ein Socket übergeben, dann mach bitte das und geh dann weiter.

01:12:20.725 --> 01:12:23.025
und da kannst du sozusagen immer wieder beliebige

01:12:23.025 --> 01:12:25.765
Typtransformationen mitten reinsetzen

01:12:25.765 --> 01:12:27.645
und hast dich dadurch flexibilisiert,

01:12:27.765 --> 01:12:29.085
dass jemand anders plötzlich anfängt,

01:12:29.225 --> 01:12:31.125
okay, ich gebe dir, liebes Programm,

01:12:31.245 --> 01:12:32.965
jetzt plötzlich Objekte anderen Typs rein

01:12:32.965 --> 01:12:35.505
und deklariere an der dritten Stelle,

01:12:35.825 --> 01:12:37.865
wie diese Typtransformationen zu laufen haben

01:12:37.865 --> 01:12:41.005
und dann kann ich plötzlich halt Anwendungen

01:12:41.005 --> 01:12:43.125
auf Arten benutzen, die nie so vorgesehen waren.

01:12:43.585 --> 01:12:45.045
Das hört sich nach großer Magie an.

01:12:45.705 --> 01:12:46.845
Das war ein Haufen Magie,

01:12:46.925 --> 01:12:48.045
da war ein Haufen Engineering drin,

01:12:48.105 --> 01:12:49.225
um das auch schnell zu kriegen.

01:12:49.225 --> 01:12:49.225


01:12:49.225 --> 01:12:51.425
also das war wirklich so

01:12:51.425 --> 01:12:53.185
wenn man bei Soap nachher in einer

01:12:53.185 --> 01:12:55.305
ernsthaften Anwendung mal eine Seite aufgerufen

01:12:55.305 --> 01:12:57.065
hatte, dann waren in einem Call bestimmt

01:12:57.065 --> 01:12:58.625
eine halbe Million Adapter Calls drin

01:12:58.625 --> 01:13:01.185
und die waren

01:13:01.185 --> 01:13:03.205
aber auf C-Ebene halt so optimiert, das waren halt

01:13:03.205 --> 01:13:05.185
nur ein paar Millisekunden, die dafür draufgingen, das war alles

01:13:05.185 --> 01:13:05.885
extrem schnell

01:13:05.885 --> 01:13:09.085
da wurde extrem viel Arbeit reingesteckt

01:13:09.085 --> 01:13:11.245
und da gibt es wirklich

01:13:11.245 --> 01:13:12.825
also da gibt es Architekturen, die wir

01:13:12.825 --> 01:13:14.745
in Anwendung hatten, die waren extrem

01:13:14.745 --> 01:13:16.225
interessant

01:13:16.225 --> 01:13:19.025
Problem ist aber, die sind auch extrem

01:13:19.025 --> 01:13:19.985
aufwendig zu pflegen.

01:13:20.925 --> 01:13:22.945
Also da spielst du dann halt Informatik

01:13:22.945 --> 01:13:24.705
wieder mit in der Klasse von

01:13:24.705 --> 01:13:26.385
wir ziehen uns jetzt alle den Laborkittel an

01:13:26.385 --> 01:13:28.845
und designen das jetzt hier ordentlich durch,

01:13:28.985 --> 01:13:30.565
ansonsten fliegt uns das alles um die Ohren.

01:13:31.105 --> 01:13:32.665
Da ist so ein iteratives Vorgehen

01:13:32.665 --> 01:13:34.685
hat nur so

01:13:34.685 --> 01:13:36.725
begrenzt getragen, weil du halt häufiger

01:13:36.725 --> 01:13:38.645
recht große starre Refactorings hattest,

01:13:38.745 --> 01:13:40.785
die du dann halt nehmen musstest.

01:13:40.845 --> 01:13:42.585
Aber dieses Adapter-Pattern hat es

01:13:42.585 --> 01:13:43.785
extrem flexibel gemacht.

01:13:45.065 --> 01:13:45.965
Also das war schon

01:13:45.965 --> 01:13:47.065
richtig gut.

01:13:47.065 --> 01:13:56.245
und das zweite wo ich mich hier in Fanatismus und Rage vor euren Augen im Video begeben hatte,

01:13:56.245 --> 01:14:00.745
war dann was da auch eine Rolle gespielt hat, waren sogenannte Proxy Patterns, dass also ein Objekt

01:14:00.745 --> 01:14:05.905
anstelle eines Anderes irgendwo rein gereicht wird und er emuliert alle Attributzugriffe und alle

01:14:05.905 --> 01:14:11.245
Funktionsaufrufe, macht irgendwas und reicht den Originalaufruf dann an das Originalobjekt halt

01:14:41.245 --> 01:14:41.245


01:14:41.245 --> 01:14:42.185
und dann hast du hier gleich

01:14:42.185 --> 01:14:44.425
sowas wie eine Middleware

01:14:44.425 --> 01:14:47.225
nur genau umgedreht, im Prinzip.

01:14:48.245 --> 01:14:49.185
Du injectest das Ding

01:14:49.185 --> 01:14:50.405
in was anderes rein.

01:14:53.145 --> 01:14:55.005
Eine Middleware ist ja typischerweise was, was

01:14:55.005 --> 01:14:56.445
in der Pipeline irgendwo drin sitzt

01:14:56.445 --> 01:14:58.985
und du kannst aber halt beliebigem

01:14:58.985 --> 01:15:00.945
anderen Code das Ding einfach unterjubeln.

01:15:01.745 --> 01:15:03.225
Und das läuft dann durch diesen Code

01:15:03.225 --> 01:15:04.965
mit durch. Und wie mache ich das?

01:15:06.325 --> 01:15:07.205
Das ist relativ

01:15:07.205 --> 01:15:09.165
easy. Also die Frage

01:15:09.165 --> 01:15:11.185
ist immer, wann du bei Python

01:15:11.185 --> 01:15:11.185


01:15:15.665 --> 01:15:20.025
Also die ernsthaften Proxys, die wir hatten, waren dann Security Proxys.

01:15:20.825 --> 01:15:26.165
Die waren in der Lage, anhand von Access Controls, einer relativ aufwendigen Architektur,

01:15:26.305 --> 01:15:30.445
tatsächlich für jeden einzelnen Funktionsaufruf zu sagen, ob der zulässig ist oder nicht.

01:15:30.505 --> 01:15:34.725
Ob dieser User mit den Rechten auf dem Objekt, das da aus der Datenbank kam,

01:15:34.785 --> 01:15:39.325
wenn das Objekt dann auch noch zu dem Kunden gehört, da so, darf der jetzt diese Funktion aufrufen, ja oder nein.

01:15:39.325 --> 01:15:43.105
das war halt eine sogenannte Subject Oriented Security

01:15:43.105 --> 01:15:45.025
und das ist so ein Unterschied

01:15:45.025 --> 01:15:47.245
heutzutage viele Systeme

01:15:47.245 --> 01:15:47.865
haben nur

01:15:47.865 --> 01:15:49.965
View Oriented

01:15:49.965 --> 01:15:53.085
Security, dass du halt sagst, okay darf ich

01:15:53.085 --> 01:15:54.565
jetzt diesen View anschauen oder nicht

01:15:54.565 --> 01:15:56.625
und da war es aber tatsächlich so, dass wir

01:15:56.625 --> 01:15:59.425
praktisch alle Objekte

01:15:59.425 --> 01:16:01.825
die aus der

01:16:01.825 --> 01:16:03.125
originalen

01:16:03.125 --> 01:16:05.585
Factory mal rausgefallen

01:16:05.585 --> 01:16:07.225
sind von, okay hier ist deine Datenbank

01:16:07.225 --> 01:16:08.945
Connection oder sowas

01:16:08.945 --> 01:16:11.465
die wurden in solche Security-Proxys eingepackt

01:16:11.465 --> 01:16:14.705
und dann konntest du nachher wirklich für jeden einzelnen Attributzugriff

01:16:14.705 --> 01:16:17.725
aussteuern, ob da jetzt Security

01:16:17.725 --> 01:16:21.045
eingreifen soll und sagen soll, nee, User mit den

01:16:21.045 --> 01:16:23.885
Permissions dürfen halt auf die Passwortfelder nicht zugreifen

01:16:23.885 --> 01:16:26.645
und wenn du das in deinem Template-Code aber gemacht hast, dann ist aber

01:16:26.645 --> 01:16:28.925
der ganze Request abgewürgt worden mit das jezu nicht

01:16:28.925 --> 01:16:32.705
da musst du halt dann noch einen Check gegenbauen und sagen, ah

01:16:32.705 --> 01:16:35.865
der darf das nicht, dann wird das Template ordentlich gerendert und ansonsten hast du

01:16:35.865 --> 01:16:38.425
aber immer den Safety-Belt, das ist dein Framework

01:16:38.425 --> 01:16:40.685
selbst wenn du Blödsinn im Code schreibst

01:16:40.685 --> 01:16:42.405
du musst da nicht drüber nachdenken

01:16:42.405 --> 01:16:44.365
darf ich jetzt hier das Passwort rausrendern oder nicht

01:16:44.365 --> 01:16:46.825
es geht nicht raus, im schlimmsten Fall wird die Seite halt abgebrochen

01:16:46.825 --> 01:16:47.725
und er sagt so hier ist nix

01:16:47.725 --> 01:16:50.565
und die mussten wir

01:16:50.565 --> 01:16:52.045
aber tatsächlich auf C-Ebene schreiben

01:16:52.045 --> 01:16:54.505
um wirklich alles komplett unterbinden

01:16:54.505 --> 01:16:56.585
zu können an Protokollen, die Python so kann

01:16:56.585 --> 01:16:58.465
mit den Doppel-Underscore-Methoden

01:16:58.465 --> 01:17:00.865
einen einfachen Proxy kannst du in Python

01:17:00.865 --> 01:17:02.465
schreiben, indem du einfach nur sagst

01:17:02.465 --> 01:17:04.405
das ist eine Klasse, die hat ein Init

01:17:04.405 --> 01:17:06.505
da übergibst du das Objekt, was

01:17:06.505 --> 01:17:06.505


01:17:06.505 --> 01:17:16.045
und über die GetAttribute Protokolle

01:17:16.045 --> 01:17:16.065
und dann kannst du über die GetAttribute Protokolle

01:17:16.065 --> 01:17:20.445
dann halt sagen, aha hier versucht jemand gerade zuzugreifen auf folgendes Attribut

01:17:20.445 --> 01:17:23.845
und jetzt kannst du ein bisschen Log-Output erzeugen

01:17:23.845 --> 01:17:26.725
und danach halt das Original-Objekt mit genau diesem Objekt wieder aufrufen.

01:17:27.345 --> 01:17:29.785
Und das ist der Vorteil bei Python, was diese Patterns angeht,

01:17:30.125 --> 01:17:32.545
mit Python als protokollorientierter Sprache.

01:17:32.945 --> 01:17:35.765
Du hast immer irgendwas, was keine spezielle Syntax braucht,

01:17:35.765 --> 01:17:37.645
sondern du kannst in der Metaprogrammierung

01:17:37.645 --> 01:17:39.745
immer diese Doppel-Underscore-Methoden

01:17:39.745 --> 01:17:41.365
benutzen, um dann wieder

01:17:41.365 --> 01:17:43.265
über das System selber zu reden.

01:17:43.305 --> 01:17:45.985
Also dann Magic quasi direkt auf den Objekten

01:17:45.985 --> 01:17:47.585
während die gebaut werden.

01:17:50.785 --> 01:17:51.645
Jetzt müssten wir

01:17:51.645 --> 01:17:53.665
im Podcast sozusagen ein bisschen Live-Coding machen, um

01:17:53.665 --> 01:17:54.285
da...

01:17:54.285 --> 01:17:57.465
An welcher Stelle das

01:17:57.465 --> 01:17:59.465
injiziert werden soll. Wenn du jetzt sagst,

01:17:59.865 --> 01:18:01.345
dass das schon gebaut wird, jetzt weißt du,

01:18:01.385 --> 01:18:03.465
die Inlet ist dann quasi schon durch. Also der Konstruktor

01:18:03.465 --> 01:18:05.045
ist quasi geschehen.

01:18:05.045 --> 01:18:06.685
und dann habe ich ein fertiges Objekt.

01:18:07.045 --> 01:18:08.425
Genau, das ist aber das Proxy-Objekt.

01:18:09.585 --> 01:18:10.905
Also es hat aber doch erst ein

01:18:10.905 --> 01:18:13.105
Proxy-Objekt gebaut und das dann quasi

01:18:13.105 --> 01:18:15.285
die anderen In-Edit-Methoden erst aufruft

01:18:15.285 --> 01:18:16.285
und währenddessen...

01:18:16.285 --> 01:18:19.025
Du hast ein Proxy-Objekt, das kriegt das

01:18:19.025 --> 01:18:19.845
Objekt, was du

01:18:19.845 --> 01:18:22.705
hinter dem Proxy haben möchtest,

01:18:22.805 --> 01:18:24.305
das reichst du dem rein.

01:18:25.225 --> 01:18:27.305
Also, ich versuche es ein bisschen

01:18:27.305 --> 01:18:28.825
bildlicher zu machen. Du hast ein Objekt

01:18:28.825 --> 01:18:30.645
aus deiner Anwendung, zum Beispiel

01:18:30.645 --> 01:18:33.105
den Datensatz von einer

01:18:33.105 --> 01:18:34.945
Person aus der Datenbank als

01:18:34.945 --> 01:18:40.265
Objekt. Class Person und die Instanz davon, die aus der Datenbank kam und jetzt mit den Daten

01:18:40.265 --> 01:18:45.645
gefüllt wurde, die hast du vor dir. Person A. Person A. So. Und jetzt würdest du sagen, ich habe einen

01:18:45.645 --> 01:18:53.505
Proxy, der loggt alle Zugriffe auf Attribute von Objekten mit. Das Ding weiß nichts von Personen,

01:18:53.645 --> 01:18:58.965
Klassen oder irgendwas. Aber ich instanziere jetzt quasi den Proxy mit dem Objekt Person A.

01:18:58.965 --> 01:19:01.585
mit dem Objekt Person A als Parameter.

01:19:02.305 --> 01:19:04.705
Bei dem Proxy heißt dieses Objekt intern nur

01:19:04.705 --> 01:19:06.525
Kontext zum Beispiel.

01:19:07.345 --> 01:19:10.285
Das speichert der bei sich auf under under

01:19:10.285 --> 01:19:11.465
Kontext zum Beispiel.

01:19:12.645 --> 01:19:17.105
Wichtig ist under under, also auch hinten, damit es in private namespace kommt und so.

01:19:18.785 --> 01:19:19.885
Und wenn jetzt

01:19:19.885 --> 01:19:22.885
implementiert der Proxy noch eine zweite Methode,

01:19:23.205 --> 01:19:25.865
wenn du es ganz einfach machst, nimmst du under under getAddr

01:19:25.865 --> 01:19:26.485
under under.

01:19:27.825 --> 01:19:29.905
Die wird ja immer dann getriggert, wenn jemand

01:19:29.905 --> 01:19:32.185
auf ein Attribut zugreift, was nicht definiert ist.

01:19:33.245 --> 01:19:34.105
Da der Proxy

01:19:34.105 --> 01:19:35.985
selber kein Attribut hat, wird es immer

01:19:35.985 --> 01:19:37.185
getriggert.

01:19:38.365 --> 01:19:39.945
In dem Moment würde er dann

01:19:39.945 --> 01:19:41.765
zum Beispiel ein Print machen von, ja,

01:19:41.825 --> 01:19:43.665
hier wurde jetzt auf folgendes Attribut zugegriffen

01:19:43.665 --> 01:19:45.865
und ruft dann

01:19:45.865 --> 01:19:48.065
self.under under context under under

01:19:48.065 --> 01:19:49.125
get attra

01:19:49.125 --> 01:19:51.105
dieses Objekt auf.

01:19:51.825 --> 01:19:54.065
Diese Attributnahme auf. Er reicht sozusagen

01:19:54.065 --> 01:19:55.665
den Methodenaufruf 1 zu 1 weiter

01:19:55.665 --> 01:19:57.945
und gibt es auch wieder zurück.

01:19:58.525 --> 01:20:00.745
Und dieses Objekt kannst du jetzt jedem anderen,

01:20:01.445 --> 01:20:02.545
der von Logging

01:20:02.545 --> 01:20:04.565
keine Ahnung hat, einfach in die Hand drücken

01:20:04.565 --> 01:20:06.705
und könntest damit zum Beispiel

01:20:06.705 --> 01:20:08.745
tracen, wer ruft

01:20:08.745 --> 01:20:10.385
denn hier auf diesem Objekt jetzt, wenn ich jetzt folgenden

01:20:10.385 --> 01:20:12.325
Client-Code habe, eigentlich was auf.

01:20:12.405 --> 01:20:14.605
Was wird da gemacht? Da könnte man auch einen Debugger bauen

01:20:14.605 --> 01:20:16.705
oder sowas quasi. Kannst du dir einen Debugger mitbauen,

01:20:16.785 --> 01:20:17.365
einen Flow-Debugger.

01:20:18.485 --> 01:20:18.765
Genau.

01:20:20.505 --> 01:20:22.125
Oder kannst du halt auch sozusagen,

01:20:22.125 --> 01:20:24.145
ja genau, einen Debugger. Kannst du zum Beispiel auch was machen

01:20:24.145 --> 01:20:25.845
mit, aha,

01:20:26.165 --> 01:20:27.845
den Code da hinten kann ich nicht ändern,

01:20:28.025 --> 01:20:29.965
weil der ist so irgendwie keine Ahnung wie, komme ich

01:20:29.965 --> 01:20:31.545
nicht ran, aber

01:20:31.545 --> 01:20:33.805
jetzt mache ich so ein Proxy-Objekt und wenn jemand

01:20:33.805 --> 01:20:35.825
auf dem Proxy-Objekt die Methode A aufruft,

01:20:35.905 --> 01:20:36.825
dann starte ich ein PDB.

01:20:41.005 --> 01:20:41.925
Und das

01:20:41.925 --> 01:20:44.125
ist dann ein Proxy, du wickelst

01:20:44.125 --> 01:20:44.765
etwas ein

01:20:44.765 --> 01:20:47.885
und gibst das eingewickelte Ding weiter mit dem

01:20:47.885 --> 01:20:48.965
anderen, mit dem Original drin.

01:20:49.605 --> 01:20:51.765
Da kann er quasi alles mitlesen, was der da

01:20:51.765 --> 01:20:53.285
an Daten aus der Datenbank zieht.

01:20:53.285 --> 01:21:08.925
Genau, also in Python kannst du, wie gesagt, es ist immer die Frage, diese Double-Under-Methoden, wenn du sagst, der andere kann alles an Python schreiben, was es gibt und du hast den Client-Code, der ist völlig unbekannt, dann musst du den auf C-Ebene schreiben, um wirklich sicher zu sein.

01:21:08.925 --> 01:21:11.245
wenn du aber weißt, was der andere Code macht

01:21:11.245 --> 01:21:13.925
dann kannst du Proxys auch rein in Python schreiben

01:21:13.925 --> 01:21:16.045
es ist nur in Python

01:21:16.045 --> 01:21:17.945
wenn jemand gegen dich arbeitet

01:21:17.945 --> 01:21:19.745
mit deiner Metaprogrammierung

01:21:19.745 --> 01:21:21.365
dann kommst du gegen das Gegenarbeiten

01:21:21.365 --> 01:21:23.685
auch erst wieder an, wenn du weißt, wie er gegen dich arbeitet

01:21:23.685 --> 01:21:27.385
damit kannst du keine Security bauen

01:21:27.385 --> 01:21:28.165
aber du kannst halt

01:21:28.165 --> 01:21:30.025
hilfreiche Dinge bauen

01:21:30.025 --> 01:21:35.545
oder du kannst zum Beispiel

01:21:35.545 --> 01:21:37.465
eine Proxy bauen, der alle Methodenaufrufe cached

01:21:37.465 --> 01:21:48.685
und das Schöne ist, du kannst das dann halt machen für Objekte, die du selber nicht unter Kontrolle hast.

01:21:48.885 --> 01:21:53.565
Also das ist sozusagen, du hast einmal die Objekte kommen von irgendwo, wo du den Code nicht ändern kannst

01:21:53.565 --> 01:21:57.965
und du steckst in irgendwas rein, wo du auch nicht ändern kannst, was da passiert

01:21:57.965 --> 01:22:02.505
und ein Proxy kann da an der Stelle halt dann plötzlich neue Fertigkeiten einführen,

01:22:02.505 --> 01:22:06.225
die mit beiden Codebasen im Prinzip nichts zu tun hatten.

01:22:07.465 --> 01:22:09.965
Ja, da gibt es verschiedene Magie mit dem Flow irgendwie was.

01:22:10.285 --> 01:22:11.245
Genau, genau.

01:22:13.625 --> 01:22:15.685
Okay, also das war der Proxy-Pattern.

01:22:15.685 --> 01:22:16.285
Das ist ein ganz interessanter Pattern.

01:22:16.285 --> 01:22:16.765
Ja, genau.

01:22:18.765 --> 01:22:21.825
So eine Strategy ist halt auch was ganz Interessantes noch.

01:22:21.985 --> 01:22:23.925
Vielleicht das wäre so eins, was ich reinbringen würde.

01:22:24.125 --> 01:22:27.445
Aber Jochen, magst du vielleicht noch eins?

01:22:28.805 --> 01:22:31.285
Ja, also zum Beispiel Fassade.

01:22:31.785 --> 01:22:36.525
Das ist halt sozusagen wie, baut man eine API sozusagen,

01:22:36.525 --> 01:22:38.625
wenn man eine komplizierte Geschichte

01:22:38.625 --> 01:22:40.405
hat mit vielen Objekten oder so, dann

01:22:40.405 --> 01:22:41.345
baut man davor halt

01:22:41.345 --> 01:22:44.465
eine API, die

01:22:44.465 --> 01:22:45.785
jetzt irgendwie einfacher zu bedienen ist.

01:22:46.105 --> 01:22:48.345
Das ist auch etwas, was man häufig hat und

01:22:48.345 --> 01:22:50.425
würde ich jetzt sagen, so in Python, was man

01:22:50.425 --> 01:22:52.385
da ganz oft macht, ist ja eben

01:22:52.385 --> 01:22:54.505
nicht das Pattern zu verwenden, sondern das halt irgendwie

01:22:54.505 --> 01:22:56.125
in, dann da in

01:22:56.125 --> 01:22:58.325
das PY zu schreiben sozusagen, was halt

01:22:58.325 --> 01:22:59.705
exportiert werden soll und

01:22:59.705 --> 01:23:02.605
quasi alles so umzuorganisieren,

01:23:02.705 --> 01:23:04.425
dass es dann halt von außen gut aussieht.

01:23:04.885 --> 01:23:05.605
Ja, genau.

01:23:06.525 --> 01:23:08.345
ja.

01:23:09.125 --> 01:23:10.865
Decorator sind in Python Sprachfeature

01:23:10.865 --> 01:23:11.285
inzwischen.

01:23:12.225 --> 01:23:14.025
Das war auch mal

01:23:14.025 --> 01:23:15.545
ein separates Muster.

01:23:16.925 --> 01:23:17.605
Aber ich meine,

01:23:17.745 --> 01:23:19.805
Decorator-Pattern ist das nicht das, wo man

01:23:19.805 --> 01:23:21.945
so etwas machen kann, wie wenn man aus einem

01:23:21.945 --> 01:23:23.905
File liest, dann die Leerzeilen

01:23:23.905 --> 01:23:25.225
wegschmeißen oder sowas?

01:23:25.305 --> 01:23:27.845
Man rappt den Funktionsabruf und Input und Output

01:23:27.845 --> 01:23:28.985
kann man dann immer modifizieren?

01:23:29.725 --> 01:23:31.885
Nee, das ist ein Python-Decorator,

01:23:32.025 --> 01:23:33.425
also das mit dem Add irgendwas drüber.

01:23:34.045 --> 01:23:36.145
Ich meine, das Decorator-Pattern wäre ein bisschen anders.

01:23:36.525 --> 01:23:59.065
Aber vielleicht höre ich mich auch quasi nicht mehr genau. Ich meinte, das wäre halt irgendwie sowas, dass du halt sozusagen tust halt so, als wäre das ein normales File, aber in Wirklichkeit schmeißt das Objekt, was du halt mit dem Deco-Hater-Pattern gebaut hast, halt intern sowas wie Leerteilen weg oder Dinge, die nicht gepasst werden können oder so.

01:23:59.065 --> 01:24:01.305
und dann... Tatsächlich ist es gerade auch so ein bisschen

01:24:01.305 --> 01:24:03.325
ähnlich zu dem Proxy,

01:24:03.445 --> 01:24:05.245
wie wir es beschrieben haben. Da ist in Python

01:24:05.245 --> 01:24:06.625
der Unterschied nicht so groß.

01:24:07.445 --> 01:24:09.305
Ja, ja. Hier wird nochmal, also ich gucke

01:24:09.305 --> 01:24:11.365
gerade immer so ein bisschen nochmal die Wiki-Seiten nebenbei

01:24:11.365 --> 01:24:13.325
nach. Beim Decorator wird

01:24:13.325 --> 01:24:15.365
nochmal explizit darauf hingewiesen,

01:24:15.445 --> 01:24:16.525
dass man hier halt chainen kann.

01:24:17.285 --> 01:24:18.605
Das kannst du im Proxy aber auch machen.

01:24:19.305 --> 01:24:21.365
Dass du da mehrere hintereinander schaltest.

01:24:22.665 --> 01:24:23.105
Ja.

01:24:25.545 --> 01:24:25.985
Ja.

01:24:25.985 --> 01:24:26.045
Ja.

01:24:29.065 --> 01:24:29.065


01:24:29.065 --> 01:24:29.945
und ansonsten

01:24:29.945 --> 01:24:30.505
was mir noch, au,

01:24:30.905 --> 01:24:33.905
letztens ist mir das aufgefallen,

01:24:34.205 --> 01:24:35.805
Mysterium, ich weiß nicht in welcher Episode

01:24:35.805 --> 01:24:37.985
wir das hatten, da habe ich mich irgendwann mal gewundert,

01:24:39.425 --> 01:24:40.165
da dachte ich

01:24:40.165 --> 01:24:41.905
zuerst, das muss irgendwann letztes Jahr gewesen sein,

01:24:41.965 --> 01:24:43.905
ob das irgendwie eine Python 3.8 Neuerung gewesen

01:24:43.905 --> 01:24:45.565
wäre oder so, ich weiß es nicht,

01:24:45.645 --> 01:24:47.665
hat ja mit Listen von irgendwelchen Dingen zu tun, mit

01:24:47.665 --> 01:24:49.065
Listen von Integers

01:24:49.065 --> 01:24:51.505
und das war deutlich

01:24:51.505 --> 01:24:53.805
kleiner, als ich das gedacht hätte.

01:24:55.025 --> 01:24:55.745
Ich dachte so, hä,

01:24:55.745 --> 01:24:57.185
komisch, warum,

01:24:57.745 --> 01:24:58.805
also es braucht tatsächlich nur

01:24:58.805 --> 01:24:59.525
irgendwie

01:24:59.525 --> 01:25:04.505
8 Byte irgendwie

01:25:04.505 --> 01:25:05.565
pro Integer.

01:25:06.385 --> 01:25:07.885
Eigentlich hätte ich jetzt mit deutlich mehr gerechnet.

01:25:08.625 --> 01:25:09.965
Weiß ich nicht, eher so

01:25:09.965 --> 01:25:12.365
23 oder

01:25:12.365 --> 01:25:12.965
weiß ich irgendwas.

01:25:14.625 --> 01:25:15.945
Darum ist das so viel kleiner.

01:25:16.865 --> 01:25:18.645
Und die Antwort darauf habe ich jetzt gefunden

01:25:18.645 --> 01:25:20.285
und das ist eigentlich blöd, aber

01:25:20.285 --> 01:25:22.525
ich weiß nicht, wisst ihr das zufällig? Oder hättet ihr eine Ahnung

01:25:22.525 --> 01:25:24.125
gehabt, was das hätte sein können?

01:25:25.165 --> 01:25:26.565
Also ich habe halt eine Liste gemacht mit

01:25:26.565 --> 01:25:28.265
irgendwie, weiß ich nicht, 100 Millionen

01:25:28.265 --> 01:25:32.245
Integers und das war halt dann bloß 800 MB im Hauptspeicher und ich hätte aber eigentlich erwartet,

01:25:32.385 --> 01:25:33.605
dass es hätte deutlich mehr sein müssen.

01:25:35.305 --> 01:25:36.565
Ich wäre ja die Redundanzen weggelassen.

01:25:38.845 --> 01:25:42.365
Das, was da tatsächlich passiert ist, ist halt intern benutzer

01:25:42.365 --> 01:25:46.405
Python-Interpreter auch ein Pattern, um halt Integers

01:25:46.405 --> 01:25:50.285
und zwar nur kleine Integers sozusagen da Hauptspeicher

01:25:50.285 --> 01:25:53.705
zu sparen. Das Pattern nennt man Flyweight

01:25:53.705 --> 01:25:56.405
und die

01:25:56.405 --> 01:25:57.965
Integer von 0 bis

01:25:57.965 --> 01:26:00.185
255, glaube ich, sind halt

01:26:00.185 --> 01:26:02.365
irgendwie immer die gleichen. Also man kriegt immer das gleiche

01:26:03.085 --> 01:26:04.385
Integer sozusagen zu sehen

01:26:04.385 --> 01:26:05.585
und deswegen ist das halt

01:26:05.585 --> 01:26:08.445
im Hauptspeicher deutlich kleiner.

01:26:08.665 --> 01:26:08.905
Das heißt,

01:26:10.005 --> 01:26:11.925
es gibt halt sozusagen nur...

01:26:11.925 --> 01:26:12.965
Ist ja auch eine Form von Singleton.

01:26:13.365 --> 01:26:15.505
Es ist sehr ähnlich zu Singleton, genau.

01:26:16.545 --> 01:26:18.445
Also eigentlich ist das halt für solche Dinge gedacht,

01:26:18.565 --> 01:26:19.885
wie du hast halt,

01:26:21.125 --> 01:26:21.465
wenn du jetzt

01:26:21.465 --> 01:26:26.905
in einen Textprocessor

01:26:26.905 --> 01:26:30.825
hast, so ein Programm, was sowas wie Word oder so, und wenn das jetzt

01:26:30.825 --> 01:26:34.085
Buchstaben rendert, dann willst du halt nicht immer

01:26:34.085 --> 01:26:37.205
quasi alles, was halt in

01:26:37.205 --> 01:26:43.005
der Buchstabe ist halt ein Objekt, dann willst du nicht immer alles für jeden Buchstaben,

01:26:43.005 --> 01:26:47.065
was da dran hängt, nochmal haben, sondern du willst es halt nur den Teil in dem

01:26:47.065 --> 01:26:50.665
Buchstaben austauschen, der halt ausgetauscht werden soll, und der ganze Rest bleibt einfach immer gleich.

01:26:51.465 --> 01:26:53.165
und genau, für sowas ist es eigentlich gedacht und

01:26:53.165 --> 01:26:55.345
in Python wird es halt auch für Integers

01:26:55.345 --> 01:26:57.305
verwendet und deswegen

01:26:57.305 --> 01:26:59.165
ist halt, wenn man jetzt sagt

01:26:59.165 --> 01:27:01.305
Liste von 100 Millionen

01:27:01.305 --> 01:27:03.045
Integers, also für i in Range

01:27:03.045 --> 01:27:04.745
weiß ich nicht, 100 Millionen,

01:27:05.325 --> 01:27:07.265
aber dann sagt man halt irgendwie sowas wie 0 oder

01:27:07.265 --> 01:27:09.105
5 oder so, dann ist das halt sehr klein,

01:27:09.725 --> 01:27:10.805
aber wenn man sagt

01:27:10.805 --> 01:27:11.545
nicht

01:27:11.545 --> 01:27:15.145
0, sondern irgendwie

01:27:15.145 --> 01:27:17.085
i, dann wird es plötzlich sehr groß.

01:27:17.565 --> 01:27:18.745
Also dann hat man den Vorteil nicht mehr.

01:27:19.385 --> 01:27:21.125
Aber genau, da hatte ich mich

01:27:21.125 --> 01:27:25.945
irgendwann mal drüber gewundert und jetzt habe ich irgendwann zufällig gesehen, woran das lag.

01:27:27.205 --> 01:27:29.505
In Python gibt es ja noch den Begriff in-turning für.

01:27:30.845 --> 01:27:38.425
Das kann man dann auch ganz gut sehen, wenn man die Objekte dann mit einem Identitätsvergleich anguckt.

01:27:39.345 --> 01:27:42.805
Dann sind es halt tatsächlich wirklich immer, dass das Is das Gleiche ist.

01:27:44.585 --> 01:27:46.285
Und das gibt es bei Strings halt auch.

01:27:46.285 --> 01:28:16.265
und Jochen unterhalten sich über die Programmiersprache Python

01:28:16.285 --> 01:28:46.265
und die Programmiersprache Python.

01:28:46.285 --> 01:28:59.705
und die Sprache, die wir unterstützen. Dann kannst du halt das lange LF so refaktorieren, dass du jeden Teil davon in eine eigene Funktion packst.

01:29:00.705 --> 01:29:15.025
Und entweder legst du die alle nach einem bestimmten Schema benannt in eine Klasse, sagst also sozusagen class country address format

01:29:15.025 --> 01:29:19.925
und die Methoden darauf sind dann entsprechend zum Beispiel die ISO-Codes von den Ländern.

01:29:20.825 --> 01:29:25.545
Und wenn du dann für eine Adresse, die du hast, dann sowas formatieren möchtest,

01:29:25.645 --> 01:29:27.865
dann kannst du sagen, so, dann schnappen wir uns die Klasse,

01:29:28.485 --> 01:29:32.405
lesen von dem Objekt runter den ISO-Code von dem Land

01:29:32.405 --> 01:29:35.885
und rufen dann die Methode auf, deren Namen dem ISO-Code entspricht.

01:29:37.205 --> 01:29:41.885
Und dann kannst du natürlich dir auch überlegen, das muss ich ja nicht unbedingt auf einer Klasse machen,

01:29:41.885 --> 01:30:16.188
und die Programmiersprache Python noch andere ISO reinzuschreiben die ich halt noch nicht kannte und mein Code ist dann in der Lage jede beliebige Art der Formatierung aufzurufen Oder jemand anderes kann auch hergehen und sagen hey ich definiere dein Format f italienische Adressen gef mir nicht also ich jetzt diesen DICT von IT mit meiner eigenen Methode

01:30:16.188 --> 01:30:18.148
und der Code, der aber jetzt

01:30:18.148 --> 01:30:20.547
das aufruft, der hat halt jetzt keine

01:30:20.547 --> 01:30:21.307
hartcodierten

01:30:21.307 --> 01:30:24.487
LFL-Zweige mehr, sondern

01:30:24.487 --> 01:30:26.467
der macht immer bloß noch dieses Dictionary-Lookup von

01:30:26.467 --> 01:30:28.427
ja, mit welcher Methode soll ich es denn formatieren?

01:30:29.767 --> 01:30:30.607
Und das ist dann

01:30:30.607 --> 01:30:32.067
halt eine sogenannte Strategy im Prinzip.

01:30:34.227 --> 01:30:34.367
Hm.

01:30:36.727 --> 01:30:37.047
Ja.

01:30:38.107 --> 01:30:39.047
Und was ist ein Observer?

01:30:43.107 --> 01:30:43.467
Hm.

01:30:43.467 --> 01:30:46.947
Ich gucke nach.

01:30:47.367 --> 01:30:48.807
Muss ich hier auch nachgucken.

01:30:49.207 --> 01:30:50.567
Happy Google this for you.

01:30:50.807 --> 01:30:52.807
Also ich glaube, das ist, ach doch, warte mal, das ist halt

01:30:52.807 --> 01:30:55.007
wenn du benachrichtigt

01:30:55.007 --> 01:30:56.668
werden möchtest, wenn sich

01:30:56.668 --> 01:30:57.567
irgendwas geändert hat.

01:30:57.867 --> 01:30:59.648
Also die, die den Bescheid sagt.

01:31:00.427 --> 01:31:00.987
Ja, du

01:31:00.987 --> 01:31:04.867
registrierst

01:31:04.867 --> 01:31:06.887
dich halt irgendwo, quasi.

01:31:07.107 --> 01:31:08.987
Also alle, die benachrichtigt werden möchten,

01:31:09.267 --> 01:31:10.607
registrieren sich irgendwie und dann

01:31:10.607 --> 01:31:12.527
rufst du da einmal

01:31:12.527 --> 01:31:13.767
halt das auf

01:31:13.767 --> 01:31:16.067
und dann werden halt alle benachrichtigt.

01:31:16.387 --> 01:31:18.467
Ach Gott. Ja, es ist lange her,

01:31:18.547 --> 01:31:20.207
dass ich mich damit beschäftigt habe.

01:31:22.107 --> 01:31:22.327
Ja.

01:31:23.047 --> 01:31:23.987
Das hat man im SOAP auch.

01:31:24.067 --> 01:31:26.467
Das war das Event-Handling-System

01:31:26.467 --> 01:31:26.887
tatsächlich.

01:31:28.188 --> 01:31:30.527
Das ist halt ein...

01:31:31.287 --> 01:31:32.387
Du hast zwei Enden,

01:31:32.447 --> 01:31:34.247
die da mitspielen müssen. Das eine ist,

01:31:34.807 --> 01:31:36.327
du möchtest halt,

01:31:36.867 --> 01:31:38.247
dass zu bestimmten Ereignissen

01:31:38.247 --> 01:31:40.387
in deiner Anwendung andere Leute

01:31:40.387 --> 01:31:42.327
flexibel definieren können, was da alles noch

01:31:42.327 --> 01:32:12.307
und die Programmiersprache Python.

01:32:12.327 --> 01:32:15.648
zu registrieren oder Interface oder was immer, aber so im einfachsten Fall sagst du sowas wie

01:32:15.648 --> 01:32:20.307
Event Trigger, Event Name und danach übergibst du zum Beispiel

01:32:20.307 --> 01:32:24.447
irgendeinen eventspezifischen Payload, das ist in Python ja auch schön zu machen,

01:32:24.547 --> 01:32:28.227
weil du ja auch mit Stern-Arcs, Stern-Stern-KW-Arcs arbeiten kannst, aber

01:32:28.227 --> 01:32:32.207
du würdest halt sagen, so, Record Change als Event und hier ist das

01:32:32.207 --> 01:32:35.707
Objekt, was sich geändert hat und jemand anders kann zu dem Event-System als

01:32:35.707 --> 01:32:40.247
unparteiischen Dritten hingehen und sagen, so, hier ist eine Funktion, die übergebe

01:32:40.247 --> 01:32:45.347
und die rufst du bitte immer dann auf, wenn ein Record Change Event kommt.

01:32:45.547 --> 01:32:50.188
Das ist so wie man es in JavaScript ja auch kennt, dass man sagt, ich möchte bei einem Mausklick benachrichtigt werden,

01:32:50.287 --> 01:32:56.668
ich möchte bei einem Tastaturanschlag benachrichtigt werden, so kann man das natürlich auch einfach für beliebige Dinge kodieren

01:32:56.668 --> 01:33:00.507
und wichtig dabei ist halt, daraus baut man sich sein eigenes Framework.

01:33:00.648 --> 01:33:07.287
In JavaScript ist über das DOM ja definiert, welche Events es da gibt und das ist eine Art, wie man sich selber solche Events halt bauen kann,

01:33:07.287 --> 01:33:17.847
dass man sagt, okay, wenn auf einem Record-Objekt das Save aufgerufen wird, dann triggert der gleichzeitig noch, wenn sich tatsächlich was geändert hat, diesen Event

01:33:17.847 --> 01:33:24.648
und dann kannst du zum Beispiel solche Dinge tun wie wieder loggen oder nochmal ein anderes Event mitschreiben oder keine Ahnung

01:33:24.648 --> 01:33:26.668
Also quasi Event-Signale abfangen quasi

01:33:26.668 --> 01:33:28.267
Kann man Signale abfangen, genau

01:33:28.267 --> 01:33:32.927
Und wichtig ist halt an der Stelle, das ist in Python dann typischerweise eine synchrone Aktion

01:33:32.927 --> 01:33:35.148
weil ja im Prinzip, du rufst die eine Funktion

01:33:35.148 --> 01:33:36.927
auf, die ruft dann, die macht ein

01:33:36.927 --> 01:33:38.887
sogenanntes, das nennt sich auch Method Dispatch

01:33:38.887 --> 01:33:41.067
die ruft dann

01:33:41.067 --> 01:33:43.127
auf, die guckt

01:33:43.127 --> 01:33:45.168
danach, da kann man auch überlegen, darf es

01:33:45.168 --> 01:33:46.927
mehrere Händler geben oder nur einen

01:33:46.927 --> 01:33:48.987
in welcher Reihenfolge werden die aufgeführt, das sind dann so

01:33:48.987 --> 01:33:50.547
wirklich so differenzierte

01:33:50.547 --> 01:33:52.927
Betrachtungen von dem konkreten Eventsystem, was man

01:33:52.927 --> 01:33:54.927
sich baut, oder

01:33:54.927 --> 01:33:56.847
gibt es nur ein Bestmatch von, je nachdem

01:33:56.847 --> 01:33:58.807
dass ich auch noch auf Typen von den Parametern

01:33:58.807 --> 01:34:01.007
matche, sowas wie, ich will aufgerufen werden

01:34:01.007 --> 01:34:04.688
beim Record Change, aber nur wenn der Record vom Typ Person war und solche Sachen.

01:34:05.427 --> 01:34:06.927
Und dann kannst du halt solche Dinge machen wie

01:34:06.927 --> 01:34:12.188
ein User setzt eine Bestellung ab und

01:34:12.188 --> 01:34:16.507
ein anderer Code von dir, ein anderes Modul, ist zum Beispiel dafür da, eine E-Mail

01:34:16.507 --> 01:34:19.267
rauszuschicken, wenn der User seine allererste Bestellung abschickt.

01:34:20.907 --> 01:34:24.387
Ja, dann kannst du das halt als völlig komplex... Häufig geht es bei

01:34:24.387 --> 01:34:28.547
diesen Sachen darum, wie kann ich Code so geschickt modularisieren,

01:34:28.547 --> 01:34:30.807
dass ich halt später, wenn ich die Anwendung

01:34:30.807 --> 01:34:32.707
umbaue, möglichst wenig umstricken

01:34:32.707 --> 01:34:34.867
muss und mir selber auf den Füßen

01:34:34.867 --> 01:34:36.847
stehe. Idealerweise kannst

01:34:36.847 --> 01:34:38.668
du halt dann auch mit sowas wie FeatureFlex

01:34:38.668 --> 01:34:40.727
ganze Module stilllegen und

01:34:40.727 --> 01:34:42.887
das ergibt aber trotzdem noch eine konsistente Anwendung

01:34:42.887 --> 01:34:44.847
und nicht, ah da musst du in der

01:34:44.847 --> 01:34:46.688
Klasse die drei Zeilen da wegschmeißen, in der

01:34:46.688 --> 01:34:48.847
Klasse die drei Zeilen, in der Klasse die drei Zeilen

01:34:48.847 --> 01:34:50.648
sondern daraus kriegst du halt so eine

01:34:50.648 --> 01:34:52.947
komponierbare Anwendungsarchitektur

01:34:52.947 --> 01:34:53.707
im Prinzip nachher.

01:34:55.287 --> 01:34:55.807
Mhm, okay.

01:34:57.387 --> 01:34:58.188
Und auch da wichtig,

01:34:58.547 --> 01:35:00.247
und die

01:35:28.547 --> 01:35:31.168
und hier jetzt geht der Blumenstrauß auf von

01:35:31.168 --> 01:35:32.887
wie könnte man das eigentlich alles bauen

01:35:32.887 --> 01:35:34.927
und das heißt aber nicht, dass man das halt

01:35:34.927 --> 01:35:36.947
jedes Mal ständig in der Vollausprägung baut

01:35:36.947 --> 01:35:39.307
ich weiß, ich sage das jetzt zum dritten Mal, aber

01:35:39.307 --> 01:35:41.227
ich habe auch gelernt, wenn man

01:35:41.227 --> 01:35:43.168
Dinge zum siebten Mal sagt, dann hat die Hälfte

01:35:43.168 --> 01:35:44.287
deutlich zum ersten Mal gehört

01:35:44.287 --> 01:35:46.987
und das habe ich auch heute gelernt, weil du gerade

01:35:46.987 --> 01:35:49.148
vom Blumenstrauß an Methoden sprachst, es gibt auch Welkeblumen

01:35:49.148 --> 01:35:49.967
in Blumensträußen

01:35:49.967 --> 01:35:52.247
ja genau, es gibt auch Welkeblumen

01:35:52.247 --> 01:35:54.867
möchtest du Welke

01:35:54.867 --> 01:35:56.847
möchtest du unter den Patterns Welkeblumen suchen

01:35:56.847 --> 01:35:59.207
Ja, tatsächlich, du weißt ja nicht genau

01:35:59.207 --> 01:36:01.367
was da stimmt, wenn du jetzt davon noch keine Ahnung

01:36:01.367 --> 01:36:02.927
hast und die eben nicht durch

01:36:02.927 --> 01:36:05.127
von vornherein verstehst, oh ja,

01:36:05.227 --> 01:36:07.188
das ist das dies und jenes, sondern du versuchst

01:36:07.188 --> 01:36:09.087
halt dich irgendwie an eine, ich sag mal,

01:36:09.148 --> 01:36:10.847
clevere Architektur zu halten oder

01:36:10.847 --> 01:36:13.327
eine, die du für clever hältst, vielleicht weil du es noch nicht verstehst

01:36:13.327 --> 01:36:14.887
oder denkst, du müsstest halt in die Richtung

01:36:14.887 --> 01:36:16.867
entwickeln, um möglichst

01:36:16.867 --> 01:36:19.007
flexibel oder modular zu bleiben oder so

01:36:19.007 --> 01:36:21.127
oder halt verschiedene Schnittstellen aufmachen

01:36:21.127 --> 01:36:23.007
zu können, wenn du sie brauchst, dann

01:36:23.007 --> 01:36:24.967
könnte sowas ja passieren, dass man eine

01:36:24.967 --> 01:36:27.227
welke Blume baut, weil man da irgendwelchen Unsinn gebaut hat.

01:36:27.887 --> 01:36:29.087
Also speziell halt,

01:36:29.188 --> 01:36:30.627
das kommt dann eher aus dem Agilen, das

01:36:30.627 --> 01:36:31.927
you ain't gonna need it.

01:36:32.727 --> 01:36:34.587
Also ich finde halt, man sollte sich bei der Anwendungsmöglichkeit

01:36:34.587 --> 01:36:37.027
extrem stark auf den, erst mal

01:36:37.027 --> 01:36:39.168
auf den Inhalt der Anwendung

01:36:39.168 --> 01:36:40.267
konzentrieren.

01:36:41.307 --> 01:36:42.927
Und erst wenn man eine gewisse Menge

01:36:42.927 --> 01:36:45.027
und Masse beisammen hat und überhaupt weiß, worum es

01:36:45.027 --> 01:36:46.487
eigentlich geht und was man tut,

01:36:47.367 --> 01:36:48.887
dann kann man irgendwie ans Gärtnern gehen und kann

01:36:48.887 --> 01:36:50.927
gucken, okay, jetzt räumen wir hier mal auf. Also da ist

01:36:50.927 --> 01:36:52.887
Python als Sprache natürlich auch wieder extrem gut

01:36:52.887 --> 01:36:54.627
positioniert, weil

01:36:54.627 --> 01:36:56.627
und die

01:37:24.627 --> 01:37:54.607
und die Programmiersprache Python.

01:37:54.627 --> 01:37:58.127
aber für mich ist das immer eine Sache, das geht erst am konkreten Objekt.

01:37:58.407 --> 01:38:02.807
Ich kann mich nicht vorher hinsetzen und sagen, so, wir bauen jetzt ein neues Backup-System,

01:38:03.188 --> 01:38:04.567
wir brauchen einen Observer.

01:38:12.947 --> 01:38:16.688
Und ich glaube, was eben ganz wichtig ist, was bei den Patterns auch...

01:38:16.688 --> 01:38:18.127
Also Yagni ist auch kein Pattern.

01:38:18.127 --> 01:38:47.547
Persistency means having to say I'm sorry

01:38:48.127 --> 01:38:48.467
und die

01:38:48.467 --> 01:38:48.487
Programmiersprache Python

01:38:48.487 --> 01:38:48.507
und die

01:38:48.507 --> 01:38:48.567
Programmiersprache Python

01:38:48.567 --> 01:38:48.627
und die

01:38:48.627 --> 01:38:48.667
Programmiersprache Python

01:38:48.667 --> 01:38:49.127
und die

01:38:49.127 --> 01:38:49.148
Programmiersprache Python

01:38:49.148 --> 01:38:49.167
und die

01:38:49.167 --> 01:38:49.188
Programmiersprache Python

01:38:49.188 --> 01:38:49.207
und die

01:38:49.207 --> 01:38:49.267
Programmiersprache Python

01:38:49.267 --> 01:38:49.287
und die

01:38:49.287 --> 01:38:49.347
Programmiersprache Python

01:38:49.347 --> 01:38:49.387
und die

01:38:49.387 --> 01:38:49.427
Programmiersprache Python

01:38:49.427 --> 01:38:49.467
und die

01:38:49.467 --> 01:38:49.567
Programmiersprache Python

01:38:49.567 --> 01:38:49.587
und die

01:38:49.587 --> 01:38:49.667
Programmiersprache Python

01:38:49.667 --> 01:38:49.688
und die

01:38:49.688 --> 01:38:49.787
Programmiersprache Python

01:38:49.787 --> 01:38:49.867
und die

01:38:49.867 --> 01:38:49.947
Programmiersprache Python

01:38:49.947 --> 01:38:50.007
und die

01:38:50.007 --> 01:38:50.067
Programmiersprache Python

01:38:50.067 --> 01:38:50.127
und die

01:38:50.127 --> 01:38:50.188
Programmiersprache Python

01:38:50.188 --> 01:38:50.228
und die

01:38:50.228 --> 01:38:50.267
Programmiersprache Python

01:38:50.267 --> 01:38:50.327
und die

01:38:50.327 --> 01:38:50.427
Programmiersprache Python

01:38:50.427 --> 01:38:50.527
und die

01:38:50.527 --> 01:38:50.587
Programmiersprache Python

01:38:50.587 --> 01:38:50.667
und die

01:38:50.667 --> 01:38:50.767
Programmiersprache Python

01:38:50.767 --> 01:38:50.827
und die

01:38:50.827 --> 01:38:50.907
Programmiersprache Python

01:38:50.907 --> 01:38:50.927
und die

01:38:50.927 --> 01:38:51.027
Programmiersprache Python

01:38:51.027 --> 01:38:51.087
und die

01:38:51.087 --> 01:38:51.188
Programmiersprache Python

01:38:51.188 --> 01:38:51.267
und die

01:38:51.267 --> 01:38:51.327
Programmiersprache Python

01:38:51.327 --> 01:38:51.387
und die

01:38:51.387 --> 01:38:51.667
Programmiersprache Python

01:38:51.667 --> 01:38:51.688
und die

01:38:51.688 --> 01:38:51.767
Programmiersprache Python

01:38:51.767 --> 01:38:51.787
und die

01:38:51.787 --> 01:38:51.867
Programmiersprache Python

01:38:51.867 --> 01:38:51.887
und die

01:38:51.887 --> 01:38:51.947
Programmiersprache Python

01:38:51.947 --> 01:38:51.987
und die

01:38:51.987 --> 01:38:52.027
Programmiersprache Python

01:38:52.027 --> 01:38:52.067
und die

01:38:52.067 --> 01:38:52.127
Programmiersprache Python

01:38:52.127 --> 01:38:52.188
und die

01:38:52.188 --> 01:38:52.287
Programmiersprache Python

01:38:52.287 --> 01:38:52.387
und die

01:38:52.387 --> 01:38:52.587
Programmiersprache Python

01:38:52.587 --> 01:38:52.667
und die

01:38:52.667 --> 01:38:52.728
Programmiersprache Python

01:38:52.728 --> 01:38:52.787
und die

01:38:52.787 --> 01:38:52.827
Programmiersprache Python

01:38:52.827 --> 01:38:52.887
und die

01:38:52.887 --> 01:38:52.907
Programmiersprache Python

01:38:52.907 --> 01:38:52.947
und die

01:38:52.947 --> 01:38:52.987
Programmiersprache Python

01:38:52.987 --> 01:38:53.007
und die

01:38:53.007 --> 01:39:11.067
Programmiersprache Python

01:39:11.067 --> 01:39:11.087
und die

01:39:11.087 --> 01:39:12.587
das einmal auf Platte geschrieben hast,

01:39:14.087 --> 01:39:15.047
dann kannst du aber wissen, dass das

01:39:15.047 --> 01:39:16.267
sich in 10 Jahren noch verfolgt.

01:39:18.087 --> 01:39:18.487
Ja.

01:39:18.987 --> 01:39:20.667
Ja, und wenn man das richtig gemacht hat, dann

01:39:20.667 --> 01:39:23.188
hat man halt

01:39:23.188 --> 01:39:25.188
sozusagen auch später noch großen Nutzen.

01:39:25.648 --> 01:39:27.167
Der schöne Spruch da an der Stelle

01:39:27.167 --> 01:39:28.927
ist ja immer irgendwie Daten,

01:39:29.228 --> 01:39:30.847
also gute Daten altern wie Wein.

01:39:31.087 --> 01:39:33.287
Das ist halt schön, wenn man irgendwie mehr gute Daten hat.

01:39:33.287 --> 01:39:34.307
Schlechte wie Milch.

01:39:35.947 --> 01:39:37.087
Ja, Applikationscode,

01:39:37.127 --> 01:39:39.007
wenn man gesagt hat, Applikationscode altert wie Fisch.

01:39:39.447 --> 01:39:39.947
Das ist halt

01:40:09.947 --> 01:40:11.407
durchaus auch und so.

01:40:11.907 --> 01:40:12.188
Jaja.

01:40:12.967 --> 01:40:15.607
Ich glaube an der Stelle auch, das ist halt der handwerkliche

01:40:15.607 --> 01:40:15.607
Teil Teil Teil Teil

01:40:39.947 --> 01:41:09.927
und die Programmiersprache Python.

01:41:09.947 --> 01:41:16.947
Client Code auf Attribute zugreift, jemals noch irgendwie sich dazwischen zu hängeln.

01:41:16.947 --> 01:41:23.387
Das ist ein reiner Future Proofing Aspekt und ich sehe immer wieder Leute, die aus der

01:41:23.387 --> 01:41:27.188
Java-Welt kommen, die in Python Code schreiben und dann für jedes Attribut eine Getter Setter

01:41:27.188 --> 01:41:33.188
Methode schreiben und du siehst sofort, dass es Java und wenn man dir dann irgendwann erzählt,

01:41:33.188 --> 01:41:37.747
nein, es gibt, du kannst im Nachhinein eine Property draus machen, kannst machen was du

01:41:37.747 --> 01:42:07.728
und die Technik der Sprache.

01:42:07.747 --> 01:42:12.087
transportiert, muss man schon immer noch mal extrem gut auf die Suche gehen von

01:42:12.087 --> 01:42:15.907
hat es hier nicht irgendeine andere Mechanik in Python, die das schon

01:42:15.907 --> 01:42:19.907
überflüssig macht. Wir haben die Dekoratoren,

01:42:20.407 --> 01:42:23.047
wir haben die Konstrukturen, wir haben New, wir haben

01:42:23.047 --> 01:42:27.387
Properties, die ganzen Sachen

01:42:27.387 --> 01:42:30.927
und die erschlagen viele von diesen anderen Sachen halt.

01:42:34.987 --> 01:42:36.148
Ja, okay.

01:42:36.148 --> 01:42:42.728
Also die Gang of Four Patterns habt ihr schon einigermaßen einmal kurz eingekringelt und erwischt.

01:42:43.387 --> 01:42:44.207
Würde ich sagen, ja.

01:42:45.327 --> 01:42:47.587
Gibt es noch welche, über die ihr unbedingt reden möchtet?

01:42:48.667 --> 01:43:03.087
Naja, es gibt dann auch so ein paar, die halt später dazugekommen sind, beziehungsweise Sachen, wo man nicht so klar sagen kann, ist das jetzt eigentlich ein Designpattern oder sowas wie, ja, MVC, weiß ich jetzt nicht, ist das ein Designpattern, eher nicht, ein bisschen größer, keine Ahnung.

01:43:04.107 --> 01:43:05.067
Model View Controller.

01:43:05.067 --> 01:43:05.767
Ja genau

01:43:05.767 --> 01:43:09.728
Schwer zu sagen oder sowas wie

01:43:09.728 --> 01:43:11.587
Model View Controllers

01:43:11.587 --> 01:43:12.067
älter

01:43:12.067 --> 01:43:14.867
Das war nicht

01:43:14.867 --> 01:43:16.367
Also Model View selber

01:43:16.367 --> 01:43:18.987
Das ist eine Anwendungsarchitektur

01:43:18.987 --> 01:43:20.927
Die kam aber

01:43:20.927 --> 01:43:23.407
82

01:43:23.407 --> 01:43:24.648
83 irgendwann

01:43:24.648 --> 01:43:27.387
Also die war halt schon

01:43:27.387 --> 01:43:28.767
auch bevor man sich mit dem Begriff

01:43:28.767 --> 01:43:30.867
Patterns auseinandergesetzt hatte an der Stelle

01:43:30.867 --> 01:43:32.167
Ja kann gut sein

01:43:32.167 --> 01:43:55.527
Ja, oder halt so etwas wie, ich glaube, die kam aber dann tatsächlich später, Datenbank, so ORM, so wie baue ich eigentlich ein ORM, also so was, eben Active Record oder halt Datamapper-Pattern, das ist halt auch so, tja, keine Ahnung, ob das Pattern sind oder

01:43:55.527 --> 01:43:57.487
Was ist denn das hier schon wieder?

01:43:57.487 --> 01:44:22.267
Ja, das ist halt die Frage, wie man sozusagen die Übersetzung macht zwischen Sachen, die jetzt in der Datenbank, vor allem in den relationalen Datenbanken liegen und halt Objekten in Python beispielsweise. Das sind halt diese beiden unterschiedlichen Dinge. Also Active Record ist halt das, was Django macht oder halt auch Ruby und Rails und Data Mapper ist halt das, was SQL Alchemy macht.

01:44:25.867 --> 01:44:26.827
Und was ist der Unterschied?

01:44:27.487 --> 01:44:57.467
und Jochen unterhalten sich über die Programmiersprache Python

01:44:57.487 --> 01:44:59.007
Dann fangst du noch mit

01:44:59.007 --> 01:44:59.987
XS Record an, Jochen?

01:45:00.648 --> 01:45:03.127
Ja, also da ist es halt so, dass quasi

01:45:03.127 --> 01:45:05.188
jedes Objekt

01:45:05.188 --> 01:45:07.127
repräsentiert halt eine Zeile in der Datenbank

01:45:07.127 --> 01:45:08.787
und die Attribute sind halt die

01:45:08.787 --> 01:45:09.487
Spalten.

01:45:12.707 --> 01:45:13.707
Wenn man halt

01:45:13.707 --> 01:45:15.307
Dinge aus der Datenbank holt, dann hat man

01:45:15.307 --> 01:45:17.228
halt eine Liste von diesen Objekten und

01:45:17.228 --> 01:45:19.287
wenn man die Attribute ändert, dann speichert das halt

01:45:19.287 --> 01:45:21.367
die, kann man halt sagen, auf dem Objekt, auf der Zeile

01:45:21.367 --> 01:45:23.148
halt, speichert das und dann

01:45:23.148 --> 01:45:24.987
geht das halt zurück in die Datenbank und

01:45:24.987 --> 01:45:25.807
ja.

01:45:27.487 --> 01:45:46.027
Genau, so sieht das halt ungefähr aus und normalerweise hat man eine Klasse, die definiert, welche Spalten es in dieser Tabelle gibt.

01:45:46.027 --> 01:45:48.467
also du hast pro Tabelle

01:45:48.467 --> 01:45:50.007
eine Klasse

01:45:50.007 --> 01:45:51.987
und die

01:45:51.987 --> 01:45:54.107
Spalten sind halt Attribute auf dieser

01:45:54.107 --> 01:45:55.648
Klasse, die halt so ein bisschen

01:45:55.648 --> 01:45:57.688
diese Deskriptoren-Geschichte

01:45:57.688 --> 01:45:59.927
ein bisschen eigenartig

01:45:59.927 --> 01:46:02.027
definiert sind und

01:46:02.027 --> 01:46:04.027
dann kann man halt auch aus diesen

01:46:04.027 --> 01:46:05.907
Klassen die Tabellen direkt erzeugen

01:46:05.907 --> 01:46:07.688
auch die sozusagen

01:46:07.688 --> 01:46:09.907
ja

01:46:09.907 --> 01:46:11.667
Relationen zwischen den Tabellen sind halt

01:46:11.667 --> 01:46:13.188
in den Attributen enthalten

01:46:13.188 --> 01:46:15.767
das heißt ich kann halt wenn ich mir so

01:46:15.767 --> 01:46:17.707
diese Tabellen

01:46:17.707 --> 01:46:19.347
hindefiniert habe, halt auch komplett

01:46:19.347 --> 01:46:21.407
mein Datenbankschema aus den Dingern

01:46:21.407 --> 01:46:21.927
erzeugen.

01:46:24.947 --> 01:46:27.148
Immer wenn einzelne Sachen

01:46:27.148 --> 01:46:29.347
passieren sollen auf einer Zeile, dann sind das

01:46:29.347 --> 01:46:29.847
halt

01:46:29.847 --> 01:46:33.228
Methoden auf dieser Klasse.

01:46:34.407 --> 01:46:35.327
Eine einzelne Instanz ist

01:46:35.327 --> 01:46:36.447
eben eine konkrete Zeile

01:46:36.447 --> 01:46:39.367
und wenn etwas alle Sachen betreffen soll

01:46:39.367 --> 01:46:41.267
oder viele Zeilen, dann sind das halt

01:46:41.267 --> 01:46:42.927
sogenannte Model Manager,

01:46:42.927 --> 01:46:48.207
die dann halt irgendwie eine ganze Reihe von Sachen updaten oder halt

01:46:48.207 --> 01:46:48.907
irgendwie

01:46:48.907 --> 01:46:52.987
eine Reihe von Zeilen löschen

01:46:52.987 --> 01:46:57.987
und so kann man das dann halt aufteilen, alle Methoden, die irgendwie auf einer einzelnen Zeile was machen sollen

01:46:57.987 --> 01:47:02.287
gehen halt in die Klasse und alle Methoden, die halt auf vielen Sachen

01:47:02.287 --> 01:47:05.787
was machen, gehen halt in den Manager auch, die jetzt irgendwas filtern oder so

01:47:05.787 --> 01:47:09.047
und dann, ja, genau, so funktioniert es ungefähr

01:47:09.047 --> 01:47:12.148
Und jetzt kommt SQL-IDEMY

01:47:12.148 --> 01:47:14.347
Ja, Datamapper

01:47:14.347 --> 01:47:15.987
Genau, ich habe jetzt

01:47:15.987 --> 01:47:18.087
erst mal wieder die Active Record Sache

01:47:18.087 --> 01:47:20.287
angeguckt und das Interessante bei Active Record ist ja,

01:47:20.347 --> 01:47:21.847
dass du relativ klar

01:47:21.847 --> 01:47:24.267
Tabelle und Klasse aufeinander

01:47:24.267 --> 01:47:26.007
mappst und beim

01:47:26.007 --> 01:47:27.987
Datamapper ist es ja so, du entkoppelst es

01:47:27.987 --> 01:47:29.927
komplett und die

01:47:29.927 --> 01:47:32.127
Objekte müssen halt, also beim Active Record

01:47:32.127 --> 01:47:34.027
hat zum Beispiel die Klasse

01:47:34.027 --> 01:47:35.547
gerne irgendwie eine Save-Methode

01:47:35.547 --> 01:47:38.047
wo du sagen kannst, ich ändere

01:47:38.047 --> 01:47:39.867
ein paar Attribute und dann kannst du irgendwie Save

01:47:39.867 --> 01:47:41.607
aufrufen und dann ist die irgendwie in der Datenbank

01:47:41.607 --> 01:47:44.087
das ist zumindest das klassische Pattern dafür

01:47:44.087 --> 01:47:46.087
wie es bei Django jetzt gerade aussieht, weiß ich nicht

01:47:46.087 --> 01:47:47.188
Ja, ja, doch, ist genauso

01:47:47.188 --> 01:47:50.307
Und bei SQL Alchemist ist es so, dass im Prinzip

01:47:50.307 --> 01:47:52.427
deine Klassen von der Datenbank

01:47:52.427 --> 01:47:53.127
überhaupt nichts wissen

01:47:53.127 --> 01:47:55.707
Es gibt

01:47:55.707 --> 01:47:58.127
einen deklarativen Stil, bei dem du tatsächlich

01:47:58.127 --> 01:48:00.127
dann wieder innerhalb, da kannst du wieder sagen

01:48:00.127 --> 01:48:02.307
doch, die Klasse weiß was davon, weil du es halt

01:48:02.307 --> 01:48:03.847
eng aneinander koppeln möchtest, um solche

01:48:03.847 --> 01:48:06.387
Effekte zu haben, wie, dass du deine Datenbank

01:48:06.387 --> 01:48:08.228
anhand deiner Klassendefinition

01:48:08.228 --> 01:48:10.127
halt ableiten kannst, aber im Prinzip

01:48:10.127 --> 01:48:10.127


01:48:10.127 --> 01:48:14.467
und die

01:48:14.467 --> 01:48:16.127
und ich beschreibe

01:48:16.127 --> 01:48:20.127
Klassen und jetzt beschreibe ich, wie diese Tabellen auf Klassen gemappt werden.

01:48:20.228 --> 01:48:22.987
Und da können halt auch alles mögliche reinspielen, dass irgendwelche Attribute

01:48:22.987 --> 01:48:27.507
über komplexere Queries erst zustande kommen und dass da irgendwelche komplexen

01:48:27.507 --> 01:48:31.627
Relationen zu sind und etc. Und SQL Alchemy bricht das auch

01:48:31.627 --> 01:48:35.567
extrem abstrakt runter, dass du halt mit den Objekten nativ arbeitest, ohne

01:48:35.567 --> 01:48:37.107
irgendwie über die Datenbank nachzudenken.

01:48:38.087 --> 01:48:39.267
Und dann

01:48:39.267 --> 01:48:46.887
baut der sich und du brauchst kein separates, wenn du viele Aktionen machst, kannst du auch einfach auf 100 Objekten rumrechnen

01:48:46.887 --> 01:48:52.207
und er fasst das nach hinten automatisch in die optimierten SQL-Statements zum Beispiel zusammen,

01:48:52.207 --> 01:48:57.107
dass er weiß, okay, der Herr hat hier 100 Objekte angefasst, jetzt machen wir ein großes Update-Statement,

01:48:57.188 --> 01:49:03.207
das irgendwie einmal sinnvoll aussieht, bumm, anstatt halt dann die eher naiveren Varianten von,

01:49:03.347 --> 01:49:08.567
okay, jedes Mal safe drücken ist jedes Mal einmal zur Datenbank laufen und speichern drücken oder so.

01:49:09.267 --> 01:49:09.267


01:49:09.267 --> 01:49:14.707
und da ist es halt einfach viel, viel flexibler, wenn du das Datenbankmodell entkoppeln möchtest.

01:49:15.047 --> 01:49:17.787
Das ist zum Beispiel auch dann, wenn du konfrontiert wirst mit,

01:49:17.867 --> 01:49:21.587
ich habe hier eine fertige Datenbank, die besteht seit 20 Jahren, die muss jetzt hier irgendwie mal rein.

01:49:22.427 --> 01:49:24.667
Und dann kannst du mit dem Data Mapper...

01:49:24.667 --> 01:49:27.107
Blala, es ist Zeit fürs Bett.

01:49:30.887 --> 01:49:36.927
Dann kannst du mit dem Data Mapper Pattern nämlich beliebige Transformationen machen,

01:49:36.927 --> 01:49:39.607
um zu sagen, okay die Datenbank

01:49:39.607 --> 01:49:41.188
sieht aus wie Kraut und Rüben, aber ich habe

01:49:41.188 --> 01:49:43.567
vorne ein ordentliches Object Model dran

01:49:43.567 --> 01:49:45.547
so und bei

01:49:45.547 --> 01:49:47.148
SQL Alchemy ist das Ganze sozusagen

01:49:47.148 --> 01:49:48.807
wie heißt es denn da so schön

01:49:48.807 --> 01:49:50.327
auf 11 gedreht

01:49:50.327 --> 01:49:53.167
da ist es so richtig laut

01:49:53.167 --> 01:49:55.627
da sind die Abstraktionen so gut gemacht

01:49:55.627 --> 01:49:57.667
und die haben sich so viel Mühe gegeben was Performance angeht

01:49:57.667 --> 01:49:58.648
das ist so ein Zeug von

01:49:58.648 --> 01:50:01.567
du machst komplexere Abfragen und er weiß

01:50:01.567 --> 01:50:03.148
okay wenn ich das jetzt mache

01:50:03.148 --> 01:50:05.527
dann lade ich schon mal die nächsten Relations mit

01:50:05.527 --> 01:50:07.927
und falte irgendwie die Relation-Objekte

01:50:07.927 --> 01:50:08.907
schon mal in die originale

01:50:08.907 --> 01:50:11.407
Seqquery mit rein, damit ich nur einmal einen großen

01:50:11.407 --> 01:50:13.547
Bulk-Transfer am Anfang habe, anstatt

01:50:13.547 --> 01:50:15.487
nachher bei jedem Attributzugriff nochmal zur

01:50:15.487 --> 01:50:17.507
Datenbank zu laufen oder so. Und das

01:50:17.507 --> 01:50:19.148
kannst du da extrem genau aussteuern.

01:50:19.807 --> 01:50:21.047
Das hat ein Django-Dynamit, oder?

01:50:22.007 --> 01:50:23.567
Ja, in Django ist

01:50:23.567 --> 01:50:24.747
das, aber da gibt es das auch.

01:50:25.188 --> 01:50:26.347
Das werden halt die Sachen,

01:50:28.447 --> 01:50:29.467
also das, was man halt nicht

01:50:29.467 --> 01:50:31.367
will, das droht bei Active Record

01:50:31.367 --> 01:50:32.767
natürlich ist, dass wenn du jetzt

01:50:32.767 --> 01:50:35.407
zum Beispiel irgendwie

01:50:35.407 --> 01:51:05.387
und Jochen unterhalten sich über die Programmiersprache Python

01:51:05.407 --> 01:51:08.228
N plus 1 Queries

01:51:08.228 --> 01:51:10.407
gegen die Datenbank

01:51:10.407 --> 01:51:12.327
und das ist natürlich extrem

01:51:12.327 --> 01:51:14.648
fies und ein Haufen Performance-Probleme

01:51:14.648 --> 01:51:16.547
kommen genau deswegen, aber also in Django

01:51:16.547 --> 01:51:18.027
sagt man dann halt Select Related

01:51:18.027 --> 01:51:20.387
genau, dann zieht es die

01:51:20.387 --> 01:51:22.127
oder Prefetch Related

01:51:22.127 --> 01:51:24.387
für N zu M

01:51:24.387 --> 01:51:26.287
Relationen und so, also das geht auch alles

01:51:26.287 --> 01:51:28.447
Machst du das am Model oder musst du das

01:51:28.447 --> 01:51:30.547
an der Query machen? Das machst du an der

01:51:30.547 --> 01:51:32.467
Query. Genau, bei SQL

01:51:32.467 --> 01:51:34.067
Alchemy kannst du das im Prinzip modellieren

01:51:34.067 --> 01:51:36.367
da kannst du halt diese ganzen Relationen

01:51:36.367 --> 01:51:37.228
alle ausdefinieren

01:51:37.228 --> 01:51:39.707
auch so richtig mit

01:51:39.707 --> 01:51:42.267
Vor- und Rückreferenzen will ich die

01:51:42.267 --> 01:51:43.927
irgendwie als Listen oder Dicks kriegen

01:51:43.927 --> 01:51:45.447
oder als Attribute oder

01:51:45.447 --> 01:51:47.467
so ein Zeug und kannst dann halt sagen

01:51:47.467 --> 01:51:50.087
die Richtung, die machst du bitte als Eagerload

01:51:50.087 --> 01:51:52.027
und die bitte nicht und folgende 10 Attribute

01:51:52.027 --> 01:51:53.827
bitte im Eagerload wieder rauslassen

01:51:53.827 --> 01:51:56.347
und das kannst du ja so alles zurecht tunen

01:51:56.347 --> 01:51:57.987
damit du halt dann möglichst dummen

01:51:57.987 --> 01:52:00.188
konkreten Query-Code schreiben kannst

01:52:00.188 --> 01:52:02.228
der über so ein Zeug nicht mehr nachdenkt

01:52:02.787 --> 01:52:03.648
ja, interessant

01:52:03.648 --> 01:52:06.887
und du kannst bei SQL Alchemy auch sehr dynamisch

01:52:06.887 --> 01:52:08.887
die haben halt auch eine voll getrennte Schicht

01:52:08.887 --> 01:52:10.407
zwischen ich hab erstmal dieses Object

01:52:10.407 --> 01:52:12.887
Mapping Ding und dann hat

01:52:12.887 --> 01:52:14.767
der nochmal eine komplette Abstraktion über SQL

01:52:14.767 --> 01:52:16.807
drüber, das heißt der kann dann halt die ganzen SQL

01:52:16.807 --> 01:52:18.728
Dialekte halt auch noch

01:52:18.728 --> 01:52:20.927
nach unten, der hat im Prinzip einmal SQL

01:52:20.927 --> 01:52:22.887
in Form von diesem Builder Pattern

01:52:24.067 --> 01:52:24.667
ja du kannst auch sagen

01:52:24.667 --> 01:52:26.787
ich hätte gerne eine Query, also Query

01:52:26.787 --> 01:52:28.688
Klammer auf von folgendem

01:52:28.688 --> 01:52:30.487
gemappten Objekt und dann

01:52:30.487 --> 01:52:31.327
Punkt

01:52:31.327 --> 01:52:54.148
und er baut dir dann nachher tatsächlich einen für die Datenbank, die du eigentlich hast, also Postgres oder MySQL, ein syntaktisch korrektes und optimiertes Query halt auf, unter Berücksichtigung von allem, was er über diese Mapper weiß, was er gleich noch als Eager Load oder nicht machen soll.

01:52:54.148 --> 01:52:57.607
und du kannst halt mittendrin immer wieder die Ebenen wechseln.

01:52:57.688 --> 01:52:59.728
Du kannst irgendwie im Object Mapping Teil sein,

01:53:00.167 --> 01:53:04.507
drei Zeichen dann von diesen generativen, also dann irgendeine Query mit dem generativen SQL machen,

01:53:04.607 --> 01:53:06.427
da dann aber wieder gemappte Objekte reinstecken

01:53:06.427 --> 01:53:09.047
und der kriegt das immer so vor und zurück und vor und zurück.

01:53:10.367 --> 01:53:14.127
Hat halt das Problem, wenn es, also es tut sehr selten nicht,

01:53:14.247 --> 01:53:16.167
aber man muss sich halt dann schon relativ viel mit,

01:53:16.627 --> 01:53:19.007
schon gut mit dem relationalen Datenmodell auskennen,

01:53:19.087 --> 01:53:21.267
um mit dieser Komplexität dann auch umgehen zu können.

01:53:21.267 --> 01:53:23.327
weil wenn es dir dann mal um die Ohren fliegt

01:53:23.327 --> 01:53:24.887
dann kommen da halt auch Fehler raus mit so

01:53:24.887 --> 01:53:26.287
was will der jetzt von mir

01:53:26.287 --> 01:53:28.707
ja

01:53:28.707 --> 01:53:30.867
naja

01:53:30.867 --> 01:53:33.127
wir haben das in Projekten

01:53:33.127 --> 01:53:35.107
eingesetzt wo es halt teilweise um richtig richtig große

01:53:35.107 --> 01:53:37.207
Datenmengen ging und da dann

01:53:37.207 --> 01:53:38.987
halt wirklich an diesen Stellen

01:53:38.987 --> 01:53:40.728
alle Stellschrauben zu haben

01:53:40.728 --> 01:53:42.407
um das gerade zu ziehen

01:53:42.407 --> 01:53:45.167
das ist halt dann in dem Moment extrem

01:53:45.167 --> 01:53:45.627
viel wert

01:53:45.627 --> 01:53:49.188
und umgekehrt das Active Record

01:53:49.188 --> 01:53:50.987
wiederum, du fängst halt an

01:53:50.987 --> 01:53:52.587
und hast sofort was, was du präsentieren kannst.

01:53:53.887 --> 01:53:55.547
Das entwickelt sich halt sehr schnell.

01:53:55.827 --> 01:53:56.447
Das ist halt super.

01:53:58.707 --> 01:53:59.688
Ja, und dann, ich meine,

01:53:59.827 --> 01:54:01.107
das geht bei SQL Alchemy

01:54:01.107 --> 01:54:02.947
auch nicht. Man kann ja auch immer noch

01:54:02.947 --> 01:54:05.127
auf rohes SQL zurückfallen,

01:54:05.228 --> 01:54:07.607
wenn man irgendwas Spezielles

01:54:07.607 --> 01:54:07.907
machen muss.

01:54:07.907 --> 01:54:07.967
Ja.

01:54:12.967 --> 01:54:13.627
Haben wir

01:54:13.627 --> 01:54:15.707
alle Patterns durch, tatsächlich?

01:54:15.907 --> 01:54:17.667
Also, du wolltest auch irgendwas zu Datenbanken sagen.

01:54:17.747 --> 01:54:19.667
Ich habe da gestern noch so ein Solid-Modell

01:54:19.667 --> 01:54:20.188
oder sowas.

01:54:20.188 --> 01:54:39.267
Ja, achso, nee, das ist nicht Datman, aber das ist auch so genau, ja, ich weiß nicht, ob das Patterns sind, das ist eher so, was sollte man, wenn man Dinge macht, sowieso beachten vielleicht. Das ist halt auch so eine ganz bekannte Geschichte. Ich weiß gar nicht, ob man es unter Pattern Design Prinzipien, ja, ja.

01:54:39.267 --> 01:54:40.407
Was ist das denn?

01:54:40.407 --> 01:54:43.587
Ja, das ist

01:54:43.587 --> 01:54:46.027
auch etwas, was, es gibt ja dieses

01:54:46.027 --> 01:54:47.087
Buch Clean Code von

01:54:47.087 --> 01:54:50.027
Robert Martin

01:54:50.027 --> 01:54:50.787
und Uncle Bob.

01:54:51.387 --> 01:54:52.228
Gibt es das auch in Python?

01:54:52.867 --> 01:54:54.047
Das ist, nee, das ist

01:54:54.047 --> 01:54:55.927
die ganze, das ist über uns,

01:54:56.087 --> 01:54:57.747
ich meine, ehrlich gesagt, ich bin ja ein bisschen

01:54:57.747 --> 01:54:59.747
peinlich berührt, wenn ich dann irgendwie so

01:54:59.747 --> 01:55:02.047
Observer-Pattern, keine Ahnung, habe ich

01:55:02.047 --> 01:55:04.107
schon mal gehört oder so. Bei den meisten

01:55:04.107 --> 01:55:06.047
Patterns ist es so, ich habe die schon mal gesehen, vielleicht irgendwann

01:55:06.047 --> 01:55:07.967
mal oder auch mal, aber so

01:55:07.967 --> 01:55:10.047
wirklich viel zu tun habe ich mit denen ja eigentlich

01:55:10.047 --> 01:55:11.947
nicht. Also dieses ganze Thema

01:55:11.947 --> 01:55:13.867
kommt eigentlich eher aus so ein bisschen anderen Ecke

01:55:13.867 --> 01:55:15.207
der Softwareentwicklung.

01:55:16.148 --> 01:55:18.007
Und während das jetzt bei

01:55:18.007 --> 01:55:19.867
so Java-Geschichten oder so halt so ist,

01:55:20.327 --> 01:55:22.007
eben, da ist also für Juniorstellen

01:55:22.587 --> 01:55:23.967
irgendwie, wenn man sich da,

01:55:24.127 --> 01:55:26.007
wenn man da in Vorstellungsgesprächen ist, dann

01:55:26.007 --> 01:55:27.927
wird halt erwartet, dass man die alle kennt und

01:55:27.927 --> 01:55:29.487
ja,

01:55:29.787 --> 01:55:31.827
das wäre dann schon sehr fein, wenn man sagt, also

01:55:31.827 --> 01:55:33.027
ich habe keine Ahnung, was das eigentlich ist.

01:55:33.807 --> 01:55:36.007
Aber ja, suche ich mal ja gerne Java.

01:55:36.927 --> 01:55:37.287
Ja, das

01:55:37.287 --> 01:55:39.987
Interessante ist auch, man kann

01:55:39.987 --> 01:55:42.027
das Zeug ja im Alltag eben nicht so benutzen

01:55:42.027 --> 01:55:43.867
wie bei jeder Zeile

01:55:43.867 --> 01:55:45.867
Code, die ich schreibe, gehe ich nochmal alle

01:55:45.867 --> 01:55:47.887
mir bekannten Patterns und Prinzipien durch, ob ich

01:55:47.887 --> 01:55:50.007
die jetzt ja nicht verletze. So funktioniert

01:55:50.007 --> 01:55:51.967
es halt nicht. Du willst ja, und deswegen

01:55:51.967 --> 01:55:53.787
ist Pattern, glaube ich, auch für unsere Kognition

01:55:53.787 --> 01:55:55.907
eigentlich ganz interessant. Du willst aber,

01:55:56.067 --> 01:55:57.947
dass dein Gehirn eine ausreichende Menge von

01:55:57.947 --> 01:55:59.407
so einem Zeug so dran trainiert hat,

01:55:59.947 --> 01:56:02.027
dass wenn da irgendwie die roten Warnlämpchen angehen,

01:56:02.107 --> 01:56:03.947
du halt weißt, Moment, jetzt mal nochmal

01:56:03.947 --> 01:56:05.327
nachdenken, warum geht das hier schief?

01:56:05.867 --> 01:56:08.067
Damit du dann halt wenigstens weißt, wo du googeln musst.

01:56:08.067 --> 01:56:13.367
Ich habe über Solid jetzt gerade nochmal schnell drüber geguckt

01:56:13.367 --> 01:56:16.007
Oh, das ist aber schon ganz schön alte Schule teilweise

01:56:16.007 --> 01:56:20.087
Also wenn ich halt Liskov Substitution höre, dann so

01:56:20.087 --> 01:56:23.487
Oh ja, das Akademikerherz

01:56:23.487 --> 01:56:26.467
Das ist das L in Solid, ja, das Liskov Substitution

01:56:26.467 --> 01:56:31.087
Ja, also es ist halt auch alles relativ alte Geschichte

01:56:31.087 --> 01:56:34.747
und das macht halt in diesem Kontext von so statisch typisierten Programmiersprachen

01:56:34.747 --> 01:56:36.047
macht das auch alles gewisserweise

01:56:36.047 --> 01:56:38.547
schon Sinn, also durchaus

01:56:38.547 --> 01:56:40.707
und auch mehr Sinn halt, vielleicht als bei Python,

01:56:41.027 --> 01:56:42.667
weil da viele Dinge einfach automatisch

01:56:42.667 --> 01:56:44.767
erfüllt sind. Also eben, ich würde sagen,

01:56:46.167 --> 01:56:50.267
ja, ich würde, Lischkows

01:56:50.267 --> 01:56:51.967
Substitution Principle?

01:56:52.648 --> 01:56:54.627
Nee, das ist ein Designthema, das musst du selber

01:56:54.627 --> 01:56:56.007
als Programmierer richtig umsetzen.

01:56:57.347 --> 01:56:58.347
Das ist Typtheorie

01:56:58.347 --> 01:57:00.607
und das ist die Aussage, dass

01:57:00.607 --> 01:57:02.767
Objekte

01:57:02.767 --> 01:57:04.648
in einem Programm, also aller Programm

01:57:04.648 --> 01:57:07.987
Code, der Objekte verwendet, also mit Objekten arbeitet,

01:57:08.787 --> 01:57:12.107
sollte immer in der Lage sein, alle Subtypen

01:57:12.107 --> 01:57:15.967
dieser Objekte zu akzeptieren, ohne die Korrektheit des Programms zu verletzen.

01:57:17.367 --> 01:57:19.887
Genau, also ich würde jetzt mal so als konkretes Beispiel

01:57:19.887 --> 01:57:24.167
wäre jetzt für mich sowas wie, man macht eine Vorschleife über

01:57:24.167 --> 01:57:28.127
Mitarbeiter und wenn man jetzt in der Vorschleife

01:57:28.127 --> 01:57:32.407
so Fallunterscheidungen macht, also nehmen wir an, man hat eine Typarchie,

01:57:32.407 --> 01:58:02.387
und Jochen unterhalten sich über die Programmiersprache Python

01:58:02.407 --> 01:58:03.947
machen wir aber folgende Ausnahmegeschichten.

01:58:04.087 --> 01:58:05.967
Wenn wir jetzt zum Beispiel Gehalt auszahlen wollen,

01:58:06.267 --> 01:58:08.347
wir rufen nicht einfach Gehaltauszahlen-Methode

01:58:08.347 --> 01:58:10.067
auf, sondern wir sagen nochmal,

01:58:10.367 --> 01:58:12.167
okay, wir machen Speziallogik,

01:58:12.247 --> 01:58:13.767
je nachdem, was das für ein Typ ist.

01:58:14.207 --> 01:58:15.987
Du weißt schon, dass der Senior Vice President

01:58:15.987 --> 01:58:17.847
Facility Management ein ziemlich stiller Witz ist.

01:58:19.247 --> 01:58:19.607
Wieso?

01:58:20.148 --> 01:58:21.367
Das ist voll wichtig.

01:58:25.927 --> 01:58:27.427
Also dann hätte man sozusagen,

01:58:28.047 --> 01:58:29.307
aus meiner Perspektive, hätte man jetzt

01:58:29.307 --> 01:58:31.747
eben Lischkows Substitution

01:58:31.747 --> 01:58:33.827
Principle verletzt, weil eben

01:58:33.827 --> 01:58:35.347
der Code nicht

01:58:35.347 --> 01:58:37.907
funktioniert, unabhängig davon,

01:58:38.067 --> 01:58:39.667
was das für ein Typ ist,

01:58:39.767 --> 01:58:41.807
sondern weil man da noch überprüft wird. Ja, noch nicht so ganz.

01:58:42.228 --> 01:58:43.747
Also Spezialfälle

01:58:43.747 --> 01:58:45.247
zu erlauben ist ja kein Problem,

01:58:45.728 --> 01:58:47.707
es muss bloß die Korrektheit gewährleistet sein. Aber

01:58:47.707 --> 01:58:49.907
Beispiel, wenn man zum Beispiel sagt,

01:58:51.787 --> 01:58:52.047
der

01:58:52.047 --> 01:58:53.907
und

01:58:53.907 --> 01:58:55.927
Korrektheit ist tatsächlich auch immer eine spannende Frage

01:58:55.927 --> 01:58:57.487
von, das gehört

01:58:57.487 --> 01:58:59.728
für mich auch dazu, im Sinne von, erfüllt tatsächlich

01:58:59.728 --> 01:59:01.547
auch nachher für den User was Sinnvolles.

01:59:01.747 --> 01:59:06.947
und du sagst zum Beispiel, alle Mitarbeiter müssen eine private Telefonnummer haben

01:59:06.947 --> 01:59:15.907
und bei den CEOs legt man dann fest, da ist wie immer 0, weil die privaten Nummern der CEOs werden nicht rausgegeben

01:59:15.907 --> 01:59:23.787
und das würde einem Subtyp entsprechen, dann hättest du halt in dem Moment das verletzt,

01:59:23.787 --> 01:59:30.387
im Sinne von, ja jetzt machen wir hier mal für Weihnachten die Telefonliste der Mitarbeiter fertig

01:59:30.387 --> 01:59:36.228
und machen die Secret Centers für hier und da und den kannst du anrufen, um noch ein bisschen was abzufragen

01:59:36.228 --> 01:59:39.887
und plötzlich kommen bei den CEOs halt da keine Telefonnummern raus.

01:59:39.887 --> 01:59:42.167
Also ja, nee, das war jetzt halt kaputt.

01:59:42.787 --> 01:59:46.667
Und das ist eine Designanforderung nicht von dem Client Code, der damit arbeitet,

01:59:47.327 --> 01:59:53.947
das ist eine Designanforderung von Objekten, von Unterobjekten, von Unterklassen, von Subklassen.

01:59:54.228 --> 01:59:59.887
Dass eine Subklasse den Raum der Möglichkeiten erweitern, aber nicht einstellen.

01:59:59.887 --> 02:00:00.287
darf.

02:00:04.987 --> 02:00:06.067
Okay, das ist L.

02:00:07.127 --> 02:00:08.667
Jetzt haben wir noch S-O-I-D.

02:00:09.947 --> 02:00:11.187
Das würde ich gerne verschieben.

02:00:14.367 --> 02:00:15.667
Ich habe vorhin schon

02:00:15.667 --> 02:00:17.807
meinen Zungenbrecher

02:00:17.807 --> 02:00:19.447
gehabt.

02:00:20.067 --> 02:00:20.887
Wir haben heute etwas Zeit.

02:00:20.947 --> 02:00:23.787
Wir haben relativ gut zeitig angefangen.

02:00:23.987 --> 02:00:25.707
Mit dem Nachteil, dass meine

02:00:25.707 --> 02:00:26.767
Technik heute ein bisschen...

02:00:26.767 --> 02:00:28.227
Du hast inzwischen für dich alleine geredet.

02:00:28.227 --> 02:00:32.287
Ja, und auch bis wir zum Reden gekommen sind, dann weil irgendwie hier

02:00:32.287 --> 02:00:33.827
alle gegen mich gearbeitet haben.

02:00:33.847 --> 02:00:35.507
Wir machen das einfach zu selten, wir müssen das häufiger machen.

02:00:36.127 --> 02:00:37.087
Das stimmt.

02:00:38.007 --> 02:00:39.767
Sehr gerne. Wie gesagt, von meiner Seite

02:00:39.767 --> 02:00:42.327
immer gerne. Wir müssen einfach immer

02:00:42.327 --> 02:00:43.847
sofort den nächsten Termin ansetzen.

02:00:43.927 --> 02:00:44.427
Ja, das machen wir.

02:00:45.967 --> 02:00:47.707
Schön, dass ihr aber alle wieder eingeschaltet habt heute.

02:00:47.987 --> 02:00:49.767
Ja, genau. An der Stelle müssen wir uns eigentlich auch entschuldigen.

02:00:49.807 --> 02:00:51.907
Wir haben den letzten Monat irgendwie verbasselt, aber ich meine,

02:00:51.907 --> 02:00:52.767
es war viel zu tun und so.

02:00:53.047 --> 02:00:55.067
Ja, es war viel zu tun und zwar ein bisschen sehr...

02:00:55.067 --> 02:00:58.007
Ja, eigentlich wollten wir noch

02:00:58.007 --> 02:00:59.647
2 aufnehmen, da ist wieder was ausgefallen und so.

02:01:00.767 --> 02:01:01.967
Die Termin-Findungs-

02:01:01.967 --> 02:01:03.887
Koordinationsschwierigkeiten kommen noch

02:01:03.887 --> 02:01:05.887
ihr Ugriges dazu. Ja, wir geloben Besserung,

02:01:05.967 --> 02:01:07.107
das kriegen wir auch schon irgendwie hin.

02:01:08.707 --> 02:01:09.887
Genau, nee, dann am besten,

02:01:10.247 --> 02:01:11.627
ja, wir haben ja auch schon echt viel

02:01:11.627 --> 02:01:13.927
Zeug gemacht, dann verschieben wir das mal solid,

02:01:13.927 --> 02:01:15.027
das ist ein gutes Thema.

02:01:16.387 --> 02:01:17.507
Ja, und halt auch noch so diverse

02:01:17.507 --> 02:01:20.027
Architektur-Patterns, halt so Repository-Pattern,

02:01:20.287 --> 02:01:21.667
Unit of Work, weiß ich nicht.

02:01:21.947 --> 02:01:23.487
Es gibt da ein schönes Buch, das wäre dann schon sozusagen

02:01:23.487 --> 02:01:25.927
Vorbereitung aufs nächste Mal. CosmicPython.com

02:01:25.927 --> 02:01:26.507
.com.

02:01:27.767 --> 02:01:29.807
Ich glaube, das heißt dann auch tatsächlich, wenn man es als Buch kauft,

02:01:30.147 --> 02:01:31.247
also kann man da online lesen.

02:01:32.847 --> 02:01:43.582
Ja es ist halt auch Architectural Patterns for Python oder irgendwie sowas Ist von dem na wie hei er noch Der auch Obey the Testing

02:01:43.582 --> 02:01:44.322
Code geschrieben hat.

02:01:46.462 --> 02:01:47.582
Und einem anderen.

02:01:48.202 --> 02:01:49.362
Verdammt. Okay.

02:01:50.122 --> 02:01:50.782
Weiß nicht mehr genau.

02:01:52.302 --> 02:01:53.502
Da kann ich eigentlich auch sofort

02:01:53.502 --> 02:01:55.022
nachgucken.

02:01:56.162 --> 02:01:56.682
Percival.

02:01:56.682 --> 02:01:57.262
Percival.

02:01:59.522 --> 02:02:00.302
Kosmos hat sich

02:02:00.302 --> 02:02:01.962
opposite auf Chaos und Gregory.

02:02:01.962 --> 02:02:04.242
Aha, Kosmos ist die Opposite of Chaos.

02:02:31.962 --> 02:02:34.322
Ja, das kannte ich noch nicht und das sieht aber tatsächlich gut aus.

02:02:34.542 --> 02:02:38.302
Das sind so tatsächlich die Patterns, die ich auch kenne, die in Python gerne kommen.

02:02:39.042 --> 02:02:41.742
Unit of Work ist so ein SQL-Meeting, auch Event-Driven.

02:02:42.742 --> 02:02:44.882
Und MessageBus klingt gut, Commands klingt gut.

02:02:45.782 --> 02:02:47.002
Dependency Injection ist super.

02:02:47.982 --> 02:02:49.562
Das klingt interessant, das kommt in die Leseliste.

02:02:50.402 --> 02:02:53.802
Super, dann haben wir auf jeden Fall auch noch eine Menge Stoff für den nächsten, für den zweiten Teil.

02:02:55.382 --> 02:02:57.322
Ja, wir haben einige Teil-Dateien noch offen übrigens.

02:02:57.802 --> 02:02:59.762
Ja, ja, Async muss wir auch unbedingt nochmal dran.

02:02:59.762 --> 02:03:04.622
Ja, vielen Dank, dass du wieder da warst, Christian, Conny.

02:03:05.462 --> 02:03:06.382
Danke, dass ich dir bei sein durfte.

02:03:06.782 --> 02:03:07.222
Na klar.

02:03:07.782 --> 02:03:09.422
Und schön, dass ihr eingeschaltet habt.

02:03:09.682 --> 02:03:12.502
Und gute Nacht, guten Morgen, guten Abend und so weiter.

02:03:12.822 --> 02:03:13.582
Bis zum nächsten Mal.

02:03:13.602 --> 02:03:13.882
Bis dann.

02:03:14.062 --> 02:03:14.422
Tschüss.

02:03:14.622 --> 02:03:14.962
Ciao, ciao.