1
00:00:01,280 --> 00:00:04,000
Moin zufolge 110 von einfach 
komplex. 

2
00:00:04,000 --> 00:00:07,600
Heute zum Thema Rust mit dem 
Marcel Koch Moin Marcel. 

3
00:00:08,240 --> 00:00:10,160
Hallo zusammen, freut mich hier 
zu sein. 

4
00:00:10,800 --> 00:00:12,720
Moin, bin auch da. 
Huhu. 

5
00:00:14,240 --> 00:00:15,560
Ja, sehr cool. 
Rust ist eine 

6
00:00:15,560 --> 00:00:18,920
Programmiersprache, so viel weiß
ich auch noch, wofür man die 

7
00:00:18,920 --> 00:00:21,680
genau einsetzt, wie die sich 
abgrenzt, was sie heute noch für

8
00:00:21,680 --> 00:00:23,640
ne Daseinsberechtigung hat, das 
hab ich schon n bisschen 

9
00:00:23,640 --> 00:00:25,600
rausgehört, all solche Themen 
wollen wir heute mal beleuchten 

10
00:00:25,600 --> 00:00:27,440
und vielleicht auch was so die 
Besonderheiten sind. 

11
00:00:27,920 --> 00:00:30,840
Aber bevor wir das tun, Marcel. 
Magst du dich ein bisschen 

12
00:00:30,840 --> 00:00:33,080
vorstellen, dass die Hörer und 
Hörer wissen, mit wem haben Sie 

13
00:00:33,080 --> 00:00:35,280
es denn hier heute hauptsächlich
zu tun? 

14
00:00:35,840 --> 00:00:37,360
Mache ich gerne. 
Vielen dank, Gerrit. 

15
00:00:37,760 --> 00:00:40,640
Ja, ich bin Marcel, hast du ja 
schon gesagt, ich betreibe eine 

16
00:00:40,640 --> 00:00:44,640
kleine, wie ich gerne sage, 
nahbare softwareberatung ich 

17
00:00:44,640 --> 00:00:47,920
arbeite mit einem Netzwerk aus 
Freelancern zusammen, wenn es 

18
00:00:47,920 --> 00:00:51,120
mal auch um größere Projekte 
geht und habe mich in den 

19
00:00:51,120 --> 00:00:54,720
letzten Jahren auf Trust 
Plattform Entwicklung auf Basis 

20
00:00:54,720 --> 00:00:57,600
von Rust. 
Oft gepaart mit Flatter 

21
00:00:57,600 --> 00:01:00,240
spezialisiert. 
Ich hab ne lange Historie von 

22
00:01:00,240 --> 00:01:02,560
verschiedenen Dingen die ich 
gemacht hab, war lange 

23
00:01:02,560 --> 00:01:08,000
Consultant in Webagenturen 
unterwegs und bin seit 2018 

24
00:01:08,000 --> 00:01:11,120
selbständig unterwegs und 
zusätzlich eine 

25
00:01:11,120 --> 00:01:13,440
Herzensangelegenheit von mir ist
noch das Thema Kommunikation in 

26
00:01:13,440 --> 00:01:16,960
der IT und da gebe ich auch 
Coachings und Trainings im 

27
00:01:17,200 --> 00:01:19,480
Bereich gewaltfreie 
Kommunikation und 

28
00:01:19,480 --> 00:01:21,920
Transaktionsanalyse. 
Sehr schön. 

29
00:01:21,920 --> 00:01:24,000
Cool, dass du da bist. 
Die die Zeit heute für uns 

30
00:01:24,000 --> 00:01:26,240
nimmst. 
Du meine erste Frage, vielleicht

31
00:01:26,240 --> 00:01:28,160
ist n guter Einstieg. 
Warum hast du Rust eigentlich 

32
00:01:28,160 --> 00:01:30,240
Rust? 
Das klingt ja n bisschen rostig.

33
00:01:30,640 --> 00:01:32,360
Und damit kommen wir schon zur 
ersten Frage, die ich gar nicht 

34
00:01:32,360 --> 00:01:36,400
beantworten kann. 
Podcast schon erledigt? 

35
00:01:36,640 --> 00:01:40,400
Ich, ich glaube es, da steckt 
dieses robust drin und wenn ich,

36
00:01:40,400 --> 00:01:42,320
wenn ich das richtig im Kopf 
habe, aber das kann ich nicht 

37
00:01:42,320 --> 00:01:45,200
richtig beantworten, aber ich 
glaube, es ging darum, eine eine

38
00:01:45,200 --> 00:01:47,760
Programmiersprache zu 
entwickeln, die besonders eine 

39
00:01:47,760 --> 00:01:49,760
robuste Codebase mit sich 
bringt, vielleicht ist auch ne 

40
00:01:49,760 --> 00:01:51,920
Urban Legend und dann hat man 
das. 

41
00:01:52,160 --> 00:01:54,240
So wie bei bei Samba share. 
Da hat man ja auch irgendwann 

42
00:01:54,240 --> 00:01:57,360
mal überlegt ne was wo steckt 
SNB überall drin, deswegen 

43
00:01:57,360 --> 00:02:00,720
nennen wir das jetzt Samba bei 
diesem Windows Netzwerk Kram und

44
00:02:00,720 --> 00:02:03,320
ich glaube das hat damit zu tun,
das ist natürlich immer n 

45
00:02:03,320 --> 00:02:06,240
bisschen schwierig und da gibt 
es auch diese ganzen, diese 

46
00:02:06,240 --> 00:02:08,639
ganzen Wortspielereien, es gibt 
ja beispielsweise in in 

47
00:02:08,639 --> 00:02:13,280
Deutschland die die Oxydice das 
ist ne ne kleine Konferenz und 

48
00:02:13,520 --> 00:02:17,200
ja und da gibt es auch Grüße 
gehen raus an den Matthias 

49
00:02:17,200 --> 00:02:20,160
Endler der auch ne. 
Consultingfirma hat die der 

50
00:02:20,160 --> 00:02:23,360
Carode genannt hat, und da kann 
man diese ganzen Dinge irgendwie

51
00:02:23,600 --> 00:02:26,960
da darauf Münzen ist natürlich 
nicht unbedingt der der 

52
00:02:26,960 --> 00:02:29,680
bestgewählte Name, wenn das, 
wenn es da verstehen soll, dass 

53
00:02:29,680 --> 00:02:34,000
es besonders lange hält und 
nicht rostet, so, aber ich weiß 

54
00:02:34,000 --> 00:02:37,400
es nicht hundertprozentig. 
Klingt aber erstmal ganz passend

55
00:02:37,400 --> 00:02:41,320
eigentlich und ganz gut, OK, und
aber jetzt vielleicht, wo du 

56
00:02:41,320 --> 00:02:43,720
dann auch immer noch mehr zu 
sagen kannst ist, wofür eignet 

57
00:02:43,720 --> 00:02:46,280
sich jetzt Rust? 
Ganz besonders also ich hab 

58
00:02:46,280 --> 00:02:48,880
schon verstanden, es gibt viele 
Programmiersprachen, ja und 

59
00:02:48,880 --> 00:02:50,960
viele haben so ihre Eigenarten 
und und besonderen 

60
00:02:50,960 --> 00:02:54,440
Anwendungsfälle, manche sind 
Allrounder, andere eignen sich 

61
00:02:54,440 --> 00:02:57,360
besonders für Machine Learning 
oder so was ist da bei Rust 

62
00:02:57,360 --> 00:03:00,040
eigentlich der 
Hauptanwendungsfall, wofür wird 

63
00:03:00,040 --> 00:03:02,560
es eingesetzt? 
Ursprünglich ist ja Rust groß 

64
00:03:02,560 --> 00:03:08,080
geworden unter dem Schirm von 
von Mozilla, und da ging es 

65
00:03:08,080 --> 00:03:12,880
damals darum, eine Alternative 
zu C plus Plus zu entwickeln. 

66
00:03:13,440 --> 00:03:19,520
Die bestimmte Probleme, die man 
in der Entwicklung mit C und C 

67
00:03:19,520 --> 00:03:21,680
plus plus, ganz besonders in 
Bezug auf das 

68
00:03:21,680 --> 00:03:25,040
Speichermanagement, die die, die
man dort hat, dass man die mit 

69
00:03:25,040 --> 00:03:28,240
der neuen Programmiersprache, in
dem Fall Rust, nicht mehr hat 

70
00:03:28,720 --> 00:03:34,720
und Rust an sich wird heutzutage
sehr oft innerhalb von der 

71
00:03:34,720 --> 00:03:38,400
Systemprogrammierung gesehen und
wurde auch ne ganze Zeit lang 

72
00:03:38,400 --> 00:03:41,440
noch mal mit go verglichen, weil
das irgendwie total unfair ist. 

73
00:03:41,840 --> 00:03:46,560
Go hat einen ganz anderen, einen
ganz anderen Hintergrund, auch 

74
00:03:46,560 --> 00:03:51,600
ein ganz anderes Ziel, denn Rust
ist aus meiner Sicht viel 

75
00:03:51,600 --> 00:03:55,400
breiter in den Möglichkeiten und
da gehen wir bestimmt später 

76
00:03:55,400 --> 00:03:57,520
auch noch drauf ein. 
Aus meiner Sicht nicht nur bei 

77
00:03:57,520 --> 00:04:00,320
bei der Systemprogrammierung zu 
sehen, sondern auch bei bei 

78
00:04:00,320 --> 00:04:02,400
Business Anwendungen wie 
beispielsweise was man 

79
00:04:02,400 --> 00:04:06,800
heutzutage oft in in Java oder 
in in C Sharp schreibt und 

80
00:04:06,800 --> 00:04:10,000
deswegen würde ich sagen erstmal
wenn man hingeht und sagt, ich 

81
00:04:10,000 --> 00:04:15,040
hätte gerne etwas. 
Sehr robustes, Performantes und 

82
00:04:15,040 --> 00:04:19,600
besonders sicheres. 
Das ist ja im Deutschen so. 22 

83
00:04:19,839 --> 00:04:23,520
hat 2 Bedeutung, dann geht man 
in in Richtung Rust. 

84
00:04:24,240 --> 00:04:28,360
Wenn wir uns mal die Blogosphäre
oder Linkedin mal angucken, da 

85
00:04:28,360 --> 00:04:32,560
wird sehr viel gestritten und 
diskutiert und ach Rust ist der 

86
00:04:32,560 --> 00:04:35,680
ist der neue Hype et cetera und 
bringt ja eigentlich gar nichts,

87
00:04:36,000 --> 00:04:39,440
aber letzten Endes geht es dahin
zu sagen, ich möchte. 

88
00:04:40,160 --> 00:04:42,800
Innerhalb meiner Sprache, wenn 
ich sie, wenn ich sie schreibe, 

89
00:04:42,800 --> 00:04:46,560
eine sehr solide Codebase haben,
eine Codebase, die sehr lange 

90
00:04:46,560 --> 00:04:50,320
wartbar ist und in der 
Ausführung hätte ich gerne 

91
00:04:50,320 --> 00:04:53,360
keinen Garbage Collector, also 
sehr viel im Bezug auf 

92
00:04:53,360 --> 00:04:58,840
Performance und da reiht sich 
dann Rust irgendwo zwischen C 

93
00:04:58,920 --> 00:05:05,000
Java und C plus Plus und C. 
Auf der anderen Seite, direkt in

94
00:05:05,000 --> 00:05:09,600
der Mitte ein und dort. 
Erfüllt es seinen Platz sehr gut

95
00:05:09,600 --> 00:05:14,000
und grundsätzlich sind die die 
Dinge, die momentan da gemacht 

96
00:05:14,000 --> 00:05:15,240
wird. 
Es wird ja auch viel darüber 

97
00:05:15,240 --> 00:05:16,720
gesprochen. 
Ja, Rust ist jetzt im Linux 

98
00:05:16,720 --> 00:05:19,680
Kernel und so weiter es stimmt 
auch alles, aber wie gesagt, ich

99
00:05:19,680 --> 00:05:22,920
verwende Rust hauptsächlich im 
Rahmen von Cross Plattform 

100
00:05:22,920 --> 00:05:25,160
Entwicklung für Mobile und 
Desktop Entwicklung und da kann 

101
00:05:25,400 --> 00:05:28,080
man das sehr gut einsetzen und 
auch sehr gut in andere 

102
00:05:28,240 --> 00:05:32,280
Programmiersprachen integrieren,
beispielsweise also wenn ich 

103
00:05:32,280 --> 00:05:34,160
noch mal auf die Frage 
zurückkomme, wenn wir es 

104
00:05:34,160 --> 00:05:37,280
einordnen müssen, dann haben wir
diese Hochsprachen in Bezug auf.

105
00:05:38,000 --> 00:05:42,320
In Bezug auf Sishab und Java. 
Und dann haben wir sowas wie C 

106
00:05:42,320 --> 00:05:45,200
und C plus Plus und genau damit 
dann in der Mitte können wir, 

107
00:05:45,200 --> 00:05:47,120
dann können wir den Rust 
einsetzen. 

108
00:05:48,400 --> 00:05:51,560
Und Marcel sagt noch einmal 
schnell von der Zeitskala her 

109
00:05:51,560 --> 00:05:55,520
ist Rust ja deutlich ne deutlich
aktuellere Sprache, sag ich mal.

110
00:05:55,600 --> 00:05:58,800
Also C und C plus Plus sind ja 
schon vor ewigen Zeiten, standen

111
00:05:58,800 --> 00:06:01,440
da nämlich gar nicht fest. 
Ich weiß gar nicht wann, aber 

112
00:06:01,440 --> 00:06:06,800
Rust gibt es seit wann ungefähr 
pi mal Auge. 2021 ist, wenn ich 

113
00:06:06,800 --> 00:06:12,640
das richtig im Kopf habe, die, 
die 1.0 rausgekommen war es 2019

114
00:06:12,640 --> 00:06:15,280
also letzten Endes ist das ne 
relativ junge Sprache. 

115
00:06:15,520 --> 00:06:18,560
Also jünger als und so weiter 
alles auf jeden Fall ja. 

116
00:06:18,560 --> 00:06:22,400
Genau, und das hat natürlich 
auch den Vorteil, dass das eine 

117
00:06:22,400 --> 00:06:26,400
neuere Sprache von den älteren 
Fehlern eben lernen kann. 

118
00:06:26,680 --> 00:06:28,400
Es gibt es auch bestimmte Dinge,
die. 

119
00:06:28,800 --> 00:06:32,000
Die bei Rust im Vergleich 
beispielsweise zur CMC Plus Plus

120
00:06:32,080 --> 00:06:34,560
nicht gegeben ist. 
Zum Beispiel die Geschichte mit 

121
00:06:34,560 --> 00:06:39,360
den Headern ich hab, ich halte 
regelmäßig Trainings in in Rust 

122
00:06:39,360 --> 00:06:42,720
für für Leute, die momentan COLC
plus plus schreiben und da gab 

123
00:06:42,720 --> 00:06:44,800
es auch schon mal die Frage, ja,
wie sieht denn das aus, wenn ich

124
00:06:44,800 --> 00:06:49,000
jetzt Header ausgeben möchte, 
aber die Implementierung nicht, 

125
00:06:49,000 --> 00:06:51,360
sondern die möchte ich nominär 
ausgeben, wie kann ich das denn 

126
00:06:51,360 --> 00:06:53,360
machen? 
Das ist beispielsweise auch ne 

127
00:06:53,360 --> 00:06:54,880
Sache. 
Also ich bin da jetzt nicht 

128
00:06:55,040 --> 00:06:58,720
blind Links hier unterwegs, sage
Rust ist das Beste, das muss man

129
00:06:58,720 --> 00:07:02,320
unbedingt einsetzen und das ist 
beispielsweise dann ein ein 

130
00:07:02,320 --> 00:07:06,480
Thema, wo wo ich sage, da hat 
Rust nichts zu bieten, weil sie 

131
00:07:06,480 --> 00:07:12,000
sagen, alles was was ich, was 
ich verbreite, ist auf Basis von

132
00:07:12,000 --> 00:07:14,720
dem kompletten Quellcode und ich
kann jetzt beispielsweise keine 

133
00:07:14,720 --> 00:07:17,840
Header Dateien ausliefern und 
dagegen dann später Linken, das 

134
00:07:17,840 --> 00:07:21,440
unterstützt Rust nicht. 
Dafür gibt es n sehr starkes 

135
00:07:21,760 --> 00:07:25,520
Modulsystem, aus meiner Sicht 
auch übersichtlicher als wie man

136
00:07:25,520 --> 00:07:27,280
das in in C und C plus Plus 
kennt. 

137
00:07:27,280 --> 00:07:29,280
Aber ich bin natürlich auch da n
bisschen parteiisch. 

138
00:07:29,840 --> 00:07:31,920
Vielleicht noch mal für unsere 
Zuhörer kurz, was du jetzt 

139
00:07:31,920 --> 00:07:34,960
gesagt hast, ist schon sehr 
tief, also Header und verlinken 

140
00:07:34,960 --> 00:07:37,600
und so weiter das mal n bisschen
aufzuklären. 

141
00:07:37,680 --> 00:07:39,520
Ich hab ja auch so meine Wurzel 
in C plus plus. 

142
00:07:39,520 --> 00:07:42,480
Ich bin leider sehr eingerostet,
eingerostet da. 

143
00:07:43,040 --> 00:07:46,880
Was C plus plus alleine angeht, 
weil bei Rust lerne ich heute 

144
00:07:46,880 --> 00:07:49,480
auch genau während so Zuhörer, 
was die Sprache hergibt und so 

145
00:07:49,480 --> 00:07:52,120
weiter hab ich tatsächlich noch,
leider noch nie die Zeit gehabt 

146
00:07:52,120 --> 00:07:53,920
mich tief mit zu befassen und 
auch nur irgendwas zu 

147
00:07:53,920 --> 00:07:57,120
programmieren, aber kurz gesagt 
in C plus Plus gibt es 

148
00:07:57,120 --> 00:07:59,760
tatsächlich n ziemlich starken 
Unterschied, den gibt es in 

149
00:07:59,760 --> 00:08:02,360
Python und in wenn man so Python
oder Javascript macht, da kennt 

150
00:08:02,360 --> 00:08:04,240
man den überhaupt nicht, da weiß
man gar nicht wovon die 

151
00:08:04,240 --> 00:08:08,240
sprechen, die Jungs mit Header 
und Source file ja sogenannte ja

152
00:08:08,240 --> 00:08:11,120
die haben. 
Auch historisch über die über 

153
00:08:11,120 --> 00:08:13,040
die Zeiten irgendwie bestimmte 
Endungen. 

154
00:08:13,280 --> 00:08:17,120
Die sind aber auch nicht strikt,
also mal Punkt h für Header, 

155
00:08:17,120 --> 00:08:22,800
also ne H wie Header oder HPP 
für Header plus plus oder wenn 

156
00:08:22,800 --> 00:08:25,680
ich da templates drin hab oder 
irgendsowas und dann halt das 

157
00:08:25,680 --> 00:08:29,000
Punkt C file in das ist 
eigentlich Standard in C. 

158
00:08:29,000 --> 00:08:31,080
Das heißt immer Punkt C 
eigentlich, da hab ich noch 

159
00:08:31,080 --> 00:08:33,360
nichts anderes gesehen und C 
plus plus heißt ganz oft Punkt 

160
00:08:33,360 --> 00:08:38,559
CPP, also für C plus plus 
Morales ja und tatsächlich muss 

161
00:08:38,559 --> 00:08:40,159
ich. 
Wenn ich jetzt in dieser 

162
00:08:40,159 --> 00:08:44,720
Programmiersprache C plus, Plus 
oder C mich befinde, meinen 

163
00:08:44,720 --> 00:08:47,280
Code, den ich schreibe, 
aufteilen zwischen diesen, 

164
00:08:47,360 --> 00:08:51,800
zwischen diesem Header file und 
dem ja, dem Source File 

165
00:08:51,800 --> 00:08:55,040
implementierungspfeil, und das 
ist, das ist am Anfang schwer zu

166
00:08:55,040 --> 00:08:57,040
erklären, für Leute, die da 
reinkommen, warum, warum zur 

167
00:08:57,040 --> 00:08:58,880
Hölle muss man das machen, das 
muss man mit vielen anderen 

168
00:08:58,880 --> 00:09:01,280
Programmiersprachen auch nicht 
machen, ja, und es hat aber. 

169
00:09:01,640 --> 00:09:04,040
Es hat es hat da, es hat damit 
auch, also ich glaube, es ist 

170
00:09:04,040 --> 00:09:06,640
erstmal, weil es historisch ist 
und weil man früher jedes 

171
00:09:06,640 --> 00:09:09,680
einzelne Byte sparen musste und 
so weiter und weil, weil es 

172
00:09:09,680 --> 00:09:12,120
einen Compiler und einen Linker 
gibt, den wir jetzt nicht näher 

173
00:09:12,120 --> 00:09:16,000
drauf eingehen, aber es gibt 
schon seine Gründe und nur kurz 

