WEBVTT

00:06.410 --> 00:09.330
So, hallo und guten Morgen.

00:09.430 --> 00:15.530
Herzlich willkommen zur letzten Übung in der Software Technik 1.

00:15.930 --> 00:20.170
Wir haben auf den Übungsblättern gesehen, das freut schon einige, dass

00:20.170 --> 00:24.450
es jetzt endlich rum ist mit diesem stressigen Übungsbetrieb, dass die

00:24.450 --> 00:28.550
meisten doch hoffentlich auch gut durchgekommen sind, auch mit viel

00:28.550 --> 00:28.990
Arbeit.

00:30.310 --> 00:32.530
Ich hoffe, der ein oder andere hat auch trotz des Stresses ein

00:32.530 --> 00:33.150
bisschen was gelernt.

00:34.830 --> 00:37.170
Auch wenn das vielleicht im ersten Moment nicht so ganz offensichtlich

00:37.170 --> 00:39.530
ist und ab und zu, und das werden wir nachher noch in der E-Wahl

00:39.530 --> 00:43.310
sehen, auch mal die Zusammenhänge zwischen Vorlesung, Übung und wahren

00:43.310 --> 00:44.930
Leben noch nicht so ganz offensichtlich sind.

00:45.010 --> 00:46.490
Ich hoffe, das kommt noch irgendwann.

00:47.190 --> 00:48.310
Wenn nicht, tut es mir leid.

00:49.010 --> 00:49.590
Wie sieht es aus?

00:49.690 --> 00:50.190
Was haben wir?

00:50.950 --> 00:53.450
Erinnern wir uns erstmal daran, was wir gelernt haben über die

00:53.450 --> 00:57.190
Parallelität hoffentlich in der Vorlesung.

00:57.550 --> 01:03.690
Es gibt Wettläufe, Wettläufe auf variablen Werte, wie auch immer.

01:04.010 --> 01:07.610
Und das tritt immer dann auf, wenn ich mehrfählige Programme habe, die

01:07.610 --> 01:09.870
auf die gleiche Speicherstelle zugreifen wollen.

01:10.690 --> 01:15.150
Und das passiert irgendwie mit schreibenden Zugriffen in kritischen

01:15.150 --> 01:15.510
Abschnitten.

01:15.650 --> 01:18.730
Und das klassische Beispiel sind immer so Banküberweisungen.

01:18.970 --> 01:23.190
Hole Kontostand 1, hole Kontostand 2, dann subtrahiere Betrag von

01:23.190 --> 01:27.410
Konto 1, addiere zu Konto 2, speichere Kontostand 1 und Kontostand 2.

01:27.630 --> 01:29.990
Ja, alles wunderbar, solange man das nur alleine ausführt.

01:30.130 --> 01:34.190
Wenn da zwei das machen, kann es gut passieren, dass zwischendrin

01:34.190 --> 01:37.650
geschrieben wird, nachdem der andere gelesen hat.

01:37.770 --> 01:40.110
Dann sind da plötzlich andere Werte, als man eigentlich dachte.

01:41.110 --> 01:45.210
Ja, also sowas hier, wenn wir eine Überweisung machen von Konto 1 an

01:45.210 --> 01:50.310
Konto 2 und gleichzeitig eine Überweisung von Konto 1 an Konto 3, dann

01:50.310 --> 01:52.890
können wir eben genau das Problem haben, dass wir den gleichen

01:52.890 --> 01:57.310
Kontostand bei Konto 1 lesen, dann die Überweisung machen und dann die

01:57.310 --> 02:00.370
Überweisung an Konto 3 machen, aber mit dem höheren Kontostand, den

02:00.370 --> 02:00.850
wir vorher hatten.

02:00.990 --> 02:03.530
Das heißt, auf meinem Konto 1 wird mir nur einmal was abgezogen, aber

02:03.530 --> 02:06.210
ich überweise es zweimal an andere Konten.

02:06.330 --> 02:08.790
Ja, und schon habe ich irgendwie Geld generiert.

02:08.890 --> 02:12.790
Und jetzt ist das ja irgendwie kein neues Problem und jetzt ist das ja

02:12.790 --> 02:14.170
irgendwie hoffentlich gelöst.

02:14.230 --> 02:15.490
Und ja, das ist eigentlich gelöst.

02:15.610 --> 02:18.670
Ja, sowas kann man wunderbar in Transaktionen packen und dann ist das

02:18.670 --> 02:19.250
kein Problem mehr.

02:19.310 --> 02:21.690
Das werden Sie wahrscheinlich auch noch im Laufe Ihres Studiums in

02:21.690 --> 02:24.410
aller Ausführlichkeit lernen, was da zu tun ist und welche

02:24.410 --> 02:26.470
unterschiedlichen Varianten man da bauen kann.

02:27.210 --> 02:29.450
Fakt ist jedenfalls, eigentlich kennt man dieses Problem und zwar

02:29.450 --> 02:30.510
nicht erst seit gestern.

02:30.630 --> 02:32.610
Jetzt sollte man auch der Meinung sein, das hat man im Griff.

02:33.170 --> 02:35.530
Die Wahrheit da draußen sieht leider ein bisschen anders aus.

02:35.730 --> 02:40.310
Viele Leute können mit solchen Situationen nicht umgehen und bauen

02:40.310 --> 02:44.050
dann entweder falsche Transaktionsmechanismen oder bauen sowas wie

02:44.050 --> 02:47.930
Timings oder noch schöner, wenn man das in Web-Sessions macht, dass

02:47.930 --> 02:52.290
man einfach sagt, von der IP aus darf nur einmal ein Cookie angelegt

02:52.290 --> 02:53.230
werden, dann ist ja fertig.

02:54.130 --> 02:56.550
Gut einen zweiten Browser daneben legen, gibt es halt nicht im wahren

02:56.550 --> 02:57.830
Leben, das macht ja kein Mensch.

03:00.110 --> 03:04.570
Und so sieht es dann halt auch aus, wenn man das zum Beispiel bei

03:04.570 --> 03:08.950
einem für Technologie bekannten Unternehmen wie Starbucks hat.

03:10.310 --> 03:14.390
Die haben Gutscheinkarten, also so ähnlich wie Konten, wo es halt,

03:14.510 --> 03:18.590
dass man da einmal Geld aufladen kann und was man machen kann mit

03:18.590 --> 03:21.630
diesen Gutscheinkarten oder konnte bei Starbucks, ich hoffe inzwischen

03:21.630 --> 03:26.130
haben sie es gefixt, man kann da Geld von einer Karte zur anderen

03:26.130 --> 03:26.890
überweisen.

03:27.030 --> 03:28.730
Also genau das Szenario, was wir gerade eben auch hatten.

03:29.670 --> 03:33.990
Und tatsächlich kann man damit ziemlich einfach ein Rezept für

03:33.990 --> 03:35.490
unbegrenzten Kaffee bauen.

03:35.810 --> 03:37.910
Und das Rezept ist nicht mehr so furchtbar kompliziert.

03:38.230 --> 03:41.070
Das heißt nämlich einfach nur, kaufe dir zwei Gutscheinkarten mit je

03:41.070 --> 03:44.290
fünf Euro Aufladung und nimm dir ein bisschen Zeit und probiere ein

03:44.290 --> 03:44.630
bisschen rum.

03:44.770 --> 03:47.530
Verlieren kannst du nichts, weil im schlimmsten Fall hast du genauso

03:47.530 --> 03:48.270
viel Geld wie vorher.

03:48.670 --> 03:50.270
Im besten Fall hast du mehr.

03:51.130 --> 03:56.750
Was man dafür machen muss, ist eine Websession selber nachbauen und da

03:56.750 --> 03:58.230
gibt es im Wesentlichen zwei Befehle.

03:58.310 --> 04:02.830
Das macht es dann ein bisschen schwieriger, weil es nicht diese eine

04:02.830 --> 04:05.610
Transaktion gibt, sondern es wird einmal die Transaktion angelegt hier

04:05.610 --> 04:05.870
oben.

04:06.170 --> 04:06.990
Überweisung anlegen.

04:07.150 --> 04:08.410
Man sieht ziemlich gut auch, was passiert.

04:08.570 --> 04:11.190
So ein Geldbetrag von Karte 1 zu Karte 2.

04:13.090 --> 04:17.730
Das alles legt aber erstmal nur diese Überweisung an und im zweiten

04:17.730 --> 04:19.270
Schritt wird das dann ausgeführt.

04:19.330 --> 04:22.570
Das heißt, die eigentliche Transaktion passiert hier unten und das hat

04:22.570 --> 04:24.690
dann mal jemand ausprobiert, ob das da unten kaputt ist.

04:24.850 --> 04:27.530
Wenn man so ein kleiner Hacker ist, dann macht man ja gerne mal solche

04:27.530 --> 04:28.110
Dinge.

04:28.230 --> 04:31.750
Denkt sich, dieses Ding da, das könnte kaputt sein, dieses Confirm.

04:32.090 --> 04:34.150
Was passiert denn, wenn man das gleichzeitig ausführt?

04:34.810 --> 04:37.390
Und dann baut man sich so einen Pseudocode.

04:37.790 --> 04:39.390
Für den Hacker habe ich den mal mitgebracht.

04:39.630 --> 04:41.950
Was man machen muss, ist tatsächlich nicht so furchtbar kompliziert.

04:42.410 --> 04:46.530
Man braucht einfach nur zwei Sessions, in denen man diese Transaktion

04:46.530 --> 04:51.890
anlegt und dann möglichst gleichzeitig hier unten abschickt, diese

04:51.890 --> 04:52.950
beiden Transaktionen.

04:53.770 --> 04:57.650
Und das macht man dann mal und dann passiert erstmal fünf, sechs mal

04:57.650 --> 05:00.810
nichts, einfach nur das Geld von der einen Karte auf die andere

05:00.810 --> 05:01.630
überwiesen.

05:01.790 --> 05:05.230
Und beim sechsten Mal hat man dann plötzlich diese Situation.

05:06.730 --> 05:10.110
Plötzlich ist da auf der einen Karte null Dollar drauf.

05:10.210 --> 05:12.270
Okay, das war zu erwarten, weil fünf runter von der einen.

05:12.870 --> 05:15.970
Fünf rauf auf die andere, aber auf der anderen irgendwie 15 Dollar.

05:17.670 --> 05:18.750
Und was macht man da?

05:18.850 --> 05:23.190
Weil man natürlich ein guter Mensch ist, sagt man, okay, das war jetzt

05:23.190 --> 05:25.430
irgendwie unfair und das ist ja irgendwie ein Fehler.

05:26.350 --> 05:30.170
Und vielleicht sollten wir das nicht ausnutzen, auch wenn wir es

05:30.170 --> 05:35.230
könnten, sondern wir weisen vielleicht mal dieses sehr sympathische

05:35.230 --> 05:37.690
Großunternehmen darauf hin, dass da irgendwas kaputt ist.

05:38.690 --> 05:43.030
Und außerdem möchte man natürlich ein Proof of Concept haben, dass das

05:43.030 --> 05:45.250
auch tatsächlich funktioniert und dass das nicht irgendwie zum

05:45.250 --> 05:47.070
Beispiel nur ein Fehler in der Darstellung ist.

05:47.130 --> 05:49.430
Also man kann sich auch online anschauen, wie viel Geld auf den Karten

05:49.430 --> 05:52.630
ist und da steht dann halt 15 Dollar bei der einen, aber das könnte ja

05:52.630 --> 05:54.630
auch nur sein, dass das Webfrontend da was Falsches anzeigt.

05:54.750 --> 05:56.250
Vielleicht ist es ja irgendwo richtig gespeichert.

05:56.470 --> 05:57.170
Also was muss man machen?

05:57.730 --> 06:00.790
Starbucks gehen und da tatsächlich was kaufen im Wert von 15 Dollar.

06:02.230 --> 06:03.450
Und das ist gar nicht so schwierig.

06:03.650 --> 06:06.530
Da braucht man irgendwie ein Sandwich und einen Kaffee.

06:08.490 --> 06:11.610
Und das hat derjenige, der das da zusammen gehackt hat, auch gemacht.

06:11.910 --> 06:16.150
Ganz wichtig, das habe ich hier unten jetzt noch, vorher noch den

06:16.150 --> 06:19.190
Dollar aufladen auf die Karte, weil ansonsten ist man wegen Betruges

06:19.190 --> 06:19.430
dran.

06:19.670 --> 06:22.070
Und das ist in Amerika passiert, das heißt, da ist man dann schon mal

06:22.070 --> 06:24.950
lebenslänglich weg, wenn man ein großes Unternehmen wegen 10 Dollar

06:24.950 --> 06:25.330
betrügt.

06:25.950 --> 06:27.370
Dementsprechend lieber das mal vorher noch machen.

06:27.770 --> 06:32.090
Und das Witzige war, er hat da einfach bei Starbucks eingekauft für 13

06:32.090 --> 06:33.730
,70 Dollar und das hat funktioniert.

06:33.890 --> 06:37.330
Also war offensichtlich tatsächlich 15 Dollar auf diesem Konto.

06:38.050 --> 06:42.790
Hat da wirklich 5 Dollar einfach erschaffen aus dem Nichts und wollte

06:42.790 --> 06:45.470
dann mit jemanden sprechen, um zu sagen, naja, hier können wir

06:45.470 --> 06:46.990
vielleicht mal mit der Technikabteilung sprechen.

06:47.170 --> 06:47.650
Ging gar nicht.

06:47.830 --> 06:49.830
Dann hat er irgendwann eine E-Mail-Adresse bekommen, da hat er da

06:49.830 --> 06:50.430
hingeschrieben.

06:50.930 --> 06:52.430
Dann ist erst mal 10 Tage nichts passiert.

06:52.910 --> 06:56.110
Und nach 10 Tagen kam dann so eine Antwort wie, ja, Betrug und wir

06:56.110 --> 06:57.970
werden Sie verklagen und so weiter und so fort.

06:58.510 --> 06:59.870
Aber keiner hat mal Danke gesagt.

07:00.030 --> 07:03.410
Und das ist eben häufig das Problem, wenn man schon auf der guten

07:03.410 --> 07:06.670
Seite steht und eigentlich so ein White Hacker ist, dass man dann auch

07:06.670 --> 07:10.030
noch eigentlich angeklagt wird für das, was man tut, was ein bisschen

07:10.030 --> 07:10.570
schade ist.

07:10.570 --> 07:16.490
Deshalb, wenn einer von Ihnen diese Karriere anstrebt, immer an solche

07:16.490 --> 07:17.150
Dinge denken.

07:17.370 --> 07:20.170
Ja, hier selber absichern, dass man da nicht irgendwie noch des

07:20.170 --> 07:21.470
Betruges bezichtigt werden kann.

07:21.810 --> 07:24.490
Und für alle anderen, die wahrscheinlich eher auf der anderen Seite

07:24.490 --> 07:27.370
landen, nämlich Systeme zu bauen, die hoffentlich sicher sind.

07:27.990 --> 07:29.450
Du meinst gerade die andere Hackers-Seite?

07:29.590 --> 07:30.230
Nee, nee.

07:31.190 --> 07:32.010
Ach, von mir aus auch.

07:32.870 --> 07:37.410
Wir geben Ihnen gerne das Grundzeug mit dafür, ein richtig guter

07:37.410 --> 07:40.130
Hacker zu werden, indem wir Ihnen zeigen, wie man Systeme richtig baut

07:40.130 --> 07:41.690
und Sie wissen, wo sie kaputt sein könnten.

07:42.390 --> 07:42.930
Ach so, ja.

07:44.230 --> 07:47.210
In dem Fall ist es tatsächlich ja gar nicht so schwierig gewesen.

07:47.690 --> 07:50.030
Und der Blogpost, der dazu war, der war auch so ein bisschen, ja,

07:50.130 --> 07:53.310
jetzt, wo keine Reaktion bei Starbucks passiert ist, könnte ich das ja

07:53.310 --> 07:57.010
einfach machen und mal gucken, wie lange es dauert, bis Starbucks sich

07:57.010 --> 07:57.590
doch mal rührt.

07:58.390 --> 07:59.290
Machen Sie es nicht, ja.

07:59.650 --> 08:02.430
Also es ist dann doch gerade als Informatiker auch ganz gut, mit

08:02.430 --> 08:03.690
ehrlicher Arbeit Geld zu verdienen.

08:04.230 --> 08:06.490
Dementsprechend würde ich Ihnen das jetzt nicht unbedingt empfehlen.

08:07.170 --> 08:09.510
Aber wenn Sie mal auf der anderen Seite stehen, also nicht auf der

08:09.510 --> 08:12.990
schwarzen Hacker-Seite, sondern auf der Entwickler-Seite, denken Sie

08:12.990 --> 08:13.690
an sowas, ja.

08:13.830 --> 08:17.250
Denken Sie zurück an die SVT, denken Sie dann später auch zurück an

08:17.250 --> 08:20.190
die Dinge, die Sie sonst noch lernen werden über Transaktionen und

08:20.190 --> 08:20.610
ähnliches.

08:20.690 --> 08:23.130
Vielleicht beschäftigen Sie sich ja auch später mal im Studium noch

08:23.130 --> 08:23.690
mit Sicherheit.

08:24.650 --> 08:28.090
An all das denken bitte, wenn Sie sowas entwickeln, weil von dieser

08:28.090 --> 08:31.370
Sorte Code ist leider auf dieser Welt viel zu viel im Umlauf und das

08:31.370 --> 08:32.710
muss jetzt nicht noch mehr werden.

08:33.430 --> 08:35.510
Gut, das dazu.

08:36.470 --> 08:38.310
Das war Ende des Quatsches heute.

08:38.810 --> 08:41.390
Jetzt machen wir weiter mit der Übung erst mal.

08:42.050 --> 08:43.770
Wir haben auch noch die EWAL-Folien dabei.

08:44.650 --> 08:49.610
Sie haben uns ja freundlichst evaluiert und das werden wir auch noch

08:49.610 --> 08:51.130
besprechen, allerdings etwas später.

08:51.250 --> 08:53.490
Wir haben uns gedacht, wir machen das jetzt so, wir machen die ersten

08:53.490 --> 09:00.410
vier Übungsaufgaben erst mal durch und dann vor der letzten gibt es

09:00.410 --> 09:03.490
noch mal die Evaluation, die ich natürlich jetzt aufgemacht habe, was

09:03.490 --> 09:04.810
natürlich völliger Quatsch ist.

09:05.330 --> 09:06.190
Ich wollte ja die Übung machen.

09:06.430 --> 09:07.210
Das war so ein Teaser.

09:07.530 --> 09:08.370
Das war ein Teaser, ja.

09:08.730 --> 09:10.030
Also ich habe die Folien wirklich, ja.

09:10.370 --> 09:17.310
Also es wird eine EWAL geben, aber jetzt gibt es erst mal Übungen.

