Kernpunkte

• Ein Algorithmus ist eine endliche Folge von eindeutig ausführbaren Anweisungen zur Lösung einer Problemklasse (Knuth 1968).
• Algorithmen sind sprachunabhängig; eine Implementation ist ihre Umsetzung in einer konkreten Programmiersprache.
• Eigenschaften: Endlichkeit (statisch + dynamisch), Eindeutigkeit (Determinismus), Ausführbarkeit (jeder Schritt durchführbar), Allgemeinheit (Klasse von Eingaben).
• Eine Spezifikation beschreibt Vorbedingung (was darf erwartet werden), Nachbedingung (was wird garantiert) und ggf. Invarianten.
• Korrektheit zerfällt in partielle Korrektheit (Nachbedingung gilt, falls Programm terminiert) und totale Korrektheit (Programm terminiert zudem).
• Hoare-Tripel {P} S {Q} dokumentieren Beweise; gA-Niveau: informell, eA: Hoare-Kalkül.

Kernpunkte

• Drei strukturierte Grundbausteine nach Böhm-Jacopini: Sequenz, Selektion (if/else, switch), Iteration (while, for, do-while).
• Jeder Algorithmus lässt sich strukturiert (ohne goto) formulieren — Theorem von Böhm und Jacopini, 1966.
• Funktionen kapseln wiederverwendbaren Code; Parameter werden in Java per Wert (Primitive) bzw. per Referenz (Objekte) übergeben.
• Lokale Variablen leben nur innerhalb des Blocks; globale Variablen sind in Java vermieden (statische Felder als Ersatz).
• Schleifenbedingung wird vor jedem Durchlauf (while) oder nach jedem Durchlauf (do-while) ausgewertet; for-Schleife ist Spezialfall mit Init/Test/Update.
• Code-Beispiel: ```java int summe(int[] werte) { int s = 0; for (int x : werte) s += x; return s; } ```

Kernpunkte

• Eine rekursive Funktion ruft sich selbst auf; jede Rekursion benötigt mindestens einen Basisfall und einen Reduktionsschritt, der das Problem verkleinert.
• Beispiel Fakultät: ```java int fak(int n) { if (n <= 1) return 1; return n * fak(n - 1); } ```
• Rekursion nutzt den Aufrufstapel: jeder Aufruf hat einen eigenen Stack Frame mit Parametern und lokalen Variablen.
• Stack-Overflow tritt auf, wenn Rekursionstiefe den Stack erschöpft (Standard JVM: ca. 10⁴–10⁵ Frames).
• Endrekursion (tail recursion) kann theoretisch in eine Schleife transformiert werden; Java optimiert dies nicht automatisch (Kotlin/Scheme schon).
• Rekursion ist natürlich für rekursive Datenstrukturen (Bäume, Listen) und Divide-and-Conquer; Iteration ist meist effizienter und stackärmer.

Kernpunkte

• Bubble Sort: paarweises Vertauschen benachbarter Elemente; einfach, aber O(n²) — nur für Lehrzwecke.
• Insertion Sort: jedes neue Element wird in den sortierten Präfix eingefügt; O(n²) Worst, O(n) Best, stabil, in-place.
• Merge Sort: Divide-and-Conquer; teilt rekursiv, mischt sortierte Teilfolgen; O(n log n) garantiert, aber O(n) Zusatzspeicher.
• Quick Sort: Pivot-basiertes Partitionieren; Average O(n log n), Worst O(n²) bei schlechter Pivot-Wahl (z.B. vorsortiert + erstes Element).
• Stabilität bedeutet: gleiche Schlüssel behalten ihre Reihenfolge — wichtig für mehrstufiges Sortieren.
• Java verwendet TimSort (modifizierter Merge Sort) für `Arrays.sort` auf Objekten und Dual-Pivot-Quicksort für Primitive.
• Code Insertion Sort: ```java void insertionSort(int[] a) { for (int i = 1; i < a.length; i++) { int key = a[i], j = i - 1; while (j >= 0 && a[j] > key) { a[j+1] = a[j]; j--; } a[j+1] = key; } } ```

Kernpunkte

• Lineare Suche: durchläuft Array sequenziell, O(n); funktioniert auf unsortierten Daten.
• Binäre Suche: setzt sortiertes Array voraus; halbiert den Suchbereich rekursiv oder iterativ. O(log n).
• Code binäre Suche: ```java int binSuche(int[] a, int key) { int lo = 0, hi = a.length - 1; while (lo <= hi) { int m = (lo + hi) >>> 1; // overflow-safe if (a[m] == key) return m; if (a[m] < key) lo = m + 1; else hi = m - 1; } return -1; } ```
• Anwendungsfälle: Wörterbuchsuche, Telefonbuch, Datenbank-Indizes.
• Bei kleinen n (n < ca. 20) ist lineare Suche praktisch schneller — Cache-Vorteil.
• Hash-Tabellen liefern O(1) im Durchschnitt — wenn Eingaben nicht sortiert vorliegen müssen.

Kernpunkte

• O-Notation beschreibt asymptotische obere Schranke: f ∈ O(g) bedeutet, dass f höchstens proportional zu g wächst.
• Hierarchie: O(1) ⊂ O(log n) ⊂ O(n) ⊂ O(n log n) ⊂ O(n²) ⊂ O(2ⁿ) ⊂ O(n!).
• Beispiele: Indexzugriff O(1), Suche in BST O(log n) im Mittel, Sortieren mind. Ω(n log n) im Vergleichsmodell.
• Untere Schranke Ω(g) und exakte Schranke Θ(g) ergänzen die O-Notation.
• Amortisierte Analyse: Folge von Operationen wird im Mittel gewichtet — z.B. dynamisches Array O(1) amortisiert für append.
• Konstante Faktoren werden in der O-Notation ignoriert; in der Praxis können sie aber dominieren (Cache, Pipelining).

Kernpunkte

• Greedy: trifft in jedem Schritt lokal optimale Entscheidung; global optimal nur unter Matroid-Bedingungen (z.B. Kruskal, Huffman).
• Divide-and-Conquer: zerlegt rekursiv, löst Teilprobleme, kombiniert Lösungen (Mergesort, Strassen-Multiplikation, Quickhull).
• Backtracking: systematische Tiefensuche im Lösungsraum mit Rücknahme; Beispiele 8-Damen-Problem, Sudoku, SAT.
• Dynamische Programmierung: optimale Substruktur + überlappende Teilprobleme; Memoisierung (Top-Down) oder Tabelle (Bottom-Up).
• Beispiel DP — Fibonacci O(n) statt O(2ⁿ): ```python def fib(n): dp = [0, 1] for i in range(2, n+1): dp.append(dp[i-1] + dp[i-2]) return dp[n] ```
• Wahl der Strategie hängt von Problemstruktur ab: ohne optimale Substruktur kein DP, ohne Matroid kein Greedy.
• Querverweis: Divide-and-Conquer baut auf den rekursiven Datenstrukturen (Bäume, Graphen) des Topics Datenstrukturen auf; Greedy-Verfahren wie Dijkstra werden dort vertieft.

