WEBVTT

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

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

00:00:09.120 --> 00:00:09.380
Hi Jochen.

00:00:09.400 --> 00:00:10.400
Jo, hallo auch Dominik.

00:00:11.000 --> 00:00:11.960
Und wir haben heute auch Ronny da.

00:00:12.320 --> 00:00:12.700
Hi Ronny.

00:00:12.820 --> 00:00:12.940
Hi.

00:00:13.020 --> 00:00:13.540
Jo, hi Ronny.

00:00:13.560 --> 00:00:14.220
Kennt ihr vielleicht auch noch.

00:00:14.600 --> 00:00:14.760
Grüße.

00:00:15.400 --> 00:00:15.600
Jo.

00:00:16.500 --> 00:00:18.480
Ja, vielleicht erstmal ein bisschen News.

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

00:00:19.620 --> 00:00:20.620
Ja, haben wir News?

00:00:20.860 --> 00:00:21.400
Ich weiß nicht genau.

00:00:21.560 --> 00:00:21.940
Also am 6.

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

00:00:27.240 --> 00:00:27.900
Ach, okay.

00:00:27.900 --> 00:00:29.040
Das ist an mir vorbeigekommen.

00:00:29.100 --> 00:00:29.840
Das habe ich gerade nicht bekommen.

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

00:00:31.700 --> 00:00:32.960
Habe ich bei mir jetzt überall eingebaut und

00:00:32.960 --> 00:00:35.600
stable. Ich glaube, das war

00:00:35.600 --> 00:00:36.820
vorgestern oder so,

00:00:37.240 --> 00:00:39.160
oder gestern, ich bin mir gar nicht sicher.

00:00:39.520 --> 00:00:41.020
Vielleicht gestern ist Django 4

00:00:41.020 --> 00:00:43.460
released worden. Ja, stimmt, genau.

00:00:43.760 --> 00:00:45.820
Ja, das ist auch eine ganz gute Neuigkeit.

00:00:47.320 --> 00:00:47.440
Ja.

00:00:48.120 --> 00:00:49.540
Es ist gar nicht so viel Neues dazu gekommen,

00:00:49.680 --> 00:00:51.320
ehrlich gesagt. Aber es ist super viel weggefallen.

00:00:51.320 --> 00:00:53.320
Also die Backwards-Incompatibility-List,

00:00:54.800 --> 00:00:55.140
oh mein Gott,

00:00:55.600 --> 00:00:57.280
die ist ungefähr fünfmal so lang wie die

00:00:57.280 --> 00:00:58.460
neuen Features. Das ist echt krass.

00:00:58.780 --> 00:00:59.560
Das ist super, ja.

00:01:00.000 --> 00:01:02.780
ein paar Sachen rausgeflogen, die man nicht mehr braucht oder die gefährlich

00:01:02.780 --> 00:01:03.840
sind oder so, schon gar nicht so schlecht.

00:01:05.420 --> 00:01:06.740
Ja, ansonsten

00:01:06.740 --> 00:01:08.620
weiß nicht genau, machen wir auch

00:01:08.620 --> 00:01:10.440
News in anderen, für andere Sprachen?

00:01:10.660 --> 00:01:12.020
Ja, ich glaube hier

00:01:12.020 --> 00:01:14.480
PHP 8.1 ist irgendwie released

00:01:14.480 --> 00:01:16.200
und da gibt es ein neues interessantes Feature

00:01:16.200 --> 00:01:17.980
mit dabei und zwar

00:01:17.980 --> 00:01:19.380
async await

00:01:19.380 --> 00:01:22.580
so wie in Python halt auch

00:01:22.580 --> 00:01:24.100
nur anders, also

00:01:24.100 --> 00:01:26.120
also die Keywords

00:01:26.120 --> 00:01:27.480
aber es

00:01:27.480 --> 00:01:29.980
ist ein bisschen anders, man kann das halt

00:01:29.980 --> 00:01:32.120
man kann halt Async-Funktionen auch so callen

00:01:32.120 --> 00:01:33.860
ohne Await, was ganz

00:01:33.860 --> 00:01:35.460
interessant ist. In JavaScript übrigens auch so.

00:01:37.320 --> 00:01:38.020
Man muss

00:01:38.020 --> 00:01:40.080
halt nur, wenn man Await sagen will

00:01:40.080 --> 00:01:41.760
innerhalb von einer Funktion, irgendwie die Async

00:01:41.760 --> 00:01:43.820
definiert haben, aber man kann die auch

00:01:43.820 --> 00:01:45.440
einfach so aufrufen und

00:01:45.440 --> 00:01:47.820
ja, dann passiert irgendwie magisch das Richtige oder

00:01:47.820 --> 00:01:48.740
was Falsches oder was.

00:01:49.780 --> 00:01:51.760
Aber man hat halt daher, also was

00:01:51.760 --> 00:01:53.780
in Python tatsächlich ein bisschen nervig ist, ist man halt

00:01:53.780 --> 00:01:55.780
dieses Farbigkeitsproblem der Funktionen hat,

00:01:55.840 --> 00:01:57.360
dass man halt, wenn man irgendwo

00:01:57.360 --> 00:01:59.320
Async was machen möchte, dann muss

00:01:59.320 --> 00:01:59.920
alles Async sein.

00:02:01.000 --> 00:02:02.820
Man kann natürlich auch hingehen und sagen,

00:02:03.340 --> 00:02:05.420
okay, async.io.run

00:02:05.420 --> 00:02:07.480
oder so, aber das ist natürlich...

00:02:07.480 --> 00:02:09.120
Man muss dann erstmal den Event-Loop immer rausführen

00:02:09.120 --> 00:02:11.180
oder wenn man im Jupyter gerade ist, dann ist das auch immer

00:02:11.180 --> 00:02:12.120
ein bisschen doof und so, ja.

00:02:12.720 --> 00:02:15.360
Ja, also in Python ist es expliziter

00:02:15.360 --> 00:02:17.220
als in JavaScript und in PHP,

00:02:17.420 --> 00:02:18.500
aber es ist halt auch so ein bisschen

00:02:18.500 --> 00:02:21.040
unhandlicher zu benutzen vielleicht, aber

00:02:21.040 --> 00:02:23.200
naja, gut. Ja, aber das ist vielleicht

00:02:23.200 --> 00:02:25.060
auch noch erwähnenswert, weil damit wird in PHP

00:02:25.060 --> 00:02:27.100
auch dann irgendwann das möglich, was ja jetzt in Python

00:02:27.100 --> 00:02:29.140
jetzt, das kommt ja jetzt in Python, ist das

00:02:29.140 --> 00:02:31.140
jetzt in den ganzen Frameworks halt irgendwie so

00:02:31.140 --> 00:02:32.000
oder zumindest Django,

00:02:32.240 --> 00:02:35.120
ich kann nicht so genau, FastAPI halt auch, aber das

00:02:35.120 --> 00:02:37.040
war ja schon immer so angekommen, dass man halt

00:02:37.040 --> 00:02:38.980
irgendwie Async-Kram da machen kann

00:02:38.980 --> 00:02:41.120
und dann eben, ja, kann man halt solche Sachen machen

00:02:41.120 --> 00:02:43.060
wie auch Filesurfing vom Applikationsserver aus

00:02:43.060 --> 00:02:44.940
oder halt auch Websockets, relativ

00:02:44.940 --> 00:02:46.980
einfach und so und das geht dann halt, weil ich weiß

00:02:46.980 --> 00:02:49.000
gar nicht, wie das in PHP ist, da normalerweise eben

00:02:49.000 --> 00:02:51.300
Sachen, PHP, Filesurfen,

00:02:51.500 --> 00:02:53.140
das geht halt einfach nicht so richtig gut, weil

00:02:53.140 --> 00:02:54.800
üblicherweise hat man nach irgendwie

00:02:54.800 --> 00:02:56.880
einer Minute oder so werden die

00:02:56.880 --> 00:02:58.920
Prozesse gekillt, weil

00:02:58.920 --> 00:02:59.980
bei den meisten Hosern.

00:03:00.260 --> 00:03:02.800
Da brauchst du mich jetzt gar nicht fragen, ich kriege nullkummer gar nicht aus,

00:03:02.860 --> 00:03:03.280
wenn ich es ja sprache.

00:03:04.260 --> 00:03:06.340
Naja, aber genau, da geht es halt auf jeden Fall auch voran.

00:03:06.500 --> 00:03:08.480
Also sowieso per letzten Version

00:03:08.480 --> 00:03:09.980
viel dazu gekommen und ja.

00:03:10.560 --> 00:03:12.140
Ich kenne mich noch vom Gegenschubsen,

00:03:12.140 --> 00:03:13.040
um umzutreten.

00:03:13.560 --> 00:03:15.520
Tja, kann man natürlich auch machen.

00:03:17.260 --> 00:03:18.360
Ja, haben wir noch andere News?

00:03:18.460 --> 00:03:18.900
Haben wir noch was?

00:03:19.880 --> 00:03:22.200
Was war denn in Django 4

00:03:22.200 --> 00:03:24.040
drin alles Schönes?

00:03:24.140 --> 00:03:24.620
Wisst ihr das noch?

00:03:25.820 --> 00:03:28.140
Ja, neuer, also Django Redis

00:03:28.140 --> 00:03:29.940
ist irgendwie, also Redis-Kind

00:03:29.940 --> 00:03:32.000
wird da reingekommen. Automatisch, das gab ja immer sonst

00:03:32.000 --> 00:03:33.880
ein Redis-Package und jetzt kam es direkt als

00:03:33.880 --> 00:03:36.120
Default-Sets oder so, ne? Ja, es ist jetzt

00:03:36.120 --> 00:03:37.580
halt drin, weil es gab irgendwie eine Umfrage,

00:03:38.000 --> 00:03:39.700
was verwendet ihr denn so für Caching und

00:03:39.700 --> 00:03:41.520
Alle nehmen Redis. Genau,

00:03:41.740 --> 00:03:42.980
Memcachedie war eingebaut,

00:03:43.480 --> 00:03:45.120
aber alle nehmen Redis, daher

00:03:45.120 --> 00:03:47.100
macht es irgendwie nicht so richtig viel Sinn,

00:03:47.760 --> 00:03:49.680
das nicht eingebaut zu haben und ja,

00:03:49.740 --> 00:03:50.560
deswegen ist das jetzt halt drin.

00:03:51.820 --> 00:03:53.400
Ja, ansonsten, naja,

00:03:53.960 --> 00:03:55.220
war's nicht. Die anderen Sachen waren...

00:03:55.220 --> 00:03:56.380
Halt, die Set ist rausgeflogen, glaube ich.

00:03:56.820 --> 00:03:57.140
Genau.

00:03:58.700 --> 00:04:03.620
Aber ich glaube, das war echt mehr ein Aufräumen-Release.

00:04:04.460 --> 00:04:04.820
Gefühlt.

00:04:06.160 --> 00:04:07.240
Was ja auch eine gute Sache ist

00:04:07.240 --> 00:04:09.540
und was auch sehr gut zu unserer Refactoring-Session passt.

00:04:10.100 --> 00:04:10.260
Ja, absolut.

00:04:10.960 --> 00:04:13.000
Genau, das ist nämlich das Thema, glaube ich.

00:04:13.000 --> 00:04:13.680
Genau, das Thema.

00:04:14.640 --> 00:04:16.460
Ja, was ist denn das überhaupt, Refactoring?

00:04:16.660 --> 00:04:17.760
Was sagt ihr denn, was das ist?

00:04:17.840 --> 00:04:20.960
Also ich sage mal so, ich baute oft meinen Code um,

00:04:21.020 --> 00:04:21.920
aber ist das schon Refactoring?

00:04:23.020 --> 00:04:24.700
Also immer dann, wenn man halt ein bisschen später wieder draufguckt.

00:04:25.000 --> 00:04:26.580
merkt man halt so, oh, wie war ich doof oder

00:04:26.580 --> 00:04:28.600
oh, ist das aber hässlich oder schlecht, was ich

00:04:28.600 --> 00:04:30.620
vorgemacht habe. Mach ich das doch mal nochmal oder

00:04:30.620 --> 00:04:32.760
pass ein bisschen an oder mach es ganz von

00:04:32.760 --> 00:04:34.620
neu oder was heißt Refactoring

00:04:34.620 --> 00:04:35.000
für euch?

00:04:36.500 --> 00:04:38.620
Nimmt man sich da extra Zeit für? Gehört das in

00:04:38.620 --> 00:04:39.840
einen Sprint oder so?

00:04:40.320 --> 00:04:41.620
Ich würde jetzt mal sagen,

00:04:41.820 --> 00:04:44.520
meiner Verständnis nach gehört das

00:04:44.520 --> 00:04:45.500
halt schon dazu,

00:04:47.200 --> 00:04:48.460
wenn man sich

00:04:48.460 --> 00:04:50.000
der agilen Softwareentwicklung

00:04:50.000 --> 00:04:51.600
bedient als

00:04:51.600 --> 00:04:54.500
Prozessmethode,

00:04:54.760 --> 00:04:56.760
was auch immer, wie man das nennen möchte, dann würde

00:04:56.760 --> 00:04:58.320
ich sagen, ich sage mal so Definitions of Done,

00:04:58.600 --> 00:05:00.080
zum Beispiel bei Scrum, sagt,

00:05:00.420 --> 00:05:02.820
wann ist was fertig und dann würde

00:05:02.820 --> 00:05:04.540
aus meiner Sicht halt dazugehören,

00:05:04.880 --> 00:05:06.760
normalerweise, dass man sagt, man hat das auch irgendwie mal

00:05:06.760 --> 00:05:08.540
refactured oder so. Wie viel

00:05:08.540 --> 00:05:10.740
Prozent der Zeit würde in sowas wie? Och, keine Ahnung,

00:05:10.820 --> 00:05:12.440
das kommt drauf an, also. So ein Tag?

00:05:12.780 --> 00:05:14.700
Je nachdem, was man macht, nee, das kommt

00:05:14.700 --> 00:05:16.660
halt, also, und manchmal muss man es vielleicht

00:05:16.660 --> 00:05:18.180
auf das komplette System refacturen, weil.

00:05:18.340 --> 00:05:20.220
Wer refactort das denn, man selber, ein anderes Team,

00:05:20.420 --> 00:05:22.680
das eigene Team mit vier, fünf, sechs Augen

00:05:22.680 --> 00:05:24.740
im Prinzip? Nee, immer der, der fragt.

00:05:24.760 --> 00:05:29.160
Okay, also bei uns

00:05:29.160 --> 00:05:31.180
bin ich, also ich bin, weil ich mag

00:05:31.180 --> 00:05:33.160
das irgendwie, Code umzubauen, ich weiß auch nicht

00:05:33.160 --> 00:05:35.160
das ist so ein bisschen blödes Hobby, also es gibt

00:05:35.160 --> 00:05:37.240
ja Zen of Python, das ist ja eigentlich

00:05:37.240 --> 00:05:39.160
eher für andere Dinge da, da

00:05:39.160 --> 00:05:41.100
wollten wir auch nochmal eine Folge drüber machen, aber der erste

00:05:41.100 --> 00:05:43.240
Satz ist natürlich, beautiful is better than

00:05:43.240 --> 00:05:43.560
ugly

00:05:43.560 --> 00:05:47.020
und ich mag das irgendwie, wenn es hübsch ist

00:05:47.020 --> 00:05:49.100
aber ist das ein guter Grund

00:05:49.100 --> 00:05:50.980
zum Refactoren, dass es dann nachhübscher aussieht

00:05:50.980 --> 00:05:52.620
es tut halt dasselbe

00:05:52.620 --> 00:05:54.920
ist das wartbarer?

00:05:55.100 --> 00:05:57.080
Aus meiner Sicht eigentlich schon,

00:05:57.440 --> 00:05:59.360
aber da ist natürlich irgendwie

00:05:59.360 --> 00:06:01.280
quasi, ja, aber ich meine

00:06:01.280 --> 00:06:03.480
Man kann unendlich viel Zeit damit zu verbringen,

00:06:03.560 --> 00:06:05.180
immer wieder dran rum zu feilen und zu gucken, dass

00:06:05.180 --> 00:06:07.300
immer alles ein bisschen hübscher ist. Das macht halt kein

00:06:07.300 --> 00:06:09.280
einziges Feature mehr. Aber das ist auch vielleicht so ein bisschen,

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

00:06:10.760 --> 00:06:12.960
warum Programmierer irgendwie

00:06:12.960 --> 00:06:15.120
Programmierer sein irgendwie nicht so

00:06:15.120 --> 00:06:17.280
Business, dass sich das wie. Wie ist nochmal

00:06:17.280 --> 00:06:18.640
dieser Talk, da hatten wir schon mal drüber gesprochen.

00:06:19.600 --> 00:06:20.740
Weiß ich gar nicht, welchen meinst du?

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

00:06:22.620 --> 00:06:25.100
der war auf der DjangoCon irgendwie ganz

00:06:25.100 --> 00:06:27.140
entspannt. Ach, der, der erste,

00:06:27.260 --> 00:06:29.280
der erste Talk auf der DjangoCon

00:06:29.280 --> 00:06:29.860
EU, ja,

00:06:31.480 --> 00:06:33.220
weil man mag halt programmieren

00:06:33.220 --> 00:06:36.920
und deswegen macht man das halt

00:06:36.920 --> 00:06:39.000
und ob es irgendwie am Schluss

00:06:39.000 --> 00:06:40.880
dabei was rauskommt oder nicht, ist eigentlich dann auch

00:06:40.880 --> 00:06:42.960
so ein bisschen egal, genau. Ich glaube, ganz

00:06:42.960 --> 00:06:44.760
wichtig ist halt, wie in allen Bereichen

00:06:44.760 --> 00:06:46.940
überall ist halt Pareto-Prinzip, also

00:06:46.940 --> 00:06:48.760
dass man einfach schauen muss, dass man

00:06:48.760 --> 00:06:50.940
also 80% der Sachen kriegst du halt

00:06:50.940 --> 00:06:53.400
einfach in 20% der Zeit refactored und die Details,

00:06:53.560 --> 00:06:55.220
die kosten dann richtig viel

00:06:55.220 --> 00:06:56.180
und da muss man abwägen.

00:06:56.460 --> 00:06:58.920
Die ganz wichtigen Details, darf man das weglassen? Ich weiß nicht.

00:06:59.600 --> 00:07:01.160
Es kommt immer ganz drauf an, würde ich

00:07:01.160 --> 00:07:03.020
sagen. Also ich meine, wenn man jetzt irgendwie an einer

00:07:03.020 --> 00:07:04.900
Software bastelt und da geht es gerade

00:07:04.900 --> 00:07:07.180
irgendwie um die, weiß ich nicht, Zahlungsschnittstelle

00:07:07.180 --> 00:07:08.880
oder Auftragsabwicklung, dann

00:07:08.880 --> 00:07:11.320
sollte man schon schauen, dass das vernünftig funktioniert

00:07:11.320 --> 00:07:13.040
und dass man da vielleicht auch eher einen Schritt

00:07:13.040 --> 00:07:15.120
weiter denkt, als einen Schritt zu kurz

00:07:15.120 --> 00:07:17.080
denkt. Aber es gibt doch in jedem System

00:07:17.080 --> 00:07:18.760
Bereiche, weiß ich nicht, irgendeine

00:07:18.760 --> 00:07:20.900
eine Administrationsseite, die zweimal im Jahr aufgerufen

00:07:20.900 --> 00:07:22.960
wird oder so und wenn die jetzt nicht ganz perfekt ist,

00:07:23.040 --> 00:07:23.820
jo, ich meine.

00:07:24.760 --> 00:07:26.900
Du sagst ja, der Business-Use-Case,

00:07:26.980 --> 00:07:28.520
das ist eigentlich, glaube ich, eine sehr gesunde Einstellung,

00:07:28.960 --> 00:07:31.120
wenn man sagt, es geht darum, Business-Value,

00:07:31.760 --> 00:07:32.740
also zumindest aus der Business-Sicht

00:07:32.740 --> 00:07:34.180
ist es eine sehr gesunde Einstellung.

00:07:35.100 --> 00:07:36.840
Aber ich würde nicht nur sagen das,

00:07:36.920 --> 00:07:38.800
also zum Beispiel, ich habe jetzt in einem

00:07:38.800 --> 00:07:40.660
Projekt, habe ich jetzt,

00:07:41.320 --> 00:07:42.480
ich habe ja vor

00:07:42.480 --> 00:07:44.800
einiger Zeit mir mal so ganz tolle Class-Based

00:07:44.800 --> 00:07:46.380
E-Mails für Django ausgedacht und

00:07:46.380 --> 00:07:48.600
habe jetzt in einem Projekt mal wirklich, weil

00:07:48.600 --> 00:07:50.620
ich jetzt Internationalisierung eingebaut habe, habe ich jetzt

00:07:50.620 --> 00:07:52.620
dann direkt alle E-Mails, weil ich

00:07:52.620 --> 00:07:54.500
da eh dran musste, weil ich die Templates halt anpassen musste

00:07:54.500 --> 00:07:57.060
und gucken musste, was halt die Sprache reingegeben wird, etc., etc.,

00:07:57.060 --> 00:07:58.480
habe ich halt dann direkt gesagt,

00:07:58.540 --> 00:08:00.580
okay, ich refactor jetzt direkt alle E-Mails zu Classbase,

00:08:00.660 --> 00:08:02.260
was ist natürlich viel,

00:08:02.880 --> 00:08:04.740
also das war definitiv in den 20%,

00:08:04.740 --> 00:08:06.280
ja, und nicht in den 80%,

00:08:06.280 --> 00:08:08.620
aber trotzdem weiß ich jetzt halt, dass wenn ich irgendwas

00:08:08.620 --> 00:08:10.080
mit den E-Mails machen muss und vielleicht mal auch

00:08:10.080 --> 00:08:12.480
generell was anpassen, zum Beispiel nochmal irgendwie das Layout

00:08:12.480 --> 00:08:14.740
überarbeiten, was eh für irgendwann ansteht bei dem Projekt und so was,

00:08:15.300 --> 00:08:16.660
habe ich halt danach einfach weniger Arbeit

00:08:16.660 --> 00:08:18.440
und das bohrt sich halt an, wenn ich das Ding ja eh gar

00:08:18.440 --> 00:08:20.120
auseinandernehme, dann mache ich das halt einfach noch mit.

00:08:20.160 --> 00:08:22.100
Gut, aber das ist jetzt auch wieder aus dem Effizienzgedanken heraus.

00:08:22.180 --> 00:08:24.220
Das heißt, du machst Refactoring deswegen, weil du später

00:08:24.220 --> 00:08:26.600
Arbeitszeit, Wartungszeit

00:08:26.600 --> 00:08:28.540
oder neue Feature-

00:08:28.540 --> 00:08:29.560
Entwicklungszeit sparst.

00:08:30.880 --> 00:08:32.640
Okay, das wäre auch so ein Effizienzgedanken.

00:08:32.760 --> 00:08:34.520
Also quasi extrem wichtig, dass man das dann tut.

00:08:34.820 --> 00:08:36.560
Und es schont dann auch meine Nerven,

00:08:36.560 --> 00:08:38.620
wenn ich das dann nächstes Mal entspannter

00:08:38.620 --> 00:08:40.200
machen kann. Ja, das finde ich auch. Also ich finde so

00:08:40.200 --> 00:08:42.540
Refactoren aufgrund von, wir brauchen das vielleicht

00:08:42.540 --> 00:08:44.440
nochmal und wie das da so steht,

00:08:44.540 --> 00:08:46.400
das versteht ja keiner. Das ist ein

00:08:46.400 --> 00:08:50.000
Eine Spaghetti-Band irgendwie hat irgendwas gebaut, weil er noch gar nicht wusste, wie das ging, hat das dann alles hingeschrieben.

00:08:50.340 --> 00:08:54.120
Das ging dann irgendwie, aber so richtig nutzbar und schön ist das alles nicht.

00:08:54.200 --> 00:08:56.380
Das ist irgendwie so, wie man es so kennt, so zusammengezimmert.

00:08:57.380 --> 00:09:03.100
Ich finde auch ein ganz wichtiger Punkt ist, dass halt die meiste Software, die funktioniert, wird ja konstant weiterentwickelt.

00:09:03.360 --> 00:09:04.100
Das ist ja einfach so.

00:09:04.800 --> 00:09:06.460
Da frage ich mich auch ehrlich gesagt immer, warum, aber okay.

00:09:06.460 --> 00:09:14.500
Und immer wenn neue Anforderungen dazu kommen, dann hat man die ja logischerweise vorher nicht bedacht, weil man ja nicht wusste, dass die kommt in den meisten Fällen oder in vielen Fällen.

00:09:14.960 --> 00:09:19.660
Und das heißt, man fängt dann an in etwas, das nicht dafür gedacht ist, mehr Sachen reinzubauen.

00:09:19.740 --> 00:09:23.940
Und das ist immer der Punkt, wo, glaube ich, intrinsisch einfach schon der Bedarf von einem gewissen Refactoring besteht.

00:09:24.060 --> 00:09:28.680
Vielleicht nicht bei der ersten oder zweiten Änderung, aber irgendwann gibt die Struktur das einfach nicht mehr her.

00:09:29.360 --> 00:09:34.600
Das ist halt genau die Frage. Wird was moderner? Muss man das dann, diesen modernen Stil, dann auch refactoren?

00:09:34.980 --> 00:09:39.020
Das ist aber eine Stilfrage. Das heißt, ich habe eine schönere Skulptur, die Skulptur hat eine andere Mode als vorher.

00:09:39.440 --> 00:09:41.760
Und deswegen mache ich es jetzt auf die gleiche Art ein bisschen neuer, ein bisschen anders.

00:09:41.860 --> 00:09:43.700
Das gibt ja jede Menge Dinge, die man neu machen kann.

00:09:44.960 --> 00:09:46.220
Ein schönes Beispiel finde ich Google.

00:09:46.400 --> 00:09:48.380
Google hat unheimlich viel Energie reingesteckt

00:09:48.380 --> 00:09:49.940
in das Gmail-Programm oder so.

00:09:50.680 --> 00:09:51.980
Und eigentlich würde ich fast setzen,

00:09:52.080 --> 00:09:54.360
das ist so quasi feature-complete zu dem, was man sich so wünscht.

00:09:54.440 --> 00:09:56.200
Man kann alles damit machen, was man mit zum E-Mail-Client

00:09:56.200 --> 00:09:58.160
eigentlich so machen will. Und die haben auch schon

00:09:58.160 --> 00:10:00.160
so viel Zeit draufgeschmissen, dass so viel Neues

00:10:00.160 --> 00:10:02.100
nicht kommt. Was ich jetzt immer sehe, da kommen irgendwelche

00:10:02.100 --> 00:10:03.800
Änderungen am Style, an der Grafik, die

00:10:03.800 --> 00:10:05.220
irgendwas eigentlich einfach nur anders machen.

00:10:05.700 --> 00:10:07.980
Die mich dann zum Beispiel eher nerven, weil ich brauche

00:10:07.980 --> 00:10:09.700
die einfach nicht. Ich will es so haben wie früher oder so, weil ich

00:10:09.700 --> 00:10:11.440
veränderungsresistent bin oder so.

00:10:11.900 --> 00:10:13.680
Und das ist aber dann

00:10:13.680 --> 00:10:15.640
mit Refactoring verbunden? Warum macht man das?

00:10:15.760 --> 00:10:17.560
Vielleicht, weil die Abteilung dann denkt so, okay, wir haben jetzt noch

00:10:17.560 --> 00:10:19.300
diesen Sprint, wir wollen nicht aufgelöst werden,

00:10:19.620 --> 00:10:21.860
wir wollen irgendwas machen und dann refactoren die da irgendwie rum.

00:10:22.260 --> 00:10:23.820
Ist halt eigentlich schon fertig, die Software.

00:10:24.160 --> 00:10:24.540
Und ja.

00:10:25.260 --> 00:10:27.360
Naja, du hast halt dann normalerweise irgendwelche Metriken,

00:10:27.540 --> 00:10:29.300
die halt an irgendeiner Stelle nicht so gut aussehen

00:10:29.300 --> 00:10:30.580
und dann machst du halt was, um das zu verbessern.

00:10:31.160 --> 00:10:33.500
Und manchmal wird das dann besser und manchmal wird das dann schlechter.

00:10:34.760 --> 00:10:35.700
Und dann nur schlechter

00:10:35.700 --> 00:10:37.140
für manche Leute und dann hast du halt

00:10:37.140 --> 00:10:38.000
vielleicht einfach Pech.

00:10:38.000 --> 00:10:38.460
Ja, genau.

00:10:39.220 --> 00:10:41.580
Naja, ist halt die Frage. Also ich meine, ja, man könnte auch sagen,

00:10:41.640 --> 00:10:42.640
Software ist irgendwann fertig.

00:10:43.520 --> 00:10:45.060
Also irgendwann ist halt der Wert,

00:10:45.160 --> 00:10:48.400
die neue Features bringen halt unter den Kosten,

00:10:48.700 --> 00:10:49.760
wenn du das halt priorisiert hast,

00:10:49.880 --> 00:10:53.760
nach irgendwie, was es reinkommt,

00:10:53.920 --> 00:10:55.660
irgendwie minus Kosten es zu entwickeln.

00:10:55.760 --> 00:10:56.580
Irgendwann wird das halt negativ.

00:10:57.000 --> 00:10:58.060
Und aus einer Business-Sicht

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

00:10:59.760 --> 00:10:59.920
Ja.

00:11:00.460 --> 00:11:01.900
Aber ja, ja, was stimmt?

00:11:02.040 --> 00:11:03.520
Mit diesem Schritt tun sich viele schwer.

00:11:03.740 --> 00:11:04.180
Ja, genau.

00:11:04.180 --> 00:11:05.740
Und dann wird er sagen, okay, gehen wir jetzt fertig,

00:11:05.860 --> 00:11:06.620
wir machen jetzt was anderes.

00:11:08.520 --> 00:11:09.140
Würde ich auch sagen,

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

00:11:10.520 --> 00:11:10.940
Und dann, na klar,

00:11:11.020 --> 00:11:11.800
kann man irgendwann in zehn Jahren

00:11:11.800 --> 00:11:12.880
nochmal einen Designer draufsetzen und sagen,

00:11:12.960 --> 00:11:14.660
hey, wir machen das ein bisschen moderner, aber dann

00:11:14.660 --> 00:11:16.740
muss die API vielleicht im Hintergrund, bleibt halt gleich.

00:11:17.280 --> 00:11:18.720
Und was ich aber als Entwickler jetzt auch

00:11:18.720 --> 00:11:20.700
sehr super finde, ist tatsächlich

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

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

00:11:25.220 --> 00:11:27.100
die ich neu mache, die kann ich vorher eigentlich

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

00:11:29.140 --> 00:11:30.980
und dann, aber wenn die neu sind, dann

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

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

00:11:34.800 --> 00:11:36.760
sehe ich halt immer, oh, auf dem Weg dahin

00:11:36.760 --> 00:11:38.780
bist du irgendwelche Sackkassen gelaufen,

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

00:11:40.920 --> 00:11:42.800
und hast voll irgendwas vergessen und das

00:11:42.800 --> 00:11:44.600
muss man dann nach und nach irgendwie einbauen. Aber das

00:11:44.600 --> 00:11:46.300
sorgfältig zu machen, das dauert halt viel mehr Zeit.

00:11:46.680 --> 00:11:48.640
Den ganzen Code kann man fast wieder neu schreiben und dann hat man

00:11:48.640 --> 00:11:49.860
am Ende was viel Schöneres da stehen.

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

00:11:52.740 --> 00:11:54.960
Und in einem halben Jahr später

00:11:54.960 --> 00:11:56.740
fasse ich es wieder an und es ist wieder irgendwie so.

00:11:56.980 --> 00:11:58.460
Ich denke, ah, das hättest du irgendwie schöner machen können.

00:11:59.580 --> 00:12:00.180
Also ich habe,

00:12:00.260 --> 00:12:02.760
ich kann das ja gleich mal direkt schon mal

