1
00:00:00,080 --> 00:00:02,280
Keine Ahnung, welche 
Privatperson anruft und fragt, 

2
00:00:02,280 --> 00:00:05,840
wie sieht's aus, alles frei, na 
du weiß nicht, ja doch hier 

3
00:00:05,840 --> 00:00:10,840
komm, mach schnell kann ich nach
Messe Coding Buddies Dein 

4
00:00:10,840 --> 00:00:12,760
Podcast rund um 
Softwareentwicklung und 

5
00:00:12,760 --> 00:00:15,320
aktueller Tech News. 
Herzlich Willkommen 

6
00:00:27,510 --> 00:00:30,710
einen wunderschönen guten Tag 
und herzlich Willkommen zur 

7
00:00:30,710 --> 00:00:33,750
neuen Folge vom Coding Buddies 
Podcast. 

8
00:00:34,160 --> 00:00:37,360
Fabi und Tino, also ich und 
Tino, Wir sind wieder am Start 

9
00:00:37,920 --> 00:00:40,640
bereit für ne neue Folge hoffe 
ich zumindest. 

10
00:00:40,640 --> 00:00:43,120
Tino bist bereit. 
Ich bin bereit. 

11
00:00:43,120 --> 00:00:47,600
Moin Fabi, Was geht ab, was geht
ab, was geht ab, was geht, was 

12
00:00:47,600 --> 00:00:52,080
geht? 
Ja, was geht eigentlich alles 

13
00:00:52,080 --> 00:00:54,640
gut da ich. 
Dich das jede Woche Frage gibt 

14
00:00:54,640 --> 00:00:57,880
es auch nicht so viele News, 
immer dazwischen ne, es hat aber

15
00:00:57,880 --> 00:01:01,680
einfach cool alles gut. 
Ja, ist schwer. 

16
00:01:01,680 --> 00:01:04,319
Wir müssen irgendwann mal, weißt
du, wir machen irgendwann mal so

17
00:01:04,319 --> 00:01:09,280
ne halbjährige Podcastpause ne 
und dann kannst du mich das noch

18
00:01:09,280 --> 00:01:12,880
mal fragen, genau. 
Oder ich frag dich einfach ein 

19
00:01:12,880 --> 00:01:14,960
halbes Jahr lang nicht. 
Wir machen weiter folgen, aber 

20
00:01:14,960 --> 00:01:17,280
ich frag dich einfach nicht und 
du denkst dir jedes mal so, 

21
00:01:17,440 --> 00:01:19,160
warum fragt ihr nicht? 
Was ist los, du? 

22
00:01:19,280 --> 00:01:21,120
Willst gar nicht mehr wissen, 
wie es mir geht. 

23
00:01:21,120 --> 00:01:23,600
Mann, nein wir. 
Machen natürlich keine 

24
00:01:24,080 --> 00:01:26,880
halbjährliche Pause. 
Das ist natürlich alles Quatsch.

25
00:01:27,280 --> 00:01:30,640
Es geht Schlach auf Schlag 
weiter, wir machen weiter, aber 

26
00:01:30,840 --> 00:01:32,320
bevor wir jetzt wirklich 
weitermachen, richtig 

27
00:01:32,320 --> 00:01:36,320
reinstarten wollte ich noch mal 
ganz kurz anmerken, Tino weil 

28
00:01:36,320 --> 00:01:40,320
Pass auf, man denkt ja, man weiß
alles über Podcast, wenn man 

29
00:01:40,320 --> 00:01:41,520
selber einen Podcast macht, 
dann. 

30
00:01:41,840 --> 00:01:44,480
Aber so ist es nicht, weil es 
gibt, und das hab ich jetzt 

31
00:01:44,480 --> 00:01:49,280
erstmal richtig realisiert, in 
zum Beispiel bei Spotify oder 

32
00:01:49,280 --> 00:01:51,520
halt auch bei den anderen 
Plattformen. 

33
00:01:51,600 --> 00:01:55,600
Gibt es so ne Glocke und die 
kannst du anmachen, ne für n 

34
00:01:55,600 --> 00:01:58,160
Podcast und wenn du die 
Anmachst, dann kriegst du immer 

35
00:01:58,160 --> 00:02:00,320
ne notification wenn es ne neue 
Folge gibt. 

36
00:02:01,040 --> 00:02:03,440
Und ich dachte mir so. 
Okay sowas gibt es bei youtube 

37
00:02:03,440 --> 00:02:06,160
auch und so ne ja okay okay. 
Krass. 

38
00:02:06,160 --> 00:02:08,520
Und das ist krass und deswegen 
will ich einmal ganz kurz sagen,

39
00:02:08,520 --> 00:02:12,480
Leute, wenn ihr das noch nicht 
angebracht habt, dann auf jeden 

40
00:02:12,480 --> 00:02:15,520
Fall diese Glocke anmachen beim 
Podcast, weil dann verpasst ihr 

41
00:02:15,520 --> 00:02:17,480
keine neue Folge. 
Und falls ihr noch nicht 

42
00:02:17,480 --> 00:02:19,680
abonniert habt, dann natürlich 
auch, weil dann ist es die 

43
00:02:19,680 --> 00:02:21,760
wahrscheinlich keine neue Folge 
zu verpassen, auch geringer. 

44
00:02:21,920 --> 00:02:24,080
Also Glocke anmachen, 
abonnieren, das ist wichtig. 

45
00:02:24,960 --> 00:02:27,080
Ey cool, dann können wir jetzt 
immer sagen, wenn du keine neue 

46
00:02:27,080 --> 00:02:29,200
Folge verpassen willst, dann 
drück auf die Glocke. 

47
00:02:29,600 --> 00:02:31,360
Ganz genau. 
Geil. 

48
00:02:31,880 --> 00:02:34,200
Keiner freut mich drauf. 
Das war ungefähr das, worauf ich

49
00:02:34,200 --> 00:02:38,400
hinaus wollte und da würde ich 
sagen, lass uns doch jetzt mal 

50
00:02:38,400 --> 00:02:42,960
so ordentlich mal richtig ins 
Thema starten und zwar geht es 

51
00:02:42,960 --> 00:02:46,880
ja heute wieder um unsere neue 
Reihe, die wir letztens 

52
00:02:46,880 --> 00:02:50,760
gestartet haben, patterns ne die
schönen Design Patterns in der 

53
00:02:50,760 --> 00:02:54,320
Softwareentwicklung. 
Wo welches Design Pattern haben 

54
00:02:54,320 --> 00:02:55,720
wir uns denn heute mal 
geschnappt? 

55
00:02:55,720 --> 00:02:58,000
Tino Worum? 
Geht es heute? 

56
00:02:58,000 --> 00:03:02,960
Heute haben wir, wie soll ich 
sagen, so n umstrittenes Pattern

57
00:03:02,960 --> 00:03:06,720
ausgewählt, aber es ist 
eigentlich so 1 der allerersten 

58
00:03:06,720 --> 00:03:10,560
was man sich so anschaut, wenn 
man in den Bereich der Design 

59
00:03:10,560 --> 00:03:14,400
Patterns geht und zwar möchten 
wir heute Fabi und ich freue 

60
00:03:14,400 --> 00:03:17,520
mich drauf, wir möchten heute 
über singleten reden, über das 

61
00:03:17,520 --> 00:03:23,560
Design Pattern singleten und. 
Ich würde sagen, wir starten 

62
00:03:23,560 --> 00:03:24,400
mal. 
Du hast doch bestimmt ne 

63
00:03:24,400 --> 00:03:26,000
Analogie oder? 
Ich freue mich immer so riesig 

64
00:03:26,000 --> 00:03:28,840
auf deine Analogien und ich sehe
es schon in deinen Augen, du 

65
00:03:28,840 --> 00:03:32,000
kannst das gar nicht abwarten, 
hau doch mal ne Analogie raus, 

66
00:03:32,000 --> 00:03:35,520
wie würdest du denn so Singleton
umschreiben? 

67
00:03:35,680 --> 00:03:39,040
Pass auf, ich hole erstmal mein 
Analogie Märchenbuch heraus, da 

68
00:03:39,040 --> 00:03:40,000
muss ich erstmal. 
Suchen? 

69
00:03:40,160 --> 00:03:43,600
Nein, so heißt so Finger 
anlecken umblättern, so neue 

70
00:03:43,600 --> 00:03:48,080
Analogie also. 
Herrn Singleton, ich glaub man 

71
00:03:48,080 --> 00:03:49,880
kann da 1000 Analogien für 
bringen. 

72
00:03:49,880 --> 00:03:52,400
Wahrscheinlich. 
Ich stell mir das ganz gerne, 

73
00:03:52,400 --> 00:03:57,280
zum Beispiel so vor, dass wenn 
du n Theater hast ne, also stell

74
00:03:57,280 --> 00:04:00,320
dir mal so n normales Theater 
vor, wie man das halt so kennt 

75
00:04:00,320 --> 00:04:05,360
ne und wir sind aber nicht in 
der Aufführung an sich, sondern 

76
00:04:05,360 --> 00:04:09,800
beim Proben ne, also du hast 
quasi du Probst entsprechende 

77
00:04:09,800 --> 00:04:13,760
Szenen und. 
Dann ist es ja im Normalfall so,

78
00:04:13,760 --> 00:04:17,040
dass du vielleicht unter 
Umständen auch verschiedene 

79
00:04:17,040 --> 00:04:20,360
Szenen parallel proben kannst. 
Also du könntest ja zum Beispiel

80
00:04:20,360 --> 00:04:24,080
3 Bühnen bauen oder irgendwie 3 
Räume nehmen und da können 

81
00:04:24,080 --> 00:04:28,320
Leute, die in den entsprechenden
Szenen halt sind, diese Szenen 

82
00:04:28,320 --> 00:04:31,520
eben proben. 
Wenn es jetzt aber irgendwie 

83
00:04:31,520 --> 00:04:35,600
Fragen gibt oder diese Szene 
bewertet werden soll, dann gibt 

84
00:04:35,600 --> 00:04:39,760
es halt am Ende einen Regisseur,
ne, der am Ende sagt, OK, Pass 

85
00:04:39,760 --> 00:04:42,640
auf, mach du die Szene so, da 
musst du noch n bisschen was an 

86
00:04:42,640 --> 00:04:45,840
deiner Aussprache ändern und 
hier, das war mir zu wenig 

87
00:04:46,080 --> 00:04:50,960
Gestik und Mimik, also da mal n 
bisschen das ganze aufpeppen und

88
00:04:50,960 --> 00:04:53,360
ich würde gern die Szene noch 
mal n bisschen ändern an der 

89
00:04:53,360 --> 00:04:57,680
Stelle ne das heißt es gibt 
einen Regisseur der allen. 

90
00:04:58,000 --> 00:05:00,800
Wenn jeder Szene, auf jeder 
Bühne oder in jedem Raum sagt, 

91
00:05:00,800 --> 00:05:04,640
wie sozusagen was gemacht werden
soll, wie das ganze aussehen 

92
00:05:04,640 --> 00:05:08,360
soll, ne. 
Und wenn du jetzt dir überlegst,

93
00:05:08,360 --> 00:05:10,160
dass du zum Beispiel sagen 
würdest, du hast jetzt 2 

94
00:05:10,160 --> 00:05:13,680
Regisseure, ne, und jetzt kommen
die, ich weiß nicht Raum 1 ne wo

95
00:05:13,680 --> 00:05:16,800
die Üben kommen zu Regisseur 1 
und sagen, wie sollen wir das 

96
00:05:16,800 --> 00:05:19,760
denn machen, dann sagt er ja, 
mach das auf jeden Fall so 

97
00:05:19,760 --> 00:05:22,840
richtig trocken so, und dann 
machen die das trocken, dann 

98
00:05:22,840 --> 00:05:25,040
kommt Regisseur 2, guckt sich 
das an, denkt sich, was macht 

99
00:05:25,040 --> 00:05:27,200
ihr da für n Quatsch, ja, ihr 
sollt das mal so richtig peppig 

100
00:05:27,200 --> 00:05:29,360
machen, das muss richtig. 
Nicht abgehen so diese Szene. 

101
00:05:29,360 --> 00:05:33,600
Ne die ist das ist, das 
herrschte Geistwort so ne und 

102
00:05:33,600 --> 00:05:36,400
das heißt im Endeffekt wenn du 
jetzt 2 Regisseure hättest, 

103
00:05:37,760 --> 00:05:40,000
würde halt totales Chaos 
entstehen, weil du hast 

104
00:05:40,000 --> 00:05:43,520
unterschiedliche Ideen oder was 
auch immer, was du dann im 

105
00:05:43,520 --> 00:05:46,480
Endeffekt in diese 
entsprechenden Szenen 

