Latest / Coding Buddies | Tech & Dev-Mindset / #163 IPOS - Dieses Prinzip ist kein Schreibfehler (und hat es in sich)

Transcript

#163 IPOS - Dieses Prinzip ist kein Schreibfehler (und hat es in sich) · Coding Buddies | Tech & Dev-Mindset

0:00
Manchmal recherchiert man für eine Folge in die komplett
0:02
falsche Richtung, trifft aber trotzdem auf coole Punkte.
0:05
Und deshalb geht es heute um das etwas andere Iosp.
0:08
Prinzip Coding Buddies Dein Podcast rund um
0:12
Softwareentwicklung und aktueller Tech News.
0:15
Herzlich Willkommen. Halli Hallo und herzlich
0:29
Willkommen zur neuen Folge des Cody Buddies Podcast.
0:32
Schön, dass du wieder eingeschaltet hast und mal
0:35
wieder mit dabei bist. Deine Gastgeber, meine
0:37
Wenigkeit, der Tino und natürlich der fantastische Fabi
0:41
Fabi. Grüße dich zu einer weiteren
0:43
Folge. Hey Tino, Was geht?
0:47
Was geht? Ich fang gleich mal an.
0:50
Ich hab gesagt was geht, ich hab ich hab gerade meinen Kaffee
0:54
getrunken, ja. Stark, stark und ich hab mich
0:58
mal gefragt ob es ne gute Idee wäre, wenn man einfach, also ich
1:02
mag ja kaffeegeschmack ne, es gibt ja Leute, die mögen jetzt
1:05
kaffeegeschmack nicht so sehr, aber ich mag ihn halt wirklich
1:08
sehr und jetzt ist die Frage ob man kaffeegeschmack noch pimpen
1:13
kann, weil ich trink den auch immer sehr stark ja damit also
1:16
ich also mein Prinzip ist je stärker der Kaffee desto mehr
1:20
kaffeegeschmack ich weiß nicht ob das stimmt, aber man kann
1:22
mich gerne da berichtigen oder? Vielleicht mir da noch n paar
1:25
Tipps geben, aber was ist wenn du so Bröselkaffee nimmst und
1:29
dir darauf so n bisschen bröselkaffee und darauf dann so
1:32
n maschinenkaffee noch drauf machst?
1:34
Dann wird der ja noch krasser. Weißt du ja, klingt.
1:38
Aber auch n bisschen eklig, muss ich sagen.
1:40
Aber hast du es schon mal? Probiert ist die Frage.
1:43
Nein, also Brösel Bröselkaffee kennt man ja jeder hatte schon
1:48
die Situation wo er sich dachte ich mach so n löslichen Kaffee.
1:52
Ja, den kannst du natürlich unfassbar stark machen, bis der
1:55
Löffel drin steht. Aber weiß ich nicht, machst du
1:59
das nicht mit frischen Bohnen, damit der Geschmack auch geil
2:02
ist. Und dann so Brösel Kaffee dazu,
2:04
nur damit es mehr kickt oder stärker wird.
2:06
Aber ich glaube geschmacklich ist das nicht gut.
2:08
Ist ja nur die genaue da willst. Du dir so einen richtigen Brei
2:10
anrühren, dass du so viel reinmachst.
2:12
Hast du das? Wirklich löffelig, das ist
2:15
wirklich, wirklich eklig, ist ja nur eine Überlegung.
2:17
Ja, ich wollte es ja nur mal einen Raum werfen.
2:19
Ja, man macht dir doch einfach eine große Tasse.
2:22
Espresso sozusagen. Aber mehr Kaffeegeschmack geht
2:26
doch nicht. Aber es ist nicht, weil mein
2:28
Herz das mitmacht. Das andere ist auch nicht gut
2:31
für dein Herz. Nur mal so.
2:35
Entkoffeinierter Kaffee, na ja, o.
2:37
K dann ja, dann mach genau löslichen entkoffeinierten
2:40
Kaffee machst du da rein und dann gib ihm, bis es dir genug
2:44
ist, bis es nicht mehr schmeckt. Probier es aus, Berichte dann
2:47
einfach in der nächsten Folge mach ich hast du jetzt ne Woche
2:50
Zeit damit. Die perfekte Dosis zu finden, um
2:53
uns allen das mitzuteilen, ja. Also ich find es auch n bisschen
2:56
eklig in der Vorstellung. Ich wollte ja nur mal fragen.
2:59
Ja, weil manchmal hat man ja Ideen, wo man sich so denkt,
3:02
dies ist Quatsch und andere denken, aber ist gar nicht so
3:04
Quatsch, aber ich merke es ist Quatsch.
3:07
Ja, pass auf. Wir hatten das Thema ja auch im
3:09
letzten. Livestream kurz.
3:11
Ich erinner mich daran ja und ich glaube, die Resonanz war
3:15
auch eher so, so Alter. Also vielleicht hast du jetzt
3:20
ist die Stichprobe groß genug jetzt.
3:23
Mich interessiert das, also ich. Es beschäftigt mich noch.
3:26
Aber aber an der Stelle muss man natürlich sagen, liebe Zuhörer,
3:31
liebe Zuhörer, falls du bei dem Livestream dabei sein möchtest,
3:34
um direkt deine Meinung sagen zu können zu solchen Themen, dann
3:38
schau doch gerne mal vorbei. Dienstag, 20:00 Uhr sind wir
3:40
immer live und falls du dem Podcast noch nicht folgst, dann
3:43
mach auch das gerne, um diese Diskussion fortan nicht mehr zu
3:46
verpassen. Also vielen Dank dafür.
3:50
Ich weiß nicht, ob man die verpassen will.
3:54
Verpass ich sehr gerne die Diskussion, OK.
3:58
Aber lass mal reinstarten. In unsere heutige Folge.
4:01
So richtig ins Thema, und zwar geht es ja um, ich sag mal, ein
4:06
Prinzip, was wir irgendwie schon mal hatten, jetzt vor kurzem gar
4:10
nicht so lange her, aber auch irgendwie wieder nicht.
4:16
OK, krass jetzt, jetzt bin ich, jetzt bin ich neugierig.
4:21
Na ja, also ich fang erstmal so an.
4:23
Ja wir hatten ja das IOSP Prinzip, das wurde uns ja
4:26
vorgeschlagen auf dem Discord und dann haben wir gesagt, OK,
4:30
wir gucken uns das mal an, weil wir kannten das selber noch
4:33
nicht und dann haben wir gesagt, es ist irgendwie interessant,
4:35
lass uns das mal angucken, recherchieren und dann mal ne
4:37
Podcast folge darüber machen und mal bewerten, so wie wir das so
4:39
finden. Was ja wirklich n cooles Prinzip
4:42
ist. Ne so.
4:44
Echt, wirklich unbekannt. Für viele aber hat n sehr guten
4:48
Kern sag ich mal. Genau fand ich dann nämlich
4:51
auch. Das Witzige war, als, wir haben
4:54
ja gesagt, OK, wir machen das und haben dann uns so n bisschen
4:57
irgendwie belesen und so weiter und jeder hat so für sich
5:00
recherchiert und dann haben wir uns quasi getroffen, haben
5:05
darüber geredet und haben gemerkt, OK warte mal, wir haben
5:09
irgendwie. Was anderes uns irgendwie daraus
5:14
recherchiert, weil du hast das richtige Prinzip gefunden und
5:18
ich irgendwas völlig was. Ist einfach falsch abgebogen.
5:20
Stimmt nicht. Ja, genau, und es und das ist
5:25
halt auch das, worum es geht. Das witzige ist, dass es halt
5:27
eigentlich gleich heißt, also auch IOSP, manche sagen auch,
5:31
oder manchmal findet es man, findet man es auch unter IPOS
5:35
oder I Pos oder so. Als man ist sich glaub ich
5:40
uneinig, wie genau das heißt. Ja, das eine ist ja auch
5:43
eigentlich eher IOS principal, ne, also Integration, Operation,
5:49
Segregation, Principal und das was wir jetzt haben ist da geht
5:54
es um Input, Output, Storage und Processing ne OK so.
6:01
Klingt erstmal n bisschen nach diesem altbekannten Eva Prinzip,
6:05
aber ich denke da steckt noch mehr hinter.
6:09
Ja, also ich sag mal so, du kennst ja wahrscheinlich, oder?
6:12
Das kennen ja, also ich kenne es auf jeden Fall, ich denke, das
6:14
kennen viele, dass man irgendwie mit einem Softwareprojekt
6:17
startet, alles harmlos, alles gut, ja man haut irgendwo ne
6:21
Funktion hin, irgendwo brauchst du vielleicht mal n API call ne
6:25
oder API call sorry hab es mal wieder falsch ausgesprochen.
6:29
Das machst du mit Absicht, oder? Das ist immer so n kleiner
6:31
Träger den du siehst kitzelst. Hinten im Nacken.
6:34
Also ich für mich ist das völlig fein, aber es hat ja echt einige
6:37
Leute hart geträgt. Wo du das das erste Mal gesagt
6:40
hast, API, was hat er gesagt. Ja, das war ich.
6:46
Meine natürlich die API, aber das ist jetzt nur ein Beispiel,
6:52
ne, aber was halt. Also ich finde an dem Beispiel
6:55
kann man es ganz gut erklären, weil du fängst dann an und hast
6:58
dann aber irgendwann ne es geht relativ schnell hast du so ein
7:02
wenn du nicht aufpasst hast du so ein Code wo dann sowas wie?
7:06
Drin ist, dass der Input gelesen wird, die Daten verarbeitet
7:09
werden, die werden gespeichert und dann wird quasi Response
7:13
rausgeschickt und an sich klingt das ja auch erstmal ganz gut,
7:16
bis zu dem Punkt, wo du dann irgendwann sagst, OK warte mal,
7:18
das ist irgendwie alles nur im Controller drin oder was weiß
7:24
ich, du lagerst das eine aus, aber nur halbherzig, also weißt
7:27
du, wenn du sozusagen an einem Punkt kommst, wo deine
7:30
Verantwortlichkeiten wieder eigentlich völlig auseinander
7:34
driften, sag ich jetzt mal ne. Und man dann halt hinterher gar
7:39
nicht mehr checkt, was passiert. Man kann es irgendwie alles
7:42
nicht testen und man kennt es ja und sowas geht ja eigentlich
7:47
viel schneller als man irgendwie denkt und dann zack.
7:52
Also das was du recherchiert hast, nennen wir es mal I Post.
7:55
Das klingt irgendwie cool. Ja.
7:57
Obwohl es erinnert so n bisschen an diese komischen
7:59
Zigarettendinger, ne, die heißen icos heißen die ne ach so, na ja
8:02
gut, aber wir reden hier von Softwarethemen von guten Sachen
8:06
ja, also nennen wir es doch icos klingt erstmal cool und ich
8:12
glaube das Prinzip, wenn ich dich jetzt auch so richtig
8:15
verstanden hab, ist quasi auch in Richtung wie das IOSP auch
8:21
ähnlichen Ansatz verfolgt, dass du ne klare Trennung von Ebenen
8:25
oder Schichten sag ich mal hast. Also würde ich das jetzt
8:29
verstehen, dass man sagt, ich hab halt Input ganz klar
8:32
definiert, was ist Input Processing, hast du gesagt
8:36
Output oder auch Storage, dass ich halt so klare
8:38
Verantwortlichkeiten hab und das sind Ebenen unterteile um
8:42
gedanklich in meiner Architektur, das ist ja auch
8:46
irgendwo nachher wieder n softwarearchitektur Grundstein
8:48
den ich damit lege mit dieser Denkweise, dass ich wieder genau
8:53
weiß, wo kümmer ich mich um was. Ja.
8:57
Ist ja auch n gutes Beispiel jetzt denken sich so Leute, ja
8:59
ich hab n Controller, warum sollte der denn das und das
9:02
machen, das passiert aber wirklich schnell, dass man da n
9:04
bisschen Zuständigkeiten sagt man das auch vermischt.
9:09
Ja und deswegen ist das halt auch immer cool, nennen wir es
9:15
mal. Ich finde, dass diese Prinzipien
9:17
kann man auch so n bisschen als eselsbrücken betrachten, ja.
9:22
Also wenn ich zum Beispiel diese Abkürzung ipos jetzt im Kopf hab
9:25
ne und ich denk bei dem entwickeln daran dann ja, das
9:28
kann man sich gut merken und dann ja wofür stand das noch
9:31
mal? OK, was ist der Sinn dahinter,
9:32
weil das Prinzip genauso wie bei IOSP ist ja nie kompliziert in
9:38
der Theorie. Die Praxis.
9:40
Ist nachher das Entscheidende ist wirklich sauber
9:42
durchzusetzen, um die Benefits davon zu haben und genauso, wir
9:47
werden ja jetzt da auch so n bisschen drüber reden hoffe ich
9:49
ne also ich hoffe du hast noch n bisschen Zeit.
9:52
Muss gleich los. OK, ich beeil mich, dass es in
9:58
der Theorie nicht immer einfach ist, diese 4 Ebenen einzuhalten,
10:01
aber man halt gute Benefits davon zieht, wenn man, wenn man
10:04
es schafft halt ja. Auf jeden Fall.
10:06
Ich mein Gut, im Endeffekt gibt es, es gibt immer viele
10:08
Prinzipien, die dafür sorgen oder sagen, ja, damit
10:11
strukturierst du deinen Code und so weiter ne das da gibt es
10:14
natürlich verschiedene und das sind doch.
10:16
Mehr oder weniger verschiedene, aber vielleicht auch Ansätze,
10:19
die sich wieder ähneln. Es ist aber trotzdem immer
10:22
irgendwie interessant, darüber sag ich mal Bescheid zu wissen
10:25
oder auch mal die ein oder andere Brille aufsetzen zu
10:29
können, um zu sagen macht das gerade mehr Sinn oder das gerade
10:32
mehr Sinn ne ich meine du hattest ja auch gesagt, dass.
10:36
Dieses ipos da sozusagen schichtentrend, und das tut es
10:40
auch irgendwo. Aber in in diesem Fall ist es
10:43
schon so, ist der Fokus von der Denkweise, sag ich jetzt mal,
10:46
für dieses Prinzip mehr wie fließen Daten durch dein System,
10:51
weißt du also wenn du das so n bisschen abgrenzt zu IOSP was
10:56
wir hatten, dann ist das ja wirklich so sag ich mal ne.
11:01
Mehr noch, diese Art von wer ist wirklich für die Business Logik
11:05
verantwortlich und wer nicht ne so diese Trennung sag ich jetzt
11:08
mal. Und hier ist es natürlich auch
11:10
irgendwo sinnvoll zu sagen, OK wo findet die Business Logik
11:14
statt, aber irgendwie ist da mehr so diese Brille aufzusetzen
11:17
wie fließen Daten durch mein System durch ne und gerade wenn
11:20
wir jetzt bei dem Controller sind und wir ne ordentliche
11:23
Struktur aufbauen wollen, dann ist es ja nicht so dass man sagt
11:27
OK du kippst Daten in den Controller rein und.
11:30
Da ist Feierabend und dann gibt es wieder ne Antwort raus.
11:33
Sozusagen ja, aber genauso kann man natürlich auch n Controller
11:36
mit IOSP betrachten, ja. Ja, es geht halt beides.
11:43
Aber siehst du es nicht denn trotzdem so, dass diese
11:47
Schichten so Verantwortlichkeiten definieren?
11:51
Ja, schon. Wie gesagt, das ist halt nur so
11:54
n. Also ich finde auch, wenn wenn
11:57
ich mal ehrlich bin, dass die. Also die Art und weisen von
12:02
beiden Prinzipien zum Beispiel, aber auch von anderen Prinzipien
12:04
schon sehr ähnlich sind. Aber.
12:07
Wie gesagt, es ist halt. Irgendwie ne Art und Weise an
12:11
die Dinge ranzugehen oder Dinge zu betrachten.
12:14
Ja, also find ich immer und für mich ist es halt so n Ding, dass
12:17
dass dieses Prinzip halt dafür da ist zu sagen, wie fließen
12:20
Daten halt durch mein System. Ne.
12:22
Die diese diese Grundbrille aufzusetzen.
12:26
Und dann halt eben die Schichten daraus abzuleiten.
12:28
Ne. Gerade bei IOSP kann sich das
12:30
ganze ja noch, wenn du es richtig durchziehst oder je
12:33
nachdem wie krass du wie feingranular du es durchziehst,
12:36
kann das ja noch sehr sehr feingranularer dann am Ende
12:40
sein, ne, dass du immer wieder ne Schicht hast die sagt OK wir
12:43
sind jetzt hier an der Operation, aber wir sind wieder
12:46
einer oder an der Integration noch mal in der Integration
12:48
jetzt sind wir in der Operation zum Beispiel ne das also.
12:51
Das das war ja diese Baumstruktur, die sich dadurch
12:54
sozusagen ergibt, dass man das wirklich wieso n.
12:56
Baum aufzeichnen kann. Das ist ja auch wirklich das
12:58
Spannende dabei, wenn man es also komplett durchzieht, ja
13:02
genau, ja, geh ich mit, also wenn man so drüber nachdenkt,
13:06
dann ist IOSP in dem Ursprung so, wie wir das ja auch erklärt
13:12
hatten. Es ist halt ne Denkweise wie ich
13:16
unterteile. Ne ist es halt wirklich Logik,
13:19
also ist es Operation oder ist es eher NN Ablauf den ich
13:23
definiere die Integration sozusagen und hier so wie ich
13:29
das jetzt verstanden habe, geht es eher darum ja ich find Fluss
13:34
Datenfluss gar nicht schlecht das so zu nennen es wirklich in
13:38
4 Ebenen einzuteilen diese. Ein Kreislauf sozusagen und
13:43
nicht Kreislauf, sondern ein Ablauf.
13:45
Ne, ich krieg halt zum Beispiel von außen ne Anfrage, keine
13:48
Ahnung was das immer es kann. Was hast du gesagt NAPI Call
13:52
sein ja den ich empfange entgegennehme es können
13:55
Sensordaten sein ja also es muss ja jetzt nicht alles wieder Back
13:58
and Frontend sein, das kann natürlich auch irgendwas
14:00
embedded mäßiges sein, dass Sensordaten aufgezeichnet werden
14:04
die verarbeitet werden müssen, dann hab ich ja auch.
14:06
Mein Input Processing, vielleicht auch noch n Storage,
14:09
wenn ich so die letzten Messungen meinetwegen speichern
14:11
möchte oder so und auch wieder n Output, dass ich irgendwas auf
14:14
einer auf dem Display Anzeige oder so.
14:17
Ja und im Prinzip geht es darum die Verantwortlichkeiten für
14:23
diese 4 Schritte im Fluss festzulegen und IOSP an sich ist
14:30
irgendwie noch ne Ebene abstrakter da drüber, weil.
14:36
Das wiederum kann ja in diesen Teil 4 Ebenen, die wir heute
14:39
besprechen, ja wieder integriert sein und mehrfach drin
14:42
vorkommen. Ja, find ich gut.
14:44
Sich den Baum noch mal vorstellt, ne, dass ich so
14:46
verschiedenen Ebenen habe, wo meine Blätter sag ich mal drin
14:50
sind und dann geh ich diese Ebenen runter und wieder hoch
14:53
sozusagen, aber der Baum kann ja mehrere Blätter da drin haben,
14:57
weißt du wie ich das mein? Ja, das war halbwegs
14:59
verständlich, also was ich eigentlich noch.
15:02
Oder was, wo, was? Ich auch.
15:04
Eigentlich gerade noch sagen wollte, das hast du ja mehr oder
15:06
weniger gerade ausgedrückt. Ich versuche noch mal
15:08
zusammenzufassen es das eine schließt das andere ja nicht
15:10
aus, nur weil man etwas betrachtet aus der Brille von
15:15
ipos ne wo wie die Daten durchs System fließen heißt das dann
15:19
noch lange nicht, dass man nicht auch in der Lage ist zusätzlich,
15:22
das ist ja eine relativ grobe Brille wie du meintest.
15:25
Diese 4 Einheiten die du dann irgendwie siehst, die eigentlich
15:27
fast immer auftreten. Und dann aber zum Beispiel IOSP
15:32
noch drauf zu setzen, um zum Beispiel die einzelnen Bereiche
15:35
zum Beispiel auch vielleicht noch mal n bisschen besser zu
15:39
strukturieren und so weiter in viel Feingranularer, das ist ja,
15:43
das schließt sich das eine ja nicht aus, und das sollte man
15:45
auch immer irgendwie, vielleicht im im Auge behalten, ne, das ist
15:48
jetzt nicht zum Beispiel wie bei Softwarearchitekturen, wo du
15:51
sagst, OK, ich mach jetzt mal n Monolith und gleichzeitig mach
15:54
ich noch n microservice. Oder Microservices draußen.
15:57
Das wird irgendwie nicht funktionieren, aber gerade bei
16:00
sowas zum Beispiel, da schließt sich das eine, schließt das eine
16:02
das andere nicht aus, ne? Ja, aber dann lass uns das Ganze
16:07
doch mal an einem simplen Beispiel machen.
16:09
Ich find halt so, n Backend ist eigentlich mal n ganz gute,
16:12
gutes Beispiel für sowas um diese 4 Schichten mal
16:15
durchzusprechen, weil ich hab das Gefühl ja also ich hoffe da
16:19
kommen wir hinzu dem Fazit, wenn nicht dann ist auch cool, dass
16:23
man das. Ipos nenn ich es jetzt noch mal.
16:28
Ja, also wie gesagt, gibt halt verschiedene, also diese 4
16:30
Ebenen ja im Prinzip ja wirklich n Grundstein für Architekturen
16:35
ist. Was ich vorhin schon mal kurz
16:37
meinte, weil wenn ich jetzt so drüber nachdenke, wir haben so
16:39
über hexagonale Architekturen gesprochen beispielsweise dann
16:42
habe ich ipos da drin in, also vervielfacht sozusagen.
16:48
Ich habe dann so Domain basiert ja immer sozusagen ipos.
16:53
Ich weiß. Nicht wie ich es anders
16:55
formulieren soll, aber es ist im Prinzip irgendwo ja schon der
16:58
Grundstein für Architekturen. Und wenn wir das jetzt mal am
17:01
Beispiel durchsprechen, glaub ich, wird das auch ersichtlich.
17:04
Ja, deswegen lass uns da mal anfangen, wir nehmen jetzt mal n
17:07
ganz einfaches Backend und das hat jetzt nicht verschiedene,
17:10
also wir betrachten das jetzt nicht domänenweise, sondern es
17:14
gibt nur eine, es ist jetzt so n ganz ganz einfaches Backend ja
17:18
minimal bei und. Wir haben jetzt nen Controller
17:23
wie du meintest. Das ist für mich jetzt gerade
17:26
so, diese Inputschicht ja unter anderem ja werden wir noch
17:30
sehen, aber es ist auf jeden Fall ne Inputschicht, das heißt
17:33
über diesen Controller ja, wir haben jetzt so ne
17:35
Controllerklasse kann ich Anfragen entgegennehmen,
17:39
beispielsweise eine ganz simple Anfrage, ich möchte wissen, die
17:45
wievielte Folge ist das vom Coding Buddies Podcast?
17:49
Ja. Irgendwas jenseits der 160.
17:52
Ja, genau, ich weiß es gerade auch nicht, das ist schon mal
17:55
gut, Backend weiß es nicht, also größer 160 erwarten wir als
18:00
Antwort so, das heißt, diese Anfrage kommt rein so, jetzt ist
18:06
das was ist so die Aufgabe von dieser input Ebene natürlich die
18:11
Daten empfangen OK aber zählst du da noch andere Sachen hinzu?
18:15
Ja, du kannst halt Daten, also Daten entgegennehmen.
18:18
Klar wie du meintest sie aber zum Beispiel auch zu validieren,
18:21
ja, oder in vielleicht in n internes Format umzuwandeln ne
18:26
und da kannst du natürlich das direkt im Controller machen, ne,
18:29
dass du das sozusagen wirklich dann dort aufnimmst.
18:31
Du kannst es natürlich, aber sozusagen auch noch auslagern,
18:33
dass du dass der Controller jetzt gar nicht so viel macht.
18:38
Da sind wir dann aber schon wieder, würde ich sagen, schon
18:39
fast wieder so n bisschen gehen wir in die Richtung IOSP, was
18:42
wir schon gesagt haben, ne, dass wir sagen wir der Controller ist
18:45
NN Operator n Integrator, der quasi dann im Endeffekt die
18:49
einzelnen Operations aufruft, ne und zum Beispiel sagt OK bitte
18:52
hier ich geb das jetzt mal weiter erstmal jetzt die
18:56
Eingaben validieren ne, aber das ist prinzipiell genau der die
19:00
Aufgabe vom Input von der Inputschicht, dass man sagt OK
19:03
es kommen Daten rein und wir. Validieren Sie und bearbeiten
19:07
Sie so oft, dass wir sie quasi auch nicht nutzen können.
19:09
Ja, also das ist zum Beispiel n wichtiger Punkt, den ich auch da
19:13
bei der Inputschicht sehe oder was so ne Practice ist, die ich
19:17
gerne mache. Ja, ist ja auch Geschmackssache,
19:19
immer am Ende des Tages, aber man trennt ja oft im Prinzip das
19:27
interne Datenmodell von der Außenrepräsentation.
19:31
Ne, also so klassische DTOS und mein internes Datenmodell.
19:38
Angenommen, ich empfange jetzt, wie soll ich sagen oder geben
19:44
wir ja doch sagen wir mal, ich empfange als Werte oder als
19:49
Anfrage zum Beispiel irgendwelche Filter oder so als
19:53
String so, das ist aber ne ne Zahl ist jetzt wirklich n ganz
19:57
simples Beispiel. Dann will ich intern ist es für
20:00
mich ne Zahlen intecher bei beispielsweise Empfang hab ich
20:03
aber n string so das ist jetzt ne relativ simple Konvertierung.
20:08
Ja, aber es ist passt halt nicht zu meinem internen Datenmodell
20:11
und das sowas seh ich halt auch bei der bei der Inputschicht zu
20:16
sagen OK ich muss aus diesem String ne Zahl machen und das
20:20
geb ich dann in mein. Processing sozusagen.
20:24
Weil intern erwartet mein System da ne Zahl und ich will nicht da
20:28
jetzt n String reingeben und erwartet dann von meinem System,
20:30
dass es das noch konvertiert. So, das ist so meine Denkweise,
20:35
ich versuch dann zum Beispiel von sag ich mal einem DTO ja
20:39
was, ich empfange es intern zu mappen auf meine interne
20:43
Datenpräsentation, aber dann halt noch in diese Inputschicht
20:47
zum Beispiel im Controller. Genau.
20:49
Und gebe dann das an die Processingschicht, was
20:52
beispielsweise ein Service sein kann, der hat weiß genau Input
20:56
Output ist klar definiert vom Format, also vom Datentyp her
20:59
und arbeitet damit. Genau.
21:02
Und dann hast du halt in deinem Processing hast du halt die
21:05
Business Logik drin, die halt die Daten dann im Endeffekt die
21:08
aufbereiteten Daten die zu deinem.
21:10
System passen die dann halt verarbeitet werden.
21:13
Also da steckt dann halt. Das ist quasi Schicht 2.
21:15
Jetzt sind wir jetzt. Gedanklich ne genau Input
21:17
Processing, genau wo dann die Geschäftslogik drin steckt.
21:21
Zum Inputschicht Ich find gerade beim Controller zum Beispiel ist
21:24
n Controller auch sag ich mal nativ auf jeden Fall auch
21:29
irgendwie ne Art von. Input Teil definitiv, weil du
21:34
kannst. Natürlich, wenn du sagst, du
21:35
erwartest zum Beispiel Daten ja n String beispielsweise in
21:39
deinem, was du entgegennimmst in deinem Rest Endpunkt nur mal als
21:42
Beispiel und. Du Sendest aber n Canon Array
21:46
oder so ne, dann knallt es da ja auch schon.
21:49
Also bevor du überhaupt dieses. Validieren das absolut, seh ich
21:53
da auch. Aber bevor du die Daten fehlen
21:55
halt ja. Also wenn du einfach keine
21:57
gültige Anfrage kriegst. Genau also musst du.
21:59
Das nicht in dein System schleifen, weil ist halt ne.
22:02
Richtig. Also es ist ja ein Unterschied,
22:04
ob du zum Beispiel sagst, du hast erwartest, eine Zahl
22:07
kriegst eine Zahl, aber du sagst, die Zahl darf nur
22:09
zwischen 5 und 10 liegen, als Beispiel ne, dann musst du es
22:13
halt noch mal für dich validieren mit deinem ich nenn
22:15
es mal eigenen input Teil, aber das wollte ich noch mal so
22:18
sagen, weil ich das irgendwie interessant für später finde,
22:22
ne. Aber das ist ein spannender
22:24
Punkt. Ich weiß nicht, ob das das
22:25
später ist. Siehst du?
22:28
Was siehst du da in der Inputschicht zu prüfen, dass die
22:31
Werte da sind, also dass es eine valide Anfrage ist oder auch
22:35
noch, ob der es in einem Geldgültigen.
22:38
Wertebereich ist ja ist n guter Punkt.
22:42
Also es kommt tatsächlich etwas drauf an.
22:44
Weil also angenommen du hast zum Beispiel sowas wie n so ne so ne
22:55
anmeldeform oder so ne. Und da sind vielleicht irgendwie
22:59
Dinge definiert, wo du wirklich sagst, ich validiere Werte,
23:03
damit ich sozusagen mit der Business Logik damit arbeiten
23:07
kann. Dann würde ich sagen, dass das
23:08
Validieren der Werte, je nachdem wie es halt eben aussieht, zum
23:12
Beispiel weiß nicht, da darf kein SZ drin sein oder so, rex
23:16
Dinge oder so ne, also Sonderzeichen oder so, dass man
23:20
sowas schon vorher finde ich abfragen kann im in der input
23:24
Validierung. Bevor man wirklich in die
23:26
Geschäftslogik reingeht, da würde ich schon, das würde ich
23:29
schon sagen, wenn es jetzt zum Beispiel um bestimmte Werte
23:31
geht, so kleinere Abfragen bei Berechnung oder so ne kann man
23:39
es theoretisch auch in der in der Geschäftslogik dann mit
23:44
Reingeben, ne, also dass man aber das das das hängt
23:47
tatsächlich n bisschen finde ich vom Anwendungsfall ab aber.
23:51
Es ist schon schön, wenn du Daten in die Geschäftslogik
23:54
reingibst, wo die Geschäftslogik weiß.
23:56
Ich kann damit arbeiten und muss nicht noch überprüfen.
23:59
Sind denn die Daten valide, mit denen ich jetzt arbeiten darf,
24:02
sondern ich finde, die Geschäftslogik kann schon sagen.
24:05
Das was ich. Bekomme damit kann ich meine
24:08
Logik auch ausführen und muss nicht vorher noch sagen ja, aber
24:11
vielleicht passt das hier gerade gar nicht.
24:16
OK. Seh ich an manchen Punkten
24:20
anders, aber wie gesagt, das ist halt Geschmackssache.
24:24
Ich zum Beispiel gehen wir also ob die valide sind, ja ob das
24:28
gilt, der Datentyp eingehalten ist, ob das zum Beispiel sag ich
24:32
mal, konvertiert werden kann, überhaupt sowas seh ich auch in
24:35
der Inputschicht, aber zum Beispiel hat etwas keine Ahnung,
24:39
du überprüfst ob es ne. Gültige Länge hat etwas nicht zu
24:42
lang ist zu kurz ob der Wertebereich eingehalten ist, ob
24:46
zum Beispiel sagen wir mal, du willst auf irgendwas zugreifen
24:49
und kriegst nen Index -1 oder sowas, sowas seh ich halt
24:54
irgendwie im Service dann also in der Processingschicht, weil
24:57
es denn einfach sich besser abtesten lässt an der Stelle
25:00
auch als das im Controller zu machen, also sowas sowas bau ich
25:05
zum Beispiel dann in den Service mit ein.
25:07
Also wie gesagt, das ist ja auch dann immer Geschmackssache, ne,
25:10
aber deswegen spannende Frage, wo hört bei dir Validierung auf
25:16
und wo? Also in im Input auf ne weil wie
25:20
gesagt diese Fehlerfälle die jetzt so wirklich definierte
25:23
Fehlerfälle sind, die hab ich zum Beispiel dann meistens in
25:27
der Processing Service Schicht. Und alles, was, so sag ich mal n
25:31
klassischer Bad Request ist, hab ich dann im Controller sowas wie
25:35
es fehlen Daten im im Body. So jetzt trifft mal n bisschen
25:38
ab aber ich find die Frage spannend also liebe Zuhörerin
25:40
liebe Zuhörer, sag uns auch gerne mal deine Meinung dazu,
25:43
weil das macht halt gefühlt auch jeder anders.
25:46
Also deswegen hatte ich vorhin gemeint, noch ganz kurz, dass
25:49
man halt zum Beispiel ja diesen Input auch auslagern kann.
25:52
Also angenommen du kriegst NDTO rein und möchtest es, aber zum
25:55
Beispiel in dein internes Datenformat wandeln, kannst du
25:57
das ja in einem eigenen ich nenn es jetzt.
25:59
Mal Service ja, was jetzt? Nicht unbedingt, sagen wir mal.
26:01
Ich nenne es jetzt mal Input, Service, Name austauschbar, aber
26:06
dass du dann quasi diese ganze Umwandlung dort machen könntest
26:09
beispielsweise und dann das Objekt in den Service rein
26:11
gibst, das heißt du könntest dann quasi muss das nicht alles
26:14
im Controller auf Controller Ebene testen, sondern kannst
26:17
sozusagen diese Validierung, Umwandlung und so weiter alles
26:19
einzeln in einem einzelnen Klasse testen und kannst dann
26:22
sozusagen im Service davon ausgehen, dass du halt eben die
26:24
entsprechenden Daten auch so bekommst, wie du sie haben
26:27
möchtest. Gerade jetzt in dem Punkt, wo
26:29
ich meinte, wenn du sagst, du kannst einen String reingeben,
26:32
OK, das kann der Controller nicht unbedingt abfangen, aber
26:35
bestimmt also ne, aber du kannst halt Sonderzeichen reingeben und
26:39
die kannst du theoretisch schon mal vorfiltern, damit du das
26:41
nicht im Service machen musst. Aber wie ich auch meinte, es
26:43
kommt voll auf den Anwendungsfall drauf an, aber ja
26:47
ist voll spannende Geschichte, weil da trifft man glaube ich
26:50
auch bei 2 Leuten auf 3 meinungs.
26:53
Ja, das zeigt halt einfach, dass diese Grenzen halt so n bisschen
26:56
schwimmend sind. Es gibt halt kein richtig oder
26:58
falsch. Ne, das Gleiche sieht man,
27:01
obwohl ich glaub in der nächsten Schicht ist es n bisschen klarer
27:04
noch wenn wir jetzt sagen wir haben jetzt unser Processing,
27:07
beispielsweise ne Serviceklasse die jetzt die Business Logik
27:10
beinhaltet und die Business Logik hat halt.
27:13
Wir jetzt zum Beispiel drin, dass wir uns eine Anfrage
27:16
speichern oder bei was hatte ich vorhin gesagt, Sensordaten, die
27:19
letzte Messung speichern, also auf jeden Fall eine Art Storage
27:23
harm, auf den wir zugreifen, und da finde ich kann kann man sehr
27:27
gut die Grenze ziehen, weil die Business Logik hat wie gesagt
27:32
also die der Service hat wie gesagt jetzt in der Processing
27:35
Schicht die Business Logik mit der Reihenfolge was wie
27:38
berechnet werden muss oder gespeichert werden muss et
27:41
cetera aber dann. Wenn ich in dem Moment komme,
27:44
dass ich etwas aus dem Speichern lese oder schreibe, verlass ich
27:47
halt die Schicht und hab wieder ne Schnittstelle und bin dann in
27:50
der Storage Ebene, was ja ganz oft so im klassischen Sinne nen
27:55
Repository ist und nur das Repository arbeitet auf der
27:59
Datenbank heißt lädt, also liest davon und schreibt da drauf.
28:03
So und das ist ne ganz klare Trennung finde ich.
28:06
Ja, auf jeden Fall. Definitiv geh ich auch so.
28:12
Ich glaub da gibt es auch gar nicht so viel zu zu sagen, weil
28:16
was Gutes ist natürlich dann an der Stelle diese die
28:20
Schnittstelle zur Datenbank so zu gestalten, dass man halt im
28:23
Endeffekt die Datenbank auch austauschen könnte.
28:25
Ne so gut wie es geht das mal sozusagen wichtiger.
28:29
Punkt. Weil wenn ich das im Service
28:30
hab, dann wird es halt schwierig.
28:32
Genau deswegen hier wieder auch die Trennung und dann gibt dann
28:36
kommen wir zum Output, ne sozusagen dem letzten Part.
28:40
Und das ist ja der Punkt, wo sozusagen die Ausgabe
28:43
stattfindet, wo das Ergebnis im Endeffekt wieder nach außen
28:45
gegeben wird. Also wenn du jetzt zum Beispiel
28:48
sowas wie bei unserem Backend hast, dann zum Beispiel den AP
28:51
Response beispielsweise ne und ich finde um.
28:56
Bevor ich das jetzt, wo ich darauf jetzt eingehe, finde ich,
28:58
es gibt noch ein kleines cooles Beispiel, was irgendwie relativ
29:01
straight ist meiner Meinung nach, weil wenn du zum Beispiel
29:05
Ziel I Befehl machst. Du machst zum Beispiel, da hast
29:07
du ja auch so den Input über das Terminal.
29:10
Beispielsweise gibst du etwas rein, dann wird irgendwie was
29:12
berechnet und dann wird zum Beispiel eventuell eine Datei
29:16
erzeugt oder so, die dann. Am Ende rausgegeben wird.
29:22
Man könnte also es ist natürlich auch wieder so n Ding es.
29:25
Ist die. Dateiausgabe, die sozusagen
29:28
erzeugt wird, ist das das Storage oder ist das die?
29:31
Ist das der Output? Kann man drüber reden, aber ich
29:33
find es, es kann halt relativ straight sein, dass es ein so ne
29:36
Linie ist. Weißt du wo du sozusagen
29:37
anfängst und dann hinten hinten rauskommst?
29:40
Bei so einem Controller ist es ja so, wir haben den.
29:43
Request, der reinkommt, dann geht der irgendwie ne
29:46
Validierung, dann die Processings wird gespeichert und
29:49
dann geht der ja irgendwie wieder zurück und kommt der über
29:52
den Controller wieder raus ne und?
29:55
Quasi rückgabewerte sozusagen, die man dann genau und damit
29:59
antwortet. Sozusagen.
30:01
Genau. Also jetzt größer 160 bei der
30:04
Folge. Richtig, und da finde ich ja zum
30:07
Beispiel, also da denk ich mir dann oder im ersten Moment, wenn
30:10
ich so darüber nachdenke, hab ich mir gedacht, OK.
30:12
Wenn jetzt n Controller n Request bekommt ne und der aber
30:16
gleichzeitig auch wieder antwortet.
30:18
Ne hab ich mich dann gefragt, ist da nicht eigentlich die
30:21
Trennung kaputt? Ne wenn man jetzt sagt man also
30:23
wir hatten ja auch von der Trennung von
30:25
Verantwortlichkeiten gesprochen und das fand ich irgendwie
30:28
interessant, wie siehst du das? Weil du jetzt quasi eine
30:35
Controller klasse oder ne Instanz davon nutzt um Input und
30:39
Output zu machen. Genau, beim Backend
30:41
beispielsweise. Also sagen wir mal so, auf
30:47
theoretischer gedanklicher Ebene ist es noch klar getrennt.
30:52
Auf codetechnischer Ebene ist das halt nicht mehr einfach so
30:56
ersichtlich ne, weil ich hab jetzt zum Beispiel eine Funktion
30:58
die aufgerufen wird ne beispielsweise da ist jetzt mein
31:02
Get Endpunkt, der ruft die Funktion auf wo wir die Daten
31:06
entgegennehmen, dann wird der Service aufgerufen und das
31:08
Ergebnis vom Service wird. Mit einer Antwort 200 OK, Größe
31:13
160 zurückgegeben. So dann hab ich jetzt in einer
31:16
Funktion Input und Output. Gedanklich ist es ja trotzdem
31:20
irgendwo klar getrennt, aber halt Code technisch nicht das
31:25
das versteh ich was du damit meinst ist aber oft sag ich mal
31:31
auf so Framework basiert einfach so umzusetzen weil es ja auch
31:35
weil es ja auch. In eine Schleife.
31:38
Es ist halt n Roundtrip sozusagen ja in dem Fall bei
31:41
Backends. Jetzt, weil.
31:43
Ich muss natürlich genau auf diesen Request auch antworten.
31:47
Ja, also ist das ja auch gut ersichtlich.
31:49
Ich kriege diese Antwort, die die Anfrage rein, ich verarbeite
31:52
sie und ich antworte da drauf und das seh ich halt im Code
31:56
dann auch sauber strukturiert und trotzdem könnte man
31:59
gedanklich in den Codezeilen so n Overlay machen sag ich mal und
32:04
sagen Input Processing. Output und im Processing in der
32:09
Funktion hab ich dann noch mein Storage sozusagen.
32:12
Also ich kann das ja trotzdem klar trennen, so Highlighten
32:16
sozusagen zeigen, wo ist die Ebene und dadurch glaub ich
32:20
meiner Meinung nach ist es schon sauber getrennt, aber es ist
32:24
natürlich nicht so schön ersichtlich, als wenn ich noch
32:28
beispielsweise gehen wir noch mal in so n.
32:32
Embedded Bereich. Ja, ich hab jetzt meine
32:34
Sensordaten gut, das seh ich jetzt kann ich auch nur in der
32:37
Theorie machen, aber da hab ich halt den Sensor als Input, diese
32:41
Daten werden wahrscheinlich denn aufbereitet irgendwie
32:44
verarbeitbar gemacht, geht ins Processing, da wird die
32:48
Berechnung durchgeführt was auch immer der das damit passiert und
32:52
am Ende ja dann hab ich das so n bisschen gespeichert auf dem
32:55
Gerät und dann geh ich zum Beispiel zu einem Display und
32:57
zeig das an das Ergebnis ja oder?
33:01
Taschenrechner, ja, Input ist. Ich drück meine Zahlen und meine
33:06
Plus zum Beispiel, Na meine rechenoperation nenn ich es mal.
33:10
Das wird intern verarbeitet, dann kann man ja auch oft noch
33:13
mal das letzte Ergebnis widerrufen, das heißt es wird
33:15
auch irgendwo gespeichert und das Display wenn ich auf ist
33:19
gleich drücke zeigt mir mein Output an so und da, da hast du
33:23
halt ne klare Trennung, da kannst du sagen ich hab die
33:24
Tasten als Input. Ich hab meine Recheneinheit da
33:27
drin. Ich hab noch n kleinen Speicher
33:30
und das Display ist die Anzeige am Ende ne also wenn du jetzt
33:33
nicht so n roundtrip hast sondern wirklich geradlinig,
33:36
dann ist es halt absolut klar trennbar.
33:38
Genau. Also das mein ich auch ne, das
33:39
ist halt, das ist halt bei manchen Systemen ist es halt,
33:42
also man sieht erstmal super gut, dass dieses ipos ja schon
33:46
irgendwie in vielen Systemen oder wenn ich gerade nahezu in
33:50
allen Systemen irgendwie drin steckt, dass man es auch so
33:53
einteilen kann wie du meintest so highlighten kann.
33:57
Und gerade beim Controller war für mich als erstes so, na ja
34:00
OK, aber du hast doch, also weil es auf der einen Seite heißt
34:03
Trend das und auf der anderen Seite, wenn du dir den
34:06
Controller nimmst, war für mich so OK, das ist aber irgendwie
34:09
dann Input und output irgendwie das gleiche ne was ich aber noch
34:12
interessant finde, so vom Gedankengang her und das hab ich
34:16
früher zum Beispiel auch ganz oft gemacht.
34:18
Es gab den Punkt, wo dann zum Beispiel das Processing vorbei
34:21
war und du kriegst ja dann irgendwie was zurück, oder du
34:24
willst ja irgendwie was zurückgeben und wenn es nur in
34:26
200 OK ist, ne im besten Fall ist es nicht nur 200 OK, aber du
34:32
willst ja irgendwas zurückgeben und dann kann es ja sein, dass
34:36
zum Beispiel die Rückgabe etwas anders ist als das, was du aus
34:41
dem Processing irgendwie aus dem Business Model Zurückbekommst.
34:44
Ne zum Beispiel möchtest du für irgendein Objekt nicht die
34:46
Datenbank ID mit übergeben? Geben oder so ne kann ja sein,
34:50
so macht ja auch irgendwie Sinn und dann hast du irgendwie n
34:54
Punkt wo du dann sagst OK ich bereite meine Daten irgendwie
34:57
noch mal auf bevor ich sie wirklich jetzt endgültig
34:59
rausschicke. So sehr wichtiger Punkt, ja.
35:02
Genau. Und dann kann es natürlich auch
35:04
sein. OK, vielleicht schicke ich ne
35:06
200 zurück, vielleicht schicke ich aber auch was anderes
35:09
zurück, auch in einem Fehlerfall, was schicke ich da
35:11
zurück und ich hab das ganz oft so gemacht, dass ich dann im
35:13
Controller gesagt Hab, wenn das und das passiert ist, dann
35:16
schicke ich zum Beispiel ne 404 104 04 zurück oder wenn das dann
35:20
200 OK mit den und den Daten und die Daten habe ich dann da noch
35:23
aufbereitet, aber eigentlich ist es ja viel schöner, dass man
35:26
dann. Sagt oder die Idee an der Stelle
35:29
ist man diesen diese Output, diesen Output Bereich wieder
35:33
auslagert in eine eigene Klasse, nenne ich das mal, dass du sagen
35:36
kannst, OK, hier nimm mal das was ich vom Processing bekommen
35:40
habe und bereite mir bitte die Antwort auf und dann hast du
35:43
nämlich genau diese Orchestrierung des Controllers,
35:45
dass der Controller sagt, OK, ich Krieg einen Input, der
35:48
Controller sagt nur. Mach erstmal bitte Validierung,
35:52
dann mach bitte das Processing. Das Processing kümmert sich dann
35:55
irgendwie auch noch ums Speichern und dann bitte bereite
35:58
mir den Rückgabe die Rückgabewerte auf und dann hast
36:02
du sozusagen den Controller irgendwie.
36:03
Als Art. Hülle.
36:05
Ne, der dann natürlich irgendwie was rein und raus gibt.
36:08
Aber das eigentliche was man dann highlightet ist dann
36:11
sozusagen wirklich dieses Input. Ne was?
36:15
Wo ich meinte, was man ja theoretisch auslagern kann, muss
36:17
man nicht. Aber dann hast du den Input, den
36:20
Processing und den Output und der Controller ist nur die
36:22
Hülle. Ne und das fand ich irgendwie
36:24
irgendwie ganz interessant so, weil so, dass den Code dann auch
36:29
wieder schöner macht und den Controller irgendwie klarer dann
36:34
definiert am Ende oder Struck das.
36:35
Macht den Controller halt unglaublich schlank, am Ende
36:38
genau und. Man besinnt sich sozusagen auf
36:42
die eigentliche Funktionalität, dass ich sehr schnell lesen
36:44
kann. Auf was reagiert der Controller
36:47
und was kann er antworten? Genau, weil das ist nur wichtig
36:51
an der Stelle und ich finde es auch gut dieses, dass du sagst,
36:54
das Aufbereiten des Ergebnisses, dass man das auch noch mal, also
36:59
nicht es ist, was heißt auslagern, aber dass man das
37:02
getrennt betrachtet, und das ist auch wichtig, und beispielsweise
37:06
finde ich, ist es keine schlechte Practice.
37:09
Die internen Datenmodelle, was als Antwort ist, weil du jetzt
37:12
meintest da ist ne ID drin. Ja dann ist natürlich n
37:14
klassischer Fall, dass ich mir auch ne Response DTO bastel, was
37:18
nicht mehr die ID drin hat, aber ich bin mittlerweile an dem
37:22
Punkt, dass ich mir immer ein DTO bastel, selbst wenn sie noch
37:25
identisch zum Datenmodell sind, weil ich habe diese Abstraktion
37:29
genau die du meintest drin, dass ich halt die Chance habe zu
37:32
sagen, wenn mein System sich so ändert, dass ich nicht mehr
37:35
alles rausgehen kann. Habe ich halt diese
37:38
Schnittstelle ne und dann ist der Controller weiß ganz klar da
37:41
gehe ich hin und da wird verwaltet was wirklich am Ende
37:44
zurückgesendet wird und ich sorge nur noch dafür, dass das
37:46
Zurückgesendet wird, weil meine Aufgabe ist nur das
37:49
Orchestrieren und das ist n wichtiger Punkt und all diese
37:52
Mechanismen oder diese Denkweisen haben am Ende ja
37:56
immer gleiche oder ähnliche Benefits, lass uns da ganz kurz
38:00
noch drüber sprechen, warum das ganze, ich hatte es vorhin kurz
38:03
angerissen. Es ist einfach viel, viel besser
38:08
für die Testbarkeit sowas umzusetzen.
38:11
Und ja, wir sagen das bei jedem zweiten Prinzip, aber es ist
38:13
halt ganz oft der Benefit dahinter, weil es unfassbar
38:17
wichtig ist seine Software abzutesten und beispielsweise
38:20
wenn ich alles Controller und Service so sauber trenne, ja
38:24
dann kann ich halt zum Beispiel sagen.
38:26
Was teste ich bei den Controller?
38:28
Dass ich ein Bad request kriege, wenn ich halt die Sachen nicht
38:31
mitschicke, die erwartet, wenn es halt nicht möglich ist aus
38:34
dem DTO dieses Datenmodell zu erstellen.
38:37
Das ist ein klassischer Bad Request, braucht gar nicht ins
38:39
System reingehen, weil damit kann man nichts anfangen.
38:42
Dann was ich meinte wenn ich auf dem Service so Verifiziere wie
38:46
die Eingaben sind ja also quasi ich habe valide Eingaben, aber
38:49
sind die überhaupt brauchbar? Das sind so für mich so 2
38:52
gedankenebenen ja, dass ich sage.
38:56
Ist es valide von den Typen her und alles?
38:59
Und kann ich damit arbeiten? Ja, dann habe ich im Service
39:02
aber noch ne Ebene, möchte ich damit arbeiten und das habe ich
39:06
dann aber dediziert im Service und kann das super geil testen,
39:09
weil ich weiß an dem Punkt habe ich auf jeden Fall mein
39:12
Datenmodell. Ich gebe jetzt komplett die
39:15
Input so rein und kann sauber abtesten ob überhaupt damit was
39:19
passiert oder nicht. Richtig und genauso kann ich
39:22
dann später auch abstrahiert diesen Storage betrachten und
39:25
kann zum Beispiel sagen Ey Service, Mach mal das und das
39:28
und übrigens im Storage wirst du das haben was ich dir jetzt sage
39:31
und dann kannst du das halt alles sauber abtesten und
39:34
genauso kannst du dann auf der Output Ebene auch wieder sagen
39:38
was geb ich denn zurück im Falle von dem und dem ne um wieder
39:42
diese Rück. Validierung sozusagen zu haben.
39:46
Und auch diese Umwandlung und gleichzeitig hab ich natürlich
39:50
auch noch die Möglichkeit Integration Test mäßig einmal
39:53
den Zyklus durch auch geil. Genau.
39:56
Da nur nicht so viel von das kostet.
39:59
Das kostet ja. Und wenn man sich jetzt fragt,
40:01
OK. Warum soll ich das alles
40:04
irgendwie mir drauf drücken? Warum interessiert mich das?
40:07
Ich kann das eher alles von RI machen lassen, ja, aber man kann
40:11
und wird auch ne Menge davon machen lassen, aber man sollte
40:15
natürlich auch immer noch die Struktur im Auge behalten, man
40:18
ist ja auf mindestens noch Reviewer des ganzen Codes und
40:22
ich hatte letztens nämlich auch wieder ne schöne Sache wo ich
40:24
mir dachte, da gehört das ganz bestimmt nicht hin, obwohl er.
40:28
Obwohl gar nicht. Obwohl.
40:30
AI meinte ja doch da will ich es aber gerne haben.
40:33
Es war aber wirklich Quatsch. Ja und das passt sogar auch hier
40:37
so n bisschen rein geh ich nicht jetzt näher drauf ein Wir sind
40:39
schon n bisschen über die Zeit sag ich jetzt mal, aber das ist
40:42
wichtig ja sich sowas sowas zu wissen um sowas halt hinterher
40:45
anwenden zu können um den Code trotzdem strukturiert zu halten.
40:49
Das ist so n guter Punkt. Ich muss es noch mal
40:51
wiederholen, damit sich es einbrennt.
40:53
Es hilft dir beim Reviewen auch einfach zu verstehen, was da
40:56
passiert. Wenn du diese klaren Trennungen
40:57
hast, weil du genau weißt, wo du gucken musst und genau weißt,
41:00
was zu erwarten ist. Genau, sehr, sehr guter Punkt,
41:03
ja. Und in diesem Sinne würde ich
41:06
sagen, sind wir fertig. Damit haben wir jetzt das I POS
41:10
princula Zufallstreffer hat. Spaß gemacht, da drüber zu.
41:13
Reden auf jeden Fall fand ich auch und liebe Zuhörerinnen,
41:17
lieber Zuhörer, wenn du sagst, ja.
41:20
Ich kenn ja jemanden, bei dem ist der Code gerade richtig
41:22
chaotisch. Da kämpft jemand mit chaotischem
41:25
Code, dann schick ihn auf jeden Fall oder leiht ihn diese Folge
41:28
weiter oder ihr und ansonsten wie gesagt Folge gerne auch den
41:33
Podcast. Wenn er dir gefällt, wenn du das
41:34
noch nicht machst. Es gibt auch so n kleines
41:36
Glöckchen, drück da auch gerne drauf, dann verpasst du keine
41:38
Folge und ansonsten würde ich sagen macht es gut, wir hören
41:44
uns in der nächsten Folge wieder deine Coding.
41:46
Buddies gemeinsam besser. Weißt du was mich fragt?
41:51
Ich glaube, du kannst diese Buchstaben mit einer ios PI
41:53
Coast in Hoch und ich habe einfach die Bilder.
41:55
Man muss immer wieder was rauskommen was man machen kann.
41:57
Ja, Mann und weißt du was? Scheiß drauf.
42:00
Ich mache mir jetzt so einen krassen Kaffee.