Für die RTL8821CE existiert ein entsprechendes GitHub-Repository: Realtek RTL8821CE Driver

Wie in der README angegeben, funktioniert dieser Treiber unter GNU/Linux-Systemen auf Debian- oder Arch-Basis, wobei der Kernel mindestens von Version 4.14 sein sollte. Du kannst also auf Systeme wie Debian, Ubuntu, Mint, Arch, Manjaro sowie viele weitere setzen. Der Installationsvorgang ist auf der verlinkten Seite in Form von Konsolenbefehlen ebenfalls beschrieben, die du einfach in ein Terminal eingeben kannst. Unter Arch kannst du zur Hilfe einen AUR-Helper wie yaourt (veraltet) oder yay installieren.

kann man das auslesen ?

Ja, dazu kannst du die Entwicklertools verwenden. Dadurch findest du das:

.head-title:before {
  position: absolute;
  content: "";
  left: 50%;
  top: 58px;
  width: 20px;
  height: 6px;
  background: #3f8ee8;
  margin: 0 auto;
  transform: translateX(-53%);
}

.head-title:after {
  position: absolute;
  content: "";
  left: 50%;
  top: 60px;
  width: 100px;
  height: 2px;
  background: #3f8ee8;
  margin: 0 auto;
  transform: translateX(-53%);
}

Fiddle: https://jsfiddle.net/25q403dc/

Guten Tag,

das Wort „Enttäuschung“ setzt sich zusammen aus der Vorsilbe „Ent-“ und dem Wort „Täuschung“. „Ent-“ bedeutet so viel wie „wegführen von etw., befreien von etw.“. Eine Täuschung ist eine falsche Auffassung eines Sachverhalts, eine Fehlvorstellung, die nicht der Wahrheit entspricht. Eine Enttäuschung ist also die Befreiung von Täuschungen, von Fehlvorstellungen, ein Schritt näher in Richtung Wahrheit.

Enttäuschungen sind mehr oder weniger selbstverschuldet. Das zu akzeptieren ist meist schwierig, aber man muss sich klar machen, dass man, bevor man enttäuscht werden kann, eine bestimmte Erfahrung bezüglich einer Situation oder einer Person haben muss. Man erhofft sich und wünscht sich etwas, man erwartet etwas, aber es tritt nicht ein. Mark Twain sagte einst:

Man ist nicht enttäuscht von dem, was ein anderer tut (oder nicht tut), sondern nur über die eigene Erwartung an den anderen.

Auf den Punkt gebracht: Eine Enttäuschung entsteht, wenn wir uns selbst etwas vormachen und wir erkennen, dass wir uns getäuscht haben. Dass es nicht der richtige Weg ist. Aus diesem Grund ist eine Enttäuschung etwas Positives. Enttäuschungen zeigen uns, was falsch ist und wie es vielleicht besser sein könnte. Sie weisen uns durchs Leben! Wie in Deinem Zitat erwähnt, geben sie uns die Gelegenheit umzusteigen, wenn wir in die falsche Richtung fahren. Sie geben uns die Chance, etwas Besseres aus unserem Leben zu machen.

Man muss akzeptieren, dass Enttäuschungen ein essentieller und unvermeidbarer Bestandteil des Lebens sind. Natürlich ist man für den Moment etwas negativ gestimmt, aber langfristig sollte man sich keine Selbstvorwürfe machen. Niemand kann die Zukunft vorhersehen und es kann nicht alles so verlaufen, wie man es sich wünscht. Nichts ist perfekt! Daher sollte man sich sogar loben: Man hat die Täuschung durchschaut und wird daraus lernen.

Wie gehe ich also mit Enttäuschungen um? Ich frage mich genau, wie es zu dieser Enttäuschung kommen konnte: Was habe ich mir erhofft und war dieses Ziel vielleicht zu unrealistisch, zu optimistisch, zu utopisch? Hätte ich die Enttäuschung irgendwie verhindern können? Was sollte ich beim nächsten Mal anders machen, besser machen? Durch all diese Fragen lerne ich immer mehr über die Enttäuschung und komme somit zur Selbsterkenntnis. Ich komme der Wahrheit, dem richtigen Weg durchs Leben immer ein Stückchen näher.

Einen schönen Sonntag wünsche ich allen ;-)

Guten Morgen,

mich ärgert am meisten, dass mich nichts ärgert :-)