09:17.890 --> 09:21.350
Wir haben als erste Aufgabe klassisch und deshalb haben wir gerade

09:21.350 --> 09:26.330
eben auch mit den Data Races angefangen, immer die Parallelisierung.

09:27.610 --> 09:31.370
Seit letztem Jahr ein bisschen anders, als wir es sonst immer hatten.

09:31.450 --> 09:34.090
Früher gab es immer nur den Parallelisierungswettbewerb, also die

09:34.090 --> 09:36.870
Aufgabe 2 vom aktuellen Übungsblatt.

09:37.370 --> 09:40.530
Das hat mir persönlich aber nicht so gut gefallen, weil das 90 Prozent

09:40.530 --> 09:42.890
der Leute nicht gemacht haben, weil der immer nur steht, machen Sie

09:42.890 --> 09:43.790
mal so schnell wie möglich.

09:44.070 --> 09:44.810
Herzlichen Glückwunsch.

09:45.530 --> 09:48.370
Das hat halt viele Leute abgeschreckt, gerade die Leute, die jetzt

09:48.370 --> 09:50.330
vorher noch nicht so viel mit Parallelisierung gemacht haben.

09:50.630 --> 09:53.330
Und dann war es halt häufig so irgendwie 13 Punkte oder 0.

09:53.330 --> 09:55.670
Das fand ich persönlich immer ein bisschen unfair, deshalb haben wir

09:55.670 --> 09:58.670
uns überlegt, das ein bisschen umzubauen, um zu sagen, wir machen eine

09:58.670 --> 10:01.630
vergleichsweise einfache Parallelisierungsaufgabe.

10:01.690 --> 10:03.970
Ich weiß, dass das fordernd ist, im zweiten Semester sich damit zu

10:03.970 --> 10:07.150
beschäftigen, aber zumindest eine Aufgabe, wo wir klar sagen, an

10:07.150 --> 10:09.270
welchen Stellen und wie zu parallelisieren ist.

10:10.010 --> 10:12.130
Und das hat zumindest letztes Jahr ganz gut geklappt.

10:12.270 --> 10:14.330
Dieses Jahr bin ich leider nicht dazu gekommen, zu schauen, wie viele

10:14.330 --> 10:17.830
tatsächlich abgegeben haben, aber ich hoffe, es waren auch dieses Jahr

10:17.830 --> 10:21.250
wieder ein paar mehr, als das sonst nur bei den reinen

10:21.250 --> 10:23.530
Parallelisierungswettbewerbsaufgaben war.

10:24.230 --> 10:27.350
So, was war jetzt bei Aufgabe 1 zu tun?

10:27.630 --> 10:28.350
Oder machen wir es nochmal anders.

10:28.410 --> 10:29.910
Wer hat denn die Aufgabe 1 gemacht von Ihnen?

10:30.570 --> 10:31.430
Wer war denn so mutig?

10:31.870 --> 10:32.890
Na ja, immerhin ein paar.

10:34.010 --> 10:34.350
Gut.

10:35.670 --> 10:38.530
Dann für die paar erkläre ich kurz, was zu tun war.

10:39.490 --> 10:43.310
Wir wollten unseren Algorithmus zur Berechnung der HDR-Bilder

10:43.310 --> 10:46.010
parallelisieren, weil das offensichtlich viel schneller geht.

10:46.390 --> 10:48.910
Parallelisierung ist gerade in der Bildverarbeitung eigentlich so ein

10:48.910 --> 10:50.370
wunderbares Mittel.

10:50.730 --> 10:52.050
Wird gerade da gerne verwendet.

10:52.110 --> 10:53.030
Es bietet sich einfach an.

10:53.070 --> 10:56.350
Es ist auch schön anschaulich, warum das gut funktioniert.

10:56.530 --> 10:58.370
Wir hatten dieses Mal Matrix-Operationen.

10:58.850 --> 11:01.570
Normalerweise haben wir sowas wie, wir zerschneiden das Bild in

11:01.570 --> 11:04.390
Streifen und parallelisieren darüber.

11:05.770 --> 11:07.870
Das sieht man einfach mal ganz gut, was da zu machen ist.

11:08.090 --> 11:09.250
So, was haben wir dieses Mal gemacht?

11:09.330 --> 11:12.110
Wir haben einmal die Berechnung der Farbkanäle parallelisieren lassen

11:12.110 --> 11:13.250
von Ihnen als Bonusaufgabe.

11:13.670 --> 11:16.770
Das ist irgendwie auch offensichtlich drei Farbkanäle, drei Threads.

11:16.810 --> 11:18.210
Die sind absolut unabhängig voneinander.

11:18.510 --> 11:20.650
Das müsste ja irgendwie gehen, dass man das nebenläufig berechnet.

11:21.110 --> 11:24.190
Dann hatten wir die Matrix-Multiplikation, die ja auch in der

11:24.190 --> 11:28.290
Vorlesung vorgestellt wird, der IJK-Algorithmus umzusetzen.

11:28.430 --> 11:30.430
Und zuletzt sollte man es halt noch lauffähig bekommen.

11:30.590 --> 11:35.310
Also eine HD-Rise-Parallel-Variante bauen, die dann im Grunde die

11:35.310 --> 11:41.150
Aufrufe so weiter delegiert, dass man am Ende auch die tatsächlich

11:41.150 --> 11:43.170
parallelen Ausführungen jeweils hat.

11:43.330 --> 11:45.650
So, und jetzt schauen wir uns mal an, wie das genau aussieht.

11:46.050 --> 11:47.830
Wir fangen mal an mit der Kamerakurve.

11:47.930 --> 11:49.390
Das war, wie gesagt, die Bonusaufgabe.

11:50.210 --> 11:53.090
Im Wesentlichen ist da nicht viel zu tun, außer ein Konstruktor

11:53.090 --> 11:55.710
anlegen, der die die Anzahl der Fäden setzt.

11:56.390 --> 11:59.950
Wir haben zwischendrin noch ein bisschen unsere Oberklasse geändert,

12:00.510 --> 12:02.550
sodass man dort zugreifen konnte.

12:02.710 --> 12:05.250
Man konnte aber an der Stelle auch einfach den Altcode kopieren.

12:06.430 --> 12:07.570
Das waren die zwei Varianten.

12:07.650 --> 12:10.010
Wir haben das zwischendrin versucht, zu kommunizieren.

12:12.090 --> 12:15.290
Das Problem war halt an der Stelle, dass wir, weil jetzt wir das

12:15.290 --> 12:18.310
gebaut haben, die ursprüngliche Variante nicht aufgepasst haben, dass

12:18.310 --> 12:20.750
man das ja brauchen könnte in der parallelen Variante später mal.

12:20.850 --> 12:22.770
Oder wir wussten noch gar nicht, was wir parallelisieren wollen.

12:23.310 --> 12:27.150
Also sehen Sie mal wieder ein klassisches Beispiel für aufgepasst,

12:27.230 --> 12:28.610
wenn man Schnittstellen baut.

12:29.850 --> 12:30.990
So, was ist dann zu tun?

12:31.110 --> 12:35.490
Wir berechnen jetzt wieder die einzelnen Farbkanäle.

12:35.590 --> 12:37.610
Das ist alles Altcode, das ist alles unverändert.

12:37.990 --> 12:40.210
Also auch nicht so richtig schön, wenn man das richtig bauen wollte,

12:40.330 --> 12:42.810
würde man wahrscheinlich auch wieder anfangen mit einer Oberklasse und

12:42.810 --> 12:45.050
mit einer Schablonmethode, wenn man das nicht doppelt baut.

12:45.630 --> 12:47.250
So, und das ist jetzt das, was hier eigentlich passiert.

12:47.330 --> 12:49.910
Wir haben hier einmal die Variante, wir haben zu wenig Fäden, das

12:49.910 --> 12:52.350
heißt 1 oder kleiner übergeben.

12:53.190 --> 12:58.290
Dann machen wir einfach die sequenzielle Variante, rufen einfach

12:58.290 --> 13:04.950
Calculate Channel ganz normal auf, berechnen die einzelnen Kanäle

13:04.950 --> 13:05.590
nacheinander.

13:06.190 --> 13:07.190
Das ist die eine Variante.

13:07.350 --> 13:09.190
Variante 2, wir haben zwei Kanäle.

13:09.490 --> 13:12.970
Da haben wir das so gemacht, gesagt, okay, wir haben einen Faden, der

13:12.970 --> 13:17.330
rot und grün berechnet und wir haben einen, der blau berechnet und

13:17.330 --> 13:17.670
fertig.

13:18.370 --> 13:20.010
Das hätte man natürlich auch anders machen können.

13:20.310 --> 13:23.270
Also wie man das macht, ist eigentlich relativ egal.

13:23.370 --> 13:24.390
Man kann das anders kombinieren.

13:25.030 --> 13:27.170
Auf alle Fälle, wir haben das jetzt halt so gemacht.

13:27.230 --> 13:30.570
Das ist nicht ganz optimal, das ist uns auch bewusst, aber so

13:30.570 --> 13:31.570
funktioniert es auf jeden Fall.

13:31.690 --> 13:35.930
Und jetzt die Variante mit den Fäden, größer gleich 3, dann nehmen wir

13:35.930 --> 13:39.670
eben genau drei Fäden, auch wenn wir da irgendwie 5 angeben, die wir

13:39.670 --> 13:40.410
benutzen könnten.

13:40.510 --> 13:44.910
In der Methode benutzen wir immer genau drei und legen halt für jeden

13:44.910 --> 13:51.810
Faden, für jeden Kanal einen Faden an und berechnen dann dort wieder

13:51.810 --> 13:54.090
die Kanäle und fertig.

13:54.910 --> 13:58.010
In der Aufgabenstellung war gesagt, machen Sie das so, dass es

13:58.010 --> 14:00.690
sinnvoll ist und sinnvoll ist offensichtlich drei Kanäle.

14:01.050 --> 14:05.770
Also wenn Sie nur sowas hier gebaut haben, was einfach nur für drei

14:05.770 --> 14:08.950
Fäden funktioniert und sich sichergestellt haben, dass das entweder

14:08.950 --> 14:12.030
mit drei Fäden funktioniert oder sequenziell und diese zwei Faden

14:12.030 --> 14:15.470
-Variante weggelassen haben oder die ein Faden-Variante, völlig in

14:15.470 --> 14:15.710
Ordnung.

14:15.850 --> 14:18.710
Also unsere Lösung ist hier wieder größer, als es sein müsste.

14:20.250 --> 14:23.510
So, am Ende wieder das, was wir damals auch schon gebaut hatten, mit

14:23.510 --> 14:27.310
dem, wenn es nicht funktioniert hat, dann probieren wir es halt noch

14:27.310 --> 14:32.230
mal und standardmäßig sind es bei uns drei Versuche für die Berechnung

14:32.230 --> 14:33.230
der Kanäle.

14:33.930 --> 14:36.430
Gut, wunderbar.

14:37.870 --> 14:40.370
Das war das Ganze zur Bonusaufgabe.

14:41.570 --> 14:45.630
Nicht so furchtbar spannend, deshalb schauen wir doch gleich mal rein,

14:45.750 --> 14:49.030
wie das jetzt mit der Matrix-Berechnung ist.

14:49.150 --> 14:50.630
Es gibt irgendwo drängende Fragen.

14:52.870 --> 14:53.190
Eine.

14:55.470 --> 14:56.490
Da oben ist eine, ja.

15:01.960 --> 15:04.480
Das ist eine sehr gute Frage, die habe ich auch schon gestellt, weil

15:04.480 --> 15:05.640
ich habe es nicht selber implementiert.

15:06.580 --> 15:09.240
Gebe ich zu, wir haben einen Tutor, der uns bei der Implementierung

15:09.240 --> 15:09.460
hilft.

15:09.520 --> 15:11.160
Ich habe auch gesagt, was ist das denn?

15:14.020 --> 15:20.900
Es gibt wohl den Fall, dass die Berechnung nicht funktioniert, weil

15:20.900 --> 15:26.180
ich ungünstige Samples ziehe und ich dann nicht inventierbare Matrizen

15:26.180 --> 15:26.480
bekomme.

15:26.580 --> 15:27.440
Ich glaube, das war das Problem.

15:28.500 --> 15:32.240
Und dann kann ich nicht weiterrechnen und dann muss ich es halt noch

15:32.240 --> 15:33.420
mal probieren.

15:33.560 --> 15:37.360
Der Fall tritt aber sehr selten auf und deshalb ist bei uns die Magic

15:37.360 --> 15:41.900
Number 3 mit dem Hinweis, machen Sie das im wahren Leben bitte nie so.

15:43.100 --> 15:45.500
Ich bin da selber ehrlich gesagt auch nicht so wirklich glücklich

15:45.500 --> 15:47.940
damit, aber hatte auch auf die Schnelle keine bessere Idee.

15:48.600 --> 15:51.280
Man hätte es natürlich auch machen können, bis es funktioniert und

15:51.280 --> 15:55.820
wahrscheinlich wäre da auch nie ein Fehler aufgetreten, aber man weiß

15:55.820 --> 15:56.200
es halt nicht.

15:56.320 --> 15:59.300
Andere Variante wäre gewesen zu sagen, okay, geht jetzt halt nicht.

15:59.620 --> 16:00.860
Bitte starte es neu oder lass es.

16:02.820 --> 16:04.880
Ich habe ehrlich gesagt keine gute Lösung dafür.

16:05.900 --> 16:06.500
Dann, ja bitte noch.

16:17.250 --> 16:20.890
Ja genau, also er kommt in die Tonne und sagt, wenn die Matrix

16:20.890 --> 16:24.010
inventierbar ist und es kaputt geht und es trotzdem nicht

16:24.010 --> 16:25.230
funktioniert, dann muss irgendwas anderes kaputt sein.

16:25.870 --> 16:28.350
Ja klar, aber das ist nicht der Fall, der hier auftritt.

16:28.490 --> 16:30.490
Also es ist tatsächlich nur, wenn die Matrix nicht inventierbar ist.

16:30.790 --> 16:35.230
Das Problem ist, das passiert sehr selten, aber die Stochastik lehrt

16:35.230 --> 16:36.870
uns, es kann trotzdem jedes Mal wieder passieren.

16:37.070 --> 16:40.570
Also theoretisch könnte das, wenn wir sagen, wir machen so lange bis

16:40.570 --> 16:43.470
die Matrix inventierbar ist, könnte das Programm ewig laufen.

16:44.150 --> 16:45.250
Deshalb ist es bei uns halt 3.

16:45.910 --> 16:48.030
Hat sich als empirischer Wert bewährt.

16:49.430 --> 16:51.910
So gut ist die Lösung aber tatsächlich nicht, das gebe ich zu.

16:53.210 --> 16:59.210
Okay, dann schauen wir mal rein in die Berechnung der Matrizen.

17:00.530 --> 17:03.370
Das haben wir gelöst, das stand ja auch als Hinweis dabei, dass man

17:03.370 --> 17:05.110
das machen könnte mit einem Threadpool.

17:05.430 --> 17:06.970
Schauen wir gleich nochmal drauf, wie das funktioniert.

17:08.050 --> 17:11.950
Auch hier wieder, wenn wir zu wenig Fäden haben, dann bauen wir halt

17:11.950 --> 17:16.070
keinen Threadpool, dann wird es später sequenziell ausgerechnet, was

17:16.070 --> 17:16.910
auch immer wir tun wollen.

17:18.450 --> 17:22.050
Und wenn wir genug Fäden haben, dann bauen wir einen Threadpool und

17:22.050 --> 17:25.710
zwar mit einer festen Größe Anzahl der Threads.

17:26.230 --> 17:28.170
So sieht das dann aus schematisch.

17:28.490 --> 17:33.510
Wir haben hier den Threadpool, in dem Fall für acht Fäden gebaut und

17:33.510 --> 17:37.910
man kann dann Aufgaben definieren und in eine Aufgabenschlange

17:37.910 --> 17:43.830
einreihen und dann sagen hier Threadpool go und was dann passiert,

17:43.930 --> 17:48.470
dann werden die Aufgaben nacheinander an freie Fäden übergeben, die

17:48.470 --> 17:51.970
berechnen, geben eine Ausgabe aus und sobald sie wieder frei sind,

17:52.030 --> 17:53.970
können sie wieder eine neue Aufgabe entgegennehmen.

17:54.330 --> 17:55.690
Das ist sehr schön zu programmieren.

17:55.790 --> 18:01.270
Es ist nicht die unbedingt schnellste Variante, um parallel zu

18:01.270 --> 18:04.290
programmieren, aber es funktioniert hier ziemlich handlich und lässt

18:04.290 --> 18:05.210
sich jetzt auch gut zeigen.

18:06.770 --> 18:09.470
Das kann man also auf jeden Fall tun und es gibt auf jeden Fall auch

18:09.470 --> 18:12.210
eine ordentliche Beschleunigung dadurch.

18:12.830 --> 18:15.950
Ist natürlich insbesondere dann hilfreich, wenn man einfach weiß, man

18:15.950 --> 18:21.430
hat eine deutlich größere Anzahl an Aufgaben, als man an Fäden zur

18:21.430 --> 18:22.070
Verfügung hat.

18:22.350 --> 18:25.910
Also besonders dann natürlich, wenn man vorher nicht weiß, wie groß

18:25.910 --> 18:26.790
die Aufgabenzahl wird.

18:26.870 --> 18:28.990
Die Situation hat man ja tatsächlich sehr häufig.

18:29.650 --> 18:31.930
In unserem Fall hätte man das ja sogar gewusst oder hätte man das ja

18:31.930 --> 18:32.770
sogar beeinflussen können.

18:34.070 --> 18:36.550
Wie funktioniert das jetzt?

18:37.370 --> 18:40.830
Hier unten ist eigentlich der spannende Teil.

18:42.410 --> 18:46.950
Nämlich, wir haben gesagt und auch das wieder als Hinweis, war nicht

18:46.950 --> 18:47.390
gefordert.

18:47.650 --> 18:50.970
Parallele Berechnungen nur dann machen, wenn unsere Matrix auch groß

18:50.970 --> 18:51.490
genug ist.

18:52.530 --> 18:57.270
Und das machen wir deshalb, weil sowohl das Anlegen des Threadpools

18:57.270 --> 19:00.850
als auch die Thread-Erzeugung immer einen gewissen Overhead erzeugt in

19:00.850 --> 19:01.230
Java.

19:01.450 --> 19:05.270
Da müssen Sie ja immer daran denken, wenn Sie Parallelisierung

19:05.270 --> 19:08.210
betreiben, machen Sie das nur, wenn die Problemgröße das auch hergibt.

19:08.610 --> 19:12.330
Also es hilft nix, irgendwie 128 Threads anzulegen, um dann eine 1x1

19:12.330 --> 19:14.490
-Matrix zu berechnen, berechnen zu lassen von einem.