Kernpunkte

• Eine Klasse ist Bauplan, ein Objekt ist eine konkrete Instanz mit eigenem Zustand.
• Attribute beschreiben Zustand, Methoden beschreiben Verhalten. Konstruktoren initialisieren ein neu erzeugtes Objekt.
• Kapselung: Attribute sind `private`, Zugriff erfolgt über öffentliche Getter/Setter — schützt Invarianten und entkoppelt API von Implementation.
• Java-Skelett: ```java public class Konto { private double saldo; public Konto(double start) { this.saldo = start; } public void einzahlen(double b) { this.saldo += b; } public double getSaldo() { return this.saldo; } } ```
• Statische Felder/Methoden gehören zur Klasse, nicht zum Objekt — Beispiel `Math.PI`.
• `this` referenziert das aktuelle Objekt; in Python heißt das Pendant `self` und ist erstes Methodenargument.

Kernpunkte

• Vererbung (`extends`) etabliert eine Ist-ein-Beziehung; Unterklasse erbt Attribute/Methoden der Oberklasse und kann sie überschreiben (`@Override`).
• Polymorphie: derselbe Methodenaufruf hat je nach dynamischem Typ unterschiedliches Verhalten — Grundlage des dynamischen Bindens zur Laufzeit.
• Abstrakte Klassen (Java `abstract`) können nicht instanziiert werden und enthalten oft abstrakte Methoden, die Unterklassen implementieren müssen.
• Interfaces (Java `interface`) definieren reine Verhaltensverträge ohne Zustand; eine Klasse kann mehrere Interfaces implementieren — pragmatische Mehrfachvererbung.
• Beispiel Polymorphie: ```java Tier t = new Hund("Rex"); System.out.println(t.lautGeben()); // ruft Hund#lautGeben → "Wuff" ```
• LSP (Liskov-Substitutionsprinzip): Unterklasse darf Vertrag der Oberklasse nicht verschärfen — sonst Polymorphie brüchig.

Kernpunkte

• UML 2 ist Standard-Notation; Klassendiagramme kapseln Klassen in Dreifach-Rechtecken: Name, Attribute, Methoden.
• Sichtbarkeit: `+` public, `-` private, `#` protected, `~` package.
• Beziehungen: Assoziation (Linie), Aggregation (offene Raute, Teil-Ganzes, schwach), Komposition (gefüllte Raute, starkes Teil-Ganzes), Vererbung (offene Pfeilspitze zur Oberklasse), Realisierung (gestrichelter Pfeil, Interface).
• Multiplizitäten an den Enden: `1`, `0..1`, ``, `1..` — beschreiben Kardinalität der Beziehung.
• CRC-Karten (Class-Responsibility-Collaboration) sind Vorstufe für Modellierung im Team; jede Karte trägt Klassenname, Verantwortlichkeiten, Kollaborateure.
• Sequenzdiagramme dokumentieren Nachrichtenfluss zwischen Objekten über die Zeitachse — ergänzen Klassendiagramme um dynamische Sicht.

Kernpunkte

• Entwurfsmuster (Gamma et al. 1994 — Gang of Four) lösen wiederkehrende Probleme strukturell und sind sprachunabhängig.
• Singleton: garantiert genau eine Instanz; kritisch wegen globalem Zustand und Testbarkeit.
• Observer: Subjekt benachrichtigt Beobachter über Zustandsänderungen — Grundlage für MVC, Event-Bus, reaktive UIs.
• Strategy: kapselt austauschbare Algorithmen hinter einer gemeinsamen Schnittstelle — Vergleich mit polymorpher Substitution.
• Factory Method: delegiert Objekterzeugung an Unterklassen; entkoppelt Client von konkreter Klasse.
• SOLID-Prinzipien (Single Responsibility, Open/Closed, Liskov, Interface Segregation, Dependency Inversion) sind Qualitätsleitlinien für OOP-Design.
• Querverweis: Das Strategy-Muster kapselt austauschbare Algorithmen aus dem Topic Algorithmen und Programmierung (z.B. Sortierverfahren) und verbindet so OOP-Struktur mit algorithmischer Variation.

Kernpunkte

• Klassische Phasenmodelle: Wasserfall (sequenziell, dokumentationsstark), V-Modell (jede Entwicklungsphase hat korrespondierende Teststufe).
• Agile Modelle: Scrum (Sprints, Product/Sprint Backlog, Daily Stand-up), Kanban (kontinuierlicher Fluss, Work-in-Progress-Limits).
• Versionierung mit Git: Commit, Branch, Merge, Pull-Request; verteiltes Modell ermöglicht parallel arbeitende Teams.
• Testarten: Unit-Tests (Methodenebene, JUnit/pytest), Integrationstests (Modulinteraktion), Systemtests (End-to-End), Abnahmetests (User).
• Testabdeckung: Anweisungs-, Zweig-, Pfadüberdeckung — höhere Abdeckung ≠ automatisch mehr Qualität.
• Continuous Integration: Tests laufen bei jedem Commit automatisch — Beispiel GitHub Actions, GitLab CI.

Kernpunkte

• Während ein Klassendiagramm die statische Struktur zeigt, beschreiben Objekt-, Sequenz- und Zustandsdiagramme das dynamische Verhalten zur Laufzeit.
• Ein Objektdiagramm ist eine Momentaufnahme: konkrete Instanzen (`k1:Kunde`) mit belegten Attributwerten und ihren aktuellen Verknüpfungen (Links).
• Ein Sequenzdiagramm stellt den Nachrichtenfluss zwischen Objekten über die Zeitachse dar: Lebenslinien, Aktivierungsbalken, synchrone (durchgezogen) und Rückgabe-Nachrichten (gestrichelt).
• Ein Zustandsdiagramm (Statechart) modelliert die Zustände eines Objekts und die durch Ereignisse ausgelösten Übergänge (z.B. Bestellung: offen → bezahlt → versandt → abgeschlossen).
• Übergänge tragen die Form `Ereignis [Bedingung] / Aktion`; Start- (gefüllter Kreis) und Endzustand (Ring um Kreis) rahmen das Diagramm.
• Die Diagrammtypen ergänzen sich: Klassendiagramm (Struktur), Sequenzdiagramm (Interaktion), Zustandsdiagramm (Lebenszyklus eines Objekts).

Kernpunkte

