1
00:00:00,080 --> 00:00:02,320
Wenn du Tests hast, ja, und 
jemand sagt ja, dann lösch die 

2
00:00:02,320 --> 00:00:06,640
Tests, dann war mal so. 
Hahaha ich bringe dich um Coding

3
00:00:06,640 --> 00:00:09,480
Buddies dein Podcast rund. 
Um Softwareentwicklung und 

4
00:00:09,480 --> 00:00:12,040
aktueller Tech News. 
Herzlich Willkommen 

5
00:00:23,790 --> 00:00:27,070
einen wunderschönen guten Tag 
und herzlich Willkommen zur 

6
00:00:27,070 --> 00:00:30,510
neuen Folge vom Coding Buddies 
Podcast. 

7
00:00:31,520 --> 00:00:35,000
Ja, was auch sonst? 
Und zwar mit mir, dem Fabi und 

8
00:00:35,000 --> 00:00:37,920
dem fantastischen Tino. 
Denn Tino, ich find dich auch 

9
00:00:37,920 --> 00:00:40,160
fantastisch, ich weiß, du sagst 
immer zu mir fantastischer Fabi,

10
00:00:40,160 --> 00:00:42,360
aber ich find dich natürlich 
auch fantastisch und deswegen. 

11
00:00:42,360 --> 00:00:43,360
Dankeschön. 
Dankeschön. 

12
00:00:43,760 --> 00:00:47,680
Wie geht es dir? 
Ja Moin fabi, mir geht es gut, 

13
00:00:47,760 --> 00:00:52,800
ich hab Bock, ich bin bereit, 
das ist soweit ne neue Folge, es

14
00:00:52,800 --> 00:00:57,600
geht los ja neue Woche neues 
Glück ja genau so. 

15
00:00:58,640 --> 00:01:03,040
Nee, mir geht es gut, ich bin 
fit, wir sind ja quasi jetzt ins

16
00:01:03,040 --> 00:01:07,280
letzte Quartal des Jahres 
gestartet und schon wieder ne 

17
00:01:07,280 --> 00:01:11,120
mal gucken, was es noch so. 
Bereithält, war ja quasi gerade 

18
00:01:11,120 --> 00:01:15,080
erst Neujahr und so weiter und 
Frühlingsanfang ne, jetzt ist 

19
00:01:15,080 --> 00:01:17,640
schon wieder, es geht ja mal 
schnell ne ist ja mal. 

20
00:01:17,640 --> 00:01:20,080
Wir haben über den Sommer 
gesprochen, dass da mal viel los

21
00:01:20,080 --> 00:01:22,840
ist und jetzt ist auch schon 
wieder ja hör auf und jetzt 

22
00:01:22,840 --> 00:01:25,760
kommt die Zeit wo es wieder 
richtig schön. 

23
00:01:26,240 --> 00:01:29,480
Nicht so viel los ist, obwohl 
doch wieder wahrscheinlich viel 

24
00:01:29,480 --> 00:01:31,840
los ist. 
Ja, es wird wieder n bisschen 

25
00:01:31,840 --> 00:01:35,960
kälter, n bisschen ungemütlich 
das er wird uns ja jetzt alles 

26
00:01:35,960 --> 00:01:40,280
wieder zu erwarten, aber eine 
Sache die vor der Tür steht und 

27
00:01:40,280 --> 00:01:44,240
die richtig ein Lächeln ins 
Gesicht zaubert, ist natürlich 

28
00:01:44,560 --> 00:01:47,120
unser nächstes Turnier fabi. 
Ja, auf jeden Fall. 

29
00:01:47,200 --> 00:01:50,240
Der nächste 
Programmierturnierwettbewerb 

30
00:01:50,880 --> 00:01:54,200
steht in den Startlöchern, auf 
jeden Fall ganz genau, wie 

31
00:01:54,200 --> 00:01:56,000
gesagt. 
Stellt euch alle schon mal drauf

32
00:01:56,000 --> 00:01:59,520
ein, da gibt es wieder was zu 
gewinnen und es gibt auf jeden 

33
00:01:59,520 --> 00:02:03,360
Fall wieder ne richtig coole 
Turnier Action auf Twitch. 

34
00:02:03,360 --> 00:02:07,760
Dann am Ende und die Infos gibt 
es natürlich alle noch ne, also 

35
00:02:07,760 --> 00:02:10,000
da folgen auf jeden Fall Infos 
noch auf unserer Website, auf 

36
00:02:10,000 --> 00:02:13,520
Social Media ne, also jetzt 
nicht gleich völlig eskalieren 

37
00:02:13,520 --> 00:02:17,040
und sagen ich weiß auch gar 
nichts, ja noch gibt es noch 

38
00:02:17,040 --> 00:02:21,440
nicht so viel zu wissen, aber es
gibt natürlich immer mehr Infos,

39
00:02:21,440 --> 00:02:24,160
auf jeden Fall ne, also seid auf
jeden Fall gespannt und bereit. 

40
00:02:24,800 --> 00:02:27,040
Genau die Infos haben wir dann 
auf unsere Website und werden es

41
00:02:27,040 --> 00:02:29,440
natürlich über Social Media auch
verbreiten. 

42
00:02:29,760 --> 00:02:35,520
Aber ich sag mal so es es es 
steht sehr sehr nah vor der Tür.

43
00:02:35,520 --> 00:02:37,920
Ich bin schon richtig aufgeregt,
ich dachte es steht sehr viel 

44
00:02:37,920 --> 00:02:42,800
auf dem Spiel, dachte sowieso 
geht um Ruhm und Ehre. 

45
00:02:45,280 --> 00:02:48,000
Genau. 
Und natürlich Vergesst auch 

46
00:02:48,000 --> 00:02:50,520
nicht, unserem Podcast zu 
folgen, weil wir werden ja auch 

47
00:02:50,520 --> 00:02:53,040
im Podcast die nächsten Wochen 
über dieses Turnier sprechen. 

48
00:02:53,040 --> 00:02:56,880
Das heißt, folgt diesem Podcast,
verpasst keine Folge, aktiviert 

49
00:02:56,880 --> 00:03:01,120
auch gerne das Glöckchen und ich
denke, das sind so die, die 

50
00:03:01,120 --> 00:03:03,840
vorweg Sachen ja, bevor wir 
jetzt zum Thema kommen, die 

51
00:03:03,840 --> 00:03:08,920
haben wir jetzt mal abgehackt so
Check und du hast n cooles Thema

52
00:03:08,920 --> 00:03:12,200
mitgebracht, du hattest mir n. 
Artikel geschickt und dann 

53
00:03:12,200 --> 00:03:15,040
hatten wir mal so n bisschen 
drüber gebrainstormt, weil wir 

54
00:03:15,040 --> 00:03:16,880
den Inhalt ganz cool fanden, den
könnten wir ja auch mal 

55
00:03:16,880 --> 00:03:19,520
verlinken. 
Aber erzähl doch mal. 

56
00:03:19,520 --> 00:03:20,880
Worüber möchtest du heute 
sprechen? 

57
00:03:22,240 --> 00:03:25,440
Genau, also es geht pass auf. 
Ja, jetzt denkt man sich 

58
00:03:25,440 --> 00:03:30,760
vielleicht so, ha war ja klar ne
testen, es geht irgendwie ums 

59
00:03:30,880 --> 00:03:35,680
Testen, aber wenn man das ganze 
jetzt noch mal so n bisschen 

60
00:03:36,320 --> 00:03:38,400
sich mal durch den Kopf gehen 
lässt ne also wenn man jetzt zum

61
00:03:38,400 --> 00:03:40,920
Beispiel mal so. 
Es gibt ja so verschiedene 

62
00:03:40,920 --> 00:03:44,160
Aussagen, die man vielleicht so 
in Sachen testen hört. 

63
00:03:44,240 --> 00:03:49,120
Ja, also zum Beispiel sowas wie,
also absolut richtige Sprüche 

64
00:03:49,120 --> 00:03:51,920
wie zum Beispiel ne schreib n 
neuen Test. 

65
00:03:51,920 --> 00:03:54,960
Wenn du ne Änderung machst, ne 
find ich erstmal an sich klasse,

66
00:03:55,120 --> 00:03:56,400
ich weiß nicht wie siehst du 
das? 

67
00:03:56,800 --> 00:03:59,280
Also erstmal schreib n Test ist 
schon ne tolle Aussage schreib. 

68
00:03:59,280 --> 00:04:02,960
Test ist gut, schreib ne Test 
für Änderung noch besser so wenn

69
00:04:02,960 --> 00:04:05,920
Bug auftritt ne erstmal mit 
einem Test den Bug 

70
00:04:05,920 --> 00:04:10,040
reproduzieren. 
Ne, dann fixen auch total geil. 

71
00:04:10,160 --> 00:04:12,640
Ne auch ne tolle Aussage kann 
ich auch unterstützen. 

72
00:04:12,800 --> 00:04:15,840
Ne es gibt natürlich auch sowas 
wie keine Ahnung, scheiß auf 

73
00:04:15,840 --> 00:04:19,160
Test schreibt keine Tests Tests.
Schreibt, der ist nicht 

74
00:04:19,160 --> 00:04:21,120
überzeugt von seiner Arbeit und 
blablabla. 

75
00:04:22,000 --> 00:04:23,040
Das. 
Unterstützen wir dich? 

76
00:04:23,040 --> 00:04:26,280
Nein, aber ne, es gibt ja auf 
jeden Fall, aber was ist auf 

77
00:04:26,280 --> 00:04:29,000
jeden Fall was immer so ne Sache
ist und das ich glaub das hab 

78
00:04:29,000 --> 00:04:32,000
ich auch relativ also sagen wir 
mal ne Zeit lang so. 

79
00:04:32,640 --> 00:04:36,520
War das für mich so n Credo zu 
sagen, Lösch halt keine Tests ne

80
00:04:36,520 --> 00:04:39,680
also wenn du Tests hast ja und 
jemand sagt ja dann Lösch die 

81
00:04:39,680 --> 00:04:41,840
Tests, dann waren wir so hahaha 
ich bring dich um. 

82
00:04:45,920 --> 00:04:49,080
Ja, die waren immer so heilig. 
Ne, also so Testumgebung und 

83
00:04:49,080 --> 00:04:51,600
Tests sind heilig. 
Ne, du kannst ja auf gar keinen 

84
00:04:51,600 --> 00:04:57,280
Fall Test löschen und genau über
diesen Punkt möchte ich auch 

85
00:04:57,280 --> 00:05:00,960
gerne sehr sag ich mal. 
Ja, ist spitz mit dir drüber 

86
00:05:00,960 --> 00:05:04,320
diskutieren, ne, also ist das 
wirklich so oder ist das Quatsch

87
00:05:04,640 --> 00:05:06,320
und ich find das passt halt auch
ganz gut rein. 

88
00:05:06,320 --> 00:05:08,640
Wir haben ja letzte Woche 
darüber gesprochen was sind so 

89
00:05:08,640 --> 00:05:12,800
Skills die wir nicht hatten 
während des Studiums? 

90
00:05:12,800 --> 00:05:17,720
Ne das war ja so ne Community 
frage was für Skills sollte man 

91
00:05:17,720 --> 00:05:19,840
sich neben dem Studium aneignen,
die man dann so fürs 

92
00:05:19,840 --> 00:05:22,880
Arbeitsleben braucht und testen 
hatten wir da ja auch ganz groß 

93
00:05:22,880 --> 00:05:25,760
geschrieben und sind ja auch 
eine Woche später immer noch der

94
00:05:25,760 --> 00:05:27,120
Meinung also es hat sich nicht 
geändert. 

95
00:05:28,400 --> 00:05:31,040
Und deswegen passt das gut rein.
Aber man muss halt auch sagen, 

96
00:05:31,040 --> 00:05:33,440
Ja, testen ist nicht gleich 
testen und deswegen kommt dieses

97
00:05:33,440 --> 00:05:36,520
Thema heute sehr gelegen, dass 
man auch mal noch mal so n 

98
00:05:36,520 --> 00:05:40,160
bisschen challenged. 
Was sind die richtigen Tests, 

99
00:05:40,160 --> 00:05:43,680
welche Tests bringen einem 
vielleicht nichts oder eher 

100
00:05:44,240 --> 00:05:47,280
können sogar Schaden anrichten. 
Ja, also man kann es ja auch so 

101
00:05:47,280 --> 00:05:50,880
weit treiben, dass man sagt, OK 
warte mal, das schadet meinem 

102
00:05:50,880 --> 00:05:53,600
Projekt jetzt eher als dass es 
hilft. 

103
00:05:54,000 --> 00:05:56,760
Und wenn wir da so n bisschen 
den Bogen spannen und dann noch 

104
00:05:56,760 --> 00:05:59,360
so n paar Learnings mitnehmen 
könnten für uns und für dich 

105
00:05:59,360 --> 00:06:02,000
liebe ZUE, liebe ZUE, wär das 
natürlich mega ne. 

106
00:06:02,640 --> 00:06:04,400
Absolut ja. 
Ich find es auf jeden Fall gut, 

107
00:06:04,400 --> 00:06:07,000
dass du noch mal angesprochen 
hast von der letzten Podcast 

108
00:06:07,000 --> 00:06:11,280
Folge mit den Tests, weil 
irgendwann bin ich zum Beispiel 

109
00:06:11,280 --> 00:06:14,840
dahin gekommen, dass so Tests 
quasi einfach gesetzt waren. 

110
00:06:14,840 --> 00:06:17,000
Ne so nach dir, also es war dann
richtig so, das war so n 

111
00:06:17,000 --> 00:06:19,760
Jobwechsel ne bei mir und dann 
war so OK ab jetzt nur noch Test

