WEBVTT

00:10.100 --> 00:12.540
Mich haben Sie eben schon mal gesehen heute Vormittag.

00:12.620 --> 00:13.560
Mein Name ist Ralf Häusler.

00:13.680 --> 00:17.120
Ich bin der Professor, der Sie jetzt quasi begleitet in dieser

00:17.120 --> 00:19.300
Vorlesung mit den Übungen zum Programmieren.

00:20.060 --> 00:22.740
Was Programmieren ist, was ist der Sinn und Unsinn dieser

00:22.740 --> 00:24.860
Veranstaltung, hatten wir ja schon heute Morgen kurz besprochen.

00:25.540 --> 00:29.260
Ich würde gerne, bevor wir jetzt weitermachen an dieser Stelle, zwei

00:29.260 --> 00:30.760
Dinge noch mit Ihnen besprechen.

00:31.880 --> 00:36.840
Einmal organisatorische Dinge und dann eine Nachfrage in eigener Sache

00:36.840 --> 00:37.620
unserer Fakultät.

00:37.620 --> 00:40.200
Sie wissen ja, unsere Fakultät macht auch viel Werbung.

00:40.320 --> 00:43.520
Umso mehr freuen wir uns auch, dass so viele Studierende hier da sind.

00:43.640 --> 00:46.460
Das ist wunderbar, weil das zeigt ja auch das Interesse am Fach.

00:47.060 --> 00:50.380
Da ist uns hier auch da, die offenbar etwas studieren, wo sie auch

00:50.380 --> 00:52.300
nachher eine reale Chance haben, auch eine Stelle zu bekommen.

00:52.400 --> 00:52.880
Das ist auch mal gut.

00:54.060 --> 00:57.000
Aber eine Werbemaßnahme, die wir ja auch besonders verstärkt mit hohem

00:57.000 --> 01:00.860
Aufwand machen, an der Fakultät sind die sogenannten Bogi-Praktika,

01:01.520 --> 01:05.060
also die berufsorientierten Praktiker, die am Gymnasium sind, das zu

01:05.060 --> 01:05.580
begleiten.

01:05.960 --> 01:08.540
Insofern nur mal kurz die Bitte als Handzeichen, wer von Ihnen hat

01:08.540 --> 01:12.420
denn hier am KIT so ein Bogi-Praktikum gemacht?

01:12.660 --> 01:14.320
Wenn ich mal ein Gefühl habe, wie wirksam das ist.

01:19.890 --> 01:21.390
Okay, danke, das reicht schon.

01:21.790 --> 01:22.850
Wunderbar, habe ich so meinen Eindruck.

01:24.670 --> 01:26.770
Gut, also das heißt, das sind dadurch die Kommilitonen, die sind

01:26.770 --> 01:28.470
besonders hartgesonnen, die sind nämlich jetzt noch nicht

01:28.470 --> 01:30.570
abgeschreckt, obwohl sie schon mal am KIT waren.

01:30.570 --> 01:32.130
Also ganz herzlichen Dank.

01:32.950 --> 01:35.870
Und die anderen hoffe ich auch nicht abzuschrecken durch diese

01:35.870 --> 01:36.510
Veranstaltung.

01:37.850 --> 01:40.650
Ja, bevor wir den Stoff eingehen, wie ich gesagt habe, erst mal ein

01:40.650 --> 01:44.710
paar organisatorische Informationen zu dieser Vorlesung.

01:45.490 --> 01:48.790
Genau, ich stehe hier auf dem Foto auch in der Mitte und ich bin

01:48.790 --> 01:51.950
natürlich derjenige, der auch hier mit Ihnen die Vorlesung

01:51.950 --> 01:53.190
näherbringt, erklärt.

01:54.490 --> 01:57.610
Aber der Ehrlichkeit halber muss man sagen, es gibt zwei Personen im

01:57.610 --> 02:00.190
Hintergrund, die jetzt hier nicht sichtbar sind, die aber mal

02:00.190 --> 02:02.390
mindestens genauso viel Arbeit da reinstecken, wenn nicht sogar noch

02:02.390 --> 02:02.590
mehr.

02:02.990 --> 02:05.970
Und das sind die Übungsleiter, einmal Frau Rostami und einmal Herr

02:05.970 --> 02:09.390
Langhammer, die beide, sage ich mal, den Übungsbetrieb, insbesondere

02:09.390 --> 02:13.070
auch den Betrieb mit den Tutoren aufrechterhalten und sich

02:13.070 --> 02:16.410
bestkoordinieren und ihre Tutoren natürlich.

02:16.870 --> 02:20.110
Das sind so viele, um die 30, dass wir jetzt nicht von jedem ein Bild

02:20.110 --> 02:20.410
haben.

02:21.030 --> 02:24.890
Aber ich möchte nochmal die Rolle der Tutorien betonen.

02:25.990 --> 02:30.310
Es ist vollkommen normal, wenn man an einer Universität studiert, dass

02:30.310 --> 02:33.570
während man in der Vorlesung ist, Verständnisfragen auftauchen.

02:34.030 --> 02:35.130
Also das ist nichts Schlimmes.

02:35.330 --> 02:38.730
Ich habe hier auch in Karlsruhe studiert und in so gewissen

02:38.730 --> 02:41.830
Mathematikvorlesungen dachte ich auch immer, super, 5 Minuten nach 8,

02:41.910 --> 02:44.230
also um 8 Uhr fing es an, ich habe immer noch alles verstanden,

02:44.830 --> 02:45.470
großartig.

02:46.830 --> 02:48.430
Normalerweise ist es nämlich so, dass man dann irgendwann den Faden

02:48.430 --> 02:51.090
verliert und sagt, okay, ich sitze zwar jetzt noch in der Vorlesung,

02:51.170 --> 02:53.350
ich kann versuchen auch wieder reinzukommen, aber so ein paar Fragen

02:53.350 --> 02:53.950
bleiben halt offen.

02:54.530 --> 02:55.930
Wie gesagt, das ist vollkommen normal.

02:56.550 --> 02:58.250
Sie brauchen sich kein schlechtes Gewissen haben, sie brauchen sich

02:58.250 --> 03:00.290
auch nicht unfähig fühlen oder sonst was.

03:01.670 --> 03:04.910
Und die Frage ist halt nur, wie organisiert man sich jetzt die Hilfe

03:04.910 --> 03:05.790
oder das Verständnis.

03:07.190 --> 03:09.810
Und Kollege Thomas Worsch hat das ja schon wunderbar gezeigt.

03:09.890 --> 03:13.090
Es gibt eine ganze Reihe von Beratungseinrichtungen drumherum.

03:13.690 --> 03:17.130
Für die konkrete Situation, ich habe fachliche Fragen, sind eigentlich

03:17.130 --> 03:19.650
ihre Tutoren schon mal eine der ersten Anlaufstellen.

03:19.650 --> 03:23.510
Sie sind nachher zugeteilt in Tutoriumsgruppen, die haben konkret die

03:23.510 --> 03:26.870
Aufgabe, natürlich mit Ihnen auch die Übungsblätter zu besprechen.

03:27.690 --> 03:29.030
Da werde ich nachher noch drauf eingehen.

03:29.510 --> 03:34.010
Aber die Tutoren sind auch ihre erste Anlaufstelle für Fragen.

03:34.310 --> 03:37.130
Und der große Vorteil der Tutoren ist halt, es sind so viele, die

03:37.130 --> 03:40.430
Tutoriumsgruppen sind im Vergleich zu dem, wie wir hier sitzen, sehr

03:40.430 --> 03:40.970
viel kleiner.

03:41.350 --> 03:44.630
Das heißt, da haben Sie auch die Chance, auf sehr individuelle Fragen

03:44.630 --> 03:46.030
von Ihnen auch eine Antwort zu bekommen.

03:46.030 --> 03:49.690
Sie können sich natürlich vorstellen, ich kann hier natürlich in dem

03:49.690 --> 03:52.010
Rahmen nicht großartig Zwischenfragen beantworten.

03:52.070 --> 03:54.050
Weil wenn wir damit anfangen würden, dann würde man gar keinen Stoff

03:54.050 --> 03:54.610
mehr durchbekommen.

03:54.690 --> 03:56.130
Das ist sehr unbefriedigend, auch für mich.

03:56.230 --> 03:59.170
Ich bin eigentlich jemand, der viel lieber auch im Dialog lehrt.

03:59.550 --> 04:02.370
Aber es ist natürlich klar, in der Masse ist das so nicht machbar.

04:02.870 --> 04:03.850
Sie brauchen sich aber nicht ärgern.

04:04.290 --> 04:07.610
Das ist egal, ob wir jetzt 900 Leute haben wie jetzt oder 600, das ist

04:07.610 --> 04:08.690
in beiden Fällen nicht mehr machbar.

04:09.610 --> 04:14.930
Ich stehe aber immer auch nach jeder Vorlesung bereit hier, um

04:14.930 --> 04:16.790
Verständnisfragen und so weiter entgegenzunehmen oder auch

04:16.790 --> 04:17.850
organisatorische Fragen.

04:18.430 --> 04:22.590
Also insofern können Sie sich die Frage auch dann aufbauen bis dahin.

04:22.990 --> 04:25.950
Dann haben wir natürlich auch eine Chat-Funktion, wo Sie im Prinzip

04:25.950 --> 04:31.210
auch Ihre Fragen eingeben können, da unter Umständen die Sache auch

04:31.210 --> 04:35.190
schon beantwortet bekommen oder aber in ganz schlimmen Fällen, wo die

04:35.190 --> 04:37.770
Folien auch bei mir missverständlich sind, bekomme ich dann ein

04:37.770 --> 04:40.330
Handzeichen von unserem Moderator und dann versuche ich natürlich

04:40.330 --> 04:41.350
direkt auch darauf einzugehen.

04:41.350 --> 04:44.730
Aber das ist, wie gesagt, einfach bei der Menge immer nur die

04:44.730 --> 04:45.170
Ausnahme.

04:47.510 --> 04:52.330
Ja, der Übungsbetrieb funktioniert so, dass es parallel zu dieser

04:52.330 --> 04:57.550
Vorlesung sechs begleitende Übungsblätter gibt, wo Sie praktisch quasi

04:57.550 --> 05:00.590
die Sachen auch üben sollen, die wir in der Vorlesung hier vermitteln.

05:01.130 --> 05:03.530
Und mit dem Programmieren, das ist so ein bisschen wie mit dem Klavier

05:03.530 --> 05:06.870
spielen, das lernt man nicht durch Bücher lesen oder Noten lesen, das

05:06.870 --> 05:07.670
lernt man durch Üben.

05:07.670 --> 05:09.490
Und das ist beim Programmieren gar nicht so viel anders.

05:10.050 --> 05:13.190
Was ich in der Vorlesung machen kann, ist Ihnen zu sagen, welche

05:13.190 --> 05:16.870
Konzepte gibt es beim Programmieren, was sind die Elemente der

05:16.870 --> 05:19.290
Programmiersprache, mit denen Sie sich ausdrücken, ich kann Ihnen

05:19.290 --> 05:20.350
diese Konzepte erläutern.

05:20.790 --> 05:24.610
Aber wie Sie diese Konzepte nutzen, wie Sie also mit anderen Worten

05:24.610 --> 05:27.970
ein guter Programmierer werden, das ist dann die Übung, dass Sie

05:27.970 --> 05:29.490
selber auch diese Dinge einsetzen.

05:29.630 --> 05:32.730
Und dann löst es gar nichts, wenn ich Ihnen das Konzept immer wieder

05:32.730 --> 05:33.490
neu erkläre.

05:33.570 --> 05:35.910
Sie müssen es einfach nicht nur verstanden haben, sondern dann auch

05:35.910 --> 05:37.230
eben üben beim Einsetzen.

05:37.230 --> 05:39.470
Das ist genau eine Dinge, die wir durch die Übungsblätter erreichen

05:39.470 --> 05:39.810
wollen.

05:40.910 --> 05:45.730
Jetzt ist es so, ähnlich auch wie bei Herrn Worsch, damit Sie den

05:45.730 --> 05:51.470
sogenannten Übungsschein bekommen, brauchen Sie 50% der Punkte bei den

05:51.470 --> 05:52.090
Übungsblättern.

05:52.830 --> 05:55.410
Sie bekommen im Prinzip immer, wenn Sie die Übungsblätter abgegeben

05:55.410 --> 05:59.390
haben, nach einer Woche, Rückmeldungen durch Ihren Tutor, wie gut Sie

05:59.390 --> 06:01.430
das Blatt bearbeitet haben, das heißt, Sie sehen dann im Prinzip

06:01.430 --> 06:03.410
einfach mal so wie Ihr Punktekonto.

06:04.310 --> 06:08.450
Meine Bitte ist aber natürlich trotzdem, nicht aufhören, wenn Sie 50%

06:08.450 --> 06:11.370
der Punkte haben, sagen, ha, jetzt bin ich ja fertig, ich habe ja 50%,

06:11.370 --> 06:14.310
der Übungsschein stimmt, der wird Ihnen auch nicht nachher aberkannt.

06:14.850 --> 06:17.930
Aber es ist natürlich so, dass die Inhalte auch in den späteren

06:17.930 --> 06:21.450
Vorlesungen nachher auch alle relevant sind für die Abschlussaufgaben

06:21.450 --> 06:23.890
und insofern macht es natürlich Sinn, kontinuierlich im Übungsbetrieb

06:23.890 --> 06:24.450
zu arbeiten.

06:24.970 --> 06:27.690
Das ist übrigens ein genereller Tipp, den ich Ihnen auch aus meinem

06:27.690 --> 06:29.610
eigenen Studium noch als Erfahrung mitgeben kann.

06:30.490 --> 06:34.810
Versuchen Sie, so schnell es geht, Vorlesungsinhalte nachzuarbeiten,

06:34.910 --> 06:37.870
nachzubereiten, das immer in die Zukunft zu schieben, zu sagen, da

06:37.870 --> 06:40.750
kümmere ich mich dann in der vorlesungsfreien Zeit drum, das geht dann

06:40.750 --> 06:41.410
meistens schief.

06:41.690 --> 06:44.910
Ich gebe zu, es ist schwer, ich weiß, dass Sie hier im

06:44.910 --> 06:47.670
Bachelorstudium, ich war früher hier im Diplom, einen sehr, sehr

06:47.670 --> 06:50.330
vollen Stundenplan haben und auch durch den Übungsblattbetrieb auch in

06:50.330 --> 06:52.890
den anderen Fächern, Grundbegriffe der Informatik, die

06:52.890 --> 06:55.590
Mathematikveranstaltung, eine hohe zeitliche Belastung haben.

06:57.350 --> 07:00.810
Trotzdem aber versuchen Sie, so gut es geht, gleich dran zu bleiben.

07:01.910 --> 07:08.170
Dann haben wir nach der Vorlesungszeit zwei Abschlussaufgaben, die in

07:08.170 --> 07:10.230
der vorlesungsfreien Zeit bearbeitet werden.

07:11.110 --> 07:15.490
Und um sich für diese Abschlussaufgaben anzumelden, brauchen Sie eben

07:15.490 --> 07:16.390
den Übungsschein.

07:17.490 --> 07:20.390
Jetzt ist es so, diese Abschlussaufgaben, die ersetzen die Klausur.

07:20.650 --> 07:23.990
Also in unserem Fach, hier im Programmieren, gibt es keine Klausur,

07:23.990 --> 07:26.090
sondern Sie bekommen Abschlussaufgaben, die Sie auch über einen

07:26.090 --> 07:28.850
längeren Zeitraum, zwei Wochen, zu Hause bearbeiten können.

07:29.730 --> 07:33.070
Und hier ist es in der Tat ganz wichtig, dass Sie auch verstehen,

07:33.190 --> 07:33.790
warum das so ist.

07:34.030 --> 07:36.590
Weil ich eben gerade sagte, Programmieren ist etwas, was auch mit

07:36.590 --> 07:40.170
praktischer Übung passiert, bin ich der Auffassung, dass man Ihre

07:40.170 --> 07:43.610
Fähigkeit im Programmieren nicht sinnvoll abprüft, indem wir das in

07:43.610 --> 07:44.390
einer Klausur machen.

07:44.470 --> 07:46.790
In einer Klausur könnte ich wieder nachfragen, haben Sie die einzelnen

07:46.790 --> 07:50.250
Konzepte verstanden, aber ob Sie gut programmieren können, kann ich im

07:50.250 --> 07:53.110
Rahmen einer Klausur, die ein oder zwei Stunden dauert, gar nicht

07:53.110 --> 07:53.850
sinnvoll abprüfen.

07:54.150 --> 07:56.530
Deswegen haben wir uns schon vor längerer Zeit hier in Karlsruhe

07:56.530 --> 07:59.870
entschieden, zu sagen, Sie machen noch eine kleine Klausur, Sie

07:59.870 --> 08:04.070
bekommen Abschlussaufgaben, die Sie zu Hause bearbeiten und die wir

08:04.070 --> 08:04.970
dann nachher bewerten.

08:06.370 --> 08:10.870
Jetzt werden natürlich die Cleveren von Ihnen sagen, super, ich mache

08:10.870 --> 08:14.310
das zu Hause, kein Prof guckt mir über die Schulter, dann kann ich ja

08:14.310 --> 08:16.390
einfach von meinen Komplitonen die Lösung kopieren.

08:17.850 --> 08:21.310
Die selbe Versuchung könnte auch beim Übungsschein entstehen, bei den

08:21.310 --> 08:22.950
Übungsblättern, weil die machen Sie ja auch zu Hause.

08:24.110 --> 08:28.650
Wir haben im Praktomat eine Plagiarismuserkennung eingebaut, das

08:28.650 --> 08:32.270
heißt, wenn zwei Lösungen verdächtig gleich sind, da geht bei uns eine

08:32.270 --> 08:35.610
Alarmglocke an und mehr dazu später.

08:35.770 --> 08:38.250
Also mit anderen Worten, so einfach abschreiben ist natürlich nicht

08:38.250 --> 08:40.170
das, was wir Ihnen beibringen wollen, wir bilden Sie nicht für das

08:40.170 --> 08:42.930
postelektrische Zeitalter aus, wo Sie unter Umgebung des Großhörens

08:42.930 --> 08:45.510
einfach nur Dinge kopieren, sondern es geht natürlich darum, dass Sie

08:45.510 --> 08:46.790
programmieren können nachher.

08:50.250 --> 08:54.150
Das Wichtige, das hat auch Herr Walsch ja heute Morgen erwähnt, das

08:54.150 --> 08:55.970
ist dieses Thema mit den Orientierungsprüfungen.

08:56.130 --> 08:59.030
Und genauso wie Grundbegriff der Informatik ist auch Programmieren

08:59.030 --> 09:00.350
eine Orientierungsprüfung.

09:00.890 --> 09:04.070
Und das heißt, wenn Sie das zweimal nicht bestanden haben, können Sie,

09:04.270 --> 09:06.530
wenn Sie dann auch noch durch die mündliche fallen, müssen Sie sich

09:06.530 --> 09:08.110
extra matrikulieren.

09:08.250 --> 09:09.990
Das ist bei diesen Orientierungsprüfungen so.

09:09.990 --> 09:13.490
Und das ist, wenn man so will, unser Aufnahmekriterium hier ins

09:13.490 --> 09:13.950
Studium.

09:15.130 --> 09:17.610
Andere Universitäten machen große Aufnahmeprüfungen, das machen wir

09:17.610 --> 09:20.150
hier alles nicht in der Informatik am KIT, aber wie gesagt,

09:20.410 --> 09:22.190
Programmieren und Grundbegriff ist, wenn man so will, die

09:22.190 --> 09:22.910
Aufnahmeprüfung.

09:24.010 --> 09:25.530
Ja, wie funktioniert das mit den Übungen?

09:25.630 --> 09:31.130
Sie bekommen, wie man schematisch dargestellt, am Donnerstag dann ein

09:31.130 --> 09:37.890
Übungsblatt und das lösen Sie dann und dann wird es vom Tutor

09:37.890 --> 09:38.490
korrigiert.

09:38.490 --> 09:42.030
Das nächste Blatt ist auch schon ausgegeben und dann findet in der

09:42.030 --> 09:45.290
Woche drauf dann die Besprechung des alten Übungsblattes in der

09:45.290 --> 09:46.930
Übungsgruppe im Tutorium statt.

09:48.210 --> 09:50.450
Also das ist immer so der Modus ist konkret.