174
00:09:16,000 --> 00:09:20,080
gesprochen, im Header erzähl ich
eigentlich im Prinzip nur, wie 

175
00:09:20,080 --> 00:09:23,520
die Funktion aussieht, ich 
deklariere sie typischerweise, 

176
00:09:23,520 --> 00:09:25,960
also ich kann sehen, es gibt die
Funktion, die heißt, die hat den

177
00:09:25,960 --> 00:09:29,320
Namen so und so, die die wird 
zurückgeben, den den den 

178
00:09:29,320 --> 00:09:31,200
Datentyp so und so, und sie 
wird. 

179
00:09:31,520 --> 00:09:35,680
Erwarten die Eingabeargumente 
vom Typ Integer, integer, String

180
00:09:35,680 --> 00:09:38,120
oder Irgendsowas? 
Das kann ich hinschreiben und 

181
00:09:38,120 --> 00:09:40,720
dann reicht n Semikolon dahinter
und dann bin ich fertig mit dem 

182
00:09:40,720 --> 00:09:44,800
Header und hab die Funktion 
deklariert wie man sagt und dann

183
00:09:44,800 --> 00:09:49,280
gehe ich in den in den in das 
Source File und nenne sie quasi 

184
00:09:49,280 --> 00:09:53,360
noch mal ganz leicht anderen 
Regeln und implementiere sie. 

185
00:09:53,360 --> 00:09:55,640
Da will ich die Klammer die 
nachdem ich das wieder 

186
00:09:55,640 --> 00:09:57,520
hingeschrieben hab die Funktion 
mach ich dann die geschweifte 

187
00:09:57,520 --> 00:10:00,080
Klammer auf. 
Und quasi das, was die 

188
00:10:00,160 --> 00:10:03,040
Programmiersprache, was ich, was
ich wirklich machen will, was 

189
00:10:03,040 --> 00:10:06,400
die Funktion tun soll, wenn sie 
aufgerufen wird von außen, da 

190
00:10:06,400 --> 00:10:09,360
steht dann normalerweise im 
Source file ne und jetzt kurz 

191
00:10:09,360 --> 00:10:11,840
das aufzuräumen mit dem linken 
und so weiter also wir haben ja 

192
00:10:11,840 --> 00:10:14,760
bei den C und ich glaub bei Rust
auch du griffst nicht weg, das 

193
00:10:14,760 --> 00:10:16,600
ist ja ne kompilierte Sprache, 
das haben wir noch gar nicht 

194
00:10:16,600 --> 00:10:18,600
gesagt, aber wir haben einen 
Compiler der darüber läuft, 

195
00:10:18,600 --> 00:10:20,400
genau. 
Der ist sehr, sehr wichtig. 

196
00:10:20,920 --> 00:10:22,160
Genau. 
Wir haben ja nämlich das da, 

197
00:10:22,240 --> 00:10:24,200
die, so kann man die 
Programmiersprachen so n 

198
00:10:24,200 --> 00:10:26,840
bisschen kategorisieren, es gibt
die die kompiliert werden, das 

199
00:10:26,840 --> 00:10:31,000
ist nämlich CC plus plus Rust. 
Ja und auch Java zum Beispiel 

200
00:10:31,000 --> 00:10:33,440
wird kompiliert, da muss man 
schon n bisschen gucken, da ist 

201
00:10:33,440 --> 00:10:36,680
so n bisschen n grauer Bereich, 
weil da so ne virtuelle Engine 

202
00:10:36,680 --> 00:10:39,600
ist, die da kompiliert ja, aber 
genau weil ich, ich würde sie zu

203
00:10:39,600 --> 00:10:41,880
den kompilierenden Sprachen 
zählen, jetzt krieg ich gleich n

204
00:10:41,880 --> 00:10:44,480
paar Kommentare im Nachgang, 
aber egal nehm ich den Kauf ich.

205
00:10:44,480 --> 00:10:47,520
Unterstütz das, ich unterstütz 
es wird ja bald kompiliert. 

206
00:10:48,080 --> 00:10:50,800
Richtig so. 
Und aber das und das genau der 

207
00:10:50,800 --> 00:10:54,000
Byte Code wird kompiliert und 
jetzt kommt was Wichtiges, das 

208
00:10:54,000 --> 00:10:57,560
was dann da rauskommt ist dann 
sind ist 1 von 2 Sachen entweder

209
00:10:57,560 --> 00:11:00,720
es ist direkt n Programm was ich
ausführen kann, Executable in 

210
00:11:00,720 --> 00:11:04,080
Maschinencode und der ist dann 
auch sehr performant und da muss

211
00:11:04,080 --> 00:11:06,880
ich auch aufpassen, dass der 
Compiler quasi den richtigen 

212
00:11:06,880 --> 00:11:09,720
Maschinencode für die richtige 
Plattformarchitektur kompiliert 

213
00:11:09,720 --> 00:11:12,440
und so das ist nicht alles so 
einmal kompiliert und dann geht 

214
00:11:12,440 --> 00:11:13,920
das überall, da muss n bisschen 
gucken. 

215
00:11:14,480 --> 00:11:16,680
Oder aber das zweite ist, wenn 
nicht n ausführbares Programm 

216
00:11:16,680 --> 00:11:19,600
direkt rauskommt, dann kommt 
eine sogenannte Bibliothek raus.

217
00:11:20,000 --> 00:11:22,760
Also das ist quasi einfach nur n
zusammengepackter binärer Haufen

218
00:11:22,760 --> 00:11:25,520
von diesen Funktionen, die wir 
gerade besprochen haben, die die

219
00:11:25,520 --> 00:11:29,440
dann wieder in einem in einer 
weiteren Executable reingelinkt 

220
00:11:29,440 --> 00:11:31,840
werden können. 
Also ich quasi mach ich nen Sack

221
00:11:31,840 --> 00:11:34,760
von Funktionalität fertig schnür
den oben zu sag das ist jetzt 

222
00:11:34,760 --> 00:11:36,960
hier irgendwie ne 
bildverarbeitungssack 

223
00:11:36,960 --> 00:11:39,440
Funktionalität. 
Und dann kommt ein anderer 

224
00:11:39,440 --> 00:11:42,160
Kollege hin, der sagt, Ich habe 
jetzt hier ein kleines Programm,

225
00:11:42,240 --> 00:11:44,800
da lese ich einfach nur von 
einer Platte ein und jetzt nutze

226
00:11:44,800 --> 00:11:49,040
ich den Bibliothekskram aus dem 
Sack und Linke den verbinde den 

227
00:11:49,040 --> 00:11:53,200
quasi bytecode technisch mit 
meinem Code und dann habe ich 

228
00:11:53,200 --> 00:11:55,600
was neues Großes geschaffen. 
Ne so, jetzt habe ich viel 

229
00:11:55,600 --> 00:11:58,640
erzählt damit wir verstehen 
ungefähr was ist ne libry und 

230
00:11:58,640 --> 00:12:02,240
diese libry Teile, die stehen 
halt quasi normalerweise halt 

231
00:12:02,240 --> 00:12:04,600
nicht im Header, sondern die 
werden halt durch implementiert 

232
00:12:04,600 --> 00:12:06,760
und jetzt gibt es bei C plus 
plus ganz modern und ganz 

233
00:12:06,760 --> 00:12:08,840
schick. 
Das hat mit Template zu tun, das

234
00:12:08,840 --> 00:12:10,120
lass ich jetzt weg. 
Wir wollen uns über Rust 

235
00:12:10,120 --> 00:12:12,960
unterhalten, die Möglichkeit 
aber auch diesen Sack von 

236
00:12:12,960 --> 00:12:16,400
Funktion tatsächlich im Header 
zu bauen, das heißt, ich lass im

237
00:12:16,400 --> 00:12:21,600
Prinzip dieses CCPP oder C File 
weg, in C geht das nicht, aber 

238
00:12:21,600 --> 00:12:24,160
in C Plus geht das und ich 
schreib dann nur noch im Header 

239
00:12:24,160 --> 00:12:28,080
alles hin, das hat den Vorteil, 
dass ich nicht mehr linken muss 

240
00:12:28,080 --> 00:12:31,040
im Prinzip, sondern ich kann es 
direkt reinkompilieren es ist so

241
00:12:31,040 --> 00:12:33,720
wie ich hab es gerade 
mitgeschrieben in dem in dem 

242
00:12:33,720 --> 00:12:36,920
neuen Code und das hat den neuen
großen Vorteil ist es. 

243
00:12:37,000 --> 00:12:40,880
Cross Plattform per Definition 
ja, weil also fast, also weil 

244
00:12:40,880 --> 00:12:42,320
weil ich keinen Byte Code mehr 
hab. 

245
00:12:42,320 --> 00:12:45,440
Ich hab immer minus immer minus 
n paar ganz krasse Edge Cases 

246
00:12:45,440 --> 00:12:48,480
Cases ja aber im Prinzip war das
sehr portabel das ganze Ding ja 

247
00:12:48,960 --> 00:12:51,840
aber ich hab halt den Nachteil, 
dass auch der Code lesbar 

248
00:12:51,840 --> 00:12:52,960
bleibt. 
Ja da kann ich nichts mehr 

249
00:12:52,960 --> 00:12:55,360
verstecken, ist halt kein 
Maschinencode ja ist halt wie 

250
00:12:55,840 --> 00:12:58,480
wie Open Source dran geklebt ja 
das ist halt auch so n Ding kann

251
00:12:58,480 --> 00:13:01,520
man machen aber ist dann 
irgendwie ja so. 

252
00:13:01,760 --> 00:13:04,320
Und du sagst jetzt, da gab es 
jetzt Leute, die haben gesagt, 

253
00:13:04,320 --> 00:13:07,680
ja, und warum kann ich in Rust 
nicht auch Header Bibliotheken 

254
00:13:07,680 --> 00:13:10,400
schreiben, wo ich gar kein 
binäres Paket hab, was ich 

255
00:13:10,400 --> 00:13:12,160
irgendwo gegenlinken muss, 
sondern ich will es irgendwie 

256
00:13:12,160 --> 00:13:14,000
einfach mitnehmen. 
Ja und du sagst das kann Rust 

257
00:13:14,000 --> 00:13:16,640
heute zum Beispiel noch nicht. 
Ja richtig, jetzt hab ich lange 

258
00:13:16,640 --> 00:13:18,960
viel erzählt, aber ich glaube es
war vielleicht noch mal zum 

259
00:13:18,960 --> 00:13:20,960
Verständnis. 
Das ist doch wunderbar. 

260
00:13:20,960 --> 00:13:23,360
Das ist natürlich immer 
schwierig, die Dinge. 

261
00:13:23,760 --> 00:13:26,560
So zu erklären, dass sie dann 
auch alle abholen, weil man dann

262
00:13:26,560 --> 00:13:28,160
nicht genau weiß, wer dann 
zuhört. 

263
00:13:28,160 --> 00:13:30,480
Aber letzten Endes ist das genau
richtig, was du gesagt hast. 

264
00:13:30,560 --> 00:13:33,400
Du hast nur von Plattformen 
gesprochen, weil wir reden ja 

265
00:13:33,400 --> 00:13:36,080
damit von Cross Plattformen und 
was ist eine Plattform, da gibt 

266
00:13:36,080 --> 00:13:39,200
es ja die verschiedenen 
Architektur Plattformen, also 

267
00:13:39,200 --> 00:13:40,600
die 
Prozessorarchitekturplattformen 

268
00:13:40,600 --> 00:13:42,240
und dann gibt es die 
verschiedenen Betriebssysteme, 

269
00:13:42,240 --> 00:13:45,480
das ist ja sehr schwierig, dann 
auch noch dieses Wort Plattform 

270
00:13:45,480 --> 00:13:47,480
in den richtigen Kontext zu 
bringen, aber du hast vollkommen

271
00:13:47,480 --> 00:13:50,480
recht und bei dem Header ist es 
so und da hast du auch 

272
00:13:50,480 --> 00:13:54,280
vollkommen recht. 
Ist die Idee, dass man, ich will

273
00:13:54,280 --> 00:13:57,280
es vielleicht auch so, als 
Schnittstelle definieren, also 

274
00:13:57,280 --> 00:14:00,640
letzten Endes sage ich, wie 
sieht meine meine meine 

275
00:14:00,640 --> 00:14:04,320
Schnittstelle innerhalb meines C
oder C plus plus Codes aus, 

276
00:14:04,800 --> 00:14:07,960
unabhängig davon, wie ich das 
später implementiere. 

277
00:14:07,960 --> 00:14:11,360
Also ich sage nur, das ist das 
ist, was du ja auch gesagt hast,

278
00:14:11,360 --> 00:14:15,080
meine meine Funktionssignatur, 
wie man ja auch sagt, also 

279
00:14:15,080 --> 00:14:17,120
welche Parameter gehen rein, 
welche was kommt raus. 

280
00:14:17,600 --> 00:14:20,320
Und später könnt ich dann noch 
sagen, ich liefere etwas, was 

281
00:14:20,320 --> 00:14:22,640
schon die sogenannte 
Maschinensprache ist. 

282
00:14:22,720 --> 00:14:25,680
Was das Binäre ist, was schon 
auf die entsprechende 

283
00:14:26,000 --> 00:14:28,240
Prozessorarchitektur übersetzt 
wurde. 

284
00:14:28,720 --> 00:14:31,680
Ich weiß aber gar nicht, wenn 
ich das dann einsetze, was da 

285
00:14:31,680 --> 00:14:34,000
genau drin steht und das ist ein
Vorteil, weil ich bestimmte 

286
00:14:34,000 --> 00:14:37,080
Dinge nicht verraten muss, und 
das ist ein Nachteil, um jetzt 

287
00:14:37,080 --> 00:14:39,800
mal noch mal zu bestätigen, dass
es auch Nachteile bei Rusk gibt,

288
00:14:40,240 --> 00:14:43,600
wenn ich zu rusk gehe, dort habe
ich die Möglichkeit nicht zu 

289
00:14:43,600 --> 00:14:46,880
sagen, ich definiere meine meine
reine Schnittstelle. 

290
00:14:47,360 --> 00:14:49,680
Sage ich liefer das 
dementsprechend aus. 

291
00:14:49,680 --> 00:14:53,760
Ich implementiere einen ganz 
geheimen Algorithmus oder einen 

292
00:14:53,760 --> 00:14:58,400
Audiocodec, also etwas was was. 
Patentiert ist im Notfall so. 

293
00:14:58,480 --> 00:15:02,400
Was genau was patentiert ist und
was dann eine bestimmte Datei 

294
00:15:02,400 --> 00:15:06,400
dekodiert p 3 oder sowas. 
Und dann müsste ich, wenn ich 

295
00:15:06,560 --> 00:15:09,960
nur das in einem reinen Rust 
mache müsste das dementsprechend

296
00:15:09,960 --> 00:15:12,000
dann auch komplett als Quellcode
rausgeben. 

297
00:15:12,560 --> 00:15:15,880
Bei C und C plus Plus hab ich 
die Möglichkeit das auch mit den

298
00:15:15,880 --> 00:15:18,200
Header zu machen. 
Es gibt auch Umwege das mit Rust

299
00:15:18,200 --> 00:15:21,240
zu machen, aber da sind wir 
jetzt, ich wollte das nur als 

300
00:15:21,240 --> 00:15:24,480
Beispiel bringen, dass es, dass 
es nicht nur Vorteile gibt im im

301
00:15:24,480 --> 00:15:27,200
Bezug auf Rust, aber das ist 
wirklich einer der wenigen 

302
00:15:27,200 --> 00:15:29,200
Nachteile, die ich jetzt 
aufzählen werde. 

303
00:15:29,520 --> 00:15:30,840
Genau. 
Aber jetzt noch mal ganz kurz 

304
00:15:30,840 --> 00:15:33,440
gesprochen hat, hat jetzt Rust 
also gar nicht das Konzept von 

305
00:15:33,440 --> 00:15:37,440
Headers und Source. 
Es gibt keine Header Dateien in 

306
00:15:37,440 --> 00:15:40,000
Rust. 
Es gibt letzten Endes nur. 

307
00:15:40,160 --> 00:15:44,320
RS Dateien, also was den was den
Quellcode angeht und die 

308
00:15:44,640 --> 00:15:47,720
strukturiere ich. 
Ich glaube, wenn ich das richtig

309
00:15:47,720 --> 00:15:51,680
im Kopf habe, so wie das auch 
bei bei C plus plus Einzug hält 

310
00:15:51,840 --> 00:15:56,960
in Module und diese Module kann 
ich komplett schneiden wie ich 

311
00:15:56,960 --> 00:16:01,040
möchte und habe aber keine 
zusätzliche Definition einer 

312
00:16:01,040 --> 00:16:04,000
Schnittstelle die ich irgendwie 
linken muss, sondern ich hab 

313
00:16:04,000 --> 00:16:06,960
eine gewisse Struktur innerhalb 
meines Codes. 

314
00:16:07,280 --> 00:16:11,040
Nicht diese 2 Ebenen von von 
Headern und der jeweiligen 

315
00:16:11,040 --> 00:16:12,480
Orientierung. 
Got it. 

316
00:16:13,040 --> 00:16:15,280
Und gleich wenn wir da sind, da 
können wir gleich n bisschen, 

317
00:16:15,280 --> 00:16:17,280
wir gehen ja sowieso n bisschen 
unter die Haube der Sprache, 

318
00:16:17,280 --> 00:16:20,320
auch um n bisschen zu gucken. 
Marcel, Wie sieht das dann aus 

319
00:16:20,320 --> 00:16:23,440
mit den mit der wie heißt das, 
wenn ich jetzt quasi ein Modul 

320
00:16:23,440 --> 00:16:26,480
Reinlade in n anderes Rust 
Modell ist das auch n Import 

321
00:16:26,480 --> 00:16:28,880
oder wie funktioniert das? 
Was schreibe ich oben hin oder 

322
00:16:28,880 --> 00:16:31,200
inklud oder irgend so NC plus 
Plus ist ja so irgendwie inklud 

323
00:16:31,600 --> 00:16:34,320
bla bla bla ja würde ich das 
machen in Rust. 

324
00:16:34,320 --> 00:16:38,160
Das machst du mit Use. 
Also letzten Endes gibt es die 

325
00:16:38,160 --> 00:16:42,320
Möglichkeit mein meine eigene, 
mein eigenes Programm in 

326
00:16:42,320 --> 00:16:46,160
verschiedene Module zu zu 
unterteilen und dort benutze ich

327
00:16:46,160 --> 00:16:49,600
dann ein ein sogenanntes 
Schlüsselwort, also was, was 

328
00:16:49,600 --> 00:16:52,080
reserviert ist für die Sprache. 
Das nennt sich dann Mod, um dann

329
00:16:52,080 --> 00:16:57,280
bestimmte Module aufzuteilen und
wenn ich dann bestimmte Symbole,

330
00:16:57,280 --> 00:17:01,360
also etwas, was in einem anderen
Modul oder in einem anderen 

331
00:17:01,360 --> 00:17:04,880
sogenannten Crate, also das ist 
eine externe Bibliothek. 

332
00:17:05,359 --> 00:17:07,839
Die ich einbinden kann. 
Gibt jetzt beispielsweise auch 

333
00:17:07,839 --> 00:17:11,599
die die Website crades. 
IO und dort sind alle da. 

334
00:17:11,599 --> 00:17:16,560
Da ist im Prinzip die, die sind 
alle Packages genau Unterschied 

335
00:17:16,560 --> 00:17:19,079
zwischen Package und Crades, 
aber alle externen Bibliotheken 

336
00:17:19,079 --> 00:17:21,040
die es so gibt da draußen von 
der Community sind da 

337
00:17:21,040 --> 00:17:22,800
aufgelistet. 
Wenn du irgendwo gefunden werden

338
00:17:22,800 --> 00:17:25,359
willst und sagst oh ich hab 
jetzt hier meine mein super 

339
00:17:25,359 --> 00:17:28,640
webframework, dann gehst du zu 
crades IO und sagst ich 

340
00:17:28,640 --> 00:17:31,280
veröffentliche jetzt hier mal 
mein entsprechendes Crades. 

341
00:17:31,920 --> 00:17:34,760
Also so, so n bisschen wie das 
bei NPM wäre, der ganz genau 

342
00:17:34,800 --> 00:17:36,240
geht Manager von. 
Richtig, genau. 

343
00:17:36,480 --> 00:17:40,400
Und bei bei NPM ist es so, dass 
es sowohl die die Webseite gibt,

344
00:17:40,400 --> 00:17:44,800
die dann NPM heißt und auch das 
der sogenannte Package Manager. 

345
00:17:44,800 --> 00:17:48,080
Oder es gibt auch Leute, die das
als Bildsystem bezeichnen. 

346
00:17:48,080 --> 00:17:50,880
Ich ich finde, dass das 
schwierig dieses dieses Produkt 