Ich könnte mich natürlich über alles Mögliche aufregen: über das Verhalten anderer Menschen, über den verspäteten Bus, über meine Nachbarn, über die Politik, über den Klimawandel, über den heruntergefallenen Stift, über das Wetter, über andere Autofahrer, über Stau, über das Schulsystem, über den Drucker, über unpassende Bohrlöcher, über ausverkaufte Artikel, über die Steuern, über Verschmutzung, über gutefrage-Nutzer etc. Es gibt so viel, worüber man sich aufregen kann.

Aber was bringt mir das? Oder bringt es überhaupt jemandem etwas? Genau: nichts. Wenn mir also etwas nicht gefällt, ignoriere ich es einfach. Sollen andere Menschen das tun, was sie nicht lassen können. Und wenn ich eine Änderung will, dann evaluiere ich, welche Möglichkeiten ich habe, solch eine Änderung zu bewirken. Denn das bringt viel mehr, als sich einfach nur aufzuregen. Außerdem ist es gut für die Nerven und die Gesundheit ;-)

Natürlich gelingt es mir nicht in jeder Situation die Fassung zu bewahren, aber ich gebe mir Mühe. Am ehesten regen mich wahrscheinlich Drucker und Technik allgemein auf. Bin zwar Softwareentwickler, aber es funktioniert leider trotzdem nicht immer so, wie es funktionieren soll... Dafür ist es umso schöner, wenn alles klappt.

Schönen Donnerstag allen! 😀

Führe die Permutationen so oft in einer Schleife durch, bis wieder das Ursprungsarray herauskommt. Zähle dabei, wie oft permutiert wurde:

private int getOrder(int[] a) {
  int[] b = permute(a, a);
  int i;

  for (i = 1; !Arrays.equals(a, b); ++i) {
    b = permute (b, a);
  }

  return i;
}

Die Ende-zu-Ende-Verschlüsselung ist automatisch aktiviert, sofern beide eine einigermaßen aktuelle WhatsApp-Version installiert haben. Der Code hat folgenden Sinn:

Verifying Keys WhatsApp users additionally have the option to verify the keys of the other users with whom they are communicating so that they are able to confirm that an unauthorized third party (or WhatsApp) has not initiated a man-in-the-middle attack.

Mithilfe dieses Codes kannst du also überprüfen, ob die Ende-zu-Ende-Verschlüsselung direkt stattfindet und somit sicherstellen, dass dazwischen nicht irgendwer („Man-in-the-middle“) mitlauscht.

Inwiefern ist eine ROM für Gaming geeignet oder nicht? Was genau soll die ROM denn bieten? Wenn du einfach nur nach einer schlanken und performanten Custom-ROM suchst, bist du mit LineageOS bestens beraten.

Ansonsten hat der Kernel weitaus größere Auswirkungen auf die Performance. Durch einen Custom-Kernel können beispielsweise CPU-Governor und Overclocking eingestellt werden. Um einen passenden Kernel empfehlen zu können, müsste das Gerätemodell bekannt sein. Generell ist ohne weitere Informationen nicht klar, ob ein Custom-Kernel für dich überhaupt sinnvoll ist.

Aufgabe 3 beinhaltet Aufgabe 2. Daher hier meine Lösung für Aufgabe 3 auf die Schnelle:

import math
from texttable import Texttable

class Tree:
  def __init__(self, chars = None, freq = None):
    self.left = None
    self.right = None
    self.chars = chars
    self.freq = freq

sum1 = 0
sum2 = 0
table = None
text = None

def newbase():
  global sum1, sum2, table, text

  text = input("Eingabe: ")
  table = {}

  for c in text:
    if (not c in table):
      table[c] = [1 / len(text)]
    else:
      table[c][0] += 1 / len(text)

  trees = []
  for r in table:
    trees.append(Tree(r, table[r][0]))

  while (len(trees) > 1):
    trees.sort(key=lambda x: x.freq)

    newTree = Tree(trees[0].chars + trees[1].chars, \
        trees[0].freq + trees[1].freq)
    newTree.left = trees[0]
    newTree.right = trees[1]
    trees.append(newTree)
    trees.pop(0)
    trees.pop(0)

  tree = trees[0]

  for i, c in enumerate(table):
    l = table[c]
    
    s1 = -((math.log(l[0])) / math.log(2)) * l[0]
    sum1 += s1
    l.append(s1)

    form = "{0:0" + str(math.ceil(math.log(len(table), 2))) + "b}"
    l.append(form.format(i))

    huffman = ""
    t = tree
    while (t != None):
      if (t.left != None and c in t.left.chars):
        huffman += "0"
        t = t.left
      elif (t.right != None and c in t.right.chars):
        huffman += "1"
        t = t.right
      else:
        t = None
    
    l.append(huffman)

    s2 = len(huffman) * l[0]
    sum2 += s2
    l.append(s2)

  return table