09:51.110 --> 09:56.170
Am Donnerstag um 1 Uhr bekommen Sie ein Übungsblatt und wie gesagt,

09:56.290 --> 09:58.530
danach haben Sie zwei Wochen Zeit, das zu lösen.

09:58.630 --> 10:00.850
Sie geben es dann auch wieder bis zum Donnerstag um 1 Uhr ab.

10:03.730 --> 10:07.050
Und dann, wie gesagt, wird die Woche drauf, das dann auch besprochen.

10:10.050 --> 10:15.190
Hier haben Sie nochmal den Überblick über die Wochen, die wir jetzt in

10:15.190 --> 10:16.370
diesem Wintersemester haben.

10:16.870 --> 10:19.310
Hier sehen Sie die Verteilung der sechs Blätter, das sind vier Blätter

10:19.310 --> 10:20.590
vor Weihnachten.

10:21.030 --> 10:23.830
Dann haben Sie natürlich logischerweise wegen der Weihnachtsurlaubs

10:23.830 --> 10:28.690
und Neujahr eine längere Bearbeitungszeit für das fünfte Übungsblatt

10:28.690 --> 10:31.990
und dann gibt es danach noch das sechste.

10:32.790 --> 10:35.590
Und dann wird das halt nachher noch besprochen und danach fangen dann

10:35.590 --> 10:37.090
eben diese Abschlussaufgaben an.

10:38.350 --> 10:40.870
Nochmal für diejenigen von Ihnen, die nicht aus Baden-Württemberg

10:40.870 --> 10:42.590
kommen, mal ein kurzes Handzeichen, wer das ist.

10:43.370 --> 10:44.910
Das sind viele.

10:45.490 --> 10:47.390
Deswegen, nee, ich komme auch nicht aus Baden-Württemberg, ich komme

10:47.390 --> 10:50.010
aus Rheinland-Pfalz, also merkt man auch in meinem undeutlichen,

10:50.150 --> 10:50.770
schnellen Sprechen.

10:51.770 --> 10:55.010
Nee, aber es ist tatsächlich so, ich will Ihnen gleich eine Sache

10:55.010 --> 10:56.990
bewahren, die man nämlich nur als Baden-Württemberger weiß.

10:58.490 --> 11:01.310
Dieses Bundesland hier kommt erst bei Heilige Drei Könige aus dem

11:01.310 --> 11:02.110
Suspend -Modus.

11:03.230 --> 11:05.450
Das heißt, es macht gar keinen Sinn, dass Sie direkt nach Weihnachten

11:05.450 --> 11:06.910
hier wieder an die Uni gehen, das ist der Laden dicht.

11:07.010 --> 11:09.230
Ich habe das natürlich prompt als Rheinland-Pfälzer falsch gemacht,

11:09.370 --> 11:12.090
ich war dann hier, habe mich gewundert, dass irgendwie gar nichts los

11:12.090 --> 11:15.830
war, aber wie gesagt, eine Woche nach, quasi sinngemäß, eine Woche

11:15.830 --> 11:19.750
nach Neujahr haben Sie immer noch Urlaub in Baden-Württemberg, erst

11:19.750 --> 11:20.850
dann geht der Unibetrieb wieder los.

11:21.110 --> 11:26.030
Deswegen auch hier diese lange Spreizung bis zum 13.01., für die, wie

11:26.030 --> 11:29.510
gesagt, Nicht-Baden-Württemberger der Hinweis, Sie haben hier etwas

11:29.510 --> 11:31.090
längeren Winterurlaub.

11:31.450 --> 11:31.590
So.

11:33.790 --> 11:35.790
Wie funktioniert das jetzt mit der Bewertung?

11:35.890 --> 11:40.490
Sie bekommen sechs Blätter, jedes Blatt hat 20 Punkte, macht also 120

11:40.490 --> 11:43.970
Punkte, die Hälfte davon, also 60, sind erforderlich, um den

11:43.970 --> 11:45.150
Übungsschein zu erhalten.

11:45.790 --> 11:46.810
Ja, was bewerten wir?

11:47.550 --> 11:52.470
Sie geben im Prinzip immer Computerprogramme ab und die bewerten wir

11:52.470 --> 11:55.190
zum einen danach, tun Sie das, was Sie sollen.

11:55.430 --> 11:59.570
Dazu testet der Praktomat, also dieses System, wo Sie nachher Ihren

11:59.570 --> 12:03.090
Code hochladen, das Programm erstmal automatisch ab.

12:03.370 --> 12:06.190
Es gibt eine Reihe von Testfällen, die sind nachher auch öffentlich,

12:06.310 --> 12:09.570
die können Sie quasi auch nutzen bei der Entwicklung Ihres Programms.

12:10.030 --> 12:12.470
Schauen, ja, ist das, was ich mir überlegt habe, tatsächlich sinnvoll,

12:12.910 --> 12:15.910
indem Sie einfach mal schauen, ob der Praktomat das so akzeptiert.

12:18.170 --> 12:21.410
Aber, es gibt auch Testfälle, die wir natürlich nicht öffentlich

12:21.410 --> 12:24.910
machen, mit denen wir nachher auch prüfen, ob Ihr Programm das tut,

12:24.950 --> 12:25.450
was es soll.

12:25.790 --> 12:28.330
Die machen wir deswegen nicht öffentlich, weil sonst würden Sie ja

12:28.330 --> 12:31.310
unter Umständen jeden einzelnen Testfall quasi so abprogrammieren und

12:31.310 --> 12:33.190
gucken, dass das halt dann das richtige Ergebnis rauskommt, was aber

12:33.190 --> 12:35.470
natürlich nicht das sinnvolle Programm ist, sondern nur ein Programm,

12:35.590 --> 12:37.630
was halt gerade eine endliche Zahl von Testfällen bearbeitet.

12:39.050 --> 12:44.370
Dann wird aber zunehmend im Verlauf der Vorlesung nicht nur eine Rolle

12:44.370 --> 12:48.410
spielen, dass Ihr Programm das tut, was es soll, sondern man wird auch

12:48.410 --> 12:51.170
im Prinzip diese Stilfragen sich anschauen.

12:51.610 --> 12:53.130
Wie gut ist das modelliert?

12:53.290 --> 12:54.230
Ist der Code lesbar?

12:54.330 --> 12:56.150
Ist das vernünftig strukturiert, modularisiert?

12:56.610 --> 13:00.590
Das sind dann alles im Prinzip Themen, die auch abgeprüft werden vom

13:00.590 --> 13:03.950
Praktomaten und die auch der Tutor sich dann anschauen wird.

13:05.450 --> 13:09.590
Wie gesagt, bei Betrugs, das erwähne ich hier nochmal, gibt es keinen

13:09.590 --> 13:09.990
Schein.

13:11.090 --> 13:15.350
Und wie gesagt, man könnte immer denken, naja, ich nehme halt mal

13:15.350 --> 13:17.530
schnell die Lösung von Kommilitonen und dann bin ich ja fertig, das

13:17.530 --> 13:18.070
merkt der ja nicht.

13:18.410 --> 13:21.590
Ich habe ja nicht in einer kontrollierten Hörsaal gesessen bei der

13:21.590 --> 13:22.110
Bearbeitung.

13:22.450 --> 13:24.150
Aber wie gesagt, das ist nicht die Logik, wie es hier geht.

13:24.390 --> 13:26.270
Wir wollen, dass Sie das in Ruhe zu Hause bearbeiten.

13:26.370 --> 13:28.410
Es ist auch vollkommen okay, wenn Sie mit den Kommilitonen darüber

13:28.410 --> 13:30.790
reden, aber bitte entwickeln Sie Ihre eigene Lösung.

13:31.070 --> 13:33.130
Das ist hoffentlich nachvollziehbar.

13:34.490 --> 13:37.830
So, weil Informatiker natürlich immer Diagramme lieben.

13:37.830 --> 13:41.830
Hier nochmal etwas präziser aufgemalt als Ablaufdiagramm.

13:43.430 --> 13:44.310
Wenig verwunderlich.

13:44.830 --> 13:45.550
Wir sind jetzt hier.

13:46.050 --> 13:46.430
Start.

13:47.330 --> 13:51.390
Und Sie müssen sich jetzt erstmal in einer Reihe von Systemeintragen

13:51.390 --> 13:52.150
registrieren.

13:53.310 --> 13:55.770
Von WebInscribe haben wir heute Morgen auch schon mal gehört.

13:55.890 --> 13:58.170
Das ist das System für die Tutoriengruppen.

13:58.410 --> 14:01.630
Und ich werde das jetzt auch im Folgenden erläutern, welche Systeme

14:01.630 --> 14:02.010
das sind.

14:03.290 --> 14:06.950
Wenn Sie diese Eintragungen alle gemacht haben, idealerweise jetzt

14:06.950 --> 14:09.230
auch gleich am Anfang, bei WebInscribe zum Beispiel ist schon die

14:09.230 --> 14:15.390
Deadline morgen, dann können Sie die Blätter bearbeiten im Verlauf der

14:15.390 --> 14:17.130
Vorlesung, wie ich Ihnen das gezeigt habe.

14:17.830 --> 14:22.570
Im Erfolgsfall bekommen Sie einen Übungsschein und dann können Sie

14:22.570 --> 14:25.430
sich nochmal über das Studierendenportal und bei Praktomaten anmelden

14:25.430 --> 14:26.730
für die Abschlussaufgaben.

14:28.090 --> 14:31.610
Und wenn Sie die da bestanden haben, prima, dann sind Sie fertig

14:31.610 --> 14:31.990
hiermit.

14:32.750 --> 14:38.990
Aber wenn Sie den Übungsschein nicht bekommen haben, dann müssen Sie

14:38.990 --> 14:39.630
hier nochmal durch.

14:40.370 --> 14:44.730
Wir bieten aber auch im Sommersemester den Übungsbetrieb an, nicht die

14:44.730 --> 14:47.730
Vorlesung, aber den Übungsbetrieb, sodass Sie dann, um jetzt nicht

14:47.730 --> 14:50.630
gleich ein ganzes Jahr im Studium zu verlieren, auch nochmal in den

14:50.630 --> 14:53.050
Übungsbetrieb im Sommersemester gehen können und da zum Beispiel den

14:53.050 --> 14:55.250
Schein nochmal versuchen können zu erwerben.

14:56.630 --> 15:01.050
Wenn Sie jetzt bei den Abschlussaufgaben weniger als die Hälfte

15:01.050 --> 15:04.390
erreicht haben, der Punktzahl, dann können Sie das Ganze nochmal

15:04.390 --> 15:05.050
wiederholen.

15:05.150 --> 15:08.250
Sie brauchen also nicht nochmal den Übungsschein machen, der gilt dann

15:08.250 --> 15:11.270
immer noch, aber Sie können noch einmal auch die Abschlussaufgabe

15:11.270 --> 15:12.250
wiederholen.

15:13.710 --> 15:16.030
Falls das nicht der Fall ist, wie gesagt, es gibt nochmal eine

15:16.030 --> 15:18.450
mündliche Prüfung, aber dann ist, wie gesagt, weil es eine

15:18.450 --> 15:21.910
Orientierungsprüfung ist, halt schon das Ende Ihres Studiums erreicht.

15:21.990 --> 15:22.970
Das will ich natürlich nicht hoffen.

15:22.970 --> 15:25.530
Ich bin auch keiner, der hier den Anspruch hat, möglichst viele Leute

15:25.530 --> 15:26.110
rauszuprüfen.

15:26.190 --> 15:28.210
Ganz im Gegenteil, ich freue mich, wenn ich möglichst alle von Ihnen

15:28.210 --> 15:28.790
mitbekomme.

15:29.930 --> 15:33.150
Aber verstehen Sie das eben im Sinne von einer Art Aufnahmeprüfung für

15:33.150 --> 15:33.710
das Studium.

15:34.110 --> 15:36.710
Die hatten Sie eben noch nicht jetzt vorher gehabt, aber wie gesagt,

15:37.050 --> 15:39.330
die Orientierungsprüfung ist, wenn man so will, hier in Karlsruhe, die

15:39.330 --> 15:40.190
Zulassung zum Studium.

15:40.650 --> 15:43.870
Deswegen auch das harte Ende, wenn man das hier nicht hinbekommt, weil

15:43.870 --> 15:46.530
wir denken, dass Sie dann auch die späteren Inhalte im Studium nicht

15:46.530 --> 15:47.890
verstehen werden, nicht bearbeiten können.

15:51.130 --> 15:55.390
Gut, dann ist klar, bei jedem einzelnen Blatt, wenn Sie da betrügen,

15:56.510 --> 15:57.550
war es das mit dem Übungsschein.

15:57.630 --> 15:59.290
Sie können gleich wieder im nächsten Semester anfangen.

15:59.430 --> 16:01.890
Also insofern der Zeitverlust vorprogrammiert.

16:02.250 --> 16:03.170
Sollten Sie also nicht tun.

16:05.330 --> 16:06.550
Dasselbe gilt beim Betrug.

16:07.250 --> 16:11.070
Wenn Sie bei der ersten Aufgabe auffliegen mit Plagiarismus, sofort

16:11.070 --> 16:13.990
wieder hier, können Sie gleich beim nächsten Mal weitermachen, haben

16:13.990 --> 16:14.930
Sie schon einen Versuch verloren.

16:14.930 --> 16:17.510
Also auch hier wieder eine gute Idee.

16:19.130 --> 16:21.490
Die Anmeldung beim Praktomat, das können Sie öfter machen, da fliegen

16:21.490 --> 16:22.310
Sie nicht aus dem Studium.

16:25.990 --> 16:28.810
Wo kann ich die Aufgaben bearbeiten?

16:30.150 --> 16:33.030
Erfahrungsgemäß ist das heute gar nicht mehr so eine Frage, weil die

16:33.030 --> 16:35.590
meisten von Ihnen ihren eigenen Rechner haben und es ist also

16:35.590 --> 16:37.850
vollkommen okay, wenn Sie das eben zu Hause machen oder wo auch immer

16:37.850 --> 16:39.830
Sie das gerne machen wollen.

16:40.210 --> 16:42.650
Es gibt aber auch für diejenigen, die zum Beispiel keinen Rechner

16:42.650 --> 16:46.110
haben oder die das gerne an der Uni machen wollen, im Poolraum der

16:46.110 --> 16:50.970
Artis, zum Beispiel hier im Untergeschoss, Möglichkeiten, das auch an

16:50.970 --> 16:54.310
einem Rechner von der Uni zu machen oder auch genauso im Poolraum von

16:54.310 --> 16:56.550
unserem Rechenzentrum, dem SCC.

16:57.270 --> 16:59.210
Hier können Sie das auch, wie gesagt, im Untergeschoss machen.

16:59.310 --> 17:01.510
Das sind Poolräume mit den Möglichkeiten, dass Sie da rechte

17:01.510 --> 17:02.190
Ressourcen nutzen.

17:03.150 --> 17:06.790
Und das sind im Wesentlichen die Arten, wo Sie dann die Aufgaben

17:06.790 --> 17:07.510
bearbeiten können.

17:11.440 --> 17:16.340
So, dann vielleicht als wichtigste URL, hier auch nochmal der Hinweis,

17:16.880 --> 17:20.260
das ist eigentlich die einzige, die Sie brauchen, diese URL, das ist

17:20.260 --> 17:25.060
die, über die Vorlesung, da können Sie auch diese Folien runterladen.

17:25.520 --> 17:28.180
Das heißt im Prinzip, wenn Sie diese URL haben, kommen Sie auch an

17:28.180 --> 17:31.180
diesen Foliensatz, den ich Ihnen jetzt gerade zeige, ran und den Rest

17:31.180 --> 17:32.520
brauchen Sie dann eigentlich auch nicht mehr mitschreiben.

17:33.740 --> 17:41.120
So, auf dieser Homepage bei mir am Institut bekommen Sie im Prinzip

17:41.120 --> 17:45.400
die Übungsblätter, die Vorlesungsfolien, Links zu weiteren Sachen und

17:45.400 --> 17:47.400
auch Tweets zu gewissen Neuigkeiten.

17:47.560 --> 17:50.080
Insofern wäre auch die Bitte, schauen Sie da regelmäßig hin.

17:50.880 --> 17:53.400
Falls jetzt mal irgendwas angekündigt werden müsste, was weiß ich, es

17:53.400 --> 17:56.340
könnte ja sein, dass ich krank werde oder sonst was, da würde man das

17:56.340 --> 17:57.800
dann halt bekannt geben.

18:00.880 --> 18:05.660
Das ist also, wie gesagt, die wichtigste URL.

18:06.280 --> 18:09.840
Alles andere, wie gesagt, haben Sie dann, wenn Sie diese URL haben,

18:09.840 --> 18:11.640
dann kommen Sie an den ganzen Foliensatz hier ran.

18:25.400 --> 18:29.180
Gut, dann ist das nächste die Ilias-Plattform.

18:30.040 --> 18:34.280
Das ist im Prinzip die Lehr- und Lernplattform des KITs.

18:34.700 --> 18:40.460
Und hier gibt es insbesondere wichtig für Sie ein allgemeines

18:40.460 --> 18:43.880
Diskussionsforum, wo Sie also Fragen, die Sie zur Vorlesung haben,

18:44.320 --> 18:48.640
eintragen können, einstellen können und die Tutoren bei uns werden

18:48.640 --> 18:52.380
auch dafür bezahlt, dass Sie hier Antworten geben.

18:52.700 --> 18:55.940
Genauso aber auch, wie Sie natürlich auch Ihren Kommilitonen helfen

18:55.940 --> 18:56.860
können hier an der Stelle.

18:57.320 --> 19:00.440
Also wenn Sie natürlich eine Frage auch beantworten können, dürfen Sie

19:00.440 --> 19:02.080
auch da ruhig die Antwort reingeben.

19:03.040 --> 19:06.780
Falls das jetzt keine gute Antwort war, würde dann vielleicht ein

19:06.780 --> 19:09.100
Tutor eingreifen, aber im Großen und Ganzen, wie gesagt, ist das auch

19:09.100 --> 19:10.980
so ein bisschen gedacht zum Austausch.

19:11.320 --> 19:14.140
Und die Erfahrung zeigt, es ist eigentlich ganz selten, dass Sie eine

19:14.140 --> 19:15.040
spezielle Frage haben.

19:15.040 --> 19:17.120
Aber meistens haben Sie eine Frage, die auch andere Kommilitonen

19:17.120 --> 19:17.460
haben.

19:18.420 --> 19:20.760
Und insofern ist es auch sinnvoll, dass dann auch die Antwort wieder

19:20.760 --> 19:22.220
alle Kommilitonen sehen können.

19:22.680 --> 19:24.920
Und insofern ist es aber meine Bitte, nutzen Sie das Forum.

19:25.300 --> 19:28.180
Es hilft wirklich dann nicht nur Ihnen, die eine konkrete Frage haben,

19:28.260 --> 19:29.480
sondern in der Regel auch Kommilitonen.

19:30.340 --> 19:35.820
Es gibt auch für jedes Übungsblatt spezifisch nochmal Diskussionsforum

19:35.820 --> 19:36.040
da.

19:37.040 --> 19:39.680
Und das hat auch den Vorteil, dass falls Sie jetzt einfach speziellere

19:39.680 --> 19:42.420
Fragen zu dem Übungsblatt haben, auch da die richtigen Leute haben,

19:42.480 --> 19:43.320
die das dann beantworten.

19:46.700 --> 19:50.400
So, das nächste System, wie gesagt, wir hatten es schon mal heute

19:50.400 --> 19:53.660
Morgen bei Herrn Worsch, das ist das WebInscribe System.

19:54.300 --> 19:56.460
Das verwaltet die Tutoriumtermine.

19:57.360 --> 20:00.460
So, diese Tutoriumgruppen finden natürlich nicht alle nur in einem

20:00.460 --> 20:03.540
Zeitslot statt, so viele Räume hätten wir gar nicht, sondern wir

20:03.540 --> 20:06.080
müssen das natürlich schon strecken über verschiedene Termine.

20:06.880 --> 20:10.080
Und hier können Sie sich im Prinzip eintragen, dann bekommen Sie eben

20:10.080 --> 20:14.240
den Tutor zugeteilt und Ihre Tutoriumsgruppe und auch den Ort und die

20:14.240 --> 20:16.100
Zeit, wo Ihr Tutorium stattfindet.

20:16.100 --> 20:20.040
Die meisten Tutorien finden bei uns im Informatik-Hauptgebäude statt,

20:20.180 --> 20:23.260
da gibt es im Untergeschoss eben die Tutoriumsräume.

