WEBVTT

00:08.700 --> 00:14.760
Ich begrüße Sie zur letzten Vorlesung, nein Übung zur Softwaretechnik

00:14.760 --> 00:18.440
1 mit einem Java-Rätsel.

00:21.080 --> 00:22.040
Was haben wir hier?

00:22.080 --> 00:27.060
Wir haben eine Main-Methode und wir haben hier drei Funktionen, die

00:27.060 --> 00:30.320
etwas ausdrucken, und zwar hier oben eine Summe und hier unten eine

00:30.320 --> 00:30.620
Summe.

00:31.220 --> 00:36.880
Und die Frage ist nun ganz einfach, was werden diese beiden wohl

00:36.880 --> 00:40.380
ausgeben, diese beiden Summen da oben, was werden die wohl für eine

00:40.380 --> 00:42.300
Ausgabe erzeugen?

00:42.940 --> 00:45.480
Ich mache es Ihnen heute nicht unnötig schwer, ich frage Sie einfach

00:45.480 --> 00:49.140
diese vier Varianten, nachdem Sie mal eine Minute darüber nachgedacht

00:49.140 --> 00:51.060
haben, was das sein könnte.

01:18.560 --> 01:24.180
Okay, dann frage ich Sie jetzt mal, glauben Sie, dass hier diese erste

01:24.180 --> 01:25.040
Zeile rauskommt?

01:28.520 --> 01:29.000
Okay.

01:29.000 --> 01:29.980
Vielleicht die zweite?

01:31.020 --> 01:31.860
Wer ist dafür?

01:34.460 --> 01:35.460
Beigen im Walde, okay.

01:35.900 --> 01:36.340
Die dritte?

01:36.960 --> 01:38.360
Wer meint, die dritte könnte rauskommen?

01:43.540 --> 01:44.020
Okay.

01:44.020 --> 01:45.800
Und die vierte?

01:46.000 --> 01:46.760
Wer ist für die vierte?

01:48.280 --> 01:49.040
Noch ein paar?

01:49.320 --> 01:49.540
Okay.

01:50.100 --> 01:53.720
Also für die ersten beiden ist irgendwie niemand und hier konzentriert

01:53.720 --> 01:54.180
es sich ein bisschen.

01:54.180 --> 01:58.000
Die vielen Sechsen, die sind, glaube ich, attraktiv.

01:58.180 --> 02:00.060
Die vielen Sechsen sind attraktiv, meinst Du?

02:00.180 --> 02:01.520
Ja, das weiß ich nicht so genau.

02:02.080 --> 02:02.940
Was sagen Sie dazu?

02:03.120 --> 02:07.520
Warum, glauben Sie, kommt hier das Nicht-Raus oder warum kommt das

02:07.520 --> 02:07.840
hier raus?

02:07.900 --> 02:09.080
Ich verrate Ihnen mal noch nicht, was rauskommt.

02:10.100 --> 02:11.260
Aber was sind Ihre Überlegungen?

02:23.630 --> 02:24.770
Welche der Zahlen meinen Sie?

02:26.030 --> 02:26.690
Die hier.

02:26.690 --> 02:26.750
Okay.

02:27.350 --> 02:31.370
Der Hinweis ist, das hier ist nicht die Zahl, wonach sie aussieht,

02:31.470 --> 02:35.890
sondern das ist eine Oktalzahl wegen der führenden Null.

02:36.810 --> 02:37.210
Aha.

02:38.310 --> 02:40.210
Ja, das ist mal ein Hinweis.

02:40.390 --> 02:42.590
Das heißt, hier unten geht mal mit der Summe was kaputt.

02:43.090 --> 02:43.490
Okay.

02:44.170 --> 02:45.310
Noch ein Gedanke dazu vielleicht?

02:53.880 --> 02:54.120
Okay.

02:54.320 --> 02:56.440
Also das hier unten war schon der Hinweis, warum die Summe hier unten

02:56.440 --> 03:00.160
kaputt geht und warum hier was anderes rauskommt, als man vielleicht

03:00.160 --> 03:03.560
vermuten würde, wenn man es naiv addiert zu 4444.

03:04.640 --> 03:09.340
Und das da oben ist noch ein Tuck fieser, denn wenn Sie Ihre Augen mal

03:09.340 --> 03:12.640
auf super scharf stellen, dann stellen Sie vielleicht einen

03:12.640 --> 03:16.720
Unterschied fest zwischen der Eins hier vorne, dieser Eins hier unten,

03:17.060 --> 03:20.360
dieser Eins da und dieser Eins da.

03:24.770 --> 03:29.830
Kann ich Ihnen ein L für eine Eins vormachen?

03:39.180 --> 03:43.460
Können Sie sich vorstellen, wie lange Sie möglicherweise in einem

03:43.460 --> 03:46.760
echten Programm nach einem Fehler dieser Bauart gesucht hätten?

03:50.670 --> 03:51.410
Schlimm, nicht wahr?

03:51.490 --> 03:52.190
Tut ein bisschen weh?

03:56.850 --> 03:57.330
Okay.

03:57.330 --> 03:59.950
Das ist nochmal, was wir gerade eben herausgefunden haben.

04:00.670 --> 04:05.750
Und unser großer Tipp ist, vermeiden Sie führende Nullen, es sei denn,

04:05.870 --> 04:08.910
Sie meinen tatsächlich die Oktalzahl, also man ist ja versucht, wenn

04:08.910 --> 04:12.850
man so irgendwelche Zahlen untereinander schreiben möchte, dass man so

04:12.850 --> 04:16.310
führende Nullen einsortiert, um das bündig zu machen oder sowas.

04:16.410 --> 04:18.810
In Java ist das sehr gefährlich, in anderen Programmiersprachen je

04:18.810 --> 04:19.390
nachdem auch.

04:19.390 --> 04:22.950
Seien Sie vorsichtig mit führenden Nullen und wenn Sie mit diesem

04:22.950 --> 04:27.790
kleinen L hier eine Typumwandlung zu long dieser Zahl machen wollen,

04:27.870 --> 04:31.270
das ist ja das, was das L an dieser Stelle macht, dann verwenden Sie

04:31.270 --> 04:34.350
doch, um das etwas deutlicher zu machen, einfach das große L.

04:35.210 --> 04:40.610
Das tut das Gleiche und es steht einfach rein typografisch viel

04:40.610 --> 04:43.110
deutlicher da als das kleine L.

04:45.450 --> 04:49.470
Das war einfach nur eine kleine Falle, die man sich so einfangen kann.

04:50.350 --> 04:51.710
Haben Sie Fragen zu diesem Java-Rätsel?

04:56.000 --> 05:05.020
Okay, dann sind wir glaube ich für heute mit dem Rätsel durch und ich

05:05.020 --> 05:08.760
übergebe das Kommando an meinen Kollegen.

05:12.730 --> 05:14.810
Vielen Dank, guten Morgen auch nochmal von mir.

05:15.590 --> 05:19.470
Ich tourne jetzt mit Ihnen die ersten paar Aufgaben des Übungsblattes

05:19.470 --> 05:19.690
durch.

05:20.690 --> 05:25.150
Wie Sie sich erinnern, war die erste Aufgabe eine Testaufgabe.

05:25.490 --> 05:29.430
Da sollten Sie zuerst mal die Zwischensprache von diesem Kell-Text

05:29.430 --> 05:34.770
erzeugen und danach einen Kontrollschlussgrafen daraus bauen.

05:35.450 --> 05:39.150
Das ist nicht furchtbar schwierig, das ist, wenn ich nicht ganz falsch

05:39.150 --> 05:39.980
liege, eine alte Klausuraufgabe.

05:41.260 --> 05:45.420
Und was Sie im Wesentlichen tun müssen, ist eben Sachen rausstreichen,

05:45.540 --> 05:46.760
die es in der Zwischensprache nicht gibt.

05:47.060 --> 05:52.280
Das ist einmal oben das Public-Final-Double-Test-Me und alles, was

05:52.280 --> 05:55.500
irgendwie mit dem Kontrollschluss zu tun hat, also was einen Sprung

05:55.500 --> 05:56.140
nach sich zieht.

05:57.040 --> 06:00.380
Das erste, was wir machen, ist ein bisschen umschreiben.

06:01.260 --> 06:04.100
Wir schmeißen oben dieses Public weg, da bleibt dann nur noch ein

06:04.100 --> 06:04.820
Kommentar übrig.

06:04.820 --> 06:10.800
Und dann muss man eben die Schleife auslösen, die Wild-Schleife, die

06:10.800 --> 06:15.660
hier unten aufhört, indem man sich den Schleifenanfang merkt, damit

06:15.660 --> 06:16.920
man weiß, wo man hinterher hin muss.

06:17.240 --> 06:20.420
Und ans Ende dieses Goto schreibt in Zeile 110.

06:20.960 --> 06:23.620
Dieser Sprung hier nach oben, das ist die Wild-Schleife.

06:25.140 --> 06:28.500
Die bricht genauso ab wie die ursprüngliche, also diese Bedingung

06:28.500 --> 06:29.400
hier, die bleibt gleich.

06:30.260 --> 06:33.800
Und was wir dann noch tun müssen, ist innen drin dieses If auflösen.

06:34.740 --> 06:40.740
Dieses if y kleiner 0, das wird erstmal negiert, damit die Reihenfolge

06:40.740 --> 06:42.660
des Programmcodes gleich bleibt.

06:42.820 --> 06:46.480
Das heißt, in Zeile 60 haben wir dann ein if not und wenn das eben

06:46.480 --> 06:49.240
nicht zutrifft, dann überspringen wir den when-Teil.

06:49.540 --> 06:52.360
Dann fangen wir also direkt mit dem else-Zweig an, das ist das a

06:52.360 --> 06:54.040
gleich c hier unten in Zeile 90.

06:55.520 --> 07:01.380
Und falls doch der true-Fall eintritt, der ursprüngliche, dann fällt

07:01.380 --> 07:04.580
man hier einfach durch, ist in der 70 und überspringt den else-Zweig.

07:04.660 --> 07:07.600
Das heißt, hier kommt ein Goto rein, das eben dieses a gleich c

07:07.600 --> 07:08.140
überspringt.

07:09.220 --> 07:10.440
Das ist im Prinzip schon alles.

07:10.740 --> 07:11.980
Dann sind wir in der Zwischensprache.

07:13.560 --> 07:17.160
Und das sollten Sie in der Klausur mehr oder minder runterschreiben

07:17.160 --> 07:17.460
können.

07:18.500 --> 07:19.940
Ist ja auch nicht furchtbar schwierig.

07:20.960 --> 07:23.940
Wenn man das gemacht hat, muss man sich überlegen, wo kriege ich denn

07:23.940 --> 07:27.000
jetzt Grundblöcke her, damit ich einen Graph bauen kann.

07:27.700 --> 07:31.760
Und Grundblöcke, die kann man immer daran identifizieren, wo ein

07:31.760 --> 07:32.780
Sprung passiert.

07:32.920 --> 07:37.380
Das heißt, dieses Goto 90 hier oben und das Goto 40 hier unten, da ist

07:37.380 --> 07:38.480
sicherlich ein Block zu Ende.

07:39.620 --> 07:41.640
Da biegt man ja im Programmfluss ab.

07:42.620 --> 07:44.460
Dann gibt es noch ein Goto 100, das ist in der Mitte.

07:45.040 --> 07:48.320
Da ist natürlich auch das Ende von so einem Knoten.

07:49.920 --> 07:53.820
Wir haben in der Vorlesung gelernt, dass man nicht mitten in den

07:53.820 --> 07:56.280
Grundblock reinspringen kann, sondern immer nur an den Anfang von

07:56.280 --> 07:56.580
einem Block.

07:57.100 --> 07:59.680
Das heißt, im nächsten Schritt gehen Sie hin und schauen, wo springe

07:59.680 --> 08:00.420
ich denn überall hin.

08:01.640 --> 08:06.380
Man springt hier zu der 40 nach oben, das heißt hier zu dem c gleich a

08:06.380 --> 08:08.280
plus b und so weiter.

08:08.720 --> 08:12.120
Das heißt, hier möchten wir in den Grundblock eintreten und dafür

08:12.120 --> 08:13.160
braucht man natürlich einen.

08:13.200 --> 08:15.240
Das heißt, an der Stelle müssen wir auch nochmal eine Grenze

08:15.240 --> 08:15.640
einziehen.

08:16.940 --> 08:19.180
Dann kommen Sie zu diesen zwei dunklen Linien.

08:20.460 --> 08:23.460
Glücklicherweise brauchen Sie in Zeile 90 nicht noch was, weil da

08:23.460 --> 08:26.460
haben Sie ja schon von dem Goto 100 oben drüber einen neuen Block.

08:28.480 --> 08:31.040
Dann haben Sie die Aufteilung des Quelltextes schon hinter sich und

08:31.040 --> 08:33.680
dann müssen Sie das eigentlich nur noch auf ein Blatt Papier malen und

08:33.680 --> 08:35.060
ein bisschen Pfeile dazwischen stecken.

08:35.760 --> 08:39.860
Das heißt, Sie machen um den Quelltext nach oben immer so einen

08:39.860 --> 08:43.700
schönen Kasten und zeichnen dann hinterher die Kanten ein,

08:44.240 --> 08:45.720
entsprechend diesen Goto-Befehlen.

08:46.280 --> 08:47.560
Und dann kommen Sie zu so einem Bild.

08:47.740 --> 08:51.360
Was Sie nicht vergessen dürfen in der Klausur ist ein Anfangs- und ein

08:51.360 --> 08:52.080
Endknoten.

08:52.880 --> 08:55.780
Der Endknoten ist einfach, da haben wir hier dieses Return-Statement.

08:56.500 --> 08:59.020
Wenn das eine Void-Methode wäre, dann kann es auch sein, dass der

08:59.020 --> 09:01.100
Endknoten leer ist, weil da einfach nichts passiert.

09:02.260 --> 09:04.380
Und was wir auch noch brauchen ist ein Startknoten.

09:04.540 --> 09:06.520
Der ist hier oben, da ist dann eben die Eingabe drin.

09:06.780 --> 09:09.280
Das ist das, was wir hier im Quelltext nur als Kommentar gesehen

09:09.280 --> 09:09.500
haben.

09:10.620 --> 09:11.920
Und dann sind Sie schon fertig.

09:12.400 --> 09:15.180
Sie sollten dann nochmal ein bisschen drüber lesen, ob die Reihenfolge

09:15.180 --> 09:18.380
des Programms noch okay ist, ob Sie das mit den True- und False

09:18.380 --> 09:20.940
-Verzweigungen richtig gemacht haben, ob das noch mit dem

09:20.940 --> 09:22.580
ursprünglichen Quellcode übereinstimmt.

09:23.340 --> 09:24.560
Und dann sind Sie eigentlich schon fertig.

09:24.980 --> 09:28.080
Und in der Klausuraufgabe war man an der Stelle dann auch fertig.

09:29.000 --> 09:30.440
Wir wollten noch ein bisschen mehr von Ihnen.

09:31.420 --> 09:34.660
Wir wollten, dass Sie da JUnit-Testfälle schreiben, um so ein paar

09:34.660 --> 09:37.560
Abdeckungskriterien mal abzuprüfen.

09:37.560 --> 09:46.720
Und wenn man das in JUnit schreibt und dann mit ECLMA durchmisst, dann

09:46.720 --> 09:51.160
bekommt man angezeigt im Eclipse, welche Anweisungen denn von den

09:51.160 --> 09:52.440
Testfällen überdeckt worden sind.

09:52.580 --> 09:53.400
Das sieht so aus.

09:53.600 --> 09:57.480
Wir haben dann im Programmcode ein schönes Highlighting, also dieses

09:57.480 --> 09:58.500
hellgrün.

09:58.640 --> 10:02.020
Das heißt, ja, da ist ein Testfall drüber gestolpert.

10:02.600 --> 10:05.920
Gelb heißt, naja, da war einer, aber nicht vollständig.

10:05.920 --> 10:08.700
Das heißt, es gibt andere Belegungen, die man da noch prüfen müsste.

10:08.840 --> 10:13.760
Wahrscheinlich in dem Fall war der If immer false.

10:13.920 --> 10:16.460
Deswegen ist auch das Return-Statement nie aufgerufen worden.

10:17.420 --> 10:21.920
Und naja, dass dieses If eben nur mit einer Wahrheitsbelegung und

10:21.920 --> 10:24.280
nicht mit beiden ausgewertet wurde, das sagt Ihnen das Gelbe.

10:24.960 --> 10:29.060
Wenn man dann mit der Maus drüber zeigt, dann sagt einem Eclipse auch,

10:29.180 --> 10:31.960
wie viele von diesen Faden man denn verpasst hat, wenn es mehrere

10:31.960 --> 10:32.260
gibt.

10:33.800 --> 10:36.400
Zusätzlich dazu gibt es eine hübsche Tabelle.

10:37.480 --> 10:39.660
Und das war im Wesentlichen die, die wir gerne gehabt hätten von

10:39.660 --> 10:39.860
Ihnen.

10:40.060 --> 10:41.540
Oder eine Zeile daraus.

10:42.080 --> 10:45.160
Wir wollten ja wissen, wie ist es denn in der KfG-Aufgabe mit der

10:45.160 --> 10:47.260
Überdeckung für Anweisungsüberdeckung.

10:48.040 --> 10:49.920
Natürlich ist es 100 Prozent, weil sonst hätten wir diese

10:49.920 --> 10:51.420
Anweisungsüberdeckung ja nicht erreicht.

10:53.760 --> 10:56.500
Was man da dann auch noch sehen kann, ist eben, welche anderen Teile

10:56.500 --> 10:59.140
vielleicht nicht vollständig abgedeckt worden sind.

10:59.140 --> 11:01.740
Und wenn man jetzt, sage ich mal, seine Testabdeckung erhöhen will,

11:01.840 --> 11:06.000
dann versucht man vermutlich nicht irgendwas von 99 auf 100 Prozent zu

11:06.000 --> 11:09.820
bringen, sondern eher was von 0 auf 50, weil das ziemlich sicher

11:09.820 --> 11:10.560
einfacher geht.

11:13.720 --> 11:15.160
Sie sollten Testfälle bauen.

11:15.300 --> 11:18.560
Das Erste, was einem da einfällt, ist ein Zweigüberdeckungstest.

11:19.060 --> 11:22.740
Das kriegen Sie hin mit der Eingabe für A gleich minus 1 und B gleich

11:22.740 --> 11:23.020
2.

11:23.020 --> 11:26.340
Wenn Sie das in JUnit hinschreiben, dann ist das so wie hier in diesem

11:26.340 --> 11:27.020
grünen Kasten.

11:27.580 --> 11:31.820
Sie brauchen also irgendwo ein K, das Sie sich vorher initialisiert

11:31.820 --> 11:32.100
haben.

11:32.240 --> 11:36.160
Ich habe das in der AddBefore gemacht, damit es den Testfall nicht so

11:36.160 --> 11:36.560
aufbläht.

11:37.100 --> 11:39.260
Und dann müssen Sie eben diese Eingabe reinlaufen lassen.

11:41.580 --> 11:45.560
Da das schon eine 100 Prozent Abdeckung gibt, sehr klar,