106
00:05:46,480 --> 00:05:50,800
reinbringst und das kann man 
sich jetzt natürlich so 

107
00:05:50,800 --> 00:05:52,800
vorstellen. 
Ne, der Regisseur ist dann am 

108
00:05:52,800 --> 00:05:55,200
Ende des Singleton. 
Ne, also quasi eine 

109
00:05:55,200 --> 00:05:58,920
Kontrollinstanz, die sagt das 
und das und das soll passieren, 

110
00:05:58,920 --> 00:06:02,560
sozusagen die Source of Truth 
über bestimmte Abläufe 

111
00:06:02,560 --> 00:06:05,480
beispielsweise und die 
entsprechenden Szenen in den 

112
00:06:05,480 --> 00:06:07,600
entsprechenden Räumen sind 
verschiedene Teile der des 

113
00:06:07,600 --> 00:06:11,000
Programms, zum Beispiel ne so, 
aber alle brauchen den Input von

114
00:06:11,000 --> 00:06:16,080
dem Regisseur. 
Genau das heißt jeder ja, also 

115
00:06:16,400 --> 00:06:18,720
so Schauspieler, die können ja 
untereinander reden und sich 

116
00:06:18,720 --> 00:06:20,880
austauschen oder so, aber wenn 
es darum geht, wirklich 

117
00:06:20,880 --> 00:06:24,480
Anweisungen zu kriegen oder die.
Absolute Wahrheit. 

118
00:06:24,480 --> 00:06:27,600
Ja, wie du es gerade meintest, 
dann gehst du halt zum Regisseur

119
00:06:27,600 --> 00:06:30,160
und fragst nach ne, das ist 
eigentlich n ganz cooles 

120
00:06:30,160 --> 00:06:34,480
Beispiel so n anderes Beispiel 
auch so n Klassiker wenn du 

121
00:06:34,480 --> 00:06:37,080
jetzt überlegst ich hab jetzt 
meine Software ist jetzt n 

122
00:06:37,080 --> 00:06:40,480
Flughafen oder so ja also ich 
nehm jetzt mal das Gedankenspiel

123
00:06:40,480 --> 00:06:44,080
Ich bin auf dem Flughafen auf 
einen ne nicht jetzt weltweit 

124
00:06:44,080 --> 00:06:47,120
mit mehreren wir machen es nicht
komplexer wir sind auf einem 

125
00:06:47,120 --> 00:06:50,960
Flughafen. 
Und um den Flugverkehr zu 

126
00:06:50,960 --> 00:06:54,080
steuern, hast du ja im Prinzip n
Kontrollturm so n Tower ne und 

127
00:06:54,240 --> 00:06:57,360
da gibt es halt einen von. 
Ja, also ist ja nicht so, dass 

128
00:06:57,360 --> 00:07:02,880
jetzt jede jedes Flugzeug so 
verschiedene Tower anfunkt oder 

129
00:07:02,960 --> 00:07:05,600
keine Ahnung welche Privatperson
anruft und fragt, wie sieht es 

130
00:07:05,600 --> 00:07:10,080
aus, alles frei na du weiß 
nicht, ja doch hier komm mach 

131
00:07:10,080 --> 00:07:15,120
schnell kann ich nach Messler. 
Und das ist, das kann man sich 

132
00:07:15,120 --> 00:07:18,400
ja auch so vorstellen, dass im 
Prinzip dieser Kontrollton auch 

133
00:07:18,560 --> 00:07:23,360
einzigartig ist in in Scope 
unserer Software oder des 

134
00:07:23,360 --> 00:07:26,320
Flughafens. 
Ja, und quasi immer angefragt 

135
00:07:26,320 --> 00:07:29,920
wird für Infos und es gibt ihn 
halt nur einmal. 

136
00:07:30,080 --> 00:07:34,280
Und genau diese Grundidee und 
dieses Prinzip verkörpert das 

137
00:07:34,280 --> 00:07:36,800
Single N Pattern. 
Ja, das heißt. 

138
00:07:37,680 --> 00:07:42,520
Mit dem Pattern sorgt man dafür,
dass es genau eine Instanz einer

139
00:07:42,520 --> 00:07:45,920
bestimmten Klasse gibt. 
Klasse Regisseur, Klasse 

140
00:07:45,920 --> 00:07:50,720
Kontrolltom, was auch immer, 
jetzt mal angepasst an unsere 

141
00:07:50,720 --> 00:07:53,600
Beispiele. 
Ja, und dass alle Teile des 

142
00:07:53,600 --> 00:07:57,040
Programms dann auf diese 
gemeinsame Instanz zugreifen, 

143
00:07:57,440 --> 00:08:01,280
richtig, ja, also das heißt, du 
Erzeugst eine Instanz und auch 

144
00:08:01,280 --> 00:08:05,600
nur eine und alle können 
gemeinsam diese Instanz 

145
00:08:05,600 --> 00:08:08,080
verwenden. 
Jetzt denkt sich vielleicht der 

146
00:08:08,080 --> 00:08:11,680
ein oder andere Leute, was ist 
das für n Pattern? 

147
00:08:11,680 --> 00:08:13,920
Das klingt total nach einer 
globalen Variable. 

148
00:08:13,920 --> 00:08:18,560
Ja, auch auf diesen Punkt werden
wir eingehen in dieser Folge und

149
00:08:18,720 --> 00:08:22,480
das Halt mal beleuchten, wie gut
ist dieses Pattern, wofür kann 

150
00:08:22,480 --> 00:08:25,240
man es verwenden, jetzt wo wir 
es mal so grob abgesteckt haben 

151
00:08:25,360 --> 00:08:28,160
und warum ist es umstritten, 
hatte ich ja schon angedeutet, 

152
00:08:28,400 --> 00:08:31,960
das lass mal jetzt in dieser 
Folge bequatschen, Fabi und 

153
00:08:31,960 --> 00:08:34,000
natürlich auch, was gibt es denn
zum Beispiel auch für 

154
00:08:34,000 --> 00:08:36,679
Alternativen, wenn man sagt, OK,
es ist umstritten. 

155
00:08:36,760 --> 00:08:38,440
Hin, weil es bringt ja nichts, 
wenn man sagt, es ist 

156
00:08:38,440 --> 00:08:39,840
umstritten. 
Na ja, gut, aber du musst es 

157
00:08:39,840 --> 00:08:44,200
nehmen, natürlich auch blöd, 
aber das sind auf jeden Fall 

158
00:08:44,200 --> 00:08:46,160
wichtige Fragen, die wir jetzt 
in der Folge klären wollen. 

159
00:08:46,160 --> 00:08:49,200
Und um jetzt aber mal so n 
bisschen wegzugehen von den 

160
00:08:49,200 --> 00:08:52,880
entsprechenden Analogien, 
sondern mal wirklich hin zur 

161
00:08:52,880 --> 00:08:55,360
Technik und man sich vielleicht 
jetzt fragt, ja OK, aber was 

162
00:08:55,360 --> 00:08:58,120
bringt mir das ganze, wenn das 
alles Quatsch ist? 

163
00:08:58,240 --> 00:09:02,400
Also es gibt natürlich auch. 
Wirklich sinnvolle Sachen oder 

164
00:09:02,400 --> 00:09:06,280
oder Dinge wo ist wo so n Single
oft genutzt wird, da gibt es 

165
00:09:06,280 --> 00:09:10,800
schon n paar Beispiele wie zum 
Beispiel jetzt ein Logger, ne 

166
00:09:10,800 --> 00:09:12,920
kann man sich so vorstellen. 
Also wenn du jetzt irgendwo n 

167
00:09:12,920 --> 00:09:14,960
Logger in deiner Software hast, 
dann macht es halt eben nicht so

168
00:09:14,960 --> 00:09:18,720
viel Sinn wenn du sagst OK du 
hast jetzt weiß nicht du willst 

169
00:09:18,720 --> 00:09:21,760
in deiner Anwendung möchtest du 
sagen OK wir gehen jetzt auf n 

170
00:09:21,760 --> 00:09:24,360
bestimmtes Log level ne das hast
du ja meistens so dass du n 

171
00:09:24,360 --> 00:09:26,320
logger hast wo du sagst OK ich 
kann irgendwie mir Infos 

172
00:09:26,320 --> 00:09:27,600
rausspucken ich kann mir aber 
auch. 

173
00:09:28,000 --> 00:09:31,680
Wirklich komplett sozusagen auf 
Debug das ganze Stellen, dass du

174
00:09:31,680 --> 00:09:34,480
wirklich alle Informationen 
rausgeklatscht bekommst, die du 

175
00:09:34,480 --> 00:09:36,440
aber eigentlich als Anwender 
vielleicht gar nicht brauchst. 

176
00:09:36,440 --> 00:09:39,000
Ne, aber unter Umständen als 
Entwickler vielleicht schon oder

177
00:09:39,000 --> 00:09:41,920
als Entwicklerin. 
Und wenn du jetzt aber n Logger 

178
00:09:41,920 --> 00:09:45,200
hast, der nicht, sag ich jetzt 
mal zum Beispiel in so einer 

179
00:09:45,200 --> 00:09:48,880
Singleton Instanz existiert. 
Dann würdest du zum Beispiel in 

180
00:09:48,960 --> 00:09:52,080
in dem einen Teil deiner 
Software beispielsweise den 

181
00:09:52,080 --> 00:09:54,800
Logger auf Info stellen und in 
dem anderen Teil deiner Software

182
00:09:55,520 --> 00:09:58,480
hast du ne andere Instanz von 
diesem Logger, der aber dann auf

183
00:09:58,480 --> 00:10:01,040
Debug steht und dann fragst du 
dich vielleicht, hey, ich hab 

184
00:10:01,040 --> 00:10:05,360
doch meinen Logger instanziiert 
und hab eine, also ne, ich hab 

185
00:10:05,360 --> 00:10:07,800
irgendwie n Logger in meiner 
Software, der auf der einen 

186
00:10:07,800 --> 00:10:10,320
Seite als in also info auf Info 
eingestellt ist. 

187
00:10:10,320 --> 00:10:13,280
Und jetzt krieg ich doch die 
ganze Zeit irgendwo ab in einem 

188
00:10:13,280 --> 00:10:16,000
bestimmten Teil krieg ich 
irgendwie debug Informationen ne

189
00:10:16,000 --> 00:10:18,560
das ist. 
Beispielsweise so n so n Ding, 

190
00:10:19,280 --> 00:10:22,480
aber dir fällt bestimmt auch 
noch was ein, wenn es jetzt 

191
00:10:22,480 --> 00:10:28,000
nicht dran locker ist. 
Ja, was halt auch so n Klassiker

192
00:10:28,000 --> 00:10:30,480
ist, ist so ne Art 
Konfigurationsmanager. 

193
00:10:30,480 --> 00:10:33,840
Wenn ich halt ne config habe in 
meiner Software ne und die soll 

194
00:10:33,840 --> 00:10:37,880
halt von allen möglichen Stellen
ausgelesen werden, dann macht 

195
00:10:37,880 --> 00:10:40,240
das da auch Sinn, weil ich 
möchte ja nicht unterschiedliche

196
00:10:40,240 --> 00:10:42,320
Konfigurationen rumgeistern 
haben, ne? 

197
00:10:42,640 --> 00:10:46,480
Sondern ich bau eine Instanz auf
meiner Config und die kann halt 

198
00:10:46,480 --> 00:10:49,760
abgerufen werden von allen und 
immer die gleiche config. 

199
00:10:49,760 --> 00:10:52,960
Das wär halt auch n Beispiel wie
gesagt, es gibt auch andere 

200
00:10:53,360 --> 00:10:56,040
Umsetzungsmöglichkeiten, aber es
ist auf jeden Fall erstmal n 

201
00:10:56,040 --> 00:11:00,080
Anwendungsfall für n Singleton 
oder halt auch n Klassiker ist 

202
00:11:00,080 --> 00:11:03,600
auch so n Cash ne wenn ich sage 
ich möchte ne Art Cash haben der

203
00:11:03,680 --> 00:11:06,880
sozusagen wirklich global ist. 
Ne dass ich halt zum Beispiel 

204
00:11:07,120 --> 00:11:09,840
Ergebnisse, Ergebnisse, 
Ergebnisse. 

205
00:11:10,240 --> 00:11:15,120
Zwischenspeicher und damit sie 
halt nicht mehrfach berechnet 

206
00:11:15,120 --> 00:11:18,640
werden oder mehrfach ausgeführt 
werden und ich kann dann wieder 

207
00:11:18,640 --> 00:11:20,560
aus diesem Cache diese 
Ergebnisse laden und dann 

208
00:11:20,560 --> 00:11:23,080
brauche ich natürlich auch die 
Gewährleistung, dass alle vom 

