WEBVTT

00:00.000 --> 00:01.080
So, schönen guten Tag.

00:01.160 --> 00:04.980
Ich begrüße Sie zur letzten Vorlesung Grundlagen der Informatik 2 in

00:04.980 --> 00:05.720
diesem Semester.

00:06.340 --> 00:09.200
Ich hätte gerne noch in viel mehr Vorlesungen erzählt, weil ich noch

00:09.200 --> 00:12.400
so viel Stoff habe, den ich präsentieren muss, aber wir kriegen das

00:12.400 --> 00:12.900
schon irgendwie hin.

00:13.400 --> 00:14.660
Es gibt schon wieder eine Frage.

00:14.840 --> 00:15.500
Was ist das hier?

00:16.920 --> 00:18.480
Das ist schon die zweite Frage.

00:19.240 --> 00:20.400
Remaining questions, fünf.

00:20.540 --> 00:20.940
Was ist das?

00:22.400 --> 00:24.700
Und alles, da ist überall nichts drin.

00:24.820 --> 00:28.420
Hat irgendjemand fünf solcher Fragen?

00:30.280 --> 00:31.840
Ich hoffe, das ist damit erledigt.

00:33.280 --> 00:35.800
Ich habe Ihnen mehrere Sachen zu erzählen heute Morgen, und zwar

00:35.800 --> 00:38.860
einmal nächste Woche gibt es die Klausur, das wissen Sie alle, Sie

00:38.860 --> 00:41.200
sind alle gut darauf vorbereitet, bereiten sich auch darauf vor.

00:41.840 --> 00:45.700
Damit Sie sich noch besser darauf vorbereiten können, haben wir etwas

00:45.700 --> 00:55.440
für Sie vorbereitet, und zwar diesen Extraservice zur Vorbereitung.

00:56.460 --> 01:00.660
Wir wollen, dass Sie noch mehr Informationen, also noch mehr

01:00.660 --> 01:03.160
Möglichkeiten haben, schon mal zu sehen, was Sie eigentlich können.

01:04.060 --> 01:08.860
Und dafür haben wir unser schönes Nukid-Werkzeug ein bisschen

01:08.860 --> 01:09.600
erweitert.

01:10.040 --> 01:15.720
Es gibt eine so genannte Survey-Funktion oder auch Test-Funktion, wo

01:15.720 --> 01:21.260
Sie Fragen bekommen, also speziell jetzt hier zu den Kapiteln 9 und 10

01:21.260 --> 01:27.260
heute, weil heute gerade erst Kapitel 9 fertig gemacht wird und 10 in

01:27.260 --> 01:28.780
Ausschnitten vorgestellt wird.

01:29.260 --> 01:33.280
Und dann kommen Dienstag fünf Fragen zu Kapitel 7 und 8, Mittwoch fünf

01:33.280 --> 01:36.580
Fragen zu Kapitel 5 und 6 und so weiter, die hier aufgeführt ist.

01:36.580 --> 01:39.420
Und wo kommen diese Fragen hin?

01:40.360 --> 01:45.300
Bekommen Sie, wenn Sie auf die Nukid-Apps draufgehen.

01:45.480 --> 01:50.900
Also Sie müssen Ihr Android-App einmal aktualisieren.

01:51.220 --> 01:54.860
Ich mache das vielleicht automatisch, wenn Sie das so eingestellt

01:54.860 --> 01:56.400
haben, sonst müssen Sie es explizit tun.

01:56.500 --> 01:59.960
Dann bekommen Sie diese Funktion mit da rein, sodass Sie diesen Survey

01:59.960 --> 02:00.680
aufrufen können.

02:00.760 --> 02:05.440
Da sind also dann fünf Fragen freigeschaltet und diese fünf Fragen

02:05.440 --> 02:06.560
können Sie dann beantworten.

02:06.660 --> 02:09.960
Das sind altes Multiple-Choice-Fragen und Sie müssen also entsprechend

02:09.960 --> 02:16.380
dann so viele Punkte anklicken, wie Sie für richtig halten und können

02:16.380 --> 02:20.960
also dort zumindest die Antworten geben.

02:21.180 --> 02:23.600
Sie bekommen dann natürlich auch Rückmeldung, was das richtige

02:23.600 --> 02:24.940
Ergebnis jeweils gewesen ist.

02:25.340 --> 02:28.420
Das wird aber erst später dann jeweils passieren, dann Ende der Woche.

02:28.860 --> 02:30.200
Und wie wird das also aussehen?

02:30.280 --> 02:33.060
Es ist so, dass Sie zwei Möglichkeiten haben, entweder übers Web

02:33.540 --> 02:33.900
reinzugehen.

02:34.280 --> 02:37.320
Da müssen Sie halt erst mal Ihren Namen angeben.

02:37.380 --> 02:40.780
Sie müssen den Kurs wählen und dann gibt es eben diesen neuen Punkt

02:40.780 --> 02:43.460
dort, dass Sie den Survey oder den Test auswählen.

02:44.200 --> 02:49.360
Und dann müssen Sie außerdem das Passwort angeben für diesen Kurs.

02:49.460 --> 02:52.440
Sie wissen, dass das Info 2 ist und so wie es hier steht.

02:53.100 --> 02:54.760
Und dann beantworten Sie die Fragen.

02:54.900 --> 02:56.040
Also der Survey wird angezeigt.

02:56.120 --> 02:57.060
Da müssen Sie auch aufklicken.

02:57.460 --> 03:00.860
Dann werden die Fragen gezeigt und dann sehen Sie hier solche Fragen.

03:00.980 --> 03:03.340
Hier ist es angedeutet auf dieser Seite.

03:04.420 --> 03:07.920
Da steht zum Beispiel die erste Frage, auf welche Art, nach welchen

03:07.920 --> 03:09.480
Verfahren und so weiter.

03:10.120 --> 03:12.500
Also welche Themenarten gibt es?

03:12.780 --> 03:14.000
Das werden Sie heute noch kennenlernen.

03:14.500 --> 03:17.100
Oder dann etwas über Assembler-Sprachen.

03:17.480 --> 03:20.640
Sie haben also eine Reihe von Fragen, die Sie gestellt werden können.

03:20.800 --> 03:24.840
Und dann müssen Sie irgendwann dann tatsächlich unten auf Answer

03:24.840 --> 03:25.520
Survey klicken.

03:25.620 --> 03:29.000
Sie können also hier die Antworten anklicken und schicken das dann ab.

03:30.240 --> 03:34.600
Und das Gleiche können Sie, ja genau, dann können Sie die Survey

03:34.600 --> 03:35.600
Results angeben.

03:35.700 --> 03:37.940
Die werden nach dem Ende freigeschaltet.

03:38.660 --> 03:40.780
Das ist ein T stehen und kein N.

03:43.880 --> 03:49.360
Und dann sehen Sie die Ergebnisse, wie Sie alle geantwortet haben auf

03:49.360 --> 03:49.840
diese Frage.

03:50.960 --> 03:53.740
Ich weiß nicht, wann die richtigen Ergebnisse mitgeteilt werden.

03:53.820 --> 03:54.540
Stehen die auch dabei?

03:56.580 --> 03:58.820
Okay, also die richtigen Antworten Ende der Woche.

03:59.460 --> 04:01.720
Und da gibt es wieder eine Frage.

04:07.690 --> 04:12.870
Dann gibt es also hier entsprechend die Ergebnisse und dann wird, also

04:12.870 --> 04:13.930
die Ergebnisse der Umfrage.

04:14.070 --> 04:15.870
Dann können Sie sehen, ob alle einer Meinung waren oder

04:15.870 --> 04:16.690
unterschiedlicher Meinung.

04:17.690 --> 04:23.210
Und dann geht das weiter mit dem Zugang über die App.

04:24.150 --> 04:27.150
Kennen Sie auch, Sie können dort entsprechend Ihren Namen eingeben,

04:27.270 --> 04:31.230
Kurs wählen, das Passwort wieder angeben, dann die Fragen beantworten,

04:31.310 --> 04:32.530
wobei Sie auf Folgendes achten müssen.

04:33.030 --> 04:35.970
Ich habe das gestern ausprobiert und festgestellt, man sitzt dann hier

04:35.970 --> 04:39.170
und sagt, auf welche Art und Weise und so weiter können hier also

04:39.170 --> 04:41.850
Rechner betrieben werden.

04:41.990 --> 04:44.550
Das sind ein paar Sachen, die Sie anklicken können.

04:45.250 --> 04:47.010
Dann wundern Sie sich, was muss ich jetzt machen?

04:48.770 --> 04:49.730
Ich weiß tatsächlich nichts.

04:49.950 --> 04:52.350
Wir müssen es einfach einmal in die Richtung schieben.

04:53.210 --> 04:55.890
Einfach das einmal rüberschieben, dann kommt die nächste Frage.

04:56.050 --> 04:59.530
Das ist hier leider nicht angegeben im Menü, aber das ist so.

04:59.710 --> 05:01.590
Die weiteren Fragen sind dann angegeben.

05:01.670 --> 05:06.050
Hier oben ist ein kleiner Punkt und da sind also mehrere Felder.

05:06.130 --> 05:09.710
Da sehen Sie dann im Prinzip, wie weit Sie bei dem Survey bereit sind.

05:10.090 --> 05:12.530
Also einfach immer nach links schieben und dann haben Sie entsprechend

05:12.530 --> 05:14.270
die nächsten Fragen, können die beantworten.

05:14.530 --> 05:18.350
Und bei der letzten Frage steht dann unten drunter dieser Button zum

05:18.350 --> 05:19.670
Abschicken.

05:19.890 --> 05:24.870
Das ist, ah ja, sehen Sie, das ist hier Fragen beantworten und dann,

05:25.110 --> 05:27.630
das hier ist Ihnen auch schon alles und Sie können dann also am Ende

05:27.630 --> 05:30.110
hier unten auch noch angeben, dass Sie das abschicken wollen.

05:30.750 --> 05:36.430
Und dann können Sie wieder, also diese Sache fehlt hier, dass man, da

05:36.430 --> 05:39.490
müsste eigentlich noch ein Punkt rein, dass man die Antworten

05:39.490 --> 05:40.330
abschicken soll.

05:41.070 --> 05:44.870
Und dann können Sie anschließend sich die Umfrageergebnisse anschauen.

05:45.790 --> 05:50.150
Gut, also, das ist ein Ding.

05:50.630 --> 05:53.690
Dann hat hier jemand, es ist ja nett, dass Sie mich hier nerven mit

05:54.310 --> 05:57.850
Fragen, die nicht lesbar sind.

05:58.190 --> 06:06.210
Aber okay, das war das, was wir hier im Test Ihnen noch anbieten

06:06.210 --> 06:06.610
wollten.

06:07.530 --> 06:15.310
Und dann kommen wir zum Inhalt der Vorlesung.

06:15.750 --> 06:18.790
Lassen Sie mich gleich da reingehen.

06:18.890 --> 06:23.030
Genau, letztes Mal haben wir uns beschäftigt mit Programmieren.

06:23.190 --> 06:27.290
Ich hatte Ihnen den Rest erzählt, Speicher und ähnlichen Dingen.

06:27.750 --> 06:32.530
Wir hatten uns dann mit Programmiersprachen beschäftigt und hatten

06:32.530 --> 06:36.390
gesehen, dass da verschiedene Ebenen gibt, in denen man Programme

06:36.390 --> 06:40.710
schreiben kann, problemorientiert bis runter zur Maschinensprache oder

06:40.710 --> 06:42.450
Mikroprogrammierung, also sehr maschinennah.

06:42.910 --> 06:46.410
Ich hatte Ihnen etwas erzählt über die Strukturen bei der

06:46.410 --> 06:50.610
Mikroprogrammierung, über diese Mikroprogramm-Einheit, die im Prinzip

06:50.610 --> 06:54.810
nochmal das Gleiche nachbildet, was wir in der CWU auch gesehen haben,

06:54.890 --> 06:57.890
diesen Ablauf, Maschinenbefehlszyklus.

06:58.290 --> 07:02.870
Hier wird ein einzelner Befehl geholt, interpretiert und dann wird ein

07:02.870 --> 07:06.810
Mikroprogramm aufgerufen, um die einzelnen Steuersignale zu erzeugen

07:06.810 --> 07:09.490
für die Ausführung der konkreten Operationen.

07:09.790 --> 07:13.450
Ich hatte Ihnen etwas erzählt über Maschinensprache, über den Aufbau,

07:14.630 --> 07:17.170
ein Adress, zwei Adress, drei Adressbefehle geben kann.

07:18.070 --> 07:21.370
Und dann hatten wir auch ein Beispiel gesehen, das war dieses Beispiel

07:21.370 --> 07:28.130
mit einer einfachen Sprache, 4-Bit-Op-Code, 12-Bit-Operantenadresse,

07:28.210 --> 07:30.170
Operantenadresse M, das war hier oben angegeben.

07:30.670 --> 07:33.890
Und da hatte ich dieses einfache Programm Ihnen dargestellt, um die

07:33.890 --> 07:40.110
Fakultätsfunktion zu berechnen, also in einer sehr einfachen Art und

07:40.110 --> 07:45.050
Weise, sukzessive eine Zahl immer wieder um 1 reduziert und dann das

07:45.050 --> 07:48.030
Zwischenergebnis wieder mit dem neuen Wert multipliziert, sodass dann

07:48.030 --> 07:51.850
am Ende alle Werte von X bis 1 multipliziert sind.

07:52.750 --> 07:58.690
Wir hatten dann gesehen, dass das, das war hier, richtig, das war

07:58.690 --> 08:02.730
hier, Entschuldigung, das erste war ja hier nur die Liste, das war nur

08:02.730 --> 08:05.450
der Befehlssatz, das hier ist das Programm, das X-Fakultät berechnet

08:05.450 --> 08:10.230
und ich hatte Ihnen dann das gleiche nochmal dargestellt in einem

08:10.230 --> 08:15.170
Assembler -Programm, aber bevor ich dazu kam, habe ich Ihnen erstmal

08:15.170 --> 08:18.450
einen wichtigen Teil vorgestellt, nämlich die Adressierungsarten.

08:19.070 --> 08:22.450
Sie wissen, dass wir hier eben die Operandadressen hatten und ich

08:22.450 --> 08:24.970
hatte Ihnen dann die verschiedenen Adressierungsarten vorgestellt.

08:25.090 --> 08:26.910
Es gibt noch durchaus Varianten davon.

08:27.930 --> 08:30.350
Das Wesentliche sind hier zunächst mal diese drei auf der linken

08:30.350 --> 08:34.150
Seite, das unmittelbare, absolute oder direkte und auch die indirekte

08:34.150 --> 08:37.450
Adressierung und dann hier die indizierte, die relative und die

08:37.450 --> 08:38.610
implizite Adressierung.

08:39.110 --> 08:44.670
Auf die Art und Weise kann ich auf die Werte von Operanden zugreifen,

08:44.790 --> 08:46.770
die in einem Befehl spezifiziert werden.

08:47.350 --> 08:51.790
Entweder unmittelbar, direkt, indirekt oder indiziert oder eben

08:51.790 --> 08:52.290
relativ.

08:53.050 --> 08:54.950
Okay, das war dazu.

08:55.410 --> 08:58.230
Da waren drei Beispiele genannt worden, wie das funktioniert, die

08:58.230 --> 08:59.150
implizite Adressierung.

08:59.250 --> 09:00.450
Dann kamen die Assembler-Sprachen.

09:00.970 --> 09:04.550
Ich habe Ihnen gesagt, dass man dort eben etwas mehr Struktur hat.

09:04.630 --> 09:06.510
Man kann besser lesen, was eigentlich passiert.

09:06.610 --> 09:09.550
Das war das Beispiel nochmal mit dem Maschinenprogramm der Ex

09:09.550 --> 09:10.110
-Fakultät.

09:10.470 --> 09:14.390
Ist hier angegeben, jetzt als Assembler-Programm lesbar, nicht einfach

09:14.390 --> 09:19.210
binär notiert mit hier vorne eine Marke, dass ich weiß, wo ich mich

09:19.210 --> 09:21.370
eigentlich befinde, wenn ich irgendwo hinspringen will.

09:21.790 --> 09:24.650
Die Marken sind deutlich angegeben und die Möglichkeit über Pseudo

09:24.650 --> 09:29.610
-Befehle Variablen zu deklarieren, denen man Werte zuweist, die dann

09:29.610 --> 09:31.930
im Programm, in weiteren Programmen verwendet werden.

09:32.390 --> 09:35.890
Und das ist also sehr nah am Maschinenprogramm, aber eben etwas besser

09:35.890 --> 09:41.470
lesbar und dadurch fürs Programmieren besser geeignet als die

09:41.470 --> 09:42.970
Maschinen -Sprache.

09:43.750 --> 09:50.790
Dann kamen die demontierten Programme, auch das habe ich Ihnen letztes

09:50.790 --> 09:53.430
Mal schon kurz erzählt, die Aufteilung in die verschiedenen

09:53.430 --> 09:54.210
Sprachklassen.

09:55.090 --> 09:59.910
Und ich hatte Ihnen dann begonnen, etwas zu erzählen über funktionale

09:59.910 --> 10:01.070
und applikative Programmiersprachen.

10:01.210 --> 10:05.770
Lassen Sie mich hier wieder reingehen in die Präsentation und dann

10:05.770 --> 10:07.770
machen wir weiter.

10:08.050 --> 10:10.730
Hier hatte ich auch Ihnen schon einiges erzählt.

10:10.850 --> 10:15.010
Das war ein Beispiel für ein Programm Merge Sort, bei dem man im

10:15.010 --> 10:19.910
Prinzip rein funktional programmiert, Funktionen definiert und nicht

10:19.910 --> 10:26.490
explizit die einzelnen Anweisungen, die ausgeführt werden müssen.

10:26.890 --> 10:31.170
Eine rekursive Struktur, genau wie man ein Problem eben mathematisch

10:31.170 --> 10:33.230
formulieren kann, kann man das so auch in der Programmiersprache

10:33.230 --> 10:33.790
formulieren.

10:34.090 --> 10:37.310
Dadurch hat man Vorteile hinsichtlich der Korrektheit der Programme.

10:37.830 --> 10:42.250
Allerdings kann es eben passieren, dass man dann eventuell eine nicht

10:42.250 --> 10:48.830
-effiziente Ausführbarkeit kriegt, weil einfach die Darstellung des

10:48.830 --> 10:51.950
Problems so in diesen Gleichungen natürlich auch logische

10:51.950 --> 10:55.810
Abhängigkeiten impliziert, die nicht notwendigerweise genau auf diese

10:55.810 --> 10:58.650
Art und Weise bestehen müssen.

10:59.170 --> 11:03.670
Aber das ist ein anderes Thema, das wir in anderen Vorlesungen dann

11:03.670 --> 11:04.330
genauer eingehen.

11:04.570 --> 11:06.450
Dann gibt es die prädikativen Programmiersprachen.

11:07.370 --> 11:10.630
Prädikativ, Prädikatenlogik kennen Sie aus Grundlageninformatik 1.

11:11.450 --> 11:16.770
Und jetzt ist die Frage, was habe ich mit logischen Formeln, wie kann

11:16.770 --> 11:19.110
ich logische Formeln in Programmen ausdrücken?

11:19.650 --> 11:21.270
Beispiel für so eine Sprache ist Prolog.

11:23.050 --> 11:26.530
Hier kann man auch Dinge ausdrücken, die eigentlich nicht logische

11:26.530 --> 11:27.290
Ableitungen sind.

11:27.450 --> 11:32.150
Also ich kann sogar die Funktion Fakultät in Prolog formulieren, wobei

11:32.150 --> 11:35.250
das eigentlich nicht die klassische Anwendung ist von Prädikaten,

11:35.350 --> 11:36.270
logischen Kalkülen.

11:36.710 --> 11:37.610
Aber ich kann es machen.

11:37.950 --> 11:41.930
Und wie würde ich so ein Prolog-Programm schreiben?

11:42.410 --> 11:45.270
Ich muss in dem Fall ein Prädikat formulieren.

11:46.010 --> 11:49.450
FAK für Fakultätsfunktion mit Argumenten N und M.