11:46.300 --> 11:49.240
Zweigüberdeckung ist ja mehr als Anweisungsüberdeckung, kann man

11:49.240 --> 11:51.520
diesen Testfall auch nehmen, um den ersten Aufgabenteil zu

11:51.520 --> 11:52.060
beantworten.

11:52.060 --> 11:55.000
Man kann einfach denselben Testfall nehmen, um auch die

11:55.000 --> 11:56.520
Anweisungsüberdeckung hinzukriegen.

11:57.400 --> 12:01.180
Wir wollten von Ihnen da einen minimalen Testfall, das heißt so wenig

12:01.180 --> 12:03.460
wie möglich Aufrufe von dem Programm haben.

12:03.640 --> 12:06.900
Und da das nur ein Aufruf ist, ist es natürlich trivialerweise

12:06.900 --> 12:08.200
minimal.

12:10.140 --> 12:13.520
Der dritte Teil von dieser Aufgabe, das war die Pfadüberdeckung.

12:14.480 --> 12:18.140
Wer von Ihnen hat den Eingabewert gefunden, um eine Pfadüberdeckung

12:18.140 --> 12:18.700
hinzukriegen?

12:18.700 --> 12:19.380
Ehrlich?

12:24.430 --> 12:27.390
Und wie kommt man dann in den dritten Durchgang?

12:29.210 --> 12:30.570
Also Ihr Kommilitone sagte gerade,

12:37.640 --> 12:41.500
er hat eine Eingabe, die zweimal durch die Schleife durchläuft.

12:41.600 --> 12:43.460
Und dann habe ich gefragt, naja, was ist denn mit dem dritten

12:43.460 --> 12:43.980
Durchlauf?

12:44.200 --> 12:46.340
Antwort der Kommilitone, ich kann ja nicht alle machen.

12:47.260 --> 12:49.860
Aber genau das ist, was Pfadüberdeckung sagt, Sie sollen alle

12:49.860 --> 12:53.000
möglichen Pfade abdecken, die das Programm nehmen kann.

12:53.000 --> 12:55.580
Und natürlich, wenn Sie eine Schleife haben, die von der Eingabe

12:55.580 --> 12:58.680
abhängt, dann können Sie die Eingabe immer größer machen und kriegen

12:58.680 --> 12:59.840
noch einen Schleifendurchlauf mehr.

13:00.520 --> 13:02.920
Dementsprechend können Sie keine Pfadüberdeckung erreichen.

13:03.980 --> 13:04.780
Das geht einfach nicht.

13:07.340 --> 13:12.200
Deutlicher sieht man das bei Methoden, die zum Beispiel einen String

13:12.200 --> 13:16.020
als Parameter haben und den zeichenweise durchgehen in der Schleife.

13:16.600 --> 13:18.140
Da können Sie natürlich den String immer länger machen.

13:18.980 --> 13:22.240
Und für jeden Buchstaben, den der String mehr hat, kriegen Sie einen

13:22.240 --> 13:24.680
Schleifendurchlauf mehr und dann auch noch einen Pfad mehr.

13:25.660 --> 13:28.400
Dementsprechend ist es zumindest theoretisch nicht möglich,

13:28.760 --> 13:31.520
Pfadüberdeckung zu erreichen, weil Sie die Eingabe immer größer machen

13:31.520 --> 13:31.760
können.

13:33.140 --> 13:35.580
Praktisch können Sie argumentieren, naja, ich nehme einfach den

13:35.580 --> 13:38.760
längsten String, den es gibt, oder ich nehme die größte Zahl, die es

13:38.760 --> 13:42.200
gibt, in dem Bereich des Parameters.

13:42.320 --> 13:44.800
Und dann habe ich ja alles abgedeckt, was pragmatisch möglich ist.

13:45.660 --> 13:48.680
Auf die Diskussion würden wir uns einlassen, aber den Testfall haben

13:48.680 --> 13:49.780
Sie vermutlich nicht geschrieben.

13:51.660 --> 13:54.460
Die richtige Antwort an der Stelle wäre, naja, das geht nicht, weil

13:54.460 --> 13:56.940
das ist halt potenziell unbegrenzt.

13:57.440 --> 13:58.720
Und damit hat es sich erledigt.

13:59.720 --> 14:03.420
Das heißt, der dritte Teil von der Aufgabe, der war ziemlich einfach,

14:03.900 --> 14:05.440
wenn man auf die Idee kam.

14:07.260 --> 14:11.700
Sie erinnern sich daran, in diesem Quelltext, den ich nochmal vorhole,

14:12.840 --> 14:16.480
da gibt es eine Methode f, die aufgerufen wird.

14:17.320 --> 14:21.460
Die ist nicht in der AFG-Aufgabenklasse drin, sondern in einer

14:21.460 --> 14:22.320
Unterklasse davon.

14:23.280 --> 14:25.240
Und wir haben sie gefragt, was ist denn, wenn man da eine andere

14:25.240 --> 14:27.460
Methode einträgt, ein anderes f.

14:28.340 --> 14:32.880
Das erste f, das war ja, das sieht man hier am Rand noch, das war im

14:32.880 --> 14:36.800
Prinzip das Quadrieren von dieser Eingabe und hinterher das Vorzeichen

14:36.800 --> 14:37.540
wieder dran pappen.

14:37.540 --> 14:40.740
Wenn sie also eine negative Zahl reingeben, dann kriegen sie das

14:40.740 --> 14:43.040
Quadrat und trotzdem das Minus davor.

14:43.600 --> 14:46.680
Das war quasi die komplizierte Fassung, die einfache Fassung war.

14:46.900 --> 14:49.380
Wir quadrieren es einfach und das Vorzeichen geht dadurch verloren.

14:50.040 --> 14:53.240
Und die Frage ist, naja, was passiert denn dann mit der Abdeckung von

14:53.240 --> 14:55.660
der KFG-Aufgaben, von dieser Test-me-Methode.

14:58.340 --> 15:02.820
Test-me hatte ja in der Mitte diesen Aufruf von f, das heißt, hier

15:02.820 --> 15:06.140
wird was berechnet und dann von diesem Berechnungsergebnis hängt der

15:06.140 --> 15:07.100
weitere Verlauf ab.

15:07.800 --> 15:10.840
Und wenn wir hier das f austauschen durch was, was nur positive

15:10.840 --> 15:14.620
Ergebnisse zurückgibt, dann ist natürlich y auch immer größer gleich

15:14.620 --> 15:14.860
0.

15:15.580 --> 15:19.940
Und dementsprechend kann man nie in den Benzweig hier reinspringen.

15:20.100 --> 15:23.320
Das heißt, diese Zeile werden sie nie abdecken können mit einem

15:23.320 --> 15:25.840
Abdeckungstest und dementsprechend auch nicht mit den anderen

15:25.840 --> 15:26.920
Abdeckungskriterien.

15:28.360 --> 15:32.380
Wenn sie das in Eclipse laufen lassen, in E-Klemmer, dann sieht das

15:32.380 --> 15:33.120
ungefähr so aus.

15:33.260 --> 15:37.760
Naja gut, in B kommen sie nie an und diese Bedingung, die wird halt

15:37.760 --> 15:39.000
nicht vollständig überdeckt.

15:39.500 --> 15:41.700
Dafür haben sie den Elstzweig immer erreicht.

15:43.600 --> 15:47.420
Und wir wollten von Ihnen wissen, wie kann man das denn detektieren.

15:47.900 --> 15:51.380
Das ist auch wieder eine Frage aus der Klausur, die ich, gelinde

15:51.380 --> 15:54.140
gesagt, ein bisschen daneben finde, weil die Antwort ist, naja,

15:54.240 --> 15:57.480
dynamisch kann man einfach so ein Überdeckungswerkzeug nehmen wie E

15:57.480 --> 15:57.820
-Klemmer.

15:58.420 --> 15:59.520
Das haben wir gerade gemacht.

16:00.100 --> 16:03.480
Dafür gab es einen Punkt in der Klausur und den anderen Punkt gab es

16:03.480 --> 16:04.920
für eine statische Methode.

16:05.720 --> 16:09.480
Und das ist alles, was mit Hingucken zu tun hat.

16:10.060 --> 16:15.600
Also Inspektion oder Methode des scharfen Hinsehens oder Code Reviews

16:15.600 --> 16:19.520
oder Walkthroughs oder was auch immer wir da in dem Testkapitel alles

16:19.520 --> 16:20.040
gemacht haben.

16:22.700 --> 16:24.620
Haben Sie Fragen soweit zu dieser Aufgabe?

16:28.460 --> 16:29.000
Sehr schön.

16:30.240 --> 16:32.260
Als nächstes haben wir Sie gefragt, was sind denn da für

16:32.260 --> 16:34.080
Entwurfsmuster drin in der Aufgabe.

16:34.380 --> 16:39.000
Und im Aufgabentext selbst gibt es eine Schablonenmethode, das haben

16:39.000 --> 16:39.960
wir schon ein paar Mal gehabt.

16:40.360 --> 16:41.500
Ich glaube sogar in einem Testfall.

16:42.900 --> 16:46.120
Und naja, die Schablonenmethode ist in der KFG-Aufgabe drin, dieses

16:46.120 --> 16:46.600
TestMe.

16:47.340 --> 16:49.960
Das ist die Methode, die den Algorithmus quasi festschreibt.

16:50.580 --> 16:53.860
Und die Einschubmethode, das Austauschbare, das ist genau das F.

16:54.600 --> 16:56.400
Ausgetauscht, das ist ja genau das, was wir gemacht haben.

16:58.860 --> 16:59.960
Ziemlich trivial an sich.

17:00.200 --> 17:03.300
Es gab noch ein zweites Muster, das so ein bisschen hinkt.

17:03.920 --> 17:06.820
Das ist in den Testfällen, da gibt es eigentlich eine Fabrikmethode,

17:06.900 --> 17:09.920
wenn man die denn haben will, in diesem Setup.

17:10.080 --> 17:13.200
Das ist aber nur in Anführungszeichen, weil die Methode ja nichts

17:13.200 --> 17:15.580
zurückgibt, sondern eigentlich eine Klassenvariable setzt.

17:15.580 --> 17:18.100
Und naja, danach haben wir auch nicht gesucht.

17:18.220 --> 17:19.160
Das ist also nur am Rande.

17:21.800 --> 17:23.580
Haben Sie Fragen zu dieser Testaufgabe?

17:24.140 --> 17:25.340
Hatten Sie da Probleme mit?

17:27.780 --> 17:30.320
Klar, warum man e-Klemmer vielleicht benutzen möchte?

17:31.360 --> 17:33.920
Haben Sie sonst irgendwelche Fragen zu dem Testen und dem JUnit?

17:38.890 --> 17:39.370
Okay.

17:40.530 --> 17:42.770
Die nächste Aufgabe, die war mit Parallelität.

17:43.630 --> 17:46.470
Sie erinnern sich vielleicht an dieses Beispiel aus der Vorlesung oder

17:46.470 --> 17:47.790
dann zumindest vom Übungsblatt.

17:48.490 --> 17:50.190
Da gab es ein Stückchen Programmtext.

17:50.490 --> 17:53.670
Da wurde eine Globalvariable geprüft, ob sie größer als 0 ist.

17:54.370 --> 17:56.870
Und wenn ja, dann wird sie dekrementiert.

17:57.110 --> 18:00.630
Und die Frage ist jetzt, wenn man mehrere Fäden hat, also 2 zum

18:00.630 --> 18:03.990
Beispiel, und die führen diesen Code gleichzeitig aus, dann gibt es ja

18:03.990 --> 18:04.350
Probleme.

18:05.170 --> 18:06.650
Das war das Beispiel aus der Vorlesung.

18:06.890 --> 18:10.410
In der Übung haben wir jetzt da noch hinzugefügt, dass dieses

18:10.410 --> 18:12.550
GlobalVar eben Volatil ist.

18:13.250 --> 18:16.450
Und die Frage ist, naja, kann mit dieser Änderung, mit dem Volatil,

18:16.590 --> 18:18.030
auch ein Wettlauf auftreten?

18:19.690 --> 18:21.870
Also die erste Frage, was war denn nochmal Volatil?

18:23.610 --> 18:25.470
Wissen Sie, was Volatil tut?

18:27.610 --> 18:28.130
Thomas?

18:32.160 --> 18:32.920
Vielen Dank.

18:33.640 --> 18:34.920
Also ein Teil von Ihnen weiß es noch.

18:36.060 --> 18:41.080
Volatil sorgt dafür, dass die Variable nicht im Cache vom Prozessor

18:41.080 --> 18:44.080
gehalten wird, sondern direkt in den Arbeitsspeicher geschrieben wird.

18:44.180 --> 18:48.080
Das heißt, wenn ein Prozessor nachschauen möchte, was denn der Wert

18:48.080 --> 18:51.340
von dieser Variable ist, dann sagt ihm sein Cache immer, ich habe

18:51.340 --> 18:53.460
keine Ahnung, guck mal im Speicher nach.

18:53.960 --> 18:55.680
Das heißt, er kriegt immer den aktuellen Wert.

18:57.640 --> 19:01.960
Das ist einerseits nicht schlecht, weil wenn sich der Wert ändert,

19:02.020 --> 19:03.480
dann kriegt der Prozessor das ja gleich mit.

19:03.960 --> 19:06.820
Aber das hilft leider trotzdem nicht, um den Wettlauf zu beheben.

19:07.740 --> 19:09.840
Man kann sich das immer noch so vorstellen, dass man eine

19:09.840 --> 19:11.360
Fadenverschränkung dieser Art bekommt.

19:11.520 --> 19:15.140
Das heißt, Volatil ist am Anfang größer als 0, dann kommt der erste

19:15.140 --> 19:18.640
Faden daher und prüft das und dann wird er schlafen gelegt, weil seine

19:18.640 --> 19:20.260
Zeit jetzt um ist, er hat genug geprüft.

19:20.740 --> 19:23.200
Dann kommt der zweite Faden, macht die Prüfung, es hat sich ja nichts

19:23.200 --> 19:23.620
geändert.

19:23.940 --> 19:25.380
Das Ergebnis ist also immer noch wahr.

19:25.920 --> 19:28.620
Er dekrementiert es und legt sich schlafen und dann kommt der erste

19:28.620 --> 19:29.000
Faden.

19:29.760 --> 19:33.240
Und der weiß ja noch, ja Global War war ja größer als 0, ich mache

19:33.240 --> 19:34.500
einfach mal da weiter, wo ich war.

19:35.040 --> 19:36.960
Also dekrementiere ich es und schon hat man genau dieses

19:36.960 --> 19:37.680
Wettlaufproblem.

19:38.860 --> 19:42.500
Das heißt, das Volatil hilft an der Stelle einfach gar nichts.

19:42.880 --> 19:44.540
Man müsste den Zugriff irgendwie sperren.

19:49.160 --> 19:50.820
Das war schon der Aufgabenteil A.

19:51.500 --> 19:56.340
Der Aufgabenteil B, da ging es um das parallele Summieren von einem

19:56.340 --> 19:56.600
Array.

19:57.820 --> 20:03.340
Das war im Wesentlichen der Aufgabentext, den Sie auf dem Blatt

20:03.340 --> 20:03.600
hatten.

20:04.480 --> 20:06.940
Und der Algorithmus, der steht jetzt hier auf der linken Seite.

20:07.080 --> 20:08.920
Das heißt, wir haben so einen Teil-und-Herrsche-Vorgang.

20:09.320 --> 20:12.880
Wir kriegen ein Array als Eingabe, das ist hier die Variable, die auch

20:12.880 --> 20:13.500
Array heißt.

20:13.500 --> 20:19.820
Und wenn das Array nur ein Element hat, dann gibt es eben genau dieses

20:19.820 --> 20:21.180
Element zurück.

20:22.040 --> 20:24.340
Da fehlt noch ein Klammer auf 0 zu.

20:25.660 --> 20:28.160
Weil wir natürlich nicht das Array zurückgeben wollen, sondern nur den

20:28.160 --> 20:28.360
Int.

20:29.260 --> 20:34.400
Und wenn das Array größer ist, dann wird ein neuer Faden aufgemacht.

20:34.540 --> 20:36.140
Der eine, also zwei neue Fäden.

20:36.240 --> 20:38.780
Der erste, der kriegt die linke Hälfte, der zweite kriegt die rechte

20:38.780 --> 20:39.120
Hälfte.

20:39.720 --> 20:42.400
Und das Ergebnis ist dann quasi die Summe aus diesen beiden Hälften.

20:42.400 --> 20:45.060
Es wird also rekursiv immer weiter aufgerufen.

20:46.020 --> 20:50.640
Und die Frage war, wie viele Fäden brauchen wir denn, um ein Array der

20:50.640 --> 20:54.200
Länge 8 durchlaufen zu lassen, durchzurechnen.

20:55.080 --> 20:57.920
Dieses komische Gekrakel, das ist das Symbol für Faden.

20:58.620 --> 21:01.020
Ist wohl auch irgendwo in den Vorlesungsfolien kursiert.

21:02.980 --> 21:05.020
Und im ersten Durchlauf wird es geteilt.

21:05.200 --> 21:07.520
Das heißt, wir haben zweimal ein Array der Länge 4.

21:07.800 --> 21:10.860
Das wird dann wieder geteilt, weil das ist ja immer noch nicht 1 lang.

21:11.700 --> 21:12.900
Wird nochmal geteilt.

21:13.320 --> 21:14.620
Das ist immer noch größer als 1.

21:15.660 --> 21:17.380
Und dann haben wir ganz viele Arrays der Länge 1.

21:18.440 --> 21:20.940
Und die kann man dann tatsächlich explizit berechnen.

21:21.060 --> 21:26.020
Das heißt, bis hier unten werden jedes Mal zwei neue Fäden

21:26.020 --> 21:27.460
aufgespalten für jedes Teil Array.

21:27.580 --> 21:30.180
Und hier unten wird dann das erste Mal wirklich gerechnet.

21:30.340 --> 21:34.240
Das heißt, hier unten in diesen Fäden, da wird dann das Return Array 0

21:34.240 --> 21:35.180
hier oben ausgeführt.

21:36.800 --> 21:40.260
Naja, kann man einfach abzählen, wie viele Fäden das sind.

21:40.440 --> 21:41.600
Das sind 14.

21:42.520 --> 21:45.420
Das ist aber leider nicht die ganze Wahrheit, weil sie brauchen ja

21:45.420 --> 21:47.460
auch noch den Hauptfaden, der am Anfang aufgerufen wurde.

21:47.620 --> 21:50.180
Also eigentlich brauchen sie 15 Fäden, um das auszurechnen.

21:55.800 --> 21:58.960
Und jetzt ist die große Frage, wieso ist das sequentiell denn

21:58.960 --> 22:00.660
schneller als parallel?

22:01.880 --> 22:05.380
Oder anders, ist es denn sequentiell schneller als parallel?

22:05.720 --> 22:08.760
Und naja, die Antwort ist ja, sequentiell ist schon ein bisschen

22:08.760 --> 22:12.060
cleverer an der Stelle, weil die ganze Infrastruktur, die man braucht,

22:12.160 --> 22:15.920
um die Fäden neu aufzumachen und die Fäden wieder zusammenzuführen und