112
00:06:19,760 --> 00:06:22,640
driven development ne und dann 
hat sich tatsächlich auch. 

113
00:06:23,040 --> 00:06:25,040
Das war ganz krass. 
Hab ich mich da irgendwie, das 

114
00:06:25,040 --> 00:06:27,240
war ich sag mal so im ersten 
Monat ne, hab ich mich mit 

115
00:06:27,240 --> 00:06:32,560
jemandem dann zusammengesetzt 
und software geschrieben und das

116
00:06:32,560 --> 00:06:35,680
war dann so richtig so. 
Ich weiß nicht, hab dann wollte 

117
00:06:35,680 --> 00:06:38,800
anfangen zu implementieren, die 
Funktion dann so AH da finden 

118
00:06:38,800 --> 00:06:42,720
des da finden des ich so oh 
Scheiße bleib Blog, da hast du 

119
00:06:42,720 --> 00:06:47,240
mich so dann gab es teilweise 
sowas wie irgendjemand guckt 

120
00:06:47,240 --> 00:06:50,160
sich n commit an ne oder guckt 
auf den Code er so hä wo ist 

121
00:06:50,160 --> 00:06:51,240
denn hier n Test? 
Hier ist kein Test. 

122
00:06:51,240 --> 00:06:53,360
Warum gibt es ja keinen Test 
dazu ist dann der hat geguckt 

123
00:06:53,360 --> 00:06:55,360
wer das committed hat ist da 
hingegangen hat gesagt EY hier 

124
00:06:55,360 --> 00:06:57,120
gibt es keinen Test, das können 
wir direkt nochmal löschen 

125
00:06:57,120 --> 00:07:00,400
nochmal neu schreiben ne also 
ohne Test wir haben wir machen 

126
00:07:00,400 --> 00:07:02,640
hier Test Driven Development und
da ist kein Test dazu also ne 

127
00:07:02,800 --> 00:07:04,280
dachte ich auch so OK alter 
krass. 

128
00:07:04,360 --> 00:07:08,240
Das bleibt mal locker ne so. 
Also man kann es halt auch. 

129
00:07:08,240 --> 00:07:13,080
Ich sag mal übertreiben, aber es
ist ja nicht komplett daneben 

130
00:07:13,080 --> 00:07:17,600
gegriffen würde ich sagen ne, 
weil Tests sind halt wichtig, 

131
00:07:17,600 --> 00:07:19,840
das wissen wir beide und das 
sagen wir auch immer ne. 

132
00:07:20,160 --> 00:07:23,120
Ja, und Testing Development ist 
ja auch ne Sache, für die wir 

133
00:07:23,120 --> 00:07:27,000
stehen, die wir auch selbst 
praktizieren. 

134
00:07:27,000 --> 00:07:31,600
Nennt man das Praktizieren also 
schon uns nach diesem Modell, 

135
00:07:31,600 --> 00:07:34,880
also nach dem Modell arbeiten? 
Aber es ist halt krass, denn zu 

136
00:07:34,880 --> 00:07:37,400
sagen, ja, hier kannst du alles 
wegschmeißen, weil der Test war 

137
00:07:37,400 --> 00:07:39,840
nicht vorher da. 
Und wenn du ihm hier Nachhinein 

138
00:07:39,840 --> 00:07:41,760
implementierst, dann schreibst 
du n Test für deine 

139
00:07:41,760 --> 00:07:43,480
Implementierung, aber nicht für 
deine Anforderungen. 

140
00:07:43,480 --> 00:07:45,760
So nach dem Motto, So würde ich 
das jetzt mal deuten, ne? 

141
00:07:45,840 --> 00:07:48,240
Das war auf jeden Fall, das ist 
schon extreme. 

142
00:07:49,280 --> 00:07:51,880
Also das war jetzt im Endeffekt 
genauso der, wie nennt man das 

143
00:07:51,880 --> 00:07:54,480
so, der Konsens, der dahinter 
gesteckt hat, so die Aussage ne,

144
00:07:54,720 --> 00:07:57,560
und das fand ich dann auch schon
n bisschen krass, ne also aber 

145
00:07:57,560 --> 00:08:00,000
trotzdem, das war du musst dir 
vorstellen, das war für mich so 

146
00:08:00,160 --> 00:08:02,720
die. 
Eben die Begegnung mit Test 

147
00:08:02,720 --> 00:08:06,080
Driven Development so n 
bisschen, wo ich mir so dachte. 

148
00:08:06,080 --> 00:08:09,920
Wow, wo bin ich denn hier 
reingeraten, aber es ist ja 

149
00:08:09,920 --> 00:08:12,880
nicht verkehrt ne, also an sich 
erstmal Test driven development 

150
00:08:12,880 --> 00:08:15,080
ist ne coole Sache, aber 
testschreiben an sich ist halt 

151
00:08:15,080 --> 00:08:18,520
auch wichtig ne und jetzt kann 
man sich natürlich fragen, OK 

152
00:08:18,520 --> 00:08:21,760
warum macht man das überhaupt ne
weil ne warum hat jetzt zum 

153
00:08:21,760 --> 00:08:24,400
Beispiel der eine Typ da so 
warum es der so eskaliert weil 

154
00:08:24,400 --> 00:08:27,920
es keine Tests gab so nach dem 
Motto und. 

155
00:08:28,320 --> 00:08:31,400
An sich, wenn man es jetzt kurz 
fasst, ist es natürlich erstmal 

156
00:08:31,400 --> 00:08:34,919
liegt auf der Hand ne, dass man 
gucken kann, ob die Software die

157
00:08:34,919 --> 00:08:38,080
man halt geschrieben hat oder 
schreibt halt auch so 

158
00:08:38,080 --> 00:08:41,720
funktioniert wie man es halt 
eben erwartet, ne oder wie man 

159
00:08:41,720 --> 00:08:45,600
es erwarten würde und ich find 
aber das reicht eigentlich noch 

160
00:08:45,600 --> 00:08:48,400
nicht so richtig aus um zu 
sagen. 

161
00:08:50,400 --> 00:08:52,600
Das ist jetzt Erklärung genug, 
weil rein theoretisch kannst du 

162
00:08:52,600 --> 00:08:54,480
ja sagen, OK, die Software ist 
da und du kannst es irgendwie 

163
00:08:54,480 --> 00:08:56,800
manuell testen, ne also. 
Genau. 

164
00:08:57,120 --> 00:08:59,560
Wir reden ja schon über 
automatisierte Tests, dann am 

165
00:08:59,560 --> 00:09:02,880
Ende ne. 
Ja, also der wichtigste Punkt 

166
00:09:02,880 --> 00:09:05,560
also, den man jetzt vielleicht 
so auf Erster auf den ersten 

167
00:09:05,560 --> 00:09:08,320
Blick nicht sieht, weil, wie du 
schon meintest, das erste, was 

168
00:09:08,320 --> 00:09:11,080
einem einfällt ist, ich teste, 
ob funktional alles so läuft, 

169
00:09:11,080 --> 00:09:13,920
wie ich mir das vorstelle. 
Jetzt kann ja jemand sagen, gut,

170
00:09:13,920 --> 00:09:15,920
die Software ist entwickelt, 
dann teste ich das manuell 

171
00:09:15,920 --> 00:09:18,240
durch, ich weiß es funktioniert 
und fertig. 

172
00:09:18,840 --> 00:09:23,200
Der viel entscheidendere Punkt, 
und das ist auch der Punkt, der 

173
00:09:23,200 --> 00:09:25,640
mich persönlich und ich denke, 
es geht dir da ähnlich, auch 

174
00:09:25,640 --> 00:09:30,160
immer zum Struggeln bringt, wenn
es heißt, wir wollen noch Sachen

175
00:09:30,160 --> 00:09:33,360
ändern, wir wollen Sachen 
umbauen, wir wollen vielleicht 

176
00:09:33,360 --> 00:09:37,280
neue Features hinzufügen, also 
quasi während der Zeit, wo sich 

177
00:09:37,280 --> 00:09:40,800
eine Software noch stark 
weiterentwickelt und ich mein 

178
00:09:40,800 --> 00:09:43,520
sie die wenigsten Projekte 
entwickeln sich nicht weiter, 

179
00:09:43,520 --> 00:09:46,320
also du hast immer diesen Moment
wo du sagst, ich änder mal was 

180
00:09:46,320 --> 00:09:49,640
ich refact da mal was. 
Und dann ist das mit dem 

181
00:09:49,640 --> 00:09:51,280
manuellen Testen halt so ne 
Sache. 

182
00:09:51,280 --> 00:09:53,120
Ne, weil du jetzt auch schon 
automatisierte Tests 

183
00:09:53,120 --> 00:09:55,640
angesprochen hast. 
Du kannst es nicht jedes Mal 

184
00:09:55,640 --> 00:09:59,120
wieder testen und das ist genau 
der Punkt wo die Tests dann so 

185
00:09:59,120 --> 00:10:02,560
und gerade die automatisierten 
Tests so wirklich glänzen. 

186
00:10:02,560 --> 00:10:07,040
Sie zeigen nicht nur, dass alles
funktioniert zu dem Zeitpunkt wo

187
00:10:07,040 --> 00:10:09,920
ich es geschrieben habe ne, also
ich implementier ein feature, 

188
00:10:09,920 --> 00:10:12,640
ich schreib n test es 
funktioniert, das kann ich auch 

189
00:10:12,640 --> 00:10:14,640
manuell machen zu sehen dass es 
funktioniert. 

190
00:10:15,000 --> 00:10:18,240
Viel wichtiger ist doch zu 
sehen, dass alles andere noch 

191
00:10:18,240 --> 00:10:20,640
funktioniert, was ich bisher 
gemacht hab. 

192
00:10:20,720 --> 00:10:24,920
Das alles im Zusammenspiel 
funktioniert, weil nichts ist 

193
00:10:24,920 --> 00:10:27,840
schlimmer als kein Vertrauen in 
deine Entwicklung, in deine 

194
00:10:27,840 --> 00:10:31,640
Software zu haben und das ist 
nämlich der große Punkt, den die

195
00:10:31,640 --> 00:10:35,440
Tester mit sich bringen, dass du
dein Vertrauen in deine 

196
00:10:35,440 --> 00:10:39,200
Entwicklung, in deine, in deinen
Code quasi erhöhst. 

197
00:10:39,720 --> 00:10:41,040
Ja, ich hab auch mal so. 
Übersichtlich. 

198
00:10:41,040 --> 00:10:42,320
Das ganze. 
Machst halt ne. 

199
00:10:42,440 --> 00:10:45,200
Ich hab mal so ne auch so ne 
krasse Story gehört da. 

200
00:10:45,200 --> 00:10:48,480
Das ist so n bisschen abseits 
von einer Softwareentwicklung 

201
00:10:48,480 --> 00:10:50,320
gewesen. 
Es war quasi so aus der Uni, 

202
00:10:50,320 --> 00:10:52,280
aber da wurde halt auch so n 
bisschen Software entwickelt, 

203
00:10:52,280 --> 00:10:55,120
aber jetzt nicht im Bereich 
Informatik oder so ne, sondern 

204
00:10:55,120 --> 00:10:58,440
es war quasi n anderer 
Fachbereich würd ich sagen ne 

205
00:10:58,440 --> 00:11:00,960
aber da war halt auch wurde halt
auch Software geschrieben so ne 

206
00:11:00,960 --> 00:11:03,680
ich nenn es jetzt mal n 
Hobbycoder der das gemacht hat 

207
00:11:04,480 --> 00:11:07,040
und mit der Person mit der ich 
mich unterhalten hatte die. 

208
00:11:07,520 --> 00:11:10,920
Hat er dann immer gefragt, ne, 
also das war so die Story ne so 

209
00:11:10,920 --> 00:11:13,960
nach dem Motto kannst du es mal 
testen und dann hat die Person 

210
00:11:13,960 --> 00:11:16,680
das getestet ne und dann immer 
manuell und dann gab es wieder 

211
00:11:16,680 --> 00:11:18,400
sowas wie ja ich hab ne neue 
Änderung gemacht. 

212
00:11:18,920 --> 00:11:21,440
Kannst du es mal wieder testen? 
Ja, ich kann es testen, ja klar,

213
00:11:21,440 --> 00:11:24,400
kein Problem, ja warte mal, aber
jetzt geht hier was nicht so 

214
00:11:24,400 --> 00:11:26,680
also das heißt es wurde quasi 
eine Seite der Software 

215
00:11:26,680 --> 00:11:29,760
angefasst und auf einer anderen 
Seite ging irgendwas nicht, ne? 

216
00:11:29,840 --> 00:11:31,880
Ja gut, das ist ja super 
klassisch, das ist ja jetzt 

217
00:11:31,880 --> 00:11:34,080
nicht so was. 
Wie kann denn das passieren, 

218
00:11:34,240 --> 00:11:37,600
sondern das ist die Realität, 
ja, jedes Daily Business. 

219
00:11:37,680 --> 00:11:40,880
Am Ende, und das krasse war, 
dass die Person, die das erzählt

220
00:11:40,880 --> 00:11:43,440
hat, auch immer dann so richtig 
so, also am Anfang war es ja 

221
00:11:43,440 --> 00:11:47,640
noch in Ordnung, ne so, aber 
dann testest du es das. 

222
00:11:47,640 --> 00:11:50,000
Dritte mal, das vierte Mal. 
Irgendwann bist du beim fünften 

223
00:11:50,000 --> 00:11:52,080
Mal und denkst dir so, warum 
muss ich denn, das dauert ja 

224
00:11:52,080 --> 00:11:55,200
auch alles und ich dacht mir so 
ja genau danke, dass du als 