def showtable():
  t = Texttable()
  t.add_row(["A", "Relative Häufigkeit", "-p(A) ld p(A)", "Blockcode", \
      "Huffmann", "Gewichtete Codelänge"])
  for k, v in table.items():
    t.add_row([k] + v)
  t.add_row(["Summe", 1, str(sum1) + " bit", \
      str(math.ceil(math.log(len(table), 2))) + " bit", "", str(sum2) + " bit"])
  print(t.draw())

def encode():
  encoded = ""

  for c in text:
    encoded += table[c][3]
  
  return encoded

def decode(encoded):
  decoded = ""

  i = 0
  while i < len(encoded):
    j = i + 1
    c = None
    while (c == None):
      s = encoded[i:j]
      for k, v in table.items():
        if (v[3] == s):
          c = k
      j += 1
    
    decoded += c
    i = j-1

  return decoded

table = newbase()
showtable()

encoded = encode()
print (encoded)

decoded = decode(encoded)
print(decoded)

Live-Test: https://repl.it/@tavkomann/Huffman

Im Endeffekt habe ich mich für ein Dictionary entschieden, welches jedem Buchstaben eine Liste mit den restlichen Tabellenspalten zuordnet. Außerdem habe ich einen ganz grundlegenden Baum implementiert.

Schau dir das einfach mal an und versuche es nachzuvollziehen. Das könnte dich für deine eigene Lösung inspirieren. Solltest du konkrete Fragen zu meinem Code haben, frage einfach nach ;-)

Rufus ist ein Windows-Programm. Um ein Live-Medium unter GNU/Linux zu erstellen, kannst du beispielsweise UNetbootin verwenden.

Wenn jetzt vom Galaxy S3 oder anderen älteren Geräten die Rede gewesen wäre, könnte man deine Aussage auf jeden Fall unterstreichen. Eine ausführliche Erläuterung dazu findest du hier. Heutzutage spielt dieses leichte Defizit bei modernen Geräten überhaupt keine Rolle mehr. Der Unterschied hat sich mittlerweile so stark relativiert, dass einige Android-Geräte sogar länger schnell und stabil bleiben als iOS-Geräte.

Daher glaube ich, dass deine Probleme eher mit einer außergewöhnlichen Nutzungsweise oder mit Samsungs angepasstem System zusammenhängen. Kaum ein Hersteller verwendet Android nämlich in der ursprünglichen Form („Vanilla Android“), sondern die meisten Hersteller entwickeln eine eigene Oberfläche. Samsung war damals mit der Oberfläche TouchWiz bekannt für besonders schlechte Performance und Stabilität geworden. Samsung Experience, die neueste Generation dieser Oberfläche, ist zwar wesentlich schlanker, aber immer noch nicht vergleichbar mit Vanilla Android.

Daher rate ich dir einfach dazu, dein Gerät zurückzusetzen oder ein neues Gerät mit einem schlanken Android zu kaufen – beispielsweise ein OnePlus- oder ein Google-Gerät, wobei ich ersteres aufgrund des Preis-/Leistungsverhältnisses bevorzugen würde. Alternativ kannst du eine schlanke Custom-ROM wie LineageOS oder Resurrection Remix auf dein Galaxy S7 installieren.

Die Aufgabenstellung sollte soweit verständlich sein: Es ist eine Methode gesucht, die aus zwei Zeichenketten die Länge der längsten gemeinsamen Teilzeichenkette berechnet. Schreiben wir das erst einmal hin:

int longEq(String s, String t) {

}

Nun benötigen wir irgendwie eine Variable, in der wir die Länge der zurzeit längsten ermittelten Zeichenkette abspeichern. Am Ende geben wir den Wert, der in dieser Variable gespeichert ist, zurück:

int longEq(String s, String t) {
  int maxLength = 0;
 
  // Magie ;-) 
  
  return maxLength;
}

