WEBVTT

00:00:00.580 --> 00:00:04.080
Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python-Podcast Episode 37.

00:00:04.940 --> 00:00:08.740
Wir wollen heute ein bisschen über Refactoring reden und natürlich ist wieder Jochen dabei.

00:00:09.080 --> 00:00:09.340
Hi Jochen.

00:00:09.360 --> 00:00:10.380
Jo, hallo auch Dominik.

00:00:10.960 --> 00:00:11.920
Und wir haben heute auch Ronny da.

00:00:12.280 --> 00:00:12.660
Hi Ronny.

00:00:12.760 --> 00:00:12.900
Hi.

00:00:12.980 --> 00:00:13.380
Jo, hi.

00:00:13.500 --> 00:00:14.180
Kennt ihr vielleicht auch noch.

00:00:14.540 --> 00:00:14.720
Grüße.

00:00:15.380 --> 00:00:15.560
Jo.

00:00:16.440 --> 00:00:18.440
Ja, vielleicht erstmal ein bisschen News.

00:00:18.680 --> 00:00:19.600
Ich weiß nicht, so viel Neues gab es noch nicht.

00:00:19.600 --> 00:00:20.580
Ja, haben wir News?

00:00:20.820 --> 00:00:21.380
Ich weiß nicht genau.

00:00:21.540 --> 00:00:21.920
Also am 6.

00:00:21.960 --> 00:00:26.240
Nikolas, das ist noch nicht so lange her, zwei Tage oder so gab es Python 13.1.

00:00:27.200 --> 00:00:27.860
Ach, okay.

00:00:27.860 --> 00:00:29.000
Das ist an mir vorbeigekommen.

00:00:29.060 --> 00:00:29.820
Das habe ich wahrscheinlich nicht bekommen.

00:00:30.000 --> 00:00:31.200
Ja, cool.

00:00:31.660 --> 00:00:32.940
Habe ich bei mir jetzt überall eingebaut und

00:00:32.940 --> 00:00:35.560
stable. Ich glaube, das war

00:00:35.560 --> 00:00:36.800
vorgestern oder so,

00:00:37.200 --> 00:00:39.140
oder gestern, ich bin mir gar nicht sicher.

00:00:39.480 --> 00:00:41.000
Vielleicht gestern ist Django 4

00:00:41.000 --> 00:00:43.440
released worden. Ja, stimmt, genau.

00:00:43.720 --> 00:00:45.800
Ja, das ist auch eine ganz gute Neuigkeit.

00:00:47.260 --> 00:00:47.400
Ja.

00:00:48.080 --> 00:00:49.500
Es ist gar nicht so viel Neues dazu gekommen,

00:00:49.640 --> 00:00:51.300
ehrlich gesagt. Aber es ist super viel weggefallen.

00:00:51.460 --> 00:00:54.720
Also die Backward-Incompatibility-List,

00:00:54.780 --> 00:00:55.100
oh mein Gott,

00:00:55.560 --> 00:00:57.700
die ist ungefähr fünfmal so lang wie die neuen Features.

00:00:57.700 --> 00:00:59.520
Das ist echt krass. Das ist super, ja.

00:01:00.000 --> 00:01:02.180
und so ein paar Sachen rausgeflogen, die man nicht mehr braucht

00:01:02.180 --> 00:01:03.820
oder die gefährlich sind oder so, schon gar nicht so schlecht.

00:01:05.380 --> 00:01:06.720
Ja, ansonsten,

00:01:06.760 --> 00:01:07.620
weiß nicht genau,

00:01:07.920 --> 00:01:10.220
machen wir auch News in anderen, für andere Sprachen?

00:01:10.620 --> 00:01:10.800
Ja.

00:01:11.560 --> 00:01:13.620
Ich glaube, hier in PHP 8.1

00:01:13.620 --> 00:01:15.520
ist irgendwie released und da gibt es ein neues,

00:01:15.640 --> 00:01:17.940
interessantes Feature mit dabei und zwar

00:01:17.940 --> 00:01:19.340
async await.

00:01:21.120 --> 00:01:22.100
So wie in Python

00:01:22.100 --> 00:01:23.700
halt auch, nur anders.

00:01:24.100 --> 00:01:26.080
Also die Keywords,

00:01:26.500 --> 00:01:27.440
aber es

00:01:27.440 --> 00:01:29.920
ist ein bisschen anders. Man kann das halt

00:01:29.920 --> 00:01:32.100
und man kann halt async-Funktionen auch so callen

00:01:32.100 --> 00:01:33.820
ohne await, was ganz

00:01:33.820 --> 00:01:35.500
interessant ist. In JavaScript übrigens auch so.

00:01:37.240 --> 00:01:37.980
Man muss

00:01:37.980 --> 00:01:40.040
halt nur, wenn man await sagen will

00:01:40.040 --> 00:01:41.720
innerhalb von einer Funktion, irgendwie die async

00:01:41.720 --> 00:01:43.780
definiert haben, aber man kann die auch

00:01:43.780 --> 00:01:45.400
einfach so aufrufen und

00:01:45.400 --> 00:01:47.800
dann passiert irgendwie magisch das Richtige oder

00:01:47.800 --> 00:01:49.040
was Falsches oder was Falsches.

00:01:49.720 --> 00:01:52.000
Aber man hat halt daher, was in Python

00:01:52.000 --> 00:01:53.740
tatsächlich ein bisschen nervig ist, ist, dass man halt

00:01:53.740 --> 00:01:55.740
dieses Farbigkeitsproblem der Funktionen hat,

00:01:55.800 --> 00:01:57.900
dass man halt, wenn man irgendwo async

00:01:57.900 --> 00:01:59.900
was machen möchte, dann muss man

00:01:59.900 --> 00:02:02.280
und Async sein. Ich meine, man kann natürlich auch hingehen

00:02:02.280 --> 00:02:03.500
und sagen, okay,

00:02:04.040 --> 00:02:05.960
async.io.run oder so,

00:02:06.160 --> 00:02:07.440
aber das natürlich...

00:02:07.440 --> 00:02:09.880
Man muss dann erstmal den Event-Loop immer rausführen, oder wenn man im

00:02:09.880 --> 00:02:11.620
Jupyter gerade ist, dann ist das auch immer ein bisschen doof.

00:02:12.620 --> 00:02:13.420
Ja, also

00:02:13.420 --> 00:02:15.620
in Python ist es expliziter als

00:02:15.620 --> 00:02:17.900
in JavaScript und in PHP, aber es ist halt

00:02:17.900 --> 00:02:19.880
auch so ein bisschen unhandlicher

00:02:19.880 --> 00:02:21.480
zu benutzen vielleicht, aber naja, gut.

00:02:22.340 --> 00:02:23.800
Aber das ist vielleicht auch noch wenigstens wert,

00:02:24.120 --> 00:02:25.900
weil damit wird in PHP auch dann irgendwann

00:02:25.900 --> 00:02:27.580
das möglich, was ja jetzt in Python...

00:02:27.580 --> 00:02:29.860
Das kommt ja jetzt in Python, ist das jetzt in den

00:02:29.860 --> 00:02:33.540
ganzen Frameworks halt irgendwie so, oder zumindest Django, ich weiß gar nicht so genau,

00:02:33.940 --> 00:02:37.520
FastAPI halt auch, aber das war ja schon immer so angekommen, dass man halt irgendwie

00:02:37.520 --> 00:02:41.320
Async-Kram da machen kann und dann eben, ja, kann man halt solche Sachen machen, wie auch

00:02:41.320 --> 00:02:45.540
Filesorving vom Applikationsserver aus oder halt auch WebSockers, relativ einfach und so.

00:02:45.760 --> 00:02:49.220
Das geht dann halt, weil ich weiß gar nicht, wie das in PHP ist, da normalerweise eben Sachen

00:02:49.220 --> 00:02:53.100
PHP-Filesorven, das geht halt einfach nicht so richtig gut, weil

00:02:53.100 --> 00:02:56.860
üblicherweise hat man nach irgendwie einer Minute oder so werden die

00:02:56.860 --> 00:02:59.540
Prozesse gekillt bei den meisten

00:02:59.540 --> 00:03:01.220
Hustern. Da brauchst du mich jetzt gar nicht fragen.

00:03:01.340 --> 00:03:03.700
Ich kenne den Nullkummer gar nicht aus, wenn es die Sprache ist.

00:03:04.240 --> 00:03:05.460
Naja, aber genau, da geht es

00:03:05.460 --> 00:03:07.220
halt auf jeden Fall auch voran. Also sowieso

00:03:07.220 --> 00:03:09.120
per den letzten Versionen viel dazu gekommen.

00:03:10.300 --> 00:03:11.600
Ich kenne mich noch vom Gegenschubsen

00:03:11.600 --> 00:03:13.020
um zu treten.

00:03:13.720 --> 00:03:15.480
Tja, kann man natürlich auch machen.

00:03:17.300 --> 00:03:18.320
Ja, haben wir noch andere News?

00:03:18.420 --> 00:03:18.860
Haben wir noch was?

00:03:19.840 --> 00:03:22.480
Was war denn in Dango 4 drin?

00:03:22.480 --> 00:03:24.600
Alles Schönes. Wüsst ihr das noch?

00:03:25.780 --> 00:03:26.460
Ja, neuer

00:03:26.460 --> 00:03:56.460
also Django Redis ist irgendwie also Redis scheint mit rein gekommen, weil automatisch, das gab ja immer sonst Django Redis Package und das kam direkt als Default-Test oder so, ne? Ja, es ist jetzt halt drin, weil es gab irgendwie eine Umfrage, was verwendet ihr denn so für Caching und alle nehmen Redis. Genau, Memcached war eingebaut und aber alle nehmen Redis, daher macht es irgendwie nicht so richtig viel Sinn, das nicht eingebaut zu haben und ja, deswegen ist das jetzt halt drin. Ja, ansonsten naja, war's nicht. Die IT-Set ist rausgeflogen, glaube ich,

00:03:56.460 --> 00:03:58.080
in der Zeitzone oder so.

00:04:00.360 --> 00:04:00.960
Aber ich glaube,

00:04:01.020 --> 00:04:02.500
das war echt mehr ein Aufräumen

00:04:02.500 --> 00:04:04.780
Release, gefühlt.

00:04:06.080 --> 00:04:07.220
Was ja auch eine gute Sache ist

00:04:07.220 --> 00:04:09.080
und was auch sehr gut zu unserer Refactoring-Session

00:04:09.080 --> 00:04:09.520
passt.

00:04:10.980 --> 00:04:12.460
Genau, das ist nämlich das Thema.

00:04:12.960 --> 00:04:13.640
Genau, das Thema.

00:04:14.620 --> 00:04:16.420
Ja, was ist denn das überhaupt, Refactoring?

00:04:16.620 --> 00:04:18.380
Was sagt ihr denn, was das ist? Also ich sag mal so,

00:04:18.800 --> 00:04:20.940
ich baute oft meinen Code um,

00:04:20.940 --> 00:04:21.900
aber ist das schon Refactoring?

00:04:22.920 --> 00:04:24.680
Also immer dann, wenn man halt ein bisschen später wieder draufguckt,

00:04:24.980 --> 00:04:26.380
merkt man halt so, oh, wie war ich doof,

00:04:26.460 --> 00:04:28.320
oder EU ist das aber hässlich oder schlecht,

00:04:28.400 --> 00:04:30.240
was ich dir vorgemacht habe. Mach ich das doch mal nochmal

00:04:30.240 --> 00:04:32.300
oder pass ein bisschen an oder mach es

00:04:32.300 --> 00:04:34.080
ganz von neu. Was heißt

00:04:34.080 --> 00:04:34.960
Refactoring für euch?

00:04:36.440 --> 00:04:37.920
Nimmt man sich da extra Zeit für?

00:04:38.140 --> 00:04:39.800
Gehört das in einen Sprint oder so?

00:04:40.280 --> 00:04:41.580
Also ich würde jetzt mal sagen,

00:04:41.780 --> 00:04:44.080
meiner Verständnis nach

00:04:44.080 --> 00:04:45.440
gehört das halt schon dazu

00:04:45.440 --> 00:04:47.880
zu den, wenn man

00:04:47.880 --> 00:04:49.960
sich der agilen Softwareentwicklung

00:04:49.960 --> 00:04:51.560
bedient als

00:04:51.560 --> 00:04:54.480
Prozessmethode,

00:04:54.480 --> 00:04:55.800
was auch immer man das nennen möchte,

00:04:55.800 --> 00:04:58.280
dann würde ich sagen, so Definitions of Done

00:04:58.280 --> 00:04:59.260
zum Beispiel bei Scrum

00:04:59.260 --> 00:05:02.020
sagt, wann ist was fertig und dann

00:05:02.020 --> 00:05:03.800
würde aus meiner Sicht halt

00:05:03.800 --> 00:05:05.960
dazugehören, normalerweise, dass man sagt, man hat das

00:05:05.960 --> 00:05:08.120
auch irgendwie mal refactured oder so

00:05:08.120 --> 00:05:09.920
Wie viel Prozent der Zeit würde in sowas

00:05:09.920 --> 00:05:11.580
wie? Och, keine Ahnung, das kommt drauf an, also

00:05:11.580 --> 00:05:13.820
So ein Tag? Je nachdem, was man macht

00:05:13.820 --> 00:05:15.220
Nee, das kommt halt, also

00:05:15.220 --> 00:05:18.220
und manchmal muss man vielleicht auch das komplette System refacturen, weil

00:05:18.220 --> 00:05:20.200
Wer refactort das denn? Man selber? Ein anderes Team?

00:05:20.400 --> 00:05:21.720
Das eigene Team mit

00:05:21.720 --> 00:05:23.580
vier, fünf, sechs Augen im Prinzip? Nee, immer

00:05:23.580 --> 00:05:24.860
der, der fragt

00:05:24.860 --> 00:05:29.660
Bei uns bin ich nicht mehr ich,

00:05:29.780 --> 00:05:32.640
weil ich mag das irgendwie, Code umzubauen.

00:05:32.740 --> 00:05:34.620
Ich weiß auch nicht, das ist so ein bisschen ein blödes Hobby.

00:05:34.800 --> 00:05:36.520
Also es gibt ja Zen of Python, das ist ja

00:05:36.520 --> 00:05:38.800
eigentlich eher für andere Dinge

00:05:38.800 --> 00:05:40.380
da, da wollten wir auch nochmal eine Folge drüber machen.

00:05:40.460 --> 00:05:41.800
Aber der erste Satz ist natürlich

00:05:41.800 --> 00:05:43.520
Beautiful is better than ugly.

00:05:45.180 --> 00:05:46.960
Und ich mag das irgendwie, wenn es hübsch ist.

00:05:47.940 --> 00:05:48.920
Aber ist das ein guter

00:05:48.920 --> 00:05:50.940
Grund zum Reflektor, dass es dann nachher hübscher aussieht?

00:05:51.180 --> 00:05:52.120
Es tut halt dasselbe.

00:05:53.400 --> 00:05:54.840
Ist das wasbarer?

00:05:54.860 --> 00:05:57.040
aus meiner Sicht eigentlich schon,

00:05:57.400 --> 00:05:59.320
aber da ist natürlich irgendwie

00:05:59.320 --> 00:06:01.240
quasi, ja, aber ich meine,

00:06:01.520 --> 00:06:03.440
man kann unendlich viel Zeit damit zu verbringen,

00:06:03.520 --> 00:06:04.660
immer wieder dran rum zu feilen,

00:06:05.020 --> 00:06:07.560
dass immer alles ein bisschen hübscher ist, das macht halt kein einziges

00:06:07.560 --> 00:06:09.020
Feature mehr. Aber das ist auch vielleicht,

00:06:09.120 --> 00:06:10.740
das hat man schon ein paar Mal erwähnt, so dieses

00:06:10.740 --> 00:06:12.940
warum Programmierer irgendwie

00:06:12.940 --> 00:06:15.100
Programmierer sein irgendwie nicht so

00:06:15.100 --> 00:06:17.440
Business, wie ist nochmal dieser

00:06:17.440 --> 00:06:18.620
Talk, da hatten wir schon mal drüber gesprochen.

00:06:19.540 --> 00:06:20.700
Weiß ich gar nicht, welchen meinst du?

00:06:20.720 --> 00:06:22.520
Ja, ja, du kennst den auch noch, den hast du auch gesehen.

00:06:22.520 --> 00:06:52.520
Der war auf der DjangoCon irgendwie ganz entspannt Ach der, der erste, ne Der erste Talk auf der DjangoCon EU Ja, weil man mag halt programmieren Und deswegen macht man das halt und ob es irgendwie am Schluss dabei was rauskommt oder nicht ist eigentlich dann auch so ein bisschen egal, genau Ich glaube ganz wichtig ist halt wie in allen Bereichen überall ist halt Pareto-Prinzip, also dass man einfach schauen muss dass man, also 80% der Sachen kriegst du halt, 21% der Zeit Refactor

00:06:52.520 --> 00:06:55.180
und die Details, die kostet man dann richtig viel.

00:06:55.220 --> 00:06:58.240
Die ganz wichtigen Details, davon das wäre klasse.

00:06:58.440 --> 00:06:58.880
Ich weiß nicht.

00:06:59.560 --> 00:07:01.300
Es kommt immer ganz drauf an, würde ich sagen.

00:07:01.440 --> 00:07:03.840
Also ich meine, wenn man jetzt irgendwie an einer Software bastelt

00:07:03.840 --> 00:07:06.280
und da geht es gerade irgendwie um die, weiß ich nicht,

00:07:06.360 --> 00:07:08.200
Zahlungsschnittstelle oder Auftragsabwicklung,

00:07:08.620 --> 00:07:11.280
dann sollte man schon schauen, dass das vernünftig funktioniert

00:07:11.280 --> 00:07:13.700
und dass man da vielleicht auch eher einen Schritt weiter denkt,

00:07:13.800 --> 00:07:15.380
als einen Schritt zu kurz denkt.

00:07:15.480 --> 00:07:17.600
Aber es gibt ja doch in jedem System Bereiche,

00:07:18.060 --> 00:07:19.880
weiß ich nicht, irgendeine Administrationsseite,

00:07:19.980 --> 00:07:21.440
die zweimal im Jahr aufgerufen wird oder so.

00:07:21.440 --> 00:07:23.780
und wenn die jetzt nicht ganz perfekt ist, jo, ich meine.

00:07:24.680 --> 00:07:25.640
Du sagst ja,

00:07:25.900 --> 00:07:27.540
der Business-User ist eigentlich, glaube ich,

00:07:27.540 --> 00:07:29.380
eine sehr gesunde Einstellung, wenn man sagt,

00:07:29.440 --> 00:07:31.080
es geht darum, Business-Value,

00:07:31.720 --> 00:07:33.380
also zumindest aus der Business-Sicht ist es eine sehr

00:07:33.380 --> 00:07:34.140
gesunde Einstellung.

00:07:35.060 --> 00:07:37.440
Aber ich würde nicht nur sagen das. Also zum Beispiel,

00:07:38.040 --> 00:07:39.240
ich habe jetzt in einem Projekt

00:07:39.240 --> 00:07:40.620
habe ich jetzt,

00:07:40.840 --> 00:07:43.340
ich habe ja vor einiger Zeit

00:07:43.340 --> 00:07:45.460
mir mal so ganz tolle Class-Based-E-Mails für Django

00:07:45.460 --> 00:07:47.620
ausgedacht und habe jetzt in einem Projekt

00:07:47.620 --> 00:07:49.620
mal wirklich, weil ich jetzt Internationalisierung

00:07:49.620 --> 00:07:50.980
eingebaut habe, habe ich jetzt dann direkt

00:07:50.980 --> 00:07:53.260
alle E-Mails, weil ich da eh dran musste,

00:07:53.340 --> 00:07:54.900
weil ich die Templates halt anpassen musste und gucken musste,

00:07:54.940 --> 00:07:57.020
dass halt die Sprache reingegeben wird, etc., etc.,

00:07:57.020 --> 00:07:59.100
habe ich halt dann direkt gesagt, okay, ich refactor

00:07:59.100 --> 00:08:01.160
jetzt direkt alle E-Mails zu Classbase. Das ist natürlich

00:08:01.160 --> 00:08:03.220
viel, also das war

00:08:03.220 --> 00:08:05.120
definitiv in den 20%, ja,

00:08:05.320 --> 00:08:07.260
und nicht in den 80%, aber trotzdem

00:08:07.260 --> 00:08:09.020
weiß ich jetzt halt, dass wenn ich irgendwas mit den E-Mails

00:08:09.020 --> 00:08:10.960
machen muss und vielleicht mal auch generell was

00:08:10.960 --> 00:08:12.880
anpassen, zum Beispiel nochmal irgendwie das Layout überarbeiten,

00:08:12.960 --> 00:08:14.700
was eh für irgendwann ansteht bei dem Projekt und sowas,

00:08:15.260 --> 00:08:16.880
habe ich halt danach einfach weniger Arbeit und das

00:08:16.880 --> 00:08:19.000
bot sich halt an. Wenn ich die Dinger eh gerade auseinandernehme,

00:08:19.080 --> 00:08:20.840
dann mache ich das halt einfach noch mit. Gut, aber das ist jetzt auch

00:08:20.840 --> 00:08:23.080
wieder aus dem Effizienzgedanken heraus. Das heißt, du machst Refactoring

00:08:23.080 --> 00:08:25.360
deswegen, weil du später Arbeitszeit,

00:08:25.640 --> 00:08:27.300
Wartungszeit oder

00:08:27.300 --> 00:08:29.080
neue Feature-Entwicklungszeit

00:08:29.080 --> 00:08:29.540
sparst.

00:08:31.040 --> 00:08:33.080
Das wäre auch so ein Effizienzgedanken. Also quasi

00:08:33.080 --> 00:08:34.500
extrem wichtig, dass man das dann tut.

00:08:34.800 --> 00:08:37.000
Und es schont dann auch meine Nerven, wenn ich

00:08:37.000 --> 00:08:38.900
das dann nächstes Mal entspannter machen kann.

00:08:38.920 --> 00:08:41.240
Ja, das finde ich auch. Ich finde so Refactoren aufgrund

00:08:41.240 --> 00:08:42.720
von, wir brauchen das vielleicht nochmal

00:08:42.720 --> 00:08:45.360
und wie das da so steht, das versteht ja keiner.

00:08:45.960 --> 00:08:47.140
Das ist ein Spaghetti-Band.

00:08:47.240 --> 00:08:49.120
Irgendwer hat irgendwas gebaut, weil er noch gar nicht wusste, wie das ging.

00:08:49.120 --> 00:08:51.340
und hat das dann alles hingeschrieben. Das ging dann irgendwie,

00:08:51.640 --> 00:08:53.200
aber so richtig nutzbar

00:08:53.200 --> 00:08:54.700
und schön ist das alles nicht, dass das irgendwie so,

00:08:55.020 --> 00:08:56.320
wie man es so kennt, so zusammengezimmert.

00:08:57.300 --> 00:08:59.080
Ich finde auch ein ganz wichtiger Punkt ist, dass

00:08:59.080 --> 00:09:01.240
halt die meiste Software,

00:09:01.240 --> 00:09:03.060
die funktioniert, wird ja konstant weiterentwickelt.

00:09:03.320 --> 00:09:04.060
Das ist ja einfach so.

00:09:04.760 --> 00:09:05.880
Da frage ich mich auch ehrlich gesagt immer warum.

00:09:06.620 --> 00:09:08.960
Und immer wenn neue Anforderungen dazu kommen, dann

00:09:08.960 --> 00:09:11.160
hat man die ja logischerweise vorher

00:09:11.160 --> 00:09:12.920
nicht bedacht, weil man ja nicht wusste, dass die kommt

00:09:12.920 --> 00:09:14.460
in den meisten Fällen oder in vielen Fällen.

00:09:14.920 --> 00:09:17.140
Das heißt, man fängt dann an

00:09:17.140 --> 00:09:19.020
in etwas, was nicht dafür gedacht ist, mehr Sachen

00:09:19.020 --> 00:09:21.300
reinzubauen. Das ist immer der Punkt, wo, glaube ich,

00:09:21.320 --> 00:09:23.160
intrinsisch einfach schon der Bedarf von einem gewissen

00:09:23.160 --> 00:09:25.040
Refactoring besteht. Vielleicht nicht bei der ersten oder zweiten

00:09:25.040 --> 00:09:26.440
Änderung, aber irgendwann ist dann,

00:09:27.180 --> 00:09:28.660
gibt die Struktur das einfach nicht mehr her.

00:09:29.380 --> 00:09:31.060
Das ist halt genau die Frage. Wird

00:09:31.060 --> 00:09:33.280
was moderner, muss man das dann, diesen modernen

00:09:33.280 --> 00:09:34.560
Stil dann auch refactoren.

00:09:34.960 --> 00:09:37.040
Das ist aber eine Stilfrage. Das heißt, ich habe eine schönere

00:09:37.040 --> 00:09:38.980
Skulptur, die Skulptur hat eine andere Mode als vorher

00:09:38.980 --> 00:09:40.900
und deswegen mache ich es jetzt auf die gleiche Art. Ein bisschen

00:09:40.900 --> 00:09:43.060
neuer, ein bisschen anders. Es gibt ja jede Menge Dinge, die man

00:09:43.060 --> 00:09:43.680
neu machen kann.

00:09:44.940 --> 00:09:46.740
Ein schönes Beispiel finde ich Google. Google hat

00:09:46.740 --> 00:09:48.960
unheimlich viel Energie reingesteckt in das

00:09:48.960 --> 00:09:51.220
Gmail-Programm oder so. Und eigentlich

00:09:51.220 --> 00:09:53.120
würde ich fast setzen, dass so quasi Feature

00:09:53.120 --> 00:09:54.940
Kompli zu dem, was man sich so wünscht. Also man kann alles

00:09:54.940 --> 00:09:56.760
dann machen, was man mit zum E-Mail-Teil eigentlich so machen will.

00:09:57.200 --> 00:09:59.020
Und die haben auch schon so viel Zeit draufgeschmissen,

00:09:59.180 --> 00:10:01.020
dass so viel Neues nicht kommt. Was ich

00:10:01.020 --> 00:10:03.100
jetzt immer sehe, da kommen irgendwelche Änderungen am Style,

00:10:03.200 --> 00:10:04.920
an der Grafik, die irgendwas eigentlich einfach nur anders

00:10:04.920 --> 00:10:07.000
machen, die mich dann zum Beispiel eher

00:10:07.000 --> 00:10:08.920
nerven, weil ich brauche die einfach nicht, die will ich so haben wie

00:10:08.920 --> 00:10:11.000
früher oder so, weil ich veränderungsresistent

00:10:11.000 --> 00:10:13.120
bin oder so. Und das

00:10:13.120 --> 00:10:14.980
ist aber dann mit Refactoring verbunden.

00:10:15.060 --> 00:10:16.880
Warum macht man das? Vielleicht, weil die Abteilung dann denkt so,

00:10:16.960 --> 00:10:18.760
okay, wir haben jetzt noch wieder einen Sprint, wir wollen nicht

00:10:18.760 --> 00:10:20.560
aufgelöst werden. Wir wollen irgendwas machen.

00:10:20.740 --> 00:10:21.820
Und dann wie fängt dann die da irgendwie rum?

00:10:22.220 --> 00:10:23.780
Ist halt eigentlich schon fertig, die Software.

00:10:25.040 --> 00:10:26.500
Naja, du hast halt dann normalerweise

00:10:26.500 --> 00:10:28.600
irgendwelche Metriken, die halt an irgendeiner Stelle

00:10:28.600 --> 00:10:30.540
nicht so gut aussehen und dann machst du halt was, um das zu verbessern.

00:10:31.140 --> 00:10:32.680
Und manchmal wird das dann besser und manchmal

00:10:32.680 --> 00:10:33.460
wird das dann schlechter.

00:10:34.700 --> 00:10:36.280
Und dann nur schlechter für manche Leute.

00:10:36.540 --> 00:10:37.980
Und dann hast du halt vielleicht einfach Pech.

00:10:38.180 --> 00:10:40.260
Aber das ist halt die Frage.

00:10:40.260 --> 00:10:42.120
Also ich meine, ja, man könnte auch sagen, Software ist irgendwann

00:10:42.120 --> 00:10:44.060
fertig. Also irgendwann

00:10:44.060 --> 00:10:45.780
ist halt der Wert, den neue Features

00:10:45.780 --> 00:10:48.360
bringen, halt unter den Kosten,

00:10:48.360 --> 00:10:50.040
wenn du das halt priorisiert hast nach

00:10:50.040 --> 00:10:50.540
irgendwie

00:10:50.540 --> 00:10:54.120
was es reinkommt, irgendwie

00:10:54.120 --> 00:10:56.200
minus Kosten es zu entwickeln, irgendwann wird das halt

00:10:56.200 --> 00:10:58.020
negativ und aus einer Business-Sicht

00:10:58.020 --> 00:10:59.520
müsstest du dann einfach aufhören zu entwickeln.

00:11:00.440 --> 00:11:01.820
Aber ja, bestimmt,

00:11:02.020 --> 00:11:03.500
mit diesem Schritt tun sich viele schwer.

00:11:03.500 --> 00:11:05.200
Ja, genau. Und dann würde er sagen, okay,

00:11:05.240 --> 00:11:06.580
wir machen jetzt was anderes.

00:11:08.420 --> 00:11:09.100
Würde ich auch sagen,

00:11:09.200 --> 00:11:10.380
das wäre eigentlich, irgendwann ist es halt durch.

00:11:10.500 --> 00:11:12.860
Klar kann man irgendwann zehn Jahre nochmal einen Designer draufsetzen und sagen,

00:11:12.940 --> 00:11:15.260
hey, wir machen das ein bisschen moderner, aber dann muss die API

00:11:15.260 --> 00:11:16.700
vielleicht im Hintergrund, bleibt halt gleich.

00:11:16.700 --> 00:11:18.680
und was ich aber als Entwickler jetzt auch

00:11:18.680 --> 00:11:20.660
sehr super finde, ist tatsächlich

00:11:20.660 --> 00:11:23.020
Code schöner machen, weil man lernt immer was.

00:11:23.140 --> 00:11:25.000
Also ich kann ja eigentlich nicht so viel mit den Sachen,

00:11:25.180 --> 00:11:27.060
die ich neu mache, die kann ich vorher eigentlich

00:11:27.060 --> 00:11:29.100
meistens nicht. Also sonst sind die immer relativ schnell fertig

00:11:29.100 --> 00:11:30.940
und dann, aber wenn die neu sind, dann

00:11:30.940 --> 00:11:32.680
baue ich irgendwas neu, dann muss ich mir ein Konzept überlegen,

00:11:32.820 --> 00:11:34.780
ich weiß gar nicht, wo ich hin will und am Ende

00:11:34.780 --> 00:11:36.720
sehe ich halt immer, oh, auf dem Weg dahin

00:11:36.720 --> 00:11:38.740
bist du irgendwelche Sackkassen gelaufen,