225
00:11:55,200 --> 00:11:58,080
außenstehende Person in der 
Softwareentwicklung verstehst, 

226
00:11:58,080 --> 00:12:01,080
die so manuelle Tests halt nicht
ausreichend sind und blöd sind, 

227
00:12:01,080 --> 00:12:06,160
ne, aber weil du meintest ne. 
Man muss ja also ne manuelle 

228
00:12:06,160 --> 00:12:09,840
Testen, reicht nicht aus, 
automatisiert Vertrauen in die 

229
00:12:09,840 --> 00:12:11,720
Softwareentwicklung schaffen, 
sozusagen in die eigene 

230
00:12:11,720 --> 00:12:14,960
Software. 
Und ich weiß nicht, ob, also was

231
00:12:14,960 --> 00:12:16,920
heißt, ich weiß nicht. 
Also sicherlich hast du es auch 

232
00:12:16,920 --> 00:12:20,560
schon n paar mal gehabt so wenn 
du Software schreibst und keine 

233
00:12:20,560 --> 00:12:25,720
Tests hast und dir dann so 
denkst so OK, du hast irgendwann

234
00:12:25,720 --> 00:12:29,040
so n mulmiges Gefühl und denkst 
dir so OK ich schreib jetzt noch

235
00:12:29,040 --> 00:12:32,520
ne Zeile und noch ne Zeile und 
reitest dich quasi immer tiefer 

236
00:12:32,520 --> 00:12:34,640
in die Scheiße rein sag ich 
jetzt mal. 

237
00:12:35,360 --> 00:12:40,240
Weil du halt irgendwann dir 
denkst, OK, ich weiß jetzt nicht

238
00:12:40,240 --> 00:12:41,840
so richtig, ob das jetzt noch 
funktioniert. 

239
00:12:41,840 --> 00:12:44,640
Genau von diesem Beispiel auch 
ne so, du hast keine Tests, du 

240
00:12:44,640 --> 00:12:46,880
bist irgendwie angewiesen, dass 
du es dann vielleicht manuell 

241
00:12:46,880 --> 00:12:49,320
testest. 
Aber je länger so und dann n 

242
00:12:49,320 --> 00:12:53,760
Projekt dauert und je größer der
Code wird, desto mehr oder desto

243
00:12:53,760 --> 00:12:55,840
schlimmer wird es ja, dass man 
irgendwie. 

244
00:12:56,920 --> 00:13:00,000
Sich denkt verdammt, 
funktioniert das noch oder hab 

245
00:13:00,000 --> 00:13:02,960
ich irgendwas übersehen? 
Dann gibt es n bugreport oder 

246
00:13:02,960 --> 00:13:05,800
sowas ne irgendwie ne Bug 
Meldung den man dann irgendwie 

247
00:13:05,800 --> 00:13:09,280
in irgendeiner Hektik fixt oder 
irgendwie sowas ne und dann halt

248
00:13:09,600 --> 00:13:13,520
irgendwie wieder was übersieht 
oder so ne und ohne diese Tests.

249
00:13:13,680 --> 00:13:17,280
Also du hast ja die ganze Zeit 
im Hinterkopf ohne Tests Scheiße

250
00:13:17,280 --> 00:13:20,600
funktioniert das noch, 
hoffentlich hab ich jetzt nicht 

251
00:13:20,600 --> 00:13:22,880
irgendwas anderes kaputt gemacht
ne oder bei einer beim 

252
00:13:22,880 --> 00:13:26,240
Refactoring oder so und damit 
man genau dieses. 

253
00:13:26,840 --> 00:13:30,720
Dieses mulmige Gefühl am Ende 
sozusagen rausklammern kann ne, 

254
00:13:30,720 --> 00:13:33,840
dafür ist es ja wichtig, dass 
man eben diese Testzeit hat oder

255
00:13:33,840 --> 00:13:35,520
gerade diese automatisierten 
Tests. 

256
00:13:36,400 --> 00:13:39,960
Ja, also da ich find, das ist 
so, das fühlt sich halt so an, 

257
00:13:39,960 --> 00:13:42,640
als wenn man sich immer mehr 
selbst in die Ecke drängt und es

258
00:13:42,640 --> 00:13:45,440
gibt irgendwann keinen Ausweg 
mehr, ne je länger das Projekt 

259
00:13:45,440 --> 00:13:48,440
läuft, je größer es wird, kommst
du halt an einem Punkt, wo du 

260
00:13:48,440 --> 00:13:52,560
einfach nicht mehr weißt, wie 
der Stand der Software ist. 

261
00:13:52,720 --> 00:13:55,840
Also im Sinne von. 
Wie gut ist sie gerade, wie 

262
00:13:55,840 --> 00:14:00,320
stabil ist sie, funktioniert 
alles und ich mag das auch 

263
00:14:00,320 --> 00:14:03,040
mittlerweile so seit den letzten
Jahren halt überhaupt nicht, 

264
00:14:03,040 --> 00:14:06,480
wenn ich keine Tests hab, wenn 
ich nicht ne Testumgebung hab wo

265
00:14:06,480 --> 00:14:09,600
ich Sachen abtesten kann, weil 
das fühlt sich an wieso im 

266
00:14:09,600 --> 00:14:13,040
Dunklen tappen so ne also so 
wirklich als wenn du kein Licht 

267
00:14:13,040 --> 00:14:16,240
hast und du so mit der Hand 
vorweg denn irgendwie abtastest 

268
00:14:16,240 --> 00:14:18,360
und hoffst noch in die richtige 
Richtung zu laufen war n 

269
00:14:18,360 --> 00:14:21,440
bisschen überspitzt gesagt, aber
so kann sich das dann irgendwann

270
00:14:21,440 --> 00:14:24,560
anfühlen, weil du nicht weißt. 
Funktioniert noch alles 

271
00:14:25,760 --> 00:14:29,200
klassisch so refactoring? 
Ja, du refact das was und baust 

272
00:14:29,200 --> 00:14:32,400
irgendwo n Schnitzer ein, keine 
Ahnung, es ändern sich Eingabe 

273
00:14:32,720 --> 00:14:35,960
Parameter so von Funktion und du
hast es nicht angepasst. 

274
00:14:35,960 --> 00:14:38,560
Du gibst vielleicht noch n alten
Wert rein, gleicher Datentyp es 

275
00:14:38,560 --> 00:14:41,680
gibt keinen Fehler ne es läuft 
die Software startet es läuft 

276
00:14:41,680 --> 00:14:44,800
alles aber du rechnest jetzt mit
falschen Werten beispielsweise. 

277
00:14:45,040 --> 00:14:47,760
Ne so. 
Ja und würdest dann halt zum 

278
00:14:47,760 --> 00:14:50,280
Beispiel mit Test sehen können. 
Ey warte mal, das stimmt nicht, 

279
00:14:50,280 --> 00:14:52,080
was du mir da gibst. 
Das kann nicht sein 

280
00:14:52,080 --> 00:14:54,720
beispielsweise. 
Es ist ja auch nicht so, dass 

281
00:14:54,720 --> 00:14:57,600
man sagt, OK, pass auf, ich bin 
jetzt irgendwie, also wenn du 

282
00:14:57,600 --> 00:14:59,920
deinen eigenen, also deine 
eigene Software schreibst in 

283
00:14:59,920 --> 00:15:02,840
Anführungsstrichen, die du halt 
in und auswendig kennst, mag das

284
00:15:02,840 --> 00:15:06,640
noch mal das eine sein, aber 
komm mal irgendwie in. 

285
00:15:06,960 --> 00:15:10,320
Neues Projekt rein wo du den 
Code nicht kennst, wo es keine 

286
00:15:10,320 --> 00:15:13,240
Tests gibt, wo jemand sagt und 
jetzt implementier mal das und 

287
00:15:13,240 --> 00:15:17,040
das Bitte oder verändere diese 
Funktionalität dahingehend, dann

288
00:15:17,040 --> 00:15:19,760
hast du nämlich irgendwann n 
Problem, weil du dir denkst OK 

289
00:15:19,760 --> 00:15:23,840
pass auf, ich hab jetzt das 
implementiert, ich hoffe es ist 

290
00:15:23,840 --> 00:15:28,000
richtig ich hab keine Tests an 
denen ich das testen kann ne im 

291
00:15:28,000 --> 00:15:30,680
Optimalfall fängt man dann 
einfach an für sich selbst 

292
00:15:30,680 --> 00:15:32,880
einfach n Testframework zu 
nehmen und Tests zu schreiben, 

293
00:15:33,040 --> 00:15:34,400
aber angenommen du machst es 
nicht. 

294
00:15:35,000 --> 00:15:36,720
So wo, wo fängst du an zu 
testen? 

295
00:15:36,720 --> 00:15:40,800
Ne, also du musst es ja 
irgendwie verifizieren und 

296
00:15:40,800 --> 00:15:44,600
angenommen du willst irgendwie 
keine Ahnung was irgendwas mit 

297
00:15:44,600 --> 00:15:47,600
dieser Software erreichen, was 
vielleicht irgendwie ne gewisse 

298
00:15:47,680 --> 00:15:50,800
kritische Sache hat, dann kannst
du es ja nicht einfach so. 

299
00:15:50,800 --> 00:15:52,600
Ja ich probier es mal. 
Ach ist schief gegangen, 

300
00:15:52,600 --> 00:15:55,360
funktioniert ja wohl noch nicht 
richtig, die Software also ach 

301
00:15:55,360 --> 00:15:59,680
so übrigens ist kaputt, sorry es
war wichtig oder blöd so weißt 

302
00:15:59,680 --> 00:16:02,240
du, das ist halt kannst du ja 
dann auch nicht machen. 

303
00:16:02,960 --> 00:16:06,400
Und das ist halt das Problem. 
Solche Sachen passieren halt 

304
00:16:06,400 --> 00:16:07,600
einfach. 
Ich meine, das ist ein recht 

305
00:16:07,600 --> 00:16:10,480
aktuelles Beispiel, wir haben ja
jetzt für das Turnier, was wir 

306
00:16:10,480 --> 00:16:13,880
angesprochen haben, wieder ein 
Minigame geschrieben, das ist ja

307
00:16:13,880 --> 00:16:16,640
quasi unser 4. 
Gewinnt Turnier in einer 

308
00:16:16,640 --> 00:16:20,680
Neuauflage, Wir haben was 
gelernt, 4 gewinnt Extreme und 

309
00:16:20,680 --> 00:16:23,480
das Ganze haben wir ja mit Go do
entwickelt, das ist auch 

310
00:16:23,480 --> 00:16:26,720
wirklich ein Cooles, eine coole 
Engine, so ein cooles Framework 

311
00:16:27,280 --> 00:16:31,360
und wir. 
Wir haben aber diese Minigames, 

312
00:16:31,360 --> 00:16:33,440
die sind ja wirklich nicht sehr 
umfangreich, ne. 

313
00:16:33,760 --> 00:16:36,440
Und trotzdem, wenn wir Sachen 
Refactern und wir haben da 

314
00:16:36,440 --> 00:16:39,760
aktuell keine Tests, dann hatten
wir halt auch den Fall, dass wir

315
00:16:39,760 --> 00:16:41,720
zum Beispiel was nicht richtig 
refacterd haben, nicht 

316
00:16:41,720 --> 00:16:43,960
vollständig, dass wir nicht 
gesehen haben, paar Sachen gehen

317
00:16:43,960 --> 00:16:46,200
nicht und beim Spielen merken 
wir so auf einmal, Hey, warte 

318
00:16:46,200 --> 00:16:48,960
mal dieses eine Feature, das das
sieht irgendwie buggy aus was da

319
00:16:48,960 --> 00:16:51,240
los. 
Nachgeguckt haben es gefunden 

320
00:16:51,240 --> 00:16:54,040
Guthaben wir gefixt, richtig, 
aber es muss ja gar nicht erst 

321
00:16:54,040 --> 00:16:56,000
so weit kommen. 
Deswegen war unser erster 

322
00:16:56,000 --> 00:16:58,960
Gedanke, ey, nee, wir müssen 
jetzt gucken, unterstützt Godo 

323
00:16:58,960 --> 00:17:01,320
zum Beispiel so N Unit Test 
Framework ja wir brauchen Unit 

324
00:17:01,320 --> 00:17:04,560
Tests für so ne Funktion, bestes
Beispiel es passiert ja auch bei

325
00:17:04,560 --> 00:17:07,920
kleinen Projekten schon, ja 
genau, also das ist ja wirklich 

326
00:17:07,920 --> 00:17:11,520
nicht zu vernachlässigen, ne und
seit dem Moment wo das passiert 

327
00:17:11,520 --> 00:17:15,119
ist war beim Code wieder so oh 
mein Gott. 

328
00:17:16,240 --> 00:17:19,280
Jetzt aufpassen, jetzt jeden 
Schritt überwachen. 

329
00:17:19,319 --> 00:17:22,000
Hier, so weißt also weil. 
Halt deine Zuversicht, dein 

330
00:17:22,000 --> 00:17:24,800
Vertrauen massiv sinkt dann. 
Richtig. 

331
00:17:24,960 --> 00:17:28,440
Und da dafür, dass dieses 
Vertrauen steigt, gibt es halt 

332
00:17:28,440 --> 00:17:30,040
eben die Tests. 
Ne, damit wir jetzt noch mal so 

333
00:17:30,040 --> 00:17:33,000
n bisschen auch weiter kommen, 
nur das Problem ist, dass es 

334
00:17:33,000 --> 00:17:37,760
halt auch dazu kommen kann, dass
selbst wenn du Tests hast, dass 

335
00:17:37,760 --> 00:17:40,120
sozusagen das Vertrauen 
gemindert werden kann, ne, also 

