Computerprogrammierkurs

Lektion 1 • Eingabe, Ausgabe und grundlegende Formatierung

Lehrt das Lesen von Benutzereingaben und das Drucken formatierter Ausgaben. Verbindet abstrakte Datenkonzepte mit sichtbarem, interaktivem Programmverhalten.

Lektion 2 • Einrichten einer Entwicklungsumgebung

Installiert und konfiguriert einen Code-Editor, eine Laufzeitumgebung und ein Terminal. Stellt sicher, dass jeder Student vom ersten Tag an Code schreiben, ausführen und debuggen kann.

Lektion 3 • Operatoren und Ausdrücke

Umfasst arithmetische, relationale, logische und Zuweisungsoperatoren. Studierende können zusammengesetzte Ausdrücke korrekt erstellen und auswerten.

Lektion 4 • Variablen, Datentypen und Literale

Stellt benannte Speicherbereiche, primitive Typen und die Literalsyntax vor. Etabliert das Vokabular, das in allen nachfolgenden Kapiteln verwendet wird.

Lektion 1 • Vergleichs- und logische Bedingungen

Vertieft das Verständnis zusammengesetzter boolescher Ausdrücke und der Kurzschlussauswertung. Verhindert häufige Logikfehler in Verzweigungscode.

Lektion 2 • Schleifensteuerung und Iterationsmuster

Lehrt break, continue und gängige Schleifenidiome wie Akkumulator- und Sentinel-Muster. Verfeinert das Schleifendesign für Klarheit und Korrektheit.

Lektion 3 • Bedingungsgesteuerte Schleifen

Behandelt while- und do-while-Schleifen für Wiederholungen, die durch eine Bedingung gesteuert werden. Die Teilnehmer handhaben Eingabevalidierung und ereignisgesteuerte Wiederholungen.

Lektion 4 • Zählergesteuerte Schleifen

Führt for-Schleifen und bereichsbasierte Iteration für eine bekannte Anzahl von Wiederholungen ein. Bildet die Grundlage für alle iterativen Algorithmen.

Lektion 1 • Definieren und Aufrufen von Funktionen

Behandelt Funktionsdeklaration, Parameterlisten und Rückgabewerte. Etabliert die grundlegende Einheit der Wiederverwendung von Code, die in jedem späteren Kapitel verwendet wird.

Lektion 2 • Standard-, Schlüsselwort- und variable Argumente

Führt flexible Parametersignaturen ein, einschließlich Standardwerten und variadischen Argumenten. Ermöglicht Funktionen, die sich an unterschiedliche Aufrufkontexte anpassen.

Lektion 3 • Gültigkeitsbereich und Lebensdauer von Variablen

Erklärt lokale, einschließende und globale Gültigkeitsbereichsregeln sowie das Überdecken von Variablen. Verhindert subtile Fehler, die durch unbeabsichtigte gemeinsame Nutzung von Variablen verursacht werden.

Lektion 4 • Funktionen höherer Ordnung und Lambdas

Behandelt das Übergeben von Funktionen als Argumente, das Zurückgeben von Funktionen und die anonyme Lambda-Syntax. Bereitet die Teilnehmer auf Muster der funktionalen Programmierung vor.

Lektion 1 • Mengen und Tupel

Behandelt ungeordnete, eindeutige Sammlungen und unveränderliche Sequenzen. Die Teilnehmer wenden Mengenoperationen an und verwenden Tupel für Daten mit fester Struktur.

Lektion 2 • Zeichenketten als Sequenzen

Behandelt Zeichenketten als indizierte Zeichensequenzen und behandelt gängige Zeichenkettenoperationen. Überbrückt primitive Typen und das Verhalten von Sammlungen.

Lektion 3 • Arrays und Listen

Behandelt indizierte sequenzielle Speicherung, Elementzugriff und Mutation. Stellt den grundlegendsten Sammlungstyp für geordnete Daten bereit.

Lektion 4 • Auswählen und Kombinieren von Datenstrukturen

Analysiert Zeit- und Speicherkompromisse zwischen Sammlungstypen. Die Teilnehmer entwerfen zusammengesetzte Strukturen für realistische Datenmodellierungsaufgaben.