19:15.250 --> 19:16.350
Also das ist irgendwie Quatsch.

19:16.450 --> 19:18.410
Da erzeugen Sie nur Laufzeit, die nix tut.

19:19.130 --> 19:20.090
Deshalb haben wir das gemacht.

19:20.410 --> 19:21.790
Wie gesagt, das war nicht gefordert.

19:22.370 --> 19:24.090
Wer sich darüber Gedanken gemacht hat, sehr schön.

19:24.090 --> 19:28.310
Ansonsten sehen Sie es hier als Hinweis, dass man das beachten sollte.

19:28.970 --> 19:35.230
Und dann gibt es hier unten den Aufruf einer privaten Methode, die das

19:35.230 --> 19:37.870
parallele Multiplizieren tut.

19:37.930 --> 19:42.410
Die sehen wir dann gleich auch noch auf der nächsten Folie.

19:43.590 --> 19:44.790
Was haben wir jetzt hier?

19:44.890 --> 19:51.870
Wir haben hier erstmal den Threadpool angelegt.

19:54.270 --> 19:55.010
Ganz oben.

19:55.190 --> 19:55.610
Ne, da ist er.

20:01.000 --> 20:02.320
Ah, das war vorher schon ein Konstruktor.

20:02.500 --> 20:03.140
Schauen wir nochmal zurück.

20:04.000 --> 20:04.540
Hier schon?

20:04.960 --> 20:05.820
Ah ja, du hast recht.

20:05.940 --> 20:06.860
Natürlich, den haben wir schon gemacht.

20:07.340 --> 20:07.500
Genau.

20:08.400 --> 20:17.160
Was wir jetzt machen, wir haben jetzt hier eine Liste von Threads.

20:17.380 --> 20:21.840
Und wir können dann mit diesen Threads jeweils sagen, für die Anzahl

20:21.840 --> 20:30.000
der Threads berechne oder mache diese Berechnung des Multiplies auf

20:30.000 --> 20:30.680
deinem Teil.

20:30.760 --> 20:36.180
Dafür brauchen wir hier im Grunde den Teil der Matrix, der berechnet

20:36.180 --> 20:36.660
werden soll.

20:37.560 --> 20:41.560
Und das ist dann genau das, worüber später parallelisiert wird.

20:41.700 --> 20:45.360
Also beim IJK-Algorithmus wird über die äußerste Schleife, also über

20:45.360 --> 20:46.500
das I parallelisiert.

20:47.140 --> 20:49.660
Das heißt, das ist genau das, was wir hier übergeben.

20:49.760 --> 20:53.840
Und das sehen wir jetzt hier in der privaten Methode.

20:55.520 --> 20:59.300
Jetzt übergeben wir nämlich, das haben wir gerade eben gesehen, dieses

20:59.300 --> 21:03.860
I -Start und I-End, damit wir wissen, diesen Teil der Schleife, des

21:03.860 --> 21:08.660
IJK -Algorithmus, müssen wir ablaufen als einzelner Thread und dort

21:08.660 --> 21:09.680
die Berechnung durchführen.

21:09.820 --> 21:10.700
Ja, also nochmal zurück.

21:11.020 --> 21:12.220
Das sind genau diese hier.

21:12.420 --> 21:16.360
Also wir berechnen uns für den Thread jeweils den Anteil, den er

21:16.360 --> 21:17.820
berechnen soll.

21:18.840 --> 21:22.160
Und dann machen wir einfach ganz normal den IJK-Algorithmus, wie man

21:22.160 --> 21:25.980
ihn in jedem Lehrbuch findet oder auf jeder Internetseite, wenn man

21:25.980 --> 21:27.440
nach IJK googelt.

21:28.580 --> 21:28.800
Genau.

21:31.140 --> 21:32.560
Das, was haben wir noch?

21:33.760 --> 21:34.980
Das ist jetzt schon der nächste Teil.

21:35.080 --> 21:36.360
Wir bleiben mal noch ganz kurz hier stehen.

21:36.520 --> 21:37.940
Gibt es dazu Fragen zum IJK?

21:38.160 --> 21:38.240
Ja.

21:40.080 --> 21:40.500
Genau.

21:40.640 --> 21:44.620
Da müssen Sie halt dafür sorgen, dass Sie, wie das hier passiert bei

21:44.620 --> 21:49.360
unserer Schleife, dass bei der Erzeugung des Threads die richtigen

21:49.360 --> 21:53.460
Variable, die richtigen Argumente übergeben werden.

21:54.600 --> 21:57.740
Die muss man halt an der Stelle tun.

21:57.840 --> 22:01.940
Also Sie können wahrscheinlich nicht einmal fest sagen für alle Fäden,

22:01.980 --> 22:04.360
das ist jetzt Start und das ist Ende, sondern das müssen Sie

22:04.360 --> 22:08.220
offensichtlich berechnen, weil das hängt ja gegebenenfalls von der

22:08.220 --> 22:11.440
Anzahl der Threads ab und von der Problemgröße.

22:11.560 --> 22:14.200
In dem Fall haben wir das natürlich jetzt nicht.

22:14.280 --> 22:16.400
In dem Fall hängt es jetzt nur von der Anzahl der Fäden ab.

22:16.420 --> 22:16.940
Und die stimmt gar nicht.

22:17.020 --> 22:18.580
Wir haben hier immer noch die Rows.

22:18.760 --> 22:20.300
Also es hängt natürlich auch von der Problemgröße ab.

22:23.490 --> 22:28.790
Das Lambda in der Vorschleife, genau, baut das Runnable.

22:32.040 --> 22:32.380
Okay.

22:34.060 --> 22:34.900
Noch mehr dazu?

22:35.200 --> 22:35.780
Da kommt noch eine Frage.

22:37.680 --> 22:42.780
Achso, Sie wollen wissen, ob hier nur aufgerufen wird, aber nicht

22:42.780 --> 22:45.380
gewartet wird, bis alle fertig sind.

22:45.620 --> 22:48.680
Das ist das Schöne, wenn wir so ein Threadpool benutzen, das wird uns

22:48.680 --> 22:49.320
da abgenommen.

22:50.040 --> 22:53.320
Also normalerweise müssten Sie ja starten, enden und joinen wieder.

22:53.820 --> 23:00.240
Das haben wir, glaube ich, auch auf den Folien der Vorlesung.

23:00.280 --> 23:02.420
Wenn Sie den Threadpool benutzen, dann bekommen Sie einfach hinten die

23:02.420 --> 23:04.200
Aufgabenschlange wieder raus.

23:05.920 --> 23:10.800
Ja, der Threadpool lebt so lange, wie Sie ihn nicht beenden, oder?

23:11.760 --> 23:13.460
Der Hauptfaden muss halt weiterlaufen.

23:13.640 --> 23:14.840
Genau, der Hauptfaden läuft halt weiter.

23:14.840 --> 23:15.800
Der Hauptfaden muss weiterlaufen.

23:15.880 --> 23:18.140
Wenn der beendet ist, der Mainfaden, dann sind natürlich alle

23:18.140 --> 23:20.440
Hintergrundfäden vom Threadpool auch beendet.

23:21.980 --> 23:23.540
Das müssen Sie halt sicherstellen.

23:26.320 --> 23:29.720
Aber die Ergebnisse bekommt man halt auch vorher schon, die

23:29.720 --> 23:30.360
Ergebnisschlange.

23:32.320 --> 23:35.260
Okay, so, jetzt müssen wir noch dafür sorgen, dass das Ganze auch

23:35.260 --> 23:39.900
irgendwie funktioniert in unserem Ökosystem.

23:40.060 --> 23:46.440
Bisher haben wir nur die einzelnen Kanäle parallelisiert und die

23:46.440 --> 23:47.940
Matrixmultiplikation.

23:48.480 --> 23:51.680
Und jetzt wollen wir natürlich, dass wir auch unser HDRIs parallel

23:51.680 --> 23:52.420
aufrufen können.

23:52.680 --> 23:53.960
Das ging ja bisher jetzt von außen nicht.

23:54.040 --> 23:56.540
Das war jetzt die Aufgabe D, glaube ich, genau.

23:57.620 --> 24:00.760
Und da muss man jetzt im Grunde einfach nur sehen, dass man an die

24:00.760 --> 24:02.900
richtigen Stellen delegiert und an einer Stelle ein bisschen

24:02.900 --> 24:03.340
aufpassen.

24:03.440 --> 24:04.240
Da wird es dann ein bisschen tricky.

24:04.360 --> 24:04.980
Das sehen wir gleich.

24:05.680 --> 24:09.740
Und zwar gleich hier schon auf der nächsten Folie.

24:09.820 --> 24:11.600
Hier nochmal, das war einfach gefordert.

24:11.700 --> 24:15.700
Wir wollen einen Standardkonstruktor haben, der sagt, nimm so viele

24:15.700 --> 24:18.100
Prozessoren, wie du zur Verfügung hast.

24:18.180 --> 24:21.260
Und da gibt es einfach genau diesen Aufruf, der uns diesen

24:21.260 --> 24:22.680
Systemparameter gibt.

24:23.260 --> 24:27.700
Und netterweise gibt uns dieser Aufruf sogar die virtuellen

24:27.700 --> 24:28.400
Prozessoren mit.

24:28.580 --> 24:33.020
Also wenn Sie irgendwie einen Vierkerner mit Hyper-Threading haben,

24:33.240 --> 24:35.180
dann bekommen Sie an der Stelle eine 8 zurückgeliefert.

24:35.560 --> 24:36.620
Also da ist man einfach schon fertig.

24:36.760 --> 24:37.900
Mehr muss man tatsächlich nicht tun.

24:38.280 --> 24:41.120
Es ist ziemlich komfortabel.

24:41.220 --> 24:43.480
Genau, ansonsten sollte ja noch ein Konstruktor angelegt werden, bei

24:43.480 --> 24:46.320
dem man einfach fest sagen kann, das soll jetzt die Anzahl der Threads

24:46.320 --> 24:46.520
sein.

24:47.840 --> 24:50.520
So, und jetzt kommt der spannende Teil.

24:50.700 --> 24:54.540
Jetzt musste man das Create RGB neu bauen und das sollte im

24:54.540 --> 24:56.380
Wesentlichen so aussehen wie das alte auch.

24:57.000 --> 25:02.500
Nur müssen wir jetzt natürlich sehen, dass wir dieses Create Curve

25:02.500 --> 25:06.780
anders aufrufen und zwar an zwei Stellen.

25:07.580 --> 25:12.360
Wir wollen ja jetzt hier einmal das Parallel machen.

25:12.360 --> 25:13.700
Wo sieht man das eigentlich?

25:14.340 --> 25:14.760
Gar nicht.

25:16.080 --> 25:18.560
Ja, dass das eine parallele Kamerakurve ist.

25:24.580 --> 25:29.380
Also, weshalb ich diese Zeile gehighlighted habe, ist, weil da ein

25:29.380 --> 25:31.920
Problem auftritt, wenn wir das mit unserer Implementierung, so wie wir

25:31.920 --> 25:34.320
das gebaut haben, aufrufen würde.

25:34.500 --> 25:38.920
Und zwar haben wir ja gesagt, wir wollen in der Bonusaufgabe jeden

25:38.920 --> 25:40.180
Kanal einzeln berechnen.

25:40.280 --> 25:42.620
Jetzt ist das Problem, dass in der Kanalberechnung die

25:42.620 --> 25:44.280
Matrixmultiplikation benutzt wird.

25:44.800 --> 25:47.280
Das heißt also, wenn wir das einfach so benutzen, wie wir es gerade

25:47.280 --> 25:53.580
gebaut haben, dann bauen wir hier einen Faden pro zu berechnenden

25:53.580 --> 25:58.080
Kanal und dann jeweils noch mal so viele Fäden, also noch mal zum

25:58.080 --> 26:01.160
Beispiel 8, wenn wir vorher 8 ausgelesen haben, pro

26:01.160 --> 26:04.840
Matrixmultiplikation.

26:05.020 --> 26:12.960
Das heißt, wir haben am Ende irgendwie das in den Griff bekommen.

26:13.140 --> 26:15.900
Es gibt ja unterschiedliche Varianten, das schön zu machen.

26:16.140 --> 26:19.380
Wir haben das in unserem Fall einfach gemacht, indem wir gesagt haben,

26:19.440 --> 26:24.500
wir haben dann durch diese parallele Berechnung der Kamerakurve haben

26:24.500 --> 26:26.580
wir dreimal so viele Fäden, wie wir hätten haben wollen.

26:26.740 --> 26:30.240
Deshalb nehmen wir unsere geforderten Fäden und teilen die durch drei

26:30.240 --> 26:32.420
nach unten, abgeschätzt die Anzahl der Fäden.

26:33.060 --> 26:35.700
Es gibt viele andere schöne Varianten, wie man das machen kann.

26:35.760 --> 26:36.800
Wir haben da auch andere gebaut.

26:36.900 --> 26:39.660
Man kann das auch in der Matrix noch aufräumen, in der

26:39.660 --> 26:41.000
Matrixberechnung noch aufräumen.

26:41.820 --> 26:47.620
Man kann es beim Aufruf des parallelen Berechnung der Farbkanäle kann

26:47.620 --> 26:48.580
man das auch noch aufräumen.

26:48.680 --> 26:49.900
Also es gibt unterschiedliche Varianten.

26:50.280 --> 26:53.420
Das ist jetzt die, die am besten funktioniert, wenn man entweder das

26:53.420 --> 26:55.260
eine gebaut hat oder das andere.

26:55.620 --> 26:58.800
Also das hat am wenigsten Einfluss, wenn man die Bonusaufgabe nicht

26:58.800 --> 26:59.220
gemacht hat.

26:59.300 --> 27:00.040
Deshalb haben wir das so gemacht.

27:00.040 --> 27:02.160
Ein Kommilitone hat einen besseren Vorschlag.

27:02.900 --> 27:03.320
Eine Frage.

27:05.980 --> 27:12.320
Also ihr Kommilitone sagt, er war besonders fleißig und hat das auch

27:12.320 --> 27:12.820
noch vermessen.

27:13.360 --> 27:17.980
Und bei ihm war es am schnellsten, wenn er das nicht gemacht hat,

27:18.000 --> 27:21.520
sondern weil er einfach gesagt hat, zum Beispiel für acht Fäden und

27:21.520 --> 27:30.180
für die drei Kanäle, dann waren es halt 24 Fäden und das war trotzdem

27:30.180 --> 27:33.420
noch schneller, als wenn er das extra so gemacht hat, dass es sich wie

27:33.420 --> 27:34.940
hier runterrechnet.

27:37.840 --> 27:40.300
Müsste man glaube ich im Detail reinschauen, warum das so ist.

27:40.520 --> 27:43.460
Ich kann mir vorstellen, dass es so ist und zwar hauptsächlich

27:43.460 --> 27:47.480
deshalb, weil die Problemgröße ja doch relativ groß war.

27:47.800 --> 27:51.500
Das heißt also, der Overhead durch das Erzeugen des Threadpools ist

27:51.500 --> 27:53.860
wahrscheinlich gar nicht so groß, zumal es ja egal ist, ob wir den

27:53.860 --> 27:57.980
Threadpool anlegen für acht oder für drei Fäden.

27:58.560 --> 28:01.580
Und dann könnte es tatsächlich sein, dass wir schätzen das ja hier

28:01.580 --> 28:05.420
nach unten ab, dass unsere Threadpools für die Berechnung der Matrizen

28:05.420 --> 28:10.000
dadurch zu klein werden, dass wir im Grunde immer einen Teil haben,

28:10.120 --> 28:12.900
der warten muss, weil der Threadpool nach unten abgeschätzt ist und

28:12.900 --> 28:13.900
dann dadurch zu klein ist.

28:14.300 --> 28:15.880
Das könnte sein, dass das der Effekt ist.

28:15.980 --> 28:18.180
Vielleicht funktioniert, wenn man es nach oben abschätzt, besser.

28:19.260 --> 28:22.340
Sie sollten aber wahrscheinlich eh keinen großen Unterschied sehen

28:22.340 --> 28:25.480
zwischen der Ausführung, also vorausgesetzt, Sie haben korrekt

28:25.480 --> 28:29.100
parallelisiert sehen Sie wahrscheinlich eh keinen großen Unterschied

28:29.100 --> 28:32.620
zwischen acht und 24 Fäden, wenn Sie acht echte Fäden haben.

28:33.200 --> 28:37.020
Also so viel Overhead wird dann doch nicht erzeugt.

28:38.280 --> 28:42.100
Und dann denke ich mal, ist der Verschnittfaktor wahrscheinlich das

28:42.100 --> 28:44.320
größere Problem, könnte ich mir vorstellen.

28:44.800 --> 28:49.880
Aber das ist jetzt nur so ein erstes Raten, warum das so ist, müsste

28:49.880 --> 28:51.200
man da noch mal genau reinschauen.

28:52.360 --> 28:54.220
Okay, sonst noch Fragen, Anmerkungen?

28:55.420 --> 28:57.260
Nee, es werden dann drei Threadpools angelegt.

28:57.360 --> 29:02.080
Es wird ja jeder Faden, also jeder legt ja dann wieder selber, also je

29:02.080 --> 29:03.120
nachdem, wie Sie implementiert haben.

29:03.200 --> 29:04.540
Ich kann ja jetzt nicht sagen, wie das bei Ihnen ist.

29:05.500 --> 29:08.540
In unserer Implementierung müsste das so sein, ja.

29:12.740 --> 29:15.780
Insofern, ja, also da werden tatsächlich dann drei Threadpools mit

29:15.780 --> 29:18.860
jeweils acht angelegt, wenn wir es einfach so benutzen, wie wir es

29:18.860 --> 29:19.940
gebaut haben.

29:20.260 --> 29:23.460
Aber auch hier gilt wieder, wenn Sie das übersehen haben und nicht

29:23.460 --> 29:25.240
gemacht haben, ja, völlig egal.

29:25.500 --> 29:28.060
Weil also das ist was, das fällt einem irgendwie so auf, nach drei

29:28.060 --> 29:30.360
Tagen an den Problemen rumschrauben, dass da plötzlich irgendwie mehr

29:30.360 --> 29:31.360
Fäden sind, als man denkt.

29:31.720 --> 29:34.800
Das würden wir jetzt tatsächlich nicht erwarten, dass man das, wenn

29:34.800 --> 29:37.860
man das erste Mal mit Parallelität hantiert, dass man einem das

29:37.860 --> 29:38.300
auffällt.

29:44.480 --> 29:47.840
Nee, also es wird tatsächlich in unserer Implementierung zumindest

29:47.840 --> 29:50.620
jeweils ein Threadpool dann angelegt für die Pro-Kanal.

29:52.640 --> 29:54.240
Okay, gut.

29:55.060 --> 29:56.220
Was müssen wir noch machen?

29:56.400 --> 29:57.600
Ah, hier sieht man es jetzt, genau.