• Array (statisch): O(1)-Zugriff per Index, O(n)-Einfügen/Löschen wegen Verschiebung. Feste Größe in Java (`int[]`).
• Verkettete Liste: jedes Element zeigt auf seinen Nachfolger; O(1)-Einfügen/Löschen am Kopf, O(n)-Zugriff.
• Stack (LIFO): Operationen `push`, `pop`, `peek` — z.B. Methoden-Aufrufstack, Klammerprüfung, Rückgängig-Funktion.
• Queue (FIFO): Operationen `enqueue`, `dequeue` — z.B. Drucker-Warteschlange, BFS-Frontier.
• Deque (doppelt verkettet) kombiniert Stack- und Queue-Operationen mit O(1) an beiden Enden.
• Skelett verkettete Liste: ```java class Knoten<T> { T wert; Knoten<T> next; } class Liste<T> { Knoten<T> kopf; void einfuegenKopf(T x) { Knoten<T> n = new Knoten<>(); n.wert = x; n.next = kopf; kopf = n; } } ```

Kernpunkte

• Ein Binärbaum hat je Knoten höchstens zwei Kinder; Tiefe d, Höhe h, vollständig wenn alle Ebenen bis auf evtl. die letzte gefüllt.
• Binärer Suchbaum (BST): links < Knoten < rechts; Operationen suchen/einfügen/löschen in O(h), bei Entartung O(n).
• Traversierungen: Preorder (Wurzel-Links-Rechts), Inorder (Links-Wurzel-Rechts — liefert sortierte Reihenfolge bei BST), Postorder (Links-Rechts-Wurzel), Levelorder (BFS).
• Balancierung: AVL- oder Rot-Schwarz-Bäume halten Höhe in O(log n); Java `TreeMap` nutzt Rot-Schwarz.
• Heap: vollständiger Binärbaum mit Heap-Bedingung; Grundlage für Priority Queue und Heapsort, O(log n) je Operation.
• Code-Skelett BST: ```java Knoten suchen(Knoten n, int key) { if (n == null || n.wert == key) return n; return key < n.wert ? suchen(n.links, key) : suchen(n.rechts, key); } ```

Kernpunkte

• Ein Graph G = (V, E) besteht aus Knotenmenge V und Kantenmenge E; gerichtet/ungerichtet, gewichtet/ungewichtet, zyklisch/azyklisch.
• Repräsentation: Adjazenzmatrix (|V|² Speicher, O(1)-Kantencheck) oder Adjazenzliste (sparsamer für dünne Graphen).
• Breitensuche (BFS): nutzt Queue, findet kürzeste Pfade in ungewichteten Graphen, Laufzeit O(|V| + |E|).
• Tiefensuche (DFS): nutzt Stack/Rekursion, erzeugt Spannbaum, klassifiziert Kanten in Baum-, Rück-, Vorwärts-, Querkante.
• Dijkstra-Algorithmus: kürzeste Pfade in gewichteten Graphen mit nicht-negativen Kanten; mit Priority Queue O((|V| + |E|) log |V|).
• Anwendungen: Routenplanung (Dijkstra/A*), soziale Netzwerke, Compiler (Abhängigkeitsgraph), Webcrawler.
• Querverweis: Dijkstra ist ein Greedy-Verfahren (Topic Algorithmen und Programmierung) und nutzt die Priority Queue aus dem Abschnitt Heaps dieses Topics.

Kernpunkte

• Eine Hashfunktion bildet Schlüssel auf einen Bucket-Index ab; gut, wenn sie gleichmäßig verteilt und schnell berechenbar ist.
• Kollisionsbehandlung: Separate Chaining (Bucket enthält verkettete Liste) vs. Open Addressing (linear/quadratic probing, double hashing).
• Lastfaktor α = n / m mit n Elementen und m Buckets; bei α > 0.75 typischerweise Rehashing auf doppelte Buckets.
• Durchschnittliche Laufzeit O(1) für put/get/remove; im Worst-Case (alle kollidieren) degeneriert zu O(n).
• Java `HashMap` nutzt seit Java 8 ab Schwelle 8 einen Rot-Schwarz-Baum statt verketteter Liste pro Bucket — verhindert DoS-Angriffe durch Hash-Kollisionen.
• Anwendungen: Datenbank-Indizes, Caches, Set-Datentyp, Deduplizierung.

Kernpunkte