00:11:38.900 --> 00:11:40.880
irgendwelche Abkürzungen gegangen, die du eigentlich gar nicht gehen solltest

00:11:40.880 --> 00:11:42.980
und hast voll irgendwas vergessen und das muss man

00:11:42.980 --> 00:11:44.920
dann nach und nach irgendwie einbauen. Aber das sorgfältig

00:11:44.920 --> 00:11:46.260
zu machen, das dauert halt viel mehr Zeit.

00:11:46.600 --> 00:11:48.860
Den ganzen Code kann man fast wieder neu schreiben und dann hat man am Ende

00:11:48.860 --> 00:11:49.860
was viel Schöneres dastehen.

00:11:50.440 --> 00:11:51.780
Und ich weiß nicht, ist das Refactoring?

00:11:53.640 --> 00:11:54.940
Ja, in einem halben Jahr später

00:11:54.940 --> 00:11:55.800
fasse ich es wieder an.

00:11:56.680 --> 00:11:58.440
Ich denke, das hätte ich irgendwie schöner machen können.

00:11:59.540 --> 00:12:00.140
Also ich habe

00:12:00.140 --> 00:12:02.720
das ja gleich mal direkt schon mal

00:12:02.720 --> 00:12:04.000
spoilern. Ich habe so ein Buch gelesen,

00:12:04.360 --> 00:12:04.960
das nennt sich

00:12:04.960 --> 00:12:08.540
A Philosophy of Software Design von

00:12:08.540 --> 00:12:10.540
John Osterhut oder so.

00:12:10.660 --> 00:12:12.240
Keine Ahnung, ob ich den jetzt richtig ausgesprochen habe.

00:12:12.900 --> 00:12:14.080
Das wurde mir empfohlen,

00:12:14.080 --> 00:12:16.780
in der Hacker News Diskussion

00:12:16.780 --> 00:12:18.360
und deswegen werde ich jetzt ganz viel daraus

00:12:18.360 --> 00:12:20.580
zitieren oder beziehungsweise Dinge

00:12:20.580 --> 00:12:22.560
sagen, die da drinstehen, weil ich davon jetzt noch

00:12:22.560 --> 00:12:24.780
eine Menge weiß und dann demnächst habe ich das wieder alles vergessen.

00:12:25.200 --> 00:12:26.900
Vielleicht habe ich jetzt schon eine ganze Menge vergessen.

00:12:28.060 --> 00:12:28.320
Aber

00:12:28.320 --> 00:12:30.700
das ist ein schöner Satz. Am Anfang steht

00:12:30.700 --> 00:12:32.600
da sowas wie, ja, also Software

00:12:32.600 --> 00:12:34.700
schreiben ist ja eigentlich toll, weil es ist halt so eine der

00:12:34.700 --> 00:12:36.780
puresten, eine der

00:12:36.780 --> 00:12:38.660
reinsten kreativen Tätigkeiten,

00:12:39.040 --> 00:12:40.700
weil man halt nicht so...

00:12:41.980 --> 00:12:42.600
Weil man hat kaum

00:12:42.600 --> 00:12:44.840
Begrenzungen durch irgendwelche Dinge.

00:12:45.160 --> 00:12:46.740
Alles, was man sich vorstellen kann, kann man

00:12:46.740 --> 00:12:48.320
im Grunde machen. Deswegen ist es halt sehr rein.

00:12:49.020 --> 00:12:51.000
Man ist nicht abhängig

00:12:51.000 --> 00:12:51.800
von irgendwelchen Dingen.

00:12:54.100 --> 00:12:55.260
Und da ist

00:12:55.260 --> 00:12:56.780
was dran. Ich weiß jetzt nicht, ob die meisten Leute

00:12:56.780 --> 00:12:58.660
das so sehen würden, aber das ist halt jetzt

00:12:58.660 --> 00:13:00.340
auch relativ weit auf der

00:13:00.340 --> 00:13:01.240
Seite.

00:13:03.360 --> 00:13:03.880
Das ist halt

00:13:03.880 --> 00:13:06.620
ein Wert, wenn das schön ist.

00:13:07.560 --> 00:13:08.780
Wenn es schön ist

00:13:08.780 --> 00:13:11.100
und rein ist und keine Ahnung, dann ist das

00:13:11.100 --> 00:13:12.020
irgendwie eine wertvolle Geschichte.

00:13:12.600 --> 00:13:15.200
und die andere Seite wäre halt, ist doch egal, Hauptsache es tut.

00:13:15.820 --> 00:13:18.620
Hauptsache die Features sind entwickelt und der Kunde ist glücklich.

00:13:19.340 --> 00:13:20.980
Und ich habe möglichst wenig Zeit dran im Rechner gesessen.

00:13:21.380 --> 00:13:24.860
Der Product Owner hat es abgenommen.

00:13:25.800 --> 00:13:26.680
Nach mir diesen Flut.

00:13:28.520 --> 00:13:30.240
Eher so ein pragmatischer Ansatz.

00:13:30.680 --> 00:13:33.660
Ich glaube, beide haben so eine gewisse Berechtigung.

00:13:34.820 --> 00:13:37.700
Ja, total. Gerade wenn ich jetzt meinen Nutzen maximiere,

00:13:37.800 --> 00:13:39.780
dann will ich möglichst wenig Zeit am Rechner verbringen,

00:13:39.920 --> 00:13:41.060
weil ich ja damit mein Geld verdiene.

00:13:41.060 --> 00:13:43.000
also, tu mir so, ich werde per Auftrag

00:13:43.000 --> 00:13:44.840
bezahlt oder sowas, ja, dann würde ich möglichst wenig

00:13:44.840 --> 00:13:46.880
Zeit daran sitzen, weil ich möchte ja irgendwas andere

00:13:46.880 --> 00:13:48.940
Sachen machen und was dann unten drunter, wie das

00:13:48.940 --> 00:13:50.820
aussieht, ob es hübsch oder hässlich ist, ist einem

00:13:50.820 --> 00:13:52.580
völlig egal, Hauptsache es ist schnell damit fertig

00:13:52.580 --> 00:13:54.920
und können das abhaken, den Auftrag

00:13:54.920 --> 00:13:57.020
erfüllt, das sieht ja quasi der Manager

00:13:57.020 --> 00:13:58.740
eh nicht, weil der guckt ja eh nicht unter die Haube,

00:13:59.140 --> 00:14:00.380
guckt ja nur, was am Ende dabei rausfällt.

00:14:00.760 --> 00:14:02.800
Du zahlst es halt beim nächsten, bei der nächsten

00:14:02.800 --> 00:14:04.720
Aufgabe. Genau, aber das passiert

00:14:04.720 --> 00:14:06.880
mir egal und ob ich dann selber dann was Neues dranflatschen muss,

00:14:07.220 --> 00:14:08.920
kann ja sein. Also man merkt es tatsächlich

00:14:08.920 --> 00:14:10.820
aber erst, wenn man so Speed aufnimmt, das heißt, wenn man das

00:14:10.820 --> 00:14:12.660
ordentlich macht, dann kann man diese Erweiterung,

00:14:12.740 --> 00:14:15.000
die Skalierung immer schneller machen und das Deliveren

00:14:15.000 --> 00:14:16.940
von neuen Sachen, wenn man es ordentlich gemacht hat,

00:14:16.960 --> 00:14:18.820
ist dann einfacher. Oder man kann halt Copy-Pasten aus dem

00:14:18.820 --> 00:14:20.440
anderen Projekt, wenn man es ordentlich gemacht hat,

00:14:20.460 --> 00:14:22.800
ganz einfach auf die neuen Sachen generalisieren.

00:14:23.160 --> 00:14:24.300
Das sind halt aber so Sachen, die

00:14:24.300 --> 00:14:26.760
nicht ziehen,

00:14:26.840 --> 00:14:28.000
wenn man halt immer was anderes machen muss.

00:14:28.660 --> 00:14:29.700
Ja, sagen wir mal so,

00:14:29.800 --> 00:14:32.600
wenn man jetzt rein aus der Business

00:14:32.600 --> 00:14:34.060
und auch aus der, sagen wir mal so,

00:14:35.240 --> 00:14:36.900
agilen Methodologie-Sicht

00:14:36.900 --> 00:14:38.720
da drauf guckt, dann ist

00:14:38.720 --> 00:14:40.720
der, es muss halt irgendwie funktionieren

00:14:40.720 --> 00:14:42.660
und ob das Feature fertig ist oder nicht, ist halt

00:14:42.660 --> 00:14:44.660
das, was man von außen sieht und das ist halt das

00:14:44.660 --> 00:14:46.580
Relevante. Das ist der

00:14:46.580 --> 00:14:48.920
deutlich dominantere

00:14:48.920 --> 00:14:51.040
Punkt,

00:14:51.180 --> 00:14:52.160
was halt dazu führt,

00:14:52.840 --> 00:14:54.580
dass der halt auch oft

00:14:54.580 --> 00:14:56.200
sehr stark betont wird in so

00:14:56.200 --> 00:14:58.840
kommerziellen Entwicklungen.

00:14:59.060 --> 00:15:00.680
Ja, ja, also der Manager, der interessiert sich nur

00:15:00.680 --> 00:15:01.880
für das KPI-Feature fertig oder nicht.

00:15:02.160 --> 00:15:03.640
Das ist halt sehr normal gesehen.

00:15:03.980 --> 00:15:06.280
Wenn man jetzt sagt, im Endeffekt jedes Feature

00:15:06.280 --> 00:15:08.300
ist, also wenn man sich das wie so, weiß ich nicht,

00:15:08.340 --> 00:15:10.200
eine Menge von Commits im Branch heraus vorstellt,

00:15:10.200 --> 00:15:16.840
und jedes Feature ist ja irgendwie ein Teil auf dieser Strecke zum Produkt, das irgendwann fertig oder an einem Release-Punkt ist.

00:15:17.520 --> 00:15:19.660
Und wenn man das halt sehr atomar sieht, dann stimmt das natürlich.

00:15:19.800 --> 00:15:24.860
Aber wenn man das halt über das große Ganze sieht, dann insbesondere bei langlaufenden Projekten,

00:15:24.900 --> 00:15:30.080
die halt wirklich konstant weiterentwickelt werden und wo vielleicht dann auch irgendwie ein Geschäftsprozess oder irgendwas,

00:15:30.140 --> 00:15:35.080
wo wirklich dann Firmengeld drüber läuft, glaube ich, ist das halt viel zu kurz gedacht.

00:15:35.080 --> 00:15:52.080
Ich habe letztens mit ein paar Entwicklern gesprochen und die waren in ihrem Projekt halt so ein bisschen, nicht wirklich schlimmer, es ging so ein bisschen fing an Richtung Zombiescrum zu werden. Es war eine relativ hohe Bugquote, das Team ist sehr viel Sachen hinterher gelaufen.

00:15:52.080 --> 00:15:53.620
generell. Was war Bugquote? Ganz kurz,

00:15:53.820 --> 00:15:56.300
Anzahl an Bugs pro 100-Zeilen-Code?

00:15:57.300 --> 00:15:58.160
Bugquote ist quasi

00:15:58.160 --> 00:16:00.300
die Anzahl der Bug-Tickets an allen Tickets im Sprint.

00:16:00.720 --> 00:16:02.560
Oder Bug-Story-Points

00:16:02.560 --> 00:16:04.380
auf die insgesamt Sprint-Story-Points

00:16:04.380 --> 00:16:05.340
gezogen, berechnet.

00:16:06.260 --> 00:16:08.200
Das Team war halt latent

00:16:08.200 --> 00:16:08.940
frustriert.

00:16:10.340 --> 00:16:12.020
Der Product Owner hat so ein bisschen

00:16:12.020 --> 00:16:13.300
die

00:16:13.300 --> 00:16:16.140
Fähigkeit des Teams irgendwie angezweifelt,

00:16:16.200 --> 00:16:17.920
weil irgendwie da waren die Bugs und Sachen, die abgesprochen waren,

00:16:17.960 --> 00:16:19.600
haben dann plötzlich nicht mehr funktioniert. Das war halt insgesamt

00:16:19.600 --> 00:16:21.520
so eine latente

00:16:21.520 --> 00:16:23.300
Unmut auf allen Seiten.

00:16:23.520 --> 00:16:24.960
Es lief halt einfach nicht wirklich rund.

00:16:25.660 --> 00:16:27.100
Dann haben die halt angefangen,

00:16:27.520 --> 00:16:29.900
so ein paar größere Sachen einfach mal anzugehen.

00:16:30.000 --> 00:16:33.000
Weil dann war halt gerade das eine große

00:16:33.000 --> 00:16:33.540
Release durch.

00:16:33.620 --> 00:16:35.980
Wir machen irgendwie Coverage rein.

00:16:36.120 --> 00:16:37.500
Wir zwingen Coverage in der Pipeline.

00:16:37.660 --> 00:16:40.100
Sprich, neuer Code muss getestet sein.

00:16:40.240 --> 00:16:41.640
Sonst kann ich nicht deployen.

00:16:42.260 --> 00:16:43.600
Committen schon, aber nicht deployen.

00:16:44.800 --> 00:16:46.000
Dann einfach mal geschaut,

00:16:46.180 --> 00:16:47.620
dass man einfach so

00:16:47.620 --> 00:16:49.160
Streamlining, wie kriegen wir

00:16:49.160 --> 00:16:51.460
wie kriegen wir alle möglichen Variablen beim

00:16:51.460 --> 00:16:53.520
Protiprogramm, das immer wieder mal auf die Nase fällt, wie kriegen wir

00:16:53.520 --> 00:16:54.860
das raus und immer mehr solche Sachen

00:16:54.860 --> 00:16:57.180
haben die halt dann angegangen

00:16:57.180 --> 00:16:59.480
und damit hat sich dann, also nicht nur, dass halt dann plötzlich

00:16:59.480 --> 00:17:01.220
die Backquote enorm gefallen ist,

00:17:01.680 --> 00:17:03.340
man glaubt nicht, was so ein simples

00:17:03.340 --> 00:17:04.100
Maß wie

00:17:04.100 --> 00:17:06.880
ich erzwinge

00:17:06.880 --> 00:17:09.400
Coverage in der Pipeline, das ist

00:17:09.400 --> 00:17:11.320
trivial, aber es hat total geholfen und auch die

00:17:11.320 --> 00:17:12.960
anderen Sachen und auf einmal hat sich dann,

00:17:13.320 --> 00:17:15.400
haben sie mir erzählt, einen ganz neuen

00:17:15.400 --> 00:17:17.440
Drive entwickelt,

00:17:17.560 --> 00:17:19.140
das ist echt faszinierend zu sehen gewesen

00:17:19.140 --> 00:17:21.300
und

00:17:21.300 --> 00:17:23.740
ja, und da hätten die selber nicht drüber nachgedacht,

00:17:23.820 --> 00:17:25.720
dass das wirklich so einen großen Effekt haben kann, aber auf einmal

00:17:25.720 --> 00:17:27.640
ist auch so diese ganze Lethargie raus, wenn man plötzlich mit

00:17:27.640 --> 00:17:29.200
hey, cool, da geht was weiter, es klappt wieder,

00:17:29.580 --> 00:17:30.860
man hat plötzlich wieder auch Energie oder

00:17:30.860 --> 00:17:33.620
Muße, irgendwie Sachen anzupassen, zu refactoren,

00:17:33.960 --> 00:17:35.780
weil man halt eh das Gefühl hat, okay, es geht jetzt wieder nach oben,

00:17:35.840 --> 00:17:37.700
wir versuchen nicht irgendwie dieses Haus immer so

00:17:37.700 --> 00:17:40.020
so lange zusammenzuzimmern, dass es bloß nicht auseinanderfällt,

00:17:40.140 --> 00:17:41.340
sondern man macht halt wieder was,

00:17:42.000 --> 00:17:43.320
ja, das Kreative, das Schöne halt.

00:17:44.280 --> 00:17:44.520
Mhm.

00:17:45.340 --> 00:17:46.940
Ich finde das so ein bisschen schwierig,

00:17:46.940 --> 00:18:16.920
und Jochen unterhalten sich über die Programmiersprache Python

00:18:16.940 --> 00:18:17.620
neu machen muss.

00:18:19.240 --> 00:18:20.720
Aus Business-Sicht ist das aber so ein bisschen komisch, weil

00:18:20.720 --> 00:18:23.040
es ist eher so, die meckern immer die ganze Zeit

00:18:23.040 --> 00:18:25.100
rum, warum läuft das denn noch nicht und warum sind da noch so viele Bugs

00:18:25.100 --> 00:18:26.620
und das verstehe ich alles nicht und es muss alles fertig sein.

00:18:27.540 --> 00:18:29.200
Aber später sind die dann gewohnt,

00:18:29.260 --> 00:18:31.060
dass sie genauso viel Zeit und Geld aufwenden müssen

00:18:31.060 --> 00:18:32.860
für Neuentwicklung und du denkst dir, ja, aber eigentlich

00:18:32.860 --> 00:18:34.360
das ist ja in zwei Tagen fertig, weil

00:18:34.360 --> 00:18:37.040
wir haben ja ordentlich am Anfang den Effekt gehört und schön gemacht.

00:18:37.140 --> 00:18:38.900
Das heißt, wenn man es richtig macht, könnte man die neuen

00:18:38.900 --> 00:18:40.900
Features alle direkt rausknallen, weil die super schnell

00:18:40.900 --> 00:18:42.960
gehen dann, aber das versteht dann keiner und

00:18:42.960 --> 00:18:44.460
das kann man auch nicht kommunizieren und

00:18:44.460 --> 00:18:46.460
ist auch eher gefährlich, das zu kommen.

00:18:46.940 --> 00:18:49.080
weil da so eine Erwartungshaltung entsteht,

00:18:49.100 --> 00:18:50.520
dass das halt immer so wäre und dass das

00:18:50.520 --> 00:18:52.900
auch nicht irgendwie clever dann vielleicht

00:18:52.900 --> 00:18:55.000
für so ein ganzes Team...

00:18:55.000 --> 00:18:57.100
Ich glaube, da ist es halt super essentiell,

00:18:57.200 --> 00:18:58.980
dass man halt einfach eine gute Vertrauensbasis

00:18:58.980 --> 00:18:59.880
mit dem Product Owner hat.

00:19:00.740 --> 00:19:03.000
Tja, genau. Oder überhaupt

00:19:03.000 --> 00:19:04.840
diese Kommunikation zwischen

00:19:04.840 --> 00:19:06.940
irgendwie eben, ob das jetzt Product Owner ist

00:19:06.940 --> 00:19:08.980
oder oft ist es ja so, der Product Owner ist ja noch so

00:19:08.980 --> 00:19:10.720
quasi mehr oder weniger Teil des Teams, aber

00:19:10.720 --> 00:19:12.780
halt, genau, Product Owner

00:19:12.780 --> 00:19:14.700
und Team irgendwie und

00:19:14.700 --> 00:19:16.800
dem Product Owner mit einem bezogen

00:19:16.800 --> 00:19:19.300
und halt irgendwie im weitesten Sinne das Management oder so.

00:19:19.380 --> 00:19:20.640
Wenn es da kein Vertrauen gibt, ist es schlecht.

00:19:20.780 --> 00:19:23.240
Ja genau und auch ganz wichtig ist eigentlich, dass die Entwickler mit dem Kunden

00:19:23.240 --> 00:19:25.280
irgendwie eigentlich so viel zu tun

00:19:25.280 --> 00:19:26.940
haben oder mit dem Gedanken der User-Stories,

00:19:27.420 --> 00:19:29.040
dass die halt da selber so committed drin sind

00:19:29.040 --> 00:19:30.960
auch, weil wenn halt die immer nur irgendwie

00:19:30.960 --> 00:19:32.300
ihre Tics wegschubsen, dann

00:19:32.300 --> 00:19:34.740
ist das dann irgendwann wurscht.

00:19:34.820 --> 00:19:36.560
Das ist halt genau so eine Kommunikationssache.

00:19:36.920 --> 00:19:38.700
Was der eigentliche Clou wäre,

00:19:38.900 --> 00:19:41.300
gutes Refactoring zu machen, von Anfang an das richtig zu tun,

00:19:41.660 --> 00:19:43.440
ist halt ein gutes Teamgespräch

00:19:43.440 --> 00:19:44.800
immer am Laufen zu halten, auch

00:19:44.800 --> 00:19:47.160
und zwar nicht nur über Tickets und Leistungen

00:19:47.160 --> 00:19:48.620
und KPIs, sondern halt auch...

00:19:48.620 --> 00:19:50.280
Aber tatsächlich, ich meine, das ist halt auch das,

00:19:50.440 --> 00:19:53.400
zu dem ganzen Agile-Kram

00:19:53.400 --> 00:19:55.100
gibt es halt auch einen kleinen Absatz in dem Buch,

00:19:55.960 --> 00:19:56.860
wo da halt so

00:19:56.860 --> 00:19:58.680
gesagt wird, ja, okay, Agile, voll gut,

00:19:58.800 --> 00:20:00.100
iterativ super, irgendwie,

00:20:00.660 --> 00:20:03.040
dass die Fachkompetenz nicht an den reichsten

00:20:03.040 --> 00:20:04.960
gekommen ist, also es gibt viele gute Sachen dabei,

00:20:05.360 --> 00:20:06.880
aber irgendwie, was nicht so toll ist,

00:20:06.940 --> 00:20:08.820
ist, dass diese ganzen Agile-Geschichten

00:20:08.820 --> 00:20:11.340
einen großen Wert auf diesen

00:20:11.340 --> 00:20:12.960
was bringt es

00:20:12.960 --> 00:20:15.380
fürs Business Punkt legen,

00:20:15.480 --> 00:20:17.060
was ja auch nicht unbedingt falsch ist, aber

00:20:17.060 --> 00:20:19.220
sozusagen sie tendieren dazu, das

00:20:19.220 --> 00:20:20.960
deutlich überzubetonen, weil

00:20:20.960 --> 00:20:23.120
es gibt halt auch diesen

00:20:23.120 --> 00:20:25.260
anderen Punkt, ist das denn jetzt gut designt

00:20:25.260 --> 00:20:26.380
zum Beispiel, ist das denn schön,

00:20:26.540 --> 00:20:29.220
ist das denn mit der geringstmöglichen

00:20:29.980 --> 00:20:31.300
Komplexität irgendwie

00:20:31.300 --> 00:20:33.080
gebaut worden und

00:20:33.080 --> 00:20:35.200
da gibt es jedenfalls auch

00:20:35.200 --> 00:20:36.960
meiner Ansicht nach nichts in dem

00:20:36.960 --> 00:20:38.860
zum Beispiel bei Scrum, was

00:20:38.860 --> 00:20:41.400
eine Rolle, die dafür zuständig wäre, das durchzusetzen.

00:20:41.400 --> 00:20:43.060
Simples, Better than Complex

00:20:43.060 --> 00:20:45.140
Das ist der nächste Sender auf Python

00:20:45.140 --> 00:20:47.520
Wenn das durch die Review beim Produkt owner, der da aber nicht aus einer

00:20:47.520 --> 00:20:49.140
technischen Perspektive drauf guckt, sondern aus einer

00:20:49.140 --> 00:20:51.520
Business Perspektive durchgeht, dann ist das ja gut

00:20:51.520 --> 00:20:53.700
und das Team ist halt, wird immer dazu gesagt

00:20:53.700 --> 00:20:55.180
ist dafür verantwortlich, dass es halt

00:20:55.180 --> 00:20:56.720
fertig sein muss, getestet sein muss

00:20:56.720 --> 00:20:59.460
aber tatsächlich, es gibt

00:20:59.460 --> 00:21:01.540
niemanden, der dann sagen kann, okay, das lasse ich nicht

00:21:01.540 --> 00:21:03.480
live gehen, das geht so nicht, das ist kacke

00:21:03.480 --> 00:21:04.840
Ich habe aber super Lust

00:21:04.840 --> 00:21:06.320
Bitte, red zu Ende

00:21:06.320 --> 00:21:09.500
Ja, und das gibt es halt nicht und das ist halt etwas, was

00:21:09.500 --> 00:21:11.340
so ein bisschen fehlt und was man, wo man

00:21:11.340 --> 00:21:13.020
sagen würde, okay, aus der

00:21:13.020 --> 00:21:15.300
taktischen Perspektive ist das irgendwie, also

00:21:15.300 --> 00:21:17.420
es führt halt, das Buch sagt, es gibt halt

00:21:17.420 --> 00:21:19.320
Unterschied zwischen taktischer Softwareentwicklung

00:21:19.320 --> 00:21:21.240
und strategischer und taktisch

00:21:21.240 --> 00:21:23.360
macht das irgendwie Sinn, die Features rauszukriegen, ja,

00:21:23.420 --> 00:21:25.140
und man hat halt auch ein Problem, wenn man das nicht hinkriegt,

00:21:25.660 --> 00:21:27.280
weil dann wird einem ja möglicherweise auch der Hahn

00:21:27.280 --> 00:21:29.220
zugedreht irgendwann, wenn man nach Reflection

00:21:29.220 --> 00:21:30.620
nicht so lange dauert, aber

00:21:30.620 --> 00:21:33.300
man muss halt diese strategische Perspektive auch berücksichtigen,

00:21:33.380 --> 00:21:34.940
weil ansonsten hat man halt irgendwann später ein Problem

00:21:34.940 --> 00:21:36.640
und diese Dinger

00:21:36.640 --> 00:21:39.220
summieren sich halt auf und machen Sachen halt

00:21:39.220 --> 00:21:40.120
am Schluss sehr, sehr teuer.

00:21:40.120 --> 00:21:42.360
in unerwarteter Weise auch.

00:21:43.880 --> 00:21:46.260
Und ich würde jetzt sagen, Reflectoring ist halt auch so ein Ding,

00:21:46.380 --> 00:21:48.360
was halt im Grunde dafür da ist, die Komplexität

00:21:48.360 --> 00:21:50.380
von so einem Software-System

00:21:50.380 --> 00:21:52.060
zu reduzieren. Das wäre

00:21:52.060 --> 00:21:53.600
so, würde ich denken, es wäre ein Ziel.

00:21:56.120 --> 00:21:57.920
Die Frage, was ist Komplexität? Komplexität

00:21:57.920 --> 00:22:00.040
würde ich jetzt auch so mal definieren, wie es in dem Buch wurde,

00:22:00.100 --> 00:22:01.340
dass er pragmatisch definiert als

00:22:01.340 --> 00:22:03.840
alles, was dazu führt, dass

00:22:03.840 --> 00:22:05.820
ein System schwerer zu ändern ist,

00:22:05.940 --> 00:22:08.400
beziehungsweise dazu führt, dass man es nicht so gut verstehen kann,

00:22:08.860 --> 00:22:09.480
ist Komplexität.

00:22:09.480 --> 00:22:34.940
Also entweder zu hohen Abhängigkeiten oder zu hohe Abstraktionsniveaus oder zu verschachteltem Falschnamen. Also ich finde, das ist relativ nah an diesem Code-Review-Gedanken dran. Ja, also kann ich den Code gut lesen? Sind die Namen so, wie ich sie haben will? Ist die Dokumentation schön? Sind halt die Designs so implementiert, wie man es erwarten würde vielleicht? Oder ist das irgendwas ganz anderes? Oder macht das Sinn?

00:22:34.940 --> 00:22:38.040
Noch ein bisschen Style

00:22:38.040 --> 00:22:40.100
Du hast irgendwie gesagt, du wolltest den Unterschied

00:22:40.100 --> 00:22:41.880
zwischen Design und Style an der Stelle

00:22:41.880 --> 00:22:44.020
vielleicht erklären, was Design gemeint ist

00:22:44.020 --> 00:22:45.800
Design

00:22:45.800 --> 00:22:46.580
ist tatsächlich

00:22:46.580 --> 00:22:49.680
wie funktioniert das

00:22:49.680 --> 00:22:51.640
System gemeint, nicht so sehr, wie sieht es aus

00:22:51.640 --> 00:22:53.520
oder wie sieht der Code aus

00:22:53.520 --> 00:22:55.100
das ist alles nicht so, sondern eher wie

00:22:55.100 --> 00:22:57.760
funktionieren die Teile miteinander

00:22:57.760 --> 00:22:59.840
Also tatsächlich so Pattern

00:22:59.840 --> 00:23:00.740
Ne

00:23:00.740 --> 00:23:03.720
also wie ist, also du hast ja

00:23:03.720 --> 00:23:05.860
also ich meine, nimm mal sowas wie Design Patterns

00:23:05.860 --> 00:23:07.500
da sieht man vielleicht, was damit gemeint ist

00:23:07.500 --> 00:23:09.080
das ist halt so

00:23:09.080 --> 00:23:11.420
das ist halt die Art, wie dein

00:23:11.420 --> 00:23:13.040
System designt ist

00:23:13.040 --> 00:23:14.340
also

00:23:14.340 --> 00:23:16.900
da gibt es mittlerweile so ein paar logische

00:23:16.900 --> 00:23:19.820
Strukturen, an denen

00:23:19.820 --> 00:23:21.500
man sich orientieren kann für Lösungen

00:23:21.500 --> 00:23:23.200
von bestimmten Problemen

00:23:23.200 --> 00:23:25.140
genau, aber man kann natürlich auch selber was machen

00:23:25.140 --> 00:23:27.360
außer wenn man irgendwas tut, ich meine, es ist ja die Frage, ob man sich

00:23:27.360 --> 00:23:29.700
an diese Patterns hält oder nicht, oder die benutzt

00:23:29.700 --> 00:23:31.200
aber man hat auf jeden Fall hinterher

00:23:31.200 --> 00:23:33.160
interessant wäre, wenn man selber was baut

00:23:33.160 --> 00:23:34.980
wo man keine Ahnung hat, man hat immer mehr Ahnung davon

00:23:34.980 --> 00:23:37.020
bekommt und das dann refactored, ohne mal, dass man

00:23:37.020 --> 00:23:39.020
die Pattern kennt, ob jetzt die Lösung, die man hat, selber

00:23:39.020 --> 00:23:40.460
Richtung dieser Pattern konvergiert.

00:23:40.620 --> 00:23:42.740
Ja, genau, Design-Python ist genau das, worauf es dann halt

00:23:42.740 --> 00:23:44.980
immer hinausläuft. Das ist eigentlich die Idee dabei.

00:23:46.880 --> 00:23:48.920
Ich wollte noch gerade eine Sache einwerfen zu der Sache

00:23:48.920 --> 00:23:50.660
mit der fehlenden Rolle im Scrum.

00:23:52.300 --> 00:23:53.120
Das ist auch eine Sache,

00:23:53.200 --> 00:23:54.220
über die ich jetzt in letzter Zeit

00:23:54.220 --> 00:23:56.420
relativ viel nachgedacht habe, weil

00:23:56.420 --> 00:23:58.940
wir ja auch ganz viele Scrum-Teams haben

00:23:58.940 --> 00:24:01.120
und im Endeffekt, es ist natürlich