29:57.740 --> 30:01.580
Wir müssen noch diese parallele Kamerakurve haben, genau.

30:01.780 --> 30:06.940
Und an der Stelle wird dann eben unser Matrix-Calculator, den wir

30:06.940 --> 30:10.580
jetzt gerade mit Threadanzahl Drittel gebaut haben, übergeben.

30:12.720 --> 30:14.400
Okay, das ist alles, was man tun musste.

30:14.680 --> 30:17.820
So ein paar delegierende Schritte, damit dann auch das aufgerufen

30:17.820 --> 30:19.260
wird, was man haben will.

30:20.160 --> 30:21.640
Das war schon die ganze Aufgabe.

30:22.820 --> 30:25.700
Wer ist denn der Meinung, dass es hinbekommen hat, die Aufgabe 1?

30:26.460 --> 30:28.900
Der Selbstbewusste, die sich sehr schnell gemeldet haben.

30:28.980 --> 30:29.280
Sehr schön.

30:29.360 --> 30:30.140
Ein paar Zögerliche noch.

30:30.580 --> 30:32.260
Okay, sehr schön.

30:33.160 --> 30:36.140
Ist wie gesagt ein wichtiges Thema und ich weiß, ein bisschen

30:36.140 --> 30:39.180
schwierig im zweiten Semester, aber man wird sich damit beschäftigen

30:39.180 --> 30:39.640
müssen.

30:39.840 --> 30:44.360
In der aktuellen Arbeitswelt ist es doch sehr weit verbreitet, dass

30:44.360 --> 30:45.500
man das auch können muss.

30:46.520 --> 30:47.560
Okay, gut.

30:48.000 --> 30:49.500
Zweite Aufgabe war Parallelisierungswettbewerb.

30:50.820 --> 30:54.000
Das wird unsere Testumgebung sein.

30:55.460 --> 30:58.060
Vielleicht benutzen wir noch einen zweiten Rechner, je nachdem, ob die

30:58.060 --> 30:59.280
Zeit dafür nächste Woche reicht.

30:59.380 --> 31:00.440
Und das ist jetzt auch schon der Hinweis.

31:00.760 --> 31:02.640
Wir können Ihnen das jetzt leider noch nicht liefern, wer da der

31:02.640 --> 31:03.160
Gewinner ist.

31:04.200 --> 31:06.920
Das liegt einfach daran, dass Abgabe am Mittwoch war.

31:07.200 --> 31:10.960
Ja, dann müssen erstmal die Tutoren jeweils herausfinden, wer denn bei

31:10.960 --> 31:13.320
Ihnen der schnellste war, weil wir können nicht alle Abgaben

31:13.320 --> 31:13.780
anschauen.

31:14.560 --> 31:15.420
Das dauert halt einen Moment.

31:16.040 --> 31:18.880
Und wenn wir dann irgendwie so zehn, zwölf Kandidaten haben, dann

31:18.880 --> 31:20.400
schauen wir uns die alle im Detail an.

31:20.920 --> 31:24.820
Und dann gibt es in der letzten Vorlesung die Siegerehrung dazu.

31:25.680 --> 31:28.180
Wer von den hier Anwesenden hat das denn gemacht überhaupt,

31:28.580 --> 31:30.140
Parallelisierungswettbewerb?

31:30.540 --> 31:32.640
Ja, wenn das nur die wären, dann hätten wir auch heute schon die

31:32.640 --> 31:33.040
Ergebnisse.

31:33.740 --> 31:35.420
Ja, aber es sind tatsächlich ein paar mehr.

31:35.560 --> 31:36.560
Also ganz so einfach ist es nicht.

31:37.620 --> 31:40.060
Okay, also tut mir leid, da müssen Sie sich noch kurz gedulden.

31:40.340 --> 31:43.960
Dafür gibt es dann nochmal ein paar hübsche Folien mit, wie schnell

31:43.960 --> 31:49.380
sind denn die unterschiedlichen Leute im Vergleich zueinander und auch

31:49.380 --> 31:51.200
warum ist das denn so schnell.

31:51.480 --> 31:52.100
Sie haben noch eine Frage?

31:54.800 --> 31:57.140
Ist schon bekannt, was man gewinnen kann, fragt ihr Kommilitone.

31:57.260 --> 31:58.080
Ja, ist uns bekannt.

32:02.400 --> 32:03.260
Ja, Informatiker.

32:04.440 --> 32:05.860
Das ist die Antwort, die man dann kriegt.

32:06.560 --> 32:09.180
Nein, also Sie wollen wahrscheinlich gerne wissen, was es zu gewinnen

32:09.180 --> 32:09.460
gibt.

32:09.740 --> 32:11.600
Dann will ich mir nicht weiter auf die Folter spannen.

32:11.700 --> 32:14.400
Es wird einen Amazon-Gutschein geben für den Gewinner.

32:14.980 --> 32:16.620
Ich weiß leider nicht mehr die Höhe.

32:16.740 --> 32:21.060
Das ist tatsächlich mir jetzt gerade nicht bekannt, aber es ist ganz

32:21.060 --> 32:23.900
nett, sage ich mal so, sowas zu bekommen.

32:24.400 --> 32:28.140
Und was es natürlich auch gibt, ist hier die große Auszeichnung vor

32:28.140 --> 32:28.380
allem.

32:28.620 --> 32:30.220
Ja, Händedruck von Professor Tichy.

32:32.980 --> 32:34.640
Nennung des Namens auf YouTube.

32:34.640 --> 32:35.780
Also was will man mehr?

32:36.680 --> 32:40.500
Also ein Traum von einer Preisverleihung.

32:41.840 --> 32:48.440
Okay, nochmal kurz zurück zum Ernst des Lebens und damit zu Martin.

32:50.640 --> 32:55.720
Wir hatten noch drei weitere Aufgaben auf dem Übungsblatt und zwar

32:55.720 --> 32:58.280
zunächst erstmal, was war das eigentlich?

32:59.040 --> 32:59.680
Äquivalenzklassen.

32:59.860 --> 33:00.800
Wunderbar, genau.

33:01.400 --> 33:04.140
Funktionales Testen war die Aufgabe, Aufgabe 3.

33:04.980 --> 33:09.200
Wir hatten Ihnen so eine Schnittstelle gegeben, dieses i-Konto und

33:09.200 --> 33:14.280
hatten Sie dann gebeten, Äquivalenzklassen zu bestimmen und später

33:14.280 --> 33:16.980
auch Grenzwerte für Ihre Äquivalenzklassen zu bestimmen.

33:17.700 --> 33:20.980
Wenn Sie da ein bisschen in den Java-Doc reinschauen, dann fällt Ihnen

33:20.980 --> 33:22.160
vielleicht ein bisschen was auf.

33:23.680 --> 33:26.780
Dieser Betrag, dieser abzuhebende Betrag ist schon mal als größer

33:26.780 --> 33:27.780
gleich 0 definiert.

33:28.460 --> 33:31.180
Ich könnte Sie darauf hinweisen, dass wenn da jemand kleiner 0

33:31.180 --> 33:34.440
eingibt, dass das vielleicht dann zu einem Fehler führen sollte.

33:35.360 --> 33:36.800
Gleiches gilt für den Kreditrahmen.

33:36.940 --> 33:38.760
Auch der ist als größer gleich 0 definiert.

33:38.900 --> 33:41.140
Das heißt auch hier wäre es natürlich sinnvoll, wenn man jetzt testet,

33:41.200 --> 33:43.740
was passiert, wenn einer etwas kleiner 0 eintippt.

33:44.680 --> 33:48.880
Was vielleicht noch auffällt, diese eine Methode hat zwei Parameter

33:48.880 --> 33:52.400
Betrag und Kreditrahmen, aber zusätzlich gibt es hier oben noch diesen

33:52.400 --> 33:53.160
Kontostand.

33:53.800 --> 33:56.220
Dieser Kontostand scheint auch irgendwie wichtig zu sein, wenn Sie

33:56.220 --> 34:01.320
testen wollen, weil der halt eben das Ergebnis so oder so beeinflussen

34:01.320 --> 34:01.620
kann.

34:02.240 --> 34:05.460
Das heißt, Sie müssen sich diese drei Parameter in irgendeiner Form

34:05.460 --> 34:07.600
anschauen und nicht nur die zwei von dieser Methode.

34:08.040 --> 34:11.720
Das heißt, der Zustand dieses Kontos wird halt eben maßgeblich durch

34:11.720 --> 34:12.780
den Kontostand bestimmt.

34:13.420 --> 34:15.060
Ich glaube, das wissen Sie aus Ihrer eigenen Erfahrung.

34:15.640 --> 34:17.320
Ist nicht ganz uninteressant.

34:18.360 --> 34:19.540
Gut, also Eingabe.

34:19.660 --> 34:22.460
Die direkte Eingabe ist eben einmal dieser Betrag und der

34:22.460 --> 34:23.100
Kreditrahmen.

34:24.240 --> 34:27.740
Das heißt, was sich hier anbietet, das sind die Äquivalenzklassen.

34:27.940 --> 34:32.360
Einmal, wir haben hier uns total aus dem Fenster gehen, haben B für

34:32.360 --> 34:34.320
Betrag genommen und KR für Kreditrahmen.

34:34.920 --> 34:38.080
Und einmal soll das Ganze positiv sein, also soll es funktionieren

34:38.080 --> 34:39.420
oder halt eben nicht.

34:40.200 --> 34:43.720
Gut, die gültige Eingabe von dem Betrag ist halt eben dann erreicht,

34:43.800 --> 34:45.820
wenn man größer gleich 0 eintippt.

34:46.020 --> 34:48.980
Das heißt, 0 wäre da wahrscheinlich so eine Zahl, die man testen

34:48.980 --> 34:49.220
wollte.

34:51.000 --> 34:54.040
Ungültige Eingabe von Betrag haben Sie genau dann, wenn Sie etwas

34:54.040 --> 34:55.560
kleiner 0 machen.

34:57.080 --> 34:59.020
Das gleiche gilt dann eben auch beim Kreditrahmen.

34:59.360 --> 35:03.680
Auch der sollte entweder mit Größe gleich 0 getestet werden und einmal

35:03.680 --> 35:04.760
mit kleiner 0.

35:05.900 --> 35:07.420
Das ist schon ein bisschen vorweggenommen.

35:07.860 --> 35:10.520
Auch eine indirekte Eingabe haben Sie.

35:10.580 --> 35:14.820
Das ist halt eben dieser Zustand, dieser Kontostand, der Ihnen da

35:14.820 --> 35:15.420
gegeben wird.

35:15.820 --> 35:17.740
Wir brauchen mal neue Batterien von Presento übrigens.

35:19.040 --> 35:19.820
Ach, zeigt immer leer an.

35:19.920 --> 35:20.800
Gut, dann ist es ein Feature.

35:23.200 --> 35:25.720
Das heißt, wir haben hier drei weitere Äquivalenzklassen.

35:25.900 --> 35:27.160
Vielleicht haben Sie noch weitere gefunden.

35:27.280 --> 35:27.820
Kann ja sein.

35:29.100 --> 35:32.460
Zum einen, Kontostand ohne Kreditrahmen ist groß genug für eine

35:32.460 --> 35:33.040
Abhebung.

35:33.740 --> 35:36.360
Also immer dann, wenn Ihr Kontostand eben größer ist als den Betrag,

35:36.460 --> 35:37.720
den Sie abheben möchten.

35:37.820 --> 35:40.160
Sie haben 1000 Euro drauf, möchten 500 Euro abheben.

35:40.580 --> 35:41.720
Sollte kein Problem sein.

35:42.960 --> 35:45.760
Oder der Kontostand ist nur mit dem Kreditrahmen, den Sie haben, groß

35:45.760 --> 35:46.780
genug für die Abhebung.

35:47.400 --> 35:49.700
Sie haben 1000 drauf, möchten 1500 abheben.

35:49.780 --> 35:51.840
Das geht nur dann, wenn Sie 500 überziehen dürfen.

35:52.320 --> 35:55.460
Also wenn Ihr Kreditrahmen mindestens 500 groß ist.

35:56.000 --> 35:58.100
Also das hier wäre dann ein bisschen formalisiert.

35:58.600 --> 35:59.940
Halt eben genau dieses da.

36:01.000 --> 36:04.600
Oder der Kontostand mit Kreditrahmen ist zu gering für die Abhebung.

36:05.020 --> 36:07.800
Also selbst mit Ihrem Limit, was Sie überziehen dürfen, ist es nicht

36:07.800 --> 36:08.860
möglich abzuheben.

36:09.240 --> 36:11.080
Das wäre dann diese dritte Äquivalenzklasse.

36:11.520 --> 36:12.160
Wir hatten eine Frage.

36:13.460 --> 36:14.840
Wir warten die nächste Folie ab.

36:14.940 --> 36:16.080
Wunderbar, dann habe ich schon mal Angst.

36:16.760 --> 36:19.540
Gut, also das sind die Äquivalenzklassen, die wir hier identifiziert

36:19.540 --> 36:19.820
haben.

36:21.640 --> 36:24.320
Jetzt ging es darum, Sie sollten auch Grenzwerte finden.

36:25.080 --> 36:28.040
Bei Geldbeträgen sind die Grenzwerte wahrscheinlich eher im

36:28.040 --> 36:28.620
Centbereich.

36:29.340 --> 36:32.200
Sie können jetzt auch sagen, Sie testen es mit einem Euro statt mit

36:32.200 --> 36:32.700
einem Cent.

36:33.040 --> 36:35.760
Aber ein Cent wäre eigentlich das naheliegendste, weil das direkt der

36:35.760 --> 36:39.560
erste Wert ist, der eben in dem Fall jetzt größer Null wäre.

36:40.220 --> 36:45.380
Das heißt, von gültigem Betrag und gültigem Kreditrahmen genau dann,

36:45.400 --> 36:46.700
wenn die Größe gleich Null ist.

36:46.940 --> 36:50.000
Das heißt, Null ist diese Grenze, die Sie dort eigentlich haben

36:50.000 --> 36:51.820
möchten, dieser Grenzwert.

36:52.420 --> 36:55.500
Und ungültig ist es halt eben dann genau ein Cent daneben.

36:55.980 --> 36:58.920
Es wäre dann halt eben minus ein Cent jeweils.

37:00.100 --> 37:03.400
Könnte auch ein Euro nehmen, aber das wäre halt eigentlich hier die

37:03.400 --> 37:04.340
korrektere Variante.

37:06.440 --> 37:09.680
Sollte man auch Plus, Minus und Endlich testen bei Big Dezimal?

37:12.320 --> 37:14.000
Da steht die Antwort, ja ist mir egal.

37:14.360 --> 37:16.040
Das ist erstmal ein Test, der überhaupt mitliest.

37:16.480 --> 37:20.500
Wer jetzt sagt, ja und der andere sagt, wollte ich auch sagen, dann

37:20.500 --> 37:21.360
weiß ich die beiden nicht.

37:21.960 --> 37:24.540
Gut, da steht die Antwort natürlich da.

37:25.480 --> 37:26.520
Können Sie nicht testen.

37:26.600 --> 37:28.100
Big Dezimal kann beliebig groß werden.

37:28.180 --> 37:30.100
Sie können auch sagen, wie genau das werden soll.

37:30.760 --> 37:32.160
Dementsprechend ist das in dem Fall nicht.

37:32.240 --> 37:35.680
Wenn Sie jetzt irgendwas testen, was ein Integer oder so als Eingabe

37:35.680 --> 37:40.140
Parameter nimmt, dann will man meistens auch MaxInt oder MinInt oder

37:40.140 --> 37:40.500
irgendwas.

37:40.740 --> 37:41.520
Gibt es MinInt?

37:42.940 --> 37:45.100
Also MaxInt mit Vorzeichen, wunderbar.

37:45.640 --> 37:48.580
Testen oder Null testen, in dem Fall hier nicht.

37:52.000 --> 37:52.480
Null.

37:52.720 --> 37:54.460
Null könnte man testen.

37:55.700 --> 37:57.740
Haben wir gesagt, ja könnte man machen.

37:58.460 --> 38:01.320
Nehmen wir auch an als extra Äquivalenzklasse.

38:01.460 --> 38:04.360
Würden wir aber nicht fordern wollen an der Stelle, weil es hier nur

38:04.360 --> 38:06.240
um numerische Werte geht.

38:06.340 --> 38:08.760
Das ist streng genommen keine Äquivalenzklasse, aber sicherlich ein

38:08.760 --> 38:09.960
sinnvoller Test, den man machen sollte.

38:10.260 --> 38:12.200
Also wenn ich eine Bank wäre, möchte ich so einen Test haben.

38:12.300 --> 38:13.340
Da gebe ich Ihnen auf jeden Fall recht.

38:14.720 --> 38:16.040
Ich versuche Ihnen zu folgen.

38:16.180 --> 38:18.600
Also Sie meinen den zweiten zusammenfassen mit dem da hier?

38:19.340 --> 38:21.500
Ja, aber die Umkehrung gilt ja nicht, oder?

38:21.540 --> 38:23.640
Wenn der Betrag gültig ist und der Kreditrahmen ungültig.

38:25.420 --> 38:28.120
Sie meinen jetzt, also aus inhaltlichen Gründen würde ich Ihnen da

38:28.120 --> 38:31.820
vielleicht recht geben wollen, aus ich lese das Javadoc und möchte

38:31.820 --> 38:33.620
gerne das tun, was im Javadoc steht.

38:33.960 --> 38:34.360
Eher nicht.

38:37.080 --> 38:40.580
Das stört mich an der Stelle ein bisschen, weil im Javadoc steht, es

38:40.580 --> 38:45.020
sollen oder Kreditrahmen soll größer Null sein.

38:45.700 --> 38:48.080
Größer gleich Null und Betrag soll größer gleich Null sein.

38:48.200 --> 38:53.360
Also würde ich erwarten, dass an der Stelle eine Ausnahme ausgelöst

38:53.360 --> 38:54.920
wird oder was auch immer.

38:55.420 --> 38:59.020
Und das würde ich dann eigentlich auch einzeln anschauen wollen.

39:00.240 --> 39:03.160
Für die einzelnen Parameter, das ist das, was im zweiten Schritt dann

39:03.160 --> 39:03.720
passiert.

39:04.140 --> 39:09.400
Also, dass man im Grunde Wertebereiche hat für einzelne Parameter,

39:09.600 --> 39:13.180
sich aber dann zusammen Äquivalenzklassen ergeben.

39:13.600 --> 39:16.580
Aber man kann natürlich auch Äquivalenzklassen für einzelne Parameter

39:16.580 --> 39:16.740
haben.

39:16.800 --> 39:21.120
Sie können natürlich auch da oben sagen, also ja, man könnte das auch

39:21.120 --> 39:21.580
zusammenfassen.

39:21.700 --> 39:22.420
Vielleicht sollte man das auch.