22:15.920 --> 22:21.100
das ganze Scheduling, das dahinter hängt, ist so langsam, dass das die

22:21.100 --> 22:24.400
Beschleunigung von der Parallelität wieder auffrisst.

22:24.520 --> 22:26.860
Das heißt, sie haben da nichts gewonnen, wenn sie das so umsetzen.

22:27.380 --> 22:31.520
Wenn sie so etwas bauen möchten in der Realität, dann würden sie

22:31.520 --> 22:34.880
irgendwo eine Abbruchschranke reinmachen, die größer ist als 1.

22:35.100 --> 22:39.760
Also sagen wir mal bei 100 oder bei 500 oder bei 1000, je nachdem wie

22:39.760 --> 22:41.580
groß das Eingabe-Array normalerweise ist.

22:42.200 --> 22:45.980
Und dann sequentiell durchrechnen, damit sie nicht so viele Fäden

22:45.980 --> 22:46.800
aufspalten müssen.

22:48.540 --> 22:52.300
Genau, das ist das Ganze nochmal in sauber erklärt.

22:53.280 --> 22:58.860
Und dann kommt meine allzeit beliebte Frage, haben Sie Fragen zu

22:58.860 --> 22:59.800
diesem Aufgabenteil?

23:03.740 --> 23:07.300
Ist Ihnen aufgefallen, dass diese Aufgabe B direkt etwas mit der

23:07.300 --> 23:09.740
Programmieraufgabe nebendran zu tun hat?

23:14.350 --> 23:16.290
Ich sehe zumindest niemanden heftig nicken.

23:17.750 --> 23:21.970
Dann darf Thomas jetzt erklären, wie wir die Earth Movers Distance

23:21.970 --> 23:24.710
parallelisieren können und ob das wirklich Sinn macht.

23:26.930 --> 23:30.910
Ja, in Aufgabe 3 haben wir Sie nochmal ein bisschen gekitzelt und ein

23:30.910 --> 23:32.450
bisschen geärgert.

23:32.610 --> 23:36.470
Denn zum einen, der Testfall, den wir Ihnen da mitgeliefert hatten,

23:36.630 --> 23:40.290
der testet natürlich nur diese Performance-Aufrufschnittstelle.

23:41.030 --> 23:44.430
Der war natürlich funktional ein bisschen kastriert.

23:44.430 --> 23:48.510
Der war nicht so, dass Sie für jede beliebige Parallelisierung dort

23:48.510 --> 23:50.910
mit einem grünen Testfall auch sicher sein konnten, dass Ihre

23:50.910 --> 23:52.230
Parallelisierung richtig ist.

23:52.970 --> 23:55.670
Aber die alten Testfälle, die Sie noch hatten, die konnten Ihnen da

23:55.670 --> 23:56.630
vielleicht einen Tipp geben.

23:57.310 --> 24:01.590
Zum zweiten mussten Sie ein klein bisschen darüber nachdenken, dass

24:01.590 --> 24:06.190
die Earth Movers Distance nicht ganz so einfach parallelisierbar ist,

24:06.250 --> 24:08.750
wie sie auf den ersten Blick aussieht.

24:08.830 --> 24:11.670
Und ich wollte jetzt auf den folgenden Folien Ihnen mal ein bisschen

24:11.670 --> 24:15.970
näher bringen, warum das vielleicht ein Tuck komplizierter ist, als

24:15.970 --> 24:18.030
sich einige von Ihnen das vielleicht zurechtgelegt haben.

24:18.590 --> 24:20.210
Was war nochmal die Earth Movers Distance?

24:21.410 --> 24:22.630
Das war folgendes.

24:22.690 --> 24:24.490
Wir haben hier zwei Histogramme.

24:24.730 --> 24:28.790
Wir haben in unserem Beispiel jetzt hier sechs Buckets, sechs

24:28.790 --> 24:29.870
Kategorien, wie auch immer.

24:30.410 --> 24:33.030
Wir haben ein blaues Histogramm und ein rotes Histogramm.

24:33.390 --> 24:37.910
Und die Earth Movers Distance berechnet Ihnen nun ein mögliches

24:37.910 --> 24:41.270
Distanzmaß zwischen diesen beiden Histogrammen.

24:41.270 --> 24:43.990
Wir sehen ja hier, dass hier Unterschiede teilweise drin sind, die

24:43.990 --> 24:46.350
sind unterschiedlich hoch, die sind auch in unterschiedliche

24:46.350 --> 24:50.110
Richtungen und manchmal haben wir auch keinen Unterschied.

24:50.770 --> 24:54.930
Und die Earth Movers Distance sagt hier, das ist hier diese

24:54.930 --> 24:59.130
Rechenvorschrift, dass man eben elementweise von links nach rechts

24:59.130 --> 25:05.350
paarweise durch die Elemente der beiden Felder durchläuft und dabei

25:05.350 --> 25:07.190
die Differenz berechnet der beiden.

25:07.330 --> 25:14.950
Also man berechnet hier das Gelbe, das ist f1i-f2i für jedes Bucket

25:14.950 --> 25:21.390
hier und zusätzlich die Differenz dessen, was wir von links sozusagen

25:21.390 --> 25:22.370
noch mitgenommen haben.

25:22.870 --> 25:23.930
Also hier fangen wir mit 0 an.

25:24.010 --> 25:27.810
Die Differenz vom Blauen zum Roten ist plus 1.

25:27.810 --> 25:33.270
Hier ist die Differenz vom Blauen zum Roten plus 3, aber um auf diese

25:33.270 --> 25:37.630
4 von dem Gelben zu kommen, addieren wir noch die 1 aus dem

25:37.630 --> 25:39.430
Vorgängerschritt hinzu.

25:40.030 --> 25:44.050
Hier geht es ähnlich weiter, hier ist die Differenz minus 3 und diese

25:44.050 --> 25:48.990
minus 3 addieren wir auf die 4 von Schritt 2 und landen wieder bei 1

25:48.990 --> 25:49.810
und so weiter.

25:49.810 --> 25:55.430
Das Gelbe sind sozusagen die Werte, die beim Durchlauf dieser Schleife

25:55.430 --> 25:59.310
der Reihe nach in der Variable div landen werden.

26:01.370 --> 26:05.770
Und die nächste Zeile macht jetzt nichts anderes als alle Gelben

26:05.770 --> 26:08.390
betragsmäßig aufsummieren.

26:08.690 --> 26:12.050
Und das sieht dann zum Beispiel so aus in unserem Beispiel.

26:12.670 --> 26:15.810
Hier unten fangen Sie mit der 1 an, dann kommt hier eine 4 hinzu, hier

26:15.810 --> 26:19.390
kommt eine 1 hinzu, hier kommt nochmal eine 1 hinzu, beachten Sie

26:19.390 --> 26:23.390
übrigens, dass hier lustigerweise eine 1 addiert wird, obwohl diese

26:23.390 --> 26:25.230
beiden Kategorien hier identisch sind.

26:26.250 --> 26:29.390
Auch das hier wird betragsmäßig addiert, also die Kurve Summen geht

26:29.390 --> 26:32.970
eben immer nach oben, egal ob Sie eine positive oder eine negative

26:32.970 --> 26:35.310
Zahl der Variable div haben.

26:35.770 --> 26:39.550
Soweit mal für Earth Movers Wissen, was sie tut.

26:40.010 --> 26:43.630
So, die Frage ist nun, wie kriegen wir das parallel?

26:44.450 --> 26:46.090
Und warum ist es nicht so einfach?

26:49.890 --> 26:53.210
Es sieht also so aus, dass Sie sich vielleicht mal die Schleife

26:53.210 --> 26:58.610
anschauen und dann stellen Sie vielleicht fest, das div hier, das ist

26:58.610 --> 27:01.850
immer ein Wert aus der vorherigen Iteration.

27:02.450 --> 27:06.830
Wir müssen also irgendwie diese vorherige Iteration irgendwie auflösen

27:06.830 --> 27:07.930
oder retten oder sowas.

27:08.410 --> 27:12.950
Nun könnten Sie ja auf die Idee kommen, naja, wenn ich das einfach,

27:13.150 --> 27:16.170
also diese beiden grünen Streifen, das sind meine beiden Arrays, das

27:16.170 --> 27:21.570
rote und das blaue aus der Vorgängerfolie und die sind, die könnte ich

27:21.570 --> 27:24.370
jetzt, der sequenzielle läuft jetzt einfach von links nach rechts

27:24.370 --> 27:27.630
durch und wenn Sie am Ende sind, dann haben Sie Ihre Summe und das ist

27:27.630 --> 27:30.950
das Differenzmaß, was der Algorithmus berechnet.

27:30.950 --> 27:36.050
Nun könnten Sie ja einfach das ganze blockweise tun und zum Beispiel

27:36.050 --> 27:39.890
einfach die beiden Felder, die beiden Arrays in vier Blöcke aufteilen

27:39.890 --> 27:43.090
und jeweils vom Beginn des Blockes bis zum Ende des Blockes laufen.

27:43.590 --> 27:50.590
Das funktioniert nicht, weil Sie für die Berechnung des ersten Index

27:50.590 --> 27:55.890
des zweiten Blockes ja den Übertrag brauchen vom Vorgängerblock.

27:56.030 --> 27:58.590
Sie brauchen also das letzte Element vom Vorgängerblock.

27:58.590 --> 27:59.670
Jeweils.

28:00.550 --> 28:03.330
Das ist diese Abhängigkeit, die hier oben drin steckt.

28:04.010 --> 28:06.990
Und nun kann man sich überlegen, kann ich das vielleicht irgendwie

28:06.990 --> 28:08.810
auflösen oder korrigieren.

28:09.030 --> 28:11.510
Also Überlegung 1 ist vielleicht, ok, ich habe hier zwar einen

28:11.510 --> 28:16.270
Übertrag, aber kann ich vielleicht trotzdem einfach erstmal blockweise

28:16.270 --> 28:21.110
naiv rechnen und das Einzelergebnis, was ich am Schluss eines Blockes

28:21.110 --> 28:26.770
hier hinten jeweils bekommen habe, korrigieren, um den Betrag, den ich

28:26.770 --> 28:29.310
danach dann im Vorgängerblock habe.

28:29.570 --> 28:34.270
Der Witz ist ja, ich möchte die parallel berechnen, das kann ich auch

28:34.270 --> 28:37.270
tun, aber ich muss dann das Ergebnis korrigieren, weil wenn alle

28:37.270 --> 28:40.950
gleichzeitig beginnen zu rechnen, habe ich ja zu Beginn noch nicht

28:40.950 --> 28:43.070
diesen Übertrag aus dem Vorgängerblock.

28:43.190 --> 28:44.150
Sonst bin ich ja wieder sequenziell.

28:45.330 --> 28:48.110
Das wäre also die erste Überlegung, um das trivial parallel zu

28:48.110 --> 28:49.690
kriegen, so Blockparallel zu kriegen.

28:49.810 --> 28:54.110
Kriege ich irgendwie diesen Übertrag auf mein Ergebnis, was ich

28:54.110 --> 28:57.570
inzwischen von meinem Block habe, rübergerettet und aufgetragen?

28:58.650 --> 29:00.910
Unsere Antwort ist, nein.

29:02.290 --> 29:03.730
Wir haben das nicht geschafft.

29:04.530 --> 29:07.030
Vielleicht sind Mathematiker unter Ihnen, die da herausgefordert sind,

29:07.410 --> 29:10.150
aber was es Ihnen kaputt macht, ist die ABS-Funktion.

29:10.850 --> 29:12.830
Die ist an der Stelle ein bisschen hinterhältig.

29:13.970 --> 29:19.550
Die macht Ihnen diesen Übertrag deshalb kaputt, weil Sie hier zu

29:19.550 --> 29:27.470
Beginn um einen Betrag eben verschoben werden, der in der Folge einen

29:27.470 --> 29:32.250
sehr großen Fehler verursacht, wenn Sie die Absolutwerte der Zahlen

29:32.250 --> 29:32.750
berechnen.

29:32.890 --> 29:34.530
Das kriegen Sie nachher nicht mehr in den Griff.

29:35.890 --> 29:38.590
Ich möchte das mal so stehen lassen, für die Details dürfen Sie sich

29:38.590 --> 29:39.410
das gerne mal überlegen.

29:39.410 --> 29:42.070
Nehmen Sie es für den Moment einfach mal so hin, die ABS-Funktion

29:42.070 --> 29:49.050
verhindert, dass Sie beliebige Stellen in diesem Feld einfach direkt

29:49.050 --> 29:53.430
berechnen können oder Berechnungen um einen Versatz korrigieren

29:53.430 --> 29:53.810
können.

29:54.190 --> 29:55.250
Das geht nicht so einfach.

29:55.890 --> 30:02.930
Also brauchen Sie früher oder später irgendeine Parallelisierung, die

30:02.930 --> 30:06.970
es Ihnen erlaubt, dieses Manko zu umgehen.

30:08.910 --> 30:10.330
Was könnte man da tun?

30:10.750 --> 30:13.330
Nun ja, jetzt sind wir hier wieder so ein bisschen inherent

30:13.330 --> 30:16.670
sequenziell und jetzt müssen wir wahrscheinlich ein bisschen

30:16.670 --> 30:20.770
feinkranularer in diesen Algorithmus reingehen und uns die Elemente

30:20.770 --> 30:25.530
anschauen, die sich parallelisieren lassen und diese parallelisieren

30:25.530 --> 30:28.170
und die anderen vielleicht mit irgendwelchen Abhängigkeiten versehen.

30:28.250 --> 30:32.850
Und eine Möglichkeit, wie man das tun kann, ist beispielsweise, dass

30:32.850 --> 30:37.650
man sich ein temporäres Array hier anlegt, in das man die

30:37.650 --> 30:39.590
Zwischenergebnisse der Differenz speichert.

30:39.670 --> 30:43.190
Also die Idee hier ist, man speichert zunächst mal alle Differenzen,

30:43.710 --> 30:45.690
also f1 von i minus f2 von i.

30:45.890 --> 30:47.850
Das ist mal der erste Schritt, den wir auf jeden Fall brauchen.

30:48.410 --> 30:50.550
Das können wir ja trivial parallel machen.

30:50.670 --> 30:54.910
Ich lege hier einfach ein drittes Array sozusagen drunter, das die

30:54.910 --> 30:56.670
Differenzen aller Elemente aufnimmt.

30:56.670 --> 30:59.870
Das kann man tun, das ist auch trivial parallel und lässt sich

30:59.870 --> 31:01.870
unabhängig berechnen.

31:02.270 --> 31:02.890
Das kann ich ja machen.

31:03.630 --> 31:10.490
So, und dann kann ich den Diff berechnen.

31:10.630 --> 31:14.110
Ich kann also für jedes Element aus meinem Feld voller Differenzen,

31:14.310 --> 31:17.350
kann ich dieses Diff hier einmal durchschleifen.

31:18.150 --> 31:23.510
Wenn ich das blockweise mache, so wie in der Idee von eben, dann habe

31:23.510 --> 31:27.790
ich im zweiten, dritten und vierten Block wieder dieses Problem, dass

31:27.790 --> 31:30.970
ich den Übertrag aus dem ersten zum zweiten, den Übertrag aus dem

31:30.970 --> 31:34.770
zweiten zum dritten und so weiter nicht berücksichtigt habe.

31:35.970 --> 31:38.030
Das ist aber eine Konstantaddition.

31:38.210 --> 31:41.090
Ich bin ja nur um den, da ich bis jetzt nur eine Differenz und eine

31:41.090 --> 31:46.470
Addition gemacht habe, bin ich nur um einen festen Betrag in die

31:46.470 --> 31:47.310
Differenzen verschoben.

31:47.430 --> 31:48.370
Es war noch keine Abs drin.

31:48.370 --> 31:52.730
Ich könnte also, nochmal zusammengefasst, erstmal parallel die

31:52.730 --> 31:58.990
Differenzen berechnen und dann oder gleichzeitig das Diff blockweise

31:58.990 --> 32:05.830
berechnen und dann in den nachfolgenden Blöcken meine Differenzen um

32:05.830 --> 32:10.870
den Wert korrigieren, nach oben oder unten, den ich beim Übertrag

32:10.870 --> 32:12.390
nicht berücksichtigen konnte.

32:13.450 --> 32:18.270
Sind Sie bis dato, rein vom Verständnis her, noch bei mir?

32:20.330 --> 32:21.870
Okay, sehr schön, dann können wir weitermachen.

32:23.030 --> 32:24.490
Dann fehlt uns nur noch die Summe, ne?

32:25.130 --> 32:25.570
Genau.

32:26.630 --> 32:28.290
Glücklicherweise habe ich da was vorbereitet.

32:28.990 --> 32:31.550
Man kann nämlich hier, naja, jetzt muss man halt mit diesem

32:31.550 --> 32:37.490
Absolutwert über dieses Temporärfeld laufen und das aufsummieren.

32:39.490 --> 32:42.370
Das lässt sich bedingt parallelisieren.

32:42.650 --> 32:45.810
Sie können ja auch jetzt wieder über dieses Temporärfeld einfach

32:45.810 --> 32:50.010
blockweise parallel arbeiten, Teilsummen bilden und dann am Schluss

32:50.010 --> 32:50.950
die Teilsummen addieren.

32:51.050 --> 32:54.590
Also wenn Sie ein Feld, ein Array haben mit 64 Elementen, das können

32:54.590 --> 32:55.990
Sie mit 4 Fäden bearbeiten.

32:56.250 --> 33:00.570
Jeder Faden rechnet 8 Elemente zusammen und wenn diese 8 Fäden fertig

33:00.570 --> 33:02.990
sind, haben Sie 4 Teilsummen aus den 4 Blöcken.

33:02.990 --> 33:07.110
Die summieren Sie meinen Wegen noch sequenziell und dann sind Sie auch

33:07.110 --> 33:07.510
schon fertig.

33:07.750 --> 33:10.370
Ein bisschen eleganter wäre hier sowas wie eine Reduktion zu verwenden

33:10.370 --> 33:14.390
oder sowas, aber das ist letzten Endes nur eine Geschmacksrichtung

33:14.390 --> 33:16.390
dessen, dass Sie da parallel summieren.

33:34.360 --> 33:37.380
Hier kommen die Tone, lamentiert, aber ist das nicht furchtbar

33:37.380 --> 33:37.780
langsam?

33:38.740 --> 33:39.220
Komme ich dazu.

33:43.360 --> 33:47.580
Also, was ich Ihnen vorgestellt habe, ist das prinzipielle Problem.

33:47.580 --> 33:51.820
Sie brauchen da eine irgendwie geartete Zwischenspeicherung und die

33:51.820 --> 33:55.040
Sache ist die, jetzt kommt eine der Fallstricke, die da drin war.

33:55.840 --> 33:59.640
Die Felder, die wir Ihnen zur Initialisierung gegeben haben, die waren

33:59.640 --> 34:03.000
relativ groß, deutlich größer, als wir sie für die Bildähnlichkeiten

34:03.000 --> 34:03.820
eigentlich brauchen.

34:04.200 --> 34:06.280
Nämlich so im Millionenbereich.

34:08.140 --> 34:12.100
Und da kommen zum Beispiel folgende interessante Dinge zustande.