209
00:11:23,080 --> 00:11:26,200
gleichen Cache arbeiten. 
So ne Source Trust dann am Ende,

210
00:11:26,200 --> 00:11:28,640
weil es bringt ja nichts wenn du
was Cache und dann kriegst du 

211
00:11:28,640 --> 00:11:31,280
aber hinterher weiß ich nicht 
von einem anderen Cache n 

212
00:11:31,280 --> 00:11:33,360
Zwischenergebnis was du aber 
eigentlich gar nicht berechnet 

213
00:11:33,360 --> 00:11:35,440
hast. 
Folgefehler. 

214
00:11:36,080 --> 00:11:38,240
Ist dann kacke? 
Genau. 

215
00:11:39,120 --> 00:11:40,720
Das wär halt auch noch so n 
Anwendungsfall. 

216
00:11:40,880 --> 00:11:42,200
Genau. 
Also im Endeffekt ist es halt, 

217
00:11:42,200 --> 00:11:44,320
wird es halt wie gesagt oft da 
verwendet, wo man halt 

218
00:11:44,320 --> 00:11:49,120
irgendwie, sagen wir mal globale
Zustände vielleicht braucht 

219
00:11:49,120 --> 00:11:53,560
speichern möchte und es jetzt 
vielleicht aber auch nicht. 

220
00:11:53,560 --> 00:11:55,320
Also da muss man natürlich auch 
noch n bisschen unterscheiden 

221
00:11:55,320 --> 00:12:00,360
zwischen einem Persistenten. 
Persistenten Speicherung oder so

222
00:12:00,360 --> 00:12:02,600
einer flüchtigen Speicherung ne.
Also wenn du sagen wir mal die 

223
00:12:02,600 --> 00:12:06,160
Software anschmeißt und so lange
wie die Software lebt halt eben 

224
00:12:06,160 --> 00:12:09,280
auch oder läuft halt eben auch 
diesen Zustand speichern 

225
00:12:09,280 --> 00:12:09,720
möchtest. 
Ne. 

226
00:12:09,720 --> 00:12:11,880
Also sonst wäre zum Beispiel ne 
Datenbank irgendwas was du 

227
00:12:11,880 --> 00:12:13,800
nehmen könntest. 
Aber das ist es jetzt quasi 

228
00:12:13,800 --> 00:12:14,960
nicht. 
Wir sind jetzt quasi wirklich 

229
00:12:14,960 --> 00:12:17,880
nur rein in unserer Software 
unterwegs und schließen jetzt 

230
00:12:17,880 --> 00:12:20,720
nicht noch ne Datenbank an genau
aber. 

231
00:12:20,720 --> 00:12:22,080
Genau. 
Also das ist auch schon n guter 

232
00:12:22,080 --> 00:12:24,480
Punkt, ne. 
Also n Singleton ist natürlich, 

233
00:12:24,480 --> 00:12:28,480
also es ist n. 
Ne Instanz eines einer Klasse, 

234
00:12:28,800 --> 00:12:32,320
die ja instanziiert wird zur 
Laufzeit der Software. 

235
00:12:32,320 --> 00:12:36,520
Das heißt du hast halt auch n 
abgesteckten Lebens ne 

236
00:12:36,520 --> 00:12:38,280
abgesteckte Lebenszeit, 
sozusagen ne. 

237
00:12:38,480 --> 00:12:42,880
Also wenn ich die Software 
beende quasi, dann ist das 

238
00:12:42,880 --> 00:12:45,120
natürlich weg, ne, also da haben
wir jetzt nichts persistentes 

239
00:12:45,120 --> 00:12:47,520
also nur ist ne gute Anmerkung, 
dass wir da halt auch vom 

240
00:12:47,520 --> 00:12:52,160
richtigen Scope gerade reden. 
Ja genau, und genau wie du 

241
00:12:52,160 --> 00:12:55,120
meintest, wenn man so globale 
Zustände gemeinsam Ressourcen 

242
00:12:55,120 --> 00:12:58,160
oder so. 
Braucht, dann denkt man oft an 

243
00:12:58,160 --> 00:13:00,200
direkt an den Singleton das. 
Klingt ja auch schon. 

244
00:13:00,200 --> 00:13:03,120
Du hast ja auch gesagt, ja, 
globale Variablen. 

245
00:13:03,840 --> 00:13:06,880
Ne. 
Kann man daran denken, ist ja 

246
00:13:06,880 --> 00:13:08,480
auch irgendwo. 
Wie gesagt, kommen wir später 

247
00:13:08,480 --> 00:13:12,920
noch drauf zurück, wir sind ja 
auch jetzt schon, also wir sind 

248
00:13:12,920 --> 00:13:14,480
natürlich bei diesen ganzen 
Design pattern sind wir 

249
00:13:14,480 --> 00:13:16,560
natürlich schon irgendwie hart 
in einem in einem. 

250
00:13:16,680 --> 00:13:19,520
Im Objektorientierungskontext 
unterwegs, da hatten wir letztes

251
00:13:19,520 --> 00:13:22,880
Mal auch so n bisschen bei der 
letzten Folge auch so n kleinen 

252
00:13:22,880 --> 00:13:24,760
Exkurs gemacht und ich würd 
diesmal auch wieder n kleinen 

253
00:13:24,760 --> 00:13:28,320
Exkurs machen, weil es schon 
glaub ich sinnvoll ist das 

254
00:13:28,320 --> 00:13:30,200
einmal in diesem Kontext gehört 
zu haben. 

255
00:13:30,200 --> 00:13:37,440
Ne und zwar über das über den 
das Schlüsselwort static ne und 

256
00:13:38,200 --> 00:13:41,080
weil gerade wenn du zum Beispiel
mit so Singleton arbeitest hast 

257
00:13:41,080 --> 00:13:45,120
du meistens irgendwie dieses 
Wort Static mit drin in ne also 

258
00:13:46,080 --> 00:13:48,920
im. 
Größeren also ne, es gibt, ich 

259
00:13:48,920 --> 00:13:50,360
weiß jetzt nicht ob es 
vielleicht Sprachen gibt, wo 

260
00:13:50,360 --> 00:13:53,120
Static vielleicht anders heißt. 
Beispielsweise kann ja auch 

261
00:13:53,120 --> 00:13:55,720
sein, hab ich jetzt nicht im 
Kopf, deswegen will ich es jetzt

262
00:13:55,720 --> 00:13:59,000
nicht ausschließlich auf Static 
runterbrechen, aber nur, dass 

263
00:13:59,000 --> 00:14:04,000
man ungefähr weiß worum es geht,
ne und Static ist im Endeffekt 

264
00:14:04,320 --> 00:14:06,160
ich, ich versuch das noch mal 
wieder mit einer Analogie ne 

265
00:14:06,160 --> 00:14:08,480
wenn wenn du jetzt sagen wir mal
du hast Häuser ne und Häuser 

266
00:14:08,480 --> 00:14:10,960
sind jetzt Objekte und die 
stehen alle in einer Straße ne 

267
00:14:11,200 --> 00:14:14,960
dann hat ja jedes Haus ne 
Hausnummer ne das heißt? 

268
00:14:15,560 --> 00:14:19,040
Das ist n Attribut, was an dem 
Haus hängt an dem Objekt Haus, 

269
00:14:19,760 --> 00:14:22,960
wo aber sich dieses Attribut 
unterscheidet, das heißt jedes 

270
00:14:22,960 --> 00:14:26,400
ein, jeder jede Instanz dieses 
Hauses bekommt eine eigene 

271
00:14:26,400 --> 00:14:29,840
Hausnummer, ne, das heißt, dass 
diese diese Hausnummer gilt 

272
00:14:29,840 --> 00:14:33,040
immer nur für ein Haus, für eine
Instanz von Haus. 

273
00:14:33,120 --> 00:14:37,360
So ne jetzt hast du aber zum 
Beispiel noch ne Postleitzahl, 

274
00:14:37,360 --> 00:14:40,080
die ja wenn die Häuser zum 
Beispiel in der Gleichenstraße 

275
00:14:40,080 --> 00:14:42,760
stehen auch. 
Immer die gleiche Postleitzahl 

276
00:14:42,760 --> 00:14:44,560
ist, das heißt, rein theoretisch
kannst du jetzt sagen, 

277
00:14:44,560 --> 00:14:48,640
Postleitzahl an sich ist Static 
für das Objekt Haus angenommen 

278
00:14:48,640 --> 00:14:52,640
die stehen alle in einer Stadt 
oder in einer Straße ne weil 

279
00:14:52,640 --> 00:14:57,040
diese Postleitzahl für dieses 
Haus halt einfach immer, also 

280
00:14:57,040 --> 00:15:00,000
für für für jede Instanz von 
Haus gleich ist. 

281
00:15:00,200 --> 00:15:03,760
Weißt du wenn du sagst ich 
instanziere instanziere ein 

282
00:15:03,760 --> 00:15:07,400
Haus, also ein Objekt der 
Klasse, dann kriegt dieses Haus 

283
00:15:07,400 --> 00:15:10,480
zwar eine. 
Hausnummer eine eigene, aber die

284
00:15:10,480 --> 00:15:12,800
Postleitzahl, die musst du nicht
immer noch mal zuweisen, weil 

285
00:15:12,800 --> 00:15:15,520
die ist halt einfach da. 
Das ist immer die gleiche so ne.

286
00:15:16,800 --> 00:15:19,200
Also vorausgesetzt, dass du 
dieses Haus auch nur 

287
00:15:19,200 --> 00:15:22,560
instanziieren möchtest in einem 
Postleitzahlgebiet. 

288
00:15:22,560 --> 00:15:24,920
Ja genau. 
Das hab ich jetzt. 

289
00:15:24,960 --> 00:15:27,360
Also wir stecken. 
Das jetzt mal in den kleinen 

290
00:15:27,360 --> 00:15:29,280
Bereich? 
Ja nur nicht, dass jetzt jemand 

291
00:15:29,280 --> 00:15:30,560
denkt, dass es denn für alle 
gilt. 

292
00:15:30,560 --> 00:15:32,800
Also aber das wär n 
Anwendungsfall genau weil wenn 

293
00:15:32,800 --> 00:15:37,360
du sagst es gibt sozusagen kein 
Objekt Haus wo die Postleitzahl 

294
00:15:37,360 --> 00:15:40,160
anders ist, dann ist das. 
Ist ein statisch gegebener 

295
00:15:40,160 --> 00:15:44,960
Kontext am Ende genau und im 
Endeffekt ist es ja so, dass 

296
00:15:44,960 --> 00:15:49,440
quasi Static am Ende bedeutet, 
dass etwas nicht zu einem 

297
00:15:49,440 --> 00:15:54,000
einzelnen Ding gehört, sondern 
zu allen Dingen von dieser 

298
00:15:54,000 --> 00:15:58,080
Klasse sozusagen ne genau genau 
kurz zusammengefasst. 

299
00:15:58,960 --> 00:16:02,640
Das heißt, du musst kein Haus 
erzeugen, um auf die 

300
00:16:02,640 --> 00:16:05,240
Postleitzahl zuzugreifen? 
Genau, genau, genau. 

301
00:16:05,600 --> 00:16:08,520
Wie gesagt, immer in dem Scope 
jetzt angenommen, wir bleiben 

302
00:16:08,520 --> 00:16:10,880
natürlich in der gleichen Stadt,
die Postleitzahl kann sich jetzt

303
00:16:10,880 --> 00:16:12,760
nicht ändern. 
Ne, das war jetzt die kleine 

304
00:16:12,760 --> 00:16:15,520
Voraussetzung für diese 
Analogie, aber wenn wir das 

305
00:16:15,520 --> 00:16:18,600
ganze jetzt noch mal technischer
machen, weil jetzt kann man sich

306
00:16:18,600 --> 00:16:21,000
hinstellen, OK, ich versteh 
jetzt noch nicht warum das jetzt

307
00:16:21,000 --> 00:16:24,480
n Singleton ist, weil du ja 
gerade gesagt hast, Fabian N 

308
00:16:24,480 --> 00:16:27,320
Haus kannst du instanzieren hast
verschiedene Häuser mit 

309
00:16:27,320 --> 00:16:29,360
verschiedenen Hausnummern, ne so
all das hast du. 

310
00:16:29,360 --> 00:16:33,200
Gerade gesagt, das ist richtig. 
Das hab ich gerade gesagt. 

311
00:16:33,520 --> 00:16:36,800
Nee, also natürlich ist das 
jetzt kein Single an sich, aber 

312
00:16:36,800 --> 00:16:40,040
das Wort Static oder dieses, 
dieses, dieses Schlüsselwort 

313
00:16:40,040 --> 00:16:43,520
static ist halt wichtig an der 
Stelle um überhaupt am Ende zum 

314
00:16:43,520 --> 00:16:45,960
Beispiel so n Single erzeugen zu
können. 