Nun kümmern wir uns um die „Magie“. Die intuitivste Möglichkeit ist sicherlich, einfach alle möglichen Teilzeichenketten durchzugehen. Wie wird eine Teilzeichenkette charakterisiert? Es gibt eine Startposition und eine Länge bzw. eine Endposition, die sich aus Startposition und Länge ergibt.

Bauen wir uns also einfach eine Schleife, mit der wir jede einzelne Startposition in der einen Zeichenkette durchgehen:

int longEq(String s, String t) {
  int maxLength = 0;

  for (int i = 0; i < s.length(); ++i) {
    // ...
  }

  return maxLength;
}

Nun gehen wir innerhalb dieser Schleife mithilfe einer weiteren Schleife jede einzelne Länge durch. Wann brechen wir ab?

1. Das Ende der Zeichenkette ist erreicht
2. Die ermittelte Teilzeichenkette kommt in der anderen Zeichenkette gar nicht vor: Daher brauchen wir sie nicht noch weiter verlängern.

Im Code sieht das so aus:

int longEq(String s, String t) {
  int maxLength = 0;

  for (int i = 0; i < s.length(); ++i) {
    int l;
    for (l = 0; i+l < s.length()
        && t.contains(s.substring(i, i+l+1)); ++l);
  }

  return maxLength;
}

Nicht verwirren lassen: Eine Schleife muss keinen Schleifenkörper besitzen. Die Schleife dient hier nur zum Zählen und uns interessiert am Ende nur der Wert der Variable l. Deshalb lagern wir die Deklaration dieser Variable aus der Schleife aus, damit wir auch außerhalb der Schleife auf sie zugreifen können.

Nun fehlt uns nur noch ein Schritt: Wenn die ermittelte Länge größer als die bisherige Maximallänge ist, speichern wir sie ab. Der fertige Code sieht daher so aus:

int longEq(String s, String t) {
  int maxLength = 0;

  for (int i = 0; i < s.length(); ++i) {
    int l;
    for (l = 0; i+l < s.length()
        && t.contains(s.substring(i, i+l+1)); ++l);
    if (l > maxLength) maxLength = l;
  }

  return maxLength;
}

Hier ein Live-Beispiel: https://repl.it/@tavkomann/LongEq

Der Code ist bezüglich der Performance noch nicht optimal, aber eine Lösung der Aufgabe wird durch ihn auf jeden Fall erreicht.

Um welche Programmiersprache geht es denn?

In Java kannst Du beispielsweise folgendermaßen eine ganzzahlige Zufallszahl zwischen min und max erzeugen:

Random rand = new Random();
int n = rand.nextInt(max - min + 1) + min;

Dies ist eine schnelle Methode zur Erzeugung von Zufallszahlen. So ganz zufällig sind sie jedoch nicht. Daher gibt es für besondere Fälle (beispielsweise Kryptographie), in denen die Zufallszahlen noch zufälliger sein müssen, folgende Methode:

Random rand = new SecureRandom()
int n = random.nextInt(max - min + 1) + min;

Obige Zufallsgeneratoren sind ziemlich gut. Wenn du jedoch verstehen möchtest, wie sie generell funktionieren, kannst du dir mal die Kongruenzgeneratoren anschauen. Es gibt verschiedene Arten. Ein linearer Kongruenzgenerator, damit können Pseudozufallszahlen erzeugt werden, sieht beispielsweise so aus:



a ist ein Faktor, mit dem der vorherige Zufallswert multipliziert wird. Das Ergebnis wird um c, das Inkrement, erhöht. Außerdem sorgt m dafür, dass sich der Zufallswert innerhalb eines bestimmten Bereiches befindet, sodass sich Zahlen auch wiederholen können. Der Zufallswert ist immer größer null und kleiner m. Der Zufallsgenerator beginnt immer mit einem bestimmten Startwert, welcher beispielsweise aus der aktuellen Zeit bestimmt werden kann.

Eine ganz einfache Java-Implementierung könnte beispielsweise so aussehen:

class SimpleRandom {
  private int max, rand;

  public SimpleRandom(int max) {
    this.max = max;
    rand = (int)(System.currentTimeMillis() % max);
  }

  public int nextInt() {
    rand = (35537 * rand + 7) % 35543;
    return rand % max;
  }
}

Nun können beispielsweise 20 Zufallszahlen im Bereich von 1-100 (ebenfalls nach der Formel ganz oben in meiner Antwort) erzeugt werden:

SimpleRandom rand = new SimpleRandom(100 - 1 + 1);