11:49.990 --> 11:57.290
Dieses FAK N M bedeutet, dass dieses Prädikat FAK N M ist wahr, wenn N

11:57.290 --> 11:58.510
Fakultät gleich M ist.

11:59.410 --> 12:04.590
Das heißt also einfach, dass der zweite Parameter M ist das Ergebnis

12:04.590 --> 12:06.790
der Berechnung von N Fakultät.

12:07.410 --> 12:12.370
Und das kann ich jetzt als Programm so ausdrücken, dass ich eine Sache

12:12.370 --> 12:13.310
hier postuliere.

12:13.850 --> 12:14.830
Dieses hier ist wahr.

12:15.630 --> 12:17.730
Fakultät von 1 ist 1.

12:19.590 --> 12:26.490
Und Fakultät von N-1, F ist wahr.

12:28.090 --> 12:33.550
Oder wenn das wahr ist, wenn Fakultät von N-1, F wahr ist, dann

12:33.550 --> 12:40.010
impliziert das, dass Fakultät von N, N mal F wahr ist.

12:42.630 --> 12:47.710
Das ist offensichtlich, dass die Fakultätsfunktion, wenn also F die

12:47.710 --> 12:53.750
Fakultät von N-1 ist, dann ist N mal F Fakultät von N.

12:54.570 --> 12:58.150
Ich muss ja nur Produkte 1 bis N-1 noch multiplizieren mit N.

12:58.410 --> 13:02.270
Also diese beiden logischen Formen, diese beiden Prädikate, die hier

13:02.270 --> 13:06.110
so formuliert sind, definieren die Funktion N Fakultät.

13:07.030 --> 13:07.990
Alles, was ich brauche.

13:08.470 --> 13:09.910
Sehr elegante Art, das aufzuschreiben.

13:10.030 --> 13:13.170
Aber jetzt stellen Sie vor, das hier muss jetzt durch ein internes

13:13.170 --> 13:17.610
System umgesetzt werden in entsprechende Abläufe im Rechner.

13:18.310 --> 13:20.570
Dazu müssen Sie das alles auflösen, zurückführen auf die

13:20.570 --> 13:25.610
entsprechenden, also entsprechend diesen Regeln, das alles auflösen.

13:25.670 --> 13:27.810
Sie müssen also dann hier entsprechend, wenn Sie wissen wollen, ob

13:27.810 --> 13:31.510
Fakt N-1, F erfüllt ist, müssen Sie immer weiter runtergehen, bis Sie

13:31.510 --> 13:33.730
dann tatsächlich den richtigen Wert dort rauskriegen.

13:34.410 --> 13:39.830
Und wenn Sie jetzt 6 Fakultät berechnen wollen, dann fragen Sie im

13:39.830 --> 13:44.590
Prinzip, welche Zahl F erfüllt das Prädikat Fak 6 F.

13:45.830 --> 13:49.690
Und das ist halt, basiert dann alles im Prinzip hier.

13:50.330 --> 13:54.290
Am Ende geht das zurück bis auf die Aktion, die hier am Anfang steht,

13:54.750 --> 13:57.530
dass die Fakultätsfunktion von 1 gleich 1 ist.

13:58.090 --> 14:02.490
Alles andere ergibt sich dann über das zweite Aktion, das das.

14:02.970 --> 14:06.690
Also das ist eine logische Programmiersprache, nicht geeignet für

14:06.690 --> 14:08.470
effiziente Berechnungen, überhaupt nicht.

14:09.130 --> 14:12.430
Führt zu sehr aufwändigen Berechnungen, sehr ineffiziente

14:12.430 --> 14:12.990
Berechnungen.

14:13.550 --> 14:17.710
Aber ich kann logische Zusammenhänge dort sehr deutlich, sehr gut

14:17.710 --> 14:18.210
ausdrücken.

14:18.630 --> 14:20.730
In der Wissensverarbeitung braucht man solche Dinge.

14:22.090 --> 14:24.310
Allerdings muss man dann natürlich sehen, dass man das irgendwie auch

14:24.310 --> 14:25.550
effizienter ausführen kann.

14:25.550 --> 14:29.150
Gibt durchaus Transformationen von solchen Programmen auch in

14:29.150 --> 14:32.030
effiziente Form und dann ist es besser zu machen.

14:32.170 --> 14:36.210
Aber zunächst mal so eine kompakte Darstellung halt gut für die

14:36.210 --> 14:39.750
Problemnähe, aber schlecht für die Ausführung im Rechner.

14:40.350 --> 14:41.470
Das muss dann auch umgesetzt werden.

14:41.550 --> 14:43.390
Dann kennen Sie objektorientierte Programmiersprachen.

14:44.110 --> 14:47.890
Das Wesentliche sind hier die Objekte und entsprechende Methoden und

14:47.890 --> 14:49.170
Eigenschaften der Objekte.

14:49.670 --> 14:50.510
Das wissen Sie alles.

14:50.670 --> 14:53.870
Die wesentlichen Prinzipien, die man hier hat, bei objektorientierten

14:53.870 --> 14:56.430
Programmiersprachen ist, dass ich einerseits ein Geheimnisprinzip

14:56.430 --> 14:56.810
habe.

14:57.130 --> 15:00.690
Das heißt, der Zugriff auf die Objekte geht nur über definierte

15:00.690 --> 15:01.290
Methoden.

15:02.050 --> 15:05.070
Ich kann also nur, wenn ich eine Methode zur Verfügung habe, um auf

15:05.070 --> 15:08.390
eine entsprechende Eigenschaft eines Objekts zuzugreifen, kann ich die

15:08.390 --> 15:08.770
anwenden.

15:08.870 --> 15:11.510
Ich kann ansonsten nicht einfach auf Teile zugreifen.

15:11.610 --> 15:13.170
Ich brauche entsprechend die Methoden.

15:13.190 --> 15:14.370
Ich habe ein Vererbungsprinzip.

15:15.010 --> 15:17.470
Eigenschaften von einer Klasse an Unterklassen weitergeben.

15:17.910 --> 15:20.550
Wenn ich also weiß, dass ein geometrisches Objekt eine Fläche hat,

15:20.550 --> 15:27.610
dann kann ich eben auch über irgendwelche Dreiecke, Vierecke, Kreise

15:27.610 --> 15:32.450
Flächen definieren, aber sie werden entsprechend dann weiter

15:32.450 --> 15:33.130
verfeinert.

15:33.270 --> 15:35.170
Das Vererbungsprinzip kennen Sie, da brauche ich nicht genau darauf

15:35.170 --> 15:35.630
einzugehen.

15:35.690 --> 15:37.410
Dynamische Bindung ebenso wichtig.

15:38.210 --> 15:43.610
Sie können eine Funktion Fläche, ich sag mal einfach hier Fläche von

15:43.610 --> 15:45.570
geometrisches Objekt.

15:46.550 --> 15:49.010
Stellen Sie sich vor, Sie haben eine solche Variable, geometrisches

15:49.010 --> 15:55.410
Objekt und dann würde entsprechend, ob das jetzt ein Dreieck ist oder

15:55.410 --> 16:00.170
ein Kreis oder ein Quadrat, würde entsprechend zur Laufzeit die

16:00.170 --> 16:04.930
richtige Methode für die Berechnung dieser Fläche halt entsprechend

16:04.930 --> 16:06.650
dazu geladen werden.

16:06.730 --> 16:09.830
Das heißt, die Zuordnung von Methoden zu Objekten erfolgt dynamisch

16:09.830 --> 16:10.570
zur Laufzeit.

16:11.070 --> 16:13.890
Welche Methode das F dann tatsächlich ist, wird entsprechend dem

16:13.890 --> 16:17.350
konkreten Objekt, das dort drin ist, ob das jetzt Dreiecke sind oder

16:17.350 --> 16:21.230
Kreise oder Quadrate oder Rechtecke, entsprechend ausgewählt.

16:21.290 --> 16:21.970
Sie kennen das.

16:22.270 --> 16:25.170
Das sind die drei wesentlichen Konzepte der objektorientierten

16:25.170 --> 16:25.770
Programmierung.

16:26.230 --> 16:29.390
Alles andere ist natürlich auch da mit drin, aber das sind so die

16:29.390 --> 16:31.750
wesentlichen Unterscheidungsmerkmale zu anderen Programmiersprachen.

16:33.030 --> 16:34.430
Sie schütteln den Kopf da oben.

16:34.490 --> 16:38.630
Ich weiß nicht, warum Sie den Kopf schütteln, aber das ist halt sehr

16:38.630 --> 16:42.810
stark reduziert auf so einige wesentliche Konzepte bei der

16:42.810 --> 16:43.830
objektorientierten Programmierung.

16:43.950 --> 16:46.970
Sie kennen Java, eine Vielzahl anderer Sprachen.

16:47.910 --> 16:54.510
So die klassische Sprache für Objektorientierung ist Smalltalk 80.

16:54.790 --> 16:57.330
Das ist also eine sehr streng objektorientierte Sprache.

16:57.750 --> 17:00.810
Java ist nicht ganz so streng objektorientiert, aber es hat sich halt

17:00.810 --> 17:01.690
sehr stark verbreitet.

17:02.190 --> 17:06.550
C++, auch objektorientiert, aber hat auch sehr viele prozedurale

17:06.550 --> 17:10.250
Elemente da drin und vor allen Dingen ist die Sprache C++ dermaßen

17:10.250 --> 17:14.810
komplex, dass es dort schon manchmal schwierig ist, Software zu

17:14.810 --> 17:19.950
erzeugen, bei der Sie, also wenn Sie hier so lange C++-Programme

17:19.950 --> 17:23.750
haben, da am Ende ein Zertifikat drauf zu machen und zu sagen, das

17:23.750 --> 17:27.410
Ding ist korrekt, ist eine ganz schwierige Aufgabe, weil Sie so viele

17:27.410 --> 17:31.770
Möglichkeiten haben, sehr komplizierte Beziehungen aufzubauen in C++.

17:32.170 --> 17:33.650
Das ist in Java wesentlich einfacher.

17:35.370 --> 17:38.190
Grundsätzlich unterstützen objektorientierte Sprachen den

17:38.190 --> 17:41.410
systematischen Entwurf korrekter, effizienter und wiederverwendbarer

17:41.410 --> 17:48.510
Programme und deswegen, je einfacher eine Sprache ist, desto klarer

17:48.510 --> 17:51.510
können Sie etwas formulieren und wenn Sie sehr viele Möglichkeiten

17:51.510 --> 17:55.390
haben, Ausdrucksmöglichkeiten in einer Sprache, wie zum Beispiel in

17:55.390 --> 17:58.630
C++, dann haben Sie da natürlich auch viele Fehlerquellen.

17:59.070 --> 18:02.830
Das Wesentliche ist immer, wenn irgendjemand anderes als der

18:02.830 --> 18:06.970
ursprüngliche Autor auf so ein Programm raufguckt, muss der in der

18:06.970 --> 18:09.010
Lage sein zu verstehen, was dort geschrieben ist.

18:09.850 --> 18:14.450
Und es hat mal Wettbewerbe gegeben, wer das kleinste C-Programm

18:14.450 --> 18:17.610
schreibt für irgendeine besondere Funktion und da kommen kryptische

18:17.610 --> 18:20.330
Programme raus, die eigentlich niemand verstehen kann auf den ersten

18:20.330 --> 18:20.610
Blick.

18:20.990 --> 18:24.370
Das ist völlig widersinnig, solche Aufgaben zu stellen.

18:24.730 --> 18:27.210
Das kürzeste Programm, das irgendeine Funktion darstellt.

18:27.670 --> 18:31.150
Das Wesentliche ist, dass Programme lesbar, verständlich sind und

18:31.150 --> 18:32.270
wiederverwendet werden können.

18:32.590 --> 18:35.730
Ansonsten ist ein Programm, das einmal geschrieben wurde, wenn es

18:35.730 --> 18:38.650
nicht von anderen gelesen werden kann, völlig wertlos.

18:38.810 --> 18:41.650
Deswegen wissen Sie, Programme, die nicht dokumentiert sind, die keine

18:41.650 --> 18:47.710
Erklärung haben, sind im Prinzip für viele Zwecke wertlos, weil sie

18:47.710 --> 18:49.090
keine Nachhaltigkeit haben.

18:49.790 --> 18:52.050
Werden nicht verändert, die werden neu geschrieben und deswegen ist

18:52.050 --> 18:53.510
das eine verschwendete Investition.

18:54.730 --> 18:59.870
Also man schreibt immer so, dass man möglichst korrekt, effizient und

18:59.870 --> 19:01.510
wiederverwendbare Programme erzeugt.

19:01.510 --> 19:04.330
Das heißt, sie müssen lesbar sein, gut dokumentiert sein und ähnlich.

19:06.050 --> 19:10.990
Das ganz kurze Querschnitt zu Programmen, gehe heute sehr schnell vor,

19:11.210 --> 19:14.010
schneller, noch schneller als sonst, tut mir leid, geht nicht anders.

19:14.930 --> 19:17.650
Ich muss ganz kurz ansprechen, den Aspekt der Sprachübersetzung.

19:18.450 --> 19:22.230
Wenn ich diese verschiedenen Ebenen habe, der Programmierung, muss ich

19:22.230 --> 19:25.150
von problemorientiert runterkommen können auf Maschinensprache.

19:25.570 --> 19:27.910
Und die erste Ebene, die ich angucken muss, da kommt schon der erste,

19:28.070 --> 19:34.430
der sagt, bitte etwas langsamer, geht das durchaus, dann muss ich mir

19:34.430 --> 19:38.190
angucken, wie wird eigentlich ein Assembler-Programm übersetzt in ein

19:38.190 --> 19:38.930
Maschinenprogramm.

19:39.110 --> 19:39.950
Das ist doch ganz einfach.

19:40.950 --> 19:47.650
Also ein Assembler-Programm, wenn da irgendwie steht, LOAD M, das ist

19:47.650 --> 19:50.710
doch praktisch genau der Maschinenbefehl.

19:51.330 --> 19:52.090
Das ist doch ganz einfach.

19:52.250 --> 19:55.070
Also das ist nicht weiter schwierig, muss zunächst mal das erkennen,

19:55.970 --> 19:59.930
muss den Text analysieren und erkennen, dass hier LOAD steht und

19:59.930 --> 20:00.570
dahinter ein M.

20:01.390 --> 20:02.610
Das ist die Syntax-Analyse.

20:02.770 --> 20:05.030
Was Syntax ist, wissen Sie, Grammatiken und ähnliches haben Sie ja

20:05.030 --> 20:05.690
alles mal kennengelernt.

20:06.170 --> 20:08.050
Dann muss ich Pseudo-Befehle ausführen.

20:08.310 --> 20:14.050
Pseudo-Befehle, das war sowas wie X, Beispiel 17 oder so.

20:14.750 --> 20:16.490
Das sind Pseudo-Befehle.

20:17.230 --> 20:21.010
Das kommt dann irgendwann hier vielleicht nicht M vor, sondern kommt

20:21.010 --> 20:22.810
vielleicht irgendwann hier im Befehl.

20:22.970 --> 20:23.450
Da steht X.

20:24.110 --> 20:26.910
Dann weiß ich, aha, da gibt es eine Rolle.

20:27.570 --> 20:28.890
Also Pseudo-Befehle ausführen.

20:29.390 --> 20:31.270
Das Maschinenprogramm kennt keine Pseudo-Befehle.

20:31.870 --> 20:35.750
Dann muss ich Konstanten in Binärdarstellung konvertieren.

20:35.930 --> 20:38.410
Auch das ist klar, wenn hier jetzt steht 17, muss ich entsprechend die

20:38.410 --> 20:39.070
Binärdarstellung geben.

20:39.690 --> 20:43.210
Ich muss den Maschinen-Code erzeugen für den Operationsteil des

20:43.210 --> 20:43.730
Befehls.

20:43.790 --> 20:46.090
Ich muss LOAD umsetzen, entsprechend den Code.

20:46.830 --> 20:47.650
Wissen, wie das geht.

20:47.790 --> 20:49.190
So und so viele Bits dafür zur Verfügung.

20:49.650 --> 20:50.710
Es gibt eine Tabelle, in der man das macht.

20:51.450 --> 20:54.770
Ich muss Adressen berechnen, die durch Symbole oder Ausdrücke gegeben

20:54.770 --> 20:55.050
sind.

20:55.490 --> 21:00.070
Also wenn hier X steht, muss da entsprechend die 17 drin stehen.

21:00.250 --> 21:01.270
Ich muss also das ersetzen.

21:01.690 --> 21:03.490
Das ist aber auch die Ausführung der Pseudo-Befehle.

21:03.570 --> 21:04.510
Hängt auch damit schon zusammen.

21:05.170 --> 21:06.670
Ich muss ein Protokoll machen.

21:07.190 --> 21:11.450
Über einen Assemblierungslauf, also eine Übersetzung, möchten sie

21:11.450 --> 21:15.250
gerne als derjenige, der die Assemblierung angestoßen hat, ein

21:15.250 --> 21:16.330
Ergebnis haben.

21:17.130 --> 21:20.050
Und in diesem Bericht muss drinstehen, insbesondere, ob es dort Fehler

21:20.050 --> 21:20.590
gegeben hat.

21:21.210 --> 21:24.190
Und es muss da stehen, als Protokoll der Analyse dieses Assembler

21:24.190 --> 21:25.610
-Programm.

21:26.790 --> 21:28.750
Ich muss natürlich die Adressrechnungen machen.

21:30.070 --> 21:32.010
Was heißt denn dieses 17 hier überhaupt?

21:32.290 --> 21:36.770
Wenn das eine relative Adresse ist, bezogen auf den Anfang meines

21:36.770 --> 21:41.570
Programms, dann muss ich natürlich relativ das noch umsetzen in das

21:41.570 --> 21:44.870
Maschinenprogramm an der entsprechenden Basisadresse.

21:45.030 --> 21:49.450
Dann muss ich hier überlegen, ist das richtig, das 17 hinzuschreiben.

21:49.610 --> 21:52.430
Das wäre also dann relativ zum Programmanfang.

21:52.470 --> 21:53.770
Da hätte ich nur relative Adressen.

21:53.950 --> 21:58.890
Oder wenn ich weiß, wo das Programm im Hauptspeicher stehen würde,

21:59.530 --> 22:02.130
dann werde ich gleich die expliziten Adressen reinschreiben.

22:02.130 --> 22:05.590
Also die Adressen im Hauptspeicher, was man normalerweise nicht macht,

22:05.790 --> 22:11.490
sondern diese endgültige Umsetzung von relativen Adressen in

22:11.490 --> 22:14.930
tatsächliche physikalische Adressen, das wird erst später durch den

22:14.930 --> 22:16.690
Binder, den Lader gemacht.

22:16.750 --> 22:18.170
Was ist ein Binder und ein Lader?

22:19.030 --> 22:23.750
Ein Programm kann bestehen aus mehreren Teilprogrammen und die müssen

22:23.750 --> 22:27.310
zusammengebunden werden zu einem großen Programm, das dann tatsächlich

22:27.310 --> 22:31.050
in den Rechner geschoben wird und dort ausgeführt, in der CPU.

22:31.050 --> 22:35.790
Dieses Binden, das Zusammenbinden von Teilprogrammen zu einem größeren

22:35.790 --> 22:38.990
Programmstück und dann, wenn ich also Unterprogramme habe und

22:38.990 --> 22:41.970
ähnliches, müssen die an entsprechenden Stellen eingebunden werden und

22:41.970 --> 22:47.050
dann kommt hier die Abbildung irgendwann oder die Aufnahme in den

22:47.050 --> 22:47.650
Hauptspeicher.

22:47.830 --> 22:52.270
Dann weiß ich, dadurch dass das Programm geladen wird, weiß ich,

22:52.870 --> 22:55.370
welche Adresse ein Programm steht und dann kann ich die relativen

22:55.370 --> 22:59.350
Adressen umführen oder überführen in absolute Adressen.

22:59.670 --> 23:02.150
Kann aber auch sein, dass ich absolute Adressen schon von vornherein

23:02.150 --> 23:04.190
drin habe, die müssen entsprechend dann auch dort drin stehen.

23:05.050 --> 23:08.090
Also, was muss hier also gemacht werden?

23:08.170 --> 23:11.770
Ich habe mein Programm und jetzt habe ich in meinem Programm hier