315
00:16:45,960 --> 00:16:49,400
Ne genau und da können wir ja 
gleich mal so n bisschen jetzt 

316
00:16:49,400 --> 00:16:53,120
technischer drauf eingehen wie 
das also wieso n Single jetzt 

317
00:16:53,120 --> 00:16:55,200
quasi technisch aussieht, weil 
wir haben ja jetzt n Beispiel ne

318
00:16:55,200 --> 00:16:57,400
Logger genannt und so weiter 
aber wie kann man das jetzt? 

319
00:16:58,080 --> 00:17:00,400
Genau. 
Also wir müssen ja jetzt quasi 

320
00:17:00,640 --> 00:17:05,599
sicherstellen, dass von einer 
Klasse zum Beispiel na, das 

321
00:17:05,599 --> 00:17:08,200
Haus, gehen wir mal n bisschen 
weg von dem Haus, weil da hast 

322
00:17:08,200 --> 00:17:11,280
du jetzt mehrere Instanziiert, 
ne, aber wenn wir jetzt wirklich

323
00:17:11,280 --> 00:17:14,319
sagen, wir wollen jetzt die 
Klasse singleten, wir nennen sie

324
00:17:14,319 --> 00:17:19,200
jetzt so richtig lehrbuchhaft 
singleten ja instanziieren und 

325
00:17:19,200 --> 00:17:21,680
wollen aber sicherstellen, dass 
es immer nur eine. 

326
00:17:21,960 --> 00:17:24,440
Instanz geben kann. 
Ja, das müssen wir jetzt 

327
00:17:24,440 --> 00:17:27,280
technisch gewährleisten und wie 
du ja gerade erklärt hast, gibt 

328
00:17:27,280 --> 00:17:31,680
es halt sozusagen ne globale 
Zugriffsmöglichkeit auf eine 

329
00:17:31,680 --> 00:17:35,880
Klasse über Static über den 
statischen Kontext sozusagen 

330
00:17:36,000 --> 00:17:40,960
oder scope so und typischerweise
so Lehrbuchhaft machst du das 

331
00:17:40,960 --> 00:17:44,920
so, dass du die. 
Klasse den Konstruktor erstmal 

332
00:17:44,920 --> 00:17:48,880
private setzt ja also zum 
Beispiel jetzt in Java oder so 

333
00:17:49,280 --> 00:17:52,160
und das ist. 
Einfach deshalb macht man das, 

334
00:17:52,160 --> 00:17:55,280
damit du halt schon mal 
verhindern kannst, dass der 

335
00:17:55,280 --> 00:18:00,160
Coder oder der die Software halt
programmiert, die Coderin keine 

336
00:18:00,160 --> 00:18:03,360
Instanzen davon erzeugen kann, 
weil der private ist halt der 

337
00:18:03,360 --> 00:18:04,640
Konstruktor, der ist nicht mehr 
public. 

338
00:18:04,640 --> 00:18:06,960
Das heißt, ich kann den nicht 
aufrufen von außen und ich kann 

339
00:18:06,960 --> 00:18:10,560
jetzt kein Haus erzeugen mehr 
oder Single in die Klasse haben 

340
00:18:10,560 --> 00:18:13,120
wir sie jetzt genannt, so dann 
ist schon mal der erste Schritt 

341
00:18:13,120 --> 00:18:17,040
gewährleistet, ich kann nicht 
beliebig viele erzeugen. 

342
00:18:17,520 --> 00:18:20,040
Aber das Ding ist, jetzt kann 
ich nicht mal eine erzeugen. 

343
00:18:20,040 --> 00:18:23,360
Ja, jetzt hab ich mich komplett 
ausgesperrt und jetzt kommt gut,

344
00:18:23,360 --> 00:18:25,240
dass du es auch noch mal 
eingebaut hast, weil das hätte 

345
00:18:25,240 --> 00:18:27,680
ich jetzt zum Beispiel vergessen
das Static mal zu erklären, 

346
00:18:28,000 --> 00:18:31,200
jetzt kommt halt der statische 
Aufruf die statische Methode 

347
00:18:31,200 --> 00:18:34,720
dazu, dass du halt ich glaub in 
Büchern heißt es meistens sowas 

348
00:18:34,720 --> 00:18:37,960
wie Get instance oder so ja also
dass du halt ne statische 

349
00:18:37,960 --> 00:18:42,080
Methode bereitstellst, die quasi
dir diese Instanz zurückgibt. 

350
00:18:42,640 --> 00:18:46,000
Genau ne, dass du halt ne 
Möglichkeit hast an eine Instanz

351
00:18:46,000 --> 00:18:49,760
von Singleton ranzukommen. 
Und jetzt liegt da auch die 

352
00:18:49,760 --> 00:18:53,280
Pattern Logik drin, weil wenn du
das jetzt einfach so machst, 

353
00:18:53,280 --> 00:18:54,800
kriegst du wieder so viel 
Instanz wie du willst. 

354
00:18:54,800 --> 00:18:58,880
Wenn du jetzt einfach Return New
Singleton drin ist, dann ja nix,

355
00:18:58,880 --> 00:19:02,880
nix gewonnen ja also das heißt 
diese Get instance Methode muss 

356
00:19:02,880 --> 00:19:07,680
ja jetzt dafür sorgen, dass wenn
noch keine Instanz erzeugt 

357
00:19:07,680 --> 00:19:08,880
wurde. 
Mhm. 

358
00:19:08,880 --> 00:19:12,240
Eine Instanz erzeugt wurde genau
von Singleton eine Instanz 

359
00:19:12,240 --> 00:19:14,400
erzeugt wird und zurückgegeben 
wird. 

360
00:19:14,480 --> 00:19:18,240
Und falls schon mal eine erzeugt
wurde, genau die wieder 

361
00:19:18,240 --> 00:19:21,120
zurückgegeben wird und dann hast
du nämlich genau diese diese 

362
00:19:21,120 --> 00:19:24,320
Pattern Logik abgebildet, 
erstmal in einem sehr einfachen 

363
00:19:24,320 --> 00:19:25,840
Stil. 
Es gibt da auch noch so ein 2 

364
00:19:25,840 --> 00:19:27,760
Probleme, die kannst du ja 
vielleicht gleich mal erläutern.

365
00:19:28,320 --> 00:19:31,200
Aber dann hast du eine sehr 
einfache Logik implementiert, um

366
00:19:31,200 --> 00:19:34,000
dieses Pattern abzubilden, weil 
dann kriegst du, wenn es noch 

367
00:19:34,000 --> 00:19:37,440
keine gibt, eine neue Instanz 
von Singleton und wenn es schon 

368
00:19:37,440 --> 00:19:40,920
eine gibt, dann kriegst du die, 
die schon mal erzeugt wurde, das

369
00:19:40,920 --> 00:19:44,640
heißt, du speicherst dir quasi 
intern diese Instanz ab und 

370
00:19:44,640 --> 00:19:47,160
gibst die dann immer wieder 
zurück, es sei denn, es gibt 

371
00:19:47,160 --> 00:19:49,760
keine, musst du sie halt 
einmalig erzeugen, richtig? 

372
00:19:50,240 --> 00:19:53,600
Und das interessante an diesem 
Static oder diesem statischen, 

373
00:19:53,600 --> 00:19:57,360
dieser statischen Funktion ist 
ja, dass du im Endeffekt, sagen 

374
00:19:57,360 --> 00:19:59,400
wir mal, du bist in einem 
Objektorientierungskontext 

375
00:19:59,400 --> 00:20:01,600
unterwegs und möchtest eine 
Funktion auf einer Klasse 

376
00:20:01,600 --> 00:20:03,920
aufrufen, dann brauchst du ja 
erstmal eine Instanz dieser 

377
00:20:03,920 --> 00:20:06,160
Klasse, das heißt, du brauchst 
ja erstmal dieses New ne 

378
00:20:06,240 --> 00:20:09,040
normalerweise, um ein neues 
Objekt anzulegen, um dann 

379
00:20:09,040 --> 00:20:11,840
sozusagen auf diesem erstellten 
Objekt dann diese entsprechenden

380
00:20:11,840 --> 00:20:14,080
Funktionen aufzurufen. 
Wenn du jetzt aber diesen diesen

381
00:20:14,080 --> 00:20:17,040
statischen Kontext hast, dieses 
Static davor setzt, dann hast du

382
00:20:17,040 --> 00:20:23,280
die Möglichkeit einfach auf. 
Der Klasse sozusagen ne diese 

383
00:20:23,280 --> 00:20:24,920
Funktion aufzurufen. 
Das heißt du brauchst keine 

384
00:20:24,920 --> 00:20:26,880
Instanz, sondern kannst einfach 
sagen, OK, ich möchte diese 

385
00:20:26,880 --> 00:20:29,360
Funktion aufrufen, das heißt du 
sagst dann sowas wie Singleton 

386
00:20:29,360 --> 00:20:32,480
Punkt, Get instance 
beispielsweise ne, ohne dass du 

387
00:20:32,480 --> 00:20:35,880
jetzt vorher sagen musst, New 
Singleton ist mein Singleton und

388
00:20:35,880 --> 00:20:38,480
dann sag ich Singleton Punkt, 
also Singleton kleingeschrieben,

389
00:20:38,480 --> 00:20:41,520
die variable Punkt get instance,
das ist sozusagen hier so 

390
00:20:41,520 --> 00:20:44,080
nochmal der Unterschied, falls 
das jetzt noch nicht richtig 

391
00:20:44,080 --> 00:20:46,880
rübergekommen ist, ne. 
Das ist jetzt auf jeden Fall so.

392
00:20:46,880 --> 00:20:52,440
Die klassische blazy Variante 
nennt man das Ganze, das heißt 

393
00:20:52,640 --> 00:20:57,120
du hast noch eventuell noch 
keine, kein Singleton und wenn 

394
00:20:57,120 --> 00:20:58,600
du 1 brauchst, dann holst du dir
1. 

395
00:20:58,600 --> 00:21:03,120
Und wenn du schon 1 da hast, 
dann halt eben nicht und. 

396
00:21:03,280 --> 00:21:05,120
Das kann natürlich aber jetzt 
sein, dass das vielleicht mit 

397
00:21:05,120 --> 00:21:07,200
Multi threading oder so noch 
nicht so richtig funktioniert. 

398
00:21:07,200 --> 00:21:09,520
Ne, musst du das ganze 
vielleicht noch synchronisieren 

399
00:21:09,920 --> 00:21:12,760
oder andere Mechanismen 
verwenden, um wirklich 

400
00:21:12,760 --> 00:21:14,920
sicherzustellen, dass du jetzt 
auch wirklich nur auf einer 

401
00:21:14,920 --> 00:21:17,040
Instanz unterwegs bist und nicht
auf einmal? 

402
00:21:17,040 --> 00:21:21,680
Wichtiger Punkt genau, 
definitiv, also das ist auch im 

403
00:21:21,680 --> 00:21:25,120
Endeffekt so n bisschen so n wie
sagt man so schon so ne kleine 

404
00:21:25,120 --> 00:21:27,680
Limitierung davon, ne, da muss 
man halt auch wirklich richtig 

405
00:21:27,680 --> 00:21:29,920
aufpassen, wenn es um Multi 
threading geht, ne? 

406
00:21:30,880 --> 00:21:34,400
Aber wie gesagt, das ist jetzt 
auf jeden Fall nicht unbedingt 

407
00:21:34,880 --> 00:21:37,000
Teil der Folge multistrailing 
oder? 

408
00:21:37,000 --> 00:21:40,080
Das Problem können wir aber 
gerne auch noch mal besprechen, 

409
00:21:40,080 --> 00:21:43,840
wenn es jemanden interessiert. 
Genau. 

410
00:21:44,080 --> 00:21:48,720
Und ja, das ist eigentlich so 
die klassische Implementierung, 

411
00:21:48,720 --> 00:21:50,080
oder? 
Genau. 

412
00:21:50,320 --> 00:21:53,240
Also so so, wenn ich es mal 
verwendet habe oder mal 

413
00:21:53,240 --> 00:21:54,560
programmiert habe ich es auch so
gemacht. 

414
00:21:56,600 --> 00:21:58,480
Und es ist auf jeden Fall auch 
nicht verkehrt, das Mal 

415
00:21:58,480 --> 00:22:04,080
auszuprobieren, weil wie gesagt,
in in in Pattern hat ja irgendwo

416
00:22:05,200 --> 00:22:08,000
irgendwo seine 
Daseinsberechtigung, aber in dem

417
00:22:08,000 --> 00:22:11,960
Fall ist es natürlich auch schon
so, dass man beim Single so n 

418
00:22:11,960 --> 00:22:15,320
bisschen sagt, Na Singleton, das
ist vielleicht auch nicht gerade