for (int i = 0; i < 20; ++i) {
  int n = rand.nextInt() + 1;
  System.out.println(n);
}

Die erzeugten Zufallszahlen sind nicht so schlecht, aber für die Praxis eher unbrauchbar. Hier ein Live-Beispiel: https://repl.it/repls/WorthwhileRoughApplication

Was ist Arch Linux?

Bei Arch Linux handelt es sich um eine flexible und leichtgewichtige GNU/Linux-Distribution für erfahrene Anwender. Die Besonderheit ist, dass nach der Installation lediglich ein Grundsystem vorliegt, welches optimal nach den Bedürfnissen des Nutzers gestaltet werden kann.

Außerdem handelt es sich um ein sogenanntes Rolling-Release-System, das heißt, dass es keinerlei Betriebssystem-Versionen gibt, bei welchen eine große Menge an Software auf einmal aktualisiert und neue Funktionalität eingebaut wird. Stattdessen werden die einzelnen Pakete kontinuierlich aktualisiert, sodass das System brandaktuell ist. Neuinstallationen sind nie erforderlich.

Ist es ein Betriebssystem?

Ja, es ist ein GNU/Linux-Betriebssystem. Es wird also der Linux-Kernel verwendet und eine große Menge an GNU-Tools eingesetzt. Das System ist unixähnlich.

Was ist daran besser?

Im Vergleich wozu? Zu Windows habe ich bereits hier und hier einen sehr ausführlichen Vergleich vorgenommen. Einen ausführlichen Vergleich zu anderen Distributionen findest du hier.

Was macht Arch aus?

• Anpassbarkeit: Arch lässt sich extrem stark an deine eigenen Bedürfnisse anpassen. Das System enthält nur das, was du wirklich brauchst und keinen redundanten Schnickschnack. Du nimmst das System nicht einfach so hin wie es ist, sondern du gestaltest es aktiv nach deinen Wünschen. Deshalb sieht ein Arch-System bei jedem Nutzer wahrscheinlich vollkommen anders aus. Der Nachteil ist natürlich, dass zu Beginn nicht alles fertig und direkt nutzbar ist, sondern du erst einmal vieles einrichten musst, bevor du anfangen kannst.
• Software: Es gibt sehr viele Software-Pakete für Arch. Arch bietet zusätzlich zum Paketmanager pacman das sogenannte AUR an, welches von Nutzern gepflegt wird. Für Debian/Ubuntu soll es zwar insgesamt mehr Pakete geben, jedoch habe ich genau die gegenteilige Erfahrung gemacht ;-)
• Software direkt vom Entwickler: Während andere Distributionen beispielsweise Desktop-Oberflächen leicht modifizieren, bekommst du bei Arch direkt das Produkt, welches der Entwickler herausgegeben hat.
• Aktualität: Arch ist durch das Rolling-Release-Modell immer sehr aktuell und Arch-User erhalten so oftmals als erste die neuesten Versionen von Programmen und somit den Zugang zu neuen Features. Dies hat jedoch zur Folge, dass die Updates nicht immer ganz glatt laufen und danach möglicherweise bestimmte Funktionalitäten beeinträchtigt werden. Du musst damit rechnen, hin und wieder mal Hand anlegen zu müssen, um Fehler zu beseitigen. Daher solltest du dich gut mit der Arbeit mit Log-Dateien auskennen, um die Probleme auch selbstständig lösen zu können.
• Arch-Wiki: Das Arch-Wiki ist das beste Linux-Wiki, welches mir bekannt ist.

Ist es kompliziert?

Es ist kompliziert, wenn man bislang zu wenig GNU/Linux-Erfahrung besitzt. Arch richtet sich wirklich nur an erfahrene Anwender, weil du damit rechnen musst, dass du dir nicht alle Einstellungen zusammenklicken kannst, sondern auch sehr viel mit der CLI arbeiten musst. Daher musst du die grundlegenden Befehle beherrschen und zudem ein gutes Wissen über einzelne Hintergründe besitzen.

Für Einsteiger ist dagegen das auf Arch basierende System Manjaro sehr empfehlenswert. Damit bekommst du natürlich bei weitem nicht alle Vorteile von Arch zu spüren – Manjaro betont stets, dass es nicht Arch ist –, jedoch ist es ebenfalls ein ganz gutes System für Einsteiger, siehe auch: https://wiki.manjaro.org/index.php?title=Manjaro:_A_Different_Kind_of_Beast