23:11.770 --> 23:15.710
irgendeinen Befehl und da steht ein Sprung drin, das sprengt irgendwo

23:15.710 --> 23:18.210
hin, da ist irgendeine Marke in meinem Befehl.

23:18.610 --> 23:20.250
Diese Marke taucht hier vorne auf.

23:21.670 --> 23:24.910
Aber wenn ich jetzt von oben nach unten hier durchlese, komme ich zu

23:24.910 --> 23:30.230
dieser Marke dorthin und es steht jetzt GOTO irgendwie label.

23:32.110 --> 23:34.410
GOTO meinetwegen L, L für label.

23:34.970 --> 23:36.750
Ich weiß auch gar nicht, wo das ist, weil ich da noch gar nicht

23:36.750 --> 23:37.290
gewesen bin.

23:37.370 --> 23:40.230
Ich habe ja diesen Befehl noch gar nicht gesehen, beim Durchlaufen von

23:40.230 --> 23:40.750
oben nach unten.

23:41.430 --> 23:45.790
Das heißt, ich habe manchmal etwas an Problemen.

23:45.810 --> 23:47.730
Ich habe sogenannte Vorwärtsreferenzen.

23:48.690 --> 23:52.190
Ich mache eine Referenz an dieser Stelle hier, dort oben, auf eine

23:52.190 --> 23:53.450
Marke, die steht erst hier unten.

23:54.650 --> 23:58.630
Das heißt, ich kann die Adresse, die dort eigentlich stehen müsste, im

23:58.630 --> 24:02.530
Maschinenprogramm, dort erst reinschreiben, nachdem ich bis hier unten

24:02.530 --> 24:06.430
durchgelesen habe und erst dann weiß ich, was hier oben stehen müsste.

24:06.870 --> 24:10.350
Deswegen kann ich gar nicht in einem Durchlauf von oben nach unten

24:10.350 --> 24:13.930
alle symbolischen Adressen durch echte Adressen ersetzen, alle Werte

24:13.930 --> 24:15.170
so entsprechend umsetzen.

24:15.230 --> 24:20.230
Ich muss da noch erstmal eine Tabelle aufbauen und in der Tabelle muss

24:20.230 --> 24:22.970
dann eben stehen, ich habe hier eine Marke L und dann muss ich

24:22.970 --> 24:25.750
irgendwann, wenn ich da hinkomme, den konkreten Wert eintragen.

24:26.450 --> 24:29.590
Den Wert irgendwie 17 oder 587.

24:30.830 --> 24:35.330
Und im zweiten Lauf, wenn ich diese Tabelle gebaut habe, kann ich dann

24:35.330 --> 24:38.670
die Werte aus dieser Tabelle, also was immer hier alles drinsteht,

24:38.750 --> 24:43.370
kann ich dann nehmen und das dann konkret übersetzen in die konkreten

24:43.370 --> 24:45.090
Adressen in meinem Programm.

24:45.850 --> 24:49.590
Also erstmal baue ich eine Symboltabelle auf, in die ich die ganzen

24:49.590 --> 24:52.270
Vorwärtsreferenzen erst mal eintrage und sobald ich an der richtigen

24:52.270 --> 24:55.410
Stelle angelangt bin und weiß, auf welchen konkreten Wert sich das

24:55.410 --> 24:58.050
bezieht, dann kann ich das entsprechend umsetzen.

24:58.730 --> 25:02.290
Und im zweiten Durchlauf kann ich dann alles ersetzen und kann das

25:02.290 --> 25:05.870
Programm entsprechend aufschreiben als Maschinenprogramm.

25:05.970 --> 25:09.270
Und das ist hier also so eine Symboltabelle, also zum Beispiel hier

25:09.270 --> 25:12.230
diese Symbole, die alle auftreten, werden mit der Tabelle

25:12.230 --> 25:16.710
reingeschrieben, verwende ich dann, um die Werte hier anschließend

25:16.710 --> 25:20.050
reinzuschreiben, dann kann ich im zweiten Lauf greifen und kann das

25:20.050 --> 25:20.950
Maschinenprogramm erzeugen.

25:22.270 --> 25:25.450
Und dann gibt es noch weitere Angaben, wie Sachen, dass meinetwegen

25:25.450 --> 25:28.390
Adresswert relativ oder absolut ist und ähnliche Dinge, was man noch

25:28.390 --> 25:29.310
an Eigenschaften braucht.

25:29.810 --> 25:32.910
Also das Wesentliche ist, dass Sie sehen, wir haben diese beiden

25:32.910 --> 25:37.590
Läufe, der erste Lauf erzeugt eine Symboltabelle, der zweite Lauf

25:37.590 --> 25:43.610
greift darauf zu und produziert dann im zweiten Pass, im Durchlauf,

25:44.190 --> 25:45.490
das Maschinenprogramm.

25:45.930 --> 25:50.550
Außerdem wird ein Protokoll erzeugt und im Protokoll stehen dann halt

25:50.550 --> 25:54.510
die ganzen Ergebnisse meiner Assemblierung drin, mit Kommentaren dazu

25:54.510 --> 25:57.410
und Angaben, was dort alles so gemacht ist, eine Nummerierung der

25:57.410 --> 26:00.050
Einzelnen, da steht, was dort alles gemacht wird.

26:00.670 --> 26:03.790
Und der Protokollpass erstellt also das Protokoll, gibt dort

26:03.790 --> 26:07.510
Fehlermeldungen an und macht schöne Zeilennummern rein und ähnliche

26:07.510 --> 26:07.710
Dinge.

26:07.890 --> 26:10.210
Zeilennummern stehen natürlich nicht im Maschinenprogramm, aber

26:10.210 --> 26:12.430
inhaltlich im Protokoll.

26:12.650 --> 26:16.830
Es stehen dort Kreuzreferenztabelle, wird angegeben, die Zeilennummer

26:16.830 --> 26:18.490
des Vorkommens jedes Symbols.

26:18.650 --> 26:21.890
Also in der Symboltabelle ist hier irgendein Wert angegeben, irgendein

26:21.890 --> 26:22.410
Wert X.

26:22.770 --> 26:26.430
Es steht ja auch da in dem Protokoll nachher, an welchen Stellen

26:26.430 --> 26:29.750
dieser Wert X überall im Programm auftaucht, also in dieser

26:29.750 --> 26:30.310
Kreuzreferenz.

26:30.850 --> 26:35.210
Und dann kann es noch weitere Dinge geben, für Sonderfunktionen, für

26:35.210 --> 26:36.370
Codeoptimierung, ähnliche Dinge.

26:36.690 --> 26:37.790
Das ist hier jetzt aber nicht angesprochen.

26:38.210 --> 26:42.450
Also Assemblierung, zwei Durchläufe wegen der Vorwärtsreferenz.

26:43.330 --> 26:48.570
Dann kommen wir zum nächsten Schritt, höhere Ebene über Assembler.

26:49.090 --> 26:51.150
Da geht es über Maschinensprache natürlich auch.

26:51.710 --> 26:54.230
Frage, wie kann ich Programm interpretieren?

26:54.330 --> 26:57.430
Ich habe hier mein Programm und gehe hier von oben nach unten durch

26:57.430 --> 27:01.510
und jeder Befehl soll direkt interpretiert werden im Rechner und soll

27:01.510 --> 27:02.230
dort ausgeführt werden.

27:02.850 --> 27:05.490
Also hier wird nicht das gesamte Quellprogramm übersetzt

27:05.490 --> 27:10.250
Maschinensprache, sondern jede Anweisung wird unmittelbar ausgeführt.

27:10.510 --> 27:11.790
Das macht man bei einigen Sprachen.

27:11.910 --> 27:15.050
Typische Beispiele sind BASIC, LISP, HOLOC, APL.

27:15.190 --> 27:15.950
In denen kann man das machen.

27:16.790 --> 27:18.670
Das macht natürlich nur Sinn zur Entwurfszeit.

27:19.230 --> 27:21.950
Wenn Sie zur Ausführungszeit immer wieder ein Programm so

27:21.950 --> 27:26.050
interpretieren müssten, wäre das furchtbar, weil insbesondere dann

27:26.050 --> 27:32.270
Nachteile, wenn Sie irgendeine Schleife haben, müssten Sie bei jedem

27:32.270 --> 27:36.130
Durchlauf die Befehle der Schleife neu interpretieren.

27:36.490 --> 27:37.650
Das macht natürlich auch keinen Sinn.

27:38.190 --> 27:40.930
Für das Debugging eines Programms, für das Überprüfen, ob das, was Sie

27:40.930 --> 27:44.390
geschrieben haben, richtig ist, ist es durchaus sehr hilfreich, solch

27:44.390 --> 27:47.710
eine Interpretation zur Verfügung zu haben.

27:48.090 --> 27:51.190
Dann sehen Sie sofort, ob eine Anweisung, die Sie geschrieben haben,

27:51.290 --> 27:53.990
etwas negativ gewesen ist.

27:55.150 --> 27:57.170
Und deswegen kann man beides kombinieren.

27:57.290 --> 27:59.990
Zunächst interpretiert man, dann übersetzt man und dann hat man ein

27:59.990 --> 28:03.790
effizientes Programm und kann das dann immer wieder ausführen.

28:04.010 --> 28:06.550
Also das ist das, was man normalerweise dann machen kann.

28:06.850 --> 28:09.390
Wobei man dann natürlich, wenn man das so macht, wenn man nur mit

28:09.390 --> 28:12.030
einem Interpreter arbeitet, hat man etwas Schwierigkeiten, Aussagen zu

28:12.030 --> 28:13.650
machen zur Leistungsfähigkeit des Programms.

28:13.750 --> 28:17.150
Aber das kann man ja später noch machen, dann mit der ausgeführten,

28:17.210 --> 28:18.830
mit der übersetzten Version.

28:19.250 --> 28:23.650
Das ist der Interpreter und das, was wir normalerweise einsetzen, ist

28:23.650 --> 28:27.670
ein Übersetzer, ein Kompilierer oder Compiler, der halt das Programm

28:27.670 --> 28:31.710
einer höheren Programmiersprache übersetzt, anschließend ausführt.

28:32.670 --> 28:35.490
Programm einer höheren Programmiersprache heißt also, ich muss hier

28:35.490 --> 28:37.810
einiges erstmal machen.

28:38.030 --> 28:41.170
Ich kann natürlich das Programm, wenn ich hier mein Programm habe, das

28:41.170 --> 28:45.530
wird übersetzt in ein Maschinenprogramm und das kann jetzt konkret

28:45.530 --> 28:46.350
ausgeführt werden.

28:46.450 --> 28:51.030
Das ist also mein Maschinenprogramm, das ist mein Quellprogramm und

28:51.030 --> 28:52.990
das kann immer wieder ausgeführt werden.

28:53.410 --> 28:56.190
Aber wenn ich mir hier irgendwelche Anweisungen anschaue, das wird

28:56.190 --> 28:59.350
ausgeführt im Rechner und da treibt irgendwo ein Fehler auf.

28:59.910 --> 29:03.090
Ist die Frage, an welcher Stelle tauchen oder sind denn dann die

29:03.090 --> 29:06.410
Quellen für diese Fehler im Originalprogramm zu suchen?

29:07.430 --> 29:10.130
Wie wird dann eigentlich so ein Programm tatsächlich übersetzt?

29:10.490 --> 29:13.730
Also Fehlererkennung und Programmtest ist ein bisschen schwieriger,

29:14.310 --> 29:20.390
weil das übersetzte Programm rechnerspezifisch sein kann und deswegen,

29:20.710 --> 29:25.950
es gibt dafür auch entsprechende Werkzeuge, um eine Rückmeldung zu

29:25.950 --> 29:31.230
bekommen, wie sich Fehler konkret auf Quelltext oder aus

29:31.230 --> 29:35.350
Quelltextstücken zusammensetzen.

29:35.950 --> 29:40.830
Aber das erfordert also extra Debugger-Funktionalität.

29:41.710 --> 29:45.410
Beim Kompilieren habe ich normalerweise mehrere verschiedene Schritte.

29:46.190 --> 29:49.270
Das erste ist die lexikalische Analyse.

29:49.830 --> 29:53.210
Das heißt, ich muss erstmal erkennen, dass das ein Programm ist.

29:53.750 --> 29:54.670
Erinnern Sie sich?

29:54.710 --> 29:56.650
Formale Modelle der Informatik.

29:57.310 --> 30:00.530
Wesentliche Frage war, was sind die formalen Modelle, um

30:00.530 --> 30:02.310
Programmiersprachen zu beschreiben?

30:02.850 --> 30:05.050
Dazu muss ich zunächst mal die Bestandteile erkennen.

30:05.750 --> 30:12.990
Also wenn da steht, meinetwegen ein If oder hier eine Klammer auf,

30:13.130 --> 30:14.010
irgendwann Klammer zu.

30:14.370 --> 30:17.310
Solche Teile müssen erstmal erkannt werden als wesentliche

30:17.310 --> 30:19.290
Bestandteile einer Programmiersprache.

30:19.410 --> 30:20.770
Das ist die lexikalische Analyse.

30:20.870 --> 30:22.870
Da habe ich eine Folge von Token, Sie kriegen gleich ein Beispiel

30:22.870 --> 30:23.190
dazu.

30:24.110 --> 30:26.770
Syntaktische Analyse ist das, was wir genannt haben, das Wortproblem.

30:26.950 --> 30:32.070
Bei Grammatiken ist das Programm, das dort steht, ein gültiges Wort

30:32.070 --> 30:33.270
der Programmiersprache.

30:33.390 --> 30:34.350
Also ein gültiges Programm.

30:34.730 --> 30:36.450
Entspricht das den Regeln der Grammatik?

30:36.910 --> 30:40.270
Das heißt, hier muss ich den entsprechenden Ableitungsbaum erzeugen,

30:40.370 --> 30:42.670
der zu diesem Programm gehört.

30:43.330 --> 30:48.210
Aus dem Ableitungsbaum kann ich dann über eine semantische Analyse,

30:48.230 --> 30:51.510
also was bedeutet das alles, entsprechend einen Code generieren in

30:51.510 --> 30:55.710
Assembler oder Maschinensprache oder halt dem Zielprogramm, das ich

30:55.710 --> 30:56.410
hier haben möchte.

30:57.190 --> 30:59.570
Dann kann dahinter noch eine Code-Optimierung kommen.

31:00.530 --> 31:04.770
Also zum Beispiel, wenn Sie eine Schleife in Ihrem Programm haben,

31:04.870 --> 31:07.150
hier ist ein Stück, das soll immer wieder ausgeführt werden.

31:07.790 --> 31:11.950
Und Sie hätten hier einen Befehl, der immer wieder ausgeführt wird,

31:12.010 --> 31:13.150
der aber immer das gleiche macht.

31:13.990 --> 31:18.150
Dann wäre es sinnvoller, so etwas nach oben zu ziehen, einmal den

31:18.150 --> 31:21.370
Befehl oben drüber auszuführen und das Ergebnis dann entsprechend

31:21.370 --> 31:22.030
umzuverwenden.

31:22.630 --> 31:24.950
Solche Dinge gehören mit zur Code-Optimierung.

31:25.390 --> 31:27.870
Bei der Code-Optimierung wird also die Reihenfolge von Befehlen

31:27.870 --> 31:28.390
verändert.

31:28.930 --> 31:32.170
Es werden eventuell Ausdrücke, die immer wieder ausgewertet werden

31:32.170 --> 31:35.850
müssen, hier nur einmal vor der Schleife ausgewertet und dann unten

31:35.850 --> 31:36.970
nur eine Variable verwendet.

31:37.410 --> 31:40.630
Das ist also ein wichtiger Punkt, wobei man auf eine Sache aufpassen

31:40.630 --> 31:40.870
muss.

31:40.950 --> 31:44.890
Sie erinnern sich, dass wir bei dem Thema Gleitpunktzahlen gesagt

31:44.890 --> 31:49.430
haben, bei Gleitpunktoperationen ist es wichtig zu wissen, in welcher

31:49.430 --> 31:52.210
Reihenfolge die Operationen ausgeführt werden, weil

31:52.210 --> 31:55.550
Gleitpunktarithmetik nicht associativ ist, nicht notwendigerweise.

31:56.390 --> 32:00.130
Wenn auf einmal die Code-Optimierung die Reihenfolge von Anweisungen

32:00.130 --> 32:04.790
verändert, kann es sein, dass das Auswirkungen hat auf die Genauigkeit

32:04.790 --> 32:05.690
ihres Programms.

32:06.410 --> 32:08.650
Deswegen gibt es immer die Möglichkeit zu sagen, ich schalte Code

32:08.650 --> 32:12.790
-Optimierung aus, ich möchte, dass genau das so ausgeführt wird, wie

32:12.790 --> 32:17.610
ich das in meinem Quellprogramm hier oben formuliert habe.

32:18.370 --> 32:19.630
Also das sind so wichtige Dinge.

32:19.750 --> 32:23.610
Code-Optimierung kann zu Problemen führen bei Genauigkeit von

32:23.610 --> 32:24.630
Ergebnissen.

32:25.950 --> 32:28.450
Entsprechend diesem Problem, die ich Ihnen genannt hatte, mit der

32:30.710 --> 32:32.450
Ausführungsreihenfolge von arithmetischen Operationen.

32:32.510 --> 32:37.430
Wir hatten das Beispiel da eben dort riesige Fehler auftreten können.

32:38.810 --> 32:40.490
Okay, das zu diesen verschiedenen Schritten.

32:40.590 --> 32:42.730
Jetzt ganz kurz zu diesen verschiedenen Schritten, die hier stehen.

32:42.990 --> 32:47.990
Die lexikalische Analyse, das ist manchmal auch der Scanner, lexical

32:47.990 --> 32:48.430
analysis.

32:49.170 --> 32:53.750
Hier geht es darum, die ganzen Namen in einem Programm entsprechend zu

32:53.750 --> 32:58.350
erkennen, Grundsymbole zu erkennen, Zahlen zu erkennen, Kommentare zu

32:58.350 --> 32:58.950
ignorieren.

32:59.390 --> 33:04.050
Beispiel ist hier, Sie haben ein Programmstatement, if x kleiner 1,5,

33:04.130 --> 33:07.710
wenn irgendwas end in einer anderen Sprache geschrieben als Java,

33:07.910 --> 33:12.250
sondern irgendwas Algol oder Modular oder was immer ähnlichen.

33:13.130 --> 33:14.670
Also eine einfache Formelsprache.

33:15.310 --> 33:19.550
Da muss sowas erkannt werden, muss also stehen hier, if ist natürlich

33:19.550 --> 33:24.810
ein Element der Sprache, dass x ist ein Name, 1,5 ist eine reelle

33:24.810 --> 33:29.690
Zahl, wenn ist ein Element der Sprache und dann steht hier Name gleich

33:29.690 --> 33:30.990
Name plus Name.

33:31.930 --> 33:34.910
Das heißt, bei der lexikalischen Analyse werden die einzelnen Elemente

33:34.910 --> 33:40.310
überführt in eigentlich ihre syntaktischen Elemente, die Platzhalter,

33:40.730 --> 33:43.770
die ich dann brauche, um zu erkennen, ob das ein gültiges Wort der

33:43.770 --> 33:44.350
Sprache ist.

33:44.790 --> 33:47.230
Ein gültiges Wort der Sprache heißt, ich mache ein Passing.

33:47.610 --> 33:52.050
Bei dem Beispiel, hier if Name kleiner reelle Zahl, wenn Name gleich

33:52.050 --> 33:55.610
Name plus Name, brauche ich also entsprechend einen Ableitungsbaum,

33:55.710 --> 34:00.050
den erzeuge ich, bei der so aussehen müsste, dass eben hier aus einer

34:00.050 --> 34:04.810
Anweisung, if-Anweisung gemacht wird und dann entsprechend if Name

34:04.810 --> 34:15.670
kleiner reelle Zahl, wenn Name gleich Name plus Name.

34:24.300 --> 34:28.500
Also, ich habe hier entsprechend einen Ableitungsbaum, Sie kennen

34:28.500 --> 34:33.100
Ableitungsbäume, gottesfreien Grammatiken, wissen Sie, habe ich für