20:25.060 --> 20:29.840
Und ganz, ganz wichtig, das müssen Sie jetzt möglichst bald machen,

20:30.180 --> 20:33.100
weil es ist klar, wir müssen Ihnen natürlich auch möglichst schnell

20:33.100 --> 20:35.860
jetzt die Tutoriumszuteilung bekannt geben, damit Sie auch in Ihr

20:35.860 --> 20:39.920
Tutorium reingehen können und deswegen diese sehr frühe Frist hier

20:39.920 --> 20:43.300
schon morgen Abend, weil danach wird das System loslaufen und die

20:43.300 --> 20:44.280
Zuteilung berechnen.

20:46.460 --> 20:50.180
Und dann können Sie im Prinzip die Ergebnisse am Freitagmittag abrufen

20:50.180 --> 20:52.860
und dann wissen Sie im Prinzip schon mal, welches Tutorium Sie müssen.

20:53.300 --> 20:56.680
Der Start der eigentlichen Tutorien ist dann die Woche drauf am 28.10.

20:57.220 --> 21:00.820
Und das erste Übungsblatt wird dann nächste Woche ausgegeben.

21:05.090 --> 21:10.550
Dann ein weiteres System, bei dem Sie sich bitte anmelden, das ist der

21:10.550 --> 21:11.550
Praktomat.

21:11.550 --> 21:16.910
Das ist ein System, heute Morgen ist es auch schon mal gefallen, das

21:16.910 --> 21:20.690
hat Gregor Snellding entwickelt, wo es im Wesentlichen darum geht,

21:20.850 --> 21:24.370
dass Sie eine Chance haben, Ihre Programme hochzuladen.

21:25.110 --> 21:28.630
Und im Prinzip funktioniert die ganze Abgabe der Lösungen, der

21:28.630 --> 21:32.190
Abschlussaufgaben und der Übungsblätter über dieses Praktomat-System.

21:33.490 --> 21:36.710
Da bekommen Sie auch Feedback zu Ihrer Abgabe, eben durch die

21:36.710 --> 21:37.570
öffentlichen Testfälle.

21:39.170 --> 21:43.010
Und wichtig ist technisch gesehen, das Ganze funktioniert nur aus dem

21:43.010 --> 21:43.850
KIT -Netz.

21:44.710 --> 21:48.990
Das ist nur über das KIT-Netz aufrufbar.

21:49.270 --> 21:52.870
Wenn Sie jetzt von außerhalb vom KIT-Netz zugreifen wollen, können Sie

21:52.870 --> 21:56.110
allerdings den VPN-Zugang vom KIT nehmen.

21:56.630 --> 21:59.290
Und wie gesagt, da bekommen Sie dann über das SCC, also unser

21:59.290 --> 22:03.790
Rechenzentrum, hier die Informationen, wie Sie sich über VPN mit Ihrem

22:03.790 --> 22:04.870
Account einloggen können.

22:04.870 --> 22:08.710
Und dann sind Sie quasi von außen betunnelt über VPN im KIT-Netz und

22:08.710 --> 22:10.830
dann können Sie daraus auch den Praktomaten aufrufen.

22:11.430 --> 22:13.430
Und das machen auch die meisten Ihrer Kommilitonen so.

22:16.670 --> 22:22.530
So, dann ist es ganz wichtig noch, als weiteren formalen Schritt, wir

22:22.530 --> 22:26.670
brauchen eine Einverständniserklärung von Ihnen für auch die

22:26.670 --> 22:27.930
Verwendung des Praktomaten.

22:28.390 --> 22:35.050
Im Prinzip hier erkennen Sie quasi zum einen die Nutzungsregeln an,

22:35.050 --> 22:37.710
aber Sie erklären auch nochmal, dass Sie nicht plagiieren.

22:40.050 --> 22:45.430
So, und das funktioniert im Wesentlichen auch, dass Sie Vor- und

22:45.430 --> 22:46.950
Nachnamen eingeben und Ihre Matrikelnummer.

22:47.350 --> 22:50.790
Wenn Sie noch keine Matrikelnummer haben, das ist erfahrungsgemäß

22:50.790 --> 22:55.010
immer bei einigen der Fall, weil einfach die Einschreibung so knapp

22:55.010 --> 22:58.770
ist, dass das Studienbüro noch nicht reagiert hat, dann holen Sie es

22:58.770 --> 23:00.530
bitte dann nach, wenn Sie eine Matrikelnummer haben.

23:01.130 --> 23:03.250
In den nächsten Wochen werden Sie garantiert eine haben.

23:03.250 --> 23:08.050
So, das Ganze, weil es juristisch auch relevant ist, drucken Sie bitte

23:08.050 --> 23:11.470
aus, unterschreiben es und dann geben Sie es ab in den

23:11.470 --> 23:16.690
Programmierbriefkästen, die sind im Untergeschoss, bei uns auch im

23:16.690 --> 23:21.950
Informatik -Hauptgebäude am Fassadengarten 5 und wie gesagt, bitte bis

23:21.950 --> 23:23.690
zum 25.10.

23:23.870 --> 23:24.330
einwerfen.

23:29.690 --> 23:33.290
Dann, Sie sehen, die IT-Systeme nehmen kein Ende, wo Sie sich

23:33.290 --> 23:36.290
registrieren müssen, das Campus-System.

23:36.430 --> 23:39.570
Das Campus-System, das Campus-Management-System, dient zur

23:39.570 --> 23:40.710
Prüfungsverwaltung.

23:41.630 --> 23:43.850
Hier müssen Sie sich aus zwei Gründen anmelden.

23:44.090 --> 23:47.350
Einmal anmelden für den Übungsschein, dass Sie sagen, ja, ich nehme am

23:47.350 --> 23:48.370
Übungsbetrieb teil

23:51.650 --> 23:54.430
und dann auch die Anmeldung zur Abschlussaufgabe.

23:55.170 --> 23:59.730
Und ich sage das hier nochmal ganz deutlich, bitte, bitte, bitte,

23:59.770 --> 24:02.630
denken Sie daran, Sie müssen sich nochmal für die Abschlussaufgaben

24:02.630 --> 24:03.090
anmelden.

24:03.170 --> 24:06.290
Das ist einfach so, dass das Campus-Management-System keinen

24:06.290 --> 24:07.330
Automatismus hat.

24:07.750 --> 24:11.650
Das Campus-Management-System kann nicht wissen, dass Sie 50% der

24:11.650 --> 24:14.310
Übungsleistung erreicht haben und Sie automatisch anmelden.

24:14.990 --> 24:17.630
Das ist auch eine Sache, dann würden wieder Leute sagen, ich wusste ja

24:17.630 --> 24:18.610
gar nicht, was ich angemeldet war.

24:18.730 --> 24:23.070
Also Sie müssen sich nochmal explizit anmelden, wenn Sie die 50%

24:23.070 --> 24:25.050
bestanden haben zur Abschlussaufgabe.

24:26.130 --> 24:29.230
Und weil immer wieder gibt es einen kleinen Prozentsatz von Leuten,

24:29.350 --> 24:31.630
die eigentlich die Zugang haben zur Abschlussaufgabe, aber sich

24:31.630 --> 24:32.990
vergessen, rechtzeitig anzumelden.

24:33.310 --> 24:34.570
Und da können wir dann auch nichts mehr machen.

24:38.880 --> 24:42.400
So, das war jetzt eine ganze Menge organisatorischer Infos, deswegen

24:42.400 --> 24:44.620
hier nochmal für Sie eine Zusammenfassung.

24:45.000 --> 24:48.700
Als Allernächstes bitte bei Web in Skype anmelden, damit wir den

24:48.700 --> 24:50.500
Tutoriumsbetrieb planen können.

24:51.180 --> 24:55.620
Dann diesen Disclaimer, diese Einverständniserklärung ausfüllen und in

24:55.620 --> 24:57.380
den Programmieren Briefkasten einwerfen.

24:57.380 --> 25:01.520
Und dann anmelden beim Campusmanagement-System für die

25:01.520 --> 25:03.320
Abschlussaufgaben und den Übungsschein.

25:04.460 --> 25:08.640
Und beim Paktomaten anmelden geht durch Initialen des Erstes

25:08.640 --> 25:09.120
einloggen.

25:12.380 --> 25:19.280
So, dann ist es so, diese Vorlesung hier wird aufgezeichnet und ist

25:19.280 --> 25:23.320
dann nachher bei YouTube so nach drei Stunden ungefähr verfügbar oder

25:23.320 --> 25:26.800
auch bei iTunes U und das ist dann am Folgetag.

25:26.800 --> 25:29.760
Spätestens hier an dieser Stelle sehen Sie, dass es schon gut ist,

25:29.800 --> 25:32.620
wenn Sie die Folien elektronisch sich runterladen, weil das ist klar,

25:32.700 --> 25:34.460
das wollen Sie nicht eintippen als URL hier.

25:36.300 --> 25:41.140
In der Tat, historisch wissen wir auch vom letzten Jahr, dass eine

25:41.140 --> 25:43.680
Zahl von Ihnen das auch gerne wahrnimmt, die Vorlesung entweder

25:43.680 --> 25:48.420
komplett zu Hause dann zu hören oder aber nochmal nachträglich Dinge,

25:48.480 --> 25:50.380
die man vielleicht hier nicht verstanden hat, dann nochmal sich in

25:50.380 --> 25:53.040
Ruhe anzuhören oder auch mit Kommilitonen zu besprechen.

25:53.040 --> 25:55.940
Also das wird auch durchaus genutzt und insofern ist das, glaube ich,

25:55.960 --> 25:57.420
auch ein sehr wichtiger Dienst hier.

26:01.710 --> 26:04.770
So, das ist jetzt nochmal alles zusammengefasst.

26:05.550 --> 26:08.490
Wie gesagt, die oberste URL ist die entscheidende, weil mit der

26:08.490 --> 26:11.650
bekommen Sie alle anderen URLs in Form von diesem Foliensatz.

26:13.370 --> 26:15.910
Wir haben auch, das hatte ich jetzt eben gar nicht erwähnt, auch noch

26:15.910 --> 26:21.610
Twitter, da können Sie auch im Prinzip während der Vorlesung oder auch

26:21.610 --> 26:25.690
aus dem Tutorium raus oder so, Kommentare, Fragen schreiben.

26:26.790 --> 26:30.130
Wir nutzen den Twitter-Kanal auch, um nochmal auch auf Neuigkeiten,

26:30.770 --> 26:32.750
Änderungen der Pläne oder sowas hinzuweisen.

26:34.930 --> 26:37.210
Auf der anderen Seite ist es so, wenn Sie Twitter nicht haben, Sie

26:37.210 --> 26:39.150
müssen auch deswegen keinen Twitter-Account machen.

26:39.270 --> 26:43.690
Das ist quasi ein Angebot für die, die schon Twitter haben, aber Sie

26:43.690 --> 26:47.110
bekommen genauso an die Informationen auch dran über die Webseite.

26:51.100 --> 26:55.820
So, dann wäre ich jetzt mit dem Orga-Teil an der Stelle schon zu Ende

26:56.440 --> 27:00.140
und würde dann weitermachen mit der ersten Vorlesung.

27:38.640 --> 27:43.460
Hier nochmal der Hinweis auch, wie gesagt, wir haben einen Livestream

27:43.460 --> 27:45.520
für die, die jetzt erst gekommen sind.

27:46.040 --> 27:49.240
Das war nochmal auch das, was ich eben gesagt hatte, auch nochmal in

27:49.240 --> 27:50.560
diesem Folien-Satz reingebaut.

27:50.700 --> 27:53.020
Also insofern gehe ich es nicht mehr durch, aber nur damit Sie eine

27:53.020 --> 27:55.980
erhöhte Chance haben, es auch zu sehen, je nachdem welchen Folien-Satz

27:55.980 --> 27:56.920
Sie runterladen zu Hause.

27:58.520 --> 28:01.340
Das ist jetzt ein Überblick über die Themen, die wir hier in der

28:01.340 --> 28:02.780
Programmier -Vorlesung behandeln werden.

28:03.600 --> 28:09.080
Und ich hatte es heute schon in der Einführung gesagt, wir als KIT

28:09.080 --> 28:13.680
-Dozenten stehen hier natürlich vor der besonderen Problematik, gerade

28:13.680 --> 28:17.580
in dieser Vorlesung, dass einige von Ihnen schon recht viel

28:17.580 --> 28:19.060
Programmier -Erfahrung haben.

28:19.580 --> 28:21.940
Sie haben es sich vielleicht selber beigebracht, Sie hatten es in der

28:21.940 --> 28:22.560
Schule gehabt.

28:22.960 --> 28:26.220
Einige von Ihnen haben vielleicht auch schon professionell Software

28:26.220 --> 28:28.280
entwickelt und schon mal Geld dafür bekommen.

28:29.300 --> 28:32.980
Andere von Ihnen sagen, nee, es wird ja immer Werbung gemacht, dass

28:32.980 --> 28:34.940
man Informatik studieren kann, auch ohne Programmieren.

28:35.040 --> 28:36.080
Und das stimmt ja auch.

28:36.660 --> 28:39.380
Das heißt also, Sie haben im Prinzip noch gar keine Vorkenntnisse.

28:39.380 --> 28:42.560
Und es ist vollkommen klar, ich stehe jetzt vor der Herausforderung,

28:42.900 --> 28:45.820
wie bekomme ich Sie beide als Gruppen adressiert.

28:45.960 --> 28:48.760
Ich möchte ja, dass am Ende von Ihnen alle den Vorlesungsstoff

28:48.760 --> 28:49.320
beherrschen.

28:50.260 --> 28:53.060
Und die eine Gefahr ist natürlich, dass ich zu schnell bin und damit

28:53.060 --> 28:56.260
dann die Leute abhänge, die konzeptionell sich erstmal langsam

28:56.260 --> 28:59.080
reindenken müssen in das Programmieren und die noch keine Erfahrung

28:59.080 --> 28:59.380
hatten.

28:59.880 --> 29:04.220
Und aus eigener Erfahrung, als ich Programmieren gelernt hatte, stand

29:04.220 --> 29:06.280
ich auch erstmal davor, als ich eine doppeltverschachtelte Schleife

29:06.280 --> 29:08.660
gesehen habe und gesagt habe, was soll denn das jetzt bitte heißen.

29:09.400 --> 29:12.160
Die anderen von Ihnen, die haben natürlich die Gefahr, dass sie

29:12.160 --> 29:14.360
schnell sagen, ich kann das ja schon alles, was der Reußner da

29:14.360 --> 29:14.740
erzählt.

29:15.100 --> 29:18.000
Mein Gott, wie langweilig ist das, mit welchen Details der dann

29:18.000 --> 29:21.320
irgendwelche Programmiersprachenelemente erzählt, die ich doch schon

29:21.320 --> 29:22.300
seit Jahren beherrsche.

29:22.660 --> 29:24.000
Ich gehe gar nicht mehr in die Vorlesung.

29:25.060 --> 29:29.200
Das Problem ist, dass letzten Endes wir hier zum einen Dinge in einer

29:29.200 --> 29:31.900
gewissen Tiefe behandeln, zum anderen auch immer mit einer gewissen

29:31.900 --> 29:35.600
Begründung, warum ist eine Programmiersprache so wie sie ist, und

29:35.600 --> 29:38.600
schlussendlich es halt doch immer wieder Teile auch in der Vorlesung

29:38.600 --> 29:40.360
gibt, die sie wahrscheinlich noch nicht wissen.

29:42.980 --> 29:46.760
Und wenn Sie jetzt hier drüben diese Liste von Themen sehen, die, die

29:46.760 --> 29:49.020
jetzt noch nicht Programmieren können, kein Schreck, das ist

29:49.020 --> 29:52.580
vollkommen klar, da können Sie noch vieles noch nicht kennen, die, die

29:52.580 --> 29:55.480
schon Programmieren können, die können vielleicht mit vielen dieser

29:55.480 --> 29:58.400
Stichworte was anfangen, einige von Ihnen vielleicht sogar mit allen

29:58.400 --> 30:03.740
Stichworten, aber seien Sie versichert, immer wieder werden auch dabei

30:03.740 --> 30:06.660
Themen rankommen, die eben etwas fortgeschrittener sind, oder auch

30:06.660 --> 30:09.800
einfach nur Stilfragen eines guten Programmierstils sind, die Sie

30:09.800 --> 30:11.120
wahrscheinlich noch nicht können.

30:12.000 --> 30:15.760
Und insofern wäre meine Bitte, auch die, die jetzt schon sagen, ich

30:15.760 --> 30:18.440
fühle mich eigentlich als Programmiercrack, und ich habe schon Geld

30:18.440 --> 30:21.100
damit verdient und alles, ich bin eigentlich schon Softwareentwickler,

30:22.200 --> 30:25.480
schauen Sie zumindest mal, selbst wenn Sie der Vorlesung fernbleiben,

30:25.560 --> 30:28.160
in die Folien rein, dass Sie immer noch die Sachen, die Sie vielleicht

30:28.160 --> 30:29.240
noch nicht kennen, auch mitbekommen.

30:29.960 --> 30:33.380
Ich habe kein Interesse daran, dass Sie die Probleme in den

30:33.380 --> 30:36.320
Abschlussaufgaben bekommen, wenn Sie dann auf einmal sagen, oh Mist,

30:36.480 --> 30:37.560
das konnte ich ja doch noch nicht.

30:38.520 --> 30:40.980
Sondern versuchen Sie auch dann, wenn Sie schon Programmieren können,

30:41.600 --> 30:44.680
zumindest mal elektronisch über die Folien dabei zu bleiben.

30:46.460 --> 30:51.280
Um das jetzt konkret ein bisschen besser zu machen, habe ich versucht,

30:51.640 --> 30:53.860
auf der einen Seite das Niveau so zu halten, dass auch die

30:53.860 --> 30:57.120
Programmieranfänger eine reale Chance haben, eben mitzukommen.

30:57.580 --> 31:00.660
Auf der anderen Seite habe ich immer auch so Folien, die quasi so,

31:00.680 --> 31:02.660
wenn man so will, die Expertenfolien sind.

31:03.200 --> 31:05.740
Das sind Folien, da habe ich dann so ein kleines Einstein-Symbol unten

31:05.740 --> 31:06.200
in der Ecke.

31:06.860 --> 31:08.420
Einstein für besonders schlau.

31:09.680 --> 31:12.740
Und das sind die, wo ich zumindest mal meine, dass die meisten von

31:12.740 --> 31:13.680
Ihnen das wahrscheinlich nicht kennen.

31:13.680 --> 31:16.420
Jetzt können Sie sich sagen, oh, wie spannend, aber trotzdem, schön,

31:16.520 --> 31:17.300
herzlichen Glückwunsch.

31:19.880 --> 31:22.860
Aber da nutzen Sie die Zeit halt eben, um besser Mathe zu lernen hier

31:22.860 --> 31:23.160
oder so.

31:23.580 --> 31:26.440
Aber nichtsdestotrotz, Sie sollten also einfach wissen, ich versuche

31:26.440 --> 31:28.080
mal beide Zielgruppen zu adressieren.

31:28.820 --> 31:31.880
Und dieses Einstein-Symbol heißt auch jetzt für die, die vielleicht

31:31.880 --> 31:34.160
beim Programmieren noch nicht so tief drin sind und sich erst

31:34.160 --> 31:37.860
eindenken müssen, das ist nicht so schlimm, wenn Sie das auf Anhieb

31:37.860 --> 31:38.980
noch nicht verstanden haben.

31:39.280 --> 31:42.180
Am Ende der Vorlesung sollten Sie natürlich alle die Einstein-Folien

31:42.180 --> 31:42.820
auch verstehen.

31:43.380 --> 31:46.400
Aber jetzt am Anfang ist es vollkommen okay, wenn die einen von Ihnen

31:46.400 --> 31:47.920
sagen, endlich mal bringt mir das.

31:48.460 --> 31:50.960
Das ist auch das, was ich im Informatikstudium lernen wollte.

31:51.060 --> 31:52.020
Die anderen Sachen wusste ich schon.

31:52.380 --> 31:54.560
Endlich kommt mal wieder so eine Einstein-Folie und die andere Hälfte

31:54.560 --> 31:57.520
von Ihnen sagt halt, naja, also diese Einstein-Folie, das war jetzt

31:57.520 --> 31:58.140
schon ein bisschen wirr.

31:58.660 --> 32:02.220
Aber wie gesagt, am Ende, wenn Sie alle quasi am Ende der