Geht es auch gut auf dem Laptop?

Natürlich! Es spielt keine Rolle, ob PC oder Laptop: Solange die notwendigen Treiber für die Hardware vorhanden sind, sollte alles problemlos funktionieren.

In Vanilla-Android gibt es keine solche Möglichkeit. Somit kann der Clipboard-Verlauf nur abgerufen werden, wenn ein Clipboard-Manager installiert ist bzw. der Smartphone-Hersteller selbst einen eingebaut hat (diesen könnte man beim Durchsuchen der Einstellungen finden, falls er vorhanden ist).

Für die Zukunft empfehle ich eine Tastatur mit integriertem Clipboard-Manager, beispielsweise SwiftKey. Für jetzt sehe ich keine Chance.

Das sind sehr viele komplexe Fragen. Hoffentlich liest du das alles, was ich jetzt schreibe. Eigentlich wird das meiste davon sogar schon an Gymnasien im Informatik-Unterricht gelehrt und entspricht einem ganzen Semester...

Ich weiß dass eine CPU aus unzählig vielen Transistoren besteht. Somit ein Binärsystem besitzt (1;0).

Allein mit dem Prinzip der Transistoren kommt man nicht weiter, das ist zu nah an der wirklichen Hardware. Um etwas Komplexes wie einen Computer zu entwickeln, ist stets Abstraktion erforderlich. Die erste Abstraktionsebene stellen dabei die sogenannten Logikgatter dar. Diese basieren auf dem EVA-Prinzip: Binäre Eingaben werden durch eine Schaltung (bestehend aus Transistoren) in binäre Ausgaben umgewandelt. Dabei existieren drei Grundgatter:

Es gibt AND-, OR- und NOT-Gatter. Hier findest du zugehörige Symbole und Tabellen detailliert erklärt.

Das UND-Gatter liefert am Ausgang nur eine 1, sofern beide Eingaben 1 sind. Das ODER-Gatter liefert am Ausgang eine 1, sofern mindestens eine der beiden Eingaben 1 ist. Das NICHT-Gatter liefert am Ausgang eine 1, sofern die Eingabe 0 ist, ansonsten liefert es eine 0. Diese Gatter basieren auf bestimmten elektrischen Schaltungen, welche aber im weiteren Verlauf nicht mehr relevant sind. Es ist wichtig, dass man das Prinzip der Gatter verinnerlicht hat, bevor man sich Gedanken über eine CPU machen kann.

In der Praxis werden zwar die drei Grundgatter oft alle durch NAND-Gatter umgesetzt, aber das vernachlässigen wir der Einfachheit halber mal.

Zum Ausprobieren eignet sich das Programm LogicSIM.

Die Grundgatter lassen sich zu komplexeren Schaltungen zusammenschließen, sodass wir beispielsweise sogar Daten speichern können. Wichtig sind noch die sogenannten JK-Flip-Flops sowie Multiplexer. Ein JKMS-Flip-Flop sieht so aus:

Der mittlere Eingang dient für ein Taktsignal, d. h. eine regelmäßige Abfolge von Einsen und Nullen:

Bei einer steigenden Taktflanke werden die Eingaben eingelesen, bei der nächsten fallenden Taktflanke ausgegeben. Sofern der obere Eingang beim Einlesen gesetzt ist, wird eine 1 gespeichert. Ist dagegen der untere Eingang beim Einlesen gesetzt, wird eine 0 gespeichert. Der gespeicherte Wert liegt am Ausgang an. Der untere Ausgang ist dasselbe, nur negiert. Ein JKMS-Flip-Flop ist eigentlich eine Zusammensetzung aus zwei JK-Flip-Flops. Ein JK-Flip-Flop wiederum ist aus einem RS-Flip-Flop zusammengesetzt. Dieses sieht mit den Grundgattern so aus, damit du dir vorstellen kannst, wie das überhaupt funktionieren kann:

Geschickt, oder? Jedenfalls werde ich jetzt nicht erklären, wie man davon zum JK-Flip-Flop und letztendlich zum JSMS-Flip-Flop kommt. Das ist auch gar nicht so relevant. Baue das mal in LogicSIM nach und spiele ein bisschen herum, schaue dir an, wie das reagiert.

Ein Multiplexer wählt aus einer Reihe von Eingaben eine aus und schaltet diese an den Ausgang durch. Hier die Schaltung für einen 1-MUX:

