Vom Fundament zur Anwendung – im zweiten Semester vertieft sich alles: Algorithmen bekommen Komplexität, Mathe wird Kalkül, und aus kleinen Skripten werden echte Softwareprojekte.
∫Modul 1
Mathematik 2 – Analysis
Wenn Lineare Algebra die Statik der Mathematik ist, ist Analysis ihre Dynamik. Hier geht es um Veränderung: Wie schnell wächst etwas? Wie verhält sich eine Funktion im Grenzwert? Wie summiert man unendlich viele Werte?
Differenzial- und Integralrechnung sind die zentralen Werkzeuge für alles, was mit kontinuierlichen Größen zu tun hat – von Physik-Simulationen über Signalverarbeitung bis hin zum Gradient Descent moderner KI-Modelle. Wer einmal verstanden hat, dass Backpropagation nichts anderes ist als die Kettenregel im großen Stil, sieht Machine Learning mit anderen Augen.
Kerninhalte
Folgen & Reihen – Konvergenz, Grenzwerte, geometrische Reihe
Taylor- und Potenzreihen zur Funktionsapproximation
Anwendung in der Optimierung (Gradientenverfahren)
Beispiel – Kettenregel & Sigmoid
Die Sigmoid-Funktion taucht in jedem klassischen neuronalen Netz auf. Ihre Ableitung – die Grundlage für Backpropagation – fällt mit der Kettenregel überraschend elegant aus:
Schöner Trick: Die Ableitung lässt sich aus dem Funktionswert selbst berechnen – ein Grund, warum Sigmoid in frühen Netzen so beliebt war.
Praktische Anwendung
Ableitungen begegnen mir konkret beim Verständnis von ML-Trainingsverfahren: Gradient Descent ist im Kern eine Anwendung der Kettenregel auf hintereinandergeschaltete Funktionen. Auch Animationen mit cubic-bezier auf dieser Webseite folgen letztlich Differenzialgleichungen.
Verwandte Projekte
Keine direkten Projekte, aber Grundlage für jedes ML- und Optimierungsthema.
Tiefer ins Material
Vollständige Lerneinheiten und Karteikarten pflege ich in meinem Lern-Hub.
Rückblick: Analysis hatte ich in der Schule, aber erst im Studium fiel der Groschen, warum Ableiten so wichtig ist. In dem Moment, in dem ich Backpropagation als "Kettenregel über tausende Schichten" gesehen habe, war Mathematik plötzlich kein Selbstzweck mehr, sondern Werkzeug.
🌐Modul 2
Web Engineering 2
Web Engineering 2 ist der Schritt von "ich kann eine Webseite bauen" zu "ich kann eine Web-Anwendung bauen". Komponentenbasierte Frameworks, deklaratives Rendering, API-Integration und Deployment-Pipelines – das tägliche Werkzeug eines Frontend-Entwicklers.
Im Mittelpunkt steht React: ein Paradigmenwechsel weg vom händischen DOM-Manipulieren hin zu deklarativen Komponentenbäumen, die ihren Zustand selbst verwalten. Darauf bauen Frameworks wie Next.js auf, die Server-Rendering, Routing und Build-Optimierung mitbringen. Am Ende steht der vollständige Lebenszyklus moderner Webapps – vom ersten Commit bis zum Production-Deploy.
Drei Konzepte in zehn Zeilen: Komponente, lokaler State, Side-Effect. React rendert die Differenz, der Browser sieht den finalen DOM-Zustand.
Praktische Anwendung
Diese Webseite ist die direkte Anwendung – sie ist mit Next.js 15 und dem App-Router gebaut. Jede Story-Seite, jede Karte und jede Animation auf braun-steven.de ist eine React-Komponente. Das Cloudinary-Upload-Skript spricht eine REST-API, die Bibliothek nutzt clientseitige Filterung mit Hooks.
Rückblick: Nach Web Engineering 1 hatte ich verstanden, wie das Web funktioniert – nach Web Engineering 2 konnte ich es selbst bauen. Der Sprung vom imperativen document.querySelector zum deklarativen Komponentenbaum war einer der zwei größten Paradigmenwechsel des Studiums (der andere war Prolog).
⚡Modul 3
Algorithmen & Komplexität
Algorithmen sind das Herzstück der Informatik – und Komplexität ist die Brille, durch die man ihre Qualität beurteilt. Ob ein Programm bei einer Million Datensätzen Sekunden oder Stunden braucht, entscheidet sich nicht am Hardware-Preis, sondern am gewählten Algorithmus.
Das Modul vertieft die O-Notation aus der Theoretischen Informatik und wendet sie auf reale Algorithmenklassen an: Sortieren, Suchen, Graphenprobleme. Die zentrale Frage lautet: Wie skaliert ein Verfahren mit der Eingabegröße? Und wann ist ein Problem so schwer, dass es grundsätzlich keinen schnellen Lösungsweg gibt (NP-vollständig)?
function mergeSort(A):
if len(A) <= 1:
return A
mid = len(A) // 2
left = mergeSort(A[:mid])
right = mergeSort(A[mid:])
return merge(left, right)
function merge(L, R):
result = []
while L and R:
if L[0] <= R[0]:
result.append(L.pop(0))
else:
result.append(R.pop(0))
return result + L + R
# Komplexität: O(n log n) – stabil sortierend
MergeSort ist das Lehrbuch-Beispiel für Divide & Conquer: Halbieren, rekursiv lösen, kombinieren – und das in garantiert O(n log n).
Praktische Anwendung
Beim Entwickeln entscheide ich täglich auf Basis von Komplexität: Set für Existenz-Checks (O(1)) statt Liste (O(n)), Map für Lookup-Tabellen, binäre Suche bei sortierten Daten. Bei der Bibliothek auf dieser Seite läuft die Filterung über vorberechnete Indizes – das spart bei jedem Tastendruck Rechenzeit.
Verwandte Projekte
Indirekt überall: Die Filterlogik in der Bibliothek und die Suchimplementierung im Karriere-Hub.
Tiefer ins Material
Vollständige Lerneinheiten und Karteikarten pflege ich in meinem Lern-Hub.
Rückblick: Das "Aha" bei diesem Modul war der Unterschied zwischen O(n²) und O(n log n) bei einer Million Einträgen: eine Trillion gegenüber zwanzig Millionen Operationen. Davor habe ich Datenstrukturen nach Bauchgefühl gewählt – seitdem nach Komplexitätsklasse.
🗄️Modul 4
Praktische Datenverarbeitung
Daten sind in fast jedem realen Softwareprojekt der eigentliche Wert – der Code drumherum ist nur die Hülle. Dieses Modul vermittelt die Werkzeuge, mit denen man Daten strukturiert speichert, gezielt abfragt und für Analysen aufbereitet.
Im Mittelpunkt stehen relationale Datenbanken mit SQL als universeller Abfragesprache: Wie modelliert man Realität in Tabellen? Wann braucht es welche Normalform? Und wie holt man aus mehreren verbundenen Tabellen genau die richtige Antwort? Anschließend kommt Pandas als pragmatischer Einstieg in datengetriebene Analysen mit Python.
Kerninhalte
Relationales Datenbankmodell & ER-Diagramme
Normalformen (1NF–3NF) zur Vermeidung von Redundanz
SQL: SELECT, JOIN, GROUP BY, Aggregatfunktionen
Transaktionen, ACID-Eigenschaften, Indizes
Pandas: DataFrames, GroupBy, Merge, Pivot
Datenbereinigung & -visualisierung (matplotlib)
Ausblick auf NoSQL (Dokument-, Key-Value-, Graph-Datenbanken)
Beispiel – SQL-Query mit JOIN
SELECT
k.name,
COUNT(b.id) AS bestellungen,
SUM(b.gesamtpreis) AS umsatz
FROM kunden k
LEFT JOIN bestellungen b
ON b.kunde_id = k.id
WHERE b.datum >= '2026-01-01'
GROUP BY k.id, k.name
HAVING SUM(b.gesamtpreis) > 500
ORDER BY umsatz DESC;
Aus zwei Tabellen wird ein Bericht: Kunden mit über 500 € Umsatz im laufenden Jahr, sortiert absteigend. Das alles deklarativ in einem Statement.
Praktische Anwendung
SQL nutze ich bei der Praxisphase regelmäßig zur Auswertung von Datenbeständen. Pandas ist das Werkzeug der Wahl, wenn ich CSV- oder Log-Exporte schnell analysieren muss – deutlich pragmatischer als alles händisch in Excel oder via Schleifen in Python.
Verwandte Projekte
Wird im Industrie-4.0-Projekt eingesetzt – dort bildet eine relationale Datenbank die persistente Schicht des Dashboards.
Tiefer ins Material
Vollständige Lerneinheiten und Karteikarten pflege ich in meinem Lern-Hub.
Rückblick: Datenbanken klangen nach trockenem Stoff, bis ich gemerkt habe: SQL ist ein deklaratives Paradigma – ähnlich wie Prolog. Man beschreibt das gewünschte Ergebnis, nicht den Weg dorthin. Dass ein guter Index eine Anfrage tausendfach beschleunigen kann, war der Moment, in dem ich Datenbankdesign ernst genommen habe.
🚀Modul 5
Anwendungsprojekt Informatik – Durchführung
Im ersten Semester war das Anwendungsprojekt vor allem Planung – jetzt geht es an die Umsetzung. Aus Architektur-Diagrammen werden Module, aus Schnittstellendefinitionen werden APIs, aus Anforderungslisten wird laufender, getesteter Code.
Das Industrie-4.0-Dashboard, das wir konzipiert haben, wird in diesem Semester gebaut: Sensordaten kommen über MQTT und Kafka herein, werden serverseitig verarbeitet, in einer relationalen Datenbank persistiert und in einem Web-Frontend visualisiert. Parallel zum Coden wird die Methodik geübt – Sprints, Reviews, Doku.
Projektphase 2 – Umsetzung
MQTT- und Kafka-Anbindung der realen & simulierten Sensoren
Serverseitige Verarbeitung & Persistenz in der relationalen DB
Berechnung der Kennzahlen (Verbrauch, Effizienz, Auslastung)
Web-Frontend mit interaktiven Charts & Live-Updates
Versionskontrolle, Code-Reviews, CI-Pipeline im Team
Abschlussdokumentation & Präsentation der Ergebnisse
Architektur – aus dem Plan wird Code
Sensor (real/sim)→MQTT / Kafka→Backend-Service
→Relationale DB→REST-API→Web-Dashboard
Die Pfeile aus dem Architektur-PDF des ersten Semesters sind jetzt echte Verbindungen – jeder Schritt ist eine eigene Komponente mit eigener Verantwortlichkeit.
Praktische Anwendung
Das Projekt ist die direkte Anwendung – aus Theorie wird ein laufendes System. Hier zahlt sich alles aus, was wir parallel im Modul lernen: SQL aus der Datenverarbeitung, React aus Web Engineering 2, Komplexitätsdenken aus Algorithmen.
Rückblick: Der Sprung von "wir haben einen Plan" zu "wir haben ein laufendes System" ist viel größer, als das Diagramm aus Semester 1 vermuten ließ. Schnittstellen, die auf dem Papier klar wirkten, mussten im Code dreimal nachverhandelt werden – genau das ist die Lektion: echtes Engineering passiert beim Bauen, nicht beim Planen.
☕Modul 6
Programmieren 2 – Java
Nach Python im ersten Semester kommt jetzt Java – eine statisch typisierte, objektorientierte Sprache, die in vielen Unternehmen das Rückgrat der Backend-Welt bildet. Der Wechsel ist gewollt: was Python elegant verbirgt, macht Java explizit – Typen, Sichtbarkeiten, Klassenstrukturen.
Der rote Faden ist ein semesterlanges Projekt: ein Flugzeug in Java zu modellieren – Klassenhierarchien für unterschiedliche Flugzeugtypen, Passagiere, Crew, Buchungen. Ein perfektes Spielfeld, um Vererbung, Polymorphismus, Interfaces und sauberes OOP-Design zu üben, ohne sich in Frameworks zu verlieren.
public abstract class Flugzeug {
protected final String kennzeichen;
protected final int sitzplaetze;
protected Flugzeug(String kennz, int plaetze) {
this.kennzeichen = kennz;
this.sitzplaetze = plaetze;
}
public abstract void starten();
public abstract void landen();
}
public class Verkehrsflugzeug extends Flugzeug {
private final List<Passagier> passagiere = new ArrayList<>();
public Verkehrsflugzeug(String k, int p) { super(k, p); }
@Override public void starten() {
System.out.println(kennzeichen + " hebt ab.");
}
@Override public void landen() {
System.out.println(kennzeichen + " ist gelandet.");
}
public void einsteigen(Passagier p) {
if (passagiere.size() < sitzplaetze) passagiere.add(p);
}
}
Eine abstrakte Basisklasse legt die Struktur fest, konkrete Unterklassen füllen sie aus – das Lehrbuch-Setup für Polymorphismus.
Projekt – Flugzeug-Simulation
Über das Semester wächst aus einer einzelnen Flugzeug-Klasse ein kleines System: verschiedene Flugzeugtypen (Verkehrs-, Fracht-, Privatflugzeug), Passagiere und Crew, Sitzplatzverwaltung, Buchungen und Flugpläne. Die Übungen zeigen Schritt für Schritt, wie Vererbung, Interfaces, Collections und Exceptions zusammenspielen.
Größte Lerneffekte: bewusst über Sichtbarkeiten nachdenken (private vs. protected) und Verantwortlichkeiten sauber trennen – wer kennt wen, und wer ändert was?
Praktische Anwendung
Java ist im Unternehmensumfeld weit verbreitet – Kenntnisse darüber helfen mir, fremde Codebasen schneller zu verstehen. Die statische Typisierung hat mein Denken über Schnittstellen geschärft: Was ein Typ nicht akzeptiert, sagt oft mehr aus als das, was er erlaubt.
Verwandte Projekte
Flugzeug-Projekt-Repo folgt.
Tiefer ins Material
Vollständige Lerneinheiten und Karteikarten pflege ich in meinem Lern-Hub.
Rückblick: Nach Python fühlte sich Java zunächst sperrig an – jeder kleine Schritt verlangt eine Typdeklaration, eine Sichtbarkeit, einen Block. Aber genau dieser "Zwang zur Klarheit" war lehrreich: in Python kann man Strukturen erraten, in Java muss man sie aussprechen. Das hat mir geholfen, OOP nicht nur zu benutzen, sondern wirklich zu denken.
01Modul 7
Digitaltechnik
Digitaltechnik ist die Brücke zwischen physischer Hardware und logischem Code. Hier wird sichtbar, wie aus zwei einfachen Zuständen – 0 und 1 – jede Berechnung der Welt zusammengesetzt werden kann.
Das Modul beginnt bei der booleschen Algebra: Wie lassen sich logische Aussagen formal beschreiben und vereinfachen? Daraus entstehen Logikgatter, aus Gattern Schaltnetze (kombinatorisch, ohne Gedächtnis) und schließlich Schaltwerke (sequenziell, mit Speicher) – die Bausteine, aus denen am Ende ein Prozessor entsteht.
Wahrheitstabelle (a, b → s, c)
a | b || s | c
---+---++---+---
0 | 0 || 0 | 0
0 | 1 || 1 | 0
1 | 0 || 1 | 0
1 | 1 || 0 | 1
Funktionen:
s (Summe) = a XOR b
c (Carry) = a AND b
Zwei Gatter, vier Eingangskombinationen – der kleinste Baustein jeder binären Addition. Aus mehreren Halbaddierern wird ein Volladdierer, daraus ein n-Bit-Addierwerk.
Praktische Anwendung
Boolesche Algebra ist nicht nur Hardware-Theorie: Jeder if-Ausdruck im Code ist ein Boolescher Term, der sich mit denselben Regeln vereinfachen lässt. Ein KV-Diagramm im Kopf hilft, aus verschachtelten Bedingungen klare Logik zu machen.
Verwandte Projekte
Direkter Anschluss an die Elektrotechnik aus Semester 1 – dort der Transistor als Schalter, hier dieselben Schalter als Logikgatter.
Tiefer ins Material
Vollständige Lerneinheiten und Karteikarten pflege ich in meinem Lern-Hub.
Rückblick: Vor Digitaltechnik wusste ich, dass ein Computer rechnet, aber nicht wie. Nach diesem Modul kann ich den Weg von einer Wahrheitstabelle über ein Schaltnetz bis zu einem echten Addierwerk zeichnen. Damit schließt sich der Kreis, der mit dem Transistor aus Semester 1 begonnen hat.
Fazit – Was bleibt?
Das zweite Theorie-Semester war der Übergang vom Lernen zum Anwenden: Aus Schleifen wurden Algorithmen mit messbarer Komplexität, aus Funktionen wurden React-Komponenten mit klar definiertem Zustand, aus "Mathe" wurde das Werkzeug, mit dem moderne KI rechnet. Was im ersten Semester noch isoliert nebeneinander stand, wuchs zu einem Bild zusammen.
Das Anwendungsprojekt war der rote Faden, der alles verknüpft hat: das Konzept aus Semester 1 wurde echter, laufender Code – mit React aus Web Engineering 2, SQL aus der Datenverarbeitung und Komplexitätsdenken aus den Algorithmen. Der größte Lerneffekt lag dabei nicht im Coden, sondern in der Abstimmung im Team.
Java in Programmieren 2 hat gezeigt, wie eine zweite Sprache die OOP-Konzepte neu schärft – Sichtbarkeiten, Typen und Interfaces sieht man in Python nicht so deutlich. Und Digitaltechnik hat den Bogen zur Elektrotechnik aus Semester 1 geschlossen: Vom Transistor zum Logikgatter, vom Logikgatter zum Addierwerk.