34:33.100 --> 34:36.080
jedes Wort der Sprache einen würdigen Ableitungsbaum, den muss ich

34:36.080 --> 34:37.040
halt erzeugen.

34:37.240 --> 34:41.180
Das heißt, ich übersetze das Programm, ich erzeuge aus dem Programm

34:41.180 --> 34:44.800
den gültigen Ableitungsbaum oder ich reduziere das Wort auf das

34:44.800 --> 34:49.020
Startsymbol und habe dann nebenbei einen Ableitungsbaum erzeugt und

34:49.020 --> 34:54.660
dann wird der Baum genommen und anhand der Struktur dieses Baumes, da

34:54.660 --> 34:57.980
wird also der Syntaxbaum durchlaufen, entsprechend dieser Struktur die

34:57.980 --> 35:02.260
richtigen Assembler- oder Maschinenbefehle zu erzeugen.

35:02.860 --> 35:08.500
Das heißt, ich ordne hier jeder Meta-Variable in jedem Symbol in

35:08.500 --> 35:12.980
meinem Ableitungsbaum entsprechend eine Prozedur zu, die den Code für

35:12.980 --> 35:14.040
dieses Symbol erzeugt.

35:14.580 --> 35:18.680
Das ist alles Dinge, die werden standardmäßig gemacht, kann ich Ihnen

35:18.680 --> 35:22.460
hier nicht genau erzählen, ist Standardinhalt einer Vorlesung über

35:22.460 --> 35:26.300
Compilerbau, die wir Ihnen gar nicht anbieten, weil Compilerbau ein

35:26.300 --> 35:31.020
Standardstoff ist, können Sie in vielen Büchern gut nachlesen, es gibt

35:31.020 --> 35:32.480
Standardfunktionen, um das aufzurufen.

35:32.980 --> 35:35.080
Das ist im Augenblick nicht Thema aktueller Forschung.

35:36.040 --> 35:37.320
Dann kommt Codeoptimierung.

35:38.560 --> 35:41.760
Optimierung ist einerseits die Laufzeitoptimierung und dann die

35:41.760 --> 35:43.840
Speicherplatzoptimierung, habe ich Ihnen kurz angedeutet.

35:44.400 --> 35:47.420
Da geht es darum, dass man mehrfach auftretende arithmetische

35:47.420 --> 35:50.160
Ausdrücke, wenn die immer wieder auftreten, nur einmal ausführen

35:50.160 --> 35:53.460
möchte und deswegen macht man solche Vereinfachungen von

35:53.460 --> 35:57.820
Programmteilen und wie gesagt, das kann dazu führen, dass auf einmal

35:57.820 --> 36:02.580
sich die numerischen Ergebnisse etwas verändern.

36:02.820 --> 36:05.540
Dadurch muss man aufpassen, ob das passiert, wenn ja, muss man

36:05.540 --> 36:06.680
entsprechend vorsichtig damit umgehen.

36:07.460 --> 36:09.460
Codeoptimierung soll eben dazu führen, dass ein Programm besser

36:09.460 --> 36:10.120
ausgeführt wird.

36:10.660 --> 36:14.020
Was natürlich heutzutage ganz wichtig ist, wäre zum Beispiel eine

36:14.020 --> 36:17.160
automatische Parallelisierung.

36:21.380 --> 36:23.920
Wenn Sie einen Multicore-Rechner haben oder einen Minicore-Rechner,

36:24.200 --> 36:26.780
dann wollen Sie, dass Ihr Programm möglichst gut verteilt wird auf

36:26.780 --> 36:28.960
viele einzelne Programmteile.

36:29.340 --> 36:32.160
Das kann man automatisch machen, aber auch da muss man natürlich

36:32.160 --> 36:33.480
aufpassen, dass es gut passiert.

36:33.580 --> 36:36.500
Das wäre aber auch etwas, was Richtung Codeoptimierung gehen würde,

36:36.860 --> 36:41.020
nämlich Optimierung des Programms für die Rechnerarchitektur, die bei

36:41.020 --> 36:42.180
der Ausführung zugrunde liegt.

36:43.640 --> 36:48.240
Das ist ein aktuelles Thema der Forschung.

36:48.600 --> 36:53.640
Wie kann ich möglichst effektiv Programme führen, transformieren,

36:54.000 --> 36:57.440
sodass sie sehr gut parallel ausgeführt werden können und die

36:57.440 --> 37:00.940
richtigen Funktionen immer noch am Ende erzeugt werden.

37:01.760 --> 37:05.340
Okay, dann ganz schnell noch Java Virtual Machine.

37:05.540 --> 37:06.960
Ein besonderes Thema.

37:07.200 --> 37:09.340
Java hat eine besondere Eigenschaft.

37:09.480 --> 37:12.760
Ich möchte gerne dafür sorgen, dass Java plattformunabhängig ist.

37:12.940 --> 37:17.900
Das ist etwas, eine wichtige Eigenschaft, plattformunabhängige

37:17.900 --> 37:21.240
Programmausführung oder plattformunabhängige Erzeugung von Code.

37:22.440 --> 37:26.200
Dazu gibt es auf jedem Rechner, der Java ausführen kann, eine

37:26.200 --> 37:27.620
sogenannte Java Virtual Machine.

37:29.200 --> 37:31.820
Diese Virtual Machine hat einen speziellen Befehlssatz, einen

37:31.820 --> 37:32.860
sogenannten Bytecode.

37:33.920 --> 37:39.600
Wird also jedes Java-Programm in ein Bytecode-Programm überführt auf

37:39.600 --> 37:43.500
dieser Java Virtual Machine und diese Java Virtual Machine wird

37:43.500 --> 37:48.600
interpretiert in entsprechend Maschinenbefehlen auf ihrem konkreten

37:48.600 --> 37:49.220
Rechner.

37:49.960 --> 37:52.900
Das heißt im Prinzip führen Sie etwas auf einer virtuellen Maschine

37:52.900 --> 37:54.540
aus, auf der Java Virtual Machine.

37:55.640 --> 37:59.460
Konkret muss es umgesetzt werden in Befehle auf ihrer konkreten

37:59.460 --> 38:01.000
Architektur, in Maschinensprache.

38:01.380 --> 38:02.900
Das kann möglichst effizient geschehen.

38:02.980 --> 38:04.220
Das wird dann unmittelbar ausgeführt.

38:04.840 --> 38:07.920
Aber zunächst mal wird das Programm übersetzt in entsprechenden

38:07.920 --> 38:08.300
Bytecodes.

38:08.900 --> 38:16.120
Es gibt auch durchaus Programme, die Java-Programme übersetzen in

38:16.120 --> 38:17.140
Maschinencode.

38:17.640 --> 38:19.520
Das sind sogenannte Just-in-Time-Compiler.

38:20.320 --> 38:24.100
Wenn Sie eine Routine in Java aufrufen, wird entsprechend

38:24.100 --> 38:26.080
normalerweise der Bytecode erzeugt.

38:26.840 --> 38:33.220
Wenn die Methode das erste Mal benutzt wird, dann wird der

38:33.220 --> 38:37.220
entsprechende Bytecode in Maschinensprache übersetzt und danach wird

38:37.220 --> 38:41.060
entsprechend diese in Maschinensprache übersetzte Version verwendet

38:41.060 --> 38:42.460
und nicht mehr der Bytecode.

38:42.560 --> 38:46.200
Das heißt, ich habe dann keine Mehrfachübersetzung mehr, sondern habe

38:46.200 --> 38:52.520
sofort den entsprechenden Code auf der Hardware.

38:53.500 --> 38:57.520
Also Just-in-Time-Compiler setzt man ein in Java um das Deutlichen.

38:58.100 --> 38:59.320
Kennen Sie aus den Java-Vorlesungen.

39:00.340 --> 39:02.260
Und manche sind doch echte Compiler.

39:02.680 --> 39:06.500
Und dann habe ich eben nicht mehr die Plattform-Unabhängigkeit für das

39:06.500 --> 39:06.800
Programm.

39:06.920 --> 39:09.820
Dann brauche ich einen entsprechenden Compiler für eine spezielle

39:09.820 --> 39:10.100
Plattform.

39:11.680 --> 39:13.740
Okay, das ist Ihnen alles im Wesentlichen bekannt.

39:13.900 --> 39:15.520
Das war etwas zu Programmiersprachen.

39:16.320 --> 39:22.120
Und damit sind wir mit dem Teil erst mal soweit durch.

39:22.320 --> 39:27.880
Ein paar wesentliche kurze Aspekte der Programmiersprachen.

39:28.440 --> 39:33.980
Und jetzt kommt ein wichtiges Kapitel, das ich Ihnen eigentlich eine

39:33.980 --> 39:35.620
Woche früher hätte vorstellen müssen.

39:36.260 --> 39:37.140
Zuerst mal eine Frage.

39:38.060 --> 39:41.420
Wird im Java-Compiler auch eine Code-Optimierung durchgeführt?

39:41.640 --> 39:44.160
Was werden Sie dort als Option haben, dass Sie den einschalten oder

39:44.160 --> 39:44.780
ausschalten können?

39:44.900 --> 39:47.260
Hängt vom Java-Compiler ab, den Sie zur Verfügung haben.

39:47.560 --> 39:48.460
Verschiedene Varianten.

39:49.160 --> 39:52.500
Und ein vernünftiger Compiler würde Ihnen die Option anbieten, dass

39:52.500 --> 39:53.660
Sie Code-Optimierung machen können.

39:54.300 --> 39:56.640
Und das heißt als Option, das heißt Sie müssen dann auch in der Lage

39:56.640 --> 39:58.540
sein, Code-Optimierung wieder auszuschalten.

39:59.580 --> 40:03.000
Das ist etwas, da hatte ich schon drauf hingewiesen, das sollte man

40:03.000 --> 40:04.200
sprechen.

40:05.180 --> 40:06.920
Ich kann also nicht sagen, im Java-Compiler.

40:07.020 --> 40:08.220
Da gibt es verschiedene Compiler.

40:08.680 --> 40:10.140
Das ist nicht nur einer.

40:11.140 --> 40:15.540
Und damit kommen wir jetzt zum nächsten Kapitel, das ich Ihnen auf

40:15.540 --> 40:17.420
jeden Fall noch präsentieren muss.

40:18.300 --> 40:22.340
Das darauffolgende Kapitel werde ich Ihnen nicht präsentieren.

40:22.420 --> 40:25.480
Kapitel 11, das Kapitel nachher über Dateiorganisation.

40:26.420 --> 40:32.240
Da ist der Inhalt doch für die Klausur am Ende des Sommersemesters,

40:32.360 --> 40:35.740
aber nicht bei der Klausur am Ende des Mittersemesters, weil ich das

40:35.740 --> 40:38.800
hier nicht in der Vorlesung mit präsentieren konnte.

40:38.940 --> 40:42.520
Das war auch ein Standard Vorgehen, weil ich sonst dieses Kapitel

40:42.520 --> 40:44.960
nicht in der letzten Vorlesungsstunde zeige.

40:45.140 --> 40:48.700
Das Betriebssystem ist normalerweise in der vorletzten, spätestens in

40:48.700 --> 40:49.720
der vorletzten Vorlesungsstunde.

40:50.840 --> 40:52.780
Worum geht es bei Betriebssystemen?

40:52.900 --> 40:54.300
Wir haben jetzt alles mögliche angeguckt.

40:54.440 --> 40:58.100
Wir haben bei Rechnerarchitekturen, wir haben uns die Hardware

40:58.100 --> 41:02.040
angeguckt, wir haben uns die Strukturen angeguckt, Speicher,

41:03.060 --> 41:03.580
Programmiersprachen.

41:04.580 --> 41:07.180
Jetzt müssen wir wissen, wie wird eigentlich ein Programm tatsächlich

41:07.180 --> 41:07.580
ausgeführt?

41:07.680 --> 41:10.440
Wir wissen, wie ein einzelner Befehl aus einem Programm geholt wird in

41:10.440 --> 41:11.760
den CPU.

41:12.460 --> 41:15.100
Aber woher weiß ich, wann ein Programm ausgeführt werden muss?

41:15.560 --> 41:20.000
Dazu, oder damit beschäftigt sich das Betriebssystem, die Zuordnung

41:20.000 --> 41:24.560
von konkreten Ressourcen zu den Programmen, die ausgeführt werden

41:24.560 --> 41:24.820
sollen.

41:25.160 --> 41:26.020
Da steht einiges drin.

41:26.580 --> 41:28.960
Ich werde Ihnen nur einen Teil dieser Themen noch wirklich darstellen.

41:29.800 --> 41:31.020
Was macht ein Betriebssystem?

41:31.680 --> 41:40.360
Es muss dafür sorgen, dass die Rechenanlagen einerseits möglichst

41:40.360 --> 41:43.360
einfach und effizient betrieben werden können.

41:44.080 --> 41:47.180
Möglichst wenig Overhead, möglichst sinnvoll ausgenutzt.

41:47.740 --> 41:49.880
Nicht nur von einem, sondern von mehreren Anwendern.

41:51.000 --> 41:53.760
Dazu muss ich wissen, welche Betriebsmittel habe ich eigentlich?

41:54.700 --> 41:55.620
Was sind Betriebsmittel?

41:55.760 --> 41:58.660
Das sind Hardware- und Softwarekomponenten, die ich brauche, um

41:58.660 --> 41:59.600
Programme auszuführen.

41:59.820 --> 42:02.660
Also, ich brauche den Prozessor, ich brauche einen Speicher, ich

42:02.660 --> 42:03.820
brauche ein Ausgabegerät.

42:04.500 --> 42:07.160
Vielleicht brauche ich noch irgendwelche Standardbibliotheken,

42:08.140 --> 42:11.120
Standardprogramme, irgendwelche Bibliotheksroutinen.

42:11.640 --> 42:14.400
Oder ich muss ein Programm haben, um irgendwas drucken zu können.

42:14.720 --> 42:16.520
Es sind bestimmte Dinge noch erforderlich.

42:17.040 --> 42:19.760
Zunächst mal sind es Hardwarekomponenten, aber eben auch einige können

42:19.760 --> 42:20.520
auch Softwarekomponenten.

42:21.480 --> 42:25.140
Und dann muss ich in der Lage sein, den Zugriff von Benutzerprogrammen

42:25.140 --> 42:27.220
auf die Betriebsmittel sinnvoll zu organisieren.

42:28.020 --> 42:31.020
Es darf natürlich nicht so sein, dass ein Benutzerprogramm auf

42:31.020 --> 42:35.960
irgendein Betriebsmittel zugreift und alle anderen, die auch darauf

42:35.960 --> 42:39.460
zugreifen wollten, stehen hier hinter einer Warteschlange und drehen

42:39.460 --> 42:42.420
Däumchen, obwohl der gar nicht so viel mit den Betriebsmitteln macht.

42:42.620 --> 42:45.780
Ich muss dafür sorgen, dass dieses Betriebsmittel möglichst gut

42:45.780 --> 42:49.280
genutzt wird und gleichzeitig jeder Benutzer den Eindruck hat, er hat

42:49.280 --> 42:50.940
exklusiven Zugriff auf die Betriebsmittel.

42:51.340 --> 42:55.080
Das sieht aus wie ein Widerspruch, wird aber weitgehend erreicht durch

42:55.080 --> 42:56.320
intelligente Betriebsmittel.

42:57.540 --> 43:03.820
Also, es geht darum, dass man alle Verwaltungs-, Steuerungs- und

43:03.820 --> 43:08.440
Dienstleistungsaufgaben eines Rechners in Systemprogrammen formuliert.

43:08.600 --> 43:12.180
Und das sind also die Elemente eines Betriebssystems, sind in jeder

43:12.180 --> 43:13.200
Rechenanlage vorhanden.

43:13.640 --> 43:16.800
Das Betriebssystem ist also im Wesentlichen, ist nur Software, das

43:16.800 --> 43:18.000
Operating System.

43:18.480 --> 43:20.880
Alle Systemprogramme einer Rechenanlage sind da zusammengenommen.

43:21.580 --> 43:22.600
Was machen diese alle?

43:23.400 --> 43:25.060
Wir müssen den Prozessor verwalten.

43:25.340 --> 43:28.980
Also, wir müssen organisieren, dass ein Programm Zugriff auf den

43:28.980 --> 43:29.760
Prozessor erhält.

43:31.020 --> 43:31.920
Manchmal auch mehrere.

43:31.980 --> 43:33.380
Ich hatte mal was erzählt über Hyperthreading.

43:33.980 --> 43:37.400
Da waren mehrere Prozesse, die gleichzeitig nebenläufig auf einen

43:37.400 --> 43:38.580
Prozessor zugreifen können.

43:39.320 --> 43:41.640
Ich muss den Hauptspeicher verwalten.

43:42.500 --> 43:43.020
Hauptspeicherverwaltung.

43:43.900 --> 43:46.880
Ich habe Ihnen erzählt, dass wir Festplatten haben,

43:47.480 --> 43:51.160
Hintergrundspeicher oder auch SSDs und müssen Dateien von der

43:51.160 --> 43:52.760
Festplatte in den Hauptspeicher kommen.

43:53.700 --> 43:55.920
Da müssen irgendwann auch andere wieder ausgelagert werden.

43:56.180 --> 43:57.460
Das ist Hauptspeicherverwaltung.

43:57.940 --> 44:00.600
Welches Programm darf wann, auf welchem Platz im Hauptspeicher?

44:01.220 --> 44:02.380
Kommen wir noch kurz darauf zurück.

44:03.460 --> 44:03.980
Programmausführung.

44:04.640 --> 44:07.520
Das ist der Maschinenbefehlszyklus, Laden der Befehle und Daten in den

44:07.520 --> 44:07.960
Hauptspeicher.

44:08.480 --> 44:13.600
Und dann vom Hauptspeicher natürlich, das wäre die konkrete Zugriff

44:13.600 --> 44:14.300
auf den Rechner.

44:14.780 --> 44:18.000
Programmausführung heißt zunächst mal, muss alles erstmal in den

44:18.000 --> 44:21.040
Hauptspeicher haben und dann vom Hauptspeicher noch wieder in die CPU.

44:21.600 --> 44:23.460
Das kennen Sie als Maschinenbefehlszyklus.

44:24.260 --> 44:27.300
Muss auf die Ein-Ausgabe-Geräte zugreifen können.

44:27.800 --> 44:29.280
Entweder direkt oder indirekt.

44:30.460 --> 44:33.340
Lese-Schreib-Operationen auf Ein-Ausgabe-Geräte.

44:33.560 --> 44:35.060
Muss aufs Netz zugreifen können.

44:35.760 --> 44:42.560
Brauche Software, um auf die Sockets, auf die Ports zuzugreifen und

44:42.560 --> 44:45.820
Anwendungsprogrammen zu ermöglichen, dass sie eine Verbindung aufbauen

44:45.820 --> 44:47.140
über TCP und ähnliche Dinge.

44:47.440 --> 44:53.100
TCP, IP, Print-Protokolle, das sind umgesetzt in Systemprogramme, die

44:53.100 --> 44:54.820
halt den Netzzugriff regeln.

44:55.660 --> 44:56.880
Zugriff auf Dateien.

44:57.400 --> 45:00.320
Wie kann ich auf eine Datei zugreifen, auf dem einen Medium, auf dem

45:00.320 --> 45:00.980
anderen Medium?

45:01.060 --> 45:03.600
Ich muss entsprechende Datei-Beschreibungsinformationen

45:03.600 --> 45:07.720
interpretieren, um dann die richtigen Daten rauszuholen.

45:08.500 --> 45:15.280
Muss dafür sorgen, dass nur gewisse berechtigte Personenprogramme

45:15.280 --> 45:19.940
Zugriff haben auf die Betriebsmittel oder auch auf Dateien.

45:20.060 --> 45:21.360
Zugriffsschutz ist ein wichtiger Punkt.

45:22.180 --> 45:24.660
Muss buchführen darüber, was auf dem Rechner passiert.

45:24.660 --> 45:27.140
Wer hat wann was womit gemacht.

45:27.980 --> 45:29.420
Das muss aufgeschrieben werden.

45:29.540 --> 45:33.000
Da hat man ein langes, langes Logbuch und da steht alles drauf, was

45:33.000 --> 45:33.780
gemacht wurde.