336
00:17:40,120 --> 00:17:43,080
angenommen du hast Tests für 
deine Software, die sind da, die

337
00:17:43,080 --> 00:17:45,880
laufen so ne. 
Mehr oder weniger. 

338
00:17:45,880 --> 00:17:47,920
Aber du hast halt welche, die du
laufen lassen kannst. 

339
00:17:47,920 --> 00:17:53,480
So nach dem Motto Ne und es ist 
halt auch möglich zu sagen, OK, 

340
00:17:53,480 --> 00:17:57,440
du hast diese Tests in deiner 
Software drin, die dir helfen 

341
00:17:57,440 --> 00:18:01,760
sollen und trotzdem sorgen diese
Tests dafür, dass du beim 

342
00:18:01,760 --> 00:18:03,360
entwickeln dich nicht mehr 
sicher fühlst. 

343
00:18:03,360 --> 00:18:05,600
Fühlst. 
So und dann ist halt immer die, 

344
00:18:05,600 --> 00:18:07,760
also dann ist halt die Frage so 
OK. 

345
00:18:08,720 --> 00:18:10,880
Wie geht denn das überhaupt? 
Weißt du also, man kann sich 

346
00:18:10,880 --> 00:18:12,960
jetzt hinstellen und sagen, Hey,
ihr habt doch gerade gesagt, OK,

347
00:18:13,280 --> 00:18:16,440
Tests sind super wichtig, Tests 
schaffen das Vertrauen in die 

348
00:18:16,440 --> 00:18:18,920
Softwareentwicklung, dass der 
Code halt richtig läuft und so 

349
00:18:18,920 --> 00:18:21,480
weiter und jetzt wollt ihr mir 
im nächsten Schritt wiederum 

350
00:18:21,480 --> 00:18:24,000
erklären, dass aber wenn du 
Tests hast, die das Vertrauen 

351
00:18:24,000 --> 00:18:28,080
wiederum mindern oder mindern 
können, ne ja, und das ist ja 

352
00:18:28,080 --> 00:18:30,960
jetzt eigentlich genau der 
Knackpunkt der Folge, dann am 

353
00:18:30,960 --> 00:18:34,160
Ende. 
Genau, und das ist jetzt so wie 

354
00:18:34,160 --> 00:18:37,360
du sagst, der Knackpunkt, weil. 
Nicht jeder Test ist n guter 

355
00:18:37,360 --> 00:18:38,760
Test und nicht jeder Test hilft 
dir. 

356
00:18:38,760 --> 00:18:42,640
Also einfach nur Tests schreiben
und selbst wenn sie, also ich 

357
00:18:42,640 --> 00:18:45,400
mein jetzt nicht Test die nichts
testen, ja sowas hab ich auch 

358
00:18:45,400 --> 00:18:48,840
schon oft gesehen wo du denkst 
OK und was testet der Test jetzt

359
00:18:48,840 --> 00:18:51,200
ab? 
Na ja das und das Na ja gut das 

360
00:18:51,440 --> 00:18:53,760
bringt aber der Software keinen 
Mehrwert also du hast eigentlich

361
00:18:53,760 --> 00:18:56,800
nichts geprüft, so wirklich ja 
gibt es auch nee wir reden schon

362
00:18:56,800 --> 00:19:00,000
von Tests die n Sinn haben und 
die auch Funktionalitäten 

363
00:19:00,320 --> 00:19:05,440
abtesten aber. 
Das bedeutet nicht zwangsläufig,

364
00:19:05,440 --> 00:19:08,600
dass es dir hilft, weil bestes 
Beispiel haben wir auch schon n 

365
00:19:08,600 --> 00:19:13,840
paar mal diskutiert, sind flaky 
Tests und das klingt immer so. 

366
00:19:13,840 --> 00:19:16,080
Ja hä nee warte mal. 
Wenn ich jetzt gerade wenn ich 

367
00:19:16,080 --> 00:19:19,040
so einfache Tests schreibe, 
naja, die sind schon sehr 

368
00:19:19,360 --> 00:19:22,240
deterministisch in dem Sinne, 
dass sie immer grün sind oder 

369
00:19:22,240 --> 00:19:25,440
immer rot. 
Ja, und flaky Test bedeutet ja, 

370
00:19:26,160 --> 00:19:29,600
dass er ab und zu auch mal den 
anderen Zustand einnimmt. 

371
00:19:29,600 --> 00:19:32,880
Ja, also beispielsweise er läuft
10 mal grün und dann einmal rot 

372
00:19:33,080 --> 00:19:35,920
ist der bessere Fall 10, mal 
rot, einmal grün wäre natürlich 

373
00:19:35,920 --> 00:19:37,880
noch schlimmer, ne, also dann 
wirst du wahrscheinlich gar 

374
00:19:37,880 --> 00:19:40,640
nicht erst in die Bredouille 
kommen, die wir jetzt erklären, 

375
00:19:40,640 --> 00:19:42,920
was n flaky Test mit sich 
bringt, ne weil wenn er jetzt 

376
00:19:42,920 --> 00:19:45,960
sag ich mal sehr oft rot ist, 
wirst du es ja schnell merken 

377
00:19:45,960 --> 00:19:49,200
oder nicht akzeptieren können 
das Verhalten Problem ist ja 

378
00:19:49,200 --> 00:19:54,800
eher wenn er nur ganz selten. 
Mal Rot läuft ja und magst du 

379
00:19:54,800 --> 00:19:57,600
das Mal erklären? 
Also was was stört dabei so 

380
00:19:57,600 --> 00:20:00,000
extrem? 
Also ich kann auf jeden Fall mal

381
00:20:00,000 --> 00:20:02,000
n Beispiel bringen von dem was 
ich erlebt hab. 

382
00:20:02,000 --> 00:20:04,480
Zum Beispiel mal. 
Also wir hatten auch, ich weiß 

383
00:20:04,480 --> 00:20:08,160
nicht, es war glaub ich n so n 
Backend mit irgendwelchen API 

384
00:20:08,160 --> 00:20:11,160
calls also wir hatten da ne API 
dran an diesem Backend ne so ne 

385
00:20:11,160 --> 00:20:15,960
API Schnittstelle oder warte API
Schnittstelle Entschuldigung ich

386
00:20:15,960 --> 00:20:17,680
wollt gerade sagen. 
Ey, mein Auge zuckt schon. 

387
00:20:19,440 --> 00:20:23,440
Abi Triggert ja n bisschen. 
Auf jeden Fall gab es dann da 

388
00:20:23,440 --> 00:20:27,080
halt eben auch Tests und wir 
haben dann einfach ne gab 

389
00:20:27,080 --> 00:20:30,440
irgendwie neue Funktionalität, 
so das typische ne du schreibst 

390
00:20:30,440 --> 00:20:32,920
dann Test damit du weißt OK die 
Funktionalität funktioniert auch

391
00:20:32,920 --> 00:20:35,360
so wie man sich das eben 
vorstellt und so weiter so und 

392
00:20:35,360 --> 00:20:38,320
dann haben wir halt eben ne 
diesen Test laufen lassen haben 

393
00:20:38,400 --> 00:20:40,240
der war rot, wir haben 
implementiert, der war 

394
00:20:40,240 --> 00:20:41,680
vielleicht immer noch rot weil 
wir es noch nicht richtig 

395
00:20:41,680 --> 00:20:44,320
implementiert haben, irgendwann 
war er dann halt eben grün so 

396
00:20:44,800 --> 00:20:49,280
dann war cool wir so OK weiter. 
Nächsten Endpunkt ne haben wir 

397
00:20:49,280 --> 00:20:51,680
nächsten Endpunkt aufgebaut, 
auch wieder Test dazu und so 

398
00:20:51,680 --> 00:20:54,920
weiter lief auch wieder grün so 
das haben wir quasi für einen 

399
00:20:54,920 --> 00:20:56,760
ganzen Controller gemacht. 
Ne also n Controller mit 

400
00:20:56,760 --> 00:20:59,440
mehreren Endpunkten, zum 
Beispiel Get was auch immer ne 

401
00:21:00,320 --> 00:21:03,840
so und dann haben wir irgendwann
gesagt ja alles klar cool, das 

402
00:21:03,840 --> 00:21:06,120
lief ja mal. 
Alle Tests waren Grün komm jetzt

403
00:21:06,120 --> 00:21:08,040
können wir Committen und pushen 
lassen noch mal alle Tests 

404
00:21:08,040 --> 00:21:11,680
laufen, wir alle Tests laufen 
lassen Test war rot wir so hä OK

405
00:21:12,080 --> 00:21:13,840
also. 
Keine Ahnung, wir hatten da, 

406
00:21:13,840 --> 00:21:16,360
sagen wir mal 1000 Unit Tests so
nach dem Motto Ne ich spinne 

407
00:21:16,360 --> 00:21:19,600
jetzt spinne jetzt einfach mal 
ne Zahl zurecht und dann war 

408
00:21:19,600 --> 00:21:23,440
halt einfach so ein Test oder 2 
Tests waren rot ich so hä wieso 

409
00:21:23,440 --> 00:21:25,120
waren sie? 
Wir sind jetzt 2 Tests rot haben

410
00:21:25,120 --> 00:21:27,840
wir OK warte wir haben bestimmt 
irgendwas kaputt gemacht krass 

411
00:21:28,080 --> 00:21:29,880
dann haben wir vielleicht 
irgendwo haben wir irgendwo ne 

412
00:21:29,880 --> 00:21:32,520
Funktion angefasst aus einem aus
einem Service der schon irgendwo

413
00:21:32,520 --> 00:21:34,920
verwendet wird und deswegen weil
wir den verändert haben ist n 

414
00:21:34,920 --> 00:21:37,280
anderer Test rot geworden 
irgendwie sowas ne keine Ahnung.

415
00:21:38,200 --> 00:21:40,640
War aber nicht der Fall, sondern
wir haben gemerkt, OK, warte mal

416
00:21:40,640 --> 00:21:43,840
den einen Test den wir gerade 
geschrieben haben vor einer 

417
00:21:43,840 --> 00:21:46,240
halben Stunde, der ist jetzt 
wieder rot. 

418
00:21:47,040 --> 00:21:49,760
OK, den lassen wir noch mal 
laufen, der ist grün, denkst dir

419
00:21:49,760 --> 00:21:52,120
so hä was zur Hölle passiert 
hier gerade und dann kannst du 

420
00:21:52,120 --> 00:21:54,440
zum Beispiel auch so, ich nenn 
es jetzt mal Tricks anwenden und

421
00:21:54,440 --> 00:21:57,600
sagen OK ich nehm mir jetzt das 
sind so annotations, dass du 

422
00:21:57,600 --> 00:22:00,000
sagst oder ne es gibt dann 
verschiedene Frameworks, dass du

423
00:22:00,000 --> 00:22:02,960
sagst lass den Test einfach mal 
1000 mal laufen und dann hast du

424
00:22:02,960 --> 00:22:05,280
gemerkt, wenn du den Test 1000 
mal laufen lässt. 

425
00:22:05,560 --> 00:22:08,480
Wird er halt so. 
Keine Ahnung. 5 mal rot oder so 

426
00:22:08,480 --> 00:22:11,960
ne von 1000 malen, das ist genau
der Punkt den du ja meintest wo 

427
00:22:11,960 --> 00:22:14,680
du denkst. 
Was zur Hölle ist hier gerade 

428
00:22:14,680 --> 00:22:16,480
los, was passiert hier gerade 
ne? 

429
00:22:17,400 --> 00:22:20,320
Das können ja verschiedenste. 
Es kann ja verschiedenste 

430
00:22:20,320 --> 00:22:23,920
Auswirkungen haben, wie zum 
Beispiel du hast irgendwo hatten

431
00:22:23,920 --> 00:22:26,000
wir schon mal drüber geredet, 
irgendwie n Singleton, der sich 

432
00:22:26,000 --> 00:22:28,800
aufbaut, der quasi als einzelner
Test, wenn du ihn laufen lässt, 

433
00:22:28,800 --> 00:22:31,680
gibt es nur dieses eine Single 
Objekt, was dann quasi auch nur 

434
00:22:31,760 --> 00:22:34,000
dementsprechend mit den Daten 
befüllt wird, die du gerade 

435
00:22:34,000 --> 00:22:36,560
haben möchtest. 
Oder du hast n timingverhalten 

436
00:22:36,560 --> 00:22:39,600
oder irgendwie sowas wie 
irgendein Emitter. 

437
00:22:39,600 --> 00:22:42,880
Weißt du wo du so ne so so 
Signale sendest die du dann. 

438
00:22:43,240 --> 00:22:46,000
Dem anderen Test quasi schon 
bekommst und dann irgendwie 

439
00:22:46,000 --> 00:22:49,200
drauf reagierst oder so richtig 
klassische Side Effects dann 

440
00:22:49,200 --> 00:22:52,560
über die Tests genau genau, Side
Effects ist eigentlich n guter 

441
00:22:53,280 --> 00:22:57,280
gutes Stichwort ne, aber so was 
kommt dann dazu, dass deine 

442
00:22:57,280 --> 00:23:01,200
Tests halt eben flaky werden und
das bedeutet ja, dass du dann in

443
00:23:01,200 --> 00:23:04,560
diesem Moment schon dir denkst, 
scheiße, was hab ich denn jetzt 

444
00:23:04,560 --> 00:23:07,280
gerade implementiert? 
Also du du, du kriegst ja direkt

445
00:23:07,280 --> 00:23:09,120
erstmal. 
Du bist ja zuversichtlich, dein 

446
00:23:09,120 --> 00:23:11,760
Test sind Grün, auf einmal wird 
der Test rot und du denkst dir 