s ist quasi ein Schalter. Ist s 0, so wird der obere Ausgang durchgeschaltet, ansonsten der untere. Ebenso gibt es auch einen 2-MUX, welcher zwei Schalteingänge besitzt und somit vier verschiedene Eingaben durchschalten kann.

Das reicht erst einmal an Grundlagen. Das waren nur mal ein paar Beispiele. Die weiteren Grundlagen musst du für ein tieferes Verständnis recherchieren und dir erarbeiten.

Die Von-Neumann-Architektur bildet die Grundlage für den Aufbau heutiger Computer:

Quelle: Lukas Grossar, Von-Neumann Architektur, CC0, Wikimedia Commons

Die CPU ist dabei aus Rechenwerk (ALU) und Steuerwerk zusammengesetzt. Über ein Bus-System können diese mit dem Ein-/Ausgabewerk sowie dem Speicherwerk kommunizieren. Nur in diesem Verbund ergeben die einzelnen Komponenten überhaupt Sinn. Wenn du die Funktionsweise einer CPU klären möchtest, musst du immer alle weiteren Komponenten in die Überlegungen hinzuziehen.

Der Aufbau heutiger Prozessoren ist sehr komplex. Daher ist es fast unmöglich, anhand der Struktur einen Einblick in Aufbau und Funktionsweise eines Computers zu bekommen. Aus diesem Grund wird oftmals ein Modellrechner zur Rate gezogen, dessen Struktur vereinfacht ist. Der grobe Aufbau des im Folgenden betrachteten Modellrechners ist in der folgenden Abbildung dargestellt:

Wie aus der Abbildung hervorgeht, ist ein Computer modular aufgebaut. Deshalb ist es sinnvoll, die Funktion jeder Komponente im Einzelnen zu beschreiben:

1. Der Taktgeber: Aus einem Dauertaktsignal werden fünf Taktimpulse generiert: Die ersten vier Takte dienen der Rechnung, der fünfte Takt dient der Erhöhung des Befehlszählers um eins und dem Übertragen des aktuellen Befehls aus dem RAM in das Befehlsregister.
2. Der Befehlszähler: Legt fest, welcher Befehl aus dem RAM ausgelesen wird, indem er die jeweilige Speicherzelle adressiert.
3. Der RAM: Hier werden alle Befehle gespeichert.
4. Das Befehlsregister: Das Befehlsregister erhält aus dem RAM mithilfe der Adressierung durch den Befehlszähler den aktuell durchzuführenden Befehl und speichert diesen.
5. Das Steuerwerk: Das Steuerwerk gibt je nach Belegung des Befehlsregisters unterschiedliche Signale an die Bauteile ab.
6. Das Eingaberegister: Das Eingaberegister speichert eine Zahl, welche beim nächsten Taktsignal an das Rechenwerk übergeben wird.
7. Das Rechenwerk (ALU): Hier wird die Zahl aus dem Eingaberegister mit der Zahl aus dem Akkumulator verrechnet. Das Ergebnis wird wiederum im Akkumulator gespeichert, sodass damit weiter gerechnet werden kann.
8. Ausgaberegister: Bei einem bestimmten Befehlscode wird der Wert des Akkumulators in das Ausgaberegister geschoben und dort als Ausgabe zwischengespeichert.

Eine solche Schaltung kann konkret folgendermaßen realisiert werden:

Damit kannst du beispielsweise 2+2 rechnen. Der obige Rechner ist wenig flexibel – du musst alles von Hand machen. Daher verlinke ich einfach mal eine 4-Bit-CPU:

https://simulator.io/board/AWZpw7Fy3I/2

Das ist letztendlich die praktische Umsetzung obiger Überlegungen. Der Befehlssatz der CPU ist dort ebenfalls aufgeführt:

https://imgur.com/a/zuRd1ZP

Nehmen wir als Beispiel mal kein Videospiel sondern eine Matheaufgabe: Wenn ich 2+2 rechnen will, wird dann einfach ein Code aus mehreren 1 und 0 abgerufen oder wie darf ich das verstehen?

Um also zwei Zahlen zu addieren, würde sich folgendes Programm eignen:

IN
SWP
IN
ADD
OUT

Binär:

0000
0011
0000
0100
0001

Das kannst du auf der Website direkt oben links im ROM per Edit eintragen und die Simulation per Klick auf das dritte Taktsignal starten. So sollte es aussehen:

https://imgur.com/a/UFwdGLj