Lektion 1 • Vererbung und Methodenüberschreibung

Lehrt die Erstellung von Unterklassen, die Wiederverwendung von Elternklassen und das Überschreiben von Methoden. Ermöglicht hierarchische Modellierung und Code-Wiederverwendung über verwandte Typen hinweg.

Lektion 2 • Komposition und Entwurfsprinzipien

Stellt Komposition vor Vererbung, das Single-Responsibility-Prinzip und das Open-Closed-Prinzip vor. Die Teilnehmer gestalten Klassendesigns für mehr Flexibilität um.

Lektion 3 • Methoden und Kapselung

Behandelt Instanzmethoden, Zugriffsmodifikatoren und Datenverbergung. Die Teilnehmer schützen den internen Zustand und legen saubere öffentliche Schnittstellen offen.

Lektion 4 • Polymorphie und Schnittstellen

Behandelt Duck-Typing, abstrakte Klassen und Schnittstellenverträge. Die Teilnehmer schreiben Code, der über eine gemeinsame Schnittstelle mit mehreren Typen arbeitet.

Lektion 1 • Lesen und Schreiben von Textdateien

Behandelt das Öffnen, Lesen, Schreiben und Schließen von Dateien mit Kontextmanagern. Verbindet In-Memory-Daten mit persistentem Speicher auf der Festplatte.

Lektion 2 • Ausnahmetypen und die Fehlerhierarchie

Ordnet häufige Ausnahmekategorien und deren Vererbungshierarchie zu. Die Teilnehmer identifizieren den richtigen Ausnahmetyp für jedes Fehlerszenario.

Lektion 3 • Try-, Except- und Finally-Blöcke

Behandelt strukturierte Ausnahmebehandlung, mehrere except-Klauseln und Bereinigungscode. Die Teilnehmer verhindern Abstürze und geben Ressourcen zuverlässig frei.

Lektion 4 • Benutzerdefinierte Ausnahmen und defensive Programmierung

Lehrt das Definieren benutzerdefinierter Ausnahmeklassen und das proaktive Validieren von Eingaben. Die Teilnehmer entwerfen APIs, die Fehler klar kommunizieren.

Lektion 1 • Algorithmenanalyse und O-Notation

Stellt Zeit- und Speicherkomplexität sowie die O-Klassifizierung vor. Gibt den Teilnehmern einen Rahmen für den objektiven Vergleich der Algorithmeneffizienz.

Lektion 2 • Lineare und binäre Suche

Implementiert und vergleicht sequenzielle und binäre Suchalgorithmen. Die Teilnehmer verstehen die Voraussetzungen und die Leistung jedes Ansatzes.

Lektion 3 • Rekursionsbasiertes Problemlösen

Wendet rekursives Denken auf klassische Probleme wie binäre Suchbäume und Permutationen an. Festigt die Rekursion aus Kapitel drei in algorithmischen Kontexten.

Lektion 4 • Effiziente Sortieralgorithmen

Implementiert Merge Sort und Quicksort mittels Divide-and-Conquer. Die Teilnehmer analysieren die O(n log n)-Leistung und Partitionsstrategien.

Lektion 1 • Code-Qualität und Refactoring

Behandelt Namenskonventionen, Code-Smells und systematische Refactoring-Techniken. Studierende verbessern vorhandenen Code, ohne dessen externes Verhalten zu ändern.

Lektion 2 • Versionskontrolle mit Git

Behandelt die Initialisierung von Repositorys, Commits, Branching und Merging. Ermöglicht kollaborative und individuelle Entwicklung mit vollständigem Änderungsverlauf.

Lektion 3 • Unit-Tests und testgetriebene Entwicklung

Lehrt das Schreiben von Unit-Tests, Assertions und den Rot-Grün-Refactor-Zyklus. Die Teilnehmer überprüfen die Korrektheit und verhindern Regressionen automatisch.

Lektion 4 • Dokumentation und Code-Lesbarkeit

Lehrt Inline-Kommentare, Docstrings und das Verfassen von READMEs. Die Teilnehmer erstellen Code, den Teammitglieder verstehen und warten können.