00:24:01.120 --> 00:24:03.020
schon so, dass wenn du einen guten Entwickler hast,

00:24:03.020 --> 00:24:33.000
und Jochen unterhalten sich über die Programmiersprache Python

00:24:33.020 --> 00:24:34.660
der Scrum Master

00:24:34.660 --> 00:24:37.500
ist vielleicht Techniker, aber vielleicht auch nicht.

00:24:37.880 --> 00:24:39.120
Das heißt, er kann es auch nicht beurteilen.

00:24:39.540 --> 00:24:41.260
Dann hast du ein Team, das ja meistens gemischt aus

00:24:41.260 --> 00:24:43.580
Juniors und Juniors ist. Bei den Juniors kann man es eigentlich nicht erwarten,

00:24:43.680 --> 00:24:45.520
dass jemand ganz frisch im Job ist, schon irgendwie

00:24:45.520 --> 00:24:47.120
drei Jahre im Voraus denkt.

00:24:47.820 --> 00:24:49.520
Und es

00:24:49.520 --> 00:24:50.900
gibt tatsächlich auch super viele

00:24:50.900 --> 00:24:53.100
Artikel dazu im Internet,

00:24:53.220 --> 00:24:55.260
die genau versuchen, diese Idee des

00:24:55.260 --> 00:24:57.280
IT-Architekten aus dem klassischen Wasserfall

00:24:57.280 --> 00:24:58.480
irgendwie in dieses

00:24:58.480 --> 00:25:01.140
ich habe jetzt ein Gänsefüßchen gesagt, IT-Architekt,

00:25:01.140 --> 00:25:04.740
weil das irgendwie in dieses

00:25:04.740 --> 00:25:06.260
Fram reinzubringen und da gibt es halt

00:25:06.260 --> 00:25:08.160
auch wirklich lange Artikel und so dazu,

00:25:09.000 --> 00:25:10.720
wo halt wirklich dafür auch gesagt wird, dass man das braucht,

00:25:10.800 --> 00:25:12.800
wie du es gerade auch gesagt hast und das ist auf jeden Fall ein Muss

00:25:12.800 --> 00:25:14.760
und dann gibt es Artikel, die sagen, nein, braucht man

00:25:14.760 --> 00:25:16.300
nicht, weil und so weiter und ich glaube, dass

00:25:16.300 --> 00:25:18.200
die Wahrheit liegt wie immer dazwischen und ich glaube,

00:25:18.740 --> 00:25:20.800
eine Sache, die im Scrum nicht vorgesehen ist, aber eine Lösung

00:25:20.800 --> 00:25:22.800
dafür könnte sein, halt jemand, der sich halt

00:25:22.800 --> 00:25:24.660
sage ich mal so als Lead-Entwickler im Team sieht.

00:25:24.740 --> 00:25:26.680
Das ist im Scrum ja explizit eigentlich nicht gewünscht, weil da alle

00:25:26.680 --> 00:25:28.660
gleich sind und alle haben gleich die Verantwortung,

00:25:29.260 --> 00:25:30.800
aber ich glaube, so zumindest

00:25:30.800 --> 00:25:33.120
Aber so gut wie es geht sind die Teams ja auch immer nicht.

00:25:33.600 --> 00:26:29.765
Genau aber ich glaube wenn du jemanden hast der sich daf verantwortlich f und der das technische Know hat und wie gesagt wichtig ist auch dass er erstens wei dass er diese Rolle hat und zweitens auch dass er das machen kann dann glaube ich kann das diese Br schon ganz gut also diese Br spannen und wenn der PO dieser Person auch vertraut und wenn die Person sagt nee sorry aber wir m das Technik vorher machen bevor wir das umsetzen weil sonst wird sonst nichts dann glaube ich ist das so der Weg den man da gut gehen kann

00:26:29.785 --> 00:26:59.765
80% Planung und dann wird umgesetzt.

00:26:59.785 --> 00:27:01.585
zwingend. Also ich glaube, es ist tatsächlich

00:27:01.585 --> 00:27:03.545
auch eine eigene Rolle gewesen oder

00:27:03.545 --> 00:27:05.645
ist es noch. Also je größer die Firma,

00:27:05.785 --> 00:27:07.465
umso mehr Rollen hast du da separat, logischerweise.

00:27:07.625 --> 00:27:09.565
Aber ich glaube, die Idee ist wirklich, das ist jemand,

00:27:09.705 --> 00:27:11.525
der gar kein zwingender Entwickler sein muss, der aber

00:27:11.525 --> 00:27:13.245
trotzdem halt technisches Know-how hat und der

00:27:13.245 --> 00:27:15.465
versucht, alle Abhängigkeit

00:27:15.465 --> 00:27:17.685
und Eventualitäten, die dieses System betrifft,

00:27:17.945 --> 00:27:19.525
also alles, was man an

00:27:19.525 --> 00:27:21.405
Setup, Surroundings und so weiter hat,

00:27:21.645 --> 00:27:23.525
alles bedenkt und das alles niederschreibt.

00:27:23.565 --> 00:27:25.425
Ja, dann braucht der eigentlich relativ viel Ahnung vom

00:27:25.425 --> 00:27:26.865
eigentlichen Business und vom Kunden.

00:27:27.825 --> 00:27:29.485
Und halt auch technisch. Das ist das Wichtige,

00:27:29.485 --> 00:27:31.525
so dass man zum Beispiel sagt, weiß ich nicht, wenn ich

00:27:31.525 --> 00:27:33.545
jetzt irgendwas habe mit asynchronen

00:27:33.545 --> 00:27:35.385
Prozessen und Mailing, dass ich halt sicherstelle,

00:27:35.505 --> 00:27:37.665
dass irgendwo drüber nachgedacht ist, dass ich irgendeine Art

00:27:37.665 --> 00:27:39.505
von asynchronen Processing auch drin habe und nicht,

00:27:39.625 --> 00:27:41.725
dass das halt dann nachher irgendwann auffällt, ups, blöd.

00:27:42.005 --> 00:27:42.725
Wie machen wir das denn jetzt?

00:27:43.665 --> 00:27:44.605
Blöd ist Blödbeformung.

00:27:45.485 --> 00:27:46.605
Blockiert leider unter Protest.

00:27:48.225 --> 00:27:49.805
Ja, also genau, Softwarearchitektur

00:27:49.805 --> 00:27:51.445
ist natürlich auch so ein verwandtes Thema und

00:27:51.445 --> 00:27:52.305
ja,

00:27:52.625 --> 00:27:54.385
genau, aber

00:27:54.385 --> 00:27:57.505
wer ist dafür zuständig, gibt es dann meistens,

00:27:57.505 --> 00:27:59.425
also kann sein, dass die

00:27:59.425 --> 00:28:01.205
dann halt nicht in den Teams immer mit drin sind, sondern

00:28:01.205 --> 00:28:02.885
übergreifen, die gucken sich das dann halt mal an

00:28:02.885 --> 00:28:05.065
und machen dann irgendwie Vorschläge oder so.

00:28:05.305 --> 00:28:07.245
Aber ja, es ist unterschiedlich,

00:28:07.365 --> 00:28:08.705
wie das gehandhabt wird, aber

00:28:08.705 --> 00:28:11.405
genau, also dass da irgendwie sich jemand drum kümmern müsste,

00:28:11.645 --> 00:28:12.645
mal so, ist eigentlich schon

00:28:12.645 --> 00:28:14.665
relativ offensichtlich.

00:28:15.905 --> 00:28:17.125
Ja, aber was

00:28:17.125 --> 00:28:17.965
genau, was

00:28:17.965 --> 00:28:21.185
denkt ihr denn so, genau,

00:28:21.325 --> 00:28:23.245
was macht man denn, wenn man

00:28:23.245 --> 00:28:24.625
versucht, so ein Software-System

00:28:24.625 --> 00:28:27.205
einfacher zu machen, was könnte man denn da tun?

00:28:27.205 --> 00:28:30.225
Muss man das refactoren?

00:28:31.025 --> 00:28:32.985
Ja gut, Refactoring ist jetzt sozusagen

00:28:32.985 --> 00:28:34.085
das, was man dann tut, aber

00:28:34.085 --> 00:28:36.945
was wäre denn das Ziel

00:28:36.945 --> 00:28:38.825
von so einem Refactoring, wenn es darum geht,

00:28:38.865 --> 00:28:39.845
die Komplexität zu senken?

00:28:43.505 --> 00:28:44.185
Also ich würde auch

00:28:44.185 --> 00:28:46.185
tatsächlich mit diesem Schönheitsansatz

00:28:46.185 --> 00:28:47.265
ausreden.

00:28:50.425 --> 00:28:51.145
Wahrscheinlich wisst ihr alle,

00:28:51.245 --> 00:28:52.785
was man damit meint, wenn ihr schon mal ein bisschen

00:28:52.785 --> 00:28:54.845
gut geschrieben habt. Kennt ihr was, was agil ist

00:28:54.845 --> 00:28:56.425
und was stinkt irgendwie oder was, wo ihr denkt,

00:28:56.425 --> 00:28:57.285
Oh, das ist aber hübsch.

00:28:58.185 --> 00:29:00.465
Was wir da am Anfang irgendwie dann so um die Ohren,

00:29:00.505 --> 00:29:02.385
ich habe das am Anfang nicht so richtig verstanden, ich weiß nicht, vielleicht geht es

00:29:02.385 --> 00:29:04.325
ja anderen Leuten auch so, wenn

00:29:04.325 --> 00:29:06.285
dann jemand draufgeguckt hat und war so, okay, vielleicht

00:29:06.285 --> 00:29:08.365
nicht so toll, dann hieß es immer so, ja,

00:29:08.925 --> 00:29:10.665
da muss man vielleicht mal so ein bisschen modularisieren

00:29:10.665 --> 00:29:11.305
oder so, ne?

00:29:12.625 --> 00:29:14.385
Modularisierung, weiß nicht, ob euch das schon mal so...

00:29:14.385 --> 00:29:16.565
Genau, da gibt es ein ganz berühmtes Paper von 1972,

00:29:16.785 --> 00:29:18.425
glaube ich, ist das...

00:29:19.205 --> 00:29:20.425
Jetzt habe ich den Titel

00:29:20.425 --> 00:29:20.985
vergessen.

00:29:21.725 --> 00:29:23.505
David Palas, genau.

00:29:24.125 --> 00:29:25.425
Wo er zum ersten Mal

00:29:25.425 --> 00:29:27.885
diese Idee formuliert hat,

00:29:28.125 --> 00:29:29.725
dass wenn du jetzt ein

00:29:29.725 --> 00:29:30.965
komplexes System hast,

00:29:31.525 --> 00:29:33.205
wo viele Abhängigkeiten sind oder so,

00:29:33.525 --> 00:29:35.845
dann ist es vielleicht eine gute Idee, das System so zu teilen,

00:29:36.705 --> 00:29:37.905
dass man

00:29:37.905 --> 00:29:39.865
nur noch einzelne Teile quasi verstehen muss

00:29:39.865 --> 00:29:40.745
und nicht alles auf einmal.

00:29:41.865 --> 00:29:43.825
Und wie man das dann macht,

00:29:43.865 --> 00:29:45.205
ist eigentlich relativ egal. Du kannst es mit

00:29:45.205 --> 00:29:47.325
Microservices machen, du kannst es aber auch

00:29:47.325 --> 00:29:49.565
mit Funktionen machen, mit Klassen, mit

00:29:49.565 --> 00:29:51.605
Modulen, Paketen, was auch immer.

00:29:51.845 --> 00:29:53.425
Völlig egal. Das ist letztlich nicht

00:29:53.425 --> 00:30:10.305
der wichtige Teil, sondern der wichtige Teil ist quasi, kannst du dein System so aufteilen, dass sich die Komplexität deines Gesamtsystems reduziert auf die Komplexität des komplexesten Moduls sozusagen.

00:30:10.305 --> 00:30:11.505
Ja, das finde ich schon ganz einfach.

00:30:11.505 --> 00:30:12.005
Im Idealfall.

00:30:12.405 --> 00:30:19.325
Also zum Beispiel in Django gelingt es mir nicht immer, dass man so die Sachen von einer trennt, weil viele Sachen sind von der User-App abhängig oder sowas. Das ist nicht so einfach.

00:30:19.865 --> 00:30:21.605
Das ist nicht so einfach. Das ist auch richtig, ja.

00:30:21.605 --> 00:30:23.825
Das ist genau das

00:30:23.825 --> 00:30:25.925
Ja, genau, ich wusste dann auch nicht so genau, was macht man denn

00:30:25.925 --> 00:30:27.925
dann da, genau, das ist sehr schwierig

00:30:27.925 --> 00:30:29.925
Ja, ist es tatsächlich auch sehr

00:30:29.925 --> 00:30:31.785
schwierig, finde ich immer noch schwierig

00:30:31.785 --> 00:30:33.365
Aber ja, also

00:30:33.365 --> 00:30:35.985
im Grunde ist das halt so die Idee, dass man

00:30:35.985 --> 00:30:37.345
das halt tatsächlich

00:30:37.345 --> 00:30:39.105
vielleicht irgendwie so hinbekommt

00:30:39.105 --> 00:30:40.605
und

00:30:40.605 --> 00:30:43.885
ja, das ist im Grunde auch, im Grunde jetzt

00:30:43.885 --> 00:30:45.585
rausfinden, wie sind diese Module und

00:30:45.585 --> 00:30:47.945
was soll damit was reden, wie sind die Interfaces

00:30:47.945 --> 00:30:49.765
Das ist eigentlich im Grunde das, was man für Architektur macht

00:30:49.765 --> 00:30:51.725
beziehungsweise was man halt auch macht,

00:30:51.805 --> 00:30:53.405
wenn man jetzt Design macht.

00:30:54.205 --> 00:30:55.825
Also nochmal, Interface

00:30:55.825 --> 00:30:57.725
ist halt die Schnittstelle, quasi eine API,

00:30:57.885 --> 00:30:59.445
wo ein Modul mit dem anderen interagiert.

00:31:00.545 --> 00:31:01.965
Und da muss man quasi definieren,

00:31:02.085 --> 00:31:03.425
welches Protokoll reden wir miteinander und

00:31:03.425 --> 00:31:05.345
mit welchen Feldern und welchen

00:31:05.345 --> 00:31:07.565
Datentypen wollen die denn haben.

00:31:07.825 --> 00:31:09.485
Und im Grunde ist,

00:31:09.685 --> 00:31:10.305
also das ist jetzt wieder,

00:31:11.305 --> 00:31:12.325
aus mir spricht dieses Buch,

00:31:14.025 --> 00:31:15.565
ist der

00:31:15.565 --> 00:31:17.405
interessante Teil gar nicht darum, wie man das jetzt

00:31:17.405 --> 00:31:19.545
technisch umsetzt oder so, sondern im Grunde

00:31:19.545 --> 00:31:22.045
ist die interessante Frage.

00:31:24.365 --> 00:31:26.025
Naja, also man hat halt

00:31:26.025 --> 00:31:28.445
Abstraktionen. Also ein Modul ist ja auch so eine Abstraktion

00:31:28.445 --> 00:31:30.245
und eine Abstraktion

00:31:30.245 --> 00:31:31.485
hat immer das Ziel,

00:31:32.185 --> 00:31:34.085
dass man

00:31:34.085 --> 00:31:36.165
etwas, also quasi

00:31:36.165 --> 00:31:38.205
nur einen bestimmten Aspekt von etwas

00:31:38.205 --> 00:31:40.045
tatsächlich wissen muss und

00:31:40.045 --> 00:31:42.145
die ganze komplexität der Tende ist halt versteckt.

00:31:42.845 --> 00:31:44.205
Und deswegen hat man nur diese

00:31:44.205 --> 00:31:45.725
Abstraktion und wenn die Abstraktion gut ist,

00:31:46.265 --> 00:31:48.125
dann muss man den Rest auch nicht

00:31:48.125 --> 00:31:49.625
wissen oder meistens nicht wissen.

00:31:50.225 --> 00:31:51.845
Wenn die Abstraktion schlecht ist, dann liegt

00:31:51.845 --> 00:31:54.065
die halt und dann muss man daran doch wissen und

00:31:54.065 --> 00:31:56.065
das ist dann schlecht. Aber wenn man eine

00:31:56.065 --> 00:31:57.905
gute Abstraktion gefunden hat, dann

00:31:57.905 --> 00:32:00.245
braucht man sich sozusagen

00:32:00.245 --> 00:32:02.085
mental nur mit dieser Abstraktion beschäftigen

00:32:02.085 --> 00:32:03.665
und gar nicht wissen, wie das im Detail alles funktioniert.

00:32:03.685 --> 00:32:04.265
Zum Beispiel Python.

00:32:05.585 --> 00:32:07.965
Ja, also eine Sprache, die so ein relativ hohes Abstraktionslevel

00:32:07.965 --> 00:32:09.885
hat, vielleicht auch schon über viele Probleme.

00:32:10.045 --> 00:32:11.905
Also das ist ja vielleicht auch der Grund, warum wir sowas benutzen

00:32:11.905 --> 00:32:14.025
und nicht mehr so alles in C schreiben oder so.

00:32:14.305 --> 00:32:15.945
Ja, natürlich. Also obwohl C ist

00:32:15.945 --> 00:32:18.065
ja auch eine High-Level

00:32:18.065 --> 00:32:19.945
Language schon, im Gegensatz

00:32:19.945 --> 00:32:21.725
Ja, gut.

00:32:22.345 --> 00:32:24.145
Das heißt, wenn wir in den Registern rumspringen wollen, wenn wir irgendwie

00:32:24.145 --> 00:32:25.745
ein Web-Server schreiben, ist das schon mal gar nicht so schlecht.

00:32:26.005 --> 00:32:27.365
Ja, das ist ja schon eine Hochsprache.

00:32:28.945 --> 00:32:30.305
Ich habe da tatsächlich ein ganz schönes

00:32:30.305 --> 00:32:31.545
Beispiel. Ich hatte letztens

00:32:31.545 --> 00:32:34.005
eine sehr undankbare

00:32:34.005 --> 00:32:36.225
Aufgabe. Ich sollte in einem

00:32:36.225 --> 00:32:36.665
Projekt

00:32:36.665 --> 00:32:40.465
bei

00:32:40.465 --> 00:32:42.505
also quasi

00:32:42.505 --> 00:32:44.305
eine Sache, die sich durch das gesamte

00:32:44.305 --> 00:32:46.225
System gezogen hat, das hat relativ viel mit

00:32:46.225 --> 00:32:49.665
mit Zeitberechnung zu tun, also wo irgendwelche Tage und irgendwelche

00:32:49.665 --> 00:32:53.565
Uhrzeiten Tage berechnet werden. Da sollte eine Sache, die vorher statisch war,

00:32:53.625 --> 00:32:57.805
also es gab halt im Endeffekt nur Tage, sollten diese Tage dann

00:32:57.805 --> 00:33:01.825
nach Regionen aufgeteilt werden. Also jetzt beispielsweise

00:33:01.825 --> 00:33:05.785
halt Feiertage, die halt jetzt nicht nur irgendwie, es gibt nicht fixe Feiertage,

00:33:05.865 --> 00:33:09.405
sondern es gibt halt Feiertage je nachdem, wo halt jemand dann ist, also wie das Zeitberechnungssystem.

00:33:10.385 --> 00:33:13.685
Und das hat halt wirklich querbeet

00:33:13.685 --> 00:33:43.665
und Jochen unterhalten sich über die Programmiersprache Python

00:33:43.685 --> 00:33:44.845
im System irgendwas angepasst.

00:33:45.545 --> 00:33:47.505
Und die Lösung war tatsächlich

00:33:47.505 --> 00:33:49.445
dann ganz, ganz blöd Abstraktion.

00:33:49.805 --> 00:33:51.765
Also sprich, jetzt war halt ein Django-Projekt,

00:33:51.845 --> 00:33:53.065
ich habe dann einfach mir

00:33:53.065 --> 00:33:55.545
Custom Query Set und Manager-Methoden geschrieben,

00:33:55.645 --> 00:33:57.605
die das halt komplett wegkapseln, wo ich dann trotzdem

00:33:57.605 --> 00:33:59.865
einfach nur das Datum und vielleicht noch den Nutzer reingebe.

00:34:00.465 --> 00:34:01.565
Und darunter

00:34:01.565 --> 00:34:03.945
liegt dann halt irgendwie ein Riesenapparat

00:34:03.945 --> 00:34:05.465
mit irgendwas, da halt alles dann passiert,

00:34:05.545 --> 00:34:07.905
um das halt zu bestimmen. Aber von oben

00:34:07.905 --> 00:34:09.705
verwendet es sich fast

00:34:09.705 --> 00:34:12.065
genauso wie die triviale Datenbankabfrage.

00:34:12.065 --> 00:34:13.805
und damit habe ich es wirklich geschafft,

00:34:13.905 --> 00:34:15.145
ich habe das ganze Ding

00:34:15.145 --> 00:34:17.965
umgebaut, ist ja auch eine Art von Refactoring

00:34:17.965 --> 00:34:20.065
eigentlich, nur dass es halt in dem Moment das Ticket war

00:34:20.065 --> 00:34:21.945
und ich habe wirklich nur

00:34:21.945 --> 00:34:23.365
drei oder vier kleine Bugs gehabt,

00:34:23.885 --> 00:34:25.885
weil halt, wie gesagt, die ganze Komplexität an einer

00:34:25.885 --> 00:34:27.965
einzigen Stelle war und ich halt danach nur noch schauen musste,

00:34:27.965 --> 00:34:30.225
dass ich halt die Methoden austausche.

00:34:30.585 --> 00:34:32.185
Und das war, es hat mich

00:34:32.185 --> 00:34:34.045
selbst total überrascht, wie gut das funktioniert hat.

00:34:34.145 --> 00:34:36.225
Also das hätte ich mir selbst nicht zugetraut,

00:34:36.285 --> 00:34:38.205
dass die Idee dann doch so gut trägt.

00:34:39.125 --> 00:34:39.245
Ja.

00:34:42.065 --> 00:34:44.905
Ja, das ist super, wenn man so eine

00:34:44.905 --> 00:34:46.785
High-Level-API hat, die man gut bedienen kann, das ist schon

00:34:46.785 --> 00:34:48.545
echt was wert. Ja, also genau

00:34:48.545 --> 00:34:50.865
und was sind gute Abstraktionen?

00:34:51.265 --> 00:34:53.065
Also nach dem

00:34:53.065 --> 00:34:54.905
Buch ist es halt so, ja, wenn Module

00:34:54.905 --> 00:34:56.345
tief sind, ist das gut

00:34:56.345 --> 00:34:58.765
und wenn die API halt

00:34:58.765 --> 00:35:00.705
klein ist, ist das auch gut. Also je kleiner die API

00:35:00.705 --> 00:35:02.845
und tiefer, je kleiner und tiefer, desto besser.

00:35:02.925 --> 00:35:04.825
Genau, du kannst mit einfachen Worten

00:35:04.825 --> 00:35:06.865
viel erreichen. Ja, also

00:35:06.865 --> 00:35:08.105
als sozusagen Beispiel für

00:35:08.105 --> 00:35:10.785
das ist irgendwie eine schöne API

00:35:10.785 --> 00:35:40.765
und Jochen unterhalten sich über die Programmiersprache Python

00:35:40.785 --> 00:35:43.125
und das war es eigentlich schon fast.

00:35:43.585 --> 00:35:45.185
Also Close weiß ich gar nicht, ob das ein eigener ist.

00:35:45.225 --> 00:35:46.085
Ja, doch, wahrscheinlich.

00:35:46.725 --> 00:35:48.425
Aber stimmt, genau.

00:35:49.285 --> 00:35:51.045
Und ja, es gibt noch

00:35:51.045 --> 00:35:53.205
IOControl. Also wahrscheinlich Read und

00:35:53.205 --> 00:35:54.805
Write oder so, aber ja. Was ist IOControl?

00:35:55.045 --> 00:35:56.945
Ja, man kann jetzt noch Spezialoperationen machen.

00:35:57.265 --> 00:35:58.605
Da wird es dann auch allmählich hässlich.

00:35:59.445 --> 00:36:01.365
Aber tatsächlich eigentlich so mit

00:36:01.365 --> 00:36:03.265
Pfeil aufmachen, irgendwie drin rumseeken,

00:36:03.745 --> 00:36:04.945
lesen, schreiben,

00:36:05.665 --> 00:36:07.185
kommt man halt schon sehr, sehr weit.

00:36:08.625 --> 00:36:08.905
Und

00:36:08.905 --> 00:36:10.625
ja, das ist halt eine schöne

00:36:10.625 --> 00:36:12.645
eine schöne Abstraktion, während zum Beispiel die

00:36:12.645 --> 00:36:14.625
Abstraktion,

00:36:14.725 --> 00:36:16.325
das ist dann so ein Negativbeispiel gewesen,

00:36:16.465 --> 00:36:18.425
halt so, wenn man jetzt in Java

00:36:18.425 --> 00:36:20.585
irgendwie Dinge lesen will

00:36:20.585 --> 00:36:22.465
aus einem File, dann macht man erstmal irgendwie so

00:36:22.465 --> 00:36:24.505
einen Input-Reader auf und dann macht man so

00:36:24.505 --> 00:36:26.745
einen Buffered-Input-Reader auf, wenn man das vergisst, hat man ein Problem,

00:36:26.885 --> 00:36:28.465
das ist alles ganz langsam, man weiß nicht so genau warum

00:36:28.465 --> 00:36:30.265
und dann muss man die Dinger konfigurieren

00:36:30.265 --> 00:36:32.445
und die Exposen halt ganz viele Sachen, die man halt

00:36:32.445 --> 00:36:34.585
setzen muss und der Default-File ist halt,

00:36:35.005 --> 00:36:36.445
den man halt eigentlich immer hat, der ist halt nicht

00:36:36.445 --> 00:36:38.325
der, also wenn man es einfach nur so

00:36:38.325 --> 00:36:39.985
aufmacht, ein File, dann hat man halt

00:36:39.985 --> 00:36:42.205
keine gebufferte I.O.

00:36:42.345 --> 00:36:43.645
und das ist halt alles ganz schrecklich.

00:36:44.565 --> 00:36:46.125
Und man muss halt sehr, sehr viel

00:36:46.125 --> 00:36:47.665
Detailwissen in der API schon,

00:36:48.185 --> 00:36:50.425
also man konfiguriert da schon sehr viel rum

00:36:50.425 --> 00:36:52.285
und also man hat halt, die API hat eine große

00:36:52.285 --> 00:36:53.225
Oberfläche und

00:36:53.225 --> 00:36:56.005
es ist schwer zu benutzen und eigentlich

00:36:56.005 --> 00:36:57.565
was sie macht, ist relativ trivial.

00:36:58.125 --> 00:36:59.685
Also es ist super flach. Also sowas wie in Python

00:36:59.685 --> 00:37:02.125
with open file name is file

00:37:02.125 --> 00:37:02.945
file.read.

00:37:03.965 --> 00:37:06.085
Genau, oder ja, for line and file

00:37:06.085 --> 00:37:08.185
oder sowas. Das ist halt irgendwie

00:37:08.185 --> 00:37:10.125
und das macht halt auch per Default

00:37:10.125 --> 00:37:11.985
alles richtig. Wenn du das in Python machst,

00:37:12.045 --> 00:37:14.185
dann ist das halt direkt schnell und macht alles

00:37:14.185 --> 00:37:15.705
schon so, wie man das eigentlich normalerweise haben will.

00:37:16.105 --> 00:37:18.245
Für die Fälle, in denen man das nicht so haben will, kann man das ja immer noch

00:37:18.245 --> 00:37:20.785
konfigurieren, dass es sich

00:37:20.785 --> 00:37:21.285
anders verhält.

00:37:22.045 --> 00:37:23.945
Aber genau, das ist halt gutes

00:37:23.945 --> 00:37:25.505
versus schlechtes API-Design quasi.

00:37:27.385 --> 00:37:27.625
Und

00:37:27.625 --> 00:37:29.825
ja, aber

00:37:29.825 --> 00:37:31.985
die richtige API für ein Problem,

00:37:32.085 --> 00:37:34.125
das man hat oder überhaupt die richtige Abstraktion zu finden,

00:37:34.185 --> 00:37:36.185
ist natürlich nicht so einfach. Das ist halt richtig schwierig.

00:37:36.845 --> 00:37:37.905
Vielleicht auch einer der Gründe für

00:37:37.905 --> 00:37:39.925
PHP, warum das immer so schlecht angesehen

00:37:39.925 --> 00:37:41.865
wird an so zwei Stellen und sich lange braucht, bis es ein bisschen

00:37:41.865 --> 00:37:43.745
besser wurde. Also wie gesagt, ich habe immer noch keine Ahnung

00:37:43.745 --> 00:37:45.905
davon, aber ist das einer der Erfinder, der irgendwie gesagt

00:37:45.905 --> 00:37:47.645
hat am Anfang so, ja, eigentlich kenne ich

00:37:47.645 --> 00:37:49.565
Programmiersprachen eigentlich gar nicht aus und ich wollte eigentlich auch

00:37:49.565 --> 00:37:51.505
Sprache machen, aber hey, jetzt bin ich ja irgendwie

00:37:51.505 --> 00:37:53.045
und wir müssen jetzt irgendwie das wieder retten.

00:37:54.785 --> 00:37:55.765
Ja, aber ich meine,

00:37:55.865 --> 00:37:57.745
es ist schon einen langen Weg gekommen

00:37:57.745 --> 00:37:59.685
sozusagen, also mittlerweile ist der

00:37:59.685 --> 00:38:01.585
PHP-Kurs. Aber ja,

00:38:02.425 --> 00:38:03.585
vielleicht einer der Gründe dafür, dass man sich

00:38:03.585 --> 00:38:05.605
über sowas noch keine Gedanken gemacht hat. Während Guido

00:38:05.605 --> 00:38:07.545
ja, glaube ich, von Anfang an, glaube ich,

00:38:07.545 --> 00:38:37.525
und Jochen unterhalten sich über die Programmiersprache Python

00:38:37.545 --> 00:38:39.265
also das wäre jetzt sozusagen, wie ist eine Sprache

00:38:39.265 --> 00:38:41.185
designt, da die richtigen

00:38:41.185 --> 00:38:43.145
Abstraktionen zu finden, auch super schwierig

00:38:43.145 --> 00:38:45.425
und da würden ja Leute dann auch direkt am Anfang

00:38:45.425 --> 00:38:47.225
schon unterschiedliche Ansichten

00:38:47.225 --> 00:38:49.185
vertreten und würden halt sagen so, okay

00:38:49.185 --> 00:38:51.325
also es gibt dann halt ein Lager irgendwie

00:38:51.325 --> 00:38:52.605
das sagen würde, so

00:38:52.605 --> 00:38:55.265
dieses dynamisch getypte

00:38:55.265 --> 00:38:56.645
das ist alles nicht gut