45:34.360 --> 45:37.040
Der Systemadministrator kann dann, wenn ein Fehler aufgetreten ist,

45:37.120 --> 45:39.460
nachvollziehen, was dort konkret geschehen ist.

45:40.420 --> 45:43.000
Es sind dann noch eine Reihe weiterer Dienste da.

45:43.100 --> 45:45.260
Editor, Compiler, Debugger, Browser und so weiter.

45:45.940 --> 45:49.140
Alle diese Komponenten sind Programme, werden auch im Rechner

45:49.140 --> 45:52.440
ausgeführt, aber sie haben natürlich, sind nicht genauso Programme wie

45:52.440 --> 45:54.460
die Anwendungsprogramme, sondern sie haben Priorität bei der

45:54.460 --> 45:55.160
Ausführung.

45:55.360 --> 45:56.380
Darauf kommen wir gleich noch zurück.

45:57.800 --> 46:01.680
Also, wenn ich ein Programm ausführe, laufen im Hintergrund alle

46:01.680 --> 46:04.380
möglichen Systemprogramme ab, die die Ausführung meines

46:04.380 --> 46:07.120
Nutzerprogramms dann konkret organisieren.

46:08.200 --> 46:11.240
Gehen wir ganz kurz eine Liste bekannter Betriebssysteme durch.

46:11.420 --> 46:15.620
Das erste, das MS-DOS, Microsoft Disk Operating System.

46:16.100 --> 46:19.580
Ein klassisches Betriebssystem, das sehr große Berühmtheit erlangt

46:19.580 --> 46:25.940
hat, weil es halt die Basis war für viele PCs und es ist halt das

46:25.940 --> 46:27.420
Betriebssystem für PCs gewesen.

46:27.940 --> 46:32.580
Es hatte im Vergleich mit damals verfügbaren anderen Alternativen

46:32.580 --> 46:34.580
haarsträubende Eigenschaften.

46:34.640 --> 46:40.880
Begrenzung auf 640 Kilobyte im Speicher und die Nutzungsschnittstellen

46:40.880 --> 46:47.460
waren katastrophal im Vergleich zu dem, was gleichzeitig bei CPM oder

46:47.460 --> 46:48.820
bei macOS verfügbar war.

46:49.460 --> 46:53.360
Aber die Entscheidung wurde halt getroffen für ein einfaches, ganz

46:53.360 --> 46:55.340
einfaches Betriebssystem für PCs.

46:55.620 --> 46:59.460
Ist ja nur für PCs und für Leute, für Rechner, die Leute direkt

46:59.460 --> 46:59.900
benutzen.

47:00.040 --> 47:03.220
Es war ja nichts für Großrechner, sondern für einzelne PCs.

47:03.800 --> 47:06.700
Da ist ja nicht so wichtig, dass man Nutzerschnittstellen so etwas

47:06.700 --> 47:07.120
anguckt.

47:07.400 --> 47:08.660
Da hat sich die Einstellung heute geändert.

47:09.660 --> 47:13.880
Darauf aufbauen gab es halt eine lange Palette von weiteren Microsoft

47:13.880 --> 47:16.060
-Betriebssystemen, Microsoft Windows.

47:16.740 --> 47:19.300
Fenstertechnik ist irgendwann auch von Microsoft entdeckt worden.

47:20.140 --> 47:21.400
War in Immerstore alles nicht vorhanden.

47:22.000 --> 47:25.620
Menüsteuerung von irgendwelchen Befehlen und ähnliches hat man alles

47:25.620 --> 47:29.620
nach und nach, hat man das alles in die Microsoft-Programme

47:29.620 --> 47:30.040
übernommen.

47:30.580 --> 47:33.920
Das war bei den Konkurrenten, insbesondere bei macOS, alles von Anfang

47:33.920 --> 47:34.440
an mit drin.

47:35.120 --> 47:39.320
Und irgendwann ist alles übernommen worden in die Windows-Version.

47:40.040 --> 47:41.620
Mittlerweile sind wir bei Windows 8.

47:42.860 --> 47:45.200
Ob das immer Vorteile sind, wenn man von einem Betriebssystem ins

47:45.200 --> 47:47.240
nächste geht, kann man sich überstreiten.

47:47.780 --> 47:50.760
Wir haben halt immer wieder neue Versionen mit neuen Eigenschaften,

47:50.880 --> 47:55.180
die immer besser auf unsere Anforderungen eingestellt sind.

47:56.000 --> 47:59.120
Ich will auf die Einzelheiten gar nicht genauer eingehen, aber es gibt

47:59.120 --> 48:01.900
halt hier inzwischen insbesondere mehr Benutzerbetrieb.

48:02.380 --> 48:06.000
War früher bei den Microsoft-Betrieben nicht vorhanden.

48:06.080 --> 48:09.600
Also zum Beispiel bei Windows 95, 98 war es so, dass es auch einen

48:09.600 --> 48:10.320
Zugriffsschutz gab.

48:10.320 --> 48:13.460
Man musste sich anmelden, wenn man einen Rechner nutzen wollte.

48:14.180 --> 48:17.020
Aber wenn man das Passwort vergessen hatte, hat man einfach dieses

48:17.020 --> 48:20.220
Anmeldefenster weggeklickt und konnte darauf zugreifen.

48:20.660 --> 48:24.240
Das heißt, da war einfach ein Fenster aufgemacht worden, das einem

48:24.240 --> 48:27.220
vorspiegelte, ich muss mich erstmal anmelden, um den Rechner zu

48:27.220 --> 48:27.480
nutzen.

48:28.080 --> 48:29.460
Da war keine wirkliche Funktion dahin.

48:30.200 --> 48:31.920
Und das ist einfach ein Witz.

48:32.700 --> 48:35.360
Und das war anderen selbstverständlich immer so, dass es verschiedene

48:35.360 --> 48:38.440
Benutzer gab, die auch von Ferne auf den Rechner zugreifen konnten.

48:39.040 --> 48:40.200
Ist inzwischen alles anders.

48:40.360 --> 48:40.860
Sie wissen das.

48:40.960 --> 48:44.420
Inzwischen hat Microsoft ein ganz fantastisches Zugriffssystem.

48:44.580 --> 48:47.960
Die haben auch Nutzerverwaltungssystem, Active Directories und so

48:47.960 --> 48:48.200
weiter.

48:48.680 --> 48:51.020
Sehr gutes System, besser als manche andere.

48:51.700 --> 48:54.300
Also ich will nicht schlecht reden über die Microsoft-Produkte, aber

48:54.300 --> 48:58.280
es war einfach so historisch, dass die nicht immer diejenigen waren,

48:58.640 --> 49:01.800
die die innovativen Ideen als erste gehabt haben, sondern die sind

49:01.800 --> 49:03.660
häufig von anderen gekommen.

49:04.460 --> 49:07.400
Mehr bei der Luxusvariante hier von Apple.

49:08.140 --> 49:11.840
Und dann gibt es natürlich die Betriebssysteme, auch auf kleineren

49:11.840 --> 49:16.940
Geräten, auf unseren Smartphones, Handys, kleineren Dingen.

49:17.180 --> 49:20.160
Selbst auf Smartcards können Sie Windows-Betriebssystem laufen lassen.

49:21.060 --> 49:27.040
In Ihrem Auto sind einige, sind auch Windows-Programme, kann auch

49:27.040 --> 49:27.960
Windows -Programm laufen.

49:28.160 --> 49:33.060
Also es gibt Windows-Betriebssysteme für eine Vielzahl von

49:33.060 --> 49:36.980
verschiedenen Geräten, auf denen Informationsverarbeitung ausgeführt

49:36.980 --> 49:37.280
wird.

49:37.860 --> 49:39.840
Macht natürlich Sinn, weil man dann innerhalb einer

49:39.840 --> 49:43.500
Betriebssystemumgebung arbeiten kann und nicht zwischen verschiedenen

49:43.500 --> 49:44.740
Betriebssystemen hin- und herspringen.

49:45.340 --> 49:50.060
Dann ganz kurz aufgeschrieben hier, obwohl ich es schon gesagt habe,

49:50.100 --> 49:53.580
Macintosh Operating System, also die Alternative von Apple.

49:54.900 --> 49:58.260
Hier wurde wirklich Pionierarbeit geleistet, was so Fenstertechnik,

49:58.420 --> 50:00.680
Maus - und Menügeführte, Benutzungsschnittstellen angeht.

50:01.340 --> 50:03.340
Da war also Windows weit von weg.

50:04.300 --> 50:06.460
Multiprogrammbetrieb, Netzwerkfähigkeit.

50:06.580 --> 50:11.720
Es gab Apple Talk als ein ganz wichtiges Protokollseiten, als ein

50:11.720 --> 50:15.920
entfernter Zugriff auf PCs, die mit Windows-Betriebssystemen gar nicht

50:15.920 --> 50:16.460
möglich war.

50:16.840 --> 50:20.120
Da haben die Apple-Rechner schon über Apple Talk miteinander

50:20.120 --> 50:20.760
kommuniziert.

50:20.860 --> 50:24.940
Man konnte verteilte Systeme aufbauen, was mit PCs damals nur sehr,

50:25.200 --> 50:26.620
sehr, sehr, sehr schwer möglich war.

50:27.160 --> 50:31.960
Mittlerweile ist eben das Betriebssystem der Macs oder von Apple auch

50:31.960 --> 50:33.020
Unix -basiert.

50:33.680 --> 50:35.200
Ab OSC war das der Fall.

50:36.100 --> 50:40.540
Jetzt gibt es das sogenannte iOS für iPhone, iPad und ähnliche Dinge.

50:40.720 --> 50:44.080
Alles Weiterentwicklungen der ursprünglichen Systeme.

50:45.260 --> 50:50.280
Dann, das sind die ganzen kleinen, Personal Computer oder Handheld

50:50.280 --> 50:50.700
-Computer.

50:51.120 --> 50:56.080
Dann gibt es das Unix-Betriebssystem für größere Rechner, überwiegend

50:56.080 --> 50:59.820
also für Workstation und Server und Rechnernetzen mit allen möglichen

50:59.820 --> 51:00.320
Varianten.

51:00.560 --> 51:03.180
Da haben die einzelnen Firmen unterschiedliche Varianten entwickelt.

51:03.560 --> 51:09.500
Also sie haben HP, UX, IBM AIX, Solaris kommt von Sun.

51:10.200 --> 51:16.400
Und dann gibt es noch das BSD 4.X, das System 5.

51:16.980 --> 51:19.380
Das sind Betriebssysteme, die wurden an der University of Berkeley

51:19.380 --> 51:20.020
entwickelt.

51:20.820 --> 51:23.000
Also University of California at Berkeley.

51:24.380 --> 51:30.120
Das BSD steht für Berkeley.

51:30.740 --> 51:32.580
Und dann halt eine Variante von Unix.

51:33.060 --> 51:36.120
Dieses Betriebssystem Unix ist halt eine akademische Entwicklung

51:36.120 --> 51:39.600
gewesen, die dann in die Industrie in Großrechner weiterentwickelt

51:39.600 --> 51:39.860
wurde.

51:40.900 --> 51:47.060
Die Variante für PCs war Linux oder auch FreeBSD oder Solaris.

51:47.220 --> 51:50.860
Das sind Derivate, die auf PCs eingesetzt werden oder auf allen

51:50.860 --> 51:52.340
möglichen anderen Rechnern.

51:52.460 --> 51:56.540
Die sind normalerweise kostenlos verfügbar, aber wenn sie das richten,

51:56.540 --> 51:59.480
wenn sie entsprechende Software oder wenn sie Services haben wollen,

51:59.900 --> 52:05.580
zusätzlich zu der Installation von Linux, dann ist es so, dass sie

52:05.580 --> 52:09.380
noch extra dafür zahlen müssen, um eben die Qualitätssicherung zu

52:09.380 --> 52:09.700
bekommen.

52:10.140 --> 52:12.940
Wobei Linux einen wesentlichen Teil ist, ich habe geschrieben,

52:13.020 --> 52:15.120
selbstorganisierte Qualitätssicherung, was heißt das?

52:16.220 --> 52:20.420
Linux unterstützt eine User- oder eine Nutzer-Community oder eine

52:20.420 --> 52:21.240
Entwickler -Community.

52:21.480 --> 52:25.880
Es gibt Linux-Nutzergruppen und wenn sie ein Programm schreiben für

52:25.880 --> 52:31.340
Linux, neuen Systemsoftware für Linux, dann lassen sie das dort über

52:31.340 --> 52:35.060
diese Entwickler-Community im Prinzip testen, kriegen Rückmeldungen.

52:35.180 --> 52:38.500
Sie haben also eine sehr gute Rückmeldung bezüglich

52:41.560 --> 52:45.640
Fehlersuche, Qualitätssicherung von Programmen, während bei den

52:45.640 --> 52:50.800
anderen Betriebssystemen, wie meinetwegen HP-UX oder IBM-IEX, alle

52:50.800 --> 52:54.500
Entwickler von einer Firma kommen und deren Auftrag arbeiten, ist eben

52:54.500 --> 52:58.940
bei Linux das so, dass sie eine riesige Entwicklergemeinde haben, die

52:58.940 --> 53:03.780
Software entwickeln und entsprechend dann auch dafür sorgen, dass die

53:03.780 --> 53:06.760
Qualität stimmt.

53:08.020 --> 53:12.060
Also Linux ist ein bisschen mehr so das frei verfügbare,

53:12.160 --> 53:17.520
selbstorganisierte, die anderen sind halt zentral entwickelt und haben

53:17.520 --> 53:19.020
auch viele gute Eigenschaften.

53:20.120 --> 53:26.820
Und dann gibt es die Großrechnerbetriebssysteme, das MVS, das VMS, den

53:26.820 --> 53:27.800
sehr ähnlichen Namen.

53:28.660 --> 53:34.300
Eigentlich könnte BS 2000 auch MVS heißen, aber es heißt halt BS 2000,

53:34.480 --> 53:37.780
weil es die deutsche Variante des IBM-Betriebssystems ist, hat auch

53:37.780 --> 53:42.860
gewisse andere Eigenschaften, ist auch weiterentwickelt worden und ist

53:42.860 --> 53:47.120
in der Industrie immer noch wahrscheinlich sehr weit verbreitet ein

53:47.120 --> 53:48.780
klassisches Großrechnerbetriebssystem.

53:50.880 --> 53:53.780
Dann kann ich Rechner natürlich sehr unterschiedlich konfigurieren,

53:53.860 --> 53:55.340
wenn ich von Betriebsmitteln rede.

53:56.760 --> 54:00.820
Beim Tablett habe ich hier nur einen Bildschirm und Prozessor plus

54:00.820 --> 54:01.260
SSD.

54:02.040 --> 54:04.540
Beim PC habe ich einen Bildschirm, Festplatte, Drucker.

54:04.980 --> 54:08.280
Beim Großrechner habe ich eventuell hunderte von Bildschirmen,

54:08.360 --> 54:11.800
hunderte von Teilnehmerstationen, an denen gleichzeitig gearbeitet

54:11.800 --> 54:14.800
wird und das muss ich entsprechend alles verwalten können.

54:15.660 --> 54:18.640
Verteiltes System ist halt noch wesentlich mehr.

54:18.740 --> 54:22.580
Ich habe ein riesiges Rechnernetz und muss dieses Rechnernetz geeignet

54:22.580 --> 54:23.280
verwalten.

54:23.700 --> 54:26.340
Macht man zum Beispiel in Grid Computing oder ähnlichen Dingen oder

54:26.340 --> 54:27.900
Sie bauen ein anderes Rechnernetz auf.

54:28.720 --> 54:31.260
Das sind alles Dinge, die dann noch Cloud dazu,

54:31.440 --> 54:34.520
Informationsverarbeitung, Service auf virtualisierten

54:34.520 --> 54:39.460
Rechnerressourcen, die nutzen einen Dienst irgendwo in der Cloud und

54:39.460 --> 54:43.200
ob da jetzt ein Rechner da ist, der das macht oder eine Vielzahl von

54:43.200 --> 54:46.140
Rechnern, die ihre Services ausführen, das wissen sie nicht so.

54:48.980 --> 54:52.100
Also diese Nutzung der Cloud.

54:52.660 --> 54:56.880
Ein Thema ist da zum Beispiel die Nutzung von Dropbox.

54:57.960 --> 54:59.400
Kennen Sie alle Dropbox?

54:59.560 --> 55:02.600
Ein virtueller Speicher, der von Google zur Verfügung gestellt wird.

55:03.180 --> 55:05.220
Öffentlichen Einrichtungen in Deutschland ist es nicht erlaubt,

55:05.380 --> 55:08.520
Dropbox zu nutzen, weil die Daten in Dropbox alle in den USA liegen.

55:09.580 --> 55:10.800
Geht natürlich nicht.

55:13.060 --> 55:14.400
Könnten auch in den USA liegen.

55:15.240 --> 55:17.880
Möchte man nicht, dass unsere Daten alle irgendwo in den USA liegen,

55:17.940 --> 55:19.920
deswegen darf man Dropbox nicht einsetzen.

55:20.320 --> 55:24.360
Hier für das KIT wird gerade eine Variante entwickelt, die virtuellen

55:24.360 --> 55:27.780
Speicher halt auch so zur Verfügung stellt, aber unabhängig von

55:27.780 --> 55:30.300
firmenspezifischen Dingen.

55:30.440 --> 55:35.780
Also Dropbox sollte man nicht nutzen, beziehungsweise wenn man kein

55:35.780 --> 55:39.580
Risiko eingehen möchte, wenn man sagt, das ist mir egal, ob jemand

55:39.580 --> 55:42.460
meine Fotos sieht oder meine Daten liest, kann man das

55:42.460 --> 55:44.460
selbstverständlich nutzen, ist ein ganz praktischer Dienst.

55:45.340 --> 55:49.080
Also, das sind so die verschiedenen Möglichkeiten, die man dort

55:49.080 --> 55:51.580
einsetzen kann.

55:52.080 --> 55:53.860
Wie ist ein Betriebssystem aufgebaut?

55:54.040 --> 55:55.840
Natürlich nicht als ein monolithisches Programm.

55:56.000 --> 55:58.400
Viele verschiedene Programme und ich hatte Ihnen schon bei der

55:58.400 --> 56:01.260
Kommunikation in Rechnern gesagt, da gibt es verschiedene Schichten.

56:01.740 --> 56:03.460
Bei Betriebssystemen gibt es auch Schichten.

56:04.220 --> 56:07.400
Eine Schichtenhierarchie der Module, die verschiedene Aufgaben haben.

56:07.700 --> 56:11.620
Ganz unten geht es zunächst mal um die konkrete Steuerung der harten

56:11.620 --> 56:14.580
Rechnerressourcen, direkter Zugriff auf Hardware.

56:15.080 --> 56:19.420
Die nächste Schicht greift dann auf diese Funktion zu und die wieder

56:19.420 --> 56:23.600
auf Funktion der Schicht und das heißt, ich kann mich in der

56:23.600 --> 56:27.040
jeweiligen Schicht konzentrieren auf die Objekte, die dort zur

56:27.040 --> 56:30.920
Verfügung stehen und was dann in den konkreten Objekten konkret

56:30.920 --> 56:33.200
passiert, das macht die Schicht unten drunter.

56:34.320 --> 56:37.540
Das ist also etwas, was man generell so macht, eine schichtenweises

56:37.540 --> 56:46.540
Vorgehen bei der Ausführung von größeren Aufgaben und wenn ich also

56:46.540 --> 56:49.800
einen Auftrag ausführen möchte einem Rechner, kann es sein, dass der

56:49.800 --> 56:52.500
Auftrag darin besteht, irgendwie eine Menge von Programmen

56:52.500 --> 56:53.020
auszuführen.

56:53.520 --> 56:58.840
Also ein Auftrag kann aus einer Menge eventuell voneinander abhängigen

56:58.840 --> 57:00.420
Teilaufträgen bestehen.

57:00.920 --> 57:07.060
Und jeder Teilauftrag ist dann ein Auftrag oder Task und jeder Task

57:07.060 --> 57:11.720
ist also eine Folge von Betriebssystemkommandos zusammen mit der zu

57:11.720 --> 57:13.400
ihrer Ausführung nötigen Betriebsmittel.