00:12:02.760 --> 00:12:04.040
spoilern. Ich habe so ein Buch gelesen,

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

00:12:04.980 --> 00:12:08.580
A Philosophy of Software Design von

00:12:08.580 --> 00:12:10.580
John Osterhut oder so.

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

00:12:12.800 --> 00:12:14.140
Das wurde mir empfohlen

00:12:14.140 --> 00:12:16.800
in der Hacker-News-Diskussion

00:12:16.800 --> 00:12:18.400
und deswegen werde ich jetzt ganz viel daraus

00:12:18.400 --> 00:12:20.600
zitieren oder beziehungsweise Dinge

00:12:20.600 --> 00:12:22.600
sagen, die da drinstehen, weil ich davon jetzt noch

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

00:12:25.240 --> 00:12:26.940
Vielleicht habe ich jetzt schon eine ganze Menge vergessen.

00:12:28.080 --> 00:12:28.360
Aber

00:12:28.360 --> 00:12:30.740
da ist ein schöner Satz. Am Anfang steht

00:12:30.740 --> 00:12:32.640
da sowas wie, ja, also Software

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

00:12:34.740 --> 00:12:36.820
puresten, eine der

00:12:36.820 --> 00:12:38.700
reinsten kreativen Tätigkeiten,

00:12:39.080 --> 00:12:40.800
weil man halt nicht so...

00:12:40.800 --> 00:12:42.640
schaffen. Genau, weil man hat kaum

00:12:42.640 --> 00:12:44.860
Begrenzungen durch irgendwelche Dinge.

00:12:45.180 --> 00:12:46.760
Also alles, was man sich vorstellen kann, kann man

00:12:46.760 --> 00:12:48.340
im Grunde machen. Deswegen ist es halt sehr rein.

00:12:49.000 --> 00:12:49.800
Man ist nicht

00:12:49.800 --> 00:12:51.820
abhängig von irgendwelchen Dingen.

00:12:53.980 --> 00:12:54.340
Und

00:12:54.340 --> 00:12:56.660
da ist was dran. Ich weiß jetzt nicht, ob die meisten

00:12:56.660 --> 00:12:58.560
Leute das so sehen würden, aber das ist halt

00:12:58.560 --> 00:13:00.380
jetzt auch relativ weit auf der

00:13:00.380 --> 00:13:02.580
Entwicklerseite schon. Auf der Seite

00:13:02.580 --> 00:13:03.920
das ist halt

00:13:03.920 --> 00:13:06.680
ein Wert, wenn das schön ist.

00:13:07.060 --> 00:13:08.640
Sozusagen. Wenn es schön

00:13:08.640 --> 00:13:10.600
ist und rein ist und keine Ahnung, dann ist

00:13:10.600 --> 00:13:12.060
Ist das irgendwie eine wertvolle Geschichte?

00:13:12.660 --> 00:13:14.540
Und die andere Seite wäre halt, ist doch egal,

00:13:14.640 --> 00:13:16.560
Hauptsache es tut. Also Hauptsache die

00:13:16.560 --> 00:13:18.640
Features sind entwickelt und der Kunde ist glücklich

00:13:18.640 --> 00:13:20.740
und ich habe möglichst wenig Zeit dran im Rechner

00:13:20.740 --> 00:13:22.820
gesessen an der blöden Kiste, weil ich eine andere Sache machen kann.

00:13:23.060 --> 00:13:24.900
Der Product Owner hat es abgenommen

00:13:24.900 --> 00:13:26.720
und nach mir diesen Flut

00:13:26.720 --> 00:13:27.560
irgendwie so ein bisschen, also

00:13:27.560 --> 00:13:30.280
eher so ein pragmatischer Ansatz.

00:13:30.700 --> 00:13:33.140
Ich glaube, beide haben so eine gewisse

00:13:33.140 --> 00:13:34.400
Berechtigung.

00:13:34.540 --> 00:13:36.080
Ja, total. Also gerade wenn ich jetzt

00:13:36.080 --> 00:13:38.180
meinen Nutzen maximiere, dann will ich

00:13:38.180 --> 00:13:40.280
möglichst wenig Zeit am Rechner verbringen, weil ich ja

00:13:40.280 --> 00:13:42.380
damit mein Geld verdienen? Also, tu mir so, ich werde

00:13:42.380 --> 00:13:44.360
per Auftrag bezahlt oder sowas, ja? Dann würde ich

00:13:44.360 --> 00:13:46.360
möglichst wenig Zeit daran sitzen, weil ich möchte

00:13:46.360 --> 00:13:48.340
ja irgendwas andere Sachen machen. Und was dann

00:13:48.340 --> 00:13:50.100
unten drunter, wie das aussieht, ob es hübsch oder hässlich ist,

00:13:50.440 --> 00:13:52.380
ist einem dann völlig egal. Hauptsächlich sind sie schnell damit

00:13:52.380 --> 00:13:54.420
fertig und können das abhaken,

00:13:54.520 --> 00:13:56.380
den Auftrag erfüllt. Das sieht ja quasi

00:13:56.380 --> 00:13:58.380
der Manager eh nicht, weil der guckt ja eh nicht unter

00:13:58.380 --> 00:14:00.400
die Haube. Der guckt ja nur, was am Ende dabei rausfällt.

00:14:00.800 --> 00:14:01.860
Du zahlst es halt beim nächsten,

00:14:02.320 --> 00:14:03.860
bei der nächsten Aufgabe. Genau, aber

00:14:03.860 --> 00:14:06.380
das passiert mir egal. Und ob ich dann selber dann was Neues

00:14:06.380 --> 00:14:08.440
dranflatschen muss, kann ja sein. Also, man

00:14:08.440 --> 00:14:10.160
merkt es tatsächlich, aber erst, wenn man so Speed aufnimmt.

00:14:10.280 --> 00:14:17.500
Das heißt, wenn man das ordentlich macht, dann kann man diese Erweiterung, die Skalierung immer schneller machen und das Deliveren von neuen Sachen, wenn man es ordentlich gemacht hat, ist dann einfacher.

00:14:17.600 --> 00:14:22.840
Oder man kann halt Copy-Pasten aus dem anderen Projekt, wenn man es ordentlich gemacht hat und kann es ganz einfach auf die neuen Sachen generalisieren.

00:14:23.200 --> 00:14:28.020
Das sind halt aber so Sachen, die nicht ziehen, wenn man halt immer was anderes machen muss.

00:14:28.400 --> 00:14:45.140
Ja, sagen wir mal so, also der, wenn man jetzt rein aus der Business und auch aus der, sagen wir mal so, agilen Methodologie-Sicht da drauf guckt, dann ist der, es muss halt irgendwie funktionieren und ob das Feature fertig ist oder nicht, ist halt das, was man von außen sieht und das ist halt das Relevante.

00:14:45.560 --> 00:14:58.860
Das ist der deutlich dominantere, der deutlich dominantere Punkt, was halt dazu führt, dass der halt auch oft sehr stark betont wird in so, ja, kommerziellen Entwicklungen.

00:14:58.860 --> 00:15:26.740
Ja, ja, also der Manager, der interessiert sich nur für das KPI-Feature, fertig oder nicht, User-Story, das ist halt sehr atomar gesehen, also wenn man jetzt sagt, im Endeffekt, jedes Feature ist, also wenn man sich das wie so, weiß ich nicht, eine Menge von Commits im Branch oder sowas vorstellt, jedes Feature ist ja irgendwie ein Teil auf dieser Strecke zum Produkt, das irgendwann fertig oder irgendwann an einem Release-Punkt ist und wenn man das halt sehr atomar sieht, dann stimmt das natürlich, aber wenn man das halt über das große Ganze sieht, dann insbesondere bei langlaufenden Projekten, die halt wirklich konstant weiterentwickelt werden

00:15:27.020 --> 00:15:52.560
Und wo vielleicht dann auch irgendwie ein Geschäftsprozess oder irgendwas so wirklich dann Firmengeld drüber läuft, glaube ich, ist das halt viel zu kurz gedacht. Also ich kann da, 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 hinterhergelaufen generell.

00:15:52.560 --> 00:15:56.320
Backquote, ganz kurz, ist Anzahl an Bugs pro 100-Seilen-Code?

00:15:57.380 --> 00:16:00.340
Backquote ist quasi die Anzahl der Bug-Tickets an allen Tickets im Sprint.

00:16:00.420 --> 00:16:00.680
Ah, okay.

00:16:01.040 --> 00:16:05.380
Oder Bug-Story-Points auf die insgesamt Sprint-Story-Points gezogen, berechnet.

00:16:05.920 --> 00:16:08.980
Und das Team war halt latent frustriert.

00:16:10.380 --> 00:16:16.180
Der Product Owner hat so ein bisschen die Fähigkeit des Teams irgendwie angezweifelt,

00:16:16.220 --> 00:16:17.940
weil irgendwie da waren die Bugs und Sachen, die abgesprochen waren,

00:16:18.060 --> 00:16:18.900
haben dann plötzlich nicht mehr funktioniert.

00:16:18.900 --> 00:16:33.560
Das war halt insgesamt so eine latente Unmut auf allen Seiten. Es lief halt einfach nicht wirklich rund. Und dann haben die halt angefangen, halt so ein paar größere Sachen einfach mal anzugehen, weil dann war halt gerade so der eine große Release durch.

00:16:33.560 --> 00:17:01.240
Okay, wir machen irgendwie Coverage rein, also wir zwingen Coverage in der Pipeline, also sprich, neuer Code muss getestet sein, sonst kann ich nicht deployen, kann ich nicht, well, Commitment schon, aber nicht deployen, dann einfach mal geschaut, dass man einfach so Streamlining, wie kriegen wir alle möglichen Variablen beim Prot-Deployment, das immer wieder mal auf die Nase fällt, wie kriegen wir das raus und immer mehr solche Sachen halt, haben die halt dann angegangen und damit hat sich dann, also nicht nur, dass halt dann plötzlich die Backquote enorm gefallen ist,

00:17:01.240 --> 00:17:30.900
Also man glaubt nicht, was so ein simples Maß wie ich erzwinge Courage in der Pipeline, das ist so trivial, aber es hat total geholfen und auch die anderen Sachen und auf einmal hat sich dann, haben sie mir erzählt, einen ganz neuen Drive entwickelt, das ist echt faszinierend zu sehen gewesen und ja, da hätten die selber nicht drüber nachgedacht, dass das wirklich so einen großen Effekt haben kann, aber auf einmal ist auch so diese ganze Lethargie raus, wo man plötzlich mit hey cool, da geht was weiter, es klappt wieder, man hat plötzlich wieder auch Energie oder

00:17:31.240 --> 00:17:33.660
Musse, irgendwie Sachen anzupassen, zu refactoren,

00:17:34.060 --> 00:17:35.420
weil man halt eh das Gefühl hat, okay, es geht jetzt

00:17:35.420 --> 00:17:37.260
wieder nach oben. Wir versuchen nicht irgendwie dieses Haus

00:17:37.260 --> 00:17:39.360
immer so lange zusammenzuzimmern, dass es bloß

00:17:39.360 --> 00:17:41.180
nicht auseinanderfällt, sondern man macht halt wieder

00:17:41.180 --> 00:17:43.360
das Kreative, das Schöne halt.

00:17:45.220 --> 00:17:46.980
Ich finde das so ein bisschen schwierig,

00:17:47.860 --> 00:17:49.280
weil du hast auch was sehr Interessantes

00:17:49.280 --> 00:17:50.300
gesagt. Also, weil der,

00:17:51.300 --> 00:17:53.280
wenn es halt nur um diese User-Stories geht, ne, und

00:17:53.280 --> 00:17:55.360
dann möchtest du da irgendwas

00:17:55.360 --> 00:17:56.120
Schönes entwickeln,

00:17:56.860 --> 00:17:59.760
das funktioniert dann irgendwie, und dann hast du langfristig

00:17:59.760 --> 00:18:02.000
Ziele, die du erreichen kannst,

00:18:02.040 --> 00:18:03.840
wenn du am Anfang von Anfang an auf gute Qualität

00:18:03.840 --> 00:18:05.620
achtest oder halt viele Tests schreibst oder ein bisschen

00:18:05.620 --> 00:18:07.560
TDD machst, also je nachdem das, was so dein

00:18:07.560 --> 00:18:09.860
Overall Quality so ein bisschen, also wenn man ein bisschen mehr nachdenkt

00:18:09.860 --> 00:18:11.600
vielleicht am Anfang und ein bisschen mehr

00:18:11.600 --> 00:18:13.800
Know-how sich von Anfang an zum Holt, ist das glaube ich auch

00:18:13.800 --> 00:18:15.240
was, was dich langfristig austeilt, ja,

00:18:15.660 --> 00:18:17.660
weil man sich irgendwie alles von vorne neu machen muss.

00:18:19.260 --> 00:18:19.840
Aus Business-Sicht

00:18:19.840 --> 00:18:21.860
ist das aber so ein bisschen komisch, weil die, es ist eher so,

00:18:22.340 --> 00:18:23.740
die meckern immer die ganze Zeit rum, so, ah, warum läuft

00:18:23.740 --> 00:18:25.840
das denn noch nicht und warum sind da noch so viele Bugs und das verstehe ich alles nicht

00:18:25.840 --> 00:18:26.900
und es muss alles fertig sein und so,

00:18:27.480 --> 00:18:29.500
dann aber später sind die dann gewohnt, dass sie

00:18:29.500 --> 00:18:31.760
genauso viel Zeit und Geld aufwenden müssen für Neuentwicklung

00:18:31.760 --> 00:18:33.760
und du denkst so, ja, aber eigentlich ist das ja in zwei Tagen

00:18:33.760 --> 00:18:35.760
fertig, weil wir haben ja ordentlich

00:18:35.760 --> 00:18:37.720
am Anfang den Faktor und schön gemacht, das heißt, wenn man es richtig

00:18:37.720 --> 00:18:39.600
macht, könnte man die neuen Features alle direkt

00:18:39.600 --> 00:18:41.340
rausknallen, weil die super schnell gehen dann,

00:18:41.760 --> 00:18:43.660
aber das versteht dann keiner und das kann man auch nicht

00:18:43.660 --> 00:18:45.580
kommunizieren und ich sag mal, ist auch eher

00:18:45.580 --> 00:18:47.540
gefährlich, das zu kommen, weil dann so eine

00:18:47.540 --> 00:18:49.600
Erwartungshaltung entsteht, dass das halt immer

00:18:49.600 --> 00:18:51.560
so wäre und dass das auch

00:18:51.560 --> 00:18:53.280
nicht irgendwie clever dann vielleicht, ne, so

00:18:53.280 --> 00:18:55.480
für so ein ganzes Team. Ich glaube,

00:18:55.540 --> 00:18:59.920
Und da ist es halt super essentiell, dass man halt einfach eine gute Vertrauensbasis mit dem Product Owner hat.

00:19:00.800 --> 00:19:00.940
Tja.

00:19:02.160 --> 00:19:10.480
Genau, oder überhaupt diese Kommunikation zwischen irgendwie eben, ob das jetzt Product Owner ist oder, oft ist es ja so, der Product Owner ist ja noch so irgendwie quasi mehr oder weniger Teil des Teams.

00:19:10.800 --> 00:19:11.180
Ja, wäre gut.

00:19:11.180 --> 00:19:19.340
Genau, Product Owner und, also sagen wir mal Team irgendwie und dem Product Owner mit einem bezogen und halt irgendwie im weitesten Sinne das Management oder so.

00:19:19.420 --> 00:19:20.680
Wenn es da kein Vertrauen gibt, ist es schlecht.

00:19:20.840 --> 00:19:29.400
Ja, genau. Und auch ganz wichtig ist eigentlich, dass die Entwickler mit dem Kunden irgendwie eigentlich so viel zu tun haben oder mit dem Gedanken der User-Stories, dass sie halt da selber so committed drin sind auch.

00:19:29.400 --> 00:19:36.600
Weil wenn halt die immer nur irgendwie ihre Tickets wegschubsen, dann ist das dann irgendwann wurscht. Das ist halt genau so eine Kommunikationssache.

00:19:36.960 --> 00:19:45.500
Was der eigentliche Clou wäre, gutes Refactoring zu machen, von Anfang an das richtig zu tun, ist halt ein gutes Teamgespräch immer am Laufen zu halten, auch mit dem PO.

00:19:45.700 --> 00:19:48.660
Und zwar nicht nur über Tickets und Leistungen und KPIs, sondern halt auch …

00:19:48.660 --> 00:20:16.840
Aber tatsächlich, also ich meine, das ist halt auch das, also zu dem ganzen Agile-Kram gibt es halt auch einen kleinen Absatz in dem Buch, wo da halt so gesagt wird, ja, okay, Agile, voll gut, iterativ super, irgendwie, dass die Fachkompetenz nicht an den Reichen gekommen ist, also es gibt viele gute Sachen dabei, aber irgendwie, was nicht so toll ist, ist, dass diese ganzen Agile-Geschichten einen großen Wert auf diesen Was-bringt-es-fürs-Business-Punkt legen, was ja auch nicht unbedingt falsch ist,

00:20:16.840 --> 00:20:40.840
aber sozusagen sie tendieren dazu, das deutlich überzubetonen, weil es gibt halt auch diesen anderen Punkt, ist das denn jetzt gut designt zum Beispiel, ist das denn schön, ist das denn mit der geringstmöglichen Komplexität irgendwie gebaut worden und da gibt es jedenfalls auch meiner Ansicht nach nichts in dem, zum Beispiel bei Scrum, was eine Rolle, die dafür zuständig wäre, das durchzusetzen.

00:20:42.000 --> 00:20:43.280
Simpeles Better than Complex, ne?

00:20:43.440 --> 00:20:43.800
Ja, genau.

00:20:43.800 --> 00:20:46.120
Du kriegst halt, wenn das durch die Review

00:20:46.120 --> 00:20:48.180
beim Produkt-Oner, der da aber nicht aus einer technischen Perspektive

00:20:48.180 --> 00:20:50.220
drauf guckt, sondern aus einer Business-Perspektive

00:20:50.220 --> 00:20:51.540
durchgeht, dann ist das ja gut.

00:20:51.940 --> 00:20:53.720
Und das Team ist halt, wird immer dazu gesagt,

00:20:53.800 --> 00:20:56.020
ist dafür verantwortlich, dass halt das fertig sein muss,

00:20:56.080 --> 00:20:57.880
getestet sein muss und, aber

00:20:57.880 --> 00:20:59.980
tatsächlich, es gibt niemanden,

00:21:00.100 --> 00:21:01.920
der dann sagen kann, okay, das lasse ich nicht live gehen,

00:21:01.980 --> 00:21:03.040
das geht so nicht, das ist Kacke.

00:21:03.900 --> 00:21:05.580
Ich habe aber super Lust, bitte,

00:21:05.740 --> 00:21:08.020
Red zu Ende, dann. Ja, und das gibt's

00:21:08.020 --> 00:21:09.920
halt nicht und das ist halt etwas, was so ein bisschen

00:21:09.920 --> 00:21:11.920
fehlt und was man, wo man sagen

00:21:11.920 --> 00:21:13.960
würde, okay, aus der taktischen

00:21:13.960 --> 00:21:15.840
Perspektive ist das irgendwie, also es führt halt

00:21:15.840 --> 00:21:17.780
sehr, das Buch sagt, es gibt halt Unterschied

00:21:17.780 --> 00:21:19.580
zwischen taktischer Softwareentwicklung und

00:21:19.580 --> 00:21:21.700
strategischer und taktisch macht das

00:21:21.700 --> 00:21:23.680
irgendwie Sinn, die Features rauszukriegen, ja, und man

00:21:23.680 --> 00:21:25.180
hat halt auch ein Problem, wenn man das nicht hinkriegt,

00:21:25.720 --> 00:21:27.740
weil dann wird einem ja möglicherweise auch der Hahn zugedreht

00:21:27.740 --> 00:21:29.620
irgendwann, wenn man auf Reflection nicht so lange

00:21:29.620 --> 00:21:31.700
dauert, aber man muss halt

00:21:31.700 --> 00:21:33.480
diese strategische Perspektive auch berücksichtigen, weil

00:21:33.480 --> 00:21:34.980
ansonsten hat man halt irgendwann später ein Problem.

00:21:35.540 --> 00:21:37.640
Und diese Dinger summieren

00:21:37.640 --> 00:21:39.560
sich halt auf und machen Sachen halt am Schluss

00:21:39.560 --> 00:21:41.820
sehr, sehr teuer, um unerwarteter

00:21:41.820 --> 00:21:42.620
Weise auch, ja.

00:21:43.980 --> 00:21:45.820
Und ich würde jetzt sagen, so Refractoring ist halt

00:21:45.820 --> 00:21:47.640
auch so ein Ding, was halt im Grunde dafür da ist,

00:21:47.680 --> 00:21:49.620
die Komplexität von

00:21:49.620 --> 00:21:51.580
so einem Software-System halt zu reduzieren.

00:21:51.740 --> 00:21:53.640
Das wäre so, würde ich denken, das wäre ein Ziel.

00:21:54.020 --> 00:21:54.100
Ja.

00:21:56.160 --> 00:21:57.960
Wenn die Frage, was ist Komplexität? Komplexität

00:21:57.960 --> 00:21:59.780
würde ich jetzt auch so mal definieren, wie es in dem

00:21:59.780 --> 00:22:01.380
Buch wurde, dass er pragmatisch definiert als

00:22:01.380 --> 00:22:03.040
alles, was dazu führt,

00:22:03.240 --> 00:22:05.840
dass ein System schwerer zu ändern ist

00:22:05.840 --> 00:22:07.700
beziehungsweise dazu führt, dass man es nicht

00:22:07.700 --> 00:22:09.520
so gut verstehen kann, ist Komplexität.

00:22:09.980 --> 00:22:11.860
Also entweder Abhängigkeiten

00:22:11.860 --> 00:22:13.740
oder zu hohe Abstraktionsniveaus

00:22:13.740 --> 00:22:15.580
oder zu verschachtelte Namen, falsche Namen.

00:22:15.680 --> 00:22:17.740
Also ich finde, das ist relativ nah an diesem

00:22:17.740 --> 00:22:19.420
Code-Review-Gedanken dran.

00:22:20.140 --> 00:22:22.040
Ja, also kann ich den Code gut lesen?

00:22:22.500 --> 00:22:23.840
Sind die Namen so, wie ich sie

00:22:23.840 --> 00:22:25.960
haben will? Ist die Dokumentation schön?

00:22:26.540 --> 00:22:27.360
Sind halt die

00:22:27.360 --> 00:22:29.720
Designs so implementiert, wie man

00:22:29.720 --> 00:22:31.180
es erwarten würde vielleicht? Oder

00:22:31.180 --> 00:22:33.340
ist das irgendwas ganz anderes? Oder

00:22:33.340 --> 00:22:34.980
macht das Sinn?

00:22:37.260 --> 00:22:37.680
Auch ein bisschen

00:22:37.680 --> 00:22:39.480
Style? Ist das auch eine Frage? Du hast irgendwie,

00:22:39.540 --> 00:22:41.520
Er sagt, du wolltest den Unterschied zwischen Design und Style

00:22:41.520 --> 00:22:43.660
an der Stelle vielleicht erklären, was Design

00:22:43.660 --> 00:22:44.180
gemeint ist.

00:22:45.480 --> 00:22:47.460
Design ist tatsächlich, damit ist tatsächlich

00:22:47.460 --> 00:22:49.440
das quasi, wie funktioniert

00:22:49.440 --> 00:22:51.480
das System gemeint? Nicht so sehr, wie sieht's

00:22:51.480 --> 00:22:53.540
aus oder wie sieht der Code aus?

00:22:53.700 --> 00:22:55.140
Das ist alles nicht so, sondern eher wie

00:22:55.140 --> 00:22:56.560
funktionieren die Teile

00:22:56.560 --> 00:22:59.400
miteinander? Also tatsächlich so Pattern?

00:23:00.560 --> 00:23:00.800
Nee,

00:23:01.820 --> 00:23:03.520
also wie ist, also du hast

00:23:03.520 --> 00:23:05.420
ja, also ich meine, nimm mal sowas wie Design

00:23:05.420 --> 00:23:07.500
Patterns, da sieht man vielleicht, was damit gemeint ist.

00:23:07.740 --> 00:23:09.140
Ja. Das ist halt so,

00:23:09.540 --> 00:23:12.000
Das ist halt die Art, wie dein System

00:23:12.000 --> 00:23:12.620
designt ist.

00:23:14.360 --> 00:23:16.040
Also da gibt es mittlerweile

00:23:16.040 --> 00:23:16.940
so ein paar logische

00:23:16.940 --> 00:23:20.000
Strukturen, an denen man

00:23:20.000 --> 00:23:21.780
sich orientieren kann für Lösungen von

00:23:21.780 --> 00:23:24.060
bestimmten Problemen. Genau, aber

00:23:24.060 --> 00:23:25.720
man kann natürlich auch selber was machen, außer wenn man

00:23:25.720 --> 00:23:27.980
irgendwas tut. Ich meine, es ist ja die Frage, ob man sich an diese

00:23:27.980 --> 00:23:29.700
Patterns hält oder nicht oder die benutzt.

00:23:30.140 --> 00:23:31.540
Aber man hat auf jeden Fall hinterher ein Design.

00:23:31.560 --> 00:23:34.080
Interessant wäre, dass wenn man selber was baut, wo man keine Ahnung hat

00:23:34.080 --> 00:23:35.900
und dann immer mehr Ahnung davon bekommt und das dann

00:23:35.900 --> 00:23:37.880
refactored, ohne mal, dass man jetzt die Pattern kennt, ob

00:23:37.880 --> 00:23:39.980
jetzt die Lösung, die man hat, selber Richtung dieser Pattern

00:23:39.980 --> 00:23:41.920
konvergiert. Ja, genau, Design-Pattern, das ist genau

00:23:41.920 --> 00:23:43.880
das, worauf es dann halt irgendwie immer hinausläuft, genau.

00:23:44.040 --> 00:23:45.140
Das ist eigentlich die Idee dabei, ja.

00:23:46.920 --> 00:23:48.040
Ich wollte noch gerade eine Sache

00:23:48.040 --> 00:23:50.060
einwerfen zu der Sache mit der fehlenden

00:23:50.060 --> 00:23:50.700
Rolle im Scrum.

00:23:52.340 --> 00:23:53.940
Das ist auch eine Sache, über die ich jetzt in letzter

00:23:53.940 --> 00:23:55.900
Zeit relativ viel nachgedacht

00:23:55.900 --> 00:23:57.940
habe, weil wir ja auch

00:23:57.940 --> 00:23:59.660
ganz viele Scrum-Teams haben und im Endeffekt

00:23:59.660 --> 00:24:01.860
es ist natürlich schon so, dass

00:24:01.860 --> 00:24:04.020
wenn du einen guten Entwickler hast, dass der natürlich schon irgendwie

00:24:04.020 --> 00:24:05.860
darauf achten sollte, dass der

00:24:05.860 --> 00:24:07.800
jetzt irgendwie gute Arbeit abliefert. Das ist ja schon irgendwie auch

00:24:07.800 --> 00:24:09.860
Teil des Jobs. Aber diese

00:24:09.860 --> 00:24:11.900
Sache, dass man halt so eine Ebene höher denkt,

00:24:12.000 --> 00:24:13.820
dass man überlegt, okay, wann

00:24:13.820 --> 00:24:15.600
ist denn jetzt der Zeitpunkt gekommen, dass ich jetzt nicht das

00:24:15.600 --> 00:24:17.940
18. Feature noch da reinbauen kann, sondern dass ich es halt mal irgendwie

00:24:17.940 --> 00:24:19.880
besser refactoren muss,

00:24:19.940 --> 00:24:21.520
umstrukturieren muss. Oder

00:24:21.520 --> 00:24:23.600
zu überlegen, wie setze ich denn jetzt

00:24:23.600 --> 00:24:25.840
die Sachen so um, dass es in einem Jahr auch noch

00:24:25.840 --> 00:24:27.740
funktioniert. Das sind ja Sachen, die stehen ja nicht

00:24:27.740 --> 00:24:29.740
in der User-Story drin, die stehen nicht mehr in den Epics drin.

00:24:29.860 --> 00:24:31.980
Der Product Owner hat davon keine Ahnung,

00:24:32.040 --> 00:24:33.140
weil er ja kein Techniker ist.

00:24:33.660 --> 00:24:35.780
Der Scrum Master ist

00:24:35.780 --> 00:24:37.540
vielleicht Techniker, aber vielleicht auch nicht.

00:24:37.800 --> 00:24:47.160
Das heißt, der kann es auch nicht beurteilen. Dann hast du ein Team, das ja meistens gemischt aus Seniors und Juniors ist. Bei den Juniors kann man es eigentlich nicht erwarten, dass jemand, der ganz frisch im Job ist, schon irgendwie drei Jahre im Voraus denkt.

00:24:48.540 --> 00:25:05.480
Und es gibt tatsächlich auch super viele Artikel dazu im Internet, die genau versuchen, diese Idee des IT-Architekten aus dem klassischen Wasserfall irgendwie in dieses, ich habe jetzt ein Gänsefüßchen gesagt, IT-Architekt, das irgendwie in dieses Scrum reinzubringen.

00:25:05.480 --> 00:25:32.180
Und da gibt es halt auch wirklich lange Artikel und so dazu, wo halt wirklich dafür auch gesagt wird, dass man das braucht, wie du es gerade auch gesagt hast. Und das ist auf jeden Fall ein Muss. Und dann gibt es Artikel, die sagen, nein, braucht man nicht, weil und so weiter. Und ich glaube, dass die Wahrheit liegt wie immer dazwischen. Und ich glaube, eine Sache, die im Scrum nicht vorgesehen ist, aber eine Lösung dafür könnte sein, halt jemand, der sich halt, sage ich mal so, als Lead-Entwickler im Team sieht. Das ist im Scrum ja explizit eigentlich nicht gewünscht, weil ja alle gleich sind. Ja, und alle haben gleich die Verantwortung. Aber ich glaube, so zumindest, soweit man das gedacht hat.

00:25:32.180 --> 00:25:33.320
Sonst sind die Teams ja auch immer nicht, ne?

00:25:33.620 --> 00:25:48.020
Genau, aber ich glaube, wenn du jemanden hast, der sich dafür verantwortlich fühlt und der das technische Know-how hat und wie gesagt, wichtig 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ücke schon ganz gut überspannen, also diese Brücke spannen.

00:25:48.020 --> 00:26:00.560
Und wenn der PO dieser Person auch vertraut und wenn die Person sagt, nee, sorry, aber wir müssen das Technik-Ticket 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:00.580 --> 00:26:04.780
reden, wie immer. Aber du hast gerade vom klassischen Wasserfall-Software

00:26:04.780 --> 00:26:06.760
Architekten gesprochen, den musst du vielleicht nochmal kurz erklären, weil

00:26:06.760 --> 00:26:08.140
den kennt vielleicht auch nicht jeder.

00:26:09.160 --> 00:26:10.640
Also ich bin da jetzt auch kein Experte,

00:26:10.740 --> 00:26:13.040
ich bin auch mit agiler Entwicklung

00:26:13.040 --> 00:26:14.280
nicht aufgewachsen, aber schon die,

00:26:15.280 --> 00:26:17.000
wir haben nie wirklich nach klassisch Wasserfall

00:26:17.000 --> 00:26:17.480
gearbeitet.

00:26:18.660 --> 00:26:20.460
Die Idee dahinter ist eigentlich, dass ein

00:26:20.460 --> 00:26:21.840
T-Architekt, der

00:26:21.840 --> 00:26:24.960
im Agilen ist es ja, dass man iterativ

00:26:24.960 --> 00:26:27.020
und kleinteilig arbeitet und im Wasserfall

00:26:27.020 --> 00:26:28.960
ist die Idee, dass man am Anfang alle Informationen,

00:26:28.960 --> 00:26:31.100
die man hat, sammelt. 80% Planung