347
00:17:50,880 --> 00:17:54,120
zu bezeichnen, aber da 
unterscheiden wir in Rust and 

348
00:17:54,120 --> 00:17:57,280
Trade, das ist das Paket, also 
ist ja die Kiste auf Englisch 

349
00:17:57,680 --> 00:18:01,760
und dann gibt es Cargo. 
Das ist dann das das Tool mit 

350
00:18:01,760 --> 00:18:05,680
dem ich das alles verwalte. 
Also ich verwalte wie heißt mein

351
00:18:05,680 --> 00:18:07,600
mein Projekt, wie heißt meine 
Applikation oder meine 

352
00:18:07,600 --> 00:18:11,360
Bibliothek, was sind meine 
Dependencies, die dann auf die 

353
00:18:11,520 --> 00:18:15,240
die Crades IO standardmäßig 
Liste und der oder die die 

354
00:18:15,240 --> 00:18:19,200
Bibliothek dort verlinkt und 
sagt Ich möchte beispielsweise 

355
00:18:19,200 --> 00:18:22,800
Tokyo verwenden und da was 
implementieren, das ist etwas 

356
00:18:23,200 --> 00:18:26,080
was in der asynchronen 
Programmierung gerne verwendet 

357
00:18:26,080 --> 00:18:28,960
wird, oder ein Webframework 
namens Exum. 

358
00:18:29,520 --> 00:18:33,280
Und das trag ich dann dort in 
meine sogenannte Cargo tommel. 

359
00:18:33,280 --> 00:18:38,160
Tommel ist eine bestimmte 
Auszeichnungssprache, um zu 

360
00:18:38,160 --> 00:18:41,280
strukturieren, so heißt mein 
Programm, das ist die Version 

361
00:18:41,280 --> 00:18:42,960
von Rust, die ich verwenden 
möchte, das sind meine 

362
00:18:42,960 --> 00:18:45,080
Dependencies. 
Folgendes ist noch wichtig für 

363
00:18:45,080 --> 00:18:47,200
den Compiler et cetera, das trag
ich da ein. 

364
00:18:47,360 --> 00:18:50,040
Im Java Space ist das 
beispielsweise die POMM XML, die

365
00:18:50,040 --> 00:18:52,360
man bei Melvin kennt. 
Das das ist. 

366
00:18:52,360 --> 00:18:55,120
Alle Programmiersprachen haben 
ja so n Ökosystem um sich rum. 

367
00:18:55,120 --> 00:18:56,760
Richtig. 
Und bei und. 

368
00:18:56,800 --> 00:18:59,600
Du hast, du hast das also 
genannt, ne dieses Cargo. 

369
00:18:59,680 --> 00:19:02,560
Cargo genau, wenn wenn ich 
standardmäßig gehst, geht man 

370
00:19:02,560 --> 00:19:03,880
hin. 
Wenn man jetzt anfängt und sagt 

371
00:19:03,880 --> 00:19:06,480
ich möchte also wenn ich meine 
Trainings beginne, fangen wir an

372
00:19:06,480 --> 00:19:08,640
zu sagen, ich möchte erstmal 
Rust installieren, dann gibt es 

373
00:19:08,640 --> 00:19:12,240
etwas, das nennt sich Rust. 
Mit dem verwalte ich die 

374
00:19:12,240 --> 00:19:14,480
entsprechenden Stand die die 
entsprechenden 

375
00:19:14,480 --> 00:19:17,360
Standardbibliotheken, die 
sogenannten Compy Targets, also 

376
00:19:17,360 --> 00:19:20,160
das von von verschiedenen 
Plattformen gesprochen. 

377
00:19:20,640 --> 00:19:25,680
Prozessorarchitekturplattformen,
und die spreche ich ja mit Rust 

378
00:19:25,680 --> 00:19:27,760
direkt an. 
Wenn ich jetzt Java 

379
00:19:27,760 --> 00:19:30,080
beispielsweise nehme, dann haben
wir vorhin drüber gesprochen, 

380
00:19:30,080 --> 00:19:33,280
da, dann gibt es einen Byte 
Code, dieser Byte Code läuft auf

381
00:19:33,280 --> 00:19:37,640
einer virtuellen Maschine, 
deswegen brauche ich für für 

382
00:19:37,640 --> 00:19:40,640
Java wenn ich was kompiliere 
keine verschiedenen compile 

383
00:19:40,640 --> 00:19:43,280
targets, das brauche ich aber in
Rust. 

384
00:19:43,600 --> 00:19:47,360
Diese verwalte ich mit Rust ab. 
Das installier ich damit und mit

385
00:19:47,360 --> 00:19:49,000
Rust. 
Nachdem ich Rust installiert 

386
00:19:49,000 --> 00:19:52,800
habe und der Rust Compiler kommt
dann mit und auch Cargo und das 

387
00:19:52,800 --> 00:19:56,240
Standardwerk Weißt du oder den 
Standardschritt, den man in 

388
00:19:56,240 --> 00:19:58,240
jeder Programmiersprache macht, 
ist das Hello World. 

389
00:19:58,440 --> 00:20:02,880
Man geht dann hin und sagt dann 
Cargo New, Hello World und dann 

390
00:20:02,880 --> 00:20:06,160
bekomme ich mein meine kleine 
Binary, hab da meine meine Main 

391
00:20:06,160 --> 00:20:09,480
Funktion drin, also der 
Startpunkt eines Programms und 

392
00:20:09,480 --> 00:20:13,360
dort kann ich dann sagen Hallo 
mein Name ist Marcel und ich 

393
00:20:13,360 --> 00:20:15,440
spiele gerne Gitarre so und 
dann. 

394
00:20:16,080 --> 00:20:19,440
Gibt man das raus, kompiliert 
das dann mit Cargo Bild oder 

395
00:20:19,440 --> 00:20:23,960
führt Cargo Run aus und dann hat
man das, was man standardmäßig 

396
00:20:23,960 --> 00:20:27,120
auf seiner jeweiligen 
Prozessorarchitektur hat schon 

397
00:20:27,120 --> 00:20:30,880
geliefert, führt das aus und hat
seine sogenannte Executable, 

398
00:20:30,880 --> 00:20:35,760
also wirklich die die Datei in 
der Maschinensprache ohne 

399
00:20:35,760 --> 00:20:39,280
Runtime und das muss ich noch 
mal unterstreichen, ohne Garbage

400
00:20:39,280 --> 00:20:41,760
Collection. 
Das ist einfach das Ding, was, 

401
00:20:41,760 --> 00:20:44,120
was dann ausgeführt wird ohne 
zusätzliches Zeug. 

402
00:20:44,120 --> 00:20:46,760
Das ist auch n Vorteil, wenn man
es dann deployen will später und

403
00:20:46,760 --> 00:20:49,760
sagt, ich möchte beispielsweise 
auf einem genux Server was 

404
00:20:49,760 --> 00:20:54,440
laufen lassen, Du hast am Ende 
nur eine Datei, eine Binary die 

405
00:20:54,440 --> 00:20:57,440
du hast, die du hochladen musst 
und dann führst du das einfach 

406
00:20:57,440 --> 00:20:59,080
aus. 
Bei Go ist das beispielsweise 

407
00:20:59,080 --> 00:21:02,800
auch so, das ist aber der der 
immense Vorteil Vergleich wenn 

408
00:21:02,800 --> 00:21:06,960
du jetzt Note, JS oder Java oder
dot net und so weiter 

409
00:21:07,040 --> 00:21:09,680
entwickelst, weil die brauchen 
ja immer noch ihre ihre Runtime.

410
00:21:10,320 --> 00:21:13,320
Und das ist auch ein Vorteil. 
Nicht nur, wenn ich das jetzt 

411
00:21:13,320 --> 00:21:15,520
auf dem News Server hochlade, 
sondern wenn wenn ich 

412
00:21:15,520 --> 00:21:19,120
beispielsweise auch etwas machen
möchte wie Web Assembly 

413
00:21:19,120 --> 00:21:22,640
entwickeln, was ja wieder dann 
Byte Code im Browser ist. 

414
00:21:22,800 --> 00:21:24,160
Aber da kommen wir vielleicht 
gleich dazu. 

415
00:21:24,240 --> 00:21:27,680
So aber letzten Endes ist es so,
Cargo ist der ist der 

416
00:21:27,680 --> 00:21:30,320
Einsprungspunkt damit fängt 
alles an. 

417
00:21:30,720 --> 00:21:34,640
Also ich würde mal sagen 99,9% 
aller Brus Projekte basieren auf

418
00:21:34,640 --> 00:21:37,520
Cargo, da gehe ich hin cargo 
New. 

419
00:21:37,800 --> 00:21:40,080
Kann loslegen. 
Tragt auch meine Dependencies 

420
00:21:40,080 --> 00:21:43,440
ein, wenn ich welche haben 
möchte und dann kann ich 

421
00:21:43,440 --> 00:21:46,080
loslegen, auch in inklusive Test
und allem. 

422
00:21:46,640 --> 00:21:49,600
Und sag mal jetzt, wir müssen da
gleich glaub ich n bisschen den 

423
00:21:49,600 --> 00:21:51,400
Speed hochdrehen, weil wir noch 
n bisschen bei den Dependencies,

424
00:21:51,400 --> 00:21:52,960
aber es interessiert mich 
trotzdem, weil das sind auch so 

425
00:21:52,960 --> 00:21:54,960
die wichtigen Sachen, auch wo 
man ja auch als Entwickler 

426
00:21:54,960 --> 00:21:57,760
irgendwie rumstolpert, wenn man,
wenn man mit den Dependencies 

427
00:21:57,760 --> 00:21:59,680
nicht klar kommt. 
Sag noch mal schnell, wie 

428
00:21:59,680 --> 00:22:01,560
funktioniert das? 
Ich weiß ja, NC plus plus zum 

429
00:22:01,560 --> 00:22:03,920
Beispiel, wenn ich jetzt, wenn 
ich jetzt ne Dependency nehme, 

430
00:22:03,920 --> 00:22:06,240
dann muss ich auch aufpassen, 
dass ich die Mitschiffe, dass 

431
00:22:06,240 --> 00:22:08,560
die auch richtig gefunden wird 
auf dem Betriebssystem und so 

432
00:22:08,560 --> 00:22:11,120
weiter das ist n also das Macht 
ja auch der Linke und der kann 

433
00:22:11,120 --> 00:22:13,080
das zu Runtime machen, zu 
compile Zeit und so weiter das 

434
00:22:13,080 --> 00:22:14,800
ist hinlänglich komplex, der 
ganze Kram. 

435
00:22:14,800 --> 00:22:16,520
Damit muss man sich wirklich 
lange befassen und das 

436
00:22:16,520 --> 00:22:19,040
ordentlich hinkriegen, ja nur 
vielleicht ein 2 Sätze, wie 

437
00:22:19,040 --> 00:22:20,960
funktioniert das denn? 
Rust and ist in deiner 

438
00:22:20,960 --> 00:22:23,280
Executable in der Hello World 
und sagen wir mal die Hello 

439
00:22:23,280 --> 00:22:26,320
World braucht jetzt. 
Zeigt das an in einem Fenster 

440
00:22:26,320 --> 00:22:28,520
und hat noch nen 3 d blinkie 
Blinkie oder irgendsowas und 

441
00:22:28,520 --> 00:22:30,440
braucht dafür ne fette 
Bibliothek, die jemand anders 

442
00:22:30,440 --> 00:22:33,360
schon gemacht hatte in Rust. 
So die du jetzt mit deinem Cargo

443
00:22:33,360 --> 00:22:35,600
da und deinem Trommel und so 
weiter alles hin formuliert hast

444
00:22:35,600 --> 00:22:37,040
und die hast du jetzt damit 
eingebunden. 

445
00:22:37,040 --> 00:22:41,000
Ja wird die jetzt in den Byte 
Code mit Einkompiliert 

446
00:22:41,000 --> 00:22:43,000
geschmissen, so ist das dann 
einfach n bisschen dicker, das 

447
00:22:43,000 --> 00:22:45,440
Ding hat das dann irgendwie 
nicht was weiß ich 2 Kilobyte 

448
00:22:45,440 --> 00:22:47,800
sondern irgendwie dann 4 
Megabyte und das ist alles drin 

449
00:22:47,800 --> 00:22:49,840
und es isoliert und funktioniert
einfach. 

450
00:22:50,160 --> 00:22:52,480
Oder muss ich das Ding irgendwie
auf n System verteilen, finden, 

451
00:22:52,480 --> 00:22:54,800
suchen oder irgendwas? 
Also kannst du da noch mal 2 

452
00:22:54,800 --> 00:22:56,160
Sätze zu. 
Sagen da, da steckt der Teufel 

453
00:22:56,160 --> 00:22:58,240
natürlich im Detail. 
Standardmäßig ist das die 

454
00:22:58,240 --> 00:22:59,840
Antwort, die du schon selbst 
gegeben hast. 

455
00:22:59,840 --> 00:23:01,560
Und dann möcht ich noch mal 
korrigieren, ist kein buyte 

456
00:23:01,560 --> 00:23:04,160
Code, sondern tatsächlich n 
Maschinencode und Maschinencode.

457
00:23:04,160 --> 00:23:07,560
Ja ja wunderbar, wollen ja nur 
wollen das Gleiche wollen ja die

458
00:23:07,600 --> 00:23:12,720
die Wahrheit finden ja ja und 
letzten Endes ist das Binary 

459
00:23:12,720 --> 00:23:16,040
dann deutlich größer, weil. 
Standardmäßig, das stimmt nicht 

460
00:23:16,040 --> 00:23:17,720
in allen Fällen, aber 
standardmäßig wird das dann 

461
00:23:17,720 --> 00:23:20,000
alles mit rein kompiliert, 
sodass du am Ende eben nur 

462
00:23:20,000 --> 00:23:23,000
dieses eine Binary hast und 
diesen ganzen Hassel und das ist

463
00:23:23,000 --> 00:23:25,120
auch n Argument, dass ich immer 
wieder in den Trainings bringe. 

464
00:23:25,440 --> 00:23:28,840
Du hast bei bei den beim C oder 
C Plus plus Ökosystem hast du 

465
00:23:28,840 --> 00:23:30,440
ganz viele verschiedene 
Möglichkeiten, wie du an die 

466
00:23:30,440 --> 00:23:32,120
Packages kommst. 
Wie du das Einbildest, dann gibt

467
00:23:32,120 --> 00:23:35,360
es viel mehr cemake und und 
verschiedene Möglichkeiten das 

468
00:23:35,360 --> 00:23:39,680
das das einzubinden wenn es um 
rein Rust geht ist das total 

469
00:23:40,160 --> 00:23:42,520
einfach im Vergleich, zumindest 
wenn du mich fragst weil du 

470
00:23:42,520 --> 00:23:45,280
sagst ich hab mein crades IO. 
Das binde ich ein. 

471
00:23:45,680 --> 00:23:48,080
Das sorgt dafür, dass dass, dass
ich das verwenden kann, dann 

472
00:23:48,080 --> 00:23:50,440
baue ich das, dann ist das 
Reinkompiliert und fertig ist 

473
00:23:50,440 --> 00:23:54,160
die Kiste. 
OK, God it, wow. 

474
00:23:55,280 --> 00:23:58,640
Ich wurde noch nicht so schnell 
so doll abgehängt, aber aber es 

475
00:23:58,640 --> 00:24:02,000
ist, aber es ist richtig cool. 
Es es ist halt, es ist halt auch

476
00:24:02,000 --> 00:24:03,840
n sehr sehr sehr breites und 
tiefes Thema. 

477
00:24:03,840 --> 00:24:05,920
Es ist nicht so wegen ich mach 
mal n bisschen. 

478
00:24:06,240 --> 00:24:08,400
Data Science mit Python und und 
und. 

479
00:24:08,400 --> 00:24:09,760
Pandas oder so. 
Völlig richtig. 

480
00:24:09,760 --> 00:24:11,040
Ja, und das? 
Ist schwierig, ja. 

481
00:24:11,040 --> 00:24:12,400
Wollen ja auch mal ans 
Angemachte gehen. 

482
00:24:12,400 --> 00:24:15,800
Ja, hier ne nicht nur jetzt 
hattest du schon das das 

483
00:24:15,800 --> 00:24:19,120
Stichwort Garbage collection 
irgendwie schon 23 mal erwähnt. 

484
00:24:19,120 --> 00:24:22,000
Ja und auch im Vorgespräch und 
und auch in meiner Recherche, 

485
00:24:22,000 --> 00:24:24,360
ich habe ja bei mir gar keine 
Ahnung was was dahinter jetzt 

486
00:24:24,360 --> 00:24:26,160
eigentlich steckt, aber ich 
glaub das sollten wir jetzt 

487
00:24:26,160 --> 00:24:28,680
schon mal besprechen und und und
noch mal verstehen was sich 

488
00:24:28,680 --> 00:24:31,440
dahinter versteckt, ja. 
Oder eben nicht bei Rust. 

489
00:24:31,440 --> 00:24:34,120
Ja, und warum? 
Ja, lustigerweise hab ich auch 

490
00:24:34,120 --> 00:24:37,120
mit meiner Frau zusammengesessen
und dann hat sie mich auch 

491
00:24:37,120 --> 00:24:39,840
gefragt, warum ist das denn so n
so n so n dickes Ding und dann 

492
00:24:39,840 --> 00:24:42,000
hab ich ihr versucht das auch 
mal zu erklären und ich glaube 

493
00:24:42,000 --> 00:24:44,000
es ist mir auch geglückt. 
Jetzt versuch ich das mal so zu 

494
00:24:44,000 --> 00:24:46,080
wiederholen und hoffe es glückt 
mir dann noch mal. 

495
00:24:46,320 --> 00:24:49,840
Also letzten Endes ist es ja so,
wenn ich wenn ich ein Programm 

496
00:24:49,840 --> 00:24:54,000
habe, dann ist es so, dass ich 
immer irgendwie einen bestimmten

497
00:24:54,160 --> 00:24:56,800
Teil von meinem Arbeitsspeicher 
reservieren muss, indem ich 

498
00:24:56,800 --> 00:25:01,000
etwas reinschreibe so das heißt.
Ich lese beispielsweise eine 

499
00:25:01,000 --> 00:25:05,280
Datei ein und will das will 
etwas mit mit ihr machen oder 

500
00:25:05,280 --> 00:25:07,480
ich habe einen bestimmten 
String, den ich nur ausgeben 

501
00:25:07,480 --> 00:25:09,320
möchte, also zum Beispiel Hallo,
ich bin Marcel und ich spiele 

502
00:25:09,320 --> 00:25:14,760
gerne Gitarre und dann ist es 
so, dass in in vielen Sprachen, 

503
00:25:14,760 --> 00:25:17,760
die heute verwendet werden, 
darunter Python, darunter wieder

504
00:25:17,800 --> 00:25:23,520
Java, darunter auch Java Script,
ob ob, ob auf dem Server oder 

505
00:25:23,520 --> 00:25:26,640
jetzt im Browser ist selber 
dahingestellt und da wird 

506
00:25:26,640 --> 00:25:28,960
Speicher reserviert 
beziehungsweise. 

507
00:25:29,320 --> 00:25:32,160
Man spricht davon. 
Allokation, das heißt, ich sage,

508
00:25:32,160 --> 00:25:36,480
das ist mein geh weg, du, das 
ist jetzt mein Speicher und dann

509
00:25:36,480 --> 00:25:39,920
arbeite ich damit, und wenn ich 
den aber nicht mehr brauche, 

510
00:25:39,920 --> 00:25:43,080
weil ich da was eingelesen habe,
meine Operation durch ist und so

511
00:25:43,080 --> 00:25:45,320
weiter, dann kann ich den wieder
freigeben, weil irgendwann ist 

512
00:25:45,320 --> 00:25:47,920
das Ding auch aufgebraucht und 
jeder kennt das ja von sich mit,

513
00:25:48,080 --> 00:25:50,920
zumindest mit Festplatten kennt 
das jeder und auf auf den 

514
00:25:50,920 --> 00:25:52,800
Smartphones auch. 
Irgendwann ist der Speicher halt

515
00:25:52,800 --> 00:25:55,360
halt aufgebraucht und deswegen 
ist es ist es total. 

516
00:25:55,680 --> 00:25:58,560
Wichtig, dass wir den, dass wir 
den Speicher wieder freigeben 

517
00:25:58,720 --> 00:26:02,680
und in einer, in einer Sprache 
oder in den meisten Sprachen, 

518
00:26:02,680 --> 00:26:05,040
die heutzutage verwendet werden,
passiert das über die Garbage 

519
00:26:05,040 --> 00:26:08,560
Collection, das heißt, ich mach 
erstmal gar nichts und sage der 

520
00:26:08,560 --> 00:26:12,040
der Umgebung, gib mir bitte mal 
diesen Speicher, dann mach ich 

521
00:26:12,040 --> 00:26:17,760
nichts mehr damit und dann kommt
ein Assistent, der dann sagt, 