32:02.220 --> 32:04.520
Vorlesungszeit sind, wenn wir im Februar sind, sollten eigentlich

32:04.520 --> 32:06.560
jeder von Ihnen auch die Einstein-Folien verstanden haben.

32:10.060 --> 32:14.260
So, ansonsten, vielleicht zu den fortgeschritteneren Themen hier,

32:14.800 --> 32:18.820
gehören dann auch Dinge, dass wir zum Beispiel auch über Java Generics

32:18.820 --> 32:24.240
sprechen, also generische Klassen, die typparametrisiert sind, nochmal

32:24.240 --> 32:26.400
speziell auch auf Tests und Assertions eingeben, auch ein paar

32:26.400 --> 32:28.300
Algorithmen bringen und ein paar auch fortgeschrittene

32:28.300 --> 32:29.840
objektorientierte Entwurfsprinzipien.

32:30.220 --> 32:33.160
Aber ich gebe gern zu, ich kann mir auch Leute vorstellen, die sagen,

32:33.280 --> 32:34.920
das kenne ich auch schon alles, aber das sind wahrscheinlich auch

32:34.920 --> 32:35.660
nicht mehr ganz so viele.

32:39.180 --> 32:43.100
Literaturhinweis, es gibt natürlich unheimlich viele Bücher zum

32:43.100 --> 32:43.640
Programmieren.

32:43.800 --> 32:47.420
Das Problem ist eher, was ist eigentlich das richtige Buch, wenn es so

32:47.420 --> 32:47.860
viele gibt.

32:48.320 --> 32:52.500
Was ich hier empfehle, ist ein Buch, auch von Karlsruher Kollegen

32:52.500 --> 32:57.540
geschrieben, was bewusst sich an die Einsteiger richtet, also was

32:57.540 --> 33:00.700
bewusst versucht, niederschwelligen Zugang zum Programmieren zu

33:00.700 --> 33:00.920
machen.

33:01.440 --> 33:05.520
Wenn Sie sagen, Programmieren ist easy für mich, werden Sie das nicht

33:05.520 --> 33:05.900
brauchen.

33:06.740 --> 33:09.420
Aber wenn Sie jemand sind, der sagt, naja, das war jetzt doch ein

33:09.420 --> 33:12.000
bisschen schnell in der Vorlesung, und den Hintergrund von ein paar

33:12.000 --> 33:14.580
Konzepten habe ich doch nicht verstanden, dann ist das eigentlich ein

33:14.580 --> 33:17.980
Buch, was es wirklich sehr schön, nochmal leicht zugänglich erklärt

33:17.980 --> 33:19.120
und wo Sie das nachlesen können.

33:19.920 --> 33:24.320
Das Buch steht natürlich auch bei uns in der Bibliothek, insofern, Sie

33:24.320 --> 33:25.480
müssen das nicht zwanghaft kaufen.

33:25.860 --> 33:29.240
Ich bekomme auch keine Tandeme hier von den Kollegen, aber es ist

33:29.240 --> 33:32.500
tatsächlich nur ein Hinweis, dass es eine Möglichkeit ist,

33:32.500 --> 33:35.320
niederschwellig einen Programmiereinstieg zu haben, auch in deutscher

33:35.320 --> 33:37.280
Sprache, wenn das wichtig ist.

33:38.880 --> 33:41.400
Ansonsten, generell, werde ich hin und wieder mal Literaturhinweise

33:41.400 --> 33:44.460
auch geben, im Laufe der Vorlesung, auch fortgeschrittenere

33:44.460 --> 33:47.320
Literaturhinweise, also für diejenigen von Ihnen, die eigentlich schon

33:47.320 --> 33:48.720
vieles kennen bei der Programmierung.

33:50.160 --> 33:53.040
Und auch wenn ich hier bewusst ein deutschsprachiges Buch empfohlen

33:53.040 --> 33:56.180
habe, grundsätzlich der Hinweis, aber das gilt für das gesamte

33:56.180 --> 33:58.020
Informatische, ich habe schon bei Ihnen keine Angst vor englischer

33:58.020 --> 33:58.680
Literatur.

33:59.840 --> 34:02.960
Viele englische Lehrbücher sind von vornherein didaktisch sehr gut

34:02.960 --> 34:07.760
aufgebaut, und insofern wäre es eigentlich schade, wenn Sie wegen

34:07.760 --> 34:11.340
Sprachgründen einen Umweg über ein englischsprachiges Lehrbuch machen,

34:11.900 --> 34:15.080
sondern ganz im Gegenteil nutzen Sie das, da sind auch viele sehr gute

34:15.080 --> 34:15.800
Lehrbücher dabei.

34:17.260 --> 34:21.540
Und ich werde dann immer am Anfang von der Vorlesung sagen, wo finden

34:21.540 --> 34:25.380
Sie in diesem Buch die Inhalte von der Vorlesung, und das ist jetzt

34:25.380 --> 34:29.100
hier in diesem Abschnitt 2.2, was heißt Programmieren, und Abschnitt 3

34:29.100 --> 34:30.340
.1, mein erstes Programm.

34:31.140 --> 34:33.780
Ansonsten werde ich das Buch natürlich nicht sklavisch durchgehen,

34:33.840 --> 34:36.520
sondern ich habe meine eigene didaktische Reihenfolge, wie ich durch

34:36.520 --> 34:39.080
den Stoff gehen will, insbesondere eben auch, weil ich immer beide

34:39.080 --> 34:41.260
Gruppen adressieren will, die Fortgeschrittenen bei Ihnen wie die

34:41.260 --> 34:41.620
Anfänger.

34:42.500 --> 34:44.580
Insofern springt es auch in dem Buch manchmal ein bisschen hin und

34:44.580 --> 34:47.640
her, aber damit Sie eben eine gewisse Orientierung haben, immer diese

34:47.640 --> 34:48.140
Daten hier.

34:50.460 --> 34:55.600
So, dann setzen wir jetzt da auf, wo wir eigentlich heute Morgen in

34:55.600 --> 34:59.540
der Begrüßung, in der Einführung aufgehört haben, bei der Frage, was

34:59.540 --> 35:01.040
ist denn eigentlich Programmierung.

35:01.180 --> 35:04.220
Und Sie erinnern sich, wir hatten dieses Verfahren hier vorgestellt,

35:04.280 --> 35:07.160
wo wir sagen, ja, ich habe zwei Arten von Instruktionen.

35:08.080 --> 35:11.780
Ich kann diese farbigen Markierungen nach links und rechts

35:11.780 --> 35:15.220
weitergeben, und ich kann eben die Anweisung geben, dass diejenigen,

35:15.440 --> 35:18.080
die so eine farbige Markierung haben, den Platz tauschen.

35:18.680 --> 35:22.020
Und wie kann ich mit diesen Instruktionen quasi sortieren?

35:22.200 --> 35:25.000
Wie kann ich einen Sortieralgorithmus aufschreiben?

35:27.160 --> 35:30.860
Das funktioniert jetzt hier in dem Fall so, wenn ich diese vier

35:30.860 --> 35:34.420
Personen habe, dann sage ich erstmal, dass das Grüne hier nach rechts

35:34.420 --> 35:35.500
weitergegeben werden soll.

35:36.140 --> 35:39.200
Dann sage ich, dass die den Platz tauschen sollen.

35:40.020 --> 35:43.080
Dann wird das Grüne auch nochmal weitergegeben werden, nach links.

35:43.080 --> 35:45.000
Wir sollen wieder den Platz wechseln.

35:45.660 --> 35:47.060
Und schon habe ich es sortiert.

35:48.260 --> 35:51.660
Und wir hatten danach diskutiert, ist das jetzt ein Programm?

35:52.480 --> 35:56.500
Und zum einen war es so ein bisschen ja, weil halt es gab eindeutige

35:56.500 --> 36:00.260
Instruktionen und im Prinzip habe ich schon so eine Art Prozess

36:00.260 --> 36:01.940
gefunden, mit dem ich die Leute sortiert bekomme.

36:02.340 --> 36:07.980
Aber es hat was gefehlt, nämlich ein genauer Plan, der eben sagt, wann

36:07.980 --> 36:10.120
soll wem so eine Karte gereicht werden.

36:10.120 --> 36:13.000
Wir haben das jetzt nur durch Draufgucken gemacht, aber es ist klar,

36:13.420 --> 36:18.120
unser Verständnis von Größe und Draufgucken ist nicht das, was ein

36:18.120 --> 36:18.740
Computer hat.

36:19.360 --> 36:21.560
Und das war insofern noch nicht eindeutig genug beschrieben.

36:22.280 --> 36:24.960
Und das Ganze muss natürlich klappen für eine beliebige Zahl von

36:24.960 --> 36:25.480
Personen.

36:25.600 --> 36:27.440
Wir wollen nicht einen Sortieralgorithmus haben, der nur für vier

36:27.440 --> 36:28.000
Leute klappt.

36:28.720 --> 36:32.580
Und wenn man ehrlich ist, zum Sortieren kann man vieles, alles was man

36:32.580 --> 36:35.760
nämlich in der Größe vergleichen kann, aber das sind eben nicht nur

36:35.760 --> 36:36.180
Personen.

36:37.020 --> 36:38.980
Und wenn man das auch noch berücksichtigt, dann hätte man ein

36:38.980 --> 36:39.380
Programm.

36:40.720 --> 36:44.640
Hier, als nächstes, Achtung, Schreck, das erste Computerprogramm.

36:46.160 --> 36:50.340
Das hier ist ein Stück Java-Code, was mit einem nicht allzu

36:50.340 --> 36:55.060
intelligenten, aber dafür einfachen Verfahren Dinge sortiert.

36:55.340 --> 36:57.520
Auch hier wieder diejenigen von Ihnen, die noch nicht programmiert

36:57.520 --> 36:58.420
haben, keine Sorge.

36:59.400 --> 37:02.720
Diejenigen, die schon programmiert haben, die sehen halt, was man

37:02.720 --> 37:06.100
letzten Endes hier macht, ist, wenn etwas in einer falschen

37:06.100 --> 37:10.060
Reihenfolge ist, vertauscht man das hier.

37:10.320 --> 37:12.660
Das ist also das Vertauschen von Elementen, was Sie hier sehen in dem

37:12.660 --> 37:12.940
Block.

37:13.720 --> 37:17.880
Und letzten Endes diese Schleifen drum herum sorgen dafür, dass oft

37:17.880 --> 37:22.120
genug geschaut wird in der Reihe von zu sortierenden Elementen, ob es

37:22.120 --> 37:23.560
noch falsch sortierte gibt.

37:24.380 --> 37:28.420
Und das wird eben durch diese Verschachtelung von zwei Schleifen

37:28.420 --> 37:28.760
gemacht.

37:29.380 --> 37:32.160
Diejenigen von Ihnen, die noch nicht programmieren können, brauchen

37:32.160 --> 37:35.540
Sie aber keinen Schreck bekommen, weil wir fangen jetzt mal mit einem

37:35.540 --> 37:37.420
viel einfacheren Programm an.

37:39.080 --> 37:41.820
Jetzt geht natürlich ein Schmunzeln drüber, weil Sie sagen, dieses

37:41.820 --> 37:43.860
Programm macht nicht wahnsinnig sinnvolle Sachen.

37:44.040 --> 37:44.280
Stimmt.

37:44.680 --> 37:46.420
Es macht auch nichts allzu Anstrengendes.

37:46.520 --> 37:50.660
Es gibt einfach nur auf der Konsole aus Hello World diesen Satz.

37:50.700 --> 37:53.340
Das ist aber so der Klassiker, wenn man eine Programmiersprache

37:53.340 --> 37:53.920
kennenlernt.

37:54.080 --> 37:57.020
Wenn Sie auch nachher mal eine neue Programmiersprache lernen, und Sie

37:57.020 --> 37:58.880
können selber schon viel programmieren, aber jetzt lernen Sie eine

37:58.880 --> 38:01.720
neue, dann ist es immer ganz geschickt, sich erst mal das Hello World

38:01.720 --> 38:02.480
Programm anzugucken.

38:02.560 --> 38:04.840
Also das Programm, was nichts anderes macht, als Hello World

38:04.840 --> 38:05.420
auszugeben.

38:05.980 --> 38:07.500
Weil, was kann man dabei lernen?

38:10.600 --> 38:15.220
Das erste, was man vielleicht sieht hier, es gibt hier so eine Klasse

38:15.220 --> 38:21.320
SimpleProgramm und da gibt es eine Routine Main und darunter gibt es

38:21.320 --> 38:22.100
dann einen Befehl.

38:22.100 --> 38:26.220
Das heißt, Programme werden letzten Endes in erster Näherung erst mal

38:26.220 --> 38:30.500
abgearbeitet von oben nach unten Main ist immer der Einstiegspunkt,

38:30.600 --> 38:33.400
das muss man sich einfach merken und danach wird zeilenweise

38:33.400 --> 38:34.960
abgearbeitet, was da steht.

38:35.680 --> 38:39.600
Und hier steht nur eine Zeile System.out.println() Hello World System

38:39.600 --> 38:42.800
.out.println() heißt nichts anderes, schreibt den Text, der danach

38:42.800 --> 38:44.880
kommt nach außen hin.

38:45.540 --> 38:47.200
So, und wie starte ich jetzt mein Java Programm?

38:47.340 --> 38:49.700
Also wenn ich jetzt so ein Programm geschrieben habe, ich habe das

38:49.700 --> 38:53.420
also irgendwo eingetippt, in einen Editor, ich habe eine Datei

38:53.420 --> 38:56.960
erzeugt, die das als Code hat, da habe ich jetzt erst mal das Problem,

38:57.020 --> 38:57.640
wie starte ich denn?

38:57.700 --> 38:59.180
Fangen wir also ganz elementar mal an.

39:01.680 --> 39:05.920
Der Prozessor im Computer, der versteht kein Java auf Anib.

39:06.080 --> 39:09.100
Der versteht etwas, was man Binärcode nennt.

39:09.220 --> 39:12.800
Das kann man darstellen als eben immer Kombinationen aus 0 und 1 daher

39:12.800 --> 39:14.340
der Name Binärcode.

39:15.440 --> 39:19.980
0 und 1 symbolisieren im Prinzip die Spannungsbelegung an den

39:19.980 --> 39:23.200
verschiedenen Pins vom Prozessor oder dann auch von internen Zuständen

39:23.200 --> 39:24.880
im Prozessor.

39:25.440 --> 39:28.580
Und ganz am Anfang in der Informatik, in den 40er Jahren, hatte man

39:28.580 --> 39:30.420
tatsächlich Computer Binär programmiert.

39:30.940 --> 39:33.380
Binär ist jetzt ein bisschen nervig, weil man nur 0 und 1 eintippen

39:33.380 --> 39:36.820
kann, dann hat man auch mal Hexadezimalcodes gehabt, das heißt Codes

39:36.820 --> 39:37.760
mit dem 16er System.

39:38.080 --> 39:40.080
Da will ich aber jetzt hier gar nicht allzu sehr weit drauf eingehen.

39:40.640 --> 39:44.740
Wir wollen ja rausbekommen, wie man ein Java Programm startet.

39:44.880 --> 39:47.120
Sie haben also das Programm, was wir eben gesehen haben, das Hello

39:47.120 --> 39:50.080
World eingetippt in einen Texteditor.

39:50.180 --> 39:57.940
Sie haben eine Textdatei erzeugt, wo dieser Inhalt drin ist und jetzt

39:57.940 --> 40:01.300
müssen Sie das aber noch übersetzen in den Binärcode, damit eben das

40:01.300 --> 40:02.580
ausgeführt werden kann.

40:03.080 --> 40:08.280
Dazu gibt es einen sogenannten Compiler Kompilieren, ist im Englischen

40:08.280 --> 40:13.320
auch so viel so ein bisschen wie Umsetzen oder Zusammensetzen und

40:13.320 --> 40:17.160
dieser Begriff Compiler hat sich quasi auch im Deutschen ein bisschen

40:17.160 --> 40:20.380
eingebürgert obwohl der deutsche eigentliche Begriff Übersetzer heißt

40:21.100 --> 40:24.800
und im Informatikerslang spricht man dann oft von Kompiliert.

40:25.420 --> 40:29.460
Und wie gesagt, dieses Java C das C steht für Compiler, das ist das

40:29.460 --> 40:32.900
Programm was Ihnen hilft, das rufen Sie auf und indem Sie im Prinzip

40:34.240 --> 40:39.620
sagen also Sie rufen mit Java C auf und sagen also jetzt soll bitte

40:39.620 --> 40:45.960
das Simple-Programm übersetzt werden und was dann erzeugt wird ist ein

40:45.960 --> 40:50.840
Simple -Programm.class Das ist das, was der Compiler quasi dann

40:50.840 --> 40:57.760
generiert hat aus Ihrer Textdatei und da steht dann ein binärerer Code

40:57.760 --> 40:58.080
drin.

40:58.460 --> 40:59.200
Die Details gleich.

41:01.100 --> 41:03.980
Also wie gesagt, wichtig Sie legen im Prinzip in einem beliebigen

41:03.980 --> 41:08.720
Texteditor eine Textdatei an Simple-Programm.java Idealerweise sollte

41:08.720 --> 41:13.260
der Dateinamen hier vor dem Punkt auch Ihrem Klassennamen entsprechen

41:13.260 --> 41:16.540
und am Ende das Ganze mit .java aufhören, das ist so eine Konvention

41:17.160 --> 41:22.260
und dann rufen Sie Java C Simple-Programm auf und dann wird genau das

41:22.260 --> 41:28.260
hier generiert So, und wenn Sie das haben, dieses Simple-Programm,

41:28.320 --> 41:31.440
dann können Sie das nämlich erst starten und das ist jetzt so

41:31.440 --> 41:34.800
übersetzt, dass das eben auf dem Computer auch ausgeführt wird.

41:35.100 --> 41:40.540
Also Sie tippen also jetzt ein Java C Simple-Programm.java, nachdem

41:40.540 --> 41:43.360
Sie das eben in einer Textdatei mit dem Namen Simple-Programm.java

41:43.360 --> 41:47.740
eingegeben haben und dann kompilieren Sie das hiermit.

41:49.520 --> 41:52.380
Wenn Sie Programmierfehler gemacht haben, also Dinge, die der Compiler

41:52.380 --> 41:54.760
nicht versteht dann würde jetzt auch an der Stelle Fehlermeldung

41:54.760 --> 42:00.660
kommen So, und wenn ich jetzt das Simple-Programm habe, wenn das

42:00.660 --> 42:03.900
kompiliert wurde, dass es keine Fehlermeldung gab, dann starten Sie

42:03.900 --> 42:09.320
mit Java Simple-Programm tatsächlich auch Ihr Programm Und was

42:09.320 --> 42:11.520
passiert jetzt im Java-Laufzeitsystem?

42:12.040 --> 42:16.800
Dieses Binäre, dieses Kompilat, das Ergebnis von dem Compiler

42:16.800 --> 42:21.500
-Durchlauf von Java, das wird jetzt geladen ins Java-Laufzeitsystem Da

42:21.500 --> 42:26.180
wird dann gesucht, was ist diese Routine main und dann wird von der

42:26.180 --> 42:29.460
eben von oben nach unten zeilenweise das ganze abgearbeitet und dann

42:29.460 --> 42:33.540
kommt man dann auf diese Zeile system.out.println und das gibt dann im

42:33.540 --> 42:38.060
Prinzip eine Ausgabe an und das println heißt, dass am Ende noch ein

42:38.060 --> 42:40.520
Zeilen -Vorschub gemacht wird, das heißt der Cursor steht dann

42:40.520 --> 42:45.460
darunter Also, machen wir das mal.

42:45.980 --> 42:51.980
Hier wieder unser Programm Simple-Programm println, erst habe ich es

42:51.980 --> 42:55.560
übersetzt javac-simple-programm.java, dann rufe ich java-simple

42:55.560 --> 42:57.640
-programm auf und was gibt es aus?

42:57.720 --> 43:02.680
Hello World und dann wird der Cursor in der nächsten Zeile hier Das

43:02.680 --> 43:06.460
ist eine Sache, die können Sie händisch machen, indem Sie diese

43:06.460 --> 43:10.200
Befehle immer eintippen Es gibt aber natürlich auch Programmier

43:10.200 --> 43:13.500
-Umgebungen Software-Entwicklungs-Umgebungen, wo man sowas auch im

43:13.500 --> 43:16.360
Prinzip durch Maus-Schubserrei und so weiter hinbekommt, indem man auf