00:26:31.100 --> 00:26:32.960
und dann wird umgesetzt. Genau und also darum auch

00:26:32.960 --> 00:26:34.920
Wasserfall, du fängst halt quasi oben an und danach geht das

00:26:34.920 --> 00:26:36.860
diese Stufen einfach immer runter und am Schluss kommt halt

00:26:36.860 --> 00:26:38.640
in Gänsefüßchen eine fertige Software raus

00:26:38.640 --> 00:26:41.020
und da sind halt einfach ganz viele Probleme, weil

00:26:41.020 --> 00:26:42.900
wie gesagt, Software ist nie fertig

00:26:42.900 --> 00:26:44.900
und Wasserfall macht auch keinen Sinn und

00:26:44.900 --> 00:26:46.620
der IT-Architekt ist halt derjenige,

00:26:47.140 --> 00:26:48.740
der unter anderem halt

00:26:48.740 --> 00:26:51.200
dieses Lasten- oder Pflichtenheft

00:26:51.200 --> 00:26:52.800
schreibt initial, also sprich,

00:26:52.860 --> 00:26:54.380
der sich überlegt. Das ist der Entwickler dann aber auch,

00:26:54.700 --> 00:26:56.580
der quasi der Entwickler ist, ein

00:26:56.580 --> 00:26:58.460
IT-Architekt in dem Falle und

00:26:58.460 --> 00:27:00.340
baut. Nicht zwingend, nicht zwingend, also

00:27:00.340 --> 00:27:02.580
ich glaube, es ist tatsächlich auch eine eigene Rolle,

00:27:02.960 --> 00:27:23.600
gewesen oder ist es noch, also je größer die Firma, umso mehr Rollen hast du da separat, logischerweise. Aber ich glaube, die Idee ist wirklich, das ist jemand, der gar kein zwingender Entwickler sein muss, der aber trotzdem halt technisches Know-how hat und der versucht, alle Abhängigkeit und Eventualitäten, die dieses System betrifft, also alles, was man an Setup, Surroundings und so weiter hat, alles bedenkt und das alles niederschreibt.

00:27:23.600 --> 00:27:25.480
Ja, dann braucht der eigentlich relativ viel Ahnung vom

00:27:25.480 --> 00:27:26.920
eigentlichen Business und vom Kunden.

00:27:27.880 --> 00:27:29.540
Und halt auch technisch. Das ist das Wichtige.

00:27:29.640 --> 00:27:31.560
Dass man zum Beispiel sagt, weiß ich nicht, wenn ich

00:27:31.560 --> 00:27:33.600
jetzt irgendwas habe mit asynchronen

00:27:33.600 --> 00:27:35.440
Prozessen und Mailing, dass ich halt sicherstelle,

00:27:35.560 --> 00:27:37.480
dass irgendwo drüber nachgedacht ist, dass ich irgendeine

00:27:37.480 --> 00:27:39.460
Art von asynchronen Processing auch drin habe und

00:27:39.460 --> 00:27:40.940
nicht, dass das halt dann nachher irgendwann auffällt.

00:27:41.060 --> 00:27:42.780
Ups, blöd. Wie machen wir das denn jetzt?

00:27:43.740 --> 00:27:44.620
Blöd gesprochen.

00:27:45.500 --> 00:27:46.660
Blockiert leider den Prozess.

00:27:48.080 --> 00:27:49.140
Ja, also genau.

00:27:49.240 --> 00:27:51.020
Software-Architektur ist natürlich auch so ein verwandtes Thema.

00:27:51.500 --> 00:27:54.040
ja, genau.

00:27:54.400 --> 00:27:55.040
Aber ja,

00:27:56.040 --> 00:27:57.780
wer ist dafür zuständig, gibt es dann meistens, also

00:27:57.780 --> 00:28:00.000
es kann sein, dass sie dann halt nicht

00:28:00.000 --> 00:28:01.800
in den Teams immer mit drin sind, sondern übergreifen.

00:28:01.880 --> 00:28:03.760
Die gucken sich das dann halt mal an und

00:28:03.760 --> 00:28:05.620
machen dann irgendwie Vorschläge oder so. Aber ja,

00:28:06.040 --> 00:28:07.800
es ist unterschiedlich, wie das

00:28:07.800 --> 00:28:09.840
gehandhabt wird, aber genau. Also, dass

00:28:09.840 --> 00:28:11.440
da irgendwie sich jemand drum kümmern müsste,

00:28:11.700 --> 00:28:13.520
ist eigentlich schon, glaube ich,

00:28:13.520 --> 00:28:14.740
relativ offensichtlich.

00:28:16.080 --> 00:28:17.760
Ja, aber was, was, genau,

00:28:17.920 --> 00:28:19.520
was, was, ähm,

00:28:19.680 --> 00:28:21.480
was denkt ihr denn so, genau, was

00:28:21.480 --> 00:28:24.680
macht man denn, wenn man versucht, so ein Software-System

00:28:24.680 --> 00:28:26.020
einfacher zu machen?

00:28:26.200 --> 00:28:27.260
Was könnte man denn da tun?

00:28:29.280 --> 00:28:30.260
Muss man das refactoren?

00:28:31.080 --> 00:28:32.240
Ja gut, Refactoring ist

00:28:32.240 --> 00:28:34.160
jetzt sozusagen das, was man dann tut, aber

00:28:34.160 --> 00:28:36.460
wenn man, was wäre

00:28:36.460 --> 00:28:38.140
denn das Ziel von so einem Refactoring,

00:28:38.280 --> 00:28:39.900
wenn es darum geht, die Komplexität zu senken?

00:28:43.560 --> 00:28:44.120
Also ich würde

00:28:44.120 --> 00:28:46.260
tatsächlich mit diesem Schönheitsansatz

00:28:46.260 --> 00:28:47.320
ausreden.

00:28:47.940 --> 00:28:48.720
Ja, das ist ein bisschen abstrakt.

00:28:50.460 --> 00:28:52.000
Wahrscheinlich wisst ihr alle, was man damit meint,

00:28:52.040 --> 00:28:53.440
wenn ihr schon mal ein bisschen guckgeschrieben habt.

00:28:53.700 --> 00:28:55.860
Kennt ihr was, was agil ist, was stinkt irgendwie?

00:28:55.980 --> 00:28:57.300
Oder was, wo ihr denkt, oh, das ist aber hübsch.

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

00:29:00.560 --> 00:29:01.760
ich habe das am Anfang nicht so richtig verstanden,

00:29:01.880 --> 00:29:03.140
ich werde vielleicht, geht es ja anderen Leuten auch so,

00:29:03.840 --> 00:29:05.640
immer wenn dann jemand draufgeguckt hat und meinte so,

00:29:05.880 --> 00:29:08.100
okay, vielleicht nicht so toll, dann hieß es immer so,

00:29:08.220 --> 00:29:11.160
ja, da muss man vielleicht mal so ein bisschen modularisieren oder so.

00:29:12.680 --> 00:29:13.960
Modularisierung, weiß nicht, ob euch das schon mal so,

00:29:14.440 --> 00:29:17.500
genau, da gibt es ein ganz berühmtes Paper von 1972, glaube ich, ist das,

00:29:19.240 --> 00:29:21.100
jetzt habe ich den Titel vergessen,

00:29:21.740 --> 00:29:23.120
naja, von David Parnas,

00:29:23.260 --> 00:29:25.480
genau, wo er zum ersten Mal

00:29:25.480 --> 00:29:26.480
diese Idee

00:29:26.480 --> 00:29:29.300
formuliert hat, dass, wenn du jetzt

00:29:29.300 --> 00:29:31.020
ein komplexes System hast,

00:29:31.580 --> 00:29:33.260
wo viele Abhängigkeiten sind oder so,

00:29:33.580 --> 00:29:35.320
dann ist es vielleicht eine gute Idee, das System so

00:29:35.320 --> 00:29:37.020
zu teilen, dass

00:29:37.020 --> 00:29:39.280
man nur noch einzelne Teile quasi

00:29:39.280 --> 00:29:40.800
verstehen muss und nicht alles auf einmal.

00:29:40.980 --> 00:29:42.960
Microservices. Und ja,

00:29:43.100 --> 00:29:45.260
wie man das dann macht, ist eigentlich relativ egal. Du kannst es mit

00:29:45.260 --> 00:29:47.380
Microservices machen, du kannst es aber auch

00:29:47.380 --> 00:29:49.080
mit Funktionen machen, mit Klassen,

00:29:49.240 --> 00:29:51.420
mit Modulen, Paketen, was auch

00:29:51.420 --> 00:29:53.320
immer. Völlig egal. Das ist letztlich

00:29:53.320 --> 00:29:55.180
nicht der wichtige Teil,

00:29:55.300 --> 00:29:57.220
sondern der wichtige Teil ist quasi

00:29:57.220 --> 00:29:59.180
kannst du

00:29:59.180 --> 00:30:00.920
dein System so aufteilen,

00:30:01.680 --> 00:30:01.760
dass

00:30:01.760 --> 00:30:05.520
sich die Komplexität deines Gesamtsystems

00:30:05.520 --> 00:30:07.360
reduziert auf die Komplexität

00:30:07.360 --> 00:30:08.240
des komplexesten

00:30:08.240 --> 00:30:10.340
Moduls sozusagen.

00:30:11.000 --> 00:30:13.320
Im Idealfall. Also weil zum Beispiel in Django

00:30:13.320 --> 00:30:15.260
gelingt es mir nicht immer, dass man so die Sachen

00:30:15.260 --> 00:30:17.440
voneinander trennt, weil viele Sachen sind von User's App abhängig

00:30:17.440 --> 00:30:19.380
oder sowas, das ist nicht so einfach,

00:30:19.480 --> 00:30:21.080
dass du irgendwie... Das ist nicht so einfach, das ist auch

00:30:21.080 --> 00:30:21.660
richtig, ja.

00:30:23.140 --> 00:30:25.280
Das ist genau das, ja, genau, ich wusste dann auch nicht so genau,

00:30:25.340 --> 00:30:27.200
was macht man denn dann da genau und so,

00:30:27.320 --> 00:30:29.480
das ist sehr schwierig, ja, ist es tatsächlich,

00:30:29.480 --> 00:30:31.560
ist auch sehr schwierig, finde ich immer noch

00:30:31.560 --> 00:30:33.420
schwierig, aber ja, also

00:30:33.420 --> 00:30:35.500
im Grunde ist das halt so die

00:30:35.500 --> 00:30:37.400
Idee, dass man das halt tatsächlich

00:30:37.400 --> 00:30:39.160
vielleicht irgendwie so hinbekommt

00:30:39.160 --> 00:30:40.660
und

00:30:40.660 --> 00:30:43.080
ja, das ist im Grunde auch,

00:30:43.480 --> 00:30:45.240
im Grunde jetzt rausfinden, wie sind diese Module

00:30:45.240 --> 00:30:47.380
und was soll damit was reden und wie sind die

00:30:47.380 --> 00:30:49.620
Interface ist, das ist eigentlich im Grunde das, was Software-Architektur

00:30:49.620 --> 00:30:51.520
macht, beziehungsweise was man halt auch

00:30:51.520 --> 00:30:53.460
macht, wenn man jetzt Design macht

00:30:53.460 --> 00:30:55.280
irgendwie. Also nochmal,

00:30:55.460 --> 00:30:57.500
Interface ist halt die Schnittstelle, quasi eine

00:30:57.500 --> 00:30:59.500
API, wo ein Modul mit dem anderen interagiert.

00:31:00.040 --> 00:31:01.520
Ja. Und dann muss man quasi

00:31:01.520 --> 00:31:03.480
definieren, welches Protokoll reden die miteinander und

00:31:03.480 --> 00:31:05.400
mit welchen Feldern und welchen

00:31:05.400 --> 00:31:07.620
Datentypen, welche wollen die denn haben.

00:31:07.680 --> 00:31:09.540
Und im Grunde ist,

00:31:09.740 --> 00:31:10.360
also das ist jetzt wieder,

00:31:11.280 --> 00:31:12.380
aus mir spricht dieses Buch,

00:31:14.080 --> 00:31:15.000
geht es da,

00:31:15.100 --> 00:31:16.940
ist der interessante Teil gar nicht da,

00:31:17.000 --> 00:31:18.380
wie man das jetzt technisch umsetzt oder so,

00:31:18.720 --> 00:31:20.720
sondern im Grunde ist

00:31:20.720 --> 00:31:22.120
die interessante Frage,

00:31:24.460 --> 00:31:24.780
naja,

00:31:25.000 --> 00:31:26.600
also man hat halt Abstraktionen.

00:31:26.680 --> 00:31:28.500
Also ein Modul ist ja auch so eine Abstraktion

00:31:28.500 --> 00:31:30.620
und eine Abstraktion hat immer

00:31:30.620 --> 00:31:32.320
das Ziel, dass

00:31:32.320 --> 00:31:34.820
man etwas,

00:31:35.700 --> 00:31:36.580
also quasi nur

00:31:36.580 --> 00:31:38.260
einen bestimmten Aspekt von etwas

00:31:38.260 --> 00:31:40.100
tatsächlich wissen muss und

00:31:40.100 --> 00:31:42.200
die ganze Komplexität dahinter ist halt versteckt.

00:31:42.900 --> 00:31:44.680
Und deswegen hat man diese Abstraktion

00:31:44.680 --> 00:31:46.460
und wenn die Abstraktion gut ist, dann

00:31:46.460 --> 00:31:48.440
muss man den Rest auch nicht wissen.

00:31:48.880 --> 00:31:50.840
Oder meistens nicht wissen. Wenn die Abstraktion

00:31:50.840 --> 00:31:52.620
schlecht ist, dann liegt die halt

00:31:52.620 --> 00:31:54.760
und dann muss man daran doch wissen und das ist dann schlecht.

00:31:55.280 --> 00:31:56.620
Aber wenn man eine gute Abstraktion

00:31:56.620 --> 00:31:57.980
gefunden hat, dann

00:31:57.980 --> 00:32:00.720
braucht man sich sozusagen mental

00:32:00.720 --> 00:32:02.700
nur mit dieser Abstraktion beschäftigen und gar nicht wissen,

00:32:02.780 --> 00:32:04.320
wie das im Detail alles funktioniert. Zum Beispiel Python.

00:32:05.620 --> 00:32:06.680
Ja, also eine Sprache,

00:32:06.760 --> 00:32:08.240
die so ein relativ hohes Abstraktionslevel hat,

00:32:08.240 --> 00:32:09.940
hat vielleicht auch schon über viele Probleme.

00:32:10.140 --> 00:32:11.960
Also das ist ja vielleicht auch der Grund, warum wir sowas benutzen

00:32:11.960 --> 00:32:14.100
und nicht mehr so alles in C schreiben oder so.

00:32:14.360 --> 00:32:21.140
Ja, natürlich. Also, obwohl C ist ja auch eine High-Level-Language schon, im Gegensatz zum Zabler.

00:32:21.300 --> 00:32:26.020
Ja, gut. Dass wir jetzt nicht mehr in Registern rumspringen wollen, wenn wir irgendwie ein Web-Service schreiben, ist ja schon mal gar nicht so schlecht vielleicht.

00:32:26.020 --> 00:32:27.420
Ja, C ist ja schon eine Hochsprache.

00:32:28.940 --> 00:32:35.020
Ich habe da tatsächlich ein ganz schönes Beispiel. Ich hatte letztens eine sehr undankbare Aufgabe.

00:32:35.780 --> 00:32:51.260
Es sollte in einem Projekt, sollte ich bei, also quasi eine Sache, die sich durch das gesamte System gezogen hat, das hat relativ viel mit Zeitberechnung zu tun, also wo irgendwelche Tage und irgendwelche Uhrzeiten Tage berechnet werden.

00:32:51.480 --> 00:33:00.720
Da sollte eine Sache, die vorher statisch war, also es gab halt im Endeffekt nur Tage, sollten diese Tage dann nach Regionen aufgeteilt werden.

00:33:00.840 --> 00:33:09.480
Also jetzt beispielsweise halt Feiertage, die halt jetzt nicht nur irgendwie, es gibt nicht fixe Feiertage, sondern es gibt halt die Feiertage je nachdem, wo halt jemand dann ist, also wie ein Zeitberechnungssystem.

00:33:10.440 --> 00:33:19.620
Und das hat halt wirklich querbeet eigentlich alle Bereiche des Systems betroffen, weil vorher war es halt einfach, du machst halt einen Abfall in die Datenbank, ist an diesem Tag ein Feiertag fertig.

00:33:19.920 --> 00:33:27.220
Danach musste aber gefragt werden, na gut, welche Leute betrachte ich denn gerade, ob jetzt Feiertage sind und wann haben die denn in dieser Region gewohnt und wann nicht mehr.

00:33:27.320 --> 00:33:36.820
Und auf einmal wurde das halt, war es halt super kompliziert, eine Sache, die vorher halt wirklich trivial war, wie die mit einem einzigen Select oder ORM, Abstraktion Select, halt super einfach abzufragen war.

00:33:37.980 --> 00:33:44.900
Und dann habe ich halt auch lange darüber nachgedacht, wie ich das überhaupt hinbekomme, weil, wie gesagt, ich habe nachher, glaube ich, an 300 Stellen im System irgendwas angepasst.

00:33:45.600 --> 00:33:49.500
Und die Lösung war tatsächlich dann ganz, ganz blöd Abstraktion.

00:33:49.840 --> 00:34:18.340
Also sprich, jetzt war halt ein Django-Projekt, ich habe dann einfach mir Custom Query Set und Manager-Methoden geschrieben, die das halt komplett wegkapseln, wo ich dann trotzdem einfach nur das Datum und vielleicht noch den Nutzer reingebe und darunter liegt dann halt irgendwie ein Riesenapparat mit irgendwas, da halt alles dann passiert, um das halt zu bestimmen, aber von oben verwendet es sich fast genauso wie die triviale Datenbankabfrage und damit habe ich es wirklich geschafft, also ich habe das quasi das ganze Ding umgebaut, ist ja auch irgendeine Art von Refactoring eigentlich,

00:34:18.340 --> 00:34:20.100
nur, dass es halt in dem Moment das Ticket war.

00:34:21.040 --> 00:34:22.300
Und ich habe wirklich nur drei oder

00:34:22.300 --> 00:34:24.240
vier kleine Bugs gehabt, weil halt

00:34:24.240 --> 00:34:26.260
wie gesagt, die ganze Komplexität an einer einzigen

00:34:26.260 --> 00:34:28.000
Stelle war und ich halt danach nur noch schauen musste,

00:34:28.000 --> 00:34:30.280
dass ich halt die Methoden austausche.

00:34:30.640 --> 00:34:32.140
Und das war, es hat

00:34:32.140 --> 00:34:34.100
mich selbst total überrascht, wie gut das funktioniert hat.

00:34:34.200 --> 00:34:36.280
Also das hätte ich mir selbst nicht zugetraut,

00:34:36.340 --> 00:34:38.000
dass die Idee dann doch so gut trägt.

00:34:39.180 --> 00:34:39.300
Ja.

00:34:42.920 --> 00:34:43.280
Ja.

00:34:44.240 --> 00:34:45.900
Wenn man so eine High-Level-App hier hat, die man

00:34:45.900 --> 00:34:47.360
gut bedienen kann, dann ist das schon echt was wert.

00:34:47.600 --> 00:34:49.860
Ja, also genau, und was sind

00:34:49.860 --> 00:34:51.440
gute Abstraktionen? Also

00:34:51.440 --> 00:34:53.720
nach dem Buch ist es halt so,

00:34:54.000 --> 00:34:55.900
ja, wenn Module tief sind,

00:34:55.980 --> 00:34:58.040
ist das gut und wenn die

00:34:58.040 --> 00:34:59.860
API halt klein ist, ist das auch gut.

00:34:59.960 --> 00:35:01.280
Also je kleiner die API und tiefer,

00:35:01.620 --> 00:35:04.340
je kleiner und tiefer, desto besser. Genau, du kannst mit einfachen

00:35:04.340 --> 00:35:05.620
Worten viel erreichen.

00:35:06.220 --> 00:35:07.740
Ja, also als sozusagen Beispiel

00:35:07.740 --> 00:35:09.620
für, das ist

00:35:09.620 --> 00:35:11.340
irgendwie eine schöne API, ist halt

00:35:11.340 --> 00:35:13.840
die File

00:35:13.840 --> 00:35:15.940
API von Unix benutzt, das ist halt auch tatsächlich

00:35:15.940 --> 00:35:17.780
eine sehr schöne, also das ist ja im Grunde

00:35:17.780 --> 00:35:18.340
Unix ist nichts,

00:35:19.540 --> 00:35:21.760
wir hatten das letztes Mal, in der letzten Episode,

00:35:21.920 --> 00:35:23.940
was wenn alles ein Dict wäre, Unix ist halt

00:35:23.940 --> 00:35:25.740
so, was wenn alles ein Pfeil wäre.

00:35:26.180 --> 00:35:27.620
Das ist irgendwie die Antwort darauf.

00:35:27.900 --> 00:35:29.380
Dann fällt halt Unix dabei raus.

00:35:30.620 --> 00:35:31.940
Und die Pfeil-API ist

00:35:31.940 --> 00:35:33.920
halt tatsächlich, die ist halt sehr, also man kann

00:35:33.920 --> 00:35:35.600
nicht, es gibt nicht viele Obterationen, die man machen kann.

00:35:35.740 --> 00:35:37.380
Also was heißt denn Open, Seek

00:35:37.380 --> 00:35:38.780
und Close?

00:35:39.440 --> 00:35:41.760
Es gibt Open, Seek

00:35:41.760 --> 00:35:43.400
und das war es eigentlich schon fast, ja.

00:35:43.700 --> 00:35:45.660
Also Close, weiß ich gar nicht, ob das ein eigener, ja doch.

00:35:45.940 --> 00:35:47.580
wahrscheinlich. Ja, aber stimmt.

00:35:48.200 --> 00:35:49.580
Genau. Und

00:35:49.580 --> 00:35:51.720
ja, es gibt noch I.O. Control,

00:35:52.160 --> 00:35:54.020
aber... Also wahrscheinlich Read&Write oder so, aber ja.

00:35:54.180 --> 00:35:55.860
Was ist I.O. Control? Ja, ja, man kann

00:35:55.860 --> 00:35:57.840
jetzt noch Spezialoperationen machen, da wird's dann auch

00:35:57.840 --> 00:35:59.760
allmählich hässlich. Aber

00:35:59.760 --> 00:36:01.800
tatsächlich eigentlich so mit Pfeil

00:36:01.800 --> 00:36:03.360
aufmachen, irgendwie drin rumzieken,

00:36:03.780 --> 00:36:04.980
lesen, schreiben,

00:36:05.760 --> 00:36:07.240
kommt man halt schon sehr, sehr weit.

00:36:08.580 --> 00:36:09.900
Und ja,

00:36:09.900 --> 00:36:11.780
das ist halt eine schöne Abstraktion, während

00:36:11.780 --> 00:36:12.720
zum Beispiel die

00:36:12.720 --> 00:36:15.940
Abstraktionen, das ist dann so ein Negativbeispiel

00:36:15.940 --> 00:36:17.740
gewesen, halt so, wenn man jetzt

00:36:17.740 --> 00:36:19.040
in Java irgendwie

00:36:19.040 --> 00:36:21.780
Dinge lesen will aus einem File, dann macht man

00:36:21.780 --> 00:36:23.780
erstmal irgendwie so einen Input-Reader

00:36:23.780 --> 00:36:25.720
auf und dann macht man so einen Buffered-Input-Reader auf,

00:36:25.760 --> 00:36:27.700
wenn man das vergisst, hat man ein Problem, das ist alles ganz langsam,

00:36:27.820 --> 00:36:29.560
man weiß nicht so genau warum und dann muss man die

00:36:29.560 --> 00:36:31.580
Dinger konfigurieren und die Exposen halt ganz

00:36:31.580 --> 00:36:33.620
viele Sachen, die man halt setzen muss und der

00:36:33.620 --> 00:36:35.660
Default-File ist halt, den man halt eigentlich

00:36:35.660 --> 00:36:36.820
immer hat, der ist halt nicht der,

00:36:37.600 --> 00:36:39.380
also wenn man es einfach nur so aufmacht, ein File, dann

00:36:39.380 --> 00:36:41.180
hat man halt keine

00:36:41.180 --> 00:36:43.180
gebufferte I.O. und das ist halt alles

00:36:43.180 --> 00:36:45.240
ganz schrecklich. Und man muss

00:36:45.240 --> 00:36:47.220
halt sehr, sehr viel Detailwissen in der

00:36:47.220 --> 00:36:49.040
API schon, also man konfiguriert

00:36:49.040 --> 00:36:51.160
da schon sehr viel rum und also

00:36:51.160 --> 00:36:53.280
man hat halt, die API hat eine große Oberfläche und

00:36:53.280 --> 00:36:55.260
es ist schwer zu benutzen

00:36:55.260 --> 00:36:57.200
und eigentlich, was sie macht, ist relativ

00:36:57.200 --> 00:36:58.880
trivial. Also es ist super flach.

00:36:58.900 --> 00:37:00.860
Also sowas wie in Python, with open

00:37:00.860 --> 00:37:02.980
filename is file, file.read.

00:37:04.040 --> 00:37:05.040
Genau, oder ja,

00:37:05.140 --> 00:37:06.680
for line and file oder sowas.

00:37:06.820 --> 00:37:08.980
Das ist halt irgendwie, und das macht halt

00:37:08.980 --> 00:37:10.720
auch bei der Default alles richtig.

00:37:11.180 --> 00:37:12.840
Wenn du das in Python machst, dann ist das halt direkt

00:37:12.840 --> 00:37:14.840
schnell und macht alles schon so, wie man

00:37:14.840 --> 00:37:16.680
das eigentlich normalerweise haben will. Für die Fälle,

00:37:16.780 --> 00:37:18.300
in denen man das nicht so haben will, kann man das ja immer noch

00:37:18.300 --> 00:37:20.840
konfigurieren, dass es sich

00:37:20.840 --> 00:37:22.780
anders verhält. Aber genau.

00:37:22.920 --> 00:37:24.780
Und das ist halt gutes versus schlechtes

00:37:24.780 --> 00:37:25.560
API-Design quasi.

00:37:27.300 --> 00:37:28.580
Und ja.

00:37:29.520 --> 00:37:30.900
Aber die richtige

00:37:30.900 --> 00:37:32.640
API für ein Problem, das man hat, oder

00:37:32.640 --> 00:37:34.600
überhaupt die richtige Abstraktion zu finden, ist natürlich

00:37:34.600 --> 00:37:36.240
nicht so einfach. Das ist halt richtig schwierig.

00:37:37.080 --> 00:37:38.700
Vielleicht auch einer der Gründe für PHP, warum das

00:37:38.700 --> 00:37:40.720
immer so schlecht angesehen wird an so zwei Stellen

00:37:40.720 --> 00:37:42.740
sich lange brauchte, bis es ein bisschen besser wurde.

00:37:42.840 --> 00:37:44.820
Also wie gesagt, ich habe immer noch keine Ahnung davon. Aber ist das

00:37:44.820 --> 00:37:46.940
einer der Erfinder, der irgendwie gesagt hat am Anfang so, ja, eigentlich

00:37:46.940 --> 00:37:48.940
kenne ich mich mit Programmiersprachen eigentlich gar nicht aus

00:37:48.940 --> 00:37:50.920
und ich wollte eigentlich auch nie Sprache machen. Aber hey,

00:37:50.980 --> 00:37:52.700
jetzt bin ich hier irgendwie und wir müssen jetzt irgendwie das

00:37:52.700 --> 00:37:53.100
wieder retten.

00:37:54.840 --> 00:37:56.600
Ja, aber ich meine, es ist schon

00:37:56.600 --> 00:37:58.700
einen langen Weg gekommen sozusagen, also

00:37:58.700 --> 00:38:00.080
mittlerweile ist der PRP.

00:38:00.780 --> 00:38:02.780
Aber ja, vielleicht einer

00:38:02.780 --> 00:38:04.880
der Gründe dafür, dass man sich über sowas noch keine Gedanken gemacht hat.

00:38:05.200 --> 00:38:06.760
Während Guido ja, glaube ich, von Anfang

00:38:06.760 --> 00:38:08.800
an, glaube ich, sehr auf diesem Level war, dass er schon

00:38:08.800 --> 00:38:10.680
so ein bisschen wusste, warum er

00:38:10.680 --> 00:38:12.000
Sachen wie machen wollte.

00:38:13.180 --> 00:38:14.300
Ja, ja, der hat

00:38:14.300 --> 00:38:16.340
viel Absicht mit dabei, ja.

00:38:17.940 --> 00:38:18.340
Ja,

00:38:19.080 --> 00:38:20.760
ja, keine Ahnung. Also ist da auch die Frage,

00:38:20.880 --> 00:38:22.700
ist da so eine neue Sprache, ein Refactoring

00:38:22.700 --> 00:38:24.360
von neuen Gedanken, die man

00:38:24.360 --> 00:38:25.500
auf dem Computer hat?

00:38:26.780 --> 00:38:27.180
Ja.

00:38:28.720 --> 00:38:30.380
Naja, ja, aber ich meine, es ist halt,

00:38:30.500 --> 00:38:32.700
es ist wirklich schwer zu sagen, also man kann

00:38:32.700 --> 00:38:34.560
das nicht unbedingt vorher,

00:38:34.840 --> 00:38:36.420
also ich glaube nicht, dass das, eben auch

00:38:36.420 --> 00:38:38.600
im Sprachdesign ist ja, also das wäre jetzt sozusagen,

00:38:38.600 --> 00:38:39.720
wie ist eine Sprache designt?

00:38:40.400 --> 00:38:42.200
da die richtigen Abstraktionen zu finden, auch

00:38:42.200 --> 00:38:44.100
super schwierig. Und da würden

00:38:44.100 --> 00:38:45.760
Leute dann auch direkt am Anfang schon

00:38:45.760 --> 00:38:48.080
unterschiedliche Ansichten vertreten und würden halt

00:38:48.080 --> 00:38:50.100
sagen so, okay, also es gibt dann

00:38:50.100 --> 00:38:52.020
halt ein Lager irgendwie, das

00:38:52.020 --> 00:38:53.940
sagen würde, so, ach, dieses

00:38:53.940 --> 00:38:55.940
dynamisch getypte, das ist alles

00:38:55.940 --> 00:38:58.160
nicht gut. Irgendwie statisch getypt,

00:38:58.500 --> 00:39:00.100
bestes getypt, voll gut.

00:39:01.900 --> 00:39:03.260
Muss alles statisch,

00:39:04.280 --> 00:39:06.140
ja, und an der Stelle

00:39:06.140 --> 00:39:07.880
wird man sich ja schon, und das ist bis heute nicht raus,

00:39:07.940 --> 00:39:08.600
was jetzt nun besser ist.

00:39:08.600 --> 00:39:11.220
Ja, aber typisieren ist auf jeden Fall anstrengender,

00:39:11.760 --> 00:39:12.980
wenn man halt einfach mal so was

00:39:12.980 --> 00:39:15.100
schnellstens hinhotzen muss. Ich habe heute eine kurze

00:39:15.100 --> 00:39:16.180
Übung in Rust geschrieben,

00:39:16.680 --> 00:39:18.780
du musst halt jedes Mal an jeden

00:39:18.780 --> 00:39:20.740
kleinen Witzel dran schreiben, was das eigentlich sein soll

00:39:20.740 --> 00:39:22.820
oder sollte und dann beschwert er sich

00:39:22.820 --> 00:39:24.520
der Compiler immer, wenn es halt nicht stimmt, was

00:39:24.520 --> 00:39:26.840
ja auch gar nicht eigentlich schlecht ist, weil in der Benutzung will man ja, dass es

00:39:26.840 --> 00:39:28.740
eigentlich stimmt, weil man weiß,

00:39:28.800 --> 00:39:30.780
es ist halt dann egal, aber es funktioniert irgendwie trotzdem und das ist

00:39:30.780 --> 00:39:32.240
ein bisschen...