• Ein abstrakter Datentyp (ADT) definiert eine Menge von Werten zusammen mit Operationen, ohne die Implementation festzulegen — Trennung von Was (Spezifikation) und Wie (Realisierung).
• Beispiel ADT Stack: `push(x)`, `pop()`, `peek()`, `isEmpty()` — die Schnittstelle ist unabhängig davon, ob ein Array oder eine verkettete Liste zugrunde liegt.
• In Java realisiert ein Interface den ADT-Vertrag; in Python erfüllt eine Klasse implizit ein Protokoll über die erwarteten Methoden („Duck Typing").
• Generische Typen (Java `<T>`, Python Type Hints) erlauben typsichere, wiederverwendbare Container ohne Casts: `Stack<String>` vs. `Stack<Integer>`.
• Vorteile der ADT-Sicht: austauschbare Implementation, lokal begrenzte Änderungen, klar prüfbare Invarianten, leichtere Wiederverwendung.
• Wahl der zugrunde liegenden Struktur richtet sich nach dem dominanten Zugriffsmuster (wahlfreier Zugriff → Array; häufiges Einfügen am Anfang → verkettete Liste).
• ADT-Skelett: ```java interface Stapel<T> { void push(T x); T pop(); boolean isEmpty(); } ```

Kernpunkte

• Ein Binär-Heap ist ein vollständiger Binärbaum mit Heap-Bedingung: im Min-Heap ist jeder Knoten ≤ seine Kinder, im Max-Heap ≥.
• Speicherung im Array: für Index i liegt das linke Kind bei 2i+1, das rechte bei 2i+2, der Vater bei ⌊(i−1)/2⌋ — kein Zeiger-Overhead.
• Priority Queue: liefert stets das Element höchster (bzw. niedrigster) Priorität; Standard-Implementation ist ein Heap mit O(log n) für Einfügen und Entfernen.
• Operationen: `insert` (Element ans Ende, dann sift-up), `extractMin/Max` (Wurzel entnehmen, letztes Element an die Spitze, dann sift-down).
• Heapsort: Array zum Max-Heap aufbauen (O(n) per Floyd-Heapify), dann wiederholt Wurzel ans Ende tauschen — Gesamtlaufzeit O(n log n), in-place, aber nicht stabil.
• Anwendungen: Dijkstra/A* (Knotenpriorität), Ereignissimulation, Task-Scheduler, Top-k-Auswahl, Median-Streaming (zwei Heaps).
• Java stellt `PriorityQueue<E>` bereit; standardmäßig ein Min-Heap über die natürliche Ordnung oder einen Comparator.

Kernpunkte

• Entity-Relationship-Modell (Chen 1976): Entität (Rechteck), Attribut (Ellipse), Beziehung (Raute), Schlüsselattribut unterstrichen.
• Kardinalitäten: 1:1, 1:n, n:m — beschreiben, wie viele Instanzen einer Entität an einer Beziehung teilnehmen.
• Min-Max-Notation präzisiert: (1,1) genau einmal, (0,*) optional beliebig oft.
• Schwache Entitäten existieren nur mit zugeordneter starker Entität (z.B. Rechnungsposition zu Rechnung).
• Spezialisierung/Generalisierung modellieren Vererbung im ER (analog OOP-Klassenhierarchie).
• Vor der Implementation immer ein ER-Diagramm zeichnen — verhindert Datenredundanz und Anomalien.

Kernpunkte

• Eine Relation ist eine Menge von Tupeln mit festem Schema; Primärschlüssel identifiziert eindeutig, Fremdschlüssel verweist auf Primärschlüssel einer anderen Relation.
• Überführung ER → Relationenmodell: Jede Entität wird Tabelle; 1:n-Beziehung integriert Fremdschlüssel in „n"-Seite; n:m-Beziehung wird eigene Verknüpfungstabelle.
• 1. Normalform (1NF): alle Attributwerte atomar — keine Listen, keine Mehrfachwerte.
• 2. Normalform (2NF): 1NF + jedes Nicht-Schlüsselattribut hängt voll vom Primärschlüssel ab (relevant bei zusammengesetzten Schlüsseln).
• 3. Normalform (3NF): 2NF + keine transitiven Abhängigkeiten (kein Nicht-Schlüssel-Attribut hängt von einem anderen Nicht-Schlüssel-Attribut ab).
• Normalisierung reduziert Redundanz und vermeidet Update-/Insert-/Delete-Anomalien — kann aber Joins verlangsamen.
• Querverweis: Die ER-Spezialisierung/Generalisierung entspricht der Vererbungshierarchie aus dem Topic Objektorientierte Modellierung; ein ER-Modell lässt sich analog zum UML-Klassendiagramm lesen.

Kernpunkte

• SQL gliedert sich in DDL (CREATE, ALTER, DROP), DML (SELECT, INSERT, UPDATE, DELETE) und DCL (GRANT, REVOKE).
• SELECT-Struktur: ```sql SELECT spalten FROM tabelle WHERE bedingung GROUP BY spalte HAVING aggregat-bedingung ORDER BY spalte ASC|DESC; ```
• Aggregatfunktionen: COUNT, SUM, AVG, MIN, MAX — meist kombiniert mit GROUP BY.
• LIKE mit `%` (beliebig viele Zeichen) und `_` (genau ein Zeichen) für Mustersuche.
• NULL ist nicht gleich leerer String — Prüfung mit `IS NULL`/`IS NOT NULL`, niemals `= NULL`.
• Beispiel: ```sql SELECT KundenNr, SUM(Betrag) AS Umsatz FROM Bestellung WHERE Datum >= '2025-01-01' GROUP BY KundenNr HAVING SUM(Betrag) > 1000 ORDER BY Umsatz DESC; ```

Kernpunkte

• INNER JOIN: nur Tupel mit Match in beiden Tabellen.
• LEFT OUTER JOIN: alle Tupel der linken Tabelle, NULL bei fehlendem Match rechts; analog RIGHT/FULL.
• CROSS JOIN = kartesisches Produkt; selten direkt verwendet.
• Theta-Join wird in der Relationenalgebra als σ(R × S) formuliert — Equi-Join ist Spezialfall mit Gleichheitsprädikat.
• Subqueries: skalar (liefern einen Wert), zeilenweise (`IN`, `EXISTS`), korreliert (Outer-Query-Referenz in Inner-Query).
• Indizes beschleunigen WHERE/JOIN auf indexierten Spalten in O(log n), kosten aber Schreibperformance — typisch B-Baum, in MySQL auch Hash-Index.

Kernpunkte

• DSGVO (EU-Verordnung 2016/679, gilt seit Mai 2018) regelt Verarbeitung personenbezogener Daten; Verstöße bis 4 % Jahresumsatz oder 20 Mio. €.
• Grundprinzipien: Rechtmäßigkeit, Zweckbindung, Datenminimierung, Richtigkeit, Speicherbegrenzung, Integrität, Rechenschaftspflicht.
• Rechte der Betroffenen: Auskunft (Art. 15), Berichtigung (Art. 16), Löschung (Art. 17), Datenübertragbarkeit (Art. 20), Widerspruch (Art. 21).
• Privacy by Design / Privacy by Default verlangen datenschutzfreundliche Voreinstellungen und systemische Schutzmaßnahmen.
• Pseudonymisierung (Re-Identifikation möglich mit Schlüssel) vs. Anonymisierung (irreversibel) — nur Anonymisierung entzieht der DSGVO.
• Verschlüsselung at-rest (Datenbank) und in-transit (TLS) sind Standardmaßnahmen.

Kernpunkte

• Eine Transaktion ist eine logisch zusammengehörige Folge von Datenbankoperationen, die atomar ausgeführt werden — Beispiel: Überweisung als Abbuchung + Gutschrift.
• ACID: Atomarität (alles oder nichts), Konsistenz (Integritätsbedingungen bleiben gewahrt), Isolation (parallele Transaktionen stören sich nicht), Dauerhaftigkeit (bestätigte Änderungen überdauern Abstürze).
• Abschluss über `COMMIT` (dauerhaft schreiben) oder `ROLLBACK` (alle Änderungen verwerfen); ein Recovery-Manager stellt nach Absturz den konsistenten Zustand her (Logging, WAL).
• Im Mehrbenutzerbetrieb entstehen Anomalien: Lost Update, Dirty Read, Non-Repeatable Read, Phantom Read — sie werden durch Isolationsstufen gesteuert.
• Isolationsstufen (ANSI): Read Uncommitted, Read Committed, Repeatable Read, Serializable — höhere Stufen schließen mehr Anomalien aus, kosten aber Parallelität.
• Sperrverfahren: Zwei-Phasen-Sperrprotokoll (2PL) garantiert Serialisierbarkeit; Sperren können zu Deadlocks führen, die per Timeout oder Wartegraph aufgelöst werden.
• SQL-Beispiel: ```sql BEGIN TRANSACTION; UPDATE Konto SET Saldo = Saldo - 100 WHERE Nr = 1; UPDATE Konto SET Saldo = Saldo + 100 WHERE Nr = 2; COMMIT; ```

Kernpunkte

• Ein von-Neumann-Rechner (1945) besteht aus CPU (Steuerwerk + Rechenwerk + Register), Hauptspeicher, Bussystem und Ein-/Ausgabeeinheit.
• von-Neumann-Prinzip: Programm und Daten teilen sich denselben Speicher — flexibel, aber Engpass („von-Neumann-Bottleneck").
• Befehlszyklus: Fetch (Befehl laden) → Decode (entschlüsseln) → Execute (ausführen); Steuerwerk taktet.
• Harvard-Architektur trennt Programm- und Datenspeicher — schneller, aber teurer; in DSPs und Mikrocontrollern eingesetzt.
• Cache-Hierarchie: L1 (Größe ~64 KiB, ~1 ns), L2 (~MiB, ~5 ns), L3 (~zig MiB, ~15 ns), Hauptspeicher (GiB, ~100 ns).
• Beispiel Maschinencode (vereinfachter Pseudo-Assembler): ``` LOAD R1, 100 ; lade Wert aus Adresse 100 ADD R1, R2 ; addiere R2 zu R1 STORE R1, 200 ; speichere Ergebnis ```

Kernpunkte

• OSI-Referenzmodell (ISO 1984): 7 Schichten — Physical, Data Link, Network, Transport, Session, Presentation, Application.
• TCP/IP-Modell (DARPA): 4 Schichten — Network Access (entspricht OSI 1–2), Internet (OSI 3), Transport (OSI 4), Application (OSI 5–7).
• Jede Schicht abstrahiert nach unten und bietet eine API nach oben; Pakete werden je Schicht mit Header verkapselt (Encapsulation).
• Schicht 3 (Network): IP — adressiert Pakete weltweit; verbindungslos, best-effort.
• Schicht 4 (Transport): TCP (zuverlässig, verbindungsorientiert, 3-Wege-Handshake) vs. UDP (verbindungslos, schnell, ohne Garantie).
• Schicht 7: Application — HTTP/HTTPS, SMTP, IMAP, DNS, FTP, SSH.
• Querverweis: Die Sicherung der Anwendungsschicht durch HTTPS/TLS greift auf die asymmetrischen Verfahren und Zertifikate aus dem Topic Kryptographie und IT-Sicherheit zurück.

Kernpunkte

• IPv4-Adresse: 32 Bit, vier dezimale Oktette (z.B. 192.168.1.42); Subnetzmaske trennt Netz- von Host-Teil.
• CIDR-Notation `/p` gibt Präfixlänge an; `/24` entspricht 255.255.255.0 und liefert 2^(32−24) − 2 = 254 nutzbare Hosts (−2 wegen Netz- und Broadcast-Adresse).
• Private Adressbereiche (RFC 1918): 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 — nicht im öffentlichen Internet routbar.
• NAT übersetzt private IPs in eine öffentliche; Standard für Heim-Router. Reduziert IPv4-Knappheit, bricht aber Ende-zu-Ende-Kommunikation.
• IPv6 (128 Bit) löst die Knappheit; Notation in acht Hex-Gruppen, Verkürzung mit `::` möglich.
• Beispielrechnung Subnetting: 192.168.10.0/24 in vier Subnetze à /26 → 64 Adressen, 62 Hosts pro Subnetz.

Kernpunkte

• Ein Betriebssystem verwaltet Hardware-Ressourcen (CPU, Speicher, E/A) und stellt Prozessen eine abstrakte, geschützte Ausführungsumgebung bereit.
• Ein Prozess ist ein Programm in Ausführung mit eigenem Adressraum; ein Thread ist ein Ausführungsstrang innerhalb eines Prozesses und teilt dessen Speicher.
• Prozesszustände: bereit, rechnend, blockiert; der Scheduler entscheidet, welcher bereite Prozess die CPU erhält (Dispatch), das Quantum-Ende erzwingt einen Timeout.
• Scheduling-Strategien: FCFS (First-Come-First-Served, fair, aber Konvoi-Effekt), SJF (Shortest-Job-First, minimiert mittlere Wartezeit, aushungernd), Round-Robin (Zeitscheibe q, interaktiv), prioritätsbasiert.
• Verklemmung (Deadlock) entsteht bei wechselseitigem Ressourcen-Warten; die vier Coffman-Bedingungen (gegenseitiger Ausschluss, Hold-and-Wait, keine Verdrängung, zyklisches Warten) müssen gleichzeitig gelten.
• Synchronisation paralleler Threads über Semaphore, Monitor oder Mutex verhindert Race Conditions auf gemeinsamen Daten (kritischer Abschnitt).
• Virtueller Speicher trennt logische von physischen Adressen; Paging lagert nicht benötigte Seiten aus (Page Fault → Nachladen).

Kernpunkte

• TCP ist verbindungsorientiert, zuverlässig und reihenfolgetreu; der Drei-Wege-Handshake (SYN, SYN-ACK, ACK) baut die Verbindung mit synchronisierten Sequenznummern auf.
• TCP-Mechanismen: Flusskontrolle (Sliding Window), Staukontrolle (Slow Start, Congestion Avoidance), Sequenz-/Bestätigungsnummern, Retransmission bei Timeout.
• UDP ist verbindungslos, ohne Garantie für Auslieferung oder Reihenfolge — minimaler Overhead, geeignet für DNS, VoIP, Streaming, Online-Spiele.
• Ein Port (16 Bit, 0–65535) adressiert den Dienst; Well-Known-Ports: 80 (HTTP), 443 (HTTPS), 22 (SSH), 25 (SMTP), 53 (DNS).
• Ein Socket ist das Endpunkt-Paar (IP-Adresse, Port); eine TCP-Verbindung ist durch das 4-Tupel (Quell-IP, Quell-Port, Ziel-IP, Ziel-Port) eindeutig.
• Verbindungsabbau über FIN/ACK in beide Richtungen; der TIME_WAIT-Zustand verhindert, dass verspätete Pakete eine neue Verbindung stören.

Kernpunkte

• Eine Firewall filtert Datenverkehr nach Regeln; Paketfilter prüfen Header (IP, Port, Protokoll), Stateful Inspection verfolgt zusätzlich den Verbindungszustand.
• NAT (Network Address Translation) übersetzt private auf öffentliche Adressen; PAT/Masquerading multiplext viele interne Hosts über eine öffentliche IP per Portzuordnung.
• DNS löst Domainnamen in IP-Adressen auf — hierarchisch über Root-, TLD- und autoritative Server; Caching beschleunigt, birgt aber DNS-Spoofing-Risiken (Gegenmaßnahme DNSSEC).
• Ein VPN baut einen verschlüsselten Tunnel über ein unsicheres Netz (IPsec, WireGuard, OpenVPN) — schützt Vertraulichkeit und ermöglicht Fernzugriff auf interne Netze.
• TLS sichert die Anwendungsschicht durch Server-Authentifizierung (Zertifikat), Schlüsselaustausch (DH/ECDHE) und symmetrische Verschlüsselung der Nutzdaten.
• Verteidigung in der Tiefe kombiniert Firewall, Segmentierung (DMZ), IDS/IPS, Verschlüsselung und Patch-Management; kein Einzelmechanismus genügt.

Kernpunkte

• Ein deterministischer endlicher Automat (DEA) ist ein 5-Tupel (Q, Σ, δ, q₀, F): Zustandsmenge, Alphabet, Übergangsfunktion δ: Q×Σ → Q, Startzustand, akzeptierende Zustände.
• Nichtdeterministischer endlicher Automat (NEA): δ: Q×Σ → 𝒫(Q); akzeptiert, wenn mindestens ein Pfad in einen F-Zustand führt. NEA und DEA erkennen exakt dieselben Sprachen (reguläre Sprachen).
• Reguläre Ausdrücke beschreiben reguläre Sprachen kompakt: `a*`, `(ab|ba)+`, `[0-9]{3,5}`.
• Konversion NEA → DEA durch Potenzmengenkonstruktion (Subset Construction); Worst-Case 2^|Q| Zustände.
• Anwendungen: Lexikalische Analyse in Compilern, Mustererkennung (grep), Protokoll-Validierung.
• DEA für L = {w ∈ {a,b}* | w endet auf ab}: q0 (Start), q1 (zuletzt a), q2 (zuletzt ab, akzeptierend).

Kernpunkte

• Eine formale Grammatik ist 4-Tupel (V, Σ, P, S): Variablen (Nichtterminale), Terminale, Produktionen, Startsymbol.
• Chomsky-Hierarchie (1956): • Typ 0 (rekursiv aufzählbar) — Turing-Maschine • Typ 1 (kontextsensitiv) — linear beschränkter Automat • Typ 2 (kontextfrei) — Kellerautomat • Typ 3 (regulär) — endlicher Automat
• Beispiel kontextfreie Sprache: L = {aⁿbⁿ | n ≥ 1}, Grammatik S → aSb | ab — nicht regulär (Pumping-Lemma).
• Backus-Naur-Form (BNF) beschreibt kontextfreie Grammatiken kompakt; verwendet in Sprachspezifikationen (z.B. JSON, ECMAScript).
• Ableitungsbaum visualisiert die Erzeugung eines Wortes; Mehrdeutigkeit führt zu mehreren Bäumen für dasselbe Wort.
• Anwendung: Parser im Compilerbau, Syntaxprüfung, BNF-Spezifikation von Programmiersprachen.

Kernpunkte

• Eine Turingmaschine (Turing 1936) hat unendliches Band, Lese-/Schreibkopf und endliche Steuerung; modelliert intuitiv das Berechenbare.
• Church-Turing-These: jede intuitiv berechenbare Funktion ist Turing-berechenbar. Nicht beweisbar, aber empirisch unbestritten.
• Entscheidbarkeit: Eine Sprache L ist entscheidbar, wenn eine Turingmaschine für jedes Wort terminiert und „akzeptiert/verwirft" ausgibt.
• Halteproblem: Frage, ob beliebiges Programm P bei Eingabe w hält. Turing 1936: unentscheidbar — keine total berechenbare Funktion H entscheidet dies.
• Beweisidee (Diagonalisierung): konstruiere Programm D, das das Gegenteil von H(P, P) tut → Widerspruch bei D(D).
• Konsequenz: Statische Analyse hat fundamentale Grenzen; z.B. Reachability, Äquivalenz von Programmen sind unentscheidbar (Satz von Rice).

Kernpunkte

• P = Menge der Sprachen, die in polynomieller Zeit deterministisch entscheidbar sind.
• NP = Menge der Sprachen, deren Lösungskandidaten in polynomieller Zeit verifiziert werden können (äquivalent: nichtdeterministisch polynomiell entscheidbar).
• P ⊆ NP — die offene Frage „P = NP?" gehört zu den sieben Millennium-Problemen (Clay Mathematics Institute 2000).
• NP-vollständig: schwerste Probleme in NP; eine effiziente Lösung würde alle NP-Probleme effizient lösen. Cook-Levin (1971): SAT ist NP-vollständig.
• Beispiele NP-vollständig: SAT, 3-SAT, Travelling Salesman (Entscheidungsversion), Vertex Cover, Subset Sum, Sudoku.
• Praktische Konsequenz: Für NP-vollständige Probleme nutzt man Heuristiken, Approximationsalgorithmen oder Constraint-Solver, kein effizientes Verfahren bekannt.

Kernpunkte

• Ein Kellerautomat (PDA) erweitert den endlichen Automaten um einen Stapel (Keller); er erkennt genau die kontextfreien Sprachen (Typ 2).
• Konfiguration: aktueller Zustand, restliche Eingabe, Kellerinhalt; Übergänge dürfen das oberste Kellersymbol lesen, ersetzen oder entfernen.
• Beispiel L = {aⁿbⁿ | n ≥ 1}: jedes gelesene `a` legt ein Symbol auf den Keller, jedes `b` entfernt eines; Akzeptanz bei leerem Keller — ein DEA kann das nicht (kein Gedächtnis für die Anzahl).
• Das Pumping-Lemma für reguläre Sprachen ist ein notwendiges Kriterium: für jede reguläre Sprache existiert ein n, sodass jedes Wort z mit |z| ≥ n in z = uvw mit |uv| ≤ n, |v| ≥ 1 und uvⁱw ∈ L für alle i ≥ 0 zerlegt werden kann.
• Es dient dem Widerspruchsbeweis der Nicht-Regularität: Annahme regulär → Zerlegung → ein „aufgepumptes" Wort verlässt die Sprache → Widerspruch.
• Für kontextfreie Sprachen gibt es ein eigenes Pumping-Lemma (z = uvwxy); damit zeigt man z.B., dass L = {aⁿbⁿcⁿ} nicht kontextfrei ist.

Kernpunkte

• Die Kleene-Äquivalenz besagt: reguläre Ausdrücke, NEA und DEA beschreiben exakt dieselbe Sprachklasse (die regulären Sprachen) und lassen sich ineinander überführen.
• Konstruktion regulärer Ausdruck → NEA (Thompson-Konstruktion), NEA → DEA (Potenzmengenkonstruktion), DEA → regulärer Ausdruck (Zustandselimination).
• Minimierung eines DEA: unerreichbare Zustände entfernen, dann äquivalente Zustände verschmelzen (Tabellenfüllverfahren bzw. Myhill-Nerode-Klassen).
• Der Satz von Myhill-Nerode charakterisiert reguläre Sprachen über die Anzahl der Äquivalenzklassen der Rechtskongruenz; endlich viele Klassen ⇔ regulär.
• Der minimale DEA ist bis auf Umbenennung der Zustände eindeutig — nützlich für den Äquivalenznachweis zweier Automaten.
• Anwendungen: Optimierung von Lexern/Scannern, Mustererkennung (RegEx-Engines), Verifikation endlicher Protokollautomaten.

Kernpunkte

• Symmetrische Verfahren nutzen denselben geheimen Schlüssel für Ver- und Entschlüsselung; Schlüssel muss sicher ausgetauscht werden.
• Caesar-Chiffre: Verschiebung jedes Buchstabens um k Positionen — historisch, kryptografisch trivial (Schlüsselraum nur 25).
• Vigenère-Chiffre: Caesar mit periodischem Schlüsselwort — bis 19. Jh. „unbrechbar", bricht durch Friedman/Kasiski-Test.
• One-Time-Pad: Schlüssel so lang wie Klartext, einmalig — beweisbar sicher (Shannon 1949), praktisch unhandlich.
• AES (Advanced Encryption Standard, Rijndael, 2001): Block-Chiffre mit 128/192/256-Bit-Schlüsseln; Standard für TLS, Festplattenverschlüsselung.
• Betriebsmodi: ECB (unsicher, gleiche Blöcke → gleicher Cipher), CBC (Verkettung), CTR (Zählermodus, parallelisierbar), GCM (auth. encryption).

Kernpunkte

• Asymmetrische Verfahren verwenden ein Schlüsselpaar: öffentlicher Schlüssel (verschlüsseln/verifizieren) und privater Schlüssel (entschlüsseln/signieren).
• RSA (Rivest, Shamir, Adleman 1977): Sicherheit beruht auf Schwierigkeit der Faktorisierung großer Zahlen n = p·q.
• Schlüsselerzeugung: 1) Primzahlen p, q wählen, 2) n = p·q, φ(n) = (p−1)(q−1), 3) e mit ggT(e, φ(n)) = 1, 4) d mit e·d ≡ 1 mod φ(n).
• Verschlüsselung c ≡ mᵉ mod n; Entschlüsselung m ≡ cᵈ mod n. Korrektheit folgt aus Satz von Euler.
• Diffie-Hellman-Schlüsseltausch: Alice und Bob einigen sich öffentlich auf gemeinsamen Schlüssel, ohne ihn zu übertragen — Sicherheit beruht auf diskretem Logarithmus.
• Praktisch: RSA mit ≥ 2048 Bit; für kleine Schulbeispiele p, q ≤ 13 mit kleinen Primzahlen rechnen.
• Querverweis: Die Sicherheit von RSA setzt voraus, dass die Faktorisierung kein effizientes Verfahren besitzt — ein hypothetischer Beweis P = NP (Topic Theoretische Informatik) würde das Verfahren gefährden.