00:38:56.645 --> 00:38:59.545
irgendwie statisch getypt, bestes getypt

00:38:59.545 --> 00:39:00.125
voll gut

00:39:00.125 --> 00:39:03.265
muss alles statisch

00:39:03.265 --> 00:39:04.785
ja

00:39:04.785 --> 00:39:06.705
und an der Stelle wird man sich ja schon

00:39:06.705 --> 00:39:08.545
und das ist bis heute nicht raus, was jetzt nur besser ist.

00:39:08.545 --> 00:39:10.425
Ja, aber Typisieren ist auf jeden Fall

00:39:10.425 --> 00:39:12.685
anstrengender, wenn man halt einfach mal

00:39:12.685 --> 00:39:14.205
sowas schnellstens hinhotzen muss. Ich habe heute

00:39:14.205 --> 00:39:16.125
eine kurze Übung in Rust geschrieben,

00:39:16.585 --> 00:39:18.385
weil das ist einfach halt, du musst halt jedes Mal

00:39:18.385 --> 00:39:20.665
an jeden kleinen Witzel dran schreiben, was das eigentlich sein soll

00:39:20.665 --> 00:39:22.565
oder sollte und dann beschwert

00:39:22.565 --> 00:39:23.925
er sich der Compiler immer, wenn es halt nicht stimmt,

00:39:24.345 --> 00:39:26.605
was ja auch gar nicht eigentlich schlecht ist, weil in der Benutzung will man ja,

00:39:26.665 --> 00:39:27.245
dass es eigentlich stimmt.

00:39:28.105 --> 00:39:30.305
Im Reißen ist es halt dann egal, aber es funktioniert irgendwie trotzdem

00:39:30.305 --> 00:39:32.185
und das ist ein bisschen...

00:39:32.185 --> 00:39:34.245
Ja, aber das ist genau so ein Punkt.

00:39:36.705 --> 00:39:37.905
Genau, also wenn du

00:39:37.905 --> 00:39:39.125
jetzt in

00:39:39.125 --> 00:39:41.825
du kannst ja jetzt auch zum Beispiel in

00:39:41.825 --> 00:39:44.065
Python Type Annotations machen.

00:39:44.285 --> 00:39:45.805
Das ist auch unbedingt eine Folge.

00:39:46.885 --> 00:39:47.745
Ich habe jetzt erst

00:39:47.745 --> 00:39:49.945
vor kurzem damit angefangen, mich so ein bisschen zu beschäftigen,

00:39:50.045 --> 00:39:52.425
bevor ich dachte, ich soll auch

00:39:52.425 --> 00:39:53.685
Type Annotation schreiben.

00:39:54.265 --> 00:39:54.865
Keine Lust.

00:39:55.825 --> 00:39:57.965
Mich interessiert das alles nicht. Ich bin ja nicht

00:39:57.965 --> 00:39:59.905
deswegen zu Python gegangen,

00:40:00.185 --> 00:40:01.485
damit ich überall

00:40:01.485 --> 00:40:04.405
Typen dran schreiben muss.

00:40:05.825 --> 00:40:06.185
Aber

00:40:06.185 --> 00:40:08.265
Ja, aber mit FastAPI, obwohl das wir übrigens auch noch eine Folge machen,

00:40:08.745 --> 00:40:09.925
das ist cool benutzt,

00:40:10.045 --> 00:40:12.185
aber dann macht das sogar dann Dinge, wenn du die Typen

00:40:12.185 --> 00:40:14.265
verwendest und so. Ja, ja, ja, ja,

00:40:14.265 --> 00:40:16.285
also, aber gut, da passieren

00:40:16.285 --> 00:40:17.545
auch Sachen dynamisch.

00:40:18.065 --> 00:40:20.125
Also, das ist halt auch nochmal so ein,

00:40:20.445 --> 00:40:21.845
das geht ja schon fast darüber, die reinen

00:40:21.845 --> 00:40:24.185
Typannotationen hinaus, sondern...

00:40:24.185 --> 00:40:26.205
Ja, also je nachdem, was für Typen man

00:40:26.205 --> 00:40:28.165
dann da hat, passieren halt

00:40:28.165 --> 00:40:30.005
unterschiedliche Sachen, aber dann auch zur Laufzeit,

00:40:30.085 --> 00:40:30.425
nicht nur

00:40:30.425 --> 00:40:33.705
für den statischen Typchecker.

00:40:35.105 --> 00:40:36.165
Ja, aber natürlich,

00:40:36.185 --> 00:40:40.685
Genau, das ist halt so ein Problem beim Sprachdesign. Will man jetzt Typisierung haben oder nicht?

00:40:41.205 --> 00:40:45.085
Weil natürlich fängt es halt Bugs. Ich habe das jetzt auch gemerkt. Ich mache das seit einiger Zeit.

00:40:45.085 --> 00:40:51.025
Mache ich auch FastAPI und habe jetzt auch, dachte mir, gut, wenn ich das schon mache, dann schreibe ich die Annotation halt auch mit dazu.

00:40:51.685 --> 00:40:56.405
Und tatsächlich sind mir schon ein paar Mal Sachen aufgefallen, wo ich dann gemerkt habe,

00:40:56.565 --> 00:41:04.725
oh, da hat mir jetzt, ich lasse noch MyPy drüber laufen, wo mir dann MyPy auf die Finger haut oder halt eben PyLens oder was auch immer.

00:41:04.725 --> 00:41:34.705
und Jochen unterhalten sich über die Programmiersprache Python

00:41:34.725 --> 00:42:04.705
und Jochen unterhalten sich über die Programmiersprache Python

00:42:04.725 --> 00:42:34.705
und Jochen unterhalten sich über die Programmiersprache Python

00:42:34.725 --> 00:42:36.725
tatsächlich weiß, warum und welche Typen man da hat.

00:42:37.085 --> 00:42:38.725
Und wenn man das irgendwie sicherstellen kann. Und das geht halt

00:42:38.725 --> 00:42:40.665
mit Python ganz gut, weil du weißt halt, oh,

00:42:40.785 --> 00:42:42.765
da muss halt ein Int rein oder so.

00:42:42.985 --> 00:42:44.205
Und wenn man das vergisst, dann

00:42:44.205 --> 00:42:46.605
funktioniert das halt nicht. Und

00:42:46.605 --> 00:42:48.545
das ist mir auch erst klar geworden, als ich jetzt zum Beispiel

00:42:48.545 --> 00:42:50.485
die Lösung auch in Rastor in Google geschrieben habe, weil

00:42:50.485 --> 00:42:52.785
dann klar ist, welchen

00:42:52.785 --> 00:42:54.545
Typ er hat und weil es halt immer das falsche anzeigt,

00:42:54.605 --> 00:42:55.925
wenn man halt den Typen nicht konvertiert.

00:42:57.245 --> 00:42:58.805
Ist aber auch, glaube ich, eine super Sache,

00:42:58.965 --> 00:43:00.705
wenn man

00:43:00.705 --> 00:43:02.605
so interne APs hat, also entweder

00:43:02.605 --> 00:43:04.465
wenn man irgendwie so

00:43:04.465 --> 00:43:34.445
und Jochen unterhalten sich über die Programmiersprache Python

00:43:34.465 --> 00:43:36.725
dann direkt anzeigt, nee, nee, du machst

00:43:36.725 --> 00:43:39.025
die App mit Birnen. Das ist einfach super praktisch.

00:43:39.645 --> 00:43:40.965
Und umso tiefer das bei mir drin ist,

00:43:41.005 --> 00:43:42.605
umso mehr versuche ich auch dann, welche Type-Ins

00:43:42.605 --> 00:43:44.725
zu machen. Ja, mit dem Dann ist halt echt ein Problem.

00:43:45.865 --> 00:43:46.185
Aber,

00:43:46.425 --> 00:43:48.685
ja, da fällt mir auch

00:43:48.685 --> 00:43:50.245
gerade noch so eine Anekdote zu ein.

00:43:51.225 --> 00:43:52.705
Da gibt es noch

00:43:52.705 --> 00:43:54.705
ein Buch, JavaScript, the good parts,

00:43:54.845 --> 00:43:56.805
glaube ich, auch ein relativ bekanntes Buch. Das muss halt dünn sein.

00:43:57.645 --> 00:43:58.645
Das ist tatsächlich relativ

00:43:58.645 --> 00:44:00.605
dünn. Da gibt es doch diesen Witz mit dem dicken

00:44:00.605 --> 00:44:02.445
Buch. Genau, die

00:44:02.445 --> 00:44:07.845
Reference, das ist irgendwie zu tausend Seiten und dann irgendwie Good Parts ist halt irgendwie so ein Häppchen, ja, das stimmt.

00:44:08.545 --> 00:44:14.205
Und der Ausser davon, ich glaube, das ist David Crockford oder ich weiß nicht genau, der ist auch in diesen Standardisierungsgremien

00:44:14.205 --> 00:44:18.385
drin und so und der schrieb dann halt auch irgendwo, weiß gar nicht,

00:44:18.905 --> 00:44:23.605
naja, also irgendwie diese, ist eigentlich kein Wert oder ist irgendwie nix,

00:44:23.805 --> 00:44:27.825
Dinger sind ein Problem bei Sprachen, ja, also Python halt none,

00:44:27.985 --> 00:44:31.825
gibt's halt ein Ding und es ist halt immer wieder in diesem, wenn man sich über so

00:44:31.825 --> 00:44:33.485
Standardisierungsfragen, ist aber die Frage,

00:44:34.205 --> 00:44:36.065
ist das eine gute Idee, sowas in der Sprache zu haben

00:44:36.065 --> 00:44:37.805
oder nicht? Zum Beispiel SQL, ja, ist ja auch

00:44:37.805 --> 00:44:39.945
Null, ist für einen Großteil der

00:44:39.945 --> 00:44:42.085
wirklich hässlichen Sachen

00:44:42.085 --> 00:44:44.045
im Sprachstandard und auch für viele Bugs

00:44:44.045 --> 00:44:45.845
in Datenbankimplementationen,

00:44:45.845 --> 00:44:47.585
die dann halt auch irgendwie, und für viele

00:44:47.585 --> 00:44:49.725
Inkompatibilitäten in den Standards und so, also

00:44:49.725 --> 00:44:51.665
Null spielt da eine große Rolle, ja, wenn man jetzt

00:44:51.665 --> 00:44:53.905
so ein harmloses Ding wie Null, das kann ja nicht so viel kaputt machen,

00:44:54.205 --> 00:44:55.725
das Ding macht irgendwie dauernd

00:44:55.725 --> 00:44:57.725
und seit Jahrzehnten und konsistent irgendwie

00:44:57.725 --> 00:44:59.525
ganz fies Probleme. Und

00:44:59.525 --> 00:45:01.585
ja, er meinte da so, ja, also es ist immer so,

00:45:01.825 --> 00:45:03.025
unter Leuten, die sich mit

00:45:03.025 --> 00:45:05.785
Sprachdesign beschäftigen, und fragen, will man sowas in der Sprache

00:45:05.785 --> 00:45:07.725
haben oder nicht? Und dann gibt es immer so

00:45:07.725 --> 00:45:09.185
einen einen Teil der Leute, die sagen, ja, doch,

00:45:09.505 --> 00:45:11.385
ist eigentlich schon gut, wenn man das hat. Ein anderer Teil sagt, nee.

00:45:11.945 --> 00:45:13.485
Aber absolut niemand, absolut niemand

00:45:13.485 --> 00:45:15.605
vertritt die Ansicht, es ist voll gut,

00:45:15.705 --> 00:45:17.425
zwei davon in einer Sprache zu haben.

00:45:17.565 --> 00:45:18.585
Und da was gibt, hat halt zwei.

00:45:19.305 --> 00:45:21.305
Null und undefined. Und das ist halt wirklich

00:45:21.305 --> 00:45:23.265
ah, ja.

00:45:27.885 --> 00:45:29.525
Ja, und das macht Dinge wirklich

00:45:29.745 --> 00:45:31.465
komplizierter. Aber das Problem ist

00:45:31.465 --> 00:45:33.805
jetzt auch die Type-Annotationen

00:45:33.805 --> 00:45:35.245
selber machen Sachen natürlich auch komplizierter.

00:45:36.265 --> 00:45:37.525
Ja, zum Beispiel auch zirkuläre Importe

00:45:37.525 --> 00:45:38.705
oder sowas, das ist ein bisschen nervig.

00:45:38.985 --> 00:45:40.125
Nee, die Annotationen.

00:45:40.385 --> 00:45:43.365
Da kannst du auf das Problem natürlich auch

00:45:43.365 --> 00:45:44.365
stoßen, ja klar.

00:45:45.405 --> 00:45:46.185
Oder leichter.

00:45:47.065 --> 00:45:48.885
Aber ich meine, wenn das jetzt eben,

00:45:49.085 --> 00:45:51.305
also entweder man macht halt, wenn man jetzt die Typen

00:45:51.305 --> 00:45:53.365
annotiert und man macht

00:45:53.365 --> 00:45:55.065
es jetzt so quasi

00:45:55.065 --> 00:45:57.085
einfach, man muss halt dann auch seinen

00:45:57.085 --> 00:45:58.945
Stil ändern. Wenn die

00:45:58.945 --> 00:46:00.965
Typ-Annotationen einfach bleiben sollen, dann

00:46:00.965 --> 00:46:03.025
muss man halt irgendwie das auf so relativ

00:46:03.025 --> 00:46:04.965
primitive Datentypen runterbrechen

00:46:04.965 --> 00:46:07.045
und kann dann eigentlich auch nur noch so relativ

00:46:07.045 --> 00:46:08.965
primitive Datentypen verwenden.

00:46:09.425 --> 00:46:11.365
Ja, man will ja eigentlich schon komplexere

00:46:11.365 --> 00:46:13.085
Daten, also so ein Pathentic-Objekt oder

00:46:13.085 --> 00:46:14.945
sowas hinten. Ja, gut, okay.

00:46:15.045 --> 00:46:16.965
Also Pathentic ist nochmal, aber das Problem

00:46:16.965 --> 00:46:18.845
dabei ist halt, also wenn man das macht,

00:46:19.065 --> 00:46:20.985
dann hat man halt im Grunde, kommt man dann

00:46:20.985 --> 00:46:22.945
irgendwie so und wenn das Typsystem relativ

00:46:22.945 --> 00:46:24.145
einfach ist, was man so verwendet,

00:46:24.245 --> 00:46:26.985
dann kommt man halt bei einem Dialekt von Java raus,

00:46:27.045 --> 00:46:27.865
der halt super langsam ist.

00:46:28.945 --> 00:46:30.785
Und es sieht überhaupt nicht mehr aus wie Python eigentlich.

00:46:30.965 --> 00:46:33.125
Das ist halt irgendwie doof

00:46:33.125 --> 00:46:35.385
aber wenn man jetzt Python

00:46:35.385 --> 00:46:37.645
idiomatisch schreibt, so Pythonisch

00:46:37.645 --> 00:46:39.605
irgendwie, dann

00:46:39.605 --> 00:46:41.505
wird das mit den Typ-Annotationen

00:46:41.505 --> 00:46:43.385
ziemlich schwierig, also weil zum Beispiel

00:46:43.385 --> 00:46:45.345
so eine, da gab es letztens auch eine

00:46:45.345 --> 00:46:46.585
Podcast-Episode mit

00:46:46.585 --> 00:46:48.505
Luciano Ramaglio

00:46:48.505 --> 00:46:50.785
der hat für Python geschrieben das Buch

00:46:50.785 --> 00:46:52.445
kann ich nur empfehlen, gibt es jetzt

00:46:52.445 --> 00:46:53.685
im Frühjahr kommt eine

00:46:53.685 --> 00:46:57.185
zweite Ausgabe, zweite Edition

00:46:57.185 --> 00:46:59.025
Second Edition

00:46:59.025 --> 00:47:01.065
wo er auch viel über Type-Annotationen

00:47:01.065 --> 00:47:02.285
und so schreibt und

00:47:02.285 --> 00:47:03.705
der hat

00:47:03.705 --> 00:47:07.025
sich das auch dann halt mal

00:47:07.025 --> 00:47:08.365
so richtig angeguckt und so und hat dann

00:47:08.365 --> 00:47:11.105
die Typ-Annotationen für

00:47:11.105 --> 00:47:12.905
die Max-Funktionen sich angeguckt

00:47:12.905 --> 00:47:15.425
und das Problem bei Typ-Annotationen

00:47:15.425 --> 00:47:17.085
ist jetzt auch, die können ja auch falsch

00:47:17.085 --> 00:47:18.605
sein, die können ja richtig sein falsch sein, die können uns

00:47:18.605 --> 00:47:20.505
Positives geben, es kann sein

00:47:20.505 --> 00:47:23.265
dass etwas dem Typ zwar entspricht

00:47:23.265 --> 00:47:25.005
aber tatsächlich ist es

00:47:25.005 --> 00:47:26.805
inkompatibel und innen knallt es irgendwo

00:47:26.805 --> 00:47:28.805
das sollte natürlich nicht passieren, sollte Typ-Annotationen

00:47:29.025 --> 00:47:31.945
sollten so sein, dass es keine false positives und keine false negatives gibt.

00:47:32.105 --> 00:47:35.945
Also auch keine, das ist halt das, was mir immer passiert, wenn ich versuche das hinzuschreiben.

00:47:36.045 --> 00:47:40.085
Ich habe halt ganz oft false negatives, das heißt, mir sagt irgendwie MyPy oder so,

00:47:40.185 --> 00:47:43.125
da hast du was falsch gemacht und ich sage, nee, das ist eigentlich schon richtig,

00:47:43.285 --> 00:47:44.785
aber ich habe es irgendwie falsch hingeschrieben.

00:47:45.945 --> 00:47:48.805
Und bei einer Funktion wie Max ist das halt extrem schwierig

00:47:48.805 --> 00:47:53.905
und hat halt in den Type-Annotationen dafür halt Fehler gefunden, eben false positives, false negatives

00:47:53.905 --> 00:47:55.805
und hat halt versucht, das richtig zu machen.

00:47:55.805 --> 00:47:57.785
also es gibt irgendwo TypeShed oder so

00:47:57.785 --> 00:47:59.885
da steht die Annotation

00:47:59.885 --> 00:48:01.705
für Max drin und

00:48:01.705 --> 00:48:03.785
das wurde dann richtig, richtig gemein, weil

00:48:03.785 --> 00:48:05.625
Max ist halt auch so eine komische, also es gibt so diverse

00:48:05.625 --> 00:48:07.365
Funktionen, so MaxLen und so, die halt

00:48:07.365 --> 00:48:09.885
schön sind irgendwie, weil du kannst halt

00:48:09.885 --> 00:48:12.025
es ist eine sehr generische Funktion, du kannst da alles reinwerfen

00:48:12.025 --> 00:48:13.385
und es macht eigentlich immer das Richtige

00:48:13.385 --> 00:48:15.845
aber das jetzt zu annotieren

00:48:15.845 --> 00:48:17.585
ist halt die Hölle

00:48:17.585 --> 00:48:18.545
also er hat dann irgendwie

00:48:18.545 --> 00:48:21.825
die eigentliche Implementation von Max

00:48:21.825 --> 00:48:23.445
sind halt irgendwie so 25

00:48:23.445 --> 00:48:25.145
Zeilen oder so und

00:48:25.145 --> 00:48:32.285
und allein die Typ-Annotationen waren hinterher, du musst halt sechs Overloads dafür definieren, der Funktion,

00:48:32.505 --> 00:48:36.785
und es waren viel, viel mehr Zeilen in den Typ-Definitionen als hinterher in der Annotation.

00:48:37.245 --> 00:48:39.185
Und dann ist natürlich die Frage, und es war sehr schwer zu verstehen,

00:48:40.025 --> 00:48:42.985
und also irgendwie diverse subtile Fehler drin,

00:48:43.805 --> 00:48:47.785
also dann ist halt die Frage, okay, wenn das so schwierig ist, die Typen hinzuschreiben,

00:48:48.605 --> 00:48:53.825
macht das dann, ist dieses Verhältnis zwischen, und es ist halt auch sehr schwer zu lesen,

00:48:53.825 --> 00:48:56.005
also ist halt die Frage

00:48:56.005 --> 00:48:57.485
ja, ist das

00:48:57.485 --> 00:48:58.685
dann wert noch?

00:48:59.425 --> 00:49:01.985
Ja, das ist halt so

00:49:01.985 --> 00:49:03.025
die Frage

00:49:03.025 --> 00:49:05.485
und das gibt es genauso

00:49:05.485 --> 00:49:08.045
das war auch was, der im Podcast hat

00:49:08.045 --> 00:49:10.125
da meinte er so

00:49:10.125 --> 00:49:11.405
es gibt denn sozusagen

00:49:11.405 --> 00:49:12.705
ein Buch zu Java

00:49:12.705 --> 00:49:16.005
ich habe vergessen welches

00:49:16.005 --> 00:49:17.785
das ist, auf jeden Fall ist auch einer

00:49:17.785 --> 00:49:19.565
der in der Sprache mitgearbeitet hat oder so

00:49:19.565 --> 00:49:21.825
der schrieb dann halt zu, als die Generics eingeführt wurden

00:49:21.825 --> 00:49:22.165
selber

00:49:22.165 --> 00:49:25.705
sagt er dazu, also die Generics waren ein

00:49:25.705 --> 00:49:26.705
Desaster in Java

00:49:26.705 --> 00:49:29.365
und es gibt diverse Geschichte

00:49:29.365 --> 00:49:31.485
Konstrukte, die sie da gemacht haben

00:49:31.485 --> 00:49:33.725
wo sie dann gesagt haben

00:49:33.725 --> 00:49:35.725
wir haben das jetzt irgendwelchen Professoren, die sich

00:49:35.725 --> 00:49:37.685
mit Typtheorie beschäftigen, gezeigt

00:49:37.685 --> 00:49:39.665
und die sagen, das stimmt

00:49:39.665 --> 00:49:41.825
aber wir können

00:49:41.825 --> 00:49:43.325
das nicht bestätigen oder

00:49:43.325 --> 00:49:45.745
weil wir

00:49:45.745 --> 00:49:46.925
verstehen nicht, was das macht

00:49:46.925 --> 00:49:49.585
und das ist dann halt einfach so, ja gut

00:49:49.585 --> 00:49:51.425
wozu macht man es dann, wenn man es nicht mal verstehen kann

00:49:51.425 --> 00:49:53.305
kann. Und also was man da sieht,

00:49:53.385 --> 00:49:55.385
ist halt, das Problem ist, dass die Sprache ist halt,

00:49:55.765 --> 00:49:56.905
also bei Python ist es halt auch so,

00:49:57.405 --> 00:49:59.265
die Sprache ist halt expressiver als die

00:49:59.265 --> 00:50:01.325
Sprache, die man verwendet, um die Typ-Annotationen zu machen.

00:50:02.045 --> 00:50:03.305
Und das hat ja schon in

00:50:03.305 --> 00:50:05.125
diversen Sprachen zu Katastrophen geführt. Also bei

00:50:05.125 --> 00:50:07.365
C++ mit den Templates, ja, ganz

00:50:07.365 --> 00:50:08.725
furchtbar, es ist ein Turing vollständig.

00:50:09.185 --> 00:50:11.465
Irgendwie, wenn man davon genug verwendet, versteht man auch nicht mehr, was da los ist.

00:50:11.505 --> 00:50:13.205
Der Compiler braucht ewig lange viel Hauptspeicher

00:50:13.205 --> 00:50:15.165
und schrecklich.

00:50:15.685 --> 00:50:17.445
Java, Generics, ganz furchtbar.

00:50:17.665 --> 00:50:19.045
Wie macht man das so, zum Beispiel mit

00:50:19.045 --> 00:50:20.945
einem JSON-Objekt? Wie würde ich das

00:50:20.945 --> 00:50:23.005
type-monetieren. Das ist so ein bisschen...

00:50:23.005 --> 00:50:24.785
Genau, das kann man. Das kann man tatsächlich.

00:50:24.945 --> 00:50:26.745
Also ich beschäftige mich ja gerade auch so ein bisschen mit

00:50:26.745 --> 00:50:28.705
TypeScript und da

00:50:28.705 --> 00:50:30.685
gibt es, also da kannst du, du kannst tatsächlich

00:50:30.685 --> 00:50:32.085
solche Sachen machen wie...

00:50:32.085 --> 00:50:34.985
Du kannst rekursive Typ-Definitionen

00:50:34.985 --> 00:50:35.785
machen, das geht.

00:50:36.885 --> 00:50:40.645
Das kann gut sein, dass das in Python nicht geht.

00:50:40.985 --> 00:50:42.485
Also die Type-Definition für

00:50:42.485 --> 00:50:43.745
ein JSON,

00:50:44.445 --> 00:50:46.625
wo dann hinterher der TypeScript,

00:50:46.665 --> 00:50:48.565
der TypeScript-Compiler auf die Finger haut,

00:50:48.685 --> 00:50:50.605
wenn du da auch bliebig rekursiv

00:50:50.605 --> 00:50:52.425
irgendwo etwas reinschreibst, was jetzt nicht mehr

00:50:52.425 --> 00:50:54.645
wirkliches JSON wäre, wo du eine rote Klingel

00:50:54.645 --> 00:50:56.645
kriegst, das sind so 25

00:50:56.645 --> 00:50:58.365
Zeilen rekursiv type-unautotationen

00:50:58.365 --> 00:51:00.505
in TypeScript. Das geht. Und das ist natürlich

00:51:00.505 --> 00:51:02.465
schon sehr cool, dass das geht. Auf der

00:51:02.465 --> 00:51:02.945
anderen Seite,

00:51:04.025 --> 00:51:06.645
ich beschäftige mich jetzt seit einer Zeit damit,

00:51:06.885 --> 00:51:08.405
also ich kann diese 25

00:51:08.405 --> 00:51:10.465
Zeilen sehen. Ehrlich gesagt, ich verstehe

00:51:10.465 --> 00:51:12.265
sie nicht so ganz. Das ist halt auch wirklich

00:51:12.265 --> 00:51:12.905
schwierig.

00:51:15.265 --> 00:51:16.345
Ja, da können halt rekursiv

00:51:16.345 --> 00:51:17.765
irgendwelche Dinge drin, irgendwelche Listen drin liegen,

00:51:17.865 --> 00:51:20.345
irgendwelche Dicks drin liegen, irgendwelche Listen drin liegen, wo vielleicht noch ein Zwingl ist

00:51:20.345 --> 00:51:21.665
0 oder irgendwas.

00:51:22.765 --> 00:51:24.345
Ja, es ist halt wieder eine Sprache für sich,

00:51:24.445 --> 00:51:25.985
also allein schon, dass du

00:51:25.985 --> 00:51:28.145
in Type, dass du halt sagst,

00:51:28.605 --> 00:51:30.245
okay, es gibt ja eben diese

00:51:30.245 --> 00:51:32.325
Generics, sag ich mal, es ist ausweichlich,

00:51:32.405 --> 00:51:33.605
du kannst halt nicht nur,

00:51:33.605 --> 00:51:35.545
du definierst die Typen nicht fix,

00:51:35.625 --> 00:51:37.125
sondern du sagst halt, also

00:51:37.125 --> 00:51:39.705
du kannst jetzt in der Funktion

00:51:39.705 --> 00:51:41.605
sagen, welchen

00:51:41.605 --> 00:51:43.485
Typ du zurück erwartest und

00:51:43.485 --> 00:51:45.345
den dann als Typ-Annotation verwenden.

00:51:45.545 --> 00:51:47.625
Du kannst also Typen parametrisieren,

00:51:47.705 --> 00:51:49.445
die du irgendwo setzt. Du kannst eine generische

00:51:49.445 --> 00:51:51.245
Funktionen haben und dann sagen,

00:51:51.985 --> 00:51:53.245
während du sie aufrufst,

00:51:53.305 --> 00:51:55.405
im Aufruf kannst du dir sagen, und die gibt jetzt

00:51:55.405 --> 00:51:57.465
das und das zurück. Und dann kann

00:51:57.465 --> 00:51:58.805
der Compiler das überprüfen, dass das stimmt.

00:51:59.185 --> 00:52:01.325
Und das kannst du dann auch noch rekursiv machen. Und das kannst du dann mit

00:52:01.325 --> 00:52:02.885
beliebig verschachtelten Sachen machen.

00:52:03.045 --> 00:52:19.150
Sollte man das vielleicht ein bisschen refactoren Naja also es wird halt ich meine es ist schon cool auf der einen Seite finde ich es voll cool dass es geht auf der anderen Seite denke ich mir so mein Gott was haben wir getan Wir haben einen Monster erschaffen Aber ja es ist

00:52:19.150 --> 00:52:31.310
Also ist das eine Mode? Also ich habe auch das relativ oft benutzt, ich benutze das auch gerne und ich versuche auch das relativ vollständig so zu benutzen, aber halt, ja, es hat halt irgendwie seine Grenzen auch. Also manchmal benutze ich das einfach nicht, weil es einfach keinen Sinn macht.

00:52:31.310 --> 00:52:33.130
für so ein Int oder String, okay,

00:52:33.550 --> 00:52:35.830
aber bei komplexeren Sachen wird es halt

00:52:35.830 --> 00:52:37.090
dann sofort ziemlich schwierig.

00:52:37.690 --> 00:52:39.670
Also eine Geschichte, die wohl

00:52:39.670 --> 00:52:40.450
cool ist, ist halt

00:52:40.450 --> 00:52:43.050
Protocols, damit kann man halt

00:52:43.050 --> 00:52:45.390
also Typing-Protocols mit

00:52:45.390 --> 00:52:47.290
Python 3.8, glaube ich, dazugekommen, damit kann man dann

00:52:47.290 --> 00:52:49.510
viele der Probleme, die man sonst hat, irgendwie

00:52:49.510 --> 00:52:51.450
gehen dann weg, weil man dann sagen kann,

00:52:51.530 --> 00:52:53.630
okay, ich erwarte hier nur ein Ding, also Protocols

00:52:53.630 --> 00:52:55.670
sind immer so kleine Sachen, wo du eine Methode hast

00:52:55.670 --> 00:52:57.590
oder vielleicht zwei oder so und dann

00:52:57.590 --> 00:52:59.550
musst du halt nur diese Methoden implementieren, du kannst

00:52:59.550 --> 00:53:00.910
halt überprüfen, ob das so ist, ob es

00:53:00.910 --> 00:53:02.790
ob das konform ist

00:53:02.790 --> 00:53:05.510
und dann fällt ein Großteil der Schmerzen

00:53:05.510 --> 00:53:06.330
weg, aber

00:53:06.330 --> 00:53:08.990
also wirklich, ja, also

00:53:08.990 --> 00:53:11.790
Also wenn das zu komplex wird,

00:53:11.830 --> 00:53:12.990
vielleicht muss man dann reflektieren, dass man

00:53:12.990 --> 00:53:14.670
einfachere Dinge macht, wie zum Beispiel nach Strings

00:53:14.670 --> 00:53:15.650
realisieren oder sowas.