419
00:22:15,320 --> 00:22:17,040
so die geilste Variante und das 
Beste. 

420
00:22:18,640 --> 00:22:21,840
Und mal, wir können ja mal n 
bisschen gucken, was oder wo man

421
00:22:21,840 --> 00:22:24,000
vielleicht so n Single 
vielleicht lieber nicht 

422
00:22:24,000 --> 00:22:27,360
verwenden sollte und warum auch 
beispielsweise ne, also ich 

423
00:22:27,360 --> 00:22:30,000
weiß. 
Noch als wir damals im Studium 

424
00:22:30,000 --> 00:22:32,880
angefangen haben, Design 
Pattern, also Pattern, zu 

425
00:22:32,880 --> 00:22:34,960
lernen, ne, also hatten wir ja 
auch so in verschiedenen 

426
00:22:34,960 --> 00:22:37,680
Vorlesungen, und dann hat man es
ja auch gecoded und gerade am 

427
00:22:37,680 --> 00:22:41,640
Anfang lernst du Design Patterns
kennen, also auch vielleicht du,

428
00:22:41,640 --> 00:22:43,440
liebe Zuhörer, liebe Zuhörer, 
falls du jetzt. 

429
00:22:43,680 --> 00:22:46,040
Dir gerade jetzt diese Folge 
anhörst und dir denkst, das 

430
00:22:46,040 --> 00:22:48,760
klingt geil, das ist, das kann 
ich jetzt echt oft verwenden, ne

431
00:22:48,880 --> 00:22:51,520
und mir ging es damals so, ich 
weiß nicht wie es bei dir war, 

432
00:22:51,520 --> 00:22:54,120
fabi, ich hab das Ding 
kennengelernt und immer wenn ich

433
00:22:54,120 --> 00:22:56,400
so n Pattern kennengelernt hab, 
dann hab ich es auch erstmal 

434
00:22:56,720 --> 00:23:00,520
überall verwendet gefühlt und 
beim Singleton das was oft 

435
00:23:00,520 --> 00:23:03,200
kritisiert wurde hat sich 
erstmal richtig angefühlt. 

436
00:23:03,520 --> 00:23:07,440
Weißt du, du hast halt ne 
einfache Möglichkeit Daten 

437
00:23:07,440 --> 00:23:10,160
überall bereitzustellen oder 
Funktion. 

438
00:23:10,320 --> 00:23:12,560
Ja dann sagt er Ja mach doch n 
Single draus, dann kannst du 

439
00:23:12,560 --> 00:23:16,320
doch überall aufrufen. 
Ja, aber genau das ist ja das 

440
00:23:16,320 --> 00:23:20,080
Problem, ne also in diese Falle 
zu tappen zu sagen nee jetzt 

441
00:23:20,640 --> 00:23:24,960
Kapsel ich alles in dieses 
Design Pattern und bau überall 

442
00:23:24,960 --> 00:23:27,720
also ich mach aus allen 
klassengefühl singletens ne und 

443
00:23:27,720 --> 00:23:30,560
dann bist du halt bei diesem was
wir meinten. 

444
00:23:31,200 --> 00:23:32,760
Ja, was ist jetzt der 
Unterschied zu globalen 

445
00:23:32,760 --> 00:23:33,600
Variablen? 
Oder? 

446
00:23:33,600 --> 00:23:36,480
Dann kannst du einfach globale 
Funktionen haben oder sowas ne, 

447
00:23:36,800 --> 00:23:41,800
weil das ist genau das Problem, 
warum viele Leute das Pattern 

448
00:23:41,800 --> 00:23:46,640
nicht mögen oder sehr sehr 
umstritten betrachten. 

449
00:23:46,640 --> 00:23:49,360
Ja, das haben wir jetzt ja schon
mehrfach erwähnt und das möchte 

450
00:23:49,360 --> 00:23:53,400
ich jetzt einfach mal kurz 
erläutern mit dir, denn Fakt ist

451
00:23:53,400 --> 00:23:59,680
ja du erschaffst sehr schnell 
viele versteckte Abhängigkeiten.

452
00:24:00,000 --> 00:24:01,080
Oder wie siehst du das? 
Ja. 

453
00:24:01,080 --> 00:24:02,920
Auf jeden Fall. 
Also ich find es gut, dass du 

454
00:24:02,920 --> 00:24:06,000
das Studium erwähnt hast, weil 
ich auch damals im Studium an n 

455
00:24:06,000 --> 00:24:09,120
Punkt gekommen bin, wo ich mir 
dachte es wär so geil, wenn ich 

456
00:24:09,120 --> 00:24:12,040
jetzt einfach nicht immer 
dieses, also ich bräuchte jetzt 

457
00:24:12,040 --> 00:24:14,560
eigentlich n Objekt was ich 
erzeuge und dann. 

458
00:24:15,680 --> 00:24:17,200
Kann es nicht noch mal 1 davon 
geben? 

459
00:24:17,200 --> 00:24:19,920
Also ich, dass ich immer das 
nehme und dann kam halt 

460
00:24:19,920 --> 00:24:21,520
irgendwann so, ja nimm doch n 
Single und ich dachte mir so 

461
00:24:21,520 --> 00:24:23,920
Alter, wie geil ist das denn, 
das ist ja. 

462
00:24:24,280 --> 00:24:27,120
Ist ja. 
Mein changing weißt du, weil ich

463
00:24:27,120 --> 00:24:29,920
mir dachte, es kann doch nicht 
wahr sein, es gibt es geht, es 

464
00:24:29,920 --> 00:24:31,920
gibt da sogar n Pattern für das 
muss gut sein. 

465
00:24:31,920 --> 00:24:34,560
Also ich mein, wenn es dafür 
Begriff gibt in der Informatik, 

466
00:24:34,560 --> 00:24:37,800
dann ist es ja wohl der Knaller.
So ne hab ich auch gemacht und 

467
00:24:37,800 --> 00:24:39,920
das und genau diese 
Abhängigkeiten von denen du 

468
00:24:39,920 --> 00:24:43,120
redest ne das ist find ich dann 
am Ende richtig richtig schwer 

469
00:24:43,120 --> 00:24:47,680
weil angenommen du hast. 
Dein Single Ne und du benutzt es

470
00:24:48,160 --> 00:24:50,960
irgendwo an der einen Seite 
deiner Software und irgendwo auf

471
00:24:50,960 --> 00:24:53,520
der anderen Seite deiner 
Software und du stellst 

472
00:24:53,520 --> 00:25:00,480
vielleicht irgendwas um ne in 
deinem in deinem Single und 

473
00:25:00,560 --> 00:25:02,240
denkst dir so in deinem 
Programmablauf. 

474
00:25:02,240 --> 00:25:06,240
Ja erstmal komme ich da durch 
und dann würde ich zum Beispiel 

475
00:25:06,480 --> 00:25:10,160
weiß nicht die und dieses 
Attribut beispielsweise auf den 

476
00:25:10,160 --> 00:25:12,800
Wert. 
X stellen und dann funktioniert 

477
00:25:12,800 --> 00:25:15,000
die Software mit dem Wert x und 
dann komme ich ja irgendwann an 

478
00:25:15,000 --> 00:25:19,120
die andere Stelle meines Codes 
und da muss ich die den das 

479
00:25:19,120 --> 00:25:22,280
Attribut aber auf Wert Y 
stellen, easy peasy gar kein 

480
00:25:22,280 --> 00:25:26,000
Problem und schon läuft die Bude
und ich muss aber nicht noch 

481
00:25:26,000 --> 00:25:29,120
irgendwas anderes machen oder 
ich stell zum Beispiel dieses 

482
00:25:29,120 --> 00:25:32,640
Attribut anhand von dem 
vorherigen Wert um oder sowas 

483
00:25:32,640 --> 00:25:34,400
ne. 
Was auch immer, ne, also dass 

484
00:25:34,400 --> 00:25:37,000
ich sozusagen nicht von x 
statisch auf Y schalte, sondern 

485
00:25:37,000 --> 00:25:40,080
sage unter bestimmten Umständen,
wenn es vorher x war, dann stell

486
00:25:40,080 --> 00:25:43,600
ich aber hier das auf Y um in 
meinem nächsten Programmablauf 

487
00:25:43,600 --> 00:25:47,200
bedeutet aber, dass du in deinem
Single irgendwo global etwas 

488
00:25:47,200 --> 00:25:50,000
änderst, was du mit 
hundertprozentiger Sicherheit an

489
00:25:50,000 --> 00:25:51,600
einer anderen Stelle wieder 
vergisst. 

490
00:25:52,080 --> 00:25:54,720
Dieser Wert wieder genutzt wird 
und irgendein Quatsch in einer 

491
00:25:54,720 --> 00:25:58,080
Software passiert und du dir 
denkst, warum ist das gerade 

492
00:25:58,080 --> 00:25:59,600
passiert? 
Das sind genau diese 

493
00:25:59,600 --> 00:26:01,680
Abhängigkeiten, diese 
Verstecken, von denen du gerade 

494
00:26:01,680 --> 00:26:05,040
geredet hast. 
Und das zu Debacken und 

495
00:26:05,040 --> 00:26:06,560
hinterher zu schnallen, was da 
los ist. 

496
00:26:06,560 --> 00:26:10,160
Wenn du vielleicht gerade nicht 
unbedingt verstanden hast, wie 

497
00:26:10,160 --> 00:26:13,680
ich zum Beispiel damals, was so 
ein Singleton eigentlich macht 

498
00:26:13,680 --> 00:26:16,400
oder wo man es vielleicht nicht 
verwenden sollte oder was 

499
00:26:16,400 --> 00:26:19,440
vielleicht die Einschränkungen 
oder die Probleme damit sind, 

500
00:26:19,920 --> 00:26:22,480
dann bist du ewig dabei, deinen 
Code zu debacken, weil du dir 

501
00:26:22,480 --> 00:26:26,800
denkst, hä, was soll das ne, wo 
kommt das her, ja. 

502
00:26:28,160 --> 00:26:31,840
Du hast halt. 
Also die Versuchung ist extrem 

503
00:26:31,840 --> 00:26:35,040
groß, gerade am Anfang, wenn man
mit dem Pattern arbeitet, halt 

504
00:26:35,360 --> 00:26:38,480
diese globalen Zustände 
auszunutzen oder es als Verein, 

505
00:26:38,480 --> 00:26:42,000
also es ist halt so easy Lunch 
am Anfang ne, weil du sagst, OK,

506
00:26:42,000 --> 00:26:44,480
ich kann jetzt schnell ne Lösung
damit basteln, aber du 

507
00:26:44,480 --> 00:26:49,920
untergräbst ja schon Prinzipien 
der Objektorientierung, also es 

508
00:26:49,920 --> 00:26:51,400
ist. 
Sag ich mal. 

509
00:26:51,400 --> 00:26:55,040
Globale Zustände gelten ja auch 
oft als Antipattern. 

510
00:26:55,040 --> 00:26:57,920
Ja, also globale Variablen oder 
so, weil du halt damit in 

511
00:26:57,920 --> 00:26:59,680
Teufels Küche kommst. 
Irgendwann. 

512
00:26:59,920 --> 00:27:04,400
Und genauso kann es dir mit dem 
Singleton halt auch ergehen und 

513
00:27:04,400 --> 00:27:07,200
n riesen unterschied, das muss 
ich auch einfach mal so sagen, 

514
00:27:07,440 --> 00:27:10,560
früher wo ich das verwendet hab 
oder viel verwendet hab gerade 

515
00:27:10,560 --> 00:27:13,680
so am Anfang sag ich mal zweites
Semester oder so, wir haben ja 

516
00:27:13,680 --> 00:27:19,160
viel am Anfang des Podcast über 
unsere Studienzeit erzählt, das 

517
00:27:19,160 --> 00:27:22,120
ist einfach. 
Da war mir das egal. 

518
00:27:22,160 --> 00:27:25,840
Die Abhängigkeiten, weil weil 
ich habe keine Tests 

519
00:27:25,840 --> 00:27:29,600
geschrieben, ich wollte einfach 
nur irgendwie diese Aufgaben in 

520
00:27:29,600 --> 00:27:32,080
den Programmierkursen lösen und 
einreichen. 

521
00:27:32,080 --> 00:27:34,840
Ja und irgendwie Lösungen 
schaffen, aber ich habe mir 

522
00:27:34,840 --> 00:27:40,240
überhaupt keine Gedanken darüber
gemacht, ob das Abhängigkeiten 

523
00:27:40,240 --> 00:27:43,680
hat, ob das Testbar und wartbar 
ist, weil das war sehr 

524
00:27:43,680 --> 00:27:45,800
flüchtiger Code. 
Ja, du hast jede Woche deine 