Kernpunkte

• Eine kryptografische Hashfunktion H: {0,1}* → {0,1}ⁿ ist Einweg, kollisionsresistent und deterministisch — Beispiele SHA-256, SHA-3.
• Eigenschaften: Pre-Image-Resistenz, 2nd-Pre-Image-Resistenz, Kollisionsresistenz; MD5 und SHA-1 gelten als gebrochen.
• HMAC (Hash-based Message Authentication Code) kombiniert Hash mit geheimem Schlüssel — schützt Integrität und Authentizität.
• Digitale Signatur: Hash der Nachricht wird mit Sender-PrivKey verschlüsselt; Empfänger verifiziert mit Sender-PubKey.
• Hashfunktionen werden auch für Passwortspeicherung verwendet — mit Salt und langsamer KDF (bcrypt, Argon2, PBKDF2) gegen Rainbow-Table-Angriffe.
• Anwendungsbereiche: Git-Commits, Blockchain (Hash-Verkettung), Code-Signaturen, Zertifikate.

Kernpunkte

• Shannon-Entropie H(X) = −Σ pᵢ log₂ pᵢ misst den mittleren Informationsgehalt einer Quelle in Bit pro Symbol.
• Untere Schranke der verlustfreien Kompression: keine Codierung kommt unter H(X) Bit/Symbol.
• Präfixcode: kein Codewort ist Präfix eines anderen — eindeutig dekodierbar ohne Trennzeichen.
• Huffman-Codierung (1952): konstruiert optimalen Präfixcode bottom-up aus den Symbolwahrscheinlichkeiten; mittlere Codelänge L̄ erfüllt H(X) ≤ L̄ < H(X) + 1.
• Algorithmus: in jeder Runde die zwei kleinsten Wahrscheinlichkeiten zu einem neuen Knoten zusammenfassen, bis ein Baum entsteht.
• Anwendung: ZIP/Deflate (mit LZ77 kombiniert), JPEG, MP3 (in spezifischen Stufen), Hardware-Codecs.