447
00:23:11,760 --> 00:23:15,040
so. 
Moment, und dann kann es ja noch

448
00:23:15,040 --> 00:23:18,040
so weit gehen, dass du dir 
denkst, warte mal ganz kurz, wir

449
00:23:18,040 --> 00:23:20,960
haben die anderen Tests ja 
genauso geschrieben, also 

450
00:23:20,960 --> 00:23:23,600
vielleicht sind die auch 
irgendwie flaky, wer weiß das 

451
00:23:23,600 --> 00:23:25,840
schon, also weißt du, und dann 
fragst du dich, im nächsten 

452
00:23:25,840 --> 00:23:29,200
Schritt ist meine Software 
eigentlich überhaupt richtig 

453
00:23:29,200 --> 00:23:31,760
oder nicht so? 
Weil wenn du deine Tests hast, 

454
00:23:31,760 --> 00:23:34,720
die dir sagen es ist gerade rot,
dann ist es halt. 

455
00:23:35,160 --> 00:23:38,080
Dann dann hinterfragst du halt 
auf einmal so viel, was dein 

456
00:23:38,080 --> 00:23:41,120
Code vielleicht irgendwie macht.
Ne, also es könnte ja sein, dass

457
00:23:41,120 --> 00:23:43,720
du sagst, wenn der Test wirklich
vielleicht manchmal rot ist. 

458
00:23:43,720 --> 00:23:45,920
Vielleicht ist meine 
Implementierung auch manchmal 

459
00:23:45,920 --> 00:23:50,880
falsch oder du sagst sowas wie 
ja gut, ey, dann weißt du, es 

460
00:23:50,880 --> 00:23:52,880
kommt zum Beispiel einer an und 
sagt, Nee, Pass auf, gar kein 

461
00:23:52,880 --> 00:23:56,160
Problem, dieser Test, der ist 
schon seit Monaten flaky mach 

462
00:23:56,160 --> 00:23:59,080
dir darüber keine Sorgen, laufen
ja lass einfach noch mal laufen,

463
00:23:59,080 --> 00:24:02,120
mach dir keine Sorgen, die 
Implementierung, die passt 

464
00:24:02,120 --> 00:24:04,320
schon. 
So, und dann kommst du an einem 

465
00:24:04,320 --> 00:24:08,080
Punkt, der halt irgendwie ein 
bisschen ungeil wird, ne? 

466
00:24:08,880 --> 00:24:12,480
Na ja gut, du hast halt das 
Problem, dass du ein falsches 

467
00:24:12,480 --> 00:24:16,320
Vertrauen aufbaust in dem 
Moment, beziehungsweise es ist 

468
00:24:16,320 --> 00:24:19,000
begründet das Vertrauen in dem 
Moment, weil du weißt, es ist 

469
00:24:19,000 --> 00:24:21,080
richtig implementiert. 
Das ist vielleicht jetzt 

470
00:24:21,080 --> 00:24:23,720
irgendwie in der Testumgebung 
ne, dass du so Side Effects 

471
00:24:23,720 --> 00:24:26,160
hast, dass es wirklich nicht an 
deinem Code liegt. 

472
00:24:26,160 --> 00:24:29,520
Kann ja sein, dass. 
Sondern dass deine Testumgebung 

473
00:24:29,520 --> 00:24:32,960
ne Convicard Side Effects hat 
und dann das einfach nicht 

474
00:24:32,960 --> 00:24:36,160
richtig sag ich mal einen von 
100 Fällen oder was du vorhin 

475
00:24:36,160 --> 00:24:40,640
meintest nicht läuft. 
So natürlich ist es naheliegend 

476
00:24:40,640 --> 00:24:42,800
zu sagen, Nee komm, wir haben 
jetzt Projektor, wir haben keine

477
00:24:42,800 --> 00:24:45,520
Zeit so der läuft das ist 
richtig ne wir haben es manuell 

478
00:24:45,520 --> 00:24:48,680
getestet, die Tests fällen ja 
nur keine Ahnung wenn ne ein 

479
00:24:48,680 --> 00:24:50,240
Prozent Wahrscheinlichkeit oder 
so. 

480
00:24:50,920 --> 00:24:53,680
Lass einfach noch mal laufen, 
das kann so weit gehen, wie die 

481
00:24:53,680 --> 00:24:56,600
Pipeline rot komm schnell, 
Trigger noch mal, das läuft beim

482
00:24:56,600 --> 00:24:58,480
nächsten Mal durch, ist 
durchgelaufen alles gut. 

483
00:24:58,800 --> 00:25:04,800
Das Problem ist, dass du darauf 
jetzt vertrauen aufbaust und es 

484
00:25:04,800 --> 00:25:07,680
ja aber sein kann, wenn du 
Änderungen einspielst. 

485
00:25:07,680 --> 00:25:10,960
Ne das sagst ich änder n feature
ab oder ich bau n neues ein. 

486
00:25:11,600 --> 00:25:15,040
Und vielleicht an anderen 
stellen Tests rot werden oder 

487
00:25:15,040 --> 00:25:18,280
der Test jetzt rot ist, der 
sonst flaky ist. 

488
00:25:18,280 --> 00:25:20,880
Und du sagst ach na ja gut, das 
ist der Flaky Test Come on noch 

489
00:25:20,880 --> 00:25:25,760
mal. 
Also was garantiert dir und das 

490
00:25:25,760 --> 00:25:28,720
ist jetzt der Knackpunkt dabei, 
was garantiert dir, dass es 

491
00:25:28,720 --> 00:25:32,760
immer noch ne Condition ist, die
dazu führt, dass der Flaky ist 

492
00:25:32,760 --> 00:25:36,000
ne, dass halt irgendwelche Side 
effects da sind oder vielleicht 

493
00:25:36,000 --> 00:25:39,440
jetzt doch was kaputt ist? 
Jetzt hast du dieses falsche 

494
00:25:39,440 --> 00:25:42,000
Vertrauen zu sagen. 
Ach flaky ja sowieso ne Ausrede.

495
00:25:42,000 --> 00:25:44,320
Komm Lars, Wir haben keine Zeit,
der ist Flaky der läuft wieder, 

496
00:25:44,880 --> 00:25:47,440
aber was wenn nicht was wenn da 
jetzt auf einmal wirklich 

497
00:25:47,440 --> 00:25:50,200
irgendwas kaputt gegangen ist? 
Ja, zum Beispiel ist halt nicht 

498
00:25:50,200 --> 00:25:52,400
das große Problem, weil dann 
hast du nämlich vielleicht 

499
00:25:52,400 --> 00:25:54,480
irgendwann, denkst du dir so, 
warte mal da in dem Test. 

500
00:25:54,480 --> 00:25:56,680
Das war auch Flaky, da haben wir
auch mit irgendwelchen Signalen 

501
00:25:56,680 --> 00:25:59,440
rumgespielt, dann wird das hier 
ja auch so sein, aber wenn du 

502
00:25:59,440 --> 00:26:01,920
dann vielleicht wirklich das 
echte Verhalten hast, dass zum 

503
00:26:01,920 --> 00:26:04,320
Beispiel Signale richtig 
gefeuert werden in deinem Code, 

504
00:26:04,640 --> 00:26:07,720
aber manchmal eben falsch, und 
deswegen ist der Test nicht 

505
00:26:07,720 --> 00:26:08,880
flaky. 
Sondern korrekt. 

506
00:26:08,880 --> 00:26:12,000
Falsch so nach dem Motto, dann 
hast du halt irgendwann n 

507
00:26:12,000 --> 00:26:15,120
Problem und es kann zum Beispiel
auch dazu führen, dass du sagst,

508
00:26:15,280 --> 00:26:17,520
OK, pass auf, aber was ist denn 
die Auswirkung? 

509
00:26:17,520 --> 00:26:20,560
Ja OK, dann ist der Test flaky 
fix ihn halt erstmal kann man 

510
00:26:20,560 --> 00:26:24,960
dazu sagen Flaky Test kann schon
echt lange dauern bis man ihn 

511
00:26:25,120 --> 00:26:27,880
eventuell gefixt bekommt, also 
bin ich. 

512
00:26:27,920 --> 00:26:29,800
Fertig. 
Und deswegen versuchen ja auch 

513
00:26:29,800 --> 00:26:32,160
viele, dem aus dem Weg zu gehen.
Genau so. 

514
00:26:32,240 --> 00:26:38,120
Und dann sagt man aber OK. 
Ich also, die nehmen wir mal die

515
00:26:38,120 --> 00:26:40,640
Situation an, man geht dem aus 
dem Weg und lässt diesen flagy 

516
00:26:40,640 --> 00:26:43,760
Test drin, ne weil wir dabei 
sind und sagen Lösch deine 

517
00:26:43,760 --> 00:26:47,680
Tests, du lässt den drin, die 
Pipeline läuft, vielleicht hast 

518
00:26:47,680 --> 00:26:49,920
du ne Pipeline die dauert ne 
Stunde und dann irgendwann ist 

519
00:26:49,920 --> 00:26:53,800
auf einmal nach 40 Minuten 
Wartezeit auf einmal merkst du 

520
00:26:53,800 --> 00:26:57,280
oh die Pipeline ist rot ja ist n
flagy Test lass noch mal laufen 

521
00:26:57,360 --> 00:27:00,400
so dann lässt du es wieder 
laufen, es heißt grün und dann 

522
00:27:00,400 --> 00:27:02,960
kann es deployed werden also es 
ist Zeit es ist Geld. 

523
00:27:03,880 --> 00:27:06,640
Und im Endeffekt kannst du dann 
auch einfach sagen, OK, pass 

524
00:27:06,640 --> 00:27:09,840
auf, Lösch einfach den Test weg,
wenn dein, wenn dein dein Test 

525
00:27:09,840 --> 00:27:12,160
wirklich so flaky ist und du 
keine Zeit hast dich darum zu 

526
00:27:12,160 --> 00:27:15,160
kümmern, dann lösch den halt weg
und wenn man sich jetzt 

527
00:27:15,160 --> 00:27:18,200
hinstellt und sagt Na ja gut, 
aber ey ganz ehrlich, es könnte 

528
00:27:18,200 --> 00:27:20,840
ja sein, dass der Test 
irgendwann mal wirklich n echten

529
00:27:20,840 --> 00:27:25,440
Fehler abfängt, dann kann man 
auch sagen, OK dann wenn der 

530
00:27:25,440 --> 00:27:28,080
Fehler wirklich auftritt, den du
irgendwie vielleicht 

531
00:27:28,080 --> 00:27:30,000
möglicherweise gerade 
befürchtest. 

532
00:27:30,160 --> 00:27:31,840
Und vielleicht ist es auch nur 
so n. 

533
00:27:33,080 --> 00:27:36,080
Du hast gar keine Idee was für n
Fehler auftreten könnte, dass 

534
00:27:36,080 --> 00:27:41,480
dieser Test vielleicht wirklich 
wichtig wäre, aber wenn, selbst 

535
00:27:41,480 --> 00:27:45,200
wenn das Auftritt dann keine 
Ahnung implementier n Test 

536
00:27:45,600 --> 00:27:49,000
implementier die Funktionalität 
dazu und zwar etwas was halt 

537
00:27:49,000 --> 00:27:51,920
nicht flake ist, aber vorher zu 
diesem Zeitpunkt, wenn es also 

538
00:27:51,920 --> 00:27:54,840
wenn es soweit ist, aber zu dem 
Zeitpunkt Lösch einfach den Test

539
00:27:54,840 --> 00:27:58,640
weg, weißt du? 
Ja und? 

540
00:27:59,960 --> 00:28:03,760
Noch mal, um das Ganze zu 
motivieren, warum man also warum

541
00:28:03,760 --> 00:28:05,520
soll ich den nicht löschen? 
Ich kann den fixen, weil du 

542
00:28:05,520 --> 00:28:08,680
meintest ja das kann sehr 
umfangreich sein, da muss man 

543
00:28:08,680 --> 00:28:11,120
sich ja nur vorstellen, 
angenommen ich hab ne 

544
00:28:11,120 --> 00:28:15,520
Testumgebung und zum Beispiel 
was du meinst bei den Controller

545
00:28:15,520 --> 00:28:18,480
und ich hab jetzt ne gewisse Art
mir überlegt wie ich das testen 

546
00:28:18,480 --> 00:28:21,080
kann mit den Signalen mit den 
Calls wie auch immer ne. 

547
00:28:21,960 --> 00:28:24,640
Jetzt stell dir vor, der Test 
ist Flaky so, das sind so die 

548
00:28:24,640 --> 00:28:27,120
ersten, bei den anderen ist es 
noch nicht aufgefallen, aber du 

549
00:28:27,120 --> 00:28:30,240
verwendest immer so die gleiche 
Art und Weise Sachen Abzutesten 

550
00:28:30,800 --> 00:28:34,480
jetzt kann es sein um das zu 
beheben musst du deine komplette

551
00:28:34,480 --> 00:28:39,280
Grundannahme wie dein Test 
Framework aufgebaut ist ändern. 

552
00:28:39,640 --> 00:28:43,360
Du musst vielleicht ganz anders 
die Sachen Abtesten, sprich dein

553
00:28:43,360 --> 00:28:47,040
komplette Test, dein komplettes 
Test Framework bezüglich dieses 

554
00:28:47,040 --> 00:28:49,920
Features oder dieser diesen Teil
der Software. 

555
00:28:49,920 --> 00:28:51,840
Ne, wenn es jetzt um zum 
Beispiel die Controller geht, 

556
00:28:52,160 --> 00:28:56,000
komplett refact dann und neu neu
schreiben oder oder sehr stark 

557
00:28:56,000 --> 00:28:59,360
umschreiben nur mal um zu 
motivieren, dass es halt auch 