Nun kannst du damit zwei Zahlen addieren. Nun probieren wir mal etwas Komplizierteres: Wir addieren zwei Zahlen und, sofern die Summe 8 ist, geben wir 5 aus. Ansonsten fragen wir wieder zwei neue Zahlen ab – so lange, bis irgendwann die Summe 8 ist. Das würde so aussehen:

IN
SWP
IN
ADD
SWP
MOV
8
SUB
JZ
12
JMP
0
MOV
5
OUT

Binär:

0000
0011
0000
0100
0011
0010
1000
0101
1011
1100
1010
0000
0010
0101
0001

Und dann zum 2. Teil der Frage: Wie arbeitet eine Programmiersprache? Wie wird es bewerkstelligt dass der PC auf die eingegebenen Zeilen reagiert?

Das geschieht genauso, wie eben beschrieben. Nun handelt es sich dabei um Maschinencode, Einsen und Nullen. Das kann man sich kaum merken, daher gibt es Programmiersprachen der zweiten Generation, sogenannte Assemblersprachen. Diese nutzen, wie man oben sieht, Symbole in Textform (z. B. IN, SWP, ADD, MOV).

Guten Morgen,

ich nehme an, dieses bedingungslose Grundeinkommen sei tatsächlich irgendwie möglich, würde ich trotzdem arbeiten gehen, weil mir die Arbeit Spaß macht. Außerdem muss ja irgendwer die ganze Software schreiben, die wir im heutigen "IT-Zeitalter" benötigen.

Das zusätzliche Geld kann ich beispielsweise gut für Spenden gebrauchen. Es gibt sehr viele Software-Projekte, z. B. Wikipedia oder Linux, die auf Spenden angewiesen sind. Darüber hinaus gibt es eine Reihe weiterer gemeinnütziger Organisationen, die sich für andere Menschen, Kinder oder die Umwelt einsetzen. Auch diese sollten unterstützt werden.

Mehr Freizeit wäre natürlich nicht schlecht. Es gibt sehr viele Länder zu erkunden und bisher beschränken sich meine Reisen so ziemlich auf Europa bzw. Europa-nahe Orte. Gerne würde ich auch Reisen an fernere Orte unternehmen. Es ist aber sehr schwierig, denn der Tourismus sollte möglichst sanft und nachhaltig sein. Es ist schon erstaunlich, welche Folgen das sonst auf die Umwelt und die Bevölkerung haben kann.

Ich würde also trotzdem arbeiten, aber gerne mehr Freizeit und Urlaub haben.

Letzter Tag der Woche - schon jetzt allen ein schönes Wochenende! ;-)

Klicke in XAMPP auf „Netstat“ und finde heraus, welches Programm den Port blockiert. Den Port kannst du einsehen, wenn du neben MySQL auf „Konfig“ klickst. Dort steht dann etwas wie „Listen XX“. Du kannst den Port auch auf einen unbenutzten Port ändern, damit MySQL starten kann. Oder du beendest das jeweilige Programm, welches den Standard-Port blockiert.

Es handelt sich um Vigenère-Verschlüsselung. Diese kannst du, falls du es von Hand machen willst, am besten über den Kasiski-Test entschlüsseln: https://de.wikipedia.org/wiki/Kasiski-Test

Suche Muster, welche sich innerhalb des Geheimtextes wiederholen und bestimme dann deren Abstand. Tue dies für mehrere Muster und ermittle den gemeinsamen Teiler der Buchstaben. Dieser ist ein Vielfaches der Schlüssellänge. Von Hand kannst du den Schlüssel am besten durch Ausprobieren ermitteln, die Häufigkeitsanalyse gestaltet sich da etwas langwierig, denke ich. Du wirst schon sehen, ob sich korrekte englische Wörter ergeben oder nicht.

Natürlich muss dir klar sein, wie die Vigenère-Chiffre und die Caesar-Chiffre funktionieren. Du solltest auch wissen, dass an jeder selben Stelle des Schlüssels im Grunde genommen eine Caesar-Verschlüsselung stattfindet. Die Grundlagen müssen vorhanden sein.

Es gibt auch entsprechende Online-Tools dafür oder du implementierst dir selbst ein Programm.

Verschlüsseln/Entschlüsseln: https://gc.de/gc/vigenere/
Knacken: https://www.guballa.de/vigenere-solver

Der Schlüssel ist übrigens PINES, falls du nicht darauf kommst ;)