Herzlich willkommen zur Rechnerstruktur und Vorlesung. Mein Name ist Andreas Meder.
Ich werde also dieses Jahr die Vorlesung lesen und ja,
hoffe, dass es für Sie lehrreich, aber auch interessant sein wird.
Und das sind die Vorlesungen, was bringt und hoffentlich auch
ein bisschen Spaß macht. Bevor es jetzt sage ich mal
so ans Eingemachte geht und ich also gleich mit dem Stoff loslege,
nochmal einige Informationen allgemein jetzt zur Organisation
Generell, oder von weg vielleicht nochmal, in Stine,
was ja nun seinem Erkennen, beziehungsweise was ja dann also
auch entsprechend ausführlich in der Orientierungseinheit vorgestellt wurde, ist also dann die Idee,
dass ich dort also jetzt entsprechende Verweise auch schon eingetragen habe.
Das heißt,
dort finden sie dann immer die jeweiligen Übungsblätter zur Handhabung mit den Übungen,
zeitlich, wann soll was abgegeben werden,
wie sind die zu lösen und so weiter,
werde ich gleich noch was zu sagen,
wenn ich also meine ersten Folien so
ein bisschen vorstelle
Und was ich dann eigentlich auch immer mache,
dass ich meine Vorlesungsfolien, also sprich alles,
was ich hier irgendwie als PDF runterbrumme,
dann auch dort Original 1 zu 1 im Download zur Verfügung stelle.
Wie gesagt, also Stina als Portal ist der offizielle Weg.
Ansonsten habe ich auch immer noch und deswegen also auch hier
der entsprechende Verweis darauf
Ein Verweis auf unsere, wenn wir mal kurz abmelden,
Webseite, weil dort habe ich dann eigentlich auch nochmal
sämtliche Informationen hinterlegt, auch direkt zum Download.
Also das ist dann von der Informatik aus erreichbar.
Und dort versuche ich dann auch immer noch so ein bisschen genauere Informationen zu machen,
beziehungsweise wenn irgendwie kurzfristig irgendwelche aktuellen Sachen aufpoppen oder irgendwas ist,
werde ich das zwar auch in Stine machen,
aber dann typischerweise auch dort zu finden ist das Ganze hier
unter Einrichtung bei den Arbeitsbereichen
Und dort dann, bei, wo ist es hier, Tumps,
das ist also die Gruppe aus, der ich jetzt bin,
das schicke Akronym steht für Technical Aspects of Multimodal Systems,
technische Aspekte, multimodaler Systeme, das,
was wir inhaltlich machen, also wie gesagt,
wer will, kann ja mal irgendwie durchklicken,
ist grob gesagt Robotik, das heißt,
wir haben also mehr oder minder große mobile Roboterplattformen,
die hoffentlich irgendwie so ein bisschen autonom und ein bisschen intelligent irgendwie was machen,
das ist also das,
womit wir uns forschungstechnisch beschäftigen und Da ist man dann eben doch auch teilweise schon etwas näher an der Hardware.
Deswegen machen wir dann eben entsprechend traditionell dann auch immer noch diese Einführungsveranstaltungen,
also in diesem Fall, also hier die Rechnerstrukturen, zu finden.
Also wie gesagt, dann hier unter Lectures, aktuelles Semester und da
sind dann also die Vorlesungsrechnerstrukturen und dann eben hier auch die Übung.
Und hier gibt es dann also eine relativ ausführliche Seite,
wo ich auch diese ganzen Informationen,
die ich ja jetzt gleich auf den ersten Folien habe,
also auch nochmal habe mit Klausurterminen mit dem Stundenplan waren wo,
welche Übungsgruppen stattfinden.
Und hier gibt es dann eben auch unter anderem,
unter Unterlagen dann eben jeweils aktuell die Vorlesungsunterlagen.
Da habe ich also jetzt schon mal die ersten drei Kapitel reingestellt,
schätzungsweise werde ich, also bis Freitag,
je nachdem wie schnell ich dann bin.
Also bis anschließlich Kapitel 2 oder so.
Fertig machen. Gut, dann kommen wir jetzt erst
mal hier
Zu den Folien. Also wie gesagt, jetzt erst noch mal so ein bisschen einführen, das zur Organisation.
Wenn man also in das Modulhandbuch reinguckt, was ist Rechnerstrukturen,
dann findet man da also irgendwie so eine Mehr- oder mit einer schönen Beschreibung,
nicht wo es also eigentlich darum geht, Rechner und Kommunikationsnetze,
Basiskomponenten und so weiter, das eben zu verstehen,
zu sehen, wie funktioniert das Ganze, was verwirkt sich das.
Die Vorlesung Rechnerstrukturen ist eben Informatik Bachelorstudium, beziehungsweise bei der Software-Systementwicklung,
dann die Wahls entsprechend mit bei und vertreten.
Gut, was wird sie jetzt also in diesem Semester inhaltlich erwarten? Zum einen erst mal einführende Grundlagen. Da geht es also eigentlich los mit irgendwelchen Sachen,
Informationsverarbeitung, was ist Information, wie wird Information dargestellt,
dann Rechner atmetik, das heißt, wir werden Zahn dargestellt,
wie können computertechnisch gesehen quasi rechnen,
nicht dazu dann eben einige Grundlagen dann eben auch entsprechende Digitaltechnik,
also Butsche, Argebrauer,
Schaltennetze und dann kommen dann eben sowas wie Schaltwerke,
was dann quasi Automaten sind,
die das dann nachher damit realisiert werden und abschließend tut dann dieser Teil zu den Grundlagen damit zu einfachen Hardwarestrukturen,
wo sie dann also im Prinzip grob von der Idee erstmal lernen sollen,
welche prinzipiellen Funktionseinheiten gibt es eigentlich so in einem Standardrechnersystem.
Gut, danach Sag mal, zweiten Teil von Rechnerstrukturen,
was dann, denke ich mal,
so im Bereich November dann, Ende November dann losgehen wird,
geht das dann also ein bisschen mehr eigentlich um die Rechner, Architektur.
Da wären dann also Stichworte eigentlich erstmal so das Grundprinzip,
wie arbeitet ein Rechner, also das sogenannte von Neumann Konzept,
dann also ein paar Konzepte beziehungsweise Sachen zum Befehlssatz,
dann Maschinencode, auch ein bisschen Assembler und Assembler-Programmierung.
Da sind wir dann quasi an der Schnittstelle zwischen der Hardware und dem,
was sich also quasi jetzt,
wenn ich mit einer Hochsprache anfange und das Ganze übersetze,
was ich dann daraus bekomme, was dann also irgendwie ein,
das ist immer Bitmuster aus Null und Einsen ist,
was irgendwo im Speicher ist und dann wirklich von der Hardware irgendwie ausgeführt werden soll.
Da kommt dann noch so ein bisschen Betriebssystemebene mit dabei und abschließend
tut das Ganze dann eigentlich mit so ein paar aktuelleren Konzepten zur Architektur,
Superskalare, Architekturen,
Parallelrechner,
Pipelining sowieso und so ein bisschen Speicherhierarchie
Und dann sind wir leider in der Regel schon an der Stelle,
wo man sagen muss, das ist zu viel Stoff, das Semester ist zu kurz.
Deswegen habe ich hier dann eigentlich noch ein paar Punkte irgendwie als Add-on,
die ich also vielleicht noch die Folien fertig mache und irgendwie ein Appendics schmeiße.
Und wenn ich sehr schnell sein sollte,
werde ich dazu dann also auch noch ein bisschen was vorstellen.
Aber das ist dann eigentlich noch so ein bisschen Zusatzmaterial, wird logischerweise demzufolge dann natürlich auch nicht in der Prüfung. Hurra abgefragt. Gut,
generell zur Vorlösung, also hier ist Überschrift,
Feedback erwünscht, wenn irgendwelche Unklarheiten sind oder Sonstiges,
gerne Zwischenfragen, entsprechend melden,
gelegentlich gucke ich also auch mal in die Menge und kriege das dann hoffentlich auch mit,
dann, wenn auf den Folien irgendwelche Fehler sein sollten,
auch da gerne entsprechend Feedback,
weil versuchen natürlich das Ganze dann auch immer so ein bisschen
zu aktualisieren und ein bisschen schöner zu machen und ich bin dann also auch eigentlich mal jedes Jahr dabei,
also nochmal eine neue Version zu machen und ein paar Sachen
zu verbessern
Gut einführen, muss ich dann immer noch mal sagen.
Also ein grundsätzliches Problem bei der Rechnerstruktur und Vorlesung ist leider
immer doch ein sehr stark unterschiedliches Vorwissen. Also wenn ich jetzt,
also wie vorhin eben mit irgendwelchen Begriffen um mich schmeiße,
dann wissen einige von ihnen, also vielleicht was damit gemeint ist.
Ein Großteil noch nicht. Und ich muss zugeben,
ich weiß dann also auch immer jetzt nicht genau,
also was ist jetzt irgendwo, wenn ich also nachher anfänge,
Zahndarstellung, Zahlensysteme, da also überhaupt,
dass man die grundlegende Arrangmedik erkläre,
was ist davon also im Prinzip jetzt,
also in der Schule schon irgendwo Mal rangekommen.
Im Sinne jetzt eines Regelunterrichts oder war es auch nicht.
Demzufolge kann es immer sein, dass gerade am Anfang bei denjenigen,
die das also vielleicht schon gehört haben, die dann sagen,
ja gut, also fängt hier bei Adam und Eva an.
Dafür muss sie jetzt nicht auf die Uni gehen.
Dann bitte ich also erstmal um Geduld, wenn der Stoff schon bekannt ist.
Also das wird später dann schon ein bisschen mehr ins Ahlengemachte gehen.
Und da kommen dann also bestimmt auch viele Sachen, die also auch dann neu sein werden. Auf der anderen Seite,
das hatte ich dann also auch immer schon, wenn,
also jetzt irgendwie in Studenten,
die jetzt also entsprechend Wald in der Materie drin sind,
dann also schon wirklich sehr dezidierte Fragen stellen und man dann also irgendwie darauf antwortet und so ein bisschen also irgendwie eine Diskussion aufkommt,
da ist es für viele, also auf einmal,
dass dort also von irgendwelchen Sachen geredet wird,
die dann also wirklich ganz abgehoben sind.
Also auch da kann ich nur nur sagen,
da sollte man sich dann also jetzt nicht von verwirren lassen,
also dass jetzt Frust aufkommt,
sondern wenn dann auch im Laufe der Vorlesung vielleicht also irgendwelche Stoffe zu schnell behandelt werden.
Zum einen würde ich dann persönlich ich, damit ich das
nächste Mal anders mache, dann also irgendwie um Rückmeldung bitten.
Ansonsten kann ich mal nur sagen, will ich auch gleich noch vorstellen,
wir haben dann eben auch noch die Möglichkeit,
neben den eigentlichen Übungsgruppen eine freiwillige Veranstaltung, sowas wie ein Tutorium zu machen,
wo man dann eben auch in Ruhe nochmal Fragen stellen kann oder irgendwelchen Stoff weiter vertiefen kann.
Gut, dass ich nochmal entsprechend Kontaktdaten, Telefonnummer,
ja, Vorlesung selber, wie gesagt, findet hier statt,
beziehungsweise dann am Freitag drüben Audi Max 2, die Folien,
gibt es dann eben entsprechend zum Download und ich verspreche,
sofern ich jetzt nicht ganz verpenne,
dann eigentlich auch die immer schon rechtzeitig vor der Vorlesung bereitzustellen,
weil ich weiß auch immer, dass viele dann sagen,
ja gut,
ich arbeite dann eigentlich direkt mit dem Laptop und mache mir jetzt irgendwelche Notizen in den PDFs selber als Annotation mit rein.
Ansonsten gibt es die Veranstaltung dann also auch als Lecture to Go auf der entsprechenden Seite,
jede Universität,
wo man das Ganze dann eben auch nochmal nachvollziehen kann oder vielleicht nochmal irgendwelche Sachen wiederholen möchte,
beziehungsweise ich weiß, also auch von einigen Nebenflächlern,
wo es also im Prinzip Terminkollisionen gibt,
die dann also zum Beispiel am Freitag jetzt also nicht mit dabei sein können,
dass die dann natürlich davon dann auch entsprechend profitieren würden.
Zu dem Stoff selber,
am Ende dieses Fohlensatzes habe ich dann also noch relativ viel Literatur verweise,
an sich baut die Vorlesung,
aber sagen wir jetzt also auf zwei Lehrbüchern auf,
wobei ich jetzt also nicht zwingend voraussetze,
dass sie die also im Laufe der Veranstaltung also irgendwie sich ausleihen,
komplett einmal durchackern oder sich kaufen oder was auch immer.
Aber auch nur als Tipp, also wenn man sich da nochmal ein bisschen vertiefen möchte,
in der Fachbereichsbibliothek sind die dann eigentlich auch in entsprechender Anzahl vorhanden. Da könnte man sich da dann eben auch nochmal was nachlesen oder nachgucken. Später dann noch Weiteren Teil,
also zum einen in dem Bereich Schaltnetze, Schaltwerke,
wo es dann also auch um Simulationen gibt,
wird dann also teilweise mit Java gearbeitet, beziehungsweise später zum Assembler,
sind dann einige Sachen, wo man sagen kann,
okay, also das, wenn man Beispiele nachvollziehen möchte,
also es wird nicht zwingend vorausgesetzt,
dass sie da jetzt irgendwie was machen, aber wenn man was nachvollziehen möchte,
wird dann also im Prinzip ein C-Compiler benötigt,
beziehungsweise an die Gnuthool-Schehen, diejenigen, die jetzt also irgendeine Unix-Umgebung benutzen,
also genug Slap-Pop oder sowas,
haben das also direkt auf dem Rechner.
Ansonsten, ich habe dann auch nochmal entsprechende Links für Windows-Benutzer, gibt es sonst die Möglichkeit,
sich die Programme dann dort auch als freie Software entsprechend zu installieren,
beziehungsweise, gut, das wird dann eigentlich auch erst im Dezember interessant.
Ich werde dann auch nochmal versuchen,
bis dahin eine entsprechende virtuelle Maschine zu generieren,
die sich dann downloaden und quasi ausführen lassen können,
dass man sagen kann, okay,
also das,
womit der da jetzt immer arbeitet und die Befehle kann man
dann wirklich so eins zu eins übernehmen und dann eben in
so einem Beispiel dann eben auch nochmal durchnudeln lassen
Gut. Verweis auf die Webseite hatte ich dann ja eben
schon entsprechend gebracht. Zu den Übungen. Wir haben jetzt
knapp 380, 280 Anmeldungen für die Übungen.
Sie sind jetzt aufgeteilt in 19 Gruppen mit einer Semesterwochenstunde wöchentlich.
Beginn logischerweise erst ab nächster Woche,
wobei ich dann auch da sagen muss,
also bei diesem ersten Termin nächste Woche
ist noch kein Übungszettel zu bearbeiten und abzugeben
Sondern das wäre dann eigentlich erst in der zweiten Woche. Das heißt also,
bei einem ersten Termin würden sie dann einfach,
sagen wir mal, so ein bisschen Übungsgruppenleiter kennenlernen,
vielleicht noch irgendwelche Fragen stellen, mit dem nochmal abklären,
wie der jetzt letztendlich mit ihnen arbeiten möchte und wie das aussieht.
Gut, dann steht hier Übung, Diskussionen,
Nachbereitung der Vorlesung, ist natürlich immer der Idealfall,
dass man also vielleicht auch nochmal irgendwie Zeit hat,
in Ruhe irgendwie Fragen zu stellen,
rein praktisch sieht das leider häufig dann immer so aus,
dass also die Zeit dann doch nicht ist,
sondern dass man dann also eigentlich mehr damit beschäftigt ist,
also den Übungszettel zu besprechen bzw.
die Aufgaben dann nochmal durchzurechnen
Deswegen, das dann so ein bisschen eingeschränkt. Der Übungsbetrieb selber,
von der Idee her sollte das sein,
also man muss das nicht als Einzelkämpfer durchstehen, sondern es empfiehlt sich,
dass sie sich da in Gruppen zu zweit oder zöderre zusammenfinden.
Die Übungen gemeinsam bearbeiten und dann eben für die Gruppe einen
Übungszettel abgeben und der Übungsgruppenleiter dann eben auch entsprechend die Punkte
dann für die gesamte Gruppe entsprechend verteilt.
Das ist einfach, weil das sind dann also mal
Gruppen von 15 plus noch ein paar mehr Leuten.
Und wenn jemand dann also wirklich jede Woche,
also irgendwie knapp 20 Übungszettel mal eben durchkorrigiert oder so,
da geht dann also wirklich sehr viel an Stunden und Aufwand rein.
Deswegen eben diese Gruppenarbeit auch so ein bisschen. Ja,
die Übungsaufgaben selber, dienen eigentlich dazu so ein bisschen den Stoff zu vertiefen.
Und da kann ich eben auch empfehlen,
sich das also wirklich nochmal in Ruhe alles anzusehen,
auch nachzuvollziehen, weil, kann ich auch schon vorhersagen,
also das, was eigentlich so diesen oder in den Übungsaufgaben vorkommt,
entspricht eigentlich dann den Aufgabe bzw. Fragestellungen, die dann auch später in der Klausur drin sind.
Das heißt, wenn man verstanden hat,
wie es ein bestimmter Rechenweg oder eine bestimmte Fragestellung in den Übungen
oder in entsprechenden Übungsaufgaben funktioniert und das entsprechend drauf hat,
dann hat man also auch in der Klausur dort keinerlei Probleme.
Abgabe ist jetzt eben so geplant, die Übungsaufgaben sind jeweils mittwochs.
Meistens versuche ich das schon ein bisschen vorherzumachen dann auf der Welt beziehungsweise auf Steene zum Download verfügbar und sollen dann eine Woche später,
sticht es halt Mitternacht, beim Übungsgruppenleiter abgegeben werden,
am liebsten per E-Mail,
kann dann eben irgendwie PDF zur Not dann eben auch sonst einfach irgendwie handgeschriebener Zettel eingescannt und dann zuschicken,
nicht weil dann haben die das eben entsprechend sehr einfach und direkt da.
Zur Not kann das aber auch bei uns im Sekretariat
abgegeben werden
Gut, zu den Übungen Scheinkriterien gibt es dann also hier
auch nochmal irgendwie so ein entsprechendes PDF-Blättchen,
wo das Ganze, was ich also hier drauf habe,
dann also auch nochmal schriftlich dargelegt ist.
Letztendlich entscheiden die Übungsgruppenleiter darüber, wo die Leistung erbracht.
Da geht es eben darum, dass sie dann also quasi
in den Übungsgruppen regelmäßig aktiv teilnehmen. Das heißt also,
man sollte dann irgendwann nochmal eine von den Aufgaben beispielhaft
an der Tafel vorrechnen können oder entsprechend lösen können.
Das Ganze also mindestens zweimal in der Regel wird man das
dann eigentlich schon entsprechend oft machen. Sieht dann auch nicht so aus,
dass man jetzt sagt, okay, also man sitzt da irgendwie unter Übungsgruppenleiter,
kommt dann also bösartig an und pickt da irgendjemanden raus,
sondern von der Idee her sollte das also per Freiwilligermeldung passieren.
Das heißt, man kann jetzt eben sagen,
wenn ich jetzt also in meiner Übungsgruppe irgendeine Aufgabe oder eine Teilaufgabe entsprechend gelöst habe,
nicht und weiß, wie das funktioniert,
dann kann ich mich natürlich also beruhigt sein,
weil es also irgendwie freiwillig melden,
dass einmal vorrechnen und dann ist das Ganze letztendlich damit abgefrühstückt
Gut, dann, wie gesagt, fehlen sollte man dort also auch nicht zu oft,
weil auch das dann entsprechend ist. Ansonsten Scheinkriterium ist,
dass die aller Aufgabenzettel entsprechend bearbeitet worden sind,
dass insgesamt einer Gesamtpunktzahl immer,
also mindestens 50 Prozent der Punkte erreicht werden, beziehungsweise,
okay, man kann der Nase vielleicht auch mal verreißen,
bei irgendwie einem Aufgabenblatt dann also mal weniger haben,
sollte dann aber eigentlich über 30 Prozent der Punkte sein.
In der Regel ist das kein Problem. Und wie gesagt,
also gerade auch dadurch, dass man ja in einer Gruppe
mit anderen zusammenarbeitet, müsste das eigentlich auch immer machbar sein.
Gut, wie gesagt, Übung, nächste Vorlesungswoche. Zur Not,
sie haben sich jetzt ja gemeldet, eingetragen,
wurden dann irgendwie von Stine da also irgendwie entsprechend verwürfelt und
also dann hoffentlich entsprechende Präferenzen in den Übungsgruppen eingeteilt.
Zur Not ist es auch noch möglich, also Übungsgruppen zu wechseln,
sofern die jetzt nicht also zu sehr überlaufen sind.
Da müsste man sich dann eben nochmal einfach direkt bei einem
entsprechenden Übungsgruppenleiter melden und zusehen, was da ist.
Derzeitige Belegung bzw. die Belegung von gestern ist dann aber eigentlich,
dass also hier jeweils die Gruppen also schon alle ziemlich komplett gefüllt sind.
Gut, dann hat ihr ja schon angesprochen, es gibt also auch noch Tutorien. Das ist,
sagen wir jetzt, eine Freiwillige Leistung, die wir,
beziehungsweise in diesem Fall dann also auch mit der Fachschaft zusammen organisiert haben,
wo es also dann nochmal die Möglichkeit gibt,
weil gerade so diese Sache haben wir denn Rechnerstrukturen,
also ein bisschen Programmierung oder sowas, das ist häufig schon da,
wenn es dann aber wirklich ja so an Logik,
Hardware, Assembler oder sowas geht,
dann ist das dann doch bei vielen einfach erstmal so ein bisschen,
um Gottes Willen, das ist also kompliziert,
das verstehe ich nicht.
Dabei, da hat man dann eben nochmal die Möglichkeit,
dort dann eigentlich nochmal Inhalte der Vorlesung nachzufragen.
Das Ganze ist eine Freiwillige Veranstaltung, findet statt quasi immer in
so einem Doppeltermin Donnerstag ab 18 Uhr in der Hoffnung,
dass das also irgendwie einigermaßen zeitlich passt.
Seit Hortmeter habe ich da jetzt also auch schon einen entsprechenden Raum,
F334 und hier ist die Kajobski, die also auch eine Fachschaft ist,
wird das Ganze machen, macht das also auch super engagiert und wie gesagt,
also da kann man dann auch mal irgendwie was machen.
Ablauf ist so, dass es eigentlich irgendwie ein Side-Slot irgendwann,
wenn sie malen, sie haben dann Zeit,
zwischen 18 und 20 Uhr muss dann vorbeikommen,
das heißt also jetzt nicht, dass man dann Punkt 18 Uhr da ist,
irgendwie bis zum bitteren Ende bleibt, sondern es ist dann eigentlich mehr so ein Ständiges kommen und gehen.
Ich habe hier auch noch mit drauf, Live-Video-Stream und Info folgt,
Yessica wollte quasi als Experiment oder um das mal auszuprobieren,
das Ganze dann eben auch noch irgendwo aufnehmen und live streamen,
wie das dann also technisch aussieht, wo das zu finden ist,
muss ich zugeben, war es jetzt auch noch nicht,
hatte ich mit ihr noch nicht drüber gesprochen, aber wie gesagt,
also auch dazu würde ich dann also nochmal auf der Webseite irgendwie was machen,
beziehungsweise wenn sie dann also in den Übungen da sind oder in der Tutorien da sind,
kann man da dann also auch nochmal nachhaken,
wie das Ganze aussieht oder wie das gehandhabt wird.
Gut, dann sollte es nochmal ein Tutorium geben,
was dann quasi am Ende des Semesters vor der Klausur ist.
Also wir nennen das halt eigentlich immer Panikfuturium.
Also es geht einfach nur darum, dass man sagt,
okay, also ich habe jetzt gelernt,
da fällt mir irgendwie auf,
um Gottes Willen das und das habe ich doch irgendwie noch nicht verstanden.
Da kann man da eben auch nochmal entsprechende Fragen stellen und dann hoffen wir,
dass das dann eben auch alles entsprechend nochmal gemacht wird.
Termin beziehungsweise wo das Ganze dann stattfindet,
wird dann eben
noch rechtzeitig bekannt gegeben
Auch noch zu den Übungen, beziehungsweise Übungsaufgaben. Hatte jetzt hier nicht mit drauf.
Es wird dann auch noch mal Musterlösungen geben. Auch gerade in Hinblick auf Klausurvorbereitung,
die werden wir dann aber quasi am Blog,
also sprich irgendwann mal kurz vor Weihnachten,
beziehungsweise dann eben entsprechend Ende Januar verteilen und rausgeben, nicht,
aber da haben sie dann also quasi zu sämtlichen Übungsaufgaben dann eben eigentlich auch noch mal den Weg.
Nicht, wenn man sagt, okay,
so und so löse ich das und so und so
mache ich das Ganze dann eben letztendlich auch in der Klausurwahl,
das ja der gleiche Stoff ist,
hervorragend 1,0,
dann hätte man
mit voller Punktzahl bestanden
Neben diesen, jetzt hier der Vorlesung und den Übungen
gibt es dann eben auch noch ein Praktikum, Rechnerstrukturen.
Ich habe das jetzt noch oben mit aufgenommen,
das ist für Informatiker quasi für das Modul verpflichtend, für Lehramtsstudiengänge nicht.
Das heißt, wer von Ihnen jetzt das irgendwie auf Lehramt
studiert und dass ihr das Nebenfach macht,
kann das belegen, muss aber nicht zwingend dran teilnehmen.
Auch da gibt es so eben entsprechende Termine im laufenden Semester
beziehungsweise dann eben auch in der vorlesungsfreien Zeit, Februar und März.
Ich habe jetzt hier also reingeschrieben im laufenden Semester, empfohlen. Gut,
da ist eigentlich auch nur die Idee,
dass man sagt, gut, wenn ich das mache,
weil das auch noch mal so ein bisschen weiter vertiefend ist,
ist das eigentlich als Prüfungsvorbereitung dann noch ganz nett,
weil man da dann noch ein paar mehr Einblicke vielleicht gewonnen hat.
Andererseits, gut, da ist leider dann eben die Teilnehmerzahl und die Anmeldungen entstehen dann natürlich dann,
also irgendwo der limitierende Faktor und das,
was ich jetzt von den Kollegen gehört habe,
sind die Kurse eigentlich auch schon alle mehr ordnemanda voll beziehungsweise überbucht.
Das heißt, Da gibt es jetzt eigentlich keine Wahlmöglichkeiten mehr.
Was ich hierzu eigentlich nur noch ansagen will,
Vorbereitung unbedingt erforderlich, weil, also zumindest jetzt bei den Praktikum,
wenn man da also innerhalb der Zeit mit den entsprechenden Aufgabenzetteln beziehungsweise Aufgabenteilen fertig werden möchte,
muss, wie auch immer, das geht ohne Vorbereitung nicht.
Das werden dann aber entsprechend die Kollegen, also in der
Veranstaltung dann natürlich auch nochmal entsprechend sagen. Da geht es dann eben darum,
so einen einfachen Prozessor zu simulieren, zu beschreiben,
dass man da dann eben auch wirklich nochmal in so einem Simulationsprogramm,
werde ich nachher auch nochmal kurz vorstellen, so was,
dann eben wirklich sieht, wie, zumindest von der Grundidee her,
so ein Rechnersystem arbeitet.
Gut, Klausur hatte ich ja schon entsprechend gesagt, Klausur-Termine sind bekannt.
Es gibt, wie gesagt, zwei Termine ein,
zu Beginn der vorlesungsfreien Zeit an, entsprechend später.
Ich weiß nicht, warum das so ist,
erfahrungsgemäß ist es aber eigentlich immer so, dass also beim ersten Termin,
wo dann eigentlich auch die meisten Studenten da sind,
der Schnitt meistens immer besser ist, als beim zweiten Termin.
Obwohl das also, sagen wir mal,
die gleichen Aufgabenstellungen und auch der gleiche Schwierigkeitsgrad ist.
Deswegen war hier einfach nur dieser Tipp, möglichst bereits die erste Klausur mitschreiben. Nein,
auch einfach deshalb, weil dann hat man eben die Möglichkeit,
wenn man jetzt nicht bestanden hat, also entsprechend zu wiederholen und muss nicht ein Jahr warten.
Was wir auch noch freiwillig machen und anbieten,
also mehr als Stutorien und sowas, geht ja nun kaum noch,
ist dann eben auch noch eine Probeklausur irgendwann auch jetzt am Ende Januar oder sowas,
wollen wir dann also auch quasi auch nochmal sowas rausgeben,
was dann eigentlich so aussieht wie vom Ablauf her eine Klausur.
Das heißt, da werden sie dann eigentlich auch nochmal entsprechend sehen,
was sie dann also später in der Klausur erwartet.
Das ist dann quasi vom Ablauf her wirklich so wie eine Klausur,
man setzt sich zwei Stunden hin, schreibt das Ganze hinterher,
wird dann aber im Plänen, um quasi alles nochmal durchgesprochen,
durchgerechnet.
Also auch da hat man dann also nochmal sehr gute Chancen,
dass wenn man jetzt also irgendwas nicht verstanden haben sollte,
man das Ganze nochmal nachvollziehen kann
Gut, anschließend habe ich jetzt ja so auf den letzten
Folien nochmal einiges an Literatur oder Literaturempfehlungen. Also das,
woran sich die Vorlesungen im Großen und Ganzen orientiert,
sind Bücher von Randall Bryant und David O'Hederon, Computersystems, Programmers Perspective.
Ist jetzt gerade dieses Jahr im Juni wieder eine neue Ausgabe erschienen. Wie gesagt,
das ist bei uns dann eben auch entsprechend in der Bibliothek,
beziehungsweise dann vielleicht schon eine etwas ältere Ausgabe. Ansonsten,
hatte ich auch schon gesagt, also mit der Literatur,
also wohl das als auch der Tarnbaum,
also das nächste Ding sind jeweils, also irgendwie so Ja,
gepflegte 500, 600 Seiten schenken,
wo also dann doch noch etwas mehr drinsteht als das,
was ich also jetzt hier in den vier Semesterwochenstunden vermitteln kann.
Nicht deswegen, wenn irgendwo vertiefende Fragen da sind,
kann man da also gerne reingucken.
Ansonsten wird aber das Studium die Literatur nicht zwingend vorausgesetzt.
Das andere Buch, an dem sich die Vorlesung orientiert,
von Andrew Tarnenbaum und Todd Austin, Rechnerarchitektur,
von der digitalen Logik zum Parallelrechner,
die deutsche Auflage ist jetzt gerade als sechste Auflage
Auch im Sommer neu erschienen. Das ist also wirklich ein
sehr gutes, empfehlenswertes Buch. Haben wir eben auf Deutsch,
beziehungsweise auf Englisch. Und ansonsten auch in der Bibliothek,
also auf der Webseite habe ich das so kurz beschrieben.
Das nur als Hinweis, die älteren Auflagen,
also fünfte Auflage und vorher heißen dann nämlich nicht recht in der Architektur,
sondern Computerarchitektur,
aber ist nach wie vor
das Gleiche Buch
So anschließend, also wie gesagt, das sind eigentlich,
ich sag mal, die beiden Lehrbücher,
an denen sich also die Vorlesung orientiert.
Habe ich dann, also hier noch so diverse weitere,
also aus diesem Bereich technische Informatik. Bei einigen von denen,
also gerade hier von Patterson und Tennessee,
werde ich dann also auch immer noch diverses an Grafiken,
was ich also hier in den Folien verwende, rausgenommen haben.
Ich habe das dann also auch immer zugesehen,
dass sie das mit entsprechenden Literaturverweisen auf den Folien versehen habe.
Das heißt also, da können sie dann auch nochmal nachvollziehen,
Wenn man jetzt also zu irgendwelchen Sachen noch mal
ein bisschen genauer was wissen möchte, wie das ist.
Gut, also wie gesagt, das als zweite Lehrbücher dann
hier so ein bisschen Vertiefung. Das ist dann etwas,
was also schon so ein bisschen über den Tellerrand hinausgeht.
Die Autoren in umgedrehter Reihenfolge, Hennessey und Patterson.
Dieses Computer-Architecture, Quantitative Approach, das ist eigentlich das Referenzbuch,
wenn es also um Rechner, Architekturen geht.
Und gut, dann habe ich hier noch von Donald Knut
diverse Sachen
Hier einige Sachen von ehemaligen Kollegen aus Hamburg und dann hier noch was zum Thema Assembler-Programmierung beziehungsweise das Ganze ist dann auch online abrufbar, runterladbar und zum Nachvollziehen. Gut,
Software hatte ja schon gesagt, Java wird benutzt,
dann werde ich relativ viel,
also gerade nachher in den Kapiteln Schaltnetze beziehungsweise Schaltwerke,
auch zeigen und vorführen mit dem Schaltungssimulator Hades,
den mein Kollege Norman Hendrich entwickelt, gemacht hat,
der dann also quasi Ein Java-Programm ist,
was man an sich dann also auch selber runterladen kann,
wo dann eben auch die ganzen Beispiele drin sind und wo dann eben auch ein Großteil der Sachen aus dem Rechnerstrukturen-Praktikum mit gemacht und gearbeitet wird.
Also dann hier auch immer jeweils die entsprechenden Webverweise,
wo man das Ganze findet und runterladen kann.
Ansonsten hat er ja schon gesagt, Knutool-Chain und wie gesagt,
ich werde dann noch versuchen, dass dann, sagen wir mal,
bis zum Dezember dann also auch nochmal entsprechend schöner Version irgendwie soweit weiter zur Verfügung zu stellen.
Ja, und ansonsten kann ich immer nur sagen,
also auf der Webseite,
die ich dann immer versuche mehr oder minder aktuell zu halten,
wenn mir dann noch irgendwie was einfällt, irgendwelche Kommentare sind,
wird sich da dann noch was finden.
Gut, dann kommen wir jetzt zum offiziellen Beginn der Vorlesung,
dem ersten von 17, 18, wie viel auch immer, Kapiteln.
Wo ich also jetzt erst so ein bisschen einführend Motivation,
was sagen würde, wo es also jetzt auch nochmal so ein bisschen darum geht,
okay, Rechnerstrukturen, was verbirgt sich dahinter,
was soll die Vorlesung vermitteln?
Wenn man beispielsweise jetzt ein Brockhaus, gut, inzwischen hätte man Wikipedia nehmen müssen.
Nein, aber irgendwo einfach mal klassisch nachguckt, also was ist Informatik.
Dann heißt es hier also, die Wissenschaft von der systematischen Verarbeitung von Informationen,
besonders der automatischen Verarbeitung mithilfe von Digitalrechnern und dann eben Querverweis auf Computer.
Nicht dem zuvor kann man eben schon sagen,
Schwerpunkt liegt ihm auf systematische Verarbeitung von Informationen. Das ist das,
womit ich quasi jetzt, also auch erstmal so ein bisschen anfangen werde,
wie wird Informationen dargestellt, repräsentiert,
kodiert und dann geht es nachher im zweiten Teil der Rechnerstrukturen dann eben wirklich mithilfe von Digitalrechnern darum,
dass man eben sagt,
okay, wie ist eben wirklich die technische Zusammenhang.
Wie kann jetzt eben irgendwie das Stück Silizium dafür sorgen,
dass also quasi irgendwie so ein Muster aus Nullen und Einsen so repräsentiert wird,
dass da so irgendwie zwei Zahlen agiert würden oder irgendwie was Bestimmtes gemacht wird?
Das ist dann eben quasi jetzt dieser zweite Aspekt,
der dann eigentlich jetzt hier in Rechnerstrukturen mit drin gehst.
Gut, kennenlernen eben der entsprechenden Themen,
das hatte ich gerade eben in dem anderen schon mal mit drin,
da will ich jetzt also nicht nochmal irgendwie wieder so eine Aufzählung machen und damit langweilen, deswegen werde ich das jetzt also hier nochmal entsprechend überspringen. Grundsätzlich kann man aber sagen,
deswegen das ganz logischerweise, natürlich auch im ersten Semester,
das, was sie jetzt eigentlich hier vorstellen werde,
kann man immer so als Informatikbasiswissen bezeichnen,
also auch wenn sie jetzt später vielleicht nicht also irgendwelche Digitalschaltungen entwerfen werden oder irgendwie als Architekte für sorgen,
dass man sagt,
also wie ist jetzt also irgendwie ein Prozessor oder ein angebettetes System aufgebaut,
dass man aber als Informatiker doch immer zumindest wissen sollte,
wie also bestimmte technische Grundlagen sind,
wie die sich auswirken,
weil das kann dann eben auch später ist ganz oben dann irgendwie in die Programmierung hinein eben entsprechende Auswirkungen haben,
dem oder das sollte dann eigentlich eben immer bewusst sein.
Dazu kommen wir auch gleich noch ein bisschen Beispiele.
Und eben vieles, wo man sagt, na gut,
also irgendwie so Trendsperspektiven, dass man das so ein bisschen bewerten kann.
Nicht dem zufolge werde ich jetzt eben auch erst nochmal so
ein bisschen mit so ein paar motivierenden Grundlagen,
beziehungsweise mit so ein bisschen Historie,
wobei ich die dann auch relativ schnell nur abhandeln werde,
dann diese Woche eigentlich anfangen.
Aber das ist eben etwas, was man eben braucht,
um es also gerade so zukünftige Entwicklungen entsprechend einschätzen zu können
Gut, und wie gesagt, Motivation, wie funktioniert ein Digitalrechner?
Also auch da ist natürlich letztendlich so, dass wir sagen,
gut, Informatik verbinden wir heutzutage eigentlich immer mit Computer,
Smartphone eingebettet im System, irgendwelchen technischen Geräten.
Im Prinzip kann man natürlich jetzt erstmal sagen, Informatik ist die Wissenschaft von einer regelhaften Verarbeitung von Informationen.
Da muss ich jetzt eigentlich erstmal nicht zwingend aus ein technisches System angewiesen sein,
aber inzwischen ist es eigentlich Synonym, dass man immer sagt,
gut, das Ganze passiert eben irgendwo auf dem Computer. Gut,
dann versuchen wir dann eben entsprechend jetzt hier am Anfang auch noch darzustellen,
eben wie wirklich wie das Grundverständnis und die Interaktion von Hardware und Software ist,
weil wie gesagt, das war,
wo wir dann also uns hier bei den Rechnerstrukturen,
also spätestens dann also ab Dezember bewegen würden,
ist dann eben genau diese Schnittstelle,
dass man eben sieht, auch von der Funktion her,
warum kann ein Computer jetzt eben entsprechend rechnen,
Programme abarbeiten und dass man das ein bisschen verstehen sollte,
was da sich dahinter verbirgt.
Gut, dann werde ich jetzt am Anfang noch so ein bisschen auch motivieren,
nicht Variantenvielfahrt von Mikroprozessesystemen, also die meisten von uns kennen natürlich jetzt,
also hier irgendwie Laptop, Desktop beziehungsweise seit, ich meine letzten sechs,
sieben Jahren hat man dann eben auch irgendwie entsprechend seine mehr oder minder smarten Smartphones dabei.
Das ist aber eigentlich nur ein sehr geringer Teil von dem,
was man also als Computer oder als Rechner irgendwo hart oder wenn man in Berührung kommt,
sondern inzwischen ist es eben so, also die meisten Rechner,
Rechnersysteme bzw. Prozessoren sind, eingebettete Systeme, nicht das heißt,
bei einem normalen Mittelklassewagen habe ich also inzwischen so um die 60 bis 80 CPUs drin,
das muss jetzt also nicht irgendwie der autonom fahrende Band sein,
sondern also wirklich ein kleiner Golfvaters und was man also auch sagen kann,
nicht also in so einer Maus ist inzwischen also auch Prozessor mit drin,
dessen Rechenleistung, also auch schon deutlich höher ist als das,
was man, sagen wir mal, vor 40 Jahren,
also nochmal als Großrechner bezeichnen konnte.
Nee, und inzwischen hat man dementsprechend große Vielfalt,
also das, was wir eben hier immer sehen,
ist einfach nur irgendwie so die Spitze des Eisberges,
PCs, Workstations, Server dann immer sehr beeindruckend,
habe ich also auch schicke Grafiken von irgendwelchen Supercomputern,
nicht, aber das meiste sind jetzt eben wirklich mobile Geräte,
Medienverarbeitung und ihm wirklich bis zu irgendwelchen einfachen Sachen,
wo man sagt, also RFID-Tags, Wegwerfcomputer, also das,
was dann Auch vor einigen Jahren schon mal so propagiert hatte,
so eine Richtung auf Heimvernetzung,
Smart Home.
Also ich schalte die Glühbirne nicht mehr dadurch ein,
dass ich also irgendwo Strom an- und ausschalte,
sondern die hängt quasi irgendwie ständig drin.
Und da ist also irgendwie so ein kleiner Mikroprozessor drin,
der also einen Bruchteil vom Centbetrag kostet und der kriegt nur
einen Befehl und dann geht eben entsprechend das Licht an.
Gut, also das hat sich nun irgendwie noch nicht durchgesetzt,
aber im Prinzip sowas dann eben zum Thema Wegwerfcomputer. Gut,
geprägt ist das Ganze eigentlich dann eben durch den entsprechenden Fortschritt,
dass man eben wirklich sagen kann,
innerhalb der Mikroelektronik hat sich in den Jahren eigentlich immer extrem viel getan.
Werde ich dann also quasi als drittes Kapitel Moore Slaw
also auch nochmal so ein bisschen beschreiben.
Wobei man sagen kann, das, was sich dort getan hat,
dann eben ein exponentielles Wachstum ist. Das heißt,
man hat dann also wirklich so pro Jahr 50 bis 100 Prozent mehr Leistung,
mehr Geschwindigkeit, mehr Datendurchsatz, was auch immer man da also quasi als Kenngröße nimmt.
Wie gesagt, also hier Rechenleistung, Speicherkapazitäten, Bandbreite, was auch immer. Hinzu kamen dann auf der Werkzeugseite,
neue Entwurfswerkzeuge, neuen Wurfsparadigmen, weil das ist dann die andere Sache,
nicht also ganz früher hat man Rechner dadurch entworfen,
dass man also quasi mehr oder minder mit grafischen Oberflächen,
also irgendwie einzelne Transistoren designt hat, das Ganze entsprechend verkleinert hat und dann eben quasi in Silizium per Planarprozess dann umgesetzt hat.
Nicht inzwischen wird also niemand mehr irgendwie die Transistoren in irgendwelchen Chips mit acht Milliarden Transistoren,
was also jetzt irgendwie entsprechend perfemanter CPUs bzw. gerade die GPUs haben da also entsprechend viel Komplexität mit drin,
wird da niemand mehr, also die Transistoren einzeln begrüßen,
sondern das wird dann eben auch ähnlich wie in der Programmierung,
wo ich dann eben mit Hochsprachen arbeite,
genauso beim Hardwareentwurf gemacht, wo es dann eben Hardware-Beschreibungssprachen gibt,
wo ich dann eben einfach nur sage,
die Hardware soll das und das tun und dann habe ich dann eben auch entsprechende Werkzeuge,
die dafür sorgen,
dass das eben entsprechend umgesetzt wird und dann letztendlich zu irgendwelchen Gardernetslisten oder Transistannetzlisten führt,
die dann eben entsprechend gefertigt werden können
Also dadurch ist es dann überhaupt erst möglich, das,
was man heutzutage so an Komplexität hat, auch vom Entwurf her zur Hand haben.
Hat eben in den letzten Jahren dazu geführt,
dass man dann eben auch sehr viele neue Anwendungsfelder hat,
neue Produkte,
neue Techniken nicht und eigentlich ständig irgendwelche Sachen jetzt weiter intelligenter werden,
neue Anwendungsfelder aufpoppen nicht,
also sowas wie Smartphones gab es dann eben vor Zehn Jahren noch nicht, nicht.
Also irgendwie wurden die intelligenter. Also jetzt in den letzten Jahren
sowas wie Tablet-Computer, wo man auch sagt, inzwischen,
ja gut, wenn ich mal irgendwo schnell was lese,
was nachschlagen möchte, auch die einfachsten beste Sache der Welt.
Also auch das ist eine Entwicklung, wo man sagen kann,
vor fünf Jahren hat da keiner drüber nachgedacht. Nicht,
also hier auch noch mal angezeigt,
also dass man eben auch einfach erst mal sieht,
also mit jeder Rechnergeneration oder mit den technischen Sachen geht dann eben
auch von den Applikationen oder von den Algorithmen hin mehr.
Hier ist einfach mal quasi oder sind beispielsweise mal zwei Maßgrößen,
sowas wie Instruktionen pro Sekunde.
Und hier irgendwie sowas wie Speichergröße. Das Ganze,
hier nur nochmal zum, das Anmerkung ist eine lugarithmische Skala.
Das heißt, ich habe hier Kilo mega Giga Terrain,
Bit oder Byte, was auch immer.
Und hier dann eben entsprechend viele Instruktionen pro Sekunde.
Und da sag mal so das,
was so der erste Rechner war von Connor Zuse
19037, müsst ihr jetzt nachgucken, mal um,
irgendwo später auf den Folien,
ist es also genau das Datum dann auch mit drauf,
Z1, nicht, da ist man also irgendwo hier unten,
ist sowas wie ein Apple 2 aus den 80er Jahren,
da kann man dann schon sagen, gut,
da habe ich dann also eben irgendwie die Speicherkapazität um eine maschinengeschriebene Seite,
Text zu speichern, beziehungsweise habe ich hier einen locker mit drin,
mit den späteren Speichergenerationen kamen dann eben gerade so jetzt im Sinne von Mediendatenverarbeitung JPEG,
MP3, Audio-CD, MPEG, DVD-Video, HDTV,
wo man sagen kann, gut, also mit dem ersten Intel Pencium-Prozessor,
die noch irgendwie mit 90 mega Herz liefen,
dagegen, so war es alles noch nicht,
aber eben im Zuge der Entwicklung, also wie gesagt,
hier dann der erste Pencium 4,
nicht inzwischen ist man also irgendwo mit einem Prozessoren,
also hier in dem Bereich, da ist das alles kein Problem mehr,
habe ich dann eben auch erstmal die Rechenleistung und die Performance,
womit ich dann also solche Anwendung überhaupt erst mal implementieren kann.
Und inzwischen muss man auch sagen,
also wenn man so in Prospekt guckt,
womit also jetzt beispielsweise Fernseher beworben werden,
dann steht dann eben auch schon entsprechend mit drin,
dass es dann also ein Dualcore oder ein Quadcore-Prozessor,
der dann eben dort entsprechend die Rechenleistung zur Verfügung steht,
um dann eben beispielsweise in Echtzeit die Videodatenströme zu dekodieren aus
unterschiedlichen Formaten und das Ganze dann eben verzögerungsfrei darzustellen
Hier habe ich jetzt nochmal ein Beispiel genommen. Du hast
eine lange vor ihrer Zeit war, aber einfach nur mal,
um zu veranschaulichen, wo wir uns bewegen.
Also wenn man jetzt nimmt, der erste Mensch auf dem Mond,
Nil Armstrong, 1969, das Apollo-11-Programm, die Mondlandung.
Was war damals rechnertechnisch Stand der Dinge?
Also da gab es einen Bordrechner, Apollo Geines Computer,
das ist also diese Kiste hier
31,7 Kilo schwer, entsprechend groß, mit einer Bedieneinheit,
was also dieses Panel ist,
mit so ein bisschen Anzeige und ein paar Tasten,
die nochmal zusätzlich acht Kilo auf die Waage gemacht hatte
. Das ist also quasi in der Apollo-Kapsel mitgeflogen,
lief mit der wahnsinnigen Taktfrequenz von 1,024 Megahertz.
Eine Addition von zwei Zahlen ging auch nicht in einem Tag,
sondern die hat also 20 Takte gebraucht,
wo miteinander,
also über
ungefähr 20 Mikrosekunden ist
Zahnformate waren also 16 Bit-Worte,
nur Festkomma und man hat dann also im Prinzip hier so ein bisschen Romspeicher,
wo also quasi das eigentliche Programm oder die Rechenprogramme hinterlegt waren und eben Rahmenspeicher,
wo man dann also quasi dynamisch was ablegen konnte jetzt anwerten,
mit denen gerechnet wurde, also sprich die entsprechenden Operanten.
Nicht, dass also alles mit irgendwelchen Worten, zwei Kilo Worte,
Größe vier Kilobyte, nicht wo man sagen kann,
also inzwischen hat also jede Glückwunsch-Postkarte,
die ich aufmache und die also irgendwie so eine Melodie hoch und da nudelt und die ich dann also irgendwie,
wenn die Batterie leer ist, wegwerfe,
Speicherkapazität und mehr Rechenleistung als das, was dort letztendlich zur Verfügung stand.
Gut, zusätzlich gab es dann in Houston,
beziehungsweise Cape Canaveral dann also entsprechend viele Großrechneranlagen.
Das ist also das, was man also hier so im Hintergrund sieht.
Damals das Neueste vom Neuen, die IBM System 360 Geräte im Vollausbau,
Modell 75S. Das waren dann eben im Prinzip so größere Seele,
so wie dieses hier dann eben vollgestellt mit solchen relativ beeindruckenden Schränken.
Und das, was man dann teilweise in irgendwelchen alten Filmen ja immer nochmal sieht,
also den sich drehenden Bandlaufwerken mit irgendwelchen Magnetbändern,
die hatten dann also Taktfrequenzen bis zu 5 Megahertz.
32 Bitwater, ein 24-Bit-Adressraum. Das heißt, man konnte
16 Megabyte adressieren. Die Geräte selber hatten bis zu
einem Megabyte Hauptspeicher. Also auch da kann man sagen,
also ein Handy von vor 20 Jahren hat deutlich mehr
Irgendwie Zykluszeit von 1,3 Megahertz. Das heißt, das ist
die Geschwindigkeit, mit der ich auf dem Speicher zugreife.
Da gab es dann aber schon so was wie Fließkomma-Formate und
die Rechenleistung, wenn man das mal irgendwie normieren möchte.
Mips ist dann immer irgendwie so, oder diese Drivestronals,
das ist dann Million Instructions per second.
Ungefähr 0,7 Drivestronals. Wenn man versucht,
das jetzt mit etwas aktuelleren Prozessoren zu vergleichen,
oder wenn man einfach mal ein Gefühl kriegt, was hat sich da inzwischen getan?
Also wie gesagt, das war 1969 Stand der Technik Großrechner.
Davon gab es also irgendwie ein paar Stück auf der Welt.
Und damit ist Amerika, also zum Mond geflogen.
Wenn man sich heute anguckt, also das, was so in Smartphones,
beziehungsweise dieses Modell wird eben eigentlich eher in Tablets verbaut, drin ist.
Also im Prinzip sind aktueller Samsung, Exzenos-Prozessor, Quartcore 1,6 Gigahertz.
Da ist man also bei 14.600 Mips. Womit man dann eben sagen kann,
dass Das, was also irgendwie so Apollo-Rennfahrtprogramm ist, habe ich also einen Faktor 10.000,
also hier schon mal eben so in der Hand drin, mit entsprechend mehr Rechenleistung.
Mit einem halbwegs aktuellen Smartphone. So im Desktop-BC-Bereich liegt man dann also nochmal irgendwie so ein,
inzwischen eigentlich deutlich über einen Faktor 10, da dann nochmal drüber,
also dies ist ein Core-I7 aus der vorletzten Generation,
mit 127.000 Mips, knapp 4 Gigahertz, Taktfrequenz, nicht,
wenn man sich jetzt die aktuellen oder jetzt die letzten großen Prozessoren von Intel ansieht,
die dann zumindest gerade so im Serverbereich inzwischen also wirklich bei physikalisch 16 Kern liegen,
da reist man dann also dann da also auch nochmal deutlich mehr mit.
Das ist einfach nur die Entwicklung von 1969 bis heute. Und demzufolge kann man sich jetzt eben überlegen,
und das ist das, was wir eben auch versuchen wollen,
hier so ein bisschen zu motivieren und was sie dann ja eigentlich auch mit gestalten sollen,
mit programmieren sollen, was wird die Zukunft bringen,
wie wird sich das Ganze weiterentwickeln, wie man sieht,
also die Rechenleistung wächst und wächst und wächst,
was kann man damit machen,
welche Anwendung kann man damit schreiben und wie füllt man das Ganze dann entsprechend mit Leben.
Gut, Konsequenzen daraus, wie gesagt,
das Ganze oder die gesamte Informatik ist eigentlich ein hochspannendes Feld,
eigentlich nichts Stationäres und das,
was ich also irgendwie während meines Studiums gelernt habe,
ist inzwischen auch schon alles längst wieder Oder in vielen Sachen überholt,
völlig veraltet, von der Technik aufgefressen worden.
Was man aber eben sagen kann, ist,
dass eben bestimmte Grundkonzepte eigentlich generell gültig bleiben.
Und das ist eben das, was wir dann auch,
beziehungsweise ich in diesem Fall dann also auch versuchen wollen, ihn hierzu vermitteln.
In Schwerpunkt deswegen letztendlich, dass man da auch sieht,
warum funktioniert das, was dann eigentlich die Konzepte dahinter und
jetzt also weniger irgendwelche technischen Details, technischen Randbedingungen.
Hier auch noch mal als Kommentar oder als Anmerkung.
Ich hatte jetzt eben das Ganze so ein bisschen motiviert,
wie sich die Technik in den letzten 40,
45 Jahren weiterentwickelt hat bei der Softwareentwicklung,
muss man sagen, hat sich auch sicherlich viel getan.
Man hat also tolle neue Werkzeuge und arbeitet also ganz anders,
als man das vor 10 oder 15 Jahren gemacht hat
Wobei man da eben auch sagen, man muss also auch vieles in der Softwareentwicklung,
also jetzt noch gerade von den Konzepten, ist sogar noch vergleichsweise alt.
Bei dem Rechner, Architekturen hat sich also auch in den
letzten Jahren, also nach wie vor extrem viel Detan.
Bei der Software kann man sagen, gut,
wenn ich jetzt von zum Beispiel jetzt irgendwie auf Sprachkonzepte gehe,
kann ich sagen, also Lisp,
also Programmierung mit irgendwelchen listenartigen Strukturen, 1958, Programmabillogic,
wo es dann im Prinzip so um Sprachen ging,
mit denen man also jetzt eben Aussagen,
Logik und sowas entsprechend gut machen kann, pro Log
1972. Die ersten Objektorientierten Konzepte, damals ganz revolutionär die Sprache Smalltalk, auch aus den 70er Jahren.
Und da muss man sagen, gut, also das,
da hat sich jetzt sicherlich einiges getan in Bezug auf die Produktivität,
wie man arbeitet,
was man zum Beispiel jetzt also auch an Bibliotheken benutzt,
aber eben gerade zum Beispiel jetzt so konzeptmäßig Objektorientierung sind da eben einige Sachen
Doch schon vergleichsweise etwas älter. Gut, nach dieser Einführung
werde ich jetzt noch mal so ein bisschen was beschreiben zum Thema,
was für überhaupt sich jetzt hinter digital rechnen.
Also auch das erst mal nur für Live-Vize allgemein.
Wenn man mal jetzt also aus dem Buch von Tarnbaum und Osten
guckt, Rechnerarchitektur, also was ist da beschrieben?
Ein Computer oder die 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 Aufgabe auszuführen ist,
nennt man Programm und die elektronischen Schaltungen eines Computers verstehen eine begrenzte Menge einfacher Befehle,
in die alle Programme konvertiert werden müssen, bevor sie sich ausführen lassen.
Gut, damit geht das Buch im Prinzip los und damit ist dann eigentlich auch schon beschrieben,
vom Grundprinzip her wie Digitalrechner funktionieren, dass man nämlich sagt,
ich habe sowas wie Primitive, ganz einfache Befehle,
die jetzt eben von so einer Maschine interpretiert bzw. abgearbeitet werden.
Nicht das, was wir dann als Programm kennen, als Algorithmus,
als Ablauf, ist dann eben eine entsprechende Abfolge solcher Befehle.
Und ich denke, was dann eigentlich auch klar ist oder klar sein sollte,
also dass eben so eine Maschine dann eben auch nur entsprechend ihre eigene Maschinensprache versteht.
Das heißt also, je nachdem, ob gesagt,
je nachdem,
welche Art von Prozesse ich da drin habe oder welche Art von Recheneinheit,
kann ich das Programm dann eben
auf dem entsprechenden Rechner ablaufen lassen
Beispiele solcher Befehle oder typische Beispiele, das ist das,
womit wir uns dann eben später bei einem Thema Assembler so
ein bisschen mit beschäftigen werden, beziehungsweise was ich vorstelle,
sie müssen jetzt nicht zwingend,
also irgendwelche Übungsaufgaben oder Sachen in Assembler selber programmieren,
aber wo das Ganze vom Prinzip her vorgestellt wird.
Also typische Beispiele solcher Befehle wären dann eben irgendwie sowas wie Adire,
die zwei Zahlen im Register R1 und R2 und schreibe
das Ganze irgendwo anders hin.
Ich überprüfe, ob irgendwie
das Resultat null ist
Kopiere ein Datenwort von Adresse 13, ein Register R4 und so weiter und so fort.
So was. Und da sieht das Ganze ist natürlich jetzt
irgendwie ein extrem niedriges Abstraktionsniveau. War es dann eigentlich auch schon voraussetzt,
dass man also wirklich jetzt weiß, für den Prozess oder diese Architektur,
da hat eben die Register R1 R2 und R4,
was ja nun auch immer nicht bei allen Maschinen entsprechend dann so gegeben ist.
Auf der anderen Seite, das,
womit wir als Menschen eigentlich arbeiten, natürliche Sprache,
liegt man also beliebig weit davon eigentlich entfernt, weil,
wenn ich also eben hier irgendwie so einen Satz reinwerfe,
also gut, ist ein schönes Beispiel, nicht so doll,
aber vor allem waren sie einen Termin mit dem Steuerberater nicht,
dann ist da eigentlich irgendwie schon beliebig viel Kontextwissen dabei.
Das heißt, irgendwie aus dem Gespräch vorher,
wo dann also schon irgendwo ein Problem beschrieben,
dann sollte eben klar sein, was ist damit gemeint,
Termin vereinbaren,
was verbirgt sich hinter Steuerberater,
nicht jeder von ihnen hat dann also im Prinzip eigentlich
schon mal so ein bisschen so eine Idee im Hinterkopf
Also das sind eigentlich Sachen, wo man sagen kann,
wenn ich sowas als Befehl jetzt an den Computer gebe,
dann kann er damit nichts anfangen, sondern es geht erstmal darum,
aus irgendwelchen Problemen, die ich also jetzt sehr hoch,
sehr abstrakt beschrieben habe, das Ganze zu übersetzen in solche Primitivbefehle,
ganz unten das, was eigentlich der Rechner versteht.
Und das bezeichnet man in der Literatur dann eben immer als Semantic Gap,
nämlich wirklich diese Diskrepanz zwischen unseren Vorstellungen und der natürlichen Sprache und eben diese elementaren Anweisungen.
Demzufolge braucht man dann eben zusätzliche Abstraktionsebenen oder Abstraktionsschichten,
die dann dafür sorgen, dass das Ganze entsprechend umgesetzt werden kann.
Das Ganze passiert dann eben in Form solcher Absaktionsschichten,
wo ich dann eben immer Schnittstellen definiere von einer Beschreibungsform in
die nächste Beschreibungsform und man dann quasi mit diesem Konzept der Abstraktion dann eben von Bit-Muster,
wo ich Nullen und Einsinn habe,
was jetzt mein Prozessor XY der Firma irgendwas versteht,
wirklich komme, zu irgendwelchen Konzepten,
wo ich sagen kann,
ich habe hier ein Problem,
einen Algorithmus und der soll dann eben von diesem Prozessor
gelöst werden
Bei dieser Übersetzung oder Umsetzung jetzt eben zwischen diesen Abstraktionsebenen gibt es dann eben noch diverse Optimierungskriterien bzw. Optimierungsmöglichkeiten,
nicht wo man dann sagen kann,
also ich mache das eben entweder möglichst schnell oder ich mache das Ganze,
vor dem Hintergrund, es soll möglichst wenig Energie verbrauchen.
Der Kurzsonn möglichst klein sein, das Ganze soll möglichst sicher sein. Das heißt,
da hat man eben noch so diverse Randbedingungen,
die jetzt also aus ökonomischen Gegebenheiten, aber eben auch teilweise ausgegebenheiten des Systems kommen,
wo die auf diese Übersetzung beziehungsweise das,
wie man Programm formuliert und wie das dann also auf irgendwelche Hardware nachher umgesetzt wird, Einfluss haben.
Wenn ich also Beispiele für sowas sind jetzt eben,
dass man sagt, na gut, also wenn ich,
ich bleiben wir jetzt also irgendwo beim späteren Aufgabenfeld als Informatiker,
also ich möchte jetzt, also ich habe irgendwo eine Aufgabenstellung,
soll ein Programm schreiben, was jetzt irgendwas löst,
das wird dann umgesetzt in technisches System.
Ich meine, gibt es eben schon qualitative Unterschiede,
ob ich sage, okay, ich mache jetzt also irgendwo
so etwas wie die Entwicklung eines Browserspiels Ich wohl mal sagen kann,
okay, das war also möglichst schnell laufen.
Vielleicht ein bisschen klein sein, damit ich also nicht so viele Daten übertragen muss.
Ansonsten gibt es da keine besonderen Anforderungen, außer dass mein Chef sagt, das Ding darf nichts kosten. Sind ganz andere Sicherheitsanforderungen,
als wenn ich sage,
ich arbeite beispielsweise bei der Firma Bosch und es geht also darum,
also für das ABS vom Auto irgendwie eine neue Steuerung zu machen,
weil dann kommt auf einmal sicherheitskritische Aspekte mit rein,
wo man dann eben feststellen muss,
das Ding darf nicht ausfallen und er darf nicht,
also irgendwie Einfach nur, weil er vielleicht einen falschen Sensorwert bekommt,
auf der Autobahn bei Tempo 160 anfangen,
eine Vollbremsung mit einem linken Förderer zu machen.
Weil dann bin ich als Fahrer nämlich weg vom Fenster.
Nicht, also das einfach nur mal so als Beispiel jetzt für solche Sachen mit so unterschiedlichen Randbedingungen.
Und wie gesagt, also da lassen sich beliebige Beispiele finden,
wo man dann eben immer entsprechend unterschiedliche Handbedingungen machen kann.
Also das andere Sache, Stromverbrauch ist eben auch ein Unterschied.
Also ob ich jetzt also irgendwas programmiere,
was also irgendwo auf dem Smartphone laufen soll,
wo ich relativ begrenzte Batteriekapazität habe oder was dann irgendwo auf dem Desktop-Rechner läuft,
wo ich mich da eigentlich erstmal nicht drum kümmern muss.
Wenn ich Programmierung mache beispielsweise jetzt für irgendeinen Tal,
was also in Orbit geschossen wird,
also jetzt irgendwie meinetwegen jetzt die Uhr für ein Galileo-Satelliten,
Nee, da muss man dann eben auch entsprechende Randbedingungen einhalten,
weil wenn das System also einmal irgendwie hochgeschossen ist,
dann kann ich da jetzt also nicht mal eben so einfach rangehen und irgendwelche Wartungen durchführen.
Das heißt, da wird dann also zum Beispiel auch schon
mal die Hardware-Redundat ausgelegt und so weiter und so fort.
Und all sowas wirkt sich dann eben eigentlich auf diesen gesamten Entwurf dann eben auch mit aus. Deswegen hier dann eben auch nur diese Anmerkung,
dass man dann eben wirklich von relativ elementaren Sachen,
wie wir sie jetzt also hier in Rechnerstrukturen,
also gerade am Anfang der Vorlesung vielleicht haben, wo sie sagen,
ja gut, das beutet auch später für die Programmierung nicht,
eben bis zu abstrakten Konzepten der Programmiertechnik,
wie sie dann also dann entsprechend weiter dann eben in Softwareentwicklung dargestellt werden oder dann eben GSS-Grundlagen,
das System, Software, wo es dann eben darum geht,
also wie läuft jetzt also die Betriebsmittelverwaltung im Rechner, sowas alles,
dass man das eigentlich alles irgendwo in meinem Hinterkopf haben muss,
eben entsprechend so ein System arbeitet,
weil ich dann eben doch relativ viel an Verknüpfung und an einer Rückwirkung zwischen diesen Sachen habe.
Ja, Rückwirkung von unteren Ebenen, Arithmetik,
also hier also auch nochmal ein klassisches Beispiel.
Also das ist, jetzt also hier beispielsweise als Java-Code geschrieben,
ich sehe es jetzt also nicht voraus, dass sie irgendwie Java können müssen.
Was ja aber einfach drin ist, dass ich sage,
okay, ich habe hier einfach irgendwelche Zahlen und die werden
einfach ausgedruckt und hier hinterher in einem Kommentar würde man dann eben entsprechend das Ergebnis sehen.
Und wenn ich sage, okay, also Ende Janul Ausdrucken ist das Ergebnis eine Null.
Das funktioniert hier auch soweit ganz gut, wenn ich aber hier dann sage,
druck mir mal das Ergebnis von 100 mal 200 Mater 300 mal 400.
Dann kriege ich also auf einmal irgendwie eine negative Zahl raus.
Was in dem Fall dann also schon mal daran liegt,
dass man sich dann eigentlich schon mal Gedanken machen müsste,
wie ist eben die Zahlendarstellung vom Indija,
wo ich dann also jetzt beispielsweise eine bestimmte Wortbreite habe.
Und das, was also quasi hier arathmetisch rauskommt,
dazu führt, dass sich also quasi einen Überlauf habe und
dann in einen Bereich komme bei der Zahlendarstellung,
dann also auf einmal als negative Zahl interpretiert wird.
Ich so war es. Sollte man dann eben schon wissen,
nicht deswegen, also dann später eben auch diese ganze Sache hier mit Zahlen,
Codierung, Zahlensystem und eben auch mit der Beschreibung dann zu Schalten setzen,
also wie ist eigentlich die Rechnerarithmetik im Prinzip arbeitet.
So bei Fließkomma-Darstellung, also wenn ich hier irgendwie mit Komma rechne,
Heinz ausgeben, 0,3 ausgeben, klappt.
So, 0,3 ist 0,1 plus 0,1 plus 0,1. Das ist für uns
aus der Schulmathematik identisch. Das ist ja kein Problem.
Wenn ich aber diesen Ausdruck hier nehme und das Ergebnis ausdrucke,
dann kommt leider eben nicht mehr 0,3 raus,
sondern dann kommt also auf einmal irgendwo weiter hinten noch irgendwie eine andere Zahl raus.
Genauso, wenn ich hier rechne, 0,3 minus diesem Ausdruck,
würde ich als Ergebnis minus 5,5 mal 10 und minus 17
Können Sie alle an Ihren Rechnern ausprobieren, nachvollziehen?
Liegt halt einfach darin, wie die Zahndarstellung ist und wie
das funktioniert. Das heißt also, da muss als Informatiker
sich dann eben auch erst mal vergegenwärtigen oder sicher sein.
Nicht wir verbinden mit Computer immer tolle Kisten,
die können unendlich schnell rechnen, sind unendlich genau.
Und das stimmt eben nicht zwingend. Man muss einfach erst
mal wissen, wie wird das dann auch technisch umgesetzt?
Wo sind da die Limitierungen? Was kann ich da machen? Nicht rein technisch,
wenn ich sage, ich habe so ein System,
das sollte jetzt irgendwie was steuern,
müsste ich dann eben solche Effekte quasi abfangen und dann eben dafür sorgen,
okay, also wenn das Ergebnis hier hinreichend klein ist, interpretiere ich das als null.
Nicht, aber sowas soll dann eben immer schon klar sein.
Anderes Beispiel, auch immer so ein beliebtes Beispiel aus der Programmierung,
wo es dann im Prinzip um die Performance geht.
Ich habe hier ein zweidimensionales Array,
beziehungsweise es ist also eigentlich ein Array von anderen Arrays.
So, und bei zweidimensionalen Arrays,
das wird jetzt also hier quasi als Argument an so einer
Funktion übergeben und dann eben entsprechend die einzelnen Elemente aufsummiert
So, und das kann ich jetzt eben so machen,
dass sich das eben entweder zahlenweise durchlaufe, wie das also hier dargestellt ist.
Oder ich kann das eben auch spaltenweise durchlaufen. Nicht dieses wäre dann,
also jetzt wie beispielsweise in Java, der entsprechende Code. Und je nachdem,
also ob ich hier diese beiden Indie habe,
macht dann eben zwei ineinander geschachtelte Schleifen,
wo ich dem einmal den Einlaufindex raufzähle,
dann dementsprechend den anderen, je nachdem,
wie ich die dann eben miteinander vertausche,
habe ich eben entweder dieses Zugkaufsmuster oder dieses hier
So, wenn man das jetzt laufen lässt, wird man eben feststellen. Gut,
also hier bei der Messung geht es jetzt also nur um die Größenordnung,
weil ansonsten ist es natürlich von Prozessor und der ist in Taktgeschwindigkeit abhängig,
aber jedenfalls man wird feststellen,
wenn ich das in dieser Art und Weise mache,
brauche ich für die Berechnung des Ergebnisses 75 Millisekunden,
wenn ich das andersrum mache,
arathmetisch genau die gleichen Operationen eigentlich ausführe,
auch genau die gleichen Elemente adressiere und auslese und aufsummiere
Brauche ich also fünfmal so lange ungefähr. Das ist der eine Effekt,
der andere Effekt, wenn man die Ergebnisse vergleicht,
da kommen auch leicht unterschiedliche Werte raus. Und auch das sind Effekte,
die jetzt eben quasi hier als Rückwirkung von den unteren Ebenen bezeichnet werden,
wo man eben sagt, okay, also man muss letztendlich wissen,
wie werden solche Ray-Elemente irgendwie abgespeichert,
wie werden die adressiert, wenn ich darauf jetzt eben zugreife,
entweder zahlenweise oder spaltenweise
Welche Auswirkungen hat das dann quasi in der Abwartung durch die Hardware?
Und das erklärt dann eben beispielsweise dann eben auch diesen Geschwindigkeitsunterschied.
Denn da lassen sich also relativ viele solcher Beispiele konstruieren,
wo jetzt eben durch solche Effekte der Rechnerarchitektur beziehungsweise eben des technischen Systems
sowas sich dann eben wirklich bis nach oben hin in die Programmiersprache hinein auswirkt.
Gut, aber jetzt wieder also zurück zu diesem Semantik-Gap und der Übersetzung,
wie ich jetzt also von Hochsprache oder natürlicher Sprache,
Algorithmus, Wasser, immer eben zu irgendwelchen unteren Ebenen komme.
Und man kann sich das eigentlich immer so ein bisschen vorstellen,
wie so eine gesamte Hierarchie der Übersetzung ist.
Also das ist jetzt hier also aus dem Tarnbaumbuch eine Grafik raus,
wo man sagt, okay,
also irgendwo ganz unten habe ich wirklich die physikalische Hardware,
wo quasi das System jetzt wirklich ein Programm,
was eben in entsprechender Sprache,
also sprich aus solchen ganz primitiven Befehlen gemacht,
ist auf diese Hardware, also direkt physikalisch dann eben auch ausführen kann.
Ich kann aber eben auch sagen,
ich habe jetzt eben von der Abstraktion her eine Ebene da drüber oder eine Ebene höher,
wo ich dann eben eine schon mächtigere Sprache habe,
in der ich dann eben quasi jetzt meine Programmierung mache und
eben in dieser mächtigen Sprache um die Programme dann also wirklich auch immer noch auf der gleichen physikalischen Hardware ausführen zu lassen.
Da habe ich dann eben die Möglichkeit zu sagen,
entweder ich habe so eine Art Übersetzungsmechanismus,
dass mir das Ganze eben in die Sprache der Ebene Null übersetzt.
Oder ich habe eben eine Art Interpreter oder Interpretationsmechanismus,
der dann quasi direkt diese Befehle der Sprache L1 nimmt,
die dann quasi umsetzt in irgendwelche Folgen,
interpretativ und das dann eben quasi darauf ausführt.
Und das Ganze geht dann eigentlich über mehrere Ebenen. Und das,
was wir jetzt eben als Informatik einer Programmierung sehen,
wenn wir jetzt sagen, okay,
also wir haben jetzt so ein Algorithmus, den wir dann also irgendwo einprogrammieren.
Da ist man dann also in der Regel dann schon irgendwo hier
deutlich höher und das, was sie noch nach oben hin weiter noch stattfindet. Nicht,
das heißt, wenn man jetzt irgendwo arbeitet oder der Chef sagt,
okay, ich schreibe ein Browserspiel, was das und das macht,
dann ist für mich dann quasi jetzt wieder die Übersetzung in dem Sinne,
dass ich sage, okay, ich überlege mir, was soll das leisten, wie funktioniert das?
Und das,
was ich dann also wirklich dann in die Tastatur eingebe bzw. in das Programm eingebe,
jetzt in der Programmiersprache meiner Wahl,
mit der dort dann also entsprechend gearbeitet wird,
das wäre dann eben Das Alleroberste von natürlicher Sprache dann eben an Übersetzung in Programmiersprache.
Gut, hier rauf nur noch mal kurz diese Unterscheidung.
Das, was also ein Compiler oder Übersetzungsmechanismus macht, ist,
dass eben quasi das Programm wirklich in eine Folge von Befehlen einer niedrigen Sprache umsetzt.
Interpreter, hat er ja schon gesagt,
nimmt quasi jetzt immer einen Befehl einer bestimmten Sprache und ersetzt
den dann eben durch eine ganze Folge von Befehlen in einer
niedrigeren Sprache
In dem Zusammenhang hier dann auch noch mal kurz erwähnt,
der Begriff der würdellen Maschine. Und zwar kann man jetzt eben sagen,
also ursprünglich fange ich ja an, jetzt zurücknehmen wir den hier.
Also irgendwo hier unten mit einer physikalischen Hardware der unteren Ebene.
Ich habe dann eben hier irgendwie eine Art Interpretationsmechanismus,
wo ich sagen kann,
Ich bin dann schon mit einer mächtigeren Sprache,
also in diesem Fall mit L1 zugange und führe das durch einen Interpreter aus und das,
was der Interpreter dann letztendlich darstellt, ist eben eine virtuelle Maschine.
Das heißt, für mich als Benutzer sieht es so aus,
als ob ich direkt mit der Sprache L1 arbeiten kann und
das Ganze wird dann eben entsprechend durch die Hardware darunter ausgeführt.
Nicht dem zuvor kann man eben sagen,
das Ganze ist letztendlich dann,
wenn ich so ein Interpretationsmechanismus habe,
eine virtuelle Maschine M für die Sprache
Nicht das führt dann eben dazu, dass man sagen kann,
okay, ich kann von irgendwelchen unteren Schichten abstrahieren, aber irgendwann, ganz unten,
wird es dann höchstwahrscheinlich irgendwelche Hardware geben, die es dann doch noch ausführen muss.
So, wenn man sich jetzt anguckt,
wir sind typischerweise jetzt unterschiedliche Ebenen, Betrachtungsebene, also das,
womit sie jetzt also im Prinzip in einer Programmierung, also in SE,
In Berührung kommen werden, ist dann eigentlich irgendwie sowas,
wo man sagt, okay, das ist also Anwendungsebene,
das heißt, da arbeite ich mit irgendwelchen Hochsprachen,
mit Java, Smalltalk, C plus plus Sisha,
was auch immer.
Nicht dann gibt es einen Mechanismus,
der das Ganze dann eben umsetzt auf Assembler-Ebene,
das ist dann also schon Low-Level-Anwendungsprogrammierung,
wo ich dann im Prinzip schon irgendwelche unteren Befehle jetzt
für irgendwie eine bestimmte Prozessorarchitektur habe
Da spielt dann eigentlich auch noch mit rein. Der Begriff der Betriebssystem-Ebene,
wo es dann also auch so ein bisschen darum geht,
dass man da also auch nochmal unterscheiden muss,
zumindest jetzt bei aktuellen Rechnerarchitekturen jetzt zwischen dem oder der Art von Assembler,
die Mayasam heißt,
als Programmierer für ein Anwendungsprogramm nimmt und der Art von Assembler,
die man jetzt also nimmt, um jetzt das Systemprogrammierung zu machen,
weil, das sagen wir einfach erstmal konzeptuell getrennt ist,
weil wenn ich sage, ich habe einen Rechner,
da laufen also irgendwie 20,
30 Programme und irgendwann kommt nochmal ein anderes hinzu, einfach aus Sicherheitsaspekten sollen,
Das eine Programm, dem anderen also irgendwie nicht reinforschen.
Genau dafür ist dann eben unter anderem auch das Betriebssystem verantwortlich,
was dafür sorgt, dass die eben quasi mit getrennten Speicherbereichen arbeiten,
dass wenn die Zugriffe auf irgendwelche ein Ausgaberessourcen oder irgendwelche anderen Ressourcen haben wollen,
das Betriebssystem dafür sorgt, das wird jetzt genau dem Prozess zugewiesen, das wird genau dem Prozess zugewiesen.
Und demzufolge gibt es dann, also sagen wir mal,
bei dem, was also Assemblerbefehlssatz für irgendein Prozessor ist,
dann eben auch noch Unterschiede zwischen dem,
was ein Anwendungsprogrammierer machen darf und was man also jetzt als ich sag mal,
privilegierter Prozess, der zum Betriebssystem gehört, dann eigentlich machen darf. Gut,
auf der anderen Seite habe ich dann,
also das ist jetzt so ein bisschen in Richtung Programmierung,
habe ich dann eben jetzt, wenn ich also auf die Hardware gehe,
unterschiede, wo ich sage, ich habe Rechnerarchitektur,
ganz oben eigentlich sowas wie die Schnittstelle zwischen Software und Hardware,
das, was ich dann später als ISA,
Instruction Set Architecture oder eben auch Befehlssatz vorstellen werde,
wo man dann eben sagt, okay,
ich habe jetzt also für einen Prozessor von dem und dem Hersteller eben irgendwie die und die Befehle,
wo man dann eben jetzt guckt,
was kann ich mit dem Befehlen machen,
wie werden die abgearbeitet durch die entsprechende Hardware.
Das ist dann eigentlich
so genau