diff --git a/IN0009_GBS/ipc.md b/IN0009_GBS/ipc.md
new file mode 100644
index 0000000..fb8425c
--- /dev/null
+++ b/IN0009_GBS/ipc.md
@@ -0,0 +1,141 @@
+# GBS: Kapitel 5: Inter-Prozesskommunikation (IPC)
+
+## Nenne drei Arten der Kommunikation zwischen Prozessen bzw. Threads.
+- Signalisierung von **Ereignissen**
+- Austausch von **Nachrichten**
+  - Auch komplexe Kommunikationsprotokolle möglich (z.B. TCP, UDP)
+- **Gemeinsamer Speicher**
+
+## Sind Linux Signale ein schmal, oder breitbandiger Kanal?
+Schmalbanding. Prozesse können sich gegenseitig Signale senden, und bestimmte Signale explizit mithilfe einer Handler Routine abfangen.
+
+SIGKILL und SIGSTOP können nicht abgefangen werden.
+
+## Was passiert wenn der Prozess ein Linux Signal nicht abfängt?
+Er wird vom Betriebsystem **beendet**.
+
+## Was ist ein Vorteil und ein Nachteil der Impliziten Kommunikation mittels Shared Memory?
+Einfach und schnell, da kein Kopieren zwischen Adressräumen benötigt wird. Es werden aber Synchronisationsmechanismen benötigt, die u.u. eine weitere schmalbandige Kommunikation benötigt.
+
+## Wofür werden schmalbandige Kanäle u.a. genutzt?
+- Übertragen von wenigen Btis an Infromation
+- Melden von Ereignissen
+- Synchronisationskonzepte und Unterbrechungskonzepte erforderlich
+
+## Nenne zwei Methoden zur expliziten Übertrageung von größeren Datenmengen.
+- Pipes
+- Sockets
+
+## Nenne eine Methode zur impliziten, aber schnellen Übertragung von größeren Datenmengen zwischen Prozessen.
+Shared Memory bzw. `mmap`.
+
+## Inwiefern beeinflusst Synchronität den **Kopplungsgrad** zwischen Prozessen
+- **synchron**: beide Prozesse werden zur Nachrichtenübertragung synchronisiert, blockierend.
+- **asynchron**: Entkopplung von Sender und Empfänger nicht blockierend
+
+## Welche zwei primären **Muster** der Nachrichtenkommunikation gibt es?
+- Meldung: Unidirektional
+- Auftrag (Request - Response): Bidirektional
+
+## Wie läuft eine asynchrone Meldung zwischen Sender und Empfänger ab?
+1. **Sender** (S) übergibt die Nachricht an den **Nachrichtendienst** des Betriebsystems (`send()`)
+2. BS puffert Nachrichten. Sender wartet nicht.
+3. **Empfänger** (E) kann Nachricht mittels `recv()` empfangen. Wenn keine Nachricht gepuffert ist, wird der Empfänger blockiert.
+
+## Wie läuft eine synchrone Meldung zwischen Sender und Empfänger ab?
+- **Empfänger** sendet nach Erhalt der Nachricht eine Bestätigung
+- Sender wartet nach dem Senden auf die Empfangsbestätigung
+- Empfangsbestätigung enthält hier keine Daten sondern dient nur der Synchronisation
+
+## Beschreibe wie ein asynchroner Auftrag abläuft.
+- Auftrag und Resultat werden als **unabhängige Meldungen** verschickt
+- Zwischen `send()` und `recv()` kann der Sender weitere Aufträge versenden
+- Aufträge können an den **gleichen** oder **andere Empfänger** gesendet werden
+
+## Beschreibe wie ein synchroner Auftrag abläuft.
+Sender wartet auf Antwort, während Empfänger antwort bearbeitet.
+
+## Nenne drei Vorteile von asynchronem Senden.
+- Nützlich für **Echtzeitanwendungen**, wenn sendender Prozess nicht blockiert werden darf
+- Ermöglicht **parallele Abarbeitung** durch Sender und Empfänger
+- Anwendbar zum Signalisieren von Ereignissen
+
+## Was sind zwei Nachteile von asynchronem Senden?
+- **Verwaltungsoverhead** im Betriebssystem (Puffer für Nachrichten)
+- **Behandlung von Fehlern** schwieriger
+
+## Beschreibe wie Message Passing funktioniert.
+Semaphoren werden durch `send()` und `recv()` Aufrufe ersetzt. Synchronisation auf BS Ebene.
+
+## Wie können Datenströme (Streams) übertragen werden?
+- Nachrichten werden auf demm Kommunikationsweg **gepuffert**
+- Als **logischer Bytestrom** vereinigt
+- Bytestrom **kann unabhängig von den Nachrichtengrenzen** verarbeitet werden
+- **Dienste im Betriebsystem**: Verbindungsauf- und -abbau, lesen und schreiben in Strom
+
+## Eine Pipe ist ein bidirektionaler Strom. Ja oder Nein?
+Nein. Eine Pipe ist ein **unidirektionaler Strom**.
+Eine bidirektionale Kommunkation mit Paaren von Pipes.
+
+## Was ist der Unterschied zwischen anonymen und named Pipes?
+- `pipe()` erstellt zwei Kommunikationsendpunkte (erstellen einer anonymen Pipe)
+- Ein Endpunkt kann mittels Fork an den Kindprozess übergeben werden (Oder Threads)
+- Named pipes als "virtuelle Datei", da sie im Dateisystem verlinkt sind.
+
+## Warum werden Ports benötigt?
+Es wird eine System-unabhängige Addressierungsart für ein System benötigt, da PIDs nicht eindeutig identifizierend sind.
+
+## Warum gibt es eine Teilmenge an Ports die für die dynamische Nutzung bestimmt sind?
+Einen festen Port haben nur Prozesse, die oftmals per Konvention über diesen Port erreichbar sind. Prozesse die diese Dienste kontaktieren können 
+
+## Beschreibe das Rendezvous-Problem.
+Sender und Empfänger stellen vor Austausch der Meldung die Sende- und Empfangsbereitschaft her
+
+## Welche System Calls können für das Lesen, Schreiben und Schließen von File-Deskriptoren verwendet werden?
+`read()`, `write()`, `close()`.
+
+## Was macht `connect()` auf einem Socket?
+Initiiert eine Verbindung zu einem entfernten Host.
+
+Es wird typischerweise von einem Client verwendet, um eine Verbindung mit
+einem Server herzustellen, indem die IP-Adresse und der Port des Servers
+angegeben werden.
+
+## Was macht `bind()` auf einem Socket?
+Weist dem Socket eine lokale Adresse (Interface) und Port zu
+
+## Was macht `listen()` auf einem Socket?
+Versetzt Socket in einen passiven Modus, wo er auf eingehende Verbindungsanfragen warten kann.
+
+## Wie können Sockets gesteuert werden?
+`setsockopt()`, `getsockopt()`, `ioctl()`.
+
+## Wie funktioniert Reference Counting und wo wird es u.a. im Kernel genutzt?
+Eine Resource verfügt über einen Zähler der alle Referenzen auf die Resource zählt.
+Wenn ein Prozess z.B. einen File Descriptor öffnet, wird der Zähler für den File Descriptor inkrementiert, wenn die Resource geschlossen wird dekrementiert.
+
+Üblicherweise wird die Ressource dealloziert, wenn Zähler == 0.
+
+## Wie kann man zwei unterschiedliche Prozesse mit einer anonymen Pipe verbinden?
+1. **Pipe Erstellen**: Elternprozess erstellt eine `pipe()`
+2. **Prozess Aufspalten**: Spaltung durch `fork()`. Beide Prozesse erben die Dateideskriptoren der Pipe.
+3. **Dateideskriptoren Schließen**:
+    - Im **Elternprozess** wird der Lese-Ende-Dateideskriptor der Pipe geschlossen, wenn der Elternprozess Daten an den Kindprozess senden soll. Der Elternprozess verwendet dann den Schreib-Ende-Dateideskriptor, um Daten in die Pipe zu schreiben.
+    - Im **Kindprozess** wird entsprechend der Schreib-Ende-Dateideskriptor geschlossen, wenn er Daten vom Elternprozess lesen soll. Der Kindprozess verwendet dann den Lese-Ende-Dateideskriptor, um Daten aus der Pipe zu lesen.
+4. **Kommunikation Durchführen**: 
+    - Der **Elternprozess** schreibt Daten mit `write()`
+    - Der **Kindprozess** liest Daten wie `read()`
+5. **Pipe Schließen**: Schließen beider Enden der Pipe
+
+## Was ist das Client-Server-Modell?
+Client-Programme senden Anfragen an Server-Programme, die Ressourcen oder Dienste bereitstellen.
+
+## Beschreibe das Peer-to-Peer Modell (P2P).
+Teilnehmer (Peer) sowohl als Client als auch als Server fungiert. In einem P2P-Netzwerk kommunizieren Peers direkt miteinander, um Ressourcen wie Dateien oder Dienste ohne zentrale Koordination zu teilen und auszutauschen.
+
+## Was ist DBus?
+Desktop Bus (DBus) ist ein **Software-Bussystem**, was das mithören von Nachrichten anderer Teilnehmer (Prozesse) ermöglicht.
+Es erspart eine teure 1:1 Verbindung zwischen Kommunikationspartnern und wird für schmalbandige Kommunikation eingesetzt.
+
+## Wie werden Dienste über DBus addressiert?
+Über Namen (Well-Known Names)
\ No newline at end of file