525
00:27:45,800 --> 00:27:48,440
Übungsaufgaben bekommen, du hast
es gelöst und danach war das für

526
00:27:48,440 --> 00:27:51,680
dich gegessen das Thema. 
Und dementsprechend hat man auch

527
00:27:51,840 --> 00:27:54,840
leider sehr schnell die 
Versuchung gehabt, sich so nicht

528
00:27:54,840 --> 00:27:56,800
gerade Best Practices 
anzueignen. 

529
00:27:56,800 --> 00:27:58,960
Ja, die du dann halt auch wieder
loswerden muss und verstehen 

530
00:27:58,960 --> 00:28:01,200
muss. 
Warum ist es denn eigentlich 

531
00:28:01,200 --> 00:28:06,360
nicht gut und das kann man ja 
auch ganz einfach an Beispiel 

532
00:28:06,360 --> 00:28:08,960
von Unit Test mal erklären. 
Ja, ich würde das jetzt mal kurz

533
00:28:08,960 --> 00:28:12,600
ein bisschen technischer machen,
nehmen wir noch mal das Beispiel

534
00:28:12,600 --> 00:28:16,320
Logger, es ist ein 
Anwendungsfall, keine Frage, 

535
00:28:16,880 --> 00:28:19,040
aber wenn ich jetzt wirklich 
testen möchte ob. 

536
00:28:19,560 --> 00:28:22,840
Ob das mit meinem Logger klappt,
also unter gewissen Umständen. 

537
00:28:22,840 --> 00:28:25,360
Ich möchte jetzt wirklich auf 
Ebene testen, dass ein Log zum 

538
00:28:25,360 --> 00:28:30,720
Beispiel geschrieben wird, ja 
und ich instanziiere den Logger 

539
00:28:31,120 --> 00:28:33,600
und mache ein Log und gucke ob 
das da drin steht, zum Beispiel 

540
00:28:33,600 --> 00:28:36,400
ich Speicher mir jetzt wirklich 
ganz ganz simpel ein ganz 

541
00:28:36,400 --> 00:28:38,320
simpler Logger selbst 
geschrieben, ja und ich Speicher

542
00:28:38,320 --> 00:28:43,360
mir einfach eine Message in der 
Liste oder so ab ja und gucke 

543
00:28:43,360 --> 00:28:45,280
dann ob die Liste jetzt einen 
Eintrag hat. 

544
00:28:45,920 --> 00:28:47,280
So ja hat sie. 
OK. 

545
00:28:47,280 --> 00:28:49,640
Test 1 ist grün. 
Ja ich wollt jetzt n Error 

546
00:28:49,640 --> 00:28:54,640
loggen und der ist da drin so 
und in Test 2 sag ich log mir 

547
00:28:54,640 --> 00:28:58,520
mal ne message ne normale Info 
hast du es genannt, ist ja auch 

548
00:28:58,520 --> 00:29:03,440
so n gängiger Begriff ja als als
log Level log mal ne Info ja ist

549
00:29:03,440 --> 00:29:06,240
drin aber die Länge der Liste 
ist 2 wieso? 

550
00:29:07,840 --> 00:29:10,880
Ich habe ja nur ne Info gelockt 
ja aber da ist ja noch n Error 

551
00:29:10,880 --> 00:29:15,280
drin so und dann denkst du ja. 
OK, warum ist da denn jetzt noch

552
00:29:15,280 --> 00:29:18,000
n Error drin? 
Und da kommst du halt je nach 

553
00:29:18,000 --> 00:29:21,120
Test Framework und je nachdem 
wie du es aufbaust genau in 

554
00:29:21,120 --> 00:29:25,440
diese Teufelsküche, weil du hast
einfach die gleiche Instanz von 

555
00:29:25,440 --> 00:29:28,880
deinem Logger und hast schon 
Test laufen lassen. 

556
00:29:29,280 --> 00:29:33,120
Ja hast den Error gelockt, der 
Test war grün und der zweite 

557
00:29:33,120 --> 00:29:37,040
Test sagt jetzt. 
Nee, aber die Länge ist nicht 1 

558
00:29:37,120 --> 00:29:39,320
von deinen Blogs, die ist 2. 
Ja, das. 

559
00:29:39,360 --> 00:29:41,840
Droht der Test, du. 
Kannst ja nicht in jedem in 

560
00:29:41,840 --> 00:29:44,160
jedem Test n neues Objekt 
erstellen oder das irgendwie 

561
00:29:44,160 --> 00:29:45,560
resetten, weil du hast es 
einmal. 

562
00:29:45,600 --> 00:29:47,680
Also du hast halt keine 
Kontrolle mehr da drüber. 

563
00:29:47,680 --> 00:29:50,120
Du hast keine Kontrolle mehr, du
hast dich quasi selbst ja 

564
00:29:50,120 --> 00:29:53,440
ausgeschlossen und jetzt fängst 
du an zu frickeln, irgendwie 

565
00:29:53,440 --> 00:29:56,920
diesen Ausgangszustand 
wiederherzustellen, wenn du mit 

566
00:29:56,920 --> 00:29:59,480
n Singleton arbeitest. 
Und das ist wirklich n Problem 

567
00:29:59,480 --> 00:30:02,320
mit in Sachen Testbarkeit, vor 
allem der Witz. 

568
00:30:03,280 --> 00:30:06,240
Und das ist das das Gemeine. 
Du schreibst diesen zweiten 

569
00:30:06,240 --> 00:30:10,240
Test, lässt den alleine laufen, 
fährst die Testsuite hoch und 

570
00:30:10,240 --> 00:30:13,120
der Test ist grün. 
Ein Log ist drin. 

571
00:30:13,120 --> 00:30:16,000
Info alles perfekt. 
Ja gut, lass alle Tests laufen 

572
00:30:16,000 --> 00:30:20,680
rot ja genau weißt du, du 
kriegst halt, du hast halt diese

573
00:30:20,680 --> 00:30:24,000
Abhängigkeiten die je nach 
Ausführung dann. 

574
00:30:24,400 --> 00:30:27,080
Echt unterschiedliche Ergebnisse
liefern und das ist natürlich in

575
00:30:27,080 --> 00:30:30,880
Sachen testen die absolute Hölle
und da ist Single wirklich 

576
00:30:30,880 --> 00:30:32,880
gefährlich und deswegen kann ich
auch verstehen, dass es 

577
00:30:32,880 --> 00:30:35,120
umstritten ist dabei. 
Ja, auf jeden Fall. 

578
00:30:36,160 --> 00:30:38,960
Es ist ja auch, es ist ja auch 
nicht nur unbedingt, also es 

579
00:30:38,960 --> 00:30:42,480
gibt ja auch n andere Beispiele,
ne, also es ist es, es macht 

580
00:30:42,480 --> 00:30:45,600
manchmal Sinn Single vielleicht 
zu verwenden, ne oder es ist 

581
00:30:45,600 --> 00:30:49,600
durchaus möglich, ich finde 
immer ich ich finde das immer so

582
00:30:49,600 --> 00:30:53,520
schön, weil das hat einmal 
jemand gesagt in in in auch n 

583
00:30:53,520 --> 00:30:54,720
sehr. 
Würde ich sagen. 

584
00:30:54,720 --> 00:30:59,760
Begnadeter Coder, der Mal gesagt
hat, du kannst alles machen, 

585
00:30:59,760 --> 00:31:03,880
wenn du weißt, wie es geht, so 
weißt du und im Endeffekt würde 

586
00:31:03,880 --> 00:31:07,840
ich mich auch hinstellen und 
sagen, OK, wenn du Herr oder 

587
00:31:07,840 --> 00:31:11,160
Frau darüber bist, sozusagen ne 
n Single zu verwenden, dann ist 

588
00:31:11,160 --> 00:31:13,000
es kein Problem, wenn du weißt 
was da los ist. 

589
00:31:13,000 --> 00:31:16,720
Wenn du um wenn du verstanden 
hast was n Single ist, wenn du 

590
00:31:16,720 --> 00:31:20,880
wenn wenn du dir dessen bewusst 
bist, dass du das jetzt wirklich

591
00:31:20,880 --> 00:31:23,240
tust und nicht einfach nur 
sagst, OK, ich hab gerade Single

592
00:31:23,280 --> 00:31:26,640
kennengelernt, los, los, los, 
los, ne, dann kannst du das 

593
00:31:26,640 --> 00:31:28,240
machen, wenn du es verstanden 
hast und. 

594
00:31:28,880 --> 00:31:32,320
Ne, das ist ja dann auch deine 
eigene, dein wie sagt man deine 

595
00:31:32,320 --> 00:31:34,560
eigene Entscheidungsgewalt 
darüber? 

596
00:31:34,560 --> 00:31:37,440
Ne, aber es gibt auch Beispiele 
wo es halt absolut gar keinen 

597
00:31:37,440 --> 00:31:40,520
Sinn macht zum Beispiel ne also 
klar, Logger hat mir gesagt OK 

598
00:31:40,640 --> 00:31:43,120
macht vielleicht Sinn, ist 
vielleicht an der Stelle nicht 

599
00:31:43,120 --> 00:31:45,440
so gut testbar, was natürlich 
auch auf jeden Fall n sehr sehr 

600
00:31:45,440 --> 00:31:48,080
wichtiger Punkt ist, weil 
testbarer Code ist natürlich 

601
00:31:48,080 --> 00:31:50,280
guter Code, wenn man ihn nicht 
testen kann, ist natürlich 

602
00:31:50,280 --> 00:31:54,600
schlecht, aber angenommen du 
hast zum Beispiel n Single der 

603
00:31:54,600 --> 00:31:57,280
dir sagt OK ich hab jetzt zum 
Beispiel n User Session. 

604
00:31:57,440 --> 00:32:00,880
Ne, also das Singleton nimmt n 
speichert ne User Session. 

605
00:32:00,880 --> 00:32:03,240
Du denkst dir so ja ist doch ne 
geile sache, du hast doch eh 

606
00:32:03,240 --> 00:32:05,920
immer nur einen User der gerade 
irgendwie aktiv ist und dann 

607
00:32:05,920 --> 00:32:09,520
sozusagen du brauchst ja nicht 
mehr in deiner Session gerade 

608
00:32:09,520 --> 00:32:13,000
ne, also angenommen du hast 
jetzt ne ne API ne und n Rest 

609
00:32:13,000 --> 00:32:16,200
Call und jetzt kommt n Call rein
und jetzt zum Beispiel hat 

610
00:32:16,200 --> 00:32:20,000
irgendwie der erste Call ist zum
Beispiel von Alice ne es wird 

611
00:32:20,000 --> 00:32:23,440
alles abgearbeitet und Returned 
und Alice war in dieser Session 

612
00:32:23,440 --> 00:32:26,160
gerade drin und dann kommt zum 
Beispiel n zweiter Call danach. 

613
00:32:26,560 --> 00:32:31,360
Zum Beispiel ne vom Bob. 
So, und jetzt hast du das 

614
00:32:31,360 --> 00:32:34,440
funktioniert soweit so gut, 
solange diese Calls jetzt nicht 

615
00:32:34,440 --> 00:32:36,400
zeitgleich kommen, aber wenn die
jetzt zum Beispiel zeitgleich 

616
00:32:36,400 --> 00:32:39,880
kommen ne und du hast jetzt zum 
Beispiel Call 1, ne Alice ruft 

617
00:32:39,880 --> 00:32:43,520
es auf Alice als oder die ganzen
Infos über Alice werden in 

618
00:32:43,520 --> 00:32:46,400
dieser Session gespeichert, 
jetzt kommt kurz danach weil es 

619
00:32:46,480 --> 00:32:49,680
fast zeitgleich ist. 
Kommt ne ne Anfrage vom Bob ne? 

620
00:32:50,080 --> 00:32:52,560
Das heißt, jetzt werden die 
Infos über Bob in der User 

621
00:32:52,560 --> 00:32:55,520
Session gespeichert und dann 
wird aber quasi der Call von 

622
00:32:55,520 --> 00:32:58,080
Alice Returnt. 
Bekommt aber alle Infos von Bob 

623
00:32:58,080 --> 00:33:00,200
zurück. 
So und damit siehst du, dass du 

624
00:33:00,200 --> 00:33:03,160
im Endeffekt quasi irgendwas 
änderst, was du aber in dem 

625
00:33:03,160 --> 00:33:04,800
Moment eigentlich gar nicht 
ändern wolltest. 

626
00:33:04,800 --> 00:33:06,960
So, obwohl es sich vielleicht 
erstmal schön anfühlt, weil du 

627
00:33:06,960 --> 00:33:09,840
sagst, ja, da kann ich ja 
irgendwie global meine ganzen 

628
00:33:09,840 --> 00:33:13,320
Daten drin speichern, so ne und 
das ist aber wieder blöd, ne? 