34:12.100 --> 34:16.000
Die Sache ist die, die Berechnungen, die Sie auf den Elementen machen,

34:16.480 --> 34:18.820
die sind einigermaßen simpel.

34:19.360 --> 34:22.240
Das sind simple Additionen und auch die Abs-Funktion ist sehr, sehr

34:22.240 --> 34:22.680
einfach.

34:23.440 --> 34:28.060
Was hier teuer ist in Java, ist das Allokieren von Speichern.

34:28.660 --> 34:32.740
Und wenn Sie, wie vorgeschlagen, dieses T allokieren, dann brauchen

34:32.740 --> 34:33.580
Sie sehr viel Zeit.

34:34.260 --> 34:35.340
Warum ist das so?

34:35.900 --> 34:40.780
Weil Java Ihnen zusichert, dass die Elemente in Ihrem Array null sind.

34:40.780 --> 34:46.780
Das heißt, wenn Sie ein 64 Millionen Array allokieren, auf diese Art

34:46.780 --> 34:50.940
und Weise hier, dann latscht Java einmal über alle 64 Millionen

34:50.940 --> 34:54.800
Elemente und setzt diese auf null, damit das auch schön sauber

34:54.800 --> 34:55.820
initialisiert ist.

34:56.540 --> 34:57.660
Das kostet Zeit.

34:58.400 --> 34:59.420
Das war sehr viel Zeit.

34:59.860 --> 35:02.760
Und zwar so viel Zeit, dass es Ihnen in aller Regel die

35:02.760 --> 35:05.300
Beschleunigung, die Sie möglicherweise durch eine solche

35:05.300 --> 35:09.040
Parallelisierung bekämen, im Regelfall wieder auffrisst.

35:10.100 --> 35:13.700
So, ich habe Ihnen mal ein paar Zahlen mitgebracht, was das eigentlich

35:13.700 --> 35:14.140
heißt.

35:15.180 --> 35:20.500
Normal heißt hier, Sie allokieren Speicher, wie Sie es gewohnt sind

35:20.500 --> 35:20.980
aus Java.

35:21.140 --> 35:22.720
Also einfach mit so einer Zeile hier.

35:23.840 --> 35:27.240
Und nur das schiere Allokieren von 64 Millionen Elementen in einem

35:27.240 --> 35:31.980
Beispiel hat auf unserer Testmaschine etwa 280 Millisekunden benötigt.

35:31.980 --> 35:36.820
Das ist aber eher so 0 Millisekunden für das Allokieren des Speichers

35:36.820 --> 35:42.420
und 279 Millisekunden für das Nullsetzen jedes einzelnen Elements.

35:43.320 --> 35:48.400
Man sieht das auch daran, wenn wir danach einmal nochmal schreibend

35:48.400 --> 35:54.760
durchlaufen, dann kostet das keine 290 Millisekunden mehr, weil dieses

35:54.760 --> 35:57.920
Feld schon im Zwischenspeicher ist, schon im Cache ist und wir daher

35:57.920 --> 35:59.240
uns ein bisschen Zeit ersparen.

35:59.240 --> 36:05.640
Was ich Ihnen gerne mitgeben möchte ist, es gibt in Java, kennen Sie

36:05.640 --> 36:11.060
Mythmasters, diese Serie, die am Anfang immer diesen Spoiler haben,

36:11.620 --> 36:14.920
machen Sie das ja nicht zu Hause, macht das ja nicht zu Hause, liebe

36:14.920 --> 36:17.960
Kinder, das ist gefährlich, hier sind Profis am Werk, die wissen, was

36:17.960 --> 36:18.680
sie tun und so.

36:19.900 --> 36:22.080
Das gilt für dieses Unsafe hier auch so.

36:22.400 --> 36:23.360
Don't do that at home.

36:24.020 --> 36:32.000
Es gibt in der Klassenbibliothek eine Möglichkeit, dass man diese

36:32.000 --> 36:36.900
Allokiersemantik ändert und sozusagen sich vom Garbage Collector

36:36.900 --> 36:40.440
verabschiedet und von dieser Nullsetzung verabschiedet und sich quasi

36:40.440 --> 36:41.840
C -Semantik reinholt.

36:42.840 --> 36:47.380
In C ist es so, dass Sie, wenn Sie Speicher allokieren, dass Sie den

36:47.380 --> 36:52.440
einfach instantan bekommen, dass es also sehr schnell geht, Sie haben

36:52.440 --> 36:55.220
aber dafür keine Initialisierung zugesichert, je nachdem, wie Sie es

36:55.220 --> 36:58.320
allokieren, aber im Regelfall haben Sie dort keine Initialisierung

36:58.320 --> 37:01.540
zugesichert und das Lustige ist, die brauchen wir ja auch gar nicht.

37:01.680 --> 37:06.140
Wir schreiben ja ausschließlich erstmal auf unser T, die bräuchten wir

37:06.140 --> 37:06.520
ja eigentlich nicht.

37:06.600 --> 37:09.480
Insofern könnten wir uns eigentlich diese Millisekunden hier sparen

37:09.480 --> 37:11.600
und ich habe es einfach mal ausprobiert, wie das ist.

37:12.300 --> 37:13.760
Ja, das funktioniert auch ganz gut.

37:14.420 --> 37:18.840
Wir haben dann halt eine Zu-Fuß-Speicherverwaltung am Bein.

37:18.960 --> 37:21.780
Die Frage ist, lohnt sich das für die Performance?

37:22.380 --> 37:23.700
Die Antwort ist nein.

37:24.120 --> 37:28.400
Weil wenn Sie anschließend dann schreibend über das zwar schnell

37:28.400 --> 37:35.640
allokierte Feld laufen und übrigens sich ziemlich viel Technik ans

37:35.640 --> 37:38.520
Bein binden, Sie müssen diesen Speicher zu Fuß indizieren und so, das

37:38.520 --> 37:44.500
ist alles sehr hässlich, dann sind Sie trotzdem noch langsamer als

37:44.500 --> 37:47.480
wenn Sie einfach, oder in einem ähnlichen Bereich, als wenn Sie

37:47.480 --> 37:52.700
einfach die Standard Garbage Collected Safe Normal Methode benutzt

37:52.700 --> 37:52.960
hätten.

37:53.700 --> 37:59.220
Das ist also auch hier leider nicht ganz die Lösung des Problems, denn

37:59.220 --> 38:00.380
das ist die Zahl, die zählt.

38:00.520 --> 38:01.620
Sie müssen ja schreibend durchlaufen.

38:02.920 --> 38:09.340
Die Frage ist also, kann man den Earth Movers Distance sinnvoll

38:09.340 --> 38:10.080
parallelisieren?

38:10.560 --> 38:12.640
Die Antwort ist vielschichtig.

38:13.240 --> 38:13.980
Ja, kann man.

38:14.640 --> 38:21.340
Aber es kommt darauf an, wie groß, es kommt darauf an, was für eine

38:21.340 --> 38:22.280
Maschine Sie haben.

38:23.320 --> 38:26.780
Sie alle, die meisten von Ihnen, und auch wir haben diese Tests auf

38:26.780 --> 38:31.980
Maschinen gefahren, in denen die Rechenleistung verhältnismäßig hoch

38:31.980 --> 38:34.980
ist im Vergleich zum Speicherdurchsatz.

38:35.500 --> 38:39.620
Das ist genau das, was uns hier die Geschwindigkeit kostet.

38:40.320 --> 38:47.720
Wir haben 264 Millionen Float-Elemente, zweimal lesend vom Speicher

38:47.720 --> 38:50.120
und einmal schreibend zum Speicher.

38:50.120 --> 38:53.220
Ein Float hat in Java vier Byte.

38:53.360 --> 38:56.500
Sie können sich also ausrechnen, wie viele Megabyte da durch den

38:56.500 --> 38:57.460
Speicherbus fließen.

38:57.920 --> 39:02.240
Und auf jedem dieser vier Bytes wird eine einigermaßen triviale

39:02.240 --> 39:04.320
Operation im Prozessor durchgeführt.

39:04.860 --> 39:08.560
Und die geht so schnell, dass der Speicherbus zum Engpass wird.

39:09.360 --> 39:13.540
Das führt dazu, dass Sie eine Beschleunigung bei der Parallelisierung

39:13.540 --> 39:19.640
nur dann in diesem Fall erreichen, wenn Sie den Cache effizient

39:19.640 --> 39:19.980
nutzen.

39:21.000 --> 39:24.180
Und von vorne nach hinten ein- oder mehrfach, was jetzt für die

39:24.180 --> 39:28.000
vorgestellte Variante notwendig wäre, von vorne nach hinten durch 64

39:28.000 --> 39:32.960
Millionen elementige Felder durchlaufen, ist nicht cache-freundlich.

39:33.700 --> 39:34.940
Warum ist das nicht cache-freundlich?

39:35.180 --> 39:36.980
Weil der Cache hat eine bestimmte Kapazität.

39:38.000 --> 39:43.440
Wenn aber Ihre Daten länger sind als diese Kapazität, dann laschen Sie

39:43.440 --> 39:47.600
von vorne einmal diesen Cache ab, dann haben Sie keine

39:47.600 --> 39:48.420
Wiederverwendung mehr.

39:48.520 --> 39:51.260
Sondern Sie machen hier weiter, dann ist wieder der Cache voll, dann

39:51.260 --> 39:52.920
ist wieder der Cache voll, dann ist wieder der Cache voll.

39:53.200 --> 39:55.180
Oh, ich muss ja nochmal durch meine Elemente durchlaufen.

39:55.700 --> 39:56.680
Aber die sind nicht mehr im Cache.

39:56.760 --> 39:58.680
Jetzt muss ich wieder von vorne beginnen und das wieder lesen.

39:59.240 --> 40:04.440
Sie können also nur dann Geschwindigkeitssteigerungen durch

40:04.440 --> 40:11.440
Parallelität herausholen, wenn Sie in den Größen bleiben, der Cache

40:11.440 --> 40:12.920
Ihnen ermöglicht.

40:13.820 --> 40:16.100
Nur so können Sie ein bisschen Performance herausholen.

40:16.800 --> 40:19.980
Das war ein bisschen fies, diese Aufgabe, denn Sie erreichen selbst

40:19.980 --> 40:27.240
auf 8 oder 12 Ternen, je nachdem nur ein Speedup von 1,3, 1,5 für die

40:27.240 --> 40:27.820
Größenordnung.

40:29.860 --> 40:31.920
Das war ein bisschen härter.

40:33.080 --> 40:39.400
Die Erkenntnis ist, Parallelisieren geht, Parallelisieren geht oft,

40:39.940 --> 40:42.700
Parallelisieren ist nicht immer einfach, wenn Sie Datenabhängigkeiten

40:42.700 --> 40:48.200
haben und der Engpass beim Parallelisieren ist nicht zwangsläufig der

40:48.200 --> 40:50.360
Prozessor, je nachdem, was Sie tun.

40:52.280 --> 40:53.780
Haben Sie Fragen dazu?

41:04.540 --> 41:07.920
Haben Sie das Gefühl, Sie haben das Problem, worum es geht,

41:08.420 --> 41:09.760
einigermaßen verstanden?

41:11.120 --> 41:12.420
Okay, das ist schön.

41:13.300 --> 41:16.320
Haben Sie das Gefühl, Sie haben aus dieser Aufgabe auch ein bisschen

41:16.320 --> 41:19.140
was gelernt, wenigstens durch die Präsentation?

41:21.020 --> 41:22.060
Okay, das ist schön.

41:22.880 --> 41:25.560
Dann sind wir, glaube ich, mit der Parallelitätsaufgabe...

41:25.560 --> 41:28.700
Wir hatten noch eine Möglichkeit, wie es doch einigermaßen flott geht,

41:29.400 --> 41:32.520
was du hier so hübsch als Alternative bezeichnet.

41:33.040 --> 41:33.440
Alternative?

41:33.740 --> 41:38.180
Ja, naja, wir brauchen ja das Eingabe-Array nicht mehr.

41:38.820 --> 41:39.720
Ah ja, richtig.

41:39.980 --> 41:43.300
Das war diese Sache, wir haben ja schon zwei Eingabe-Arrays, kann ich

41:43.300 --> 41:44.740
die denn nicht einfach missbrauchen?

41:46.020 --> 41:47.180
Na sicher kann ich das tun.

41:47.280 --> 41:51.200
Also die Idee dahinter ist, wir hatten ja dieses Array T, in dem wir

41:51.200 --> 41:54.580
die Zwischenergebnisse speichern, und wenn wir uns jetzt nicht mit

41:54.580 --> 41:57.760
dieser Cache-Optimiererei da beschäftigen wollen, dann wäre ja auch

41:57.760 --> 42:01.280
die Möglichkeit, ich benutze einfach die, die muss ich ja eh lesend

42:01.280 --> 42:05.260
laden, also ich lade immer zwei Elemente, addiere sie, diffe sie,

42:05.520 --> 42:08.540
absolviere sie, wie auch immer, und schreibe das Ergebnis einfach in

42:08.540 --> 42:11.360
ein Element der beiden Eingabe-Arrays wieder zurück.

42:11.960 --> 42:16.660
Das geht technisch, das können Sie tun, aber damit verändern Sie

42:16.660 --> 42:19.580
natürlich die Eingabe-Arrays als solche.

42:19.700 --> 42:21.780
Die Eingabedaten gehen dann verloren.

42:21.780 --> 42:26.160
Und im allgemeinen Fall ist das natürlich dann eine Semantikänderung

42:26.160 --> 42:27.040
Ihrer Funktion.

42:27.420 --> 42:31.600
Das heißt, wenn Sie als der Programmierer, der die Funktion

42:31.600 --> 42:36.440
programmiert, nicht wissen, ob der Aufrufer seine übergebenen

42:36.440 --> 42:40.780
Variablen vielleicht nochmal im Originalzustand braucht, dann pfuschen

42:40.780 --> 42:42.540
Sie den in die Daten und ins Handwerk.

42:43.140 --> 42:46.400
Und wenn Sie semantisch nicht vorher klargemacht haben, dass Sie

42:46.400 --> 42:51.880
Eingabevariablen, eigentlich Eingabevariablen, in der Funktion, in

42:51.880 --> 42:56.660
place, ändern, dann hat der Aufrufer wahrscheinlich damit ein Problem,

42:56.780 --> 42:58.520
dass seine übergebenen Variablen weg sind.

42:59.940 --> 43:03.840
Insofern, das in place würde Ihnen hier diese ganze Speichergeschichte

43:03.840 --> 43:09.660
ein bisschen entschärfen, die Cache-Geschichte bleibt aber, und Sie

43:09.660 --> 43:13.500
haben eine Semantikänderung, die Sie im allgemeinen Fall eigentlich

43:13.500 --> 43:16.740
nicht wollen, seien Sie haben sie eben vorhalb der Schnittstelle

43:16.740 --> 43:17.460
vereinbart.

43:18.280 --> 43:18.840
Okay.

43:20.660 --> 43:21.820
Dann, jetzt aber.

43:22.140 --> 43:23.400
Jetzt aber sind wir durch.

43:23.900 --> 43:24.560
Okay, sehr schön.

43:24.640 --> 43:26.260
Parallelität lohnt sich.

43:26.880 --> 43:27.240
Genau.

43:28.240 --> 43:28.500
Okay.

43:29.020 --> 43:29.400
Okay.

43:29.880 --> 43:33.680
Die letzte Aufgabe auf dem Übungsblatt war eine Bonusaufgabe, da

43:33.680 --> 43:35.980
sollten Sie UML nach Code abbilden.

43:37.160 --> 43:41.200
Schauen Sie es sich einfach im Quelltext an, von der Musterlösung, wie

43:41.200 --> 43:45.700
immer nicht sofort, sondern vielleicht morgen Mittag.

43:48.140 --> 43:52.140
Es macht wenig Sinn, das hier am Quelltext durchzuturnen, weil Sie

43:52.140 --> 43:54.160
ohnehin immer nur sehr wenig lesen können.

43:54.840 --> 43:57.000
Schauen Sie sich einfach an, wie die unterschiedlichen Arten

43:57.000 --> 43:57.820
implementiert sind.

43:57.980 --> 44:02.240
In der Musterlösung sind noch weitere Implementierungsbeispiele drin,

44:02.340 --> 44:03.640
als die, die wir gefordert hatten.

44:04.680 --> 44:07.420
Einfach mal einen Blick drauf werfen und sich überlegen, könnte ich

44:07.420 --> 44:11.740
das zum Beispiel in UML hinmalen in der Klausur in fünf Minuten.

44:12.740 --> 44:16.120
Das ist ungefähr so die Zeit, die Sie dafür hätten, wenn Sie einen

44:16.120 --> 44:19.920
Automaten kriegen und die Frage ist, wie macht man das denn in Java

44:19.920 --> 44:23.880
mit der expliziten ausgelagerten Speicherung.

44:25.120 --> 44:27.960
Haben Sie ungefähr fünf Punkte, vielleicht sechs, also fünf, sechs

44:27.960 --> 44:31.260
Minuten und dann ist die Aufgabe durch.

44:31.520 --> 44:33.200
Also einfach mal ausprobieren, ob Sie das hinbekommen.

44:34.320 --> 44:38.320
Und ja, diese Klausurfrage, das ist natürlich genau das, was in der

44:38.320 --> 44:39.360
letzten Übung gerne kommt.

44:39.360 --> 44:44.900
Matthias, Matthias, sag mal, was kommt eigentlich in der Klausur dran?

44:46.640 --> 44:47.140
Alles.

44:49.840 --> 44:51.760
Gibt es da nichts, was ich weglassen kann?

44:52.380 --> 44:52.880
Nee.

44:54.020 --> 44:56.340
Auch nicht vielleicht das, was unter Optionales ist?

44:56.800 --> 44:57.840
Das vielleicht schon, ja.

44:57.840 --> 44:58.960
Das vielleicht schon, okay.

45:00.180 --> 45:03.160
Also das, was unter Optionales steht, ist tatsächlich optional, ist

45:03.160 --> 45:04.340
für die Klausur nicht relevant.

45:04.520 --> 45:07.760
Wir werden Sie also nicht nach OCL abfragen und nach Java 2D.

45:08.780 --> 45:11.740
Davon abgesehen, könnte Sie aber alles treffen.

45:12.120 --> 45:18.500
Wenn in den Vorlesungsunterlagen eher so bla bla drin ist, sage ich

45:18.500 --> 45:22.720
mal abwertend, dann kommen natürlich dazu auch eher bla bla Fragen.

45:23.040 --> 45:27.540
Also nicht malen Sie ein Prozessmodell, sondern nennen Sie die sieben

45:27.540 --> 45:30.120
Stufen und die 43 Dokumente, die daraus fallen.

45:30.900 --> 45:33.340
Da muss man natürlich kein UML-Diagramm vom Wasserfall bauen.

45:34.200 --> 45:38.560
Bei den UML-Sachen muss man natürlich eher ein UML-Dokument malen.

45:38.900 --> 45:40.200
Wird die Klausur arg schwer?

45:40.600 --> 45:43.040
Das wird die schwerste Klausur, die wir jeweils gemacht haben.

45:44.520 --> 45:46.440
Und korrigieren wir arg hart?

45:47.060 --> 45:47.620
Gnadenlos.

