WEBVTT

00:19.380 --> 00:23.660
Ok, jetzt packen wir es wieder auf zur 11. Zentralübung.

00:25.480 --> 00:28.420
Diesmal ist es ja stärker programmierlastig.

00:29.620 --> 00:34.280
Ich möchte Ihnen auch ein bisschen zeigen, wie man mit Gopher umgeht, was so die Paradigmen sind, die dahinter stehen.

00:35.460 --> 00:38.420
Und werde Sie da sozusagen einführen auf die wichtigsten Datentypen.

00:58.720 --> 01:02.800
Vorneweg muss ich noch ein paar organisatorische Sachen mit Ihnen noch abklären.

01:04.080 --> 01:07.100
Und zwar hinsichtlich der Klausur, wie das genau laufen wird.

01:08.580 --> 01:11.020
Und ich habe mal was vorbereitet.

01:13.500 --> 01:16.900
Sie müssen sich ja anmelden zur Klausur.

01:18.260 --> 01:21.280
Und wie läuft das prinzipiell? Sie gehen zum Prüfungsamt.

01:24.300 --> 01:26.720
Sie holen sich so einen gelben Zettel, das ist ein Antrag.

01:27.560 --> 01:33.880
Wenn Sie ihn ausgefüllt haben, dann erhalten Sie vom Prüfungsamt einen blauen, oder wenn Sie Wiederholer sind, einen rosa Zettel.

01:34.880 --> 01:41.820
Und diesen rosa Zettel, ich werde nächste Woche, Montag wird in der Vorlesung, in der Zentralübung, wird hier immer so ein kleiner Karton stehen.

01:42.180 --> 01:43.380
Da können Sie den Zettel schon mal einwerfen.

01:43.480 --> 01:47.120
Sie müssen nicht irgendwo rumrennen oder so, sondern Sie können den da schon mal einwerfen.

01:47.220 --> 01:49.140
Und das können Sie so lange machen, bis zum Semesterende.

01:49.600 --> 01:55.120
Und dann haben Sie noch zwei Wochen Zeit, wo Sie es bei mir persönlich vorbeibringen können, bis drei Tage vor der Klausur.

01:55.240 --> 01:56.340
Dann brauche ich halt einen Attest.

01:57.180 --> 02:00.020
Wie gesagt, das ist der Ablauf.

02:00.140 --> 02:05.600
Und wenn Sie dann zur Klausur kommen, dann brauchen wir noch einen Lichtbildausweis, einen Studentenausweis von Ihnen.

02:06.720 --> 02:08.100
So, und dann sollten Sie sich entscheiden.

02:08.280 --> 02:10.780
Also jetzt haben Sie den blauen Zettel schon eingeworfen, oder den rosa Zettel.

02:12.180 --> 02:15.300
Jetzt ist es mir doch nicht mehr so recht, ich möchte zurücktreten.

02:15.300 --> 02:23.520
Dann können Sie ganz locker zurücktreten von der Klausur, indem Sie mir einfach so eine informelle Rücktrittserklärung in den Karton werfen oder mich halt dann eben vorbeibringen.

02:23.820 --> 02:27.020
Das genügt mir, wie Sie es machen müssen.

02:27.300 --> 02:33.480
Und wie gesagt, drei Tage bevor die Klausur ist und Sie müssen dann zurücktreten, dann brauchen Sie ein ärztliches Attest,

02:34.000 --> 02:37.540
dass dann eben dieser blaue Schein wieder beim Prüfungssekretariat zurückgereicht wird.

02:37.800 --> 02:39.020
Das organisiere ich aber dann.

02:40.200 --> 02:41.580
So, und das ist für den Mainstream.

02:41.580 --> 02:44.140
Also die Leute, die sozusagen Informatik I studieren.

02:45.600 --> 02:50.400
Und jetzt gibt es ein paar Sonderfälle, bei denen läuft es etwas anders.

02:51.520 --> 02:53.720
Zum Beispiel bei den Physikern.

02:54.740 --> 02:58.500
Bei den Physikern genügt es mir, wenn sie mir eine informelle Erklärung schreiben.

02:59.000 --> 03:02.460
Name, Matrikelnummer, ich nehme an der Klausur Informatik I teil.

03:03.240 --> 03:07.460
Das ist sozusagen der Ersatzblaue Zettel, den schmeißen Sie genauso bei mir rein.

03:08.580 --> 03:11.360
Dann sollte es Studenten geben, die Lehramt machen.

03:12.300 --> 03:18.680
Da läuft es so, dass Sie sich beim Studien- und Prüfungssekretariat, das ist das Gebäude 5034,

03:19.000 --> 03:21.420
müssen Sie sich sozusagen anmelden beim Herrn Portelmes.

03:21.980 --> 03:27.860
Und der gibt Ihnen dann eine Auswertung, auch so einen pseudo-blauen Schein, der auch hier reinkommt.

03:28.780 --> 03:33.580
Für die Schülerstudenten auch informelle Anmeldung genügt mir vollkommen.

03:34.100 --> 03:36.780
Und bei den Mathematikern ist es wieder ein klein wenig anders.

03:37.380 --> 03:39.740
Da läuft es so, dass Sie sich am Institut für Informatik anmelden.

03:39.840 --> 03:41.500
Das ist auch so ein gelber Zettel.

03:42.180 --> 03:45.440
Der ist ein bisschen dunkelgelber als der andere gelbe Zettel.

03:46.500 --> 03:51.380
Und der wird dann beim Institut für Mathematik abgelegt.

03:51.920 --> 03:53.380
Und die reichen das dann rüber zu uns.

03:55.120 --> 03:57.440
Okay, da ist ein Fall.

03:57.440 --> 04:00.520
Ein großer Buch.

04:03.220 --> 04:06.080
Das Studienbuch brauchen Sie nicht bei der Klasse.

04:07.840 --> 04:11.160
Also wie gesagt, nur Lichtbildausweis und Studentenausweis, das genügt mir.

04:11.880 --> 04:16.920
Sie haben sich ja dann schon registriert und das reicht vollkommen aus, dass Sie eindeutig identifiziert werden können.

04:18.080 --> 04:21.340
Also das ist so das Prozedere, das vorliegt.

04:25.960 --> 04:31.200
Sonst sollten Sie eine Behinderung haben oder sowas.

04:31.560 --> 04:32.800
Das ist ein Extrafall.

04:33.540 --> 04:35.700
Bitte melden Sie sich einfach persönlich bei mir.

04:36.240 --> 04:40.580
Ich leite Sie dann weiter bzw. check Sie anders ein.

04:40.580 --> 04:43.740
Ich schalte es aber nochmal an bei der Tafel.

04:44.120 --> 04:49.120
Sie können sich einfach bei mir nochmal melden, per E-Mail oder auch persönlich.

04:54.880 --> 04:57.280
So, soweit zu den organisatorischen Sachen.

04:57.660 --> 04:59.760
Ich denke mal, es ist relativ klar, wie es abläuft.

05:03.400 --> 05:09.780
So, wir haben ja einen kurzen Überblick, was Sie heute nochmal erwartet.

05:10.920 --> 05:16.000
Also Gopher steht ja im Raum. Gopher müssen wir sozusagen beherrschen.

05:19.660 --> 05:22.360
Gopher hängt ziemlich stark mit dem Lambda-Kalkul zusammen.

05:22.440 --> 05:26.920
Das ist sozusagen eine Realisierung davon, von diesem theoretischen Konzept.

05:27.620 --> 05:29.920
Und ich werde Ihnen jetzt auch zeigen, wie das zusammenhängt.

05:31.220 --> 05:33.440
Ein Stück weit möchte ich Sie auch in die Gopher-Syntax einführen,

05:33.520 --> 05:35.780
um Ihnen zu zeigen, wie es auch mit der Bacchus-Nauer-Form zusammenhängt.

05:36.560 --> 05:40.180
Am Schluss mache ich so etwas, dass Sie die Unterschiede zwischen Java und Gopher

05:40.180 --> 05:42.220
an einem sehr einfachen Beispiel nochmal darstellen.

05:43.780 --> 05:48.480
Und natürlich gibt es eine ganze Menge von Hinweisen zu den Aufgaben.

05:49.720 --> 05:53.720
Beispiele, wie arbeitet man mit eingebetteten Funktionen, wie arbeitet man mit Listen,

05:54.240 --> 05:55.340
wie geht man damit überhaupt um.

05:56.420 --> 05:59.520
Und ein Stück weit auch die Auswertung, wie arbeitet Gopher,

05:59.720 --> 06:01.720
wie wird sozusagen die Auswertung durchgeführt.

06:02.040 --> 06:05.000
Das ist eigentlich auch interessant, weil dahinter lässt sich dann

06:05.000 --> 06:07.380
relativ genau sehen, wie arbeitet die Rekursion.

06:07.900 --> 06:11.240
Und wenn Sie dann Ihr Programm schreiben und die Auswertung nachvollziehen können,

06:11.320 --> 06:13.600
dann können Sie auch die Richtigkeit gewährleisten.

06:17.520 --> 06:19.680
So, und ich fange mal mit dem ersten Teil an.

06:20.500 --> 06:23.780
Ich fange mal hier an bei der Syntax-Beschreibung.

06:24.420 --> 06:27.500
Ich werde mal zeigen, wie sowas aussieht an einer einfachen Funktion.

06:27.620 --> 06:30.660
Eine Funktion, die einfach zwei Zahlen addiert.

06:31.620 --> 06:34.500
Mit der spielen wir uns jetzt ein Stück weit mit dieser Funktion.