Kernpunkte

• Das Schlüsselaustauschproblem symmetrischer Verfahren: Wie vereinbaren zwei Parteien einen geheimen Schlüssel über einen unsicheren Kanal?
• Diffie-Hellman löst dies: aus öffentlichen Werten g, p, A, B berechnen beide denselben Schlüssel g^(ab) mod p, ohne ihn zu übertragen — Sicherheit beruht auf dem diskreten Logarithmus.
• Hybride Verschlüsselung kombiniert asymmetrisch (Schlüsseltausch) und symmetrisch (Massendaten): RSA/DH transportiert einen AES-Sitzungsschlüssel, AES verschlüsselt dann effizient.
• Eine Public-Key-Infrastruktur (PKI) bindet öffentliche Schlüssel an Identitäten über Zertifikate (X.509), die von einer Zertifizierungsstelle (CA) signiert werden.
• Vertrauensketten: ein Wurzelzertifikat (im Betriebssystem/Browser vorinstalliert) signiert Zwischenzertifikate, die wiederum Server-Zertifikate signieren — Validierung entlang der Kette.
• Bedrohung Man-in-the-Middle: ungeschützter DH ist anfällig; erst die Authentifizierung über Zertifikate (im TLS-Handshake) bindet den Schlüssel an die echte Gegenstelle.