45:48.420 --> 45:49.280
Wie immer.

45:50.040 --> 45:51.400
Und wie viele Punkte gibt es?

45:51.920 --> 45:53.060
Es gibt 60 Punkte.

45:53.960 --> 45:55.160
Und wie lange muss ich schreiben?

45:55.580 --> 45:56.160
Eine Stunde.

45:57.240 --> 46:00.540
Also daher auch die Sache, wenn Sie fünf Minuten für eine Aufgabe

46:00.540 --> 46:03.080
brauchen, dann sollten Sie da auch fünf Punkte für bekommen.

46:03.600 --> 46:06.940
Wenn in der Aufgabe steht, es gibt zwei, dann sollten Sie nach fünf

46:06.940 --> 46:09.420
Minuten vielleicht darüber nachdenken, etwas anderes zu machen, weil

46:09.420 --> 46:10.520
es lohnt sich schon nicht mehr.

46:13.260 --> 46:14.900
Danach die größere Frage.

46:15.040 --> 46:16.520
Mit wie vielen Punkten hat man dann bestanden?

46:17.280 --> 46:17.780
Keine Ahnung.

46:20.180 --> 46:23.360
Voraussichtlich mit irgendwas um die 20.

46:23.880 --> 46:25.460
Also 15 bis 25.

46:28.120 --> 46:31.660
Das können wir Ihnen nach der Klausur sagen.

46:36.540 --> 46:40.280
Als Klausurlerntipp möchte ich Ihnen gerne noch eine kleine Metapher

46:40.280 --> 46:40.820
erzählen.

46:41.460 --> 46:46.720
Wenn Sie jetzt hier säßen und stellen Sie sich vor, wir wollten Ihnen

46:46.720 --> 46:52.160
das Kochen beibringen, dann stellen Sie sich vor, dass Sie bitte nicht

46:52.160 --> 46:56.540
jetzt hergehen und auf chefkoch.de alle Rezepte auswendig lernen, die

46:56.540 --> 46:57.120
es da gibt.

46:58.240 --> 47:02.680
Sondern wir wollten Ihnen nicht zeigen, gucken Sie mal, hier gibt es

47:02.680 --> 47:04.960
178 Millionen Rezepte, die kann man auswendig lernen.

47:05.040 --> 47:08.200
Nein, wir wollten Ihnen zeigen, wie funktioniert ein Herd, wie

47:08.200 --> 47:11.800
funktioniert ein Topf, wie funktioniert ein Messer, wie schmeckt

47:11.800 --> 47:15.460
Gemüse und wie schmeckt Obst und welches Gewürz passt zu welchem

47:15.460 --> 47:16.840
Gemüse und welchem Obst.

47:17.320 --> 47:22.500
Und zu welchem Gericht Sie das jetzt verarbeiten, in Ihrem konkreten

47:22.500 --> 47:25.200
Fall, das bleibt Ihnen überlassen.

47:26.760 --> 47:30.100
Und wie so oft ist auch draußen in der Wirtschaft so, ob Ihrem Kunden

47:30.100 --> 47:34.540
das Gericht schmeckt, das entscheidet halt der Kunde.

47:35.800 --> 47:37.760
Sie müssen halt einfach so gut kochen, wie es irgendwie geht.

47:38.200 --> 47:41.920
Kochen Sie kreativ, kochen Sie gut, kochen Sie nett, nutzen Sie die

47:41.920 --> 47:42.700
Werkzeuge.

47:43.500 --> 47:48.780
Wenn Sie immer nur alles aufkochen und pürieren, werden Ihre Gerichte

47:48.780 --> 47:52.880
halt möglicherweise nach der Weile ein bisschen fad und Sie werden

47:52.880 --> 47:54.320
irgendwann Kunden verlieren.

47:55.120 --> 47:56.620
Dann kommt der Restaurantretter?

47:58.400 --> 47:59.700
Oder die Nachklausur?

48:00.060 --> 48:01.720
Da wollte ich jetzt nicht hin.

48:01.740 --> 48:02.940
Da wolltest Du nicht hin, okay.

48:03.680 --> 48:04.700
Die Superkochs.

48:05.140 --> 48:10.160
Genau, also lernen Sie so, dass Sie das Gefühl haben, Sie haben die

48:10.160 --> 48:12.480
Werkzeuge verstanden, das Prinzip verstanden.

48:12.620 --> 48:15.020
Sie wissen, wie ein Messer funktioniert, wie man es schleift und

48:15.020 --> 48:17.740
welche Länge von Messern man für welches Gemüse einsetzt.

48:18.800 --> 48:20.760
Nicht 178.000 Kochrezepte.

48:22.400 --> 48:22.620
Okay?

48:24.780 --> 48:26.160
Haben Sie Fragen zur Metapher?

48:33.310 --> 48:33.830
Okay.

48:35.510 --> 48:38.170
Dann sind wir für heute mit dem Übungsstoff durch.

48:38.250 --> 48:40.670
Wir haben aber noch ein bisschen Vorlesungsstoff für Sie.

48:41.230 --> 48:43.370
Das ist aber leichte Kost, Sie brauchen keine Angst haben.

48:54.140 --> 48:57.980
Wenn mich nicht alles täuscht, haben Sie diese Folie von Herrn Tichy

48:57.980 --> 48:59.060
schon gezeigt bekommen.

49:02.700 --> 49:05.380
Wenn nicht, dann ist das äußerst schade.

49:06.320 --> 49:08.040
Und dann müssen Sie es zu Hause nachlesen.

49:08.140 --> 49:11.260
Das gleiche gilt für die nächsten drei Folien, weil die sind nicht so

49:11.260 --> 49:13.020
super toll, interessant und lustig.

49:13.640 --> 49:16.800
Und wir fangen jetzt direkt an mit dieser Folie.

49:17.320 --> 49:20.620
Und Sie haben sich mit Professor Tichy mit Inspektionen und

49:20.620 --> 49:24.240
Lesetechniken und mit lauter solchen Offline-Sachen beschäftigt.

49:24.740 --> 49:26.820
Und wir haben gedacht, wir bringen Ihnen noch mal ein bisschen was

49:26.820 --> 49:27.360
online mit.

49:28.140 --> 49:31.060
Also Werkzeuge, die das Ganze ein bisschen leichter machen.

49:31.640 --> 49:34.940
Wie schon Unit-Tests zeigen, ist eigentlich so ein Entwicklungsprozess

49:34.940 --> 49:38.240
oder Schritte im Entwicklungsprozess sind eigentlich viel cooler, wenn

49:38.240 --> 49:40.780
man irgendetwas Technisches hat als Informatiker, an dem man sich

49:40.780 --> 49:41.580
festhalten kann.

49:42.000 --> 49:47.780
In den Unit-Tests haben Sie Programmquelltext geschrieben, um das

49:47.780 --> 49:48.740
Programm zu testen.

49:48.740 --> 49:51.820
Und wenn Sie jetzt hier für eine Inspektion noch ein technisches

49:51.820 --> 49:54.260
Werkzeug haben, das vielleicht schön integriert ist in den

49:54.260 --> 49:57.660
Entwicklungsprozess, das ist doch gleich viel attraktiver eigentlich.

49:57.940 --> 50:00.580
Wenn man was zum Tatteln hat, macht es gleich mehr Spaß.

50:00.640 --> 50:01.440
Macht es gleich mehr Spaß.

50:01.780 --> 50:03.780
Und deswegen haben wir uns gedacht, wir zeigen Ihnen mal ein, zwei

50:03.780 --> 50:07.760
Werkzeuge, die Inspektionen ein bisschen informatiktauglicher machen,

50:07.840 --> 50:11.720
indem Sie einfach so ein bisschen technisches Gedöns zur Inspektion

50:11.720 --> 50:12.380
hinzufügen.

50:12.820 --> 50:18.440
Und das können Sie prozessmäßig im Wesentlichen von der Werkzeugseite

50:18.440 --> 50:20.280
her auf zwei Arten und Weisen machen.

50:20.580 --> 50:25.200
Das eine ist, Sie integrieren die Inspektion, das Review, in den

50:25.200 --> 50:27.400
Entwicklungsprozess selbst.

50:28.040 --> 50:30.960
Das ist, glaube ich, das andere Beispiel, das kommt danach.

50:33.620 --> 50:37.420
Aber das hier ist die Methode, Sie haben Ihren ganz normalen

50:37.420 --> 50:41.080
Entwicklungsprozess, das heißt, Sie checken was aus, Sie entwickeln

50:41.080 --> 50:45.820
was, Sie buchen es wieder ein, Sie kommitten das Ganze und dann hängt

50:45.820 --> 50:49.140
irgendwo in Ihrem Versionskontrollsystem vielleicht ein hübsches

50:49.140 --> 50:52.880
Webfrontend, das Ihnen die Commits aus dem Versionskontrollsystem

50:52.880 --> 50:57.640
wieder schön darstellt und dann kann man in diesem Webfrontend an die

50:57.640 --> 51:01.920
Commits noch irgendwelche Metadaten dran pappen, wie zum Beispiel

51:01.920 --> 51:02.880
Kommentare.

51:03.140 --> 51:05.780
Andere Entwickler können einfach einen Commit kommentieren und sagen,

51:06.180 --> 51:08.000
der Quelltext hat mir aber sehr gut gefallen.

51:08.260 --> 51:12.880
Oder die Übergabe der Parameter funktioniert zwar so, ist aber eine

51:12.880 --> 51:16.100
Sicherheitslücke, an der Stelle können wir das nicht so und so machen

51:16.100 --> 51:18.000
und einen Änderungsvorschlag bringen.

51:18.520 --> 51:22.640
Dann kann man zu einem Commit eben eine verbesserte Version einpflegen

51:22.640 --> 51:24.440
und die erscheint dann eben dort auch.

51:24.980 --> 51:28.820
Außerdem kann man bei einer Inspektion eben auch Bewertungen

51:28.820 --> 51:33.620
verteilen, wie gut der Quelltext ist, der da inspiziert wurde.

51:34.020 --> 51:37.880
Also bin ich als Entwickler, der den Code eines anderen Entwicklers

51:37.880 --> 51:42.160
inspiziert, würde ich diesen Code jetzt freigeben wollen für den

51:42.160 --> 51:42.520
Kunden?

51:42.620 --> 51:43.500
Ist das okay so?

51:43.640 --> 51:45.580
Oder hat Matthias vielleicht missprogrammiert?

51:45.960 --> 51:49.000
Und dann kann ich in dem Review-Werkzeug auf den Knopf drücken und

51:49.000 --> 51:52.200
sagen, ja, also die Änderungen, die er da jetzt eingebucht hat, das

51:52.200 --> 51:54.240
ist okay, die geben wir an den Kunden frei.

51:56.620 --> 51:59.780
Da ich ja keinen missbaue, Thomas aber schon, wie ich das aber vorher

51:59.780 --> 52:04.020
wusste, kann man natürlich, also hier ist es optional, er bucht es ein

52:04.020 --> 52:05.120
und es ist direkt sichtbar.

52:05.300 --> 52:07.900
Also alle anderen leiden direkt unter dem, was er da verbrochen hat

52:08.340 --> 52:11.440
und können sich dann hinterher in dem Inspektionswerkzeug beschweren.

52:11.900 --> 52:13.980
Jetzt bin ich sein Chef und sage, ich sag Käse.

52:14.260 --> 52:17.720
Wenn die eh immer nur alle meckern, dann machen wir das einfach mal

52:17.720 --> 52:18.300
verpflichtend.

52:18.460 --> 52:19.220
Das ist die Alternative.

52:20.700 --> 52:25.580
Thomas darf zwar auschecken, er darf programmieren und darf das dann

52:25.580 --> 52:30.360
einchecken, aber eben nicht ins Versionskontrollsystem, sondern in das

52:30.360 --> 52:31.640
Inspektionswerkzeug.

52:31.640 --> 52:35.240
Das heißt, irgendwo poppt dann ein Fenster auf und sagt, ja der

52:35.240 --> 52:39.580
Thomas, der hat da mal wieder was programmiert, soll mal besser einer

52:39.580 --> 52:39.960
angucken.

52:41.240 --> 52:42.280
Genau das passiert dann.

52:43.080 --> 52:46.460
Der Prozess ist jetzt so gebaut, Sie dürfen quasi als Entwickler nicht

52:46.460 --> 52:50.600
direkt in das Versionskontrollsystem einbuchen, das nachher für

52:50.600 --> 52:56.300
offizielle Versionen des Programms verwendet wird, sondern Sie buchen

52:56.300 --> 52:58.160
in das Inspektionswerkzeug ein.

52:58.160 --> 53:02.240
Im konkreten Fall Gerrit ist das tatsächlich einfach ein Git nach

53:02.240 --> 53:05.940
außen, Sie buchen also einfach per Git ganz normal Ihre Änderungen in

53:05.940 --> 53:06.660
das Gerrit rein.

53:07.280 --> 53:11.400
Und der Witz ist jetzt, Gerrit nimmt Ihren Commit und stellt den jetzt

53:11.400 --> 53:15.340
auch, wie die anderen Werkzeuge, auf einer Weboberfläche dar und

53:15.340 --> 53:19.220
erfordert jetzt, das ist jetzt konfigurierbar, verschiedene Aktionen

53:19.220 --> 53:23.960
an diesem Commit, bevor Gerrit diesen Commit dann weitergibt an das

53:23.960 --> 53:25.360
echte Versionskontrollsystem.

53:26.140 --> 53:31.160
Und das ist eine Art der, wie soll ich sagen, der Commit-Hürde, wenn

53:31.160 --> 53:31.780
Sie so wollen.

53:32.720 --> 53:36.320
Sie programmieren etwas, Sie buchen etwas in Gerrit ein.

53:36.740 --> 53:41.780
In Gerrit ist dann hinterlegt, dass zwei andere Entwickler Ihren Patch

53:41.780 --> 53:45.520
da irgendwie genehmigen müssen und erst wenn zwei andere Entwickler

53:45.520 --> 53:49.440
meinetwegen gesagt haben, ja, Ihre Änderung ist okay, dann fließt sie

53:49.440 --> 53:54.080
ins tatsächliche offizielle Repository von Git oder so.

53:54.380 --> 53:56.360
Das wäre eine Möglichkeit, wie man das gestalten kann.

53:56.980 --> 54:00.020
Übrigens ist das auch eine schöne Variante, die Gerrit Leute sagen

54:00.020 --> 54:04.540
selbst, so kann man relativ leicht bei irgendwelchen

54:04.540 --> 54:07.820
Softwareprojekten, die Open Source sind oder sowas, einfach Änderungen

54:07.820 --> 54:09.340
der großen Masse annehmen.

54:09.500 --> 54:13.720
Sie können ja einfach jeden Wild in das Gerrit buchen lassen und Sie

54:13.720 --> 54:16.420
als Kernentwickler gucken sich die Änderungen an und entscheiden dann,

54:16.520 --> 54:19.340
na, das war Quatsch oder diese Änderung war okay und dann übernehmen

54:19.340 --> 54:23.060
Sie diese Änderungen von Ihrem Git, ohne dass Sie Ihr hochheiligstes

54:23.060 --> 54:26.780
Git an irgendwelche fremden Leute zum Schreiben exponiert haben.

54:27.420 --> 54:29.820
Eine Möglichkeit, einfach Inspektion zu nutzen.

54:31.240 --> 54:31.420
Genau.

54:31.840 --> 54:32.700
Wie sieht es jetzt aus?

54:35.580 --> 54:40.180
Das ist ein Werkzeug, das sich als Eclipse-Plugin tarnt.

54:40.680 --> 54:43.480
Sie haben ja also einen Eclipse-Schirm, was die Details machen, ist ja

54:43.480 --> 54:44.260
nicht so dramatisch.

54:44.320 --> 54:48.140
Der Punkt ist, Sie haben in der Mitte Ihren Quelltext-Editor, der wird

54:48.140 --> 54:51.780
erweitert um Markierungen, hier zum Beispiel das Blaue oder das Rote,

54:52.200 --> 54:58.040
zu einer Markierung gibt es hier rechts ein Kommentarfeld, wo also ein

54:58.040 --> 55:02.200
Inspektor, ein Reviewer hier oben seine Kommentare hinzugeben kann und

55:02.200 --> 55:05.720
eben sagen kann, naja, dieser Abschnitt, der ist eben nicht so hübsch

55:05.720 --> 55:08.020
oder da ist irgendwie ein Fehler drin oder sowas.

55:08.460 --> 55:12.240
Hier unten haben Sie noch die Liste dieser hinzugefügten Kommentare

55:12.240 --> 55:18.020
zum Quelltext und das heißt Agile Review hier und dieses Werkzeug

55:18.020 --> 55:22.900
bucht einfach die Kommentare und Metainformationen, die zur Inspektion

55:22.900 --> 55:26.620
gehören, einfach zum Projekt in die Versionskontrolle einfach mit ein.

55:27.160 --> 55:27.540
Fertig.

55:28.680 --> 55:31.320
Das ist eines der Werkzeuge aus der ersten Kategorie.

55:31.680 --> 55:36.220
Sie haben Metadaten beim Projekt dabei, die können Sie nutzen, müssen

55:36.220 --> 55:38.760
Sie aber nicht von technischer Seite her.

55:39.060 --> 55:41.100
Möglicherweise ist es organisatorisch durchgesetzt.

55:43.660 --> 55:43.800
Genau.

55:44.180 --> 55:44.440
Blabla.

55:46.080 --> 55:48.220
Gerrit, das hatte ich Ihnen schon gesagt.

55:48.600 --> 55:51.200
Zu Gerrit haben wir kein Foto mehr.

55:51.300 --> 55:51.720
Doch.

55:52.200 --> 55:52.760
Willst du sehen?

55:53.520 --> 55:54.600
Gib mir mal das Gerrit-Foto.

55:54.740 --> 55:55.640
Wollen Sie sie auch sehen?

55:58.500 --> 55:59.740
Ja, einer hat...

56:01.120 --> 56:02.900
Auch nicht viel übersichtlicher.

56:04.400 --> 56:05.700
Ist ein Webfrontend.

56:06.580 --> 56:08.620
Hier oben haben Sie die Daten zu dem Commit.

56:10.200 --> 56:15.620
Die Informationen, die hier stehen, die haben Sie mit Git in Gerrit

56:15.620 --> 56:16.680
gepusht.

56:18.100 --> 56:20.640
Und hier oben stehen jetzt die Daten zu dem Commit.

56:21.180 --> 56:24.360
In diesem Feld hier stehen die Inspektoren, die Reviewer.

56:24.680 --> 56:29.520
Je nach Konfiguration von Gerrit sind da Zwangseinträge drin oder der

56:29.520 --> 56:31.900
Einbucher kann da selbst Reviewer benennen.

56:32.540 --> 56:36.980
In diesem speziellen Fall ist übrigens der Hudson ein Inspektor.

56:37.080 --> 56:39.320
Der taucht doch hier unten bei den Kommentaren wieder auf.

56:40.000 --> 56:41.120
Matthias, was ist denn Hudson?

56:42.380 --> 56:43.020
Ein Hudson?

56:44.520 --> 56:46.020
Fluss in New York?

56:47.980 --> 56:48.540
Auch.