558
00:28:59,360 --> 00:29:02,600
wirklich viel Aufwand bedeuten 
kann um einen so n flaky Test 

559
00:29:02,600 --> 00:29:04,280
dann wegzukriegen, weil die 
anderen vielleicht noch nicht 

560
00:29:04,280 --> 00:29:06,600
flaky sind, da funktioniert es 
halt irgendwie noch, aber du 

561
00:29:06,600 --> 00:29:08,640
merkst halt ey um das beheben zu
können. 

562
00:29:08,960 --> 00:29:11,880
Müssen wir ne komplett andere 
Grundannahme treffen und die 

563
00:29:11,880 --> 00:29:15,760
Test of Suite anders aufbauen 
und True Story, das hatten wir 

564
00:29:15,760 --> 00:29:18,880
im Projekt zusammen schon ne, 
dass wir gemerkt haben, ey warte

565
00:29:18,880 --> 00:29:22,240
mal hier in dem und dem Projekt,
das wird uns nicht ins Ziel 

566
00:29:22,240 --> 00:29:24,000
bringen, also haben wir die 
komplette Testsuite da 

567
00:29:24,000 --> 00:29:27,360
umgeschrieben. 
Ja, das war also das. 

568
00:29:27,560 --> 00:29:30,400
Ist das ist ja die Realität, ne,
also das heißt ja nicht flaky 

569
00:29:30,400 --> 00:29:32,240
Test. 
Ja dann schreib den Halt um, ich

570
00:29:32,240 --> 00:29:36,160
mein die sind flaky nicht weil 
weil du irgendwie keine Ahnung. 

571
00:29:36,520 --> 00:29:39,520
Wieder Bock drauf. 
Hast du mal blöd gesagt, sondern

572
00:29:39,520 --> 00:29:42,400
weil halt vielleicht 
irgendwelche Kombination an Side

573
00:29:42,400 --> 00:29:45,520
Effects zusammenspielen und das 
dann halt einfach nicht 

574
00:29:45,520 --> 00:29:48,600
gewährleistet, dass es immer die
gleichen Bedingungen hat am Ende

575
00:29:48,600 --> 00:29:50,800
und das ist das das passiert 
schnell. 

576
00:29:50,960 --> 00:29:53,440
Ja, definitiv. 
Also ich würd auch zum Beispiel 

577
00:29:53,440 --> 00:29:56,320
sagen, OK, es ist durchaus 
wertvoll zu sagen, warum ist der

578
00:29:56,320 --> 00:30:01,400
Test flaky ja nachgucken und 
verstehen warum es so ist, weil 

579
00:30:01,400 --> 00:30:03,520
es hilft ja und bringt dich 
selbst nur weiter. 

580
00:30:04,640 --> 00:30:07,280
Das ist halt wichtig. 
Aber wir gehen ja jetzt von der 

581
00:30:07,280 --> 00:30:11,280
Annahme aus, dass man wirklich 
sagt, OK, der Test bleibt drin 

582
00:30:12,160 --> 00:30:16,720
und er verzögert regelmäßig, 
fängt an, das Vertrauen 

583
00:30:16,720 --> 00:30:20,200
sozusagen der Entwickler oder 
der Entwicklerin Halt eben zu 

584
00:30:20,200 --> 00:30:23,600
untergraben in den Code. 
Wenn das der Fall sein sollte, 

585
00:30:23,600 --> 00:30:26,400
dann Lösch den Test raus, wenn 
du die Zeit dafür hast ihn zu 

586
00:30:26,400 --> 00:30:28,520
fixen und der Sache auf den 
Grund zu gehen, vielleicht das 

587
00:30:28,520 --> 00:30:30,440
Test Framework noch mal n 
bisschen zu überarbeiten 

588
00:30:30,440 --> 00:30:32,720
beziehungsweise die Art und 
Weise wie getestet wird. 

589
00:30:33,400 --> 00:30:36,160
Dann macht das auf jeden Fall. 
Aber sollte das nicht der Fall 

590
00:30:36,160 --> 00:30:38,240
sein, dann löscht den Test halt 
einfach raus, weil dann. 

591
00:30:38,240 --> 00:30:40,600
Brauchst du ihn nicht. 
Da kommen wir nämlich auch zu 

592
00:30:40,600 --> 00:30:43,120
einem ganz anderen wichtigen 
Punkt, um mal so ein bisschen 

593
00:30:43,120 --> 00:30:45,200
von den flaky Tests wegzukommen,
weil es gibt natürlich auch 

594
00:30:45,200 --> 00:30:48,720
andere Gründe, weil du ja 
meintest, die Pipeline läuft 

595
00:30:48,720 --> 00:30:50,480
eine Stunde und dann merkst du 
es erst. 

596
00:30:50,480 --> 00:30:53,280
Musst du es noch mal laufen 
lassen, das heißt du hast halt 

597
00:30:53,280 --> 00:30:57,240
sehr. 
Also ne langsame Testsuite 

598
00:30:57,280 --> 00:30:59,840
klingt jetzt irgendwie fies. 
Ne, es kann ja einfach sein, 

599
00:30:59,840 --> 00:31:02,120
dass es eine sehr umfangreiche 
Testsuite ist. 

600
00:31:02,120 --> 00:31:05,680
Ne, gerade dieses du hast n 
neues Feature, schreib n Test, 

601
00:31:05,680 --> 00:31:09,560
schreib mehrere Tests Tests 
genau ab Bug ersten Test damit 

602
00:31:09,560 --> 00:31:13,200
du sag ich mal gewährleisten 
kannst, dass er nicht wieder 

603
00:31:13,200 --> 00:31:15,280
auftritt und der Fall ab sofort 
geklärt ist. 

604
00:31:15,360 --> 00:31:19,680
Das sind ja alles Gute, wie soll
ich sagen Prinzipien. 

605
00:31:20,720 --> 00:31:23,960
Verhaltensweisen eines Coders 
oder einer Coderin zu sagen, 

606
00:31:23,960 --> 00:31:26,040
nein, ich möchte das so 
gewährleisten, das ist ja auch 

607
00:31:26,040 --> 00:31:28,800
richtig. 
Problem ist, wenn du jetzt immer

608
00:31:28,800 --> 00:31:31,960
mehr Tests hast und vielleicht 
auch richtig teure Tests, ja, 

609
00:31:31,960 --> 00:31:35,680
also so E to e Tests ja auch 
Integration, Tests, also alles 

610
00:31:35,680 --> 00:31:38,560
was auch irgendwann Zeit frisst 
um das zu testen. 

611
00:31:38,920 --> 00:31:42,120
Und deine Pipeline sehr langsam 
wird oder umfangreich ist. 

612
00:31:42,120 --> 00:31:45,040
Ja, du kannst das natürlich 
irgendwann auf mehreren Ebenen 

613
00:31:45,040 --> 00:31:47,280
testen, das hatten wir ja auch, 
zum Beispiel in unserer Defops 

614
00:31:47,280 --> 00:31:50,560
Reihe, dass du sagst, im CI teil
lass ich die Unit Tests laufen, 

615
00:31:50,560 --> 00:31:54,200
also dass du immer mehr Tests 
dazu packst Richtung Deployment,

616
00:31:54,200 --> 00:31:56,320
um dann die absolute 
Gewährleistung zu haben, ne, 

617
00:31:56,800 --> 00:31:59,520
weil was ich auch erlebt hab und
das ist jetzt der Punkt auf den 

618
00:31:59,520 --> 00:32:04,000
ich kommen möchte. 
Du hast viele viele Tests und 

619
00:32:04,000 --> 00:32:07,440
einige davon oder viele sind 
schon sehr lange in der 

620
00:32:07,440 --> 00:32:10,560
Software. 
Das heißt, die Laufen schon seit

621
00:32:10,560 --> 00:32:16,480
Monaten grün, dass sich Leute 
denken, ja, müssen wir das noch 

622
00:32:16,480 --> 00:32:19,520
testen, also also, was bringt 
uns das, das war schon immer 

623
00:32:19,520 --> 00:32:22,720
grün, so ne, also da an an dem 
Teil machen wir doch auch gar 

624
00:32:22,720 --> 00:32:26,240
nichts mehr, ne, also auch jetzt
noch mal zum Beispiel Richtung 

625
00:32:26,240 --> 00:32:28,840
manuelles testen, was du vorhin 
meintest. 

626
00:32:28,840 --> 00:32:31,920
Ja, dass jemand sagt so ja Mann,
das hab ich doch schon fünfmal 

627
00:32:31,920 --> 00:32:35,520
getestet, dass du irgendwann 
lazy wirst und sagst. 

628
00:32:36,120 --> 00:32:38,480
Nee, warte mal, das dauert mir 
zu lange mit der Pipeline oder 

629
00:32:38,480 --> 00:32:40,240
das manuelle testen. 
Das gilt für beides. 

630
00:32:40,240 --> 00:32:43,440
Jetzt ne, lass doch, lass uns 
mal die Tests deaktivieren, 

631
00:32:43,440 --> 00:32:46,000
kommt die die laufen eh, die 
machen wir halt nur noch dann am

632
00:32:46,000 --> 00:32:48,320
Ende noch mal zum Release oder 
was auch immer, also die 

633
00:32:48,320 --> 00:32:51,200
brauchen wir nicht immer 
mitlaufen lassen ne weil das Ey 

634
00:32:51,200 --> 00:32:53,760
ganz ehrlich das läuft seit 5 
Versionen seit Jahren mal 

635
00:32:53,760 --> 00:32:56,360
überspitzt gesagt oder der 
manuelle Tester denkt denkt sich

636
00:32:56,360 --> 00:32:59,080
ich hab das 100 Mal getestet es 
ist immer gleich es wird beim 

637
00:32:59,080 --> 00:33:02,640
101. 
Mal auch gleich sein ne und das 

638
00:33:02,640 --> 00:33:05,840
folgt daraus. 
Also dieses Verhalten folgt ja 

639
00:33:05,840 --> 00:33:09,040
daraus, dass deine Pipeline 
Quatsch, deine Testumgebung sehr

640
00:33:09,040 --> 00:33:11,840
groß und langsam wird oder 
Wartungsintensiv zum Beispiel 

641
00:33:11,840 --> 00:33:15,120
auch ne und das ist halt n 
riesen Punkt, warum man auch 

642
00:33:15,120 --> 00:33:20,320
wieder sagen kann, macht es 
vielleicht nicht Sinn diese 

643
00:33:20,320 --> 00:33:22,960
Tests zu refactern und zu 
gucken, welche ich davon 

644
00:33:22,960 --> 00:33:25,960
wirklich noch brauche. 
Ja, ich meine gut, wenn du 

645
00:33:25,960 --> 00:33:28,560
sagst, du hast zum Beispiel 
deine Tests, die du halt einfach

646
00:33:28,560 --> 00:33:32,720
eh immer deaktivierst, weil du 
immer sagst, die sind viel zu 

647
00:33:32,720 --> 00:33:35,720
langsam, dann. 
Wie gesagt, wenn du die Zeit 

648
00:33:35,720 --> 00:33:38,080
dafür nicht hast, dann lösch die
halt einfach weg, weil sie dich 

649
00:33:38,080 --> 00:33:42,160
einfach, also entweder dich 
aufhalten oder du sie eh immer 

650
00:33:42,160 --> 00:33:44,040
nur deaktivierst. 
Also kannst du sie auch 

651
00:33:44,040 --> 00:33:47,040
weglöschen, weil Tests heißen 
auch gleichzeitig es ist 

652
00:33:47,040 --> 00:33:50,080
wartungsarbeit. 
Du musst bei Tests halt 

653
00:33:50,480 --> 00:33:54,000
irgendwie ne gewisse Wartung 
reinstecken und ich find das ist

654
00:33:54,000 --> 00:33:57,760
auch n Punkt wo man auch 
durchaus mal sagen kann, weil 

655
00:33:58,080 --> 00:34:00,440
wir sind ja auch an dem Punkt, 
dass wir auch sagen Refactoring 

656
00:34:00,440 --> 00:34:02,800
ist wichtig im Code, genauso ist
es halt. 

657
00:34:03,080 --> 00:34:05,920
Also Tests sind auch Code, also 
sollte man die auch refactern 

658
00:34:06,400 --> 00:34:08,159
ganz genau. 
Und wenn du jetzt aber zum 

659
00:34:08,159 --> 00:34:10,960
Beispiel Tests hast, ne, weil 
wir jetzt von wartungsintensiven

660
00:34:10,960 --> 00:34:15,280
Tests gesprochen haben, du hast 
Tests wo du weißt wenn ich jetzt

661
00:34:15,280 --> 00:34:18,719
ne kleine Änderung im Code 
mache, dann muss ich auf einmal 

662
00:34:18,719 --> 00:34:25,400
bei einer Codezeile muss ich 150
andere 150 Tests anpassen, nicht

663
00:34:25,400 --> 00:34:28,120
nur den einen der sozusagen ich 
sag jetzt mal übertrieben für 

664
00:34:28,120 --> 00:34:31,920
diese Codezeile zuständig ist, 
sondern 150 andere Tests. 

665
00:34:32,600 --> 00:34:37,440
Wenn du das hast, ja, dann sind 
die Tests wahrscheinlich auch 

666
00:34:37,440 --> 00:34:40,280
nicht ganz so geil, ne? 
Also da kannst du dich schon 

667
00:34:40,280 --> 00:34:42,880
fast hinstellen und sagen, OK 
ey, lösch doch diese Tests weg, 

668
00:34:42,880 --> 00:34:45,920
weil diese Tests haben sich so 
extrem in deinen Code 

669
00:34:45,920 --> 00:34:49,520
reingebrannt, dass sie nicht 
mehr wirklich ein Verhalten 