39:22.480 --> 39:24.700
Dann hat man aber noch mehr Äquivalenzklassen.

39:25.020 --> 39:29.140
Dann könnten Sie zum Beispiel prüfen, ob Betrag und Kreditrahmen

39:29.140 --> 39:30.500
gleichzeitig ungültig sind.

39:31.600 --> 39:35.000
Aber dann fallen die Äquivalenzklassen, die wir jetzt haben, nicht

39:35.000 --> 39:38.440
weg, sondern das sind dann einfach nur noch mehr und Sie bauen dann im

39:38.440 --> 39:40.800
Grunde Parameter dazu, die Sie nicht brauchen für den Test.

39:40.940 --> 39:45.360
Also ja, könnte man machen, finde ich aber in dem Fall zu viel.

39:46.160 --> 39:48.480
Also das ist eher schon so die Untergrenze.

39:50.200 --> 39:51.440
Jetzt haben wir zwei Fragen.

39:51.880 --> 39:53.800
Wenn es zu der Folie ist, würde ich die Folie erst vorstellen.

39:54.060 --> 39:58.080
Ansonsten zu einer davor.

39:58.440 --> 39:59.300
Gut, ich blättere.

40:00.660 --> 40:02.820
Ja, ja, ich verstehe, was Sie meinen.

40:02.940 --> 40:06.500
Also es ist entweder gültig oder nicht, weil entweder kann ich mein

40:06.500 --> 40:07.840
Konto belasten oder nicht.

40:07.900 --> 40:09.220
Es gibt nur diese zwei Möglichkeiten.

40:09.680 --> 40:13.840
Ja, schon, aber es gibt ja zwei Parameter, die das beeinflussen.

40:15.080 --> 40:19.040
Und deshalb möchte man da schon eine extra Äquivalenzklasse haben,

40:19.580 --> 40:22.940
weil Sie ja testen möchten, wie das Programm sich verhält.

40:23.280 --> 40:28.220
Es könnte ja sein, dass die Implementierung den Kreditrahmen

40:28.220 --> 40:28.980
ignoriert.

40:29.540 --> 40:33.220
Wenn Sie dann nur den einen Test machen mit Betrag positiv, weil das

40:33.220 --> 40:36.340
ist ja alles gut, Kreditrahmen ignorieren, weil brauchen wir nicht,

40:36.400 --> 40:37.660
ist ja gleiche Äquivalenzklasse.

40:38.480 --> 40:40.680
Dann haben Sie an der Stelle einen Test zu wenig.

40:40.880 --> 40:43.040
Nämlich der, den der Kreditrahmen mit betrachtet.

40:44.120 --> 40:48.460
Nee, nee, nee, deshalb variieren wir ja die Äquivalenzklassen über die

40:48.460 --> 40:49.500
Eingabe -Parameter.

40:49.920 --> 40:54.440
Wir wissen, dass Kreditrahmen und Betrag und der ursprüngliche

40:54.440 --> 40:55.700
Kontostand einen Einfluss haben.

40:55.820 --> 40:58.760
Also versuchen wir, diese drei Sachen so zu variieren, dass sie

40:58.760 --> 41:02.220
gemeinsam in unterschiedlichen Bereichen landen.

41:02.280 --> 41:04.680
Das ist das, was wir jetzt gleich hier auf diesem auf diesem Strahl

41:04.680 --> 41:05.660
sehen.

41:05.880 --> 41:09.240
Und das erreichen Sie nicht, wenn Sie nur die zwei Äquivalenzklassen

41:09.240 --> 41:09.980
bilden.

41:10.740 --> 41:13.180
Das ist halt das Problem, was da entsteht.

41:13.520 --> 41:16.960
Da verdecken Sie im Grunde den Kreditrahmen oder können den

41:16.960 --> 41:21.240
Kreditrahmen nicht mehr unabhängig von dem absehbenden Betrag testen.

41:21.400 --> 41:23.480
Also Sie übersehen dann gegebenenfalls einen Fehler.

41:25.980 --> 41:26.380
Eine Frage?

41:34.040 --> 41:35.140
Ja, ja, ja.

41:37.820 --> 41:41.280
Also Ihr Kommilitone beschwert sich, ist ein bisschen schwammig auf

41:41.280 --> 41:43.420
den Folien zur Vorlesung.

41:43.920 --> 41:45.460
Bin ich fast geneigt, Ihnen recht zu geben.

41:45.520 --> 41:46.740
Die sind sicherlich nicht optimal.

41:46.880 --> 41:49.220
Deshalb haben wir versucht, extra so ein greifbares Beispiel zu

41:49.220 --> 41:53.100
nehmen, was jeder schon mal hatte im roten Bereich des Kontos.

41:53.160 --> 41:54.380
Und trotzdem konnte man noch Geld abheben.

41:55.880 --> 41:58.340
Ja, die sind da vielleicht nicht genau genug.

41:58.460 --> 42:00.700
Vielleicht muss man das mal noch ein bisschen klarer machen.

42:00.840 --> 42:03.680
Ist uns jetzt in den letzten zwei Wochen auch aufgefallen, dass das,

42:04.020 --> 42:07.240
was wir mit sehr viel Wissen über den ganzen Kram unter

42:07.240 --> 42:10.540
Äquivalenzklassen verstehen, vielleicht Ihnen durch die Vorlesung

42:10.540 --> 42:11.980
nicht genügend klar geworden ist.

42:12.240 --> 42:14.140
Also ja, könnte tatsächlich sein.

42:14.280 --> 42:17.180
Werden wir auf jeden Fall noch mal anschauen und gegebenenfalls die

42:17.180 --> 42:17.820
Folien anpassen.

42:18.300 --> 42:19.720
Sehe ich nämlich ähnlich.

42:21.020 --> 42:22.360
Okay, sonst noch Fragen?

42:25.280 --> 42:26.780
Da ist noch eine Frage.

42:28.560 --> 42:33.740
Die ersten drei, warum die getrennt sind, oder?

42:41.780 --> 42:43.160
Genau, genau.

42:43.480 --> 42:45.240
Das ist jetzt wieder das, was ich gerade eben schon mit Ihrem

42:45.240 --> 42:46.760
Kommilitonen diskutiert habe.

42:46.940 --> 42:51.560
Also die Kommilitonin merkt an, ja, da haben wir jetzt auch keine

42:51.560 --> 42:54.300
sinnvollen Äquivalenzklassen, weil mein Argument, was ich gerade

42:54.300 --> 42:57.940
gebracht habe, man soll doch bitte die Parameter in Kombination

42:57.940 --> 43:00.880
testen, geht ja da verloren.

43:02.500 --> 43:04.680
Da haben sie ein Stück weit recht.

43:04.900 --> 43:09.080
Man müsste hier eigentlich auch die Kombination bauen, aber dann

43:09.080 --> 43:11.760
fallen die halt wieder zusammen und am Ende bleibt das im Wesentlichen

43:11.760 --> 43:17.080
übrig, weil wir können hier natürlich sagen, wir haben eine ungültige

43:17.080 --> 43:21.200
Eingabe von Betrag und dazu die gültige Eingabe von Kreditrahmen und

43:21.200 --> 43:24.240
dann haben wir noch eine weitere Äquivalenzklasse mit ungültiger

43:24.240 --> 43:29.400
Eingabe von Betrag und ungültige Eingabe von Kreditrahmen, aber die

43:29.400 --> 43:30.760
fallen dann halt eigentlich wieder zusammen.

43:30.960 --> 43:31.960
Deshalb haben wir die weggelassen.

43:32.400 --> 43:34.380
Aber eigentlich haben sie recht, sollte man das so machen.

43:34.540 --> 43:36.320
Sollte man eigentlich sämtliche Kombinationen bauen.

43:36.600 --> 43:37.960
Das ist jetzt eher schon das Zusammengeschobene.

43:38.180 --> 43:41.640
Die Klasse von Fehler ist die gleiche, weil der Fehler eben die

43:41.640 --> 43:44.960
ungültige Eingabe von Betrag ist, aber natürlich sind es mehrere

43:44.960 --> 43:48.260
verschiedene Kombinationen, die dadurch möglich sind, weil die anderen

43:48.260 --> 43:49.400
beiden Parameter egal sind.

43:51.420 --> 43:52.580
Weitere Fragen noch?

43:55.680 --> 43:58.980
Dann spreche ich mal zu dieser schönen Zahlenstrahlfolie.

43:59.460 --> 44:01.520
Ich habe versucht, das Ganze mal ein bisschen zu visualisieren.

44:02.400 --> 44:05.220
Also das hier soll der Kontostand darstellen, KS.

44:05.760 --> 44:09.260
Hier wäre er schön im Plus-Bereich, hier ist er im Minus-Bereich.

44:09.900 --> 44:12.500
Im Endeffekt lässt sich das Ganze so ein bisschen in drei Teile

44:12.500 --> 44:13.120
einteilen.

44:14.820 --> 44:17.940
Zum einen Kontostand ohne Kreditrahmen ist groß genug für die

44:17.940 --> 44:18.560
Abhebung.

44:19.140 --> 44:20.460
Das wäre hier dieser Teil.

44:21.340 --> 44:25.940
Also wenn ich da etwas abheben möchte, dann bin ich immer noch im Plus

44:25.940 --> 44:26.400
-Bereich.

44:26.640 --> 44:27.420
Also das reicht aus.

44:28.020 --> 44:29.080
Dann dieser zweite Fall.

44:29.160 --> 44:31.600
Der Kontostand ist nur mit dem Kreditrahmen groß genug für die

44:31.600 --> 44:32.020
Abhebung.

44:32.400 --> 44:34.640
Das heißt, ich falle unter Null, aber ich habe hier diesen

44:34.640 --> 44:35.440
Kreditrahmen.

44:36.120 --> 44:40.040
Und mit diesem Kreditrahmen, den kann ich ausschöpfen bis zu dem

44:40.040 --> 44:41.560
Rahmen an sich, bis zu der Linie an sich.

44:41.940 --> 44:43.120
Das ist so die zweite Klasse.

44:43.640 --> 44:45.480
Und dann gibt es halt eben noch die, es reicht nicht.

44:45.640 --> 44:49.400
Also selbst wenn ich das Konto überziehe und bis zum Kreditrahmen

44:49.400 --> 44:50.780
gehe, reicht es immer noch nicht.

44:50.840 --> 44:52.080
Ich wäre noch weiter im Minus.

44:53.020 --> 44:56.060
Was Sie hier aber sehen, wenn Sie jetzt testen wollen, Sie möchten die

44:56.060 --> 44:56.940
Grenzen testen.

44:57.040 --> 45:00.180
Also Sie haben irgendwelche Werte bestimmt und sagen, okay die Null

45:00.180 --> 45:01.540
scheint ja wichtig zu sein.

45:02.260 --> 45:05.700
Das jetzt testen mit einem Cent oder mit minus einem Cent.

45:06.100 --> 45:10.980
Sie sehen, wenn Sie eben auf die eine Klasse eins draufhauen oder

45:10.980 --> 45:12.860
wegnehmen, dann rutschen Sie in die andere Klasse.

45:13.020 --> 45:15.400
Das heißt, Sie haben hier einen Überlapp, weil eben die eine

45:15.400 --> 45:18.520
Äquivalenzklasse nahtlos an die andere anschließt.

45:18.780 --> 45:21.640
Das heißt, wenn Sie Tests bauen, würden Sie die Tests bauen, dass Sie

45:21.640 --> 45:26.260
die eben jenseits dieser Trennungen von diesen Äquivalenzklassen bauen

45:26.260 --> 45:26.620
würden.

45:28.880 --> 45:29.320
Genau.

45:29.520 --> 45:32.160
Und auch hier nochmal der Hinweis, eigentlich müsste natürlich da oben

45:32.160 --> 45:44.880
die Äquivalenzklasse heißen, Kontostand positiv, also Betrag größer

45:44.880 --> 45:48.440
Kontostand und Kreditrahmen gültig.

45:49.400 --> 45:51.400
So müsste es eigentlich sein, weil wir eigentlich noch den dritten

45:51.400 --> 45:52.820
Parameter auch mit testen müssen.

45:53.700 --> 45:55.960
Aber das haben wir jetzt hier weggelassen, weil das ist halt da die

45:55.960 --> 45:56.300
Voraussetzung.

45:56.420 --> 45:57.400
Aber eigentlich wäre das so.

45:57.540 --> 45:59.460
Und dann wäre wieder die Umkehrung davon.

45:59.560 --> 46:03.580
Wir variieren den dritten Parameter mit Kreditrahmen ungültig, aber

46:03.580 --> 46:06.620
dann fallen wir wieder in die Äquivalenzklasse mit Kreditrahmen ist

46:06.620 --> 46:09.020
ungültig und das wirft hoffentlich eh immer einen Fehler.

46:09.680 --> 46:11.980
Deshalb haben wir das jetzt hier nicht nochmal mit drin.

46:12.060 --> 46:16.120
Aber eigentlich müsste man natürlich alle einzelnen Parameter

46:16.120 --> 46:19.760
miteinander in allen möglichen Varianten kombinieren, die

46:19.760 --> 46:20.900
Äquivalenzklassen zu bekommen.

46:21.940 --> 46:23.640
Haben Sie noch Fragen zu dieser Aufgabe?

46:26.260 --> 46:27.540
Ja, nein, vielleicht.

46:29.060 --> 46:30.140
Wird noch diskutiert.

46:32.180 --> 46:36.320
Dann kommen wir zu dem Moment, auf den ich mich schon das ganze

46:36.320 --> 46:37.120
Semester über freue.

46:38.220 --> 46:42.000
Zum kontrollflussorientierten Testen.

46:44.080 --> 46:51.320
Das ist ein Testverfahren, was sehr genau Aufschluss darüber gibt, ob

46:51.320 --> 46:55.260
man alles, was man hätte testen können für einen gewissen

46:55.260 --> 46:59.360
Programmausschnitt, meistens Methoden, auch tatsächlich getestet hat.

47:00.160 --> 47:03.120
Und es ist was, worauf bei uns auch in der Vorlesung relativ viel

47:03.120 --> 47:04.100
großen Wert gelegt wird.

47:04.220 --> 47:06.360
Wenn Sie schon Eiklausuren angeschaut haben, werden Sie gesehen haben,

47:06.900 --> 47:09.840
dieses kontrollflussorientierte Testen kommt irgendwie immer vor in

47:09.840 --> 47:10.320
der Klausur.

47:10.500 --> 47:13.560
Deshalb wollen wir das jetzt hier in der Übung auch nochmal relativ

47:13.560 --> 47:14.520
ausführlich machen.

47:16.180 --> 47:20.800
Was muss man oder könnte man tun, wenn man kontrollflussorientiert

47:20.800 --> 47:22.320
testet von Hand?

47:23.440 --> 47:26.000
Dann möchte man vielleicht den Quelltext in Zwischensprache

47:26.000 --> 47:26.540
überführen.

47:27.840 --> 47:29.040
Ich mache das selber nicht.

47:29.900 --> 47:32.640
Ich baue das immer direkt aus dem Code, ohne die Zwischensprache.

47:32.840 --> 47:36.720
Aber am Anfang zur Übung ist das eine tatsächlich gute Variante.

47:36.840 --> 47:39.460
Deshalb führen wir das in der Vorlesung so ein.

47:39.640 --> 47:43.820
Und so die ersten drei, vier, fünf Kontrollflussgrafen, die Sie bauen,

47:44.300 --> 47:47.640
zur Übung würde ich Ihnen auch echt empfehlen, über die

47:47.640 --> 47:50.380
Zwischensprache zu machen, weil die ansonsten einfach Dinge vergessen

47:50.380 --> 47:53.220
oder erstmal grundsätzlich nicht wissen, wie man so eine Schleife

47:53.220 --> 47:53.740
auflöst.

47:54.760 --> 47:55.000
Gut.

47:55.560 --> 47:57.880
Dann fangen nämlich so Dinge an, wie man braucht ja dann irgendwie

47:57.880 --> 47:59.640
diese Sprungziele, die ergeben sich.

47:59.960 --> 48:02.280
Man muss sich überlegen, wie groß sind denn eigentlich die Blöcke,

48:02.400 --> 48:03.100
wann hören die auf?

48:04.540 --> 48:07.580
Und am Ende, wenn man das Ganze fertig gebaut hat, gibt es noch so ein

48:07.580 --> 48:13.020
paar Prüfkriterien, die man noch mal anlegen sollte an seine eigene

48:13.020 --> 48:13.420
Lösung.

48:14.240 --> 48:17.620
Und das ist so was wie, gibt es Pfeile, die in die Mitte eines Blockes

48:17.620 --> 48:21.100
zeigen, dann sollte man wohl davor aufteilen, weil ein Pfeil kann

48:21.100 --> 48:24.220
niemals in die Mitte von einem Block gehen beim Kontrollflussgrafen,

48:24.600 --> 48:26.340
sondern die fangen immer oben an.

48:26.620 --> 48:27.920
Dann nächster Test.

48:28.620 --> 48:31.640
Gibt es leere Blöcke, dann kann man offensichtlich verschmelzen.

48:32.800 --> 48:37.420
Und gibt es irgendwo unbedingte Sprünge, dann kann man gegebenenfalls

48:37.420 --> 48:38.720
Knoten verschmelzen.

48:39.380 --> 48:43.160
Es sei denn, man kommt dann wieder irgendwo mit einem anderen Sprung

48:43.160 --> 48:44.380
in die Mitte von einem Block rein.

48:44.700 --> 48:48.760
Also das Eins und Drei bei diesen Prüfkriterien widersprechen sich

48:48.760 --> 48:50.000
ganz gerne mal.

48:50.220 --> 48:51.240
Also da aufpassen.

48:51.480 --> 48:55.120
Wir sehen das jedes Jahr wieder in der Klausur, dass irgendwie Sprünge

48:55.120 --> 48:57.580
in die Mitte von Blöcken reingehen und dann denkt man sich, das ist

48:57.580 --> 48:59.520
doch eigentlich das einfachste und offensichtlichste, was nie

48:59.520 --> 49:00.180
passieren darf.

49:00.680 --> 49:01.360
Denken Sie da dran.

49:01.620 --> 49:03.360
Auch beim Üben jetzt schon.

49:04.660 --> 49:09.840
Und weil ich ja versuche, mich immer ganz gerne in die Leiden von

49:09.840 --> 49:11.380
Studenten reinzuversetzen.

49:14.260 --> 49:17.520
Ich habe nicht gesagt, dass ich das dann vorher erzeugt habe.

49:17.640 --> 49:19.620
Ja, das ist genau das Leid, was ich vorher erzeugt habe.

49:19.680 --> 49:21.180
In das versuche ich, mich ganz gerne reinzuversetzen.

49:21.840 --> 49:28.280
Und aus diesem Grund versuche ich jetzt mal, diesen KfG von Hand zu

49:28.280 --> 49:28.740
zeichnen.