56:48.800 --> 56:50.180
Ne, aber das hier.

56:51.780 --> 56:53.380
Hudson ist ein Build-Server.

56:54.380 --> 56:57.220
Der macht nichts anderes als immer bei der Versionskontrolle

56:57.220 --> 56:57.760
nachfragen.

56:57.980 --> 56:58.720
Gibt's denn was Neues?

56:58.720 --> 56:59.540
Gibt's denn was Neues?

57:00.960 --> 57:04.140
Und wenn es mal was Neues gibt, dann holt er sich das unübersetztes

57:04.140 --> 57:07.520
und dann kann man noch verschiedene andere Werkzeuge daran schließen.

57:07.940 --> 57:11.320
Der kann zum Beispiel die Testfälle automatisch laufen lassen.

57:11.600 --> 57:12.560
Wofür brauchen wir die Testfälle?

57:13.260 --> 57:18.720
Und wenn dann ein Testfall fehlschlägt aufgrund eines Commits, dann

57:18.720 --> 57:21.920
steht das natürlich im Webfrontend drin.

57:22.200 --> 57:27.140
Dieser Commit führt dazu, dass Test XYZ nicht mehr durchläuft.

57:27.200 --> 57:27.740
Also Beispiel.

57:28.280 --> 57:29.380
Ich programmiere etwas.

57:30.440 --> 57:33.360
Meine Programmierung, mein Stückchen, was ich jetzt geändert habe,

57:33.420 --> 57:34.640
meinen Quelltext, buche ich ein.

57:34.920 --> 57:35.920
Dann landet es in Gerrit.

57:36.360 --> 57:39.160
In Gerrit ist hinterlegt, dass alle Änderungen einmal durch den Hudson

57:39.160 --> 57:39.680
durch müssen.

57:40.020 --> 57:43.700
Der Hudson hängt also mit seinem Schnorchel an Gerrit und stellt fest,

57:43.800 --> 57:45.180
oh, da ist eine frische Änderung.

57:45.500 --> 57:49.320
Er lädt sich mein Zeug runter, lässt alle Unit-Tests laufen.

57:49.780 --> 57:51.160
Laufen die alle grün durch?

57:51.640 --> 57:52.220
Daumen hoch.

57:52.220 --> 57:54.800
Dann hat er vielleicht noch weitere Tests, wie zum Beispiel

57:55.260 --> 57:55.720
Checkstyle.

57:56.180 --> 58:00.760
Entspricht das, was ich da geschrieben habe, den allgemeinen Code

58:00.760 --> 58:02.100
-Conventions des Projekts.

58:02.420 --> 58:03.620
Läuft meinetwegen grün durch?

58:03.800 --> 58:04.240
Alles klar.

58:04.980 --> 58:07.260
Dann habe ich vielleicht noch ein MA hintendran, das mir irgendwie

58:07.260 --> 58:09.240
Testabdeckung der Unit-Tests analysiert.

58:09.380 --> 58:13.480
Habe ich mindestens 85% Testabdeckung auch in dem Code, den ich gerade

58:13.480 --> 58:14.300
eingebucht habe?

58:14.760 --> 58:16.060
Alles klar, grün.

58:16.480 --> 58:19.000
Und wenn alle diese Dinge, die ich in Hudson konfigurieren kann, diese

58:19.000 --> 58:22.600
automatischen Prüfungen über meinen Quelltext gelaufen sind, dann

58:22.600 --> 58:26.820
macht der Hudson hier oben einen grünen Haken hin bei Verified und

58:26.820 --> 58:31.200
sagt, alles klar, die Änderung von Herrn Karcher, die darf hier

58:31.200 --> 58:34.640
durchgehen, bezogen auf die formalen Prüfungen, die der Hudson da

58:34.640 --> 58:34.900
macht.

58:36.720 --> 58:36.920
Genau.

58:38.880 --> 58:41.600
Was gibt es hier noch mit der restlichen Metainformation?

58:41.820 --> 58:44.820
Man kann halt auch zu Fuß irgendwelche Kommentare einpflegen und

58:44.820 --> 58:46.920
irgendwelche Abhängigkeiten einpflegen und sowas.

58:47.760 --> 58:51.300
Und der Punkt ist, wenn ausreichend Reviewer, alles konfigurierbar,

58:51.380 --> 58:53.760
bla bla, eben gesagt haben, jawohl, die Änderung von Herrn Karcher,

58:53.800 --> 58:56.720
die ist durch den Hudson durch, ich finde die auch okay, wir können

58:56.720 --> 58:59.140
die funktional brauchen, die sieht auch hübsch aus, es gibt keine

58:59.140 --> 59:01.820
Sicherheitsbedenken oder sowas, dann drücken Sie auf den Knopf,

59:02.580 --> 59:04.520
genehmigt, dann wandert das durch.

59:06.020 --> 59:08.420
Okay, damit sind wir, glaube ich, mit den Review-Werkzeugen an der

59:08.420 --> 59:09.820
Stelle durch.

59:10.020 --> 59:13.040
Das ist alles, was ich Ihnen auch schon mündlich gesagt habe.

59:13.600 --> 59:18.500
Und dann kommen wir so langsam zu den Prüfprogrammen.

59:19.380 --> 59:19.860
Kommen wir zu Ihnen?

59:21.220 --> 59:26.460
Genau, das eine Prüfprogramm, was Sie schon kennen, ist das

59:26.460 --> 59:28.480
Checkstyle, das setzen Sie schon ein und verwenden Sie.

59:28.720 --> 59:30.800
Es gibt natürlich jede Menge andere Prüfprogramme, die Sie

59:30.800 --> 59:33.260
automatisiert auf den Quelltext ansetzen könnten.

59:33.820 --> 59:37.440
Es gibt eine ganze Reihe von Fehlersuchprogrammen, die Sie da benutzen

59:37.440 --> 59:41.220
können oder noch mehr Prüfprogramme?

59:42.480 --> 59:48.100
Ich spick mal sowas oder sowas oder sowas.

59:48.580 --> 59:52.160
Ja genau, das sind alles Dinge, die Sie automatisch mit statischer

59:52.160 --> 59:55.320
oder dynamischer Analyse finden können, wie zum Beispiel, Sie haben

59:55.320 --> 59:58.520
aus Versehen einen Quelltext geschrieben, der nicht mehr erreichbar

59:58.520 --> 01:00:01.720
ist, den kann man also rausmachen, solche Dinge.

01:00:04.800 --> 01:00:08.900
Die kann man teilweise eben auch einfach in diesen Hudson einpflegen

01:00:08.900 --> 01:00:13.740
und der lehnt beispielsweise dann Ihre Einbuchung ab in Gerrit, wenn

01:00:13.740 --> 01:00:17.780
Sie gewisse Voraussetzungen nicht erfüllt haben, die das Projekt eben

01:00:17.780 --> 01:00:18.460
einfach durchsetzt.

01:00:22.120 --> 01:00:24.580
Dann schauen wir uns doch mal die Integrationstests an.

01:00:24.940 --> 01:00:26.800
Was sind Integrationstests?

01:00:28.600 --> 01:00:33.140
Na ja, Integrationstests sind die nächsthöhere Stufe in der

01:00:33.140 --> 01:00:36.680
Granularität und dafür ist natürlich erforderlich, dass Sie die

01:00:36.680 --> 01:00:39.040
Komponenten schon mal getestet haben.

01:00:40.040 --> 01:00:43.200
Bei Integrationstests können Sie, wir kommen gleich dazu, auf

01:00:43.200 --> 01:00:46.000
unterschiedliche Art und Weisen die verschiedenen Einzelkomponenten

01:00:46.000 --> 01:00:51.940
des Systems Stück für Stück zu einem Gesamtsystem zusammenklappen und

01:00:51.940 --> 01:00:57.880
das Zusammenspiel der Komponenten testen und dafür gibt es, wir haben

01:00:57.880 --> 01:01:00.280
uns mal so eine Matrix ausgedacht, die sieht ungefähr so aus.

01:01:01.200 --> 01:01:06.280
Sie können also entweder vorgehensorientiert oder testzielorientiert

01:01:06.280 --> 01:01:07.420
Integrationstesten.

01:01:08.080 --> 01:01:09.680
Wir sagen Ihnen gleich, was das ist.

01:01:09.980 --> 01:01:15.380
Oder Sie können inkrementell integrieren oder eben unmittelbar.

01:01:15.720 --> 01:01:18.400
Das ist eigentlich meiner Meinung nach die wichtigere Unterscheidung.

01:01:18.740 --> 01:01:22.280
Bei inkrementell fügen Sie Komponente für Komponente zusammen und

01:01:22.280 --> 01:01:24.960
gucken dann, wie das Zusammenspiel funktioniert und können immer Stück

01:01:24.960 --> 01:01:26.100
für Stück das Ganze testen.

01:01:27.060 --> 01:01:31.340
Unmittelbar ist, ich glaube, der Begriff Big Bang trifft die

01:01:31.340 --> 01:01:36.220
Vorgehensweise hier auch ganz gut, also Sie integrieren erstmal alles

01:01:37.080 --> 01:01:40.060
und Big Bang trifft es an der Stelle im Sinne von, dann muss alles

01:01:40.060 --> 01:01:42.560
gehen, aber es könnte halt auch sein, dass alles in die Luft fliegt.

01:01:44.940 --> 01:01:46.240
Was bedeuten die einzelnen Dinge?

01:01:47.340 --> 01:01:48.040
Ah ja, hier haben wir es nochmal.

01:01:48.860 --> 01:01:52.260
Sie haben die Sache, Sie müssen alle Systemkomponenten fertig haben,

01:01:52.360 --> 01:01:55.920
Sie können also schlecht teilintegrieren, wenn es unmittelbar komplett

01:01:55.920 --> 01:02:01.520
ist und Sie haben Schwierigkeiten, wenn Sie Testüberdeckung oder

01:02:01.520 --> 01:02:04.280
Defektlokalisierung betreiben wollen, weil das ganze System

01:02:04.280 --> 01:02:06.260
funktioniert ja oder nicht.

01:02:09.800 --> 01:02:11.600
Alternativ machen Sie es eben Stück für Stück.

01:02:12.020 --> 01:02:14.780
Sie testen einfach die fertigen Komponenten, soweit sie vorhanden

01:02:14.780 --> 01:02:14.980
sind.

01:02:15.300 --> 01:02:20.280
Das hat auch den Vorteil, Sie können den Integrationstest für

01:02:20.280 --> 01:02:23.740
Komponenten beginnen, obwohl andere Komponenten vielleicht noch gar

01:02:23.740 --> 01:02:24.660
nicht fertiggestellt sind.

01:02:24.660 --> 01:02:27.660
Sie haben da also eine etwas zeitlichere Flexibilität und

01:02:27.660 --> 01:02:28.820
Überschneidung möglicherweise.

01:02:30.380 --> 01:02:34.680
Einen kleinen Nachteil gibt es allerdings, wenn Sie Abhängigkeiten

01:02:34.680 --> 01:02:38.680
haben in einem Modul, in irgendeiner Komponente auf etwas, was noch

01:02:38.680 --> 01:02:42.020
nicht fertig ist, dann brauchen Sie unter Umständen einen Testhelfer,

01:02:42.140 --> 01:02:45.340
der eben so tut, als wäre diese Komponente, die Sie brauchen.

01:02:45.980 --> 01:02:48.560
Sie haben also unter Umständen da unten ein bisschen mehr Testarbeit,

01:02:48.740 --> 01:02:51.780
weil Sie noch Mockups schreiben müssen für Code, der eben noch nicht

01:02:51.780 --> 01:02:52.300
fertig ist.

01:02:52.540 --> 01:02:56.040
Ja, weil möglicherweise eine Komponente, irgendeine andere Komponente

01:02:56.040 --> 01:02:58.320
braucht, die aber noch nicht fertig ist, dann muss ich die halt

01:02:58.320 --> 01:03:00.020
irgendwie simulieren oder so.

01:03:01.400 --> 01:03:04.000
Dafür muss ich dann ein bisschen zusätzlichen Code schreiben, um den

01:03:04.000 --> 01:03:07.340
Simulant zum Testen zu benutzen, der echten fertigen Komponent.

01:03:07.780 --> 01:03:11.140
Hat aber auch den Vorteil, wenn man zum Beispiel eine Abhängigkeit hat

01:03:11.140 --> 01:03:15.260
von einer Datenbank, dann will man nicht jedes Mal die große Oracle-12

01:03:15.260 --> 01:03:19.460
-Datenbank mit 84 GB Daten befüllen, um testen zu können, sondern

01:03:19.460 --> 01:03:23.420
vielleicht will man genau dafür ohnehin einen Mock schreiben, der nur

01:03:23.420 --> 01:03:26.060
ein paar Dummy-Daten zurückliefert, ohne Datenbank-Anbindung.

01:03:26.960 --> 01:03:29.260
Also Vorteil und Nachteil zugleich.

01:03:32.480 --> 01:03:36.020
Die Kategorisierung vorgehensorientiert oder testzielorientiert ist so

01:03:36.020 --> 01:03:38.060
ein bisschen, wie akademisch Sie vorgehen möchten.

01:03:38.720 --> 01:03:42.080
Bei der vorgehensorientierten gehen Sie etwas akademischer vor,

01:03:42.160 --> 01:03:44.920
nämlich so, wie Sie sich das System ausgedacht haben, wie die

01:03:44.920 --> 01:03:49.120
Architektur, wie Sie sich als Modell zurechtgelegt haben, Ihnen das

01:03:49.120 --> 01:03:49.700
diktiert.

01:03:50.640 --> 01:03:57.000
Und bei der testzielorientierten Integrationstesterei gehen Sie eben

01:03:57.000 --> 01:04:01.320
von Testzielen aus, die Ihnen möglicherweise von Ihrem Projektleiter

01:04:01.320 --> 01:04:04.880
oder von wem auch immer gesetzt werden und Sie schauen halt, dass Sie

01:04:04.880 --> 01:04:09.220
diese Testziele erfüllen, statt akademisch Ihr Modell zu befolgen.

01:04:09.940 --> 01:04:11.660
So, und was bedeuten jetzt die Begriffe im Einzelnen?

01:04:11.820 --> 01:04:15.700
Ja, das Big Bang hatten wir schon, das ist so die Kernaussage, es geht

01:04:15.700 --> 01:04:21.160
nichts, bis schließlich alles geht, mit ein paar Nachteilen behaftet.

01:04:22.000 --> 01:04:28.120
Ja, dann können Sie geschäftsprozessorientiert testen, das heißt, das

01:04:28.120 --> 01:04:30.940
ist natürlich testzielorientiert, weil das Testziel hier sozusagen

01:04:30.940 --> 01:04:36.000
inherent ist, ich möchte einen bestimmten Geschäftsvorfall testen

01:04:36.000 --> 01:04:39.480
können, von vorne nach hinten, und dann gehen Sie eben

01:04:40.500 --> 01:04:44.020
geschäftsprozessorientiert an die Testerei ran und prüfen eben die

01:04:44.020 --> 01:04:46.020
Geschäftsvorfälle der Reihe nach, ob sie funktionieren.

01:04:49.160 --> 01:04:56.540
Funktionsorientiert heißt, Sie bündeln Ihre fertigen Komponenten so

01:04:56.540 --> 01:05:01.180
zusammen, dass Sie die funktionalen Anforderungen zusammengefasst

01:05:01.180 --> 01:05:05.560
haben und testen die der Reihe nach, oder Sie gehen halt einfach, so

01:05:05.560 --> 01:05:08.900
schnell Ihre Programmierer halt programmieren können und testen, was

01:05:08.900 --> 01:05:09.500
fertig wurde.

01:05:09.500 --> 01:05:13.740
Das ist möglicherweise auch suboptimal aus Sicht des Testers, könnte

01:05:13.740 --> 01:05:14.940
aber zeitlich einen Vorteil.

01:05:17.580 --> 01:05:22.000
Alternativ können Sie diese berühmten Top-Down, Bottom-Up, Inside-Out

01:05:22.000 --> 01:05:25.640
und so weiter Vorgehensweisen machen, da geht es lediglich darum, wie

01:05:25.640 --> 01:05:27.660
Sie an die Komponenten herangehen.

01:05:28.680 --> 01:05:32.960
Bei Top-Down gehen Sie einfach logisch von der obersten Ebene her und

01:05:32.960 --> 01:05:38.680
versuchen, von der abstrakten Ebene nach unten sich die

01:05:38.680 --> 01:05:41.540
Testkomponenten zusammenzustöpseln.

01:05:42.620 --> 01:05:45.740
Und bei Bottom-Up machen Sie das eben genau umgekehrt.

01:05:49.030 --> 01:05:52.710
Das sind natürlich die beiden gegenläufigen Aufbauzeiten.

01:05:54.110 --> 01:05:59.010
Inside-Out und Outside-In ist sozusagen der Kompromiss aus Bottom-Up

01:05:59.010 --> 01:06:01.390
und Top-Down, also wenn Sie Bottom-Up und Top-Down machen, dann haben

01:06:01.390 --> 01:06:05.510
Sie ja so eine Art Komponentenbaum mit den Vor- und Nachteilen, je

01:06:05.510 --> 01:06:08.670
nachdem von welcher Seite Sie an den Baum rangehen.

01:06:09.010 --> 01:06:11.450
Wenn Sie Inside-Out oder Outside-In machen, dann versuchen Sie, diese

01:06:11.450 --> 01:06:14.750
Nachteile dadurch ein bisschen zu entschärfen, dass Sie halt irgendwo

01:06:14.750 --> 01:06:18.190
in der Mitte anfangen und dann halt von einer möglicherweise sehr

01:06:18.190 --> 01:06:21.890
zentralen Komponente nach außen laufen oder von außen eben das Gesamte

01:06:21.890 --> 01:06:28.050
so Stück für Stück nach innen aufbauen und die beiden Ansätze eben

01:06:28.050 --> 01:06:29.290
aufeinander zulaufen lassen.

01:06:29.450 --> 01:06:32.170
Also die beiden Ansätze Top-Down oder Bottom-Up.

01:06:32.170 --> 01:06:36.470
Hardest-First ist davon eigentlich nur noch eine Geschmacksrichtung

01:06:36.470 --> 01:06:40.070
sozusagen bezogen auf dessen, was möglicherweise das Inside ist.

01:06:42.350 --> 01:06:46.570
Ja, das war's.

01:06:46.890 --> 01:06:49.730
Wenn wir gut integriert haben, haben wir hinterher ein System.

01:06:50.730 --> 01:06:51.910
Das können wir natürlich auch wieder testen.

01:06:51.930 --> 01:06:54.910
Jetzt haben wir hoffentlich ein lauffähiges System und das können wir

01:06:54.910 --> 01:06:57.450
jetzt als System testen.

01:07:00.180 --> 01:07:00.660
Magst du?

01:07:00.660 --> 01:07:02.160
Kann ich gerne.

01:07:03.460 --> 01:07:06.940
Im Wesentlichen geht man dann von ganz außen vor.

01:07:07.040 --> 01:07:09.440
Das ist also Top-Top-Top-Top-Top-Down.

01:07:10.400 --> 01:07:13.380
Man guckt sich einfach das Gesamtsystem an, wie man das fertig gebaut