43:16.360 --> 43:19.040
ein paar Knöpfe drückt aber im Hintergrund passiert das, Sie müssen

43:19.040 --> 43:24.420
immer erst kompilieren und dann können Sie es ausführen So, das ist

43:24.420 --> 43:26.680
aber jetzt erstmal für diejenigen von Ihnen die noch nicht

43:26.680 --> 43:30.040
programmieren können, erstmal das Wichtigste Es gibt immer so einen

43:30.040 --> 43:34.280
Rahmen von einem Java-Programm public class, dann der Name vom

43:34.280 --> 43:38.300
Programm bitte keine Leerzeichen hier, dann so geschweifte Klammern

43:38.300 --> 43:42.980
hier und hier, dann eine Main-Routine auch wieder aus irgendwelchen

43:42.980 --> 43:45.040
Gründen, die Sie nachher erst verstehen hier steht der Public-Static

43:45.040 --> 43:48.540
-Void -Main davor, dann kommt hier sowas auch einfach auswendig

43:48.540 --> 43:51.440
lernen, erstmal noch nicht verstehen und dann können Sie das machen

43:52.840 --> 43:54.200
angeben, was das Programm machen soll.

43:54.280 --> 43:58.020
Und da wird das eben teilweise abgearbeitet So, bevor wir jetzt hieran

43:58.020 --> 44:01.000
weitermachen und uns das im Detail anschauen, jetzt schon mal die

44:01.000 --> 44:06.120
erste Expertenfolie Wie gesagt, hier unser symbolisierter Einstein

44:06.120 --> 44:08.120
Jetzt werden Sie sagen, Einstein war doch gar kein Informatiker, war

44:08.120 --> 44:10.860
Physiker Ja klar, aber die meisten Physiker entwickeln ja nachher auch

44:10.860 --> 44:12.740
Software Insofern...

44:13.720 --> 44:19.200
Und zwar, was ist jetzt das Programm?

44:19.460 --> 44:22.980
Also das Programm drückt einen Algorithmus aus und das macht es in

44:22.980 --> 44:27.680
einer Programmiersprache und wenn man so will, sprechen wir mit dem

44:27.680 --> 44:30.140
Rechner aber wie gesagt, der Rechner kann unsere Sprache nicht auf

44:30.140 --> 44:31.660
Anim verstehen wir müssen erst kompilieren

44:36.600 --> 44:39.780
Die eine Variante ist wir ändern halt unsere Sprache, wir reden direkt

44:39.780 --> 44:42.480
im Binärcode mit dem Rechner das ist aber halt schwer verständlich und

44:42.480 --> 44:44.480
außerdem ist es ziemlich mühsam da Fehler zu finden.

44:44.820 --> 44:48.160
Ja, weil klar, Sie haben 0 und 1 eine Haufenweise vor sich da ein

44:48.160 --> 44:52.480
Fehler finden ist mühsam Dann hat man mal gesagt, naja, diese 0 und 1

44:52.480 --> 44:55.200
haben ja schon eine konkretere Bedeutung, das sind einzelne

44:55.200 --> 44:58.480
Instruktionen die der Prozessor direkt versteht, also lassen Sie doch

44:58.480 --> 45:00.280
mal wenigstens textuelle angeben.

45:00.420 --> 45:03.180
Und das sind dann so einfache Befehle wie zum Beispiel, dass zwei

45:03.180 --> 45:07.160
Registerinhalte verschoben werden sollen oder dass was addiert werden

45:07.160 --> 45:07.460
soll.

45:07.760 --> 45:11.320
Das ist aber auf einer so feinkanonalen Ebene dass das auch nicht

45:11.320 --> 45:12.820
wirklich Spaß macht so zu programmieren.

45:12.940 --> 45:18.540
Es macht vielleicht Spaß, aber es ist relativ ineffizient So, deswegen

45:18.540 --> 45:23.500
hat man halt gesagt, naja wir hätten gerne eine Sprache, die ein

45:23.500 --> 45:26.720
bisschen näher ist an dem, was wir Menschen verstehen und dann kommen

45:26.720 --> 45:30.400
eben diese höheren Programmiersprachen ins Spiel und eben diesen

45:30.400 --> 45:38.700
Übersetzer jetzt kann ein Übersetzer ein Programm ausführen entweder

45:38.700 --> 45:42.260
direkt übersetzen in eine Maschinensprache, das ist das, was wir so

45:42.260 --> 45:46.620
klassischerweise bei Programmiersprachen wie C, C++ haben und dieses

45:46.620 --> 45:49.760
Maschinensprachenprogramm, das ist dann schon quasi binär das kann

45:49.760 --> 45:50.720
sofort ausgeführt werden.

45:51.220 --> 45:55.700
Oder aber das ist jetzt der Fall, wie es in Java funktioniert in eine

45:55.700 --> 45:56.620
Zwischensprache.

45:57.160 --> 46:01.060
Das heißt das Kompilat, was Sie mit dem Java C Aufruf bekommen ist

46:01.060 --> 46:06.760
noch gar keine Maschinenbinär-Code sondern das ist eine Sprache von

46:06.760 --> 46:08.500
der Java Virtual Machine.

46:08.720 --> 46:10.840
Der heißt Bytecode Warum der Bytecode?

46:10.920 --> 46:13.380
Das ist ein Marketingbegriff, da gibt es keine Logik dahinter, aber es

46:13.380 --> 46:17.200
ist im Prinzip ein Code der näher dran an der Maschine ist, aber noch

46:17.200 --> 46:21.940
nicht exakt der Maschinencode So, warum wird das so gemacht?

46:22.160 --> 46:26.240
Das wird so gemacht, weil man sagt dieser Bytecode läuft auf den

46:26.240 --> 46:30.140
verschiedenen Hardware-Plattformen und Betriebssystemen gleichermaßen

46:30.140 --> 46:32.580
ab weil er wird nämlich dort immer vermeintlich mit sogenannten

46:32.580 --> 46:34.440
Interpreter interpretiert.

46:34.540 --> 46:35.520
Was ist jetzt ein Interpreter?

46:37.100 --> 46:43.160
Ein Interpreter nimmt eine Anweisung von einem Programm übersetzt sie

46:43.160 --> 46:46.060
in den Maschinencode führt das aus.

46:46.920 --> 46:49.620
Und dann kommt die nächste Instruktion da wird übersetzt, ausgeführt.

46:50.780 --> 46:55.780
Ein Compiler hingegen nimmt das gesamte Programm, transformiert das in

46:55.780 --> 46:58.400
einen anderen Code, der dann ausgeführt wird.

46:58.760 --> 47:01.740
Und bei Java ist es interessanterweise so, dass eine Mischform genutzt

47:01.740 --> 47:04.360
wird In Java haben sie zum einen den Java C-Compiler, das ist das, was

47:04.360 --> 47:07.800
ich Ihnen eben gesagt habe, der übersetzt ihr Programm in Bytecode und

47:07.800 --> 47:12.360
der Bytecode wird dann interpretiert auf der Plattform Und die

47:12.360 --> 47:14.440
Hauptidee ist halt, dass man sagt ich nehme eigentlich den Java

47:14.440 --> 47:18.000
Bytecode und den kann ich kopieren von einer Windows-Plattform auf

47:18.000 --> 47:20.960
eine Linux-Plattform das dann wieder auf eine ganz andere Plattform

47:20.960 --> 47:25.720
und immer wird im Prinzip derselbe Bytecode ist ausführbar.

47:26.060 --> 47:29.680
Das wäre er nicht, wenn er ein Binärcode ist Ein Binärcode ist immer

47:29.680 --> 47:34.640
abhängig vom konkreten Prozessor, also der Hardware die eingebaut ist,

47:34.840 --> 47:38.300
und vom Betriebssystem Und sobald ich ein anderes Betriebssystem habe,

47:38.380 --> 47:40.520
kann ich nicht mehr denselben Binärcode nehmen.

47:42.680 --> 47:45.680
Und in dem Augenblick, wenn man das umgehen will, diese

47:45.680 --> 47:49.400
Plattformabhängigkeit, dann nimmt man eben so einen Zwischencode, wie

47:49.400 --> 47:51.980
das auch Java macht und sagt, bis dahin wird kompiliert und dieser

47:51.980 --> 47:56.920
Zwischencode, der wird dann erst interpretiert Es gibt auch Sprachen

47:56.920 --> 48:00.280
die ganz auf den Compiler verzichten, die halt sagen ich interpretiere

48:00.280 --> 48:04.560
alles von vornherein, ich nehme also im Prinzip meine Zeile, wie das

48:04.560 --> 48:08.180
der Programmierer hingeschrieben hat und übersetze die gleich in den

48:08.180 --> 48:10.480
entsprechenden Maschinencode und führe das dann aus.

48:11.020 --> 48:13.560
Das sind reine Interpretersprachen, davon gibt es eine ganze Menge,

48:13.700 --> 48:19.800
gerade im Webumfeld wo es oft darum geht, dass man sagt, naja, die

48:19.800 --> 48:23.300
ultimative Geschwindigkeit ist gar nicht das Hauptziel, Hauptsache ich

48:23.300 --> 48:24.500
bin sehr plattformunabhängig.

48:24.560 --> 48:28.280
Und das sind dann gerade schon eben Sprachen im Webumfeld Jetzt habe

48:28.280 --> 48:30.440
ich schon gesagt, Geschwindigkeit spielt keine Rolle.

48:31.180 --> 48:33.300
Warum ist es tatsächlich so, dass im Schnitt eigentlich immer

48:33.300 --> 48:42.000
Compilierte Programme während ihr Programm abläuft, ist der

48:42.000 --> 48:45.100
Interpreter immer noch damit beschäftigt, wieder die nächste Zeile zu

48:45.100 --> 48:49.500
übersetzen und das kostet natürlich Zeit von ihrem Prozessor weil wir

48:49.500 --> 48:50.400
sonst woanders herkommen.

48:51.000 --> 48:54.440
Und wenn sie halt Befehle in einer Fly verarbeiten, also das heißt

48:54.440 --> 48:57.620
wiederholt und wiederholt werden, dann wird jedes Mal neu übersetzt

48:58.200 --> 49:02.040
zur Laufzeit, also werden sie mit dem Programm interagieren Beim

49:02.040 --> 49:06.040
Compiler hat man den großen Vorteil dieser Aufwand der Übersetzung,

49:06.180 --> 49:08.800
der wird ja gemacht bevor das Programm läuft.

49:09.020 --> 49:11.480
Das heißt, während das Programm läuft haben sie die ganzen Aufwände,

49:11.580 --> 49:13.500
die der Compiler hat, nicht mehr in der Backe.

49:13.780 --> 49:16.760
Das heißt, dann verbrät er auch keine Rechenzeit mehr Und der weitere

49:16.760 --> 49:19.820
Vorteil ist, wenn Dinge in einer Schleife ausgeführt werden, also

49:19.820 --> 49:23.480
dieselben Befehle nach und nach immer wieder wiederholt, muss der

49:23.480 --> 49:26.760
Interpreter halt jedes Mal neu übersetzen Der Compiler übersetzt das

49:26.760 --> 49:30.060
natürlich nur einmal und ist fertig Und deswegen ist es so, dass in

49:30.060 --> 49:32.740
der Regel Compilierte Programme immer schneller sind als

49:32.740 --> 49:36.780
Interpretierte Programme Es gibt ein paar Ausnahmen, deswegen sage ich

49:36.780 --> 49:41.120
positiv in der Regel, aber in erster Näherung stimmt es So, und

49:41.120 --> 49:46.600
deswegen ist es tatsächlich auch so Genau, das ist das, was ich schon

49:46.600 --> 49:51.220
vorher gesagt hatte mit der Plattformunabhängigkeit Genau, das war

49:51.220 --> 49:54.560
auch schon alles auf der Tonspur da So, genau, so sieht das jetzt hier

49:54.560 --> 49:58.840
bei Ihnen aus Sie haben Ihren Java-Quellcode, den Java-Compiler also

49:58.840 --> 50:03.160
das Java-C, dann bekommen Sie Java-Bytecode und den können Sie jetzt

50:03.160 --> 50:08.080
auf einer ganzen Reihe von sogenannten Java Virtual Machines ausführen

50:08.080 --> 50:12.180
das sind die Ausführungsumgebungen die sind speziell für jedes

50:12.180 --> 50:15.860
Betriebssystem, aber das müssen Sie nur einmal installieren und dann

50:15.860 --> 50:18.460
können Sie jedes beliebige Java-Programm eben hier ausführen und

50:18.460 --> 50:20.800
dasselbe Programm hier und hier Sie müssen es aber nur einmal

50:20.800 --> 50:29.480
kompilieren Jetzt aber um das ganze Bild komplex zu machen und Sie

50:29.480 --> 50:34.520
sehen, naja, ganz so einfach ist es dann im realen Leben auch nicht Es

50:34.520 --> 50:37.900
gibt auch in der Java Virtual Machine noch einen kleinen Compiler der

50:37.900 --> 50:41.400
heißt Just-in-Time-Compilation Was hat es damit auf sich?

50:41.460 --> 50:44.700
Das ist erstmal die Frage herum, wer kennt Just-in-Time-Compilation in

50:44.700 --> 50:44.980
Java?

50:45.780 --> 50:49.360
Okay, das sind ein paar, aber dann doch nicht mehr so viele Das zeigt

50:49.360 --> 50:55.160
eben, dass mit meiner Expertenfolie doch klappt das Konzept Also, wenn

50:55.160 --> 50:58.560
die Java Virtual Machine merkt, oh, ich interpretiere, so mutter mal

50:58.560 --> 51:01.780
wieder hier meinen Byte-Code rum Ups, ich bin ja in der Schleife

51:02.460 --> 51:04.880
Sprich, ich mache genau das, was eigentlich ein bisschen blöd ist,

51:04.960 --> 51:07.980
nämlich jedes Mal neu übersetzen, ausführen, übersetzen, ausführen

51:08.840 --> 51:12.080
Dann sagt man irgendwann, die Java Virtual Machine, Moment mal hier

51:12.080 --> 51:15.240
macht es mal Sinn, eine sogenannte Kompilierung vorzunehmen Das heißt,

51:15.320 --> 51:18.820
in dem Augenblick wird das Programm dann doch kompiliert auf den

51:18.820 --> 51:22.260
richtigen Binär-Code der Plattform Das passiert aber so, dass Sie das

51:22.260 --> 51:24.940
nicht merken als Software-Entwickler Sie machen ganz normal Java C,

51:25.100 --> 51:29.520
Sie haben Ihren Byte-Code Dieser Byte-Code wird aber eben nicht stumpf

51:29.520 --> 51:32.140
immer nur interpretiert in der Java Virtual Machine, sondern da gibt

51:32.140 --> 51:36.360
es auch diese sogenannte Just-in-Time-Kompilation Weil es halt während

51:36.360 --> 51:39.200
der Laufzeit Ihres Programms passiert, dass nochmal intern in der Java

51:39.200 --> 51:43.540
Virtual Machine ein Compiler angeworfen wird Und der kann auch einige

51:43.540 --> 51:47.900
Optimierungen machen die ein Interpreter, irgendwie z ist gleich x

51:47.900 --> 51:51.780
plus y, y ist gleich f und das kann man natürlich ersetzen, im Prinzip

51:51.780 --> 51:54.520
mit einem Ausdruck der semantisch genau dasselbe besagt, nämlich z ist

51:54.520 --> 52:00.360
gleich x plus f und diese quasi Zusammenfassung von Ausdrücken wo man

52:00.360 --> 52:04.760
eben sicher eine komplette Zuweisungsoperation spart das kann eben ein

52:04.760 --> 52:07.040
Interpreter nur sehr sehr schwer weil er halt nicht den Überblick hat,

52:07.100 --> 52:10.380
ein Compiler sieht das natürlich wenn man das Programm eingelesen hat

52:10.380 --> 52:16.680
oder es kann auch sogenannten Dead-Code entfernen, das ist Code, der

52:16.680 --> 52:18.900
entweder nie aufgerufen wird, d.h.

52:18.980 --> 52:21.180
man braucht ihn eigentlich auch nicht mitschleppen oder aber auch

52:21.180 --> 52:23.200
Code, dessen Ergebnis gar nicht verwendet wird d.h.

52:23.300 --> 52:26.140
man hat aufwändige Berechnungen vielleicht gemacht, aber ein Compiler

52:26.140 --> 52:29.780
sieht, dass dieses Ergebnis nirgendwo anders weiterverwendet wird.

52:30.280 --> 52:32.580
Und in dem Augenblick kann ich mir natürlich auch die ganze Ausführung

52:32.580 --> 52:38.440
sparen So, das sind eben Dinge, die der Just-in-Time-Compiler macht.

52:38.840 --> 52:41.100
Also grob gesagt, Just-in-Time-Compilation ist ein

52:41.100 --> 52:45.500
Optimierungskonzept, um die Nachteile der Interpretation in einer Java

52:45.500 --> 52:49.600
Virtual Machine zu umgehen Natürlich wird Just-in-Time-Compilation

52:49.600 --> 52:52.860
auch außerhalb von Java angewendet, aber das ist jetzt eine prominente

52:52.860 --> 52:53.700
Verwendung hier zu uns.

52:55.300 --> 52:59.380
So, kommen wir wieder zu unserem einfachen Programm zurück.

53:00.700 --> 53:06.060
Wir haben das jetzt einmal kompiliert, wir haben Java aufgerufen die

53:06.060 --> 53:08.680
Java Virtual Machine lief los mit unserem simple Programm, hat das

53:08.680 --> 53:12.400
ausgeführt, sprich hat sich das Main gesucht und hat dann das gemacht,

53:12.520 --> 53:13.020
was hier steht.

53:13.660 --> 53:16.720
Nämlich System.out wird dann Hello World gemacht und danach kommt

53:16.720 --> 53:18.480
nichts mehr dann hört es auch automatisch auf.

53:19.440 --> 53:21.960
So, und das passiert auch hier, jetzt bin ich wieder bei meiner

53:21.960 --> 53:24.500
Konsole und kann weitere Eingaben machen als Benutzer.

53:25.840 --> 53:28.340
So, jetzt kann man ja mal sagen, ok, jetzt möchte ich mal das Programm

53:28.340 --> 53:29.160
gerne modifizieren.

53:29.240 --> 53:31.320
Ich habe jetzt verstanden, wie dieses eine Hello World Programm geht

53:31.800 --> 53:33.120
Was kann ich jetzt mal ändern daran?

53:33.260 --> 53:35.920
Ohne, dass ich allzu viel Programmierungsverständnis schon habe.

53:36.440 --> 53:38.440
Gut, man kann natürlich sagen, ich ändere mal die Ausgabe.

53:38.600 --> 53:41.920
Ja, also gut, wenn man hier eine andere Zeichenkette ergibt, nur

53:41.920 --> 53:42.120
Hello.

53:43.220 --> 53:47.940
Und ok das ist die Frage erstmal, muss ich das Programm wieder

53:47.940 --> 53:48.300
kompilieren?

53:49.180 --> 53:52.540
Und die Antwort ist ja, weil sie haben natürlich ihr Programm geändert

53:53.780 --> 53:57.240
im Quelltext, aber in der Binärform ist es natürlich noch nicht

53:57.240 --> 53:57.600
geändert.

53:57.960 --> 54:00.900
Das heißt, sie müssen erstmal eine neue Binärform erzeugen, das heißt,

54:00.940 --> 54:02.680
sie müssen jetzt erstmal wieder den Compiler anwerfen.

54:02.840 --> 54:07.900
Also erste Botschaft für die Anfänger, sie schreiben natürlich ihr

54:07.900 --> 54:11.240
Programm in den Texteditor hin, aber sie müssen es natürlich bei jeder

54:11.240 --> 54:13.840
Änderung nochmal neu übersetzen in die Binärform, weil im Prinzip im

54:13.840 --> 54:17.580
Java -System immer nur die Binärform ausgeführt wird und wenn sie ihre

54:17.580 --> 54:20.720
Textform ändern, kriegt das die Binärform halt nicht mit deswegen muss

54:20.720 --> 54:22.380
der Compiler nochmal angeworfen werden.

54:22.440 --> 54:25.740
So mache ich jetzt hier, sehen Sie, ich habe jetzt nochmal Java C

54:25.740 --> 54:29.060
aufgerufen und da ist eben Java und dann klappt das mit dem Hello,

54:30.140 --> 54:31.040
wenn nur das ausgibt.