06:41.040 --> 06:42.360
Nehmen wir mal eine Funktion.

06:45.160 --> 06:45.560
Add.

06:54.980 --> 06:56.140
Fängt schon gut an hier.

06:56.600 --> 06:56.900
Super.

07:05.540 --> 07:07.660
Das ist das erste, was Sie zum Kennen.

07:07.660 --> 07:09.080
Die Funktionsspezifikation.

07:09.400 --> 07:10.300
Was macht das überhaupt?

07:10.760 --> 07:12.120
So, und wie müssen Sie das jetzt lesen?

07:13.060 --> 07:15.020
Lesen müssen Sie es in dem Fall so,

07:15.020 --> 07:20.400
dass diese Funktion add, oder addieren von zwei Zahlen,

07:21.560 --> 07:23.320
das bedeutet hier,

07:25.080 --> 07:26.360
das ist die Eingabe,

07:28.940 --> 07:29.680
und das hier,

07:33.300 --> 07:34.700
das hier ist die Ausgabe.

07:36.640 --> 07:40.160
Wie gesagt, Sie können es auch dynamisch verschieben, das ist kein Problem.

07:41.040 --> 07:43.620
Die Ausgabe könnte, nein, die könnte nicht so eintätig sein.

07:43.620 --> 07:45.200
Die Ausgabe ist ein Wort.

07:46.200 --> 07:53.060
So, das Ganze lässt sich nochmal in einem sogenannten Funktionstdiagramm oder Syntaxdiagramm darstellen.

07:56.160 --> 08:03.020
Also diese Datentypen, die sind jetzt nicht irgendwie nur einfach so festgelegt,

08:03.540 --> 08:08.440
sondern die lassen sich schon relativ generisch erzeugen.

08:15.000 --> 08:15.840
So, Syntaxdiagramm.

08:19.060 --> 08:19.980
Also, was haben wir?

08:22.060 --> 08:23.160
Wir haben eine Funktion.

08:28.440 --> 08:30.260
So, und die Funktion heißt in dem Fall add.

08:30.560 --> 08:33.180
Das ist also das, was wir hier vorliegen haben.

08:33.500 --> 08:37.140
Ich mache nochmal ganz kurz so eine Rinde, dass Sie wissen, das ist die Funktion hier.

08:41.380 --> 08:45.080
So, dann kommen diese Doppelpunkte.

08:46.020 --> 08:46.540
Lässt sich auch.

08:52.120 --> 08:53.640
Also ich nehme genau zweimal.

08:54.640 --> 09:00.660
So, und anschließend, und das ist immer so, anschließend kommt der Typ, also der Funktionstyp.

09:09.460 --> 09:13.180
So, und dann ist es fertig.

09:13.460 --> 09:14.650
Das ist so das Basiskonstrukt.

09:16.040 --> 09:19.580
Die Funktionen sind den Typen dran, und dann ist es eigentlich schon gelaufen.

09:20.360 --> 09:24.180
Und dass Sie sowas erzeugen können, wie jetzt zum Beispiel oben bei dieser Funktion add,

09:24.520 --> 09:29.960
dass Sie mehrere Typen erzeugen können, brauchen Sie eben diesen Pfeil hier.

09:31.240 --> 09:33.780
Ich warme ihn hier mal kurz ein.

09:35.740 --> 09:39.620
Den Pfeil brauchen Sie auch noch, und der muss sozusagen immer wiederkehren können.

09:42.660 --> 09:43.960
So, und das ist hier dieser Pfeil.

09:46.240 --> 09:50.860
Nach dem Typen können Sie einen Pfeil erzeugen oder auch nicht.

09:51.840 --> 09:54.780
Und dann kommt der nächste Typ, und so können Sie das, wie wir auch sehen,

09:54.900 --> 10:00.700
eben diese drei Integer-Typen da zusammenbauen für die Eingabe und auch für die Ausgabe.

10:01.550 --> 10:04.220
Das ist jetzt dann das, was wir hier brauchen.

10:05.220 --> 10:08.540
Und das Ganze lässt sich auch mit der Bacchus-Nauer-Form beschreiben.

10:08.800 --> 10:15.000
Sie sehen auch schon, dass hier ziemlich viel Anwendung findet, was wir früher gelernt haben.

10:21.300 --> 10:29.620
Also das Ganze sieht in Bacchus-Nauer-Form.

10:33.220 --> 10:34.200
Das sieht jetzt dann so aus.

10:35.340 --> 10:38.360
Für diesen oberen Pfeil mache ich das jetzt mal, für diese Funktion add.

10:42.360 --> 10:43.680
Also Sie haben einen Typen,

10:46.820 --> 10:51.220
B becomes, so und das ist jetzt eben hier diese natürlichen Zahlen.

10:53.000 --> 10:56.760
Und dann müssen Sie nochmal eine Funktion definieren.

10:59.120 --> 11:00.080
Die Funktion.

11:06.100 --> 11:08.980
Ich nehme jetzt mal eine andere Farbe.

11:09.700 --> 11:13.920
Das sind die Doppelpunkte, die jetzt da oben auch auftreten.

11:15.540 --> 11:20.000
Dann kommt der Typ.

11:22.500 --> 11:27.400
Und dann kann wahlweise ein Pfeil kommen.

11:32.680 --> 11:34.920
Und dann kommt der nächste Typ hinten dran.

11:35.360 --> 11:37.280
Also einen Pfeil ohne einen Typen gibt es gar nicht.

11:38.060 --> 11:38.380
Am Schluss.

11:41.680 --> 11:44.240
So, ich hoffe das kann man gut erkennen.

11:45.400 --> 11:46.480
Ja, sieht ganz gut aus.

11:47.560 --> 11:48.640
Also da ist eine Frage.

11:50.840 --> 11:52.720
Ja, das eine.

11:53.420 --> 11:57.980
Das hier sind die Doppelpunkte von dem B becomes, so wie das in der Bacchus-Nauer-Form definiert ist.

11:58.500 --> 12:03.600
Und das sind die Doppelpunkte, die Sie hier oben an der Funktion add.

12:04.580 --> 12:05.220
Versuch es mal.

12:05.940 --> 12:08.600
Also hier oben diese zwei Doppelpunkte, die nach dem add kommen.

12:09.500 --> 12:12.280
Das sind ja tatsächliche Zeichen, mit denen Sie arbeiten.

12:12.560 --> 12:13.080
Da ist eine Frage.

12:16.920 --> 12:17.960
Oh ja, stimmt.

12:18.080 --> 12:19.440
Braucht man rein in die Ecke die Klammern setzen.

12:19.760 --> 12:19.960
Danke.

12:21.120 --> 12:21.400
Sorry.

12:22.760 --> 12:24.060
Das ist ja ein feststehendes Zeichen.

12:29.660 --> 12:31.080
So, das ist dieser Pfeil.

12:32.400 --> 12:33.400
So, da hinten ist noch eine Frage.

12:35.720 --> 12:36.060
Bitte?

12:43.340 --> 12:47.660
Ja, ja, also in dem Fall gehe ich nur davon aus, dass ich versucht habe,

12:47.700 --> 12:49.760
dieses Syntax-Diagramm zu beschreiben.

12:50.340 --> 12:52.440
Und ich habe halt mit dem Beispiel Integer gearbeitet.

12:52.900 --> 12:56.220
Also klar kann man den Bezeichner noch extra ausführen.

12:57.560 --> 12:58.140
Schon richtig.

13:00.220 --> 13:02.980
Okay, also da steckt nicht so viel dahinter.

13:03.180 --> 13:04.920
Da lege ich auch keinen großen Schwerpunkt drauf.

13:05.300 --> 13:05.900
Weil ich...

13:05.900 --> 13:09.060
Oder wo wir auch mehr Schwerpunkt drauf legen ist eben,

13:09.940 --> 13:11.000
wie funktioniert das Ganze.

13:14.620 --> 13:16.500
So, und ich habe Ihnen jetzt nochmal hier so ein Beispiel.

13:19.900 --> 13:24.820
Wie ist eigentlich die Verbindung zwischen dem Lambda-Kalkül und Gopher?

13:25.220 --> 13:26.740
Wie läuft das prinzipiell ab?

13:28.440 --> 13:30.520
Und es sieht im Wesentlichen so aus,

13:30.560 --> 13:34.100
Sie haben also im Beispiel Lambda-Kalkül auch zwei Zahlen addieren.

13:35.340 --> 13:37.780
Und nebendran haben wir diese Funktion add,

13:38.280 --> 13:40.360
die auch zwei Zahlen addiert.

13:40.660 --> 13:43.260
Also in Gopher sieht es dann so aus.

13:45.200 --> 13:47.040
Sie haben irgendeine Funktionsspezifikation.

13:47.120 --> 13:49.160
Haben wir gerade eben kennengelernt, wie die aufgebaut ist.

13:49.940 --> 13:53.100
So, und dann wird die konkrete Ausprägung,

13:54.000 --> 13:55.700
mit der Sie dann arbeiten, von dieser Funktion,

13:56.000 --> 13:57.040
das wird dann festgelegt.

13:58.700 --> 14:01.720
Also add, und dann kommen die zwei Eingabe-Parameter x und y.

14:02.460 --> 14:04.080
Und wie werden die verarbeitet?

14:04.240 --> 14:06.200
Also x wird auf y addiert.

14:06.880 --> 14:09.340
Also, ich bin jetzt gerade in der Zeile.

14:11.940 --> 14:14.940
So, und dann ist das Programm fertig.