629
00:33:13,440 --> 00:33:16,720
Das wäre jetzt mal das ist. 
Ja, das ist halt genau der 

630
00:33:16,720 --> 00:33:18,720
Punkt. 
Also du musst halt irgendwie 

631
00:33:18,720 --> 00:33:21,520
abstecken können und das macht 
nachher auch so ein bisschen die

632
00:33:21,520 --> 00:33:27,720
Erfahrung wie wie Wartbar und 
skalierbar muss meine Software 

633
00:33:27,720 --> 00:33:29,960
am Ende sein, welche Änderungen 
können noch reinkommen, also wie

634
00:33:29,960 --> 00:33:33,360
überschaubar ist es diesen 
Anwendungsfall einzuschätzen und

635
00:33:33,360 --> 00:33:35,880
jetzt kann man natürlich sagen, 
ja lieber immer auf die 

636
00:33:35,880 --> 00:33:38,440
skalierbare und wartbare Lösung 
setzen, wir wollen ja gleich 

637
00:33:38,440 --> 00:33:41,880
noch eine kleine Alternative an 
teasern, so ne, weil ganz 

638
00:33:41,880 --> 00:33:43,920
ausführlich werden wir es nicht 
besprechen können in einer 

639
00:33:43,920 --> 00:33:46,280
Folge. 
Aber manchmal gibt es Fälle, wo 

640
00:33:46,280 --> 00:33:48,480
es halt so wirklich kleine 
Softwarelösungen sind, wo du 

641
00:33:48,800 --> 00:33:50,520
genau überblicken kannst, wie du
meintest. 

642
00:33:50,520 --> 00:33:53,040
Wenn man weiß, was man tut, wo 
das halt dann einfach auch Sinn 

643
00:33:53,040 --> 00:33:54,960
macht. 
Ja, also auf diese Lösung zu 

644
00:33:54,960 --> 00:33:57,360
gehen. 
Bestes Beispiel, Wir hatten ja 

645
00:33:57,360 --> 00:34:00,080
vor kurzem mal so n ganz kleines
Mini Beispiel Backend 

646
00:34:00,080 --> 00:34:03,600
geschrieben und da gab es also 
ohne jetzt irgendwelche 

647
00:34:03,600 --> 00:34:07,760
Frameworks zu verwenden ja also 
wirklich so so wirklich plain 

648
00:34:08,080 --> 00:34:10,639
und. 
Dann mussten wir uns halt auch 

649
00:34:10,639 --> 00:34:14,080
ne Art Mechanismus bauen um ne 
Art Service bereitzustellen. 

650
00:34:14,159 --> 00:34:18,199
Ja und da haben wir dann einfach
auch schnell n Singleton 

651
00:34:18,199 --> 00:34:21,280
gemacht, so klar, wir konnten 
dann auch direkt zeigen was das 

652
00:34:21,280 --> 00:34:24,320
Problem ist beim Testen. 
Ja, also das hat man dann auch 

653
00:34:24,320 --> 00:34:27,760
direkt gespürt, konnte man 
lösen, aber man merkt halt immer

654
00:34:27,760 --> 00:34:32,080
wieder wo denn halt die die 
Nachteile sind und genauso kann 

655
00:34:32,080 --> 00:34:36,080
man sagen es gibt ne andere 
Möglichkeit das umzusetzen ein 

656
00:34:36,080 --> 00:34:38,440
ähnliches Verhalten. 
Und da möchte ich jetzt noch 

657
00:34:38,440 --> 00:34:42,639
ganz kurz mit dir darauf 
eingehen, was so ne Alternative 

658
00:34:42,639 --> 00:34:44,960
wäre und ich glaub da ist so n 
großes Stichwort, was auch 

659
00:34:44,960 --> 00:34:47,520
schnell genannt wird, auch 
gerade von Kritikern gegenüber 

660
00:34:47,520 --> 00:34:51,520
den Singleton Peppern is 
dependency Injection, magst du 

661
00:34:51,520 --> 00:34:54,239
das vielleicht das Konzept 
dahinter mal kurz erklären? 

662
00:34:55,239 --> 00:34:57,280
Kann ich machen. 
Ich würd es glaub ich auch nicht

663
00:34:57,280 --> 00:34:59,480
wirklich sehr vertiefen. 
Also wir können gerne auch noch 

664
00:34:59,480 --> 00:35:01,720
mal ne eigene Folge über die 
Penency Injection machen, wenn 

665
00:35:01,720 --> 00:35:03,120
ja gerne. 
Das ist nämlich super geiles 

666
00:35:03,120 --> 00:35:03,680
Thema. 
Genau. 

667
00:35:03,680 --> 00:35:07,080
Also wenn auch gerade wenn es 
euch interessiert, liebe zura 

668
00:35:07,080 --> 00:35:09,760
Liebe zura, wenn du sagst, ey 
ist ne coole Sache, würd ich 

669
00:35:09,760 --> 00:35:12,000
gern was drüber hören, dann sag 
uns auf jeden Fall mal Bescheid,

670
00:35:12,960 --> 00:35:16,320
dann können wir das auch, ein 
Scadulen sozusagen das Thema 

671
00:35:18,080 --> 00:35:21,240
kurz gesagt ist die Penency 
Injection, ich glaub wir hatten 

672
00:35:21,240 --> 00:35:23,400
das auch mal in irgendeiner 
Folge kurz angesprochen, ich bin

673
00:35:23,400 --> 00:35:25,880
mir nicht ganz sicher. 
Aber da geht es im Endeffekt 

674
00:35:25,880 --> 00:35:32,120
darum, dass du beispielsweise, 
also du nimmst eine eine Instanz

675
00:35:32,120 --> 00:35:36,320
einer Klasse und injizierst sie 
in eine andere, was im Endeffekt

676
00:35:36,320 --> 00:35:39,360
im Code, sagen wir mal, nichts 
großartig anderes ist als 

677
00:35:39,360 --> 00:35:42,560
beispielsweise ein Parameter, 
den du übergibst. 

678
00:35:42,880 --> 00:35:45,720
Aber wenn du jetzt zum Beispiel 
sagst, du hast irgendwo in 

679
00:35:45,720 --> 00:35:50,720
deiner Main, legst du dir eine 
Instanz eines Loggers an und 

680
00:35:50,720 --> 00:35:53,680
kannst jetzt diese Instanz des 
Loggers einfach. 

681
00:35:53,920 --> 00:35:57,360
Immer weiter sozusagen in deine 
Software rein injizieren 

682
00:35:57,360 --> 00:36:00,720
sozusagen ne die Dependency 
diese Abhängigkeit rein injecten

683
00:36:00,720 --> 00:36:03,000
sozusagen in deine Software, das
heißt du brauchst zum Beispiel 

684
00:36:03,000 --> 00:36:05,600
von der Main irgendwann nen 
Service und dieser Service zum 

685
00:36:05,600 --> 00:36:07,680
Beispiel der aufgerufen wird, 
der braucht n Logger und das 

686
00:36:07,680 --> 00:36:10,800
heißt dieser Logger wird dann 
diesem Service übergeben. 

687
00:36:11,120 --> 00:36:15,120
So das heißt kannst dann im 
Endeffekt rein theoretisch ne 

688
00:36:15,120 --> 00:36:16,320
und das ist jetzt wieder das 
andere. 

689
00:36:16,720 --> 00:36:19,760
Du kannst natürlich auch jedem 
Service ne eigene Instanz 

690
00:36:19,760 --> 00:36:22,080
übergeben. 
Was du dann natürlich nicht 

691
00:36:22,080 --> 00:36:23,680
machen solltest. 
An der Stelle. 

692
00:36:23,680 --> 00:36:26,320
Frameworks haben sowas auch zum 
Beispiel so n bisschen 

693
00:36:26,480 --> 00:36:29,240
eingebettet, dass das nicht 
unbedingt passieren kann. 

694
00:36:29,240 --> 00:36:34,680
Ne, dass du sowas halt eben ist 
es komfortabel gemacht mit 

695
00:36:34,680 --> 00:36:36,760
dieser dependence injection, 
dass du halt eben sagst, OK, ich

696
00:36:36,760 --> 00:36:38,680
möchte jetzt dieses eine Ding 
was ich mir da angelegt hab 

697
00:36:38,680 --> 00:36:41,280
möchte ich jetzt nehmen, so 
fühlt sich mal n bisschen an wie

698
00:36:41,280 --> 00:36:42,840
n Singleton, dann aber ist es 
nicht. 

699
00:36:43,880 --> 00:36:46,640
Und das ist halt das geile ne, 
dass große Frameworks. 

700
00:36:47,920 --> 00:36:49,480
Genau, weil wir auch gerade 
Backend hatten. 

701
00:36:49,480 --> 00:36:52,800
Ne, also sowas wie Spring Boot 
oder auch cater und so die Beat 

702
00:36:52,800 --> 00:36:58,040
natürlich Packages und Lips 
sozusagen wo du genau das hast. 

703
00:36:58,040 --> 00:37:01,120
Ne du hast das Gefühl von ich 
habe diese eine Instanz wieso n 

704
00:37:01,120 --> 00:37:04,080
Singleton kaufst dir aber nicht 
die Nachteile ein, weil es halt 

705
00:37:04,080 --> 00:37:05,640
über dependency Injection gelöst
ist. 

706
00:37:05,640 --> 00:37:07,840
Am Ende richtig. 
Das ist halt geil, genau, aber 

707
00:37:07,840 --> 00:37:11,360
nichtsdestotrotz. 
Kleine Side Note brauchst da 

708
00:37:11,360 --> 00:37:13,280
trotzdem ne ganz gute 
Architektur deiner Software, 

709
00:37:13,280 --> 00:37:15,040
weil ansonsten kommst du nämlich
auch schnell mal in diese 

710
00:37:15,040 --> 00:37:17,720
Möglichkeit, dass du vielleicht 
dann doch noch mal ne neue 

711
00:37:17,720 --> 00:37:20,000
Instanz erstellst. 
Also es ist, du bist nicht 

712
00:37:20,000 --> 00:37:23,880
gewahrt davor neue Instanzen von
so einem ne von den Objekten 

713
00:37:23,880 --> 00:37:25,520
dann zu erstellen, also auch von
Logger. 

714
00:37:25,520 --> 00:37:28,880
Ne, du kannst mehrere erstellen,
das das muss einem dann 

715
00:37:28,880 --> 00:37:32,080
Bewusstsein, aber Fakt ist ist 
es ist ne Möglichkeit wenn du 

716
00:37:32,080 --> 00:37:34,600
weißt wie gesagt wenn du weißt 
was du tust, dann kannst du es 

717
00:37:34,600 --> 00:37:37,080
super machen und dann hast du 
eben auch gerade weil du die 

718
00:37:37,080 --> 00:37:39,760
Testbarkeit angesprochen hast 
die Möglichkeit zu sagen ich 

719
00:37:39,760 --> 00:37:41,600
teste. 
Es dir jetzt das ganze erstell 

720
00:37:41,600 --> 00:37:44,920
mir n neuen Logger und entjekte 
den sozusagen in meine Funktion,

721
00:37:44,920 --> 00:37:47,320
in meinen Service, was auch 
immer ne, das heißt du kannst 

722
00:37:47,320 --> 00:37:48,800
jetzt. 
Immer ne saubere Ausgangslage. 

723
00:37:48,800 --> 00:37:52,160
Genau, und das ist halt 
natürlich der der Vorteil und im

724
00:37:52,160 --> 00:37:56,560
Normalfall würde ich so als 
Daumenregel auch sagen, man kann

725
00:37:56,560 --> 00:37:58,680
Single verwenden, wenn man weiß 
was es ist und wenn man weiß, 

726
00:37:58,680 --> 00:38:01,120
was man tut, sollte man aber 
definitiv nicht überall und 

727
00:38:01,120 --> 00:38:04,960
immer machen und gerne auch auf 
Dependency Injection auf 

728
00:38:04,960 --> 00:38:09,080
ausweichen, was definitiv ne 
super mega Alternative ist. 

729
00:38:09,440 --> 00:38:11,840
Aber auch da muss man wissen, 
was da passiert, ne? 

730
00:38:12,400 --> 00:38:14,720
Ja, die Menge macht das Gift, 
oder wie sagt man so schön. 

731
00:38:14,720 --> 00:38:18,000
Also wenn ich jetzt anfange, 
überall alles zu injekten, dann 

732
00:38:18,000 --> 00:38:20,440
kriege ich halt auch unfassbar 
viele Abhängigkeiten rein und 

733
00:38:20,440 --> 00:38:22,000
komme auch wieder in 
Teufelsküche am Ende. 

734
00:38:22,840 --> 00:38:26,160
Man muss halt immer gucken, ja 
wie du schon meinst ne gute 