522
00:26:17,760 --> 00:26:21,680
Ah, Marcel hat jetzt hier, da 
diese diese Datei gelesen oder 

523
00:26:21,680 --> 00:26:23,640
diesen diesen String. 
Hallo, ich bin Marcel Spiel 

524
00:26:23,640 --> 00:26:26,920
gerne Gitarre ausgegeben. 
Ich sehe da, der wird nicht mehr

525
00:26:26,920 --> 00:26:28,760
verwendet. 
Ich räum den mal auf, also kann 

526
00:26:28,760 --> 00:26:31,280
man sich wirklich vorstellen wie
ach das wird markiert, man 

527
00:26:31,280 --> 00:26:34,560
spricht auch von Mark and Sweep,
das heißt, das wird markiert und

528
00:26:34,560 --> 00:26:39,760
dann wird das weggefegt oder 
gewischt und diese diesen Punkt,

529
00:26:39,920 --> 00:26:43,120
dem muss diese Runtime, also 
etwas was dann das Programm 

530
00:26:43,120 --> 00:26:48,000
ausführt, muss das irgendwie 
umsetzen und das führt dazu, 

531
00:26:48,240 --> 00:26:51,280
dass das auf der einen Seite 
erstmal passieren muss, das 

532
00:26:51,280 --> 00:26:53,240
heißt, während das passiert, 
kann das Programm nicht 

533
00:26:53,240 --> 00:26:57,440
weiterlaufen und zweitens. 
Um dieses Aufräumen zu machen, 

534
00:26:57,440 --> 00:26:59,040
braucht die Runtime auch wieder 
Speicher. 

535
00:26:59,440 --> 00:27:05,200
So, und das bedeutet unter 
unterm Strich, dass dass die die

536
00:27:05,200 --> 00:27:08,560
Ausgabe beziehungsweise die die 
die, dass es dem Programm, wie 

537
00:27:09,280 --> 00:27:14,400
soll man sagen Ausführungsfluss 
kurz unterbricht und dass 

538
00:27:14,400 --> 00:27:18,600
dadurch die die Performance 
leiden kann, nicht muss, aber es

539
00:27:18,600 --> 00:27:21,080
ist immer was, was noch 
zusätzlich dazu kommt, das heißt

540
00:27:21,080 --> 00:27:24,160
da ist irgendwas noch dabei 
innerhalb von von der Runtime. 

541
00:27:24,720 --> 00:27:28,160
Und das trennt im Prinzip, oder 
dass das das verlangsamt, das, 

542
00:27:28,160 --> 00:27:32,160
was der, was der Prozessor an 
Performance bringen könnte, dass

543
00:27:32,160 --> 00:27:34,800
das kann das dementsprechend 
verlangsamen und da muss 

544
00:27:34,800 --> 00:27:39,520
irgendwas mit getan werden und 
das gibt es bei Rust aufgrund 

545
00:27:39,520 --> 00:27:43,160
der Tatsache, dass es ein, wie 
ich gerne sage, ein Semi 

546
00:27:43,160 --> 00:27:46,800
manuelles Speichermanagement 
gibt, nicht, denn da gibt es die

547
00:27:46,800 --> 00:27:51,520
Idee des sogenannten Oderships, 
bei dem der der Rust Compiler 

548
00:27:51,520 --> 00:27:54,640
zur compile Zeit weiß. 
Ah, da wird Speicher gebraucht, 

549
00:27:54,880 --> 00:27:58,400
hier wird er aufgeräumt und wenn
das Programm ausgeführt wird, 

550
00:27:58,400 --> 00:28:02,160
dann ist das alles schon damit 
eingebacken sozusagen, und das 

551
00:28:02,160 --> 00:28:03,760
muss dann nicht zur Laufzeit 
passieren. 

552
00:28:03,760 --> 00:28:06,480
Das passiert dann zur 
Übersetzungszeit das ist das, 

553
00:28:06,480 --> 00:28:08,880
was man sagt, ich sag hab ich 
mein Rust Code, ich will den 

554
00:28:08,880 --> 00:28:13,400
Maschinencode haben und dann. 
Während während das passiert, 

555
00:28:13,400 --> 00:28:16,240
diese Übersetzung dieser 
Kompilierung wird dann 

556
00:28:16,240 --> 00:28:19,400
entschieden, wie verwalte ich 
denn den Speicher, wenn der ras 

557
00:28:19,400 --> 00:28:21,720
Compiler das ich nicht kapiert, 
was ich, was ich da machen 

558
00:28:21,720 --> 00:28:25,600
möchte oder ich es nicht 
kapiere, dann meckert der 

559
00:28:25,600 --> 00:28:29,440
Compiler und sagt das kapier ich
nicht das das kann ich nicht 

560
00:28:29,440 --> 00:28:32,720
verwalten geh weg und deswegen 
passieren bestimmte Fehler die 

561
00:28:33,040 --> 00:28:36,480
bei anderen Programmiersprachen 
zur zur Laufzeit passieren, also

562
00:28:36,480 --> 00:28:39,440
wenn das ausgeführt wird die 
passieren in Ras nicht. 

563
00:28:39,920 --> 00:28:42,960
Das C plus Plus und C angeht, da
gibt es auch eine 

564
00:28:42,960 --> 00:28:46,960
Speicherverwaltung, aber die 
mach ich komplett selbst und das

565
00:28:46,960 --> 00:28:49,320
hab ich gestern hab ich noch n 
linkedin Post abgesetzt, wo ich 

566
00:28:49,320 --> 00:28:54,560
auch noch gesagt habe, sogar das
Weiße Haus und die CISA hat mal 

567
00:28:54,560 --> 00:28:59,440
da davor gewarnt, dass so und so
viele Probleme durch 

568
00:28:59,600 --> 00:29:02,880
Speichermanagement, manuelles 
Speichermanagement kommen und da

569
00:29:02,880 --> 00:29:05,880
kommt eben dieser Hype daher. 
Es ist auch n Hype, das will ich

570
00:29:05,880 --> 00:29:07,440
auch nicht, will ich nicht in 
Abrede stellen. 

571
00:29:07,800 --> 00:29:10,640
Aber trotzdem gibt es auch den 
Vorteil, dass der Rust Compiler 

572
00:29:10,960 --> 00:29:14,560
da bestimmte Dinge abnimmt und 
man nicht alles selbst im Kopf 

573
00:29:14,560 --> 00:29:16,160
behalten muss und sich selbst 
drum kümmern muss. 

574
00:29:16,240 --> 00:29:19,360
Denn wenn ich in einen Speicher 
reinschreibe oder den 

575
00:29:19,360 --> 00:29:21,680
Überschreibe, den ich vorher 
reserviert habe von Nick, ich 

576
00:29:21,680 --> 00:29:25,280
hab gesagt, ich will jetzt, ich 
sag jetzt einfach mal 5 Einhalt 

577
00:29:25,280 --> 00:29:27,680
egal und auf einmal schreibe ich
aber 10. 

578
00:29:28,240 --> 00:29:30,840
Dann oder lese Szenen, dann 
passt das nicht mal zusammen und

579
00:29:30,840 --> 00:29:33,280
dann gibt es Probleme. 
Das ist diese große Geschichte 

580
00:29:33,280 --> 00:29:35,920
mit Garbage Collection und dem 
Speichermanagement, so mal 

581
00:29:35,920 --> 00:29:38,400
zusammen hydriert. 
Hab ich verstanden. 

582
00:29:38,400 --> 00:29:39,840
Burkhard würd es mir Recht 
geben, ja. 

583
00:29:40,560 --> 00:29:42,000
Ja, total. 
Und ich geb noch mal n 

584
00:29:42,000 --> 00:29:44,160
anschauliches Beispiel vom 
klingt klingt jetzt immer noch 

585
00:29:44,160 --> 00:29:45,600
so. 
Jetzt wird sich so zuhören. 

586
00:29:45,600 --> 00:29:48,240
Ja keine Ahnung, aber ich bin 
faul so ich hab Bock auf diesen 

587
00:29:48,240 --> 00:29:50,880
Garbage Collector, der macht das
Halt für mich ja ist auch 

588
00:29:50,880 --> 00:29:54,560
richtig so ne und also du wir 
müssen jetzt gucken warum brauch

589
00:29:54,560 --> 00:29:57,440
ich das manchmal und ich geb mal
was zum Anfassen ich hab mal. 

590
00:29:58,000 --> 00:30:00,720
Ich durfte mal in meinem Leben 
kuda programmieren, das ist die,

591
00:30:00,720 --> 00:30:03,880
die die Programmiersprache für 
die Grafikkarten, für die 

592
00:30:03,880 --> 00:30:07,200
Nvidias, die man ja heute sehr, 
sehr gut kennt, die ja unsere KI

593
00:30:07,200 --> 00:30:08,760
im Moment rechnet. 
Vorher haben Sie die Bitcoins 

594
00:30:08,760 --> 00:30:12,320
geschürft, und davor hab ich mit
den Dingern, mal mit Kuda 1, 

595
00:30:12,320 --> 00:30:16,160
also die erste Version dieser 
Sprache, ewig her, hab ich mal 3

596
00:30:16,160 --> 00:30:19,040
d Rekonstruktion gerechnet auf 
der Grafikkarte quasi auf und 

597
00:30:19,040 --> 00:30:21,320
zwar auf meiner Grafikkarte, die
da im Computer stand, die sie 

598
00:30:21,320 --> 00:30:23,440
hat nebenbei auch noch den 
Bildschirm da befeuert da und. 

599
00:30:24,640 --> 00:30:27,760
So, und jetzt mal als greifbares
Beispiel da, da willst du jetzt 

600
00:30:27,760 --> 00:30:28,800
auf einmal. 
Musst du jetzt tatsächlich 

601
00:30:28,800 --> 00:30:31,240
relativ viel Daten hochladen, 
nämlich die, die Rohdaten für 

602
00:30:31,240 --> 00:30:34,000
die für die und das sind 2 d 
Projektionen quasi sind, also 

603
00:30:34,240 --> 00:30:38,600
Matrizen oder Zahlenfelder 2 d 
ganz viele eine Millionen oder 

604
00:30:38,600 --> 00:30:41,040
Irgendsowas und und und und die 
muss ich dann quasi auf der 

605
00:30:41,040 --> 00:30:43,600
Grafikkarte, weil das schnell 
geht in so n 3 d Bild 

606
00:30:43,600 --> 00:30:45,360
zusammenrechnen. 
Ich muss die halt quasi drehen 

607
00:30:45,360 --> 00:30:47,440
und schieben und so weiter 
ausprobieren bis die schön 3 d 

608
00:30:47,440 --> 00:30:49,120
sind. 
So und jetzt haben diese 

609
00:30:49,120 --> 00:30:51,120
Grafikkarten nicht so viel 
Speicher. 

610
00:30:51,440 --> 00:30:54,800
Also heute ja damals. 
Ich weiß nicht 2 Gigabyte oder 4

611
00:30:54,800 --> 00:30:57,800
was ich da hatte, keine Ahnung. 
Ja und so ne Matrize selber ist 

612
00:30:57,800 --> 00:31:01,520
halt fett so und jetzt willst du
die jetzt willst du genau und 

613
00:31:01,520 --> 00:31:03,520
und jetzt deswegen nimmst du da 
so ne Programmiersprache wie 

614
00:31:03,520 --> 00:31:06,240
Rust oder C plus plus, denn 
jetzt willst du das Memory 

615
00:31:06,240 --> 00:31:09,720
Management nicht nur nicht 
Garbage Collection haben, 

616
00:31:09,720 --> 00:31:13,200
sondern explizit weil du musst 
genau wissen ich wie ich 

617
00:31:13,280 --> 00:31:16,240
allokiere was was Marcel gesagt 
hatte jetzt genau. 

618
00:31:16,720 --> 00:31:20,160
Diese Größe an Speicher auf der 
Grafikkarte und ich weiß OK 

619
00:31:20,160 --> 00:31:22,440
minus diesen ganzen anderen 
Quatsch, dass die noch so machen

620
00:31:22,440 --> 00:31:23,960
muss. 
Passt das gerade so dahin? 

621
00:31:23,960 --> 00:31:27,000
Ja, hätte ich die jetzt aber 
schon zweimal da die Matrixe 

622
00:31:27,000 --> 00:31:29,600
macht bumm und die und die die 
die knallt dir die Grafikkarte 

623
00:31:29,600 --> 00:31:31,240
um die Ohren weil der Speicher 
überlaufen ist. 

624
00:31:31,240 --> 00:31:32,320
Da kannst du gar nichts mehr 
rechnen. 

625
00:31:32,320 --> 00:31:35,360
Ja und jetzt das anschauliche 
Beispiel ist, du willst sowas 

626
00:31:35,360 --> 00:31:38,000
mehrere Male da rechnen auf der 
Karte jetzt musst du das 

627
00:31:38,000 --> 00:31:41,000
Hochschieben von deinem 
Arbeitsspeicher RAM in den 

628
00:31:41,000 --> 00:31:43,680
Grafikkartenspeicher dann 
rechnest du das. 

629
00:31:44,040 --> 00:31:45,760
Und jetzt willst du, wenn die 
Rechnung, sobald die Rechnung 

630
00:31:45,760 --> 00:31:47,440
fertig ist, willst du keine Zeit
verlieren? 

631
00:31:47,840 --> 00:31:50,400
Willst du jetzt diesen Speicher 
deallokieren? 

632
00:31:50,400 --> 00:31:54,640
Du willst jetzt sofort sagen der
ist weg, ich kill den ja ich 

633
00:31:54,640 --> 00:31:57,920
brauch den nicht mehr um um im 
übernächsten Moment zu sagen, 

634
00:31:57,920 --> 00:32:00,160
hier hole ich mir jetzt die 
nächste das die nächste Matrix 

635
00:32:00,160 --> 00:32:03,080
Matrix um die zu rechnen das 
würde nie funktionieren mit dem 

636
00:32:03,080 --> 00:32:05,920
Garbage Kollektor weil du weißt 
nie wann der läuft, der ist 

637
00:32:05,920 --> 00:32:08,960
nämlich auch implizit, der ist 
nicht explizit du kannst nicht 

638
00:32:08,960 --> 00:32:12,680
als Programmierer steuern wann 
dein Garbage Kollektor läuft 

639
00:32:12,680 --> 00:32:15,520
denn das ist dieses Mark and 
Sweep der der denkt irgendwann 

640
00:32:15,520 --> 00:32:18,160
so, oh ja, die jetzt eigentlich 
ist die Matrix, die benutzt 

641
00:32:18,160 --> 00:32:21,320
keiner mehr, woher weiß der das 
der ist keiner zeigt mir quasi 

642
00:32:21,320 --> 00:32:23,160
auf diesen Speicher, das ist so 
die Idee, ja die steht da 

643
00:32:23,160 --> 00:32:26,600
alleine im Raum, also wird die 
ja geflaggt, da kann weg ja aber

644
00:32:26,600 --> 00:32:28,840
wann die wirklich weg ist weißt 
du nicht, ja und dann kannst du 

645
00:32:28,840 --> 00:32:31,240
das Problem haben der der 
Garbage Collector ist langsamer 

646
00:32:31,240 --> 00:32:33,280
als du die nächste Matrix 
hochlädst, dann ist die noch 

647
00:32:33,280 --> 00:32:35,720
nicht deallokiert und der macht 
die nächste Matrix fertig auf 

648
00:32:35,720 --> 00:32:38,440
der Grafikkarte und Boom ja hast
du halt auf einmal nicht 4 

649
00:32:38,440 --> 00:32:40,480
Gigabyte allokiert sondern 8 
Gigabyte und das war halt zu 

650
00:32:40,480 --> 00:32:43,040
viel ja. 
Also überall da, wo wir auch 

651
00:32:43,040 --> 00:32:46,640
hardwarenah sind, wo wir, wo wir
Arbeitsspeicher nicht zur 

652
00:32:46,640 --> 00:32:48,960
Verfügung haben oder wo wir 
einfach riesige Probleme 

653
00:32:49,240 --> 00:32:52,200
rechnen, selbst wenn du riesigen
Speicher hast, da wo du riesige 

654
00:32:52,200 --> 00:32:55,440
Matrizen zusammenrechnest, 
willst du gerne explizit das 

655
00:32:55,440 --> 00:32:57,560
Memory Management da haben und 
dich nicht darauf verlassen, 

656
00:32:57,560 --> 00:32:59,560
dass der Garbage Collector früh 
genug da war, bevor du den 

657
00:32:59,560 --> 00:33:01,520
nächsten großen Blocker 
blockierst? 

658
00:33:01,520 --> 00:33:03,120
Ja. 
Vielleicht macht das noch mal so

659
00:33:03,120 --> 00:33:05,080
n bisschen auch greifbar, warum 
man das dann noch braucht. 

660
00:33:05,080 --> 00:33:08,400
Ja explizit Memory Management. 
Ja, und da komm ich noch mal 

661
00:33:08,400 --> 00:33:10,320
Gerrit auf deine Frage von 
vorhin zurück mit. 

662
00:33:10,560 --> 00:33:12,880
Also ich könnt dir jetzt jemand 
zuhören und sagen, also wenn du 

663
00:33:12,880 --> 00:33:15,120
jetzt bislang bis hier 
durchgehalten hat und gar nicht 

664
00:33:15,120 --> 00:33:21,440
so mit am Hut hat, Hut ab, geil,
du hast ja vorhin gefragt, warum

665
00:33:21,440 --> 00:33:24,360
sollte man das einsetzen und da 
würde ich gerne das kurz noch 

666
00:33:24,360 --> 00:33:27,680
mal anbringen, was ich vorhin 
auch gesagt hatte, wenn du eine 

667
00:33:27,680 --> 00:33:29,760
bestimmte. 
Man spricht ja von Codebase, 

668
00:33:29,760 --> 00:33:33,280
also hast du eine bestimmte 
Sache für dich in in dem 

669
00:33:33,280 --> 00:33:37,960
Programmcode umgesetzt und wenn 
du sagst, du möchtest flexibel 

670
00:33:37,960 --> 00:33:42,520
sein in dem wo du das einsetzt, 
also ob du das auf einem 

671
00:33:42,520 --> 00:33:45,920
Mobilgerät einsetzt, ob du das 
auf dem auf dem normalen Desktop

672
00:33:45,920 --> 00:33:50,960
Rechner, die wir gerade alle vor
uns haben einsetzt oder ob du 

673
00:33:50,960 --> 00:33:53,320
das vielleicht noch sogar auf 
einem Mikrocontroller einsetzt, 

674
00:33:53,320 --> 00:33:55,360
also irgendwas, was in dem 
Backofen läuft oder sowas. 

675
00:33:55,840 --> 00:33:58,000
Da ist mein Punkt, an dem ich 
dahin komme. 

676
00:33:58,000 --> 00:34:01,000
Es gibt sehr viele 
Einsatzgebiete von von Rust. 

677
00:34:01,000 --> 00:34:02,760
Ach, so einen hab ich vergessen 
tatsächlich, das mit Web 

678
00:34:02,760 --> 00:34:05,040
Assembly, also ich möchte das 
vielleicht im Browser laufen 

679
00:34:05,040 --> 00:34:08,719
lassen und da kommt für meine 
Begriffe Rust besonders ins 

680
00:34:08,719 --> 00:34:12,080
Spiel. 
Du hast eine sehr sehr neue 

681
00:34:12,080 --> 00:34:15,480
Sprache mit mit einem 
wunderbaren Typsystem können wir

682
00:34:15,480 --> 00:34:19,600
auch gleich mal drauf eingehen, 
aber du hast eine sehr robuste 

683
00:34:19,679 --> 00:34:23,520
und trotzdem flexible 
Möglichkeit diesen. 

684
00:34:23,760 --> 00:34:27,040
Diesen Programmcode in 
verschiedene Umgebungen 

685
00:34:27,280 --> 00:34:29,840
einzubetten und zu verwenden, 
und das ist auch der Grund, 

686
00:34:29,840 --> 00:34:33,600
warum ich so dafür plädiere, für
Cross Plattformen, also es geht 

687
00:34:33,600 --> 00:34:36,560
tatsächlich um mobile Apps auf 
My Phone auf auf dem Android 

688
00:34:36,560 --> 00:34:40,400
oder und oder. 
Auch Anwendungen wie was weiß 

689
00:34:40,400 --> 00:34:42,800
ich, Photoshop oder Microsoft 
Word, die tatsächlich auf dem 

690
00:34:42,800 --> 00:34:46,400
Rechner laufen und da gehen wir 
hin, ich bin meinem Team und 

691
00:34:46,400 --> 00:34:49,800
sagen wir bedienen unsere Kunden
damit zu sagen, was ist 

692
00:34:49,800 --> 00:34:52,800
tatsächlich der Kern eures 
Businesses. 

693
00:34:53,440 --> 00:34:57,320
Gießen, das in den Rust Code und
wir sind für ich n Kunde hat zu 