14:16.340 --> 14:18.700
Und jetzt, wenn Sie das Programm ausführen,

14:19.340 --> 14:21.020
dann geben Sie die Werte ein.

14:21.180 --> 14:23.840
Sie geben die Funktion, also das ist hier die Ausführung.

14:28.900 --> 14:32.260
Sie geben die Funktion, die Werte 4, 3 ein.

14:32.260 --> 14:34.880
Und dann startet das ganze Ding.

14:35.900 --> 14:37.340
So, und jetzt lassen Sie uns mal vergleichen,

14:37.400 --> 14:39.300
wie die beiden miteinander ablaufen.

14:40.720 --> 14:41.780
Also bei dem Lambda.

14:51.150 --> 14:53.550
Also Lambda y.

14:57.540 --> 14:59.320
Also Sie ersetzen jetzt das x.

15:08.330 --> 15:10.130
So, und die 4 geht auf das x.

15:12.830 --> 15:14.630
Und die 3 bleibt stehen.

15:14.770 --> 15:16.030
Was passiert in Gopher?

15:17.770 --> 15:21.330
Gopher startet und sagt, also gut, wir fangen mal an.

15:22.730 --> 15:23.430
Hier das x.

15:26.150 --> 15:27.170
Hier ist das x.

15:31.230 --> 15:32.750
Und dann wird der erste Wert ersetzt.

15:35.550 --> 15:36.310
Plus y.

15:37.370 --> 15:40.190
So kann man sich das vorstellen, wie es innen abläuft.

15:41.530 --> 15:43.490
So, jetzt die nächste Zeile in dem Lambda.

15:44.710 --> 15:45.650
Sieht so aus.

15:47.790 --> 15:50.070
Wir nehmen jetzt das Lambda y.

15:54.610 --> 15:55.570
Plus 4y.

15:57.470 --> 15:59.370
Also jetzt haben wir die 4 sozusagen ersetzt.

16:00.030 --> 16:01.890
Und das Gleiche ist hier drüben auch passiert.

16:03.650 --> 16:05.270
4 plus y.

16:06.610 --> 16:09.290
So, und jetzt machen wir das Ganze einfach nur kanonisch weiter.

16:09.850 --> 16:11.770
Wir ersetzen jetzt das y.

16:14.770 --> 16:16.050
Plus 4y.

16:21.940 --> 16:24.980
So, und das Ganze wird hier genauso bei dem Lambda

16:27.560 --> 16:28.200
durchexerziert.

16:44.020 --> 16:50.520
So, und letztendlich kommen wir dann bei beiden raus.

16:51.080 --> 16:56.440
Bei hier plus 4, 3.

16:57.440 --> 17:01.220
Und das Ganze ist hier 4 plus 3.

17:01.340 --> 17:03.080
Und dann können wir noch die Arithmetik drauf anwenden.

17:04.300 --> 17:07.200
Und dann landen wir bei beiden bei 7.

17:07.500 --> 17:09.360
So, und das Fazit, das wir eigentlich hier verwenden,

17:09.360 --> 17:09.920
kann man sich hier drauf ziehen.

17:11.120 --> 17:15.360
Die Grundaussage ist, dass

17:18.080 --> 17:19.440
das Lambda-Kalkül

17:28.030 --> 17:28.990
liefert

17:33.680 --> 17:35.760
die theoretische Grundlage

17:47.350 --> 17:48.770
für Golfer.

17:49.250 --> 17:52.190
Das ist dann zwar ganz schön gesagt, nicht gemeint.

17:52.190 --> 17:55.050
Bei komplexeren Beispielen können Sie es in Golfer noch machen.

17:55.170 --> 17:56.790
Das können Sie auch nachvollziehen beim Programmieren.

17:57.170 --> 18:00.510
Komplexere Beispiele mit dem Lambda-Kalkül sind eher schwieriger nachvollziehbar.

18:01.830 --> 18:04.610
Aber wie gesagt, prinzipiell bietet das die theoretische Grundlage,

18:05.210 --> 18:07.170
wie dann Golfer implementiert worden ist.

18:09.970 --> 18:12.430
Und jetzt möchte ich mit Ihnen ein paar Beispiele entwickeln,

18:12.910 --> 18:15.550
wie Sie an so ein Golfer-Programm erstmal herangehen können,

18:16.350 --> 18:17.590
um das umzusetzen.

18:17.790 --> 18:21.410
Golfer hat, speziell bei der Auswertung mit den Rekursionen,

18:22.390 --> 18:24.290
es dauert ein bisschen, bis man es verstanden hat.

18:24.390 --> 18:26.690
Aber es ist prinzipiell relativ einfach aus meiner Sicht.

18:28.110 --> 18:34.550
So, und zu entwickeln ist ein...

18:37.490 --> 18:39.090
Lass uns einfach mal ein Beispiel ausprobieren,

18:39.170 --> 18:44.370
wie man mit der Summe über die natürlichen Zahlen von 1 bis N,

18:44.370 --> 18:46.510
wie man dazu das Golfer-Programm schreibt.

18:47.070 --> 18:50.010
Die Funktionen, denke ich, wir kennen sie aus der Mathematik.

18:53.830 --> 18:58.050
Es wird 1 bis 2 bis 3 bis 4 bis N, wird einfach aufsummiert.

18:58.750 --> 18:59.670
Das ist das Ganze.

19:00.610 --> 19:02.570
So, und wie bringen wir jetzt das in ein Golfer-Programm?

19:05.230 --> 19:07.510
So, das können wir...

19:07.510 --> 19:10.010
Also ich habe so ein paar Arbeitshypothesen,

19:10.010 --> 19:13.050
die muss ich erstmal aus dieser Summenfunktion ableiten.

19:13.910 --> 19:17.010
Und diese Arbeitshypothesen, ich stelle mir das vor.

19:27.140 --> 19:33.040
So, also das erste ist noch relativ trivial,

19:33.160 --> 19:34.260
ich muss mir mal Gedanken machen.

19:35.080 --> 19:36.840
Also die Eingabe...

19:39.690 --> 19:43.190
Eingabe ist...

19:44.690 --> 19:46.930
eine natürliche Zahl.

19:49.830 --> 19:53.290
Und die Ausgabe...

19:56.840 --> 19:58.440
ist genauso...

19:59.760 --> 20:01.580
eine natürliche Zahl.

20:03.740 --> 20:05.000
Also das ist noch nicht das Thema,

20:05.840 --> 20:07.340
das ist uns eigentlich relativ klar,

20:07.500 --> 20:11.800
aber ist wichtig für die Spezifikation der Funktion.

20:14.180 --> 20:15.020
Dann zweitens,

20:18.400 --> 20:20.380
wenn das I...

20:21.300 --> 20:22.380
hier dieses I,

20:23.700 --> 20:24.520
wenn das 1 ist,

20:24.860 --> 20:27.020
dann muss ich eigentlich gar nichts Großes machen.

20:27.800 --> 20:30.360
Oder wenn N gleich 1 ist,

20:31.720 --> 20:33.180
dann bin ich schon fertig.

20:33.920 --> 20:36.440
Also wenn N gleich 1,

20:38.040 --> 20:43.220
dann ist mein Ergebnis...

20:43.940 --> 20:44.260
1.

20:47.940 --> 20:49.100
So, und das andere.

20:51.320 --> 20:53.780
Wenn N größer als 1 ist,

20:55.080 --> 20:56.680
so, wie sieht das dann aus?

20:57.300 --> 20:59.040
Dann muss ich halt anfangen,

20:59.980 --> 21:02.820
immer wieder das N hochzuzählen.

21:04.180 --> 21:07.380
Also mein Ergebnis...

21:08.560 --> 21:09.840
sieht dann so aus.

21:10.700 --> 21:15.100
Ich habe N plus,

21:15.960 --> 21:17.680
und dann geht es sukzessiv runter,

21:18.560 --> 21:19.840
N minus 1.

21:21.400 --> 21:23.140
Dann zähle ich das N so lange runter.

21:26.720 --> 21:27.320
So, jetzt 2,

21:28.640 --> 21:29.380
1 bin.

21:29.460 --> 21:34.220
Das ist der umgekehrte Weg.

21:34.380 --> 21:36.580
Bei der Summenfunktion denkt man ja immer,

21:36.880 --> 21:40.060
man zählt so einfach hoch, von 1 bis N.

21:42.980 --> 21:44.940
Und hier ist eine rekursive Darstellung.

21:45.420 --> 21:47.280
Sie packen das N und fangen an,

21:47.320 --> 21:49.980
das N runter zu zählen, bis Sie bei der 1 landen.

21:50.120 --> 21:51.380
Also genau den umgekehrten Weg.

21:51.660 --> 21:52.940
Das macht auch mehr Sinn bei Gopher,

21:53.540 --> 21:54.980
um die Terminierung hinzukriegen.

21:56.760 --> 21:58.120
Also überlegen wir uns das mal.

21:58.120 --> 21:59.340
Das sind die Arbeitshypothesen.

21:59.420 --> 22:01.560
Wenn Sie die für sich selber festgelegt haben,

22:02.260 --> 22:08.160
können Sie daraus eine Funktionsspezifikation

22:08.160 --> 22:09.740
für sich selber ableiten.

22:11.220 --> 22:17.230
Das erste ist das Gopher-Programm.

22:19.680 --> 22:20.680
Ich kann das lesen.

22:21.320 --> 22:22.620
Das wird man nachher nicht mehr lesen können,

22:22.620 --> 22:23.260
aber ich kann den Web-Shot sehen.