00:53:15.810 --> 00:53:18.510
Nee, nee, nee, aber das Problem ist ja, also das willst du ja eigentlich vielleicht nicht.

00:53:18.590 --> 00:53:20.950
Du willst ja vielleicht sowas, so generische Funktionen haben wie Max oder so.

00:53:21.250 --> 00:53:22.810
Aber die kannst du praktisch nicht mehr gut

00:53:22.810 --> 00:53:24.210
also außer, du machst halt

00:53:24.210 --> 00:53:25.810
es ist halt schwer, die zu amperieren.

00:53:26.570 --> 00:53:28.550
Wir müssen es ja nicht in Python, ne?

00:53:28.550 --> 00:53:30.830
Von daher vielleicht. Ja, genau. Und vielleicht ist es für die Fälle

00:53:30.830 --> 00:53:33.690
einfach nicht typisieren,

00:53:33.770 --> 00:53:35.870
sondern sagen, okay, wir machen es an den Stellen, wo es halt was bringt

00:53:35.870 --> 00:53:37.790
und nicht so gerne Arbeit ist und an den Stellen, wo es

00:53:37.790 --> 00:53:39.730
halt nicht gut geht, dann lassen wir es halt weg und dann schreiben wir halt

00:53:39.730 --> 00:53:40.610
eine generische Funktion.

00:53:40.930 --> 00:53:41.610
Magic Python.

00:53:42.730 --> 00:53:45.730
Genau, ja, das ist vielleicht irgendwie so der richtige

00:53:45.730 --> 00:53:45.930
Weg.

00:53:46.150 --> 00:53:47.290
Wir kommen hier zu Tyson.

00:53:49.530 --> 00:53:49.730
Ja.

00:53:50.950 --> 00:53:53.210
Eine Sache, die mir noch aufgefallen ist,

00:53:53.210 --> 00:53:54.310
jetzt in

00:53:54.310 --> 00:53:56.810
den letzten Monaten beim

00:53:56.810 --> 00:53:58.610
Arbeiten bezüglich Refactoring,

00:53:58.610 --> 00:54:06.090
Es geht auch so ein bisschen Richtung Modularisierung, aber mehr Richtung die Semantik, denn wirklich die Sachen physisch irgendwie zu trennen.

00:54:06.690 --> 00:54:11.410
Und das ist, wenn man relativ viel, also in meinem Beispiel relativ viel Businesslogik hat.

00:54:12.170 --> 00:54:16.430
Also wenn man meistens fängt, also wenn man agil arbeitet, fängt so ein System mit MVP an.

00:54:16.510 --> 00:54:19.130
Also sprich, man hat, weiß ich nicht, irgendeinen Online-Shop, da kann irgendwer was kaufen.

00:54:19.330 --> 00:54:22.810
Dann kriegt er vielleicht eine E-Mail, da gibt es irgendwie eine Bestellung und das war es im Endeffekt.

00:54:22.810 --> 00:54:26.690
Und dann kommt vielleicht noch ein anderer Fall dazu, noch ein Fall und noch ein Fall und irgendwann wird ein neuer Geschäftsbereich dazu gebaut.

00:54:26.690 --> 00:54:27.890
und irgendwann hat man halt dann da

00:54:27.890 --> 00:54:30.670
ein riesiges Konstrukt von irgendwie E-Mails,

00:54:30.770 --> 00:54:32.790
die hin und zurück geschickt werden und irgendwelche

00:54:32.790 --> 00:54:34.690
Order-Objekte in der Datenbank,

00:54:34.790 --> 00:54:36.710
die riesig werden, wo 100.000 Felder drin sind.

00:54:37.850 --> 00:54:38.650
Und das eigentliche

00:54:38.650 --> 00:54:40.530
Problem ist, dass dann an einem gewissen Punkt,

00:54:40.710 --> 00:54:41.930
das habe ich jetzt schon mehrfach gesehen,

00:54:42.950 --> 00:54:44.810
weder der Kunde noch die Entwickler

00:54:44.810 --> 00:54:47.050
eigentlich noch genau wissen, was eigentlich

00:54:47.050 --> 00:54:49.250
der Geschäftsprozess ist.

00:54:49.690 --> 00:54:50.750
Das System macht zwar

00:54:50.750 --> 00:54:53.030
ungefähr das, aber dann kommt plötzlich irgendwann mal ein Fehler.

00:54:53.130 --> 00:54:54.790
Dann schickt man sich eine E-Mail und hat irgendwie ein falsches geschickt

00:54:54.790 --> 00:54:56.270
und dann stehen die Leute dann da und sagen,

00:54:56.270 --> 00:54:58.410
ja, was passiert da eigentlich

00:54:58.410 --> 00:55:00.330
genau? Und das finde ich

00:55:00.330 --> 00:55:02.270
ein total interessantes, interessanten

00:55:02.270 --> 00:55:03.750
Refactoring-Ansatz, weil das halt nicht so,

00:55:04.530 --> 00:55:06.270
also keine Ahnung, wenn ich jetzt irgendwie merke,

00:55:06.370 --> 00:55:08.230
okay, das ist irgendwie ein schlechtes Pattern oder

00:55:08.230 --> 00:55:09.390
keine Ahnung, das ist nicht

00:55:09.390 --> 00:55:12.330
lindkonform oder keine Ahnung was, dann geht man hin

00:55:12.330 --> 00:55:14.250
und refactors halt, weil das schreit einen quasi an,

00:55:14.310 --> 00:55:15.470
dass das hässlich überzumalte ist.

00:55:15.470 --> 00:55:17.490
Das ist ein Code-Review, weil man relativ sehen kann,

00:55:17.890 --> 00:55:19.250
wie gesagt, Kommentare stimmen nicht,

00:55:19.330 --> 00:55:21.630
oder Docs sind falsch, oder es sieht hässlich aus,

00:55:21.690 --> 00:55:23.530
es ist zu lang, man kann es so ein bisschen umbauen,

00:55:23.630 --> 00:55:25.330
Namings sind komisch, dann kann man das schnell machen.

00:55:25.330 --> 00:55:36.290
Genau, aber so eine Sache, wenn man sagt, okay, ich habe jetzt dieses Konstrukt und es ist auch alles vielleicht auch gar nicht so schlecht an sich für den Pattern, also man hat das vielleicht alles in Klassen drin und Services und du hast auch irgendwie Models gebaut, wo das auch alles irgendwie die Datenstruktur ist.

00:55:36.290 --> 00:55:38.890
In der Phase, wenn man auf Services ist, müssen wir auch nochmal darüber reden, was das eigentlich ist.

00:55:39.810 --> 00:55:53.750
Aber wenn halt irgendwann dieser ganze Business-Prozess halt nicht mehr offensichtlich ist, da muss man halt einfach diese Art von Abstraktion, einfach eine neue Art von Abstraktion finden und da ist eine sehr interessante Sache, mit der wir uns jetzt beschäftigt haben, sind halt die Finance-Welt-Machines.

00:55:53.750 --> 00:55:57.550
dazu gibt es auch einen sehr coolen Vortrag von 2019

00:55:57.550 --> 00:56:00.750
ich habe vergessen von wem, aber da gibt es Django FSM

00:56:00.750 --> 00:56:02.650
das Problem ist, das Packet ist leider

00:56:02.650 --> 00:56:05.630
deprecated und die neue Version ist noch in Alpha

00:56:05.630 --> 00:56:08.190
also man kann die schon nutzen, aber die Doku hat Lücken

00:56:08.190 --> 00:56:11.770
wen es interessiert, wir haben beim letzten

00:56:11.770 --> 00:56:14.950
Django Meetup in Köln haben wir länger drüber gesprochen, das ist bei YouTube

00:56:14.950 --> 00:56:17.850
Vielleicht nochmal ganz kurz erklären, was ist denn

00:56:17.850 --> 00:56:18.970
eine Finite State Machine?

00:56:19.830 --> 00:56:21.970
Also, Finite State Machine ist im Endeffekt

00:56:21.970 --> 00:56:27.010
relativ simpel, dass man sagt, ich habe ein Objekt und dieses Objekt kann in verschiedenen

00:56:27.010 --> 00:56:31.190
Status sein. Also spreche ich am Auftrag, der kann neu offen sein,

00:56:31.290 --> 00:56:35.210
der kann in Bearbeitung sein, der kann in Lieferung sein, der kann abgeschlossen sein,

00:56:35.290 --> 00:56:39.150
der kann bezahlt sein und dass es eine endliche Menge von Wegen gibt,

00:56:39.150 --> 00:56:43.330
wie ich von jedem Status, also nicht von jedem zu jedem, aber wie ich von einem Status zum anderen komme.

00:56:43.730 --> 00:56:46.950
Kann man sich im Endeffekt einfach wie ein Graph mit Pfeilen, also Kringeln und Pfeilen

00:56:46.950 --> 00:56:50.570
vorstellen und man hat halt im Endeffekt fix definiert,

00:56:50.570 --> 00:56:52.290
also erstmal auf dem

00:56:52.290 --> 00:56:54.390
grafischen Level, dass ich zum Beispiel

00:56:54.390 --> 00:56:56.290
von offen, ich kann nicht von offen

00:56:56.290 --> 00:56:58.250
direkt nach geschlossen kommen, weil davor muss es

00:56:58.250 --> 00:56:59.470
erstmal irgendwie bearbeitet,

00:57:00.250 --> 00:57:01.650
bezahlt und geliefert werden.

00:57:02.390 --> 00:57:04.010
Ja, oder so, das geht halt sonst nicht.

00:57:04.110 --> 00:57:05.390
So könnte man sich jetzt vorstellen, ja.

00:57:06.130 --> 00:57:08.390
Und der Vorteil

00:57:08.390 --> 00:57:10.290
an diesen, also das ist nur eine von vielen

00:57:10.290 --> 00:57:12.110
Möglichkeiten, um sowas anzugehen und wir haben das

00:57:12.110 --> 00:57:14.330
ausprobiert und es hat wirklich, wirklich gut funktioniert.

00:57:14.710 --> 00:57:15.650
Weil das Schöne ist, diese

00:57:15.650 --> 00:57:18.250
Graphen sind sehr, also

00:57:18.250 --> 00:57:20.170
die werden natürlich auch immer komplexer, wenn man halt

00:57:20.170 --> 00:57:50.150
und Jochen unterhalten sich über die Programmiersprache Python

00:57:50.170 --> 00:57:51.170
oder so.

00:57:51.170 --> 00:57:53.070
Und dann hat er gesagt, okay, ich habe einen Flow und hier definiere ich jetzt genau, was

00:57:53.070 --> 00:57:55.290
passiert, wenn Auftritt von offenen Bearbeitungen geht.

00:57:55.290 --> 00:57:59.270
Zum Beispiel, da geht eine E-Mail raus oder da geht keine E-Mail raus oder da muss jemand

00:57:59.270 --> 00:58:02.790
irgendwas machen damit und welche Variablen gesetzt werden.

00:58:02.790 --> 00:58:06.110
Und erstens ist es halt im Code sauber gekapselt und die alte Version konnte, wie gesagt, direkt

00:58:06.110 --> 00:58:07.110
die Graphen rausrennen.

00:58:07.110 --> 00:58:12.610
Das heißt, wenn man ein hinreichend komplexes Business-Modell implementiert hat und dann

00:58:12.610 --> 00:58:15.110
kommt der Kunde und sagt, ich würde da gerne was dran ändern, dann kann man im Endeffekt

00:58:15.110 --> 00:58:19.350
auf den Knopf drücken, kriegt dann ein wunderbares PDF raus, kann darüber dann dem Kunden reden

00:58:19.350 --> 00:58:22.670
welche Pfeile sollen wir jetzt umbiegen und wo soll was anders passieren.

00:58:23.210 --> 00:58:26.250
Und das ist halt wirklich auf einer ganz anderen Ebene.

00:58:26.330 --> 00:58:27.930
Das ist halt so trivial.

00:58:28.170 --> 00:58:33.410
Ich bin eher schockiert, dass ich da so spät drüber gestolpert bin.

00:58:35.610 --> 00:58:39.350
Ich glaube, was eigentlich schwierig ist, ist tatsächlich diese Dinge aufzumalen.

00:58:39.450 --> 00:58:43.130
Weil ich glaube, selbst die Kunden kennen nicht immer ihren Flowchart.

00:58:43.810 --> 00:58:45.490
Weil die halt nicht wissen, was passiert denn da.

00:58:45.490 --> 00:58:47.690
und bevor sich das nicht jemand angeguckt hat

00:58:47.690 --> 00:58:49.590
und vielleicht mal das in der Realität

00:58:49.590 --> 00:58:51.150
getestet hat, oh, da ist aber noch ein Problem,

00:58:51.590 --> 00:58:53.510
dann tauchen diese einzelnen Ereignispunkte

00:58:53.510 --> 00:58:55.370
oder auch die States, die irgendwas haben kann,

00:58:55.770 --> 00:58:57.230
gar nicht auf. Und bei uns hat das

00:58:57.230 --> 00:58:58.690
einen ganz bösen Bug geführt.

00:58:59.650 --> 00:59:01.150
Ja, die Tests waren eigentlich ganz gut.

00:59:01.330 --> 00:59:03.190
Also die haben eigentlich das getestet, was getestet werden soll,

00:59:03.230 --> 00:59:05.490
das heißt, Carbide war hoch, aber es gab halt

00:59:05.490 --> 00:59:07.330
den Fall einfach nicht. Und das führte halt einfach dazu,

00:59:07.450 --> 00:59:09.210
dass fälschlicherweise beispielsweise, wir haben so

00:59:09.210 --> 00:59:11.150
viel im Endquatsch gemacht, an

00:59:11.150 --> 00:59:13.250
ein paar hundert Vertriebler einfach so E-Mails rausgingen,

00:59:13.250 --> 00:59:14.950
die gar nicht rausgehen sollten oder so, oder zu oft.

00:59:14.950 --> 00:59:16.830
und du hast halt so ein bisschen so ein, okay,

00:59:17.430 --> 00:59:18.850
ups, und das

00:59:18.850 --> 00:59:20.930
schreit halt dann, weil man denkt sich halt so, nein,

00:59:21.050 --> 00:59:22.830
wie können die nur und total doof und das macht ja gar nicht

00:59:22.830 --> 00:59:24.810
was, was soll, alles falsch. Aber eigentlich

00:59:24.810 --> 00:59:26.770
ist halt nur der Fall, dass man halt nicht bedacht hat, dass

00:59:26.770 --> 00:59:28.810
einen besonderen Fall geben kann, der halt

00:59:28.810 --> 00:59:30.590
nicht abgebildet wird. Genau, aber das

00:59:30.590 --> 00:59:32.730
Schöne ist halt, wenn man halt mit solchen Tools vielleicht

00:59:32.730 --> 00:59:34.670
auch direkt konzeptionell, also auch im Agilen,

00:59:34.770 --> 00:59:36.690
einfach mal, wenn man die Tickets überarbeitet,

00:59:36.750 --> 00:59:38.710
sagt, hey, wir haben hier dieses Modell und wir arbeiten immer an diesem

00:59:38.710 --> 00:59:40.890
Modell, dann kann

00:59:40.890 --> 00:59:42.730
man halt vielleicht über solche Sachen auch schon viel früher

00:59:42.730 --> 00:59:44.370
stolpern, weil der Kunde dann plötzlich merkt,

00:59:44.370 --> 00:59:46.330
so, ja Moment mal, oder wenn der Kunde

00:59:46.330 --> 00:59:47.730
es an seinen Stakeholdern zeigt, also der

00:59:47.730 --> 00:59:50.050
Stakeholder zeigt, dann sagt vielleicht, ja Moment mal,

00:59:50.110 --> 00:59:52.390
aber ich arbeite doch die ganze Zeit an einem Pfeil, den es ja gar nicht

00:59:52.390 --> 00:59:53.350
gibt, da stimmt doch was nicht.

00:59:54.010 --> 00:59:56.270
Weil, wenn das halt implementiert ist, dann ist es

00:59:56.270 --> 00:59:58.170
halt für die Non-Techies halt

00:59:58.170 --> 00:59:59.570
quasi weg.

01:00:00.010 --> 01:00:01.470
Dann nicht mehr einsehbar.

01:00:01.990 --> 01:00:04.370
Und als Entwickler, natürlich sollte

01:00:04.370 --> 01:00:05.850
man das grob verstehen, wie du halt gesagt hast,

01:00:05.890 --> 01:00:08.210
das System ab einer gewissen Hinreichung an Komplexität

01:00:08.210 --> 01:00:10.270
ist es halt vorbei, dann kann man nicht mehr alles

01:00:10.270 --> 01:00:12.110
verstehen, dann sind die Sachen hoffentlich irgendwie gekapselt

01:00:12.110 --> 01:00:14.250
und dann will man auch gar nicht mehr wissen, was da hinten passiert.

01:00:14.370 --> 01:00:16.230
und vielleicht muss ich das wissen für meine Sache,

01:00:16.330 --> 01:00:18.030
weil es irgendwas gibt, was halt noch keiner weiß.

01:00:18.030 --> 01:00:18.290
Ja.

01:00:20.450 --> 01:00:22.170
Vielleicht nochmal ein Definitionsding.

01:00:22.250 --> 01:00:23.210
Finite State Machine.

01:00:24.870 --> 01:00:26.470
Deutsch ist endlicher Automat.

01:00:26.810 --> 01:00:28.190
Genau, also einen endlichen

01:00:28.190 --> 01:00:29.770
Automaten kann man quasi auf alles dann abbilden.

01:00:30.050 --> 01:00:31.830
Was ja mit unendlichen Automaten geht, du weißt auch.

01:00:31.830 --> 01:00:33.230
Nein, du kannst damit nicht alles machen.

01:00:34.450 --> 01:00:35.570
Also endliche Automaten zum Beispiel,

01:00:36.170 --> 01:00:38.150
also etwas, was quasi

01:00:38.150 --> 01:00:39.970
äquivalent ist, sind reguläre

01:00:39.970 --> 01:00:42.010
Ausdrücke. Das ist halt auch eigentlich,

01:00:42.190 --> 01:00:43.950
wobei reguläre Ausdrücke, je nach Implementation,

01:00:43.950 --> 01:00:45.490
und da gibt es auch noch ein bisschen mehr, was man da machen kann,

01:00:45.630 --> 01:00:47.890
aber das ist halt, ja,

01:00:48.370 --> 01:00:48.630
also

01:00:48.630 --> 01:00:51.650
wenn man endlich

01:00:51.650 --> 01:00:53.470
einen Automat hat, die Sprachen,

01:00:54.570 --> 01:00:55.550
die, also jetzt komme ich

01:00:55.550 --> 01:00:57.010
in die theoretische Informatik,

01:00:57.970 --> 01:00:59.750
vielleicht rede ich nicht allzu großen Unsinn,

01:00:59.790 --> 01:01:01.610
das ist alles schon sehr lange her, aber im Grunde

01:01:01.610 --> 01:01:03.830
wenn du endlich

01:01:03.830 --> 01:01:05.430
einen Automaten hast, dann sind die Sprachen,

01:01:06.450 --> 01:01:07.910
die von dem akzeptiert werden,

01:01:08.030 --> 01:01:09.230
heißen regulär und

01:01:09.230 --> 01:01:11.430
deswegen auch reguläre Ausdrücke, weil es halt

01:01:11.430 --> 01:01:13.630
Ausdrücke sind, mit denen du reguläre Sprachen

01:01:13.630 --> 01:01:15.110
parsen kannst, aber

01:01:15.110 --> 01:01:17.270
du kannst damit nicht alles machen.

01:01:17.770 --> 01:01:19.790
Zum Beispiel, was du damit nicht machen kannst, sind halt

01:01:19.790 --> 01:01:21.550
so, also das ist

01:01:21.550 --> 01:01:23.290
Informatik 1

01:01:23.290 --> 01:01:25.610
oder bei mir war das glaube ich tatsächlich

01:01:25.610 --> 01:01:26.730
Informatik 1 Klausur,

01:01:27.630 --> 01:01:29.550
musst du dann beweisen, dass eine bestimmte

01:01:29.550 --> 01:01:31.650
Sprache nicht mit einem endlichen Automaten

01:01:31.650 --> 01:01:33.730
parsbar ist. Normalerweise nimmt man dann

01:01:33.730 --> 01:01:35.570
irgendwas, wo es so Klammer gibt. Dann hast du eine

01:01:35.570 --> 01:01:37.730
Sprache, die halt so Klammern hat, wo halt

01:01:37.730 --> 01:01:39.770
ob du hinten eine Klammer zumachst, davon abhängt, ob du die vorne

01:01:39.770 --> 01:01:41.590
aufgemacht hast. Und dann gibt es dann so ein

01:01:41.590 --> 01:01:43.190
Pumpkin Lemmon heißt das.

01:01:43.190 --> 01:01:45.230
Das kann man dann benutzen, um zu zeigen,

01:01:45.410 --> 01:01:46.730
dass man

01:01:46.730 --> 01:01:48.750
keinem endlichen Automaten das parsen kann,

01:01:49.130 --> 01:01:50.210
weil man sich nicht merken kann,

01:01:50.890 --> 01:01:52.590
wie das...

01:01:52.590 --> 01:01:54.770
Dafür braucht man dann halt so einen Stack-Automaten oder

01:01:54.770 --> 01:01:56.030
irgendwie sowas.

01:01:56.650 --> 01:01:57.630
Was ist ein Stack-Automat?

01:01:57.770 --> 01:01:59.810
Ich kenne keine theoretische Informatik.

01:02:00.350 --> 01:02:01.650
Was ist ein Stack-Automat?

01:02:02.090 --> 01:02:03.450
Ja, so ein Ding, was halt einen Speicher hat.

01:02:03.850 --> 01:02:05.930
Also einfach nur tatsächlich einen Stapel, den es gibt.

01:02:06.410 --> 01:02:06.510
Okay.

01:02:07.870 --> 01:02:09.010
Warum ist das Ding Automat?

01:02:10.170 --> 01:02:10.790
Ja, ich weiß gar nicht.

01:02:10.790 --> 01:02:13.130
Methode mit Maschine, vielleicht auch, ich weiß es nicht genau,

01:02:13.190 --> 01:02:14.110
ich weiß gar nicht, ob das Automat heißt.

01:02:14.350 --> 01:02:16.730
Also alles, was halt dann ein

01:02:16.730 --> 01:02:18.510
unendlicher Automat quasi ist,

01:02:18.990 --> 01:02:20.810
das hat halt dann States, die du vorher nicht kennst

01:02:20.810 --> 01:02:22.910
oder sowas, oder worum geht es da?

01:02:23.370 --> 01:02:25.090
Dass du das nicht vorher wegdefinieren kannst?

01:02:25.330 --> 01:02:26.770
Nein, du musst dir halt sozusagen merken,

01:02:27.330 --> 01:02:29.170
was passiert ist. Das kannst du

01:02:29.170 --> 01:02:31.150
im endlichen Automat nicht machen. Da hast du halt Zustände,

01:02:31.330 --> 01:02:33.130
die sind endlich und du kannst zwischen

01:02:33.130 --> 01:02:35.090
denen wechseln, aber du kannst dir jetzt nicht merken, wo du

01:02:35.090 --> 01:02:37.190
schon überlang gelaufen bist oder so, oder ob du Klammern aufgemacht

01:02:37.190 --> 01:02:38.950
hast oder nicht. Das geht halt nicht.

01:02:38.950 --> 01:02:41.310
und genau, das nächste

01:02:41.310 --> 01:02:43.270
also, gehen wir mal die Dinger

01:02:43.270 --> 01:02:43.590
durch

01:02:43.590 --> 01:02:47.230
das zweite ist halt dann sozusagen Stack Machine

01:02:47.230 --> 01:02:49.290
damit kannst du halt dann kontextfrei

01:02:49.290 --> 01:02:51.330
Grammatiken parsen und dann gibt es halt

01:02:51.330 --> 01:02:53.310
noch Kontextsensitiv, dafür brauchst du dann

01:02:53.310 --> 01:02:53.570
schon

01:02:53.570 --> 01:02:57.330
Loop-Rechenbar oder sowas und dann irgendwie gibt es

01:02:57.330 --> 01:02:58.290
noch irgendwie

01:02:58.290 --> 01:03:00.270
alles irgendwie

01:03:00.270 --> 01:03:02.870
und dafür brauchst du dann Turing-Maschinen

01:03:02.870 --> 01:03:05.210
oder halt ein While-Programm oder ein For-Programm

01:03:05.210 --> 01:03:07.130
oder was auch immer. Okay, also nochmal jetzt vielleicht

01:03:07.130 --> 01:03:09.410
zum Abschließen, was eine Turing-Maschine ist.

01:03:10.830 --> 01:03:11.430
Oh Gott,

01:03:11.570 --> 01:03:13.130
eine Turing-Maschine, ein Siebentuppel aus

01:03:13.130 --> 01:03:14.550
Sprache, Grammatik,

01:03:15.370 --> 01:03:17.470
Terminalsymbolen, Nicht-Terminalsymbolen,

01:03:17.550 --> 01:03:18.930
keine Ahnung, weiß ich nicht, Alphabet.

01:03:19.970 --> 01:03:20.930
Ja, also

01:03:20.930 --> 01:03:23.010
im Grunde das Ding, was halt sozusagen

01:03:23.010 --> 01:03:25.030
die Informatik als Fach irgendwie

01:03:25.030 --> 01:03:26.210
so ein bisschen begründet hat damals.

01:03:26.530 --> 01:03:28.710
1937 gab es das Paper, glaube ich.

01:03:28.710 --> 01:03:30.030
Von Neumann Architektur?

01:03:30.150 --> 01:03:31.010
Nein, nein, nein.

01:03:31.090 --> 01:03:32.290
Was ist das?

01:03:37.130 --> 01:03:39.270
von Neumann Architektur ist, dass

01:03:39.270 --> 01:03:41.490
der Speicher für

01:03:41.490 --> 01:03:43.870
Daten und Programme der gleiche ist.

01:03:45.090 --> 01:03:45.590
Mehr oder weniger.

01:03:46.050 --> 01:03:47.690
Aber das ist halt

01:03:47.690 --> 01:03:49.610
eine Rechnerarchitektur, aber das ist halt Hardware.

01:03:49.890 --> 01:03:52.190
Turing-Maschine ist ein theoretisches

01:03:52.190 --> 01:03:52.590
Konstrukt.

01:03:53.670 --> 01:03:55.490
Wie gesagt, das hat Turing da 1937

01:03:55.490 --> 01:03:57.530
veröffentlicht. Ich glaube, das

01:03:57.530 --> 01:03:58.070
Paper hieß

01:03:58.070 --> 01:04:01.770
On Computable Numbers

01:04:01.770 --> 01:04:03.730
with an Application to the Entscheidungsproblem

01:04:03.730 --> 01:04:05.670
oder sowas. Und da

01:04:05.670 --> 01:04:06.910
hat er das Ding halt vorgestellt.

01:04:07.130 --> 01:04:09.030
und in dem Paper bewiesen, dass

01:04:09.030 --> 01:04:10.090
das Problem

01:04:10.090 --> 01:04:11.970
nicht entscheidbar ist.

01:04:13.370 --> 01:04:14.770
Also, ja, und genau,

01:04:14.890 --> 01:04:16.210
das hat eigentlich die Informatik begründet.

01:04:17.350 --> 01:04:17.790
Beziehungsweise

01:04:17.790 --> 01:04:20.910
es gibt da halt noch irgendwie

01:04:20.910 --> 01:04:23.090
ein Paper-to-Lambda-Kalkulus

01:04:23.090 --> 01:04:24.810
von Church, das ist ein bisschen später rausgekommen,

01:04:24.890 --> 01:04:26.350
ist eigentlich ein Stückchen eleganter, aber

01:04:26.350 --> 01:04:27.590
ja.

01:04:30.510 --> 01:04:32.730
Ja, aber genau, also

01:04:32.730 --> 01:04:35.230
Typ 0 Sprachen,

01:04:35.230 --> 01:04:37.090
also mit einer Turing-Maschine kannst du halt alles

01:04:37.090 --> 01:04:38.550
parsen, was du auch parsen kannst.

01:04:39.370 --> 01:04:42.250
Und mit einem regulären

01:04:42.250 --> 01:04:44.410
Automaten,

01:04:44.590 --> 01:04:46.590
also mit einem endlichen Automaten halt nicht,

01:04:46.730 --> 01:04:47.590
sondern nur ganz spezielle Sachen.

01:04:48.630 --> 01:04:50.690
Aber trotzdem kannst du wahrscheinlich eine Menge damit abbilden.

01:04:50.870 --> 01:04:52.130
Ja, ich meine, so ist es nicht.

01:04:52.530 --> 01:04:54.450
Vor allem in meinem Case ging es ja wirklich auch

01:04:54.450 --> 01:04:55.750
tatsächlich um Business Flows.

01:04:55.750 --> 01:04:56.070
Ja.

01:04:57.450 --> 01:05:00.470
Ich glaube,

01:05:00.530 --> 01:05:01.810
das Interessante an Business Flows

01:05:01.810 --> 01:05:03.410
ist, weil das halt wirklich eine Sache ist,

01:05:04.610 --> 01:05:05.830
man muss ja dann im Endeffekt

01:05:05.830 --> 01:05:35.810
und Jochen unterhalten sich über die Programmiersprache Python

01:05:35.830 --> 01:05:37.590
der spannende Punkt, warum da halt

01:05:37.590 --> 01:05:39.990
zum Beispiel, ich meine, es gibt doch bestimmt noch 50

01:05:39.990 --> 01:05:41.450
andere schlaue Ideen, wie man da umgehen kann,

01:05:42.010 --> 01:05:44.030
aber halt damit mit diesen endlichen Automaten halt

01:05:44.030 --> 01:05:46.070
schon mehr Struktur reinbringen kann.

01:05:46.130 --> 01:05:48.030
Ich glaube, wenn man das halt auch von Anfang an sich für

01:05:48.030 --> 01:05:50.050
irgendwas entscheidet und nicht halt sagt, wir machen das halt

01:05:50.050 --> 01:05:51.950
wie ich halt den ganzen normalen Code

01:05:51.950 --> 01:05:54.010
programmieren würde, glaube ich, da kann man sich sehr

01:05:54.010 --> 01:05:55.350
viel Knatscher sparen und

01:05:55.350 --> 01:05:57.810
hat bestimmt

01:05:57.810 --> 01:06:00.030
zwei, drei Jahre Entwicklungszeit Entspannung

01:06:00.030 --> 01:06:00.330
vom

01:06:00.330 --> 01:06:03.550
also quasi

01:06:03.550 --> 01:06:04.990
ein bisschen Schutz vor

01:06:04.990 --> 01:06:07.090
tiefgreifendem Refactoring.

01:06:08.810 --> 01:06:08.990
Ja.

01:06:09.630 --> 01:06:10.110
Nee, klar.