694
00:34:57,320 --> 00:34:59,960
mir mal gesagt Herr Koch, ich 
möchte, dass das in 30 Jahren 

695
00:34:59,960 --> 00:35:03,120
noch läuft, da hab ich erst mal 
geschluckt und hab gesagt na gut

696
00:35:03,120 --> 00:35:05,680
also ich würd jetzt mal die 
Wette eingehen, dass das in 30 

697
00:35:05,680 --> 00:35:09,280
Jahren noch existiert und das 
ist der Punkt warum wir in 

698
00:35:09,280 --> 00:35:13,440
unseren Projekten vermehrt auf 
auf Rust setzen um zu sagen da 

699
00:35:13,440 --> 00:35:16,480
ist der Business OK geht auch so
n bisschen in das Domain driven 

700
00:35:16,480 --> 00:35:18,960
Design rein, da ist der der der 
der. 

701
00:35:19,280 --> 00:35:22,480
Business Wert hier ist die Core 
Domain also wirklich das wo was,

702
00:35:22,480 --> 00:35:25,480
was die Firma ausmacht, das 
Gießen wir da rein, wir sind 

703
00:35:25,480 --> 00:35:30,120
vollkommen flexibel, das in 
andere Bereiche einzubetten, 

704
00:35:30,120 --> 00:35:32,800
also jetzt unabhängig von diesem
ganzen technischen Kram. 

705
00:35:33,200 --> 00:35:37,200
Aber das ist wirklich Business 
wert, den man hat um zu sagen 

706
00:35:37,280 --> 00:35:41,360
wir übersetzen das in diesen 
Rust Code und auf einmal sagt 

707
00:35:41,360 --> 00:35:43,840
dann was weiß ich in der Firma 
wie Oracle Ach das mit Java ist 

708
00:35:43,840 --> 00:35:46,640
doch immer so ne gute Idee wenn 
sie nicht machen aber so also 

709
00:35:46,640 --> 00:35:50,000
man ist. 
Sehr, sehr, sehr flexibel und 

710
00:35:50,000 --> 00:35:53,360
trotzdem sehr robust bei bei der
Sache in Bezug auf auf seine, 

711
00:35:53,360 --> 00:35:55,760
auf seine Business Logik. 
Das ist das was wir, was wir 

712
00:35:55,760 --> 00:35:58,560
hauptsächlich machen. 
Ja, kompilierter Code Cross 

713
00:35:58,560 --> 00:36:01,240
Plattform musst du dich noch mal
naiv nachfragen und du kannst 

714
00:36:01,240 --> 00:36:04,160
den du meinst, den kann man in 
verschiedenen Stellen einsetzen,

715
00:36:04,160 --> 00:36:06,720
vom Mikrocontroller bis zur 
mobile App und so weiter. 

716
00:36:07,200 --> 00:36:09,920
Genau. 
Den gleichen Code dann oder so 

717
00:36:09,920 --> 00:36:13,840
also also ja, ja, führ das gern 
noch mal n Tick aus, wie du das 

718
00:36:13,840 --> 00:36:15,760
genau meinst. 
Also oder hast du da n Beispiel 

719
00:36:15,760 --> 00:36:18,160
oder so was du da machen kannst?
Also es ist. 

720
00:36:18,160 --> 00:36:21,600
Ich habe beispielsweise einen 
einen Kunden, der kommt aus der 

721
00:36:21,600 --> 00:36:25,040
Messtechnik und da gibt es 
verschiedene. 

722
00:36:25,040 --> 00:36:29,120
Es gibt um um um Umwelttechnik 
geht es, um Messen, draußen im 

723
00:36:29,120 --> 00:36:31,520
Wald, ist da, so kann das sowas 
gar nicht sagen, und da gibt es 

724
00:36:31,520 --> 00:36:35,120
bestimmte mathematische 
Verfahren, und wir haben den 

725
00:36:35,120 --> 00:36:38,960
Fall, dass wir diese Verfahren 
sowohl auf dem Telefon. 

726
00:36:39,520 --> 00:36:44,640
Als auch auf dem Desktop und ein
im Rahmen von einem Messgerät, 

727
00:36:44,720 --> 00:36:47,360
also wo man dann das das Telefon
nicht mehr dazu braucht 

728
00:36:48,000 --> 00:36:52,000
wiederverwenden wollen und du 
bist dann in mit mit Rust in der

729
00:36:52,000 --> 00:36:56,400
Lage das einmal zu kodieren das 
auch aus aus meiner Sicht sehr 

730
00:36:56,400 --> 00:37:01,440
elegant zu kodieren durch das 
Typsystem, also wie man den Code

731
00:37:01,440 --> 00:37:04,720
gestaltet und dass man sagt es 
gibt bestimmte Repräsentationen 

732
00:37:04,720 --> 00:37:06,880
von dem. 
Also wenn man jetzt sagen würde,

733
00:37:06,880 --> 00:37:09,600
ich hab einen einen Weg, den ich
habe, ich hab ne gewisse 

734
00:37:09,600 --> 00:37:12,480
Strecke, ich hab ne ich hab 
bestimmte Anzahl von von Bäumen,

735
00:37:12,480 --> 00:37:16,400
ich definiere einen einen Wald 
beispielsweise und da kannst du 

736
00:37:16,400 --> 00:37:20,160
das in in Rust so kodieren und 
kannst durch diese verschiedenen

737
00:37:20,160 --> 00:37:22,480
compai Tage, von denen ich 
vorhin gesprochen habe dann 

738
00:37:22,480 --> 00:37:25,680
sagen, OK, das läuft jetzt auf 
dem iphone, das läuft jetzt auf 

739
00:37:25,680 --> 00:37:28,480
Android, das läuft jetzt auf 
Windows, das läuft auf Linux, 

740
00:37:28,800 --> 00:37:32,200
das läuft dann auch auf dem 
Mikrocontroller, standardmäßig 

741
00:37:32,200 --> 00:37:37,120
ist das da so n. 
SEM 32 oder NESP 32 und das 

742
00:37:37,120 --> 00:37:39,680
kannst du dann dementsprechend 
tatsächlich, wenn du bestimmte 

743
00:37:39,680 --> 00:37:42,480
Dinge beachtest, 
wiederverwenden, ohne es noch 

744
00:37:42,480 --> 00:37:45,600
mal neu schreiben zu müssen. 
Und das ist für mich Cross 

745
00:37:45,600 --> 00:37:50,040
Plattformen in in in Gänze 
sozusagen, weil ich sage, ich 

746
00:37:50,040 --> 00:37:51,360
hab. 
Kein Part of the Programming 

747
00:37:51,360 --> 00:37:53,360
Language quasi schon, aber du 
brauchst kein extra Tool mehr 

748
00:37:53,360 --> 00:37:56,240
von außen dran flanschen, es 
kommt mit mit dem Inhalt der 

749
00:37:56,240 --> 00:37:58,240
Sprache. 
Richtig, und durch diese 

750
00:37:58,240 --> 00:38:01,920
verschiedenen verschiedenen. 
Compile targets also man, man 

751
00:38:01,920 --> 00:38:04,440
könnte es dann sagen, das das 
wird dann übersetzt wie n 

752
00:38:04,440 --> 00:38:08,000
Dolmetscher, Übersetzer das dann
in die verschiedenen Geräte für 

753
00:38:08,000 --> 00:38:11,440
für das für das iphone, für für 
Android, für den entsprechenden 

754
00:38:11,440 --> 00:38:14,760
kleinen Chip, diese 
Mikrocontroller und das hab ich 

755
00:38:14,760 --> 00:38:19,000
dann als Basis für alles und 
darüber hinaus kann ich das auch

756
00:38:19,000 --> 00:38:20,800
noch wunderbar testen, das ist 
ja auch immer so ne Geschichte 

757
00:38:20,800 --> 00:38:24,000
ne ich hab ich hab wunderbare 
Anforderungen ne und auf einmal 

758
00:38:24,000 --> 00:38:26,800
geht das Ding dann in Produktion
ist auf dem Handy installiert 

759
00:38:26,800 --> 00:38:28,640
auf einmal stürzt dieser Kram 
ab. 

760
00:38:29,040 --> 00:38:31,760
Und das ist durch dieses 
Speichermanagement auch noch 

761
00:38:31,760 --> 00:38:33,280
mal. 
Wie soll ich mal sagen, 

762
00:38:33,280 --> 00:38:35,960
Businessfreundlicher, weil ich 
bestimmte Dinge während der 

763
00:38:35,960 --> 00:38:39,920
Entwicklung feststelle und der 
der der Compiler, also 

764
00:38:39,920 --> 00:38:43,680
derjenige, der übersetzt der 
Dolmetscher sagt mir, OK, das 

765
00:38:43,680 --> 00:38:46,320
versteh ich nicht, das, das 
müssen wir noch mal klären, aber

766
00:38:46,320 --> 00:38:49,680
wenn ich das dann übersetzt 
habe, hab ich sehr, sehr, sehr 

767
00:38:49,840 --> 00:38:52,400
robuste Software in der 
Produktion, das ist diese 

768
00:38:52,400 --> 00:38:55,600
Geschichte mit Cross Plattform. 
Ich bin sehr flexibel und ich 

769
00:38:55,600 --> 00:38:58,560
bin trotzdem. 
Sehr robust innerhalb, wenn das 

770
00:38:58,560 --> 00:39:01,680
mal läuft, das ist das ist aus 
meiner Sicht das das 

771
00:39:01,680 --> 00:39:04,400
Hauptargument oder die beiden 
Hauptargumente für für den 

772
00:39:04,400 --> 00:39:06,400
Einsatz von Rust. 
Wenn ich dafür Gerrit noch mal 

773
00:39:06,400 --> 00:39:10,240
zu sagen, was du gesagt hast, 
wir wir codieren quasi einmal in

774
00:39:10,240 --> 00:39:12,400
der Sprache des Rust, das könnt 
man sagen wie Englisch einmal 

775
00:39:12,400 --> 00:39:16,880
runter den gleichen Code, den 
gleichen Algorithmus und wird 

776
00:39:16,880 --> 00:39:21,440
und dann macht Rust quasi aus 
einmal Code 10 oder 20 

777
00:39:21,440 --> 00:39:24,600
verschiedene kleine 
Progrämmchen, die für die 10 

778
00:39:24,600 --> 00:39:27,920
oder 20 verschiedenen. 
Bereiche, nämlich Telefon, 

779
00:39:27,920 --> 00:39:30,600
Desktop, Sensor im Wald und so 
weiter geeignet. 

780
00:39:30,600 --> 00:39:32,000
Bei der Tage. 
Also so so. 

781
00:39:32,000 --> 00:39:33,280
Also es ist. 
Genau, genau. 

782
00:39:33,520 --> 00:39:35,680
Es kommt bei der Tage genau und 
auch es entstehen. 

783
00:39:35,680 --> 00:39:38,400
Quasi ganz viele Programme 
daraus, die auch ganz 

784
00:39:38,400 --> 00:39:40,720
unterschiedlich sind, vom 
Maschinencode her jeweils auf 

785
00:39:40,720 --> 00:39:43,040
die entsprechende 
Plattformarchitektur blablabla 

786
00:39:43,040 --> 00:39:44,960
angepasst. 
Aber es ist wird, es entsteht 

787
00:39:44,960 --> 00:39:49,360
quasi aus einem Code heraus und 
es ist und dieses dieses Bauen 

788
00:39:49,360 --> 00:39:51,480
in ist quasi Teil der Rust 
Sprache, wenn ich das richtig 

789
00:39:51,480 --> 00:39:52,640
verstehe. 
Richtig, ich habe auch noch ein 

790
00:39:52,640 --> 00:39:54,800
anderes Beispiel. 
Ein anderer Kunde von mir. 

791
00:39:55,360 --> 00:39:57,840
Die heißen Zeitkapsel, die 
machen Fotospeicherung in der 

792
00:39:57,840 --> 00:40:00,080
Cloud. 
Also wenn man hier sagt, Ich 

793
00:40:00,080 --> 00:40:03,440
möchte Google oder Apple nicht 
vertrauen, da kann man, kann man

794
00:40:03,440 --> 00:40:07,440
da hingehen und da ist wirklich 
die Idee, dass dieser Kern, also

795
00:40:07,440 --> 00:40:10,560
der der, der der sogenannte Core
von dem, was wir gerade 

796
00:40:10,560 --> 00:40:13,280
besprochen haben, also wirklich 
das, was das Business ausmacht, 

797
00:40:13,600 --> 00:40:17,840
dass wir das auch in in Rust 
definiert haben, und ob das 

798
00:40:17,840 --> 00:40:20,800
jetzt auf dem, wie gesagt, auf 
dem iphone läuft oder auf 

799
00:40:20,840 --> 00:40:23,360
Android oder, und das ist auch 
nur das große Ding. 

800
00:40:23,840 --> 00:40:27,920
Weil wir keine Runtime haben im 
Bezug auf die Garbish Collection

801
00:40:27,920 --> 00:40:31,240
und dass der Code ausgeführt 
werden muss et cetera, sind wir 

802
00:40:31,240 --> 00:40:34,160
auch in der Lage, sehr gut. 
Web Assembly, Das ist eine, das 

803
00:40:34,160 --> 00:40:39,200
ist im Prinzip Byte Code, also 
eine Repräsentation von Rust. 

804
00:40:39,360 --> 00:40:41,080
Also wieso n kleines 
Progrämmchen von dem Booker 

805
00:40:41,080 --> 00:40:45,280
gerade gesprochen hat, dass ich 
für den Browser vorbereite und 

806
00:40:45,280 --> 00:40:48,760
Browser ist es total wichtig, 
dass die Dinger natürlich nicht 

807
00:40:48,760 --> 00:40:51,120
besonders groß sind. 
Sondern dass ich nicht auf 

808
00:40:51,120 --> 00:40:54,680
einmal 4 Megabyte runterlade, 
nur weil ich jetzt diese 

809
00:40:54,680 --> 00:40:58,880
Applikation starten möchte, kann
ich natürlich machen, aber durch

810
00:40:58,880 --> 00:41:02,120
diese Möglichkeit, dass dass ich
diese ganze Runtime nicht 

811
00:41:02,120 --> 00:41:05,600
brauche, kann ich auch sehr 
kleine Web Assembly Module 

812
00:41:05,600 --> 00:41:09,120
erzeugen und dadurch eignet sich
Rust wieder für dieses Cross 

813
00:41:09,120 --> 00:41:11,200
Plattform. 
Also ich geh dann hin ganz 

814
00:41:11,200 --> 00:41:13,920
konkret bei bei Zeitkapsel und 
sage. 

815
00:41:14,560 --> 00:41:17,680
Wir definieren bestimmte Dinge 
von unserer Abfolge, von der 

816
00:41:17,680 --> 00:41:20,160
Verschlüsselung. 
Da geht es dann auch um um das 

817
00:41:20,240 --> 00:41:23,200
das Verschlüsseln der ganzen 
Fotomediathek et cetera, und das

818
00:41:23,200 --> 00:41:27,440
definiere ich einmal und binde 
das in die verschiedenen 

819
00:41:27,440 --> 00:41:30,720
Plattformen dann ein, inklusive 
dem Browser und dann habe ich im

820
00:41:30,720 --> 00:41:34,520
im Browser die gleiche Logik, 
die ich auch auf dem Telefon 

821
00:41:34,520 --> 00:41:37,800
habe und binde die Binde, die 
dann nur an die man spricht dann

822
00:41:37,800 --> 00:41:39,760
von von einem Core und von einer
Shell. 

823
00:41:40,320 --> 00:41:43,280
Dass dass der Chor das exakt das
gleiche macht und die Shell sagt

824
00:41:43,280 --> 00:41:46,480
dann, ach ja, ich Speicher jetzt
meine bestimmten Dinge nicht auf

825
00:41:46,480 --> 00:41:49,120
der Festplatte, sondern im 
sogenannten Local Storage im 

826
00:41:49,120 --> 00:41:52,640
Browser, aber der, der der Punkt
ist einfach, ich definiere das 

827
00:41:52,640 --> 00:41:55,440
einmal, das ist da, das kann ich
immer nur noch mal 

828
00:41:55,440 --> 00:41:58,480
unterstreichen, ich definiere 
das einmal, verwende das über 

829
00:41:58,480 --> 00:42:02,240
diese Struktur, auf diesen 
ganzen Sachen wieder und auch 

830
00:42:02,640 --> 00:42:05,600
wenn sich meine Technologie 
ändert, also wir benutzen ja 

831
00:42:05,600 --> 00:42:08,720
viel flatter. 
Und angenommen, Flatter wäre 

832
00:42:08,720 --> 00:42:11,240
jetzt nicht mehr da oder Google 
würde sagen, das machen wir 

833
00:42:11,240 --> 00:42:13,840
jetzt nicht mehr, das ist so ne 
Technologie um die Oberfläche zu

834
00:42:13,840 --> 00:42:16,280
machen auf den verschiedenen 
Geräten, dann gehen wir einfach 

835
00:42:16,280 --> 00:42:18,520
woanders hin und sagen OK, dann 
machen wir es, machen wir es auf

836
00:42:18,520 --> 00:42:24,360
einer anderen Ebene, weil wir 
diesen robusten Kern haben, den 

837
00:42:24,360 --> 00:42:26,960
ich immer wieder verwerten kann.
Ich kann das immer, ich hab das 

838
00:42:26,960 --> 00:42:29,000
Gefühl, ich hab es jetzt zum zum
sechsten Mal gesagt, aber ich 

839
00:42:29,000 --> 00:42:32,560
find das sehr so genial, dass 
dass ich das machen kann. 

840
00:42:33,040 --> 00:42:34,520
Ja. 
Marcel, Ich will ich find ich 

841
00:42:34,520 --> 00:42:37,280
find es cool, dass also du 
motivierst Motivierst mit deiner

842
00:42:37,560 --> 00:42:39,280
mit deiner Begeisterung 
natürlich für Rust. 

843
00:42:39,280 --> 00:42:41,200
Ich glaube ich werd auch im 
Nachhinein noch mir das so mal 

844
00:42:41,200 --> 00:42:43,000
angucken müssen. 
Ich würd dich gerne mal fast 

845
00:42:43,000 --> 00:42:45,360
wieso n bisschen quizduell oder 
irgend sowas n paar Sachen 

846
00:42:45,360 --> 00:42:48,080
abfragen die die die mir so 
wichtig sind irgendwie wenn ich 

847
00:42:48,080 --> 00:42:50,080
ne Programmiersprache 
kennenlerne ja vielleicht können

848
00:42:50,080 --> 00:42:52,480
wir das irgendwie. 
So nämlich, so die Inhalte, so 

849
00:42:52,480 --> 00:42:53,520
weißt du, wie schreibe ich das 
hin? 

850
00:42:53,520 --> 00:42:55,120
So, ja, das haben wir noch gar 
nicht besprochen. 

851
00:42:55,120 --> 00:42:57,440
Ich möchte, bevor wir dann 
machen wir sofort bevor ich hab 

852
00:42:57,440 --> 00:43:01,080
nur eine Sache verwechselt. 
Vorhin hab ich von 2021 ist die 

853
00:43:01,080 --> 00:43:03,680
1.0 rausgekommen, ich hab das 
verwechselt, da ist die Rust 

854
00:43:03,680 --> 00:43:05,920
Foundation gegründet worden, das
ist ne Sache die ich noch 

855
00:43:05,920 --> 00:43:09,360
erwähnen möchte, also weil die 
Rust wird aber auch wenn man das

856
00:43:09,360 --> 00:43:11,760
das immer wieder hört ist bei 
Mozilla gegründet worden und so 

857
00:43:11,760 --> 00:43:14,000
weiter und so weiter 
mittlerweile gibt es eine ganze 

858
00:43:14,000 --> 00:43:17,280
Riege an Firmen. 
Die, die Rust unterstützen 

859
00:43:17,280 --> 00:43:18,800
innerhalb von dieser Rust 
Foundation. 

860
00:43:18,960 --> 00:43:21,200
Und da ist Mozilla nur climb 
dabei. 

861
00:43:21,200 --> 00:43:25,840
Also da sind Größen wie ABS auch
Google, Microsoft macht ganz 

862
00:43:25,840 --> 00:43:28,960
viel mit Azure, also dass diese 
Cloud von von von Microsoft auch

863
00:43:28,960 --> 00:43:31,480
Basis von Rust und das ist auch 
der Punkt warum ich zu meinem 

864
00:43:31,480 --> 00:43:33,760
Kunden damals sagen konnte, also
es geht so n bisschen ins 

865
00:43:33,760 --> 00:43:38,320
Quizduell rein, schon wo ich zu 
meinem Kunden sagen könnte, also

866
00:43:38,560 --> 00:43:41,360
ich kann es nicht, kann es 
natürlich garantieren, aber ich 

867
00:43:41,360 --> 00:43:44,480
gehe fest davon aus, durch diese
Breite der Unterstützung der 

868
00:43:44,480 --> 00:43:46,400
Firmen. 
Halte ich es für sehr, sehr, 