22:28.100 --> 22:33.460
Also, das Ganze in Gopher sieht dann so aus.

22:38.180 --> 22:43.480
Wir nennen mal die Funktion SummeInt.

22:43.580 --> 22:45.960
Das ist die Eingabe, eine natürliche Zahl.

22:47.360 --> 22:51.960
Und die Ausgabe ist genauso eine natürliche Zahl.

22:52.140 --> 22:52.600
Das ist die SummeInt.

22:52.600 --> 22:55.220
Sie haben den ersten Schritt, den Punkt 1,

22:57.960 --> 22:59.040
intellekt abgeleitet.

22:59.640 --> 23:03.080
Das ist genau das, was hier unter Erstens verstanden wurde.

23:05.380 --> 23:06.440
Das Zweite.

23:07.660 --> 23:10.180
Wenn n gleich 1 ist, dann soll das Ergebnis 1 sein.

23:10.720 --> 23:11.540
Also, was mache ich?

23:12.600 --> 23:13.280
Meine Funktion,

23:19.550 --> 23:20.470
die Summe von 1.

23:20.470 --> 23:21.410
Kein Doppelfunkt.

23:25.610 --> 23:28.450
Die Summe von 1.

23:28.630 --> 23:33.010
So eine Klammerung kennt man in Gopher nur ganz selten.

23:34.250 --> 23:37.090
Wenn ich 1 eingebe, dann muss 1 rauskommen.

23:37.610 --> 23:42.090
Das ist dann das Ergebnis.

23:42.750 --> 23:46.770
Die 1 ist die Ausgabe, die Sie dann forcieren.

23:48.550 --> 23:50.190
Dann als letzter Schritt.

23:50.270 --> 23:52.050
Das ist für Zweitens gewesen.

23:55.150 --> 23:56.970
Wenn n gleich 1 ist, ist das Ergebnis 1.

23:59.890 --> 24:01.010
Der letzte Schritt.

24:05.030 --> 24:06.970
Jetzt muss ich das rekursiv hinschreiben.

24:08.050 --> 24:08.570
Also für n.

24:10.130 --> 24:13.490
Jetzt müsste es sich gewährleisten, dass es für n größer 1 einsteigt.

24:13.490 --> 24:15.590
Und wie arbeitet das Gopher ab?

24:17.350 --> 24:20.470
Gopher kommt rein, schaut sich den ersten an.

24:20.530 --> 24:21.930
Summe 1 gleich 1.

24:22.430 --> 24:26.590
Die Zeile verwerfe ich, interessiert mich nicht mehr.

24:27.230 --> 24:28.630
Und ich gehe in die nächste Zeile.

24:29.470 --> 24:33.210
Wenn er in der nächsten Zeile ist, muss er überlegen, was er machen muss.

24:35.850 --> 24:37.570
Das ist der dritte Schritt.

24:38.070 --> 24:40.130
Ich sage n.

24:40.550 --> 24:41.890
Dieses n brauche ich auf jeden Fall.

24:44.870 --> 24:48.110
Zu diesem n muss ich aber noch einen Betrag dazuzählen.

24:48.350 --> 24:50.750
Das ist genau das, was ich in den eckigen Klammern geschrieben habe.

24:51.210 --> 24:53.910
Diesen Betrag muss ich jetzt in einer Rekursion beschreiben.

24:56.030 --> 24:57.030
Was mache ich dazu?

24:58.990 --> 25:02.890
Die Funktion Summe muss ich nochmal aufrufen.

25:04.310 --> 25:06.250
Dann muss ich den Wert n runterzählen.

25:06.610 --> 25:08.950
Ich muss anfangen, dieses n-1.

25:09.250 --> 25:11.050
Jetzt nehme ich zum ersten Mal ein Klammern.

25:14.850 --> 25:17.890
Ich muss jetzt anfangen, dieses n runterzuzählen.

25:19.910 --> 25:21.890
Was jetzt hier passiert ist,

25:23.670 --> 25:25.730
nehmen wir mal die Zahl 3.

25:27.410 --> 25:30.070
Die erste Zeile ist es nicht, Summe gleich 1.

25:30.070 --> 25:32.350
In der zweiten Zeile kommt er rein und sagt,

25:32.530 --> 25:36.690
Summe von 3 ist gleich 3 plus Summe von 2.

25:36.690 --> 25:39.490
Er ruft sich nochmal auf mit Summe von 2.

25:40.170 --> 25:42.750
Er geht wieder rein und kommt wieder an die zweite Zeile.

25:43.170 --> 25:47.810
Summe von 2 ist gleich 3 plus 2.

25:50.370 --> 25:52.150
Summe von 1.

25:52.430 --> 25:53.690
Summe von 1 ist 1.

25:53.690 --> 25:54.910
Damit ist er fertig.

25:55.090 --> 25:57.850
Er hat dann die Summe abgearbeitet.

25:58.450 --> 26:01.610
Ich zeige Ihnen nochmal ein Beispiel, wie das aussieht.

26:03.650 --> 26:04.810
Das war hier der dritte Schritt.

26:08.050 --> 26:11.290
Ich denke mal, dass die Auswertung nicht ganz unwesentlich ist

26:11.290 --> 26:13.610
für das Verständnis, wenn man es mit Go verarbeitet.

26:14.710 --> 26:17.150
Sie können nicht einfach nur plan ran gehen und denken,

26:17.150 --> 26:19.410
ich schreibe da mal ein paar Funktionen hin

26:19.410 --> 26:20.950
und wir schauen, ob es richtig rauskommt.

26:21.450 --> 26:23.090
Das muss schon durchdacht sein.

26:24.810 --> 26:27.770
Ich schreibe die Funktion nochmal auf

26:29.230 --> 26:32.630
und zeige Ihnen, wie die Auswertung für die Summe gleich 5 aussieht.

26:45.620 --> 26:47.020
Ich schreibe es nur noch einmal ab,

26:47.640 --> 26:48.740
damit Sie es auch nochmal haben.

27:12.850 --> 27:16.550
Jetzt machen wir mal das Beispiel.

27:24.120 --> 27:26.360
Summe von 5 ist gleich.

27:28.240 --> 27:31.380
Ich bezeichne jetzt mal die Zweige.

27:32.120 --> 27:32.960
1.

27:32.960 --> 28:00.920
1 und 2 und jetzt läuft es folgendermaßen ab, das ist hier 5, 5-1, ja, so dann ist der

28:00.920 --> 28:04.980
Der erste Schritt, jetzt ruft sich die Funktion wieder auf und es geht weiter.

28:06.640 --> 28:22.480
Die Summe von 5-1, das ist eben 4, also hier die 4, plus 4-1.

28:23.680 --> 28:38.670
Dann ruft sich die Summe wieder auf, die Summe von 3, 3-1 und dann geht es nochmal 1 weiter.

28:39.450 --> 28:45.750
Also die Summe von 2, wir sind noch nicht am Ende, wir sind die ganze Zeit in diesem zweiten Zweig und rollieren da.

28:47.150 --> 28:51.070
Wir prüfen aber immer wieder den ersten ab, das sollten Sie nicht vergessen.

28:59.530 --> 29:07.630
2-1 und das ist dann hier die 1 und das Ganze wird dann zusammengepackt.

29:13.810 --> 29:39.180
Jetzt holen wir uns alle Werte der Reihe nach hier runter und erhalten als Ergebnis die Arithmetik von Gopher ausgeführt.

29:40.720 --> 29:45.280
Das ist eine Auswertung, wie Sie es sich bei der Summe vorstellen können.

29:46.480 --> 29:48.440
Gopher nimmt Ihnen die Reihenfolge übel.

29:50.060 --> 29:55.200
Ein falsches Beispiel, wie man es nicht machen sollte, sieht so aus.

29:58.400 --> 30:10.900
Die Summe, Sie sollen ja hier nicht nur das Richtige sehen, sondern auch sehen, wie man es nicht machen soll.

30:11.720 --> 30:12.540
Das spart Ihnen Zeit.

30:24.680 --> 30:31.720
Wenn ich jetzt die Zeilen umdrehe, dann ist die Reihenfolge nicht mehr gewährleistet.

30:33.200 --> 30:36.980
Stellen Sie sich vor, Sie geben die 5 ein, wie wir es gerade eben gemacht haben.

30:38.480 --> 30:41.520
Dann läuft es die ganze Zeit, die Zeile 1 ist erfüllt.

30:42.260 --> 30:48.400
Die ist ewig lang erfüllt und irgendwann wechselt er den Datentypen.

30:48.600 --> 30:57.180
Er hat nur noch 1-1, 0 und dann 0-1 und dann ist er in einem negativen Datentypen und das Ganze schlägt fehl.

30:57.560 --> 31:00.520
Sie können die Funktion nicht mehr abbremsen.

31:00.760 --> 31:05.000
Noch viel schlimmer, wenn Sie eine Funktion haben, die hochzählt, die erreicht nie diese Zeile.

31:06.860 --> 31:09.940
Diese Zeile ist die sogenannte Terminierung.

31:11.340 --> 31:14.740
Das ist dieser Fixpunkt, von dem Sie vielleicht auch schon kennengelernt haben aus der Vorlesung.

31:15.700 --> 31:17.360
Auf den müssen Sie zuarbeiten.

31:19.860 --> 31:38.130
Das ist die falsche Reihenfolge, mit der dürfen Sie nicht arbeiten.

31:43.870 --> 31:47.870
An dieser Funktion, die Summe, möchte ich mich noch ein bisschen aufhalten.

