Jetzt in dem zweiten Kapitel von Rechnerstrukturen und Betriebssysteme
wird es um einige Grundbegriffe zu dem Thema der Informationsverarbeitung gehen.
Einiges davon wird es dann später nochmal in anderen Kapiteln,
nämlich einmal bei der Informationstheorie und dann auch an der Schnittstelle Rechnerarchitektur zum Assembler hin, nochmal erneut begegnen.
Hier ist aber schon mal so einige einführende Beispiele und eben auch Begriffe aus der Informationsverarbeitung. Ja,
wenn man jetzt in die Literatur guckt, Ja,
ein Zitat aus dem Buch von Thorn, Baum und Austin,
sieht man ein Computer oder 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, das nennt man Programm.
Die elektronischen Schaltungen eines Computers verstehen eine begrenzte Menge einfache Befehle,
in die alle Programme konvertiert werden müssen, bevor sie sich ausführen lassen.
Was hier wichtig ist, ist einmal zum einen der Programmbegriff,
nämlich als Abfolge dieser elementaren Befehle,
das haben wir schon in einem letzten Kapitel,
als ich das Grundkonzept des von Norman Computers erklärt habe, gesehen.
Und was hier dann eben auch nochmal explizit mit drin ist,
dass man eben wirklich sagt, ich habe diese einfachen Befehle,
die dann sequenziell drei nach abgearbeitet werden. Diese einfachen Befehle,
dass es dann eben das, was man unter Maschinensprache versteht,
nämlich die Folge oder Sequenzen aus Nullen und Einzelnen,
die ich jetzt also quasi wie einen Befehl interpretieren kann,
der dann für einen bestimmten Prozess und eine bestimmte Hardwarearchitektur dann abgearbeitet werden kann.
Da kommt jetzt der Begriff des Semantic Gap ins Spiel.
Vor allem, wie gesagt, eine begrenzte Menge einfacher Befehle. Was ist damit gemeint? Ja,
das sind eigentlich immer solche trivialen Befehle, wie das,
was ja so in der letzten Woche schon kurz beschrieben hatte,
addiere beispielsweise zwei Zahlen, die in irgendwelchen Wie auch immer,
da ist noch mal reden, oder gestern,
eins und eins, zwei stehen.
Überprüfe, ob das Resultat gleich null ist und kopiere
ein Datenwort von einer Adresse, noch ein anderes Register.
Das sind alles vergleichsweise triviale Beispiele, die aber eben auf einem extrem niedrigen Abstraktionsniveau sind.
Du hast ja nichts mit dem zu tun hat,
was wir jetzt eigentlich typischerweise als Problemstellung oder als Aufgabenstellung sehen.
Jetzt für einen Computer, also beispielsweise irgendeine Textverarbeitung auszuführen, irgendeine größere Berechnung zu machen.
Da werden wir uns jetzt nicht mit solchen Befehlen auf dieser Abstraktionsebene heraus bewegen. So,
und wenn wir jetzt also wirklich dahin geht,
wie unterhalten wir uns in der natürlichen Sprache,
da ist es eben immer wichtig, dass man sagt,
in der Regel haben wir in einer Gesprächssituation doch immer ein gewisses Kontextwissen,
was uns auch gerade bei Mehrdeutigkeiten, vorher gleich noch,
dann eben auch erlaubt, die Informationen entsprechend zu interpretieren bzw. daraus dann eben den richtigen Schluss zu ziehen.
Ja, Kontextwissen,
wie gesagt, wenn wir jetzt also die irgendwie sagen,
Verein waren sie ein Termin mit dem Steuerberater,
nicht damit dann natürlich jetzt als Beispiel einfach nur gedacht,
wenn jetzt nicht klar ist, was ist Termin,
was heißt vereinbaren, was soll sich dahinter verbergen,
soll der jetzt also irgendwo einen Termin abgemacht werden,
wie passiert das,
telefonisch,
wo wir das Ergebnis dann hinterlegt auf Papier,
auch irgendwo elektronisch oder was auch immer
Das ist also das, was dann in dem Sinne da jetzt als Kontextwissen da noch mit dahinter ist. So,
und das führt uns jetzt eben zu diesem Begriff der Samantic Gap,
nämlich diese des Kurvens, dieser wirklich trivialen Elementaren Anweisung,
wo ich jetzt eben auf so einem Abstraktionsniveau bin,
wo ich jetzt also hier irgendwelche, wie auch immer,
durchnummerierten Speicheradressen und irgendwelche, wie auch immer,
ein nummerierten Register habe oder das,
was wir eigentlich machen wollen, wo man eben sagt,
ich möchte als Mensch mit dem Computer irgendwas machen,
damit irgendwie kommunizieren und ich bewege mich eben auf dieser Ebene.
Und das führt dann eben dazu, dass ich da eben entsprechend große Lücke habe,
die sich auftut und die dann eben, sei es durch Hardware,
sei es durch Software, über verschiedene Ebenen der Abstraktion dann geschlossen werden muss. So,
und das ist eben etwas,
was jetzt hier bei uns in der Rechnerarchitektur an mehreren Stellen auftaucht,
dass man eben diese Abstraktionsebenen oder Abstraktionsschichten hat,
wo ich jetzt eben mit definierten Schnittstellen sagen kann,
dass ich von diesen sehr einfachen, sehr primitiven Befehlen,
zu immer komplexeren Darstellungen komme,
bis ich damit dann eben irgendeine Komplexität habe,
wo ich dann eben auch als Mensch mit kommunizieren kann und man dadurch dann also von diesen aller einfachsten Anweisungen auf Maschinensprachenebene dann eben bis zu Programmiersprachen oder bist du Eingaben von Betriebssystemen und beziehungsweise irgendwelchen Computeranwendungen letztendlich landet?
Ja, bei diesen Abstraktionsebenen gibt es jetzt also unterschiedliche Optimierungskriterien,
das können natürlich so die klassischen technisch bedingten Sachen,
also performancegrößte Leistungsaufnahme sein, das können Wirtschaftlichkeitsüberlegungen sein,
wie sieht das jetzt mit irgendwelchen Kosten aus,
sprich welche Hardware setze ich ein, welche Software setze ich ein,
Bei beiden muss ich natürlich nicht nur das Produkt als solches bezahlen,
sondern also auch den Entwurf der Software oder der Hardware.
Bei der Hardware ist es klar,
bei der Software sollte es zumindest klar sein,
dass wenn eine Firma eine bestimmte Software entwickelt,
da gegebenenfalls dann natürlich auch Kosten für anfallen und man die bezahlen sollte und ja,
dann eben aber auch andere Optimierungskriterien, sowas wie Zuverlässigkeit,
Wartungsfreundlichkeit, Sicherheit und je nach Anwendung beziehungsweise je nach der Art und Weise,
wo ich jetzt mein Optimum sehe,
ergibt sich dann eben insgesamt für das System eigentlich ein Mix aus vielen unterschiedlichen Einzelaspekten,
wo man dann eben versucht,
einen möglichst optimale Lösung für so ein Gesamtsystem zu erreichen.
Ja, damit kommt man jetzt eben von sehr einfachen Sachen
zu entsprechend immer komplizierteren. Nichtsdestotrotz ist es eben notwendig,
Deswegen fangen wir jetzt hier also auch auf sehr niedrigem Abstraktionsniveau
am Anfang der Vorlesung zum Beispiel auch erstmal an. Nichtsdestotrotz ist es eben notwendig,
auch auf diesen alleruntersten Ebenen schon gewisse Grundkenntnisse zu haben,
weil sich dadurch dann eben Rückwirkungen ergeben, die auf oberen Ebenen,
also beispielsweise, wenn wir jetzt was programmieren, eben auch entscheidend sind,
wie gut kann ich jetzt also irgendwie diese Optimierungskriterien performance,
was auch immer,
entsprechend einhalten
Das war ja etwas, was ich also in der letzten Session,
also auch schon mit angedeutet habe, warum das Ganze überhaupt,
dass man eben wirklich ein zumindest Grundverständnis von der Abarbeitung der Programme,
die man entwickelt, auf der Hardware haben muss,
um eben eine entsprechend gute und effiziente Programmierung hinzukriegen.
Ja, was wären jetzt Wahlspiele dafür für solche Rückwirkungen,
jetzt mal kurz ein Spielbeispiel dazu, wie gesagt,
weil ich will jetzt gar nicht also auf die Programmierung an sich eingehen oder was sich dahinter verbirgt,
sondern einfach nur zeigen, welche Effekte da auftauchen können,
wie das jetzt genau aussieht mit den Programmen.
Ich denke mir, das ist dann Aufgabe von SE beziehungsweise vielleicht,
wenn du später bei einigen Sachen dann also auch noch mal
ein bisschen was in der Richtung sehen,
aber hier am Anfang keine Angst,
wenn die ihn jetzt also hier mit irgendwelchen programmiersprachlichen Konstrukten oder sowas noch nicht so klar ist,
was damit gemalt ist.
Also ein Beispiel für so eine Rückwirkung wäre jetzt
zum Beispiel
die Adatmetik
Weil gefühlt sagen wir ja doch immer, ja,
so Computer ist eine Vergleichsweise dumme Kiste ohne Programm,
ohne irgendwelche Anweisungen, die dem sagen,
was das macht, kann eigentlich gar nichts.
Und das, was er kann,
sind eben wirklich nur diese ganz einfachen, trivialen Anweisungen.
Aber dafür kann er das eben unendlich schnell.
Und dann kann er eben gefühlt also auch beliebig schnell rechnen.
Und im Vergleich zu dem, was wir jetzt mal
so kopfrechenmäßig können, eben auch beliebig genau.
Und auch da sollte einem eigentlich schon relativ früh klar sein,
das stimmt so nicht
Hier eben das klassische Beispiel dazu. Also das, was hier gezeigt ist,
ist, sind im Prinzip, also in diesem Fall, das ist ein Java-Programm.
Das ist, also hier quasi solche Printanweisungen gibt,
wo ich also entweder ein Integer werde, also sprechende ganze Zahlen,
oder ein Double, das ist also eine Fließkomma-Zahl,
aber das heißt eine Zahl mit einem Punkt, also eine Komma-Zahl, entsprechend ausgeben kann. So,
und wenn ich das jetzt also hier mit solchen Routinen mal ausgebe,
eine Null erzeugt als Ausgabe eine Null,
also hier nach diesen beiden slash, das ist dann immer quasi das,
was also quasi dann also die Ausgabe von dieser,
diesem Printbefehl wäre, da sieht man,
das passiert hier alles wunderbar, dann habe ich ihn aradhmetischen Ausdruck,
da wird auch soweit alles richtig ausgerechnet,
ich dann irgendwie hier 100-mal 200 mal 300, wunderbar,
bekommen da sechs Millionen draus,
auch das ist richtig und jetzt rechne ich nochmal mal 400 und habe auf einmal eine relativ große negative Zahl.
Das heißt, an der Stelle komischerweise ein Rechenfehler,
so bei Fließkommazahlen 1,0, ja, funktioniert,
0,3,
ja,
Print Double 0,1 plus 0,1 plus 0,1. Das können wir noch
vergleichsweise einfach im Kopf rechnen. Es sollte ja 0,3 rauskommen.
Tut es aber nicht, sondern da habe ich hier hinten,
also auf einmal doch noch irgendwo eine Stelle,
wo ich also irgendwie einen sehr kleinen Fehler drin habe.
Und Print Barbell von 0,3 minus 0,1 plus 0,1 plus 0,1 ist eben nicht leicht null,
sondern auch an der Stelle habe ich eben eine sehr kleine negative Zahl.
Nicht dies ist dann eben die Schreibweise für diejenigen,
die es jetzt nicht kennen, die,
also sag mal, unsere üblichen Wissenschaftlichen Schreibweise entspricht,
also minus 5,5 mal 10 hoch minus 17 ist das.
So, das heißt, selbst für uns triviale Ausdrücke, Rechnung Computer, nicht richtig.
Das ist die eine Erkenntnis. Warum das so ist,
werden wir dann noch kennenlernen am Rande vor dieser. Eine andere Sache, performance. Da geht es also um ein Beispiel,
wo man eine zweidimensionale Struktur hat,
dass es also hier quasi diese Matrix hat,
ist also ein Reh, wo ich Zeile und Spalte habe,
also sprich sowas wie beispielsweise jetzt,
also irgendwie die Pixel auf dem Bildschirm,
wo man typischerweise zum Beispiel,
wenn ich da jetzt also irgendwelche Bildverarbeitung drauf mache,
dann also jetzt hier irgendwie zahlenweise durch die Pixel laufe und dann dort irgendwelche Operationen ausführe,
um Weltsaison was zu berechnen oder zu machen.
So, und jetzt kann man natürlich sagen, wie laufe ich hier durch?
Zahlenweise? Oder laufe ich hier irgendwie spaltenweise durch? So,
und das macht also genau irgendwie jetzt hier so ein Java-Programm für so einen Trivialbeispiel.
Also ich habe jetzt hier dieses Array. Das hat eben
eine Anzahl von Zahlen und Spalten. Und wird jetzt über
eine andere Routine initialisiert, hier dann quasi übergeben.
Und es soll dann eben die Summe über alle Elemente gebildet werden.
So und bei diesem Summebilden kann ich jetzt eben entweder jetzt zahlenweise oder wie hier angedeutet spaltenweise durchlaufen.
So in dem Fall passiert das jetzt also durch diese beiden ineinander geschachtelt.
Vorschlafen, wo ich dann eben Wie jetzt hier angedeutet,
einmal über alle Zahlen gehe und innerhalb jeder Zeile,
das ist dann diese hier eingebettet für Schlafe,
dann eben über alle Spalten gehe.
Das heißt, das, was also diese Reihenfolge macht,
ist das, was also ich in Blau gekennzeichnet ist.
Und ich berechne dann also hier quasi die Summe,
indem ich dann immer das Element nehme und zu diesem Pferd hinzuaddiere,
der wurde vorher mit 0,0 initialisiert.
So, und anschließend wird das Ergebnis auch ausgegeben. So,
und das, was jetzt hier unten passiert ist, dass man sagt,
okay, Das fahren RA von 5.000 mal 5.000 Elementen heranzulegen.
Dauert irgendwie eine gewisse Zeit auf Hardware XY, hat mal irgendwie ausgemessen. So,
und wenn ich das jetzt jetzt in dieser Reihenfolge hier berechne,
dauert die Berechnung, bis die Routine hier zu Ende ist.
75 Millisekunden. Wenn ich das in dieser Reihenfolge mache,
was da so quasi passieren würde,
wenn ich jetzt einfach diese beiden Schleifen in der Reihenfolge austausche,
beziehungsweise hier die Indizes tauschen würde,
dauert das
383 Millisekunden
Das heißt, es ist nicht nur irgendwie ein bisschen langsamer,
sondern es ist fünfmal so langsam geworden.
So, gerade heutzutage, wo jeder sagt, wunderbar,
ich möchte also immer bessere und schöne orangenere Hardware und gegebenenfalls liefert uns die Technik das sogar.
Siehe Mooreslor aus dem letzten Kapitel, sieht man dadurch,
dass ich also hier einfach nur R&C irgendwo mal in dem Code vertauschen würde,
ist mein Programm bei identischer Hardware deutlich langsamer geworden.
Das heißt, also hier sieht man dann eben auch nochmal,
dass man also selbst für so einfache Trivialbeispiele schon Ein gewisses Grundverständnis haben sollte,
was dahinter passiert und das ist eben genau das,
was also hier die Vorlesung leisten soll,
was dann eben für genau solche Effekte verantwortlich ist.
Hinzu kommt in dem Fall dann auch noch,
dass ich hier dann also auch noch andere Werte berechne.
Das heißt, also hier für die ersten paar Nachkommastellen habe ich dann zwar noch identische Werte,
aber irgendwo hier sieht man schon, unterscheiden sich dann also auch die Ergebnisse.
Das heißt also auch hier habe ich jetzt irgendwelche numerischen Abweichen,
die da also mit reinkommen, die ihm dazu führen,
dass man jetzt nicht sagen kann, ich habe identische Ausgangsdaten,
ich berechne das mal so und ich berechne das mal so und kriege also leichte unterschiedliche Ergebnisse.
Das sollte einem als Informatiker dann eben eigentlich immer bewusst sein. Ja gut,
also das ist jetzt nur zum Beispiel für zwei mögliche Effekte,
die also in dieser Rückwirkung auftreten können. Wodurch sie zustande kommen,
werden wir dann in dem nächsten Kapitel, also in Kapitel 3,
wo es dann also um die Zahlendarstellung und um die Arithmetik geht,
kennenlernen, beziehungsweise dann in einem späteren Kapitel,
wo es dann also um die Rechnerarchitektur geht,
weil das dann im Prinzip die Grundeffekte oder dort wird dann also erklärt,
was dann für genau diese Effekte verantwortlich ist.
Gut, kommen wir jetzt aber wieder zurück zu diesen Ebenen und zu der Darstellung,
wo man dann also wirklich mit diesem Semantic Gap irgendwo bei dem landet,
was wir jetzt als Kommunikation verstehen beziehungsweise Programmierung,
Kommunikation oder eben mit dem Computer machen wollen.
So, dazu, hier ist eine Grafik aus dem Buch von Tarnbaum,
Structured Computer Organization, wo man eben auch sieht, was da passiert.
Und zwar schreibe ich jetzt also unterschiedliche Abstraktionsebenen,
fange also irgendwo auf einer ganz niedrigen Ebene an.
Auf dieser Ebene habe ich so etwas, was ich dann virtuelle Maschine nenne.
Das kann auch in dem Fall dann wirklich eine reale Hardware sein.
Und die kann eben eine Maschinensprache L. 0 verarbeiten. Das heißt,
die Programme, die in dieser Sprache L. 0 geschrieben sind,
können ihn direkt von elektronischen Schaltungen ausgeführt werden.
So rein praktisch wird das so aussehen,
dass die Programme folgen von 0 und 1 sind.
Reine binär Worte, nichts anderes. So,
und dann kann man jetzt sagen, das ist natürlich nicht
das, wo wir programmieren wollen. Das heißt,
ich fange jetzt nicht an, also hier irgendwie 1,
2, 0 und 1 irgendwie in den Rechner reinzuschreiben.
Also das hat man in den ersten Jahren oder mit dem Hennyek,
also irgendwie mit diesen Steckbrettern in den Äh, allerersten Computern gemacht.
Sondern wir arbeiten ja eigentlich auf deutlich abstrakteren Ebenen oder Beschreibungssprachen.
Also siehe eben dieses Java-Beispiel. So,
und da kommen es eben Übersetzungshierarchien hinzu,
die dann eben zu immer komplexeren Sprachen, immer mächtigeren Sprachen kommen,
die dann eben diesen unterschiedlichen Abstraktionsebenen entsprechen.
So, in dem zuvor kann man jetzt also hier sagen,
von einer Maschine M, die jetzt also diese Sprache L0 verarbeitet,
kann man dann eben sagen, ich habe jetzt als mächtigeren Sprache eine Maschinensprache L1.
Und die wird eben entweder von einem Interpreter abgearbeitet,
der jetzt hier auf L0 läuft oder ich habe einen anderen Mechanismus,
einen Compiler, ein Übersetzungsprogramm, was das Programm dieser Sprache L1 in Anweisung dieser Sprache L0 übersetzt.
So, und das Ganze geht dann eben über mehrere Ebenen entsprechend eben immer weiter,
bis ich dann eben auch hier irgendwo bei meinen Programmiersprachen bin,
die dann eben über mehrstufige Übersetzungsmechanismen irgendwann so weit runtergebrochen werden,
bis sich dann also irgendeine Sprache, irgendwelche Anweisungen habe,
die dann also auch wirklich von der physikalischen Hardware abgearbeitet werden.
So, das heißt, zusammenfassend, jede Ebene definiert eine neue mächtigere Sprache.
Ebene Sprache ist dann hier quasi Äquivalent zu sehen. Und
für diese Übersetzung habe ich letztendlich zwei Mechanismen zur Verfügung,
entweder ein Compiler, der Compiler erzeugt eben aus einem Programm,
was sich also beispielsweise in der Sprache allein geschrieben habe.
Ein Programm war es in der Sprache L0, da ist,
wobei dann typischerweise jedem Befehl aus L1 eben eigentlich ein
ganzer Satz von Befehlen oder eine Folge von Befehlen aus L0
entspricht und ich dann also quasi eine Art Ersetzung habe.
Dabei passiert noch ein bisschen mehr, aber das ist also grob das,
was man sich da als Compiler vorstellen muss.
Ein anderer Mechanismus wäre, die Interpretation. Dazu gibt es eben
ein Interpreter. Das heißt, ich habe ein Programm,
das selber in der Schwarzen Elro geschrieben ist,
hier irgendwo ausgeführt wird.
Und dieses Programm kann jetzt Anweisungen aus der Sprache L1 interpretieren
und führt die zur Laufzeit
dann auf der Hardware aus
Das heißt, ich habe dann eben eine direkte Ausführung von Befehlsfolgen zu jedem Befehl LA1.
Nicht dieses Jahr ist dann quasi was wie eine Offline-Übersetzung.
Hier wird zur Laufzeit, das dann eben entsprechend interpretiert.
Das zu den Begrifflichkeiten. So,
was dabei eben noch wichtig ist bei dieser Interpretation,
das eben für diesen Interpreter, die Befehle,
nichts anderes sind als Daten,
die ja liest und die ja dann in Befehle der Niederlandssprache,
also in der L0,
entsprechend umsetzt
Das heißt, was dieser Interpreter macht, ist,
dass er quasi sowas wie eine virtuelle Maschine generiert,
die dann eben direkt die Sprache L1 abarbeiten kann.
Das heißt, damit ist es dann eben möglich,
mit diesem Interpretationsmechanismus jede beliebige Maschine zu simulieren, auf einer entsprechend einfacheren Maschine.
Und der Programmierer muss sich dann eben auch nicht um die unteren Schichten kümmern,
sprich, wie sieht jetzt der beispielsweise Maschinenbefehlssatz aus,
für an bestimmte Hardware oder wie sieht es sogar das Binärformat dazu aus,
sondern er kann dann eben wirklich zur Laufzeit das Ganze laufen lassen und da ist dann dadurch auch über diesen Interpretationsmechanismus unabhängig von der Hardware.
Gut, das lässt sich eben über mehrere Ebenen oder Stufen entsprechend auf- oder runter propagieren. Nachteil von dem Ganzen ist natürlich,
dass die virtuelle Maschine in der Regel langsamer ist,
als wenn ich das jetzt also auf der Echtmaschine laufen lasse,
nicht dem zuvor kann man auch immer grob sagen,
sowas wie so ein Interpreter ist eben mit einem gewissen Overhead versehen im Vergleich mit der,
diese Offline-Übersetzung des Comparilers, darf man auch gesehen,
dass ich hier also auch immer noch deutlich mehr Optimierungsmöglichkeiten habe,
nicht aber der Interpreter ist auf der anderen Seite der flexiblere Mechanismus,
weil man dadurch dann eben auch sehr gut und sehr einfach Programme laufen lassen kann,
Obwohl die jetzt also zum Beispiel eigentlich für eine ganz andere Hardware gehen würden.
Nicht demzufolge kann ich zum Beispiel über einen Interpreter sagen,
ich entwickle ein Programm jetzt für ein Smartphone-Mobilprozessor,
da hat jetzt also irgendwie ein Armprozessor mit drin und ich habe jetzt also mein Hochsprachenprogramm übersetzt,
das ist jetzt ein entsprechendes Armprogramm und habe dann aber auf meinem Rechner,
der jetzt aber gar nicht diese Hardware dahinter hat,
eben ein Interpretationsmechanismus,
auf dem dieses Programm dann eben direkt laufen könnte und ich eben sehe,
funktioniert das soweit richtig?
Das Programm physikalisch gesehenen, aber eben eigentlich auf einer ganz anderen Maschine läuft,
als das, was dann später die Zielanwende dann beispielsweise ist.
Also das ist eben das, was man mit diesen Virtuellen Maschinen erreichen kann. Ich habe das jetzt gerade beschrieben,
so auf so einer relativ abstrakte, untere Ebene,
wo es also im Prinzip jetzt um unterschiedliche Prozessoren unterschiedliche Hardware geht,
lässt sich aber auch beliebig nach oben hin erweitern, mit diesen Begriff der Wörtlerin-Maschine. Und zwar in dem Sinne,
dass man, kann ich hier einmal kurz zeigen,
jetzt also zum Beispiel folgendes macht,
dass ich hier mit solchen Interpretationsmechanismen dann eben auf höheren Ebenen was machen kann,
dass ich also hier eigentlich ein blöder Linux laufen habe,
als Rechner,
jetzt also ein sogenannte Virtualisierungssoftware und in dieser Virtualisierungssoftware habe ich jetzt eben hier beispielsweise irgendwelche Windows-Versionen installiert und kann also hier quasi jetzt wie nativ,
also irgendwie anfangen, ein,
wenn das zu unten und laufen zu lassen und alles,
was sich jetzt hier eingebe,
ist eben genau das,
was man also normalerweise dann bei einem Windows-Rechner
sehen oder machen würde
Irgendwann klappt das mit dem richtigen Passwort. So, das heißt also,
hier habe ich jetzt eigentlich sowas wie ein Windows-Rechner laufen können,
jetzt, dass ich also beliebige Programme laufen lassen.
Die denken und arbeiten so, als ob sie ja so,
wie man hier sieht, auf dem Windows-Betriebssystem arbeiten.
Dieses, wenn das Betriebssystem ist, aber eben virtuell in einer Linux abgebildet.
Das war so läuft, dann hast du die auf eine Linux drauf. Gut,
für diese Art der Virtualisierung, das ist also etwas,
was man gerade auch so im Rechenzentrum Cloud-Rechnung macht,
gibt es dann auch unterschiedliche Ansätze.
Da muss er jetzt nicht zwingend noch ein anderes Betriebssystem drunter nehmen.
In diesem Fall ist dann die Hardware eigentlich identisch,
weil Dieses Jahr läuft jetzt eben auf X86 Architektur und dieses hier eigentlich auch.
Aber ich könnte jetzt also hier auch sowas wie ein Mac-Betriebssystem oder
was anderes laufen lassen und zumindest ab dem nächsten Jahr,
wenn Mac dann also auch wieder andere Prozessor, Architekturen eigentlich haben wird,
nicht dann wird sich dahinter dann eben auch virtualisiert,
dann ein ganz anderer Prozessor verbergen als das,
was eigentlich physikalisch in dem Rechner verbaut ist.
Also das zu dem Begriff der Virtualisierung, wie gesagt,
von Sehr weit unten gehenden Ebenen bis zu ganz oben Betriebssystem.
Das, was sie jetzt hier eben so gezeigt habe,
so in Richtung Betriebssystem, werde ich jetzt also hier nicht weiter
in Rechnerstrukturen und Betriebssysteme irgendwie dann noch mitmachen oder mir zeigen.
Das wäre dann beispielsweise in der VSS-Vorlesung mit drin,
wo es dann also um diese Typ 1,
Typ 2 Virtualisierung geht, die man dann also hat,
um beispielsweise jetzt so in irgendwelchen Cloud-Rechenzentren zu arbeiten und so weiter.
Gut, also das nur zu dem Begriff der virtuellen Maschine
Grundidee eben, ich habe ein Programm,
was jetzt irgendwie nach außen hin so tut,
was auch es jetzt eben eine niedere Abstraktion oder Annette,
höhere Abstraktionsebene direkt ausführt,
das aber übersetzt dann eben eigentlich in eine andere,
in eine niedrigere Abstraktionsebene in dem Fall.
Gut, was sind hier so diese üblichen Einteilungen jetzt in Bezug,
also auf diese Abstraktionsebenen, also das,
was wir eigentlich immer sehen, sind Anwendungen, also sprich Hochsprachenprogrammierung.
Nicht dann kommen als nächstes Assembler-Anweisung. Das ist dann das,
was ihm die Betriebs, die Anweisung für den Prozessor sind.
Da ist man dann schon also relativ weit unten. Das wird also,
wenn man jetzt nicht gerade Compilerbau macht oder jetzt also wirklich sein System für irgendwelche Sachen komplett ausnutzen will,
wird einem das also in der Programmierung dann eigentlich auch schon nicht mehr begegnen.
Nicht dann kommt dann noch die Betriebssystemebene mit rein,
wo es dann also darum geht,
dass hier teilweise dann oder seitens des Betriebssystems dann also auch noch Übersetzungen mit drin sind,
weil ich also jetzt beispielsweise aus meinem Programm,
wenn ich jetzt also irgendwelche ein- oder Ausgabegeräte ansprechen möchte,
jetzt nicht einfach sagen kann, wunderbar,
greifen wir auf die und die Adresse irgendwo darauf zu,
sondern da ist an der Stelle dann also auch nochmal das Betriebssystem dann dazwischen,
was dann eben guckt,
habe ich also überhaupt die entsprechenden Zugriffsrechte,
um das Machen zu dürfen und so weiter.
Und das heißt, da kommen dann eben,
was dann eigentlich hier so ein Mix aus dem hier ist,
dann eben noch solche Sachen mit rein,
wie sogenannte System Calls dann eben deren Abarbeitung durch das Betriebssystem.
So, und dann geht das also entsprechend weiter runter,
dann also wirklich also auf das, was ich jetzt hier als Rechnerarchitektur bezeichne.
Also das heißt, genau diese Schnittstelle zwischen Software und der Hardware,
wo dann also wirklich auf unbester Ebene der Befehlssatz des Prozesses,
was die Referenz ist,
das wird dann eben weiter und übersetzt in das,
was man so als Mikroarchitektur bezeichnet.
Das heißt, diese Trennung in Steuerwerk und Operationswerk,
was war das noch, von Neumann-Konzept, Hier werden die Daten verarbeitet.
Hier werden die Befehle verarbeitet. Mich und jeder Befehl
wird dann gegebenenfalls auch noch in Folgen von Einzelschritten übersetzt,
die ich dann eben habe, um irgendwie diese Datenverarbeitung auszuführen.
Das Ganze nennt sich dann eben Mikroprogrammierung nochmal.
Das ist dann eben wieder so rumgesehen,
die nächste Übersetzung von Hörer in niedrigere Instruktionsebene. Keine Ahnung,
von Bären entsprechen jetzt also irgendwelche Werte auf Registern gespeichert,
mit irgendwelchen adatmetisch-logischen Einheiten irgendwas berechnet und so weiter
Die Teile wiederum sind jetzt eben aufgebaut irgendwie aus Elementen der logischen Ebene.
Das heißt, hier habe ich jetzt also Bullshir Al gebracht.
Sowas wie Logikatter und oder Negierung, irgendwelche speichernden Elemente. Ja,
und die sind wiederum aufgebaut dann irgendwo aus Transistoren in der Elektrotechnik,
technisch realisiert dann eben in Form eines Shiplayouts.
Und was sich dahinter verbirgt, ist dann eben Physik in der Ship-Fertigung,
nämlich, dass ich also bestimmte in dem Silitium Cristalis,
also bestimmte Teile, So und so, dort sultiere.
Und wenn ich das in geeigneter Weise mache und dann irgendwie 80 verschiedene Prozessschritte drüber laufe,
dann ach, dann habe ich eben irgendwie zwei Transistoren.
Und diese beiden Transistoren werden sie dann eben durch Metall miteinander so und so verbunden sind,
verhalten sich dann eben wie ein Inverter,
der aus einer logischen Null eine logische Eins macht und umgekehrt.
So, das wären jetzt also diese Ebenen,
wie gesagt, wir bewegen uns an der Stelle hier.
Nicht das wird also noch so ein bisschen vorgestellt und
spätestens da, wo wir jetzt also hier die Digitaltechnik verlassen
Nämlich Transester-Netzlisten und die Fertigungstechnik dahinter ist an dieser Stelle hier Schloss.
Gegebenenfalls will ich da also vielleicht auch nochmal Portfolien zu sowas hier zeigen,
beziehungsweise also auch nochmal da nochmal einen kurzen Exkurs mit reinbringen an einigen Stellen, wo das irgendwie mal passt. Aber das sind dann eigentlich Sachen, Profilen als Informatikers draußen sind. Gut,
hier nochmal das Beispiel von diesen Abstraktionsebenen jetzt,
also aus dem Buch von Tarnbaum,
also auf der untersten Ebene digitalen Logik,
das wäre dann die Ship Hardware, nicht dann die Mikro Architektur,
wo ich dann also hier sowas wie ein Instruktionscash habe,
dann die eigentliche Befehlsatzarchitektur,
das wäre dann also zum Beispiel jetzt in Hill-Tale X-86,
also sprich dann die unterste Ebene von Assembler-Anweisungen,
die ihrerseits in diesem Fall jetzt durch die Hardware übersetzt werden in Teilschritte,
die da irgendwie ausgeführt werden,
nicht darüber dann eben sowas wie so ein Betriebssystemmaschine,
wo ich dann eben unterschiedliche Betriebssysteme habe,
nicht darüber dann eben eigentlich eine Assembler-Schwache und das,
was wir eigentlich jetzt sehen,
war es eh irgendwelche Hochsprachen für die Programmierung.
Ich das nur so als so ein Beispiel für so eine mögliche Übersetzungsgierarchie.
So, wo taucht das Ganze jetzt also hier im Studiengang auf?
Ja, die oberste Ebene, Anwendungsebene ist Softwareentwicklung, Algorithmen,
Datenstrukturen und so weiter. In Rechnerstrukturen und Betriebssysteme. Wie gesagt,
wenn wir ein bisschen was zur Assembler-Ebene,
ein paar Grundlagen, ein bisschen was zur Betriebssystemebene,
Teil davon taucht dann eben auch in vertalte Systeme und Systemsicherheit
auf und
ein bisschen was
In die Grundlagen der Digitaltechnik dann eben bis runtergehend zur Logik-Ebene haben und alles, was hier Elektrik ist,
die Vice-Level, werde ich zwar vielleicht nochmal ein paar bunte Folien auflegen, aber da machen wir da nichts weiter. Gut,
wie sieht jetzt das Ganze,
wenn ich jetzt diese unterschiedlichen Ebenen habe und irgendwo ganz oben meine Hochsprache aus,
rein praktisch aus, also hier auch nur ein kurzes Beispiel,
was mir eigentlich als erstes in allen Programmiersprachen oder wo auch immer also findet,
also das allgemein beliebte Hello World, wo man dann eben sagt,
ich habe jetzt also hier oben seine Programmiersprache, als Hochsprache in diesem Fall jetzt,
also als C-Code und das soll dann eben irgendwie übersetzt und ausgeführt werden.
Wie gesagt, hier geht es jetzt nicht darum,
dass sie jetzt, wenn sie jetzt von C noch nichts gehört haben,
sie jetzt fragen, ja, was erzählt er,
wenn er jetzt hier irgendwie über eine Programmiersprache,
das ist also wirklich nur Beispiel dafür, was da passiert,
was mit dieser Übersetzung jetzt also in der Praxis gemeint ist,
in diesem Fall jetzt als Beispiel mit einem Linux-Betriebssystem und IMC-Compilight,
der dann eben hier diese Sprache entsprechend jetzt in X86 als Hamler-Code übersetzen wird,
beziehungsweise wie näher Code übersetzen würde.
So, also ich habe jetzt hier meinen Quellcode,
Hauptprogramm besteht aus einer einzigen Zeile, Hello World, das heißt,
da soll einfach jetzt nur dieser Streng ausgegeben werden. Und das,
was dann also machen würde, NC ist,
dass sich das Ganze eigentlich in ein ausführbares Programm übersetze und auch gleich irgendwie linke und lauffähig habe,
dass wir dann also diese Untersitzzahl jetzt für GCC als C-Compiler,
wo ich dann also quasi jetzt ein Linux-System dann oder ein System,
wo ich ein GCC installiert habe, dann eben mit dieser Zeile, also quasi aus diesem hier, ein ausführbares Programm mache.
Ich habe das jetzt hier also quasi als Name auch einfach hellowell.excel genannt.
Eigentlich finden sich dahinter dann aber schon mehrere Schritte,
nämlich einmal, dass die Übersetzung, das sind diese Anweisungen,
wo das, was ich hier einmal kompiliert wird,
in eine sogenannte Objektdatei, das ist ein schneller Teil,
wo Folgen aus 9 und 1 stehen oder dass das hier noch lesbar kompiliert wird, in Assembler-Code.
Das wäre dann also diese Zeile. So,
was sind dann die Ausgaben, wenn ich das jetzt,
also ein Assembler-Code, übersetze und mir ausgeben lasse und Linux-System wäre das dann,
also zum Beispiel mit einem Cut, dass ich das in die Erfahrung,
wir haben also durchlisten lasse, würde dann also helloworld.s,
was also die Ausgabe von diesem Befehl hier ist, folgendermaßen aussehen.
Wie gesagt, keine Angst, dass müssen sie jetzt nicht wissen,
das wird auch nirgendwo abgefragt, so was.
Nachher, wenn wir in einem deutlich späteren Kapitel noch mal
so ein bisschen auf Assembler-Quote eingehen, wird noch ein bisschen was zu einigen von diesen Befehlen gesagt.
Aber da wollt ihr jetzt also nicht speziell irgendwas in Richtung Assembler-Programmierung gemacht werden.
Ja, also wie gesagt, wie sieht das Ganze jetzt hier aus?
Ich habe jetzt in diesem Fall meine Ursprungsdatei,
die wurde dann eben hier übersetzt in diesem Teil Main ist zu dem her,
kommen dann die eigentlichen Assembler-Anweisungen. Dieses hier, alles,
was mit dem Punkt beginnt, sind also entweder sowas wie Label oder Steueranweisungen,
die dann für den Assembler-Wang genutzt werden,
wo ich eben zum Beispiel diesen Strenger als Konstante mit drin habe,
wo drin steht, also aus welcher Latar das kommt und so weiter.
So, und alles, was jetzt hier ein bisschen fettgedruckt ist,
da sind dann eben die eigentlichen Assembler-Befehle, wo dann also,
je nachdem, auf welchen Prozess,
wenn ich das ablaufen lasse oder für welchen rechne ich das,
übersetze ich dann eben hier quasi unterschiedliche Sachen, unterschiedliche Formen komme.
Und hier steht nur noch so ein bisschen Verwaltungsinformation.
Also in diesem Fall wurde das also mit Armen um rund
um 18 Systemen und Armen um GCC 750 irgendwie übersetzt worden.
Ja, wie gesagt, aber das ist etwas,
was dann sich normalerweise auch schon überhaupt nicht mehr anguckt,
weil wie gesagt, das, wo wir uns ja in der Programmierung bewegen,
ist dieses hier
So, und das, was dann passiert, ist das,
was der Assembler macht, nämlich also aus diesem Assembler-Anweisung in einem nächsten Schritt.
Objekt kurz zu erzeugen, das ist das, was also hier gelistet ist,
was man sich dann also quasi mit so einem Object-Darm-Exitezimal unter einem Vellworld vom Büro,
dass wir also die Ausgabe dieses Befehls hier,
oder durch diesen Befehl wird das hellowworld.o erzeugt, was hier gelistet wird.
Hier diese erste Spalte ist sowas wie Adresse, wo es also hier einfach nur irgendwelche Hexerdizimalwerte der Reihe nach folgen. Und jede Stelle hier steht dann also für vier Bit,
also vier Werte 0 oder 1. Ich finde das,
was dieses hier insgesamt ist, ist also nichts anderes,
als eine lange Folge von Nullen und Einsen,
die irgendwo in den Speicher kommt,
hier dann eben an die Speicheradresse 0,0,
dann jagen die Speicheradresse 0, 2-0,
0, 4-0, 0, 6-0,
das ist auch alles Hexerdizimat, was sich hierhinter verbirgt,
Hexagezimal, gehen wir im nächsten Kapitel kennenlernen.
Nicht nur, um zu sehen, Übersetzung von meinem See-Code in diesen Assembler-Code.
Und dann eben wirklich in sowas wie so ein,
wie in der Format. Und das ist dann also das,
was später dann wirklich mal durch die Hardware oder eben auch durch
einen zugegebenen Maßen dann nochmal da stattfinden, Interpreter ausgeführt werden kann.
Sodass wir jetzt also hier dieser Objektcoach Das Schöne ist jetzt bei diesem Objektcoach,
wenn ich jetzt weiß, oder wenn das System weiß,
für welche Zielarchitektur er das ist, dann kann ich hin und wieder disassemblieren.
Das heißt, zurückübersetzen. Weil von diesem Code hier,
zu dem hier, ist das also erstmal nichts anderes,
als vielleicht etwas komplizierter, aber das macht ja der Rechner, Textersetzung.
So, und genauso kann ich das rückwärts laufen lassen,
dass wir dann so ein Befehl wie Object da,
wo ich dann also quasi diese Datei nehme und mir hier
zurück über Lachs setzen lasse und dann also hier quasi wieder diese Folge der Assembler-Befehle sehe,
die dem ganzen Land zugrunde liegt.
Dieses hier wäre dann eben entsprechend das Ganze oder die an jeweiligen Befehle dann im Exeditionalformat,
was man hier auch schon sieht,
werden wir auch deutlich später dann da noch zukommen,
X-86-Befehlsformate sind halt so, also sowas wie ein Push-Befehl,
belegt hier zwei Byte, so was wie dieser Move-Befehl,
belegt hier also irgendwie vier Byte,
das heißt also man sieht dann eben auch die einzelnen Befehle sind dann teilweise eben auch immer unterschiedlich lagen.
Da ist also zum Beispiel wieder so eine historische Unsäglichkeit des X86-Befehlssatzes,
was also andere Prozessor, Architekturen zum Beispiel jetzt wieder nicht haben.
Gut, aber dazu werden wir dann deutlich später noch kommen. Gut,
das heißt also, dass diese Zurückübersetzung,
und hier sehe ich dann also noch mal das eigentliche Object Dunkel,
also von einem Executable,
wo ich dann eben wirklich so eine reine ausführbare Datei habe,
was ist der Unterschied zwischen HelloWorld.exe und Hellowworld.o
Ich will, man sieht, also es fängt ja teilweise gleich an,
danach geht das aber irgendwie doch noch doch noch so ein bisschen anders weiter.
Das, was, also ein Ausführer als Programm,
das eigentliche Executable und so ein Zwischenergebnis,
diese Objektata unterscheidet, ist,
dass an dieser Stelle hier dann eben noch geguckt wird,
welche Bibliotheken werden noch benutzt,
dort dann noch entsprechende Verweise in diese Bibliotheken mitgemacht werden oder gegebenenfalls,
also auch Teile der Bibliotheksroutinen dann eben hier in Code
auch mit eingebaut werden
Das habe ich bei,
also sprich, wenn ich unterbekomme, Aufrufe mache,
das habe ich also in einer einzelnen Objektdatei noch nicht,
sondern da ist das dann noch nicht alles in einem Ausführer,
das Programm zusammengepackt, sondern danach habe ich jetzt eben noch mehrere getrennte Objektdateien,
die dann erst durch den eigentlichen Linker zu einem ausführbaren Programm gemacht werden,
was dann eben dieses hier ist.
Ja, was ich dahinter dann noch genauer verbirgt und auch zu diesen Begrifflichkeiten,
wenn ich jetzt sage Compiler, Assembler, Linker,
wären wir auch in, ich glaube,
Kapitel 12 wird das sein, da noch ein bisschen was zu machen.
Also von daher jetzt keine Angst,
dass sie jetzt hier schon irgendwas verpasst haben oder dass sie irgendwas vorausgesetzt wird,
was da noch nicht ist,
sondern das geht hier nur so ein bisschen um dieses Beispiel,
was mit diesem Abstraktionsebene in dieser Praxis mit gemeint ist.
Ja, und diese Rückübersetzung von Executable,
beziehungsweise von so einem Objektcode in diesen Assemblercode,
das funktioniert jetzt eben auch im Prinzip unabhängig von der CPU oder von der zugrunde liegenden Hardware.
Das heißt, wenn ich jetzt weiß,
für einen bestimmten Prozessor habe ich jetzt eben hier irgendwie einen Assembler-Format,
dann kann ich natürlich aus diesem Benär-Code,
dem her sie hier irgendwo einen Arm ausführbaren Programm steckt,
den zugehörigen Assembler-Code zurückübersetzen.
Und das hier als Beispiel jetzt eben auch unabhängig von den Betriebssystemen machen.
Dazu habe ich jetzt hier Zum Beispiel ein Programm, Notepad plus plus.exe
. Nee, ich frohe ich jetzt also hier sehe,
dass es ANPs waren. 30 Execudable, X-86 64,
das ist in dem Fall jetzt die Hardware-Architektur für so eine X-86-Prozessor vor MS Windows.
Jetzt habe ich hier einen Linux laufen, wenn ich jetzt
also hier anfangen würde, das Programm einmal irgendwie laufen zu lassen.
Sagt er nur, kann die Datei nicht ausführen.
Was ich aber machen kann, ist, dass ich hier
also quasi diesen Object-Tampefehl nehme, mir das Ganze ausgeben lasse.
Und dann sehe ich jetzt hier Fallformat und kriege jetzt also hier
das Assembly und habe dann also hier wirklich meine Assembler-Anweisung,
die dann in dem Fall erst, also hier dieses Windows-Programm darstellt.
Also das zu der Art und Weise,
dass man diesen Disney Samra natürlich dann sowas machen kann.
Gut, was man hier auch sieht,
wir sind ja irgendwo gestartet in diesen unterschiedlichen Abstraktionsebenen,
Aber was hier natürlich nicht funktioniert, ist, wie man gesehen hat,
zum einen, ich kann dieses Programm nicht ausführen.
Warum nicht? Es sind völlig unterschiedliche Betriebssysteme. Das,
was ich als Laufzeitumgebung, als Mechanismen zur Programmsteuerung unter Windows
oder unter Linux habe, ist völlig unterschiedlich.
Irgendwelche einen Ausgaben, irgendwelche Zugriffe auf grafische Umgebung und so weiter,
sind eben ganz andere Ansätze. Die Systembibliotheken sind eben völlig
unterschiedlich. Nicht deswegen gibt es daran eine Zusammenarbeit,
aber eben also auf dieser Ebene, welche Anweisung für diesen Prozessor,
auf dem ich jetzt ja sowohl ein Windows-Hauser und Linus laufen lassen kann, stehen da drin.
Das kann ich eben unabhängig von dem Betriebssystem ausmachen.
Also da kann man dann eben entsprechend so eine Rückübersetzung machen.
Ja, nochmal eben zurück, also auf diese verschiedenen Abstraktionsebenen.
Ich könnte jetzt natürlich sagen, wunderbar,
nicht verstreiten sich jetzt alle alle Leute irgendwie über die Sicherheit von Windows oder Sonstiges.
Da nehme ich mir also irgendwie ein System oder irgendein Programm
und mache dann also hier irgendwie so ein West-Assembler,
lass den drauf los und dann kriege ich also hier sowas und dann so ein bisschen Reverse-Engineering machen,
also wie hat Acrosoft oder wer auch immer dann mal so ein Programm zusammengebaut.
Und da muss man sagen,
das funktioniert natürlich jetzt also einfach wegen dieser Abstraktionsebene nicht,
weil also auf der Ebene hier irgendwie sowas wie Universe Engineering zu machen und zu gucken,
wie hat also ein Programmierer jetzt also irgendwie ein Programm gemacht,
geht für einfache Trivialbeistibile vielleicht noch, aber für irgendwelche komplexeren Beispiele,
spätestens wenn das dann also um irgendwelche Bibliotheksaufrufe oder sowas Hier zum Beispiel an so einer Stelle irgendwo stattfindet,
nicht mehr,
weil dann müsste ich mir nämlich also auch noch den entsprechenden Code,
also aus diesen sogrunde Linienbibliotheken nehmen und so weiter.
Deswegen habe ich da jetzt nicht das Allheilmittel oder den Mechanismus gefunden,
um da jetzt also irgendwie so ein beliebiges Reverse-Animeering zu machen.
Gut, ja, also das zu diesen unterschiedlichen Abstraktionsszenen,
wenn du in der Praxis, wie gesagt,
wenn das nachher an die Assembler-Programmierung geht,
dann wird uns dieses kleine Beispiel
nochmal wieder begegnen
Wo ich dann also vielleicht noch mal ein bisschen genauer also
auf die einzelnen Teile eingehe. Deswegen ist jetzt keine Angst,
wenn jemand von ihm damit oder mit diesen Begriffen und Begrifflichkeit
noch nicht so viel anfangen kann.
Oder es ist irgendwie völlig neu ist. Ja, gut,
also wir haben diese Unterschiede, eine Abstraktionsebene, diese Ausführung.
Und das führt eben ein zu dem Begriff,
dass man jetzt sagen kann, okay,
ich habe also so eine virtuelle Maschine,
die führt jetzt eben Software einer höheren Sprache aus.
Also beispielsweise wie meine virtuelle Maschine läuft, die ist eben
in Sprache. Nur geschrieben führt jetzt,
also die Software eine Sprache L1 aus und die selber kam dann eben
auch entweder ins Software ausgeführt werden oder eine virtuelle Maschine würden natürlich auf der wondersten Ebene dann irgendwo auch in Hardware realisiert.
So und so rum gesehen kommt man eben zu dieser Aussage von Karen Panathalets,
wo man dann eben sagen kann,
Software und Hardware sind so rum gesehen, eigentlich logisch äquivalent.
Also nicht und die hatte eben den Spruch geprägt,
Hardware ist just patrified, Software, also verstandete Software.
Das führt uns dann eben auch zu etwas,
was man eigentlich auch immer so als Paradigma oder sehen muss oder in Bezug auf diese Trennlinie.
Da gibt es also irgendwie die Softwareentwickler und da gibt es
die Hardwareentwickler und die reden nicht miteinander oder ja teilweise,
auch in Bezug auf die Realisierung jetzt von irgendwelchen Systemen,
ist man eigentlich immer völlig frei,
mache ich irgendwas in Software oder mache ich irgendwas in Hardware,
weil von der Funktionalität her kann ich mit beiden Mechanismen identische Sachen machen.
Was ich nehme, ist dann eben nur davon abhängig,
Wie sieht das mit den Kosten aus?
Wir haben halt eben dies Grundprinzip des von Neumann-Rechners und haben darauf jetzt eben irgendwelche Software,
die dann also irgendwie diese Abstraktionsebenen generiert und ich damit dann meine höheren Sprachen abarbeite.
Ich kann aber natürlich auch irgendwelche Hardware bauen,
auf der theoretisch dann also sowas wie der Code Anabruch oder
die Eingabe einer Programmiersprache auch direkt ausführbar ist oder die das Ganze realisiert.
Ich wusste, die wäre dann halt eben so groß und so teuer, dass das niemand macht. Und wenn ich irgendwas in Hardware realisiert habe,
bin ich natürlich nicht mehr flexibel, nicht also bei Software,
wenn ich einen Programmierfehler habe und den feststelle,
dann gibt es eben entsprechende Updates oder wenn man ein schlaues Marketing hat,
ich verkaufe man den Kunden also eine neue Version des Produkts,
die viel besser und schöner ist,
wenn ich irgendwas in Hardware realisiert habe,
dann hat man da also mehrere Millionen für das eine Stück Silizium investiert,
was eben genau diesen einen Algorithmus oder dies eine Problem lösen kann
Dann zwar auch schneller als jede Software,
aber wenn ich irgendwo darin einen Fehler gemacht habe,
dann ist das Geld ihm weg und ich darf ihm
eine entsprechend ein neues System aufbauen und entwerfen.
Das heißt, da ist man dann eben überhaupt nicht mehr flexibel.
Auf der anderen Seite in Bezug auf Sicherheitsaspekte ist man dann teilweise
ein Hardware wieder ein bisschen besser. Also wie gesagt,
das sind immer sehr viele sehr unterschiedliche Fraktoren,
die da mit reinspielen und je nach Aufgabenstellung von einem System muss man da dann eben irgendwie einen einen Mix finden. Nicht,
weil man sagen kann, was möchte ich oder muss ich flexibel handhaben,
wo habe ich jetzt also wirklich eine Sternesache oder wo habe ich jetzt also bestimmte kritische Randbedingungen in Bezug auf Größe,
Energieeffizienz und so weiter nicht, weil ich kann eigentlich nur sagen,
wenn ich jetzt also bestimmte Aufgabenstellungen habe, ja,
das kann ich natürlich,
also irgendwie im Desktop-Rechner mit irgendwie ein entsprechend leistungsfähigen CPU irgendwie alles machen oder ich rechne irgendwas auf einer Grafikkarte,
kostet mich dann aber auch eine Leistungsaufnahme von 400 Warte und das
kann ich also beim Batteriebetriebenen Gerät eben nicht machen
Ich meine, da sind dann eben entsprechend diese Sachen,
wo man dann das geeignete Optimum ist, endlich finden muss.
Ja, das erstmal zu diesem Themenbereich, dieser Abstraktionsebenen.
Dann haben wir jetzt hier noch einiges an Begriffen,
die ich jetzt also hier einfach nur relativ schnell in Form von Definitionen vorstellen werde,
wo es also darum geht, was ist damit gemeint.
Und zwar zum einen haben wir jetzt also erstmal den Begriff der Informationen,
Die Information entspricht also dem Gehalt einer Aussage.
Und zwar jetzt also wirklich im Sinne eines abstrakten Gehaltes.
Also das heißt, die Information selber können wir eigentlich nicht fassen.
Und jeder von uns hat aber vielleicht irgendwie eine etwas andere Interpretation.
Eine Aussage, aber das, was irgendwo, sagen wir jetzt,
als Idee oder als Wahrheit dahinter steckt, das ist dann eben das, was diese Information ist. So,
und diese Aussage,
die ja so mit der Information dann eigentlich nach außen hin dargestellt wird,
das ist dann eben die Repräsentation der Information, nämlich,
wenn ich jetzt also beispielsweise zu Ihnen spreche und versuche,
da wird jetzt also meine Gedanken nach außen hin zu fassen,
dann wäre das eben die Repräsentation der Information,
die ist dann irgendwo konkret messbar ist, nicht während Informationen,
also sowas wie so ein abstrakter Begriff vielleicht ist.
Statt Repräsentation spricht man dann in der Informationsverarbeitung und auch gerade in
der Information zu übertragen, dann eigentlich auch immer von Nachricht.
So, aus dieser Nachricht, die Information wieder rauszuholen,
das wäre dann eben eine Interpretation Und für uns aus dieser Nachricht
die Informationen rauszuholen, wie er dann letztendlich das verstehen.
Ernst begriffen. So, was ist jetzt eben mit Repräsentation gemeint?
Also wir haben jetzt als Informationen sowas wie die Zahl 25. Let's abstrakt.
Dann kann ich das jetzt unterschiedlich repräsentieren. Ich kann das
jetzt also irgendwie als Text in irgendeiner Sprache machen,
25, 25, man sagt, was auch immer.
Ich kann das jetzt also irgendwie als Zahl schreiben
Das kann eine römische Zahl sein, das kann
eine dezimalzahl sein, das kann eine wie Nährzahl sein.
Das kann eine Zahl sein in einem ganz anderen Zahlensystem,
irgendwas Exotisches, Dreierzahnsystem ist auch machbar.
So, und das, was ich da immer nur sehe,
ist hier die Repräsentation. Und wenn ich jetzt nicht weiß,
wie die Kodierung ist, das ist jetzt eben dieses Kontextwissen,
kann ich mit dieser Repräsentation erstmal
herzlich wenig anfangen
Also da ist man im Hinterkopf. Hier auch nur ein Beispiel,
nicht, also auch ganz anders,
ich kann das auch irgendwie als Morse-Code 25 nicht,
also irgendwie zweimal kurz, dreimal lang, fünfmal kurz, wie gesagt.
So, ja, Repräsentation in Informationen, wie gesagt,
eigentlich malen wir ja also Informationen.
Ich sage, wir haben jetzt ja sich zum Beispiel sowas
wie so ein Arreth Media schon Ausdruck, fünfmal zwei plus 9,
vielleicht 25. So, die Informationen selber, hat er ja schon gesagt,
kann man eigentlich in dem Sinne jetzt nicht notieren,
sondern das Wasser notiert, ist dann immer nur eine Repräsentation.
So, und hat ja eben auch schon gesagt,
es muss dann eben immer die zuhörigen Absprachen geben,
wie das gemeint ist, weil, solange ich eben nicht weiß,
dass ich also beispielsweise mit Analyzimaldarstellung arbeite, nicht,
dann kann ich mit den beiden Zahlen 2 und 5 dort erstmal nichts weiter anfangen.
So, diese Repräsentation kann dann also auch häufig ihrerseits auch wiederum mehr stufig sein.
Hier als Beispiel, ich habe also hier sowas wie diese Dezimalzahl, daran hat 47
Die wird jetzt beispielsweise in so einer Darstellung gemacht,
die sich, also BCD nennt, Bahnrecode Dessemble.
Das heißt, jede Stelle des Dezima-Systems,
also die drei und die vier und die sieben, wird jetzt binär codiert, jede für sich.
Drei wäre 00111, die 40100 und so weiter. Und jede dieser Folgen wird dem Computer,
wenn ich jetzt also irgendwie diese Information übertrage, oder vielmehr diese Repräsentation,
dann technisch gesehen übertragen will, dann auch wieder übersetzt,
in zum Beispiel jetzt Folgen von elektrischen Spannungen,
also 0,1 Volt, 0,1 Volt, das sind diese beiden Nullen,
2,5 Volt soll es als 1 interpretiert werden,
2,5 Volt auch wieder als 1, das heißt,
diese 3 entsprecht dem hier und dieses hier entsprecht dann eben mit einem zeitlichen Verlauf von irgendwie so vier unterschiedlichen Spannungspegeln.
Auch noch als Hintergrund, Binärdarstellung wird im nächsten Kapitel noch kommen.
Also das heißt, wenn die jetzt also nicht wussten,
also drei binär als 1-1 oder je nachdem,
wie viele Stellen ich da habe,
also 0 und 1-1 in diesem Fall dargestellt wird,
keine Angst, dass Volk dann nochmal ganz genau, was damit gemalt ist.
Also wie gesagt, hier geht das jetzt nur um diese Mehrstufigkeit der Kodierung. Ja,
wie man da gesehen hat, kann man eben wirklich jetzt sagen,
also in jeder von diesen Abstraktionsebenen gibt es dann eben auch noch beliebig viele andere Rativen für die Repräsentation,
in das, was dann typischerweise macht in dem System ist,
dass man da natürlich sagt, je nachdem, was ich jetzt mache,
in Bezug auf Datenübertragung, Datenspeicherung, was auch immer,
dass man dann eben eine entsprechend hoffentlich effizientere Präsentation findet, um das Ganze hinreichend gut zu machen.
Ja, und auch je nach Abstraktionsebene habe ich daran natürlich dann auch unterschiedliche Repräsentationen.
Ja, hier das Ganze jetzt mal also auf diese Abstraktionsebene bezogen.
Also wir möchten die Zahl P,
die ich also selbst hier dann in Text vom so schmal ich fassen kann,
also 3,14-1,5 und dann geht das dann entsprechend weiter.
Irgendwie darstellen, dann wird das also im Prinzip im Prozessor,
wenn damit intern gerechnet wird, mit Binärdaten dargestellt,
80 Bit bereit, die ihrerseits technisch gesehen dann eben solche Spannungspegel sind,
wie diese 0,1 oder 2,5 holt.
Bei einer Speicherung im Hauptspeicher, auch in Binärdaten,
da habe ich aber schon ein anderes Format,
also nur 64 Bit
Auch als Spannung, wenn ich das irgendwo oft da Festplatte abspeicher,
dann wird das irgendwo kodiert in Form von magnetischen Bereichen,
also in diesem Fall ist es eine Magnetfestplatte,
wenn ich das auf einer CD-Raumlauf fahre, drauf habe,
auch irgendwie kodiert, in unterschiedlich reflektierenden Bereichen,
auf der CD oder ich kann das dann eben hier auch in Drecksform natürlich dann also auf Papier aufschreiben.
Das wären jetzt unterschiedliche Repräsentationen, die dann in dem System,
je nachdem wo die Informationen hin soll, beziehungsweise wo sie repräsentiert wird, dann eben auch unterschiedliche aussehen. So,
hinzu kommt dann noch was anderes,
ein Effekt, dass man natürlich sagen kann,
wenn ich jetzt also wirklich auf diese untere Ebene elektrische Ebene gehe,
wo ich ja gesagt habe, ja gut,
also so eine Folge 0011-1 erzeuge ich mir dann eben als 0,1 Wort,
noch mal ein Wort, zweieinhalb oder zweieinhalb Volt,
dann sind das ja eigentlich auch zeitliche Verläufe von Spannungen,
die jetzt natürlich nicht nur einzelne zeiteskrete und werteskrete Punkte enthalten,
sondern ich habe ihm wirklich wie das hier aus dem Blau angedeutet ist,
also einen zeitlichen Verlauf.
Und zu bestimmten Zeitpunkten, das, was ist also
hier rot, gekennzeichnet ist, interpretiere ich die Werte.
Und bei dieser Interpretation habe ich dann eben eine Zuordnung von bestimmten Spannungspegeln oder Spannungspegelbereichen dann eben,
dass ich sage, alles, was hier in diesem Bereich ist,
interpretiere ich als eins, alles, was hier in diesem Bereich ist, interpretiere ich als null.
Aber der Spannungsverlauf selber ist eben beliebig kontinuierlich. Ich habe eine Zeit ist Creda Abtastung und hinsichtlich der Werte habe ich dann eben eine Quantisierung,
dass ich dann eben sage,
hier so ein ganzes Intervall interpretiere ich als Null,
das als eins und alles hier dazwischen,
das dann eben ungültige Werte,
die technisch gesehen vorkommen und wo ich Probleme bekomme,
wenn ich jetzt also quasi auch den Wert zu diesem Zeitpunkt versuchen würde zu interpretieren,
weil dann habe ich eben hier bei der Ablastung ein Problem,
Gut, das sind dann eben Sachen,
dass wir das dann also auch später nochmal kurz begegnen,
wo es dann also im Prinzip also um diese Hintergründe geht,
jetzt Trennung von analoger Welt in die digitale Welt,
wo ich dann nämlich im Prinzip die zeitliche Trennung habe,
auf solche Ablasszeitpunkte und auf der anderen Seite eben auch in Bezug auf die Werte dann eben so eine Lisskritisierung haben möchte.
Also da ist dann auch nochmal im Hintergrund, weil das,
was technisch natürlich stattfindet, ist sowas hier,
Und das ist ja genau das, wo wir sagen,
damit wollen wir nichts zu tun haben.
Wir sind Informatiker und bei uns interessieren Nullen und Einsen.
Und über welche technische Kenngröße. Ob das also irgendwelche Spannungspegel sind im zeitlichen Verlauf,
wie das jetzt, also hier eigentlich der Fall wäre,
ob das irgendwelche Ströme sind, irgendwelche Magnetisierungen, optische Sachen,
also sprich, wenn ich jetzt irgendwie DVD habe oder eben über ein Glasfaserkabel,
also irgendeine Datenübertragung, wo ich dann Licht ein Licht aus habe.
Wie gesagt, das sind dann eben wirklich die Themen,
technischen Sachen, wo man dann eben in dem Bereich der technischen Informatik,
beziehungsweise dann eben ganz spontan bis eigentlich bis in die Elektrotechnik geht,
wo wir dann auch so ein bisschen außen vor sind.
Ja, also das, wie gesagt, nochmal zu diesen Repräsentationen.
Dann haben wir also auch nur das Problem, das,
was sie übertragen wird, ist ja eigentlich eine Nachricht.
Dahinter steckt es als abstrakter Gehalt, die Information und das,
was wir also auch schon üblichen Sprachgebrauch haben, ist,
dass es da eben auch mehr Deutlichkeiten gibt,
wenn ich jetzt also eine Nachricht habe,
er besucht ja eine Motors,
was ist damit gemeint
Ist das ein General? Oder ist das die Firma?
Oder sie nimmt ihren Hut, nimmt sie den jetzt vom Tisch,
wenn wir das sehen würden, wissen wir Bescheid.
Oder ist das im übertragenen Sinne, geht sie weg und das war's? Nicht deswegen,
das ist etwas, wo wir eigentlich aus dem Sprachgebrauch,
also auch schon Mehrdeutigkeiten mit drin haben,
die ihm bei dieser Gewinnung von Informationen aus den Nachrichten,
weil übertragen wir ihn ja immer nur die Nachrichten,
da dann natürlich auch zu Problemen führen kann
Ja, also wie gesagt, das hier also nochmal zu
dieser Trennung zwischen Nachricht und Information, wenn ich diese Interpretation habe. Ja,
deshalb hier nochmal kurz zusammengefasst, was ist Information,
was ist Nachricht,
Information ist jetzt wirklich das abstrakte Wissen oder der Sachverhalt und Nachricht ist dann eben das,
was übertragen wird, beziehungsweise als Äquivalent zu Nachrichten,
also die Repräsentation,
wie das Ganze dargestellt wird,
wobei ich dann eben bestimmte Abmachungen hinsichtlich dieser Kodierung
implizit da mit drin habe
Das heißt also, grob gesagt, die Nachricht ist,
die physikalische Darstellung von Informationen. So,
damit kommen wir jetzt also zu einem Begriff aus der Informationstheorie,
also diese Folie wird uns dann später auch nochmal begegnen,
wo man eben sieht, was passiert jetzt hier eigentlich.
Auf der einen Seite habe ich ja beim Sender,
dass die Information, also das abstrakte Wissen,
über diese Funktion Alpha minus eins in eine Nachricht
überführt wird,
diese wird dann eben übertragen
Und beim Empfänger findet dann eben die Interpretation statt, Alpha,
die also aus dieser Nachricht dann eben wieder die Informationen I2
liefert und im Idealfall sollte das halt eben identisch sein.
So, und auf Sender und Empfängerseite gibt es dann eben implizite Abmachung über die Bedeutung,
die dann quasi diesen Funktionen Alpha minus 1 und Alpha zugrunde liegen,
die dann eben beispielsweise durch Sprache,
Sozialisation,
Kontext wissen,
was auch immer
Zur Gräune gelegt werden. So,
bei der Nachrichtentechnik kommt an der Stelle jetzt noch hinzu,
dass ich also hier einmal irgendwie die Informationsquelle habe.
Ich habe den Sender. Dort wird das Ganze dann kodiert in eine Nachricht gepackt.
Die wird eben über einen sogenannten Übertragungskanal übertragen, also irgendein Medium.
In dem Fall hier, bei uns wird das jetzt also
Sprache und Willsing nahe sein, das Video.
Ich kann aber auch jetzt irgendwie jetzt eine elektrische Übertragung sein und,
und, und alles, was dahinter ist.
Und auf der Empfängerseite wird das Ganze dann eben dekodiert
Entsprechend interpretiert und man sollte daraus dann irgendwie diese Information erhalten.
So, und auf diesem Weg von Sender zum Empfänger,
dem Übertragungskanal habe ich jetzt eben noch so Effekte wie Störung und Rauschen.
Das kann sein, dass irgendwo beispielsweise, wenn ich jetzt
also irgendwas binärkodiert habe, es zu einzelnen Mitfehlern kommen.
Das heißt, aus einer 1 wird eine 0,
aus einer 0 wird ein 1 oder was auch immer.
Wenn ich das Ganze jetzt zum Beispiel per Funk übertragen würde,
dass ich also dort irgendwelche Störungen habe, Sachen nicht für nun ziemlich funktionieren.
Wenn ich das jetzt mechanisch auf einer DVD gespeichert habe und dort also irgendwie Schmutzdorf ist,
irgendwelche Kratzer, wird das auch nicht mehr richtig ausgelesen.
Das heißt, da gibt es sehr viele sehr unterschiedliche Störungsquellen,
die da auftreten können und die dazu führen, dass die Nachricht von Sender zum Empfänger irgendwie verfälscht wird.
Damit werden wir uns jetzt also noch in drei Kapiteln beschäftigen,
wo es dann eben noch um die ein bisschen um die Nachrichtentechnik,
Kodierung und Kodierungstheorie geht, wie man dafür sorgen kann,
beispielsweise durch Fehlererkennung, Fehlerkorrekturmechanismen, durch Mechanismen,
wo ich jetzt also irgendwie über andere Kanäle jetzt dafür sorgen kann,
dass ich hier meine Informationen so umbaue,
dass also auch mit Fehler,
die jetzt also hier beispielsweise in diesem Übertragungskanal auftreten,
das Ganze Nicht so weit verfälschen,
als dass es hier nicht noch zumindest wieder richtig dekodiert werden kann.
Auch da gibt es also sehr viele sehr unterschiedliche Ansätze,
wird in der Übertragung im Computersystem, nicht also in dem
ganzen Netzwerkprotokollen dann eben auch an beliebig vielen Stellen angewandt.
Wie gesagt, darauf werden wir dann noch in einigen Kapiteln,
also auch nochmal kurz zu sprechen kommen. Ja,
daneben müssen wir jetzt hier also auch noch irgendwie gucken, wie sie das jetzt mit der Verarbeitung von Informationen aus. Und zwar setzt Verarbeitung in dem Sinne,
dass sie jetzt also auf der auf der Information eine Informationsverarbeitung machen möchte,
also sprich beispielsweise,
ich habe jetzt als abstrakte Information die Zahlen 2 und 3,
als Operation sei daraus eine Addition ausgeführt werden und ich habe das Ergebnis,
die Zahl 5. Das wäre jetzt also erstmal abstrakt gesehen,
die für Arbeit und Information und die Addition,
das wäre dann also hier jetzt beispielsweise irgendwie eine Funktion,
die Insel falls, also hier irgendwie mit so einem Signal gekennzeichnet ist.
Und auf der anderen Seite Habe ich jetzt diese Information
irgendwo repräsentiert, beispielsweise jetzt durch Binärwerte mit vier Stellen.
Hätte jetzt also quasi hier die zwei Akku,
die er dann als 0-0 1-0. Und das,
was technisch natürlich stattfindet, ist nicht diese Operation Sigma,
sondern eine Operation Nü, die dann eben diese beiden,
wie näher Werte,
also sprich die Repräsentation verarbeitet und daraus einen neuen Wert errechnet
Wenn ich nur das, was im Idealfall natürlich passieren sollte,
ist, dass ich hier,
wenn ich das Ganze jetzt eben wieder interpretiere, also das,
was ich dieses Jahr verstriche, ist,
ich dann also zu denselben Ergebnis komme.
Oder mathematisch beschrieben, er gibt Alpha gefolgt von,
ich sag mal, genau dasselbe Vinyl gefolgt von Alpha Strich.
Dann heißen die Informationstreu und es
gilt eben dieses hier,
dieser Ausdruck
Wo ich dann eben sage,
auf der einen Seite habe ich diese Fahrten,
auf der anderen Seite habe ich diesen Pfad und deswegen beides entsprechend identische Ergebnisse.
So, dann kann man das Ganze noch in Bezug jetzt,
also auf diese Funktion Sigma, ein bisschen weiter,
mathematisch jetzt mal irgendwie aufdröseln.
Und zwar, wenn Sigma injektiv ist,
dann ist nie eine Umschlüsselung. Also wie gesagt,
das geht jetzt also in der Art und Weise,
wie diese Operation hier stattfinden.
Also da lasse ich mal da
das Nö
Einmal auf der Information, haben wir auf der Repräsentationsseite.
Und es geht eben bei der Verarbeitung dann keine Informationen verloren,
ist das Nü-Injektiv, so nennen wir das eben eine Umkodierung und mathematisch
gesehen kann man dann eben daraus dann sowas wie einen Homophismus ableiten,
wo man dann eben sagt,
dass ich in der Menge I der Information eine innere Verknüpfung.
Sigma habe, in diesem Fall ist also diese Adition.
Und in der Menge der Repräsentation er eine innere Verknüpfung nü,
was dann eben in diesem Fall die Adition auf dem,
auf der jeweiligen Repräsentation ist,
nicht dann wäre das Ganze eben ein Homo-Moffismus dieser beiden Algewaagenstrukturen.
So, und wenn das Zach Meisters auch noch beam-objektiv ist,
dann habe ich dann eben ein Isomorphismost,
weil dann lässt sich das,
dann spreche ich auch
noch zurückrechnen
Ja, soweit zu den Begriffen aus der Informationstheorie. Auf der anderen Seite,
was gilt da jetzt in Bezug auf die mathematischen Eigenschaften?
Das war etwas, was wir eben gerade bei dieser Funktion,
die eben entweder auf der Information oder eifter Repräsentation ausgeführt wird,
schon gesehen haben. Hier zwei Beispiele,
die dann im nächsten Kapitel bzw. am Ende des nächsten Kapitels
dann also auch nochmal entsprechend beantwortet werden, warum das so ist.
Deswegen da dann also auch noch der Verweis später. Ja,
also nochmal zu den mathematischen Eigenschaften. Normalerweise würden wir jetzt immer sagen,
wenn ich jetzt also irgendwelche Zahlen habe, eine Zahl,
quadliert, ist immer eine Zahl größer gleich null.
Das heißt, ich habe ein positives Ergebnis oder die Zahl der SNO gewesen.
Bei den Darstellungen muss ich eben sagen, bei Fließkommazahlen gilt das.
Bei Entiture-Zahn-Darstellung gilt das nicht. Das heißt, hier kann
der Computer falsch rechnen. Was ist dann als nächstes mit dem,
assoziativ Gesetz, auch hier vor uns eigentlich aus der Mathematik selbstverständlich,
ich kann hier entsprechend die Klammern verschieben,
wenn ich das jetzt bei irgendwelchen Indiger-Zeit-Darstellungen mache,
funktioniert das, wenn ich das bei Fließkomma-Zahlen-Darstellungen mache,
funktioniert das eben nicht.
Sprich, nehmen wir diesen Ausdruck hier und ich rechne das
in einer Art und Weise, wie das hier geklammert ist,
dann wird der Computer mir als Ergebnis die Null rausgeben.
Das heißt, 1,0 mal 10.20 Uhr plus Und dann minus eins,
kommen wir nochmal 10 und 20 plus 3,14. Ist dann eben nicht 3,14,
wie das, was da so im Computer berechnen würde,
wenn ich das entsprechend anders klar mache.
Warum das so ist, sehen wir dann eben im nächsten Kapitel.
Ja, dann hier noch ein paar Begriffe in Bezug auf Zeichen, Alphabete und Zeichenketten.
Also ein Zeichen ist entsprechend ein Element aus einer Menge von entsprechenden Elementen,
die Menge ist dann eben das Zeichen Vorrat oder Zeichensatz,
das was dann im Englischen an dementsprechend Charakter ist oder Charakter-Set
ist und Charakter dann eben als einzelnes Zeichen.
Je nachdem, in welchem Zusammenhang ich das brauche,
brauche ich mir dann ebenentsprechend passend meine Mengen.
Das heißt also für irgendwelche binären Darstellungen habe ich dann eben
quasi meine beiden Elemente 0 und 1 für irgendwelche Hexer-Dezimalzahlen,
habe ich von 0 bis 9 und A bis F die Buchstaben oder
ich habe hier die Buchstaben des griechischen Alphabets oder irgendwelche Steuerzeichen,
die also irgendwie Zeilen enden, in Computern markieren.
Da kann man dann eben entsprechend, je nachdem, worum es geht,
passende Zeichensätze definieren und da dann eben entsprechend Zeichen daraus wählen.
Umgangssprachlich hat man oft noch eine Unterscheidung zwischen numerischen Zeichensätzen,
nämlich wo ich also quasi das brauche, um Zahlen darzustellen.
Das können also nur Ziffern sein oder eben auch Sonderzeichen,
die ich also für die Darstellung von Zahlen brauche.
Und beim Alphanumerischen Zeichensatz habe ich dann eben die eben auch
noch die Buchstaben des Alphabets und eben die Guin Refurs eben auch noch irgendwelche Satzzeichen,
der Zeichenpunktkomma, die man da dann auch noch mal reinbringt.
Ja, uns werden natürlich hauptsächlich, wie Nährzeichen begegnen,
also Binary Digits oder dann auch kurz abgekürzt Bit,
wo war das mit mehrdeutig ist,
wird später auch noch kommen, in dem Zusammenhang hier,
also bis nachher zu Kapitel 5 soll das also erstmal nur ein,
ich weiß ein,
wie Nährzeichen sein,
das heißt ein Zeichnung aus einer Menge von
genau zwei Symbolen
Typischerweise sowas wie 0 oder 1, kann aber auch eben High Low,
Rot, Coln plus minus, was soll immer sein.
Dann, was wir bei Zeichen auch noch häufig haben,
ist, dass in diesem Zeichensatz eine Ordnungsrelation definiert ist. Das heißt,
wenn ich also eine bestimmte Reihenfolge mit drin habe,
dann spreche ich eben von einem Alphabet, nicht das,
was wir also typischerweise dann so bei den Buchstaben eben von A bis Z haben oder wenn ich jetzt also entsprechend ihre Größe jetzt als irgendwie die Ziffern nehme,
dann eben von 0 bis 9 oder eben hier sowas wie Wochentage,
mich darüber lässt sich dann sowas wie ein Alphabet bilden,
wo ich dann eben noch so eine Ordnung mit drin habe.
Auch da muss man sagen, ist natürlich dann abhängig von dem,
wie ich das vereinbart habe. Also auch die Ordnung natürlich
zu sehen. Ich war zum Beispiel bei den Wochentagen,
dass die Wochen mit Montag losgeht, ja, ist allgemein üblich.
Es gibt auch teilweise zählweise, wo man also Sonntag dann
also als ersten Tag der Woche irgendwo mit drin hat.
Ja, und dann abschließend landen wir eigentlich bei den Begriffen der Zeichenkette.
Nicht das, was im Englischen ein String ist,
ist dann eben eine Folge von Zeichen,
ein Wort
Ist dann eben eine Folge von Zeichen, die also irgendwo
als eine Einheit genommen oder als eine Einheit interpretiert wird.
Also sprich das, was war so in der Nacht natürlichen Sprache ja auch immer haben.
Dann bei Binärzeichen kann man sagen, dass Worte mit 8-Bit
ein Bytes sind, also sprich 8, 1, net Wits.
Alles bald. Ja, und dann eben nur als Begriff stelle, wäre dann eben entsprechend die Position eines Zeichens innerhalb einer Zeichenkette. Ja,
damit sind jetzt eigentlich alle grundlegenden Begriffe aus der Informationsverarbeitung gekehrt und in den nächsten Kapiteln werden wir zum einen jetzt mit den Zahndarstellungen beschäftigen,
nämlich im Kapitel 3, wie natürliche Zahlen, Fest,
Komma Zahlen und Fließ, Komma Zahlen dargestellt werden,
in Kapitel 4 dann darauf aufbauen, wie damit gerechnet wird,
also sprich Charit Metik und in dem fünften Kapitel,
danach geht es dann eben um die Zeichendarstellung, also sprich welche Textkodierung gibt es,
was gibt es da an Möglichkeiten, auch an Problemen, die auftreten können, was dann dort verwendet wird.
Teile von Zahndarstellungen, jetzt im Sinne von heuntern,
also sprich Zeiger auf irgendwelche Datenobjekte oder Zeiger auf irgendwelche Prozedurenfunktionen.
Das, was wir, also in Programmiersprachen,
als Pointer haben, werden uns da noch in dem Kapitel 13,
wenn das nur mit der Assembler-Programmierung losgeht, dann also auch nochmal entsprechend geben.
Ja, damit sind wir jetzt hier komplett fertig und dann
tschüss, bis zum nächsten Mal