869
00:43:46,400 --> 00:43:49,200
sehr unwahrscheinlich, dass das 
auf einmal weggeht, wie wenn 

870
00:43:49,200 --> 00:43:50,840
Google mal sagt, wir haben 
keinen Bock mehr, eine 

871
00:43:50,840 --> 00:43:53,040
bestimmte, ein bestimmtes 
Produkt oder eine bestimmte 

872
00:43:53,040 --> 00:43:56,240
Sprache zu unterstützen. 
Das ist auch noch mal ein ein 

873
00:43:56,240 --> 00:44:00,240
Punkt, der der in die Richtung 
geht, also die 1.0 kam 2015 

874
00:44:00,240 --> 00:44:03,840
raus, die Rust Foundation ist 
2021 gegründet worden, mein 

875
00:44:03,840 --> 00:44:06,360
Fehler so und jetzt. 
Ab ins Quizduell. 

876
00:44:07,040 --> 00:44:08,480
Ab ins Quizduell. 
Ja, ich hab einfach noch mal. 

877
00:44:08,480 --> 00:44:10,640
Ich will einfach noch mal so die
Dinger raushauen, so ne von den 

878
00:44:10,640 --> 00:44:13,600
Sprachen die ich so kenne also. 
Klassen und Objektorientierung 

879
00:44:13,600 --> 00:44:16,320
hab wie sieht das aus? 
In Rust hab ich auch glaskeyword

880
00:44:16,320 --> 00:44:18,320
und kann ich Instanzen erzeugen,
ist das ganz normal. 

881
00:44:18,320 --> 00:44:20,560
Wie ist in Heritans geregelt und
so weiter jetzt mal so von den 

882
00:44:20,560 --> 00:44:24,000
Keywords in der Sprache. 
Es gibt weder Klassen noch eine 

883
00:44:24,000 --> 00:44:27,920
typische Vererbung. 
Es gibt es gibt Structs, also 

884
00:44:27,920 --> 00:44:33,520
Datenstrukturen, die du alleine 
verwenden kannst und an die du 

885
00:44:33,760 --> 00:44:36,480
Methoden oder Funktionen binden 
kannst. 

886
00:44:37,280 --> 00:44:39,920
Ich unterscheide Methoden und 
Funktionen. 

887
00:44:40,160 --> 00:44:42,640
Associated Functions heißt das 
dann in in Rust. 

888
00:44:42,640 --> 00:44:45,480
In anderen Sprachen heißt es 
dann klassenfunktionen, das 

889
00:44:45,480 --> 00:44:48,800
heißt, Methoden greifen auf 
bestimmte Inhalte innerhalb des 

890
00:44:48,800 --> 00:44:52,640
Structs zu und Associated 
Functions hängen an dem Struct 

891
00:44:52,640 --> 00:44:55,280
und die kannst du sozusagen 
statisch verwenden, unabhängig 

892
00:44:55,280 --> 00:44:58,000
von von der dem Zustand der des 
Structs. 

893
00:44:58,560 --> 00:45:02,080
Vererbung gibt es bei Structs 
nicht, du fängst dann an so ne 

894
00:45:02,080 --> 00:45:05,040
Composition, also man macht dann
eher composition als in 

895
00:45:05,040 --> 00:45:08,320
Harritons es. 
Gibt etwas, das nennt sich 

896
00:45:08,320 --> 00:45:11,520
Trades. 
Das ist vergleichbar mit ich 

897
00:45:11,520 --> 00:45:13,760
komm dann wieder auf Java 
zurück, weil ich, weil ich halt 

898
00:45:13,760 --> 00:45:16,800
n Java background habe, was 
vergleiche mit Interfaces in in 

899
00:45:16,800 --> 00:45:21,040
Java, also du, du beschreibst 
ein bestimmtes Verhalten von von

900
00:45:21,040 --> 00:45:23,240
einem Struck beziehungsweise von
diesen entsprechenden 

901
00:45:23,240 --> 00:45:25,680
Funktionen, das ist so ähnlich 
wie das, was du vorhin mit den 

902
00:45:25,680 --> 00:45:28,080
Headern gesagt hast. 
Also ein Trade beschreibt das 

903
00:45:28,080 --> 00:45:30,160
das entsprechende Verhalten 
implementiert, das aber 

904
00:45:30,240 --> 00:45:33,440
standardmäßig nicht. 
Dort kannst du eine eine 

905
00:45:33,440 --> 00:45:36,400
Vererbung herstellen, also ein 
Trade kann sagen, ich bin das 

906
00:45:36,400 --> 00:45:39,120
und ein Trade sagt, ich mach das
von dem und dem und dem und dem 

907
00:45:39,120 --> 00:45:42,800
und dann hast du sozusagen so ne
so n ganzen Korb von Funktionen.

908
00:45:43,200 --> 00:45:46,480
Standardmäßig gibt es bei gibt 
es aber keine Vererbung bei 

909
00:45:46,480 --> 00:45:49,400
Klassen, weil es auch gar keine 
Klassen gibt und das wird dann 

910
00:45:49,400 --> 00:45:52,960
durch die Composition gelöst. 
OK, God it, aber ich ich bin 

911
00:45:52,960 --> 00:45:56,480
jetzt mal Devil's Advocate und 
sag mal OK destructs gibt es ja 

912
00:45:56,480 --> 00:45:59,360
auch im C plus plus. 
Ja, also es gibt ja beide 

913
00:45:59,360 --> 00:46:02,800
Keywords Struct und class. 
Und im Prinzip ist Destruct und 

914
00:46:02,800 --> 00:46:06,960
die Class das gleiche minus 
destruct by default public ist 

915
00:46:06,960 --> 00:46:10,720
und ne class by default private 
ist was ihre Members angeht, 

916
00:46:11,040 --> 00:46:13,840
aber was ich jetzt so rausgehört
hab von deinem Rust Erläuterung 

917
00:46:13,840 --> 00:46:16,080
mit, dass es Methoden gibt die 
quasi ihren eigenen State 

918
00:46:16,080 --> 00:46:18,800
isolieren wenn ich eine struct 
instanziere was ich 

919
00:46:18,800 --> 00:46:21,840
wahrscheinlich kann und dass ich
jetzt Aktionen habe die Struct 

920
00:46:21,840 --> 00:46:24,880
weit laufen, das sind ne quasi 
analog die statischen hab ich im

921
00:46:24,880 --> 00:46:26,680
Prinzip Objektorientierung 
gelöst. 

922
00:46:26,680 --> 00:46:29,600
Ich nenn es nicht class. 
Aber ich, ich habe quasi meinen 

923
00:46:29,600 --> 00:46:32,000
Struck, das so so sich so 
eigentlich verhält wie ne Glas 

924
00:46:32,000 --> 00:46:34,480
und ich habe sowas wie statische
und wenn man Funktion für mich 

925
00:46:34,480 --> 00:46:38,080
ist das also ich sag immer es 
gibt ja 1000 und und eine 

926
00:46:38,080 --> 00:46:39,920
Ausprägung in den 
Programmiersprachen aber am Ende

927
00:46:39,920 --> 00:46:42,720
geht es nur darum kann ich 
irgendwas hinschreiben was ich 

928
00:46:42,720 --> 00:46:45,280
wiederverwerten kann und da 
einen isolierten State drauf hab

929
00:46:45,280 --> 00:46:47,720
was ich irgendwie so nenne wie 
Instanzfunktionen oder Methoden 

930
00:46:47,720 --> 00:46:50,640
oder da geht es halt schon los 
mit den ganzen Namen so und und 

931
00:46:50,640 --> 00:46:53,120
hab ich gleichzeitig auch auf 
diesem Ding die Möglichkeit 

932
00:46:53,120 --> 00:46:55,440
Funktionen aufzurufen die quasi 
quer. 

933
00:46:55,840 --> 00:46:58,480
Spät, irgendwie funktionieren 
für alle gleich, sind also quasi

934
00:46:58,480 --> 00:47:01,840
den den State Destructs selber, 
also der Klasse selber quasi 

935
00:47:01,840 --> 00:47:03,440
benutzen. 
Das ist dann so ne Art statische

936
00:47:03,440 --> 00:47:05,040
Funktion, scheint so zu sein in 
Rust. 

937
00:47:05,040 --> 00:47:07,200
Also würd ich Haken dran machen,
dann kann ich könnte ich mit 

938
00:47:07,200 --> 00:47:10,720
arbeiten gut nächste Frage 
funktionales Programmieren es 

939
00:47:10,720 --> 00:47:13,640
gibt javascript zum Beispiel 
viel schöner oder einfacher man 

940
00:47:13,680 --> 00:47:15,920
muss aufpassen, C plus Plus 
entwickelt sich krass weiter, 

941
00:47:16,360 --> 00:47:18,480
aber jedenfalls in den älteren C
plus plus Ausprägungen war es 

942
00:47:18,480 --> 00:47:22,240
nicht ganz so einfach, gibt es 
ja sehr mächtige Funktion 

943
00:47:22,240 --> 00:47:24,800
funktionale. 
Ja, Möglichkeiten zum Beispiel 

944
00:47:24,800 --> 00:47:27,440
an einem RE ne ich hab RE map, 
ich hab reduce, ich hab filter, 

945
00:47:27,440 --> 00:47:29,800
ich hab was weiß ich und so 
weiter und kann quasi und die 

946
00:47:29,800 --> 00:47:32,400
Retournieren quasi die Funktion 
hier gerade wieder das Ergebnis,

947
00:47:32,560 --> 00:47:36,560
so dass ich quasi so ne Chain 
von von Prozess Prozessor 

948
00:47:36,560 --> 00:47:39,440
prozessorierungen machen kann. 
Von meinen Daten gibt das auch n

949
00:47:39,440 --> 00:47:40,560
Rust. 
Weißt du was ich meine? 

950
00:47:40,960 --> 00:47:42,440
Ich glaube, ich weiß was du 
meinst. 

951
00:47:42,440 --> 00:47:44,720
Also was ich gerade eben auch 
noch mal sagen wollte ist, dass 

952
00:47:44,720 --> 00:47:47,080
dass du Rust, wenn du möchtest 
auch komplett funktional 

953
00:47:47,080 --> 00:47:50,040
schreiben kannst. 
Es gibt auch Closures, die du 

954
00:47:50,040 --> 00:47:51,760
definieren kannst, also auch 
anonyme. 

955
00:47:51,760 --> 00:47:54,560
Solche anonyme Funktionen. 
Und dann bin ich auch gleich 

956
00:47:54,560 --> 00:47:56,960
zugekommen. 
Genau, also die gibt es auch 

957
00:47:57,520 --> 00:48:00,320
standardmäßig in Bezug auf das 
auf das Chaining was du, was du 

958
00:48:00,320 --> 00:48:03,960
auch sagst, gibt es auch die 
Möglichkeiten das das hängt dann

959
00:48:03,960 --> 00:48:08,320
davon ab welche welche Trades 
beziehungsweise welche konkreten

960
00:48:08,320 --> 00:48:11,120
Sachen du machen möchtest. 
Du kannst das auch, kannst das 

961
00:48:11,120 --> 00:48:14,160
auch Chainen da geht es ja auch 
noch hier Map, Reduce, flatmap 

962
00:48:14,160 --> 00:48:16,800
und Gedöns. 
Die die Möglichkeiten gibt es 

963
00:48:16,960 --> 00:48:18,960
nicht, alles ist in der 
Standardbibliothek enthalten, 

964
00:48:18,960 --> 00:48:22,480
aber du kannst auch Rust auch 
mit mit unter der Unterstützung 

965
00:48:22,480 --> 00:48:25,600
von von dem ein oder anderen 
Trade auch komplett funktional 

966
00:48:25,600 --> 00:48:26,960
schreiben. 
Du musst überhaupt keine 

967
00:48:27,440 --> 00:48:30,240
Objektorientierung anstreben, 
indem du dann Methoden bindest, 

968
00:48:30,240 --> 00:48:32,480
sondern du sagst ich arbeite 
hier nur mit sich durch die 

969
00:48:32,480 --> 00:48:35,360
Gegendreiche, das geht ja. 
OK, cool. 

970
00:48:36,000 --> 00:48:39,600
Dann, genau Datentypen ist immer
hinlänglich langes Thema. 

971
00:48:39,600 --> 00:48:42,720
Vielleicht aber also ich geh 
davon aus, dass Rust auch nen 

972
00:48:42,720 --> 00:48:44,640
guten Array Typen hat, den ich 
einfach verwende, der 

973
00:48:44,640 --> 00:48:47,440
standardisiert ist und und 
hoffentlich auch nen Dictionary 

974
00:48:47,760 --> 00:48:51,240
Datentypen also so n Key Value 
mapper, da gibt es so NC Plus 

975
00:48:51,240 --> 00:48:53,920
plus leider ja, beim Standard 
Array ist es eigentlich relativ 

976
00:48:53,920 --> 00:48:56,320
klar, bei der bei der Standard 
Map gibt es dann die Hash Map 

977
00:48:56,320 --> 00:48:59,440
und so weiter nachdem ob dann 
betwee hinter ist oder ne Hash 

978
00:48:59,440 --> 00:49:01,840
Implementierung und so weiter 
ich was hat sich Rust überlegt? 

979
00:49:01,840 --> 00:49:04,200
Das ist da ein Typ den man 
empfiehlt oder gibt es da auch 

980
00:49:04,200 --> 00:49:06,320
schon wieder mehrere oder ganz 
ganz schnell? 

981
00:49:07,200 --> 00:49:10,960
Ganz, ganz, ganz schnell. 
Es gibt Arrays, Arrays sind sind

982
00:49:10,960 --> 00:49:13,240
fix, sie können nicht verändert 
werden, wenn du eine 

983
00:49:13,240 --> 00:49:15,920
Veränderbare Liste haben 
möchtest, nimmst du einen Vektor

984
00:49:16,160 --> 00:49:19,200
und bei einem Quebellu nimmst du
eine Hash Map. 

985
00:49:19,600 --> 00:49:21,760
Von der es auch mehrere 
Implementierungen gibt. 

986
00:49:21,920 --> 00:49:25,120
Aber es gibt es gibt ne Standard
hashmap und es gibt aber auch 

987
00:49:25,120 --> 00:49:28,120
sowas was was ich hash Brown 
nennt, was wir dann sagen, wir 

988
00:49:28,120 --> 00:49:30,480
implementieren das schneller und
so weiter aber letzten Endes ist

989
00:49:30,480 --> 00:49:34,800
es weg, Array gibt es Vektoren 
gibt es für veränderbare Listen,

990
00:49:34,800 --> 00:49:37,440
das heißt falls du nicht weißt 
wieviel sollen dann jetzt meine 

991
00:49:37,600 --> 00:49:38,880
wie wie lang ist jetzt meine 
Liste? 

992
00:49:38,880 --> 00:49:41,280
Hey, so n bisschen wie n Python,
wo ich verschiedene Datentypen 

993
00:49:41,280 --> 00:49:43,760
hab hier nach Mutability. 
Also wenn ich wenn ich n mutible

994
00:49:43,760 --> 00:49:45,680
Objekt hab, dann ist es 
normalerweise n anderer Datentyp

995
00:49:45,680 --> 00:49:46,960
als wenn ich n mutible Objekt 
hab. 

996
00:49:46,960 --> 00:49:48,320
Ne. 
In in die Richtung. 

997
00:49:48,320 --> 00:49:49,680
Ja, ja, o. 
K gut. 

998
00:49:49,840 --> 00:49:52,480
Ist nur wichtig zu verstehen. 
Es gibt Array und Vektoren und 

999
00:49:52,480 --> 00:49:55,600
meistens nimmt man Vektoren, 
weil man am, weil man dann doch 

1000
00:49:55,600 --> 00:49:57,120
nicht weiß wie lang das Ding 
werden soll. 

1001
00:49:57,520 --> 00:50:00,120
Ja, für die Zuhörenden kurz in C
plus Plus ist es dann auch oft 

1002
00:50:00,120 --> 00:50:00,920
so. 
Da hast du dann immer den 

1003
00:50:00,920 --> 00:50:03,920
gleichen Datentyp und wenn du 
das irgendwie im Utable machen 

1004
00:50:03,920 --> 00:50:05,800
willst, also wenn du quasi 
erzwingen willst, dass von außen

1005
00:50:05,800 --> 00:50:08,480
das keiner verändern darf und 
von außen ist meistens man 

1006
00:50:08,480 --> 00:50:10,760
selber als Entwickler, wenn man 
es irgendwie noch mal benutzt, 

1007
00:50:10,760 --> 00:50:13,880
da gibt es diese const flex, 
also man also mit C plus plus 

1008
00:50:13,880 --> 00:50:16,360
ist voll mit const. 
Hier ist congstar ist constant. 

1009
00:50:16,360 --> 00:50:18,800
Alles Mögliche kann constant ja 
der Pointer, die Referenz, das 

1010
00:50:18,800 --> 00:50:21,200
Objekt selber, die Funktion und 
was weiß ich nicht alles das das

1011
00:50:21,200 --> 00:50:23,280
muss man üben. 
Ja es gibt locker 6 stellen wo 

1012
00:50:23,280 --> 00:50:25,800
man Constant schreiben kann, das
meint die das meint 6 

1013
00:50:25,800 --> 00:50:29,040
verschiedene Dinger und ich hab 
ich hab verstanden das das haben

1014
00:50:29,040 --> 00:50:30,680
Sie in Python glaub ich n 
bisschen abgeräumt indem man 

1015
00:50:30,680 --> 00:50:33,280
einfach sagt Pass mal auf dieser
ganze Datentyp dieses Array das 

1016
00:50:33,280 --> 00:50:35,720
ist halt quasi in sich im 
youtube Feierabend, da brauchst 

1017
00:50:35,720 --> 00:50:36,960
du nicht mehr so viel Constant 
schreiben. 

1018
00:50:37,440 --> 00:50:39,600
OK, was mich am meisten 
interessiert ist eigentlich, und

1019
00:50:39,600 --> 00:50:41,880
das ist natürlich auch noch mal 
n ganz hartes Thema für ne für 

1020
00:50:41,880 --> 00:50:44,080
ne fortgeschrittene Minute in 
der wir sind, aber das muss ich 

1021
00:50:44,080 --> 00:50:47,520
jetzt trotzdem noch mal horchen,
asynchronität, weil das ist ja, 

1022
00:50:47,520 --> 00:50:50,800
wenn also wir sprechen über Map 
Assembly, wir sprechen über High

1023
00:50:50,800 --> 00:50:54,200
Performance und so weiter und 
sofort und ich, ich brech mal 

1024
00:50:54,200 --> 00:50:56,080
gerade mein ganze 
Programmiersprachen kreuz 

1025
00:50:56,080 --> 00:50:59,880
runter, ich sehe immer grob 2 
Sachen, coole 

1026
00:50:59,880 --> 00:51:02,880
Programmiersprachen können 
sowohl sauberes Threading machen

1027
00:51:02,880 --> 00:51:06,040
und haben dafür ihre Toolkits. 
Also arbeiten mit echten 

1028
00:51:06,040 --> 00:51:10,160
Threads, mit echten parallelen 
Parallelläufigkeiten und dann 

1029
00:51:10,160 --> 00:51:13,040
brauche ich die ganze Toolbox 
von Multi CS und so weiter um 

1030
00:51:13,040 --> 00:51:15,920
das um um auszuschalten, dass 
ich da entsprechende 

1031
00:51:16,320 --> 00:51:20,320
Kollidierungen habe und und und.
Noch viel wichtiger Threading 

1032
00:51:20,320 --> 00:51:25,520
ist das eine und saubere Promise
basierte Asynculate Bibliothek, 

1033
00:51:25,520 --> 00:51:28,280
wo ich quasi ohne dass ich 
wahnsinnig werde in 

1034
00:51:28,280 --> 00:51:30,640
irgendwelchen Callback Chains, 
sondern wo ich sauber 

1035
00:51:30,640 --> 00:51:33,760
hinschreiben kann. 
Eine eine das in dir gibt es 

1036
00:51:33,760 --> 00:51:35,360
jetzt in den in den 
unterliegenden Sprachen gibt es 

1037
00:51:35,360 --> 00:51:37,640
da verschiedene Wörter für 
Promise, Futures und so weiter 

1038
00:51:37,640 --> 00:51:41,280
und sofort, aber ich will das 
einfach quasi sequentiell 

1039
00:51:41,280 --> 00:51:43,920
runterschreiben ich will als 
Entwickler sehen Awayed 

1040
00:51:43,920 --> 00:51:47,440
irgendwas ja und wir wissen alle
er springt irgendwo anders in 

1041
00:51:47,440 --> 00:51:51,000
dem Programm macht das hat n 
Event loop quasi drin ja hier 

1042
00:51:51,000 --> 00:51:52,560
auch noch mal ne Frage was macht
da Rust? 

1043
00:51:52,560 --> 00:51:56,120
Haben wir hoffentlich in Rust 
einen eigenen sicher eingebauten