57:14.020 --> 57:16.760
Das heißt, ich muss wissen, was brauche ich, um diesen Task

57:16.760 --> 57:20.580
tatsächlich auszuführen und die Art und Weise, wie das gemacht wird,

57:20.640 --> 57:23.400
ist dann halt die Betriebsart, wie ein Task ausgeführt werden kann.

57:23.880 --> 57:27.940
Ich habe also zunächst diesen größeren Auftrag, der wird aufgeteilt in

57:27.940 --> 57:33.900
eine Menge von Einzeltasks, die dann aufwarten, dass sie ausgeführt

57:33.900 --> 57:39.060
werden können auf meinen Betriebsmittel-CPU oder Prozessor und dass da

57:39.060 --> 57:41.800
Sachen in Speicher gelegt werden, aus dem Speicher zurückkommen und so

57:41.800 --> 57:42.000
weiter.

57:42.600 --> 57:45.020
Und wie das geschieht, ist etwas, was mit der Betriebsart der

57:45.020 --> 57:46.020
Rechenanlage zu tun hat.

57:46.480 --> 57:49.260
Und da gibt es halt diese verschiedenen Möglichkeiten von

57:49.260 --> 57:53.180
Doppelbetrieb bis runter zu kleinen Serverbetrieben, die jetzt im

57:53.180 --> 57:54.640
Einzelnen vorstellen werden.

57:55.700 --> 57:57.020
Was ist der Stapelbetrieb?

57:57.480 --> 57:58.120
Das Einfache.

57:59.040 --> 57:59.840
Ich nehme ein Programm.

58:00.420 --> 58:01.180
Was ist ein Stapel?

58:01.260 --> 58:02.160
Ein Stapel ist sowas.

58:02.520 --> 58:05.860
Ich habe hier irgendeinen Tisch, da lege ich jetzt ein Stapel von

58:05.860 --> 58:08.180
Aufträgen rauf.

58:08.920 --> 58:11.940
Und dann sitzt hier jemand und der greift sich hier irgendeinen

58:11.940 --> 58:15.760
Auftrag, bearbeitet ihn und legt ihn wieder hier irgendwo hin, dann

58:15.760 --> 58:16.320
landet er da.

58:17.540 --> 58:19.680
Also das ist Stapelverarbeitung.

58:19.700 --> 58:20.200
Ganz einfach.

58:20.340 --> 58:23.600
Ich habe einen Stapel von Aufträgen, die werden in irgendeiner

58:23.600 --> 58:24.580
Reihenfolge ausgeführt.

58:25.600 --> 58:30.360
Und wenn ich das so mache, dann kann derjenige, der hier sitzt, der

58:30.360 --> 58:34.940
das macht, der sich hier ausführt, kann ständig aktiv sein.

58:35.020 --> 58:40.620
Er hat ja ständig seine Aufträge, die ihm dahin gelegt werden und er

58:40.620 --> 58:44.060
kann seine Arbeit so organisieren, dass er seine Zeit bestmöglich

58:44.060 --> 58:44.440
nutzt.

58:44.900 --> 58:48.840
Alle Komponenten werden bestmöglich ausgenutzt.

58:49.100 --> 58:53.800
Das heißt aber auch, dass ein Auftrag, der gegeben wird, bei Übergabe

58:53.800 --> 58:55.880
an den Rechner vollständig definiert sein muss.

58:56.160 --> 58:59.280
Wenn Sie jetzt ein Programm schreiben und im Programm werden Sie als

58:59.280 --> 59:03.600
Nutzer irgendwas gefragt, über irgendwelche Parameter für, meinetwegen

59:03.600 --> 59:06.900
Optimierung, Sie haben irgendein Optimierungsproblem und jetzt wollen

59:06.900 --> 59:08.200
Sie da irgendein Parameter einstellen.

59:09.800 --> 59:12.180
Anzahl der Generationen bei volitionärer Optimierung zum Beispiel.

59:13.840 --> 59:16.240
Dann heißt das, das Programm muss bei der Ausführung bei Ihnen nochmal

59:16.240 --> 59:16.940
nachfragen.

59:17.360 --> 59:19.080
Dann ist es nicht vollständig definiert.

59:19.580 --> 59:23.140
Sie können also im Batch-Betrieb nur sowas durchführen, was

59:23.140 --> 59:24.420
vollständig bekannt ist.

59:25.000 --> 59:28.940
Meinetwegen, ich habe Rechnungen für alle Ihre Mitarbeiter, einmal am

59:28.940 --> 59:29.640
Ende des Monats.

59:30.080 --> 59:33.480
Ein Auftrag, steht alles drin, was gemacht werden muss und am Ende

59:33.480 --> 59:35.880
kommen dann die ganzen Gehaltszettel.

59:36.760 --> 59:40.360
Also ich habe eine zusammenhängende Übergabe so einer Beschreibung

59:40.360 --> 59:44.440
eines Auftrags, kann nicht mehr eingreifen während der Bearbeitung

59:44.440 --> 59:45.200
eines Auftrags.

59:45.260 --> 59:46.280
Keine interaktiven.

59:47.240 --> 59:51.660
Und in der Regel keine strengen Zeitanforderungen hinsichtlich

59:51.660 --> 59:52.800
Beendigung der Aufträge.

59:53.740 --> 59:57.340
Es kann sein, dass ich irgendwelche Deadlines habe, dann muss ich die

59:57.340 --> 59:58.280
entsprechend rausgreifen.

59:59.060 --> 01:00:02.360
Aber das ist dann etwas, was noch dazukommen könnte.

01:00:02.800 --> 01:00:07.840
Zunächst mal habe ich da keine genauen Zeitanforderungen, kann das

01:00:07.840 --> 01:00:09.580
optimieren bezüglich meines Rechens.

01:00:09.700 --> 01:00:13.400
Typische Anwendungen sind halt so alle möglichen wissenschaftlich

01:00:13.400 --> 01:00:16.520
-technischen Berechnungen, alles was nicht interaktiv laufen muss.

01:00:18.260 --> 01:00:23.100
Hauptaufgabe ist eben hier, den Durchsatz des Rechners zu erhöhen,

01:00:23.280 --> 01:00:26.480
möglichst viel Rechenleistung rauszuholen aus ihrem Rechner.

01:00:27.480 --> 01:00:29.160
Dass wir wirklich mit voller Kraft arbeiten.

01:00:30.020 --> 01:00:34.920
Das ist Batch-Betrieb, ist für viele Großrechner ein ganz wichtiger

01:00:34.920 --> 01:00:36.920
Teil der Betriebsarbeit.

01:00:37.720 --> 01:00:42.140
Dann kommt der Multiprogramm-Betrieb oder auch mehr Prozessbetrieb.

01:00:43.040 --> 01:00:47.160
Das heißt, Sie haben hier mehrere Prozesse, die gleichzeitig im

01:00:47.160 --> 01:00:48.600
Hauptspeicher resident sind.

01:00:48.700 --> 01:00:52.180
Wenn das unser Hauptspeicher ist, haben Sie also hier mehrere

01:00:52.180 --> 01:00:54.800
Programme, die gleichzeitig da drin sind.

01:00:55.400 --> 01:01:00.140
Und hier haben Sie Ihre CPU, das Central Processing Unit und jetzt

01:01:00.140 --> 01:01:05.240
wird entschieden, welches Programm tatsächlich ausgeführt wird.

01:01:05.360 --> 01:01:07.860
Manchmal werden mehrere nebenläufig ausgeführt.

01:01:08.400 --> 01:01:09.140
Das ist eine Frage.

01:01:11.500 --> 01:01:12.760
Gustav asked nothing.

01:01:16.240 --> 01:01:19.560
Hauptaufgabe hier ist, dass Sie Betriebsmitteln den Prozessen

01:01:19.560 --> 01:01:22.720
zuteilen, dass Sie Prozesse aktivieren, blockieren.

01:01:22.820 --> 01:01:24.260
Da gehen wir gleich darauf ein, was da passiert.

01:01:24.860 --> 01:01:27.740
Und natürlich muss ich auch dafür sorgen, dass ein Programm, wenn das

01:01:27.740 --> 01:01:30.700
hier ausgeführt wird, hier in meinem Rechner, dann greift das

01:01:30.700 --> 01:01:32.920
natürlich auf den Speicher zu an verschiedenen Stellen.

01:01:33.700 --> 01:01:37.520
Ich muss dafür sorgen, dass die Ausführung so eines Programms nicht

01:01:37.520 --> 01:01:40.620
dazu führt, dass an anderen Stellen etwas verändert wird.

01:01:41.620 --> 01:01:45.660
Also eine gegenseitige Isolation der Prozesse zur Vermeidung und der

01:01:45.660 --> 01:01:48.740
Wünsch der gegenseitiger Beeinflussung beim Zugriff auf gemeinsam

01:01:48.740 --> 01:01:51.660
benutzte Betriebssynchronisierung von Prozessen.

01:01:51.920 --> 01:01:56.140
Wichtiges Thema, müsste ich eigentlich kurz darauf eingehen.

01:01:56.980 --> 01:01:59.120
Jetzt haben wir noch eine solche Frage.

01:02:00.840 --> 01:02:01.320
Naja.

01:02:02.460 --> 01:02:06.380
Ich bin dankbar, dass in der Vergangenheit, wenn dieses Fragetool

01:02:06.380 --> 01:02:09.840
benutzt wurde, überwiegend sehr gute Fragen gekommen sind.

01:02:10.240 --> 01:02:12.000
Was wir heute haben, habe ich sonst eigentlich nie erlebt, dass da

01:02:12.000 --> 01:02:12.620
leere Fragen stehen.

01:02:12.700 --> 01:02:15.340
Vielleicht irgendein Fehler im Programm durch eine neue Person.

01:02:15.460 --> 01:02:15.860
Weiß ich nicht.

01:02:16.840 --> 01:02:19.520
Also, das zu diesen Dingen.

01:02:20.900 --> 01:02:23.500
Vorteil des Modiprogrammbetriebs natürlich, dass ich den Rechner

01:02:23.500 --> 01:02:24.400
besser ausnutzen kann.

01:02:24.820 --> 01:02:29.200
Wenn ein Programm hier ausgeführt wird und es braucht ein

01:02:29.200 --> 01:02:33.340
Betriebsmittel, dann ist es sinnvoll, dass ich sofort das nächste

01:02:33.340 --> 01:02:37.200
Programm ausführen kann und dieses teilweise ausgeführte Programm

01:02:37.200 --> 01:02:40.020
erstmal irgendwo im Wartezustand kommt und später wieder dran kommt.

01:02:40.480 --> 01:02:43.220
Ich kann also meine Rechenanlage besser ausnutzen, wenn ich mehrere

01:02:43.220 --> 01:02:44.820
gleichzeitig laufende Programme mache.

01:02:46.180 --> 01:02:49.460
Und hier ist ein kurzes Beispiel, was da passieren kann.

01:02:50.120 --> 01:02:55.400
Wenn ich also ein Programm betrachte, getrennt voneinander, dann habe

01:02:55.400 --> 01:02:57.560
ich jeweils solche Programmausführungen.

01:02:57.640 --> 01:03:02.480
Ich habe eine gewisse Vereinfachphase, in der ich Daten eingebe, dann

01:03:02.480 --> 01:03:04.320
etwas verarbeite und dann etwas ausgebe.

01:03:05.240 --> 01:03:09.420
Wenn ich also so einen typischen Stapelbetrieb hätte, wäre das ein

01:03:09.420 --> 01:03:09.800
Programm.

01:03:10.340 --> 01:03:13.420
Wäre was eingelesen, was ausgeführt, was ausgegeben.

01:03:13.820 --> 01:03:15.020
Dann kommt das nächste Programm dran.

01:03:16.300 --> 01:03:19.640
Besser wäre es, wenn ich mehrere Programme im Prinzip nebenläufig

01:03:19.640 --> 01:03:20.400
ausführen kann.

01:03:20.540 --> 01:03:23.900
Das heißt, die Betriebsmittel meines Rechners sind gleichzeitig für

01:03:23.900 --> 01:03:25.100
mehrere Programme aktiv.

01:03:25.340 --> 01:03:29.460
Hier angedeutet, wenn Sie sich den Teil anschauen, da sind mehrere

01:03:29.460 --> 01:03:31.540
Aufträge aktiv.

01:03:31.700 --> 01:03:38.000
Und hier wird einfach gesagt, sobald Auftrag A1 die Eingabe beendet

01:03:38.000 --> 01:03:41.980
hat, kann ja Auftrag A2 auch die Eingabe schon mal machen.

01:03:42.760 --> 01:03:45.320
Währenddessen wird Auftrag A1 ausgeführt.

01:03:46.220 --> 01:03:49.260
Und wenn A2 fertig ist mit der Eingabe, macht A3 auch schon mal

01:03:49.260 --> 01:03:49.820
Eingabe.

01:03:51.020 --> 01:03:53.580
Währenddessen wird hier gerade A2 ausgeführt.

01:03:53.660 --> 01:03:55.580
A2 wird gar nicht so lange ausgeführt.

01:03:55.940 --> 01:03:59.640
Wenn A3 hier fertig ist, dann mit der Eingabe, wird ausgeführt.

01:04:00.120 --> 01:04:03.740
Und ich habe insgesamt eine deutlich kürzere Zeit für die Ausführung

01:04:03.740 --> 01:04:06.680
dieser drei Aufträge, als wenn ich die nacheinander gemacht hätte.

01:04:07.040 --> 01:04:10.000
Im Prinzip ist es das gleiche Prinzip wie das Pipelining-Prinzip.

01:04:10.520 --> 01:04:14.900
Ich habe also, wenn ich mir angebe, welche Zeiten ich hier brauche,

01:04:15.740 --> 01:04:19.240
ich habe bei einer zeitlich nicht verzahnten Ausführung halt einfach

01:04:19.240 --> 01:04:24.780
die Summe der jeweiligen Eingabe, Verarbeitungs- und Ausgabezeiten.

01:04:25.800 --> 01:04:32.380
Und wenn ich das zeitlich verzahnt mache, dann ist das in etwa so das

01:04:32.380 --> 01:04:36.180
Maximum für viele Aufträge, das Maximum dieser jeweiligen Zeiten.

01:04:37.240 --> 01:04:41.180
Und also Summe der Eingabezeiten.

01:04:41.820 --> 01:04:46.820
Die Summe der Ausführungszeiten, Summe irgendwann der Summe der

01:04:46.820 --> 01:04:49.080
Eingabezeiten, Ausführungszeiten, Ausgabezeiten.

01:04:49.620 --> 01:04:55.140
In etwa die Summe dieser Zeiten, das heißt also das Maximum der

01:04:55.140 --> 01:04:58.560
Eingabe, Verarbeitungs- und Ausführungszeiten und nicht die Summe

01:04:58.560 --> 01:04:58.880
aller diese.

01:04:59.400 --> 01:05:01.700
Eine deutliche Verkürzung kann ich dadurch erreichen.

01:05:02.320 --> 01:05:06.920
Das also Pipelining-Prinzip oder Multiprogramm-Betrieb kann meine

01:05:06.920 --> 01:05:08.280
Ressourcen besser ausnutzen.

01:05:08.840 --> 01:05:11.820
Dann gibt es natürlich auch Dialogbetrieb oder Timesharing-Mode.

01:05:12.560 --> 01:05:16.340
Ich möchte gerne, dass jeder Teilnehmer zugreifen kann.

01:05:16.760 --> 01:05:20.200
Also jeder, der hier an seinem Rechner sitzt, der möchte gerne

01:05:20.200 --> 01:05:22.440
zugreifen auf meinen leistungsfähigen Rechner.

01:05:22.860 --> 01:05:25.660
Ist die Frage, wie kann ich das denn erreichen, dass jeder Zugriff hat

01:05:25.660 --> 01:05:27.020
und meint, er wäre der einzige Nutzer.

01:05:27.400 --> 01:05:31.760
Das geht natürlich nur so, dass ich im Prinzip hier eine Zeitscheibe

01:05:31.760 --> 01:05:35.040
habe und jeder einzelne Nutzer hat für einen kleinen Augenblick

01:05:35.040 --> 01:05:36.860
Zugriff auf den Rechner und dann ist der nächste dran.

01:05:37.720 --> 01:05:42.260
Und da kleiner Augenblick bei der Verarbeitungsfrequenz von

01:05:42.260 --> 01:05:45.180
Rechenanlagen durchaus einiges an Verarbeitungskapazität bedeutet,

01:05:45.620 --> 01:05:47.860
kann ich hier viele Rechner unterstützen oder viele Teilnehmer

01:05:47.860 --> 01:05:54.040
unterstützen, gleichzeitig Aufträge ausführen und aber eben immer

01:05:54.040 --> 01:05:58.060
stückweise, jeder hat ein kleines Stück Zeit zur Verfügung, um zu

01:05:58.060 --> 01:05:59.200
kommunizieren mit dem Rechner.

01:05:59.580 --> 01:06:01.900
Das ist also der Teilnehmerbetrieb im Timesharing-Mode.

01:06:02.860 --> 01:06:07.320
Also Timesharing heißt, ich teile meine Zeit, meinetwegen eine Sekunde

01:06:07.320 --> 01:06:11.820
auf, in entsprechende Abschnitte für die einzelnen Teilnehmer, die an

01:06:11.820 --> 01:06:14.280
so einem Rechner dransitzen.

01:06:15.200 --> 01:06:19.480
Der Teilhaberbetrieb ist was anderes, zum Beispiel bei der Buchung von

01:06:19.480 --> 01:06:22.900
irgendwelchen Hotels oder ähnlichen kann es sein, dass viele

01:06:22.900 --> 01:06:27.720
Reisebüros gleichzeitig auf eine Buchungssoftware zugreifen.

01:06:28.240 --> 01:06:32.320
Da habe ich also viele Nutzer einer und derselben Software und auch

01:06:32.320 --> 01:06:33.060
das gibt es.

01:06:33.640 --> 01:06:40.280
Und ich habe dort eine Möglichkeit der Interaktion, anders als beim

01:06:40.280 --> 01:06:46.520
Batchbetrieb, kann ich eben während der Ausführung dann mal kurz noch

01:06:46.520 --> 01:06:48.780
interaktiv zugreifen.

01:06:49.940 --> 01:06:51.820
Anwendungen sind hier kurz dargestellt.

01:06:51.960 --> 01:06:55.280
Teilhaberbetrieb oder Teilnehmerbetrieb habe ich kurz schon erläutert.

01:06:55.900 --> 01:07:01.300
Die Hauptaufgabe ist eben, dass man die Antwortzeit minimieren möchte

01:07:01.300 --> 01:07:04.900
für den einzelnen Nutzer, während ich beim Batchbetrieb irgendwann

01:07:04.900 --> 01:07:08.960
meinen Auftrag abgebe und dann am nächsten Tag schaue, ob das Ergebnis

01:07:08.960 --> 01:07:12.820
da ist, kann ich beim Timesharing-Betrieb halt am Rechner sitzen und

01:07:12.820 --> 01:07:14.080
direkten Programme ausführen.

01:07:15.100 --> 01:07:18.440
Gleichzeitig mit vielen anderen bekomme ich immer ein kleines Stück

01:07:18.440 --> 01:07:19.460
der Rechenzeit zur Verfügung.

01:07:20.520 --> 01:07:23.740
Dann gibt es in technischen Anwendungen den Echtzeitbetrieb, Real-Time

01:07:23.740 --> 01:07:27.960
-Mode, ganz wichtig, also Stichwort cyberphysische Systeme.

01:07:28.240 --> 01:07:32.060
Wenn Sie technische Systeme steuern mit Informationsverarbeitung,

01:07:32.340 --> 01:07:36.900
müssen Sie manchmal Zeit, also einfach Zeitschranken einhalten.

01:07:37.140 --> 01:07:41.980
Wenn Sie zum Beispiel ein ABS-System haben und bremsen wollen, da muss

01:07:41.980 --> 01:07:46.880
die Elektronik innerhalb vorgegebener Zeitschranken reagieren.

01:07:46.980 --> 01:07:50.240
Das heißt, eventuelle Softwareprozesse müssen entsprechend ausgeführt

01:07:50.240 --> 01:07:50.560
werden.