01:06:10.970 --> 01:06:13.550
Um Refactoring zu vermeiden. Aber das wäre jetzt aber auch nur Refactoring

01:06:13.550 --> 01:06:15.570
vermeiden, was quasi Bugs entfernt und die

01:06:15.570 --> 01:06:17.350
Features sicherer macht. Aber

01:06:17.350 --> 01:06:19.710
das wäre jetzt nicht das Refactoring, was keinen Style schöner

01:06:19.710 --> 01:06:21.550
macht, Namenskonventionen besser

01:06:21.550 --> 01:06:22.950
einhält, dokumentierbarer macht.

01:06:23.450 --> 01:06:25.690
Ja, okay. Das ist natürlich auch eine Art von Refactoring.

01:06:25.910 --> 01:06:27.490
Ja, man kann auch quasi irgendwas, also wenn man

01:06:27.490 --> 01:06:29.450
das übergibt, also wenn ich jetzt selber was geschrieben habe, was

01:06:29.450 --> 01:06:31.570
ich mich gut mit auskenne, ist es ja was anderes,

01:06:31.570 --> 01:06:32.930
als wenn jetzt jemand anders das

01:06:32.930 --> 01:06:35.550
benutzen muss. Und wenn man

01:06:35.550 --> 01:06:37.430
seinen Krug in einen Zustand versetzt, in dem er

01:06:37.430 --> 01:06:39.410
gut übergiebbar ist, dass jeder

01:06:39.410 --> 01:06:40.710
damit arbeiten kann.

01:06:41.490 --> 01:06:43.530
Ja, wobei man da ein bisschen vorsichtig sein muss.

01:06:43.650 --> 01:06:45.450
Ich meine, da geht es

01:06:45.450 --> 01:06:47.530
dann quasi um, würde ich mal sagen,

01:06:47.590 --> 01:06:48.410
Konsistenz.

01:06:49.810 --> 01:06:51.230
Und da ist leider

01:06:51.230 --> 01:06:52.050
also

01:06:52.050 --> 01:06:55.170
meine persönliche Ansicht dazu ist,

01:06:55.810 --> 01:06:56.830
konsistent ist es dann so,

01:06:57.070 --> 01:06:58.430
wenn es mir gefällt.

01:07:01.250 --> 01:07:02.390
Taste kann man nicht schreiben.

01:07:02.390 --> 01:07:02.750
aber

01:07:02.750 --> 01:07:05.990
das Problem ist halt, das habe ich ja auch

01:07:05.990 --> 01:07:07.570
eine eigene Code-Ankunft, die einem selber nicht mehr gefällt.

01:07:07.710 --> 01:07:10.090
Ja, aber wenn man so in Code-Basen

01:07:10.090 --> 01:07:12.110
guckt, die es da so gibt und sich denkt

01:07:12.110 --> 01:07:14.050
so, oh, das ist alles ganz schrecklich, dann habe

01:07:14.050 --> 01:07:16.010
ich so den, dann zuerst fängt

01:07:16.010 --> 01:07:17.910
das Augenlid an zu zucken und dann irgendwann

01:07:17.910 --> 01:07:20.050
lasse ich Black über

01:07:20.050 --> 01:07:20.710
alles drüber laufen.

01:07:22.130 --> 01:07:24.050
Ja, ich kenne das aber auch von Jochen, das ist mal ganz

01:07:24.050 --> 01:07:25.950
super, also er hat ja immer netterweise

01:07:25.950 --> 01:07:27.470
ein paar Sachen von mir mal korrigiert und so

01:07:27.470 --> 01:07:30.050
und ganz am Anfang so, äh, was ist das denn, das geht ja überhaupt

01:07:30.050 --> 01:07:31.850
nicht, alles wegschmeißen, neu machen, nee, nee, kann man nicht

01:07:31.850 --> 01:07:35.530
wieder angefangen, neu gemacht und das ging dann so ein paar Mal so, ah, wieder wegschmeißen,

01:07:35.570 --> 01:07:38.390
und dann irgendwann hat er gesagt, ah, was ist denn das, das ist ja das, was er alle wissen will,

01:07:38.390 --> 01:07:40.290
wieder neu machen, weg, ja, das habe ich von dir kopiert.

01:07:42.990 --> 01:07:44.050
Ja, das mag sein,

01:07:44.150 --> 01:07:45.330
das ist vollkommen sowas.

01:07:46.110 --> 01:07:48.210
Ja, ja, ich meine, manchmal ist es auch einfach Quatsch,

01:07:48.350 --> 01:07:49.910
da hat man sich so daran gewöhnt, dass irgendwie,

01:07:50.910 --> 01:07:52.050
und dann macht man hinterher

01:07:52.050 --> 01:07:54.290
irgendwas dann falsch, wenn man

01:07:54.290 --> 01:07:56.310
davon ausgeht, dass es sowieso irgendwie nicht richtig

01:07:56.310 --> 01:07:57.670
oder so, man muss aufpassen, das ist nicht so einfach.

01:07:58.050 --> 01:07:59.830
Aber, genau, also,

01:07:59.830 --> 01:08:16.450
Also ich tendiere dazu, das dann so zu machen. Ich glaube aber, es ist falsch. Und eben auch da das Buch würde sagen, Konsistenz wichtiger, weil es halt für Leute wichtiger ist, das zu verstehen und dass es genauso ist, wie sie das halt kennen, als dass es richtig ist.

01:08:16.450 --> 01:08:46.430
und Jochen unterhalten sich über die Programmiersprache Python

01:08:46.450 --> 01:08:48.350
Komplexität vielleicht ein bisschen, aber wahrscheinlich

01:08:48.350 --> 01:08:50.530
gleicht das nicht das aus,

01:08:50.570 --> 01:08:52.410
dass man das dann halt inkonsistent gemacht hat

01:08:52.410 --> 01:08:54.230
und damit dann komplexer. Also, ja,

01:08:54.290 --> 01:08:56.370
es ist blöd. Das ist ja generell auch ein Problem,

01:08:57.010 --> 01:08:58.370
dass wenn man jetzt

01:08:58.370 --> 01:09:00.390
ein altes, gewachsenes Projekt hat,

01:09:00.670 --> 01:09:02.550
dass man dann vielleicht im schlimmsten

01:09:02.550 --> 01:09:04.230
Fall übernimmt oder vielleicht auch wo man halt auch schon

01:09:04.230 --> 01:09:06.290
selber lange dran arbeitet und irgendwann kommt dann jetzt der Impuls,

01:09:06.810 --> 01:09:08.250
wir müssen da jetzt mal irgendwie anfangen, Sachen

01:09:08.250 --> 01:09:09.690
besser zu machen, das geht so nicht mehr weiter.

01:09:10.230 --> 01:09:12.310
Und da ist dann ja auch bei vielen

01:09:12.310 --> 01:09:14.370
motivierten Entwicklern, wie das bei mir früher auch so war,

01:09:14.370 --> 01:09:15.690
man geht dann halt, okay, machen wir irgendwie so,

01:09:15.690 --> 01:09:19.010
und so. Hier fühlt alles neu. Und dann fängt man irgendwie sieben Baustellen an und

01:09:19.010 --> 01:09:23.630
das klappt halt einfach nicht. Also ich glaube, die größte Kunst, wenn man wirklich so ein

01:09:23.630 --> 01:09:26.710
altes Projekt retten möchte, ist wirklich

01:09:26.710 --> 01:09:30.690
sich zu überlegen, wie kriege ich die Patterns, die ich möchte,

01:09:31.730 --> 01:09:35.790
unter den Nebenbedingungen meines Projektes, ohne dass ich quasi alles anzünden muss

01:09:35.790 --> 01:09:38.750
und... Oh oh, lieber die Finger vor lassen.

01:09:40.290 --> 01:09:42.890
Also ich habe tatsächlich mal jahrelang auf dem

01:09:42.890 --> 01:09:45.890
wirklich komplett von der grünen Wiese gewachsenen

01:09:45.890 --> 01:09:47.390
Plain PHP Projekt gearbeitet.

01:09:47.490 --> 01:09:49.830
Das war halt einfach, das war vor und hinten eine Katastrophe.

01:09:50.010 --> 01:09:51.290
Also die Code-Basis war

01:09:51.290 --> 01:09:53.510
wirklich, wirklich schlimm. Da gab es nie irgendjemand,

01:09:53.590 --> 01:09:55.470
der drüber geguckt hat. Das waren alles, im Endeffekt

01:09:55.470 --> 01:09:57.910
alles von Freelancern gebaut, die, genau wie du es gerade gesagt hast,

01:09:58.010 --> 01:09:59.450
halt die dafür bezahlt wurden, möglichst schnell

01:09:59.450 --> 01:10:01.530
eine Feature abzuliefern und danach mit diesem Flut.

01:10:01.990 --> 01:10:03.550
Böse, ich meine, nicht bei allen, aber

01:10:03.550 --> 01:10:05.650
es gab auf jeden Fall Leute und wenn du halt einen so im Team

01:10:05.650 --> 01:10:07.030
hast, dann ist es halt schwierig.

01:10:08.130 --> 01:10:09.510
Ich habe einen Freund, einen Entwickler aus

01:10:09.510 --> 01:10:11.430
Malawi, der halt so versucht,

01:10:11.430 --> 01:10:13.450
günstige Aufträge heranzubekommen und weil die

01:10:13.450 --> 01:10:15.510
Kunden, die er hat, dann relativ wenig Budget haben und immer

01:10:15.510 --> 01:10:17.390
ausgeben, merkt man halt auch, welche Entwickler sich

01:10:17.390 --> 01:10:19.510
dann leisten können und wenn er halt

01:10:19.510 --> 01:10:20.830
dann so sieht, so die Leute, die

01:10:20.830 --> 01:10:23.230
von denen er das aufräumen muss,

01:10:23.290 --> 01:10:25.370
weil er selber nicht weiß, worum es geht und die haben dann teilweise Pandas

01:10:25.370 --> 01:10:27.330
selbst implementiert, weil sie nicht wussten, was das dann gab und

01:10:27.330 --> 01:10:29.230
hat Sachen selber geschrieben und vorne

01:10:29.230 --> 01:10:31.430
auseinanderfallen und unheimlich viel Spaghetti-Zeug

01:10:31.430 --> 01:10:33.370
und das dann neu zu machen, also die

01:10:33.370 --> 01:10:35.510
Arbeit, die er hat, ist die ganze Zeit

01:10:35.510 --> 01:10:37.210
am Limit und weiß überhaupt nicht, was da passiert

01:10:37.210 --> 01:10:39.350
und es ist unheimlich schwierig, das besser zu machen und das

01:10:39.350 --> 01:10:40.890
zu refactoren, aber ich glaube, da ist dann

01:10:40.890 --> 01:10:42.830
gotische Knoten besser gelösen,

01:10:42.910 --> 01:10:45.110
indem man manchmal tatsächlich dann durchschneidet

01:10:45.110 --> 01:10:46.670
oder halt einfach verbrannte Erde hinterlässt

01:10:46.670 --> 01:10:47.890
und das neu anfängt oder so.

01:10:48.250 --> 01:10:50.450
Also es gibt es auf jeden Fall, aber

01:10:50.450 --> 01:10:52.030
es ist ja leider,

01:10:52.630 --> 01:10:54.330
zum Beispiel bei vielen Firmen, die so

01:10:54.330 --> 01:10:56.670
vor, weiß ich nicht, 10 Jahren,

01:10:56.710 --> 01:10:58.630
15 Jahren angefangen haben und einfach

01:10:58.630 --> 01:11:00.430
ihr Geschäftsmittel irgendwie implementiert haben,

01:11:00.510 --> 01:11:02.470
da wurde ja die meisten, oder vor allem auch so Frühzeiten

01:11:02.470 --> 01:11:04.430
des Web, da sind ja einfach sehr, sehr viele

01:11:04.430 --> 01:11:06.470
schlimme Dinge passiert. Da gab es

01:11:06.470 --> 01:11:08.230
teilweise noch keine Frameworks, das waren Leute, die

01:11:08.230 --> 01:11:10.670
da nicht so richtig wussten, was die da tun.

01:11:10.890 --> 01:11:16.970
und das Problem ist aber, dass halt, weil halt auch da in der Firma dann nie jemand ist, der dann wirklich

01:11:16.970 --> 01:11:21.590
da versucht, das kontinuierlich besser zu machen, dann kommt halt irgendwann, okay, es geht nicht mehr,

01:11:21.710 --> 01:11:25.110
ja, weiß ich nicht, ein Formularen passend dauert eine Woche, wir müssen irgendwas machen

01:11:25.110 --> 01:11:30.150
und das ist halt dann, dass diese Firmen dann halt in so einem Deadlock sind, dass die halt nicht das Budget haben,

01:11:30.230 --> 01:11:34.530
diese riesige gewachsene Software mit 28.000 Sonderfällen neu implementieren zu können,

01:11:34.530 --> 01:11:39.110
aber es geht auch nicht weiter und das ist halt genau der Fall und ich glaube, das ist ein sehr häufiger Fall,

01:11:39.110 --> 01:11:41.250
in der Sonderwende, wenn das halt so eine Software ist,

01:11:41.310 --> 01:11:43.190
die halt wirklich in-house dann für sich selbst

01:11:43.190 --> 01:11:45.070
entwickelt wurde, dass man da

01:11:45.070 --> 01:11:46.910
da ist super wichtig, dass man reflektiert,

01:11:46.950 --> 01:11:49.150
das ist super wichtig, dass man, also vor allem, ich finde

01:11:49.150 --> 01:11:51.170
in solchen Fällen das Einzige, was einen irgendwie motivieren

01:11:51.170 --> 01:11:52.970
kann, an diesem Projekt zu arbeiten, dass man

01:11:52.970 --> 01:11:54.970
versucht, die Herausforderung halt anzunehmen und das

01:11:54.970 --> 01:11:57.050
irgendwie besser zu machen kontinuierlich und da

01:11:57.050 --> 01:11:58.990
ist es halt einfach super wichtig, dass man sich Patterns überlegt.

01:11:59.090 --> 01:12:01.110
Also beispielsweise bei diesem alten Plain PHP Ding

01:12:01.110 --> 01:12:03.130
war halt auch, das war

01:12:03.130 --> 01:12:05.030
halt einfach eine Kette von Skripten, die

01:12:05.030 --> 01:12:07.250
eingebunden wurden, eine N-lange

01:12:07.250 --> 01:12:11.830
Niemann wusste genau, was da oben kommt und was unten kommt. Du hattest keinen Variatenscope.

01:12:11.950 --> 01:12:16.070
Das kann man sich nicht vorstellen, was das für ein Segen ist, dass man einen Variatenscope hat.

01:12:16.830 --> 01:12:22.050
Und im Endeffekt habe ich dann, das war das, wo ich mich am meisten darüber gefreut habe, dass es funktioniert hat,

01:12:22.350 --> 01:12:26.510
ich habe mir im Endeffekt Django Class-Based Views in klein nachgebaut und es war ein Segen.

01:12:26.910 --> 01:12:32.190
Und es war im Endeffekt, das halt einmal zu bauen, also mir im Endeffekt grob abzugucken und dann halt ein bisschen fein zu schleifen,

01:12:32.190 --> 01:12:34.410
da war ich in zwei, drei Tagen durch. Das war jetzt echt nicht viel Arbeit.

01:12:34.410 --> 01:12:36.850
jedes Mal, wenn ich halt an irgendeinem

01:12:36.850 --> 01:12:39.230
View dran war, also View in Gänsefüßchen,

01:12:39.650 --> 01:12:41.130
letzte Skript der Reihe,

01:12:42.090 --> 01:12:42.790
habe ich halt dann einfach,

01:12:42.890 --> 01:12:44.870
okay, jetzt stelle ich das einfach um, habe ich mit meinem Kunden

01:12:44.870 --> 01:12:46.810
noch abgesprochen, das hat dann auch meistens

01:12:46.810 --> 01:12:48.590
nicht rasend viel, weil es meistens nur einsortieren war.

01:12:48.630 --> 01:12:50.210
Ich habe gar nichts im Code wirklich gemacht, aber

01:12:50.210 --> 01:12:52.790
da ich dann plötzlich Scope hatte, konnte auch die

01:12:52.790 --> 01:12:54.770
IDE plötzlich mit Variablen arbeiten,

01:12:54.850 --> 01:12:56.830
hat einem plötzlich zum Beispiel gesagt, ey, da ist ein

01:12:56.830 --> 01:12:58.730
ganzer, weiß ich nicht, 100-Zeilen-Zweig in

01:12:58.730 --> 01:13:00.830
diesen Dings, die Variable wird gar nicht gesetzt,

01:13:00.910 --> 01:13:01.930
die kommt nirgendwo her,

01:13:02.510 --> 01:13:04.050
das kann man einfach rauswerfen, ja,

01:13:04.410 --> 01:13:17.070
Das war im Endeffekt mehr oder weniger eine Kleinigkeit und das war so ein Gewinn für dieses Projekt, weil wie gesagt, man wusste, was diese Views, man hat angefangen, man konnte, man wusste auch nicht, wie ich überhaupt anfangen soll aufzuräumen.

01:13:17.070 --> 01:13:20.030
Ja, so unterschiedlich ist die

01:13:20.030 --> 01:13:21.670
Ich habe auch da gehört

01:13:21.670 --> 01:13:23.990
Also es gibt Leute auf der Welt, die programmieren unterschiedlich

01:13:23.990 --> 01:13:25.990
Zum Beispiel, ich habe jetzt

01:13:25.990 --> 01:13:27.850
von einem Freund gehört, der mit

01:13:27.850 --> 01:13:29.850
Ukrainen relativ viel zu tun hat, also wirklich die dann

01:13:29.850 --> 01:13:32.090
lange Jahre schon so Auftragsarbeit machen

01:13:32.090 --> 01:13:33.530
für europäische Kunden oder sowas

01:13:33.530 --> 01:13:35.750
und die sich jetzt auf internationalen Vergleich

01:13:35.750 --> 01:13:37.650
da irgendwie gucken, wie das dann so aussieht

01:13:37.650 --> 01:13:39.850
Und da gibt es Firmen aus anderen Teilen der Welt

01:13:39.850 --> 01:13:41.890
irgendwo aus Asien oder sowas, die entweder genug genau

01:13:41.890 --> 01:13:42.930
das machen, was sie aufgeschrieben haben

01:13:42.930 --> 01:13:45.890
und halt nur genau Definition, das heißt du brauchst

01:13:45.890 --> 01:13:48.030
ultra lange, wenn du mit dem zusammenhäufst, um diese Definition

01:13:48.030 --> 01:13:49.970
aufzuschreiben, weil alles, was da

01:13:49.970 --> 01:13:51.470
nicht drin steht, das wird halt nicht gemacht.

01:13:51.990 --> 01:13:52.350
Das ist halt blöd.

01:13:54.310 --> 01:13:55.970
Oder die halt diese Abstraktions-Levels

01:13:55.970 --> 01:13:57.110
nicht benutzen. Also mit

01:13:57.110 --> 01:13:59.850
auch Firmen aus dem anderen asiatischen Raum, wo du

01:13:59.850 --> 01:14:00.670
halt dann da stehst und

01:14:00.670 --> 01:14:03.630
anstatt, dass du so ein Pattern jetzt halt hast

01:14:03.630 --> 01:14:05.490
und eine abstrakte Klasse, dass du schreibst,

01:14:06.050 --> 01:14:07.510
werden halt alle 100

01:14:07.510 --> 01:14:09.590
einzelne Möglichkeiten einzeln implementiert.

01:14:10.290 --> 01:14:11.590
Und dann so, ja, kommen ja noch weitere, ja,

01:14:11.710 --> 01:14:13.410
900 dazu, irgendwie vielleicht mehr

01:14:13.410 --> 01:14:15.470
im Abstraktionsniveau sinnvoll. Nur, nur, die 900

01:14:15.470 --> 01:14:16.350
machen wir dann auch ganz schnell.

01:14:18.150 --> 01:14:19.650
So halt, das ist halt dann schwierig.

01:14:19.810 --> 01:14:21.330
Also wenn man das halt dann refactored, dann ist halt

01:14:21.330 --> 01:14:22.850
unheimlich viel Fleißarbeit auch dann, ne?

01:14:23.370 --> 01:14:25.030
Wie man das irgendwie dann versucht, so

01:14:25.030 --> 01:14:26.530
modulisieren, auseinanderziehen.

01:14:26.810 --> 01:14:29.010
Ist Refactoring auseinanderziehen

01:14:29.010 --> 01:14:31.010
oder Extraktion? Ich weiß nicht.

01:14:31.910 --> 01:14:33.130
Ich glaube, es hat viele Facetten, oder?

01:14:33.270 --> 01:14:35.850
Ja, aber...

01:14:35.850 --> 01:14:37.150
Ich würde sagen, eben,

01:14:37.310 --> 01:14:39.470
letztlich sollte es halt dazu führen,

01:14:39.550 --> 01:14:41.010
dass die Komplexität vom Gesamtsystem

01:14:41.010 --> 01:14:42.170
geringer wird.

01:14:42.170 --> 01:14:43.610
Und wenn du halt...

01:14:43.610 --> 01:14:45.550
Dann ist halt die Frage, was ist Komplexität eigentlich?

01:14:45.590 --> 01:14:47.010
Ja, so wie BGSA vielleicht auch.

01:14:47.610 --> 01:14:49.150
Genau, wenn du das

01:14:49.150 --> 01:14:51.210
so implementierst, also nehmen wir

01:14:51.210 --> 01:14:53.250
diesen Fall, du machst halt nicht

01:14:53.250 --> 01:14:55.310
eine generelle Lösung für irgendwas, sondern du hast

01:14:55.310 --> 01:14:57.290
halt dann 900

01:14:57.290 --> 01:14:59.010
Spezialfälle, dann

01:14:59.010 --> 01:15:01.250
sieht das ja erstmal

01:15:01.250 --> 01:15:03.150
gar nicht so schlimm aus, aber tatsächlich,

01:15:03.310 --> 01:15:05.230
wenn du jetzt etwas hast, was all diese Fälle

01:15:05.230 --> 01:15:07.270
betrifft, quasi etwas, was du

01:15:07.270 --> 01:15:08.550
zum Beispiel immer tun musst, oder

01:15:08.550 --> 01:15:10.770
dann musst du die alle anfassen.

01:15:11.210 --> 01:15:12.810
Das heißt, du hast eine Abhängigkeit

01:15:12.810 --> 01:15:14.070
zwischen allen,

01:15:14.750 --> 01:15:16.390
die nicht sichtbar ist.

01:15:18.570 --> 01:15:20.670
Wir sind schon wieder bei Son of Python

01:15:20.670 --> 01:15:22.110
und können jetzt hier die Liste wieder runter bieten.

01:15:22.430 --> 01:15:23.190
Was hast du da zu tun?

01:15:23.410 --> 01:15:26.590
Das Beispiel hier in dem Buch ist sozusagen, wenn du eine Webseite

01:15:26.590 --> 01:15:28.690
mit ein paar tausend Seiten hast und du hast

01:15:28.690 --> 01:15:30.550
halt irgendwo einen Banner da drin, das halt

01:15:30.550 --> 01:15:32.270
eine Hintergrundfarbe hat und

01:15:32.270 --> 01:15:34.510
du hast die jetzt halt einfach von Hand

01:15:34.510 --> 01:15:36.070
gesetzt in allen Seiten.

01:15:36.670 --> 01:15:37.870
Dann hast du halt eine

01:15:37.870 --> 01:15:40.450
implizite Abhängigkeit zwischen allen Seiten,

01:15:40.630 --> 01:15:42.670
weil du kannst diese Farbe nicht mehr ändern,

01:15:42.670 --> 01:15:44.330
ohne alle anderen Sachen anzufassen.

01:15:45.670 --> 01:15:46.510
Besser ist es halt,

01:15:46.550 --> 01:15:47.930
nur eine Abhängigkeit zu haben zu einem

01:15:47.930 --> 01:15:50.390
Modul irgendwie, wo du

01:15:50.390 --> 01:15:51.330
diese Farbe setzen kannst.

01:15:52.350 --> 01:15:54.690
Und dann hast du eine explizite

01:15:54.690 --> 01:15:56.430
Abhängigkeit, das heißt, du siehst auch, dass es die gibt

01:15:56.430 --> 01:15:58.270
und du kannst es an einer Stelle ändern

01:15:58.270 --> 01:15:59.250
und dann ist es halt für alle geändert.

01:15:59.690 --> 01:16:01.530
Das wäre ein Refactoring quasi.

01:16:01.750 --> 01:16:04.250
Ja, aber gerade das, also es gibt ja so Sprachen, wo das nicht ging,

01:16:04.370 --> 01:16:06.430
zum Beispiel mit Variablen setzen oder so was,

01:16:06.510 --> 01:16:08.110
also in HTML oder alten CSS oder so was,

01:16:08.190 --> 01:16:10.030
waren Variablen ja nicht so einfach zu setzen.

01:16:10.030 --> 01:16:11.230
Keine Ahnung, ich weiß aber auch nicht,

01:16:11.230 --> 01:16:11.530
zu beziehen.

01:16:12.710 --> 01:16:14.710
Das war zum Beispiel dann ein Problem, wenn du quasi

01:16:14.710 --> 01:16:16.830
eine Variable,

01:16:17.310 --> 01:16:18.750
also eine Farbe gesetzt hattest,

01:16:19.030 --> 01:16:20.210
auf eine Farbe, die es schon gab.

01:16:20.730 --> 01:16:22.210
Von zwei verschiedenen Komponenten.

01:16:23.430 --> 01:16:24.650
Weil, wie willst du denn jetzt,

01:16:24.730 --> 01:16:27.070
da sind ein paar hundert Stellen, wo das auftaucht

01:16:27.070 --> 01:16:28.090
und die Farbe ist aber immer dieselbe.

01:16:28.430 --> 01:16:30.990
Wie kriegst du denn jetzt raus, was war jetzt vorher der Hintergrund 2,

01:16:31.110 --> 01:16:32.310
was war der Hintergrund 1 oder so.

01:16:33.370 --> 01:16:34.510
Solche Dinge, das ist halt

01:16:34.510 --> 01:16:35.930
ziemlich hässlich.

01:16:37.690 --> 01:16:38.790
Aber genau, also

01:16:38.790 --> 01:16:40.930
ja, das Buch sagt dazu

01:16:40.930 --> 01:16:42.850
quasi zu, wo kommt diese Komplexität eigentlich her

01:16:42.850 --> 01:16:44.950
und wie kriegt man sie klein? Es gibt eigentlich

01:16:44.950 --> 01:16:46.950
im Grunde nur zwei Quellen von Komplexität.

01:16:47.210 --> 01:16:48.890
Das eine ist halt solche Abhängigkeiten

01:16:48.890 --> 01:16:51.150
und

01:16:51.150 --> 01:16:52.870
das ist halt, wenn man

01:16:52.870 --> 01:16:54.770
viel davon hat, ist halt doof, weil das

01:16:54.770 --> 01:16:56.610
bedeutet halt, wenn du etwas änderst, musst du viele

01:16:56.610 --> 01:16:58.910
anderen Sachen, die von allen Abhängigkeiten her auch anfassen.

01:17:00.050 --> 01:17:00.810
Und die zweite

01:17:00.810 --> 01:17:01.730
Geschichte ist

01:17:01.730 --> 01:17:04.590
Obscurity.

01:17:04.850 --> 01:17:06.050
Ich weiß gar nicht, wie man das am besten übersetzt.

01:17:07.890 --> 01:17:08.950
Undurchsichtigkeit. Undurchsichtigkeit,

01:17:08.950 --> 01:17:11.030
Nebel

01:17:11.030 --> 01:17:12.590
Obskurität

01:17:12.590 --> 01:17:15.030
Unklarheit

01:17:15.030 --> 01:17:16.530
Unklarheit vielleicht, ich weiß es nicht

01:17:16.530 --> 01:17:18.370
Jedenfalls, das ist halt

01:17:18.370 --> 01:17:20.510
das passiert, also

01:17:20.510 --> 01:17:22.490
das sorgt halt für noch schlimmere

01:17:22.490 --> 01:17:24.810
Probleme, das sorgt für so unknown

01:17:24.810 --> 01:17:26.470
unknowns, dass du halt gar nicht

01:17:26.470 --> 01:17:28.930
also wenn du viele Abhängigkeiten

01:17:28.930 --> 01:17:30.550
hast, nehmen wir an, du hast halt

01:17:30.550 --> 01:17:32.750
irgendwie, du weißt halt, wenn du das jetzt

01:17:32.750 --> 01:17:34.730
änderst, dann musst du das an 100 Stellen auch noch anfassen

01:17:34.730 --> 01:17:36.370
dann weißt du halt so, oh mein Gott, das

01:17:36.370 --> 01:17:38.810
dauert jetzt lang. Aber was dann diese 100 Stellen

01:17:38.810 --> 01:17:40.530
eigentlich alles machen, das weißt du halt nicht vielleicht.

01:17:41.490 --> 01:17:42.970
Ja, aber wenn du, genau, zum Beispiel

01:17:42.970 --> 01:17:44.790
nehmen wir an, du hast jetzt diese eine

01:17:44.790 --> 01:17:46.890
Abhängigkeit, die sagt, wenn du die Hintergrundfrage

01:17:46.890 --> 01:17:48.630
von diesem Banner ändern willst, dann machst du das hier

01:17:48.630 --> 01:17:51.070
und jetzt hast du aber in zehn Dingern

01:17:51.070 --> 01:17:52.410
hast du es halt von Hand überschrieben.

01:17:53.650 --> 01:17:54.930
Aber das weißt du halt nicht mehr, das ist nicht

01:17:54.930 --> 01:17:57.130
dokumentiert. Dann, das sind halt

01:17:57.130 --> 01:17:58.950
diese Sachen, wo dir dann hinterher

01:17:58.950 --> 01:18:00.110
auffällt, dass der

01:18:00.110 --> 01:18:02.850
Kunde sagt dann halt irgendwann so, oh, da stimmt

01:18:02.850 --> 01:18:04.830
aber die Farbe nicht, wir hatten das doch geändert, wieso ist denn die

01:18:04.830 --> 01:18:06.010
jetzt da in der Stelle falsch?

01:18:06.010 --> 01:18:08.890
und dann kriegst du das sozusagen als Bugs wieder zurück,

01:18:09.690 --> 01:18:19.075
was du nicht wusstest dass es diese Abh gibt aber die war halt nicht dokumentiert Das sind die schlimmsten weil das Problem ist halt

01:18:19.755 --> 01:18:21.255
du weißt halt gar nicht,

01:18:21.795 --> 01:18:23.335
dass du das eigentlich hättest machen sollen.

01:18:23.635 --> 01:18:26.115
Ja, was implizit dann tatsächlich einem nicht auf die Füße fällt.

01:18:26.255 --> 01:18:27.315
Ja, und dann ist halt

01:18:27.315 --> 01:18:29.895
die Frage, wo kommt das her und wie kriegt man