1044
00:51:56,120 --> 00:51:58,360
Event loop oder muss ich mir den
auch von außen dran kaufen und 

1045
00:51:58,360 --> 00:51:59,680
aktivieren oder wie funktioniert
das? 

1046
00:52:00,160 --> 00:52:04,320
Was in die Sprache eingebacken 
ist, ist das Asic and the Wait, 

1047
00:52:04,800 --> 00:52:08,960
was nicht in die, was nicht in 
die Sprache eingebacken ist, ist

1048
00:52:08,960 --> 00:52:12,560
die Runtime oder der der 
sogenannte Execute, wobei der 

1049
00:52:12,560 --> 00:52:17,600
Execute n Teil der Runtime ist. 
Es gibt de facto Standards, aber

1050
00:52:17,600 --> 00:52:23,840
es gibt keine Standard Runtime 
für Asic and the Wait, die musst

1051
00:52:23,840 --> 00:52:26,720
du dir von außen rein kaufen, 
die meisten nehmen dafür, das 

1052
00:52:26,720 --> 00:52:28,160
hab ich vorhin kurz erwähnt, 
Tokio. 

1053
00:52:28,640 --> 00:52:31,320
Es gibt auch andere 
Möglichkeiten, je nachdem was 

1054
00:52:31,320 --> 00:52:34,200
man was man erreichen möchte. 
Dazu gibt es auch n Masse 

1055
00:52:34,200 --> 00:52:35,480
Artikel. 
Wir haben auch schon n linkedin 

1056
00:52:35,480 --> 00:52:38,400
Post zu zu gemacht, es ist 
wunderbar möglich das zu tun, 

1057
00:52:38,760 --> 00:52:42,320
man muss sich gut überlegen 
welche Runtime man nimmt, weil 

1058
00:52:42,440 --> 00:52:45,280
man sich dann auch etwas an sie 
bindet, weil sie bestimmte 

1059
00:52:45,280 --> 00:52:48,320
Sachen wie beispielsweise 
asynchrone Datei einlesen und so

1060
00:52:48,320 --> 00:52:50,640
weiter da mal selbst 
implementiert, das ist das find 

1061
00:52:50,640 --> 00:52:52,760
ich spannend, dass das nicht 
geregelt wird in einer modernen 

1062
00:52:52,760 --> 00:52:55,000
Sprache. 
Das hätte ich also jetzt 

1063
00:52:55,000 --> 00:52:56,720
persönliche Meinung, ohne 
irgendwie wie zu wissen oder 

1064
00:52:56,720 --> 00:52:59,360
sowas, aber ich find ja. 
Das ist so grundsätzlich, dass 

1065
00:52:59,360 --> 00:53:02,480
und auch in Python ist es auch 
so, dass es lange nicht fix war.

1066
00:53:02,480 --> 00:53:04,720
Und es ist, natürlich gibt es 
bei mir ne Community Bibliothek,

1067
00:53:04,720 --> 00:53:07,800
die man dafür nimmt und so, ich 
find das ist ein großer Vorteil 

1068
00:53:07,800 --> 00:53:10,520
von javascript da ich mach kurz 
nochmal javascript was in die 

1069
00:53:10,520 --> 00:53:14,080
Waage und voll ich javascript 
und Note GS also ne die haben ja

1070
00:53:14,160 --> 00:53:17,000
die haben das festgelegt da ist 
das ist der der Event Loop ist 

1071
00:53:17,000 --> 00:53:20,800
Teil der der Idee von Note GS 
und so weiter und fix ja und für

1072
00:53:20,800 --> 00:53:24,240
alle gleich und ist ja auch was 
total essentielles ja das Ganze.

1073
00:53:24,560 --> 00:53:26,640
Ja, diese ganze Nebenläufigkeit 
und und und. 

1074
00:53:26,640 --> 00:53:29,280
Die Eventschachtelung und so 
weiter ist ja quasi. 

1075
00:53:29,600 --> 00:53:32,560
Also es gibt Leute, die sagen, 
ich würde es ist überhaupt kein 

1076
00:53:32,560 --> 00:53:35,520
Ding, ne gehst du hin, nimmst 
Tokio, funktioniert alles. 

1077
00:53:35,520 --> 00:53:38,960
Die Community ist riesig, gibt 
so keine eigene Tokio Konferenz 

1078
00:53:39,200 --> 00:53:42,480
so also so so beliebt ist das, 
aber ich würde eben lügen wenn 

1079
00:53:42,480 --> 00:53:45,440
ich sagen würde das ist mitkommt
mit der Sprache und man muss 

1080
00:53:45,440 --> 00:53:48,720
sich dann halt überlegen, dass 
dass man, dass das nicht Teil 

1081
00:53:48,800 --> 00:53:50,680
der kompletten Rust Foundation 
und der Sprache ist. 

1082
00:53:50,680 --> 00:53:53,360
Das ist einfach nicht so, ich 
seh da jetzt nicht das Problem, 

1083
00:53:53,360 --> 00:53:55,920
aber ja ja. 
Vielleicht erliegt Tokio dann 

1084
00:53:55,920 --> 00:53:57,840
dem Schicksal der Boost 
Libraries, und die werden dann 

1085
00:53:57,840 --> 00:54:00,600
quasi peu a peu in den Standard 
mit übernommen. 

1086
00:54:00,600 --> 00:54:02,960
In den neueren Versionen von 
Rust wird man sehen, ne. 

1087
00:54:03,040 --> 00:54:05,000
Ich fand das nicht schlimm, ich 
find das auch. 

1088
00:54:05,040 --> 00:54:06,880
Ich fand jetzt momentan ist ja 
jetzt momentan auch nicht so, du

1089
00:54:06,960 --> 00:54:08,880
find es wahrscheinlich. 
Sogar gut. 

1090
00:54:08,880 --> 00:54:10,480
Ich find es gut. 
Ja ich bin mal. 

1091
00:54:10,480 --> 00:54:13,600
Ich bin meiner Meinung, also du 
musst ja auch als Entwickler 

1092
00:54:13,600 --> 00:54:15,600
sehen, ja wir haben, wir haben 
sowieso 1000 und eine 

1093
00:54:15,600 --> 00:54:17,600
Möglichkeit der 
Programmiersprachenauswahl und 

1094
00:54:17,600 --> 00:54:19,760
so weiter und sofort ja also 
wenn ich finde wenn. 

1095
00:54:20,320 --> 00:54:22,400
Wenn mir irgendjemand sagt, ich 
garantier dir das und das ist 

1096
00:54:22,400 --> 00:54:24,360
cool, und das gehört zur 
Programmiersprache und somit ist

1097
00:54:24,360 --> 00:54:27,120
es halt gut ausgewählt. 
Ja, und auch die Implementierung

1098
00:54:27,120 --> 00:54:29,840
ist auch gut ausgewählt, wenn 
ich da weniger Freiheitsgrade 

1099
00:54:29,840 --> 00:54:33,600
hab für Sachen die ich finde. 
Zum Standard gehören zum 

1100
00:54:33,600 --> 00:54:36,440
Programmiersprachen Standard, 
dann bin ich nur happy, ja. 

1101
00:54:36,440 --> 00:54:40,720
Also ich gehe auch davon aus, 
dass das nur noch ne Frage der 

1102
00:54:40,720 --> 00:54:43,200
Zeit ist, bis das bis das dann 
integriert wird. 

1103
00:54:43,200 --> 00:54:47,360
Aber das ist wirklich. 
Nur eine Vermutung von mir und 

1104
00:54:47,360 --> 00:54:49,280
das kann ich überhaupt nicht 
belegen, aber ich, ich geh davon

1105
00:54:49,280 --> 00:54:51,120
aus, dass das ne, dass das 
passieren wird. 

1106
00:54:51,200 --> 00:54:52,880
Aber und. 
Jetzt kommt noch mein letzter 

1107
00:54:52,960 --> 00:54:56,480
und dann bin ich auch wirklich 
fertig, weil es ist spannend. 

1108
00:54:56,480 --> 00:54:58,440
Es wird ne lange frage, was 
macht nichts vielleicht ich 

1109
00:54:58,440 --> 00:55:00,360
glaube alle die noch mit Rust 
nicht so viel zu tun hatten, die

1110
00:55:00,360 --> 00:55:02,600
finden es vielleicht auch ganz 
spannend legen wir los, du hast 

1111
00:55:02,600 --> 00:55:06,000
mir angeteasert im im in der 
Vorschau schon als wir uns 

1112
00:55:06,000 --> 00:55:07,880
zusammengesprochen haben, da 
hast du gesagt es gibt keine 

1113
00:55:07,880 --> 00:55:10,520
Exceptions ja mal gucken ob ich 
das verstanden hab. 

1114
00:55:10,720 --> 00:55:11,960
Aber das wär jetzt mal nächste 
Frage. 

1115
00:55:11,960 --> 00:55:14,480
Also Ausnahmebehandlung in 
Programmiersprachen ist ja auch 

1116
00:55:14,480 --> 00:55:17,320
ein Programmiersprachen Cross 
Konzept, was entweder haben die 

1117
00:55:17,320 --> 00:55:19,560
das oder nicht. 
Ja also ich sag es noch mal für 

1118
00:55:19,560 --> 00:55:23,400
die Zuhörer n ganzer ganzer 
Klassiker ist ja ich will 

1119
00:55:23,400 --> 00:55:26,320
irgendwie n Pfeil lesen und hab 
den Code hingeschrieben ja und 

1120
00:55:26,320 --> 00:55:29,040
den Read irgendwas und was 
meistens dynamisch ist, nämlich 

1121
00:55:29,040 --> 00:55:31,200
der der Pfeilname selber der 
Pass dahin. 

1122
00:55:31,840 --> 00:55:34,560
So und sind aus irgendeinem 
Grund, und das ist, den gibt es 

1123
00:55:34,560 --> 00:55:37,240
schnell, gibt es dieses File 
nicht mehr an der Stelle, so wie

1124
00:55:37,240 --> 00:55:39,760
es angegeben wurde und jetzt 
versucht quasi der Code an der 

1125
00:55:39,760 --> 00:55:41,600
Stelle n file zu lesen, was 
nicht existiert. 

1126
00:55:41,600 --> 00:55:44,200
Ja und das ist n klassischer 
Fall bei vielen 

1127
00:55:44,200 --> 00:55:46,880
Programmiersprachen, dann würde 
quasi die Read Funktion die aus 

1128
00:55:46,880 --> 00:55:49,200
dem Aus der Programmiersprache 
selber oft kommt. 

1129
00:55:49,200 --> 00:55:52,800
Ja das ist ne standardbibliothek
also file file IO ist also 

1130
00:55:52,800 --> 00:55:55,800
gehört genauso wie 
Entschuldigung Promis und so 

1131
00:55:55,800 --> 00:55:57,680
weiter gehört zu mich zur zur 
Stelle. 

1132
00:55:59,200 --> 00:56:00,720
Kürze mich zur 
Standardausrüstung einer 

1133
00:56:00,720 --> 00:56:03,200
Programmiersprache. 
So, und wenn das das nicht kann,

1134
00:56:03,760 --> 00:56:06,400
ja dann, dann gibt es 
normalerweise ne Exception, was 

1135
00:56:06,400 --> 00:56:08,920
heißt normalerweise ja aber und 
ne Exception ist und das muss 

1136
00:56:08,920 --> 00:56:10,720
man vielleicht noch mal kurz 
hier auf die Tonspur bringen, 

1137
00:56:10,720 --> 00:56:12,240
dass man das versteht was los 
ist. 

1138
00:56:12,240 --> 00:56:15,040
Normalerweise kann ne Funktion, 
wenn sie keine Exception hat, 

1139
00:56:15,040 --> 00:56:18,320
nichts anderes als von oben nach
unten durchlaufen und ich trete 

1140
00:56:18,320 --> 00:56:20,560
aus der Funktion ich trete ein 
in die Funktion, indem ich sie 

1141
00:56:20,560 --> 00:56:22,920
aufrufe und geb die Argumente 
rein und ich trete aus aus der 

1142
00:56:22,920 --> 00:56:25,280
Funktion mit dem schönen Wort 
Return, das ist auch fast in 

1143
00:56:25,280 --> 00:56:26,560
allen Programmiersprachen 
gleich. 

1144
00:56:26,920 --> 00:56:29,960
Das heißt fast immer return ne, 
weil ich komme zurück aus diesem

1145
00:56:29,960 --> 00:56:33,680
Prozess. 
Ja und und wenn ich jetzt keine,

1146
00:56:33,680 --> 00:56:36,720
wenn ich jetzt keine exceptions 
hab, dann komm ich da so raus 

1147
00:56:36,720 --> 00:56:39,040
und wenn dann muss ich in dem 
Return, das ist nämlich Punkt, 

1148
00:56:39,040 --> 00:56:42,400
dann muss ich entweder indem ich
n Argument überschreibe oben was

1149
00:56:42,400 --> 00:56:45,840
ich ziemlich aggly finde oder in
dem Return Statement sagen hier 

1150
00:56:45,840 --> 00:56:49,280
ist irgendein Fehler vorgekommen
in während ich das machen wollte

1151
00:56:49,280 --> 00:56:52,160
eigentlich ja. 
Und deswegen gibt es exceptions,

1152
00:56:52,160 --> 00:56:54,560
weil was das führt dazu. 
Eigentlich will ich im Return 

1153
00:56:54,560 --> 00:56:57,280
Statement sagen das Return was 
das Ding ausrechnen soll, 

1154
00:56:57,280 --> 00:56:59,680
nämlich zum Beispiel irgendwie 
ne Statistik die ich in dem Fall

1155
00:57:00,160 --> 00:57:03,520
calculated hab ja jetzt muss ich
auf einmal sagen es hat auch 

1156
00:57:03,520 --> 00:57:06,320
nicht geklappt ja dann hab ich 
irgendwie 2 Datentypen weil die 

1157
00:57:06,320 --> 00:57:08,640
Statistik ist irgendwie ach was 
weiß ich, das war vielleicht 

1158
00:57:08,640 --> 00:57:10,680
irgendein Average also es ist 
irgendwie n Floating Point 

1159
00:57:10,680 --> 00:57:12,640
gewesen oder irgend sowas und 
jetzt will ich auf einmal sagen 

1160
00:57:12,640 --> 00:57:15,680
es hat nicht geklappt ja es ist 
dann 0 oder irgendwas oder so 

1161
00:57:15,680 --> 00:57:18,120
das ist halt da da komm ich halt
so n Twist ja und deswegen hat 

1162
00:57:18,120 --> 00:57:19,680
man sich überlegt es gibt 
Exceptions. 

1163
00:57:19,920 --> 00:57:22,400
Mhm und wenn ich ne Exception 
hab, dann brech ich an der 

1164
00:57:22,400 --> 00:57:24,320
Stelle wo ich irgendwie nicht 
mehr weiter kann, weil das File 

1165
00:57:24,320 --> 00:57:26,560
nämlich nicht ist. 
Ab den Flow und es ist der 

1166
00:57:26,560 --> 00:57:28,960
zweite Austrittspunkt aus einer 
Funktion, nämlich nicht der 

1167
00:57:28,960 --> 00:57:32,600
Return wert, sondern ich hör da 
auf und geb quasi dem Programm 

1168
00:57:32,600 --> 00:57:33,800
mit. 
Alter ich hab hier n Fehler 

1169
00:57:33,800 --> 00:57:36,120
gehabt, der heißt so und so und 
hier kann ich noch n Code und so

1170
00:57:36,120 --> 00:57:39,840
weiter und dann rollt sich das 
alles ab ja so und du sagst 

1171
00:57:39,840 --> 00:57:42,320
dieses schöne Feature der 
Exceptions gibt es nicht oder 

1172
00:57:42,320 --> 00:57:43,720
was? 
Obwohl es so ne moderne 

1173
00:57:43,720 --> 00:57:46,560
Programmiersprache ist. 
Ja genau, es gibt auch keinen 0.

1174
00:57:46,560 --> 00:57:48,240
Wert. 
Also da, das ist ja genau der 

1175
00:57:48,240 --> 00:57:51,240
Punkt, der den bei dem mein Herz
tatsächlich dann auch wieder ein

1176
00:57:51,240 --> 00:57:54,200
bisschen hüpft. 
Denn viele Probleme, das hatte 

1177
00:57:54,200 --> 00:57:57,360
ich ja vorhin auch noch mal zu 
dir gesagt, passieren ja dann, 

1178
00:57:57,360 --> 00:58:00,400
während das während das Programm
ausgeführt wird, und da ist es 

1179
00:58:00,400 --> 00:58:05,520
so, dass wir aus verschiedenen 
Sprachkonstrukten etwas bauen 

1180
00:58:05,520 --> 00:58:09,120
können, was letzten Endes auch 
für eine Fehlerbehandlung sorgt,

1181
00:58:09,200 --> 00:58:13,680
aber dafür sorgt, dass wir kein 
kein unvorgesehenes Verhalten 

1182
00:58:13,680 --> 00:58:18,000
haben, denn. 
In in Rust gibt es sind die E 

1183
00:58:18,000 --> 00:58:20,960
Nams, also eine E. 
Nam ist im Prinzip eine eine 

1184
00:58:20,960 --> 00:58:24,240
Menge von von Variationen. 
Also ich könnte sagen ich hab 

1185
00:58:24,240 --> 00:58:27,240
einen, ich hab ein Tier und das 
hat die Ausprägung Katze und 

1186
00:58:27,240 --> 00:58:31,320
Hund und diesen Ausprägung Katz 
und Hund kann ich noch was 

1187
00:58:31,320 --> 00:58:34,240
mitgeben n sogenannter Payload 
wie man gerne sagt also ich 

1188
00:58:34,240 --> 00:58:38,720
hänge noch zusätzliche Daten 
dort dran und bei bei Rust ist 

1189
00:58:38,720 --> 00:58:43,440
es so, dass ich standardmäßig 
oder in in vielen Fällen. 

1190
00:58:43,840 --> 00:58:48,240
Ein Enam habe, was sich result 
nennt und in diesem Result 

1191
00:58:48,240 --> 00:58:52,560
steckt entweder das wirkliche 
konkrete Ergebnis drin oder der 

1192
00:58:52,560 --> 00:58:56,880
Fehler, der bei der Ausführung 
der entsprechenden Funktion 

1193
00:58:56,880 --> 00:58:59,600
passiert ist. 
Und dann kann ich über das 

1194
00:58:59,600 --> 00:59:03,440
sogenannte Pattern Matching, das
heißt ich habe einen bestimmten,

1195
00:59:03,440 --> 00:59:06,400
eine bestimmte Variable und da 
können verschiedene Dinge drin 

1196
00:59:06,400 --> 00:59:08,560
sein. 
Also ich hab diese Varianten 

1197
00:59:08,560 --> 00:59:11,520
von. 
Von Tier oder ich hab den dieses

1198
00:59:11,520 --> 00:59:14,440
ihr diese inumeration Enem von 
Tier und da hab ich Katze und 

1199
00:59:14,440 --> 00:59:17,120
Hund und da kommt jetzt eine 
Funktion die sagt Ich geb dir 

1200
00:59:17,120 --> 00:59:20,120
jetzt n Tier zurück und dann sag
ich mit dem Pattern Matching ja 

1201
00:59:20,120 --> 00:59:23,120
Moment in dem Fall von Katze 
mach ich das in dem Fall von 

1202
00:59:23,120 --> 00:59:27,360
Hund mach ich das und so kann 
ich dann auch mit Fehler oder 

1203
00:59:27,360 --> 00:59:31,600
mit dem mit dem jeweiligen Wert 
also mit dem jeweiligen Success 

1204
00:59:31,600 --> 00:59:35,520
der zurückkommt auch arbeiten 
und so gehe ich hin und muss. 

1205
00:59:35,880 --> 00:59:38,120
Das ist wieder dieses dieses 
Punkt und ich hoffe jetzt 

1206
00:59:38,120 --> 00:59:42,480
verzeiht mir, dass mein Herz so 
hüpft, muss zur Kompeilzeit, 

1207
00:59:42,480 --> 00:59:45,760
also zur Übersetzungszeit dann 
sagen können, wie soll dieses 

1208
00:59:45,760 --> 00:59:48,920
Verhalten sein, dass ich auf 
keinen Fall in diese Situation 

1209
00:59:48,920 --> 00:59:51,560
einkomme, indem ich sage, oh, 
ich weiß nicht, es kam jetzt 

1210
00:59:51,560 --> 00:59:54,320
doch der Hamster zurück, was 
geht, was geht ab und wenn er 

1211
00:59:54,320 --> 00:59:57,360
wenn wenn ich den Hamster 
behandeln möchte, dann muss ich 

1212
00:59:57,360 --> 00:59:59,800
den definieren, wenn ich den 
Vordefiniert habe, muss ich ihn 

1213
00:59:59,800 --> 01:00:02,960
behandeln et cetera, das heißt, 
es gibt kein unvorhergesehenes 

