So. Ja, also herzlich willkommen zur Rechnerstrukturenvorlesung. Mein Name
ist Andreas Meder. Ich werde dieses Jahr Rechnerstrukturen lesen.
Wie sie schon gesehen haben, kämpfen wir noch ein bisschen mit der Technik.
Ich bitte das zu entschuldigen auf dem Lecture to Go.
Sieht das Format vernünftig aus. Hier auf dem Beamer wird
das also irgendwie jetzt in ein Querformat umgerechnet. Gut,
das ist wieder so ein bisschen irgendwie das Problem mit den jeweiligen Anschlüssen,
Anschlussboxen. Ich hoffe mal, dass wir das Ganze dann
also bis zum nächsten Termin dann alles weit beseitigt haben.
Nichtsdestotrotz sollte jetzt soweit eigentlich alles funktionieren. In dem Fall
wird das jetzt also hier auch nicht weiter stören.
Ja, heute zum ersten Termin werde ich erstmal so ein
bisschen allgemeine Informationen geben.
Sprich, wie soll die Rechnerstrukturen
Vorlesungen ablaufen
Hoffe ich zumindest, werden Sie daraus mitnehmen.
Anschließend ein bisschen noch was so an Motivation vorstellen und eben
so noch einige Informationen darzubringen. Zu dem Ganzen vielleicht nochmal,
hier oben sehen Sie auch schon einen entsprechenden Link,
über den Sie dann also zu den Informationen zu den Folien kommen.
Alles, was ich hier vorstelle,
beziehungsweise dann eben auch die Übungsaufgaben, sind online direkt abrufbar.
In der Regel auch immer schon vor der Vorlesung. Das heißt,
wenn sich da also jetzt nochmal irgendwelche Sachen,
also jetzt in einem PDF annotieren wollen oder so weiter,
können sie das dort entsprechend dann alles schon finden und runterladen.
Die Sachen sind auch unter Stine verlinkt. Nichtsdestotrotz muss ich immer sagen,
also das, was wir eigentlich haben,
beziehungsweise wo wir die Unterlagen dann auch entsprechend lassen,
ist dann im Prinzip auf den Fachbereichswebseiten.
Einfacher, sagen wir mal, aus Gründen der Aktualität,
weil das ist zentral, das liegt bei mir ganz normal
im Dateisystem und zumindest so einige Änderungen beziehungsweise Ergänzungen an den Folien,
muss ich sagen, sind also irgendwie von heuten Mittag.
Also von daher kann man das dann immer relativ aktuell halten.
Gut, vielleicht jetzt zum Hintergrund. Ich bin bei einem der vielen Arbeitsbereiche oder Professoren,
wie sie jetzt hier heißen, im Fachbereich, Tumps,
Akronym steht für Technical Aspects of Multimodal Systems,
technische Aspekte, multimodale Systeme, grausiges Akronym,
dahinter verbirgt sich im Prinzip als das, was wir als zack,
daneben.
Das, was wir als Forschung machen, grob besagt, Robotik. Das heißt,
wir haben da also mehr oder minder größere oder kleinere Roboterplattformen,
wo dann also jetzt verschiedene Forschungsprojekte,
Handhabung von Objekten greifen und so weiter, letztendlich laufen.
Das wird Ihnen hoffentlich, vielleicht auch noch später im Laufe
des Studiums begegnen, sind wir jetzt noch weit davon weg.
Jetzt erst mal bei den ganz einfachen Grundlagen, wo es
erst mal darum geht, wie Rechner arbeiten, wie Rechner funktionieren.
Gut, aber noch mal auf die Webseiten zurück.
Also wie gesagt, wenn man auf den Fachbereichs-Webseiten ist,
also irgendwie ist die WLAN-Verbindung jetzt wieder ein bisschen langsam.
Gut, also versuchen wir das noch mal so rum.
Also im Prinzip ist, wenn man also auf den Fachbereichs-Webseiten ist,
kann man sich zu den Arbeitsbereichen durchklicken irgendwann,
dann wird man da eben auch bei Trumps.
Und dort ist dann eben entsprechend prominent hier unter Vorlesungen beim
aktuellen Semester dann also Rechnerstrukturen, Übungen, Informationen zum Tutorium.
Wie gesagt, die ganzen Inhalte werde ich gleich noch ein bisschen kurz vorstellen.
Und wie gesagt, hier findet sich dann eben alles zur Vorlesung.
Jeweils aktuell auch ergänzt irgendwelche Aktualitäten. Da auch gleich der Hinweis,
ich weiß nicht, inwieweit sie das jetzt also schon
in Stine gesehen haben
Möglich ist der Freitagstermin im Audi Max 2,
dass dort beim guten Bauzustand der Universität gerade mal wieder technische Probleme gibt und
diese Trennwand zum Audi Max 1 nicht bewegt werden kann,
können wir den Hörsaal dort bis schätzungsweise Mitte Dezember nicht bespielen.
Deswegen wird Freitag die Vorlesung dann in der roten Baumschassee
gegenüber im Rechtshaus in dem Hörsaal
dort stattfinden
Gut, wie gesagt, also hier finden sich dann immer aktuelle Informationen,
verweise auf die Übung, verweise auf das Tutorium,
eine Referenz dann hier auf den Stundenplan,
die jeweiligen Übungsgruppen und so weiter und so fort und dann eben auch jeweils als Unterlagen die Vorlesungsskripte,
also sprich das,
was ich jetzt gleich anfangen würde hier als PDF vorzustellen,
also einmal ein bisschen was Allgemeines zur Organisation,
dann eben jetzt erst mal gerade neu erstellt und dort abgelegt,
dann also jetzt die ersten beiden Kapitel der Vorlesungsfolien.
Außerdem finden sich dort dann eben auch noch einige Literaturverweise,
irgendwelche Links zu interessanten Seiten,
Hintergrundmaterial und so weiter und so fort.
Das wird dann immer begleitend zur Vorlesung entsprechend ergänzt.
Gut, dann kommen wir jetzt also hier
nochmal wieder zu diesen Infos zurück
Tja. Also, das,
was ich jetzt hier erstmal so ein bisschen vorstelle lässt,
also überhaupt erstmal, wie ist Rechnerstrukturen eingeordnet,
also hier der entsprechende Text aus dem entsprechenden Modulhandbuch,
wo es dann eben darum geht, dass man sagt,
okay, also Rechnerstrukturen geht es eben letztendlich darum,
die Grundlagen der Rechnertechnologie kennenzulernen, sprich grob gesagt,
das,
was sie hier lernen sollen,
ist die Art und Weise,
wie Rechner funktionieren
Weil im Prinzip Programmierung,
sowas haben sie was vielleicht schon in der Schule jeweils gemacht,
wie das aber dann letztendlich da drunter aussieht,
wie man mit der Hardware das also schaffen kann,
entsprechend die Programme abzuarbeiten, warum diese Kisten so erfolgreich sind,
weswegen das eben vielleicht für sie dann interessant ist.
Also hier Informatik zu studieren, das soll dann eigentlich letztendlich
dann dort alles vermittelt werden. Gut, ansonsten denke ich mir,
werden sie hier eben entweder als Bett Schlagstudenten oder eben als Studenten der Software-Systementwicklung hier sitzen,
beziehungsweise gut nebenfach wird man dann eben auch entsprechend hier sein.
Gut, was wird jetzt hier also inhaltlich behandelt? Zum einen geht es um allgemeine Grundlagen,
was ist Information, wie wird Information kodiert,
wie werden Zahlen dargestellt, wie werden Buchstaben,
Zeichensysteme dargestellt, dann darauf aufbauen im Prinzip,
wie die Arrethmetik funktioniert, das heißt also,
wie so ein PC oder ein Rechner jetzt überhaupt erstmal rechnen kann in das jeweilige Zahnsystem,
dann, wie das Ganze digital-technisch umgesetzt wird.
Und es kommt dann eben auch noch ein bisschen was zu den drunter liegenden Hardware-Strukturen.
Das heißt also, wie man letztendlich jetzt mit dem,
was, also quasi im Ship, im Prozessor innen drin ist,
wie man damit erreicht, dass das Ganze dann eben letztendlich technisch umgesetzt wird.
Das wird nur relativ kurz angesprochen. Anschließend geht es dann eigentlich zu dem etwas interessanteren Tal der Rechner Architektur,
wo es also im Prinzip um die Prinzipien geht,
wie die Rechner funktionieren, wie Instruktionssätze von Rechnern aufgebaut sind,
dann so ein bisschen was zum Maschinencode zur Assembler-Programmierung,
das heißt zu dem, was unten dabei rauskommt,
wenn sie jetzt also ein Hochsprachenprogramm in irgendeiner Programmiersprache geschrieben haben,
das entsprechend übersetzen und anschließend dann eben sagen,
das soll dann eben von der Maschine entsprechend ausgeführt werden
Und dann geht es eben noch ein bisschen mehr jetzt zur Architekturprinzipien. Das heißt,
Pipelining, Superskalare,
Architekturen werden kurz vorgestellt,
wird noch ein bisschen was zur Speicherhierarchie kommen und dann letztendlich abhängig davon,
wie weit wir jetzt kommen im Laufe der Vorlesung,
wird dann also noch ein bisschen was zur Umgebung der Rechner vorgestellt werden,
beziehungsweise wenn die Zahl dann eben auch noch ein bisschen reicht,
in die technischen Grundlagen
nochmal kurz eingestiegen werden
Gut, generell zu der Vorlesung kann ich immer nur sagen,
Feedback wird erwünscht, gerne genommen,
einfach per E-Mail an mich, beziehungsweise ansonsten,
wenn ich jetzt also hier irgendwie was vorstelle, zwischen Fragen,
wenn irgendwas unklar ist oder wenn ich dann also jetzt vor dem Hintergrund,
dass man da ja sagen wir mal so als Fachidiote,
also irgendwas relativ schnell oder einfach erklärt,
wenn das also bei ihm nicht angekommen ist,
dass sie da dann nochmal entsprechend Ich möchte darauf hinweisen,
beziehungsweise ich deine Sachen nochmal anders oder genauer erklären kann.
Gut, ein bisschen das Problem, also generell bei dieser Vorlesung ist immer,
ich weiß jetzt immer nicht, wie das das jetzt mit ihrem Vorwissen ist.
Ich denke mal, einige von ihnen werden also zum Thema Informatik
schon was in der Oberstufe gehört haben. Einige werden aus Eigeninteresse,
weil man jetzt selber also irgendwie einen Computer hat,
damit bastelt, schon mehr oder minder tief eingestiegen sein,
da man das letztendlich dann sowieso immer nicht Genau,
jetzt allen hundertprozentig richtig machen kann,
muss ich mich jetzt also immer so ein bisschen dafür entschuldigen,
dass ich sage, okay, also Voraussetzung,
hier ist erstmal kein bis wenig Vorwissen.
Gerade bei Rechnerstrukturen trifft das eigentlich immer ganz gut den Kern.
Deswegen zwei Punkte. Zum einen muss ich sie dann immer um Geduld bitten,
wenn ich jetzt also gerade am Anfang vielleicht also irgendwelche Sachen erkläre,
wo sie sagen, na gut, das ist trivial,
das habe ich schon fünfmal gehört.
Was bespaßt, da möchte ich jetzt also irgendwie wochenlang Ich denke mal,
das wird später nach den ersten sieben,
acht Terminen dann sicherlich, also auch zu irgendwelchem Stoff kommen,
den sie also noch nicht kennen, noch nicht gehört haben,
was dann eben auch entsprechend interessant hoffentlich sein wird.
Auf der anderen Seite kann es eben sein,
dass also gerade, wenn jetzt das auch,
kenne ich immer aus den vorigen Jahren,
also wenn jetzt irgendwelche Fragen kommen und man dann also auf einmal in irgendwelche Fachsimplein geht,
dass sich dann einige,
also irgendwie so ein bisschen abgehängt fühlen,
auch da kann man immer nur sagen,
sollte man sich nicht
von frustrieren lassen
Zum einen gibt es da dann immer noch Möglichkeiten in den Tutorien,
in Übungsgruppen weitere Fragen zu stellen,
beziehungsweise ansonsten eben natürlich direkt vor Ort,
dann also auch jetzt hier mich nochmal zu fragen,
beziehungsweise ich hoffe dann auch immer,
dass ich also jetzt mit irgendwelchen Literaturverweisen,
mit irgendwelchen anderen Informationen, also auch noch so viel Hintergrund,
Material mitliefer,
dass sie dann also auch noch mit ein bisschen argen Initiative im Zweifelsfall da dann eben auch noch nachkommen können.
Das heißt, das sollte dann auch
kein Problem werden
Gut, hier nochmal allgemeine Kontaktinformation. Das ist jetzt eigentlich
nur zum Nachschlagen. Gut, womit arbeiten wir jetzt?
Also jetzt hier eben natürlich erstmal die Vorlesung,
sprich zu den entsprechenden beiden Terminen. Wie gesagt,
wichtig, solange ich nichts anderes behaupte, wird da Freitagstermin,
also im Rechtshaus in der roten Baumschossee stattfinden.
Die Folien, wie gesagt, sind vor der Vorlesung zum Download verfügbar.
Dann haben wir eben hier Kamera und Tonaufzeichnung beziehungsweise eben noch diese Splitterbox dazwischen,
die also quasi das, was ich hier also auf dem Monitor habe,
eben entsprechend mit aufzeichnet.
Das Ganze läuft dann eben als Electure to go und man
kann sich das dann eben hier unter entsprechendem Link dann eben auch direkt runterladen.
Eigentlich hätte ich dann hier auch irgendwo einen direkten Link
schon zur Rechnerstrukturen quasi so als Kanal drinstehen,
da das heute das erste Mal ist,
wird das dann also noch nicht kommen
Komme ich gleich drauf zurück. Eine Sache noch zu dem Lecture to go,
in der Regel, weil die Sachen immer noch ein bisschen nachbearbeitet werden,
dauert das so zwei bis drei Tage,
bis die Vorlesungen dann oder diese Videos dann eben entsprechend online stehen.
Ich aber dann können Sie dann das nehmen,
um dann also vielleicht Beordnetlarheiten oder in der Klausurvorbereitung da nochmal drauf reinzugehen.
So ist ja eine Frage. Die Frage war,
also ob es ein Livestream gibt,
den gibt es jetzt hier bei dieser Art Lecture to go,
wo jetzt die Vorlesung aufgezeichnet wird,
nicht Das kann man sich dann eben wirklich nur offline hinterher ansehen.
Also im Prinzip bietet das System die Möglichkeit,
aber da die Übertragungskapazitäten also relativ begrenzt sind, ist das eigentlich immer was,
was dann also nur für wenige spezielle Veranstaltungen gemacht werden kann.
Gut, ansonsten werde ich jetzt also hier auch gleich nochmal,
beziehungsweise hier in diesen Vorlesungsfolien, finden Sie das dann auch relativ viel an Literaturverweisen mitgeben.
Die meisten Sachen, nein, eigentlich alles, was ich da also vorstelle,
haben wir auch in mehr oder minder aktuellen Versionen in der Fachbereichsbibliothek, das heißt,
dort können sich dann eben auch nochmal die Bücher ausleihen und dort nochmal nachschlagen oder ansehen.
Ansonsten werden wir hier relativ einfache, relativ wenig Software,
also irgendwie rein praktisch benutzen, auch in den Übungen,
ist im Prinzip also nur eine Java-VM irgendwann mal benötigt,
also um dann also nachher den Schaltungssimulator laufen zu lassen,
sowas wie Ein C-Compiler,
der dann nachher so für die Assembler-Sachen benötigt wird.
Dazu würde ich dann speziell noch mal ein bisschen was sagen.
Da gibt es dann die Möglichkeit, wenn man jetzt also nicht gerade sagt,
also ich bin jetzt also hier derjenige,
der es also hier irgendwie ein lauffähiges Linux am Start hat.
Es wird dann auch die Möglichkeit geben, im Prinzip fertig
installiertes System in Form einer virtuellen Maschine laufen zu lassen.
Werde ich, wenn das aktuell sein wird,
dann also noch mal darauf hinweisen,
beziehungsweise vielleicht also auch noch mal eine kurze Live-Vorführung machen,
wie sowas aussieht, das werde ich dann also passend vorbereiten,
wird dann eben auch bei uns auf den Webseiten ganz normal zur Verfügung stehen.
Wie gesagt, also dort sollen die Sachen dann mehr oder minder aktuell rumstehen.
Gut, zu den Übungen, Rechnerstrukturen, geplant sind 19 Gruppen.
Die sind also auch schon entsprechend über Stine verteilt worden.
Das ist dann eben jeweils eine Semesterwochenstunde wöchentlich.
Übungsbeginn ist dann regulär im Prinzip ab der nächsten Woche.
Sprich Montag, Dienstag, Mittwoch sind dann ja immer
jeweils die Übungsgruppen
Dort geht es letztendlich darum, also zum einen so ein bisschen was zur Vorlesung vielleicht noch zu klären,
wenn offene Fragen sind ansonsten, dann natürlich die Übungsaufgaben teilweise vorzubesprechen.
In der Regel nachzubesprechen, beziehungsweise nachzurechnen. Zu den Übungen bzw. zum Übungsbetrieb,
das werden die Übungsgruppenleiter dann also auch noch sagen,
wird das Ganze dann so aussehen,
dass sie also da jetzt nicht als Einzelkämpfer auftreten müssen bzw. sollen,
sondern dann in Zwei bis Dreiergruppen, entsprechend jeweils ein Übungszettel bearbeiten.
Das heißt, da kann man sich dann also auch so ein bisschen mit irgendwelchen Kommilitonen,
sagen wir mal so, den Arbeitsaufwand teilen. Was natürlich nicht heißt,
dass man sich dann also irgendwie dann also von zwei Dritteln des Inhalts verabschiedet,
sondern spätestens zur Klausur sollte das dann natürlich entsprechend drauf sein,
weil, also da kann ich auch schon sagen, also das,
was dann in der Regel so an Surraufgaben auftaucht,
wird sich eigentlich im Großen und Ganzen mit den Typen der Übungsaufgaben decken.
Das heißt also, wenn man das also als Vorbereitung dann
für die Klausur dann eben auch entsprechend drauf hat,
sollte dann also auch die Klausur jetzt also nicht irgendwie ein unüberwindliches Hindernis werden.
Auch dazu werde ich dann am Ende der Vorlesung,
wenn das an die Klausur geht, da nochmal genauer was sagen,
beziehungsweise dann eben auch nochmal einen Termin abmachen,
dass wir dann also im SV HSV nochmal sowas wie eine Probeklausur machen,
beziehungsweise nochmal so ein Futorium als Vorbereitung, um da dann eben wirklich entsprechend Alle möglichst gut zu unterstützen.
Gut, bei den Übungsaufgaben sieht das eben so aus,
die werden jeweils mittwochs online gestellt. Das heißt,
jetzt sieht das eben auch schon so aus,
dass ich irgendwann heute Mittag sind sie dann endlich mal fertig
Dass ich da dann eben auch nochmal die Übungsaufgaben,
soweit ich schon online habe, das wird dann so aussehen,
dass in der nächsten Woche quasi das,
was das Aufgabenblatt 0 bezeichnet ist, durchgearbeitet wird,
das ist dann quasi eine Art Präsenzaufgabe.
Das heißt, da müssen sie jetzt also nichts ausfüllen und machen.
Sie können sich das oder es ist vielleicht nicht verkehrslich,
das ist also vorher alles schon mal anzusehen,
wird dann aber eben in den Übungsgruppen vor Ort
besprochen bzw. damit gearbeitet
Ansonsten gibt es dann aber eben auch schon das erste Aufgabenblatt.
Eigentlich wäre bei dem Aufgabenblatt dann natürlich also irgendwie Abgabe auch
schon der nächste Mittwoch. Ist jetzt natürlich,
sagen wir mal, mehr als unfair, wenn für die Leute,
die jetzt also quasi am Mittwoch, Vormittag ihre Übungsgruppe haben,
wenn sie dann also abends das Übungsplatt schon abgeben sollen.
Deswegen wird es nächste Woche dann so aussehen,
dass die Übungen dann eben besonderstag abgegeben werden
Ja, ansonsten haben wir das eigentlich immer so,
dass man sagt, okay,
die Übungen werden quasi per E-Mail an den Übungsgruppenleiter geschickt,
sollen dann eben quasi bis Mittwoch Mitternacht letztendlich irgendwann passiert sein.
Und wie gesagt, Mittwoch ist ja auch immer jeweils Ausgabe der Übungen.
Das heißt, sie haben dann also jeweils eine Woche Zeit,
um den Übungszettel zu bearbeiten. Gut, hier nochmal kurz zusammengefasst,
für die Übungen gibt es dann eben auch entsprechende Scheinkriterien,
auch über die Webseiten als PDF irgendwie runterladbar.
Man kann einfach nur sagen, okay, also um den Rechnerstruktur und Übungsschein zu bekommen.
Sie sollten vernünftig, halbwegs engagiert irgendwie mitgearbeitet haben, regelmäßig da gewesen sein.
Nicht mehr als zweimal gefehlt haben und worauf wir dann eben auch hatten,
dass man da eben nochmal irgendwie so ein bisschen mal selber aktiv
eben mal beispielsweise eine Aufgabe an der Tafel beziehungsweise bei den anderen eben entsprechend vorrechnet.
Auch das ist jetzt keine zu große Hürde,
weil das kann man natürlich machen, wenn man jetzt sagt,
okay, ich habe jetzt also von den jeweiligen Übungsaufgaben oder Teilaufgaben mal eine irgendwie bearbeitet,
dass man sich dann eben auch sagt, na gut,
also anstatt, dass alle da sitzen, der Übungsgruppenleiter darauf wartet, dass sich jemand meldet.
Kann man dann eben auch sagen, okay,
also ich habe die und die Aufgabe bearbeitet,
habe mich so ein bisschen darauf vorbereitet.
Man meldet sich freiwillig, geht nach vorne,
rechnet das vor und damit ist da dann also diese Hürde dann eigentlich schon abgehakt.
Nicht ansonsten heißt es eben, alle Aufgabenblätter sollten bearbeitet werden,
je Aufgabenblatt gibt es, sagen wir mal sowas wie maximal 100 Punkte,
nicht mindestens 30 sollte man dabei dann eben erreicht haben und insgesamt mindestens 50 Prozent der Gesamtpunktzahl.
Wie gesagt, dadurch, dass sie dann ja als Gruppe,
zu zweit oder zu dritt, dort arbeiten, ist das eigentlich relativ gut machbar.
Zu den Übungsgruppen, die sind teilweise schon sehr voll,
teilweise nicht so voll. Ich weiß,
es ist natürlich jetzt immer so, also einigen von ihnen,
also die Termine passt dann immer nicht so gut.
Es gibt prinzipiell die Möglichkeit, also noch irgendwie zu wechseln,
wo es jetzt also kein deutscher Verwaltungsakt sein,
wo man das in Stine ändert,
sondern man geht dann eigentlich quasi zu dem Übungsgruppenleiter,
sofern dort in der Gruppe noch was frei ist und fragt nach,
ob ein Wechsel möglich ist.
Das sollte natürlich relativ zeitnah, das heißt also,
nächste, übernächste Woche, also sprich relativ früh erfolgen.
Geht auch noch ein bisschen später. Nicht nur,
dass sich dann eben mit den Übungsgruppenleitern entsprechend absprechen,
dass die dann eben auch das mit den Punkten dann passend gegenreich nennen.
Ansonsten die Übungsgruppen, ursprünglich waren die eigentlich mal für jeweils 15 Teilnehmer gedacht.
Inzwischen sind wir da also wegen größerer Belegung, also schon
auf 20 gegangen. Heute Morgen sah es so aus,
dass das im Prinzip die Montagsgruppen hier von 12 bis 13 Uhr
beziehungsweise von 15 bis 16 Uhr schon jeweils komplett ausgebucht waren.
Bei den anderen Gruppen ist aber im Prinzip dann also noch so ein bisschen Spielraum.
Das heißt, da könnte man dann also auch noch wechseln.
Gut, neben den Übungen gibt es quasi als freiwillige Veranstaltung noch einen Rechnerstrukturen-Tutorium. Wie gesagt,
rein freiwillig ist eigentlich dafür gedacht, dass man sagt,
bei den Übungen wird das oder wird natürlich relativ viel erstmal jetzt,
also konkret einen Übungszetteln gearbeitet und die dann eben dementsprechend nachbesprochen beziehungsweise dort was gemacht.
Tutorium ist von der Idee her eben dafür gemacht,
dass man sagt, okay,
ich habe jetzt zu irgendeinem bestimmten Thema jetzt also irgendwie was nicht verstanden,
dann möchte da nochmal genauer nachhaken,
wofür dann vielleicht in den Übungsgruppen nicht die Zeit ist.
Dazu können sie dann eben einfach entsprechend in das Tutorium kommen. Das wird veranstaltet,
Donnerstagabend, ab 18.30 Uhr, weil ich weiß nur,
dass also bis 18 Uhr also relativ viele dann wohl
auch hier noch irgendwo Veranstaltungen haben,
dass man dann dementsprechend Zeit hat,
wieder zu ins Informatikum
zu kommen
Wie gesagt, man muss nicht pünktlich da sein.
Das ist eben wirklich eine reine freiwillige Veranstaltung. Das heißt, man kann auch irgendwann zwischendurch kommen oder entsprechend wieder gehen. Findet statt in House F und einem Erdgeschoss in dem etwas größeren Vorlegungssaal,
also F-132, wird veranstaltet von Jessica Jobski,
die einige von euch vielleicht also auch schon in der Orientierungseinheit kennengelernt haben,
die da also entsprechend engagiert ist und das Ganze dann quasi jetzt mit ihrem persönlichen Account dann nämlich also irgendwo als Live-Videostream über YouTube quasi macht und damit das dann also nicht nur eine Video raus,
Einbahnstraße ist, gibt es da dann eben auch noch die Möglichkeit,
über den Server der Fachschaft, dann also ein Live-Chat zu machen,
dass sie sich da dann eben entsprechend,
wenn sie jetzt also nicht kommen sollten und also jetzt irgendwelche Fragen haben,
da dann eben auch noch von außen drauf schalten können,
um dann also Fragen loszuwerden oder irgendwelche Probleme erläutert zu bekommen.
Also wie gesagt, das ist nochmal eine sehr gute Gelegenheit,
also jetzt irgendwelche Sachen,
die ich jetzt vielleicht blöd erklärt habe,
die bei ihnen da nicht angekommen sind,
dann also nochmal weiter zu vertiefen
Ansonsten gibt es irgendwann vor der Klausur dann eben,
ich denke mal schätzensweise,
so ab Mitte Januar oder so wird das dann eben irgendwie dann stattfinden,
nochmal so ein vorbereitendes Tutorium, wo also alle diejenigen,
die jetzt sagen, okay,
ich bin jetzt gerade dabei zu lernen und um Gottes Willen,
das habe ich jetzt nicht verstanden,
dort dann eben nochmal nachfragen können,
wie das ist,
beziehungsweise in der Regel wird dann parallel dazu dann eben
auch noch eine Übungsklausur angeboten
Gut, dann die meisten von Ihnen,
also sprich alle, die jetzt nicht neben Fächler sind,
wären dann ja also auch noch eine Rechnerstruktur und Praktikum machen.
Das findet dann quasi als Blogveranstaltung statt,
wo im Prinzip jetzt also in Blöcken kleinere Aufgaben zum Thema,
wie funktioniert ein Rechner, wie kann da Befehle abarbeiten,
behandelt werden.
Dort eigentlich auch nur wichtig, beziehungsweise ganz wichtig,
dort muss man sich zwingend vorbereiten.
Es gibt dann eben
auch entsprechende Unterlagen
Auf den Webseiten beziehungsweise bei Stine, die man sich runterladen kann.
Wenn man dort also quasi zu dem Termin erscheint und dann anfängt,
die Zettel zu lesen, das schafft man in der Zeit nicht.
Das heißt also, da ist es wirklich wichtig,
dass man sich das vorher macht. Wenn man das macht,
hat man allerdings auch die Chance,
da so relativ schnell zeitlich durchzukommen,
weil man dann eigentlich nur so ein paar Informationen braucht,
die man dann also quasi jetzt in diesem Praktikum,
wo dann also letztendlich online mit so einem System gearbeitet wird,
dauert dann also das Ganze auszufüllen beziehungsweise irgendwelche Sachen zu programmieren,
zu ergänzen und dann kommt man damit
relativ schnell hin
Inhalt dieses Praktikums ist dann eben eigentlich das,
was also jetzt hier in der Vorlesung,
sagen wir mal so, in, ja ich sag mal,
größenordnungsmäßig zwei Monaten dann also irgendwie passieren wird,
nämlich also die Schnittstelle zwischen irgendwelcher Computer-Hardware und einfachen Assembler-Code beziehungsweise Befehlssatz,
wo man dann eben eigentlich sieht, wie es möglich ist,
dass also jetzt irgendwie so ein technisches System quasi die Befehle,
die ich jetzt eingegeben habe,
das,
was ja ein Code programmiert habe,
jetzt irgendwie abarbeitet und da eben entsprechend dann also
quasi auf unterster Ebene die Programme ausgeführt werden
Gut, Klausur. Wie gesagt, zwei Klausurtermine.
20. Februar und 20. März. Auf den entsprechenden Webseiten
des Studienbüros entsprechend schon verfügbar. Auch nur als Tipp,
weil viele dann immer irgendwie sagen, ja Mensch,
ich traue mich nicht und gehe dann immer erst zur zweiten Klausur.
Die Erfahrung aus den letzten Jahren ist eigentlich immer,
dass erstaunlicherweise bei der ersten Klausur der Schnitt immer irgendwie
deutlich besser ist
Obwohl, dass sie die gleichen Aufgaben oder Aufgabentypen sind.
Also ich kann auch immer nur empfehlen,
einmal kräftig lernen durch und dann klappt das aber auch.
Und wie gesagt, also für die Klausurvorbereitung,
Probeklausur werden sie ja dann schon gesehen haben.
Und am Ende der Vorlesung werde ich dann eben auch noch
ein bisschen mehr dazu sagen, was man dort machen muss.
Im Großen und Ganzen kann man eben sagen, das,
was in den Übungen, Übungsaufgaben drankommt,
wenn man das drauf hat,
passiert einem in der Klausur
überhaupt nichts
Gut, Probo-Klausur, auch da kann ich nur sagen,
wird noch entsprechend bekannt gegeben. Gut, zur Literatur,
beziehungsweise das, was man da vielleicht noch finden kann,
also Referenz oder das,
wo relativ viel jetzt hier von der Rechnerstruktur und Vorlesung darauf aufbaut,
ist, also hier diese etwas dickere Schinken von Brian und Orhelleren,
Computersystem, Approgrammers Serspective.
Wie gesagt, haben wir in der Bibliothek,
da ist nicht ganz billig, aber eigentlich ein relativ gutes Lehrbuch,
zu dem es dann also auch noch hier auf entsprechender Webseite Kekse so.
Dann also auch noch so ein bisschen Hintergrundmaterial gibt,
beziehungsweise dann also auch noch einige andere Informationen dazu.
So, jetzt habe ich natürlich gerade Gut,
dann als zweites Buch,
was eigentlich vom Stoff und Fang her ähnlich ist,
ein bisschen anderer Schwerpunkt von Endrotanenbaum und Todd Austin,
Wovon es dann also auch noch eine deutsche Übersetzung gibt.
Auch ein sehr gutes Buch, was sie empfehlen kann,
wo man dann eigentlich auch alles entsprechend zu diesem Thema Rechner,
Architektur findet. Ansonsten, wie gesagt, so was
wie ein explizites Skript zu der Vorlesung gibt es nicht.
Aber wie gesagt, unterlagen Literaturverweise, Hintergrundmaterial. Ansonsten zur
Literatur vielleicht auch noch zu jedem Kapitel werde ich dann,
was ich also bringe,
würde ich also am Ende des Kapitels immer noch jeweils eine Literaturliste haben,
wo sich mehr oder männer diese Bücher in jeweils unterschiedlichen Reihenfolgen wiederfinden.
Die Reihenfolge wieder in Literaturliste stehen,
ist eigentlich auch immer schon so ein bisschen Indiz dafür,
also von welchem Buch jetzt welche Inhalte sind.
Nicht, das heißt, das, was vorne steht,
das ist dann immer quasi die, ich sag jetzt mal,
so Primäre Quelle aus dem entsprechenden Teil.
Gut, dann zum Thema Rechnerarchitektur oder Rechnerstrukturen,
also hier noch so einige weitere Lehrbücher,
also im Prinzip gibt es da dann noch technische Informatik warst,
dann von auch noch ein Sprechen zu erwähnen von Patterson und Tennessee,
Computerorganization and Design.
Daraus würde ich dann also auch relativ viel an Stoff bringen bzw. zitieren.
Also da gibt es dann also auch einige Sachen.
Ansonsten folgt jetzt hier auf diesen Folien noch einiges an weiteren Lehrbüchern,
die dann also jeweils immer alle mal teilweise so ein bisschen hier angesprochen worden sind.
Wobei ich dann aber eben auch immer sagen muss,
wenn man sich in dem Bereich weiter vertieft,
sind die sicherlich interessant
Das wäre dann was. Ansonsten,
weil das dann immer wirklich nur einzelne Kapitel sind,
muss ich jetzt natürlich also nicht irgendwie so ein 1200 Seiten schenken nehmen,
wo ich dann also sage, okay,
also auf den drei Seiten habe ich dann also irgendwie das,
was mich jetzt irgendwie zum Thema Assembler-Programmierung interessiert.
Gut, also wie gesagt, da ist hier relativ viel dann,
also hier noch so allgemeine Literatur zur Vertiefung,
aus der ich dann teilweise auch immer jeweils zitieren werde.
Aber wie gesagt, also die entsprechenden Referenzen finden sich dann
auch immer auf den Folien.
Hier habe ich das nur alles nochmal komplett zusammengefasst.
Das heißt, wenn sie da dann nochmal irgendwo gucken wollen,
hat man da also quasi eine komplette Literaturliste
Und dann hier von ehemaligen Kollegen, also aus Hamburg noch mal irgendwie
was, noch mal was zur Assembler-Programmierung und so weiter.
Ja, zur Software, wie gesagt, werde ich,
wenn das dann soweit ist, dann also auch noch mal ein bisschen genauer vorstellen. Das,
womit das Rechnerstruktur und Praktikum und dann eben auch einige von den Übungen bzw. Sachen hier dann gemacht werden,
ist dann nachher dieser Schaltungssimulator, den der Kollege Hendrik entworfen oder programmiert hat,
den wir dann eben hier auch benutzen werden, wenn das dann entsprechend soweit ist,
werde ich dazu also noch mal ein bisschen genauer was sagen.
Nicht ansonsten zu dem Thema Assembler-Programmierung sind dann eben, sagen wir mal, die üblichen Entwicklungswerkzeuge, ein C-Compiler quasi dann mitgemacht hast. Was ich jetzt hier an Beispielen habe,
ist jetzt natürlich also dann hier auch an dem Buch angelehnt,
einfacher X86 Assembler mit der Genug-Shoochain, das heißt also das,
was man also standardmäßig unter Linux irgendwie installiert,
was man zur Not Angst dann auch überzeigt,
unter Windows laufen lassen kann,
beziehungsweise das, was sie dann schon angedeutet hatte,
also ich werde dann irgendwann nochmal so eine virtuelle Maschine im Welt entsprechend vorinstallierter Software aufsetzen,
werde ich dann, wenn das ansteht, wie gesagt,
das wird dann nachher irgendwann Kapitel 12 oder 13 werden,
werde ich das dann also nochmal entsprechend darauf hinweisen.
Gut, ansonsten nehmen wie immer der Verweis auf die Webseiten,
wo dann eben nochmal entsprechend viel an Informationen dazu folgt.
Gut, das war jetzt eigentlich das,
was ich jetzt hier zu den Allgemeinen Einführungen gemacht habe,
dann würde ich jetzt also ganz normal mit den offiziellen Vorlesungsfolien begehen.
Wobei, also wie gesagt, also auch dort,
also das Kapitel 1, erste so ein bisschen Einführung,
ein paar Seiten allgemeine Motivation sind.
Digitale Rechner, Kapitel 2, das ist dann etwas,
was ich denke mal mal,
also Freitag spätestens nächsten Mittwoch dann also abschließen werde.
Und dann geht das also dann hier eben entsprechend über die
einzelnen Kapitel dann jeweils weit durch
Gut, ja, die sind jetzt hier um Informatik zu studieren.
Wenn man jetzt also irgendwo guckt, was ist Informatik,
kann man sagen, also laut Brockhaus,
die Wissenschaft von der systematischen Verarbeitung von Informationen,
besonders der automatischen Verarbeitung mit Hilfe von Digitalrechnern,
da kommen Querverweise auf Computer.
Das heißt also, wichtig, systematisch Verarbeitung von Informationen und Digitalrechner.
So, und das war's letztendlich Rechnerstrukturen jetzt hier vermitteln soll,
ist eben,
wie funktioniert so ein Digitalrechner
Sprich, okay, sie haben jetzt alle irgendwie ihren Laptop,
ihren PC, ihr Tablet, mobiles Gerät,
was weiß ich auch immer, was jetzt benutzen, vielleicht auch programmieren.
Und das, was also hier letztendlich vorgestellt werden soll,
ist eben die Art und Weise,
wie diese Systeme technisch arbeiten,
dass man also ein bisschen technisches Grundverständnis hat,
auch wenn natürlich der Schwerpunkt des Informatikstudiums eindeutig auf die Programmierung liegt,
aber dass man eben auch weiß,
was verbirgt sich dahinter
Das ist dann eigentlich das, was hier dann darum geht.
Wie gesagt, die einzelnen Themen hatte ich ja gerade eben
schon in einem anderen Teil so ein bisschen kurz angesprochen.
Deswegen denke ich mal, würde ich wissen, es nicht weiter vorstellen. Generell kann man eben sagen,
dieses Grundprinzip, also zu wissen, wie ein Rechner arbeitet,
wie er die Programme abarbeitet, wie Informationen kodiert wird,
dargestellt wird, gehört eigentlich zu dem, was, dass mein Informatikbasiswissen ist. Das heißt,
was eine Informatik eigentlich typischerweise wissen sollte, ist natürlich gemein,
weil das sagt also jeder Veranstalter in der Vorlesung,
also das, was ich bringe, ist triviales Basiswissen,
das müssen sie sowieso drauf haben,
aber auch ich werde mich davon also jetzt nicht frei machen und dem zufolge also jetzt sagen,
okay, also in dem Fall zumindest einiges von dem sollte man also schon im Hinterkopf haben,
wenn man programmiert, auch wenn man,
auch wenn sie dann später also nicht zwingend Assembler-Programmierung machen werden,
vor allem muss sie zugeben,
kann ich
genauso wenig
Also deswegen nicht, aber im Prinzip zu wissen, warum das so funktioniert,
hat dann eben doch deutliche Auswirkungen auf die eigene Arbeit,
auf das Programmieren, auf das Verständnis,
wie das Ganze dann eben wirklich rein technisch erarbeitet.
Und die andere Sache ist, das ist dann das,
was also hier eigentlich so mit diesen letzten Punkten hier noch so ein bisschen angedeutet ist,
dass man da dann eben einfach darüber nochmal so ein bisschen weiß oder Verständnis hat,
wie jetzt also bestimmte Trends sind, wie die Informatik sich entwickelt,
welche Chancen es da eben vielleicht noch gibt,
Und wie eben sowas dann ebenentsprechend noch einzuschätzen ist.
Gut, ja, wenn wir jetzt hier bei der Motivation sind,
der hatte ja gesagt, also das,
was eigentlich die Vorlegung vermitteln soll, ist eben letztendlich Wien Digitalrechner funktioniert.
Gut, da kann man jetzt eben sagen, ja,
warum baue ich das? Informatik ist ohne Rechner,
Rechnersysteme letztendlich nicht denkbar, ist insofern jetzt natürlich trivial,
dass man sagen kann, gut,
also Für sie ist das jetzt eigentlich alles kein Thema mehr.
Gehört zum täglichen Leben. Vor 20, 30 Jahren war das eben doch noch anders.
Dann muss er eben sagen, dies Grundverständnis von der Interaktion,
von Software und Hardware sollte eigentlich entsprechend vorgestellt werden.
Und was eben dann eben auch wichtig ist, ist,
dass man aufgrund dieses Wissens dann eben auch bei der eigenen Arbeit
relativ gut sehen kann, wie da vielleicht Wechselwirkungen sind.
Dazu folgen gleich noch ein paar kleine Beispiele,
die da so irgendwie so ein bisschen darauf hinweisen,
wohin oder was sie damit dann vielleicht meine.
Und die andere Sache ist, was man auch sagen muss,
nicht, also wenn man jetzt sagt, okay,
also hier Digitalrechner, ja, was ist Digitalrechner?
Okay, das ist hier natürlich also offensichtlich,
also der Laptop oder eben irgendwo im PC, den man rumstehen hat.
Das ist aber natürlich nicht die Großteil der Großteil der Rechner,
sondern der Großteil der Rechner ist inzwischen in eingebetteten Systemen verbaut,
um Größenordnungen mehr als das, was uns,
sagen wir jetzt so, bewusster Form als Rechner irgendwo entgegensteht.
Nicht, wenn man sagt, also in irgendeinem Kleinwagen Mittelklasse-Wagen
sind es so um die 80, 90 Mikrocontroller verbaut,
die jetzt eben alles Mögliche von Radiosteuerung über Motormanagement und,
und, und machen.
Das ist eigentlich das, wo dann eben entsprechend viel mit reingeht.
Und demzuvor kann man eben auch sagen,
also das ist das, was man irgendwie angedeutet ist.
Nicht also im Prinzip die Rechnersysteme gehen eben eigentlich von dem,
was wir zu kennen, also von irgendwelchen Workstation-PCs, bis zu irgendwie
Auch wenn sich das dann immer irgendwie so toll anhört,
Supercomputer dann eben über relativ viele kleine und eingebettete Geräte bis zu irgendwelchen Low-Cost-Varianten,
wo man sagt, okay,
also inzwischen sind eben auch schon AFID-D-Techs,
also mehr oder minder intelligent und können ein bisschen was machen oder man hat eben irgendwelche,
das, was wir sagen wir jetzt mal so Wegwerf-Computer nennen,
wo irgendwelche Billigsysteme, wo man dann eben auch sagt,
also die sind eben für einfache Anwendungen machen ein bisschen was und anschließend werden die dann eben entsprechend entsorgt und das war es,
gut.
Also ob das jetzt ökologisch sinnvoll ist, da haben wir dahingestellt, aber...
Im Prinzip auch so war es. Gut wurde ich für
das Ganze letztendlich motiviert und da muss man eben sagen,
gut, also das kommt jetzt natürlich irgendwo durch den riesigen technischen Fortschritt.
Nicht, also sowohl in der Mikroelektronik als auch in dem,
was dann irgendwie so Opto-Elektronik oder eben andere technische Basistechnologien sind,
gibt es eben eigentlich einen wahnsinnigen Fortschritt, bei dem man eben sagen kann,
der läuft eigentlich seit 50 Jahren mit einem exponentiellen Wachstum.
Das heißt also, pro Jahr kann man eben ein bestimmtes
Wachstum von, je nachdem, was man da betrachtet.
Also teilweise bis zu 50 Prozent und mehr haben, was eben dazu führt,
dass eben damit eigentlich dann auch die Rechenleistung der Systeme so stark steigt,
dass das, was heutzutage möglich ist,
womit wir leben, was also völlig normal ist,
also vor 20 Jahren letztendlich undenkbar ist,
Beispiele dazu folgen gleich.
Und dass ihm dieses Wachstum gilt, Für sehr viele sehr unterschiedliche Messgrößen,
die man sich jetzt ausdenken kann. Ich kann sagen,
das gilt für die Rechenleistung, also für das,
wie schnell ein Computer ist oder Wasser berechnen kann.
Das gilt aber eben auch für die Speicherkapazität,
sei das also Hauptspeicher, sei das also das,
was, also jetzt an dauerhaften Speicher da ist,
also was früher eben irgendwelche Magnetplatten oder irgendwelche anderen Systeme waren,
heute eben häufig irgendwelche Flash-Speicher.
Das gilt aber eben auch für Übertragungstechniken von Daten,
also sprich Netzwerktechnik, das heißt,
mit welchen Bandbreiten man eben die Daten zwischen den Rechnern
bzw. zwischen den Systemen
austauschen kann
Nee, das ist eben das eine, also dieser Exponist,
der wachsende technische Fortschritt und auf der anderen Seite,
bevor er das natürlich dann also wieder die Möglichkeiten,
die Anwendung und andersrum dann eben auch die Entwicklung der Systeme,
da muss man eben auch sagen,
wenn wir jetzt also irgendwie ganz am Ende noch wirklich entsprechend viel Zeit haben,
also habe ich dann also noch so quasi als Add-on,
also auch nur so ein bisschen Foliensatz, wo es darum geht,
wie Mikroprozessoren entworfen werden, wie die gefertigt werden,
wo man dann eben auch sagen muss, na gut,
also vor 30,
40 Jahren war also im Prinzip der Entwurf eines Mikroprozessors fürchterlich viel Elektrotechnik.
Man musste sich ja im Prinzip mit der Transisto-Technik,
mit der Fertigungstechnik dazu und allen möglichen auskennen. Heute kann man eben sagen,
als anderes Entwurfspartig, weil wenn ich also irgendwie einen Prozessor haben will,
der die und die Aufgaben löst, kann ich den wie in der Programmierung beschreiben. Das heißt,
ich habe Hardware-Beschreibungssprachen, wo ich jetzt nicht mehr sage,
da soll irgendein Wert herkommen und der soll mit irgendeinem anderen Wert zusammen addieren,
addiert werden und da landet das Ergebnis,
sondern ich sage nur,
ich möchte dann im Prinzip in einem Tagzyklus rechnen,
X ist gleich A plus B und automatisch wird dann eben aus diesem Plus-Opperator dann eben irgendwie eine entsprechende Hardware-Einheit generiert.
Das heißt also auch der Hardware-Entwurf ist dann letztendlich
nichts anderes als eine Programmierung,
nur dass man dafür dann eben
etwas andere Programmiersprachen einsetzt
Man kann aber im Prinzip also mit den Leichen Mitteln analog zur Softwareentwicklung,
wo ich dann sage,
ich habe jetzt also irgendwie meine Programmiersprachen, Java,
See, was weiß ich, also irgendwas auf höheren Ebenen,
wo ich dann eben sage, anschließend habe ich irgendwelche Übersetzungswerkzeuge,
die mir aus diesen Programmiersprachen den Maschinenquoten machen,
der dann eben letztendlich dann irgendwo auf der Hardware abläuft.
Genauso kann ich eben sagen, ich habe meine Hardware-Beschreibungssprachen,
wo ich eben sage,
der Prozesse soll das und das rechnen können und habe dann Übersetzungswerkzeuge,
die mir quasi daraus Silizium rausschmeißen
Gut, ganz so einfach ist es nicht, aber im Großen und Ganzen läuft das eigentlich auch so. Und das führt dann eben auch dazu,
dass das Ganze dann eben letztendlich so erfolgreich geworden ist,
dass man eben auch sagen kann, okay,
wenn ich mir heute einen großen Prozessor nehme, gut,
also zurzeit ist, glaube ich, irgendwie so Rekordhalter von NVIA,
die Pascal GPU, irgendwie so mit 8 Milliarden Transistoren,
dann wird nicht jemand diese 8 Milliarden Transistoren von Hand begrüßt haben und gesagt haben,
also den schalte ich so, sondern den schalte ich suche,
sondern man sagt einfach nur,
Ich möchte jetzt eben irgendwelche Einheiten haben,
die das und das berechnen und damit wird dann eben quasi sein Schäder oder die Rasterendstufe oder was weiß ich,
funktional beschrieben und anschließend habe ich Werkzeuge,
die mir daraus dann eben so ein Mordership generieren.
Gut, das heißt, das ist eigentlich das,
wie sich das Ganze entsprechend weiterentwickelt, wo ich dann eben hoffe,
ihnen das so ein bisschen im Rahmen dieser Vorlesung dann also auch nahe zu bringen,
zumindest so andeutungsweise diese Schnittstelle zwischen Programmprogrammierung und der darunter liegenden Hardware,
wo das Ganze eben so ein bisschen modelliert wird.
Ja, hier auch noch mal zum Fortschritt. Nicht,
wenn man jetzt eben auch sieht, was eben letztendlich jetzt
mit unterschiedlichen Rechnergenerationen eben auch an Anwendungen möglich geworden ist.
Früher konnte man sagen, na gut,
als Konrad Zuse irgendwie Ende der 30er Jahre,
also im Prinzip seine programmierbare Rechenmaschine da entwickelt hatte,
dann konnte die eben so ein bisschen Kurs minus mal durch.
Nein, also auch ein bisschen mehr und man konnte es programmieren,
aber letztendlich ist es nicht viel mehr als das,
was ein Taschenrechner kann. So,
und nicht mit jeder Jeweils dem technischen Fortschritt und eben hier unterschiedlichen Systemen,
die dann eben entweder bzw. die,
beziehungsweise die dann eben entsprechend mehr Rechenleistung bereitstellen und die dann
eben auch entsprechend mehr Informationen speichern können und verarbeiten können,
wurden dann eben neue Anwendungen möglich.
Und hier sieht man dann eben, dass im Prinzip sowas
wie Videoverarbeitung, Audio-Datenströme, DVD-Wiedergabe Spracherkennung, Videoverarbeitung.
Nicht, dass das letztendlich voraussetzt, dass sich eben eine gewisse Rechenleistung zur Verfügung habe,
wie auch immer ich die jetzt messen mag.
Also hier jetzt also einfach mal als Instruktion pro Sekunde oder sowas
gesagt und dass ich eben auch eine entsprechende Menge an Speicher zur Verfügung habe. Und das ist eben auch so ein Trend,
der heutzutage dann eben eigentlich immer noch weitergeht,
wo man dann eben auch sagen muss, na gut,
also was ist jetzt zurzeit gerade an heißen Themen oder interessanten Sachen mit drin,
wenn man da dann sieht, also Datenbanken, Big Data,
wo eben wirklich so bestimmte Informationen zusammengefasst werden,
dort was gemacht werden, maschinelles Lernen, ganz heißes Thema,
muss man eben auch sagen, das ist eben auch erst möglich geworden,
seitdem entsprechend leistungsfähige Systeme zur Verfügung stehen.
So, als ein Beispiel,
wie sich das Ganze entwickelt hat,
habe ich hier jetzt mal einfach was recht Historisches rausgesucht,
was das im Zweifelsfall die Generation ihrer Eltern als Kinder
noch erlebt hat
Die erste Mondlandung, 1969, ich war also im Prinzip
die Apollo 11-Mission zum Mond geflogen ist dort,
also die Astronauten abgesetzt hat und so weiter und so fort.
So, wenn man sich mal ansieht,
was zu der Zeit an Rechner, Technologie verfügbar war,
eingesetzt wurde, haben wir hier also einmal den Bordrechner,
also eine relativ kompakte Kiste, knapp 32 Kilo Gewicht,
der eigentliche Rechner.
Und das war es dann also quasi die Bedieneinheit war,
also sprich die Tastatur und das Display.
Das war dann also dieser Carsten, auch nochmal mit acht Kilogramm Gewicht.
Das Ganze lief also intern mit einer Taktfrequenz von etwas über einem Megaherz.
Da muss ich sagen, also inzwischen meine Uhr,
taktet oder dort verbaute Rechner taktet,
also in Größenordnung schneller, braucht für eine Addition 20 Mikrosekunden.
Es gab nur relativ einfache Datentypen, beziehungsweise überhaupt eigentlich als Datentypen,
also nur Festkommazahlen, 16 Bit breit.
Und ich habe eben eine relativ begrenzten Speicher von Horm, sogenanntes Read-Only-Memory. Das ist also Spar, ich habe auch quasi das eigentliche Programm abgelegt wird. Und dann eben dem Arbeitsspeicher,
der dann als RAM ausgeführt ist,
also irgendwie sowas wie 72 Kilo Bart beziehungsweise 4 Kilo Bart,
das sind also irgendwie Informationszwängen, wo man sagen muss,
na gut, Zeitalter von Gigabyte, Micro-SD-Karten und irgendwie Terabyte Fest,
Platten, mutet sowas dann, also natürlich,
beziehungsweise Gigabyte oder ein zig Gigabyte Speicher mutet,
so war es dann natürlich, also dann entsprechend an Zugriff auf einen Speicher,
weil der Speicher also um Größenordnung langsamer ist als der Prozessor,
ging mit einer Zykluszeit von 11,7 Millisekunden, 85 Hertz,
das heißt, wenn also irgendwie eine Zahl aus dem Speicher ausgelesen wurde,
wenn man sagt, also ich möchte jetzt zwei Zahlen addieren,
das Ergebnis wieder irgendwo in den Speicher schreiben,
brauche ich also hier entsprechend drei von diesen Speicherzyklen.
Das heißt also, da ist man dann also irgendwie in der 30. Sekunde lang dabei,
quasi also jetzt nur diese Addition zu machen.
Gut, das ist aber natürlich noch nicht das Beeindruckende,
sondern das Beeindruckte ist das, was also damals wirklich so Die Großrechner sind, klassisch, IBM-System 360. Das,
was man also gelegentlich mal in so ganz alten Filmen noch sieht,
sprich hier so eine Halle voll mit irgendwelchen Schränken,
wo dann im Prinzip hier so eine Kiste,
der eigentliche Rechner steht, hier jetzt also irgendwelche Festplatten,
das waren dann Wechselfestplatten, also konnte man diese Teile dann hier austauschen.
Hier hinten dann immer so schön die Magnetbänder,
Ein- und Ausgabe passiert dann also quasi über Tastatur unseren Fernschreibterminal,
der eigentliche Rechner war dann, also inzwischen können wir sagen,
okay, wir kennen Mikroprozesse und Mikrocontroller, wo man dann eben sagt,
also ich habe jetzt also wirklich so auf so einem kleinen Ship mein gesamtes System.
Damals war das eben in mehrerer solcher Schränke, also auf was weiß ich,
wie viele Platinen und entsprechend viele Leitungen aufgetrennt, verbaut.
Das Ganze lief mit einer Taktfrequenz von bis zu 5 Megahertz
, bei den ganz großen Maschinen.
32 Bit Wortbreite, man konnte 16 Megabyte adressieren
Und gut, hatte dann also auch noch irgendwelche eigenen Festkomma-Formate,
also das heißt, oder Fließkomma-Formate, das heißt,
der konnte also schon irgendwie eine Fließkomma-Arrathmetik machen,
also sprich irgendwas mit Komma-Zahlen,
würde ich dann entsprechend dann im Rahmen der Vorlesung auch noch genauer drauf eingehen,
wie Fließkommarathmetik funktioniert und hatte also die sagenhafte Rechenleistung von 0,7 Drive-Downlips.
Gut, das war also das,
was im Prinzip so in Houston,
wir haben ein Problem in den damals Rechenzentrum der NASA
verbaut war
Ich ja so zwei solcher Dinger. Gut,
wenn man sich das jetzt gegenüberstellt, zu dem,
was wir heute an der Rechenleistung mit uns rumtragen.
Smartphone. Aktuelle Generation Exinus, 8000 von Firma Samsung.
Das ist also das Gerät, was,
beziehungsweise der Prozessor, der die Galaxy Notes befeuert,
wenn sie nicht gerade abbrennen.
Acht Kerne
Ungefähr 47.800 Maps Rechenleistung, Taktfrequenz 2,3 Gigahertz. Das heißt also von der Taktfrequenz
500 Mal so schnell und von der Rechenleistung 50.000 Mal so viel,
wie das, was damals das gesamte Apollo-Programm hatte.
Das heißt, damit hat man ausgerechnet,
wie die alles bauen, wie sie ihre Raketen raufschießen,
wieder runterkriegen, eigentlich alles, was dort wichtig war.
Für uns heutzutage selbstverständlich, das habe ich in der Hosentasche
Desktop-PC, hier jetzt quasi als Beispiel für die letzte Intel-Prozessor-Generation,
also 6900er-Serie, Mehrkernprozessor, in diesem Fall jetzt mit 10 Kern,
dadurch, dass es jetzt also in einer von diesen Prozessoren ist,
die jetzt wirklich schon fast Workstation-Charakter haben, also mit deutlich mehr Kern,
würde nicht ganz so hoch getaktet, das heißt,
da läuft nur mit 3 Gigahertz, bei den kleineren Prozessoren,
die dann also, sagen wir jetzt nur 4 Kerne haben,
die laufen dann eben mit 4, irgendwas Gigahertz,
nicht der ist dann im Bereich von 3018.000 Maps Rechenleistung.
Gut, das ist also heutzutage eigentlich selbstverständlich für uns.
Kein Thema. Nicht, das ist also wirklich so als
Beispiel dafür, wie sich das Ganze letztendlich technisch entwickelt hat.
Deswegen kann man eben sagen, diese technische Entwicklung,
und das werden Sie dann sicherlich auch im Laufe Ihres Informatikerlebenssaison feststellen,
ist natürlich kein stationärer Zustand,
sondern es ist entwickelt sich eben wirklich rasant und was weiß
ich wie weiter
Macht das Ganze aber eben wirklich deswegen natürlich auch sehr,
sehr spannend, weil man jetzt nicht sagen kann, okay,
ich habe jetzt mein Wissen und das wird sie nicht weiter ändern,
sondern im Laufe des Berufslebens werden sich da also doch sehr viele Sachen,
also auch noch ändern, entwickeln.
Es werden also irgendwann später rechnen, irgendwelche Technologien aufkommen,
von denen wir uns jetzt also auch noch nichts weiter träumen können.
Von daher ist es eben sehr sparen. Teilweise gibt es dann eben schon so ein bisschen,
zumindest in Bereich auf die technische Entwicklung, also ein bisschen Roadmaps, wie sich das Ganze weiterentwickelt.
Dazu werde ich dann also übernächsten Kapitel dann noch ein bisschen was zu vorstellen,
wo es dann also quasi um More Slaw geht und die Frage,
wird das Ganze letztlich immer so weiter wachsen,
weil da ist es eben auch so,
dass zumindest so bei der Standard-Selitium-Technologie,
wie jetzt also schon so ein bisschen das Problem haben,
dass die Rechner bzw. die Prozessoren eben massiv Probleme bekommen,
also man kann die zwar immer kleiner fertigen,
höre immer höhere Taktraten,
immer mehr Rechenleistung,
heißt aber
auch immer mehr Abwärme
Die abzuführen ist. Und das ist also zum Beispiel einer der Gründe,
weswegen, also hier bei den Prozessoren, die jetzt also deutlich mehr Kerne haben,
dann also insgesamt die Taktfrequenz dann wieder nicht mehr ganz so hoch geschaltet werden,
weil man einfach Probleme hat, also die 160 war,
die die also quasi an Abwärme produzieren, dann also irgendwo nochmal loszuwerden.
Wenn man sich so umhört, was also letztendlich in Rechenzentren,
wo jetzt also wirklich irgendwelche großen Server, wo dann also ein Prozessor,
also irgendwie mit 20 CPU-Kern vor sich hin werkelt und davon dann aber in so einem Reck,
also mehrere hundert Prozessoren drin sitzen,
was da dann also das Problem ist,
also zum einen die überhaupt erst mal mit Strom zu versorgen und zum anderen dann eben die entsprechenden wieder zu kühlen,
weil das, was man da an Energie reinsteckt,
wird quasi bei der Berechnung einfach in Wärme umgewandelt.
Und das ist eben eine der Sachen,
wo man sagen kann, okay,
also da kommen wir jetzt also schon so ein bisschen an die Grenzen,
wo das zumindest mit der derzeitigen Technologie,
also sich jetzt so ein bisschen abschwächt und dieses Exponentielle Wachstum der Rechenleistung da ist,
also ein bisschen nachlässt.
Nicht, aber nichtsdestotrotz kann man eben sagen,
viele von diesen Konzepten bleiben, generell gültig.
Und das ist eben letztendlich das, was eben hier in dieser Vorlesung,
wo es so ein bisschen eben um diese technischen Grundlagen und Zusammenhänge geht,
dann eben vermittelt werden soll.
Nicht dazu kann man immer sagen, na gut,
also bei der Softwareentwicklung,
nicht also zurzeit eigentlich auch immer noch als Softwareentwicklung oder Hautparadigm,
kann man immer sagen, objektorientierte Programmierung.
Nicht nur muss man sagen, na gut,
also Objektorientierung kam, 1972 mit Smalltalk im Prinzip auf.
Nicht ansonsten haben wir so andere Programmierparadigmen Lisp, pro Log,
also um jetzt einfach mal so ein paar andere interessante Sprachen noch zu nennen,
sind eben auch schon vergleichsweise alt.
Das heißt also, da tut sich nicht zwingend so viel,
wie das jetzt, also vielleicht,
also beide dann technologiegetriebenen Sache letztendlich der Fall ist.
Gut, das war jetzt eigentlich schon mal so ein bisschen
die Motivation zur Einführung. Damit kommen wir jetzt eigentlich schon
zu dem zweiten Kapitel war es dann als Digitalrechner beschrieben wird,
was eigentlich auch noch so ein bisschen einführenden Charakter hat,
wo es darum geht, zu verstehen, wie Rechnerprogramme abarbeiten.
Dazu hier ein Zitat aus diesem Buch von Tarnbaum und Osted, Rechnerarchitektur.
Nicht, dass man sagt, also ein Computer,
der Digitalrechner ist eine Maschine, die Probleme für den Menschen lösen kann,
indem sie die ihr gegebenen Befehle ausführt.
Eine Befehlssequenz, die beschreibt, wie eine bestimmte Ausgabe auszuführen,
das nennt man ein Programm
Und die elektronische Schaltung eines Computers verstehen alle begrenzte Menge einfacher Befehle,
die in allen Programmen, in die alle Programme konvertiert werden müssen,
bevor sie sich ausführen lassen.
Sodass umschreibt eigentlich schon alles, was dann in der Programmierung passiert,
dass man eben sagt, okay,
ich habe jetzt also irgendeine Art Mechanismus,
in der Regel eben der Prozessor oder die Hardware des
Prozessors,
die sehr einfache Befehle versteht
Und das, was eben die Programmierung ist, ist dann
eben einfach nur die Abfolge seiner Befehle, der Befehle.
Und die Menge dieser Befehle ist dann eben das,
was also quasi der Maschinensprache, beziehungsweise ein Befehlssatz eines Prozessors entspricht.
So, in dem Zusammenhang taucht dann immer auf der Begriff des Semantic Gap.
Das heißt, wenn man sich jetzt sagt, okay,
ich habe eben wirklich diese, Mehr oder minder begrenzte Menge sehr einfarbefehle.
Was sind das für Befehle? Typischerweise sowas wie Adire 2 Zahlen,
die in Register R1 und R2 stehen und schreibe das Ergebnis in Register R4. Oder überprüfe,
ob das Resultat null ist oder Kopiere,
ein Datenwort von einer Adresse im Speicher,
in ein bestimmtes Register.
So, das ist natürlich, wie man hier schon sieht,
also wirklich ein extrem niedriges Abstraktionsniveau.
So, und damit wollen wir jetzt aber
irgendwelche Aufgaben lösen
Die ja eigentlich irgendwo dementsprechend,
womit wir so typischerweise arbeiten und das, was wir eigentlich machen,
ist das irgendwie so eine natürliche Sprache, wo man sagt,
naja, also da bin ich also wirklich um Größenordnung über diesem Abstraktionsniveau,
wo man dann eben letztendlich also irgendwie sowas wie so ein Kontextwissen mit drin hat.
Das heißt, wenn ich jetzt irgendeinen Satz sagen würde,
wie Verein, weil sie einen Termin mit dem Steuerberater,
den ich nicht habe, zu einer Sekretärin,
die ich nicht habe, aber jedenfalls,
also wäre das dann eigentlich so ein Beispiel für eben so eine abstrakte Sprache.
So, um jetzt von so einer Problembeschreibung zu so einer Problembeschreibung zu kommen,
muss man dann eben irgendwelche Mechanismen haben,
die quasi jetzt diese Formulierung auf sehr hohen Abstraktionsebenen dann eben immer weiter verfeinern und runterbringen,
bis man eben wirklich zu solchen sehr primitiven elementaren Anweisungen kommt.
Das ist eben das, was man dann eben in
der Literatur immer unter Semantic Gap findet
So, demzufolge kann man eben sagen,
zwischen Hardware und dem, was also jetzt Aufgabenstellung Problem ist,
was auch immer, habe ich jetzt eben mehrere Schichten,
beziehungsweise mehrere solche Abstraktionsebenen,
die mehr oder minder hoffentlich sauber mit irgendwelchen Schnittstellen voneinander getrennt sind und mit jeder Ebene,
die man dann eben entsprechend höher geht,
hat man dann eben immer neue, mächtigere Sprachen,
bis man dann also irgendwo hoffentlich bei einer Beschreibung landet,
die dann eben eigentlich dem entspricht,
was man jetzt also quasi so in natürlicher Sprache ausdrücken würde
So, wie gesagt, wir werden uns jetzt hier relativ weit unten auf diesen Ebenen mit bewegen,
wären natürlich das, was, also sag mal,
meistens die Programmierung ist, also schon einigermaßen weit oben stattfindet.
Nichtsdestotrotz möchte ich hier also nochmal explizit darauf hinweisen,
dass es eben so ist, dass vieles von dem,
was man eben in der Programmierung braucht,
eigentlich begründet ist, also von einem Verständnis,
wie also irgendwie so eine Kiste letztendlich funktioniert,
weil man da eben bestimmte Rückwirkungen hat, die sich eigentlich auswirken.
Was wären Beispiele für solche Rückwirkungen? Ein mögliches Beispiel ist
im Prinzip die Arrathmetik. Also wir sind eigentlich gewohnt,
Computer sind tolle Sachen, die rechnen unendlich schnell,
die rechnen unendlich genau. Stimmt nicht. Ganz einfaches Beispiel,
also hier quasi so als Java-Code, wie gesagt,
also zu der Syntax will ich jetzt also gar nichts weiter sagen.
Nicht, wenn ich jetzt also im Prinzip jetzt hier sowas habe,
wie jetzt irgendwelche Zahlen im Code und quasi hier hinten im Kommentar
dann immer das jeweilige Ergebnis. Dann kann man sagen,
wenn ich jetzt also hier quasi so eine Intiger-Zahn,
also quasi ganz ganze Zahlen nehme, passt das einigermaßen hin.
Wenn ich hier in der Angst schon rechne, hundertmal,
200 mal 300, kommt als Ergebnis raus,
sechs Millionen, wenn ich daraus jetzt mache,
100 mal 200 mal 300 mal 300,
400 habe ich auf einmal
eine negative Zahl
Weil dieser Datentyp für die Zahlen, Entel-Daten begrenzten Wertebereich,
ich habe einen Überlauf und von der Zahlenkodierung her,
ist man dann auf einmal bei einer Zahl,
die quasi dann die Ausgabe auf dem Bildschirm, also das,
was dieser Print-Befehl dann eben hier machen würde,
als negative Zahl entsprechend interpretiert bzw. Computer würde es dann schon als negative Zahl interpretieren.
Ähnliches hier, Computer rechnet beliebig genau, Kommazahlen.
Also 1,0, ja, klappt, 0,3 klappt auch,
wenn ich rechne,
0,1 plus 0,1 plus
Ist vor uns noch ganz einfach. Ich muss jetzt nicht
mehr lange rechnen. Im Computer kann es aber sein,
dass also hier hinten, also auf einmal irgendwo,
noch irgendwie was auftaucht,
weil eben diese 0,1 in der Zahlendarstellung im Rechner nicht beliebig genau gemacht werden kann,
diese Zahlen nicht genau genug dargestellt werden kann und es deshalb eben zu solchen Rundungsfehlern bzw. Effekten kommt.
Genau das Gleiche, hier dann eben auch,
wenn ich also hier sage, 0,3 minus 0,1 plus 0,1 plus 0,1 nicht.
Also für uns Schulmathematik, wunderbar, ist null.
Hier habe ich also auf einmal minus 5,5 mal 10 und minus 17.
Auch irgendwie so ein Rundungseffekt, der sich also quasi aus dieser Zahlendarstellung ergibt.
Das heißt, diese Aussage, der Computer rechnet beliebig genau
, stimmt dann eben schon mal nicht. Das heißt,
man muss eigentlich wissen, mit welchen Artentmetiken,
mit welchen Zahlendarstellungen man arbeitet, um dann eben,
wenn es darum geht, was weiß ich, später vom Auftraggeber nicht,
also berechnen Sie mal ein Programm, das also irgendwie das und das macht.
Ich mache da irgendwelche Fließkammer-Berechnungen, wundere mich,
dass dann also irgendwie was Falsches bei rauskommt, nicht.
Also wenn es darum geht, dann eben solche Fehler zu erklären,
beziehungsweise zu unterdrücken. Also man kann da gegen was machen,
aber man muss sich eben erst mal bewusst sein,
dass dieses Problem überhaupt da ist.
Gleiches gilt dann eben auch noch, also jetzt hier
also in Bezug auf die Rechnerarchitektur.
Da gibt es dann eben auch bestimmte Auswirkungen, die sich da auswirken können.
Auch hier so ein klassisches Beispiel. Ich habe ein zweidimensionales Array. Das heißt,
ich habe hier also irgendwie sowas wie so eine Datenstruktur,
also eine Matrix mit zwei Elementen, die zahlenweise spaltenweise angeordnet sind.
Das kann also was, was ich jetzt,
also irgendwie ein Bild sein mit irgendwelchen Bildpunkten, das kann irgendwas anders sein.
So, diese Datenstruktur wurde jetzt mit irgendwelchen Werten gefüllt und
ich möchte jetzt quasi die einmal durchlaufen und alle Werte einfach nur aufsummieren. Typischerweise in Programmiersprache,
also in diesem Fall jetzt also hier in Da war,
würde man das dann so machen,
dass ich dann eben hier so zwei Vorschleifen ineinanderschachtel,
wo ich dann eben sage, okay, ich laufe hier einmal mit Laufindex,
quasi jetzt über die Reihen und innen drin dann also quasi mit Laufindex C über die Spalten.
Das heißt also, ich würde dieses zweidimensionale RA so in
dieser Reihenfolge hier irgendwie durchlaufen.
So genau das Gleiche kann ich jetzt machen,
indem ich jetzt einfach diese Abarbeitung ändere
Wenn ich also quasi jetzt einfach hier diese Reihenfolge vertauschen würde,
wo ich dann also jetzt eben nicht innerhalb der Zeile durch die Spalten laufe,
sondern wo ich also innerhalb der Spalten durch die Zahlen laufe und
dann würde ich das Ganze quasi in dieser Reihenfolge so rum abarbeiten.
So, und auch da würde uns jetzt also der gesunde Menschenverstand sagen,
okay, ich erweise hier ein bisschen eine Datenstruktur,
da stehen irgendwelche,
in diesem Fall jetzt meinetwegen Werte zwischen 0 und 1 drin,
die werden also alle da rein nach aufsummiert und Ich erhalte ein Ergebnis.
Und das, was da jetzt also letztendlich auftaucht,
sind also zwei Effekte. Der eine Effekt ist im Prinzip
das, was also auf der Folie vorher drauf war.
Je nachdem, wie rum ich das berechne, kriege ich andere Werte.
Das heißt also hier ab dieser Stelle, hier unterscheiden sich die Ergebnisse.
Auch das, klassisches Beispiel von Rundungsfehlern. Der andere Effekt ist,
wenn ich das in dieser Reihenfolge durchlaufe, Brauche ich eine bestimmte Zeit.
Also in diesem Fall ist es meinetwegen 75 Millisekunden. Ich weiß nicht,
mit welchem Rechner das gemacht wurde, was auch ist.
Immer geht jetzt einfach erst mal nur um die Größenordnung.
Wenn ich das in dieser Reihenfolge mache,
brauche ich auf einmal fünfmal so lange.
Es findet die gleiche Anzahl von Zugriffen auf Elemente dieses Arrays
statt. Es findet die gleiche Anzahl von Additionen statt.
Das heißt, letztendlich werden genauso viele Operationen ausgeführt von dem
Prozessor, von der Hardware.
Trotzdem braucht das eine fünfmal so lange
wie das andere
Warum ist das so? Auch das wieder eine Frage,
die letztendlich hier in der Vorlesung, beziehungsweise dem war es dann also irgendwann ein bisschen später nachher noch kommt, hoffentlich passend geklärt wird.
In diesem Fall eben sind das eben bestimmte Eigenschaften aus der Prozessorarchitektur,
wo man dann eben sagen kann, durch das,
was ich dann also Speicherhierarchie nenne,
das wird also sagen wir mal das vorletzte Kapitel,
hier werden, hat man eben bestimmte Auswirkungen,
dass wenn ich in dem Fall jetzt also sowas wie solche Caching-Effekte habe,
man im Prinzip eben immer solche Beispiele konstruieren kann,
wo ich jetzt eben irgendwie größere Datenstrukturen Mal in einer sehr günstigen Reihenfolge durchlaufe,
dann funktioniert das sehr gut,
mal in einer sehr ungünstigen Reihenfolge durchlaufe und dann ist es ihm entsprechend langsamer.
Und das ist dann eben auch schon entscheidend,
wo man sagt kann, na gut, also so ein Faktor 5,
wenn ich mir jetzt also irgendwie einen Rechner oder einen PC kaufe und sage, ja,
der ist jetzt fünfmal so schnell, das ist natürlich schon ein Kaufargument,
für das man also bereit ist, ja nun relativ viel Geld auszugeben.
Nicht, dass das aber im Prinzip solche Effekte oder solche Größenordnungen
eigentlich auch schon durch die Art und Weise der Software und der Programmierung herauskommen können,
wo man das ja eben besonders günstig oder besonders ungünstig macht und warum das so ist,
das soll dann eben eigentlich auch hier alles noch so ein bisschen vermittelt werden.
Gut, kommen wir jetzt wieder zurück,
also auf diese Umsetzung in die unterschiedlichen Abstraktionsebene, wo man sagt,
also ich habe eben irgendwo ganz unten diese sehr einfachen Befehle,
ich hole den Inhalt von Register R4 und mache damit irgendwie das und das und ich habe irgendwo hier oben meine natürliche Sprache,
okay, so weit sind wir noch nicht,
aber eben zumindest schon mal meine Programmiersprache, mit der ich jetzt also irgendwie entsprechend viel machen kann.
Ja, und das Ganze wird dann eben letztendlich dadurch umgesetzt,
dass man immer sagt, ich habe so eine Beschreibung,
wo man eben mehrere dieser Abstraktionsebenen hat, diese Grafik,
wie gesagt, also ich aus dem Tarnbaumbuch, wo man eben sagt,
ich habe hier wirklich meine physikalische Hardware oder mein System Dort kann ich natürlich auch mein Programm schreiben,
aber das ist dann eine Folge von Nullen und Einsen,
weil das ist das, was der Computer versteht.
So möchte ich natürlich nicht programmieren, dass ich sage,
an der Stelle im Speicher ist,
also irgendwie eine Null an der Stelle, ein Speicher ist eine Eins,
sondern ich möchte ja schon mit irgendeiner Art Programmiersprache und mit irgendwie so ein bisschen abstrakteren Prinzipien da vorgehen.
So, das heißt, anstatt eben hier sein Programm zu schreiben,
hat man dann eben unterschiedliche Abstraktionsebene, wo man sagt,
ich habe eben eigentlich irgendwo ein Programm auf einer höheren Ebene,
was von einem entweder von einem Interpretationsmechanismus übersetzt wird.
Das heißt, diese Interpretationsmechanismus nimmt dieses Programm auf der höheren
Ebene und macht quasi dort aus jedem Befehl mehrere Befehle der
unteren Ebene
Und arbeitet, die dann quasi der Reihe nach ab.
Und das kann eben entweder interpretativ erfolgen, das heißt,
dieses Programm sind für den Interpreter letztendlich nur Daten und erzeugt daraus dann
quasi jetzt Befehle auf der unteren Ebene, die direkt abgearbeitet werden.
Oder man hat eben einen Übersetzer, das,
was also im Prinzip jetzt über Programmiersprachen der Compiler ist,
der jetzt eben diese Programmiersprache nennt und das Ganze eben in Code
auf einer niedrigeren Ebene umsetzt und diesen Code auf der niedrigeren Ebene kann ich dann eben entsprechend darauf ablaufen lassen.
Gut, und das Ganze kann man jetzt eben beliebig weiterspinnen dann eben für sukzessive dann eben immer höhere Ebenen, so einer Hierarchie. Gut,
hier nochmal zusammengefasst, was sie eben schon gesagt hat,
also diese beiden Grundideen, wie das Ganze passieren kann,
eben entweder über einen Mechanismus des Kompilierens, das heißt also,
dass eben aus einem Programm für jeden Befehl der mächtigeren Sprache
eben eine ganze Folge von sehr einfachen Befehlen generiert wird oder eben durch einen Interpreter,
der da ihm quasi jetzt online oder live dann eben diese Befehlsfolgen heraus generiert.
Je nachdem, wofür man das einsetzt,
hat eben entweder mal der eine, mal der andere Mechanismus seine Vorteile,
nicht also aus Performance-Gründen kann man eigentlich immer sagen,
ist sowas wie so ein Compiler günstiger,
weil wenn ich das Programm mehrfach aufrufe oder mehrfach ausführe,
wird es einmal übersetzt,
quasi dann von L1 In die Sprache L0 übersetzt.
Ich habe das dann in L0 vorliegen und kann dann immer jedes Mal schnell,
wenn es benötigt wird, das direkt auf der Hardware ausführen.
Bei Metapreta passiert das Ganze online. Das heißt,
wenn ich das Programm fünfmal ausführe, wird fünfmal dieses Programm gestartet,
was daraus diese Folgen von L0 macht.
Dauert dann demzufolge dann immer etwas länger,
weil natürlich dann also dieses Programm, also sprich der Interpreter,
da dann ja quasi dazwischen sitzt und dann eben auch
noch entsprechend Zeit braucht
Gut, hier noch mal der Begriff der virtuellen Maschine.
Letztendlich ist das jetzt das, was also durch den Interpreter
oder durch so einen Interpretationsmechanismus erreicht wird.
Dass man dann eben sagt,
für so einen Interpreter sind diese Befehle letztendlich nur da,
die dann ja irgendwo eins zu eins umgesetzt werden.
Das heißt, der virtuelle,
dieser Interpreter erzeugt dann eben sowas wie so eine Art
virtuelle Maschine für die Sprache
Das heißt, man kann mit einem Interpreter eben letztendlich jede beliebige Maschine simulieren.
Das heißt, man kann irgendwelche andere Hardware,
irgendwelche anderen Systeme dadurch dann eben auch entsprechend nachbauen.
Also ich könnte jetzt eben sagen,
ich nehme also hier irgendwie so ein altes Programm aus dem Apollo-Programm,
selbst wenn es diesen Prozessor und diesen IBM 360-Rechner da also irgendwie gar nicht mehr gibt.
Nicht, wenn ich eben den entsprechenden Interpreter dazu habe,
kann ich das eben jetzt, dass ich irgendwo auf meinem PC laufen lassen
Und gegenüber dem Programm würde dann eben dieses Interpreter-Programm so tun,
als ob es diese entsprechende Rechner ist.
Gut, als Nachteil natürlich mit diesem Mechanismus,
dass das Ganze meistens langsamer ist, hatte ich ja eben entsprechend schon gesagt.
Und gut, diese Grundidee, diese Interpretation kann man eben
eigentlich auch durch die Schicht noch beliebig drauf oder runterziehen.
Gut, irgendwo ganz unten brauche ich natürlich Hardware,
die das Ganze irgendwann mal ausführt,
aber auch darauf kann man dann eben schon sehr schnell oder
sehr einfach virtuelle Maschinen oder sowas bauen
Auch das ist etwas, was ihn jetzt,
sagen wir mal, mehr oder minder täglich begegnet,
weil dann auch da muss man sagen, wenn sie PC haben,
damit arbeiten, x, 86 Befehlssatz,
hat eigentlich einen ganz anderes Konzept als die Art und Weise,
wie aktuelle Prozessoren arbeiten.
Und das, was passiert, ist,
dass eigentlich quasi in Hardware irgendwo so eine Art Interpreter eingebaut ist,
der diesen Befehl denen also irgendwie die Firma enter sich,
also vor 40 Jahren mal ausgedacht hat,
in eine Folge von mehreren kleinen Befehlen umsetzt,
die auf dem eigentlichen Prozessor abgearbeitet werden.
Also auch da gibt es dann eben so einen Mechanismus der Interpretation. Gut,
bevor ich jetzt also hier nochmal mit den Ebenen entsprechend weitermache,
würde ich sagen, ich habe sowieso schon ein paar Minuten überzogen,
würde dann am Freitag dann dort nochmal entsprechend aufsetzen und sagen,
das soll es dann für heute gewesen sein.
Schönen Abend und dann
bis übermorgen