01:18:29.895 --> 01:18:31.315
das her und oft ist es halt vielleicht

01:18:31.315 --> 01:18:33.715
Dokumentation. Das ist auch etwas,

01:18:33.715 --> 01:18:35.575
das fand ich nett,

01:18:35.855 --> 01:18:37.615
dieses Buch hat meine Einstellung zu

01:18:37.615 --> 01:18:39.515
zu Kommentaren und Dokumentationen so ein bisschen verändert.

01:18:39.575 --> 01:18:41.735
Jochen schreibt übrigens nie Dokumentationen.

01:18:41.775 --> 01:18:43.515
Nein, das wäre

01:18:43.515 --> 01:18:45.295
nie zu hart.

01:18:45.695 --> 01:18:47.555
Der Code erklärt sich selbst und so.

01:18:48.115 --> 01:18:48.775
Ja, okay.

01:18:51.635 --> 01:18:53.255
Aber tatsächlich, ich würde auch sagen,

01:18:53.475 --> 01:18:55.095
es gibt ja da unterschiedliche Ansichten zu.

01:18:55.775 --> 01:18:56.555
Auch verbreitete,

01:18:56.735 --> 01:18:59.335
wenn man mal so Klingcode nimmt, auch ein Buch, was sich

01:18:59.335 --> 01:19:00.795
mit solchen Themen beschäftigt,

01:19:00.895 --> 01:19:03.335
von Robert Martin, Uncle Bob genannt,

01:19:03.795 --> 01:19:05.295
der sagt ja immer,

01:19:05.295 --> 01:19:06.815
wenn du einen Kommentar schreibst,

01:19:06.815 --> 01:19:09.175
gut, manchmal lässt sich das nicht vermeiden, musst du halt machen

01:19:09.175 --> 01:19:11.215
oder manchmal musst du halt, aber sei dir

01:19:11.215 --> 01:19:13.095
bewusst, wenn du das tust, ist es im Grunde

01:19:13.095 --> 01:19:14.935
ein Fehler, also es ist im Grunde ein Versagen,

01:19:15.035 --> 01:19:17.115
hast versagt, weil

01:19:17.115 --> 01:19:19.215
wenn du es richtig gemacht hättest, dann hättest du

01:19:19.215 --> 01:19:21.115
es so hingeschrieben, dass man das nicht hätte kommentieren müssen.

01:19:21.215 --> 01:19:23.215
Ja, ich meine, ein paar Kommentare

01:19:23.215 --> 01:19:25.035
sind natürlich blöd, weil man muss sie halt aktualisieren

01:19:25.035 --> 01:19:27.315
und anpassen, wenn man sie... Ja, du hast halt eine mögliche

01:19:27.315 --> 01:19:29.235
Inkonsistenz auch erzeugt. Ja, genau, das ist

01:19:29.235 --> 01:19:30.875
schon doof, also man muss halt echt schon auffassen,

01:19:31.275 --> 01:19:33.095
aber es ist einfach an vielen Stellen sehr, sehr

01:19:33.095 --> 01:19:35.195
hilfreich, auch gerade wenn man kollaborativ arbeitet,

01:19:35.195 --> 01:19:37.015
einmal kurz hinzuschreiben, was denn da

01:19:37.015 --> 01:19:38.975
passiert, warum denn da irgendwas passiert.

01:19:39.315 --> 01:19:39.575
Ja, absolut.

01:19:40.775 --> 01:19:43.015
Anstatt das halt einfach nicht zu machen, weil dann die Leute fragen sich ja,

01:19:43.075 --> 01:19:44.075
da wird irgendwo schon auch gucken, warum?

01:19:45.075 --> 01:19:46.495
Selbst wenn der Name toll ist und so.

01:19:46.795 --> 01:19:47.055
Ja, absolut.

01:19:47.555 --> 01:19:50.095
Ja, ich muss auch sagen,

01:19:50.495 --> 01:19:53.015
genau, dieses Buch hier nimmt das auch

01:19:53.015 --> 01:19:53.695
relativ

01:19:53.695 --> 01:19:55.915
detailliert auseinander.

01:19:56.935 --> 01:19:58.515
Und da sagt er halt so Sachen wie, ja gut,

01:19:58.635 --> 01:20:00.715
selbst wenn der Code selbst dokumentierend ist,

01:20:00.715 --> 01:20:02.535
dann einmal, du kriegst das Problem,

01:20:02.635 --> 01:20:04.935
die Variablen und die Funktionsnamen werden handelang

01:20:04.935 --> 01:20:11.695
Du hast das Problem, du schreibst dann, wenn das die Dokumentation von deinem Ding ist, dann schreibst du die ja an jede Stelle, wo du die verwendest

01:20:11.695 --> 01:20:16.915
Das ist ja auch Quatsch, das ist ja auch offensichtlich Quatsch, das kann ja nicht sein

01:20:16.915 --> 01:20:19.475
Das sollte ja reichen, wenn man das an einer Stelle schreibt

01:20:19.475 --> 01:20:31.055
Und hat halt noch so viele Punkte, aber der allerwichtigste Punkt eigentlich, wo ich dann auch gesagt habe, okay, ich glaube, ich muss meine Einstellung dazu überdenken und es vielleicht mal anders probieren

01:20:31.055 --> 01:20:32.615
und mal gucken, vielleicht funktioniert es dann ja anders besser.

01:20:33.415 --> 01:20:34.875
Ist, äh, das ist ja,

01:20:35.315 --> 01:20:36.995
also eigentlich das,

01:20:37.295 --> 01:20:38.915
was dein Code tut, ist

01:20:38.915 --> 01:20:40.975
eigentlich, oder das Entscheidende

01:20:40.975 --> 01:20:43.215
beim Design von so einem System

01:20:43.215 --> 01:20:45.015
ist eigentlich nicht so sehr, der Code

01:20:45.015 --> 01:20:47.115
ist eigentlich gar nicht das Entscheidende, weil der Code ist halt

01:20:47.115 --> 01:20:48.595
die Implementation davon, aber das ist halt

01:20:48.595 --> 01:20:50.915
Magie, äh,

01:20:50.955 --> 01:20:53.095
Call Magie, Call Magie, Call Magie, und aber

01:20:53.095 --> 01:20:54.635
was dabei rauskommt, ist wichtig.

01:20:54.795 --> 01:20:56.915
Die Abstraktionen sind wichtig und die

01:20:56.915 --> 01:20:58.535
stehen aber, aber Code ist

01:20:58.535 --> 01:21:00.895
möglicherweise gar keine so gute Art, um das

01:21:00.895 --> 01:21:02.915
um diese Abstraktionen

01:21:02.915 --> 01:21:05.175
sichtbar zu machen oder irgendwie zu dokumentieren.

01:21:05.875 --> 01:21:07.135
Und er sagte, also natürliche

01:21:07.135 --> 01:21:08.615
Sprache ist dafür deutlich besser geeignet.

01:21:09.195 --> 01:21:10.755
Und eigentlich sollte man sich Gedanken über die

01:21:10.755 --> 01:21:13.075
Abstraktionen machen. Dann schreibt man in natürlicher

01:21:13.075 --> 01:21:15.195
Sprache hin. Und wie man das dann implementiert,

01:21:15.235 --> 01:21:16.235
ist ja nochmal eine andere Sache.

01:21:16.535 --> 01:21:18.855
Weil Python, finde ich, von meinem

01:21:18.855 --> 01:21:20.395
Empfinden her, ich habe natürlich auch keine Ahnung,

01:21:20.715 --> 01:21:23.155
aber die Sprache ist, mit der man am nächsten an natürlicher

01:21:23.155 --> 01:21:24.695
Sprache schreiben kann,

01:21:24.775 --> 01:21:26.275
entwickeln kann und dass das irgendwie stimmt.

01:21:27.135 --> 01:21:28.175
Pythonic hört sich für mich

01:21:28.175 --> 01:21:30.195
irgendwie so ein bisschen mehr nach, ich schreibe wirklich

01:21:30.195 --> 01:21:33.095
was dahin, was ich auch so sagen könnte vielleicht, also ein bisschen.

01:21:34.395 --> 01:21:37.835
Und das ist nicht immer bei allen anderen Sprachen so, eigentlich nie.

01:21:37.835 --> 01:21:47.835
Ja, naja, es gibt da ganz unterschiedliche Philosophien.

01:21:48.455 --> 01:21:49.775
Ich finde das sowieso auch interessant.

01:21:49.875 --> 01:21:55.915
Bei Go zum Beispiel gibt es auch bekannte, ich weiß jetzt nicht mehr, wie der Talk ist,

01:21:56.235 --> 01:21:59.835
aber einer, der auch die Sprache mitdesignt hat,

01:22:00.195 --> 01:22:01.735
der ist halt ein Verfechter von

01:22:01.735 --> 01:22:03.275
kurze Variablen Namen nehmen.

01:22:03.655 --> 01:22:04.795
Ja, aber letztens irgendwann...

01:22:04.795 --> 01:22:05.635
A, B, C, D und E.

01:22:08.055 --> 01:22:08.975
Ja, also

01:22:08.975 --> 01:22:11.655
ja, also es ist nicht immer gut.

01:22:11.735 --> 01:22:13.035
Es gibt auch einen auf der Frostcon,

01:22:13.375 --> 01:22:15.315
da hatte ich letztens einen getroffen, der hatte

01:22:15.315 --> 01:22:17.415
einen sehr extremen Standpunkt und meinte, das muss mal lang sein.

01:22:17.635 --> 01:22:19.195
Kurze Variablen Namen, schrecklich.

01:22:19.755 --> 01:22:21.035
Ganz furchtbar, geht gar nicht.

01:22:21.595 --> 01:22:22.215
Das ist schrecklich.

01:22:23.795 --> 01:22:25.435
Manchmal ist das schon nett, also gerade wenn man jetzt

01:22:25.435 --> 01:22:27.595
komplizierte Logik hat,

01:22:27.595 --> 01:22:29.435
ja, dann kann das sein, wenn man lange Variablen

01:22:29.435 --> 01:22:31.235
und stehen einem wie variablen Namen im Weg,

01:22:31.315 --> 01:22:32.435
dann sieht man überhaupt nicht mehr, was passiert.

01:22:33.315 --> 01:22:35.335
Das ist ja auch in der Mathematik so, da schreibt man

01:22:35.335 --> 01:22:37.335
auch eigentlich immer nur ganz kurz Sachen

01:22:37.335 --> 01:22:39.675
und Formeln so kurz hin. Das hat halt auch den Vorteil,

01:22:39.795 --> 01:22:41.355
dass man das dann auch überblicken kann, wenn man das

01:22:41.355 --> 01:22:43.215
alles ganz detailliert ausschreiben würde.

01:22:43.235 --> 01:22:45.635
Was ich dann manchmal mache, an der Stelle tatsächlich

01:22:45.635 --> 01:22:47.275
vorher die Zuweisung, zum Beispiel

01:22:47.275 --> 01:22:49.375
Idee gleich Data vor irgendwas

01:22:49.375 --> 01:22:51.035
und dann mache ich dann nicht immer Data vor irgendwas,

01:22:51.195 --> 01:22:52.195
sondern nur das D.

01:22:52.755 --> 01:22:54.595
Dann wird das so ein bisschen dadurch klar.

01:22:55.115 --> 01:22:57.475
Ja, genau. Und da macht

01:22:57.475 --> 01:22:58.975
das Buch auch einen interessanten Vorschlag und sagt so,

01:22:58.975 --> 01:23:07.255
Der Name sollte umso länger sein, je weiter weg die Variable von ihrem ursprünglichen Ort, wo sie mal definiert wurde, verwendet wird.

01:23:07.495 --> 01:23:12.435
Je weiter das weg ist, desto länger muss der Name sein.

01:23:13.015 --> 01:23:19.455
Aber je näher du da dran bist, dann kannst du auch kürzere Namen nehmen oder sehr kurze.

01:23:21.735 --> 01:23:24.195
Weil dann ja immer noch alles im Blick ist.

01:23:24.575 --> 01:23:27.495
Du siehst halt, was da passiert sofort.

01:23:27.495 --> 01:23:31.715
Also Readability counts, das ist ja auch wieder so eine Sache, außer noch Python.

01:23:34.275 --> 01:23:35.095
Naja, also

01:23:35.095 --> 01:23:37.135
ja, schon faszinierend.

01:23:37.875 --> 01:23:38.635
Genau, aber auch sowas,

01:23:39.295 --> 01:23:40.215
Obscurity kommt halt auch,

01:23:40.515 --> 01:23:42.695
ein sehr schönes Beispiel beschrieben,

01:23:43.375 --> 01:23:45.375
wo Variablen Namen

01:23:45.375 --> 01:23:47.295
an böse, böse

01:23:47.295 --> 01:23:48.655
Überraschungen bescheren können.

01:23:49.155 --> 01:23:51.435
Also der Autor von dem Buch,

01:23:51.495 --> 01:23:53.375
der hat TCL mal dieses Ritting Language

01:23:53.375 --> 01:23:55.235
geschrieben, also diese Sprache designt.

01:23:56.055 --> 01:23:57.095
Vielleicht kennt man das auch von früher,

01:23:57.095 --> 01:23:59.695
da hat man so User Interfaces

01:23:59.695 --> 01:24:01.215
damit gebaut in Unix

01:24:01.215 --> 01:24:02.135
TickleTK

01:24:02.135 --> 01:24:04.435
Ja, das gibt es ja

01:24:04.435 --> 01:24:06.115
Genau, das ist die Python Geschichte

01:24:06.115 --> 01:24:09.235
mit Python kann man das auch machen, das ist die einzige UI-Geschichte

01:24:09.235 --> 01:24:10.775
die in der Standard-Bibliothek drin ist

01:24:10.775 --> 01:24:13.435
und der hat aber noch

01:24:13.435 --> 01:24:14.995
diverse andere, der hat zum Beispiel einen

01:24:14.995 --> 01:24:18.935
Cloud-Dings gebaut

01:24:18.935 --> 01:24:21.075
quasi verteiltes Betriebssystem

01:24:21.075 --> 01:24:23.295
und ganz viele

01:24:23.295 --> 01:24:24.155
coole, interessante Dinge

01:24:24.155 --> 01:24:26.395
und in diesem

01:24:26.395 --> 01:24:27.735
Dings gab es ein Fallsystem

01:24:27.735 --> 01:24:30.375
und in der Fallsystemimplikation gab es

01:24:30.375 --> 01:24:31.735
eine Variable, die hieß Block.

01:24:32.715 --> 01:24:34.555
Und da hatten sie einen ganz fiesen

01:24:34.555 --> 01:24:36.515
Bug, wo sie Monate

01:24:36.515 --> 01:24:37.675
gebraucht haben, um den zu finden.

01:24:38.375 --> 01:24:39.775
Und der lag dann letztlich daran,

01:24:39.835 --> 01:24:42.435
dass das dann diese Obscurity tatsächlich

01:24:42.435 --> 01:24:44.195
so schlimm macht, der lag daran,

01:24:44.355 --> 01:24:46.695
dass sie Block subtil unterschiedlich

01:24:46.695 --> 01:24:48.235
in der Bedeutung verwendet haben. Also sie haben

01:24:48.235 --> 01:24:50.615
Block als Variablen-Namen benutzt,

01:24:50.755 --> 01:24:52.475
aber in dem einen Fall bedeutete er

01:24:52.475 --> 01:25:22.455
und Jochen unterhalten sich über die Programmiersprache Python

01:25:22.475 --> 01:25:26.215
und das lag halt einfach daran, dass der Variablename

01:25:26.215 --> 01:25:28.215
halt zu generisch war.

01:25:28.375 --> 01:25:31.155
Sie können halt zu generisch sein, sie können aber auch zu speziell sein.

01:25:31.515 --> 01:25:38.595
Ich meine, keine Ahnung, der Java-File-Input-Buffer-Stream-Schlag-mich-tot-Reader

01:25:38.595 --> 01:25:40.255
ist halt auch irgendwie dann nicht mehr so der Sinn.

01:25:40.255 --> 01:25:41.395
Das ist auch nicht so schön.

01:25:43.155 --> 01:25:46.875
Ja, aber das ist vielleicht geschmacksfrei, vielleicht auch anwendungsfrei spezifisch.

01:25:47.735 --> 01:25:49.975
Ich glaube, eine Sache, die man ganz generell festhalten kann,

01:25:50.075 --> 01:25:51.375
ist, wenn man irgendwas refactoren möchte,

01:25:51.375 --> 01:26:21.355
und Jochen unterhalten sich über die Programmiersprache Python

01:26:21.375 --> 01:26:25.635
mit dieser Oracle-Implementierung,

01:26:25.735 --> 01:26:29.135
wo die dann auch gesagt haben, das Ding war irgendwie dermaßen alt und verbuggt,

01:26:29.515 --> 01:26:31.975
dass die dann quasi alles komplett mit Unit-Tests zementiert haben.

01:26:32.075 --> 01:26:34.895
Also jeden Bug und jedes merkwürdige Verhalten, das das System hatte,

01:26:34.975 --> 01:26:36.015
haben die mit Unit-Tests zementiert.

01:26:36.115 --> 01:26:37.735
Die haben irgendwie ein Jahr lang, glaube ich, nichts anderes gemacht.

01:26:38.975 --> 01:26:41.375
Und dann haben die angefangen, das zu refactoren,

01:26:41.435 --> 01:26:42.375
weil die halt einfach Angst hatten.

01:26:42.535 --> 01:26:44.115
Also teilweise war es wohl auch so in der Community,

01:26:44.215 --> 01:26:46.715
dass die Leute halt auch auf diesen merkwürdigen Verhalten

01:26:46.715 --> 01:26:48.055
oder Bugs, wie man es halt nennen möchte,

01:26:48.555 --> 01:26:51.215
halt aufgebaut haben und Features draufgesetzt haben.

01:26:51.215 --> 01:26:52.915
und die konnten das den Leuten nicht einfach wegnehmen,

01:26:53.035 --> 01:26:54.735
weil dann halt irgendwie ganz viele Sachen zerbrochen wären,

01:26:54.815 --> 01:26:57.175
weil das halt irgendwie so Teil der impliziten

01:26:57.175 --> 01:26:58.515
API gewesen ist und sowas.

01:26:59.195 --> 01:27:00.295
Und das kann tatsächlich auch...

01:27:00.295 --> 01:27:03.995
Und das kann tatsächlich auch helfen.

01:27:04.135 --> 01:27:05.375
Also ich habe das jetzt einmal gemacht,

01:27:05.535 --> 01:27:07.455
als ich jetzt ein größeres Teil angefangen habe

01:27:07.455 --> 01:27:09.335
zu refactoren, also einfach Tests für den Bestandscode

01:27:09.335 --> 01:27:11.295
zu schreiben. Das macht keinen Spaß.

01:27:13.095 --> 01:27:17.275
Ja, aber das mit den Tests ist auch

01:27:17.275 --> 01:27:18.995
ein gutes Stichwort.

01:27:19.315 --> 01:27:21.155
Das ist halt auch so. Also natürlich, es gehört

01:27:21.155 --> 01:27:37.195
dass man Sachen testet und das ist auf jeden Fall super also das ist eine der Dinge, die viel gebracht haben. Auf der anderen Seite, muss ich sagen Test-Driven Development weiß ich nicht so genau. Da würde mich jetzt nochmal allmählich interessieren, ob es wirklich Leute gibt, die das so durchziehen und die das gut finden.

01:27:37.615 --> 01:27:38.215
Ich glaube schon.

01:27:38.435 --> 01:27:39.295
Vielleicht müssen wir mal jemanden suchen.

01:27:39.295 --> 01:27:41.375
Das kommt nochmal an, also ich glaube, wenn man selber

01:27:41.375 --> 01:27:43.375
schreibt und wenn man weiß,

01:27:43.415 --> 01:27:43.835
was man tut.

01:27:45.695 --> 01:27:47.235
Wenn man halt tatsächlich weiß, was man raus

01:27:47.235 --> 01:27:49.135
haben will, dann schreibt man einen Test, der das quasi

01:27:49.135 --> 01:27:51.355
die Logik, die man implementiert, die zwei

01:27:51.355 --> 01:27:53.055
Methoden quasi mit einem Testcase

01:27:53.055 --> 01:27:55.015
so das Ergebnis hat.

01:27:55.615 --> 01:27:56.875
Zum Beispiel, du hast halt einen

01:27:56.875 --> 01:27:59.195
Datensatz und du kennst das Ergebnis, das heißt, du machst

01:27:59.195 --> 01:28:01.295
einen Beispiel-Datensatz und am Ende weißt

01:28:01.295 --> 01:28:02.855
du, das Ergebnis kommt raus und dann

01:28:02.855 --> 01:28:04.415
weißt du ja quasi schon

01:28:04.415 --> 01:28:07.175
implizit in der Stelle wahrscheinlich oder explizit

01:28:07.175 --> 01:28:09.135
so ein bisschen, also du kannst auch hinschreiben

01:28:09.135 --> 01:28:11.735
in Logik,

01:28:12.155 --> 01:28:12.975
wie das aussehen soll.

01:28:13.075 --> 01:28:14.255
Was muss passieren, damit das passiert?

01:28:14.415 --> 01:28:17.095
Dann kannst du den Methoden schon die richtigen Namen geben,

01:28:17.175 --> 01:28:18.215
die du dann irgendwie füllen musst,

01:28:18.335 --> 01:28:20.315
die am Ende rauskommen sollen,

01:28:20.575 --> 01:28:22.035
wenn das jetzt nicht zu komplex ist.

01:28:22.095 --> 01:28:23.395
Und dann kannst du das implementieren.

01:28:23.895 --> 01:28:24.935
Und wenn das für dein Testcase stimmt,

01:28:25.015 --> 01:28:26.015
wirst du ziemlich sicher sein,

01:28:26.095 --> 01:28:28.715
dass das auch für die anderen Fälle laufen sollte.

01:28:30.715 --> 01:28:32.935
Ja, aber...

01:28:32.935 --> 01:28:34.655
Das ist halt so ein TDD-Fall,

01:28:34.655 --> 01:28:36.695
wo ich sagen würde, das kann dann ganz gut sein.

01:28:36.835 --> 01:28:37.755
Du kennst quasi...

01:28:37.755 --> 01:28:38.655
ein Test-File.

01:28:39.855 --> 01:28:42.035
Du kennst den Test-File, du kennst halt den Test-File,

01:28:42.095 --> 01:28:43.375
du weißt den Test-Case, den kennst du schon,

01:28:43.735 --> 01:28:45.615
du weißt, okay, das sind meine Test-Daten und du weißt,

01:28:45.655 --> 01:28:47.715
das Ergebnis von dem Test ist so und dann kannst du

01:28:47.715 --> 01:28:50.035
dafür dann eine Methode schreiben, die diesen Test-File

01:28:50.035 --> 01:28:52.015
richtig macht und wenn du quasi

01:28:52.015 --> 01:28:53.415
alle Test-Cases hast,

01:28:53.875 --> 01:28:55.155
dann ist dein Code schon richtig.

01:28:55.855 --> 01:28:57.695
Und das ist ein cooler Fall, wo man das machen kann,

01:28:57.775 --> 01:28:59.315
wo man dann halt für generische Fälle

01:28:59.315 --> 01:29:01.095
Code hat, der funktioniert und wo TDDs sind, macht.

01:29:01.335 --> 01:29:03.975
Wenn du es aber nicht hast, weil du nicht weißt, ob die Test-Case vollständig sind,

01:29:04.055 --> 01:29:05.395
ob du irgendwelche Edge-Cases hast oder sowas,

01:29:05.695 --> 01:29:07.275
dann ist es halt super nervig, weil dann

01:29:07.275 --> 01:29:09.355
muss ich Testhaus mal umbauen, irgendwas wegmocken.

01:29:09.435 --> 01:29:11.515
Aber das ist ja auch Teil des Prozesses,

01:29:11.595 --> 01:29:12.995
dass du halt die Tests auch ständig anpackst.

01:29:13.855 --> 01:29:14.855
Also ich glaube,

01:29:15.095 --> 01:29:17.415
ich glaube, TDD, der größte

01:29:17.415 --> 01:29:18.735
Vorteil davon ist einfach,

01:29:19.255 --> 01:29:21.415
dass man erstens Code so schreibt,

01:29:21.535 --> 01:29:23.315
dass er testbar ist, weil das

01:29:23.315 --> 01:29:25.315
habe ich früher auch nicht so gemacht. Wenn man keine Unitests

01:29:25.315 --> 01:29:26.915
schreibt, dann schreibt man Code anders.

01:29:27.095 --> 01:29:28.875
Und das ist schlechterer Code.

01:29:28.875 --> 01:29:30.815
Das ist einfach eine generelle, richtige Aussage.

01:29:31.215 --> 01:29:31.955
Und das Zweite ist,

01:29:32.515 --> 01:29:34.775
wenn dann plötzlich der

01:29:34.775 --> 01:29:36.715
PO oder irgendwer Stress macht, dann lässt man

01:29:36.715 --> 01:29:38.175
die Tests nicht weg, weil die sind schon da.

01:29:38.895 --> 01:29:40.995
Ich glaube, das sind die beiden Hauptverkaufsargumente

01:29:40.995 --> 01:29:41.355
dafür.

01:29:42.715 --> 01:29:44.815
Ja, du kannst ja keinen ungetesteten Code schreiben.

01:29:44.995 --> 01:29:46.515
Das ist halt irgendwie natürlich so ein bisschen,

01:29:46.915 --> 01:29:48.275
das ist halt schon vielleicht gut.

01:29:48.815 --> 01:29:50.235
Aber eben,

01:29:50.435 --> 01:29:52.395
es gab auch in der letzten Django-Chat-EP

01:29:52.395 --> 01:29:54.675
so, ich weiß nicht, letzte oder vorletzte, keine Ahnung,

01:29:55.395 --> 01:29:56.595
da ging es auch um

01:29:56.595 --> 01:29:58.395
das Thema Test-Development und auch alle

01:29:58.395 --> 01:30:00.555
da meinten so, ja, ganz gut,

01:30:00.655 --> 01:30:01.835
ist eigentlich vielleicht nicht so schlecht, aber

01:30:01.835 --> 01:30:04.695
der Konsens in der Runde war halt auch so,

01:30:04.695 --> 01:30:06.555
naja, also wirklich machen, macht das dann doch

01:30:06.555 --> 01:30:08.555
Keiner. Und auch mit dem

01:30:08.555 --> 01:30:10.175
Argument und das,

01:30:10.895 --> 01:30:12.535
was wir, glaube ich, auch schon mal gemacht haben,

01:30:12.615 --> 01:30:14.435
dass halt das Problem ist,

01:30:14.595 --> 01:30:16.455
wenn man jetzt, wenn klar ist, was

01:30:16.455 --> 01:30:18.355
zu tun ist, dann ist das vielleicht machbar, aber

01:30:18.355 --> 01:30:20.075
ich hatte auch heute wieder so einen Fall,

01:30:20.415 --> 01:30:22.435
wenn man nicht weiß, was man machen will, dann ist das

01:30:22.435 --> 01:30:24.575
ganz blöd, weil

01:30:24.575 --> 01:30:26.455
das hilft einem überhaupt nicht,

01:30:26.495 --> 01:30:28.515
dass man dann mit dem Text Test anfängt, weil man muss sowieso

01:30:28.515 --> 01:30:30.515
irgendwie rumprobieren und das

01:30:30.515 --> 01:30:32.115
dann in einem Test zu machen, macht irgendwie nicht so viel Sinn.

01:30:33.655 --> 01:30:34.395
Das Buch

01:30:34.395 --> 01:30:35.715
macht da auch ein

01:30:35.715 --> 01:30:37.875
interessanten Punkt und sagt halt,

01:30:38.135 --> 01:30:39.895
naja, also wenn du

01:30:39.895 --> 01:30:41.935
Test-Driven Development machst,

01:30:42.075 --> 01:30:43.435
dann zwingt dich im Grunde das

01:30:43.435 --> 01:30:47.815
Vorgehen, dir von

01:30:47.815 --> 01:30:49.795
Anfang an ganz viele detaillierte

01:30:49.795 --> 01:30:51.975
Gedanken über die Implementation zu machen,

01:30:52.295 --> 01:30:53.895
an der Stelle, wo das vielleicht überhaupt

01:30:53.895 --> 01:30:55.735
nicht zielführend ist, sondern

01:30:55.735 --> 01:30:57.755
du willst vielleicht am Anfang dir erstmal Gedanken über das

01:30:57.755 --> 01:31:00.075
Design oder Abstraktionen machen und nicht über die Implementierung

01:31:00.075 --> 01:31:01.775
und das geht mit

01:31:01.775 --> 01:31:03.235
Test-Driven Development gar nicht so richtig.

01:31:03.735 --> 01:31:05.615
Und was er dann vorschlägt, ist zu sagen,

01:31:05.715 --> 01:31:07.155
doch lieber Document.

01:31:08.675 --> 01:31:08.695
Oder

01:31:08.695 --> 01:31:10.435
ja.

01:31:10.495 --> 01:31:15.975
Du schreibst halt nur

01:31:15.975 --> 01:31:17.735
in natürlicher Sprache

01:31:17.735 --> 01:31:19.915
sozusagen, was die Abstraktionen sind, was die ungefähr machen sollen

01:31:19.915 --> 01:31:21.935
und mit denen spielst du so lange rum,

01:31:22.015 --> 01:31:22.915
bis dir das Design gefällt.

01:31:23.435 --> 01:31:26.155
Und dann fängst du erst an, das zu implementieren.

01:31:27.275 --> 01:31:27.955
Ehrlich gesagt,

01:31:28.355 --> 01:31:29.855
also ich versuche das jetzt, mal gucken, keine Ahnung.

01:31:30.015 --> 01:31:31.795
Dann die Tests schreiben und dann implementieren vielleicht.

01:31:32.115 --> 01:31:33.735
Ja, aber

01:31:33.735 --> 01:31:35.655
genau, also ich weiß es nicht so genau,

01:31:35.715 --> 01:32:05.695
und Jochen unterhalten sich über die Programmiersprache Python

01:32:05.715 --> 01:32:08.015
aus der Implementation. Also dass ich merke so,

01:32:08.135 --> 01:32:10.155
okay, an der Stelle mache ich zwei, drei Umstellungen

01:32:10.155 --> 01:32:12.075
und dann merke ich so, okay, das ist jetzt alles, jetzt brauche ich ja kein

01:32:12.075 --> 01:32:13.495
Objekt mehr, das nehme ich da einfach im Dikt oder so.

01:32:13.775 --> 01:32:16.035
Und dann, oh, dann kann ich das ja so ausdrücken und dann kann ich so, oh,

01:32:16.215 --> 01:32:17.775
und jetzt ist das Design auch klar.

01:32:18.775 --> 01:32:20.015
Aber es kommt halt aus dem

01:32:20.015 --> 01:32:21.975
mit den Datenstrukturen rumspielen.