00:39:32.240 --> 00:39:34.300
Ja, aber das ist genau so ein Punkt.

00:39:36.920 --> 00:39:37.940
Genau, also wenn du

00:39:37.940 --> 00:39:41.440
du kannst ja jetzt auch zum Beispiel

00:39:41.440 --> 00:39:43.820
in Python Type Annotations

00:39:43.820 --> 00:39:44.100
machen.

00:39:44.340 --> 00:39:47.540
Ich habe jetzt

00:39:47.540 --> 00:39:49.560
erst so vor kurzem damit angefangen, mich so ein bisschen

00:39:49.560 --> 00:39:50.700
zu beschäftigen, weil vorher dachte ich mir so,

00:39:52.020 --> 00:39:53.740
Type Annotation schreiben,

00:39:53.880 --> 00:39:54.920
keine Lust.

00:39:55.700 --> 00:39:57.200
Und ach, mich interessiert das alles nicht.

00:39:57.300 --> 00:39:59.600
Ich bin ja nicht deswegen zu Python

00:39:59.600 --> 00:40:01.620
gegangen, damit ich irgendwie überall

00:40:01.620 --> 00:40:03.820
Typen

00:40:03.820 --> 00:40:04.460
dran schreiben muss.

00:40:05.120 --> 00:40:07.180
Aber mit FastAPI,

00:40:07.180 --> 00:40:08.400
Obwohl, das wir übrigens auch noch eine Folge machen wollen.

00:40:09.120 --> 00:40:11.160
Das ist cool benutzt zu haben. Aber dann macht das sogar

00:40:11.160 --> 00:40:13.220
dann Dinge, wenn du die Typen verwendest und so.

00:40:13.500 --> 00:40:14.000
Ja, ja, ja.

00:40:14.940 --> 00:40:17.600
Aber gut, da passieren auch Sachen dynamisch.

00:40:18.120 --> 00:40:18.620
Genau, ja.

00:40:18.880 --> 00:40:21.200
Das ist halt auch nochmal so ein, das geht ja schon fast

00:40:21.200 --> 00:40:22.880
darüber, die reinen Typ-Annotationen hinaus.

00:40:23.140 --> 00:40:25.240
Typ-Magie. Ja, also je nachdem,

00:40:25.400 --> 00:40:27.240
was für Typen man dann da hat,

00:40:27.600 --> 00:40:29.080
passieren halt unterschiedliche Sachen,

00:40:29.200 --> 00:40:30.060
aber dann auch zur Laufzeit.

00:40:31.200 --> 00:40:33.060
Das ist nicht nur für einen statischen

00:40:33.060 --> 00:40:33.760
Typ-Checker.

00:40:35.200 --> 00:40:36.680
Ja, aber natürlich, genau.

00:40:36.840 --> 00:40:38.780
das ist halt so ein Problem beim Sprachdesign.

00:40:38.900 --> 00:40:40.740
Will man jetzt Typisierung haben oder nicht?

00:40:41.240 --> 00:40:42.900
Weil natürlich fängt es halt

00:40:42.900 --> 00:40:44.780
Bugs. Ich habe das jetzt auch gemerkt, ich mache das seit einiger

00:40:44.780 --> 00:40:46.900
Zeit, mache ich auch Fast API und

00:40:46.900 --> 00:40:48.860
habe jetzt auch, dachte mir, oh gut, wenn

00:40:48.860 --> 00:40:50.820
ich das schon mache, dann schreibe ich die Annotation halt auch mit

00:40:50.820 --> 00:40:52.940
dazu. Und tatsächlich sind mir schon ein paar Mal

00:40:52.940 --> 00:40:54.760
Sachen aufgefallen, wo ich

00:40:54.760 --> 00:40:56.900
dann gemerkt habe, so, oh,

00:40:57.720 --> 00:40:58.620
da hat mir jetzt,

00:40:58.820 --> 00:41:00.260
ich lasse dann auch MyPi drüber laufen,

00:41:01.340 --> 00:41:02.780
wo mir dann MyPi auf die Finger haut

00:41:02.780 --> 00:41:04.780
oder halt eben Pylense oder was auch immer.

00:41:05.520 --> 00:41:06.560
So, da ist irgendwas nicht richtig.

00:41:06.840 --> 00:41:34.420
Und ich denke so, okay, also meistens ist es tatsächlich nur, ich habe es nicht richtig hingeschrieben, ich habe das irgendwie nicht richtig bedient. Und deswegen, und man muss es ein bisschen anders hinschreiben und dann stimmt es, aber das, was ich vorhatte, war schon richtig. Und dann ab und zu kommt dann doch so ein Ding, wo ich dann drüber nachdenke und dann so, oh Mist, tatsächlich, an der Stelle kann irgendwas nannen werden oder so. Das ist meistens sowas. Und wenn man ein bisschen drüber nachdenkt, dann wird einem klar, dass das auch tatsächlich so sein kann.

00:41:34.420 --> 00:41:36.060
Aber mir war das vorher gar nicht klar.

00:41:36.180 --> 00:41:38.020
Den Fall habe ich, ich dachte, das kann überhaupt nicht passieren.

00:41:38.340 --> 00:41:39.400
Ach doch, kann doch passieren.

00:41:39.640 --> 00:41:41.760
Und dann habe ich tatsächlich im Grunde einen Fall übersehen

00:41:41.760 --> 00:41:43.420
und da wäre ein Bug gewesen eigentlich.

00:41:43.780 --> 00:41:46.320
Ja, sowas hat er, ich glaube auch.

00:41:46.400 --> 00:41:47.860
Also die meisten Bugs, die ich irgendwann entdecke,

00:41:47.960 --> 00:41:49.500
sind wirklich viele Type-Bugs irgendwann.

00:41:49.720 --> 00:41:52.080
Ja, also viele sind es nicht gewesen, ein paar waren es.

00:41:52.340 --> 00:41:54.240
Also ich habe zum Beispiel, ihr kennt ja Antwerpen auf Code.

00:41:55.020 --> 00:41:56.480
Also Antwerpen auf Code ist so ein tolles Spiel,

00:41:56.540 --> 00:41:57.980
was man in der Adventszeit spielen kann,

00:41:58.080 --> 00:42:00.080
wo man halt so Coding-Rätsel macht, ganz süß immer gemacht.

00:42:00.440 --> 00:42:01.700
Diesmal ist es ein U-Boot.

00:42:01.700 --> 00:42:19.620
Und auch da, also ganz einfache Aufgabe, erste Aufgabe, iterieren über so ein Array vergleichen. Es gibt einen unheimlich großen Unterschied, ob man halt den Typ, das ist eigentlich nur eine Liste, also in einer Datei, von Zahlen, ob man da ein Int drauf castet oder halt nicht, weil halt der Vergleich, den man machen muss zwischen Zahlen, halt ein anderes Ergebnis hat, aber nur an zwei Punkten.

00:42:19.620 --> 00:42:21.840
Das heißt, man kommt am Ende irgendwie auf 1.300 Treffer

00:42:21.840 --> 00:42:23.880
und dann kommt man auf 1.301 Treffer,

00:42:23.980 --> 00:42:25.680
wenn man halt den Typ ändert oder sowas.

00:42:25.740 --> 00:42:26.740
Und das ist halt nur eine Sache richtig.

00:42:27.120 --> 00:42:28.980
Und das halt zu finden, dass man halt überhaupt so einen Bug hat,

00:42:29.040 --> 00:42:30.240
wenn halt das meistens stimmt.

00:42:30.600 --> 00:42:32.860
Ja, also in 1.299 Fällen ist das richtige Ergebnis da.

00:42:33.260 --> 00:42:35.360
Das geht halt nur wirklich, wenn man tatsächlich weiß,

00:42:35.440 --> 00:42:36.800
warum und welche Typen man da hat.

00:42:37.140 --> 00:42:38.240
Und wenn man das irgendwie sicherstellen kann.

00:42:38.300 --> 00:42:39.700
Und das geht halt mit Type-Ins ganz gut,

00:42:40.000 --> 00:42:42.820
weil du weißt halt, oh, da muss halt ein Int rein oder so.

00:42:43.040 --> 00:42:45.280
Und wenn man das vergisst, dann funktioniert das halt nicht.

00:42:46.320 --> 00:42:47.920
Und das ist mir auch erst klar geworden,

00:42:47.920 --> 00:42:49.480
als ich jetzt zum Beispiel die Lösung auch in Rust oder in Go

00:42:49.480 --> 00:42:50.880
geschrieben habe, weil dann

00:42:50.880 --> 00:42:53.700
klar ist, welchen Typ er hat und weil es halt

00:42:53.700 --> 00:42:55.620
immer das falsche anzeigt, wenn man halt den Typen nicht

00:42:55.620 --> 00:42:55.980
konvertiert.

00:42:57.280 --> 00:42:59.380
Ist aber auch, glaube ich, eine super Sache, wenn man

00:42:59.380 --> 00:43:01.600
so interne

00:43:01.600 --> 00:43:03.800
APs hat, also entweder, wenn man irgendwie

00:43:03.800 --> 00:43:05.700
so zentrale Funktionalität hat,

00:43:05.720 --> 00:43:07.640
die irgendwo liegt oder Sachen, die halt von vielen verschiedenen

00:43:07.640 --> 00:43:08.980
Seiten irgendwie verwendet wird oder

00:43:08.980 --> 00:43:11.060
von vielen verschiedenen Entwicklern,

00:43:11.400 --> 00:43:13.640
gehe ich inzwischen auch immer hin und versuche die

00:43:13.640 --> 00:43:15.660
so weit wie möglich zu typisieren in

00:43:15.660 --> 00:43:17.020
Python. Einfach, dass dann

00:43:17.020 --> 00:43:24.760
Und dass der nächste Entwickler, auch wenn ich das bin, einfach weiß, okay, da kommt jetzt, weiß ich nicht, vielleicht ein Nun raus oder eine Liste oder ist das ein Dictionary?

00:43:25.060 --> 00:43:28.840
Weil das sind halt wirklich so Sachen, meistens findet man es, bevor es wirklich auf Production geht.

00:43:28.920 --> 00:43:33.240
Aber selbst dann sucht man nochmal irgendwie fünf oder zehn Minuten, wenn man nochmal denkt, hey, ich hab doch und warum, was soll das denn?

00:43:33.640 --> 00:43:39.080
Und wenn einem dann die IDE dann direkt anzeigt, nee, nee, du machst die Äpfel mit Birnen, das ist einfach super praktisch.

00:43:39.480 --> 00:43:43.080
Und umso tiefer das bei mir drin ist, umso mehr versuche ich auch dann wirklich die Type-Ins zu machen.

00:43:43.080 --> 00:43:44.940
Ja, mit dem Nun ist halt echt ein Problem, ne?

00:43:45.880 --> 00:43:56.060
Aber, ja, da fällt mir auch gerade so eine Anekdote zu ein, da gibt es noch ein Buch, JavaScript, The Good Parts, glaube ich, auch ein relativ bekanntes Buch.

00:43:56.120 --> 00:43:56.860
Das muss halt dünn sein.

00:43:57.660 --> 00:43:58.920
Das ist tatsächlich relativ dünn.

00:43:59.320 --> 00:44:01.400
Da gibt es doch diesen Witz mit dem dicken Buch, der JavaScript.

00:44:01.400 --> 00:44:07.900
Genau, die Reference, das ist irgendwie zu tausend Seiten und dann irgendwie Good Parts ist halt irgendwie so ein Heftchen, ja, das stimmt.

00:44:08.520 --> 00:44:36.420
Und der Autor davon, ich glaube, das ist David Crockford oder ich weiß nicht genau, der ist auch in diesen Standardisierungsgremien drin und so und der schrieb dann halt auch irgendwo, weiß gar nicht, meinte so, naja, also irgendwie diese, ist eigentlich kein Wert oder ist irgendwie nix, Dinger sind ein Problem bei Sprachen, ja, also Python halt none, da gibt es halt ein Ding und es ist halt immer wieder in diesen, wenn man sich über so Standardisierungsfragen, ist immer die Frage, ist das eine gute Idee, sowas in der Sprache zu haben oder nicht?

00:44:36.420 --> 00:44:38.260
zum Beispiel SQL, ja, ist ja auch, Null

00:44:38.260 --> 00:44:39.980
ist für einen Großteil der

00:44:39.980 --> 00:44:42.380
wirklich hässlichen Sachen im

00:44:42.380 --> 00:44:44.320
Sprachstandard und auch für viele Bugs in

00:44:44.320 --> 00:44:46.500
Datenbankimplementationen, die dann halt

00:44:46.500 --> 00:44:48.460
auch irgendwie, und für viele Inkompatibilitäten

00:44:48.460 --> 00:44:50.200
in den Standards und so, also Null

00:44:50.200 --> 00:44:52.500
spielt da eine große Rolle, ja, wenn man jetzt sagt, so ein harmloses

00:44:52.500 --> 00:44:53.960
Ding wie Null, das kann ja nicht so viel kaputt machen,

00:44:54.240 --> 00:44:56.280
das Ding macht irgendwie dauernd und seit

00:44:56.280 --> 00:44:58.420
Jahrzehnten und konsistent irgendwie ganz viel Probleme

00:44:58.420 --> 00:45:00.600
und, ja, er meinte

00:45:00.600 --> 00:45:02.500
da so, ja, also es ist immer so, unter Leuten,

00:45:02.580 --> 00:45:04.560
die sich mit Sprachdesign beschäftigen,

00:45:04.560 --> 00:45:06.440
in Frage, will man sowas in der Sprache haben oder nicht?

00:45:07.000 --> 00:45:08.440
Und dann gibt es immer so einen einen Teil der Leute,

00:45:08.580 --> 00:45:10.560
die sagen, ja, doch, ist eigentlich schon gut, wenn man das hat.

00:45:10.660 --> 00:45:12.440
Ein anderer Teil sagt, nee. Aber absolut

00:45:12.440 --> 00:45:14.560
niemand, absolut niemand vertritt die Ansicht,

00:45:15.120 --> 00:45:16.420
es ist voll gut, zwei davon

00:45:16.420 --> 00:45:18.640
in einer Sprache zu haben. Und da was gibt, hat halt zwei.

00:45:18.840 --> 00:45:20.500
Das hat halt immer null und undefined.

00:45:20.660 --> 00:45:22.460
Und das ist halt wirklich, ah.

00:45:23.140 --> 00:45:23.300
Ja.

00:45:23.920 --> 00:45:25.220
Das ist halt irgendwie so.

00:45:27.960 --> 00:45:28.280
Ja.

00:45:28.520 --> 00:45:30.220
Und das macht Dinge wirklich komplizierter.

00:45:30.520 --> 00:45:31.840
Aber das Problem ist jetzt auch,

00:45:31.840 --> 00:45:33.860
die Type-Annotationen

00:45:33.860 --> 00:45:35.260
selber machen Sachen natürlich auch komplizierter.

00:45:36.320 --> 00:45:37.940
Ja, zum Beispiel zirkuläre Importe oder so was,

00:45:37.980 --> 00:45:38.740
das ist ja ein bisschen nervig.

00:45:39.000 --> 00:45:41.520
Nee, die Annotationen, also, achso, gut,

00:45:41.700 --> 00:45:43.920
okay, klar, da kannst du auf das Problem natürlich auch stoßen,

00:45:44.080 --> 00:45:45.660
ja klar, oder

00:45:45.660 --> 00:45:48.180
leichter, aber ich meine, wenn das

00:45:48.180 --> 00:45:49.880
jetzt eben, also entweder man macht

00:45:49.880 --> 00:45:51.820
halt, wenn man jetzt die Typen annotiert

00:45:51.820 --> 00:45:53.880
und man macht es jetzt so

00:45:53.880 --> 00:45:55.740
quasi einfach,

00:45:56.160 --> 00:45:57.620
man muss halt dann auch seinen Stil ändern,

00:45:58.060 --> 00:45:59.780
wenn die Typannotationen

00:45:59.780 --> 00:46:01.820
einfach bleiben sollen, dann muss man halt irgendwie

00:46:01.820 --> 00:46:03.560
das auf so relativ primitive

00:46:03.560 --> 00:46:05.760
Datentypen runterbrechen und kann dann

00:46:05.760 --> 00:46:07.560
eigentlich auch nur noch so relativ primitive

00:46:07.560 --> 00:46:09.020
Datentypen verwenden.

00:46:09.480 --> 00:46:11.720
Ja, man will ja eigentlich schon komplexere Daten,

00:46:11.860 --> 00:46:13.420
also so ein Pathentic-Objekt oder sowas

00:46:13.420 --> 00:46:15.720
hinten. Ja, gut, okay, also Pathentic ist nochmal,

00:46:16.040 --> 00:46:17.660
aber das Problem dabei ist halt,

00:46:18.100 --> 00:46:19.660
also wenn man das macht, dann hat man

00:46:19.660 --> 00:46:21.420
halt im Grunde, kommt man dann irgendwie so

00:46:21.420 --> 00:46:23.580
und wenn das Typsystem relativ einfach ist,

00:46:23.620 --> 00:46:25.700
was man so verwendet, dann kommt man halt

00:46:25.700 --> 00:46:27.620
bei einem Dialekt von Java raus, der halt super langsam

00:46:27.620 --> 00:46:29.740
ist. Was halt, und es sieht

00:46:29.740 --> 00:46:30.840
überhaupt nicht mehr aus wie Python eigentlich.

00:46:31.820 --> 00:46:33.180
Das ist halt irgendwie doof,

00:46:33.920 --> 00:46:35.420
aber wenn man jetzt Python

00:46:35.420 --> 00:46:37.700
idiomatisch schreibt, so Pythonisch

00:46:37.700 --> 00:46:39.660
irgendwie, dann

00:46:39.660 --> 00:46:41.560
wird das mit den Typ-Annotationen

00:46:41.560 --> 00:46:43.440
ziemlich schwierig. Also weil zum Beispiel

00:46:43.440 --> 00:46:45.400
so eine, da gab es letztens auch eine

00:46:45.400 --> 00:46:46.620
Podcast-Episode mit

00:46:46.620 --> 00:46:48.540
Luciano Ramaglio,

00:46:49.460 --> 00:46:50.840
der hat für Python geschrieben, das Buch,

00:46:51.020 --> 00:46:53.440
kann ich nur empfehlen. Es gibt jetzt, im Frühjahr kommt

00:46:53.440 --> 00:46:55.380
eine zweite

00:46:55.380 --> 00:46:57.200
Ausgabe, zweite Edition,

00:46:58.440 --> 00:46:59.080
Second Edition,

00:46:59.440 --> 00:47:01.540
wo er auch viel über Type-Annotationen und so schreibt.

00:47:01.820 --> 00:47:12.960
Und der hat sich das auch dann halt mal so richtig angeguckt und so und hat dann die Typ-Annotationen für die Max-Funktionen sich angeguckt.

00:47:13.800 --> 00:47:17.420
Und das Problem bei Typ-Annotationen ist jetzt auch, die können ja auch falsch sein.

00:47:17.500 --> 00:47:18.320
Die können ja richtig sein, falsch sein.

00:47:18.400 --> 00:47:19.860
Die können uns dann False-Positives geben.

00:47:20.080 --> 00:47:26.820
Es kann sein, dass etwas dem Typ zwar entspricht, aber tatsächlich ist es inkompatibel und innen knallt es irgendwo.

00:47:27.200 --> 00:47:28.360
Das sollte natürlich nicht passieren.

00:47:28.360 --> 00:47:30.480
Typ-Annotationen sollten so sein, dass es keine

00:47:30.480 --> 00:47:32.560
False-Positives und keine False-Negatives gibt, also auch keine

00:47:32.560 --> 00:47:34.620
das ist halt das, was mir immer

00:47:34.620 --> 00:47:36.480
passiert, wenn ich versuche, das hinzuschreiben, ich habe halt

00:47:36.480 --> 00:47:38.380
ganz oft False-Negatives, das heißt, mir sagt

00:47:38.380 --> 00:47:40.620
irgendwie MyPi oder so, da hast du

00:47:40.620 --> 00:47:42.400
was falsch gemacht und ich sage so, ne, das ist eigentlich nicht

00:47:42.400 --> 00:47:44.460
das ist eigentlich schon richtig, aber ich habe es irgendwie falsch

00:47:44.460 --> 00:47:46.540
hingeschrieben und bei

00:47:46.540 --> 00:47:48.460
einer Funktion wie Max ist das halt extrem

00:47:48.460 --> 00:47:50.420
schwierig und hat er halt in den

00:47:50.420 --> 00:47:52.500
Type-Annotationen dafür halt Fehler gefunden

00:47:52.500 --> 00:47:54.040
eben False-Positives, False-Negatives

00:47:54.040 --> 00:47:56.520
und hat dann versucht, das richtig zu machen, also es gibt irgendwo

00:47:56.520 --> 00:47:57.880
Type-Chat oder so

00:47:57.880 --> 00:48:00.540
da steht die Annotation für Max

00:48:00.540 --> 00:48:02.580
drin und das wurde dann

00:48:02.580 --> 00:48:04.440
richtig, richtig gemein, weil Max ist halt auch

00:48:04.440 --> 00:48:06.500
so eine komische, also es gibt so diverse Funktionen, so Max

00:48:06.500 --> 00:48:08.700
Len und so, die halt schön sind

00:48:08.700 --> 00:48:10.600
irgendwie, weil du kannst halt, es ist eine sehr

00:48:10.600 --> 00:48:12.460
generische Funktion, du kannst da alles reinwerfen und es macht

00:48:12.460 --> 00:48:13.440
eigentlich immer das Richtige,

00:48:14.360 --> 00:48:16.600
aber das jetzt zu annotieren ist halt

00:48:16.600 --> 00:48:18.580
die Hölle, also er hat dann irgendwie

00:48:18.580 --> 00:48:19.980
so, naja, also die

00:48:19.980 --> 00:48:22.340
eigentliche Implementation von Max sind halt

00:48:22.340 --> 00:48:24.520
irgendwie so 25 Zeilen oder so

00:48:24.520 --> 00:48:26.240
und allein die

00:48:26.240 --> 00:48:28.240
Typ-Annotationen waren hinterher, du musst halt

00:48:28.240 --> 00:48:30.660
sechs Overloads

00:48:30.660 --> 00:48:32.320
dafür irgendwie definieren, der Funktion

00:48:32.320 --> 00:48:33.920
und es waren viel, viel mehr

00:48:33.920 --> 00:48:36.300
Zeilen in den Typ-Definitionen als hinterher in der

00:48:36.300 --> 00:48:38.420
Annotation. Und dann ist natürlich die Frage, und es war

00:48:38.420 --> 00:48:39.580
sehr schwer zu verstehen und

00:48:39.580 --> 00:48:42.260
also irgendwie diverse

00:48:42.260 --> 00:48:44.320
subtile Fehler drin. Also dann ist

00:48:44.320 --> 00:48:46.280
halt die Frage, okay, wenn das so schwierig ist,

00:48:46.520 --> 00:48:48.060
die Typen hinzuschreiben, ja,

00:48:48.780 --> 00:48:50.260
macht das dann, ist dieses Verhältnis

00:48:50.260 --> 00:48:52.340
zwischen, und es

00:48:52.340 --> 00:48:54.060
ist halt komplett, es ist auch sehr schwer zu lesen, ja.

00:48:54.780 --> 00:48:58.720
Also es ist halt die Frage, ja, ist das dann wert noch?

00:48:59.380 --> 00:49:03.080
Und ja, das ist halt so die Frage.

00:49:04.420 --> 00:49:07.380
Und das gibt es genauso, weil das war auch aus dem Podcast.

00:49:08.620 --> 00:49:12.760
Da meinte er so, es gibt so ein Buch zu Java.

00:49:14.920 --> 00:49:16.300
Ich habe vergessen, welches das ist.

00:49:16.380 --> 00:49:19.640
Auf jeden Fall ist auch einer, der in der Sprache mitgearbeitet hat oder so,

00:49:19.700 --> 00:49:21.860
der schrieb dann halt zu, als die Generics eingeführt wurden,

00:49:22.000 --> 00:49:24.360
selber sagt er

00:49:24.360 --> 00:49:26.240
dazu, also die Generics waren ein Desaster

00:49:26.240 --> 00:49:28.140
in Java und

00:49:28.140 --> 00:49:30.340
es gibt diverse Geschichte, Konstrukte,

00:49:30.440 --> 00:49:32.280
die sie da gemacht haben, wo es

00:49:32.280 --> 00:49:34.200
dann, wo sie dann gesagt haben, so wir haben

00:49:34.200 --> 00:49:36.240
das jetzt irgendwelchen Professoren, die sich mit Typtheorie

00:49:36.240 --> 00:49:37.700
beschäftigen, gezeigt

00:49:37.700 --> 00:49:39.720
und die sagen, das stimmt,

00:49:40.860 --> 00:49:42.240
aber wir können das nicht

00:49:42.240 --> 00:49:43.380
bestätigen oder

00:49:43.380 --> 00:49:46.360
weil wir verstehen nicht,

00:49:46.460 --> 00:49:46.980
was das macht.

00:49:48.060 --> 00:49:50.300
Und das ist dann halt einfach so, ja gut, wozu macht man es

00:49:50.300 --> 00:49:51.660
dann jetzt, wenn man es nicht mal verstehen kann?

00:49:52.000 --> 00:50:17.500
Und also was man da sieht, ist halt, das Problem ist, dass die Sprache ist halt, also bei Python ist es halt auch so, die Sprache ist halt expressiver als die Sprache, die man verwendet, um die Typ-Annotationen zu machen. Und das hat ja schon in diversen Sprachen zu Katastrophen geführt. Also bei C++ mit den Templates, ja, ganz furchtbar, das ist ein Turing vollständig. Irgendwie, wenn man davon genug verwendet, versteht man auch nicht mehr, was da los ist. Der Compiler braucht ewig lange viel Hauptspeicher und schrecklich. Java, Generics, ganz furchtbar.

00:50:17.660 --> 00:50:20.440
Wie macht man das so, zum Beispiel mit einem JSON-Objekt?

00:50:20.560 --> 00:50:21.540
Wie würde ich das type-contentieren?

00:50:21.640 --> 00:50:23.080
Das ist so ein bisschen...

00:50:23.080 --> 00:50:24.000
Genau, das kann man.

00:50:24.160 --> 00:50:24.840
Das kann man tatsächlich.

00:50:25.000 --> 00:50:27.220
Also ich beschäftige mich ja gerade auch so ein bisschen mit TypeScript.

00:50:27.720 --> 00:50:30.100
Und da gibt es, also da kannst du,

00:50:30.120 --> 00:50:32.140
du kannst tatsächlich solche Sachen machen wie...

00:50:32.140 --> 00:50:33.200
Rekursiv definieren.

00:50:33.440 --> 00:50:35.840
Du kannst rekursive Typ-Definitionen machen, wenn es geht.

00:50:36.900 --> 00:50:37.940
Das geht in Python, glaube ich, bisher nicht.

00:50:38.640 --> 00:50:40.700
Ja, das kann gut sein, dass das in Python nicht geht.

00:50:40.700 --> 00:50:43.800
Also die Type-Definition für einen JSON,

00:50:44.480 --> 00:50:47.540
wo dann hinterher der TypeScript, der TypeScript-Compiler,

00:50:47.660 --> 00:50:49.740
auf die Finger haut, wenn du da auch

00:50:49.740 --> 00:50:51.700
bliebig rekursiv irgendwo etwas reinschreibst,

00:50:51.760 --> 00:50:53.440
was jetzt nicht mehr welches JSON wäre,

00:50:53.820 --> 00:50:55.040
wo du eine rote Klingel kriegst,

00:50:55.800 --> 00:50:57.580
das sind so 25 Zeilen rekursiv

00:50:57.580 --> 00:50:59.460
Type-O-Notationen in TypeScript. Das geht.

00:51:00.040 --> 00:51:01.740
Und das ist natürlich schon sehr cool, dass das geht.

00:51:02.300 --> 00:51:03.020
Auf der anderen Seite,

00:51:04.440 --> 00:51:05.660
ich beschäftige mich

00:51:05.660 --> 00:51:07.640
jetzt seit einer Zeit damit, also ich kann

00:51:07.640 --> 00:51:09.000
diese 25 Zeilen sehen.

00:51:09.620 --> 00:51:11.180
Ehrlich gesagt, ich verstehe sie nicht so ganz.

00:51:11.420 --> 00:51:12.980
Das ist halt auch wirklich, wirklich schwierig.

00:51:12.980 --> 00:51:16.400
Ja, da können ja rekursiv

00:51:16.400 --> 00:51:17.820
irgendwelche Dinge drin, irgendwelche Listen drin liegen,

00:51:17.920 --> 00:51:20.040
irgendwelche Dicks drin liegen, irgendwelche Listen drin liegen, wo vielleicht noch ein

00:51:20.040 --> 00:51:21.700
Zwingl ist und irgendwie Null oder irgendwas.

00:51:22.540 --> 00:51:24.080
Ja, es ist halt wieder eine Sprache

00:51:24.080 --> 00:51:26.040
für sich, also allein schon, dass du

00:51:26.040 --> 00:51:28.200
in Types, dass du halt sagst,

00:51:28.640 --> 00:51:30.100
okay, es gibt ja eben

00:51:30.100 --> 00:51:31.920
diese Generics, sag ich mal,

00:51:31.960 --> 00:51:33.640
du kannst halt nicht nur,

00:51:33.920 --> 00:51:36.140
du definierst die Typen nicht fix, sondern du sagst

00:51:36.140 --> 00:51:38.100
halt, also du kannst

00:51:38.100 --> 00:51:39.760
jetzt in der Funktion

00:51:39.760 --> 00:51:42.000
sagen, welchen Typ

00:51:42.000 --> 00:51:44.040
du zurück erwartest und den dann

00:51:44.040 --> 00:51:45.380
als Typ-Annotation verwenden.

00:51:45.600 --> 00:51:47.660
Du kannst also sozusagen Typen parametrisieren,

00:51:47.760 --> 00:51:49.500
die du irgendwo setzt. Du kannst eine generische

00:51:49.500 --> 00:51:51.300
Funktion haben und dann sagen,

00:51:52.040 --> 00:51:53.980
während du sie aufrufst, im Aufruf

00:51:53.980 --> 00:51:55.860
kannst du dir sagen, und die gibt jetzt das und das

00:51:55.860 --> 00:51:57.880
zurück. Und dann kann der Compiler

00:51:57.880 --> 00:51:59.820
das überprüfen, dass das stimmt. Und das kannst du dann

00:51:59.820 --> 00:52:01.380
auch noch rekursiv machen. Und das kannst du dann mit

00:52:01.380 --> 00:52:02.960
beliebig verschachtelten Sachen machen.

00:52:03.100 --> 00:52:04.720
Sollte man das vielleicht ein bisschen refactoren?

00:52:05.900 --> 00:52:06.180
Naja,

00:52:08.180 --> 00:52:09.240
also es wird halt

00:52:09.570 --> 00:52:11.230
Ich meine, es ist schon cool. Auf der einen Seite finde ich es

00:52:11.230 --> 00:52:12.850
voll cool, dass es geht. Auf der anderen Seite denke ich mir so,

00:52:12.870 --> 00:52:14.890
mein Gott, was haben wir getan? Wir müssen ja mal ein Monster

00:52:14.890 --> 00:52:17.070
erschaffen. Aber ja,

00:52:17.210 --> 00:52:19.230
es ist...

00:52:19.230 --> 00:52:21.090
Also ist das eine Mode? Also ich habe auch

00:52:21.090 --> 00:52:22.910
das relativ oft benutzt. Ich benutze das auch gerne

00:52:22.910 --> 00:52:24.950
und ich versuche auch, das relativ vollständig so

00:52:24.950 --> 00:52:26.730
zu benutzen. Aber halt,

00:52:27.210 --> 00:52:28.790
ja, es hat halt irgendwie seine Grenzen auch.

00:52:29.390 --> 00:52:31.030
Also manchmal nutze ich das einfach nicht, weil es einfach keinen