31:47.970 --> 31:50.010
Ich möchte Ihnen ein weiteres Beispiel zeigen.

31:51.070 --> 31:54.510
Und zwar gibt es in Gopher so etwas wie eingebettete Funktionen.

31:55.330 --> 32:03.510
Und eingebettete Funktionen sind notwendig, dass Sie, speziell bei dieser Aufgabe Quadratwurzel, dass Sie die lesen können.

32:13.250 --> 32:18.450
Dieses Beispiel mit den eingebetteten Funktionen möchte ich Ihnen zeigen an dem Beispiel.

32:18.450 --> 32:30.010
Wir geben eine Zahl ein, zum Beispiel 15, und testen, ob sie diese Summe ist.

32:30.970 --> 32:33.790
Oder ob das eine Zahl ist, die außerhalb dieses Bereiches liegt.

32:34.410 --> 32:40.750
Also alle Zahlen, so 1, 2, 6, 10, das sind alles diese 6, 10, 15.

32:41.170 --> 32:47.270
Das sind alles diese Zahlen, über die wir hier ein Programm schreiben wollen.

32:47.270 --> 32:53.170
Und genau bei so einem Programm ist es natürlich auch lästig, dass Sie immer das N mit eingeben müssen, wie weit das läuft.

32:54.230 --> 32:58.050
Und das möchte ich Ihnen mal zeigen, wie man das mit eingebetteten Funktionen lösen kann.

33:01.550 --> 33:07.150
Ich fange erstmal an mit der prinzipiellen Funktionalität.

33:15.240 --> 33:17.140
Ich nenne mal die Funktion Summentest.

33:21.840 --> 33:23.280
Das ist ein Integer.

33:32.300 --> 33:38.580
Das Ergebnis soll sein, Sie geben eine Zahl ein, und das sagt einfach nur Ja oder True oder False.

33:40.120 --> 33:42.240
Und etwas anderes wollen Sie eigentlich gar nicht haben.

33:45.240 --> 33:46.480
Sie haben jetzt den Wert Pool.

33:49.540 --> 33:50.880
Den wollen Sie zurückbekommen.

33:51.660 --> 33:56.620
Das ist der erste Teil.

33:57.940 --> 34:13.200
Und diese Funktion Summentest, wenn Sie jetzt hier ein x eingeben, dann rufen Sie eine weitere Funktion auf.

34:13.580 --> 34:15.760
Und ich zeige Ihnen auch gleich, wie die andere Funktion funktioniert.

34:17.300 --> 34:21.060
Wir nennen mal die Funktion st.

34:26.000 --> 34:29.440
Und die hat die Parameter x und 1.

34:30.920 --> 34:33.480
So, und wie ist die Funktion st definiert?

34:38.150 --> 34:42.490
Ich erkläre es dann auch rückwirkend nochmal, damit Sie die Zusammenhänge nochmal besser erkennen können.

34:44.370 --> 34:47.550
Das Integer, Sie müssen ja hochzählen.

34:47.830 --> 34:50.350
Sie müssen ja von der 1 bis n zählen.

34:50.710 --> 34:53.870
Und Sie müssen ja jedes Mal die 1 eingeben, sonst weiß der Gopher nicht, wo er starten muss.

34:53.870 --> 34:58.470
Und das ist genau das. Die 1, die ich hier an der Seite mit übergebe.

35:00.190 --> 35:09.230
Also das heißt, die Funktion st nimmt zwei Eingabe-Parameter, eben das x und die 1, die lege ich nämlich gleich fest.

35:11.950 --> 35:16.490
So, und dann liefert das einen Boolean-Wert zurück.

35:17.030 --> 35:20.690
Und das ist ja auch genau das, was die Funktion Summentest von mir erwartet.

35:20.930 --> 35:23.170
Also ich will einen Boolean-Wert haben, True oder False.

35:23.170 --> 35:27.210
Und dann bin ich zusammen fertig mit der Ausarbeitung.

35:27.530 --> 35:29.030
Das sieht dann so aus.

35:30.950 --> 35:34.850
Dieses st hat einen x und einen y.

35:38.370 --> 35:44.750
So, und wenn x und y, also dieses y, das ist aufgrund dieser Konstellation, die wir hier oben haben,

35:49.340 --> 35:55.360
die beiden, also dieses y wird eigentlich nur den Wert 1 annehmen in Zukunft.

35:55.880 --> 36:03.020
Zwar ist die Funktion allgemein definiert, aber durch diese Einbettung wird ja immer fix der Wert 1 übergeben.

36:04.580 --> 36:06.700
So, und wie arbeitet jetzt diese andere Funktion st?

36:07.840 --> 36:13.260
Also, if x gleich y.

36:13.260 --> 36:15.080
So, und das war das, was wir vorhin gesagt haben.

36:15.180 --> 36:19.940
Wenn das n gleich 1 ist, dann ist das Ergebnis ja 1.

36:21.460 --> 36:23.540
Und, ahopp, jetzt habe ich einen kleinen Fehler gemacht.

36:25.800 --> 36:31.680
Und zwar, das ist gleich in Gopher, das sind hier zwei ist gleich.

36:31.780 --> 36:34.340
Das andere ist sozusagen die Zuweisung, das andere ist gleich.

36:38.140 --> 36:47.240
Ist gleich y, wenn, dann ist das true.

36:47.900 --> 36:52.820
Das ist klar, also die 1 ist auf jeden Fall nicht eine Summenzahl.

36:52.820 --> 37:11.720
Aber, else, wenn das x kleiner ist als das y, ist falsch.

37:11.860 --> 37:13.580
Das ist sozusagen alles, was unterhalb der 1 liegt.

37:15.680 --> 37:21.460
Und jetzt haben wir hier nochmal, ups, das f ist groß geschrieben.

37:26.820 --> 37:32.660
So, und jetzt nutze ich wieder die Stärke von Gopher aus, eben diese Rekursion.

37:37.780 --> 37:47.140
So, und ich nehme x minus y und y plus 1.

37:48.280 --> 37:52.800
Das sieht jetzt erstmal ein bisschen kryptisch aus, kann man auch ein bisschen schwer nachvollziehen.

37:52.800 --> 37:57.760
Wie das genau aussieht, möchte ich Ihnen mit so einem Dreieck nochmal zeigen, so einer Dreieckspyramide.

37:58.940 --> 38:01.920
Da wird es ein bisschen deutlicher, ich gehe gleich nochmal drauf ein.

38:03.860 --> 38:07.060
Also die Summenfunktion ist ja so aufgebaut.

38:18.230 --> 38:27.310
Wenn sie in den einzelnen Zeilen sind, die 1, dann kommt die 2, dann 3, etc.

38:27.310 --> 38:29.930
Und wenn sie das hochzählen, dann haben sie die Anzahl der Elemente.

38:30.330 --> 38:33.470
Also in dem Fall hier 5, die Summe von 5 ist 15.

38:34.110 --> 38:36.330
Kennt man ja vom Billardspielen, sieht genauso aus.

38:37.290 --> 38:49.450
So, das ist sozusagen hier, das ist mein x, dass das läuft, oder n, je nachdem wie Sie es nehmen.

38:50.350 --> 38:56.750
So, und hier für mein Gopher-Programm sind hier diese einzelnen Zeilen.

38:57.050 --> 39:04.550
y ist gleich 1, y ist gleich 2 und dann wird es einfach weitergezählt.

39:05.450 --> 39:10.230
So, und dieses Hochzählen, das mache ich genau an dieser Stelle.

39:11.830 --> 39:17.590
Das ist genau dieses Hochzählen, dass ich einzeln das y hochzähle.

39:17.850 --> 39:24.170
Und das x würde ich sagen, also das y ziehe ich dann von dem x ab.

39:24.710 --> 39:25.910
Das ist immer ein bisschen schwierig zu erklären.

39:27.390 --> 39:33.110
So, und was sie letztendlich erreicht haben, wenn wir das mal als eine Art Blackbox betrachten,

39:33.110 --> 39:35.130
hier diese Funktion st.

39:40.850 --> 39:46.270
Diese Funktion st. kann für sich alleine stehen, das können sie natürlich alles machen mit der Funktion.

39:47.410 --> 39:52.790
Und die Funktion Summentest, da wird die Funktion st. einfach nur eingebettet.

39:52.990 --> 39:58.450
Und dieses Einbetten, das ist das, was ich schon hier einfach mal so lax hingeschrieben habe.

39:59.930 --> 40:01.950
So betten sie sozusagen so eine Funktion ein.

40:01.950 --> 40:07.310
Sie rufen durch die Funktion Summentest eine weitere Funktion auf,

40:07.990 --> 40:16.950
übergeben fest vordefinierte Parameter und dann wird die Funktion st. gestartet und läuft dann separat ab.

40:18.350 --> 40:23.550
Was aber nicht heißt, dass diese Funktion st. exklusiv für den Summentest bereitsteht.

40:23.650 --> 40:25.350
Sie können das auch für andere Programme verwenden.

40:26.130 --> 40:29.390
Sie können sich den Summentest 2 schreiben, der was anderes macht.

40:29.390 --> 40:31.170
Er kann genauso diese Funktion einbetten.

40:31.630 --> 40:34.950
Sie müssen ihm nicht die 1 oder sowas übergeben, sie können ihm irgendeinen Wert übergeben.

40:35.330 --> 40:37.250
Das heißt, das ist nicht fest vordefiniert.

40:37.710 --> 40:45.450
Nur, dieser Mechanismus des Einbettens funktioniert eben so, wie wir es gerade eben kennengelernt haben.