01:07:13.380 --> 01:07:16.540
hat und wie es ursprünglich spezifiziert wurde und testet es einfach

01:07:16.540 --> 01:07:17.320
mal als Blackbox.

01:07:17.520 --> 01:07:21.940
Also quasi aus Sicht des Benutzers oder wenn man irgendeinen Dienst

01:07:21.940 --> 01:07:24.440
hat, dann eben aus Sicht eines Dienstnehmers.

01:07:25.400 --> 01:07:29.200
Und man versucht eine möglichst realistische Umgebung dafür zu haben.

01:07:29.200 --> 01:07:33.580
Also idealerweise nimmt man echte Daten und auch die richtigen Geräte,

01:07:33.740 --> 01:07:34.640
die dafür benutzt werden.

01:07:34.780 --> 01:07:38.340
Also macht es nicht auf dem Entwickler-PC, sondern am besten auf der

01:07:38.340 --> 01:07:40.020
Maschine, wo das Ding dann hinterher auch läuft.

01:07:41.760 --> 01:07:45.140
Und naja, dann geht man eben Schritt für Schritt durch.

01:07:45.280 --> 01:07:50.520
Das heißt, man guckt sich den funktionalen Teil an und nicht den nicht

01:07:50.520 --> 01:07:54.260
-funktionalen und guckt erstmal...

01:07:54.260 --> 01:07:56.120
Was war denn nochmal funktional und nicht-funktional?

01:07:57.000 --> 01:07:58.300
Funktional und nicht-funktional.

01:07:58.960 --> 01:08:02.860
Naja, das eine ist das, was es tut und das andere ist, wie es das tun

01:08:02.860 --> 01:08:03.100
soll.

01:08:04.400 --> 01:08:07.460
Also die funktionalen Anforderungen, das waren die...

01:08:07.460 --> 01:08:12.500
Naja, es muss XYZ berechnen oder darstellen oder whatever.

01:08:13.040 --> 01:08:13.340
Okay.

01:08:13.720 --> 01:08:14.060
Okay.

01:08:14.480 --> 01:08:16.360
Und nicht-funktional war...

01:08:16.360 --> 01:08:19.520
Naja, ich muss auf die Berechnung nicht länger warten als N Sekunden.

01:08:20.500 --> 01:08:21.140
Ah ja, richtig.

01:08:21.140 --> 01:08:26.300
Diese weichen Qualitätsdinger, die man am besten als Zahl hinschreibt

01:08:26.300 --> 01:08:30.700
und nicht, es muss schnell gehen oder es muss gut bedienbar sein.

01:08:30.800 --> 01:08:33.880
Der Benutzer darf höchstens drei Klicks brauchen, um Funktion A zu

01:08:33.880 --> 01:08:35.240
Funktion B zu wechseln oder so.

01:08:35.600 --> 01:08:35.860
Genau.

01:08:37.500 --> 01:08:42.040
Das heißt, man teilt das ein, macht einen funktionalen, einen nicht

01:08:42.040 --> 01:08:45.960
-funktionalen Systemtest und geht dann eben diese einzelnen Kriterien

01:08:45.960 --> 01:08:46.200
durch.

01:08:46.860 --> 01:08:49.980
Idealerweise macht man das dann anhand von den Dokumenten, die man

01:08:49.980 --> 01:08:52.420
ganz am Anfang vom Prozess mal aufgeschrieben hat.

01:08:53.060 --> 01:08:56.280
Weil wenn man alles erreicht hat, alles getestet hat, was da drin

01:08:56.280 --> 01:08:59.280
steht, dann ist man ja fertig, weil mehr hat man ja vertraglich auch

01:08:59.280 --> 01:08:59.980
nicht zugesichert.

01:09:02.500 --> 01:09:05.260
Was da noch dazu kommt, ist genau das, was wir in der letzten

01:09:05.260 --> 01:09:08.040
Übungsaufgabe gemacht haben, den Leistungstest.

01:09:08.560 --> 01:09:10.060
Das will man natürlich auch irgendwie machen.

01:09:10.220 --> 01:09:14.320
Man will gucken, wie man an die Systemgrenzen rankommt, was die

01:09:14.320 --> 01:09:16.500
Leistung und was die Beanspruchbarkeit angeht.

01:09:16.800 --> 01:09:20.640
Oder auch immer ganz lustig, was passiert mit dem System, wenn man da

01:09:20.640 --> 01:09:21.200
hinkommt?

01:09:21.480 --> 01:09:22.800
Oder drüber raus.

01:09:22.940 --> 01:09:23.600
Oder drüber hinaus.

01:09:23.700 --> 01:09:24.860
Da gibt es manchmal ganz lustige Effekte.

01:09:26.400 --> 01:09:26.640
Genau.

01:09:28.140 --> 01:09:31.860
Was wir dabei natürlich auch tun, sind Regressionstests.

01:09:32.060 --> 01:09:37.180
Das heißt, wir bauen die Tests möglichst wiederholbar und lassen die

01:09:37.180 --> 01:09:40.060
jedes Mal wieder neu laufen, wenn sich irgendwas am System ändert.

01:09:40.720 --> 01:09:45.040
Das heißt, diese Systemtests und auch alle Tests, die wir vorher

01:09:45.040 --> 01:09:47.920
gemacht haben, sollten wir aufbewahren und auch die Ergebnisse davon,

01:09:48.660 --> 01:09:53.640
damit wir bei Änderungen oder bei Eingriffen oder bei was auch immer

01:09:55.300 --> 01:09:58.880
sicherstellen können, dass alles, was schon mal ging, immer noch geht.

01:09:59.820 --> 01:10:02.200
Dass wir also nie durch irgendeine Änderung was kaputt machen.

01:10:04.300 --> 01:10:07.000
Idealerweise, habe ich gesagt, schreibt man sich das auf, weil man

01:10:07.000 --> 01:10:10.000
will ja nicht alles nochmal durchlesen von den Testergebnissen,

01:10:10.220 --> 01:10:12.700
sondern man will nur gucken, was hat sich denn geändert zum letzten

01:10:12.700 --> 01:10:13.320
Durchlauf.

01:10:14.080 --> 01:10:16.960
Das ist insbesondere dann interessant, wenn das nicht Unit-Tests sind,

01:10:17.000 --> 01:10:19.560
die rot oder grün sind, sondern wenn man irgendeine Zeitnutzung macht

01:10:19.560 --> 01:10:20.040
oder sowas.

01:10:21.260 --> 01:10:23.400
Dann ist es halt hilfreich, wenn man sich die Ergebnisse nicht

01:10:23.400 --> 01:10:26.140
durchlesen muss, sondern einfach gesagt bekommt, hier hat sich was

01:10:26.140 --> 01:10:26.620
verändert.

01:10:28.420 --> 01:10:30.780
Dann ist man mit dem Systemtest schon durch.

01:10:32.700 --> 01:10:35.820
Relativ wenig Folien, vermutlich aber relativ viel Zeit, weil das ist

01:10:35.820 --> 01:10:41.260
ja die Vorbereitung für das, was man eigentlich gerne haben möchte.

01:10:41.540 --> 01:10:44.020
Man möchte die Software abgenommen bekommen vom Kunden.

01:10:44.220 --> 01:10:46.620
Das heißt, es findet dann ein Abnahmetest statt.

01:10:48.080 --> 01:10:54.100
Und wenn man einen Kunden hat, einen echten, dann nimmt man den

01:10:54.100 --> 01:10:54.660
natürlich her.

01:10:54.980 --> 01:10:55.900
Der soll da mitmachen.

01:10:56.160 --> 01:11:01.020
Der soll in der Regel das zumindest beaufsichtigen, überwachen, weil

01:11:01.020 --> 01:11:03.180
dann muss er hinterher unterschreiben, dass er das abnimmt.

01:11:03.180 --> 01:11:05.340
Also sollte er auch gesehen haben, was er da tut.

01:11:07.200 --> 01:11:10.240
Und meistens ist es auch so, dass er da selber mit einwirkt.

01:11:10.340 --> 01:11:12.880
Das heißt, man bekommt dann vom Kunden Menschen, die das tatsächlich

01:11:12.880 --> 01:11:13.400
durchführen.

01:11:16.360 --> 01:11:18.620
Und idealerweise macht man das natürlich mit Echtdaten.

01:11:18.920 --> 01:11:21.840
Also vorher hat man versucht, realistische Daten zu nehmen in den

01:11:21.840 --> 01:11:22.460
Systemtest.

01:11:23.180 --> 01:11:27.100
Und beim Abnahmetest sollte man dann tunlichst echte Daten haben, weil

01:11:27.100 --> 01:11:29.420
sonst weiß man ja nicht, ob es klappt.

01:11:29.640 --> 01:11:32.800
Insbesondere wird der Kunde darauf bestehen, funktioniert es denn auch

01:11:32.800 --> 01:11:35.300
mit dem, was wir hier im Keller liegen haben und nicht nur das, was

01:11:35.300 --> 01:11:36.300
ihr euch ausgedacht habt.

01:11:39.520 --> 01:11:43.220
Normalerweise ist es dann so, dass der Auftraggeber einfach Testfälle

01:11:43.220 --> 01:11:46.080
aus den Systemtests übernimmt, weil wenn sie da schon was getestet

01:11:46.080 --> 01:11:48.720
haben, was der sich ohnehin angucken möchte, dann muss er sich ja den

01:11:48.720 --> 01:11:51.640
Testfall und das Szenario nicht nochmal neu ausdenken.

01:11:53.220 --> 01:11:56.160
Meistens geht er dann hin und ändert irgendwelche Details, dreht an

01:11:56.160 --> 01:11:59.680
irgendeiner Schraube, macht einen Sonderfall draus, führt noch einen

01:11:59.680 --> 01:12:03.560
Umlaut in irgendein Namensfeld ein und dann explodiert es, hoffentlich

01:12:03.560 --> 01:12:06.860
nicht, und ist dann zufrieden.

01:12:07.000 --> 01:12:12.420
Und was sie dann bekommen, ist eben eine formale Abnahme im Sinne von,

01:12:12.980 --> 01:12:15.860
der Kunde sagt, ja, das, was ich bestellt habe und das, was ich

01:12:15.860 --> 01:12:18.600
bezahlen werde, das habe ich jetzt geliefert bekommen.

01:12:19.380 --> 01:12:23.280
Natürlich genau das, was sie als Systemhaus oder als Entwickler haben

01:12:23.280 --> 01:12:23.580
wollen.

01:12:23.720 --> 01:12:27.800
Sie wollen das Okay vom Kunden, weil der am Ende die Rechnung bezahlt.

01:12:27.800 --> 01:12:31.600
Und wenn er das Okay an der Stelle gibt, dann hat er halt auch keine

01:12:31.600 --> 01:12:35.140
Chance mehr, aus diesem Bezahlen rauszukommen, zumindest auf normalem

01:12:35.140 --> 01:12:36.380
Wege.

01:12:37.940 --> 01:12:41.180
Ja, dann sind wir mit dem Testen und Prüfen schon schön durch.

01:12:41.320 --> 01:12:44.560
Es gibt noch ein bisschen Literatur in diesem Kapitel, die Sie sich

01:12:44.560 --> 01:12:45.740
gerne mal anschauen können.

01:12:47.180 --> 01:12:50.940
Und das war alles, was in diesem hübschen Testkapitel drin ist.

01:12:51.280 --> 01:12:55.620
Es gibt noch eine Testmethode, mit der ich mal Kontakt hatte bei web

01:12:55.620 --> 01:12:55.960
.de.

01:12:55.960 --> 01:12:59.020
Das ist die schwäbische Testmethode.

01:12:59.820 --> 01:13:03.300
Die geht so, nicht gemotzt, ist genug gelobt.

01:13:03.420 --> 01:13:08.440
Und es war also so, dass die ersten Versionen von web.de vor 15 Jahren

01:13:08.440 --> 01:13:12.840
oder so, liefen auf den Arbeitsplatzrechnern der Mitarbeiter unter

01:13:12.840 --> 01:13:17.380
Solaris, weil der Chef der IT der Meinung war, Solaris ist ein super

01:13:17.380 --> 01:13:20.760
performantes Betriebssystem, dort kann man diesen Dienst zuverlässig

01:13:20.760 --> 01:13:22.780
laufen lassen und sowas.

01:13:22.780 --> 01:13:25.560
Und die Mitarbeiter teilten diese Meinung nicht ganz so.

01:13:25.740 --> 01:13:28.360
Linux war zu der Zeit sehr hip und modern und man brauchte das

01:13:28.360 --> 01:13:29.080
unbedingt und so.

01:13:29.400 --> 01:13:32.540
Und dann ging der Chef eines schönen Tages mal in Urlaub für drei

01:13:32.540 --> 01:13:36.920
Wochen und dann haben sie das web.de-System genommen und haben es auf

01:13:36.920 --> 01:13:41.040
Linux portiert, einfach mal so, zack, haben es laufen lassen und haben

01:13:41.040 --> 01:13:42.060
dem Chef nichts gesagt.

01:13:42.140 --> 01:13:45.940
Als er zurückkam, haben wir geguckt, wie lang es braucht, bis er es

01:13:45.940 --> 01:13:46.340
merkt.

01:13:49.800 --> 01:13:51.100
Sie sind bis heute auf Linux.

01:13:55.320 --> 01:13:57.580
Wahrscheinlich hat er schon gemerkt, dass irgendwann keiner mehr

01:13:57.580 --> 01:13:58.980
Solaris -Lizenzen haben wollte.

01:13:59.660 --> 01:14:01.980
Ja, das ist das zweite, erste Geschäftsmodell-Problem.

01:14:02.520 --> 01:14:03.420
Auch wieder schwäbisch.

01:14:03.660 --> 01:14:08.900
Dinge, die man bezahlen muss, in N skalieren nicht, wenn Kunden nichts

01:14:08.900 --> 01:14:11.000
bezahlen, aber in N skalieren.

01:14:11.400 --> 01:14:13.400
Das ist ein grundsätzliches Freemailer-Problem.

01:14:15.420 --> 01:14:15.920
Genau.

01:14:17.920 --> 01:14:19.560
Wollen wir mit dem Kapitel noch anfangen?

01:14:20.040 --> 01:14:20.920
Ja, ein bisschen.

01:14:20.920 --> 01:14:25.220
Okay, dann fangen wir mal noch mit dem hübschen Abnahmekapitel an.

01:14:26.080 --> 01:14:28.540
Die Frage ist, jetzt haben wir den Abnahmetest gemacht.

01:14:29.220 --> 01:14:31.480
Das Ding ist beim Kunden, was passiert denn dann?

01:14:32.120 --> 01:14:36.300
Also im Wasserfall sind wir dann ganz hier unten, das heißt Abnahme,

01:14:36.460 --> 01:14:37.520
Einsatz und Wartung.

01:14:37.760 --> 01:14:40.560
Das heißt, wir müssen es offensichtlich beim Kunden einsetzen und

01:14:40.560 --> 01:14:42.460
vermutlich dann auch warten.

01:14:43.320 --> 01:14:46.160
Heißt, dem wird im Betrieb irgendwas auffallen, da werden Dinge kaputt

01:14:46.160 --> 01:14:47.660
gehen und dann muss man eben nachpflegen.

01:14:50.500 --> 01:14:54.460
Das ist hier nochmal ein bisschen ausgerollt mit den einzelnen Dingen,

01:14:54.560 --> 01:14:55.220
die man da so hat.

01:14:55.480 --> 01:14:58.960
Das heißt, wenn man den Abnahmeprozess durch hat, dann hat man also

01:14:58.960 --> 01:15:01.020
offensichtlich ein installiertes Produkt beim Kunden.

01:15:01.720 --> 01:15:03.220
Das ist dann da und läuft.

01:15:03.820 --> 01:15:08.000
Der Systemtest ist durch, der Kunde hat also gesagt, toll, nehme ich.

01:15:09.340 --> 01:15:12.740
Und wir haben dem Kunden die Dokumentation über den Zaun geworfen und

01:15:12.740 --> 01:15:14.800
sind dann schnell weggerannt, damit er nicht merkt, was da alles für

01:15:14.800 --> 01:15:15.480
Quatsch drin steht.

01:15:16.380 --> 01:15:20.980
Aber ganz wichtig, dieses Okay, das Thomas gerade simuliert hat, das

01:15:20.980 --> 01:15:22.960
haben wir natürlich protokolliert, das haben wir aufgeschrieben.

01:15:23.380 --> 01:15:24.700
Und das haben wir ihnen auch unterschreiben lassen.

01:15:24.840 --> 01:15:27.520
Das heißt, hier hat es wieder hübsche Dokumente, nämlich ein Abnahme-

01:15:27.520 --> 01:15:31.220
und Einführungsprotokoll, in dem am Ende halt drin steht, ja, wir

01:15:31.220 --> 01:15:32.480
haben es gekriegt.

01:15:37.560 --> 01:15:41.480
Ab diesem Moment ist man also nicht mehr im Entwicklungsprozess,

01:15:41.620 --> 01:15:43.780
sondern jetzt ist man in Wartung und Pflege.

01:15:44.460 --> 01:15:49.620
Und naja, das ist wohl irgendwo am Ende und man muss offensichtlich

01:15:49.620 --> 01:15:50.660
auch noch implementieren.

01:15:51.000 --> 01:15:52.900
Das heißt, da hängt auch noch was dran.

01:15:55.700 --> 01:15:58.820
Das haben wir eigentlich schon gemacht im letzten Ding, deswegen

01:15:58.820 --> 01:16:01.240
springe ich das mal ein bisschen schneller durch.

01:16:02.160 --> 01:16:05.860
Genau, wenn man den externen Auftraggeber hat, das ist das, was wir

01:16:05.860 --> 01:16:07.480
gerade hatten, der muss das eben abnicken.

01:16:16.930 --> 01:16:20.010
Irgendwo sollte noch stehen, was passiert, wenn man keinen externen

01:16:20.010 --> 01:16:22.410
Auftraggeber hat, sondern für den Markt entwickelt.

01:16:22.890 --> 01:16:24.630
Dann macht man so Sachen wie Betatests.

01:16:25.850 --> 01:16:29.770
Das ist gestern auch in Folien gelesen, aber ich weiß nicht mehr genau

01:16:29.770 --> 01:16:29.990
wo.

01:16:30.650 --> 01:16:33.590
Naja, ist klar, wenn man keinen Kunden hat, der es abnehmen kann, weil

01:16:33.590 --> 01:16:37.130
es den Kunden nicht gibt, dann muss man seine Produkte eben so an den

01:16:37.130 --> 01:16:40.450
Mann bringen und sich Feedback von den zukünftigen Nutzern holen.

01:16:40.590 --> 01:16:41.710
Das ist das, was wir alle kennen.

01:16:42.290 --> 01:16:45.170
Da kommt diese Frage, wer ist meine Zielgruppe und was möchten die?

01:16:45.310 --> 01:16:47.990
Sind es die Autofahrenden Männer zwischen 25 und 35?

01:16:48.130 --> 01:16:51.450
Dann muss ich vielleicht anders vermarkten, als wenn es irgendwie die

01:16:51.450 --> 01:16:54.390
Senioren zwischen 70 und 90 sind oder so.