00:52:31.030 --> 00:52:32.890
Sinn macht. Also für so ein Int oder String,

00:52:32.990 --> 00:52:34.850
okay, aber dann so komplexe Objekte...

00:52:34.850 --> 00:52:37.130
Ja, aber bei komplexeren Sachen wird es halt dann sofort ziemlich schwierig.

00:52:37.450 --> 00:52:38.950
Ja. Also eine

00:52:38.950 --> 00:52:40.510
Geschichte, die wohl cool ist, ist halt

00:52:40.510 --> 00:52:43.090
Protocols. Damit kann man halt

00:52:43.090 --> 00:52:45.250
also Typing.Protocols

00:52:45.250 --> 00:52:47.170
mit Python 3.8 glaube ich dazu gekommen, damit kann man

00:52:47.170 --> 00:52:49.150
dann viele der Probleme, die man sonst hat

00:52:49.150 --> 00:52:51.170
irgendwie gehen dann weg, weil man dann

00:52:51.170 --> 00:52:52.950
sagen kann, okay, ich erwarte hier nur ein Ding, dass

00:52:52.950 --> 00:52:55.130
also Protocols sind immer so kleine Sachen, wo du eine

00:52:55.130 --> 00:52:56.830
Methode hast oder vielleicht zwei oder so

00:52:56.830 --> 00:52:59.330
und dann musst du halt nur diese Methoden implementieren.

00:52:59.430 --> 00:53:00.710
Du kannst halt überprüfen, ob das so ist,

00:53:00.850 --> 00:53:02.810
ob das konform ist

00:53:02.810 --> 00:53:05.070
und dann fällt ein Großteil

00:53:05.070 --> 00:53:06.390
der Schmerzen weg, aber

00:53:06.390 --> 00:53:08.530
also wirklich, ja,

00:53:08.770 --> 00:53:11.830
Also wenn das zu komplex wird,

00:53:11.870 --> 00:53:13.710
vielleicht muss man dann refactoren, dass man einfachere Dinge

00:53:13.710 --> 00:53:15.710
macht, wie zum Beispiel nach Strings zu realisieren oder sowas.

00:53:15.850 --> 00:53:17.710
Nee, nee, nee, aber das Problem ist ja, also das willst du

00:53:17.710 --> 00:53:19.730
ja eigentlich vielleicht nicht. Du willst ja vielleicht sowas, so generische

00:53:19.730 --> 00:53:20.970
Funktionen haben wie Max oder so.

00:53:21.310 --> 00:53:23.570
Aber die kannst du praktisch nicht mehr gut annotieren, also außer

00:53:23.570 --> 00:53:25.850
du machst halt, es ist halt schwer, die zu annotieren.

00:53:26.630 --> 00:53:27.810
Das gute ist, wir müssen es ja

00:53:27.810 --> 00:53:29.330
nicht im Python, von daher vielleicht.

00:53:29.330 --> 00:53:30.890
Ja, genau. Und vielleicht ist es für die Fälle,

00:53:31.230 --> 00:53:33.730
einfach dann nicht typisieren,

00:53:33.730 --> 00:53:35.670
sondern sagen, okay, wir machen es an den Stellen, wo es halt was

00:53:35.670 --> 00:53:37.750
bringt und nicht so viel Arbeit ist. Und an den Stellen, wo

00:53:37.750 --> 00:53:39.770
es halt nicht gut geht, dann lassen wir es halt weg und dann schreiben wir halt

00:53:39.770 --> 00:53:41.650
eine generische Funktion. Magic Python.

00:53:42.650 --> 00:53:43.090
Genau.

00:53:43.790 --> 00:53:45.770
Das ist vielleicht irgendwie so der richtige

00:53:45.770 --> 00:53:47.350
Weg. Das haben wir kommen hinterher zu Tyson.

00:53:49.610 --> 00:53:49.790
Ja.

00:53:50.910 --> 00:53:51.590
Eine Sache,

00:53:51.830 --> 00:53:53.530
die mir noch aufgefallen ist, jetzt

00:53:53.530 --> 00:53:54.430
in

00:53:54.430 --> 00:53:57.730
den letzten Monaten beim Arbeiten

00:53:57.730 --> 00:53:59.430
bezüglich Refactoring, ist,

00:53:59.430 --> 00:54:01.310
es geht auch so ein bisschen Richtung Modularisierung,

00:54:01.430 --> 00:54:02.750
aber mehr Richtung

00:54:02.750 --> 00:54:05.330
die Semantik, denn wirklich die Sachen physisch

00:54:05.330 --> 00:54:07.130
irgendwie zu trennen. Und das ist,

00:54:07.750 --> 00:54:22.870
Wenn man relativ viel, also in meinem Beispiel relativ viel Business-Logik hat, also wenn man meistens fängt, also wenn man agil arbeitet, fängt so ein System mit MVP an, also sprich man hat, weiß ich nicht, irgendeinen Online-Shop, da kann irgendwer was kaufen, dann kriegt er vielleicht eine E-Mail, da gibt es irgendwie eine Bestellung und das war es im Endeffekt.

00:54:22.870 --> 00:54:36.750
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 und irgendwann hat man halt dann da ein riesiges Konstrukt von irgendwie E-Mails, die hin und zurück geschickt werden und irgendwelche Order-Objekte in der Datenbank, die riesig werden, wo hunderttausend Felder drin sind.

00:54:37.750 --> 00:54:49.270
Und das eigentliche Problem ist, dass dann an einem gewissen Punkt, das habe ich jetzt schon mehrfach gesehen, weder der Kunde noch die Entwickler eigentlich noch genau wissen, was eigentlich der Geschäftsprozess ist.

00:54:49.510 --> 00:54:58.830
Das System macht zwar ungefähr das, aber dann kommt plötzlich irgendwann mal ein Fehler, dann schickt man sich eine E-Mail und hat irgendetwas Falsches geschickt und dann stehen die Leute dann da und sagen, ja, was passiert da eigentlich genau?

00:54:59.650 --> 00:55:15.510
Und das finde ich einen total interessanten Refactoring-Ansatz, weil das halt nicht so, also keine Ahnung, wenn ich jetzt irgendwie merke, okay, das ist irgendwie ein schlechtes Pattern oder keine Ahnung, das ist nicht Lind-konform oder keine Ahnung was, dann geht man hin und refactort es halt, weil das schreit einen quasi an, das ist das Hässliche, was du meintest.

00:55:15.510 --> 00:55:25.390
Das ist ein Code-Review, wenn man relativ sehen kann, wie gesagt, Kommentare stimmen nicht oder Docs sind falsch oder es sieht hässlich aus, es ist zu lang, man kann es so ein bisschen umbauen, Namings sind komisch, dann kann man das schnell machen.

00:55:25.490 --> 00:55:36.350
Genau, aber so eine Sache, wenn man sagt, okay, ich habe jetzt da 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.350 --> 00:55:38.930
Interessant ist immer noch Services, da müssen wir auch nochmal drüber reden, was das eigentlich ist.

00:55:40.110 --> 00:55:53.810
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 Final-State-Machines.

00:55:54.270 --> 00:56:14.990
Dazu gibt es auch einen sehr coolen Vortrag von 2019. Ich habe vergessen von wem, aber da gibt es Django FSM. Das Problem ist, das Package ist leider deprecated und die neue Version ist noch in Alpha. Also man kann die schon nutzen, aber die Doku hat Lücken. Wen es interessiert, wir haben beim letzten Django Meetup in Köln haben wir länger drüber gesprochen. Das ist bei YouTube.

00:56:16.190 --> 00:56:18.990
Vielleicht nochmal ganz kurz dann erklären, was ist denn eine Finite State Machine?

00:56:19.830 --> 00:56:36.230
Also Final State Machine ist im Endeffekt relativ simpel, dass man sagt, ich habe ein Objekt und dieses Objekt kann in verschiedenen Status sein. Also sprich, ich habe einen Auftrag, der kann neu offen sein, der kann in Bearbeitung sein, der kann in Lieferung sein, der kann abgeschlossen sein, der kann bezahlt sein.

00:56:36.330 --> 00:57:05.430
Und dass es eine endliche Menge von Wegen gibt, wie ich von jedem Status, also nicht von jedem zu jedem, aber wie ich von einem Status zum anderen komme. Kann man sich im Endeffekt einfach wie ein Graf mit Pfeilen, also Kringeln und Pfeilen vorstellen. Und man hat halt im Endeffekt fix definiert, also erstmal auf dem grafischen Level, dass ich zum Beispiel von, ich kann nicht von offen direkt nach geschlossen kommen, weil davor muss es erstmal irgendwie bearbeitet, bezahlt und geliefert werden. Ja, oder so, das geht halt sonst nicht, so könnte man sich jetzt vorstellen, ja.

00:57:06.230 --> 00:57:11.810
Und der Vorteil an diesen, also das ist nur eine von vielen Möglichkeiten, um sowas anzugehen.

00:57:11.870 --> 00:57:14.390
Und wir haben das jetzt halt ausprobiert und es hat halt wirklich, wirklich gut funktioniert.

00:57:14.570 --> 00:57:22.710
Weil das Schöne ist, diese Graphen sind sehr, also die werden natürlich auch immer komplexer, wenn man halt sehr viel Business-Logik hat, aber trotzdem, die versteht halt wirklich jeder.

00:57:22.830 --> 00:57:26.370
Also der komplette Non-Techie kannst du das auf den Tisch legen und der weiß sofort, um was es geht.

00:57:26.870 --> 00:57:35.230
Und das Schöne ist halt, das geht mit der neuen Version glaube ich nicht, sondern mit der alten Version, wenn man diese Flows implementiert in Django, mit diesem Package,

00:57:35.570 --> 00:57:37.590
dann konnte man sich die Graphen auch rausrendern lassen.

00:57:37.790 --> 00:57:39.330
Also sprich, die Business-Logik,

00:57:39.410 --> 00:57:42.690
die man einerseits für als Entwickler sinnvoll ablegen kann,

00:57:42.690 --> 00:57:45.030
weil man halt auf einmal nicht mehr überall irgendwo langwurschtelt

00:57:45.030 --> 00:57:47.590
und irgendwie in jedem Service das irgendwie ein bisschen anders macht,

00:57:47.630 --> 00:57:50.350
je nachdem aus welcher Ära vom Projekt das dann halt gebaut wurde.

00:57:50.750 --> 00:57:51.810
Sondern man sagt, okay, ich habe einen Flow

00:57:51.810 --> 00:57:53.450
und hier definiere ich jetzt genau, was passiert,

00:57:53.530 --> 00:57:55.050
wenn Auftritt von offenen Bearbeitungen geht.

00:57:55.330 --> 00:57:57.950
Zum Beispiel, da geht eine E-Mail raus oder da geht keine E-Mail raus

00:57:57.950 --> 00:58:00.610
oder da muss jemand irgendwas machen damit, ja,

00:58:01.090 --> 00:58:02.550
und welche Variablen gesetzt werden.

00:58:02.870 --> 00:58:04.630
Und erstens ist es halt im Code sauber gekapselt

00:58:04.630 --> 00:58:22.730
Und die alte Version konnte, wie gesagt, direkt die Graphen rausrennen. Das heißt, wenn man ein hinreichend komplexes Business-Modell implementiert hat und dann kommt der Kunde und sagt, ich würde da gerne was dran ändern, dann kann man im Endeffekt auf den Knopf drücken, kriegt dann ein wunderbares PDF raus, kann darüber dann mit dem Kunden reden und sagen, okay, welche Pfeile sollen wir jetzt umbiegen und wo soll was anders passieren?

00:58:22.970 --> 00:58:34.150
Und das ist halt, also das ist halt wirklich auf einer ganz anderen Ebene und es ist halt so trivial, also ich bin eher schockiert, dass mir sowas noch nicht, also dass ich da so spät im Endeffekt drüber gestolpert bin über solche Sachen.

00:58:34.150 --> 00:58:56.250
Ja, ich glaube, was eigentlich schwierig ist, ist tatsächlich diese Dinger aufzumalen, weil ich glaube, selbst die Kunden kennen nicht immer ihren Flowchart, weil die halt nicht wissen, was passiert denn da und bevor sich das nicht jemand angeguckt hat und vielleicht mal das in der Realität getestet hat, oh, da ist aber noch ein Problem, dann tauchen diese einzelnen Ereignispunkte oder auch die States, die irgendwas haben kann, gar nicht auf.

00:58:56.250 --> 00:58:58.230
und das, bei uns hat das so einen ganz bösen

00:58:58.230 --> 00:58:59.910
Bug geführt. Ja,

00:59:00.410 --> 00:59:02.270
die Tests waren eigentlich ganz gut, also die haben eigentlich das getestet,

00:59:02.330 --> 00:59:03.950
was getestet werden soll, das heißt, Carbide war hoch,

00:59:04.050 --> 00:59:06.170
also der Code, aber es gab halt den Fall einfach nicht

00:59:06.170 --> 00:59:08.270
und das führte halt einfach dazu, dass fälschlicherweise

00:59:08.270 --> 00:59:10.110
beispielsweise, wir haben so 4MN-Quatsch

00:59:10.110 --> 00:59:12.410
gemacht, an ein paar hundert Vertriebler

00:59:12.410 --> 00:59:14.070
einfach so E-Mails rausgingen, die gar nicht rausgehen sollten

00:59:14.070 --> 00:59:16.130
oder so, oder zu oft und sonst halt so ein bisschen

00:59:16.130 --> 00:59:17.730
so, okay, ups

00:59:17.730 --> 00:59:20.190
und das böse schreit halt dann, man denkt sich

00:59:20.190 --> 00:59:22.090
halt so, nein, wir können den nur und total

00:59:22.090 --> 00:59:23.950
doof und das macht ja gar nicht, dass wir es sollen, das ist falsch

00:59:23.950 --> 00:59:29.510
Aber eigentlich ist halt nur der Fall, dass man halt nicht bedacht hat, dass es einen besonderen Fall geben kann, der halt nicht abgebildet wird.

00:59:29.510 --> 00:59:53.390
Genau, aber das Schöne ist halt, wenn man halt mit solchen Tools vielleicht auch direkt konzeptionell, also auch im Agilen einfach mal, wenn man die Tickets überarbeitet, sagt, hey, wir haben hier dieses Modell und wir arbeiten immer an diesem Modell, dann kann man halt vielleicht über solche Sachen auch schon viel früher stolpern, weil der Kunde dann plötzlich merkt, so ja, Moment mal, oder wenn der Kunde es an seinen Stakeholdern zeigt, also der Kunde an den Stakeholdern zeigt und sagt vielleicht, ja, Moment mal, aber ich arbeite doch die ganze Zeit an einem Pfeil, den es ja gar nicht gibt, da stimmt doch was nicht.

00:59:53.950 --> 01:00:10.570
Weil wenn das halt implementiert ist, dann ist es halt für die Non-Techies halt quasi weg. Das ist dann nicht mehr einsehbar. Und als Entwickler, natürlich sollte man das grob verstehen, wie du halt gesagt hast, das System ab einer gewissen hinreichenden Komplexität ist es halt vorbei. Dann kann man nicht mehr alles verstehen.

01:00:10.570 --> 01:00:18.090
Dann sind die Sachen hoffentlich irgendwie gekapselt und dann will man auch gar nicht mehr wissen, was da hinten passiert. Vielleicht muss ich das wissen für meine Sache, weil es irgendwas gibt, was halt noch keiner weiß.

01:00:18.090 --> 01:00:23.250
Vielleicht nochmal die Definitionsdinge. Finite State Machine.

01:00:24.870 --> 01:00:26.530
Deutsch ist endlicher Automat.

01:00:26.890 --> 01:00:29.850
Genau, also einen endlichen Automaten kann man quasi auf alles dann abbilden.

01:00:30.110 --> 01:00:31.470
Was ist denn mit unendlichen Automaten?

01:00:31.570 --> 01:00:33.310
Nein, du kannst damit nicht alles machen.

01:00:34.510 --> 01:00:40.090
Also endliche Automaten zum Beispiel, also etwas, was quasi äquivalent ist, sind reguläre Ausdrücke.

01:00:41.350 --> 01:00:45.510
Das ist halt auch eigentlich, wobei reguläre Ausdrücke, je nach Implementation, da gibt es auch noch ein bisschen mehr, was man machen kann.

01:00:45.510 --> 01:01:14.710
Aber das ist halt, ja, also wenn man endlich einen Automat hat, die Sprachen, die theoretische Informatik, hoffentlich rede ich nicht allzu großen Unsinn, das ist alles schon sehr lange her, aber im Grunde, wenn du endlich einen Automaten hast, dann sind die Sprachen, von denen akzeptiert werden, heißen regulär und deswegen auch reguläre Ausdrücke, weil es halt Ausdrücke sind, mit denen du reguläre Sprachen parsen kannst halt.

01:01:15.510 --> 01:01:17.330
aber du kannst damit nicht alles machen.

01:01:17.810 --> 01:01:19.170
Zum Beispiel, was du damit nicht machen kannst,

01:01:19.310 --> 01:01:21.110
sind halt so, also das

01:01:21.110 --> 01:01:23.330
ist immer so Informatik 1

01:01:23.330 --> 01:01:25.390
oder bei mir war das glaube ich

01:01:25.390 --> 01:01:26.770
tatsächlich Informatik 1 Klausur,

01:01:27.430 --> 01:01:29.610
musst du dann beweisen, dass eine bestimmte

01:01:29.610 --> 01:01:31.650
Sprache nicht mit einem endlichen Automaten

01:01:31.650 --> 01:01:33.510
passbar ist. Normalerweise

01:01:33.510 --> 01:01:34.950
nimmt man dann irgendwas, wo es so Klammer gibt.

01:01:35.210 --> 01:01:37.130
Du hast dann eine Sprache, die halt so Klammern hat,

01:01:37.470 --> 01:01:39.270
wo halt, ob du hinten eine Klammer zumachst, davon abhängt,

01:01:39.270 --> 01:01:41.290
ob du die vorne aufgemacht hast. Und dann gibt es

01:01:41.290 --> 01:01:43.230
dann so ein Pumpkin-Lammern, heißt das.

01:01:43.550 --> 01:01:45.270
Das kann man dann benutzen, um zu zeigen,

01:01:45.410 --> 01:01:46.770
dass man

01:01:46.770 --> 01:01:48.790
in keinem endlichen Automaten das parsen kann,

01:01:49.170 --> 01:01:50.250
weil man sich nicht merken kann,

01:01:50.930 --> 01:01:52.650
wie das...

01:01:52.650 --> 01:01:54.510
Dafür braucht man dann halt so einen Stack-Automaten

01:01:54.510 --> 01:01:56.090
oder irgendwie sowas.

01:01:56.710 --> 01:01:57.670
Was ist ein Stack-Automat?

01:01:57.810 --> 01:01:59.850
Wie gesagt, ich kenne keine theoretische Informatik.

01:02:00.450 --> 01:02:01.690
Was ist ein Stack-Automat?

01:02:02.170 --> 01:02:03.490
Ja, so ein Ding, was halt einen Speicher hat.

01:02:03.910 --> 01:02:05.970
Also einfach noch tatsächlich einen Stapel, den es gibt.

01:02:06.450 --> 01:02:06.570
Okay.

01:02:07.950 --> 01:02:09.070
Warum ist das Ding Automat?

01:02:10.230 --> 01:02:12.030
Ja, ich weiß gar nicht, ob das Stapelmaschine

01:02:12.030 --> 01:02:14.170
vielleicht auch, ich weiß es nicht genau, ich weiß gar nicht, ob das Automat heißt.

01:02:14.390 --> 01:02:18.570
Also alles, was halt dann ein unendlicher Automat quasi ist,

01:02:19.110 --> 01:02:21.750
das hat halt dann States, die du vorher nicht kennst oder sowas.

01:02:21.870 --> 01:02:25.150
Oder worum geht es da, dass du das nicht vorher wegdefinieren kannst?

01:02:25.370 --> 01:02:28.630
Nein, du musst dir halt sozusagen merken, was passiert ist.

01:02:28.710 --> 01:02:30.290
Das kannst du im eigentlichen Automaten nicht machen.

01:02:30.450 --> 01:02:33.650
Da hast du halt Zustände, die sind endlich und du kannst zwischen denen wechseln.

01:02:33.910 --> 01:02:36.350
Aber du kannst dir jetzt nicht merken, wo du schon überlang gelaufen bist oder so.

01:02:36.450 --> 01:02:37.710
Oder ob du Klammern aufgemacht hast oder nicht.

01:02:38.090 --> 01:02:38.990
Das geht halt nicht.

01:02:40.110 --> 01:02:41.630
Und genau, das nächste, also

01:02:41.630 --> 01:02:43.630
gehen wir mal die Dinger durch

01:02:43.630 --> 01:02:45.490
bei der theoretischen Informatik.

01:02:45.750 --> 01:02:47.310
Das zweite ist halt dann sozusagen Stackmaschinen.

01:02:48.130 --> 01:02:49.790
Damit kannst du halt dann kontextfrei Grammatiken

01:02:49.790 --> 01:02:51.530
parsen und dann gibt es halt noch

01:02:51.530 --> 01:02:53.810
Kontextsensitiv. Dafür brauchst du dann schon

01:02:53.810 --> 01:02:55.850
Loop-Rechenbar oder

01:02:55.850 --> 01:02:57.650
sowas und dann irgendwie gibt es noch

01:02:57.650 --> 01:02:59.570
irgendwie alles

01:02:59.570 --> 01:03:01.830
irgendwie und

01:03:01.830 --> 01:03:03.850
dafür brauchst du dann Turing-Maschinen. Oder halt

01:03:03.850 --> 01:03:05.710
ein While-Programm oder ein Vorprogramm oder was auch immer.

01:03:05.970 --> 01:03:07.170
Okay, also nochmal jetzt vielleicht

01:03:07.170 --> 01:03:09.430
zum Abschließen, was eine Turing-Maschine ist.

01:03:10.110 --> 01:03:18.970
Oh Gott, eine Turing-Maschine, ein Siebentuppel aus Sprache, Grammatik, Terminalsymbolen, Nicht-Terminalsymbolen, keine Ahnung, weiß ich nicht, Alphabet.

01:03:20.030 --> 01:03:28.750
Ja, also im Grunde das Ding, was halt sozusagen die Informatik als Fach irgendwie so ein bisschen begründet hat damals, 1937, gab es das Paper, glaube ich.

01:03:28.950 --> 01:03:30.070
Von Neumann-Architektur?

01:03:30.190 --> 01:03:30.710
Nein, nein, nein.

01:03:30.730 --> 01:03:31.630
Nein, nein, nein, du weißt was anderes.

01:03:31.790 --> 01:03:32.450
Das war ganz anders.

01:03:33.570 --> 01:03:34.190
Was ist das?

01:03:34.190 --> 01:03:52.630
Das ist, von all meinen Architekturen ist das halt Hauptspeicher, also dass der Speicher für Daten und Programme der gleiche ist, mehr oder weniger. Aber das ist halt wie eine Rechnerarchitektur, aber das ist halt Hardware, das ist Turing-Maschine, das ist ein theoretisches Konstrukt.

01:03:53.730 --> 01:03:55.010
Wie gesagt, das hat Turing da

01:03:55.010 --> 01:03:56.130
1930 veröffentlicht.

01:03:57.230 --> 01:03:58.150
Ich glaube, das Paper hieß

01:03:58.150 --> 01:04:01.250
On Computable

01:04:01.250 --> 01:04:02.990
Numbers with an Application to the

01:04:02.990 --> 01:04:04.370
Entscheidungsproblem oder sowas.

01:04:05.210 --> 01:04:06.950
Da hat er das Ding halt vorgestellt

01:04:06.950 --> 01:04:09.090
und in dem Paper bewiesen, dass

01:04:09.090 --> 01:04:10.130
das Problem

01:04:10.130 --> 01:04:11.990
nicht entscheidbar ist.

01:04:13.450 --> 01:04:14.810
Also ja, und genau.

01:04:14.930 --> 01:04:16.270
Das hat eigentlich die Informatik begründet.

01:04:17.330 --> 01:04:17.810
Beziehungsweise

01:04:17.810 --> 01:04:20.950
es gibt da halt noch irgendwie

01:04:20.950 --> 01:04:23.130
ein Paper zu Lambda-Kalkulus

01:04:23.130 --> 01:04:24.850
von Church. Das ist ein bisschen später rausgekommen.

01:04:24.950 --> 01:04:26.390
Das ist eigentlich ein Stückchen eleganter, aber

01:04:26.390 --> 01:04:27.650
ja.

01:04:30.610 --> 01:04:30.970
Ja.

01:04:31.770 --> 01:04:33.010
Aber genau, also das

01:04:33.010 --> 01:04:35.290
Typ 0 Sprachen,

01:04:35.430 --> 01:04:36.950
also mit der Turing-Maschine kannst du halt

01:04:36.950 --> 01:04:38.610
alles parsen, was du auch parsen kannst.

01:04:39.250 --> 01:04:41.070
Und mit einem regulären, also mit

01:04:41.070 --> 01:04:42.310
einem regulären

01:04:42.310 --> 01:04:44.910
Automaten, also

01:04:44.910 --> 01:04:46.990
mit einem endlichen Automaten halt nicht, sondern nur

01:04:46.990 --> 01:04:48.930
ganz spezielle Sachen. Aber

01:04:48.930 --> 01:04:50.730
trotzdem kannst du wahrscheinlich eine Menge damit abbilden.

01:04:50.730 --> 01:04:52.190
Ja, ich meine, so ist es nicht.

01:04:52.510 --> 01:04:55.810
Ja, vor allem in meinem Case ging es ja wirklich auch tatsächlich um Business Flows.

01:04:56.050 --> 01:04:56.130
Ja.

01:04:56.690 --> 01:05:16.270
Und ich glaube, das Interessante an Business Flows ist, weil das halt wirklich eine Sache ist, man muss ja dann im Endeffekt die gelebte Realität von dem Kunden oder von demjenigen, für den man das baut, muss man ja halt wirklich eins zu eins spiegeln, ohne dass man wirklich genau weiß, was die da eigentlich tun.

01:05:16.270 --> 01:05:33.890
Also wenn man jetzt, keine Ahnung, wenn es darum geht, verschicke E-Mails, dann ist das Ergebnis wichtig. Aber bei der Geschäftslogik, beim Geschäftsmodell, muss man tatsächlich das nachbauen. Also da kommt irgendwas daher, da werden irgendwie Daten reingegeben, dann wird mit den Daten irgendwas gemacht, dann wandert das irgendwo weiter hin.

01:05:34.630 --> 01:05:46.130
Und das ist, glaube ich, so der spannende Punkt, warum da halt zum Beispiel, ich meine, es gibt doch bestimmt noch 50 andere schlaue Ideen, wie man da umgehen kann, aber halt damit mit diesen endlichen Automaten halt schon mehr Struktur reinbringen kann.

01:05:46.130 --> 01:06:07.130
Ich glaube, wenn man das halt auch von Anfang an sich für irgendwas entscheidet und nicht halt sagt, wir machen das halt, wie ich halt den ganzen normalen Code programmieren würde, glaube ich, da kann man sich sehr viel Knater sparen und hat bestimmt zwei, drei Jahre Entwicklungszeit Entspannung vom, also quasi ein bisschen Schutz vor tiefgreifendem Refactoring.

01:06:08.730 --> 01:06:11.090
Ja, nee, klar, also es ist ...

01:06:11.090 --> 01:06:16.650
Um Refactoring zu vermeiden, aber das wäre jetzt aber auch nur Refactoring vermeiden, was quasi Bugs entfernt und die Features sicherer macht.

01:06:17.210 --> 01:06:23.010
Aber das wäre jetzt nicht das Refactoring, was keinen Style schöner macht, Namenskonventionen besser einhält, dokumentierbarer macht.

01:06:23.510 --> 01:06:25.970
Ja, okay, stimmt, das ist natürlich auch eine Art von Refactoring, ja.

01:06:25.970 --> 01:06:34.650
Ja, man kann auch quasi irgendwas, also wenn man das übergibt, also wenn ich jetzt selber was geschrieben habe, was ich mich gut mit auskenne, ist es ja was anderes, als wenn jetzt jemand anders das benutzen muss.

01:06:34.650 --> 01:06:40.750
Und wenn man halt seinen Krug in einen Zustand versetzt, in der er halt irgendwie auch gut übergiebbar ist, dass halt jeder damit arbeiten kann.

01:06:41.550 --> 01:06:48.970
Ja, wobei man da ein bisschen vorsichtig sein muss. Ich meine, da geht es dann quasi um, würde ich mal sagen, Konsistenz.

01:06:49.850 --> 01:06:58.570
Und da ist leider, also meine persönliche Ansicht dazu ist, konsistent ist es dann so, ist es dann, wenn es mir gefällt.

01:07:01.310 --> 01:07:02.430
Taste kann man nicht schreiten.

01:07:02.430 --> 01:07:05.570
Aber das Problem ist halt,

01:07:05.610 --> 01:07:06.030
das habe ich ja auch mit...

01:07:06.030 --> 01:07:06.690
Wenn man seinen eigenen Code anguckt,

01:07:06.730 --> 01:07:07.610
der einem selber nicht mehr gefällt.

01:07:07.710 --> 01:07:10.490
Ja, aber wenn man so in Codebasen guckt,

01:07:10.610 --> 01:07:11.570
die es da so gibt

01:07:11.570 --> 01:07:12.290
und sich denkt so,

01:07:12.350 --> 01:07:13.390
oh, das ist alles ganz schrecklich,

01:07:13.850 --> 01:07:14.530
dann habe ich so den,

01:07:14.970 --> 01:07:16.990
dann zuerst fängt das Augenlid an zu zucken

01:07:16.990 --> 01:07:19.910
und dann irgendwann lasse ich Black

01:07:19.910 --> 01:07:20.750
über alles drüber laufen.

01:07:22.170 --> 01:07:23.610
Ja, ich kenne das aber auch von Jochen,

01:07:23.650 --> 01:07:24.210
das ist immer ganz super.

01:07:24.350 --> 01:07:25.990
Also er hat ja immer netterweise

01:07:25.990 --> 01:07:27.530
ein paar Sachen von mir mal korrigiert und so.

01:07:27.890 --> 01:07:28.410
Und ganz am Anfang war es so,

01:07:28.530 --> 01:07:29.190
äh, was ist das denn?

01:07:29.350 --> 01:07:30.250
Das geht ja überhaupt nicht.

01:07:30.330 --> 01:07:31.270
Alles wegschmeißen, neu machen.

01:07:31.330 --> 01:07:32.170
Nee, nee, kann man nichts mehr retten.

01:07:32.430 --> 01:07:34.690
wieder angefangen, neu gemacht und das ging dann so ein paar

01:07:34.690 --> 01:07:36.630
Mal, wieder wegschmeißen, nochmal weg. Und dann irgendwann

01:07:36.630 --> 01:07:37.770
hat er gesagt, ah, was ist denn das?

01:07:39.050 --> 01:07:40.330
Ja, das habe ich von dir kopiert.

01:07:43.030 --> 01:07:44.550
Ja, das mag sein, dass das

01:07:44.550 --> 01:07:45.150
vorkommt.

01:07:46.770 --> 01:07:48.250
Manchmal ist es auch einfach Quatsch.

01:07:48.470 --> 01:07:49.970
Da hat man sich so dran gewöhnt, dass irgendwie

01:07:49.970 --> 01:07:52.130
und dann macht man hinterher

01:07:52.130 --> 01:07:54.350
irgendwas dann falsch, wenn man

01:07:54.350 --> 01:07:56.470
davon ausgeht, dass es sowieso irgendwie nicht richtig ist.

01:07:56.550 --> 01:07:57.710
Man muss aufpassen, das ist nicht so einfach.

01:07:58.110 --> 01:07:59.890
Aber genau, also

01:07:59.890 --> 01:08:02.430
Also ja, ich tendiere dazu, das dann so zu machen.

01:08:02.530 --> 01:08:03.570
Ich glaube aber, es ist falsch.