40:47.370 --> 40:49.990
Das ist mal soweit zu dem Go-Verteil.

40:56.770 --> 41:06.730
Eine besondere Komplexität bei Gopher ist es, dass sie auch konstruktiv programmieren können.

41:06.810 --> 41:10.150
Sie können so einen eigenen Datentypen erstellen, wie z.B. den Keller.

41:11.550 --> 41:15.330
Wir haben den Keller ja schon kennengelernt, haben er schon zweimal in der Vorlesung durchgearbeitet.

41:17.590 --> 41:20.190
Das Ganze wollen wir natürlich auch, dass sie es in Gopher können.

41:22.410 --> 41:24.550
Die Aufgabenstellung hatte ich mir auch vor einem Jahr gestellt.

41:25.390 --> 41:26.450
Mir hat es ein bisschen gedauert.

41:26.990 --> 41:31.250
Ich denke mal, dass ich Ihnen eine gewisse Hilfestellung geben muss, wie man so Datentypen definiert.

41:31.450 --> 41:36.630
Das Gopher Manual ist jetzt nicht unbedingt so adäquat zu handhaben, dass man das lockerer sieht.

41:37.490 --> 41:42.310
Ich zeige Ihnen, welche Stellen in dem Keller Sie auf jeden Fall brauchen.

41:42.430 --> 41:43.990
Den Rest müssen Sie dann selber dazu programmieren.

41:43.990 --> 41:47.750
Aber Sie brauchen so eine Initial-Hilfestellung aus meiner Sicht.

41:48.210 --> 41:49.210
Und die möchte ich Ihnen mal mitgeben.

41:52.770 --> 41:57.770
Es gibt in Gopher die Möglichkeit, Datentypen zu definieren.

41:59.210 --> 42:01.990
Das ist jetzt nochmal so eine erste informelle Geschichte.

42:07.720 --> 42:08.960
Das sieht so aus.

42:08.960 --> 42:12.380
Data.

42:15.000 --> 42:25.570
Dann kommt der Datentyp.

42:29.270 --> 42:30.430
Datatype.

42:43.330 --> 42:53.690
So etwas wie A1 bis AN ist gleich 1.

42:56.380 --> 43:01.240
Dann geht es weiter zum Konstruktor N.

43:02.360 --> 43:04.780
Das ist das, was in dem Gopher Manual steht.

43:04.940 --> 43:06.760
Und das Ganze muss man konstruktiv anwenden.

43:07.320 --> 43:10.840
Bis dahin kommt man noch relativ einfach, wenn man mit dem Gopher Manual arbeitet.

43:11.760 --> 43:13.720
Aber dann wird es schwierig, das anzuwenden auf dem Keller.

43:16.440 --> 43:19.460
Eine Anwendung auf dem Keller sieht dann so aus.

43:21.760 --> 43:24.720
Und zwar sind folgende Zeilen von Interesse.

43:26.720 --> 43:28.600
Also ich muss einen Stack kreieren.

43:30.140 --> 43:32.340
Ich habe keine Datenstruktur, die Stack heißt.

43:32.520 --> 43:33.700
Die muss ich mir erst mal erzeugen.

43:34.700 --> 43:37.740
Und genau dieses Erzeugen läuft so.

43:40.440 --> 43:44.580
Das ist der knallharte Befehl von Gopher.

43:46.380 --> 43:49.120
Keller ist der Datentyp.

43:51.660 --> 43:57.820
Nennen wir A ist gleich Create.

44:01.120 --> 44:03.300
Und dann noch dieses konstruktive Element.

44:05.960 --> 44:07.420
Push, Klammer auf.

44:11.380 --> 44:12.060
Keller A.

44:13.840 --> 44:15.560
Und dann hier hinten noch ein A dran.

44:16.380 --> 44:17.340
Ich schreibe es nochmal.

44:18.840 --> 44:19.440
Sinnvoller.

44:19.440 --> 44:20.860
Sie sind einer.

44:22.120 --> 44:22.300
So.

44:24.940 --> 44:25.620
Create.

44:29.020 --> 44:29.700
Push.

44:36.580 --> 44:44.300
Das ist sozusagen das, was wir brauchen, um diese Zeile umzusetzen.

44:45.040 --> 44:46.400
Das ist der eine Teil.

44:47.720 --> 44:52.000
Dann können Sie sich so eine Funktion, eine kleine Hilfestellung.

44:53.240 --> 44:54.380
Zum Beispiel Funktion Top.

44:56.080 --> 44:57.180
Wie sieht das dann aus?

44:58.400 --> 44:59.980
Sie können Top verwenden.

45:01.560 --> 45:07.320
Klammer ist nochmal diese Funktionsspezifikation.

45:07.400 --> 45:08.240
Die sieht dann so aus.

45:16.020 --> 45:19.020
Sie nehmen den Keller und ein einelementiges Element.

45:19.020 --> 45:23.600
Und was Sie mit Top machen, Sie nehmen das oberste Element weg und kriegen ein Element zurück.

45:23.740 --> 45:24.560
Das ist Element A.

45:25.300 --> 45:26.260
Damit können Sie arbeiten.

45:27.780 --> 45:29.740
Und wie sieht das dann aus bei so einem Axiom?

45:30.420 --> 45:30.940
Unten dran.

45:32.820 --> 45:33.940
Zum Beispiel diesen K4.

45:35.680 --> 45:39.160
Das ist dann Top.

45:42.990 --> 45:44.370
Da verwenden Sie das Push.

45:46.450 --> 45:46.970
Kx.

45:46.970 --> 45:48.670
Das ist ein Blank dazwischen.

45:51.450 --> 45:55.530
Und von dem Keller nimmt das ein Element runter.

45:56.910 --> 45:58.310
Ich kann das noch lesen.

45:59.850 --> 46:03.210
Das brauchen Sie, wenn Sie den Keller umsetzen wollen.

46:05.710 --> 46:07.790
Was auf jeden Fall noch von Interesse ist,

46:07.790 --> 46:11.990
sind die Zeilen 1 und 7.

46:19.510 --> 46:20.930
Da müssen Sie nichts machen.

46:21.150 --> 46:22.330
Das können Sie ersatzlos streichen.

46:22.390 --> 46:25.970
Das brauchen Sie in Gopher nicht, weil Sie da keine Elemente definieren müssen.

46:26.050 --> 46:28.490
Das machen Sie alles mit diesem Data Keller.

46:28.770 --> 46:30.990
Da wird es automatisch erzeugt.

46:31.310 --> 46:34.590
Sie können in den Keller alles reinstecken, was Sie wollen.

46:36.050 --> 46:38.730
Das ist absolut notwendig, wenn Sie mit Kellern arbeiten.

46:38.950 --> 46:41.190
Die Hilfestellung sei mitgegeben.

46:42.890 --> 46:47.790
Jetzt kommen wir noch zu etwas Komplexem.

46:47.950 --> 46:48.710
Und zwar Listen.

46:49.110 --> 46:53.270
Das ist nichts anderes, als dass Elemente zusammengepackt werden.

46:53.750 --> 46:56.290
In einer Art Liste.

46:57.830 --> 47:04.930
Und das Ganze sieht so aus.

47:05.370 --> 47:06.310
Sie sind in Gopher.

47:07.890 --> 47:09.130
Also hier muss man sich...

47:10.110 --> 47:10.470
Pause!

47:12.310 --> 47:12.510
Oh!

47:15.910 --> 47:16.270
Naja.

47:19.010 --> 47:20.310
Also, so viel ist es noch.

47:20.670 --> 47:22.170
Es sind noch drei, es geht noch eigentlich.

47:24.010 --> 47:25.570
Es ist dann nur noch die Liste, die schwierig ist.

47:25.930 --> 47:27.370
Nach der Liste ist es ja schon vorbei.

47:29.150 --> 47:30.310
Also, Liste.

47:39.610 --> 47:41.590
Also sowas ist eine Liste.

47:41.830 --> 47:42.830
Das ist eine satzierte Liste.

47:46.310 --> 47:46.660
Und...

47:47.010 --> 47:48.130
Was wird in Gopher?

47:48.890 --> 47:50.830
Werden die einzelnen Elemente...

47:50.830 --> 47:52.770
Wenn Sie mit den einzelnen Elementen der Liste arbeiten,

47:53.450 --> 47:55.690
dann werden die mit Doppelpunkt getrennt.

47:55.690 --> 47:57.210
Oder werden auch rausgeholt.

47:59.150 --> 47:59.870
Also, eins.

48:07.660 --> 48:09.420
Das ist für die Auswertung dann auch noch wichtig.

48:09.560 --> 48:11.600
Ich zeige Ihnen nochmal in der Auswertung, wie das genau aussieht.

48:14.360 --> 48:15.080
So, und...

48:16.200 --> 48:20.060
Vielleicht nochmal ein zweiter Punkt, oder ein zweiter Aspekt zu den Listen.

48:22.500 --> 48:23.220
Und zwar...

48:23.880 --> 48:25.280
Wie muss man sich das vorstellen?

48:25.380 --> 48:26.080
Sie haben so eine Liste.

48:29.160 --> 48:30.540
x, y, z.

48:31.420 --> 48:34.020
Und danach kommen vielleicht noch beliebig viele Elemente.

48:35.740 --> 48:40.060
Das ist gleich x Doppelpunkt xs.

48:41.000 --> 48:44.880
So, das heißt, diese beiden x, die sind noch gleich.