01:16:55.690 --> 01:16:55.930
Genau.

01:16:57.090 --> 01:17:00.010
Wenn man allerdings so einen externen Auftraggeber hat, dann ist die

01:17:00.010 --> 01:17:01.050
Welt wieder schön und einfach.

01:17:01.050 --> 01:17:04.450
Man muss nur vorher mit dem vereinbaren, wer denn dieses Produkt

01:17:04.450 --> 01:17:05.970
wartet und pflegt.

01:17:06.770 --> 01:17:11.250
Wenn er das nur nutzt, Sie allerdings derjenige sind, der es wartet

01:17:11.250 --> 01:17:13.050
und pflegt, dann sollten Sie dafür Geld bekommen.

01:17:13.210 --> 01:17:14.410
Das sollten Sie vorher vereinbaren.

01:17:15.130 --> 01:17:19.070
Und wenn er das selber warten und pflegen will, naja, dann braucht er

01:17:19.070 --> 01:17:23.390
offensichtlich die Quellen und die Entwicklerdokumentation und das

01:17:23.390 --> 01:17:25.070
ganze Zeug, um das auch machen zu können.

01:17:25.630 --> 01:17:27.290
Auch das sollten Sie vorher vereinbaren.

01:17:27.290 --> 01:17:31.590
Insbesondere sollten Sie sich im Klaren sein, dass Sie damit ja Ihr

01:17:31.590 --> 01:17:33.610
Betriebsgeheimnis rausschenken.

01:17:34.270 --> 01:17:35.570
Der braucht Sie dann nicht mehr.

01:17:36.810 --> 01:17:37.290
Möglicherweise.

01:17:37.750 --> 01:17:38.230
Möglicherweise.

01:17:39.470 --> 01:17:43.150
Also als Microsoft-Firma nicht hingehen und seinem Kunden den Windows

01:17:43.150 --> 01:17:43.910
-Quelltext geben.

01:17:45.030 --> 01:17:46.230
Das hat aber auch andere Gründe.

01:17:46.250 --> 01:17:47.610
Das hat auch andere Gründe, ja.

01:17:47.910 --> 01:17:50.610
Das ist bei der Individualentwicklung aber nicht anders.

01:17:50.790 --> 01:17:53.090
Also da muss man ein bisschen aufpassen.

01:17:53.710 --> 01:17:54.190
Genau.

01:17:57.330 --> 01:18:01.090
Während das Produkt genutzt wird, dann gibt es natürlich diese

01:18:01.090 --> 01:18:04.430
Qualitätsmerkmale, die man sich im Abnahmetest oder im Systemtest

01:18:04.430 --> 01:18:05.730
schon angeguckt haben sollte.

01:18:06.930 --> 01:18:09.750
Und wenn man das Ding dann warten und pflegen muss, dann kommt einfach

01:18:09.750 --> 01:18:13.270
noch dazu, naja, es muss offensichtlich wartbar sein und es sollte

01:18:13.270 --> 01:18:16.290
testbar sein über das Maß hinaus, das wir schon gemacht haben.

01:18:16.750 --> 01:18:18.670
Und es sollte ein bisschen Flexibilität mitbringen.

01:18:18.670 --> 01:18:23.050
Wenn Sie im Produkteinsatz sind und da ändert sich ein bisschen was

01:18:23.050 --> 01:18:26.090
beim Kunden, der ruft an und sagt, ich bräuchte jetzt aber mal den

01:18:26.090 --> 01:18:28.830
Knopf in grün, dann ist das wahrscheinlich einfach.

01:18:29.550 --> 01:18:33.190
Und wenn das ein Bankhaus ist und sagt, ich möchte jetzt aber die

01:18:33.190 --> 01:18:37.670
Kontokorrentzinsberechnung anders haben und Sie müssen dann zwei Tage

01:18:37.670 --> 01:18:40.850
die Bank ausschalten, weil Sie da irgendwas umdrehen müssen im Kern,

01:18:41.010 --> 01:18:43.990
dann ist Ihr Produkt offensichtlich nicht ganz so flexibel und eher

01:18:43.990 --> 01:18:44.470
ungeschickt.

01:18:44.470 --> 01:18:48.410
Mir kommen diese zusätzlichen Merkmale übrigens sehr, sehr bekannt vor

01:18:48.410 --> 01:18:49.470
aus dem Modellierungskapitel.

01:18:50.770 --> 01:18:54.810
Dort hat man ja möglicherweise schon das Modell und den Entwurf so

01:18:54.810 --> 01:18:58.450
angepasst, dass man nachher dann, nämlich jetzt, Wartbarkeit und

01:18:58.450 --> 01:19:02.290
Testbarkeit und Flexibilität vielleicht mehr hat, als wenn man

01:19:02.290 --> 01:19:06.290
irgendwie hanebüchen einen Entwurf hätte, der die Wartbarkeit oder

01:19:06.290 --> 01:19:08.550
Testbarkeit oder die Flexibilität eben einschränkt.

01:19:10.010 --> 01:19:10.610
Genau.

01:19:11.610 --> 01:19:15.110
Wenn Sie das Produkt beim Kunden einführen, dann müssen Sie es

01:19:15.110 --> 01:19:18.230
natürlich erstmal installieren und einrichten und was das alles

01:19:18.230 --> 01:19:22.290
dazugehört, aber vermutlich müssen Sie die Benutzer auch entsprechend

01:19:22.290 --> 01:19:22.650
schulen.

01:19:22.870 --> 01:19:26.990
Also Sie installieren da irgendwas Neues und verabschieden sich dann,

01:19:27.070 --> 01:19:30.950
dann wird es vermutlich beim Kunden am ersten Tag krachen.

01:19:31.990 --> 01:19:34.570
Wenn er nämlich selber wieder Kunden hat, die er bedienen muss und

01:19:34.570 --> 01:19:36.110
nicht weiß, wie sein System funktioniert.

01:19:37.590 --> 01:19:38.850
Das alles gehört da dazu.

01:19:46.030 --> 01:19:49.630
Das alles, wie schon 15 mal gesagt heute, müssen wir natürlich

01:19:49.630 --> 01:19:52.170
entsprechend dokumentieren und protokollieren.

01:19:57.610 --> 01:19:58.870
Was haben wir noch?

01:19:59.190 --> 01:20:03.230
Wenn Sie das Ganze einführen und Sie sind auf der grünen Wiese, dann

01:20:03.230 --> 01:20:03.890
ist es natürlich toll.

01:20:04.190 --> 01:20:07.230
Das ist genau das, was Sie haben wollen.

01:20:07.390 --> 01:20:09.710
Sie haben keine Abhängigkeiten, Sie müssen nichts beachten.

01:20:09.710 --> 01:20:11.870
Das ist aber in aller Regel nicht der Fall.

01:20:14.530 --> 01:20:19.070
In der Regel ist es so, dass Sie ein System ausrollen und ein anderes

01:20:19.070 --> 01:20:20.330
ersetzen oder ergänzen.

01:20:22.290 --> 01:20:25.270
Das müssen Sie sich vorher vielleicht mal überlegen.

01:20:25.630 --> 01:20:27.990
Stellen Sie sich vor, Sie haben hier eine Fluggesellschaft als Kunden

01:20:27.990 --> 01:20:29.510
und die wollen ein neues Buchungssystem.

01:20:30.450 --> 01:20:37.190
Okay, ich installiere das Freitagabend, am Montag früh können Sie

01:20:37.190 --> 01:20:37.930
damit arbeiten.

01:20:39.150 --> 01:20:39.950
Hoffentlich.

01:20:40.670 --> 01:20:41.710
Genau, hoffentlich.

01:20:42.370 --> 01:20:46.350
Wenn nichts schief geht und die Datenübernahme aus dem Altsystem und

01:20:46.350 --> 01:20:51.650
die Installation auf den 823 Clients an 48 Standorten funktioniert,

01:20:52.250 --> 01:20:54.950
dann können Sie am Montag Ihren ganz normalen Betrieb wieder

01:20:54.950 --> 01:20:55.370
hochfahren.

01:20:55.370 --> 01:21:00.850
Dann sagt der Kunde nicht, oh toll, weil es läuft, sondern er sagt,

01:21:00.910 --> 01:21:01.610
spinnen Sie eigentlich?

01:21:01.810 --> 01:21:03.370
Samstag und Sonntag arbeiten wir auch.

01:21:04.390 --> 01:21:08.070
Sie haben einen 24-7 Betrieb, Sie können nicht für drei Tage den

01:21:08.070 --> 01:21:11.670
Betrieb lahmlegen und dann vielleicht wieder hochfahren.

01:21:11.870 --> 01:21:12.990
Das ist einfach keine Option.

01:21:13.050 --> 01:21:14.250
Keine Option, genau.

01:21:16.290 --> 01:21:20.230
Das heißt, Sie müssen sich vorher darüber Gedanken machen, dass Sie

01:21:20.230 --> 01:21:21.170
dafür Zeit brauchen.

01:21:21.170 --> 01:21:25.550
Das größte Problem bei der Übertragung von dem Alt in ein neues System

01:21:25.550 --> 01:21:27.190
ist das Mitnehmen von den Daten.

01:21:27.490 --> 01:21:30.530
Und ich sag mal, einen Dump aus dem Altsystem rauslassen und das Neue

01:21:30.530 --> 01:21:34.370
einspielen, das kann man drei-, viermal im Laborbetrieb machen und

01:21:34.370 --> 01:21:35.290
dann weiß man, wie das geht.

01:21:35.370 --> 01:21:37.550
Und dann hat man alle Sonderfälle abgefangen und dann ist es okay.

01:21:38.630 --> 01:21:42.910
Aber während Sie das neue System ausrollen, entstehen ja weiterhin

01:21:42.910 --> 01:21:46.530
Daten im Altsystem, die Sie auch noch irgendwann erfassen müssen.

01:21:47.070 --> 01:21:49.790
Und das weißt Sie dann irgendwann halt schon.

01:21:50.210 --> 01:21:52.970
Sie müssen sich also überlegen, kriege ich eine direkte Umstellung

01:21:52.970 --> 01:21:53.250
hin?

01:21:53.370 --> 01:21:58.250
Das heißt, ich entlade das Altsystem und belade das neue System.

01:21:58.370 --> 01:22:00.670
Dann haben Sie bei der Fluggesellschaft das Problem, dass das halt

01:22:00.670 --> 01:22:03.770
nicht instantan passiert, sondern eher über Tage.

01:22:04.470 --> 01:22:05.190
Und das geht nicht.

01:22:06.070 --> 01:22:07.690
Eine Alternative ist ein Parallellauf.

01:22:07.810 --> 01:22:10.710
Sie installieren einfach das neue System, laden die Altdaten rein und

01:22:10.710 --> 01:22:13.650
sagen, okay, viel Spaß, Sie haben jetzt das Neue und das Alte, machen

01:22:13.650 --> 01:22:14.470
Sie es einfach doppelt.

01:22:15.070 --> 01:22:17.270
Und wenn Sie das Alte nicht mehr brauchen, schalten Sie das Alte ab.

01:22:17.270 --> 01:22:19.690
Schalten Sie das Alte halt ab, kein Problem.

01:22:20.330 --> 01:22:23.370
Dann sagt der Kunde vielleicht, wenn es gut läuft, ja, ist wunderbar,

01:22:23.410 --> 01:22:26.130
das machen wir, weil wir haben genug Zeit und nichts zu tun und das

01:22:26.130 --> 01:22:27.750
ist eh super und dann wissen wir, dass es geht.

01:22:27.910 --> 01:22:29.830
Und das Geschäftsmodell erlaubt das vielleicht oder so?

01:22:30.250 --> 01:22:30.770
Ja, dann ist es toll.

01:22:31.650 --> 01:22:36.470
Wenn aber die Landhäuser eher 200.000 Passagiere pro Woche

01:22:36.470 --> 01:22:39.890
transportiert und der Passagier muss dann wissen, ob er im Altsystem

01:22:39.890 --> 01:22:44.430
oder im Neuesystem gebucht ist, das hört sich dann auch an, als ob das

01:22:44.430 --> 01:22:45.170
schief gehen muss.

01:22:45.950 --> 01:22:49.610
Also parallel ist in dem Fall keine Lösung, weil Sie wollen ja nicht

01:22:49.610 --> 01:22:52.450
am Schalter stehen und alles doppelt machen, doppelt einchecken und

01:22:52.450 --> 01:22:54.530
doppelt Ihr Gepäck abgeben und so weiter.

01:22:54.850 --> 01:22:56.410
Oder entscheiden, in welchem System.

01:22:56.930 --> 01:22:59.750
Und entscheiden, dass Sie ins Neue oder ins Alte System wollen, das

01:22:59.750 --> 01:23:01.170
geht ja auch nicht, stellen Sie sich vor, Sie haben ein Problem.

01:23:01.170 --> 01:23:03.110
Herzlichen Glückwunsch, Sie sind Betakunde in unserem neuen

01:23:03.110 --> 01:23:03.990
Buchungssystem.

01:23:04.150 --> 01:23:07.950
Wenn Sie Fragen haben, am Ende der Halle gibt es einen Schalter, der

01:23:07.950 --> 01:23:09.270
kann das vielleicht beantworten.

01:23:09.270 --> 01:23:11.270
Der ist mit dem neuen, kleinen bestückt.

01:23:11.570 --> 01:23:15.570
Ja, geht aber nur bis 10 Minuten vor dem Abflug, weil da transferieren

01:23:15.570 --> 01:23:17.870
wir alle Daten ins Altsystem, weil sonst kriegen Sie kein Essen.

01:23:18.230 --> 01:23:18.430
Genau.

01:23:19.830 --> 01:23:20.970
Ist einfach ungeschickt.

01:23:21.270 --> 01:23:24.490
Da macht man dann vermutlich eher einen Versuchslauf, das heißt, man

01:23:24.490 --> 01:23:28.550
setzt das neue System auf einen definierten Stand, man zieht sich also

01:23:28.550 --> 01:23:31.230
einen Damm vom Altsystem, installiert das neue System, lädt die Daten

01:23:31.230 --> 01:23:34.770
rein und sagt, okay, jetzt habe ich ja noch Verkehrsdaten.

01:23:34.770 --> 01:23:38.750
Also ich protokolliere einfach, was passiert denn im Altsystem und

01:23:38.750 --> 01:23:43.530
spiele das doppelt wie beim Parallelllauf einfach nochmal durch und

01:23:43.530 --> 01:23:45.690
gucke, ist dann das Ergebnis das gleiche.

01:23:45.750 --> 01:23:50.670
Das hat den Charme und den Vorteil, dass man das natürlich offline im

01:23:50.670 --> 01:23:51.430
Keller machen kann.

01:23:52.130 --> 01:23:55.470
Das heißt, Sie holen sich irgendeinen definierten Stand plus die

01:23:55.470 --> 01:23:59.210
Änderung und mit der Änderungsliste sitzt einfach ein armer Praktikant

01:23:59.210 --> 01:24:02.910
im Keller und checkt 400 Passagiere ein, die jetzt gar nicht da sind,

01:24:03.110 --> 01:24:06.050
aber er tut es halt und dann guckt er hinterher, ob die Maschine voll

01:24:06.050 --> 01:24:06.230
ist.

01:24:06.870 --> 01:24:10.510
Und wenn das alles klappt, dann kann man wohl gefahrlos umstellen.

01:24:11.630 --> 01:24:14.190
Also quasi eine Simulierung vom Echtbetrieb.

01:24:15.110 --> 01:24:18.810
In den Folien haben Sie dieses ganze Gelaber nochmal ein bisschen

01:24:18.810 --> 01:24:25.210
hübscher, inlesbar und den Teil überspringe ich einfach.

01:24:25.650 --> 01:24:28.170
Das haben wir alles jetzt schon durchgeturnt.

01:24:28.670 --> 01:24:33.050
Was dann am Ende rauskommt, wie immer, 143 Protokolle und

01:24:33.050 --> 01:24:34.210
Dokumentationen.

01:24:36.290 --> 01:24:40.130
Was Sie aber auch noch protokollieren und festhalten sollen, da reiten

01:24:40.130 --> 01:24:41.210
wir auch ein bisschen drauf rum.

01:24:42.250 --> 01:24:45.030
Das kennen Sie auch schon aus dem Versionskontrollkapitel, das ist

01:24:45.030 --> 01:24:46.310
das, was Sie ausgerollt haben.

01:24:46.430 --> 01:24:48.470
Sie sollten die Software archivieren.

01:24:48.830 --> 01:24:51.310
Sie müssen wissen, was für ein Stand läuft denn beim Kunde.

01:24:52.310 --> 01:24:56.990
Hey Landhäuser, könnt ihr uns euren Stand unserer Software nochmal

01:24:56.990 --> 01:24:59.990
schicken, weil wir haben leider vergessen, welchen wir euch geschickt

01:24:59.990 --> 01:25:00.390
haben.

01:25:00.790 --> 01:25:02.230
Ja, es geht nicht, der Server steht.

01:25:04.470 --> 01:25:05.270
Irgendwie blöd.

01:25:05.810 --> 01:25:06.530
Das machen wir nicht.

01:25:07.010 --> 01:25:09.310
Das heißt, Sie sollten wissen, was haben Sie bei welchem Kunden, in

01:25:09.310 --> 01:25:12.110
welcher Version, mit welchem Patch installiert.

01:25:13.930 --> 01:25:17.630
Und, naja, idealerweise weiß die Software auch, welche Version sie

01:25:17.630 --> 01:25:17.830
hat.

01:25:18.130 --> 01:25:21.170
Das haben Sie bei der Anwendungssoftware einfach immer in diesem Hilfe

01:25:21.170 --> 01:25:21.970
-Übermenü.

01:25:22.030 --> 01:25:23.890
Da steht die Version und die Revisionsnummer.

01:25:24.570 --> 01:25:26.830
Das haben Sie natürlich bei einer großen Software auch.

01:25:27.170 --> 01:25:29.310
Die sollte auch wissen, welchen Stand sie hat.

01:25:30.170 --> 01:25:33.770
Und wenn Sie wissen, welchen Stand die Software beim Kunden hat und

01:25:33.770 --> 01:25:36.250
der mit einem Problem auf sie zukommt, dann können Sie das einfach

01:25:36.250 --> 01:25:37.830
nachstellen und dann beheben.

01:25:39.470 --> 01:25:43.710
An der Stelle haben wir thematisch, glaube ich, einen Bruch in den

01:25:43.710 --> 01:25:46.130
Folien und an der Stelle hören wir dann mit den Folien auf.

01:25:46.350 --> 01:25:49.190
Sie dürfen aber noch nicht gehen, weil wir haben...

01:25:49.190 --> 01:25:50.690
Ich habe noch einen Hinweis für Sie.

01:25:50.970 --> 01:25:51.810
Einen Hinweis?

01:25:51.890 --> 01:25:56.690
Zum einen, die Verleihung für Aufgabe 3 machen wir nächste Woche.

01:25:56.870 --> 01:25:58.990
Sie haben uns also heute nicht zum letzten Mal ertragen.

01:25:59.130 --> 01:26:02.370
Wir werden uns nochmal wiedersehen nächste Woche für ein paar Minuten

01:26:02.370 --> 01:26:03.070
in der Vorlesung.