54:31.040 --> 54:35.760
So, jetzt könnte ich natürlich sagen, ich mache natürlich auch mal

54:35.760 --> 54:39.360
jetzt hier zwei Zeilen rein, weil der Reusner hat gesagt, es wird von

54:39.360 --> 54:41.600
oben nach unten ausgeführt, also nachdem diese Zeilen ausgeführt

54:41.600 --> 54:45.100
werden, werden diese ausgegeben und jetzt ist die Frage, welche

54:45.100 --> 54:50.920
Ausgabe erwarte ich, exakt dasselbe als eben oder nicht und das

54:50.920 --> 54:54.440
Ergebnis, also erstmal muss ich natürlich wieder übersetzen und dann

54:54.440 --> 54:57.180
sieht man, hoppala, das sind jetzt zwei Zeilen.

54:58.000 --> 54:59.280
Warum sind das zwei Zeilen?

54:59.280 --> 55:03.640
Weil jedes Mal ein Zeilenvorschub hier mit Printline gemacht wurde.

55:03.720 --> 55:06.040
Ja, wenn ich nur Print gemacht hätte, wäre das nicht so aber bei

55:06.040 --> 55:08.160
Printline wird immer die nächste Zeile gegangen und deswegen steht

55:08.160 --> 55:10.380
jetzt hier, Hello, neue Zeile, World.

55:11.560 --> 55:14.780
So, dann denken Sie sich, oh super, das ist jetzt mal ein bisschen

55:14.780 --> 55:18.000
langweilig mit dem Hello World, ich will jetzt Hardcore-Mathematik

55:18.000 --> 55:18.320
machen.

55:18.600 --> 55:22.540
Gut, Hardcore-Mathematik ein bisschen vorsichtig, aber gut, 1 plus 1,

55:22.660 --> 55:26.000
ja So, welche Ausgabe erwarte ich?

55:26.000 --> 55:27.600
Wer denkt, dass da 2 rauskommt?

55:28.520 --> 55:29.400
Gut, das sind schon mal ein paar.

55:31.380 --> 55:34.760
Die meisten von Ihnen ahnen, so schlau ist leider unser Computer nicht

55:36.700 --> 55:37.920
weil, was gibt der aus?

55:38.120 --> 55:39.700
1 plus 1 als Zeichenkette.

55:39.800 --> 55:43.100
Er hat das natürlich nicht interpretiert, er hat nicht gerechnet.

55:43.460 --> 55:44.640
Mist, große Enttäuschung, ja.

55:48.960 --> 55:54.320
Bevor wir jetzt weiter anschauen, wie man das hinbekommt, dass da 2

55:54.320 --> 55:57.060
ausrechnet, gucken wir uns mal ein paar Bestandteile an hier.

55:59.000 --> 56:00.940
Also, wir haben eine Klasse.

56:01.060 --> 56:03.800
Was eine Klasse ist, kommt in der nächsten Vorlesung dran, nicht

56:03.800 --> 56:04.440
erschüttert sein.

56:05.540 --> 56:08.600
Aber in einer objektorientierten Programmiersprache wie Java können

56:08.600 --> 56:13.040
Sie nicht einfach Code so hinschreiben, es muss immer in einer Klasse

56:13.040 --> 56:13.740
gekapselt sein.

56:13.820 --> 56:15.740
Wie gesagt, wenn Sie nicht wissen, was eine Klasse ist, nächste

56:15.740 --> 56:16.800
Vorlesung kommt noch dran.

56:17.900 --> 56:22.480
Dann haben Sie einen Namen für diese Klasse.

56:23.960 --> 56:27.280
SimpleProgram ist unser Name hier, die könnten da auch einen anderen

56:27.280 --> 56:28.100
Namen angeben.

56:28.200 --> 56:31.880
Und hier schon mal wieder der erste Punkt, Sie programmieren nicht für

56:31.880 --> 56:33.500
den Computer, sondern für den nächsten Menschen.

56:33.900 --> 56:38.180
Dem Computer könnten Sie auch da hinschreiben B3Alpha, das wäre für

56:38.180 --> 56:43.100
den auch ein vollkommen einwandfreier Klassenname, aber dem nächsten

56:43.100 --> 56:44.180
Menschen sagt das nicht viel.

56:44.180 --> 56:48.880
Und deswegen wählen Sie immer Bezeichner so, dass das möglichst viel

56:48.880 --> 56:52.060
Inhalt, was das Programm tun soll, was die Bedeutung ist für Sie als

56:52.060 --> 56:55.160
Mensch, dass es den nächsten Leser transportiert wird.

56:55.240 --> 56:57.360
Weil wie gesagt, Sie schreiben das Programm für den nächsten Menschen.

56:57.460 --> 56:59.500
Das ist eine ganz wichtige Botschaft, das sind Informatiker gerade als

56:59.500 --> 57:01.840
Anfänger, denkt man immer erst, ich schreibe das Programm nur für den

57:01.840 --> 57:04.220
Computer, Hauptsache das kompiliert durch, es gibt keine

57:04.220 --> 57:05.940
Fehlermeldung, das reicht ja.

57:07.000 --> 57:09.640
Die meisten Software-Engineering-Probleme entstehen immer dadurch,

57:09.640 --> 57:11.520
dass die Leute die Programme nicht richtig mehr verstehen.

57:13.320 --> 57:17.440
So, dann haben wir die Main-Methode, das ist jetzt in der

57:17.440 --> 57:20.340
Programmiersprache Java vordefiniert, damit wird angefangen.

57:20.440 --> 57:24.360
Wenn Sie keine Main-Routine haben, weiß das Java-System nicht, womit

57:24.360 --> 57:25.300
soll es eigentlich anfangen.

57:25.640 --> 57:27.320
Deswegen, das ist immer wichtig, dass Sie eine haben.

57:27.860 --> 57:31.060
Der ganze Kram drumherum werden Sie im Laufe des Wintersemesters

57:31.060 --> 57:33.440
kennenlernen, brauchen Sie jetzt nicht erschüttern, wenn Sie es noch

57:33.440 --> 57:33.940
nicht verstehen.

57:35.060 --> 57:37.720
So, dann haben wir Methodennamen.

57:38.300 --> 57:40.820
Main ist ganz offensichtlich einer, weil das ist die Main-Methode,

57:41.000 --> 57:42.640
aber eben auch System-Outprint-Line.

57:43.500 --> 57:48.500
Methode ist schon wieder so ein Wort, was im Umgangssprachlichen eine

57:48.500 --> 57:51.180
gewisse Bedeutung hat und in der Informatik eine sehr spezielle

57:51.180 --> 57:51.760
Bedeutung hat.

57:51.860 --> 57:55.240
Methode ist ein Stück Code, was ausgeführt werden kann und was einen

57:55.240 --> 57:56.120
eigenen Namen hat.

57:59.280 --> 58:01.840
So, und jetzt gehen wir mal rein wieder in unser Programm.

58:03.640 --> 58:06.320
Jetzt habe ich das so viel modifiziert, indem ich hier bei dem System

58:06.320 --> 58:10.040
-Outprint -Line nicht irgendwas mit Anführungszeichen gemacht habe,

58:10.940 --> 58:17.440
sondern ich nehme zwei sogenannte Variablen FirstNumber, SecondNumber

58:17.440 --> 58:22.280
und die habe ich vorne hier, wie Sie sehen, definiert, deklariert und

58:22.280 --> 58:23.580
mit dem Wert 1 belegt.

58:24.240 --> 58:27.140
Auch wenn Sie noch nicht programmieren können, ahnen Sie vielleicht

58:27.140 --> 58:30.440
hier wird gesagt, FirstNumber soll den Wert 1 haben, SecondNumber soll

58:30.440 --> 58:34.460
den Wert 2 haben und jetzt schreibe ich tatsächlich das hin.

58:34.900 --> 58:39.120
System-Outprint-Line FirstNumber und SecondNumber und was passiert?

58:39.500 --> 58:43.480
Es passiert jetzt in der Tat gut, das war jetzt gerade trickreich,

58:43.560 --> 58:46.400
also hier 2 das Ergebnis ist 3

58:49.660 --> 58:52.160
So, der Gag ist was ist jetzt hier passiert?

58:52.400 --> 58:58.180
Hier haben Sie nicht eine Zeichenkette ausgegeben, wie immer vorher

58:58.180 --> 59:01.800
Hello World, die in diesen Anführungsstrichen stand sondern Sie haben

59:01.800 --> 59:05.440
hier tatsächlich einen mathematischen Ausdruck angegeben, nämlich 2

59:05.440 --> 59:09.300
Variablen addiert und genau das passiert jetzt auch hier dass genau

59:09.300 --> 59:12.300
das Ergebnis auch ausgewertet wird und ausgegeben wird.

59:12.620 --> 59:16.760
Das was ich eben eigentlich auch gerne gehabt hätte So, was haben wir

59:16.760 --> 59:17.520
jetzt hier neu dazu?

59:17.640 --> 59:21.880
Wir haben eine sogenannte Variablen-Deklaration Ich kann nicht einfach

59:21.880 --> 59:26.560
irgendeinen Begriff hinschreiben dem ich nicht vorher dem Compiler

59:26.560 --> 59:27.540
verrate was es ist.

59:27.620 --> 59:30.280
Das ist auch so eine generelle Regel beim Programmieren Sie können

59:30.280 --> 59:34.780
nicht erstmal sich irgendwas ausdenken an Bezeichnern an Namen, Sie

59:34.780 --> 59:36.760
müssen an irgendeiner Stelle mal sagen was ist das?

59:37.980 --> 59:44.460
Und das machen Sie bei einer Variable so, dass Sie den Typ angeben int

59:44.460 --> 59:49.220
steht für ganzzahlige Variable, was das ist alles nächste Vorlesung

59:51.360 --> 59:54.020
FirstNumber und dann wird das auch gleich schon initialisiert mit

59:54.020 --> 59:56.220
einem Wert hier und dasselbe halt mit einem SecondNumber

01:00:02.270 --> 01:00:05.050
Dann nochmal zum Thema Reihenfolge hatten wir aber eigentlich eben

01:00:05.050 --> 01:00:09.090
auch gehabt es fängt mit der Main-Methode an und dann wird die erste

01:00:09.090 --> 01:00:11.270
Zeile ausgeführt und dann die zweite.

01:00:11.630 --> 01:00:14.810
Aber wie gesagt, es wird nicht streng genommen nicht diese Datei

01:00:14.810 --> 01:00:18.150
ausgeführt, sondern die Binär-Variante, die der Compiler erzeugt wird,

01:00:18.210 --> 01:00:19.990
aber sinngemäß ist das eben auch zeilenweise

01:00:24.250 --> 01:00:26.730
Jetzt können natürlich die Schlauberger unter Ihnen sagen, es ist

01:00:26.730 --> 01:00:29.570
natürlich nicht zeilenweise sondern ich kann natürlich mehrere Befehle

01:00:29.570 --> 01:00:31.730
hintereinander schreiben, aber so kompliziert wollen wir es jetzt am

01:00:31.730 --> 01:00:36.150
Anfang nicht machen Jetzt habe ich das Ganze nochmal so aufgetröselt

01:00:36.150 --> 01:00:39.830
unser kleines Beispielprogramm, in dem ich sage hier mache ich System

01:00:39.830 --> 01:00:43.310
.out.println.hello und jetzt definiere ich mir eine neue Methode,

01:00:43.470 --> 01:00:48.330
printWorld die nichts anderes macht, als printWorld auszugeben So, das

01:00:48.330 --> 01:00:51.570
sehen Sie hier Jetzt könnte man sagen, super, mal schauen, was jetzt

01:00:51.570 --> 01:00:55.430
hier die Ausgabe ist Also klar, Sie müssen es erstmal nochmal

01:00:55.430 --> 01:00:58.030
kompilieren, ist auch klar Jetzt ist die spannende Frage, wird denn

01:00:58.030 --> 01:01:00.510
dieses printWorld überhaupt ausgeführt Jetzt könnte man vielleicht

01:01:00.510 --> 01:01:04.110
denken, ja, der Reuss hat ja gesagt, von oben nach unten Also erst

01:01:04.110 --> 01:01:09.070
Main und dann printWorld Die bittere Aussage ist Nein Warum aber

01:01:09.070 --> 01:01:09.390
jetzt?

01:01:09.990 --> 01:01:15.250
Also Main fängt bei dieser geschweiften Klammer an und hört bei dieser

01:01:15.250 --> 01:01:20.130
geschweiften Klammer auf Alles was nach Main kommt, interessiert bei

01:01:20.130 --> 01:01:23.610
der Ausführung erstmal den Compiler nicht Das heißt, was muss ich

01:01:23.610 --> 01:01:27.790
machen, damit meine neue Methode printWorld ausgeführt werden kann

01:01:27.790 --> 01:01:30.550
Naja, ich muss sie an einer Stelle mal innerhalb von Main auch

01:01:30.550 --> 01:01:38.730
aufrufen Und das passiert jetzt so dass ich jetzt hier das printWorld

01:01:38.730 --> 01:01:41.930
eintrage, quasi wie ein Befehl Genauso wie das System.out.println,

01:01:42.010 --> 01:01:45.470
trage ich jetzt hier printWorld an Und was passiert jetzt bei der

01:01:45.470 --> 01:01:45.930
Ausführung?

01:01:46.030 --> 01:01:50.190
Also wieder Java C übersetzen, wieder mit Java starten Dann bekomme

01:01:50.190 --> 01:01:53.850
ich hier erstmal das Hello ausgedruckt Dann wird die Zeile danach,

01:01:53.930 --> 01:01:58.550
also printWorld, aufgerufen Dann springt das Programm quasi hin der

01:01:58.550 --> 01:02:02.050
Programmzeiger, und dann führt er bei printWorld das hier aus Danach

01:02:02.050 --> 01:02:05.490
ist das fertig, dann springt er wieder da hin und hier ist Main zu

01:02:05.490 --> 01:02:09.090
Ende, also bin ich auch ganz zu Ende Und genau das passiert dann auch

01:02:09.090 --> 01:02:15.170
als Ausgabe So, das war jetzt vielleicht ein bisschen langweilig für

01:02:15.170 --> 01:02:17.210
die von Ihnen, die schon programmieren können weil das ist das, was

01:02:17.210 --> 01:02:21.950
sie schon alles kennen Aber, deswegen jetzt wieder der Schritt für

01:02:21.950 --> 01:02:27.510
alle Das war jetzt ein sehr, sehr einfaches Programm Es ist aber ein

01:02:27.510 --> 01:02:30.230
ganz entscheidender Punkt bei der Programmierung, jetzt von mir noch

01:02:30.230 --> 01:02:32.270
gar nicht erwähnt worden Das ist nämlich die sogenannte

01:02:32.270 --> 01:02:39.750
Datenmodellierung Programmieren ist eben nicht nur die Definition von

01:02:39.750 --> 01:02:42.850
Befehlen oder in Ausführungsreihenfolge, das haben wir eben gemacht

01:02:42.850 --> 01:02:47.350
mit unserem kleinen, harmlosen Hello-World-Beispiel sondern es geht

01:02:47.350 --> 01:02:50.850
noch um eine zweite Sache nämlich die Datenmodellierung Mit

01:02:50.850 --> 01:02:55.110
Datenmodellierung ist gemeint, dass man Entitäten der realen Welt

01:02:55.110 --> 01:03:03.470
versucht abzubilden in computerrepräsentierbare Werte Wir hatten eben

01:03:03.470 --> 01:03:05.770
die Variante First Number, Second Number die fielen so ein bisschen

01:03:05.770 --> 01:03:10.010
vom Himmel Eigentlich ist es ja so, dass ein Computerprogramm immer

01:03:10.010 --> 01:03:13.570
einen bestimmten Zweck erfüllt Und häufig ist dieser Zweck, den ein

01:03:13.570 --> 01:03:17.570
Computerprogramm erfüllt, in der realen Welt gegeben Das heißt, die

01:03:17.570 --> 01:03:21.410
Entitäten, mit denen das Programm abstrakt hantiert, haben auch immer

01:03:21.410 --> 01:03:25.290
eine Entsprechung eigentlich in der realen Welt Und wenn man so will,

01:03:25.350 --> 01:03:28.950
ist Programmieren oder Software entwickeln genau der Schritt, dass man

01:03:28.950 --> 01:03:32.670
sich überlegt welche Eigenschaften der Entität in der realen Welt und

01:03:32.670 --> 01:03:36.670
welche Entitäten muss ich jetzt darstellen in meinem Computerprogramm

01:03:37.770 --> 01:03:40.030
Wir machen das jetzt mal hier an einem Beispiel nämlich ein

01:03:40.030 --> 01:03:45.150
Billiardspiel was wahrscheinlich die meisten von Ihnen kennen Da kann

01:03:45.150 --> 01:03:48.510
man sich überlegen, was habe ich denn in einem Billiardspiel Also was

01:03:48.510 --> 01:03:51.770
will ich von meinem Programm Es soll im Prinzip die Bewegung der

01:03:51.770 --> 01:03:58.210
Kugeln simulieren Und wenn ich jetzt das machen will, so ein Programm

01:03:58.210 --> 01:03:59.670
schreiben will muss ich überlegen, was habe ich denn eigentlich für

01:03:59.670 --> 01:04:03.070
Entitäten Also ich habe natürlich einmal offenbar den Billiardtisch

01:04:03.970 --> 01:04:07.590
Das ist quasi das, worauf das ganze Billiardspiel stattfindet Das muss

01:04:07.590 --> 01:04:11.250
ich also irgendwo modellieren Insbesondere die Größe von dem Tisch

01:04:11.250 --> 01:04:14.290
spielt natürlich eine Rolle weil es ist klar, indem man über die Kugel

01:04:14.290 --> 01:04:19.350
hier an der Bande dotzt, wird sie natürlich reflektiert Und das hängt

01:04:19.350 --> 01:04:21.990
natürlich davon ab, wo die Bande ist Also die Größe vom Tisch muss ich

01:04:21.990 --> 01:04:25.850
offenbar modellieren Wenn man jetzt ganz pinsig ist, würde man sagen

01:04:25.850 --> 01:04:27.890
Oh, dann fangen wir auch mal an mit Luftwiderstand, Wind und

01:04:27.890 --> 01:04:34.010
Luftströmung So machen wir das alles nicht Dann, jede Kugel hat zu

01:04:34.010 --> 01:04:36.670
jedem Zeitpunkt eine Position auf dem Tisch Das kann man natürlich am

01:04:36.670 --> 01:04:41.670
besten mit karatesischen Koordinaten angeben Die hat aber eben auch

01:04:41.670 --> 01:04:46.690
eine Bewegungsrichtung und Geschwindigkeit Das kann natürlich Null

01:04:46.690 --> 01:04:51.350
sein, wenn sie liegt Das kenne ich am besten vielleicht auch als

01:04:51.350 --> 01:04:56.150
Vektor an Eine Bewegungsrichtung Und sie kann einen sogenannten Effet

01:04:56.150 --> 01:04:58.830
haben, wie das beim Billiard heißt Das heißt, dass sie noch einen

01:04:58.830 --> 01:05:02.230
bestimmten Drall oder Spinnen mitbekommt Und dadurch natürlich, wenn

01:05:02.230 --> 01:05:06.410
sie irgendwie gegen eine andere Kugel stößt oder gegen die Bande das

01:05:06.410 --> 01:05:08.930
den Winkel beeinflusst, indem sie zum Beispiel selber reflektiert wird

01:05:09.610 --> 01:05:13.150
So, und die Kugeln können aneinanderstoßen und ändern dabei dann ihre

01:05:13.150 --> 01:05:17.670
Bewegungsrichtung Das ist jetzt auf eine ganz abstrakte Art und Weise

01:05:17.670 --> 01:05:20.950
ein Billiardspiel beschrieben Viele Details haben wir jetzt

01:05:20.950 --> 01:05:23.670
weggelassen Und das ist genau das, was ich auch heute Morgen meinte

01:05:23.670 --> 01:05:26.290
bei der Einführung Das ist die sogenannte Abstraktion Abstraktion ist

01:05:26.290 --> 01:05:29.510
ein wesentliches Hilfsmittel, mit der wir Informatiker versuchen die

01:05:29.510 --> 01:05:32.910
Komplexität der realen Welt zu beherrschen Indem wir nämlich

01:05:32.910 --> 01:05:36.690
unwichtige Details weglassen Und natürlich, wie das immer ist bei

01:05:36.690 --> 01:05:40.450
einer Abstraktion Man geht natürlich Ungenauigkeiten ein Ich hatte