735
00:38:26,160 --> 00:38:29,360
Architektur aufbauen, ne das da 
gibt es ja dann auch, es gibt ja

736
00:38:29,360 --> 00:38:32,080
auch Architektur Pattern und 
alles ne das sind wir ja heute 

737
00:38:32,080 --> 00:38:34,320
nicht, aber. 
Ich mein nicht ohne Grund 

738
00:38:34,320 --> 00:38:37,200
beschäftigen sich sehr viele und
schlaue Leute sehr viel mit 

739
00:38:37,200 --> 00:38:39,920
solchen Themen. 
Ne um einfach ne gute Software 

740
00:38:39,920 --> 00:38:43,840
am Ende entwickeln zu können und
Dependency Injection ist n 

741
00:38:43,840 --> 00:38:47,720
cooles Prinzip und hat halt auch
seine Tücken am Ende oder muss 

742
00:38:47,720 --> 00:38:51,600
man halt auch aufpassen richtig 
klare klarer Disclaimer hier so.

743
00:38:52,040 --> 00:38:53,280
Genau. 
Und wir wollten das ja auch 

744
00:38:53,280 --> 00:38:55,720
immer n bisschen einordnen, wie 
stark das zum Beispiel verwendet

745
00:38:55,720 --> 00:38:57,680
wird. 
Also Single gehört schon das 

746
00:38:57,680 --> 00:38:59,920
Pattern zu einem bekannten 
Design Pattern. 

747
00:39:00,960 --> 00:39:02,960
Also man stolpert eigentlich 
sofort darüber. 

748
00:39:03,120 --> 00:39:06,040
Ja, also jetzt mal ohne Scheiß 
ne, ist doch eigentlich glaub 

749
00:39:06,040 --> 00:39:10,240
ich das bekannteste und das 
erste was man so hört oder weil 

750
00:39:10,240 --> 00:39:12,800
es halt auch ich, also ich weiß 
nicht irgendwie hab ich immer 

751
00:39:12,800 --> 00:39:16,240
das Gefühl ist das erste worüber
man stolpert, weil es halt so 

752
00:39:16,240 --> 00:39:19,040
pro und contra hat, weil es halt
auch n gutes Beispiel ist um 

753
00:39:19,200 --> 00:39:23,280
direkt zu zeigen es ist nicht 
die absolute Wahrheit so ne 

754
00:39:23,280 --> 00:39:26,320
Pattern zu verwenden, aber man 
muss immer wissen was vor und 

755
00:39:26,320 --> 00:39:28,160
Nachteil ist und wann sie Sinn 
machen. 

756
00:39:28,320 --> 00:39:30,240
Genau. 
Aber wie gesagt also. 

757
00:39:30,640 --> 00:39:33,920
Es es ist es, ich würde sagen, 
in modernen 

758
00:39:34,000 --> 00:39:37,920
Softwarearchitekturen wird es 
wird das Pattern Single eher 

759
00:39:37,920 --> 00:39:42,960
sparsam eingesetzt, aber wie 
gesagt, nichtsdestotrotz ist es 

760
00:39:43,120 --> 00:39:46,880
gut es zu kennen und ich würde 
es auf jeden Fall auch wenn man 

761
00:39:46,880 --> 00:39:48,960
sich jetzt zum Beispiel gesagt 
hat, ey ich hab das noch nie 

762
00:39:48,960 --> 00:39:52,320
programmiert, ich würde 
vorschlagen, dass man sich 

763
00:39:52,320 --> 00:39:56,400
hinsetzt mal und sagt OK ich 
mach das mal, probier das mal. 

764
00:39:56,800 --> 00:39:59,200
Und Versuche zum Beispiel 
erstmal einmal, dass es 

765
00:39:59,200 --> 00:40:05,320
überhaupt funktioniert, ne, also
beispielsweise also wirklich zu 

766
00:40:05,320 --> 00:40:07,840
verifizieren, dass es dann am 
Ende auch wirklich nur eine 

767
00:40:07,840 --> 00:40:11,520
Instanz gibt, ne und dann 
vielleicht auch mal zu gucken, 

768
00:40:11,920 --> 00:40:16,080
OK, wie krieg ich es hin, dass. 
Ich so eine richtige Falle mir 

769
00:40:16,080 --> 00:40:19,000
aufbauen kann in meinem Code mit
so einem Single, weil klar kann 

770
00:40:19,000 --> 00:40:21,120
man sich jetzt hinstellen und 
sagen, ja, wenn es jetzt nicht 

771
00:40:21,120 --> 00:40:24,520
so verbreitet ist, gerade in 
modernen Softwarearchitekturen, 

772
00:40:24,520 --> 00:40:26,320
warum soll ich es denn dann 
verwenden? 

773
00:40:26,320 --> 00:40:28,240
Warum soll ich denn dann darüber
wissen? 

774
00:40:29,040 --> 00:40:32,920
Es hilft halt einfach manchmal 
um das große Ganze sozusagen 

775
00:40:32,920 --> 00:40:36,240
besser zu verstehen und deswegen
ist es auf jeden Fall hilfreich,

776
00:40:36,240 --> 00:40:39,200
sich das anzugucken und auch mal
auszuprobieren. 

777
00:40:40,080 --> 00:40:42,160
Ja. 
Eigentlich kann man genau das 

778
00:40:42,160 --> 00:40:44,800
Loggerbeispiel, wie wir heute 
erklärt haben. 

779
00:40:45,440 --> 00:40:48,400
Mal nachcoden ne, dass du jetzt 
sagst, OK, ich hab n logger, ich

780
00:40:48,640 --> 00:40:52,480
hab jetzt den das den Bedarf, 
dass es ihn nur einmal gibt, 

781
00:40:52,480 --> 00:40:55,040
weil ich ja immer in den 
gleichen Speicher sozusagen 

782
00:40:55,040 --> 00:40:57,200
loggen möchte. 
Ich code das wie du meintest 

783
00:40:57,200 --> 00:41:00,760
einfach mal n Single und dann 
Leute schreibt ruhig mal n Test 

784
00:41:00,760 --> 00:41:03,320
dazu und probiert das mal aus 
was denn beim Testen da die 

785
00:41:03,320 --> 00:41:07,200
Probleme sind und. 
Dann sieht man einfach. 

786
00:41:07,200 --> 00:41:08,800
Also dann hat man es wirklich 
mal erlebt. 

787
00:41:08,800 --> 00:41:11,080
Weißt du und ich finde, man muss
das auch mal erleben, diesen 

788
00:41:11,080 --> 00:41:14,880
Pain dabei und dann hat man das 
glaube ich auch ganz cool 

789
00:41:14,880 --> 00:41:16,520
verinnerlicht. 
Also es ist ne geile Übung, auf 

790
00:41:16,520 --> 00:41:18,400
jeden Fall gut, dass du das 
angesprochen hast. 

791
00:41:18,720 --> 00:41:22,360
Aber lass uns mal jetzt zum 
Abschluss der Folge noch mal 

792
00:41:22,360 --> 00:41:25,680
kurz zusammenfassen. 
Also ich fang noch mal an 

793
00:41:26,480 --> 00:41:30,000
Singleton, was ist das Pattern 
dahinter, also das Singleton 

794
00:41:30,000 --> 00:41:34,560
Design Pattern stellt sicher, 
dass es genau eine Instanz einer

795
00:41:34,560 --> 00:41:38,480
Klasse gibt. 
Und dass quasi diese Instanz von

796
00:41:38,480 --> 00:41:41,760
überall erreichbar ist. 
Ja, also ich kann halt nur eine 

797
00:41:41,760 --> 00:41:44,240
Instanz erzeugen und sie von 
überall verwenden. 

798
00:41:44,400 --> 00:41:50,880
Das ist erstmal das Petter 
tipptopp genau, also wir hatten 

799
00:41:50,880 --> 00:41:54,160
ja schon gesagt, das ist super 
für so Dinge, die man vielleicht

800
00:41:54,160 --> 00:41:56,960
zentral steuern möchte, auch mit
Bedacht natürlich, wie zum 

801
00:41:56,960 --> 00:42:00,560
Beispiel sowas wie n Logger oder
was wir jetzt schon paar Mal 

802
00:42:00,560 --> 00:42:02,800
genannt haben oder vielleicht 
auch sowas wie ne bestimmte Art 

803
00:42:02,800 --> 00:42:07,480
von Konfiguration. 
Threadpools oder zum Beispiel 

804
00:42:07,480 --> 00:42:10,400
Caches oder sowas in die 
Richtung ne ist aber kann aber 

805
00:42:10,400 --> 00:42:12,960
durchaus wie gesagt gefährlich 
werden, wenn es halt zu globalen

806
00:42:12,960 --> 00:42:17,920
Zuständen kommt. 
Und es ist natürlich auch 

807
00:42:17,920 --> 00:42:21,280
ratsam, vielleicht gerade wenn 
es jetzt um die Testbarkeit 

808
00:42:21,280 --> 00:42:24,960
geht, muss man mal gucken, da 
eignen sich. 

809
00:42:26,320 --> 00:42:29,440
Solche Singletons nicht so gut 
hattest du ja auch ein super 

810
00:42:29,440 --> 00:42:32,880
Beispiel geben Kino und wenn man
da jetzt vielleicht auch mal in 

811
00:42:32,880 --> 00:42:35,640
Teufels Küche kommt und sich 
denkt, verdammt, was habe ich 

812
00:42:35,640 --> 00:42:39,080
hier nur gemacht, wieso kann ich
das nicht testen, einfach mal 

813
00:42:39,080 --> 00:42:41,760
probieren das Ganze mit dem 
Dependency Injection umzusetzen,

814
00:42:42,000 --> 00:42:43,520
vielleicht flutscht es dann 
besser. 

815
00:42:43,840 --> 00:42:46,360
Ja, und falls ihr da eine eigene
Folge zu wollt, dann schreibt 

816
00:42:46,360 --> 00:42:49,040
uns gerne, dann machen wir das 
sehr gerne, weil es wirklich ein

817
00:42:49,040 --> 00:42:51,120
cooles Thema ist. 
Auch ein sehr lehrreiches Thema 

818
00:42:51,120 --> 00:42:53,120
ist und ein cooles Prinzip 
dahinter. 

819
00:42:54,800 --> 00:42:57,040
Ja, ansonsten, liebe 
Zuhörerinnen, liebe Zuhörer, 

820
00:42:57,040 --> 00:42:59,840
stellt sich uns natürlich jetzt 
die Frage, hast du schon mal mit

821
00:42:59,840 --> 00:43:01,360
dem Singleton Pattern 
gearbeitet? 

822
00:43:01,360 --> 00:43:04,880
Hast du positive oder negative 
Erfahrungen damit gemacht, wann 

823
00:43:04,880 --> 00:43:06,880
hat es dir vielleicht auch mal 
wirklich geholfen? 

824
00:43:07,120 --> 00:43:10,880
Teile gerne deine Erfahrung mit 
uns, dann können wir sie auch, 

825
00:43:10,880 --> 00:43:13,920
wenn du möchtest natürlich gerne
mal in einer nächsten Folge mal 

826
00:43:14,080 --> 00:43:16,720
vorstellen oder wenn du 
ergänzende Infos dazu hast, dann

827
00:43:16,720 --> 00:43:19,760
immer raus damit. 
Wir sind eine große Community 

828
00:43:19,760 --> 00:43:23,960
und helfen uns gegenseitig. 
Und ansonsten schau auch gerne 

829
00:43:23,960 --> 00:43:26,240
mal in die Show Notes. 
Gerade wenn du unsere anderen 

830
00:43:26,240 --> 00:43:27,880
Plattformen kennenlernen 
möchtest. 

831
00:43:27,880 --> 00:43:29,760
Du findest auch einen kleinen 
Spenden Link, falls du uns 

832
00:43:29,760 --> 00:43:31,920
unterstützen möchtest. 
Das würde uns mega freuen. 

833
00:43:33,120 --> 00:43:35,960
Bewerte diesen Podcast, wenn Dir
die Folge gefallen hat, wie 

834
00:43:35,960 --> 00:43:38,800
gesagt Abonnier die Glocke oder 
da drauf drücken was war wie 

835
00:43:38,800 --> 00:43:42,080
weiter empfiehlt gerne den 
Podcast weiter, das würde uns 

836
00:43:42,080 --> 00:43:45,920
mega mega freuen und ansonsten 
würde ich sagen hören uns alle 

837
00:43:45,920 --> 00:43:50,240
beim nächsten Mal wieder und bis
dahin habt eine gute Zeit. 

838
00:43:50,720 --> 00:43:52,560
Ciao, ciao, deine Kunden bei 
dies. 

839
00:43:52,920 --> 00:43:53,800
Gemeinsam besser.