670
00:34:49,520 --> 00:34:53,400
abtesten, sondern halt eher die 
Implementierung ne und ich finde

671
00:34:53,400 --> 00:34:55,520
das ist auch wirklich 
tatsächlich ein richtig schmaler

672
00:34:55,520 --> 00:34:58,040
und sehr sehr schwieriger Grad 
bei Test. 

673
00:34:58,040 --> 00:35:00,880
Beim Test schreiben wirklich zu 
sagen ich teste. 

674
00:35:01,320 --> 00:35:02,840
Die Funktionalität und nicht die
Implementierung. 

675
00:35:02,840 --> 00:35:05,520
Man neigt schnell dazu, 
Implementierungen zu testen, das

676
00:35:05,520 --> 00:35:08,640
heißt, wenn du deine 
Implementierung, du kannst ja 50

677
00:35:08,640 --> 00:35:11,280
Art und weisen zum Beispiel 
implementieren, wie du etwas 

678
00:35:11,280 --> 00:35:13,120
sortierst. 
Es gibt so viele 

679
00:35:13,120 --> 00:35:16,440
Sortieralgorithmen, ne, wenn du 
aber wirklich sagst, ey ich 

680
00:35:16,440 --> 00:35:19,200
teste jetzt aber explizit, dass 
da Heep Sort verwendet wird 

681
00:35:19,280 --> 00:35:23,760
anstatt keine Ahnung Merch Sort 
oder irgendwas ne und du dann 

682
00:35:23,760 --> 00:35:26,240
aber sagst Ey Moment, aber wir 
brauchen jetzt aber noch viel 

683
00:35:26,240 --> 00:35:33,440
schnelleren Search Algorithmus. 
Sort Algorithmus sorry, dann 

684
00:35:33,440 --> 00:35:35,800
funktionieren Tests auf einmal 
nicht mehr, obwohl ja eigentlich

685
00:35:35,800 --> 00:35:37,120
das Verhalten ist, wurde 
sortiert. 

686
00:35:37,120 --> 00:35:40,320
Richtig ist weißt du, das ist 
halt da, muss man halt auch 

687
00:35:40,320 --> 00:35:43,120
drauf achten und wenn du dann so
n so so etwas hast wo du sagst 

688
00:35:43,120 --> 00:35:46,240
OK pass auf, ich ändere ne 
Kleinigkeit und super viele 

689
00:35:46,240 --> 00:35:48,480
Tests failen, dann sind deine 
Tests wahrscheinlich nicht so 

690
00:35:48,480 --> 00:35:50,920
gut also du machst den 
Riesenaufwand anstatt dann 

691
00:35:50,920 --> 00:35:53,360
einfach zu OK pass auf ich ich 
hau die weg so. 

692
00:35:54,040 --> 00:35:55,800
Genau. 
Und da schließt sich der Kreis. 

693
00:35:55,800 --> 00:35:57,680
Worauf ich hinaus wollte. 
Gut, dass du es angesprochen 

694
00:35:57,680 --> 00:36:00,960
hast, weil dieses Verhalten ich 
deaktiviere Test, weil etwas 

695
00:36:00,960 --> 00:36:04,160
langsam läuft und so resultiert 
ja auch daraus, dass ich 

696
00:36:04,160 --> 00:36:07,600
Altlasten mit Trage und ich nenn
es jetzt mal provokativ 

697
00:36:07,600 --> 00:36:09,680
Altlasten wie du gerade 
meintest, so Tests. 

698
00:36:09,960 --> 00:36:13,920
Die eigentlich gar nicht mehr so
richtig Funktionalität abbilden,

699
00:36:13,920 --> 00:36:16,000
sondern vielleicht noch so 
Implementierungen, die drin 

700
00:36:16,000 --> 00:36:17,840
sind. 
Features ändern sich, ich 

701
00:36:17,840 --> 00:36:20,440
refector die Software und wie du
meintest, da muss auch die Test 

702
00:36:20,440 --> 00:36:24,640
Suite refected werden ne es ist 
Schritt 1 zu sagen ich änder was

703
00:36:24,640 --> 00:36:28,080
OK meine Tests sind noch grün, 
schritt 2 ist aber brauch ich 

704
00:36:28,080 --> 00:36:30,480
noch alle Tests davon bilden die
noch überhaupt das Verhalten 

705
00:36:30,480 --> 00:36:33,760
sauber ab oder sind da jetzt 
testbei die zwar grün sind aber 

706
00:36:33,760 --> 00:36:35,360
eigentlich gar nicht mehr 
relevant sind? 

707
00:36:35,360 --> 00:36:40,880
Und da gibt es auch. 
Ne coole Denkweise zu sagen, es 

708
00:36:40,880 --> 00:36:43,360
ist jetzt grün. 
Es war also die Funktion 

709
00:36:43,360 --> 00:36:46,360
funktioniert so wie sie soll, 
ich refector sie funktioniert so

710
00:36:46,360 --> 00:36:49,040
wie sie soll und ich guck jetzt 
die Tests durch, dann kann ich 

711
00:36:49,040 --> 00:36:52,400
ruhig Test die vermeintlich 
nicht mehr wirklich ne Rolle 

712
00:36:52,400 --> 00:36:58,160
spielen ja wirklich löschen, 
dass ich sage OK nee ich glaub 

713
00:36:58,160 --> 00:37:00,080
die brauch ich nicht mehr, das 
sieht nicht so aus als wenn die 

714
00:37:00,080 --> 00:37:04,080
jetzt wirklich noch 
Funktionalität abbilden im 

715
00:37:04,080 --> 00:37:07,840
Testsinne ne weil. 
Angenommen, dann tritt 

716
00:37:07,840 --> 00:37:12,400
irgendwann ein Bug auf, wird es 
leichter sein, den zu finden. 

717
00:37:12,400 --> 00:37:14,720
Also weil es ja, weil du ja 
einen definierten Zeitpunkt 

718
00:37:14,720 --> 00:37:16,880
hast. 
Ja, dass du sagst, okay, ich 

719
00:37:16,880 --> 00:37:20,480
habe jetzt meine Funktion, die 
funktioniert und falls denn doch

720
00:37:20,480 --> 00:37:23,760
ein Bug kommt, schreibe ich 
einfach einen neuen Test statt 

721
00:37:23,760 --> 00:37:27,440
den alten irgendwie immer wieder
umzubauen und irgendwie wieder 

722
00:37:27,440 --> 00:37:29,840
reinzuzwängen in mein neues 
Konstrukt. 

723
00:37:30,200 --> 00:37:32,240
Dass ich dann sage, OK, ich 
nehme in Kauf, dass irgendwas 

724
00:37:32,240 --> 00:37:35,040
nicht funktioniert, potenziell. 
Ja, es ist ja nicht 

725
00:37:35,040 --> 00:37:38,480
gewährleistet, dass es soweit 
kommt, und dann bin ich aber am 

726
00:37:38,480 --> 00:37:41,840
Ende schneller nicht die 
Altlasten zu verwalten und zu 

727
00:37:41,840 --> 00:37:44,480
erneuern, sondern dann zu sagen,
OK, dann haben wir jetzt n Bug 

728
00:37:44,480 --> 00:37:47,040
und den fixen wir. 
Ja richtig, auf jeden Fall. 

729
00:37:47,120 --> 00:37:49,960
Und das ist meistens dann sogar 
am Ende sogar schneller unter 

730
00:37:49,960 --> 00:37:51,680
Umständen. 
Genau das, das klingt jetzt 

731
00:37:51,680 --> 00:37:53,040
erstmal, das muss man auch mal 
sacken lassen. 

732
00:37:53,040 --> 00:37:55,080
Das klingt n bisschen komisch, 
weil man sich so denkt, Na ja, 

733
00:37:55,080 --> 00:37:57,480
warte, aber der Bug kann gar 
nicht auftauchen, wenn ich ja 

734
00:37:57,480 --> 00:37:59,920
diese alten Tests noch hab. 
Nee, genauso ist es ja nicht, 

735
00:37:59,920 --> 00:38:03,680
weil die ja eventuell wirklich 
auf alte Konstrukte basieren, 

736
00:38:03,680 --> 00:38:06,960
alte Annahmen und gar nicht mehr
so wirklich der aktuellen 

737
00:38:06,960 --> 00:38:08,960
Software entsprechen. 
Ja, richtig. 

738
00:38:09,760 --> 00:38:12,440
Und ich würd auch sagen, nicht 
nur veraltete Tests, sondern 

739
00:38:12,440 --> 00:38:15,080
vielleicht auch manchmal hab ich
auch schon erlebt, man schreibt 

740
00:38:15,080 --> 00:38:18,160
irgendwie ne Funktionalität um 
und kommt dann dahin, dass du 

741
00:38:18,160 --> 00:38:22,120
vielleicht 2 Tests hast, die du 
anpasst an so nach dem Motto Ah,

742
00:38:22,120 --> 00:38:24,640
ich hab jetzt hier was quasi 
verändert, ist ja durchaus 

743
00:38:24,640 --> 00:38:27,360
möglich, dass du keine Ahnung ne
ne Änderung machst und dann 

744
00:38:27,360 --> 00:38:31,280
siehst OK meine Tests, also es 
ist n Tests rot ne bessere Weg 

745
00:38:31,280 --> 00:38:33,600
wär zu sagen erstmal pass ich 
meine Tests an, also meine 

746
00:38:33,600 --> 00:38:36,000
Erwartung und dann wirklich die 
Implementierung. 

747
00:38:36,440 --> 00:38:38,960
In der Realität sieht es oft so 
aus, dass du einfach erstmal den

748
00:38:38,960 --> 00:38:40,800
Code anpasst und guckst. 
OK, was ist denn rot? 

749
00:38:41,120 --> 00:38:43,360
Dann guckst du dir Tests an und 
sagst Ah, diese 2 Tests sind 

750
00:38:43,360 --> 00:38:45,360
rot. 
Ja genau, weil da steht ja der 

751
00:38:45,360 --> 00:38:47,280
Test. 
Sagt das und das soll getestet 

752
00:38:47,280 --> 00:38:49,840
werden, ist ja jetzt nicht mehr 
soweit ich das verändert hab, 

753
00:38:49,840 --> 00:38:53,520
also passt du den Test an die 
Implementierung an was wo ich 

754
00:38:53,520 --> 00:38:56,080
sage auch unter Umständen 
durchaus in Ordnung ist, weil du

755
00:38:56,080 --> 00:38:58,800
ja eigentlich im Normalfall und 
das jetzt wieder wichtig n 

756
00:38:58,800 --> 00:39:03,440
kleinen Scope hast wo du sagst 
eine kleine Änderung ein 2 Tests

757
00:39:04,080 --> 00:39:06,440
failen so. 
Und du kannst so anpassen und 

758
00:39:06,440 --> 00:39:09,360
sagen, zum Beispiel sowas wie 
ne, wenn wir beim Sort Beispiel 

759
00:39:09,360 --> 00:39:11,280
sind. 
Du sagst du möchtest, dass es 

760
00:39:11,680 --> 00:39:13,840
andersrum sortiert wird, 
könntest du natürlich erst 

761
00:39:13,840 --> 00:39:16,600
deinen Test anpassen und sagen, 
ey das was ich erwarte nach der 

762
00:39:16,600 --> 00:39:19,200
Funktion ist, dass es absteigend
sortiert ist, nicht aufsteigend 

763
00:39:19,360 --> 00:39:22,400
ne kannst aber auch erstmal die 
Implementierung ändern und dann 

764
00:39:22,400 --> 00:39:24,480
sagen ja ich hab es ja jetzt 
absteigend sortiert, also muss 

765
00:39:24,480 --> 00:39:26,520
ich das quasi mal im Test 
umdrehen und dann ist der Test 

766
00:39:26,520 --> 00:39:29,360
wieder grün ne so aber ich hab 
auch schon mal erlebt, dass dann

767
00:39:29,360 --> 00:39:33,360
genau aus solchen Veränderungen 
2 Tests eigentlich so gut wie. 

768
00:39:33,880 --> 00:39:36,880
Identisch waren zumindest von 
dem, was getestet wurde, aber 

769
00:39:36,880 --> 00:39:38,720
nicht von dem, wie der Test am 
Ende aussah. 

770
00:39:38,720 --> 00:39:41,600
Weißt du, und dann ist es 
wichtig, auch mal zu sagen, OK, 

771
00:39:41,600 --> 00:39:44,680
ich hab hier vielleicht gleiche 
Tests, die aber das, also 

772
00:39:44,680 --> 00:39:47,200
unterschiedliche Tests die das 
gleiche Abtesten sozusagen am 

773
00:39:47,200 --> 00:39:50,440
Ende ne, also vielleicht auch 
auf anderen Ebenen oder so ne 

774
00:39:50,440 --> 00:39:52,480
und da bietet sich dann halt 
auch mal an zu sagen. 

775
00:39:52,560 --> 00:39:55,200
Absolut Lösch die Tests, die. 
Redundant sind das brauchst du 

776
00:39:55,200 --> 00:39:57,280
nicht, das ist alles 
Wartungsarbeit am Ende die 

777
00:39:57,280 --> 00:39:59,600
hinterher. 
Runterfällt. 

778
00:39:59,680 --> 00:40:02,320
Genau also das über mehrere 
Ebenen ist n absoluter 

779
00:40:02,320 --> 00:40:06,160
Klassiker, dass du sagst, ich 
teste auf kleinster Ebene ab. 

780
00:40:06,160 --> 00:40:08,960
Das und das darf nicht 
passieren, dann also 

781
00:40:08,960 --> 00:40:10,800
beziehungsweise diese Eingaben 
sind nicht erlaubt, 