48:45.580 --> 48:47.960
Und zwar, Sie lesen die Liste von links nach rechts.

48:50.160 --> 48:51.920
Das ist das oberste Element in der Liste.

48:52.040 --> 48:54.420
Sie können immer noch auf das erste Element in der Liste zugreifen.

48:55.700 --> 48:57.060
Und das rausholen.

48:58.600 --> 48:59.820
So, und dieses xs.

49:04.420 --> 49:05.460
Das xs hier.

49:06.160 --> 49:07.800
Das ist nichts anderes als der ganze Rest.

49:08.820 --> 49:12.160
Also, das eine ist sozusagen das erste Element, fast wie im Keller.

49:12.660 --> 49:15.420
Und das andere ist dann der Rest, was noch in dem Keller liegt.

49:15.580 --> 49:16.600
Oder in dem Fall in der Liste.

49:18.760 --> 49:20.440
Also, so können Sie sich das vorstellen.

49:20.600 --> 49:22.080
Das brauchen wir auch gleich.

49:22.560 --> 49:23.500
So wird man das anwenden.

49:24.800 --> 49:29.760
So, und jetzt machen wir drei Gopher-Programme nochmal durch.

49:30.680 --> 49:34.560
Und wir einfach genau diese Anzahl der Elemente in einer Liste mal zählen.

49:35.200 --> 49:37.200
Dann sehen Sie schon, wie man die Elemente rausholt.

49:37.320 --> 49:39.140
Und wie man damit arbeiten kann.

49:42.860 --> 49:44.380
Und diese Länge.

49:46.440 --> 49:48.520
Ich nenne die Funktion mal Längs.

49:49.640 --> 49:54.020
So, und die nimmt eine Liste von natürlichen Zahlen.

50:04.020 --> 50:06.980
Und wie gesagt, ich zähle die Elemente in der Liste.

50:07.520 --> 50:08.740
Was muss ich am Schluss raushaben?

50:09.080 --> 50:11.220
Nichts anderes als eine einzige Zahl.

50:11.480 --> 50:13.600
Ich möchte wissen, wie viele Elemente in der Liste waren.

50:16.080 --> 50:18.300
Das hier, das Integer.

50:18.300 --> 50:24.300
So, und was auf jeden Fall schon mal klar sein muss, ist...

50:28.700 --> 50:30.420
Was passiert, wenn eine Liste leer ist?

50:31.140 --> 50:34.400
Dann ist die Länge nichts, also null.

50:37.200 --> 50:38.300
Und das ist der Terminierungsfall.

50:39.580 --> 50:40.820
Also Sie haben irgendwie eine Liste.

50:41.400 --> 50:42.640
20, 30 Elemente.

50:42.980 --> 50:44.980
Dann schieben Sie alle Elemente sukzessive raus.

50:45.440 --> 50:46.320
Hoffentlich rekursiv.

50:46.320 --> 50:48.000
Und am Schluss bleibt nichts mehr übrig.

50:48.160 --> 50:49.960
Und dann muss genau diese Terminierung stattfinden.

50:50.060 --> 50:51.200
Und das kriegen Sie hin.

50:51.540 --> 50:55.080
Genau indem Sie sagen, die längere leere Liste ist null.

50:57.560 --> 51:00.320
So, und dann haben wir noch...

51:01.500 --> 51:01.940
Längs.

51:03.540 --> 51:06.600
So, jetzt unterscheiden wir unsere Liste.

51:09.260 --> 51:12.140
Indem wir sagen, diese Liste hat ein erstes Element.

51:12.320 --> 51:13.160
Und das heißt x.

51:13.160 --> 51:14.540
Und danach kommt der Rest.

51:14.640 --> 51:16.700
Den nennen wir xs, also die xs.

51:18.620 --> 51:19.800
So unterscheiden wir die Liste.

51:20.120 --> 51:21.500
Und jetzt können wir mit der Liste arbeiten.

51:21.620 --> 51:22.880
Und zwar konstruktiv arbeiten.

51:23.680 --> 51:26.600
Indem wir sagen, das ist gleich.

51:33.160 --> 51:34.540
Also wir nehmen das erste Element weg.

51:34.660 --> 51:37.040
Damit haben wir die Liste um 1 verringert.

51:38.380 --> 51:40.380
Und arbeiten dann nur noch mit dem Rest weiter.

51:40.380 --> 51:45.840
So, und damit ich noch meine natürliche Zahl am Schluss rauskriege,

51:46.500 --> 51:51.440
muss ich schauen, dass ich hier 1 dazuzähle.

51:51.880 --> 51:56.320
Und dann sehen Sie schon, dass das Ganze sich abarbeitet.

51:58.100 --> 52:00.380
Das heißt, Sie können sich...

52:00.380 --> 52:01.640
Das ist genauso wie bei der Summe.

52:02.800 --> 52:05.520
Diese Länge von xs wird immer wieder aufgerufen.

52:07.000 --> 52:09.080
Und arbeitet die Liste so lange ab,

52:09.080 --> 52:11.160
bis nichts mehr in der Liste ist.

52:11.580 --> 52:12.960
Dann kommen wir in diese erste Zeile.

52:13.520 --> 52:17.700
Die Länge einer leeren Liste ist 0.

52:18.340 --> 52:22.340
Das ist, wie wir auf dieses Element zugreifen.

52:22.520 --> 52:24.560
Und das ist eigentlich das einzig Entscheidende.

52:25.840 --> 52:27.420
Dass Sie eine Liste einlesen.

52:27.480 --> 52:29.300
Sie lesen sie auch mit den eckigen Klammern ein.

52:29.660 --> 52:30.220
Übergeben die.

52:30.880 --> 52:34.080
Und dann müssen Sie es schaffen, auf ein Element in der Liste zuzugreifen.

52:34.800 --> 52:37.760
So, und das machen wir genau, indem wir das mit diesen Klammern machen.

52:38.080 --> 52:39.100
Und x und xs.

52:41.280 --> 52:43.160
So, genauso können wir...

52:43.160 --> 52:46.960
Damit Sie es auch mit der Terminierung nochmal ein bisschen ein Gefühl dafür kriegen.

52:47.500 --> 52:49.820
Wenn wir jetzt das letzte Element aus der Liste wollen,

52:50.340 --> 52:54.920
dann müssen wir eine Liste, genauso wie gerade eben,

52:57.840 --> 52:59.280
also die Funktion letzt,

53:02.180 --> 53:07.140
wir lesen eine Liste ein

53:10.160 --> 53:12.960
und liefern das letzte Element aus der Liste.

53:15.640 --> 53:17.920
So, und das letzte Element aus der Liste, das heißt,

53:19.840 --> 53:20.940
ich fang mal an,

53:21.180 --> 53:23.460
den Terminierungsfall machen wir dann am Schluss.

53:24.600 --> 53:26.140
Wir machen mal die Rekursion.

53:26.140 --> 53:29.160
So, eben hier diese Funktion letzt.

53:32.460 --> 53:32.860
So, und...

53:33.900 --> 53:35.440
Natürlich nicht mit den Doppelpunkten.

53:37.300 --> 53:38.480
So, das ist die Funktion letzt.

53:39.680 --> 53:41.220
Auch hier diese Unterscheidung.

53:43.780 --> 53:46.220
Ich greife jetzt das Ganze ab.

53:47.680 --> 53:48.700
Dieses x.

53:52.760 --> 53:55.460
Und arbeite nur noch mit diesem xs weiter.

53:55.960 --> 53:57.660
Also das ist so ein Grundparadigma,

53:59.440 --> 54:00.980
wie Sie mit Listen arbeiten.

54:01.080 --> 54:02.360
Sie nehmen sich immer irgendein Stück weg

54:03.060 --> 54:05.560
und entweder schreiben Sie es in eine andere Liste rein

54:06.520 --> 54:08.500
oder verwerfen es ganz, wie in dem Fall.

54:09.040 --> 54:10.140
Und dann arbeiten wir weiter.

54:11.060 --> 54:13.920
So, und wenn wir jetzt den Terminierungsfall annehmen würden,

54:14.000 --> 54:15.060
wie wir es oben gemacht haben,

54:15.260 --> 54:16.560
dass wir sagen, wenn die Liste leer ist,

54:16.700 --> 54:18.860
dann muss er auch irgendwas zurückgeben,

54:19.180 --> 54:20.200
dann würden wir einen Fehler machen,

54:20.300 --> 54:21.660
weil dann würden wir das letzte Element verlieren.

54:21.660 --> 54:26.400
Das heißt, sobald die Liste nur noch aus einem Element besteht,

54:27.040 --> 54:28.660
ist dieses Element das letzte Element.

54:29.540 --> 54:32.380
Und das Ganze beschreiben wir hier.

54:35.760 --> 54:41.360
Letzt von x ist genau dieses Element x.

54:41.980 --> 54:45.680
Also wenn Sie eine einelementige Liste einlesen, ist es klar,

54:46.180 --> 54:49.460
dann ist dieses eine Element das letzte Element,

54:50.120 --> 54:51.920
ist das erste wie das letzte Element.

54:52.640 --> 54:58.120
Und alle anderen größeren Listen müssen erst abgearbeitet werden,

54:58.380 --> 55:00.760
bis eben diese Liste nur noch ein Element hat.

55:00.840 --> 55:03.240
Und dann haben Sie auch wirklich das letzte Element abgegriffen

55:03.240 --> 55:05.960
und bekommen das auch ausgegeben.

55:09.120 --> 55:11.900
So, und jetzt ein bisschen kniffligeres Beispiel.