01:05:40.450 --> 01:05:43.530
eben schon so gesagt, naja, also die Windverhältnisse auf der

01:05:43.530 --> 01:05:46.390
Billiardplatte die berücksichtigen wir jetzt nicht Aber es ist

01:05:46.390 --> 01:05:48.530
natürlich klar, stellen Sie sich vor, Sie spielen ein Billiard im

01:05:48.530 --> 01:05:52.610
Freien Und ein Windstoß kann natürlich Ihre Kugel manipulieren Aber

01:05:52.610 --> 01:05:55.090
man sagt halt, gut, diesen Fehler, der dadurch entsteht in der

01:05:55.090 --> 01:05:58.090
Simulation, bin ich bereit eben zu akzeptieren Das ist aber eine

01:05:58.090 --> 01:06:01.350
bewusste Entscheidung, weil mir das zu aufwendig wird Windverhältnisse

01:06:01.350 --> 01:06:04.330
noch mit einzuberechnen Aber im Prinzip ist das immer so die

01:06:04.330 --> 01:06:07.490
Entscheidung, die Sie als Informatiker treffen Modelliere ich noch

01:06:07.490 --> 01:06:11.250
irgendeinen Einflussfaktor mit in meiner Software, in meinem

01:06:11.250 --> 01:06:14.390
Computerprogramm in meinen Daten, oder lasse ich das lieber bleiben

01:06:14.390 --> 01:06:18.370
Und das ist, wie immer, so Abwägeentscheidungen Irgendwann wird die

01:06:18.370 --> 01:06:21.490
Sache immer komplizierter Und irgendwann, sagen Sie ja, der positive

01:06:21.490 --> 01:06:23.970
Effekt für das, was ich will nämlich die Billiardsimulierung, ist es

01:06:23.970 --> 01:06:27.630
einfach nicht mehr wert Und das ist eben das, was eigentlich das

01:06:27.630 --> 01:06:30.170
Wichtigste ist, fast als Informatiker was man können muss, genau diese

01:06:30.170 --> 01:06:35.150
Abwägungen gut zu treffen Und die Grundidee bei der objektorientierten

01:06:36.710 --> 01:06:38.610
Programmierung, das war auch so ein bisschen einer der Gründe warum

01:06:38.610 --> 01:06:41.630
das so eine Erfolgsgeschichte war dass man sagt

01:06:44.770 --> 01:06:48.370
Ich kopple die Datenmodellierung und den Programmcode aneinander.

01:06:49.250 --> 01:06:51.590
Früher war es so, Sie haben im Prinzip Code geschrieben und die

01:06:51.590 --> 01:06:56.290
Datenmodellierung war getrennt davon und das ist halt insofern

01:06:56.290 --> 01:06:58.390
umgeschickt, weil wenn Sie irgendwas ändern, den Code oder die

01:06:58.390 --> 01:07:00.430
Datenmodellierung dann ist halt erstmal nicht so klar, passt das

01:07:00.430 --> 01:07:05.030
wieder gut zueinander Und stattdessen hat die objektorientierte

01:07:05.710 --> 01:07:12.350
Programmierung gesagt, eigentlich hat jedes Objekt ein Gegenstück in

01:07:12.350 --> 01:07:15.410
der virtuellen Welt, also jedes Teil aus der realen Welt, daher kommt

01:07:15.410 --> 01:07:18.670
auch der Name objektorientierte Programmierung und diese Objekte

01:07:18.670 --> 01:07:21.330
kooperieren miteinander durch Datenaustausch.

01:07:21.390 --> 01:07:23.790
Jetzt können Sie sagen, naja, Kooperation ist vielleicht kein gutes

01:07:23.790 --> 01:07:26.810
Wort, stimmt, aber letzten Endes geht es darum, die kommunizieren über

01:07:26.810 --> 01:07:27.790
einen Austausch von Daten.

01:07:28.490 --> 01:07:32.890
Und das heißt die Modellierungsfrage ist nicht mehr so sehr Wie mache

01:07:32.890 --> 01:07:36.110
ich etwas, sondern erstmal nur Wer macht denn hier bitte was?

01:07:37.950 --> 01:07:41.490
Und dann sagt man halt, wenn man über so ein Programm spricht dass ein

01:07:41.490 --> 01:07:46.970
Objekt A eine Nachricht an Objekt B sendet oder gleichbedeutend, ein

01:07:46.970 --> 01:07:51.810
Objekt A ruft eine Methode, also ein Codestück von Objekt B auf.

01:07:52.230 --> 01:07:54.690
Und darüber findet dann die Kommunikation statt.

01:07:56.270 --> 01:08:01.450
Schauen wir uns das mal in unserem Billard-Spiel wieder an Das hier

01:08:01.450 --> 01:08:04.350
soll jetzt mal einen Augenblick an die reale Welt darstellen.

01:08:04.470 --> 01:08:06.550
Ich weiß, das ist auch schon eine Abstraktion davon, aber das soll

01:08:06.550 --> 01:08:10.710
unser realer Billard-Tisch sein und in meiner Programmierwelt habe ich

01:08:10.710 --> 01:08:15.610
jetzt ein Objekt, nämlich einen Tisch, der T heißt der ganz konkret

01:08:15.610 --> 01:08:21.710
die Länge von 254 cm hat die Breite von 127 cm, der einen Namen hat,

01:08:21.850 --> 01:08:25.830
Toronto Deluxe zum Beispiel und, jetzt kommt diese lustige Sache mit

01:08:25.830 --> 01:08:30.070
den offenen und geschlossenen Klammern, der bestimmte sogenannte

01:08:30.070 --> 01:08:30.830
Methoden hat.

01:08:30.990 --> 01:08:33.690
Das sind Dinge, das sind in dem Falle Dinge die sie aufrufen können,

01:08:33.790 --> 01:08:36.690
Methoden die sie aufrufen können, wie zum Beispiel getLength,

01:08:36.790 --> 01:08:40.710
getWidth, getName wo sie dann im Prinzip das Ergebnis bekommen von

01:08:40.710 --> 01:08:45.290
diesen Werten hier oder auch sie können einen Ball hinzufügen d.h.

01:08:45.350 --> 01:08:48.550
sie können eine Kugel hier platzieren auf dem Feld und das ist also

01:08:48.550 --> 01:08:49.530
die Routine AddBall

01:08:52.550 --> 01:09:00.170
und so ein Objekt besteht immer aus einem Namen Attributen die das

01:09:00.170 --> 01:09:01.050
Objekt beschreiben.

01:09:01.810 --> 01:09:04.130
Hier geht im Wesentlichen unsere Abstraktion ein.

01:09:04.170 --> 01:09:07.030
Sie sehen, wir beschreiben einen Billard-Tisch lediglich durch Länge,

01:09:07.190 --> 01:09:11.590
Breite und seinen Namen von seinem Modell, aber jetzt zum Beispiel

01:09:11.590 --> 01:09:14.710
nicht durch das Material oder seine Höhe, weil das bei uns in der

01:09:14.710 --> 01:09:16.070
Simulation keine Rolle spielt.

01:09:16.670 --> 01:09:19.690
Und dann gibt es Methoden und das ist halt das, was sie immer haben,

01:09:20.210 --> 01:09:23.290
wenn sie ein Objekt haben sie haben immer den Namen, die Attribute und

01:09:23.290 --> 01:09:30.890
die Methoden So und jetzt haben sie verschiedene Bälle oder Kugeln z

01:09:30.890 --> 01:09:30.930
.B.

01:09:31.070 --> 01:09:35.310
haben sie hier die rote Kugel die hat einen Durchmesser, die hat ein

01:09:35.310 --> 01:09:39.570
Gewicht, sie hat eine Farbe die ist rot und sie hat eine X und Y

01:09:39.570 --> 01:09:47.410
Position, die sich eben hier dann auf den Tisch bezieht So, wie wir

01:09:47.410 --> 01:09:50.910
gesagt haben, so ein Objekt es kann ja mehrere Objekte geben wie

01:09:50.910 --> 01:09:55.310
diesen roten Ball und jetzt ist die Frage, wie komme ich eigentlich zu

01:09:55.310 --> 01:09:55.950
meinen Objekten?

01:09:56.030 --> 01:09:58.830
Erstmal haben wir die Objekte jetzt abgeleitet aus der realen Welt

01:09:58.830 --> 01:10:01.970
aber Sie sehen, es macht ja schon einen Unterschied, rede ich über die

01:10:01.970 --> 01:10:07.190
rote Kugel also eine konkrete, oder rede ich über Billardkugeln

01:10:07.190 --> 01:10:10.390
generell, wir meinen jetzt nicht eine spezielle damit und das ist

01:10:10.390 --> 01:10:13.310
genau der Unterschied zwischen Objekt und Klasse.

01:10:14.190 --> 01:10:18.990
Ein Objekt ist eine konkrete Ausprägung oder in Informatikerdeutsch

01:10:18.990 --> 01:10:23.110
eine Instanz das heißt, das ist der konkrete Gegenstand, die

01:10:23.110 --> 01:10:25.310
Repräsentation eines konkreten Gegenstands im Computer.

01:10:25.650 --> 01:10:30.590
Eine Klasse ist, wenn man so will, der Bauplan für ein Objekt wo man

01:10:30.590 --> 01:10:34.570
generell sagt, welche Eigenschaften haben die Objekte?

01:10:35.870 --> 01:10:39.170
Also, wir haben jetzt hier zum Beispiel, geben Sie alle sagen, es gibt

01:10:39.170 --> 01:10:43.370
einen Durchmesser, es gibt ein Gewicht es gibt eine x- und y-Position,

01:10:43.490 --> 01:10:45.950
aber Sie geben keine konkreten Werte an wie wir das hier beim Objekt

01:10:45.950 --> 01:10:50.350
gemacht haben sondern wir sagen nur, welchen Typ hat das hier also in

01:10:50.350 --> 01:10:55.130
dem Fall eine Vielskommazahl oder eine Ganzzahl und wir definieren

01:10:55.130 --> 01:11:01.990
auch die Methoden wir sagen aber nicht wie das jetzt für eine konkrete

01:11:01.990 --> 01:11:04.890
Ausprägung ist dafür muss man, das werden wir ja auch später noch

01:11:04.890 --> 01:11:09.390
kennenlernen dann diese Objekte erzeugen aus den Klassen.

01:11:09.510 --> 01:11:12.050
Sie können sich das so ein bisschen vorstellen die Klasse ist ein

01:11:12.050 --> 01:11:15.530
Stempel und mit dem Stempel können Sie beliebig viele Objekte machen

01:11:20.990 --> 01:11:25.470
jetzt ist es so, die auch wieder so ein bisschen Experten wissen es

01:11:25.470 --> 01:11:28.070
gab lange Zeit eine Diskussion darüber, was sind eigentlich Objekte

01:11:28.070 --> 01:11:28.550
und Klassen.

01:11:28.630 --> 01:11:31.850
Weil wie das immer so ist, wenn man einen neuen Begriff hat denkt

01:11:31.850 --> 01:11:34.430
erstmal, jeder kann da ja mitreden und es dauert eine Zeit lang, bis

01:11:34.430 --> 01:11:38.790
man mal wirklich die Essenz raus hat und ein Objekt wird durch drei

01:11:38.790 --> 01:11:42.210
verschiedene Aspekte charakterisiert.

01:11:42.330 --> 01:11:47.670
Das eine ist die Identität das heißt also wenn Sie ein Objekt im

01:11:47.670 --> 01:11:49.910
Speicher haben, ist das eindeutig.

01:11:50.010 --> 01:11:52.930
Es können sich die Werte, die Attributwerte ändern, es bleibt aber

01:11:52.930 --> 01:11:56.090
trotzdem erstmal ein Objekt und zwar dasselbe Objekt.

01:11:56.350 --> 01:11:58.690
Und wenn Sie ein anderes Objekt haben da kann es vielleicht auch

01:11:58.690 --> 01:12:01.850
dieselben Attributwerte haben aber es ist ein anderes Objekt.

01:12:04.630 --> 01:12:09.830
Dann hat das Ganze einen Zustand das ist im Wesentlichen der Wert den

01:12:09.830 --> 01:12:10.830
die Attribute haben.

01:12:11.090 --> 01:12:13.670
Das definiert den Zustand eines Objekts.

01:12:14.390 --> 01:12:18.370
Und schlussendlich noch das Verhalten, das sind die Dinge, die durch

01:12:18.370 --> 01:12:22.490
die Methoden realisiert werden, also dann tatsächlich den Code und wie

01:12:22.490 --> 01:12:25.050
ich eingangs sagte, das Besondere an der Objektorientierung ist, dass

01:12:25.050 --> 01:12:29.890
ich durch die Klasse eine Chance habe Code und Daten zusammenzufassen

01:12:30.650 --> 01:12:33.570
dass auch wirklich das, was zusammen gehört, auch tatsächlich in einem

01:12:33.570 --> 01:12:36.550
syntaktischen Konstrukt, nämlich der Klasse, hingeschrieben werden

01:12:36.550 --> 01:12:36.870
kann.

01:12:37.130 --> 01:12:40.770
In den nicht objektorientierten Sprachen habe ich halt diese

01:12:40.770 --> 01:12:43.510
Datenmodellierung auf der einen Seite den Code auf der anderen Seite.

01:12:43.890 --> 01:12:45.990
Die müssen natürlich trotzdem noch zusammenarbeiten na klar, der Code

01:12:45.990 --> 01:12:48.450
muss ja zur Datenmodellierung passend umgedreht aber ich habe nicht

01:12:48.450 --> 01:12:51.570
die Möglichkeit, das syntaktisch in der Sprache auszudrücken.

01:12:51.650 --> 01:12:54.150
Und das ist eben das Besondere an objektorientierten Sprachen dass ich

01:12:54.150 --> 01:12:54.630
das kann.

01:12:57.330 --> 01:13:01.630
Dann ist, wie wir sagten, eine Klasse ein Bauplan für gleichartige

01:13:01.630 --> 01:13:06.150
Objekte und legt eben fest, welche Attribute sollen die Objekte haben

01:13:06.150 --> 01:13:08.970
und welche Methoden sollen die Objekte haben.

01:13:10.330 --> 01:13:13.330
Und wer da gerne mehr nachlesen will, es gibt ein schönes Buch, was

01:13:13.330 --> 01:13:17.370
diese Grundlagen auch mal rausgearbeitet hat in den 90ern, von Creddy

01:13:17.370 --> 01:13:21.690
Buch, Objektorientiertes Analysis and Design und das Schöne ist, es

01:13:21.690 --> 01:13:24.230
gibt es mittlerweile, weil es schon so alt ist auch online for free,

01:13:24.810 --> 01:13:27.870
das heißt die können sich das da runterladen und da halt nachgucken.

01:13:28.210 --> 01:13:31.530
Derjenige, der jetzt Programmieranfänger ist, der muss da vielleicht

01:13:31.530 --> 01:13:33.790
noch nicht sofort reingucken, aber die anderen finden das vielleicht

01:13:33.790 --> 01:13:34.270
ganz spannend.

01:13:36.370 --> 01:13:39.030
Ja, wo kommt eigentlich diese objektorientierte Programmierung her?

01:13:39.550 --> 01:13:43.830
Der Hintergrund ist der dass es mal in den 60er Jahren eine Sprache

01:13:43.830 --> 01:13:44.930
gab, die hieß Simula.

01:13:45.530 --> 01:13:48.390
Und der Name war hier auch Programm, das war eine Programmiersprache,

01:13:48.490 --> 01:13:52.410
die wurde entwickelt um reale Sachverhalte aus der realen Welt

01:13:53.010 --> 01:13:54.670
mathematisch zu simulieren im Computer.

01:13:55.550 --> 01:14:02.830
Und da gab es Simula 1, dann Simula 67 und das war eigentlich die

01:14:02.830 --> 01:14:05.330
erste Programmiersprache, die systematisch zwischen Klassen und

01:14:05.330 --> 01:14:07.230
Objekten unterschieden hat.

01:14:07.230 --> 01:14:09.230
Und das ist eigentlich der Ursprung auch für die ganzen

01:14:09.230 --> 01:14:11.050
objektorientierten Sprachen, wie wir sie heute kennen.

01:14:11.930 --> 01:14:15.170
Zwei Bemerkungen dazu Das erste, diejenigen, die sich schon ein

01:14:15.170 --> 01:14:17.810
bisschen auskennen mit Programmiersprachen Sie sehen, das ist

01:14:17.810 --> 01:14:22.170
eigentlich ziemlich alt in der Geschichte der Programmierung 60er

01:14:22.170 --> 01:14:26.270
Jahre Das heißt, die Objektorientierung ist genauso alt wie die

01:14:26.270 --> 01:14:29.550
prozedurale oder imparative Programmierung Es ist nicht so, wie das

01:14:29.550 --> 01:14:32.130
heute manchmal verstanden wird dass man sagt, naja, erst haben die

01:14:32.130 --> 01:14:36.370
Leute prozedural programmiert mit C oder Pascal und dann kam nachher

01:14:36.370 --> 01:14:37.890
die Objektorientierung draufgesattelt.

01:14:38.490 --> 01:14:39.170
Nein, das ist Quatsch.

01:14:39.450 --> 01:14:41.030
Das ist im Prinzip alles parallel entstanden.

01:14:41.430 --> 01:14:44.090
Und dann nachher hat sich die objektorientierte Programmierung halt

01:14:44.090 --> 01:14:44.790
eben durchgesetzt.

01:14:45.370 --> 01:14:47.210
Das war aber jetzt nur so Expertenwissen, das müssen die anderen nicht

01:14:47.210 --> 01:14:47.510
verstehen.

01:14:49.110 --> 01:14:54.810
Und das andere, eigentlich ist die Idee der Name objektorientierte

01:14:54.810 --> 01:14:57.310
Programmiersprache meiner Meinung nach ziemlich schlecht gewählt.

01:14:57.390 --> 01:14:59.710
Das müsste eigentlich heißen Klassenorientierte Programmiersprache.

01:14:59.710 --> 01:15:02.030
Weil was sie ja hinschreiben, sind ja die Klassen.

01:15:02.850 --> 01:15:06.370
Die Objekte entstehen dann zur Laufzeit aus ihren Klassen aber die

01:15:06.370 --> 01:15:07.150
schreiben sie ja nicht hin.

01:15:07.470 --> 01:15:10.550
Es gibt tatsächlich objektorientierte Sprachen, die wirklich, wo sie

01:15:10.550 --> 01:15:12.850
gezwungen sind, Objekte hinzuschreiben aber das ist nicht Java.

01:15:13.710 --> 01:15:16.150
Also insofern lassen sie sich nicht verwirren, wenn sie jetzt gerade

01:15:16.150 --> 01:15:18.990
dachten, der Logik nach wäre es viel besser wenn ich darüber reden

01:15:18.990 --> 01:15:21.430
würde, dass es eigentlich Klassenorientierte Programmiersprache heißt,

01:15:21.530 --> 01:15:23.870
nicht objektorientierte, haben sie eigentlich vollkommen recht weil

01:15:23.870 --> 01:15:25.290
beim Programmieren schreiben sie Klassen hin.

01:15:26.570 --> 01:15:29.030
So, wie sieht das jetzt in Java konkret aus?

01:15:29.630 --> 01:15:31.930
Naja, wir hatten das ja schon bei unserem Hello World Programm das

01:15:31.930 --> 01:15:35.130
fängt irgendwie mit einem Class an und hier schreiben wir, wir möchten

01:15:35.130 --> 01:15:39.770
eine Klasse für unsere ganzen Fallobjekte hinschreiben.

01:15:40.130 --> 01:15:45.330
Diese Klasse legt also fest, wie Bälle beschrieben werden und das

01:15:45.330 --> 01:15:49.690
machen wir halt durch die folgenden Attribute, Durchschnitt, Gewicht

01:15:49.690 --> 01:15:54.990
Position und jetzt haben wir die Position und auch noch die

01:15:54.990 --> 01:15:59.530
Geschwindigkeit Was sie hier auch sehen, das ist aber erstmal rein so

01:15:59.530 --> 01:16:04.850
taktisch, ist Kommentare Also immer das, was hier hinter zwei Slashs

01:16:06.170 --> 01:16:08.910
anfängt, das ist ein Kommentar das heißt, sie können hier was

01:16:08.910 --> 01:16:12.830
hinschreiben, was den Compiler nicht weiter interessiert, weil der