01:07:50.940 --> 01:07:55.360
Wenn Sie Drive-by-Wire machen, lenken über Software, das muss

01:07:55.360 --> 01:07:57.420
innerhalb von Zeitschranken ausgeführt werden.

01:07:57.540 --> 01:07:59.300
Genauso bei Flugzeugsteuerung.

01:08:01.080 --> 01:08:05.340
Echtzeitbetrieb ist eine ganz wesentliche Anforderung und das hat

01:08:05.340 --> 01:08:09.360
große Auswirkungen auf die Art der Programmierung, auf die Art der

01:08:09.360 --> 01:08:10.680
Betriebsmittel, die Sie einsetzen können.

01:08:11.260 --> 01:08:14.580
Da können Sie also nicht mehr irgendwie Caches verwenden und

01:08:14.580 --> 01:08:17.540
ähnliches, weil Sie dort zugesicherte Ausführungszeiten haben.

01:08:18.920 --> 01:08:24.260
Sie brauchen dann geeignete Ein- und Ausgabegeräte dafür, Sensorik,

01:08:24.380 --> 01:08:29.020
Steuerungsventile, Sensoren, Aktoren, die halt ihren Echtzeitbetrieb

01:08:29.020 --> 01:08:30.040
umsetzen.

01:08:31.220 --> 01:08:35.480
Sie brauchen Unterbrechungsmöglichkeiten, aber eben nur innerhalb von

01:08:35.480 --> 01:08:36.080
Zeitschranken.

01:08:37.000 --> 01:08:42.180
Wenn ein Programm ausgeführt wird, das eine feste Zeitschranke hat,

01:08:42.240 --> 01:08:44.880
können Sie natürlich nicht unterbrechen, aber Sie müssen eben dafür

01:08:44.880 --> 01:08:48.220
sorgen, dass Sie innerhalb der vorgegebenen Zeitschranken alle

01:08:48.220 --> 01:08:49.320
Aufgaben erledigen können.

01:08:49.820 --> 01:08:52.660
Hier ist also das Wesentliche, die größtmögliche und zeitgerechte

01:08:52.660 --> 01:08:56.040
Verfügbarkeit der Betriebsmittel, so dass die technischen

01:08:56.040 --> 01:09:00.720
Anwendungssysteme sinnvoll gesteuert werden.

01:09:02.120 --> 01:09:04.640
Dann haben wir noch eine Art Client-Server-Betrieb.

01:09:04.720 --> 01:09:06.440
Habe ich auch schon mal darauf hingewiesen, meine ich.

01:09:07.300 --> 01:09:09.980
Das war beim Thema verteilte Systeme.

01:09:10.620 --> 01:09:15.500
Ich kann viele Funktionen auf irgendwelche Server abschieben, z.B.

01:09:15.920 --> 01:09:20.000
Dateiverwaltung, Mail-Server, WWW-Server, Druckersteuerung und

01:09:20.000 --> 01:09:22.700
ähnliche und die einzelnen Clients brauchen sich darum nicht zu

01:09:22.700 --> 01:09:27.220
kümmern, schicken Auftrag hin zum Server und erledigt die Aufgabe und

01:09:27.220 --> 01:09:29.060
kann das dann machen.

01:09:29.220 --> 01:09:35.400
Jeder Client kann also über Remote Procedure Calls oder auch Remote

01:09:35.400 --> 01:09:40.260
Method Invocation in Java Funktionen auf so einem entfernten Rechner

01:09:40.260 --> 01:09:43.960
ausführen und kann dann entsprechend die eigene Arbeit optimieren.

01:09:44.380 --> 01:09:47.480
Auch hier eine sinnvolle Verteilung von Aufgaben auf verschiedene

01:09:47.480 --> 01:09:51.060
Rechnerkomponenten, so dass man insgesamt eine möglichst effiziente

01:09:51.060 --> 01:09:54.420
Ausführung der Informationsverarbeitung erreichen kann.

01:09:55.860 --> 01:09:57.720
Was sind hier die Hauptaufgaben?

01:09:57.840 --> 01:10:03.180
Hier ist natürlich so, dass ich insgesamt beim Client-Server

01:10:03.180 --> 01:10:08.440
-Betriebssystem entfernte Prozessaufrufe möglichst effizient abwickeln

01:10:08.440 --> 01:10:09.020
muss.

01:10:09.300 --> 01:10:15.840
Dazu muss ich natürlich zunächst mal von meinem Client über eine

01:10:15.840 --> 01:10:22.600
Kommunikationsschicht zugreifen können, oder andersrum, muss von hier

01:10:22.600 --> 01:10:25.240
unten zugreifen können auf eine entsprechende Maklerschicht.

01:10:25.720 --> 01:10:29.140
Dieser Makler muss mit den geeigneten Servers den geeigneten Server

01:10:29.140 --> 01:10:32.840
liefern für die Ausführung einer bestimmten Aufgabe und die

01:10:32.840 --> 01:10:35.440
Kommunikation mit dem Server geschieht über diese sogenannte

01:10:35.440 --> 01:10:36.400
Kommunikationsschicht.

01:10:37.100 --> 01:10:39.860
Das ist wieder so eine schichtenorientierte Aufteilung von Aufgaben,

01:10:40.960 --> 01:10:43.380
sogenannte Multi-Tier-Architektur.

01:10:44.160 --> 01:10:49.020
Tier ist halt ein Tier im biologischen Sinne, sondern eine Schicht.

01:10:50.120 --> 01:10:54.480
Multi-Tier-Architektur heißt also eine Mehrschichten-Architektur und

01:10:54.480 --> 01:10:57.060
sie haben halt hier, wie gesagt, die Service-Schicht, die

01:10:57.060 --> 01:10:59.100
Maklerschicht und die Kommunikationsschicht.

01:10:59.640 --> 01:11:03.460
Ein klassisches Beispiel zur Unterstützung solcher verteilten Client

01:11:03.460 --> 01:11:08.860
-Server -Systeme ist der Common Object Request Broker, Torba, der ein

01:11:08.860 --> 01:11:13.780
solches verteiltes System, der effizient zur Verfügung steht.

01:11:15.580 --> 01:11:18.560
Genaues darüber hören Sie in anderen Vorlesungen.

01:11:19.060 --> 01:11:21.800
Diese Dinge, die man in der Kommunikationsschicht und Maklerschicht

01:11:21.800 --> 01:11:24.720
macht, also diese Sachen hier, werden manchmal aus Middleware

01:11:24.720 --> 01:11:28.400
bezeichnet, weil ich hier halt die Kommunikation, spezielle Dienste

01:11:28.400 --> 01:11:31.040
zur Kommunikation zwischen verschiedenen Rechnern mit

01:11:31.040 --> 01:11:33.100
unterschiedlichen Aufgaben abwickeln kann.

01:11:33.980 --> 01:11:36.800
Ganz modern sind Service-orientierte Architekturen.

01:11:37.360 --> 01:11:39.880
Bei Service-orientierten Architekturen habe ich im Prinzip meine

01:11:39.880 --> 01:11:43.300
Aufgaben aufgeteilt auf Dienste, auf Services.

01:11:43.580 --> 01:11:47.020
Zum Beispiel im universitären Betrieb haben wir hier mal im Rahmen der

01:11:47.020 --> 01:11:52.000
KIM -Architektur ein Service-Portal entwickelt für unterschiedliche

01:11:52.000 --> 01:11:54.300
Dinge, also für Forschung und Entwicklung, Lehre, Studium,

01:11:54.360 --> 01:11:54.980
Weiterbildung.

01:11:55.700 --> 01:11:59.000
Kennen das Studierenden-Portal, wenn sie auf Studium, KIT.edu

01:11:59.000 --> 01:11:59.620
zugreifen.

01:11:59.760 --> 01:12:03.480
Das ist die oberste Schicht, ein Service-Portal für Aufgaben.

01:12:03.820 --> 01:12:06.500
Da gibt es eine ganze Reihe Anwendungsdienste, die basieren auf

01:12:06.500 --> 01:12:09.560
Basisdiensten, die dann wiederum auf technische Infrastruktur

01:12:09.560 --> 01:12:10.200
zugreifen.

01:12:10.820 --> 01:12:17.400
Und das Ganze wird intern unterstützt durch eine sogenannte Landkarte,

01:12:17.520 --> 01:12:20.900
bei der Sie für jeden Service sehen, auf welche Ressourcen der

01:12:20.900 --> 01:12:22.380
zugreift, welche Anforderungen er hat.

01:12:23.100 --> 01:12:27.300
Und das ist also eine klassische Architektur, auch wie verschiedene

01:12:27.300 --> 01:12:31.140
Schichten mit unterschiedlichen Aufgaben.

01:12:31.400 --> 01:12:34.740
Einige Basisdienste, man hat Sicherheitsdienste und ähnliche Dinge

01:12:34.740 --> 01:12:36.240
oder Zugriffsdienste auf Dateien.

01:12:36.820 --> 01:12:41.260
Und dann Anwendungsdienste für spezielle Aufgabenbereiche im

01:12:41.260 --> 01:12:43.120
universitären Bereich, halt Forschung, Entwicklung,

01:12:43.240 --> 01:12:46.820
Informationsversorgung, Verwaltung oder Lehre, Studium und

01:12:46.820 --> 01:12:47.480
Weiterbildung.

01:12:48.020 --> 01:12:53.360
Das sind hier diese verschiedenen Themen, die hier eine Rolle spielen.

01:12:54.000 --> 01:12:57.320
Wir haben hier das Studierendenportal realisiert auf diese Art und

01:12:57.320 --> 01:12:58.660
Weise in einem größeren Projekt.

01:12:58.900 --> 01:13:02.400
Wird gerade abgelöst, teilweise durch Campusmanagement.

01:13:03.180 --> 01:13:05.260
Das erleben Sie ja täglich, was da alles so passiert.

01:13:06.760 --> 01:13:11.180
Dann wird in der Regel nicht nur ein Betriebssystem ausgeführt,

01:13:11.520 --> 01:13:16.060
sondern es gibt mehrere Betriebsarten nebeneinander.

01:13:16.840 --> 01:13:21.240
Und dann muss ich sehen, dass das entsprechend dem Aufgabenprofil

01:13:21.240 --> 01:13:22.260
unterschiedlich gemacht wird.

01:13:22.720 --> 01:13:24.960
Deswegen kann ich nachts irgendwelchen Batchbetrieb laufen lassen.

01:13:25.440 --> 01:13:27.500
Tagsüber habe ich hier den Timesharing-Betrieb.

01:13:28.360 --> 01:13:33.940
Und hier ist also dann die Aufgabe so eines kombinierten Systems dafür

01:13:33.940 --> 01:13:38.980
zu sorgen, dass ich jeweils für die richtigen Anforderungen die

01:13:38.980 --> 01:13:41.080
richtige Betriebsart zur Verfügung stelle.

01:13:41.840 --> 01:13:44.260
Deswegen habe ich dann Betriebsarten gleichzeitig nebeneinander.

01:13:44.640 --> 01:13:47.080
Das ist auf Großrechner normalerweise der Fall.

01:13:47.840 --> 01:13:52.380
Und jetzt kommen wir zu dem Punkt der Prozesse und Prozesszustände.

01:13:53.540 --> 01:13:55.860
Also jeder Prozess... Entschuldigung, das war jetzt zu schnell.

01:13:56.800 --> 01:14:03.060
Jeder Prozess, hatten wir gesagt, ist also ein Stück Code, der

01:14:03.060 --> 01:14:05.020
ausgeführt werden soll.

01:14:05.380 --> 01:14:08.900
Folge von Aktionen eines Rechners, die zu einer identifizierbaren

01:14:08.900 --> 01:14:10.600
funktionellen Einheit zusammengefasst sind.

01:14:11.180 --> 01:14:13.160
Und ich habe also meinen Programmcode.

01:14:13.620 --> 01:14:15.780
Ich habe die Daten, die verwendet werden.

01:14:16.660 --> 01:14:19.000
Ich weiß, in welchem Kontext das ausgeführt werden muss.

01:14:19.940 --> 01:14:22.140
Was sind sonst noch für Dinge erforderlich?

01:14:23.140 --> 01:14:25.980
Ich brauche oder in einem Prozess habe ich einen eigenen

01:14:25.980 --> 01:14:28.340
Kontrollfluss, in der Regel einen eigenen Adressraum.

01:14:29.960 --> 01:14:34.380
Und eine Variante sind halt die leichtgewichtigen Prozesse oder

01:14:34.380 --> 01:14:41.700
Threads, bei denen eben nicht für jeden Thread einen getrennten

01:14:41.700 --> 01:14:44.720
Adressraum habe, sondern einen gemeinsamen Adressraum.

01:14:45.180 --> 01:14:48.260
Da muss man natürlich dafür sorgen, dass ich hier entsprechend keine

01:14:48.260 --> 01:14:51.280
Probleme kriege und hier Werte überschreibe.

01:14:52.420 --> 01:14:58.100
Das ist also ein Vorteil von Prozessen, dass sie Teilaufträge zeitlich

01:14:58.100 --> 01:14:59.080
verzahnt ausführen können.

01:14:59.520 --> 01:15:03.540
Und bei mehrfältigen Programmen können sie zwischen den Threads

01:15:03.540 --> 01:15:06.580
einfacher umschalten, sind effizienter ausführbar als Prozesse mit

01:15:06.580 --> 01:15:07.820
jeweils einem eigenen Adressraum.

01:15:08.600 --> 01:15:13.440
Sie können einfacher kommunizieren, dadurch dass mehrere Prozesse auf

01:15:13.440 --> 01:15:18.060
gleichen Bereiche zugreifen können, können sie auch indirekt

01:15:18.060 --> 01:15:21.960
kommunizieren, weil ein Thread kann einen Wert setzen, der andere

01:15:21.960 --> 01:15:24.240
Prozess Thread liest daraus.

01:15:24.840 --> 01:15:30.560
Insofern haben sie dann Möglichkeiten, dass Threads kommunizieren über

01:15:30.560 --> 01:15:31.760
ihren gemeinsamen Adressraum.

01:15:33.140 --> 01:15:39.320
Und was ich Ihnen hier auf jeden Fall noch zeigen wollte, ist, dass

01:15:39.320 --> 01:15:41.580
wir bei einem Prozess verschiedene Zustände haben können.

01:15:42.380 --> 01:15:45.680
Können zunächst mal initiiert werden, dann sind sie irgendwann bereit

01:15:45.680 --> 01:15:49.820
zur Ausführung, können aktiv sein, blockiert sein oder terminiert.

01:15:49.920 --> 01:15:51.640
Und was das Einzelne heißt, wird hier dargestellt.

01:15:52.440 --> 01:15:53.780
Das sind die verschiedenen Zustände.

01:15:54.480 --> 01:15:59.900
Und jetzt geht es darum, initiiert ein Programm oder Prozess wird

01:15:59.900 --> 01:16:00.600
angestoßen.

01:16:01.000 --> 01:16:04.440
Ein Sortierprogramm soll ausgeführt werden oder irgendein anderes

01:16:04.440 --> 01:16:05.880
Programm, hohen Gehaltsabrechnung.

01:16:06.900 --> 01:16:14.340
Dann wird es häufig mehrere solche geben und ein Prozess wird bereit,

01:16:15.820 --> 01:16:21.860
wenn hier im Prinzip alle Mittel verfügbar sind, damit er ausgeführt

01:16:21.860 --> 01:16:22.500
werden kann.

01:16:22.740 --> 01:16:30.100
Braucht also eine Betriebssystemkomponente, zunächst mal ein Prozess,

01:16:30.260 --> 01:16:36.180
der initiiert wurde, mit dem Label versetzt oder belegt bereit.

01:16:37.280 --> 01:16:45.340
Und dann müssen im Prinzip die Befehle dieses Programms ausgeführt

01:16:45.340 --> 01:16:45.480
werden.

01:16:46.020 --> 01:16:50.580
Es kann es sein, dass ein Prozess, der hier gelandet ist, bei dem die

01:16:50.580 --> 01:16:53.060
bereit sind zur Ausführung, aktiv wird.

01:16:53.300 --> 01:16:59.640
Dadurch, dass der Prozess-Scheduler sagt oder der Prozess-Umschalter

01:16:59.640 --> 01:17:04.280
sagt, dass ein Programm tatsächlich ausgeführt werden soll in der CPU.

01:17:05.340 --> 01:17:07.440
Dann geht also der Maschinenbefehlszyklus los.

01:17:07.600 --> 01:17:12.120
Das wird aus den entsprechenden Orten in dem Programm, wenn die

01:17:12.120 --> 01:17:16.280
Befehle rausgeholt werden, ausgeführt, bis es irgendwann wieder eine

01:17:16.280 --> 01:17:20.200
Unterbrechung gibt, weil ich zugreife auf ein Betriebsmittel.

01:17:20.280 --> 01:17:21.940
Ich muss vielleicht eine Eingabe machen oder ähnliches.

01:17:22.540 --> 01:17:26.020
Also wenn ich aktiv gewesen bin, tatsächlich ausgeführt werde, kann es

01:17:26.020 --> 01:17:30.720
sein, dass ich dann irgendwann unterbrochen werde, weil irgendein

01:17:30.720 --> 01:17:32.860
anderer Prozess aktiv werden möchte.

01:17:33.420 --> 01:17:37.440
Oder es kann sein, dass ich blockiert werde, weil oder nicht ich,

01:17:37.580 --> 01:17:40.980
sondern der Prozess, weil er auf irgendein Ereignis warten muss.

01:17:41.100 --> 01:17:46.060
Irgendein Ausgabe-Vorgang oder Verfügbarkeit eines Betriebsmittels und

01:17:46.060 --> 01:17:48.260
dann wird er erstmal blockiert.

01:17:48.720 --> 01:17:50.420
Ist also in diesem Zustand.

01:17:51.480 --> 01:17:53.000
War aktiv, ist blockiert worden.

01:17:53.580 --> 01:17:57.280
Sofern oder sobald dieses Betriebsmittel zur Verfügung steht, kann er

01:17:57.280 --> 01:18:00.460
wiederum von blockiert auf den bereiten Zustand kommen.

01:18:00.920 --> 01:18:04.880
Das heißt, wenn ein Ausgabe-Vorgang abgeschlossen ist, kann er weiter

01:18:04.880 --> 01:18:05.680
ausgeführt werden.

01:18:06.040 --> 01:18:08.860
Dann geht er wieder in die Schlange der bereiten Prozesse rein und

01:18:08.860 --> 01:18:10.300
kann wieder ausgeführt werden.

01:18:10.300 --> 01:18:13.540
Und irgendwann wird er natürlich fertig sein, dann kommt er in den

01:18:13.540 --> 01:18:15.680
Zustand terminiert, da müssen eine ganze Reihe Dinge noch

01:18:15.680 --> 01:18:17.980
abgeschlossen werden, Speicherplastik muss freigegeben werden und

01:18:17.980 --> 01:18:18.480
ähnliche Dinge.

01:18:19.160 --> 01:18:20.740
Und dann bin ich tatsächlich mit dem Prozess fertig.

01:18:21.480 --> 01:18:25.920
Also wird ein Prozess normalerweise hier mehrfach durchlaufen,

01:18:26.520 --> 01:18:28.620
beschleifen und irgendwann dann dort rauskommen.

01:18:29.700 --> 01:18:33.700
Die Frage, wie man das macht, ist halt etwas der Zuteilung von

01:18:33.700 --> 01:18:34.360
Rechenzeit.

01:18:35.320 --> 01:18:37.020
Ich habe eine Warteschlange von Prozessen.

01:18:37.820 --> 01:18:39.940
Mein Prozessor soll diese Prozesse ausführen.

01:18:40.180 --> 01:18:41.180
Wie mache ich das am besten?

01:18:41.900 --> 01:18:46.680
Also formal angegeben, ich habe meine bereiten Prozesse, die haben

01:18:46.680 --> 01:18:49.760
alle Betriebsmittel im Prinzip zur Verfügung und sollen jetzt nur noch

01:18:49.760 --> 01:18:50.520
den Prozessor kriegen.

01:18:51.040 --> 01:18:55.740
Der Prozessor P wird frei, ist die Frage, welchem Prozess wird P als

01:18:55.740 --> 01:18:56.620
nächstes zugeteilt.