01:08:03.890 --> 01:08:07.430
Ich glaube es ist, und eben auch da das Buch würde sagen,

01:08:07.770 --> 01:08:12.650
ja, Konsistenz wichtiger, weil es halt für Leute wichtiger ist,

01:08:12.710 --> 01:08:15.110
das zu verstehen und dass es genauso ist, wie sie das halt kennen,

01:08:15.510 --> 01:08:16.490
als dass es richtig ist.

01:08:16.590 --> 01:08:19.450
Weil richtig ist halt kein guter Wert quasi.

01:08:20.250 --> 01:08:21.770
Oder es senkt halt nicht die Komplexität.

01:08:21.890 --> 01:08:22.430
Also es kommt darauf an.

01:08:22.430 --> 01:08:26.330
Also ich meine, es gibt natürlich Situationen, in denen es so schlimm ist,

01:08:26.330 --> 01:08:27.130
da muss man halt was machen.

01:08:27.610 --> 01:08:29.390
Aber wenn es

01:08:29.390 --> 01:08:31.530
jetzt sozusagen nur unschön

01:08:31.530 --> 01:08:33.410
ist, aber halt in sich konsistent, dann ist

01:08:33.410 --> 01:08:35.190
es wahrscheinlich besser, das so zu lassen,

01:08:35.390 --> 01:08:37.390
weil es senkt halt

01:08:37.390 --> 01:08:39.370
nicht, also die Konsistenz

01:08:39.370 --> 01:08:41.350
zu brechen, erhöht halt die Komplexität

01:08:41.350 --> 01:08:42.270
ganz sicher, während

01:08:42.270 --> 01:08:44.530
das anders zu machen

01:08:44.530 --> 01:08:47.410
verringert die Komplexität vielleicht ein bisschen,

01:08:47.610 --> 01:08:48.390
aber wahrscheinlich

01:08:48.390 --> 01:08:51.290
gleicht das nicht das aus, dass man das dann halt

01:08:51.290 --> 01:08:53.310
inkonsistent gemacht hat und damit dann komplexer.

01:08:53.410 --> 01:08:54.770
Also, ja, es ist blöd.

01:08:55.050 --> 01:08:56.430
Das ist ja generell auch ein Problem,

01:08:57.010 --> 01:09:00.450
dass wenn man jetzt ein altes, gewachsenes Projekt hat,

01:09:00.750 --> 01:09:03.030
das man dann vielleicht im schlimmsten Fall übernimmt,

01:09:03.130 --> 01:09:05.090
aber vielleicht auch, wo man halt auch schon selber lange dran arbeitet

01:09:05.090 --> 01:09:06.330
und irgendwann kommt dann jetzt der Impuls,

01:09:06.850 --> 01:09:08.750
wir müssen da jetzt mal irgendwie anfangen, Sachen besser zu machen,

01:09:08.790 --> 01:09:09.750
das geht so nicht mehr weiter.

01:09:10.310 --> 01:09:13.350
Und da ist dann ja auch bei vielen motivierten Entwicklern,

01:09:13.390 --> 01:09:14.410
wie das bei mir früher auch so war,

01:09:14.470 --> 01:09:16.830
man geht dann und sagt, okay, machen wir irgendwie so gefühlt alles neu.

01:09:17.070 --> 01:09:18.750
Und dann fängt man irgendwie sieben Baustellen an

01:09:18.750 --> 01:09:21.190
und das klappt halt einfach nicht.

01:09:21.270 --> 01:09:22.770
Also ich glaube, die größte Kunst,

01:09:22.890 --> 01:09:25.010
wenn man wirklich so ein altes Projekt retten möchte,

01:09:25.930 --> 01:09:26.750
ist wirklich

01:09:26.750 --> 01:09:29.430
sich zu überlegen, wie kriege ich

01:09:29.430 --> 01:09:30.750
die Patterns, die ich möchte,

01:09:31.790 --> 01:09:33.290
unter den Nebenbedingungen meines

01:09:33.290 --> 01:09:35.550
Projektes, ohne dass ich quasi alles anzünden

01:09:35.550 --> 01:09:36.830
muss und ...

01:09:36.830 --> 01:09:38.810
Oh oh, lieber die Finger vorn lassen,

01:09:39.150 --> 01:09:41.330
das ist zu viel. Also ich habe tatsächlich

01:09:41.330 --> 01:09:42.950
mal jahrelang auf einem

01:09:42.950 --> 01:09:45.190
wirklich komplett von der grünen Wiese

01:09:45.190 --> 01:09:47.450
gewachsenen Plain-PHP-Projekt gearbeitet.

01:09:47.550 --> 01:09:49.310
Das war halt einfach, das war vorne und hinten

01:09:49.310 --> 01:09:51.310
eine Katastrophe. Also die Code-Basis war

01:09:51.310 --> 01:09:53.550
wirklich, wirklich schlimm. Da gab es nie irgendjemand,

01:09:53.630 --> 01:09:54.890
der drüber geguckt hat. Das waren alles,

01:09:55.190 --> 01:09:57.090
im Endeffekt alles von Freelancern gebaut, die, genau wie

01:09:57.090 --> 01:09:59.070
du es gerade gesagt hast, halt die dafür bezahlt wurden,

01:09:59.150 --> 01:10:01.090
möglichst schnelle Feature abzuliefern und dann nach mir

01:10:01.090 --> 01:10:03.110
die Sintflut. Böse, ich meine, nicht bei

01:10:03.110 --> 01:10:05.110
allen, aber es gab auf jeden Fall Leute und wenn du halt

01:10:05.110 --> 01:10:07.090
einen so im Team hast, dann ist halt schwierig.

01:10:08.190 --> 01:10:08.990
Ich habe einen Freund,

01:10:09.050 --> 01:10:10.750
einen Entwickler aus Malawi, der halt so

01:10:10.750 --> 01:10:13.090
versucht, günstige Aufträge ranzubekommen und

01:10:13.090 --> 01:10:15.090
weil die Kunden, die er hat, dann relativ wenig Budget

01:10:15.090 --> 01:10:16.950
haben und immer ausgeben, merkt man halt auch, welche

01:10:16.950 --> 01:10:18.630
Entwickler sich halt dann leisten können und

01:10:18.630 --> 01:10:20.870
wenn er halt dann so sieht, so die Leute, die

01:10:20.870 --> 01:10:23.110
von denen er das aufräumen

01:10:23.110 --> 01:10:25.030
muss, dass wenn er selber nicht weiß, worum es geht und die haben dann teilweise

01:10:25.030 --> 01:10:27.270
Panda selbst implementiert, weil sie nicht wussten, was das dann gab

01:10:27.270 --> 01:10:29.090
und hat so Sachen selber geschrieben und

01:10:29.090 --> 01:10:31.470
vorne auseinanderfallen, unheimlich viel Spaghetti-Zeug

01:10:31.470 --> 01:10:32.710
und das dann neu zu machen.

01:10:33.150 --> 01:10:35.130
Also die Arbeit, die hat, er ist

01:10:35.130 --> 01:10:37.270
die ganze Zeit am Limit und weiß überhaupt nicht, was da passiert.

01:10:37.410 --> 01:10:38.950
Das ist unheimlich schwierig, das besser zu machen

01:10:38.950 --> 01:10:40.950
und das zu refactoren, aber ich glaube, da ist dann

01:10:40.950 --> 01:10:43.110
gotische Knoten besser gelöst, indem man

01:10:43.110 --> 01:10:45.150
manchmal tatsächlich dann durchschneidet

01:10:45.150 --> 01:10:46.970
oder halt einfach verbrannte Erde hinterlässt und das

01:10:46.970 --> 01:10:49.130
neu anfängt oder so. Also es gibt es

01:10:49.130 --> 01:10:50.490
auf jeden Fall, aber

01:10:50.490 --> 01:10:53.090
es ist ja leider, zum Beispiel

01:10:53.090 --> 01:10:54.750
bei vielen Firmen, die so vor

01:10:54.750 --> 01:10:57.170
vor, weiß ich nicht, 10 Jahren, 15 Jahren

01:10:57.170 --> 01:10:59.350
angefangen haben und einfach ihr Geschäftsmittel

01:10:59.350 --> 01:11:01.050
irgendwie implementiert haben. Da wurde ja die

01:11:01.050 --> 01:11:02.850
meistens, oder vor allem auch so Frühzeiten des Web,

01:11:03.190 --> 01:11:04.930
da sind ja einfach sehr, sehr viele schlimme Dinge

01:11:04.930 --> 01:11:07.010
passiert. Da gab es auch teilweise noch keine

01:11:07.010 --> 01:11:08.930
Frameworks, das waren Leute, die dann

01:11:08.930 --> 01:11:10.730
nicht so richtig wussten, was sie da tun.

01:11:12.030 --> 01:11:12.390
Und

01:11:12.390 --> 01:11:14.890
das Problem ist aber, dass halt, weil

01:11:14.890 --> 01:11:17.010
halt auch da in der Firma dann nie jemand ist, der dann wirklich

01:11:17.010 --> 01:11:18.950
da versucht, das

01:11:18.950 --> 01:11:20.650
kontinuierlich besser zu machen. Dann kommt halt irgendwann,

01:11:20.650 --> 01:11:22.290
okay, es geht nicht mehr, ja, weiß ich nicht,

01:11:22.350 --> 01:11:23.730
ein Formular anpassen dauert eine Woche,

01:11:23.950 --> 01:11:25.150
wir müssen irgendwas machen.

01:11:25.970 --> 01:11:27.870
Und das ist halt dann, dass diese Firmen dann halt

01:11:27.870 --> 01:11:29.890
in so einem Deadlock sind, dass die halt nicht das Budget

01:11:29.890 --> 01:11:31.650
haben, diese riesige gewachsene Software mit

01:11:31.650 --> 01:11:34.130
28.000 Sonderfällen neu implementieren

01:11:34.130 --> 01:11:35.650
zu können, aber es geht auch nicht weiter.

01:11:36.130 --> 01:11:37.930
Und das ist halt genau der Fall und ich glaube, das ist ein sehr

01:11:37.930 --> 01:11:39.850
häufiger Fall, insbesondere

01:11:39.850 --> 01:11:41.750
wenn das halt so eine Software ist, die halt wirklich

01:11:41.750 --> 01:11:43.830
in-house dann für sich selbst entwickelt wurde,

01:11:44.590 --> 01:11:45.770
dass man da, da ist

01:11:45.770 --> 01:11:47.830
super wichtig, dass man reflektiert, das ist super wichtig, dass

01:11:47.830 --> 01:11:49.710
man, also vor allem, ich finde in solchen Fällen

01:11:49.710 --> 01:11:51.630
das Einzige, was einen irgendwie motivieren kann, an diesem

01:11:51.630 --> 01:11:53.450
Projekt zu arbeiten, dass man halt versucht, die

01:11:53.450 --> 01:11:55.610
Herausforderung halt anzunehmen und das irgendwie besser zu

01:11:55.610 --> 01:11:57.530
machen kontinuierlich. Und da ist es halt einfach

01:11:57.530 --> 01:11:59.510
super wichtig, dass man sich Patterns überlegt. Also beispielsweise

01:11:59.510 --> 01:12:01.170
bei diesem alten Plain PHP Ding

01:12:01.170 --> 01:12:03.630
war halt auch, das war halt einfach

01:12:03.630 --> 01:12:05.630
eine Kette von Skripten, die eingebunden

01:12:05.630 --> 01:12:07.570
wurden. Eine N-lange Liste.

01:12:07.670 --> 01:12:09.570
Niemand wusste genau, was da oben

01:12:09.570 --> 01:12:11.590
kommt und was unten kommt. Du hattest keinen Variablen

01:12:11.590 --> 01:12:13.750
Scope. Also das kann man sich nicht vorstellen, was das

01:12:13.750 --> 01:12:15.590
für ein Segen ist, dass man einen Variablen

01:12:15.590 --> 01:12:17.450
Scope hat. Und im Endeffekt

01:12:17.450 --> 01:12:19.490
habe ich dann, das war das, wo ich

01:12:19.490 --> 01:12:21.350
dann so mich am meisten darüber gefreut habe,

01:12:21.390 --> 01:12:23.110
dass es funktioniert hat. Ich habe mir im Endeffekt

01:12:23.110 --> 01:12:25.190
Django Class-Based Views in klein nachgebaut

01:12:25.190 --> 01:12:27.230
und es war ein Segen. Und es war

01:12:27.230 --> 01:12:28.970
im Endeffekt, das halt einmal zu bauen,

01:12:29.150 --> 01:12:31.110
also mir im Endeffekt grob abzugucken und dann

01:12:31.110 --> 01:12:33.090
halt ein bisschen fein zu schleifen, war ich in zwei, drei Tagen

01:12:33.090 --> 01:12:34.450
durch. Das war jetzt echt nicht viel Arbeit.

01:12:34.930 --> 01:12:37.110
Jedes Mal, wenn ich halt an irgendeinem View

01:12:37.110 --> 01:12:39.270
dran war, also View in Gänsefüßchen,

01:12:39.710 --> 01:12:41.590
letzte Skript der Reihe,

01:12:41.630 --> 01:12:43.050
habe ich halt dann einfach, okay,

01:12:43.130 --> 01:12:45.070
jetzt stelle ich das einfach oben. Habe ich dann mit dem Kunden noch

01:12:45.070 --> 01:12:47.210
abgesprochen, das hat dann auch meistens nicht rasend

01:12:47.210 --> 01:12:49.050
viel, weil es meistens nur einsortieren war. Ich habe gar nicht

01:12:49.050 --> 01:12:51.050
zum Code wirklich gemacht, aber da ich das dann

01:12:51.050 --> 01:12:53.050
plötzlich Scope hatte, konnte auch die IDE

01:12:53.050 --> 01:12:55.130
plötzlich mit Variablen arbeiten, hat einem

01:12:55.130 --> 01:12:56.890
plötzlich zum Beispiel gesagt, ey, da sind ganz viele, da ist ein

01:12:56.890 --> 01:12:58.970
ganzer, weiß ich nicht, 100-Zeilen-Zweig in diesem

01:12:58.970 --> 01:13:00.870
Dings, die Variable wird gar nicht gesetzt,

01:13:00.970 --> 01:13:02.930
die kommt nirgendwo her, das gibt's

01:13:02.930 --> 01:13:04.630
gar nicht, das kann man einfach rauswerfen, ja, also

01:13:04.630 --> 01:13:06.810
das war im Endeffekt mehr oder weniger eine

01:13:06.810 --> 01:13:08.010
Kleinigkeit und das war

01:13:08.010 --> 01:13:10.630
so ein Gewinn für dieses Projekt,

01:13:11.190 --> 01:13:12.590
weil, wie gesagt, man wusste

01:13:12.590 --> 01:13:14.950
was diese Views, man hat angefangen, man konnte,

01:13:15.030 --> 01:13:17.110
man wusste auch erst mal, wie ich überhaupt anfangen soll, aufzuräumen,

01:13:17.190 --> 01:13:17.350
ja.

01:13:18.930 --> 01:13:20.490
Ja, so unterschiedlich ist die, ne, ich hab

01:13:20.490 --> 01:13:23.110
da gehört. Also es gibt Leute auf der Welt,

01:13:23.210 --> 01:13:24.010
programmieren unterschiedlich.

01:13:24.910 --> 01:13:26.870
Zum Beispiel, ich habe jetzt von einem Freund gehört, der

01:13:26.870 --> 01:13:29.070
mit Ukrainen relativ viel zu tun hat,

01:13:29.170 --> 01:13:30.790
also wirklich, die dann lange Jahre schon

01:13:30.790 --> 01:13:33.110
so Auftragsarbeit machen für europäische Kunden

01:13:33.110 --> 01:13:34.630
oder sowas und die sich jetzt halt

01:13:34.630 --> 01:13:36.910
auf internationalen Vergleich da irgendwie gucken,

01:13:37.030 --> 01:13:38.830
wie das dann so aussieht. Und da gibt es Firmen aus

01:13:38.830 --> 01:13:40.890
anderen Teilen der Welt, irgendwo aus Asien oder sowas,

01:13:40.970 --> 01:13:43.010
die entweder nur genau das machen, was sie aufgeschrieben haben

01:13:43.010 --> 01:13:44.810
und halt nur genau

01:13:44.810 --> 01:13:46.750
Definition, das heißt, du brauchst ultra lange, wenn du

01:13:46.750 --> 01:13:49.030
mit dem zusammenarbeitest, um diese Definition aufzuschreiben,

01:13:49.150 --> 01:13:51.050
weil alles, was da nicht drin steht, das wird

01:13:51.050 --> 01:13:52.410
halt nicht gemacht. Das ist halt blöd.

01:13:54.370 --> 01:13:55.150
Oder die halt

01:13:55.150 --> 01:13:56.490
diese Abstraktions-Levels nicht benutzen.

01:13:57.650 --> 01:13:59.170
Auch vor allem aus dem anderen asiatischen

01:13:59.170 --> 01:14:00.710
Raum, wo du halt dann da stehst und

01:14:00.710 --> 01:14:03.150
anstatt, dass du so einen Pattern

01:14:03.150 --> 01:14:04.950
jetzt halt hast und eine abstrakte Klasse,

01:14:05.030 --> 01:14:06.770
dass du schreibst, werden halt alle

01:14:06.770 --> 01:14:08.810
100 einzelne Möglichkeiten

01:14:08.810 --> 01:14:10.910
einzeln implementiert. Und dann so, ja, kommen ja

01:14:10.910 --> 01:14:12.710
noch weitere, ja, 900 dazu,

01:14:12.870 --> 01:14:14.630
vielleicht wäre ein Abstraktionsniveau sinnvoll.

01:14:14.970 --> 01:14:16.390
Nur, nur, die 900 machen wir dann auch ganz schnell.

01:14:18.230 --> 01:14:18.790
So halt.

01:14:18.870 --> 01:14:20.870
das ist halt dann schwierig. Also wenn man das halt dann refactored,

01:14:20.950 --> 01:14:22.770
dann ist halt unheimlich viel Fleißarbeit auch dann.

01:14:23.250 --> 01:14:24.610
Wie man das irgendwie dann versucht

01:14:24.610 --> 01:14:26.590
zu modulisieren, auseinanderziehen.

01:14:26.890 --> 01:14:29.050
Ist Refactoring auseinanderziehen

01:14:29.050 --> 01:14:31.050
oder Extraktion? Ich weiß nicht.

01:14:31.970 --> 01:14:33.010
Ich glaube, es sind halt viele Facetten,

01:14:33.150 --> 01:14:34.770
oder? Ja. Ist auf jeden Fall eine davon.

01:14:35.290 --> 01:14:36.970
Ja. Ich würde sagen,

01:14:37.090 --> 01:14:39.050
eben, das ist halt, letztlich sollte es halt

01:14:39.050 --> 01:14:41.050
dazu führen, dass die Komplexität vom Gesamtsystem

01:14:41.050 --> 01:14:43.010
geringer wird. Und wenn du halt,

01:14:43.650 --> 01:14:45.290
dann ist halt die Frage, was ist Komplexität

01:14:45.290 --> 01:14:47.070
eigentlich? Ja, don't repeat yourself vielleicht auch.

01:14:47.470 --> 01:15:10.830
Genau, wenn du das jetzt so implementierst, also nehmen wir diesen Fall, du machst halt nicht eine generelle Lösung für irgendwas, sondern du hast halt dann 900 Spezialfälle, dann sieht das ja erstmal gar nicht so schlimm aus, aber tatsächlich, wenn du jetzt etwas hast, was all diese Fälle betrifft, quasi etwas, was du zum Beispiel immer tun musst, dann musst du die alle anfassen.

01:15:11.270 --> 01:15:12.850
Das heißt, du hast eine Abhängigkeit

01:15:12.850 --> 01:15:14.130
zwischen allen,

01:15:14.810 --> 01:15:16.430
die nicht sichtbar ist.

01:15:18.770 --> 01:15:20.770
Wir sind schon wieder bei Sennoff Heißen

01:15:20.770 --> 01:15:22.170
und können jetzt hier die Liste wieder runterbieten.

01:15:23.250 --> 01:15:24.610
Das Beispiel hier

01:15:24.610 --> 01:15:26.650
in dem Buch ist sozusagen, wenn du eine Webseite

01:15:26.650 --> 01:15:28.750
mit ein paar tausend Seiten hast und du hast

01:15:28.750 --> 01:15:30.610
halt irgendwo einen Banner da drin, das halt

01:15:30.610 --> 01:15:32.330
eine Hintergrundfarbe hat und

01:15:32.330 --> 01:15:34.570
du hast die jetzt halt einfach von Hand

01:15:34.570 --> 01:15:36.110
gesetzt in allen Seiten.

01:15:36.710 --> 01:15:37.930
Dann hast du halt eine

01:15:37.930 --> 01:15:40.510
implizite Abhängigkeit zwischen allen Seiten,

01:15:40.670 --> 01:15:42.730
weil du kannst diese Farbe nicht mehr ändern,

01:15:42.830 --> 01:15:44.370
ohne alle anderen Sachen anzufassen.

01:15:45.690 --> 01:15:46.570
Besser ist es halt,

01:15:46.610 --> 01:15:48.010
nur eine Abhängigkeit zu haben zu einem

01:15:48.010 --> 01:15:50.450
Modul irgendwie, wo du

01:15:50.450 --> 01:15:51.390
diese Farbe setzen kannst.

01:15:52.410 --> 01:15:54.750
Und dann hast du eine explizite

01:15:54.750 --> 01:15:56.470
Abhängigkeit, das heißt, du siehst auch, dass es die gibt

01:15:56.470 --> 01:15:58.310
und du kannst es an einer Stelle ändern

01:15:58.310 --> 01:15:59.310
und dann ist es halt für alle geändert.

01:15:59.670 --> 01:16:01.590
Das wäre ein Refactoring quasi.

01:16:01.890 --> 01:16:04.310
Es gibt ja so Sprachen, wo das nicht ging,

01:16:04.430 --> 01:16:06.470
zum Beispiel mit Variablen setzen oder so was.

01:16:06.570 --> 01:16:08.170
Also in HTML oder alten CSS oder so was

01:16:08.170 --> 01:16:10.090
waren Variablen ja nicht so einfach zu setzen.

01:16:10.170 --> 01:16:11.670
Keine Ahnung, ich weiß aber auch noch nichts über CSS.

01:16:12.790 --> 01:16:14.070
Das war zum Beispiel dann ein Problem,

01:16:14.170 --> 01:16:16.150
wenn du quasi eine

01:16:16.150 --> 01:16:18.150
Variable, also eine Farbe

01:16:18.150 --> 01:16:20.250
gesetzt hattest, auf eine Farbe, die es schon gab.

01:16:20.830 --> 01:16:22.450
Von zwei verschiedenen Komponenten.

01:16:23.490 --> 01:16:24.290
Weil, wie willst

01:16:24.290 --> 01:16:26.170
du denn jetzt, also das sind, ich weiß nicht, ein paar hundert

01:16:26.170 --> 01:16:28.150
Stellen, wo das auftaucht und die Farbe ist aber immer dieselbe.

01:16:28.490 --> 01:16:29.930
Wie kriegst du denn jetzt raus, was dann war jetzt vorher

01:16:29.930 --> 01:16:32.370
der Hintergrund 2, was war der Hintergrund 1 oder so?

01:16:33.450 --> 01:16:33.970
Solche Dinge,

01:16:34.050 --> 01:16:35.970
das ist halt ziemlich hässlich.

01:16:35.970 --> 01:16:36.230
Ja.

01:16:37.690 --> 01:16:39.350
Aber genau, also ja,

01:16:39.950 --> 01:16:42.470
Das Buch sagt dazu, wo kommt diese Komplexität

01:16:42.470 --> 01:16:43.750
eigentlich her und wie kriegt man sie klein?

01:16:44.550 --> 01:16:46.230
Es gibt eigentlich im Grunde nur zwei Quellen von

01:16:46.230 --> 01:16:48.050
Komplexität. Das eine ist halt solche

01:16:48.050 --> 01:16:48.950
Abhängigkeiten.

01:16:51.050 --> 01:16:52.190
Und das ist halt,

01:16:52.630 --> 01:16:54.190
wenn man viel davon hat, ist halt doof, weil

01:16:54.190 --> 01:16:56.250
das bedeutet halt, wenn du etwas änderst,

01:16:56.310 --> 01:16:58.310
musst du viele andere Sachen, die von allen Abhängigkeiten

01:16:58.310 --> 01:16:58.950
ja auch anfassen.

01:17:00.090 --> 01:17:01.770
Und die zweite Geschichte ist

01:17:01.770 --> 01:17:04.610
Obscurity.

01:17:04.610 --> 01:17:06.130
Ich weiß gar nicht, wie man das am besten übersetzt.

01:17:07.890 --> 01:17:08.330
Undurchsichtigkeit.

01:17:08.570 --> 01:17:09.210
Undurchsichtigkeit, ja.

01:17:09.950 --> 01:17:12.610
Nebel. Obskurität,

01:17:12.750 --> 01:17:13.750
ja, ich weiß nicht, genau.

01:17:14.730 --> 01:17:16.330
Unklarheit, Unklarheit vielleicht, ich weiß

01:17:16.330 --> 01:17:18.310
nicht, naja. Jedenfalls, das ist halt,

01:17:19.010 --> 01:17:19.990
das passiert,

01:17:20.470 --> 01:17:22.530
also, und das sorgt halt für noch schlimmere

01:17:22.530 --> 01:17:24.190
Probleme, das sorgt für so

01:17:24.190 --> 01:17:26.210
Unknown-Unknowns, dass du halt

01:17:26.210 --> 01:17:28.330
gar nicht, also wenn du viele Abhängigkeiten

01:17:28.950 --> 01:17:29.790
hast, ja, nehmen wir an,

01:17:30.130 --> 01:17:32.250
du hast halt irgendwie, du weißt

01:17:32.250 --> 01:17:34.110
halt, wenn du das jetzt änderst, dann musst du das an 100 Stellen

01:17:34.110 --> 01:17:36.210
auch noch anfassen, ja, dann weißt du halt so, oh mein Gott,

01:17:36.330 --> 01:17:38.130
das dauert jetzt lang. Aber was

01:17:38.130 --> 01:17:40.090
dann diese 100 Stellen eigentlich alles machen, das weißt du halt

01:17:40.090 --> 01:17:42.190
nicht vielleicht. Ja, aber wenn du

01:17:42.190 --> 01:17:43.630
genau, zum Beispiel, nehmen wir an, du hast jetzt

01:17:43.630 --> 01:17:46.110
diese eine Abhängigkeit, die sagt, wenn

01:17:46.110 --> 01:17:48.090
du die Hintergrundfarbe von diesem Banner ändern willst, dann

01:17:48.090 --> 01:17:49.990
machst du das hier. Und jetzt hast du aber

01:17:49.990 --> 01:17:51.850
in 10 Dingern, hast du es halt von Hand

01:17:51.850 --> 01:17:54.150
überschrieben. Aber das

01:17:54.150 --> 01:17:55.550
weißt du halt nicht mehr, das ist nicht dokumentiert.

01:17:56.170 --> 01:17:57.610
Dann, das sind halt diese Sachen,

01:17:58.250 --> 01:17:59.870
wo dir dann hinterher auffällt, dass

01:17:59.870 --> 01:18:02.150
ein Kunde sagt dann halt irgendwann so,

01:18:02.210 --> 01:18:04.030
oh, da stimmt aber die Farbe nicht. Wir hatten das

01:18:04.030 --> 01:18:06.050
doch geändert. Wieso ist denn die jetzt da an der Stelle falsch?

01:18:06.690 --> 01:18:07.990
Und dann kriegst du das sozusagen

01:18:07.990 --> 01:18:08.930
als Bugs wieder zurück,

01:18:09.750 --> 01:18:12.070
was du nicht wusstest, dass es

01:18:12.070 --> 01:18:13.310
diese Abhängigkeit gibt, aber die

01:18:13.310 --> 01:18:14.330
war halt nicht so gut.

01:18:14.350 --> 01:18:15.730
dokumentiert. Ja, und dann

01:18:15.730 --> 01:18:18.150
das sind die Schlimmsten, weil

01:18:18.150 --> 01:18:19.110
das Problem ist halt,

01:18:19.790 --> 01:18:22.270
du weißt halt gar nicht, dass du das

01:18:22.270 --> 01:18:23.350
eigentlich hättest machen sollen.

01:18:23.650 --> 01:18:26.150
Ja, was implizit dann tatsächlich einem nicht auf die Füße fällt.

01:18:26.290 --> 01:18:27.350
Ja, und dann ist halt

01:18:27.350 --> 01:18:30.050
die Frage, wo kommt das her und wie kriegt man das

01:18:30.050 --> 01:18:32.250
verhindert? Und oft ist es halt vielleicht Dokumentation.

01:18:32.990 --> 01:18:34.010
Das ist auch etwas, das

01:18:34.010 --> 01:18:35.610
fand ich nett,

01:18:35.910 --> 01:18:37.670
dieses Buch hat meine Einstellung zu

01:18:37.670 --> 01:18:39.550
Kommentaren und Dokumentationen so ein bisschen verändert.

01:18:39.630 --> 01:18:41.670
Jochen schreibt übrigens nie Dokumentation.

01:18:41.670 --> 01:18:43.950
Nein, das wäre nie

01:18:43.950 --> 01:18:45.610
wäre zu hart, nein.

01:18:45.790 --> 01:18:47.610
Ja, der Code erklärt sich selbst und so.

01:18:47.770 --> 01:18:48.830
Ja, okay.

01:18:51.750 --> 01:18:53.650
Aber tatsächlich, ich würde auch sagen, also ja,

01:18:53.690 --> 01:18:55.410
ich meine, es gibt ja da unterschiedliche Ansichten zu, eine

01:18:55.410 --> 01:18:57.630
auch verbreitete, jetzt wenn man mal

01:18:57.630 --> 01:18:59.710
so Clean Code nimmt, auch ein Buch, was sich ja mit solchen

01:18:59.710 --> 01:19:01.670
Themen beschäftigt, von Robert

01:19:01.670 --> 01:19:03.370
Martin, Uncle Bob genannt,

01:19:03.810 --> 01:19:05.650
der sagt ja immer, ja, so

01:19:05.650 --> 01:19:07.530
wenn du einen Kommentar schreibst, gut,

01:19:07.670 --> 01:19:09.470
manchmal lässt sich das nicht vermeiden, musst du halt machen oder

01:19:09.470 --> 01:19:11.250
manchmal musst du halt, aber sei dir

01:19:11.250 --> 01:19:13.470
bewusst, wenn du das tust, das ist im Grunde ein Fehler,

01:19:13.670 --> 01:19:14.970
es ist im Grunde ein Versagen.

01:19:15.230 --> 01:19:17.170
Du hast versagt. Weil,

01:19:17.450 --> 01:19:19.390
wenn du es richtig gemacht hättest, dann hättest du es

01:19:19.390 --> 01:19:21.150
so hingeschrieben, dass man das nicht hätte kommentieren müssen.

01:19:21.890 --> 01:19:23.570
Ein paar Kommentare sind

01:19:23.570 --> 01:19:25.510
natürlich blöd, weil man muss sie halt aktualisieren und anpassen,

01:19:25.690 --> 01:19:27.350
wenn man sie... Ja, du hast halt eine mögliche

01:19:27.350 --> 01:19:29.710
Inkonsistenz auch erzeugt. Ja, genau. Das ist schon doof.

01:19:29.850 --> 01:19:31.490
Also man muss halt echt schon aufpassen. Aber

01:19:31.490 --> 01:19:33.530
es ist einfach an vielen Stellen sehr, sehr hilfreich,

01:19:33.630 --> 01:19:35.230
auch gerade, wenn man kollaborativ arbeitet,

01:19:35.570 --> 01:19:37.550
einmal kurz hinzuschreiben, was denn da passiert,

01:19:37.890 --> 01:19:39.650
warum denn da irgendwas passiert. Ja, absolut.

01:19:40.850 --> 01:19:41.670
Anstatt das halt einfach