01:16:12.830 --> 01:16:16.830
blendet alle Kommentare von vornherein aus, aber das soll dann Ihnen

01:16:16.830 --> 01:16:20.470
und auch dem nächsten Menschen, der das Programm behandelt, helfen das

01:16:20.470 --> 01:16:21.530
Programm zu verstehen.

01:16:21.770 --> 01:16:25.770
Das ist so ein klassischer Anfängerkommentar, dass man das

01:16:25.770 --> 01:16:27.550
hinschreibt, was eh klar ist.

01:16:28.050 --> 01:16:31.850
Wir werden nachher im Verlauf der späteren Vorlesung noch dazu kommen

01:16:31.850 --> 01:16:33.290
das sind gute Kommentare.

01:16:33.390 --> 01:16:36.550
Und gute Kommentare sind natürlich die die wirklich zusätzliche

01:16:36.550 --> 01:16:39.670
Informationen zum Verständnis des Programms machen, die aber nicht

01:16:39.670 --> 01:16:42.190
durch eine reine Kenntnis der Programmiersprache sich erschließen.

01:16:42.610 --> 01:16:45.070
Jeder, der sich auskennt beim Programmieren, würde sagen, klar, das

01:16:45.070 --> 01:16:47.770
ist die Attributdefinition, das brauche ich nicht mehr als Kommentar

01:16:47.770 --> 01:16:48.230
hinschreiben.

01:16:48.590 --> 01:16:49.150
Stimmt auch.

01:16:49.550 --> 01:16:51.530
Ich wollte Ihnen aber jetzt nur mal hier in dem Beispiel zeigen, was

01:16:51.530 --> 01:16:52.350
ein Kommentar ist.

01:16:52.750 --> 01:16:56.170
Sie können Ihre Kommentare auch länger machen, über mehrere Zeilen

01:16:56.170 --> 01:16:59.110
indem Sie das so mit einem Slash und einem Sternchen beginnen und

01:16:59.110 --> 01:17:00.550
Sternchen, Slash aufhören.

01:17:01.330 --> 01:17:04.490
Auch hier wieder können Sie sagen, Firlefanz, je mehr ich tippen muss,

01:17:04.570 --> 01:17:06.990
umso schlechter Ich weiß eh nicht so genau, wo die Buchstaben auf der

01:17:06.990 --> 01:17:11.610
Tastatur sind aber Sie denken wieder daran, das Programm schreiben für

01:17:11.610 --> 01:17:14.290
den nächsten Menschen und erfahrungsgemäß wird ein Programm viel, viel

01:17:14.290 --> 01:17:17.030
seltener editiert, also getippt als gelesen.

01:17:17.310 --> 01:17:18.730
Das Programm wird nachher viel häufiger gelesen.

01:17:19.070 --> 01:17:23.030
Insofern tun Sie also jedem, auch durch längere Variablenamen, längere

01:17:23.030 --> 01:17:26.290
Bezeichnernamen, längere Kommentare, jedem, der es liest einen

01:17:26.290 --> 01:17:28.690
gefallen, auch wenn es Ihnen in dem Augenblick gerade ein bisschen

01:17:28.690 --> 01:17:29.210
Mühe macht.

01:17:31.070 --> 01:17:33.950
Keine Angst vor langen Variablenamen und Kommentaren.

01:17:35.010 --> 01:17:39.590
So, dann sehen wir hier im Prinzip dieses Schema.

01:17:40.350 --> 01:17:44.470
Wir fangen mit diesem Wort Class an geben da einen Namen, hier Ball,

01:17:44.970 --> 01:17:47.310
und dann kommt in geschweiften Klammern dieser Rumpf.

01:17:47.430 --> 01:17:49.530
Und der zieht sich in der Regel über viele Zeilen dann hin.

01:17:51.510 --> 01:17:55.150
Eine Sache fällt uns vielleicht hier auch auf, und zwar schaut mal

01:17:55.150 --> 01:18:00.330
hier, die Position und die Geschwindigkeit, beides mal quasi so als

01:18:00.330 --> 01:18:04.350
Vektor angegeben, mit x- und y-Koordinaten das ist doch eigentlich

01:18:04.350 --> 01:18:05.250
dasselbe Konstrukt.

01:18:05.330 --> 01:18:08.550
Ist doch ein bisschen blöd dass wir das jetzt hier immer so komplett

01:18:08.550 --> 01:18:09.650
ausgerollt angeben müssen.

01:18:09.710 --> 01:18:11.510
Kann man das nicht einfacher machen?

01:18:11.610 --> 01:18:13.950
Und die Antwort ist ja zum Glück kann man sowas einfacher machen.

01:18:14.570 --> 01:18:19.490
Und zwar brauche ich dafür eine neue Klasse nämlich die Klasse 2D

01:18:19.490 --> 01:18:19.970
-Vektor.

01:18:20.290 --> 01:18:26.110
Also Vektor 2D im Sinne von einem zweidimensionalen Vektor und dann

01:18:26.110 --> 01:18:29.930
mache ich das so, dass ich sage also dieses x- und y-Koordinate, das

01:18:29.930 --> 01:18:33.970
mache ich in Vektor 2D rein, als neue Klasse deswegen wieder class

01:18:33.970 --> 01:18:39.610
Vektor2D, geschweifte Klammer, Attribute und jetzt kann ich das auch

01:18:39.610 --> 01:18:44.170
verwenden, indem ich nämlich dann in der Klasse Ball sage Vektor2D

01:18:44.170 --> 01:18:48.770
-Position Vektor2D-Velocity und dann im Prinzip das hier jedes Mal

01:18:48.770 --> 01:18:49.450
wiederverwende.

01:18:50.310 --> 01:18:52.570
Noch mal gerade einen Schritt zurück, damit Sie die Veränderung sehen.

01:18:53.110 --> 01:18:57.710
Vorher stand das hier alles als Gleitkommazahl definiert und jetzt

01:18:57.710 --> 01:19:01.290
fasse ich das im Prinzip in zwei Attribute zusammen, wobei aber jedes

01:19:01.290 --> 01:19:06.110
selber wieder x- und y-Koordinaten hat Und was habe ich jetzt

01:19:06.110 --> 01:19:06.490
gewonnen?

01:19:07.530 --> 01:19:11.050
Zum einen habe ich einen großen Vorteil, das Ganze ist verständlicher

01:19:11.050 --> 01:19:11.490
geworden.

01:19:11.810 --> 01:19:15.290
Weil jetzt habe ich hier den Begriff Vektor stehen und jetzt ist schon

01:19:15.290 --> 01:19:17.970
mal jedem klar, ah, das soll ein Vektor sein und hier gibt es auch

01:19:17.970 --> 01:19:18.550
einen Vektor.

01:19:19.090 --> 01:19:21.870
Das kann ich schneller verstehen, wenn ich das auch ausgeschrieben

01:19:21.870 --> 01:19:25.610
habe und nicht wie vorher, einfach eine Reihe von Gleitkommazahlen

01:19:25.610 --> 01:19:28.270
habe, wo ich mir dann überlegen muss aha, das sollen wohl Vektoren

01:19:28.270 --> 01:19:28.590
sein.

01:19:28.750 --> 01:19:31.850
Also ich habe mehr expliziten Ausdruck in das Programm gebracht, das

01:19:31.850 --> 01:19:35.930
ist schon mal gut Das andere ist, wenn ich jetzt mein Programm mal auf

01:19:36.670 --> 01:19:39.810
3D umstellen will, gebe ich zu, ein 3D-Modernes Bild macht jetzt

01:19:39.810 --> 01:19:41.930
vielleicht nicht so viel Sinn, springende Kugeln will man eigentlich

01:19:41.930 --> 01:19:45.310
auch nicht so haben, aber nehmen wir mal an, wir wollten das dann habe

01:19:45.310 --> 01:19:47.130
ich natürlich jetzt den Vorteil, ich muss nämlich nur noch an einer

01:19:47.130 --> 01:19:50.990
Stelle meinen Vektor ändern und muss das nicht mühsam von Hand an

01:19:50.990 --> 01:19:52.830
allen Stellen der Verwendung von Vektor durchziehen.

01:19:52.930 --> 01:19:55.570
Also auch ein Vorteil, es ist leichter evolvierbar geworden, das

01:19:55.570 --> 01:20:00.730
Programm Und wir haben eben die Art, wie wir einen Vektor, einen

01:20:00.730 --> 01:20:03.110
zweidimensionalen Vektor darstellen, auch wieder gekapselt in einer

01:20:03.110 --> 01:20:03.490
Klasse.

01:20:04.110 --> 01:20:06.310
Wenn ich das mal nämlich nicht in kathesischen Koordinaten machen

01:20:06.310 --> 01:20:08.550
will, sondern weil das vielleicht für die Winkelberechnung einfacher

01:20:08.550 --> 01:20:12.630
ist, in Polarkoordinaten, brauche ich das auch nur hier zu ändern und

01:20:12.630 --> 01:20:13.610
muss es nicht da ändern.

01:20:13.990 --> 01:20:15.050
Auch ein weiterer Vorteil.

01:20:18.150 --> 01:20:22.270
So, dann nächste Frage ist, wie komme ich denn jetzt an meine Objekte?

01:20:22.350 --> 01:20:25.130
Also wir haben gesehen, eigentlich habe ich Objekte in der realen

01:20:25.130 --> 01:20:29.310
Welt, eine Abstraktion davon ist im Computer Aber wie komme ich da

01:20:29.310 --> 01:20:29.490
hin?

01:20:29.650 --> 01:20:31.290
Ich habe ja jetzt erstmal nur die Klassen hingeschrieben.

01:20:31.970 --> 01:20:36.390
Und das mache ich in der Tat mit einem sogenannten Konstruktor, dem

01:20:36.390 --> 01:20:40.990
New Operator Und dann schreibe ich als Befehl hin einem Vektor 2D

01:20:40.990 --> 01:20:43.310
Position gleich New Vektor 2D.

01:20:43.430 --> 01:20:46.310
Und das erzeugt dann tatsächlich, das deklariert nicht nur und sagt,

01:20:46.390 --> 01:20:49.730
Position ist ein 2D Vektor, sondern es erzeugt quasi auch wirklich

01:20:49.730 --> 01:20:52.490
einen neuen Vektor dann hier und genauso bei der Velocity.

01:20:53.030 --> 01:20:53.310
Und z.B.

01:20:54.170 --> 01:20:56.530
mit Ball kann ich hier z.B.

01:20:56.550 --> 01:20:58.130
eine neue Kugel erzeugen mit New Ball.

01:21:02.300 --> 01:21:09.560
So, und jetzt kleine praktische Übung nochmal zum Schluss Alle also

01:21:09.560 --> 01:21:10.320
nochmal mitdenken.

01:21:11.220 --> 01:21:14.260
Sie sehen dieses Konstrukt der objektorientierten Modellierung hilft

01:21:14.260 --> 01:21:20.260
uns in erster Linie Programme zu schreiben, die von ihrer Terminologie

01:21:20.260 --> 01:21:22.140
nahe dran sind an der Anwendungswelt.

01:21:22.540 --> 01:21:23.460
Warum ist das so wichtig?

01:21:23.980 --> 01:21:26.880
Das ganze Problem der Softwaretechnik dreht sich letztendlich immer um

01:21:26.880 --> 01:21:30.580
die Frage, wie kann ich eine Aufgabenstellung, die formuliert ist in

01:21:30.580 --> 01:21:33.800
einer Terminologie der normalen Welt, umsetzen in einem Programm, was

01:21:33.800 --> 01:21:34.600
der Computer versteht.

01:21:34.680 --> 01:21:38.200
Das ist die gesamte Softwaretechnik sprich das gesamte Studentenleben

01:21:38.200 --> 01:21:42.720
wird sich das hier im Prinzip immer umtreiben Wie sind sie in der

01:21:42.720 --> 01:21:45.780
Lage, irgendwas was aus der normalen Welt kommt umzusetzen in ein

01:21:45.780 --> 01:21:47.380
Computerprogramm.

01:21:47.380 --> 01:21:54.360
Und je leichter diese Nachvollziehbarkeit dieser Umsetzung ist von der

01:21:54.360 --> 01:21:58.060
realen Welt in dieses Programm desto leichter ist das Programm nachher

01:21:58.060 --> 01:22:01.720
zu lesen, zu warten, zu verstehen Und da hilft jetzt in der Tat auch

01:22:01.720 --> 01:22:04.540
die Objektorientierung Das ist nämlich dann zum einen, wie wir das

01:22:04.540 --> 01:22:08.180
jetzt hier kennenlernen die syntaktische Art, wie wir das in der

01:22:08.180 --> 01:22:11.380
Programmiersprache ausdrücken können Es ist aber auch überhaupt eine

01:22:11.380 --> 01:22:14.580
ganze Denkweise Und um diese Denkweise zu üben, machen wir jetzt mal

01:22:14.580 --> 01:22:17.120
etwas, was Sie wahrscheinlich schon kennen, nämlich die Mensa hier in

01:22:17.120 --> 01:22:20.600
Karlsruhe Wenn wir ein Mensasystem modellieren wollen, zum Beispiel

01:22:20.600 --> 01:22:23.760
weil wir den Speiseplan elektronisch anzeigen wollen, manchmal klappt

01:22:23.760 --> 01:22:27.920
das ja auch in der Mensa, können wir uns überlegen wenn wir jetzt ein

01:22:27.920 --> 01:22:31.240
Softwaresystem dafür bauen wollen, was für Entitäten braucht es.

01:22:31.720 --> 01:22:36.120
Welche Attribute und im nächsten Schritt dann auch welche Methoden So

01:22:36.120 --> 01:22:41.020
und jetzt können wir mal anfangen Also, offenbar ist eine Sache, wenn

01:22:41.020 --> 01:22:43.780
man die Mensa modellieren will, dass man eine klasse Mensa hat Die

01:22:43.780 --> 01:22:46.900
Mensa hat zum Beispiel Namen, wie zum Beispiel bei uns Mensa am

01:22:46.900 --> 01:22:50.700
Adenauerring, aber es gibt ja noch andere Es hat eine Posterzahl, es

01:22:50.700 --> 01:22:55.020
hat eine Straße als Adresse Dann habe ich, was habe ich noch weiter an

01:22:55.020 --> 01:22:59.600
Eigenschaften Ich habe zum Beispiel den Speiseplan Ich habe Gerichte,

01:23:00.180 --> 01:23:07.900
ich habe Mensa-Besucher Und das sind Das sind die Entitäten, mit denen

01:23:09.280 --> 01:23:13.200
ein Softwareprogramm, was eben Speisepläne verwaltet, berücksichtigen

01:23:13.200 --> 01:23:13.360
kann.

01:23:13.420 --> 01:23:15.960
Den Besucher kann ich zum Beispiel noch haben, um nachzuzählen,

01:23:16.020 --> 01:23:22.000
welches Essen wird wie häufig gerne gegessen oder so Und was Sie jetzt

01:23:22.000 --> 01:23:24.420
hier sehen, das ist auch eine Sprache, die werden Sie im zweiten

01:23:24.420 --> 01:23:27.080
Semester in der Softwaretechnik 1 kennenlernen, eine grafische

01:23:27.080 --> 01:23:30.680
Modellierungssprache Das heißt, Sie haben jetzt hier grafische Symbole

01:23:30.680 --> 01:23:37.340
dafür für die verschiedenen Klassen Und das ist die sogenannte UML

01:23:37.340 --> 01:23:41.220
Unified Modelling Language, das ist, wenn man so will unsere Art, wie

01:23:41.220 --> 01:23:43.920
wir Informatiker komplexe IT-Systeme beschreiben.

01:23:44.400 --> 01:23:47.220
Einige Ingenieure in der Elektrotechnik haben ihre Symbole für

01:23:47.220 --> 01:23:49.780
Widerstände, Transistoren und so weiter und genauso haben wir eben

01:23:49.780 --> 01:23:53.080
auch was, um objektorientierte Systeme zu beschreiben Und das ist

01:23:53.080 --> 01:23:57.980
jetzt eine Klasse hier, das ist der Name Name Mensa für die Klasse

01:23:57.980 --> 01:24:01.360
Mensa Speiseplan, die Klasse Gericht und die Klasse Mensa Besucher Wir

01:24:01.360 --> 01:24:05.520
haben hier die Attribute und dann darunter die Methoden.

01:24:05.700 --> 01:24:08.100
Man kann zum Beispiel hier einen Speiseplan beziehen und man kann zum

01:24:08.100 --> 01:24:12.860
Beispiel bezahlen Und dasselbe ist da auch, wie beschreibe ich den

01:24:13.380 --> 01:24:20.580
Mensa Besucher, wie beschreibe ich zum Beispiel den Speiseplan, wie

01:24:20.580 --> 01:24:23.380
beschreibe ich das Gericht Alles das haben wir jetzt mal hier,

01:24:23.500 --> 01:24:29.900
spaßeshalber für sie mal vormodelliert, damit sie sehen, wie geht man

01:24:29.900 --> 01:24:33.760
an diesen Umsetzungsprozess dran, wenn ich halt eben was aus der

01:24:33.760 --> 01:24:37.880
normalen Welt, wie hier die Mensa langsam versuchen muss, das in

01:24:37.880 --> 01:24:41.940
Richtung Computerprogramm zu bringen Und wie gesagt, diese

01:24:42.520 --> 01:24:44.220
objektorientierte Denkweise, dass man davon sagt, naja, was gibt es

01:24:44.220 --> 01:24:47.400
für Entitäten Wie beschreibe ich die, also was sind die Attribute, was

01:24:47.400 --> 01:24:48.860
sind die Methoden Das ist eigentlich der Weg

01:24:51.880 --> 01:24:56.020
So und jetzt ist halt die spannende Frage an Sie und da kriegen Sie

01:24:56.020 --> 01:25:00.960
jetzt tatsächlich auch noch 4 Minuten Zeit für Schreiben Sie sich mal

01:25:00.960 --> 01:25:04.620
kurz entweder im Geiste oder auf dem Computer oder auf dem Blatt

01:25:04.620 --> 01:25:08.240
Papier ganz altbacken Was wäre denn eine Main-Methode für eine Klasse

01:25:08.240 --> 01:25:13.060
Vector2D die die Koordinaten von einem Vektor ausgibt Also wie sieht

01:25:13.060 --> 01:25:13.500
das aus?

01:25:13.520 --> 01:25:18.200
Sie haben alles davon jetzt schon gelernt bis jetzt Und jetzt wie

01:25:18.200 --> 01:25:21.340
gesagt, notieren Sie mal in den nächsten 3-4 Minuten wie müsste das

01:25:21.340 --> 01:25:25.200
aussehen, diese Main-Routine Das Schöne am Papiercomputer ist, es

01:25:25.200 --> 01:25:30.160
ergibt keine Fehlermeldungen aus So, am Ende der Vorlesung will ich

01:25:30.160 --> 01:25:33.880
jetzt natürlich auch mit dem Ergebnis rausrücken, so sieht es aus Sie

01:25:33.880 --> 01:25:36.620
haben also hier Ihre Klasse Vector2D und dann gibt es eine Main

01:25:36.620 --> 01:25:39.880
-Routine, die fängt aus nicht nachvollziehbaren Gründen immer noch

01:25:39.880 --> 01:25:43.760
erstmal mit public static void main an hat dann diesen string args

01:25:43.760 --> 01:25:47.020
eckige Klammern das müssen Sie nicht verstehen, das lernen wir noch

01:25:47.580 --> 01:25:52.020
dann muss ich mir einen neuen Vektor erzeugen weil, wenn ich keinen

01:25:52.020 --> 01:25:54.100
Vektor habe, kann ich ihn auch nicht ausgeben, das mache ich mit new

01:25:54.100 --> 01:25:59.400
und dann nehme ich unser HelloWorld System.out.println und sage zum

01:25:59.400 --> 01:26:08.320
Beispiel hier Zeichenkette x v.x ist gleich und dann mit plus hier

01:26:08.320 --> 01:26:14.020
kommt dann dieser Wert von v.x und hier kommt dann der Wert von v.y,

01:26:14.220 --> 01:26:19.740
also die beiden Koordinaten und Sie sehen auch wieder hier bei main

01:26:19.740 --> 01:26:23.620
fängt es an und dann gehe ich zeilenweise durch ich rufe was auf und

01:26:23.620 --> 01:26:27.400
mache da die zwei Ausgaben Vielen Dank bis an die Stelle und dann

01:26:27.400 --> 01:26:29.280
sehen wir uns in einer Woche hier wieder