1214
01:00:02,960 --> 01:00:06,000
Verhalten. 
So werden die Exceptions 

1215
01:00:06,000 --> 01:00:10,200
sozusagen ja ergänzt ersetzt. 
Ja, sag mal ich. 

1216
01:00:10,240 --> 01:00:13,040
Ich bin provokativ und sage, OK,
wir programmieren Rust halt 

1217
01:00:13,040 --> 01:00:15,680
immer so, dass wir einen 
komplexen Return Typ haben, ne, 

1218
01:00:15,680 --> 01:00:18,040
wir verzichten also wir haben 
keine Exceptions, dafür 

1219
01:00:18,040 --> 01:00:20,360
verzichten wir darauf einfache 
Returnwerte zu haben, sondern 

1220
01:00:20,360 --> 01:00:23,040
haben eigentlich immer nen 
Konstrukt was mindestens n Pair 

1221
01:00:23,040 --> 01:00:25,840
ist oder oder wie auch immer n 
oder irgend so was oder n 

1222
01:00:25,840 --> 01:00:27,840
Dictionary oder irgend so wie ja
wo immer dran steht. 

1223
01:00:28,000 --> 01:00:29,960
Hier kommt was raus und übrigens
war das Scheiße, oder? 

1224
01:00:29,960 --> 01:00:32,920
Das war nicht Scheiße so. 
Ja, also richtig, ja muss quasi 

1225
01:00:32,920 --> 01:00:34,960
immer wenn ich und das wird 
wahrscheinlich bei den dann bei 

1226
01:00:34,960 --> 01:00:37,680
den Standardbibliothekfunktionen
auch so sein, dass die dann auch

1227
01:00:37,680 --> 01:00:40,120
schon quasi dieses Standard 
result nehmen, irgendwie OK, 

1228
01:00:40,120 --> 01:00:42,720
alles klar, also dann für unsere
Zuhörer alles klar, dann haben 

1229
01:00:42,720 --> 01:00:46,720
wir quasi es so gelöst, dass wir
tatsächlich dieses im Return 

1230
01:00:46,720 --> 01:00:48,840
wert, den wird der wird so 
Aufgepustet in Rust 

1231
01:00:48,840 --> 01:00:51,280
typischerweise einfach 
wahrscheinlich bei Policy muss 

1232
01:00:51,280 --> 01:00:54,480
es wahrscheinlich nicht tun, 
aber es ist der gute, der gute 

1233
01:00:54,480 --> 01:00:57,280
Weg, der gute Ton, der gute Ton,
genau. 

1234
01:00:57,680 --> 01:01:00,320
Hab ich einen Return wert, der 
quasi beides ausdrücken kann? 

1235
01:01:00,320 --> 01:01:04,200
Entweder den tatsächlichen Wert 
oder halt ein Fehler und ich 

1236
01:01:04,200 --> 01:01:06,400
kann das halt gut erkennen in 
der Sprache und dann brauch ich 

1237
01:01:06,560 --> 01:01:09,800
brauch ich vielleicht nicht das 
Exception Handling genau und das

1238
01:01:09,800 --> 01:01:12,440
aber spielt natürlich in eine 
spielt die gleiche Geige sag ich

1239
01:01:12,440 --> 01:01:15,160
mal weil das weiß man auch 
Exception Handling und das 

1240
01:01:15,160 --> 01:01:17,600
Abkürzen von Funktionen und das 
wieder aufräumen von Memory und 

1241
01:01:17,600 --> 01:01:20,840
so weiter das ist genauso. 
Nebenläufig speicherintensiv sag

1242
01:01:20,840 --> 01:01:22,960
ich mal. 
Nicht ganz so performant, wie 

1243
01:01:22,960 --> 01:01:24,480
wenn ich das halt einfach 
abschalte. 

1244
01:01:24,480 --> 01:01:26,480
Und wenn ich auch Garbage 
Collection abschalte, dann kann 

1245
01:01:26,480 --> 01:01:28,680
ich halt, ich sag mal ganz 
Hardware nah, wenn ich auf dem 

1246
01:01:28,880 --> 01:01:31,440
SP laufe oder irgend so was, da 
kann ich da richtig viel 

1247
01:01:31,440 --> 01:01:34,440
rausholen an Performanz ja man 
es ist auch so, dass man mit C 

1248
01:01:34,440 --> 01:01:37,160
plus plus kann man ja, man kann 
ja mit C plus plus auch Hardware

1249
01:01:37,160 --> 01:01:39,400
nah programmieren, klar wissen 
wir Embedded, klar, da wird 

1250
01:01:39,400 --> 01:01:41,440
tatsächlich auch Exception 
Handling typischerweise 

1251
01:01:41,440 --> 01:01:44,360
abgeschaltet per Default, ja da 
muss ich auch anders irgendwie 

1252
01:01:44,360 --> 01:01:46,680
klarkommen so. 
Aus genau den Gründen. 

1253
01:01:46,720 --> 01:01:49,040
Und nur um ne kleine Anekdote 
aus der Realität nochmal zu 

1254
01:01:49,040 --> 01:01:50,800
bringen. 
Es gab das ist durch die durch 

1255
01:01:50,800 --> 01:01:53,760
das Internet gegeistert, ich 
glaube vor 4 Monaten oder so wo 

1256
01:01:53,760 --> 01:01:56,680
dann irgendwie Cloud Flair 
Problem hatte und dann ist ganz 

1257
01:01:56,680 --> 01:02:00,000
ist so n Ruscode auch angezeigt 
worden oder geleakt worden oder 

1258
01:02:00,000 --> 01:02:02,880
was weiß ich und da gab es 
dieses wunderschöne Wort unrap 

1259
01:02:03,200 --> 01:02:06,880
und die Idee von Unrap ist ich 
hab meine ich hab dieses Result 

1260
01:02:07,280 --> 01:02:10,840
und da steckt etwas drin der der
der Wert den ich wirklich haben 

1261
01:02:10,840 --> 01:02:13,600
möchte und wenn es mir. 
Puste ist und ich sage, ist mir 

1262
01:02:13,600 --> 01:02:16,520
vollkommen wurscht. 
Ich will jetzt, ich gehe fest 

1263
01:02:16,520 --> 01:02:19,360
davon aus, dass dieser Wert da 
drin steckt, dann ruf ich unrap 

1264
01:02:19,360 --> 01:02:21,840
aus und dann wird das einfach 
ausgepackt, ohne dass ich was 

1265
01:02:21,920 --> 01:02:26,600
anderes behandeln muss und wenn 
ich das aber mache und da ist 

1266
01:02:26,600 --> 01:02:28,960
nichts drin, dann fängt das Ding
auf einmal an zu crashen, so, 

1267
01:02:28,960 --> 01:02:30,840
und das ist der Punkt, also du 
kannst das machen, wenn du 

1268
01:02:30,840 --> 01:02:33,840
möchtest. 
Und deswegen ist Unrap eine 

1269
01:02:33,840 --> 01:02:36,880
Möglichkeit, um schnell zu 
ergeb, zu Ergebnissen zu kommen,

1270
01:02:36,880 --> 01:02:39,280
wenn man das in Produktion 
reinbringen möchte, dann gibt es

1271
01:02:39,280 --> 01:02:41,480
viele Leute, die statische 
Codeanalyse machen, also wo dann

1272
01:02:41,480 --> 01:02:44,320
einer durchgeht und noch mal 
sagt, steckt hier irgendwo unrap

1273
01:02:44,320 --> 01:02:46,640
drin und dann sagt Ah Unrap 
steckt hier drin, das darf nicht

1274
01:02:46,640 --> 01:02:50,000
und das muss weg, so kann man 
das dementsprechend für die 

1275
01:02:50,000 --> 01:02:53,400
Produktion dann machen so das 
ist der der Punkt den man an an 

1276
01:02:53,400 --> 01:02:56,080
der Stelle bei Code ja auch 
gemacht hat und hat gesagt da 

1277
01:02:56,080 --> 01:02:58,640
mach ich n unrap da war aber 
kein Wert drin bumm ist das Ding

1278
01:02:58,720 --> 01:03:00,080
gecrasht. 
Arbeit. 

1279
01:03:00,960 --> 01:03:02,880
Auf jeden Fall mal ne Folge für 
wahrscheinlich 

1280
01:03:02,880 --> 01:03:04,920
Softwareentwickler oder 
mindestens für Leute, die sich 

1281
01:03:04,920 --> 01:03:07,200
für Rust interessieren. 
Aber macht nichts wir, wir haben

1282
01:03:07,200 --> 01:03:09,000
ja verschiedene Folgen für 
verschiedene Geschmäcker, das so

1283
01:03:09,000 --> 01:03:10,840
alles das ist genau richtig so. 
Ja ich fand es richtig spannend 

1284
01:03:10,840 --> 01:03:11,920
für. 
Wen soll es sonst sein, wenn ich

1285
01:03:11,920 --> 01:03:13,360
für Leute, die sich für Rust 
interessieren. 

1286
01:03:14,000 --> 01:03:16,800
Also und das das ist ja der 
Punkt, den den ich auch noch mal

1287
01:03:16,800 --> 01:03:18,760
rausstellen möchte, auch für die
für die Businessleute und auch 

1288
01:03:18,760 --> 01:03:21,400
für die Kunden, die ich, die ich
habe, das ist so das, was ich 

1289
01:03:21,400 --> 01:03:24,160
vorhin schon gesagt habe, wenn 
man hingeht und sagt, ich möchte

1290
01:03:24,160 --> 01:03:27,920
was Verlässliches machen. 
Ich möchte mein mein Business so

1291
01:03:27,920 --> 01:03:31,120
sichern, dass ich sage, ich 
möchte in in Produktion wenig 

1292
01:03:31,120 --> 01:03:35,040
Probleme haben. 
Dann investiert in in die Idee 

1293
01:03:35,040 --> 01:03:38,080
das auf Basis von Ress zu machen
kann ich nur empfehlen. 

1294
01:03:38,160 --> 01:03:39,360
Könnt ihr auch meine Kunden mal 
fragen. 

1295
01:03:39,680 --> 01:03:42,600
Die die 2 Hauptthemen hab ich 
hier so rausgezogen ohne die 

1296
01:03:42,600 --> 01:03:45,160
ganzen technischen Details zu 
verstehen und mehr merken zu 

1297
01:03:45,160 --> 01:03:46,280
müssen. 
Ist nicht glaub ich nicht so 

1298
01:03:46,280 --> 01:03:48,280
wichtig, aber ich hab verstanden
es ist einerseits für die 

1299
01:03:48,280 --> 01:03:50,520
Programmierer eigentlich super, 
weil das Ökosystem irgendwie 

1300
01:03:50,520 --> 01:03:53,000
stark ist und man eigentlich 
letzten Endes effizient ist. 

1301
01:03:53,000 --> 01:03:55,120
Ja, Cross Plattformen haben wir 
drüber gesprochen. 

1302
01:03:55,400 --> 01:03:58,920
Programmiere einmal Compiler für
alles und ist dann aber auch 

1303
01:03:58,920 --> 01:04:01,640
entsprechend für die Nutzer ganz
praktisch, vielleicht auch 

1304
01:04:01,640 --> 01:04:03,520
kostengünstiger, sogar 
langlebig. 

1305
01:04:03,520 --> 01:04:05,920
Du hast auch von Robustheit 
gesprochen, das könnte man auch 

1306
01:04:05,920 --> 01:04:08,600
fast als Langlebigkeit irgendwie
so n bisschen betiteln, ne hätt 

1307
01:04:08,600 --> 01:04:11,200
ich jetzt so mitgenommen und was
ich auch noch verstanden hab 

1308
01:04:11,200 --> 01:04:13,280
ist, dass es irgendwie n 
ziemlich starken Compiler gibt 

1309
01:04:13,280 --> 01:04:17,520
und Probleme die entstehen nicht
zur Runtime entstehen, sondern 

1310
01:04:17,520 --> 01:04:19,440
einfach schon im 
Entwicklungsprozess letzten 

1311
01:04:19,440 --> 01:04:23,760
Endes ne das exakt perfekt. 
Genau so hab ich es gemeint. 

1312
01:04:23,760 --> 01:04:24,920
Was? 
Haben wir denn noch vergessen 

1313
01:04:24,920 --> 01:04:26,720
aus deiner Sicht? 
Also was sollten wir noch auf 

1314
01:04:26,720 --> 01:04:29,120
die Turnschuhe bringen heute zu 
Rust gibt es. 

1315
01:04:29,640 --> 01:04:34,840
Da was also wir, wir bleiben ja 
ehrlich in in der in der ganzen 

1316
01:04:34,840 --> 01:04:37,680
Kommunikation. 
Ja, das kommt natürlich auch 

1317
01:04:37,760 --> 01:04:41,200
alles mit einem, mit einer 
Gewissen, mit einem gewissen 

1318
01:04:41,200 --> 01:04:44,600
Aufwand, denn, und das das ist 
auch ne Sache, die man immer 

1319
01:04:44,600 --> 01:04:48,480
wieder liest und da ist auch was
dran, die Lernkurve ist am 

1320
01:04:48,480 --> 01:04:51,360
Anfang schwierig. 
Und beziehungsweise nicht 

1321
01:04:51,360 --> 01:04:53,440
schwierig. 
Die Lernkurve ist erstmal steil,

1322
01:04:53,760 --> 01:04:56,600
ich hab ja gesagt ich geb 
regelmäßig Rust Trainings und da

1323
01:04:56,600 --> 01:04:59,840
ist es so es es geht über 3 Tage
und das ist so erster Tag 

1324
01:05:01,040 --> 01:05:06,800
zweiter Tag Oh dritter Tag ah so
und diese diese 3 Tage man 

1325
01:05:06,800 --> 01:05:09,120
braucht diese wo ich wo ich dann
ich hab hol dir dann mal 

1326
01:05:09,120 --> 01:05:11,240
Feedback ein nach den 
entsprechenden Tagen nachdem sie

1327
01:05:11,240 --> 01:05:14,400
durch sind. 
Und es ist wirklich regelmäßig 

1328
01:05:14,400 --> 01:05:17,600
so, dass man am zweiten Takt 
sagt, also ich, ich, ich weiß 

1329
01:05:17,600 --> 01:05:20,160
nicht genau, wo soll denn das 
hinführen, irgendwie, wie wie, 

1330
01:05:20,160 --> 01:05:22,880
was ist denn jetzt hier und wie 
funktioniert denn das jetzt 

1331
01:05:22,880 --> 01:05:24,960
gerade, was ist jetzt mit diesem
ownership, was das ist dieses 

1332
01:05:24,960 --> 01:05:28,240
Move und was weiß ich, und wenn 
es dann durch ist, dieser Anfang

1333
01:05:28,240 --> 01:05:30,840
ist es, das ist wie also ich, 
ich vergleiche jetzt das gerne 

1334
01:05:30,840 --> 01:05:33,600
mit mit Gitarre spielen und und 
Schlagzeug spielen, ich find 

1335
01:05:33,760 --> 01:05:37,160
Schlagzeug spielen ist am Anfang
relativ einfach, weil man macht 

1336
01:05:37,160 --> 01:05:40,240
es dann so n Takt Gitarre 
spielen das am Anfang relativ 

1337
01:05:40,240 --> 01:05:41,800
schwer mit diesen Saitendrücken 
was. 

1338
01:05:41,960 --> 01:05:45,480
Alles und ich vergleich das dann
gerne mit Rust ist dann wie wie 

1339
01:05:45,480 --> 01:05:48,720
Gitarre lernen, mehr wie Gitarre
lernen als jetzt bei 

1340
01:05:48,720 --> 01:05:51,600
beispielsweise Schlagzeug musste
erst mal durch, dass das 

1341
01:05:51,600 --> 01:05:54,520
irgendwie Sinn ergibt und wenn 
man es dann aber gemacht hat und

1342
01:05:54,520 --> 01:05:58,360
dann so ne so ne gewisse 
Fingerfertigkeit hat, dann wird 

1343
01:05:58,360 --> 01:06:00,400
das einfacher und dann ergibt 
das auch alles Sinn und dann 

1344
01:06:00,400 --> 01:06:02,160
sagt man. 
Ach, ist ja irre. 

1345
01:06:02,160 --> 01:06:03,920
Das finde ich total cool, dass 
das so ist. 

1346
01:06:03,920 --> 01:06:05,760
Und das möchte ich zumindest 
noch erwähnen. 

1347
01:06:06,160 --> 01:06:09,200
Guckt euch das an, probiert das 
erst mal aus und. 

1348
01:06:09,720 --> 01:06:12,000
Und gebt dem n bisschen ne 
Chance. 

1349
01:06:12,000 --> 01:06:14,880
Nicht nur Hello World und et 
cetera, sondern probiert das 

1350
01:06:14,880 --> 01:06:16,400
wirklich aus. 
Es hat alles seinen Sinn. 

1351
01:06:16,960 --> 01:06:19,320
Ich glaube, den anderen wirst du
angesteckt haben. 

1352
01:06:19,320 --> 01:06:21,120
Auf jeden Fall durch die Folge 
heute definitiv. 

1353
01:06:21,440 --> 01:06:24,160
Ich hoffe das sag noch mal ganz 
kurz für Deine Trainings, für 

1354
01:06:24,160 --> 01:06:26,080
wen ist das interessant? 
Also du hast vorhin schon mal 

1355
01:06:26,240 --> 01:06:28,560
gesagt, Personen die schon C 
plus plus können oder 

1356
01:06:28,560 --> 01:06:31,200
programmieren oder so die dann 
sag ich mal umschwenken oder ihr

1357
01:06:31,520 --> 01:06:34,480
Repertoire erweitern oder ist 
das für blutige Neulinge, also 

1358
01:06:34,480 --> 01:06:38,640
ganz kurz so die Flughöhe wie 
wann sollte man da bei dir ins 

1359
01:06:38,640 --> 01:06:40,960
Training kommen? 
Ich passe die Trainings 

1360
01:06:40,960 --> 01:06:43,440
grundsätzlich an, die meisten 
Trainings gehe ich tatsächlich 

1361
01:06:43,440 --> 01:06:48,000
für C plus Plus und C Umsteiger,
aber ich habe das auch. 

1362
01:06:48,000 --> 01:06:51,400
Ich habe mit 2 Kollegen in der 
Vergangenheit auch ein ein Buch 

1363
01:06:51,400 --> 01:06:54,240
geschrieben im D Punkt Verlag 
für Anwendungsentwicklung, das 

1364
01:06:54,320 --> 01:06:57,040
richtet sich auch an Java 
Entwickler, also wenn man 

1365
01:06:57,040 --> 01:06:59,640
Interesse daran hat und sagt Ich
möchte jetzt nicht mehr 

1366
01:06:59,640 --> 01:07:02,320
timescrip schreiben oder Python 
und ich möchte jetzt, dass es 

1367
01:07:02,320 --> 01:07:05,520
abgeht kann kann man sich immer 
an mich wenden, weil es. 

1368
01:07:05,800 --> 01:07:08,560
Verschiedene Trainingspakete 
gibt, wenn man das das machen 

1369
01:07:08,560 --> 01:07:10,480
möchte. 
Das ist überhaupt nicht das das 

1370
01:07:10,480 --> 01:07:12,880
Problem, cool, weil ich die 
Leute dort abhole, wo sie 

1371
01:07:12,880 --> 01:07:15,120
stehen. 
Super cool, Marcel. 

1372
01:07:15,120 --> 01:07:17,280
Dann würd ich sagen, haben wir 
was zu Rust gelernt. 

1373
01:07:17,280 --> 01:07:20,000
Vielen herzlichen Dank, dass du 
für euch zu Gast warst. 

1374
01:07:20,000 --> 01:07:24,080
Und ja, mich hat es sehr gefreut
und sage schon mal ciao. 

1375
01:07:24,560 --> 01:07:27,320
Mach es gut, ciao. 
Ich kann mich auch nur gerne 

1376
01:07:27,320 --> 01:07:28,480
anschließen. 
Vielen dank Marcel. 

1377
01:07:28,480 --> 01:07:30,400
Ich hab auch sehr viel gelernt, 
ich muss mir ja mal Rust 

1378
01:07:30,400 --> 01:07:32,960
reinziehen n bisschen tiefer. 
Das freut mich. 

1379
01:07:33,120 --> 01:07:35,440
So soll es sein. 
Macht's gut. 

1380
01:07:35,520 --> 01:07:39,280
Ciao, bis dahin, Tschüss. 
Einfach komplex wird produziert 

1381
01:07:39,280 --> 01:07:42,640
und präsentiert von Heisenware 
Heisenware ist deine Loco 

1382
01:07:42,640 --> 01:07:46,120
Plattform zur Erstellung und zum
Betrieb interaktiver Apps rund 

1383
01:07:46,120 --> 01:07:48,160
um den Shopfloor. 
Starte noch heute dein Free 

1384
01:07:48,160 --> 01:07:51,920
Trial unterheisenware.com 
einfach komplex.