782
00:40:11,120 --> 00:40:16,240
beispielsweise so jetzt hast du 
auf einer höheren Ebene quasi 

783
00:40:16,240 --> 00:40:19,440
getestet, dass diese Eingaben 
niemals da reingehen können, nur

784
00:40:20,160 --> 00:40:23,440
mal so n kleines konstruiertes 
Beispiel, dann hast du jetzt 2 

785
00:40:23,440 --> 00:40:26,640
Tests die in sich. 
Funktionalität abbilden, aber 

786
00:40:26,640 --> 00:40:29,040
irgendwo halt auch wirklich 
deine Implementierung und nicht 

787
00:40:29,040 --> 00:40:34,080
mehr die Anforderung oder die 
Funktionsweise ne und hast 2 

788
00:40:34,080 --> 00:40:37,200
Tests, obwohl das eine gar nicht
eintreten kann, aber der Test an

789
00:40:37,200 --> 00:40:40,640
sich ist ja trotzdem grün, weil 
er sorgt dafür, dass bei der 

790
00:40:40,640 --> 00:40:45,520
Eingabe n Fehler fliegt, zum 
Beispiel ja grün der obere Test 

791
00:40:45,520 --> 00:40:48,200
sagt diese Eingabe kann niemals 
sein, hast du abgetestet kann 

792
00:40:48,200 --> 00:40:50,640
nicht passieren. 
Und trotzdem stehen die beiden 

793
00:40:50,640 --> 00:40:53,760
Tests einzeln ja für ne gewisse 
Bedeutung, dass du sagst, ey, 

794
00:40:53,760 --> 00:40:56,480
den brauch ich doch, den Test. 
Aber eigentlich brauchst du den 

795
00:40:56,480 --> 00:40:59,880
unteren an der Stelle nicht, 
weil weil es ja gar nicht 

796
00:40:59,880 --> 00:41:02,400
passieren kann, weil du ja auf 
höherer Ebene das Abgetestet 

797
00:41:02,400 --> 00:41:04,080
hast. 
Jetzt ist es halt wie gesagt 

798
00:41:04,080 --> 00:41:06,760
immer n Trade auf und deswegen 
testen ist ne Kunst für sich und

799
00:41:06,760 --> 00:41:08,320
man muss da auch viel Erfahrung 
sammeln. 

800
00:41:09,200 --> 00:41:11,760
Je nachdem, jetzt kann man ja 
sagen, ja, dann test ich nur auf

801
00:41:11,760 --> 00:41:13,680
höchster Ebene. 
Mir ist egal wie das intern 

802
00:41:13,680 --> 00:41:16,000
aussieht, ich will das von außen
wirklich grob, meine 

803
00:41:16,000 --> 00:41:19,440
Anforderungen funktionieren, da 
hat mir auch mal n ne Folge 

804
00:41:19,440 --> 00:41:23,680
gemacht mit der Testpyramide das
alles immer natürlich n Preis 

805
00:41:23,680 --> 00:41:25,520
hat. 
Ne wenn ich jetzt sage ich teste

806
00:41:25,520 --> 00:41:29,760
viel im Verbund wird es schnell 
auch sehr zeitintensiv und teuer

807
00:41:29,840 --> 00:41:32,320
das ganze ne und. 
Dann kommst du vielleicht wieder

808
00:41:32,320 --> 00:41:34,440
dahin, dass deine Testsuite 
irgendwann so langsam wird, dass

809
00:41:34,440 --> 00:41:36,480
du irgendwann sagst, komm, die 
nehmen wir mal raus. 

810
00:41:36,920 --> 00:41:38,640
Ne, damit genau das geht gar 
keine. 

811
00:41:39,200 --> 00:41:40,600
Genau. 
Und dann kannst du die Tests 

812
00:41:40,600 --> 00:41:44,320
auch wieder löschen. 
So ne auf jeden Fall auf. 

813
00:41:44,480 --> 00:41:47,520
Also das ist auf jeden Fall 
wichtig, dass man sich halt auch

814
00:41:47,520 --> 00:41:51,520
sagt, so als Fazit. 
OK, man darf auch Tests löschen,

815
00:41:51,560 --> 00:41:54,880
es ist OK Tests zu löschen, wenn
du einen gewissen Grund dahinter

816
00:41:54,880 --> 00:41:56,400
hast. 
Ne wenn du jetzt zum Beispiel 

817
00:41:56,400 --> 00:41:59,560
sagst Ey das ist ne wirklich 
kritische wichtige Logik die ich

818
00:41:59,560 --> 00:42:01,720
da hab und hier sind Tests dazu,
dann lösch die Tests auf gar 

819
00:42:01,720 --> 00:42:04,240
keinen Fall, das ist ja wichtig 
so, aber wenn du keine Ahnung 

820
00:42:04,800 --> 00:42:06,840
diese Logik 5 mal abtestest so 
dann brauchst. 

821
00:42:06,920 --> 00:42:07,800
Musst du es aber auch nur 
einmal. 

822
00:42:07,800 --> 00:42:12,160
Lösch also die anderen 5 ne, das
ist flaky hau das Weg, keine 

823
00:42:12,160 --> 00:42:15,640
Ahnung, musst du übermäßig viel 
Wartungsarbeit in bestimmte 

824
00:42:15,640 --> 00:42:18,160
Tests stecken, hau die Tests 
weg, das frisst einfach nur zu 

825
00:42:18,160 --> 00:42:22,880
viel Zeit, so ne sind sind die 
zu langsam Hau-Weg irrelevant 

826
00:42:22,880 --> 00:42:26,720
geworden, dann hau die Tests weg
also man darf Tests löschen, das

827
00:42:26,720 --> 00:42:30,080
ist wichtig, man sollte halt wie
gesagt immer drauf achten, dass 

828
00:42:30,080 --> 00:42:33,440
Tests halt sinnvoll sind und 
halt auch sinnvoll bleiben, ne? 

829
00:42:34,040 --> 00:42:38,000
Genau also die große Take Home 
Message für uns und auch für 

830
00:42:38,000 --> 00:42:41,160
dich, liebe Zuhörer, liebe 
Zuhörer, ist einfach das Test 

831
00:42:41,160 --> 00:42:44,240
Suiten und die Tests einfach 
regelmäßig refacted werden 

832
00:42:44,240 --> 00:42:47,120
müssen, dass man immer wieder 
challengen muss, ob die Tests 

833
00:42:47,120 --> 00:42:51,640
noch sinnvoll sind oder nicht. 
Und was kann ich optimieren? 

834
00:42:51,640 --> 00:42:54,720
Ne um halt quasi nicht in so n 
Bottle neck zu kommen zu sagen 

835
00:42:54,720 --> 00:42:57,640
Ey jetzt dauert alles viel zu 
lange, jetzt sind die Entwickler

836
00:42:57,640 --> 00:42:59,520
genervt davon, zum Beispiel 
schon. 

837
00:42:59,920 --> 00:43:02,720
Ja, ich würd auch noch ne 
Kleinigkeit noch sagen, weil das

838
00:43:02,720 --> 00:43:05,880
liegt mir nur auf dem Herzen. 
Es gibt ja viele Metriken, wo 

839
00:43:05,880 --> 00:43:09,120
man zum Beispiel sagt, Ey hier 
keine Ahnung, deine Tests 

840
00:43:09,200 --> 00:43:12,040
Coverage, wie hoch ist die 
Coverage, wie viele Tests gibt 

841
00:43:12,040 --> 00:43:14,400
es eigentlich wurde die 
Testpyramide eingehalten, so 

842
00:43:14,400 --> 00:43:16,720
nach dem Motto Ne das sind alles
irgendwie so. 

843
00:43:17,400 --> 00:43:20,480
Metriken oder ich sag mal so 
eine gewisse Art von Fokus auf 

844
00:43:20,480 --> 00:43:23,760
den ganz häufig irgendwie 
sozusagen geschaut wird. 

845
00:43:24,000 --> 00:43:26,880
Aber eigentlich finde ich, sind 
das völlige Bullshit, Metriken 

846
00:43:26,880 --> 00:43:29,040
mal wirklich ein bisschen 
provokativ das ganze 

847
00:43:29,040 --> 00:43:31,600
hinzustellen, sondern die 
wichtigste Metrik an dieser 

848
00:43:31,600 --> 00:43:35,360
ganzen Stelle ist, wie hoch ist 
dein Vertrauen in deinen eigenen

849
00:43:35,360 --> 00:43:37,960
Code und wie stark kannst du 
dich darauf verlassen, dass 

850
00:43:37,960 --> 00:43:40,640
irgendwie Änderungen oder zum 
Beispiel bei Refactoring auch 

851
00:43:40,640 --> 00:43:43,800
nichts kaputt geht. 
Wenn du da sagst, ey, das ist 

852
00:43:43,800 --> 00:43:45,520
richtig, richtig geil und ich 
kann. 

853
00:43:45,960 --> 00:43:49,040
Mich vollends darauf verlassen, 
dann sind deine Tests richtig 

854
00:43:49,040 --> 00:43:51,960
geil. 
So richtig guter Punkt also. 

855
00:43:51,960 --> 00:43:54,560
Es ist viel aussagekräftiger, 
die Entwicklerinnen und 

856
00:43:54,560 --> 00:43:58,720
Entwickler zu fragen, wie 
zuversichtlich sie coden und was

857
00:43:58,720 --> 00:44:00,400
zum Beispiel auch 
aussagekräftiger ist. 

858
00:44:00,400 --> 00:44:03,120
Wie oft steht denn deine 
Pipeline, wie oft failed denn 

859
00:44:03,120 --> 00:44:04,880
ein? 
Eine Integration oder ein 

860
00:44:04,880 --> 00:44:06,920
Deployment? 
Ja du kannst ja 100% 

861
00:44:06,920 --> 00:44:09,120
Testcoverage haben und trotzdem 
steht bei jedem dritten Lauf 

862
00:44:09,120 --> 00:44:14,160
deine Pipeline bringt dir also 
nichts, das ist so n so n flexen

863
00:44:14,400 --> 00:44:18,320
ja guck mal 100% Test. 
Deckung was aber am Ende schon 

864
00:44:18,640 --> 00:44:23,760
symbolisiert so n bisschen uh 
weiß nicht ob das jetzt wirklich

865
00:44:23,760 --> 00:44:26,240
gut ist was ihr da macht. 
So ne also bin ich ehrlich wenn 

866
00:44:26,240 --> 00:44:29,080
da wenn jemand mit sowas um die 
Ecke kommt bin ich immer erstmal

867
00:44:29,080 --> 00:44:32,480
n bisschen skeptisch vielleicht 
unbegründet, aber weil das 

868
00:44:32,480 --> 00:44:36,240
sollte kein Maß sein sondern 
eher die beiden Punkte zum 

869
00:44:36,240 --> 00:44:37,760
Beispiel die ich gerade 
angesprochen hab. 

870
00:44:39,480 --> 00:44:41,320
Ja, hast du sonst noch n 
abschließendes Wort Fabi? 

871
00:44:41,320 --> 00:44:43,440
Sonst würde ich sagen, haben wir
das Thema gut besprochen. 

872
00:44:44,480 --> 00:44:50,240
Bitte teste jetzt erst mal n 
paar Worte zu testen genau und 

873
00:44:50,560 --> 00:44:53,280
deswegen jetzt am Ende noch die 
Frage an dich, liebe Zuhörer, 

874
00:44:53,280 --> 00:44:56,960
liebe Zuhörer, was halt ist, was
hältst du von Tests? 

875
00:44:57,840 --> 00:45:00,520
Testest du regelmäßig deine 
Software, hast du das was wir 

876
00:45:00,520 --> 00:45:02,640
geschildert haben mit unseren 
Erfahrungen schon mal selbst 

877
00:45:02,640 --> 00:45:05,600
erlebt? 
Wie stehst du zu den Metriken, 

878
00:45:05,600 --> 00:45:08,400
die Fabi gerade kritisiert hat? 
Das sind alles so Punkte, die 

879
00:45:08,400 --> 00:45:11,280
wir gerne, wo wir gerne in 
Austausch kommen würden, schreib

880
00:45:11,280 --> 00:45:13,560
uns gerne zum Beispiel über die 
Podcast Mail, die findest du in 

881
00:45:13,560 --> 00:45:15,480
Show Notes über allen 
Plattformen kannst du uns 

882
00:45:15,480 --> 00:45:18,080
erreichen, wir werden auf jeden 
Fall antworten findest du auch 

883
00:45:18,080 --> 00:45:21,400
in den Show Notes die ganzen 
links ansonsten, wenn dir die 

884
00:45:21,400 --> 00:45:23,600
Folge gefallen hat du findest 
auch einen kleinen Spendling 

885
00:45:23,600 --> 00:45:25,920
wenn du uns unterstützen 
möchtest, dann vielen, vielen 

886
00:45:25,920 --> 00:45:28,640
Dank dafür. 
Vergiss nicht, den Podcast zu 

887
00:45:28,640 --> 00:45:30,640
abonnieren, falls du es noch 
nicht gemacht hast, lass gerne 

888
00:45:30,640 --> 00:45:32,640
eine Bewertung da. 
Das sind alles Punkte die uns 

889
00:45:32,640 --> 00:45:36,240
massiv helfen das Ganze hier 
weiter zu treiben und ansonsten 

890
00:45:36,240 --> 00:45:38,720
würde ich sagen, haben uns alle 
nächste Woche wieder habt eine 

891
00:45:38,720 --> 00:45:42,560
schöne Zeit bis dahin ciao ciao 
deine Coding Buddies. 

892
00:45:42,720 --> 00:45:43,920
Gemeinsam besser.