01:18:57.380 --> 01:19:01.400
Das einfachste wäre First Come, First Serve oder FIFO, First In, First

01:19:01.400 --> 01:19:01.680
Out.

01:19:01.780 --> 01:19:05.000
Ich habe eine einfache Warteschlange und muss halt so lange warten,

01:19:05.120 --> 01:19:06.340
bis ich dort ausgeführt bin.

01:19:07.260 --> 01:19:12.360
Nächste Möglichkeit wäre, dass meine Prozesse eine Priorität bekommen.

01:19:13.380 --> 01:19:22.340
Sage meinetwegen, dass der Kürzeste Priorität hat oder einer, der mir

01:19:22.340 --> 01:19:25.100
besonders gut gefällt, also irgendwelche Nummern bekommen, die werden

01:19:25.100 --> 01:19:26.840
entsprechend der Reihenfolge ausgeführt.

01:19:27.500 --> 01:19:29.420
Also ich kann das auch etwas komplizierter machen.

01:19:29.580 --> 01:19:33.000
Ich kann sagen, meine bereiten Prozesse sind eingeteilt in

01:19:33.000 --> 01:19:39.920
unterschiedliche Prioritätsebenen, L1 bis LK, jeder Prozess ist genau

01:19:39.920 --> 01:19:46.600
einer solchen Ebene drin und die Prozesse haben also unterschiedliche

01:19:46.600 --> 01:19:47.220
Prioritäten.

01:19:48.440 --> 01:19:56.880
Diejenigen in, also P von P ist größer als P von Q, wenn das P in LI

01:19:56.880 --> 01:19:57.820
ist und I kleiner J.

01:19:57.960 --> 01:19:59.720
Also L1 wird als erstes ausgeführt.

01:20:00.960 --> 01:20:08.120
Die Rechenzeit geht halt so, dass sich Rechenzeit zuteile an ein

01:20:08.120 --> 01:20:16.560
Programm oder ein Auftrag in einer Menge LI von P, wenn alle anderen,

01:20:16.760 --> 01:20:21.580
die eine kleinere Nummer haben, bereits leer sind.

01:20:22.160 --> 01:20:24.940
Das heißt, alle mit den kleineren Werten werden zunächst ausgeführt

01:20:24.940 --> 01:20:27.200
und innerhalb der Klasse mache ich das mit First Come, First Serve.

01:20:27.820 --> 01:20:32.080
Das heißt zum Beispiel, wenn ich Betriebssystemprozesse habe, die

01:20:32.080 --> 01:20:33.340
haben die höchste Priorität.

01:20:33.780 --> 01:20:36.220
Sobald ein Betriebssystemprozess da ist, wird der ausgeführt.

01:20:37.020 --> 01:20:39.680
Und irgendwann werden dann meine interaktiven Prozesse ausgeführt,

01:20:39.780 --> 01:20:43.080
Übersetzungsprozesse, Editierprozesse und mit niedrigster Priorität

01:20:43.080 --> 01:20:43.700
die Batchprozesse.

01:20:44.380 --> 01:20:46.300
Die können irgendwo im Hintergrund ablaufen, die haben keine

01:20:46.300 --> 01:20:46.820
Zeitschranken.

01:20:47.620 --> 01:20:51.480
Während der Benutzer, der interaktiv was machen möchte, der sitzt am

01:20:51.480 --> 01:20:54.920
Rechner und wartet darauf, dass sein Programm ausgeführt wird.

01:20:55.800 --> 01:20:59.740
Eine andere Sache ist Shortest Job First, der mit der kürzesten, das

01:20:59.740 --> 01:21:05.140
ist also eines der klassischen Verfahren, Shortest Job First, heißt

01:21:05.140 --> 01:21:08.740
also die mit der kürzesten erwarteten Rechenzeit, wenn das erste ist

01:21:08.740 --> 01:21:14.420
ausgeführt, hat so ein, wenn ich also hier eine Reihe von Programmen

01:21:14.420 --> 01:21:18.140
habe, alle unterschiedliche Rechenzeiten haben.

01:21:19.080 --> 01:21:22.600
Wenn ich mir die durchschnittliche Wartezeit anschaue, bei First Come,

01:21:22.660 --> 01:21:26.960
First Serve und bei Shortest Job First, habe ich bei Shortest Job

01:21:26.960 --> 01:21:31.580
First immer eine Verkürzung oder eine durchschnittlich kürzere,

01:21:31.920 --> 01:21:39.240
mittlere Wartezeit, weil die kleinen hier müssten ja sehr lange

01:21:39.240 --> 01:21:41.920
warten, bis ein langer ausgeführt wird.

01:21:42.460 --> 01:21:45.540
Da kann ich lieber wenige lange, länger warten lassen, dafür viele

01:21:45.540 --> 01:21:47.220
kleine schneller ausführen.

01:21:48.100 --> 01:21:50.620
Ich kann auch Dinge kombinieren, ich kann sagen, ich kombiniere

01:21:50.620 --> 01:21:54.600
Wartezeit und Laufzeit und habe dann eine Kombination dieser beiden

01:21:54.600 --> 01:21:55.140
Dinge.

01:21:55.660 --> 01:21:58.740
Wenn eine längere Zeit nicht ausgeführt wurde, weil er eine so lange

01:21:58.740 --> 01:22:02.880
Laufzeit hat, dann wartet er so lange, bis er irgendwann eine

01:22:02.880 --> 01:22:04.480
Priorität bekommt und trotzdem ausführt.

01:22:04.840 --> 01:22:06.140
Das kann man alles kombinieren.

01:22:06.800 --> 01:22:10.500
Ein Verfahren, das hier ein klassisches Verfahren ist, das sogenannte

01:22:10.500 --> 01:22:15.980
Round Robin-Verfahren, Zeitscheibenverfahren, ähnlich wie das, was ich

01:22:15.980 --> 01:22:17.800
Ihnen beim Timestaring schon angedeutet habe.

01:22:18.660 --> 01:22:24.740
Mein Prozess bekommt jeweils eine maximale Prozessorzeit zugeteilt.

01:22:25.240 --> 01:22:31.440
Also dieser Prozess PI soll jetzt Rechenzeit zugeteilt bekommen und

01:22:31.440 --> 01:22:33.840
dann geht es also nach diesem Round Robin-Verfahren.

01:22:34.460 --> 01:22:39.500
Jeder Scheibe ist hier ein Prozess zugeordnet und ich habe also hier

01:22:39.500 --> 01:22:44.020
den Prozessor und dieser Prozessor da oben, der soll, wird also seine

01:22:44.020 --> 01:22:47.420
Aufmerksamkeit immer für einen bestimmten Zeitabschnitt in einzelnen

01:22:47.420 --> 01:22:49.500
Prozessen zuordnen.

01:22:50.320 --> 01:22:52.440
So läuft die Scheibe darum.

01:22:53.720 --> 01:22:59.300
Und dann kann ich entsprechend meine Programme ausführen.

01:22:59.420 --> 01:23:03.080
Das heißt, wenn ich Befehle oder wenn ich Programme habe oder Prozesse

01:23:03.080 --> 01:23:08.100
habe, die so wie hier angedeutet ausgeführt werden, sollten der eine

01:23:08.100 --> 01:23:10.680
sehr lang, die anderen relativ kurz und ich habe deswegen zehn

01:23:10.680 --> 01:23:13.580
Millisekunden zur Verfügung für die Ausführung.

01:23:14.540 --> 01:23:17.380
Oder hier steht, ich habe 16 Millisekunden zur Verfügung.

01:23:18.020 --> 01:23:20.900
Dann würde ich den ersten ausführen, der steht vorne in der Schlange,

01:23:21.360 --> 01:23:22.800
16 Millisekunden lang.

01:23:22.940 --> 01:23:26.000
Dann kommt der nächste dran, P2 braucht nur 12 Millisekunden.

01:23:26.640 --> 01:23:28.980
Danach kommt sofort der dritte dran, der braucht wieder 12

01:23:28.980 --> 01:23:29.580
Millisekunden.

01:23:30.180 --> 01:23:34.020
Dann kommt P4 dran, der hat 32, die ersten 16 werden ausgeführt.

01:23:34.840 --> 01:23:40.460
Und dann kommt, also jetzt der hier kommt da dran, dann wird wieder P1

01:23:40.460 --> 01:23:44.840
ausgeführt mit dem nächsten Stück Rechenzeit, wieder 16 Sekunden.

01:23:45.360 --> 01:23:49.220
Danach nochmal P4, dann ist P4 fertig und dann wird entsprechend P1

01:23:49.220 --> 01:23:53.100
ausgeführt, sofern nicht schon wieder weitere Prozesse in dieser

01:23:53.100 --> 01:23:54.700
Schlange hier angekommen sind.

01:23:55.400 --> 01:23:56.460
Also das ist das Round Robin.

01:23:57.580 --> 01:24:00.200
Und was hier anders ist bei den anderen Verfahren ist, dass ein

01:24:00.200 --> 01:24:04.780
Programm ausgeführt wird, ein Prozess und dann unterbrochen wird und

01:24:04.780 --> 01:24:06.920
irgendwann später wieder weiter ausgeführt wird.

01:24:07.020 --> 01:24:09.860
Das heißt, ich muss hier einen Prozess unterbrechen.

01:24:11.000 --> 01:24:13.420
Und das nennt man ein sogenanntes Preemptive Scheduling.

01:24:13.920 --> 01:24:18.540
Das heißt, ein Prozess wird unterbrochen, vorzeitig, wird also

01:24:18.540 --> 01:24:23.240
vorzeitig geleert, Preemptive, bevor er fertig ist, wird der Prozessor

01:24:23.240 --> 01:24:25.100
geleert, kommt der nächste rein.

01:24:25.840 --> 01:24:29.220
Beim Non-Preemptive Scheduling muss ich warten, bis er fertig ist und

01:24:29.220 --> 01:24:29.680
selbst raus.

01:24:30.380 --> 01:24:35.720
Wenn ich also Preemptive Scheduling mache, wie beim Round Robin, dann

01:24:35.720 --> 01:24:40.260
unterbreche ich die, weil irgendein anderes Programm darauf zugreifen

01:24:40.260 --> 01:24:46.500
möchte und danach wird halt entsprechend der nächste hier ausgeführt.

01:24:46.820 --> 01:24:48.320
Das sind Zeitscheibenverfahren.

01:24:48.960 --> 01:24:52.160
Dann müsste ich Ihnen eigentlich jetzt noch einiges erzählen über

01:24:52.160 --> 01:24:56.620
Hauptspeicherverwaltung, Paging-Verfahren, was ich jetzt leider hier

01:24:56.620 --> 01:24:59.040
nicht mehr schaffe in der heutigen Vorlesung.

01:24:59.300 --> 01:25:03.960
Ich müsste Ihnen was erzählen darüber, wie man hier Seiten vom

01:25:03.960 --> 01:25:07.000
Hintergrundspeicher in den Hauptspeicher hinein lädt über

01:25:07.000 --> 01:25:11.640
Seitentabellen, die dafür sorgen, dass ich entsprechend eine

01:25:11.640 --> 01:25:16.080
Seitenadresse in eine Seitenrahmenadresse im Hauptspeicher umsetzen

01:25:16.080 --> 01:25:16.400
kann.

01:25:17.460 --> 01:25:19.960
Ich müsste Ihnen hier darstellen, was genau passiert über die

01:25:19.960 --> 01:25:20.640
Seitentabellen.

01:25:21.240 --> 01:25:24.800
Und dann kommt noch das Thema der Synchronisation von Prozessen.

01:25:24.800 --> 01:25:28.940
Bei denen man aufpassen muss, dass nicht auf die gemeinsamen

01:25:28.940 --> 01:25:33.660
Ressourcen zugegriffen wird und dadurch Reihenfolgen verändert werden

01:25:33.660 --> 01:25:38.640
und unterschiedliche Ergebnisse daraus ergeben, je nachdem, in welcher

01:25:38.640 --> 01:25:42.740
Reihenfolge ich verschiedene Programme, Programmteile in meinem

01:25:42.740 --> 01:25:43.580
Rechner ausführe.

01:25:44.200 --> 01:25:45.140
Das ist die Synchronisation.

01:25:45.920 --> 01:25:51.300
Dazu gibt es viele interessante Themen, die man durch den

01:25:51.300 --> 01:25:54.180
wechselseitigen Ausschluss dann erledigen möchte, also das

01:25:54.180 --> 01:25:55.580
Synchronisieren.

01:25:56.560 --> 01:26:00.400
Und auch dazu gibt es hier einiges, was man da erzählen können.

01:26:00.980 --> 01:26:04.220
Als schönes Abschlussbild möchte ich Ihnen das Philosophenproblem noch

01:26:04.220 --> 01:26:05.100
mal kurz darstellen.

01:26:05.440 --> 01:26:10.560
Da haben sie ein klassisches Problem, dass sie viele Ressourcen oder

01:26:10.560 --> 01:26:16.180
viele Auftraggeber haben, die auf Ressourcen zugreifen wollen.

01:26:16.640 --> 01:26:19.960
Die wollen etwas essen, diese ganzen Philosophen hier, brauchen dafür

01:26:19.960 --> 01:26:21.440
zwei Gabeln.

01:26:21.620 --> 01:26:25.180
Und wenn jeder auf zwei Gabeln zugreifen möchte, aber aus

01:26:25.180 --> 01:26:30.180
Sparsamkeitsgründen, wie es halt so ist bei Philosophen, nur zwischen

01:26:30.180 --> 01:26:33.720
zwei Tellern nur eine Gabel liegt, dann können eben nicht zwei

01:26:33.720 --> 01:26:36.500
nebeneinanderliegende gleichzeitig essen, sondern die müssen sich

01:26:36.500 --> 01:26:37.220
irgendwie absprechen.

01:26:37.980 --> 01:26:41.260
Wenn sie Pech haben und alle machen immer genau das Gleiche, würden

01:26:41.260 --> 01:26:45.740
sie alle gleichzeitig ihre rechte Gabel nehmen und brauchen auch noch

01:26:45.740 --> 01:26:46.440
die linke Gabel.

01:26:46.480 --> 01:26:48.380
Die hat aber schon der Nachbar und dann warten sie darauf, dass der

01:26:48.380 --> 01:26:48.900
fertig wird.

01:26:48.980 --> 01:26:49.640
Der wird nie fertig.

01:26:50.220 --> 01:26:55.200
Wir haben auf einmal Probleme wie Deadlock, Starvation im wahrsten

01:26:55.200 --> 01:26:58.320
Sinne des Wortes, weil die nicht essen können oder Fairness, dass

01:26:58.320 --> 01:27:01.060
eigentlich jeder irgendwann mal essen können soll.

01:27:01.600 --> 01:27:03.340
Was haben Philosophen mit Rechnern zu tun?

01:27:03.860 --> 01:27:07.520
Im Rechner haben wir auch viele verschiedene aktive Komponenten, die

01:27:07.520 --> 01:27:10.540
zugreifen wollen auf Ressourcen und sie müssen dafür sorgen, dass die

01:27:10.540 --> 01:27:13.380
alle irgendwann fair auf ihre Ressourcen zugreifen können.

01:27:14.380 --> 01:27:17.120
Es gibt noch viele weitere Themen, die ich hätte ansprechen können.

01:27:17.680 --> 01:27:22.040
Es ist wirklich ärgerlich, dass ich anscheinend meine Zeit zu Beginn

01:27:22.040 --> 01:27:26.480
etwas großzügiger verwendet habe und Ihnen dadurch etwas intensiver

01:27:26.480 --> 01:27:29.060
erzählt habe, was es in dieser Vorlesung geht.

01:27:29.980 --> 01:27:33.240
Die Inhalte liegen seit einiger Zeit auf dem Server.

01:27:34.000 --> 01:27:35.700
Schauen Sie sich die restlichen Folien an.

01:27:36.300 --> 01:27:37.920
Es tut mir leid, dass ich Ihnen die nicht mehr vorstellen kann.

01:27:38.400 --> 01:27:41.400
Es ist auch noch das Kapitel 11 dabei, das jetzt für die Klausur am

01:27:41.400 --> 01:27:43.620
Ende der Vorlesung eine Rolle spielt.

01:27:44.020 --> 01:27:47.960
Es ist noch ein Kapitel 12 da drauf, Zusammenfassung, wo nochmal die

01:27:47.960 --> 01:27:49.500
wesentlichen Punkte aufgeführt werden.

01:27:50.100 --> 01:27:55.180
Und wie gesagt, es sind eine ganze Reihe wichtige Punkte hier in

01:27:55.180 --> 01:27:56.560
dieser Vorlesung präsentiert worden.

01:27:57.080 --> 01:28:00.820
Es ist eine ziemlich große Menge an Informationen.

01:28:01.040 --> 01:28:01.620
Das weiß ich.

01:28:02.060 --> 01:28:04.020
Großer Stoff, sehr umfangreicher Stoff.

01:28:05.240 --> 01:28:09.160
Aber Wirtschaftsingenieure müssen nun mal in einer konzentrierten Form

01:28:09.160 --> 01:28:11.620
die wesentlichen Punkte präsentiert bekommen.

01:28:11.820 --> 01:28:15.400
Ich hoffe, dass es mir gelungen ist, bei Ihnen so ein bisschen

01:28:15.400 --> 01:28:19.400
Interesse auch zu wecken an den Themen, die hier eine Rolle spielten.

01:28:19.500 --> 01:28:24.900
Dass Sie einen Eindruck bekommen haben, welche Möglichkeiten, welche

01:28:24.900 --> 01:28:29.380
Begrenzungen und welche Chancen es gibt durch Informationstechnologie.

01:28:30.400 --> 01:28:33.740
Das war eigentlich der wesentliche Sinn dieser Vorlesung, Ihnen die

01:28:33.740 --> 01:28:37.100
Grundlagen zu geben dafür, dass Sie anschließend in sinnvoller Art und

01:28:37.100 --> 01:28:40.500
Weise weiter mit Informationsverarbeitung arbeiten können an

01:28:40.500 --> 01:28:41.260
verschiedenen Stellen.

01:28:41.840 --> 01:28:43.100
Kommen Sie in unsere Vorlesungen.

01:28:44.060 --> 01:28:46.700
In meinem Bereich, wissen Sie, gibt es viel im Zusammenhang mit

01:28:46.700 --> 01:28:49.520
selbstorganisierenden adaptiven Systemen, gerade im Bereich Energie,

01:28:50.060 --> 01:28:51.060
aber auch in anderen Themen.

01:28:51.600 --> 01:28:52.880
Effiziente Algorithmen spielen eine Rolle.

01:28:53.020 --> 01:28:55.240
Bei meinen Kollegen sind eine ganze Reihe anderer Themen abgedeckt.

01:28:55.800 --> 01:28:59.840
Schauen Sie sich den Abschnitt oder das Kapitel 12 Zusammenfassung an.

01:28:59.900 --> 01:29:02.400
Da sind ein paar Hinweise gegeben, was für Themen bei uns noch

01:29:02.400 --> 01:29:02.880
auftauchen.

01:29:03.340 --> 01:29:08.460
Ich wünsche Ihnen viel Erfolg in der Klausur nächsten Montag.

01:29:09.020 --> 01:29:11.960
Bereiten Sie sich vor, Sie sollten jetzt schon gut vorbereitet sein.

01:29:12.420 --> 01:29:16.600
Nutzen Sie die Möglichkeiten der Tests diese Woche, jeden Tag über die

01:29:16.600 --> 01:29:17.600
Apps können Sie das nutzen.

01:29:18.340 --> 01:29:21.380
Und ansonsten haben Sie das Forum, wo Sie Fragen stellen können.

01:29:21.500 --> 01:29:26.000
Unsere Doktoren, Mitarbeiter stehen für Sie bereit, dort zu antworten.

01:29:26.240 --> 01:29:27.900
Also, ich hoffe, ich sehe Sie noch mal wieder.

01:29:28.460 --> 01:29:30.520
Mir bringt es immer Spaß, Ihnen Stoff zu vermitteln.

01:29:30.900 --> 01:29:32.280
Ich hätte nur gerne ein bisschen mehr Zeit dafür.

01:29:33.180 --> 01:29:34.460
Also, vielen Dank!