49:30.020 --> 49:31.540
Jetzt hier live und in Farbe.

49:32.200 --> 49:33.020
Das war die Aufgabe.

49:33.860 --> 49:38.740
Das war ein Ausschnitt aus unserer Identitätsberechnung, ein bisschen

49:38.740 --> 49:41.800
abgewandelt, damit es ein bisschen handlicher ist.

49:44.060 --> 49:49.760
Dann konnte man da auch relativ schnell und hoffentlich einfach einen

49:49.760 --> 49:51.580
KfG daraus bauen.

49:53.020 --> 49:57.840
Wichtig ist, wenn Sie sowas sehen bei der Klausur, wie diese ewig

49:57.840 --> 49:59.140
lange Bedingung da.

49:59.780 --> 50:02.320
Sie werden in der Klausur keine Zeit dafür haben, das komplett

50:02.320 --> 50:03.060
aufzuschreiben.

50:03.620 --> 50:06.780
Kürzen Sie es ab, aber kürzen Sie es bitte sinnvoll ab und eindeutig.

50:06.980 --> 50:12.040
Häufiger haben wir auch mal Sysouts drin für gewisse

50:12.040 --> 50:12.700
Programmausschnitte.

50:12.820 --> 50:13.900
Auch da gilt das gleiche.

50:13.980 --> 50:16.740
Sinnvoll abkürzen, aber so, dass es bitte noch eindeutig bleibt.

50:17.600 --> 50:19.080
Also bitte unterscheidbar.

50:19.240 --> 50:23.260
Wenn es zwei Sysouts gibt und Sie sagen nur Sysout A und B und wir

50:23.260 --> 50:25.540
können es da nicht zuordnen, welches Sysout Sie jetzt wo gemeint

50:25.540 --> 50:27.200
haben, dann können wir das nicht bewerten.

50:27.320 --> 50:30.620
Also bitte so abkürzen, dass es eindeutig ist, welches Sysout.

50:30.640 --> 50:32.400
Und vor allem auch zuordnenbar noch zum Code ist.

50:33.060 --> 50:33.760
Ja, klar.

50:34.140 --> 50:34.340
Genau.

50:34.680 --> 50:36.200
So, da gibt es schon mal zwei Fragen.

50:36.280 --> 50:37.780
Bevor ich überhaupt angefangen habe, besonders schön.

50:37.900 --> 50:38.740
Dann fangen wir bei Ihnen mal an.

50:43.550 --> 50:47.750
Okay, der Kommilitone fragt, ob es sinnvoll ist, die Zwischensprache

50:47.750 --> 50:49.590
zu benutzen in der Klausur.

50:51.730 --> 50:52.690
Kurze Antwort, nein.

50:52.970 --> 50:53.750
Ich würde es nicht machen.

50:53.850 --> 50:54.990
Ich würde es vorher zur Übung machen.

50:55.070 --> 50:56.050
Das ist mein persönlicher Tipp.

50:56.510 --> 50:59.810
Und so viel Sicherheit erlangen vorher schon, dass ich es dann in der

50:59.810 --> 51:01.030
Klausur direkt vom Code kann.

51:02.430 --> 51:05.090
Weil ich glaube, das verbraucht zu viel Zeit.

51:05.190 --> 51:07.430
Wir sehen das jedes Jahr wieder, dass das vereinzelt Studenten machen.

51:07.630 --> 51:08.510
Ich halte es für keine gute Idee.

51:08.630 --> 51:10.410
Dieses Jahr haben wir eine halbe Stunde mehr Zeit in der Klausur.

51:10.910 --> 51:12.870
Vielleicht ist es dann nicht mehr so kritisch, aber ich glaube, die

51:12.870 --> 51:14.770
halbe Stunde kann man auch woanders besser verbrennen.

51:14.930 --> 51:16.190
Insofern, ich würde es nicht machen.

51:16.590 --> 51:17.090
Noch eine Frage?

51:25.640 --> 51:28.560
Also, Ihr Kommilitone fragt, dürfte man auch die Zeilennummern

51:28.560 --> 51:28.940
verwenden?

51:29.500 --> 51:31.900
Und egoistisch, wie ich bin, sage ich nein.

51:32.860 --> 51:35.020
Weil das spart Ihnen einen Haufen Zeit.

51:35.200 --> 51:38.100
Das bereitet mir aber extrem viel Schmerzen beim Korrigieren.

51:39.500 --> 51:41.640
Insofern, sorry, machen wir nicht.

51:42.040 --> 51:45.740
Sie dürfen gerne abkürzen, so viel Sie wollen, solange es

51:45.740 --> 51:47.740
übersichtlich und lesbar bleibt.

51:48.200 --> 51:52.460
Aber es lässt sich halt nicht mehr korrigieren, wenn da halt nur noch

51:52.460 --> 51:56.880
1, 2, 3, 4, 5 in den Kästchen drin steht und ich jedes Mal wieder

51:56.880 --> 51:59.020
rüberschauen muss, war das jetzt das Return?

51:59.140 --> 52:00.540
War das jetzt hier die Zuweisung?

52:02.000 --> 52:04.160
Davon abgesehen funktioniert das nicht.

52:05.180 --> 52:09.020
Dazu müssten Sie die Zwischensprache bauen, damit das funktioniert und

52:09.020 --> 52:11.280
dann auf die Zwischensprache verweisen und die durchnummerieren.

52:11.720 --> 52:15.160
Weil wenn Sie mal in Seite 7 umschauen, das werden drei Zeilen.

52:15.920 --> 52:16.820
Das könnte schwierig werden.

52:17.720 --> 52:18.320
Da noch eine Frage?

52:25.200 --> 52:27.620
Ihr Kommilitone fragt, ja, kann ich nicht einfach da Blöcke zeichnen

52:27.620 --> 52:28.180
und die dann nummerieren?

52:29.120 --> 52:32.360
Tatsächlich habe ich gestern versucht, in diesen Code den KFG rein zu

52:32.360 --> 52:32.580
zeichnen.

52:32.680 --> 52:33.540
Das wäre so eine ähnliche Idee.

52:33.980 --> 52:34.560
Machen Sie es nicht.

52:34.960 --> 52:35.620
Keine gute Idee.

52:36.740 --> 52:39.500
Ich habe dann spätestens bei der zweiten Vorschleife habe ich dann

52:39.500 --> 52:41.540
aufgehört, weil es funktioniert nicht.

52:42.620 --> 52:42.800
Gut.

52:43.220 --> 52:46.580
Noch Fragen zu den technischen Feinheiten des KFG-Zeichnens?

52:47.880 --> 52:48.280
Nein?

52:48.560 --> 52:48.800
Okay.

52:49.040 --> 52:51.440
Dann jetzt viel Spaß mit meiner unleserlichen Schrift.

52:52.580 --> 52:54.100
Wir versuchen das jetzt mal hier live.

52:54.540 --> 52:54.800
Yay.

52:55.020 --> 52:56.560
Das funktioniert soweit schon mal ganz gut.

52:56.900 --> 52:57.720
Der Fokus passt auch.

52:57.780 --> 52:59.780
Ich habe da oben noch mal den Code abgedruckt, damit wir ab und zu mal

52:59.780 --> 53:02.060
nach und nach hochspringen können, während ich hier zeichne.

53:02.140 --> 53:04.800
Und ich habe natürlich die Mussel-Lösung neben mir liegen, weil ich

53:04.800 --> 53:06.960
mache hier nichts ohne Netz und doppelten Boden.

53:07.580 --> 53:09.020
Ich will mich ja hier auch nicht blamieren.

53:09.680 --> 53:13.360
Dementsprechend, ja, Martin guckt schon erwartungsvoll, dass das doch

53:13.360 --> 53:13.720
passiert.

53:13.800 --> 53:14.840
Wie viel Zeit habe ich denn eigentlich noch?

53:14.900 --> 53:15.560
Ich sollte mich beeilen.

53:15.980 --> 53:20.980
Also vielleicht mache ich auch nur den Anfang live, weil der spannende

53:20.980 --> 53:22.800
Teil kommt ehrlich gesagt nur am Anfang.

53:22.940 --> 53:26.400
Und da möchte ich auch mal sehen, ob Sie das schon wissen, kennen,

53:26.500 --> 53:27.120
verstanden haben.

53:27.240 --> 53:28.300
Also, wie fangen wir denn an?

53:28.360 --> 53:33.260
Wir haben hier irgendwie so eine Eingabe und die Eingabe ist bei uns

53:33.260 --> 53:39.300
eine Double Matrix.

53:41.180 --> 53:46.460
Ja, schon habe ich hier meinen ersten Block fertig und dem gebe ich

53:46.460 --> 53:47.260
jetzt noch einen Namen.

53:48.120 --> 53:50.800
Bitte, bitte nicht vergessen in der Klausur.

53:50.900 --> 53:54.180
Wir fragen fast immer, was sind dann irgendwie durchlaufende Pfade,

53:54.280 --> 53:57.100
wenn wir Anweisungsüberdeckung oder so ähnlich machen wollen.

53:57.320 --> 54:04.360
Wir haben jedes Jahr wieder Abgaben ohne Nummern an den Blöcken und

54:04.360 --> 54:07.800
dann stehen da irgendwelche Testpfade und man denkt sich ja, wo gehört

54:07.800 --> 54:08.300
das jetzt dazu?

54:08.920 --> 54:10.300
Gut, da kommt gleich die erste Frage.

54:10.420 --> 54:12.620
Ich habe noch nicht mal einen Block fertig gemalt, aber bitte?

54:15.100 --> 54:16.640
Also Zustände gibt es schon mal gar nicht.

54:17.100 --> 54:18.100
Es gibt, wenn, dann gibt es Blöcke.

54:18.680 --> 54:19.100
Bitte, was?

54:19.380 --> 54:19.460
Ja,

54:24.340 --> 54:25.800
das ist ja das, was ich hier auch gemacht habe.

54:25.880 --> 54:27.660
Ich habe das bloß ein bisschen größer ausgeführt.

54:28.180 --> 54:29.600
Das ist Endstart da oben.

54:29.700 --> 54:32.540
Das sind nicht zwei genau, also meine Beschriftungsart ist immer so,

54:32.800 --> 54:35.440
dass ich da so kleine Kästchen oben dran schreibe, weil dann bin ich

54:35.440 --> 54:36.980
flexibler mit dem Zeichnen.

54:38.400 --> 54:40.180
Wir können das natürlich auch so hier reinschreiben, ja.

54:42.960 --> 54:43.840
Endstart, Doppelpunkt.

54:44.080 --> 54:44.420
Ja, klar.

54:44.800 --> 54:45.660
Also uns gerade egal.

54:45.820 --> 54:47.600
Ich könnte es jetzt nicht mehr lesen, gebe jetzt Abzug in der Klausur.

54:47.620 --> 54:51.220
Ich auch nicht, aber... So, jetzt kommt gleich der erste spannende

54:51.220 --> 54:51.440
Punkt.

54:51.800 --> 54:55.080
Was mache ich denn mit dem If mit dieser Bedingung?

54:55.720 --> 54:56.860
Wie mache ich das richtig?

54:58.240 --> 54:59.060
Da meldet sich jemand.

55:02.920 --> 55:03.620
Zwei Blöcke, bitte.

55:07.430 --> 55:10.550
Also, wir müssen zwei Blöcke jetzt bauen.

55:10.730 --> 55:17.510
Also wir haben einmal hier das If mit der Matrix gleich null.

55:17.910 --> 55:19.390
Das ist jetzt der erste Teil, ja.

55:21.050 --> 55:22.890
Da haben wir jetzt den 1.

55:24.470 --> 55:28.410
So, und das teilen wir jetzt auf und bauen jetzt noch den zweiten Teil

55:28.410 --> 55:33.350
des eigentlichen Codes.

55:35.050 --> 55:35.970
Was war das?

55:36.470 --> 55:36.830
Blank.

55:38.950 --> 55:39.430
Ungleich.

55:41.410 --> 55:44.270
Hätte man nicht eigentlich einen einfachen Code nehmen können hier zum

55:44.270 --> 55:44.570
zeigen?

55:44.730 --> 55:45.150
Nein, gell?

55:45.770 --> 55:47.210
Wer hat denn diese Aufgabe gebaut?

55:48.770 --> 55:50.430
Immerhin war es der, der es jetzt auch ausbaden muss.

55:50.690 --> 55:50.810
So.

55:52.550 --> 55:54.450
Könnte ich ja zeigen, wie man geschickt abkürzt.

55:55.090 --> 55:56.770
Ja, ich habe das jetzt gerade wunderbar nicht getan.

55:57.250 --> 55:57.370
Ja.

55:58.110 --> 56:00.410
Also so machen sie es bitte nicht in der Klausur.

56:03.390 --> 56:05.630
Das kann man zum Beispiel machen als Zeichen für falsch.

56:05.950 --> 56:06.730
Fände ich völlig okay.

56:08.950 --> 56:12.090
Und dann entsprechend, also wir bräuchten jetzt hier oben noch den,

56:12.910 --> 56:14.890
was dann passiert im Block.

56:15.550 --> 56:17.850
Nämlich das return false.

56:19.550 --> 56:21.910
Das wäre bei uns hier in 3.

56:25.420 --> 56:28.500
Ich würde ja echt Abzug machen hier mit deiner Sauklaue, ne?

56:29.180 --> 56:30.160
Ach, Martin.

56:30.320 --> 56:31.680
Du weißt genau, dass das nicht stimmt.

56:33.540 --> 56:34.120
Dass du das sagst.

56:34.380 --> 56:35.420
Genau, ich würde dir was abziehen.

56:36.520 --> 56:36.880
Aber ja.

56:37.240 --> 56:41.020
Also Martin würde das nie machen, weil Martin ist der netteste von uns

56:41.020 --> 56:44.960
dreien im Übungsleiterkreis.

56:45.180 --> 56:46.360
Dementsprechend würde er es nie tun.

56:46.460 --> 56:49.780
Er würde eher noch mit der Lupe rangehen und versuchen, das doch noch

56:49.780 --> 56:50.260
zu verstehen.

56:51.060 --> 56:51.220
Gut.

56:51.880 --> 56:55.720
Und hier unten geht es dann halt entsprechend weiter wieder mit, was

56:55.720 --> 56:56.460
ist, wenn das nicht ist.

56:56.700 --> 56:59.480
Ich würde jetzt mal hier kurz pausieren und noch mal fragen, warum

56:59.480 --> 57:05.380
muss ich das denn bei der Kurzschlussauswertung hier aufteilen?

57:05.380 --> 57:09.140
Ich weiß, wir legen da seit einigen Jahren Wert drauf und wir sehen

57:09.140 --> 57:11.800
das immer schön in den Altklausuren und Sie lernen das bestimmt alle

57:11.800 --> 57:12.500
schön auswendig.

57:12.600 --> 57:14.360
Aber warum muss man das denn tun?

57:15.800 --> 57:16.900
Komm, die Tone meldet sich.

57:21.840 --> 57:22.160
Genau.

57:22.300 --> 57:24.360
Also bei der Kurzschlussauswertung haben wir das Problem, dass der

57:24.360 --> 57:27.620
rechte Teil gegebenenfalls überhaupt angeschaut wird.

57:27.800 --> 57:32.200
Und da könnte ja auch tatsächlich eine Zuweisung drin passieren.

57:33.480 --> 57:36.560
Es gibt einen ganzen Methodenaufruf oder whatever könnte passieren.

57:38.480 --> 57:41.900
Dementsprechend muss man das aufteilen, weil sich einfach die

57:41.900 --> 57:46.340
Anweisungsüberdeckung ändert, wenn man das nicht tun würde.

57:46.960 --> 57:48.080
Da kommt noch eine Anmerkung.

57:49.860 --> 57:56.940
Also Ihr Kommentator fragt, ja, in der Zwischensprache wird das doch

57:56.940 --> 57:58.260
immer umgedreht.

57:58.800 --> 58:01.100
Warum ist das jetzt hier nicht der Fall?

58:02.040 --> 58:03.280
Das können Sie gerne machen.

58:03.560 --> 58:04.420
Da haben wir nichts dagegen.

58:04.520 --> 58:06.980
Wenn Sie zum Beispiel mit der Zwischensprache geübt haben, die

58:06.980 --> 58:14.580
Bedingungen umdrehen, um dann den Kontrollflussgrafen zu bauen mit den

58:14.580 --> 58:17.100
umgedrehten Bedingungen, dann müssen Sie natürlich gerade die

58:17.100 --> 58:19.200
Umgekehrten an die Kanten schreiben.

58:20.080 --> 58:21.320
Man kann es aber auch so machen.

58:21.500 --> 58:22.800
Es ist uns persönlich völlig egal.

58:22.900 --> 58:24.540
Ich mache es lieber so, weil das ist näher am Code.

58:24.600 --> 58:26.140
Ich kann es dann besser kontrollieren.

58:26.720 --> 58:28.600
Ich habe mich auch mal gefragt, warum machen wir das eigentlich in der

58:28.600 --> 58:29.140
Zwischensprache?

58:29.440 --> 58:33.620
Es gibt allerdings vereinzelt Fälle, wo es nicht funktioniert, wegen

58:33.620 --> 58:37.780
den Sprungbefehlen, wenn man die Bedingungen nicht umkehrt.

58:37.780 --> 58:40.020
Ich nagele mich jetzt nicht mehr fest, was das war, aber ich habe da

58:40.020 --> 58:41.780
auch schon mal dran gezweifelt, ob das überhaupt nötig ist.

58:41.840 --> 58:43.040
Aber leider ist es das tatsächlich.

58:43.160 --> 58:46.580
Also wenn man die Zwischensprache benutzt, dann muss man es

58:46.580 --> 58:47.620
tatsächlich tun.

58:48.000 --> 58:50.580
Aber wie gesagt, ich würde die Zwischensprache eh nur zum Üben, zum

58:50.580 --> 58:53.960
Reinkommen benutzen und dann direkt am Code und mit den normalen

58:53.960 --> 58:56.660
Bedingungen arbeiten, weil dann ist es einfach auch nachvollziehbar,

58:56.880 --> 58:59.560
wie es denn im Code abläuft und wie es im KFG abläuft.

59:00.500 --> 59:01.700
Okay, sonst noch Fragen bis hierher?

59:02.420 --> 59:03.520
Noch eine Frage, wunderbar.

59:08.970 --> 59:10.070
So, genau, sehr schön.

59:10.150 --> 59:11.530
Das wäre das Nächste, was ich hätte erklären wollen.

59:11.630 --> 59:15.450
Könnte man nicht aus diesem einen return false einen Block machen ganz

59:15.450 --> 59:17.870
am Ende und dann hat man halt nur noch einen, statt den jetzt

59:17.870 --> 59:20.910
irgendwie, wie ist es in unserer Musterlösung, dreimal zu zeichnen.