55:13.780 --> 55:16.700
Wie müssen Sie mit Listen arbeiten, wenn Sie irgendwas zusammenfügen wollen?

55:16.800 --> 55:18.860
Wir haben ja auch den Merge Sort Algorithmus.

55:20.040 --> 55:21.600
Und das möchte ich Ihnen nochmal zeigen,

55:21.700 --> 55:25.060
dass man mit Listen durchaus arbeiten kann.

55:25.940 --> 55:31.960
Und zwar zusammenfügen zweier Listen ist das, was wir wollen.

55:32.900 --> 55:34.280
Ich nenne mal die Funktion Fug.

55:38.260 --> 55:44.460
So, und die hat als Eingabeparameter die zwei Listen.

55:49.600 --> 55:51.080
So, das sind die zwei Listen.

55:51.440 --> 56:06.500
Und als Ergebnis möchte ich die beiden zusammengefügten Listen haben.

56:07.260 --> 56:10.120
Das ist das, was am Schluss herauskommen muss.

56:10.360 --> 56:11.740
Ich habe zusammengefügt zwei Listen.

56:12.200 --> 56:13.560
Aus zwei Listen mache eine Liste.

56:15.280 --> 56:19.460
So, und dann können wir mit den ersten Terminierungsfällen beginnen.

56:20.560 --> 56:26.640
Und zwar, Sie müssen sich das auch immer so vorstellen,

56:26.740 --> 56:30.720
dass das wirklich die einfachsten Fälle sind.

56:34.040 --> 56:38.060
Und zwar, wenn Sie eine leere Liste haben und eine Liste, in der was drinsteht,

56:38.460 --> 56:42.640
dann ist natürlich klar, dass das Ergebnis die Liste ist, in der was drinsteht.

56:44.160 --> 56:46.260
Also in dem Fall hier das YS.

56:47.100 --> 56:48.860
Das mache ich auch nochmal für den anderen Fall.

56:53.380 --> 56:55.180
Also XS, ich unterscheide die.

56:59.080 --> 57:00.520
Also da ist nichts besonders viel dahinter.

57:00.660 --> 57:02.200
Wie gesagt, Sie geben halt eine leere Liste ein,

57:02.260 --> 57:03.800
entweder auf der linken oder auf der rechten Seite.

57:04.340 --> 57:05.580
Und in der anderen Liste steht etwas.

57:05.740 --> 57:10.040
Und dann kommt natürlich nur das raus, was in der einen Liste steht.

57:12.040 --> 57:15.260
So, und interessanter wird es dann, wenn Sie die Elemente zusammenfügen.

57:16.860 --> 57:19.100
So, und das machen wir folgendermaßen.

57:21.140 --> 57:22.680
Wir nehmen diese Funktionen Füg.

57:24.380 --> 57:30.300
So, und jetzt würde man, machen wir mal so,

57:30.400 --> 57:34.720
wenn Sie jetzt, lassen Sie ein bisschen Abstand links.

57:35.680 --> 57:36.160
XS.

57:40.020 --> 57:43.600
Wenn Sie jetzt die beiden hier angeben würden, hätten Sie ein Riesenproblem,

57:43.780 --> 57:46.700
weil Sie auf keinen der Elemente zugreifen können von den beiden Listen.

57:47.000 --> 57:49.800
Also jetzt haben Sie zwei Listen, in denen was drinsteht.

57:50.060 --> 57:52.100
XS und YS.

57:53.460 --> 57:57.160
Und wie gesagt, wenn Sie jetzt mit den beiden, wenn Sie da irgendwas zusammenfügen,

57:57.460 --> 58:01.720
mergen wollen, haben Sie ein Problem, weil Sie auf keins der Elemente zugreifen können.

58:01.720 --> 58:03.720
Also, wie machen wir es?

58:03.880 --> 58:10.080
Wir schieben, wir überlegen uns, dass wir die Elemente von XS, schieben wir auf das YS.

58:12.780 --> 58:20.000
Also, greifen wir das erste Element von dem XS, greifen wir ab.

58:22.840 --> 58:24.520
So, und dann bauen wir eine neue Liste auf.

58:28.660 --> 58:39.060
X, Doppelpunkt, und dann hier, Füg, XS, YS.

58:40.020 --> 58:43.940
So, das ist jetzt endlich genau das, was ich Ihnen oben gezeigt habe.

58:44.560 --> 58:52.500
Wir bauen an dieser Stelle, bauen wir sukzessive so eine Liste auf.

58:52.500 --> 59:00.180
Das heißt immer, bei jedem Durchlauf von dieser Funktion Füg, wird ein Element von XS genommen

59:00.180 --> 59:07.300
und rausgestellt, bis eben die Funktion hier leer ist.

59:08.380 --> 59:11.080
Und wenn der hier leer ist, terminiert dieser Fall.

59:11.580 --> 59:15.320
Ich komme zu YS, und YS ist in dem Moment die ganze Liste.

59:15.960 --> 59:17.660
Das ist ein bisschen schwierig zu verstehen.

59:19.300 --> 59:21.740
Mag sein, aber letztendlich ist das der Terminierungsfall.

59:21.740 --> 59:29.960
Dass ich darauf zuarbeite, dass ich hier diese Seite so lange bearbeite,

59:31.400 --> 59:34.680
bis ich genau in diesen Terminierungsfall komme, dass das hier auf der Seite leer ist.

59:35.100 --> 59:36.280
Und dann gebe ich eine Liste aus.

59:36.480 --> 59:42.540
Also dann gebe ich eine Liste aus, und die Liste ist in dem Moment genau diese rausgezählten einzelnen X,

59:43.320 --> 59:46.740
plus eben das, was in dem YS ist.

59:47.540 --> 59:47.860
So.

59:50.660 --> 59:54.900
Ich habe versucht, es sich auch noch einmal klar zu machen, mit den Listen zu arbeiten.

59:55.440 --> 59:57.840
Das ist eigentlich eine schöne Geschichte mit Listen.

59:59.360 --> 01:00:01.420
Vor allem ist sie relativ einfach.

01:00:01.800 --> 01:00:04.180
Trivial ist es allerdings wiederum nicht.

01:00:09.320 --> 01:00:12.540
Okay, jetzt noch eine allerletzte Geschichte.

01:00:20.360 --> 01:00:23.650
Was sie...

01:00:23.650 --> 01:00:26.210
Also Gopher hat schon Vorteile.

01:00:26.410 --> 01:00:28.790
Also versuchen Sie nicht die Vorteile einfach zu sagen,

01:00:28.870 --> 01:00:32.970
das ist irgendwie so eine komische Programmiersprache, Gopher, die keiner braucht oder so.

01:00:33.890 --> 01:00:36.310
Einen guten Anwendungsfall draußen in der Praxis habe ich auch noch nicht gesehen.

01:00:38.230 --> 01:00:42.850
Aber der Unterschied zwischen Java und Gopher ist aus meiner Sicht enorm,

01:00:42.850 --> 01:00:46.770
weil sie sich, also bei dieser Funktion, die wir gerade vorhin hatten,

01:00:48.070 --> 01:00:48.310
Add,

01:00:54.210 --> 01:00:56.690
und sie lesen genau die Werte ein.

01:01:00.330 --> 01:01:02.850
Und dann addieren sie die beiden.

01:01:12.050 --> 01:01:13.050
X plus Y.

01:01:13.790 --> 01:01:16.290
Und Sie sehen schon den deutlichen Vorteil.

01:01:16.470 --> 01:01:18.910
Mit einem Zweizeiler bin ich fertig.

01:01:19.010 --> 01:01:21.550
Das ganze Programm ist schon gelaufen.

01:01:22.110 --> 01:01:24.730
Während in Java muss ich mir da schon einen abbrechen.

01:01:24.870 --> 01:01:26.810
Klar habe ich mehr Vorteile in Java.

01:01:27.590 --> 01:01:31.670
Wenn ich mal was Kleines, Einfaches machen will, dann werden die Vorteile nicht unbedingt ideal.

01:01:32.030 --> 01:01:32.470
Was wollen Sie fragen?

01:01:39.690 --> 01:01:40.150
Ja.

01:01:41.070 --> 01:01:44.550
Richtig, ja.

01:01:46.690 --> 01:01:52.510
Die Anmerkung war hier, das Einlesen von der Konsole wird von Java nicht automatisch unterstützt,

01:01:52.590 --> 01:01:54.610
vielleicht wie Sie es von Pascal oder sowas kennen würden.

01:01:55.530 --> 01:01:58.410
Von daher ist es nur bedingt fair, die beiden gegeneinander überzustellen.

01:01:59.430 --> 01:02:01.410
Was ich eigentlich noch mal zeigen wollte ist,

01:02:01.410 --> 01:02:03.350
bei dem einen haben Sie halt mehr Funktionalitäten,

01:02:03.450 --> 01:02:07.590
bei dem anderen kommen Sie relativ schnell mit einfachen Datenstrukturen weiter

01:02:07.590 --> 01:02:09.210
und kommen zu Ergebnissen.

01:02:09.850 --> 01:02:13.510
Also zum Beispiel das Implementieren von Listen, was wir gerade eben gemacht haben zum Beispiel,

01:02:14.090 --> 01:02:17.550
das dürfte in Java doch einiges an größerem Aufwand darbieten.

01:02:19.010 --> 01:02:21.610
Okay, dann wäre ich heute mal ein bisschen früher fertig.

01:02:22.010 --> 01:02:22.210
Okay.

01:02:23.490 --> 01:02:23.790
Ciao.