Kernpunkte

• Stellenwertsysteme: Dual (Basis 2), Oktal (8), Dezimal (10), Hexadezimal (16); Umrechnung über fortlaufende Division (Dezimal → Basis) bzw. Wertigkeitssumme.
• Eine Hex-Ziffer fasst vier Bit zusammen (0xB = 1011) — kompakte Schreibweise für Bytes (zwei Hex-Ziffern = 8 Bit).
• Zweierkomplement stellt negative Ganzzahlen dar: Bits invertieren und 1 addieren; das höchste Bit hat die Wertigkeit −2^(n−1). Vorteil: Addition funktioniert ohne Sonderbehandlung des Vorzeichens.
• Wertebereich n-Bit-Zweierkomplement: −2^(n−1) bis 2^(n−1) − 1; Überlauf entsteht, wenn das Ergebnis außerhalb liegt.
• Gleitkommazahlen nach IEEE 754: Vorzeichen, Exponent (mit Bias) und Mantisse; endliche Genauigkeit verursacht Rundungsfehler (0,1 ist binär nicht exakt darstellbar).
• Zeichencodierung: ASCII (7 Bit), Latin-1 (8 Bit), Unicode mit der Kodierung UTF-8 (variable Länge 1–4 Byte, ASCII-kompatibel) für internationale Texte.

Kernpunkte