59:21.630 --> 59:23.370
Hat da jemand eine Meinung dazu, ob das eine gute Idee ist?

59:23.390 --> 59:24.530
Ach komm, die sitzen direkt neben dran.

59:31.640 --> 59:33.380
Ja, ich danke für diese perfekte Antwort.

59:33.560 --> 59:34.900
Also, ihr Kommilitone direkt nebendran.

59:35.520 --> 59:37.440
Erklärt Ihnen das vollkommen richtig, Sie hätten einfach mal nach

59:37.440 --> 59:38.260
links fragen müssen.

59:39.580 --> 59:41.100
Also, es ist die vollkommen richtige Antwort.

59:41.240 --> 59:43.420
Also, das Problem ist, es sieht jetzt irgendwie so aus, als wäre das

59:43.420 --> 59:43.720
redundant.

59:43.960 --> 59:47.120
Ich zeige mal, ich ende mal ganz kurz hier unsere finale Lösung ein.

59:47.300 --> 59:52.600
Ja, also wir haben hier irgendwie dreimal return false, aber brauchen

59:52.600 --> 59:55.140
wir auch alle, weil wenn wir jetzt wieder mal zurück, eigentlich ist

59:55.140 --> 59:58.700
das witzig hier, zurück in den Code schauen, dann haben wir die an

59:58.700 --> 59:59.920
unterschiedlichen Stellen stehen.

59:59.960 --> 01:00:02.300
Was wir erreichen wollen mit diesen kontrollflussorientierten Testen

01:00:02.300 --> 01:00:04.720
ist, zum Beispiel anschauen, haben wir alle Anweisungen angeschaut.

01:00:04.960 --> 01:00:06.900
Da können wir nicht sagen, okay, wir haben einmal in return false

01:00:06.900 --> 01:00:07.980
gesehen, wir haben sie alle gesehen.

01:00:08.420 --> 01:00:09.760
Ja, das funktioniert halt leider nicht.

01:00:10.320 --> 01:00:15.040
Also, nicht zusammenziehen von irgendwie return false Geschichten.

01:00:15.420 --> 01:00:15.600
Gut.

01:00:15.940 --> 01:00:16.620
Und noch Fragen?

01:00:18.180 --> 01:00:20.760
Ja, sie wollen ja wissen, ob sie, genau, also ihr Kommilitone sagt,

01:00:20.840 --> 01:00:23.360
ja, aber es ist doch trotzdem irgendwie das gleiche in der Praxis.

01:00:24.000 --> 01:00:26.280
Nee, also sie wollen ja schon wissen, ob sie in diesen Block überhaupt

01:00:26.280 --> 01:00:26.780
reinkommen.

01:00:27.060 --> 01:00:28.720
Ja, es kann ja irgendwas in der Bedingung falsch sein.

01:00:30.600 --> 01:00:31.740
Ja, genau.

01:00:32.140 --> 01:00:35.620
Also und spätestens, wenn es dann an die Zweigüberdeckung geht, hört

01:00:35.620 --> 01:00:37.860
es dann halt auf zu funktionieren, weil sie dann schon wissen, kommen

01:00:37.860 --> 01:00:41.520
sie auch über alle Zweige zum return, zu dem jeweiligen return.

01:00:43.080 --> 01:00:45.600
Okay, noch Fragen, Wünsche, Anmerkungen?

01:00:45.800 --> 01:00:47.960
Ich glaube, ich würde ansonsten mal mit den Folien weitermachen, weil

01:00:47.960 --> 01:00:50.580
ich glaube, wenn ich hier zeichne, dauert es dann doch zu lang.

01:00:51.120 --> 01:00:54.100
Ich überlege gerade, gibt es noch irgendeinen spannenden Fall in der

01:00:54.100 --> 01:00:55.000
Aufgabe?

01:00:57.300 --> 01:00:58.280
Eine Vorschleife noch.

01:00:58.340 --> 01:00:58.840
Ach ja, genau.

01:00:58.940 --> 01:01:00.660
Du meinst, damit man mal gesehen hat, wie man so eine Vorschleife

01:01:00.660 --> 01:01:02.180
aufbaut, auflöst.

01:01:02.280 --> 01:01:02.840
Okay, gut.

01:01:02.980 --> 01:01:03.960
Dann machen wir an der Stelle mal noch weiter.

01:01:04.380 --> 01:01:07.500
Also, wir hätten hier im Code als Nächstes erstmal diese Zuweisung mit

01:01:07.500 --> 01:01:08.600
dem Integer.

01:01:08.960 --> 01:01:11.040
Ja, die machen wir mal als Nächstes.

01:01:11.100 --> 01:01:13.460
Wir bauen also hier wieder einen Block.

01:01:15.200 --> 01:01:17.080
Wir machen int n, Punkt, Punkt, Punkt.

01:01:19.500 --> 01:01:22.820
So, und mit meiner großen Erfahrung im KFG-Zeichnen weiß ich jetzt,

01:01:22.880 --> 01:01:23.560
hier kommt eine Vorschleife.

01:01:23.640 --> 01:01:26.320
Und das ist jetzt genau der Grund, machen Sie das nicht mit den

01:01:26.320 --> 01:01:28.880
Vorschleifen und Zeilnummern und bauen Sie da Blöcke und üben Sie es

01:01:28.880 --> 01:01:31.300
vor allem auch einmal mit der Zwischensprache, weil das sieht man nur,

01:01:31.400 --> 01:01:32.440
wenn man es schon ein paar Mal gemacht hat.

01:01:33.020 --> 01:01:36.940
Diese Laufvariable der Schleife, in dem Fall ist das hier r, die muss

01:01:36.940 --> 01:01:38.480
ich ja auch erstmal anlegen.

01:01:38.720 --> 01:01:43.240
Also, ich kann jetzt hier gleich int r gleich 0 anlegen.

01:01:43.740 --> 01:01:50.100
Und das ist in einem Block mit dem davor, obwohl dann eine Schleife

01:01:50.100 --> 01:01:50.480
anfängt.

01:01:50.580 --> 01:01:53.460
Ja, das r wird nur einmal angelegt, deshalb kann ich das da mit in den

01:01:53.460 --> 01:01:53.900
Block machen.

01:01:54.360 --> 01:01:57.960
Das wird also hier mein Block n4.

01:01:58.520 --> 01:02:00.820
Genau, n4.

01:02:03.360 --> 01:02:04.900
So, wunderbar.

01:02:05.400 --> 01:02:11.860
Und jetzt kann ich im Grunde die Schleifenvariable prüfen als

01:02:11.860 --> 01:02:12.280
Nächstes.

01:02:12.380 --> 01:02:14.720
Das heißt, wieder Zwischensprache gelernt.

01:02:14.900 --> 01:02:19.520
Ich mache aus Schleifen ein if mit einem Sprungbefehl.

01:02:21.320 --> 01:02:29.480
Und hier kommt jetzt erstmal in mein n5 eine Bedingung.

01:02:30.080 --> 01:02:32.260
Was mache ich jetzt mit dem Sprungbefehl?

01:02:33.240 --> 01:02:35.400
Also, wir machen jetzt, hier wird es weitergehen, was auch immer

01:02:35.400 --> 01:02:35.820
passiert.

01:02:37.200 --> 01:02:42.120
Und irgendwo haben wir dann unser, in unserem Fall wäre das jetzt

01:02:43.400 --> 01:02:44.640
tatsächlich n14 gewesen.

01:02:44.820 --> 01:02:45.620
Also, es sind ein paar Blöcke.

01:02:46.720 --> 01:02:48.960
Und da ist dann unser r++.

01:02:49.420 --> 01:02:52.840
Das heißt, das passiert irgendwo... das war natürlich jetzt Käse,

01:02:52.920 --> 01:02:53.000
gell?

01:02:57.980 --> 01:02:59.160
Ah, live ist immer doof.

01:02:59.860 --> 01:03:00.320
So, genau.

01:03:02.700 --> 01:03:04.740
Auf dem Overhead ist es noch schöner.

01:03:05.960 --> 01:03:09.080
Irgendwann haben wir dann halt unser r++ am Ende der Schleife.

01:03:09.720 --> 01:03:16.360
Und dann springen wir natürlich von dort aus wieder zurück an diese

01:03:16.360 --> 01:03:16.660
Stelle.

01:03:17.180 --> 01:03:19.840
Und da sehen wir jetzt auch genau, wir haben den Einspruchspunkt bei

01:03:19.840 --> 01:03:23.940
der Bedingung und eben nicht bei der initialen Zuweisung von dem r.

01:03:24.120 --> 01:03:26.240
Deshalb können wir das r mit in den Block davor ziehen.

01:03:27.340 --> 01:03:28.800
Gut, das war noch der spannende Teil.

01:03:28.920 --> 01:03:30.020
Gibt es noch was Spannendes in der Aufgabe?

01:03:30.180 --> 01:03:30.620
Ich glaube nicht.

01:03:30.700 --> 01:03:32.840
Ansonsten schauen wir jetzt einfach mal auf die Lösung.

01:03:33.460 --> 01:03:39.300
Wir haben auch noch mal die Zwischensprache mitgebracht, wer sich das

01:03:39.300 --> 01:03:40.800
tatsächlich reinziehen will.

01:03:42.720 --> 01:03:45.700
Was halt schön ist, man sieht dann halt sehr gut die Sprünge.

01:03:45.820 --> 01:03:49.200
Man sieht genau das, worauf ich hingewiesen habe, dass das r

01:03:49.200 --> 01:03:53.100
unabhängig ist von der eigentlichen Schleife, dass das einmal vorher

01:03:53.100 --> 01:03:53.780
angelegt wird.

01:03:54.360 --> 01:03:57.740
Wir sehen wunderbar hier unten, dass das r++ ganz am Ende passiert.

01:03:58.080 --> 01:04:01.140
Wir sehen hier dieses goto7, was am Ende die Kante wird.

01:04:01.540 --> 01:04:04.200
Also, es ist schon sehr übersichtlich, das damit zu machen, aber wie

01:04:04.200 --> 01:04:06.280
gesagt, machen Sie es lieber nur zur Übung.

01:04:06.340 --> 01:04:06.540
Frage?

01:04:08.080 --> 01:04:08.440
Ja.

01:04:10.060 --> 01:04:14.280
Also, Ihr Kommilitone fragt, ob, wenn wir jetzt ein if haben, an das

01:04:14.280 --> 01:04:16.980
später nicht zurückgesprungen wird, ob das in einen extra Block kommt

01:04:16.980 --> 01:04:20.020
oder ob das mit dem Block, der davor kommt, verschmolzen wird.

01:04:20.480 --> 01:04:22.480
Und die Frage gebe ich jetzt einfach mal an Sie zurück.

01:04:22.620 --> 01:04:23.240
Was meinen Sie denn?

01:04:28.060 --> 01:04:31.000
So, Ihr Kommilitone meint, es sollte mit dem Block dazukommen.

01:04:31.060 --> 01:04:31.580
Damit hat er recht.

01:04:31.660 --> 01:04:33.160
Und jetzt sagt er mir noch, warum er damit recht hat.

01:04:34.820 --> 01:04:35.660
Gemein heute, gell?

01:04:36.120 --> 01:04:38.100
Muss man seine Fragen selber beantworten.

01:04:40.440 --> 01:04:42.300
Es wäre konsistent, ist mir ein bisschen zu einfach.

01:04:42.400 --> 01:04:43.120
Sie haben eine bessere Meinung?

01:04:44.640 --> 01:04:44.860
Genau.

01:04:45.080 --> 01:04:48.960
Also, Ihr Kommilitone meint, die Definition von Block ist, der endet

01:04:48.960 --> 01:04:51.480
dann, wenn ein Sprungbefehl passiert und der passiert danach.

01:04:51.880 --> 01:04:54.980
Und wir haben auch keinen, wie Sie gesagt haben, mehr, der davor

01:04:54.980 --> 01:04:56.900
zurückspringt, also vor das if.

01:04:57.820 --> 01:04:59.220
Deshalb kann man es zusammenziehen.

01:05:00.500 --> 01:05:03.420
Okay, also Ihr Kommilitone meint, er hätte es in Altklausuren anders

01:05:03.420 --> 01:05:03.700
gesehen.

01:05:04.340 --> 01:05:07.160
Wenn Sie meinen, dass da ein Fehler in der Altklausur ist, gerne bei

01:05:07.160 --> 01:05:07.580
uns melden.

01:05:08.340 --> 01:05:14.200
Gerne mit Ihrer Klausur, sagen wir, Semester 2009, Aufgabe 14 ist ein

01:05:14.200 --> 01:05:14.440
Fehler.

01:05:15.240 --> 01:05:16.420
Oder da ist irgendwas komisch.

01:05:16.500 --> 01:05:16.980
Ich verstehe es nicht.

01:05:17.060 --> 01:05:18.940
Gerne im Forum melden, sagen, fragen.

01:05:19.220 --> 01:05:20.600
Kann ich jetzt von hier aus nicht beurteilen.

01:05:22.300 --> 01:05:25.300
Genau, den haben wir halt im Zwischencode, sehen wir den.

01:05:29.340 --> 01:05:31.760
Den Stop Block, den kann man zusammenfassen.

01:05:31.880 --> 01:05:33.780
Also Sie brauchen nicht für jedes Return einen eigenen Stop Block.

01:05:34.880 --> 01:05:37.860
Der Stop ist ja im Grunde nur ein Platzhalter für, hier sind wir jetzt

01:05:37.860 --> 01:05:39.040
am Ende unseres Testverfahrens.

01:05:39.080 --> 01:05:40.280
Den gibt es ja im Code eigentlich nicht.

01:05:40.740 --> 01:05:42.980
Also schauen wir einfach mal an, wie die Musterlösung aussehen würde.

01:05:43.340 --> 01:05:47.160
Den Teil da oben, ich erkläre das mal ganz kurz noch.

01:05:47.520 --> 01:05:49.120
Also das ist der Teil, den wir da oben gesehen haben.

01:05:49.340 --> 01:05:51.100
Bis hierhin hatte ich Ihnen das gezeigt.

01:05:52.380 --> 01:05:54.160
Und der Rest, der funktioniert analog.

01:05:54.360 --> 01:05:57.740
Ich meine, das sind auch immer nur noch, hier war nochmal ein if, hier

01:05:57.740 --> 01:06:01.880
ist nochmal eine Schleife, hier ist nochmal ein if mit einem Sprung.

01:06:02.420 --> 01:06:03.880
Alles nicht so furchtbar spannend.

01:06:04.560 --> 01:06:09.220
Man sollte halt keinen echten Code nehmen für Kontrollflussgraphen.

01:06:09.320 --> 01:06:10.760
Das wird häufig ein bisschen unspannend.

01:06:11.980 --> 01:06:14.300
Naja, also das würde rauskommen am Ende.

01:06:14.580 --> 01:06:17.620
Ist wie gesagt, der spannende Teil ist einmal das hier oben und dann

01:06:17.620 --> 01:06:19.680
einmal eine Schleife auflösen.

01:06:19.780 --> 01:06:21.520
Alles andere funktioniert eigentlich analog.

01:06:21.820 --> 01:06:23.000
So, jetzt zu Ihrer Frage bitte.

01:06:28.060 --> 01:06:30.420
Ihr Kommentator möchte wissen, ist es wichtig, ob die Dinger

01:06:30.420 --> 01:06:31.540
abgerundet oder eckig sind?

01:06:32.040 --> 01:06:34.640
Ich würde da gerne Wert drauf legen, aber die Erfahrung sagt mir, ich

01:06:34.640 --> 01:06:37.460
bin froh, wenn ich überhaupt was erkennen kann in der Klausur, was

01:06:37.460 --> 01:06:38.600
dahin geschmiert wurde.

01:06:39.140 --> 01:06:41.800
Nee, also ist uns relativ egal, wie das aussieht.

01:06:41.940 --> 01:06:42.380
Solange es...

01:06:43.580 --> 01:06:44.020
Bitte?

01:06:45.560 --> 01:06:47.640
Genau, bei anderen Diagrammen ist das wichtig.

01:06:47.780 --> 01:06:51.660
Bei UML-Diagrammen kann das wichtig sein, weil das teilweise einen

01:06:51.660 --> 01:06:54.100
semantischen Unterschied macht, ob die eckig sind oder rund.

01:06:54.840 --> 01:06:58.360
Hier hätte ich es gerne eckig, aber ganz ehrlich, wenn es nicht eckig

01:06:58.360 --> 01:07:01.100
wird und wenn es rum und schief wird, Hauptsache, ich kann es lesen

01:07:01.100 --> 01:07:02.040
und eindeutig zuordnen.

01:07:02.260 --> 01:07:03.060
Also, ja.

01:07:03.680 --> 01:07:06.280
Geben Sie sich Mühe beim Zeichnen, aber ob das jetzt eine runde Ecke

01:07:06.280 --> 01:07:08.920
ist oder eine eckige Ecke, mir gerade egal.

01:07:10.140 --> 01:07:11.700
Okay, noch Fragen dazu?

01:07:12.380 --> 01:07:12.380
Ja?

01:07:14.900 --> 01:07:18.160
Nee, aber die Zwischensprache, also die Kommilitone fragt, stopp,

01:07:18.220 --> 01:07:19.140
Block in der Zwischensprache.

01:07:19.340 --> 01:07:21.460
Nein, muss nicht und ist mir auch ehrlich gesagt völlig egal.

01:07:21.620 --> 01:07:23.420
Selbst wenn sie die Zwischensprache machen, gucke ich mir die nicht

01:07:23.420 --> 01:07:23.620
an.

01:07:24.080 --> 01:07:24.260
Okay.

01:07:31.670 --> 01:07:34.690
Kommilitone fragt, gibt es eine eindeutige einheitliche Nominierung

01:07:34.690 --> 01:07:36.350
der Blöcke?

01:07:36.810 --> 01:07:40.070
Die richtige Antwort ist, so wie in der Musterlösung, weil nur dann

01:07:40.070 --> 01:07:40.850
können wir es korrigieren.

01:07:42.230 --> 01:07:42.450
Nein.

01:07:42.770 --> 01:07:46.170
Also, es ist natürlich schön, wenn das irgendwie korrespondiert mit

01:07:46.170 --> 01:07:49.150
der Reihenfolge, wie es im Code vorkommt.

01:07:49.330 --> 01:07:51.510
Das geht natürlich nicht immer eins zu eins, sondern es gibt einfach

01:07:51.510 --> 01:07:52.050
Unterschiede.

01:07:52.530 --> 01:07:55.610
Wir werden das sicherlich nicht mit Abzügen belegen.

01:07:55.810 --> 01:07:57.690
Also ja, das ist im Wesentlichen künstlerische Freiheit.

01:07:58.010 --> 01:08:00.350
Sie tun uns beim Korrigieren großen Gefallen, wenn Sie das irgendwie

01:08:00.350 --> 01:08:02.990
versuchen, fortlaufend zu machen.