01:19:41.670 --> 01:19:42.990
nicht zu machen, weil dann die Leute fragen sich,

01:19:43.050 --> 01:19:44.110
Da wird irgendwo schon abgerufen, warum.

01:19:44.710 --> 01:19:46.550
Oder so, sei es, wenn der Name toll ist und so.

01:19:46.830 --> 01:19:47.050
Ja, absolut.

01:19:47.550 --> 01:19:48.170
Ja, ja.

01:19:48.950 --> 01:19:50.130
Ja, ich muss auch sagen,

01:19:50.330 --> 01:19:55.950
also genau, dieses Buch hier nimmt das auch relativ detailliert auseinander.

01:19:56.990 --> 01:19:58.230
Und da sagt er halt so Sachen wie,

01:19:58.290 --> 01:20:00.750
ja gut, selbst wenn der Code selbst dokumentierend ist,

01:20:00.750 --> 01:20:02.570
dann einmal, du kriegst das Problem,

01:20:02.650 --> 01:20:04.970
die Variablen und die Funktionsnamen werden handelang.

01:20:05.710 --> 01:20:07.370
Du hast das Problem, du schreibst dann,

01:20:07.530 --> 01:20:09.470
wenn das die Dokumentation von deinem Ding ist,

01:20:09.490 --> 01:20:11.710
dann schreibst du die ja an jede Stelle, wo du die verwendest.

01:20:12.470 --> 01:20:14.430
Das ist ja auch Quatsch. Das sollte man ja nicht, also

01:20:14.430 --> 01:20:16.590
das ist ja auch irgendwie offensichtlich Quatsch. Das kann ja

01:20:16.590 --> 01:20:18.590
nicht sein. So, das sollte ja reichen, wenn man

01:20:18.590 --> 01:20:19.910
das an einer Stelle schreibt und dann

01:20:19.910 --> 01:20:22.650
ja, und

01:20:22.650 --> 01:20:24.370
hat halt noch so viele, viele Punkte

01:20:24.370 --> 01:20:26.550
und aber der allerwichtigste

01:20:26.550 --> 01:20:28.550
Punkt eigentlich, wo ich dann auch gedacht habe, okay, ich

01:20:28.550 --> 01:20:30.570
glaube, ich muss meine Einstellung dazu überdenken und vielleicht mal

01:20:30.570 --> 01:20:32.410
anders probieren und mal gucken, vielleicht funktioniert es dann ja anders

01:20:32.410 --> 01:20:33.470
besser, ist

01:20:33.470 --> 01:20:36.290
ja, also eigentlich

01:20:36.290 --> 01:20:38.310
das, was dein Code tut,

01:20:38.790 --> 01:20:39.990
ist eigentlich, oder das

01:20:39.990 --> 01:20:42.270
das Entscheidende beim Design

01:20:42.270 --> 01:20:44.190
von so einem System ist eigentlich nicht so

01:20:44.190 --> 01:20:45.990
sehr, der Code ist eigentlich gar nicht das

01:20:45.990 --> 01:20:47.990
Entscheidende, weil der Code ist halt die Implementation davon,

01:20:48.110 --> 01:20:49.010
aber das ist halt...

01:20:49.010 --> 01:20:51.890
Magie, Call, Call, Magie,

01:20:52.010 --> 01:20:54.010
Call, Magie, Call, Magie, aber was dabei

01:20:54.010 --> 01:20:54.650
rauskommt, ist wichtig.

01:20:54.830 --> 01:20:57.590
Die Abstraktionen sind wichtig und die stehen aber,

01:20:57.890 --> 01:20:59.970
Code ist möglicherweise gar keine so gute

01:20:59.970 --> 01:21:01.950
Art, um das, um diese

01:21:01.950 --> 01:21:03.970
Abstraktionen sichtbar zu machen oder

01:21:03.970 --> 01:21:05.210
irgendwie zu dokumentieren.

01:21:05.930 --> 01:21:07.970
Also natürliche Sprache ist dafür deutlich

01:21:07.970 --> 01:21:09.830
besser geeignet und man

01:21:09.830 --> 01:21:11.690
Eigentlich sollte man sich Gedanken über die Abstraktionen machen.

01:21:12.010 --> 01:21:13.590
Dann schreibt man in natürlicher Sprache hin.

01:21:14.030 --> 01:21:16.270
Und wie man das dann implementiert, ist ja nochmal eine andere Sache.

01:21:16.510 --> 01:21:17.030
Ja, das ist sehr schön.

01:21:17.130 --> 01:21:19.410
Weil bei Python, finde ich, von meinem Empfinden her,

01:21:19.470 --> 01:21:20.430
ich habe natürlich auch keine Ahnung,

01:21:20.750 --> 01:21:23.690
aber die Sprache ist, mit der man am nächsten an natürlicher Sprache

01:21:23.690 --> 01:21:26.310
schreiben kann, entwickeln kann und dass das irgendwie stimmt.

01:21:27.010 --> 01:21:29.270
Bei Sonic, es hört sich für mich irgendwie so ein bisschen mehr nach,

01:21:29.730 --> 01:21:32.590
ich schreibe wirklich was dahin, was ich auch so sagen könnte vielleicht.

01:21:32.790 --> 01:21:33.130
Also ein bisschen.

01:21:34.530 --> 01:21:36.670
Und das ist nicht immer bei allen anderen Sprachen.

01:21:36.770 --> 01:21:36.970
Nö.

01:21:37.270 --> 01:21:37.870
Eigentlich nie.

01:21:37.870 --> 01:21:38.230
Nie.

01:21:39.670 --> 01:22:03.290
Ja, naja, es gibt da ganz unterschiedliche Philosophien. Ich finde das sowieso auch interessant. Bei Go zum Beispiel gibt es auch bekannte, ich weiß jetzt nicht mehr, wie der Talk ist, aber einer, der auch die Sprache mitdesignt hat, der ist halt ein Verfechter von kurzen Variablen-Namen-Nehmen.

01:22:03.290 --> 01:22:04.450
Ja, aber letztens irgendwann

01:22:04.450 --> 01:22:05.650
ein... A, B, C, D und E.

01:22:05.650 --> 01:22:06.830
Auf einer Frostcon.

01:22:08.130 --> 01:22:09.470
Ja, also...

01:22:09.470 --> 01:22:11.690
Ja, also es ist nicht immer gut.

01:22:11.770 --> 01:22:13.070
Es gibt auch einen auf der Frostcon,

01:22:13.430 --> 01:22:15.350
da hatte ich letztens einen getroffen, der hatte

01:22:15.350 --> 01:22:17.430
einen sehr extremen Standpunkt und meinte, das muss mal lang sein.

01:22:17.670 --> 01:22:19.230
Kurze Variablen-Namen, schrecklich.

01:22:19.670 --> 01:22:21.070
Ganz furchtbar, geht gar nicht.

01:22:21.630 --> 01:22:22.250
Das ist schrecklich.

01:22:23.870 --> 01:22:25.470
Manchmal ist das schon nett, also gerade wenn man jetzt

01:22:25.470 --> 01:22:27.610
komplizierte Logik hat,

01:22:27.830 --> 01:22:29.450
dann kann das sein, wenn man lange Variablen

01:22:29.450 --> 01:22:31.270
hat, dann stehen einem die Variablen-Namen im Weg,

01:22:31.350 --> 01:22:32.490
dann sieht man überhaupt nicht mehr, was passiert.

01:22:33.290 --> 01:22:38.690
Das ist ja auch in der Mathematik so, da schreibt man auch eigentlich immer nur ganz kurz Sachen und Formeln so kurz hin.

01:22:38.750 --> 01:22:43.250
Das hat halt auch den Vorteil, dass man das dann auch überblicken kann, wenn man das alles ganz detailliert ausschreiben würde.

01:22:43.270 --> 01:22:49.430
Was ich dann manchmal mache, an der Stelle tatsächlich vorher die Zuweisung, zum Beispiel ED gleich Data vor irgendwas.

01:22:49.770 --> 01:22:52.230
Und dann mache ich dann nicht immer Data vor irgendwas, sondern nur das D.

01:22:52.630 --> 01:22:54.630
Irgendwie so, dann wird das so ein bisschen dadurch klar.

01:22:54.630 --> 01:23:12.470
Ja, genau. Und da macht das Buch auch einen interessanten Vorschlag und sagt so, ja, also der Name sollte umso länger sein, je weiter weg die Variable quasi von ihrem ursprünglichen Ort, wo sie mal definiert wurde, verwendet wird. Also je weiter das weg ist, desto eher musst du halt einen langen Namen nehmen oder desto länger muss der Name sein.

01:23:12.830 --> 01:23:14.470
Aber je näher du da dran bist,

01:23:15.570 --> 01:23:15.770
dann

01:23:15.770 --> 01:23:18.850
kannst du auch kürzere Namen nehmen

01:23:18.850 --> 01:23:19.490
oder sehr kurze.

01:23:21.850 --> 01:23:22.250
Weil

01:23:22.250 --> 01:23:24.230
dann ja immer noch alles im Blick ist.

01:23:24.630 --> 01:23:26.710
Du siehst halt, was da passiert

01:23:26.710 --> 01:23:27.670
irgendwie sofort.

01:23:28.950 --> 01:23:30.670
Also Readability Counts, das ist ja auch wieder

01:23:30.670 --> 01:23:31.750
so eine Sache, außer auf Python.

01:23:34.390 --> 01:23:35.150
Naja, also

01:23:35.150 --> 01:23:37.170
ja, das ist schon faszinierend.

01:23:37.930 --> 01:23:38.670
Genau, aber auch so was

01:23:38.670 --> 01:23:40.250
Obscurity kommt halt auch,

01:23:40.550 --> 01:23:42.750
da ist auch ein sehr schönes Beispiel beschrieben,

01:23:43.370 --> 01:23:45.430
wo Variable-Namen

01:23:45.430 --> 01:23:47.290
an böse, böse

01:23:47.290 --> 01:23:48.690
Überraschungen bescheren können.

01:23:49.170 --> 01:23:51.470
Also der Autor von dem Buch,

01:23:51.510 --> 01:23:53.430
der hat TCL mal diese Scripting-Language

01:23:53.430 --> 01:23:55.290
geschrieben, also diese Sprache designt.

01:23:56.090 --> 01:23:57.130
Vielleicht kennt man das auch von früher,

01:23:57.250 --> 01:23:59.730
da hat man so User-Interfaces

01:23:59.730 --> 01:24:01.250
damit gebaut, in Unix

01:24:01.250 --> 01:24:02.730
häufig TickleDK, ist das?

01:24:03.350 --> 01:24:05.390
Ja, TickleDK gibt's, ja. Genau, das ist

01:24:05.390 --> 01:24:07.390
die Python-Geschichte, mit Python kann man das

01:24:07.390 --> 01:24:09.270
auch machen, das ist die einzige UI-Geschichte,

01:24:09.270 --> 01:24:10.790
die in der Standard-Bibliothek drin ist.

01:24:11.690 --> 01:24:13.950
Und der hat aber noch diverse andere,

01:24:14.030 --> 01:24:19.010
der hat zum Beispiel ein Cloud-Dings gebaut,

01:24:19.010 --> 01:24:21.110
ein quasi verteiltes Betriebssystem

01:24:21.110 --> 01:24:24.170
und ganz viele coole, interessante Dinge.

01:24:24.970 --> 01:24:28.010
Und in diesem Dings gab es ein Fallsystem auch

01:24:28.630 --> 01:24:31.010
und in der Fallsystem-Implementation gab es irgendwie eine Variable,

01:24:31.150 --> 01:24:31.750
die hieß Block.

01:24:32.710 --> 01:24:35.150
Und da hatten sie einen ganz fiesen Bug,

01:24:35.430 --> 01:24:37.710
wo sie irgendwie Monate gebraucht haben, um den zu finden.

01:24:38.290 --> 01:24:39.810
Und der lag dann letztlich daran,

01:24:39.910 --> 01:24:43.050
Und das ist dann halt eben das, was dann diese Obscurity tatsächlich so schlimm macht.

01:24:43.610 --> 01:24:47.850
Der lag daran, dass sie Block subtil unterschiedlich in der Bedeutung verwendet haben.

01:24:47.970 --> 01:24:54.270
Also sie haben Block als Variablen-Namen benutzt, aber in dem einen Fall bedeutete er etwas leicht anderes als in dem anderen Fall.

01:24:54.690 --> 01:24:58.610
Und wenn du das liest, dann sieht es aber so aus, als ob das irgendwie das Gleiche ist.

01:24:59.090 --> 01:25:03.030
Aber wenn du es dann halt verwendest, so als wäre es das Gleiche, dann hast du halt einen subtilen Fehler gemacht.

01:25:03.210 --> 01:25:05.610
in ganz obskuren Fällen

01:25:05.610 --> 01:25:07.790
hat das dann halt irgendwie mal

01:25:07.790 --> 01:25:09.570
irgendwie zusätzliche Daten in irgendwie

01:25:09.570 --> 01:25:11.530
Files reingeschrieben oder so, weil irgendwas nicht richtig

01:25:11.530 --> 01:25:13.370
allein war oder so. Ganz Horror

01:25:13.370 --> 01:25:14.430
Bugs.

01:25:15.250 --> 01:25:17.450
Ja, ja, irgendwie so Magie, die passiert im Dunkeln, aber

01:25:17.450 --> 01:25:19.530
schwarze Magie macht irgendwas kaputt und du weißt

01:25:19.530 --> 01:25:20.170
nicht genau was.

01:25:21.790 --> 01:25:23.330
Ja, ja, schwierig. Und das

01:25:23.330 --> 01:25:25.390
halt dann, ja, das lag halt einfach daran, dass

01:25:25.390 --> 01:25:26.610
der Variablename halt

01:25:26.610 --> 01:25:29.390
zu generisch war. Also sie können halt zu generisch

01:25:29.390 --> 01:25:31.190
sein, sie können halt aber auch zu speziell sein.

01:25:31.410 --> 01:25:33.170
Also ich meine irgendwie, keine Ahnung,

01:25:33.230 --> 01:25:38.650
der Java-File-Input-Buffer-Stream-Schlag-mich-tot-Reader

01:25:38.650 --> 01:25:40.270
ist halt auch irgendwie dann nicht mehr so der Sinn.

01:25:40.590 --> 01:25:41.430
Das ist auch nicht so schön.

01:25:43.190 --> 01:25:45.390
Ja, aber das ist vielleicht ein Geschmacksfall,

01:25:45.430 --> 01:25:46.910
vielleicht auch anwendungsfrei spezifisch.

01:25:47.770 --> 01:25:50.030
Ich glaube, eine Sache, die man ganz generell festhalten kann,

01:25:50.090 --> 01:25:51.410
ist, wenn man irgendwas refactoren möchte,

01:25:51.810 --> 01:25:54.150
also jetzt nochmal ganz generell gesprochen ist,

01:25:54.790 --> 01:25:57.430
dass einem der Unit-Tests oder funktionale Tests

01:25:57.430 --> 01:26:00.170
oder was auch immer für Tests sehr, sehr helfen können.

01:26:00.170 --> 01:26:16.830
Und nicht nur, dass man quasi das, was man refactored hat, dass man das vernünftig testet, das sollte eh klar sein, sondern wenn es hinreichend kompliziert ist, dass man auch einfach mal Test schreibt für den Bestandscode, dass man einfach sicher sein kann, was macht das eigentlich und dass sich das nicht verändert hat.

01:26:18.170 --> 01:26:37.770
Ich habe letztens, ich weiß nicht, ob das mit euch war, ob ich mit euch darüber gesprochen habe, mit dieser Oracle-Implementierung, wo die dann auch gesagt haben, das Ding war irgendwie dermaßen alt und verbuggt, dass die dann quasi alles komplett mit Unitests zementiert haben. Also jeden Bug und jedes merkwürdige Verhalten, das das System hatte, haben die mit Unitests zementiert. Die haben irgendwie ein Jahr lang, glaube ich, nichts anderes gemacht.

01:26:39.470 --> 01:26:51.250
Und dann haben die angefangen, das zu refactoren, weil die halt einfach Angst hatten, weil also teilweise war es wohl auch so in der Community, dass die Leute halt auch auf diesen merkwürdigen Verhalten oder Bugs, wie man es halt nennen möchte, halt aufgebaut haben und Features draufgesetzt haben.

01:26:51.330 --> 01:26:58.550
Und die konnten das den Leuten nicht einfach wegnehmen, weil dann halt irgendwie ganz viele Sachen zerbrochen wären, weil das halt irgendwie so Teil der impliziten API gewesen ist und sowas.

01:26:59.250 --> 01:27:04.010
Und das kann tatsächlich auch helfen.

01:27:04.010 --> 01:27:09.830
Also ich habe das jetzt einmal gemacht, als ich jetzt ein größeres Teil angefangen habe zu refactoren, also einfach Tests für den Bestandscode zu schreiben.

01:27:10.490 --> 01:27:11.330
Das macht keinen Spaß.

01:27:13.130 --> 01:27:19.030
Ja, aber das mit den Tests ist auch ein gutes Stichwort.

01:27:19.350 --> 01:27:24.970
Das ist halt auch so, also natürlich, es gehört, dass man Sachen testet und das ist auch auf jeden Fall super.

01:27:25.250 --> 01:27:27.790
Also das ist eine der Dinge, die viel gebracht haben.

01:27:27.870 --> 01:27:32.210
Auf der anderen Seite, muss ich sagen, Test Driven Development, weiß ich nicht so genau.

01:27:32.210 --> 01:27:34.090
Da würde mich jetzt doch nochmal allmählich interessieren,

01:27:34.430 --> 01:27:35.930
ob es wirklich Leute gibt, die das so durchziehen

01:27:35.930 --> 01:27:37.230
und die das gut finden.

01:27:37.750 --> 01:27:39.330
Vielleicht müssen wir mal jemanden suchen.

01:27:40.090 --> 01:27:42.070
Es kommt drauf an, wenn man es selber schreibt

01:27:42.070 --> 01:27:43.870
und wenn man weiß, was man tut.

01:27:45.750 --> 01:27:46.310
Wenn man halt

01:27:46.310 --> 01:27:48.110
tatsächlich weiß, was man raushaben will, dann schreibt man

01:27:48.110 --> 01:27:49.170
einen Test, der das quasi,

01:27:49.990 --> 01:27:52.110
die Logik, die man implementiert, die zwei Methoden, quasi

01:27:52.110 --> 01:27:53.550
mit einem Testcase so

01:27:53.550 --> 01:27:56.170
das Ergebnis hat. Also zum Beispiel

01:27:56.170 --> 01:27:57.930
du hast halt einen Datensatz und

01:27:57.930 --> 01:28:00.410
du kennst das Ergebnis, das heißt, du machst einen Beispiel-Datensatz

01:28:00.410 --> 01:28:02.170
und am Ende weißt du, das Ergebnis kommt raus

01:28:02.170 --> 01:28:04.410
und dann weißt du ja quasi schon

01:28:04.410 --> 01:28:06.590
implizit in der Stelle wahrscheinlich

01:28:06.590 --> 01:28:08.390
oder explizit so ein bisschen, also du kannst

01:28:08.390 --> 01:28:09.750
auch hinschreiben in

01:28:09.750 --> 01:28:12.470
Logik, wie das

01:28:12.470 --> 01:28:14.290
aussehen soll, was muss passieren, damit das passiert,

01:28:14.450 --> 01:28:16.370
dass das stimmt und dann kannst du den Methoden schon die

01:28:16.370 --> 01:28:18.230
richtigen Namen geben, die du dann irgendwie füllen musst,

01:28:18.350 --> 01:28:20.350
die am Ende rauskommen sollen,

01:28:20.610 --> 01:28:22.450
wenn das jetzt nicht zu komplex ist und dann kannst

01:28:22.450 --> 01:28:24.370
du das implementieren und dann, wenn das für

01:28:24.370 --> 01:28:26.350
dein Testcase stimmt, wirst du ziemlich sicher sein, dass das

01:28:26.350 --> 01:28:28.310
auch für die anderen Fälle laufen

01:28:28.310 --> 01:28:28.750
sollte.

01:28:30.690 --> 01:28:32.970
Ja, aber ...

01:28:32.970 --> 01:28:34.670
Und wenn du das halt so machst, das ist halt so ein TDD-Fall,

01:28:34.730 --> 01:28:36.730
wo ich sagen würde, das kann dann ganz gut sein.

01:28:36.870 --> 01:28:37.810
Du kennst quasi einen Testfall.

01:28:37.810 --> 01:28:39.430
Wenn du genau weißt, was passieren soll.

01:28:39.430 --> 01:28:41.310
Genau, du kennst den Testfall.

01:28:42.090 --> 01:28:43.410
Du weißt den Testcase, den kennst du schon.

01:28:43.750 --> 01:28:45.310
Du weißt, okay, das sind meine Testdaten

01:28:45.310 --> 01:28:46.750
und du weißt, das Ergebnis von dem Test ist so.

01:28:47.150 --> 01:28:49.270
Und dann kannst du dafür dann eine Methode schreiben,

01:28:49.350 --> 01:28:51.370
die diesen Testfall richtig macht.

01:28:51.450 --> 01:28:53.450
Und wenn du quasi alle Testcases hast,

01:28:53.910 --> 01:28:55.190
dann ist dein Code schon richtig.

01:28:55.870 --> 01:28:57.730
Und das ist ein cooler Fall, wo man das machen kann,

01:28:57.810 --> 01:28:59.350
wo man dann halt für generische Fälle

01:28:59.350 --> 01:29:01.130
Code hat, der funktioniert und wo TDD Sinn macht.

01:29:01.390 --> 01:29:03.430
Wenn du es aber nicht hast, weil du nicht weißt, ob die Testcase

01:29:03.430 --> 01:29:05.450
vollständig sind, ob du irgendwelche Edge-Cases hast oder so was,

01:29:05.850 --> 01:29:07.310
dann ist es halt super nervig, weil dann

01:29:07.310 --> 01:29:09.370
muss ich Testhausen mal umbauen, irgendwas wegmocken.

01:29:09.490 --> 01:29:11.550
Aber das ist ja auch Teil des Prozesses,

01:29:11.630 --> 01:29:13.030
dass du halt die Tests auch ständig anpasst.

01:29:13.390 --> 01:29:14.870
Ja, genau. Also ich glaube,

01:29:15.110 --> 01:29:17.450
ich glaube, TDD, der größte

01:29:17.450 --> 01:29:18.770
Vorteil davon ist einfach,

01:29:19.250 --> 01:29:21.450
dass man erstens Code so schreibt,

01:29:21.450 --> 01:29:23.350
dass er testbar ist, weil das

01:29:23.350 --> 01:29:25.350
habe ich früher auch nicht so gemacht. Wenn man keine Unitest

01:29:25.350 --> 01:29:26.950
schreibt, dann schreibt man Code anders.

01:29:27.410 --> 01:29:28.910
Und das ist schlechterer Code.

01:29:29.150 --> 01:29:30.850
Das ist einfach eine generelle, richtige Aussage.

01:29:31.270 --> 01:29:31.990
Und das Zweite ist,

01:29:32.570 --> 01:29:34.590
du wirst, du kommst, wenn dann plötzlich

01:29:34.590 --> 01:29:36.630
der PO oder irgendwer Stress macht, dann lässt

01:29:36.630 --> 01:29:38.210
man die Tests nicht weg, weil die sind schon da.

01:29:38.930 --> 01:29:41.030
Ich glaube, das sind die beiden Hauptverkaufsargumente

01:29:41.030 --> 01:29:41.370
dafür.

01:29:42.750 --> 01:29:44.550
Ja, du kannst halt keinen ungetesteten Code

01:29:44.550 --> 01:29:46.530
schreiben. Das ist halt irgendwie natürlich so ein bisschen,

01:29:46.950 --> 01:29:48.310
das ist halt schon vielleicht gut.

01:29:48.850 --> 01:29:50.270
Aber eben,

01:29:50.490 --> 01:29:52.350
das gab es auch in der letzten Django-Chat-EP

01:29:52.350 --> 01:29:54.210
so, ich weiß nicht, letzte, vorletzte,

01:29:54.330 --> 01:29:56.510
keine Ahnung, da gab es auch, ging es auch

01:29:56.510 --> 01:29:58.450
um das Thema Test-Development und auch alle

01:29:58.450 --> 01:30:00.590
da meinten so, ja, ganz gut,

01:30:00.710 --> 01:30:01.850
ist eigentlich vielleicht nicht so schlecht, aber

01:30:01.850 --> 01:30:04.730
der Konsens in der Runde war halt auch so,

01:30:04.810 --> 01:30:06.810
naja, so wirklich machen, macht das dann doch keiner.

01:30:07.750 --> 01:30:09.090
Und auch mit dem Argument

01:30:09.090 --> 01:30:10.210
und das,

01:30:10.950 --> 01:30:12.930
was wir, glaube ich, auch schon mal gemacht haben, dass halt

01:30:12.930 --> 01:30:14.850
das Problem ist, wenn man

01:30:14.850 --> 01:30:16.950
jetzt, wenn klar ist, was zu tun ist,

01:30:16.990 --> 01:30:18.390
dann ist das vielleicht machbar, aber

01:30:18.390 --> 01:30:20.830
ich hatte auch heute wieder so einen Fall, wenn man nicht

01:30:20.830 --> 01:30:22.490
weiß, was man machen will, dann ist das

01:30:22.490 --> 01:30:24.610
ganz blöd, weil

01:30:24.610 --> 01:30:26.710
das hilft einem überhaupt nicht, dass man

01:30:26.710 --> 01:30:28.550
dann mit dem Text Test anfängt, weil man muss sowieso

01:30:28.550 --> 01:30:30.710
irgendwie rumprobieren und das dann

01:30:30.710 --> 01:30:32.170
in einem Test zu machen, macht irgendwie nicht so viel Sinn.

01:30:33.590 --> 01:30:34.430
Das Buch

01:30:34.430 --> 01:30:36.830
macht da auch einen interessanten

01:30:36.830 --> 01:30:38.650
Punkt und sagt halt, naja, also

01:30:38.650 --> 01:30:40.170
wenn du Test

01:30:40.170 --> 01:30:42.710
development machst, dann zwingt

01:30:42.710 --> 01:30:43.450
dich im Grunde das

01:30:43.450 --> 01:30:47.070
das Vorgehen,

01:30:47.430 --> 01:30:48.630
dir von Anfang an ganz

01:30:48.630 --> 01:30:50.670
viele detaillierte Gedanken

01:30:50.670 --> 01:30:52.650
über die Implementation zu machen, an der

01:30:52.650 --> 01:30:54.230
Stelle, wo das vielleicht überhaupt nicht

01:30:54.230 --> 01:30:56.450
zielführend ist, sondern du willst vielleicht

01:30:56.450 --> 01:30:58.250
am Anfang die erstmal Gedanken über das Design oder

01:30:58.250 --> 01:31:00.110
Abstraktionen machen und nicht über die Implementierung

01:31:00.110 --> 01:31:02.490
und das geht mit Test Driven Development

01:31:02.490 --> 01:31:04.510
gar nicht so richtig. Und was

01:31:04.510 --> 01:31:06.270
er dann vorschlägt, ist zu sagen, mach doch lieber

01:31:06.270 --> 01:31:07.190
Document

01:31:07.190 --> 01:31:08.750
oder

01:31:08.750 --> 01:31:12.050
Implementierst die Methoden, schreibst den Document dazu,

01:31:12.110 --> 01:31:13.010
weil das tut toll und schreibst dann

01:31:13.010 --> 01:31:16.050
sondern du schreibst halt nur

01:31:16.050 --> 01:31:18.410
in natürlicher Sprache sozusagen, was die

01:31:18.410 --> 01:31:19.950
Abstraktionen sind, was die ungefähr machen sollen

01:31:19.950 --> 01:31:22.330
und mit denen spielst du so lange rum, bis dir das

01:31:22.330 --> 01:31:24.470
Design gefällt und dann fängst

01:31:24.470 --> 01:31:26.190
du erst an, das zu implementieren.

01:31:26.450 --> 01:31:29.110
ehrlich gesagt, also ich versuche das jetzt,

01:31:29.170 --> 01:31:31.070
mal gucken, keine Ahnung. Okay, dann die Tests schreiben

01:31:31.070 --> 01:31:32.430
und dann implementieren vielleicht. Ja,

01:31:33.130 --> 01:31:35.210
aber genau, also ich weiß

01:31:35.210 --> 01:31:36.950
es nicht so genau, ob es wirklich funktioniert, weil ich habe immer so einen

01:31:36.950 --> 01:31:39.130
Verdacht, also bei mir ist es oft so, wenn ich irgendwie

01:31:39.130 --> 01:31:41.250
ich merke erst beim Rumprobieren

01:31:41.250 --> 01:31:43.170
damit und Rumspielen und Umstellen irgendwann

01:31:43.170 --> 01:31:45.110
ach, wie das Design eigentlich hätte sein

01:31:45.110 --> 01:31:47.090
sollen. Ich finde mir auch so. Ich kann das nicht

01:31:47.090 --> 01:31:48.990
gut mir vorher irgendwie,

01:31:49.130 --> 01:31:50.970
also, dass ich

01:31:50.970 --> 01:31:52.810
mit einem Design, dass ein

01:31:52.810 --> 01:31:55.030
gutes Design dabei rauskommen würde, wenn ich nur so

01:31:55.030 --> 01:31:56.650
mit abstrakten Geschichten rumspiele,

01:31:57.510 --> 01:31:58.930
das ist bei mir irgendwie nicht so.

01:31:58.950 --> 01:32:00.970
Man merkt ja auch mal ein paar Mal, wenn man auch das erweitert hat,

01:32:01.070 --> 01:32:02.930
also ist auch doch nicht so toll, dann musst du doch nochmal anders

01:32:02.930 --> 01:32:04.950
und für sich selber. Oft kommt halt die Idee für das

01:32:04.950 --> 01:32:07.110
Design aus der Implementation.

01:32:07.430 --> 01:32:08.990
Also dass ich merke so, okay, an der Stelle

01:32:08.990 --> 01:32:10.830
mache ich zwei, drei Umstellungen und dann merke ich so, okay,

01:32:10.910 --> 01:32:12.970
das ist jetzt alles, jetzt brauche ich gar kein Objekt mehr, das nehme ich da einfach

01:32:12.970 --> 01:32:15.130
und dick oder so und dann, oh, dann kann ich das ja so ausdrücken

01:32:15.130 --> 01:32:16.970
und dann kann ich so, oh, und jetzt ist das

01:32:16.970 --> 01:32:18.250
Design auch klar und

01:32:18.250 --> 01:32:21.050
das kommt halt aus dem, mit den

01:32:21.050 --> 01:32:22.890
Datenstrukturen rumspielen. Nicht so sehr

01:32:22.890 --> 01:32:24.310
aus dem sich abstrakte Gedanken machen.

01:32:25.030 --> 01:32:27.330
ich weiß es nicht. Ich probiere es mal aus, mal gucken.

01:32:27.490 --> 01:32:29.170
Also es klingt auf jeden Fall ganz interessant und es ist halt

01:32:29.170 --> 01:32:30.490
nochmal ein bisschen was anderes als Test-Driven

01:32:30.490 --> 01:32:33.190
Development. Und ja, ich glaube

01:32:33.190 --> 01:32:35.110
auch, das habe ich bisher einfach unterschätzt und

01:32:35.110 --> 01:32:36.350
irgendwie nicht richtig gemacht mit den

01:32:36.350 --> 01:32:39.090
Dokumentationen und Kommentaren. Das ist wahrscheinlich

01:32:39.090 --> 01:32:41.150
doch deutlich wichtiger, als ich gedacht habe. Da muss ich mal

01:32:41.150 --> 01:32:41.450
mehr machen.

01:32:43.350 --> 01:32:44.990
Ja, das klingt gut. Also tatsächlich

01:32:44.990 --> 01:32:47.390
dokumentierter Code. Sehr zen, sehr zen,

01:32:47.390 --> 01:32:48.110
sehr zen auf Weißen.