• Künstliche Intelligenz (KI): Sammelbegriff für Systeme, die Aufgaben lösen, die typischerweise menschliche Intelligenz erfordern (Wahrnehmung, Sprache, Schlussfolgern).
• Maschinelles Lernen (ML) ist Teilgebiet der KI: System lernt aus Daten, statt explizit programmiert zu sein.
• Lernparadigmen: überwacht (Daten mit Label, z.B. Klassifikation), unüberwacht (Cluster, Dimensionsreduktion), bestärkend (Belohnung im Umfeld, z.B. AlphaGo).
• Deep Learning nutzt tiefe neuronale Netze (mehrere verdeckte Schichten); ermöglicht Repräsentationslernen aus Rohdaten (Bild, Audio, Text).
• Trainings-Pipeline: Daten sammeln → bereinigen → trainieren → validieren → testen → bereitstellen → monitoren.
• Overfitting tritt auf, wenn Modell Trainingsdaten auswendig lernt — Gegenmaßnahmen: Regularisierung, Dropout, Cross-Validation.

Kernpunkte

• Ein Perceptron (Rosenblatt 1958) berechnet y = step(Σ wᵢ·xᵢ − θ); modelliert Schwellwert-Logik mit anpassbaren Gewichten.
• Trainingsregel: wᵢ ← wᵢ + η · (t − y) · xᵢ, mit Lernrate η, Ziel t, Output y — konvergiert auf linear separierbaren Daten.
• XOR-Problem: nicht linear separierbar; Perceptron versagt — Minsky/Papert 1969. Lösung: Multi-Layer-Perceptron (MLP) mit verdeckter Schicht und nichtlinearer Aktivierung.
• Backpropagation (Rumelhart, Hinton, Williams 1986): Fehlergradient wird per Kettenregel rückwärts durch Netz propagiert — Grundlage allen Deep Learning.
• Aktivierungsfunktionen: Sigmoid, tanh, ReLU (max(0, x), Standard seit 2010er), Softmax (für Klassifikation, normierte Wahrscheinlichkeiten).
• CNNs (Bildverarbeitung), RNNs/LSTMs (Sequenzen), Transformer (Sprachmodelle) sind spezialisierte Architekturen.

Kernpunkte

• Algorithmischer Bias entsteht durch verzerrte Trainingsdaten oder Modellierungsentscheidungen und kann Diskriminierung verstärken (COMPAS, Gesichtserkennung).
• Fairness-Metriken: Demographic Parity, Equal Opportunity, Equalized Odds — meist nicht gleichzeitig erfüllbar (Impossibility Theorem, Kleinberg et al. 2016).
• EU AI Act (2024 verabschiedet) klassifiziert KI-Systeme nach Risiko: unzulässig (Social Scoring), hoch (Medizin, Justiz), begrenzt (Chatbots), minimal — verschärfte Anforderungen je Klasse.
• Urheberrecht: Generierte Werke gelten in DE/EU derzeit nicht als urheberrechtlich geschützt, weil keine menschliche Schöpfung; Trainingsdaten-Urheberrecht ist umstritten (Text-Data-Mining-Ausnahme § 44b UrhG).
• Ökologische Bilanz: Training großer Sprachmodelle verursacht hohen CO₂-Ausstoß (GPT-3 ca. 552 t CO₂eq, Strubell et al. 2019) — Diskussion um Green AI.
• Berufliche Verlagerung: Automatisierung verändert Arbeitsmarkt — Studie Frey/Osborne (2013) schätzt 47% US-Jobs als gefährdet, kritisiert wegen Aufgabenstatt-Berufsbetrachtung.

Kernpunkte

• Schutzziele der IT-Sicherheit (CIA-Triade): Vertraulichkeit (Confidentiality), Integrität (Integrity), Verfügbarkeit (Availability) — ergänzt um Authentizität und Nicht-Abstreitbarkeit.
• Angriffsklassen: Malware (Virus, Wurm, Trojaner, Ransomware), Phishing, Man-in-the-Middle, DDoS, SQL-Injection, Cross-Site-Scripting, Zero-Day-Exploits.
• Schutzmaßnahmen: Defense in Depth — mehrere Schutzschichten (Firewall, IDS, Verschlüsselung, Backups, Patch-Management, Schulung).
• Zero Trust geht von „kein implizites Vertrauen" aus — jede Anfrage wird authentifiziert, autorisiert, verschlüsselt, unabhängig vom Netzwerksegment.
• DSGVO (siehe Topic Datenbanken) verlangt technische und organisatorische Maßnahmen; Meldepflicht binnen 72 Stunden bei Datenpanne.
• Digitale Mündigkeit: Bürger sollen Risiken einschätzen, Quellen prüfen, persönliche Daten bewusst freigeben können — verankert in KMK-Strategie „Bildung in der digitalen Welt" (2016, fortgeschrieben 2021).

Kernpunkte

• Lernen heißt, die Verlustfunktion (z.B. mittlerer quadratischer Fehler MSE bei Regression, Kreuzentropie bei Klassifikation) über die Trainingsdaten zu minimieren.
• Gradientenabstieg passt die Parameter iterativ entgegen dem Gradienten an: w ← w − η·∇L; die Lernrate η steuert die Schrittweite.
• Zu große η lässt den Verlust divergieren oder oszillieren, zu kleine η führt zu sehr langsamer Konvergenz — η ist ein zentraler Hyperparameter.
• Varianten: Batch (gesamter Datensatz pro Schritt), Stochastic (ein Beispiel), Mini-Batch (Kompromiss, in der Praxis Standard).
• Overfitting: das Modell lernt das Rauschen der Trainingsdaten auswendig — niedriger Trainings-, aber hoher Testfehler. Underfitting: Modell zu einfach, beide Fehler hoch.
• Gegenmaßnahmen: mehr/bessere Daten, Regularisierung (L1/L2), Dropout, Early Stopping, Cross-Validation, Vereinfachung der Architektur.
• Datenaufteilung: Trainings- (Parameter), Validierungs- (Hyperparameter, Early Stopping) und Testmenge (einmalige Endbewertung) strikt trennen.

Kernpunkte

• Generative Modelle erzeugen neue Inhalte (Text, Bild, Code), statt nur zu klassifizieren — Beispiele große Sprachmodelle (LLM), Diffusionsmodelle für Bilder.
• Die Transformer-Architektur (Vaswani et al. 2017) verarbeitet Sequenzen parallel über Self-Attention, statt sequenziell wie RNN/LSTM — Grundlage moderner LLMs.
• Ein LLM wird auf riesigen Textmengen darauf trainiert, das nächste Token vorherzusagen; daraus entsteht statistisches Sprach- und Weltwissen, aber kein Faktenverständnis.
• Halluzinationen: das Modell erzeugt plausibel klingende, aber falsche Aussagen — es optimiert Wahrscheinlichkeit, nicht Wahrheit; Ausgaben müssen geprüft werden.
• Phasen: Pretraining (Selbstüberwachung auf Rohtext), Feintuning und RLHF (Reinforcement Learning from Human Feedback) zur Ausrichtung an menschlichen Präferenzen.
• Grenzen und Risiken: Verzerrungen aus Trainingsdaten, fehlende Quellentransparenz, Datenschutz, Urheberrecht der Trainingsdaten, hoher Ressourcenbedarf.