01:08:03.350 --> 01:08:07.830
Aber wenn Sie mit N42 rückwärtszählend anfangen, kann ich Sie dafür

01:08:07.830 --> 01:08:08.530
auch nicht bestrafen.

01:08:08.970 --> 01:08:09.490
Glaube ich.

01:08:09.930 --> 01:08:12.870
Ich muss aber meinen Chef fragen, was der dazu sagt, aber ich glaube

01:08:12.870 --> 01:08:13.090
nicht.

01:08:13.470 --> 01:08:15.130
Also kann man machen.

01:08:16.310 --> 01:08:16.790
Noch Fragen?

01:08:18.430 --> 01:08:20.330
Sonst komme ich ja gar nicht hin, mir dazu noch die Ewald

01:08:20.330 --> 01:08:20.870
vorzustellen.

01:08:21.630 --> 01:08:25.190
Gut, es war noch gefragt, wie sind denn jetzt eigentlich die

01:08:25.190 --> 01:08:27.510
durchlaufenden Pfade für, was wollen wir machen,

01:08:27.570 --> 01:08:28.450
Anweisungsüberdeckung.

01:08:28.530 --> 01:08:30.190
Also jede Anweisung mal gesehen haben.

01:08:31.490 --> 01:08:34.130
Welche Testfälle muss man da eingeben?

01:08:34.270 --> 01:08:35.790
Das fragen wir auch ganz gerne mal in Klausuren.

01:08:35.890 --> 01:08:38.450
Und zwar fragen wir immer nach der minimalen Testfallmenge.

01:08:38.610 --> 01:08:40.030
Also man könnte ja dann noch 15 machen.

01:08:40.150 --> 01:08:43.050
Oder manchmal ist es auch so, dass einem irgendwie ein Testfall

01:08:43.050 --> 01:08:43.510
einfällt.

01:08:43.790 --> 01:08:44.890
Mit dem geht das dann ganz schnell.

01:08:45.810 --> 01:08:48.850
Und man läuft so ein paar Anweisungen ab und dann braucht man halt

01:08:48.850 --> 01:08:49.570
noch fünf andere.

01:08:49.710 --> 01:08:51.910
Aber eigentlich hätte es drei gegeben, mit denen es auch funktioniert

01:08:51.910 --> 01:08:52.230
hätte.

01:08:53.170 --> 01:08:56.590
Das heißt, immer versuchen, die minimale Testfallmenge zu finden.

01:08:56.710 --> 01:08:59.550
Das heißt, Mengen von diesen Eingaben.

01:08:59.990 --> 01:09:00.950
Ihr Kommilitone hat eine Frage?

01:09:01.510 --> 01:09:01.730
Okay.

01:09:02.110 --> 01:09:06.250
Ihr Kommilitone fragt, haben wir bei P1 nicht Freiheitsgrade, was die

01:09:06.250 --> 01:09:06.990
Eingabe betrifft?

01:09:07.090 --> 01:09:15.310
Könnte das nicht entweder null sein oder das andere, um auf den ersten

01:09:15.310 --> 01:09:16.630
Return -Block zu kommen?

01:09:17.570 --> 01:09:17.670
Ja.

01:09:19.190 --> 01:09:21.910
Genau, das ist jetzt genau das Problem.

01:09:22.170 --> 01:09:30.010
Wenn Sie null benutzen würden, würden Sie an der Stelle den Block 2

01:09:30.010 --> 01:09:30.610
verpassen.

01:09:30.810 --> 01:09:32.350
Aber den sehen wir eh noch in anderen Fällen.

01:09:32.490 --> 01:09:34.210
Also Sie könnten da oben auch null benutzen.

01:09:34.590 --> 01:09:35.190
Wäre völlig okay.

01:09:35.990 --> 01:09:39.010
Könnten Sie machen, weil wir haben ja hier eh den Block 2 noch

01:09:39.010 --> 01:09:39.510
abgedeckt.

01:09:39.810 --> 01:09:41.990
Das ist nämlich genau der, der die zweite Bedingung prüft.

01:09:42.110 --> 01:09:43.830
Insofern, könnten Sie auch anders bauen.

01:09:44.350 --> 01:09:45.030
Noch Fragen?

01:09:46.630 --> 01:09:50.470
Ihr Kommilitone fragt, ich sitze in der Klausur und bin mir nicht

01:09:50.470 --> 01:09:52.670
sicher, ob das die minimale Testfallmenge ist.

01:09:54.010 --> 01:09:55.650
Wie kann ich das denn prüfen?

01:09:56.370 --> 01:09:58.110
Ganz ehrlich, da habe ich kein Kochrezept dazu.

01:09:59.030 --> 01:10:01.530
Was ich Ihnen aber sagen kann, ist das, was ich gerade eben gesagt

01:10:01.530 --> 01:10:01.770
habe.

01:10:01.950 --> 01:10:04.050
Man fängt mal mit irgendwas an, mit irgendeiner Eingabe, die einem

01:10:04.050 --> 01:10:05.450
einfällt und macht dann weiter.

01:10:05.570 --> 01:10:07.150
Das ist im Allgemeinen eine schlechte Idee.

01:10:07.750 --> 01:10:11.430
Versuchen Sie sowas zu machen, wie Äquivalenzklassen bilden.

01:10:11.550 --> 01:10:14.830
Also schauen Sie sich die Bedingungen an, die hier vorkommen und

01:10:14.830 --> 01:10:17.250
überlegen Sie sich, was kann man denn hier, wie variieren.

01:10:17.510 --> 01:10:19.770
So kommt man am schnellsten auf die Eingabemengen und die sind dann

01:10:19.770 --> 01:10:22.730
auch im Normalfall dann schon minimal, weil man sich daher überlegt

01:10:22.730 --> 01:10:25.550
hat, wird es entweder so oder so und hat nicht irgendwas zufällig

01:10:25.550 --> 01:10:25.890
gewählt.

01:10:26.430 --> 01:10:28.130
Da muss man manchmal noch ein bisschen scharf hingucken.

01:10:28.490 --> 01:10:30.710
Aber mehr kann ich dazu tatsächlich nicht sagen.

01:10:31.270 --> 01:10:34.170
In diesem Fall möchten Sie auch jeden Returnblock einmal treffen.

01:10:34.470 --> 01:10:37.090
Das heißt, Sie würden auch schauen, wenn Sie zu diesem Returnblock

01:10:37.090 --> 01:10:37.510
kommen.

01:10:37.850 --> 01:10:41.530
Ja, davon noch abgesehen, wenn Ihre Testvermengung nicht minimal ist,

01:10:41.610 --> 01:10:43.510
da gibt es dafür dann auch nur einen minimalen Abzug.

01:10:47.630 --> 01:10:48.070
Gut.

01:10:48.070 --> 01:10:49.850
Ja, sorry, noch eine Frage.

01:10:52.330 --> 01:10:53.010
Ja, genau.

01:10:53.150 --> 01:10:55.730
Ihr Kommilitone fragt, ja, hier sind so geschweifelte Klammern für die

01:10:55.730 --> 01:10:56.230
Matrizen.

01:10:57.190 --> 01:10:58.390
Wäre uns völlig egal.

01:10:58.770 --> 01:11:00.530
Ich mache mal einen kurzen Spoiler.

01:11:01.010 --> 01:11:04.170
Wir werden sowas garantiert nicht in der Klausur drannehmen, weil das

01:11:04.170 --> 01:11:05.770
ergibt genau zu viele Fights gerade.

01:11:05.910 --> 01:11:08.950
Also wenn da jemand anfängt, Matrizen hinzuzeichnen als Eingabe, habe

01:11:08.950 --> 01:11:10.590
ich da keine Lust, das zu korrigieren in der Klausur.

01:11:11.130 --> 01:11:13.190
Das dürfen die Tutoren im Übungsbetrieb machen.

01:11:14.990 --> 01:11:17.370
Dementsprechend verlassen sie sich darauf, dass das irgendwie ziemlich

01:11:17.370 --> 01:11:19.630
einfach sein wird, was man da in Eingabe liefern kann.

01:11:19.990 --> 01:11:22.410
Aber ja, jetzt für den Übungsbetrieb haben wir auch im Forum

01:11:22.410 --> 01:11:25.350
beantwortet mit wahnsinnigen in Ordnung.

01:11:27.590 --> 01:11:28.510
Noch Fragen?

01:11:28.870 --> 01:11:28.970
Ja.

01:11:34.720 --> 01:11:36.520
Sie können aufhören zu fragen, ich erkläre es Ihnen.

01:11:37.640 --> 01:11:40.400
Also Ihr Kommilitone möchte wissen, wenn ich einen falschen Graphen

01:11:40.400 --> 01:11:42.640
gemalt habe und dann baue ich eine Testvermenge dazu, wird es dann

01:11:42.640 --> 01:11:44.260
trotzdem noch bewertet in der Klausur, richtig?

01:11:44.440 --> 01:11:45.380
Das wäre Ihre Frage gewesen.

01:11:47.200 --> 01:11:48.660
Ob das als Folgefehler zählt?

01:11:48.780 --> 01:11:52.640
Ja, die Antwort ist wie immer ein ganz klares Jein.

01:11:53.420 --> 01:11:59.220
Wir versuchen natürlich Folgefehler zu berücksichtigen und werden uns

01:11:59.220 --> 01:12:02.040
oder schauen uns immer dann auch die durchlaufenden Pfade für kaputte

01:12:02.040 --> 01:12:03.380
Graphen an, auf alle Fälle.

01:12:03.700 --> 01:12:06.960
Es gibt allerdings eine Ausnahme und das ist, wenn Sie den Graphen so

01:12:06.960 --> 01:12:10.340
einfach bauen, dass Sie zum Beispiel nur noch einen...ja, genau.

01:12:10.860 --> 01:12:13.400
Sie lachen, aber das kommt häufiger vor, als Sie denken.

01:12:13.720 --> 01:12:16.260
Und wo die Schwelle liegt, das kann ich Ihnen jetzt nicht sagen.

01:12:16.480 --> 01:12:20.180
Also das wird bei uns dann während der Korrektur im Kollegenkreis

01:12:20.180 --> 01:12:20.740
festgelegt.

01:12:20.740 --> 01:12:23.480
Also der Graph da, das ist zu einfach, da können wir keine Punkte mehr

01:12:23.480 --> 01:12:23.880
drauf geben.

01:12:24.300 --> 01:12:27.160
Also wenn man zum Beispiel irgendwie vier Tests braucht, um da

01:12:27.160 --> 01:12:30.320
durchzukommen und man sich echt Gedanken machen muss, welche vier

01:12:30.320 --> 01:12:33.540
Testeingaben das sind, um dann Anweisungsüberdeckung hinzubekommen.

01:12:33.660 --> 01:12:36.400
Und Sie bauen einen Graph, der vielleicht nur drei, vier Kanten

01:12:36.400 --> 01:12:40.420
weniger hat und man braucht am Ende nur noch einen Testfall, der auch

01:12:40.420 --> 01:12:43.340
noch trivial ist, dann sind Sie leider raus an der Stelle.

01:12:43.540 --> 01:12:46.380
Aber ansonsten, wenn dann nur ein Block falsch ist und dadurch das

01:12:46.380 --> 01:12:49.060
irgendwie leicht anders ist, gucken wir uns auf jeden Fall an.

01:12:49.620 --> 01:12:54.000
Dann gibt es Abzug auf den KfG, aber normale Punkte auf

01:12:54.660 --> 01:12:56.420
Anweisungszweig oder was auch immer Überdeckung.

01:12:57.360 --> 01:12:58.520
Gut, noch Fragen?

01:12:59.140 --> 01:13:00.680
Wollen alle gar nicht die Eval-Ergebnisse wissen, oder?

01:13:01.000 --> 01:13:02.700
Ich glaube, die zögern das raus heute, ja.

01:13:02.880 --> 01:13:06.260
Okay, ich glaube, es geht einfach auf die Klausur zu und die Leute

01:13:06.260 --> 01:13:08.720
haben sich mit dem Stoff beschäftigt und plötzlich kommen die Fragen.

01:13:08.760 --> 01:13:09.820
Damit konnten wir nicht rechnen.

01:13:09.880 --> 01:13:12.160
Ja, genau, dass sich tatsächlich mal jemand mit dem Stoff beschäftigt.

01:13:12.280 --> 01:13:14.960
Gut, ich würde mal sagen, wir machen das jetzt so.

01:13:15.480 --> 01:13:18.320
Auf den nächsten Folien sieht man noch, welche Pfade jetzt hier

01:13:18.320 --> 01:13:19.240
einzeln durchlaufen werden.

01:13:20.520 --> 01:13:21.960
Kann man sich auch zur Not noch zu Hause angucken.

01:13:22.060 --> 01:13:23.880
Ist eh nur das Gleiche, wie gerade eben, nochmal in Grafisch.

01:13:25.060 --> 01:13:27.580
Letzte Frage war noch, wie das müsste man denn machen, um die

01:13:27.580 --> 01:13:28.820
Zweigüberdeckung noch hinzubekommen?

01:13:29.580 --> 01:13:31.700
Und da ist die Antwort, jetzt brauchen wir halt noch hier Matrix

01:13:31.700 --> 01:13:32.160
gleich Null.

01:13:32.480 --> 01:13:35.160
Oder, wenn wir das vorher in der Anweisungsüberdeckung hatten mit der

01:13:35.160 --> 01:13:37.060
Matrix Null, brauchen wir jetzt halt noch die andere Matrix dazu.

01:13:37.320 --> 01:13:40.420
Und dann haben wir halt noch den Pfad 1, 3, Stopp auch noch dabei.

01:13:40.540 --> 01:13:44.780
Und damit sehen wir jetzt gerade eben, also hier da oben, dieser

01:13:44.780 --> 01:13:46.080
Zweig, der fehlt uns.

01:13:46.640 --> 01:13:50.180
Und jetzt haben wir dann halt noch den abgearbeitet mit diesem Pfad.

01:13:50.740 --> 01:13:51.940
So, dann Bonusaufgabe.

01:13:52.200 --> 01:13:55.320
Ich hoffe, die hat jeder gemacht, weil die war tatsächlich geschenkt.

01:13:56.360 --> 01:13:57.680
Warum geht Pfadeüberdeckung nicht?

01:13:58.360 --> 01:14:00.220
Martin, sagst du uns, warum geht Pfadeüberdeckung nicht?

01:14:01.240 --> 01:14:01.940
Machst du nicht?

01:14:02.040 --> 01:14:03.660
Okay, also was bedeutet Pfadeüberdeckung?

01:14:03.700 --> 01:14:05.800
Wir müssen alle möglichen Pfade durchlaufen.

01:14:05.920 --> 01:14:10.380
Und Pfade heißt jetzt nicht, wir müssen alle Zweige mal in Kombination

01:14:10.380 --> 01:14:15.140
abgelaufen haben, sondern wir müssen alle Zweige in Kombination zum

01:14:15.140 --> 01:14:17.820
Beispiel bei Schleifen auch mit allen möglichen Schleifendurchläufen

01:14:17.820 --> 01:14:18.720
angeschaut haben.

01:14:19.500 --> 01:14:22.040
Das heißt also, wenn so eine Schleife von der Eingabe abhängt, hier

01:14:22.040 --> 01:14:24.680
von der Matrixgröße, kann man das quasi vergessen.

01:14:25.060 --> 01:14:28.280
Also es ist, als wenn man sagen würde, okay, wir haben irgendwie eine

01:14:28.280 --> 01:14:31.280
Speicherbeschränkung und die Matrizen können nicht unendlich groß

01:14:31.280 --> 01:14:31.640
werden.

01:14:32.040 --> 01:14:33.440
Selbst dann ist es noch unpraktikabel.

01:14:33.600 --> 01:14:35.280
Dann hätten sie da irgendwie zwei Milliarden Pfade.

01:14:35.840 --> 01:14:37.020
Ja, ist nicht möglich.

01:14:38.200 --> 01:14:40.060
Okay, gut.

01:14:40.600 --> 01:14:43.880
Dann würden wir sagen, bevor wir zur Code-Inspektion kommen, machen

01:14:43.880 --> 01:14:46.260
wir mal die E-Wahl, weil die ist spannender als die Code-Inspektion.

01:14:46.820 --> 01:14:49.960
Und Code-Inspektion könnte man sich theoretisch auch einfach auf den

01:14:49.960 --> 01:14:50.660
Folien anschauen.

01:14:51.820 --> 01:14:54.820
E-Wahl ohne unsere schönen Kommentare dazu macht natürlich überhaupt

01:14:54.820 --> 01:14:55.320
keinen Spaß.

01:14:57.240 --> 01:14:59.200
Deshalb machen wir das jetzt mal noch schnell.

01:15:00.300 --> 01:15:01.580
Die Zeit ist heute ganz schön knapp.

01:15:01.680 --> 01:15:02.040
Wir haben los.

01:15:02.460 --> 01:15:06.380
So, deshalb ohne große Umschweifung, Evaluation der Übung.

01:15:07.720 --> 01:15:10.120
Ich hätte mit Schlimmen gerechnet, aber es war tatsächlich gar nicht

01:15:10.120 --> 01:15:10.720
so schlimm dieses Mal.

01:15:10.780 --> 01:15:15.000
Wir haben einen Lehrqualitätsindex von 94,4 erreicht.

01:15:15.120 --> 01:15:18.180
Das ist tatsächlich 1,5 Prozentpunkte besser als letztes Jahr.

01:15:18.840 --> 01:15:20.800
Wir steigern uns konsequent.

01:15:20.860 --> 01:15:22.260
Wir schauen gleich mal noch, wie der berechnet wird.

01:15:23.340 --> 01:15:26.720
Aber unsere Lehrequalität ist also ziemlich gut, sogar besser als in

01:15:26.720 --> 01:15:27.280
der Vorlesung.

01:15:28.100 --> 01:15:30.720
Ich vermute ja, das liegt hauptsächlich daran, dass hier nur die Leute

01:15:30.720 --> 01:15:33.620
sind, die gerne in der Übung sind und deshalb uns einigermaßen gut

01:15:33.620 --> 01:15:34.100
evaluieren.

01:15:34.580 --> 01:15:36.540
Und die Leute, die uns gar nicht mögen, die kommen vielleicht trotzdem

01:15:36.540 --> 01:15:38.900
noch in die Vorlesung und lassen dann halt dort ihren Frust ab.

01:15:39.460 --> 01:15:41.480
Schade für den Chef, aber gut für uns.

01:15:43.060 --> 01:15:44.400
Also 94,4.

01:15:44.520 --> 01:15:45.180
Danke dafür.

01:15:46.560 --> 01:15:48.440
Das kann man, wie gesagt, nachlesen, wie das Ding berechnet wird.

01:15:48.520 --> 01:15:49.760
Wir schauen aber gleich auch noch mal kurz drauf.