01:32:22.375 --> 01:32:24.015
Nicht so sehr aus dem sich abstrakte Gedanken

01:32:24.015 --> 01:32:24.275
machen.

01:32:25.715 --> 01:32:28.175
Ich weiß es nicht. Ich probiere es mal aus, mal gucken. Also es klingt auf jeden Fall

01:32:28.175 --> 01:32:30.035
ganz interessant und es ist halt nochmal ein bisschen was anderes als

01:32:30.035 --> 01:32:31.495
Test-Driven Development.

01:32:32.215 --> 01:32:34.235
Und ja, ich glaube auch, das habe ich bisher einfach

01:32:34.235 --> 01:32:36.315
unterschätzt und irgendwie nicht richtig gemacht mit den

01:32:36.315 --> 01:32:38.555
Dokumentationen und Kommentaren.

01:32:38.655 --> 01:32:40.355
Das ist wahrscheinlich doch deutlich wichtiger, als ich gedacht habe.

01:32:40.735 --> 01:32:41.415
Da muss ich mal mehr machen.

01:32:43.295 --> 01:32:44.315
Ja, das klingt gut. Also

01:32:44.315 --> 01:32:45.715
tatsächlich dokumentierter Code.

01:32:46.455 --> 01:32:47.975
Sehr zen, sehr zen, sehr zen auf Python.

01:32:49.195 --> 01:32:50.135
Ah, ja.

01:32:51.455 --> 01:32:52.475
Ja, ich glaube, wir haben

01:32:52.475 --> 01:32:54.535
bei Refactoring, ich habe nicht mehr

01:32:54.535 --> 01:32:56.175
so viel auf meinem Titel, was ich hätte.

01:32:56.275 --> 01:32:58.015
Ich kann mal gerade gucken, ob ich habe, ich habe mir,

01:32:58.235 --> 01:32:59.815
was habe ich mir denn aufgeschrieben, was ich dazu noch?

01:33:00.195 --> 01:33:02.455
Ich muss natürlich sagen, mein T-Sync kaputt, hatte ich am Anfang schon

01:33:02.455 --> 01:33:03.455
erwähnt, aber das ist nicht so schlimm.

01:33:03.955 --> 01:33:04.855
Übrigens, achso, genau,

01:33:05.175 --> 01:33:08.715
das, was ich mir aufgeschrieben habe,

01:33:08.875 --> 01:33:10.275
Red Flag, irgendwie

01:33:10.275 --> 01:33:12.295
extensive Dokumentation schreibt er auch, obwohl er

01:33:12.295 --> 01:33:14.255
eigentlich sagt, Dokumentation, voll gut, er sagt,

01:33:14.415 --> 01:33:16.155
ja, wenn Leute viel, viel dokumentieren,

01:33:17.095 --> 01:33:18.255
ist auch ein Zeichen

01:33:18.255 --> 01:33:20.495
für schlechtes Design, weil das ist ja

01:33:20.495 --> 01:33:22.295
etwas, was nicht, ist ja nicht gut, dass man das hat,

01:33:22.375 --> 01:33:23.975
sondern je mehr man dokumentieren muss,

01:33:23.975 --> 01:33:25.195
man muss viel erklären, ist auch gut.

01:33:25.195 --> 01:33:27.635
Ja, wenn du viel erklären musst, ist nicht gut. Eigentlich sollte es offensichtlich sein,

01:33:27.715 --> 01:33:29.755
man sollte es mit wenig...

01:33:29.755 --> 01:33:31.695
Also ein oder zwei Sätze am Anfang, was machen das

01:33:31.695 --> 01:33:33.575
zu kaufen. Dann muss man die ganze Funktion nicht lesen, wenn das

01:33:33.575 --> 01:33:35.835
stimmt. Aber das finde ich

01:33:35.835 --> 01:33:37.295
auch so eine Sache, warum ich Typefins gut finde.

01:33:37.395 --> 01:33:39.515
Nicht, weil es unbedingt die Typensicherheit alles sicherstellt,

01:33:39.875 --> 01:33:41.535
aber wenn ich halt den Funktionsnamen lese,

01:33:41.595 --> 01:33:43.495
der gut gewählt ist, die Typefins, die dazu passen,

01:33:43.555 --> 01:33:45.595
zu den Parametern, die die Funktion hat

01:33:45.595 --> 01:33:47.575
und dann den Dockstring, der idealerweise

01:33:47.575 --> 01:33:49.515
mir erklärt, was das macht, dann habe ich ja den

01:33:49.515 --> 01:33:51.315
Return-Wert, dann muss ich gar nicht in die Funktion reingucken,

01:33:51.435 --> 01:33:53.095
um dir alles genau angucken, sondern ich weiß halt, was sie tut,

01:33:53.155 --> 01:33:54.815
und kann zum nächsten übergehen.

01:33:54.975 --> 01:33:57.115
Das ist super schön zum Arbeiten.

01:33:57.115 --> 01:33:59.275
Ja, das ist dann halt beispielsweise für die gelungene Abstraktion,

01:33:59.395 --> 01:34:00.175
wenn du halt sozusagen

01:34:00.175 --> 01:34:03.195
der Interface-Dokumentation

01:34:03.195 --> 01:34:04.015
schon ansehen kannst.

01:34:04.535 --> 01:34:06.455
Also daraus alles erfährst,

01:34:06.535 --> 01:34:07.955
was du brauchst, um das benutzen zu können.

01:34:07.975 --> 01:34:10.235
Ja, genau. Du kannst also die Docstrings skimmen

01:34:10.235 --> 01:34:12.215
und kurz gucken, okay, jetzt mach das und das und das.

01:34:12.555 --> 01:34:14.535
Du musst gar nicht so genau den Code dir angucken, dann ist das auch egal,

01:34:14.615 --> 01:34:16.575
ob die Leute da so ordentlich gearbeitet haben

01:34:16.575 --> 01:34:18.255
irgendwann. Ja, absolut.

01:34:19.775 --> 01:34:20.255
Ja, ja.

01:34:20.595 --> 01:34:22.255
Ja. Ne, ich habe jetzt gerade nochmal geguckt,

01:34:22.255 --> 01:34:23.855
ich habe auch sonst nichts mehr eigentlich, was ich

01:34:23.855 --> 01:34:25.535
unbedingt unterbringen wollte.

01:34:25.535 --> 01:34:27.595
Nein, bei mir ist auch alles untergebracht.

01:34:27.675 --> 01:34:29.635
Oh, wir sind ja schon relativ weit dran.

01:34:29.635 --> 01:34:30.935
Wir haben immer viele Leute, die ab dann

01:34:30.935 --> 01:34:31.895
abspringen.

01:34:33.315 --> 01:34:35.355
Die Meinung

01:34:35.355 --> 01:34:37.895
von Leuten, die

01:34:37.895 --> 01:34:39.435
das hier durchgehalten haben, wäre

01:34:39.435 --> 01:34:40.935
ganz interessant vielleicht.

01:34:41.515 --> 01:34:43.295
Und zwar, das war letztens

01:34:43.295 --> 01:34:45.235
im Stream, hat dann irgendjemand geschrieben, meinte so,

01:34:45.295 --> 01:34:47.555
ach, es wäre doch voll gut, wenn ihr sowas hättet wie ein Discord oder so.

01:34:47.835 --> 01:34:49.475
Aha. Wollen wir sowas haben?

01:34:49.575 --> 01:34:51.355
Ich meine, wir haben Slack, aber Slack ist irgendwie...

01:34:51.355 --> 01:34:54.055
Wie hat das jemand dann genannt? Ah, Slack ist ja mehr so ein Boomer-Discord.

01:34:54.335 --> 01:34:54.535
Ja.

01:34:55.955 --> 01:34:57.435
Also Discord habe ich übrigens auch

01:34:57.435 --> 01:34:59.535
für meine eigenen Zeugs schon online

01:34:59.535 --> 01:35:01.335
einmal und so. Also ja, wir gucken

01:35:01.335 --> 01:35:02.375
den Teller an, ist ja kein Problem.

01:35:03.835 --> 01:35:05.615
Ja, oder ich meine, welche Plattform sollte man

01:35:05.615 --> 01:35:07.355
da verwenden? Discord. Discord, echt?

01:35:07.755 --> 01:35:09.495
Weil, also die Firma dahinter

01:35:09.495 --> 01:35:11.235
ist auch so ein bisschen unsympathisch, ne? Ja.

01:35:11.735 --> 01:35:13.635
Ja, die machen auch so NFT-Kram

01:35:13.635 --> 01:35:15.875
und Krypto...

01:35:15.875 --> 01:35:17.555
Das sagt jemand, der Werbung

01:35:17.555 --> 01:35:19.335
für VPNs macht.

01:35:22.915 --> 01:35:23.935
Spoiler, ich weiß nicht.

01:35:24.115 --> 01:35:25.535
Ja, es ist alles so ein bisschen...

01:35:26.375 --> 01:35:27.675
Ich weiß

01:35:27.675 --> 01:35:29.495
nicht so genau. Ja, okay,

01:35:29.535 --> 01:35:37.515
Also Discord wäre gut, weil ich meine, dann könnten halt auch Leute da irgendwie mal, man könnte mit Leuten chatten und so, also Leute live, wenn wir machen jetzt noch nichts live.

01:35:37.515 --> 01:35:41.275
Ja, das ist eigentlich auch doof, also das haben wir auch irgendwann wieder weggeschmissen. Also Discord würde ich auch sagen, ist cool.

01:35:41.815 --> 01:35:42.055
Okay.

01:35:42.755 --> 01:35:53.535
Also was cooler Discord ist, das nutzen halt alle von früher und so vom Gaming und so weiter. Man kann halt super easy da halt irgendwie reingehen, man hat halt Video, man hat halt Chat, man hat halt alles eigentlich, was man so will.

01:35:54.055 --> 01:35:56.575
Die Firma kenne ich gar nicht, also du hast irgendwas Böses, wo die Firma gehört?

01:35:56.575 --> 01:35:59.475
Ja, also es ist halt nicht so, dass man

01:35:59.475 --> 01:36:01.655
das selber betreiben könnte, du bist halt dann abhängig von der Firma

01:36:01.655 --> 01:36:03.055
genau wie bei Slack. Ja gut, du machst dann

01:36:03.055 --> 01:36:04.555
ein Channel auf für dich, ne? Ja, ja, okay

01:36:04.555 --> 01:36:07.215
Ja, ich weiß so ein bisschen, was du meinst, aber so

01:36:07.215 --> 01:36:09.535
Also ich würde das natürlich, mir ist

01:36:09.535 --> 01:36:11.375
schon sympathisch zum Beispiel auch, was die technisch machen

01:36:11.375 --> 01:36:12.835
die haben ja auch irgendwie

01:36:12.835 --> 01:36:15.535
da Rekorde aufgestellt

01:36:15.535 --> 01:36:17.355
mit wie viel Clients an einem Server

01:36:17.355 --> 01:36:18.815
hängen können, mit Erlangen und so

01:36:18.815 --> 01:36:21.495
die machen halt, das ist

01:36:21.495 --> 01:36:22.795
alles schon cool, aber

01:36:22.795 --> 01:36:25.475
irgendwie, ja, das ist halt eine Firma, also ich würde es gerne

01:36:25.475 --> 01:36:26.815
selber hosten können oder sowas.

01:36:26.835 --> 01:36:29.295
Ja, aber diese ganzen Inti-Lösungen, die es für sowas halt gibt,

01:36:29.375 --> 01:36:31.255
ich weiß nicht, die sind halt von der Nutzerbasis, glaube ich,

01:36:31.255 --> 01:36:32.415
gar nicht so interessant.

01:36:33.615 --> 01:36:35.735
Ja, man muss wahrscheinlich dahin gehen, wo die User sind.

01:36:35.955 --> 01:36:36.315
Ja, genau.

01:36:37.635 --> 01:36:38.375
Hey, wir haben ein Instagram-Store.

01:36:38.375 --> 01:36:39.335
Gefällt mir gar nicht, aber gut.

01:36:40.755 --> 01:36:42.015
Sind wir doch nicht auf Instagram, schade.

01:36:42.795 --> 01:36:44.375
Ja, gefällt mir nicht. Genau, ja.

01:36:44.495 --> 01:36:45.855
Dann lass uns doch noch ein Facebook-Store machen.

01:36:49.915 --> 01:36:51.335
Ja, Discord finde ich ganz okay, es geht.

01:36:52.015 --> 01:36:52.715
Aber bei mir ist es eh immer an.

01:36:53.675 --> 01:36:54.555
Ja, gut, okay.

01:36:55.475 --> 01:36:57.355
Johannes auch da. Ja, ich weiß,

01:36:57.435 --> 01:36:59.595
der hat ja da auch irgendwie ein eigenes Ding

01:36:59.595 --> 01:37:01.435
aufgemacht, aber da ist auch gar nicht so wahnsinnig viel los.

01:37:01.855 --> 01:37:03.415
Ja, aber das liegt auch ein bisschen daran,

01:37:03.535 --> 01:37:05.295
also unter anderem, dass

01:37:05.295 --> 01:37:07.335
er das halt auch so bei seinen Sachen

01:37:07.335 --> 01:37:08.675
benutzt wie seine Spielfirma.

01:37:10.255 --> 01:37:11.035
Naja, aber wie auch immer.

01:37:11.935 --> 01:37:12.855
Lustig auch, das gerade auf der Arbeit?

01:37:13.595 --> 01:37:15.315
Nein. Okay, also ich habe meine eigene

01:37:15.315 --> 01:37:17.215
mit Leuten, ich würde da auch mit Kunden drüber sprechen,

01:37:17.355 --> 01:37:18.895
also ich finde, das ist so die beste

01:37:18.895 --> 01:37:21.235
Teams-Alternative zum Beispiel, wenn ich jetzt

01:37:21.235 --> 01:37:23.275
so Kundenprojekte habe, wenn die auf meine Plattform kommen

01:37:23.275 --> 01:37:24.655
und ich nicht auf deren muss, dann

01:37:24.655 --> 01:37:27.655
die Kommunikation ist irgendwie schöner, professioneller, sauberer, cleaner.

01:37:30.675 --> 01:37:32.735
Aber es ist noch wieder so eine ästhetische Sache und keine Ahnung,

01:37:32.855 --> 01:37:33.535
alles kommt ja teller.

01:37:34.435 --> 01:37:37.235
So besser als Teams zu sein ist jetzt nicht so furchtbar schnell.

01:37:37.815 --> 01:37:39.055
Okay, das war ein Beispiel.

01:37:39.675 --> 01:37:41.295
Weil wir darüber reden, wo die User sind und so.

01:37:42.915 --> 01:37:44.355
Die sind ja auch schon alle leider da.

01:37:47.815 --> 01:37:48.895
Wollen wir noch Pics machen?

01:37:49.735 --> 01:37:50.715
Stimmt, wir haben noch Pics.

01:37:51.715 --> 01:37:52.555
Bonnie darf anfangen.

01:37:54.655 --> 01:38:00.415
Ich habe mich jetzt motiviert von der letzten DjangoCon jetzt echt intensiver mal mit HTMX auseinandergesetzt.

01:38:00.775 --> 01:38:01.495
Ah, ja.

01:38:01.675 --> 01:38:04.215
Und das finde ich wirklich sehr, sehr cool.

01:38:04.595 --> 01:38:07.075
Ja, da machen wir auch irgendwann eine Folge und das ist tatsächlich toll.

01:38:07.595 --> 01:38:15.275
Ich bin ja tatsächlich auch nicht so ein riesen JavaScript-Freund und diese Karotte quasi,

01:38:16.075 --> 01:38:19.515
kleinseitige Weblogik ohne JavaScript zu schreiben, ist schon sehr, sehr groß für mich.

01:38:20.855 --> 01:38:24.415
Ich habe da letztens noch einen sehr interessanten Vortrag von dem Macher gehört.

01:38:24.415 --> 01:38:25.655
Das war von der...

01:38:25.655 --> 01:38:27.015
Das war Python US oder so.

01:38:27.135 --> 01:38:30.475
Der hat auch sehr schön erklärt,

01:38:30.675 --> 01:38:32.295
wie REST eigentlich funktioniert.

01:38:32.475 --> 01:38:34.755
Genau, und dass es ja eigentlich darum geht,

01:38:34.815 --> 01:38:36.855
HTML-Schnittlern herzuschicken und nicht JSON-APIs

01:38:36.855 --> 01:38:37.235
zu bauen.

01:38:38.135 --> 01:38:40.755
Also super interessanter Vortrag, hat mir ein Kollege empfohlen.

01:38:41.555 --> 01:38:42.675
Und ich habe mich damit noch mal

01:38:42.675 --> 01:38:44.775
beschäftigt, habe heute noch ein kleines

01:38:44.775 --> 01:38:46.775
Feature damit gebaut. Ich muss gestehen,

01:38:46.855 --> 01:38:48.395
ich glaube, ich habe es noch nicht so

01:38:48.395 --> 01:38:50.435
100%... Also es tut

01:38:50.435 --> 01:38:52.475
die Beispiele, die da drin sind, relativ simpel.

01:38:52.475 --> 01:38:54.095
Also ich klicke irgendwo, dann taucht sich was aus.

01:38:54.095 --> 01:38:56.215
ist klar, aber wenn man halt so ein bisschen

01:38:56.215 --> 01:38:58.355
darüber hinausgehen möchte und halt

01:38:58.355 --> 01:39:00.175
ja, einfach mal

01:39:00.175 --> 01:39:01.655
irgendwo Daten schicken oder so, also mal

01:39:01.655 --> 01:39:02.955
Postdaten schicken,

01:39:03.495 --> 01:39:06.055
die Patterns habe ich noch nicht so ganz raus, ich bin leider nicht

01:39:06.055 --> 01:39:08.075
ganz ohne jQuery rausgekommen, das hat mich persönlich

01:39:08.075 --> 01:39:10.035
dann sehr geärgert, weil erstens jQuery

01:39:10.035 --> 01:39:10.735
und zweitens JavaScript,

01:39:12.575 --> 01:39:13.915
aber ich glaube,

01:39:14.255 --> 01:39:15.875
also die Dokumentation lässt leider

01:39:15.875 --> 01:39:17.795
in meinen Augen ein bisschen zu wünschen übrig und

01:39:17.795 --> 01:39:19.815
googeln kann man auch nicht, weil Google immer denkt

01:39:19.815 --> 01:39:20.375
an mein HTML,

01:39:21.395 --> 01:39:23.695
das ist beides ein bisschen blöd. Ja, wie HTTPS

01:39:23.695 --> 01:39:25.755
ist auch mal doof. Ja, genau.

01:39:26.495 --> 01:39:26.755
Und

01:39:26.755 --> 01:39:28.975
ja, aber ich glaube, wenn

01:39:28.975 --> 01:39:31.695
das sehr viel Potenzial hat, das macht auf jeden Fall sehr viel Spaß

01:39:31.695 --> 01:39:33.555
damit zu arbeiten. Und

01:39:33.555 --> 01:39:35.215
im Endeffekt die Idee ist halt einfach, dass man halt

01:39:35.215 --> 01:39:36.735
Custom JavaScript Code durch

01:39:36.735 --> 01:39:39.475
Custom HTML Tags ersetzt.

01:39:40.435 --> 01:39:40.795
Und

01:39:40.795 --> 01:39:42.515
das ist echt cool. Also ich habe

01:39:42.515 --> 01:39:45.555
auch letztens meine Findings, wie man das mit

01:39:45.555 --> 01:39:46.915
Django verheiraten kann,

01:39:47.555 --> 01:39:48.915
auch in einem kleinen Artikel zusammengeschrieben.

01:39:49.195 --> 01:39:51.535
Das habe ich mir noch nicht angeguckt. Ich weiß nur, dass es es gibt. Es gibt ein

01:39:51.535 --> 01:39:53.395
Paket von Adam Johnson

01:39:53.395 --> 01:39:54.655
also der mit dem

01:39:54.655 --> 01:39:58.635
Was tut das Paket denn?

01:39:58.995 --> 01:40:00.955
Tatsächlich sind das eigentlich vier Zeilen Code

01:40:00.955 --> 01:40:02.635
man muss den CSF beibringen und das war's.

01:40:03.355 --> 01:40:04.615
Ah, okay, also das ist

01:40:04.615 --> 01:40:06.495
Django-HTMLX heißt das Paket glaube ich.

01:40:06.495 --> 01:40:07.795
Ah, okay, ich weiß gar nicht, was das tut.

01:40:08.115 --> 01:40:10.295
Weiß ich auch nicht, aber das ist auf jeden Fall

01:40:10.295 --> 01:40:12.515
der Autor ist auf jeden Fall

01:40:12.515 --> 01:40:14.895
schon mal ein Hinweis darauf, dass man sich das mal angucken sollte.

01:40:14.975 --> 01:40:15.615
Auf jeden Fall, ja.

01:40:16.795 --> 01:40:19.075
Und ja, genau.

01:40:19.295 --> 01:40:20.855
Ja, muss ich echt mal machen, weil wie gesagt, ich hab's halt einfach

01:40:20.855 --> 01:40:22.655
zu Fuß gemacht, weil ich wusste, dass das Pakete existiert sind.

01:40:22.655 --> 01:40:27.255
wenn man es einmal gefunden hat, das sind literally halt einfach vier Zeilen JavaScript, die man einbinden muss,

01:40:27.615 --> 01:40:30.175
dass man halt dem HTMLX quasi den CSF-Token injectet.

01:40:30.775 --> 01:40:33.515
Ja, da muss er auf jeden Fall in unserer nächsten Folge hören, da werden wir da auch nochmal drauf eingehen.

01:40:35.415 --> 01:40:35.815
Jochen?

01:40:38.235 --> 01:40:40.195
Ich weiß nicht so genau, was pücke ich denn?

01:40:41.295 --> 01:40:43.775
Also ich picke Pendulum. Ich glaube, das hatte ich schon mal gepickt, weiß ich nicht.

01:40:43.875 --> 01:40:45.215
Ich weiß immer, vielleicht kann man ja immer das nicht merken.

01:40:45.515 --> 01:40:47.595
Du musst immer so einfache Sachen picken. Ja, kennst du Pendulum?

01:40:47.775 --> 01:40:47.935
Nee.

01:40:48.335 --> 01:40:50.155
Das ist eine Date-Time-Parsing-Politik.

01:40:50.755 --> 01:40:50.995
Cool.

01:40:50.995 --> 01:41:06.235
Ja, also ein bisschen einfacher, so ein bisschen schöneres Interface, ein bisschen moderner. Früher hat man, glaube ich, Maya viel benutzt, aber ich kenne das Ries irgendwie, als wenn es nicht tot ist oder so. Und ja, aber da kann man so schöne Sachen machen, indem man Date-Times irgendwie machen möchte, in Time-Zone wechseln und so zu Strings umbauen und sowas.

01:41:06.235 --> 01:41:08.135
Okay, interessant, ich bin letztens

01:41:08.135 --> 01:41:11.555
das war gestern glaube ich

01:41:11.555 --> 01:41:14.655
da war

01:41:14.655 --> 01:41:16.375
das mich mit JavaScript beschäftigt

01:41:16.375 --> 01:41:16.775
und Zeit

01:41:16.775 --> 01:41:20.335
ich wollte eigentlich nichts kompliziertes machen, ich wollte zum Beispiel einfach nur

01:41:20.335 --> 01:41:22.055
ein Date-Objekt einfach darstellen

01:41:22.055 --> 01:41:23.615
und

01:41:23.615 --> 01:41:26.255
das war ganz

01:41:26.255 --> 01:41:26.835
schrecklich

01:41:26.835 --> 01:41:30.195
Also Pendulum ist für Python, weil das auch immer nervt

01:41:30.195 --> 01:41:31.755
meiner Meinung nach, sehr schön eigentlich

01:41:31.755 --> 01:41:33.015
Ja, also da ist

01:41:33.015 --> 01:41:35.095
das JavaScript-Date-Ding

01:41:35.095 --> 01:41:37.295
also das hatte, also sowas wie

01:41:37.295 --> 01:41:38.875
StoveTime gibt es da halt einfach nicht.

01:41:39.515 --> 01:41:41.415
Wenn man jetzt die Differenz

01:41:41.415 --> 01:41:43.095
zwischen zwei Dates bildet

01:41:43.095 --> 01:41:45.515
in JavaScript, ja, so hast du ein DateObjekt,

01:41:45.595 --> 01:41:47.215
ein anderes, machst eins minus das andere,

01:41:47.335 --> 01:41:48.355
was kommt dabei raus? Wisst ihr das?

01:41:49.295 --> 01:41:51.215
Bei Python kommt so ein

01:41:51.215 --> 01:41:52.075
Timedelta raus.

01:41:53.115 --> 01:41:55.155
Bei JavaScript

01:41:55.155 --> 01:41:57.255
kommt die absolute

01:41:57.255 --> 01:41:58.355
Zeit in Millisekunden raus.

01:41:59.055 --> 01:42:01.395
Was natürlich ein bisschen

01:42:01.395 --> 01:42:03.255
blöd ist, wenn man jetzt Mikrosekunden braucht oder keine Ahnung

01:42:03.255 --> 01:42:04.255
oder was ganz anderes oder

01:42:04.255 --> 01:42:06.675
oder halt an den Tagen

01:42:06.675 --> 01:42:07.435
interessiert oder so.

01:42:08.555 --> 01:42:10.075
Ja, das hat mich

01:42:10.075 --> 01:42:11.535
Ja, ich kann es so erklären,

01:42:11.935 --> 01:42:14.595
weiß ich jetzt nicht, aber Pendulum in Python macht genau das

01:42:14.595 --> 01:42:16.575
so ein bisschen schöner, so ein bisschen mehr moderner

01:42:16.575 --> 01:42:18.635
vielleicht. Okay, gut. Keine Ahnung, ich kann es

01:42:18.635 --> 01:42:19.335
nicht mal angucken.

01:42:20.935 --> 01:42:22.175
Ist das du noch ein Pick?

01:42:22.435 --> 01:42:24.275
Ja, vielleicht picke ich einfach

01:42:24.275 --> 01:42:25.575
Blue statt Black.

01:42:26.135 --> 01:42:27.815
Macht im Grunde das gleiche, nur halt mit

01:42:27.815 --> 01:42:30.375
einem einfachen Tick statt

01:42:30.375 --> 01:42:32.215
Doppel-Einführungszeichen.

01:42:32.215 --> 01:42:34.275
Ja. Wir hätten noch mal

01:42:34.275 --> 01:42:36.075
erstens irgendwas mit Black, was man... Darker.

01:42:36.255 --> 01:42:38.115
Darker war auch schön, ja. Weil Darker macht

01:42:38.115 --> 01:42:40.315
nämlich inkrementelles Black und zwar immer nur auf die neuen

01:42:40.315 --> 01:42:41.335
Änderungen.

01:42:42.195 --> 01:42:43.755
Was gut ist, wenn man halt ein neues...

01:42:43.755 --> 01:42:45.275
Sodass es halt immer dunkler wird zu der Zeit.

01:42:45.275 --> 01:42:46.935
Und wenn man... Weil das macht auch Sinn, dann halt

01:42:46.935 --> 01:42:49.255
As-Git-Commit-Hook irgendwie einzusetzen. Darker, weil

01:42:49.255 --> 01:42:50.815
dann nur die neuen Sachen halt

01:42:50.815 --> 01:42:53.155
tatsächlich gelintet werden und das ist ganz schön.

01:42:53.535 --> 01:42:55.335
Okay, aber Blue ist ein bisschen... Oh, warte. Was ich auch noch

01:42:55.335 --> 01:42:57.135
picke ist PipTools. Da habe ich letztens auf Twitter gesehen

01:42:57.135 --> 01:42:58.935
auch jemand... Ich habe...

01:42:58.935 --> 01:43:01.195
Angefangen. Weil du mir das gezeigt hast, wollte ich gerade

01:43:01.195 --> 01:43:02.495
was wir machen, ich komme immer nicht dazu.

01:43:03.935 --> 01:43:04.935
Weil ich habe nämlich auch,

01:43:05.015 --> 01:43:06.595
ich verwende ja sonst Poetry und

01:43:06.595 --> 01:43:08.915
genau,

01:43:09.035 --> 01:43:10.715
dann jetzt für das neueste Ding mit FastAFI

01:43:10.715 --> 01:43:12.795
und View und Frontend-Dings da,

01:43:12.875 --> 01:43:14.995
für meinen Deploy-Teil, da habe ich

01:43:14.995 --> 01:43:16.775
jetzt auch PipTools verwendet, weil

01:43:16.775 --> 01:43:19.055
mich Poetry so genervt hat, weil es so lange braucht

01:43:19.055 --> 01:43:20.855
und... Also PipTools sind so richtig

01:43:20.855 --> 01:43:22.955
toll, fand ich es jetzt auch. Und weil es halt oft auch

01:43:22.955 --> 01:43:24.295
irgendwie komisch kaputt geht. Aber es gibt

01:43:24.295 --> 01:43:26.215
Empfehlungen von dir?

01:43:27.095 --> 01:43:28.335
Ja, also genau,

01:43:28.535 --> 01:43:30.115
heute auf Twitter meint jemand so,

01:43:30.115 --> 01:43:36.955
also Pochi, eigentlich super sexy sieht das aus, aber ich bin durch, ich nehme jetzt wieder PipTools, weil das funktioniert einfach nicht.

01:43:37.915 --> 01:43:41.375
Und dann habe ich in diesem Twitter-Thread, den muss ich nochmal aufmerksam machen,

01:43:41.695 --> 01:43:42.955
ganz viele Leute was Ähnliches gesagt haben.

01:43:43.315 --> 01:43:47.155
Viele Leute sagen so, oh, furchtbar langsam, geht immer kaputt.

01:43:47.555 --> 01:43:51.895
Ja, also es geht auch bei mir ständig kaputt und ich muss immer was fixen, das nervt extrem.

01:43:52.635 --> 01:43:55.495
Aber es ist schon eigentlich eine gute Idee und eigentlich sollte es genauso aussehen,

01:43:55.495 --> 01:43:56.895
aber es tut halt nichts.

01:43:56.895 --> 01:44:01.675
Aber vielleicht lassen wir uns einfach mal fixen, anstatt was Neues wieder zu machen, was auch nicht funktioniert

01:44:01.675 --> 01:44:03.895
Vielleicht, gutes Schlusswort

01:44:03.895 --> 01:44:06.775
Ja, vielleicht lassen wir das mal refactoren

01:44:06.775 --> 01:44:09.835
Danke Ronne, dass du wieder da warst

01:44:09.835 --> 01:44:11.755
Ja, vielen Dank für eure Aufmerksamkeit

01:44:11.755 --> 01:44:15.155
Ja, bleibt uns gewogen, schaltet uns gerne wieder ein

01:44:15.155 --> 01:44:15.935
Bis zum nächsten Mal

01:44:15.935 --> 01:44:17.495
Bis dann mit Werbung, tschüss

01:44:17.495 --> 01:44:18.375
Tschüss, ciao