01:32:49.210 --> 01:32:50.190
Ah, ja.

01:32:51.490 --> 01:32:53.290
Ja, ich glaube, wir haben bei Refactoring

01:32:53.290 --> 01:32:55.250
ich habe nicht mehr so viel auf meinem Zettel,

01:32:55.490 --> 01:32:57.230
was ich hätte. Ich kann mal gerade gucken,

01:32:57.330 --> 01:32:59.230
ob ich habe, ich habe mir, was habe ich mir denn aufgeschrieben,

01:32:59.290 --> 01:33:01.030
was ich dazu noch? Ich muss natürlich sagen, mein

01:33:01.030 --> 01:33:03.490
Thyssen kaputt hatte ich am Anfang schon erwähnt, aber das ist nicht so schlimm.

01:33:03.730 --> 01:33:04.910
Ja, übrigens, ach so, genau,

01:33:05.050 --> 01:33:07.090
ich meine, das ist jetzt

01:33:07.090 --> 01:33:08.750
das, was ich mir aufgeschrieben habe,

01:33:08.910 --> 01:33:11.430
Red Flag, irgendwie extensive Dokumentation

01:33:11.430 --> 01:33:12.790
schreibt er auch, obwohl er eigentlich sagt,

01:33:12.930 --> 01:33:15.190
voll gut, er sagt, ja, wenn Leute

01:33:15.190 --> 01:33:16.190
viel, viel dokumentieren,

01:33:17.110 --> 01:33:19.330
ist auch ein Zeichen für schlechtes Design,

01:33:19.710 --> 01:33:21.170
weil das ist ja etwas, was

01:33:21.170 --> 01:33:22.570
nicht, ist ja nicht gut, dass man das hat, sondern

01:33:22.950 --> 01:33:24.150
Je mehr man dokumentieren muss ...

01:33:24.150 --> 01:33:25.210
Man muss viel erklären, ist auch ...

01:33:25.210 --> 01:33:26.370
Ja, wenn du viel erklären musst, ist nicht gut.

01:33:26.490 --> 01:33:27.670
Eigentlich sollte es offensichtlich sein

01:33:27.670 --> 01:33:29.830
und man sollte es mit wenig ...

01:33:29.830 --> 01:33:31.250
Ja, so ein oder zwei Sätze am Anfang,

01:33:31.310 --> 01:33:32.090
was machen, was behaupten,

01:33:32.130 --> 01:33:33.370
dann muss man die ganze Funktion nicht lesen,

01:33:33.410 --> 01:33:34.090
wenn das stimmt.

01:33:34.830 --> 01:33:36.370
Aber das finde ich auch so eine Sache,

01:33:36.490 --> 01:33:37.330
warum ich Type-Ins gut finde.

01:33:37.430 --> 01:33:38.130
Jetzt nicht, weil es unbedingt

01:33:38.130 --> 01:33:39.550
so die Typensicherheit alles sicherstellt,

01:33:39.910 --> 01:33:41.570
aber wenn ich halt den Funktionsnamen lese,

01:33:41.630 --> 01:33:42.230
der gut gewählt ist,

01:33:42.270 --> 01:33:43.530
die Type-Ins, die dazu passen,

01:33:43.570 --> 01:33:45.630
zu den Parametern, die die Funktion hat

01:33:45.630 --> 01:33:46.390
und dann den Dockstring,

01:33:46.390 --> 01:33:48.410
der idealerweise mir erklärt, was das macht,

01:33:48.990 --> 01:33:49.910
dann habe ich ja den Return-Wert,

01:33:49.950 --> 01:33:51.990
dann muss ich gar nicht in die Funktion reingucken, um dir alles genau

01:33:51.990 --> 01:33:53.550
angucken, sondern ich weiß halt, was sie tut, ah ja, okay,

01:33:53.950 --> 01:33:55.890
und kann zum nächsten übergehen. Das ist super,

01:33:55.890 --> 01:33:57.830
super schön zum Arbeiten. Ja, das ist dann halt

01:33:57.830 --> 01:33:59.830
beispielsweise eine gelungene Abstraktion, wenn du halt

01:33:59.830 --> 01:34:02.150
sozusagen der Interface

01:34:02.150 --> 01:34:04.050
Dokumentation schon ansehen kannst,

01:34:04.570 --> 01:34:05.930
also alles, daraus alles

01:34:05.930 --> 01:34:07.990
erfährst, was du brauchst, um das benutzen zu können.

01:34:08.010 --> 01:34:09.610
Ja, genau, also du kannst einfach die Docs

01:34:09.610 --> 01:34:11.830
skimmen, ja, und kurz gucken, ja, okay, jetzt mach das

01:34:11.830 --> 01:34:13.830
und das und das, musst gar nicht so genau den Code hier angucken,

01:34:13.930 --> 01:34:15.830
dann ist das auch egal, ob die Leute da so

01:34:15.830 --> 01:34:17.610
ordentlich gearbeitet haben irgendwann, ne? Ja.

01:34:17.610 --> 01:34:18.310
Ja, absolut.

01:34:19.790 --> 01:34:20.310
Ja, ja.

01:34:21.230 --> 01:34:23.190
Ich habe jetzt gerade noch mal geguckt, ich habe auch sonst nichts mehr

01:34:23.190 --> 01:34:25.570
eigentlich, was ich unbedingt unterbringen wollte.

01:34:25.570 --> 01:34:27.630
Nein, bei mir ist auch ab alles untergebracht.

01:34:27.730 --> 01:34:29.210
Oh, jetzt sind wir auch, wir sind ja schon relativ

01:34:29.210 --> 01:34:30.970
weit dran, wir haben immer viele Leute, die ab dann

01:34:30.970 --> 01:34:32.550
abspringen, jetzt kann man

01:34:32.550 --> 01:34:35.410
eine Meinung

01:34:35.410 --> 01:34:37.390
von Leuten, die sich

01:34:37.390 --> 01:34:38.930
die bis hierhin durchgehalten haben,

01:34:39.050 --> 01:34:40.970
wäre ganz interessant vielleicht.

01:34:41.530 --> 01:34:43.310
Und zwar habe ich, das war letztens

01:34:43.310 --> 01:34:45.270
im Stream, hat dann irgendjemand geschrieben, meinte so

01:34:45.270 --> 01:34:47.170
ach, es wäre doch voll gut, wenn ihr sowas hättet wie ein Discord

01:34:47.170 --> 01:34:49.290
oder so. Wollen wir sowas

01:34:49.290 --> 01:34:50.830
haben. Ich meine, wir haben Slack, aber Slack ist

01:34:50.830 --> 01:34:52.850
irgendwie, wie hat das jemand dann genannt? Ah, Slack ist ja

01:34:52.850 --> 01:34:54.090
eher so ein Boomer-Discord.

01:34:54.390 --> 01:34:57.130
Ja. Also Discord habe ich übrigens auch.

01:34:57.130 --> 01:34:59.010
Habe ich auch für meine eigenen Zeugs schon

01:34:59.010 --> 01:35:01.110
online einmal und so. Also ja,

01:35:01.190 --> 01:35:02.410
wir gucken uns den Teller an, aber ist ja kein Problem.

01:35:03.750 --> 01:35:05.270
Ja, oder ich meine, welche Plattform

01:35:05.270 --> 01:35:07.170
sollte man da verwenden? Discord. Discord,

01:35:07.270 --> 01:35:09.250
echt? Ja. Weil, also die Firma

01:35:09.250 --> 01:35:10.750
dahinter ist auch so ein bisschen unsympathisch, ne?

01:35:11.090 --> 01:35:13.650
Ja. Ja, die machen auch so NFT-Kram

01:35:13.650 --> 01:35:15.210
und Krypto...

01:35:15.210 --> 01:35:17.050
Dass das sagt jemand, der

01:35:17.050 --> 01:35:19.350
Werbung für VPNs macht.

01:35:22.930 --> 01:35:23.970
Spoiler, nein, ich weiß nicht.

01:35:24.150 --> 01:35:25.530
Ja, es ist alles so ein bisschen,

01:35:26.390 --> 01:35:28.230
ich weiß nicht so genau.

01:35:29.110 --> 01:35:30.650
Ja, okay, also Discord wäre gut.

01:35:30.890 --> 01:35:32.530
Ja, weil ich meine, dann könnten halt auch Leute da

01:35:32.530 --> 01:35:34.690
irgendwie mal, man könnte mit Leuten chatten

01:35:34.690 --> 01:35:36.070
und so, also könnten Leute live,

01:35:36.390 --> 01:35:37.570
wir machen jetzt noch nichts live.

01:35:38.090 --> 01:35:40.510
Also Discord würde ich auch

01:35:40.510 --> 01:35:41.310
sagen, ist cool.

01:35:42.910 --> 01:35:44.710
Was cool an Discord ist,

01:35:44.770 --> 01:35:46.670
das nutzen halt alle von früher

01:35:46.670 --> 01:35:48.030
und so vom Gaming und so weiter.

01:35:48.470 --> 01:35:50.230
Man kann halt super easy da halt irgendwie reingehen.

01:35:50.330 --> 01:35:52.110
Man hat halt Video, man hat halt Chat, man hat halt

01:35:52.110 --> 01:35:53.570
alles eigentlich, was man so will.

01:35:54.130 --> 01:35:56.610
Die Firma kenne ich gar nicht. Du hast irgendwas Böses über die Firma gehört?

01:35:57.410 --> 01:35:58.510
Ja, also

01:35:58.510 --> 01:36:00.310
es ist halt nicht so, dass man das selber betreiben könnte.

01:36:00.450 --> 01:36:02.410
Du bist halt dann abhängig von der Firma, genau wie bei Slack.

01:36:02.490 --> 01:36:03.910
Ja gut, du machst halt einen Channel auch für dich.

01:36:04.110 --> 01:36:06.870
Ja, ich weiß so ein bisschen, was du meinst.

01:36:06.870 --> 01:36:08.610
Also ich würde das natürlich,

01:36:09.210 --> 01:36:10.650
mir ist schon sympathisch zum Beispiel auch,

01:36:10.730 --> 01:36:12.850
was sie technisch machen. Die haben ja auch irgendwie

01:36:12.850 --> 01:36:14.730
da Rekorde

01:36:14.730 --> 01:36:16.670
aufgestellt, mit wie viel Clients

01:36:16.670 --> 01:36:18.550
an einem Server hängen können, mit Erlangen

01:36:18.550 --> 01:36:20.650
und so. Die machen halt

01:36:20.650 --> 01:36:22.410
das ist alles schon cool,

01:36:22.590 --> 01:36:24.670
aber irgendwie, ja, das ist halt

01:36:24.670 --> 01:36:26.550
eine Firma, also ich würde es gerne selber hosten können

01:36:26.550 --> 01:36:28.610
oder sowas. Ja, aber diese ganzen Indie-Lösungen,

01:36:28.690 --> 01:36:30.510
die es für sowas halt gibt, ich weiß nicht, die sind halt von

01:36:30.510 --> 01:36:32.450
der Nutzerbasis, glaube ich, gar nicht so interessant.

01:36:33.670 --> 01:36:34.610
Ja, man muss

01:36:34.610 --> 01:36:36.370
wahrscheinlich dahin gehen, wo die User sind, ne? Ja, genau.

01:36:37.690 --> 01:36:38.210
Hey, wir haben einen Instagram-Count.

01:36:38.210 --> 01:36:39.370
Gefällt mir gar nicht, aber gut.

01:36:40.790 --> 01:36:42.050
Sind wir doch nicht auf Instagram, schade.

01:36:42.850 --> 01:36:44.390
Ja, gefällt mir nicht. Genau, ja,

01:36:44.510 --> 01:36:45.290
Dann lass es doch noch auf Facebook.

01:36:48.990 --> 01:36:51.390
Nee, aber Discord finde ich ganz okay, es geht.

01:36:52.050 --> 01:36:52.750
Also bei mir ist eh immer an.

01:36:53.710 --> 01:36:54.590
Ja, gut, okay.

01:36:55.430 --> 01:36:56.030
Johannes auch da.

01:36:56.510 --> 01:36:58.410
Ja, ich weiß, der hat ja da auch irgendwie

01:36:58.410 --> 01:37:01.450
ein eigenes Ding aufgemacht, aber da ist auch gar nicht so wahnsinnig viel los.

01:37:01.890 --> 01:37:03.450
Ja, aber das liegt auch ein bisschen daran,

01:37:03.590 --> 01:37:04.790
also unter anderem,

01:37:05.310 --> 01:37:07.370
dass er das halt auch so wie seine Sachen

01:37:07.370 --> 01:37:08.710
benutzt, wie seine Spielfirma.

01:37:09.010 --> 01:37:09.410
Ja.

01:37:10.050 --> 01:37:11.050
Naja, aber wie auch immer.

01:37:11.970 --> 01:37:12.890
Nutzst du auch Discord auf der Arbeit?

01:37:13.610 --> 01:37:15.350
Nein. Okay, also ich habe meine eigene

01:37:15.350 --> 01:37:17.250
mit Leuten, ich würde da auch mit Kunden drüber sprechen,

01:37:17.370 --> 01:37:18.930
also ich finde, das ist so die beste

01:37:18.930 --> 01:37:21.270
Teams-Alternative zum Beispiel, wenn ich jetzt

01:37:21.270 --> 01:37:23.310
so Kundenprojekte habe, wenn die auf meine Plattform kommen

01:37:23.310 --> 01:37:24.690
und ich nicht auf deren muss, dann

01:37:24.690 --> 01:37:27.010
die Kommunikation ist irgendwie schöner, professioneller,

01:37:27.170 --> 01:37:27.970
sauberer, cleaner irgendwie.

01:37:30.810 --> 01:37:31.430
Aber es ist noch wieder

01:37:31.430 --> 01:37:32.770
so eine ästhetische Sache und keine Ahnung,

01:37:32.770 --> 01:37:33.510
alles kommerzieller.

01:37:34.450 --> 01:37:36.510
So besser als Teams zu sein, ist jetzt nicht so

01:37:36.510 --> 01:37:38.290
furchtbar schwierig, ehrlich gesagt.

01:37:38.690 --> 01:37:40.750
Beispiel, weil wir darüber reden, wo die

01:37:40.750 --> 01:37:41.330
User sind und so.

01:37:42.090 --> 01:37:45.310
Die sind ja auch schon alle leider da, meistens dann.

01:37:45.470 --> 01:37:46.770
Ja, ja, ja.

01:37:47.830 --> 01:37:48.930
Wollen wir noch Pics machen?

01:37:49.770 --> 01:37:50.730
Stimmt, wir haben noch Pics.

01:37:51.730 --> 01:37:52.590
Bonny darf anfangen.

01:37:54.710 --> 01:37:57.650
Ich habe mich jetzt motiviert von der letzten DjangoCon

01:37:57.650 --> 01:38:00.450
jetzt echt intensiver mal mit HTMX auseinandergesetzt.

01:38:00.770 --> 01:38:01.050
Oh ja.

01:38:01.690 --> 01:38:04.250
Und das finde ich wirklich sehr, sehr cool.

01:38:04.250 --> 01:38:06.150
Ja, dann machen wir auch irgendwann eine Folge.

01:38:06.270 --> 01:38:07.110
Das ist tatsächlich toll.

01:38:07.630 --> 01:38:11.190
Ich bin ja tatsächlich auch nicht so ein Riesen-JavaScript-Freund.

01:38:11.730 --> 01:38:17.350
Und dass diese Karotte quasi kleinseitige Weblogik

01:38:17.350 --> 01:38:19.570
ohne JavaScript zu schreiben, ist schon sehr, sehr groß für mich.

01:38:20.830 --> 01:38:22.830
Ich habe da letztens noch einen sehr interessanten Vortrag

01:38:22.830 --> 01:38:24.450
von dem Macher gehört.

01:38:24.550 --> 01:38:25.650
Ich glaube, das war von der ...

01:38:25.650 --> 01:38:27.050
Das war Packern US oder so.

01:38:27.170 --> 01:38:28.350
Carson Cross heißt der irgendwie.

01:38:28.410 --> 01:38:29.090
Ja, genau, genau.

01:38:29.150 --> 01:38:32.310
Der hat auch sehr schön erklärt, wie REST eigentlich funktioniert.

01:38:32.490 --> 01:38:34.790
Genau, und dass es ja eigentlich darum geht,

01:38:34.850 --> 01:38:35.970
HTML-Schnipps hin und her zu schicken

01:38:35.970 --> 01:38:37.270
und nicht JSON-APIs zu bauen.

01:38:37.670 --> 01:38:37.810
Ja.

01:38:38.090 --> 01:38:39.610
Und es ist ein super interessanter Vortrag,

01:38:39.790 --> 01:38:40.790
hat mir ein Kollege empfohlen.

01:38:41.550 --> 01:38:45.630
Und ich habe mich jetzt damit nochmal beschäftigt, habe heute noch ein kleines Feature damit gebaut.

01:38:46.190 --> 01:38:52.530
Ich muss gestehen, ich glaube, ich habe es noch nicht so 100 Prozent, also es tut die Beispiele, die da drin sind, relativ simpel.

01:38:52.530 --> 01:38:54.630
Also ich klicke irgendwo, dann tauchst du dich was aus, das ist klar.

01:38:55.130 --> 01:39:05.430
Aber wenn man halt so ein bisschen darüber hinausgehen möchte und halt, ja, einfach mal irgendwo Daten schicken oder so, also mal Postdaten schicken, die Patterns habe ich noch nicht so ganz raus.

01:39:05.490 --> 01:39:10.770
Ich bin leider nicht ganz ohne jQuery ausgekommen, das hat mich persönlich dann sehr geärgert, weil erstens jQuery und zweitens JavaScript.

01:39:11.550 --> 01:39:13.310
Ähm, aber, ähm,

01:39:13.390 --> 01:39:15.490
ich glaube, wenn, also die Dokumentation

01:39:15.490 --> 01:39:17.270
lässt leider in meinen Augen ein bisschen zu wünschen

01:39:17.270 --> 01:39:18.990
übrig und googeln kann man auch nicht, weil

01:39:18.990 --> 01:39:20.410
Google immer denkt an mein HTML.

01:39:21.350 --> 01:39:22.950
Ähm, das ist beides ein bisschen blöd.

01:39:22.970 --> 01:39:24.350
Ja, wie HTTPX ist auch mal doof.

01:39:25.070 --> 01:39:27.230
Äh, ja, genau. Und, ähm,

01:39:27.910 --> 01:39:29.010
ja, aber ich, ich glaube, wenn,

01:39:29.230 --> 01:39:31.270
äh, dass das sehr viel Potenzial hat, das macht auf jeden Fall

01:39:31.270 --> 01:39:33.030
sehr viel Spaß, damit zu arbeiten. Ähm,

01:39:33.390 --> 01:39:35.230
und im Endeffekt die Idee ist halt einfach, dass man halt

01:39:35.230 --> 01:39:36.750
Custom JavaScript Code durch

01:39:36.750 --> 01:39:39.110
äh, Custom HTML Tags

01:39:39.110 --> 01:39:41.190
ersetzt. Mhm. Und, ähm,

01:39:41.550 --> 01:39:43.530
Das ist echt cool. Also ich hab da auch

01:39:43.530 --> 01:39:45.550
letztens meine Findings, wie man das mit

01:39:45.550 --> 01:39:46.950
Django verheiraten kann,

01:39:47.590 --> 01:39:48.950
auch in einem kleinen Artikel zusammengeschrieben.

01:39:49.210 --> 01:39:51.570
Das hab ich mir noch nicht angeguckt. Ich weiß nur, dass es gibt. Es gibt ein

01:39:51.570 --> 01:39:53.450
Paket von Adam Johnson,

01:39:53.750 --> 01:39:54.690
also der mit dem

01:39:54.690 --> 01:39:58.650
Was tut das Paket denn?

01:39:59.010 --> 01:40:00.990
Tatsächlich sind das eigentlich vier Zeilen Code,

01:40:01.070 --> 01:40:02.650
man muss dem CSF beibringen und das war's.

01:40:03.390 --> 01:40:04.650
Ah, okay. Also das ist

01:40:04.650 --> 01:40:06.550
Django HTMX heißt das Paket, glaube ich.

01:40:06.550 --> 01:40:07.830
Ah, okay. Ich weiß gar nicht, was das tut.

01:40:08.190 --> 01:40:10.330
Weiß ich auch nicht. Aber das ist auf jeden Fall,

01:40:10.450 --> 01:40:12.510
Der Autor ist auf jeden Fall

01:40:12.510 --> 01:40:14.450
schon mal ein Hinweis darauf, dass man sich das mal

01:40:14.450 --> 01:40:15.630
angucken sollte. Auf jeden Fall, ja.

01:40:16.850 --> 01:40:17.890
Und ja,

01:40:18.830 --> 01:40:20.330
genau. Ja, muss ich echt mal machen, weil wie gesagt,

01:40:20.390 --> 01:40:22.210
ich habe es halt einfach zu Fuß gemacht, weil ich wusste, dass das Paket

01:40:22.210 --> 01:40:24.110
existiert und sind, wenn man es halt mal einmal gefunden hat,

01:40:24.150 --> 01:40:26.210
das sind literally halt einfach vier Zeilen JavaScript,

01:40:26.490 --> 01:40:28.170
die man einbinden muss, dass man halt dem

01:40:28.170 --> 01:40:30.210
HTMX quasi den CSF-Token injectet.

01:40:30.850 --> 01:40:32.190
Ja, der muss auf jeden Fall in unserer nächsten

01:40:32.190 --> 01:40:33.550
Folge hören, da werden wir da auch nochmal drauf eingehen.

01:40:35.490 --> 01:40:36.230
Joa. Ja.

01:40:37.410 --> 01:40:37.690
Jochen?

01:40:38.350 --> 01:40:40.250
Ich weiß nicht so genau, was pücke ich denn

01:40:41.230 --> 01:40:42.190
Also ich picke Pendulum.

01:40:42.650 --> 01:40:43.810
Ich glaube, das hatte ich schon mal gepickt. Weiß ich nicht.

01:40:43.910 --> 01:40:45.230
Ich weiß immer, weil ich kann mir immer nichts merken.

01:40:45.590 --> 01:40:47.630
Du musst immer so einfache Sachen picken. Ja, kennst du Pendulum?

01:40:47.810 --> 01:40:50.230
Nee. Nein. Das ist eine Date-Time-Parsing-Bibliothek.

01:40:50.790 --> 01:40:52.070
Cool. Ja, da kannst du so ein bisschen

01:40:52.070 --> 01:40:54.110
einfacher, so ein bisschen schöneres Interface, ein bisschen moderner.

01:40:54.790 --> 01:40:56.110
Früher hat man, glaube ich, Maya viel benutzt.

01:40:56.210 --> 01:40:57.990
Kennst du, wie es irgendwie ist, als du nicht tot bist oder so?

01:40:58.730 --> 01:41:00.210
Und ja, aber da kann man so schöne Sachen machen,

01:41:00.350 --> 01:41:02.210
wenn man Date-Times irgendwie machen

01:41:02.210 --> 01:41:04.290
möchte, in Time-Zone wechseln und

01:41:04.290 --> 01:41:06.250
so zu Strings umbauen und sowas.

01:41:06.910 --> 01:41:08.170
Okay, interessant. Ich bin letztens

01:41:08.170 --> 01:41:09.570
habe ich, das war, nein,

01:41:09.730 --> 01:41:11.170
das war gestern, glaube ich.

01:41:11.670 --> 01:41:12.650
Irgendwie so einen kleinen,

01:41:14.350 --> 01:41:15.890
da war, das mich mit JavaScript

01:41:15.890 --> 01:41:16.810
beschäftigt und Zeit.

01:41:18.070 --> 01:41:19.910
Ich wollte eigentlich nichts Kompliziertes machen. Ich wollte zum Beispiel

01:41:19.910 --> 01:41:22.070
einfach nur ein Date-Objekt einfach darstellen.

01:41:22.210 --> 01:41:23.670
Ja. Und

01:41:23.670 --> 01:41:25.730
das war

01:41:25.730 --> 01:41:27.290
ganz schrecklich. Also

01:41:27.290 --> 01:41:29.890
Pendulum ist für Python, für sowas, weil das auch immer

01:41:29.890 --> 01:41:31.670
nervt, meiner Meinung nach, sehr schön eigentlich.

01:41:32.170 --> 01:41:33.070
Ja, also da ist

01:41:33.070 --> 01:41:35.470
das JavaScript-Date-Ding, also

01:41:35.470 --> 01:41:37.330
das hatte, also sowas wie

01:41:37.330 --> 01:41:38.890
Stove-Time gibt es da halt einfach nicht.

01:41:39.510 --> 01:41:41.450
Wenn man jetzt die Differenz

01:41:41.450 --> 01:41:43.130
zwischen zwei Dates bildet,

01:41:43.810 --> 01:41:45.550
in JavaScript, ja, du hast ein Date-Objekt,

01:41:45.610 --> 01:41:47.250
ein anderes, machst eins minus das andere,

01:41:47.370 --> 01:41:48.390
was kommt dabei raus? Wisst ihr das?

01:41:49.330 --> 01:41:51.250
Ein Integer. Bei Python kommt so ein

01:41:51.250 --> 01:41:52.130
Time-Delta raus.

01:41:53.170 --> 01:41:55.210
Genau, bei JavaScript

01:41:55.210 --> 01:41:57.290
kommt die absolute

01:41:57.290 --> 01:41:58.890
Zeit in Millisekunden raus. Ja, tatsächlich.

01:41:59.250 --> 01:42:01.410
Was natürlich ein bisschen

01:42:01.410 --> 01:42:03.290
blöd ist, wenn man jetzt Mikrosekunden braucht oder keine Ahnung

01:42:03.290 --> 01:42:04.370
oder was ganz anderes oder

01:42:04.370 --> 01:42:06.710
oder halt an den Tagen

01:42:06.710 --> 01:42:07.470
interessiert ist oder so.

01:42:08.550 --> 01:42:10.130
Ja, das hat mich

01:42:10.130 --> 01:42:11.590
ja, ich kann es so empfehlen,

01:42:11.970 --> 01:42:14.630
weiß ich jetzt nicht, aber Pendulum in Python macht genau das

01:42:14.630 --> 01:42:16.610
so ein bisschen schöner, so ein bisschen mehr moderner

01:42:16.610 --> 01:42:18.670
vielleicht. Okay, gut. Keine Ahnung, ich kann es

01:42:18.670 --> 01:42:19.370
nicht mal angucken.

01:42:20.950 --> 01:42:22.210
Ist das du noch ein Pick?

01:42:22.470 --> 01:42:24.330
Ja, vielleicht picke ich einfach

01:42:24.330 --> 01:42:25.610
Blue statt Black.

01:42:26.210 --> 01:42:27.850
Macht im Grunde das gleiche, nur halt mit

01:42:27.850 --> 01:42:30.390
einem einfachen Tick statt

01:42:30.390 --> 01:42:32.250
Doppel-Einführungszeichen.

01:42:33.390 --> 01:42:35.370
Wir hätten noch mal letztens irgendwas mit Black, was man

01:42:35.370 --> 01:42:37.070
Darker. Darker war auch schön.

01:42:37.570 --> 01:42:39.430
Weil Darker macht nämlich inkrementelles Black und zwar

01:42:39.430 --> 01:42:41.370
immer nur auf die neuen Änderungen.

01:42:42.230 --> 01:42:43.390
Was ganz gut ist, wenn man halt

01:42:43.390 --> 01:42:45.310
so, dass es halt immer dunkler wird mit der Zeit.

01:42:45.310 --> 01:42:46.970
Und wenn man, weil das macht auch Sinn, dann halt

01:42:46.970 --> 01:42:49.290
als Git-Commit-Hook irgendwie einzusetzen. Darker, weil

01:42:49.290 --> 01:42:50.850
dann nur die neuen Sachen halt

01:42:50.850 --> 01:42:53.210
tatsächlich gelintet werden und das ist ganz schön.

01:42:53.590 --> 01:42:55.250
Okay, aber Blue ist ein bisschen, oh warte, was ich auch

01:42:55.250 --> 01:42:57.170
noch picke ist Pip-Tools. Da habe ich letztens auf Twitter gesehen

01:42:57.170 --> 01:42:58.410
auch jemand, ich habe

01:42:58.410 --> 01:43:01.230
angefangen, weil du mir das gezeigt hast, wollte ich gerade

01:43:01.230 --> 01:43:02.550
was damit machen und ich komme immer nicht dazu.

01:43:03.390 --> 01:43:05.690
weil ich habe nämlich auch, ich verwende ja sonst

01:43:05.690 --> 01:43:06.630
Poetry und

01:43:06.630 --> 01:43:09.650
genau, dann jetzt für das

01:43:09.650 --> 01:43:11.050
neueste Ding mit FastAPI und

01:43:11.050 --> 01:43:13.150
Frontend-Dings da, für mein

01:43:13.150 --> 01:43:15.430
Deploy-Teil, da habe ich jetzt auch

01:43:15.430 --> 01:43:17.490
Pip-Tools verwendet, weil mich Poetry so

01:43:17.490 --> 01:43:19.630
genervt hat, weil es so lange braucht und

01:43:19.630 --> 01:43:21.710
Also Pip-Tools sind so richtig toll, fand ich es jetzt auch

01:43:21.710 --> 01:43:23.750
und weil es halt oft auch irgendwie komisch kaputt

01:43:23.750 --> 01:43:24.790
geht und es ist schwer zu installieren.

01:43:25.130 --> 01:43:26.250
Pip-Tools gibt eine Empfehlung von dir?

01:43:27.130 --> 01:43:29.470
Ja, also genau, heute auf Twitter

01:43:29.470 --> 01:43:31.610
meinte jemand so, also Poetry

01:43:31.610 --> 01:43:33.650
eigentlich super sexy sieht das aus und so, aber ich bin

01:43:33.650 --> 01:43:35.470
durch. Ich nehme jetzt wieder PIP-Tools, weil

01:43:35.470 --> 01:43:36.970
es funktioniert einfach nicht.

01:43:37.930 --> 01:43:39.230
Und da dachte ich so, ja, und dann habe ich

01:43:39.230 --> 01:43:41.250
in diesem Twitter-Thread, den musst du dir mal auffallen,

01:43:41.450 --> 01:43:43.470
ganz viele Leute was Ähnliches gesagt haben. Also da

01:43:43.470 --> 01:43:45.190
viele Leute sagen so, oh, furchtbar langsam,

01:43:45.510 --> 01:43:47.190
geht immer kaputt.

01:43:47.590 --> 01:43:49.590
Ja, also es geht auch bei mir ständig, ständig

01:43:49.590 --> 01:43:51.570
kaputt und ich muss immer was fixen, das nervt

01:43:51.570 --> 01:43:53.550
extrem. Aber es ist schon

01:43:53.550 --> 01:43:55.510
eigentlich eine gute Idee und eigentlich sollte es genauso aussehen.

01:43:55.510 --> 01:43:58.250
So was sollte es geben, aber es sieht halt nicht richtig aus.

01:43:58.450 --> 01:43:59.630
Aber vielleicht sollte man es einfach mal fixen,

01:43:59.690 --> 01:44:01.350
anstatt was Neues wieder zu machen, was auch nicht

01:44:01.350 --> 01:44:02.890
funktioniert. Vielleicht.

01:44:03.210 --> 01:44:03.910
Gutes Schlusswort.

01:44:05.450 --> 01:44:06.770
Vielleicht sollte man das mal refactoren.

01:44:08.470 --> 01:44:09.790
Danke, Ronne, dass du wieder da warst.

01:44:10.210 --> 01:44:11.750
Vielen Dank für eure Aufmerksamkeit.

01:44:12.230 --> 01:44:12.890
Für die Einladung.

01:44:13.170 --> 01:44:15.170
Bleibt uns gewogen. Schaltet uns gerne wieder ein.

01:44:15.310 --> 01:44:17.010
Bis zum nächsten Mal. Bis dann mit Werbung.

01:44:17.190 --> 01:44:18.430
Tschüss. Tschau.