Lesson · Lesson · 1 hr 5 min

Python lokal einrichten: Interpreter, Editor, erste Skripte außerhalb der Browser-Sandbox.

• Python-Installation und PATH prüfen
• Datei speichern und mit `python script.py` starten
• Unterschied REPL vs. Skriptdatei verstehen

Lesson · Lesson · Academy · 3 hrs

Wahrheitswerte, Vergleichsoperatoren und logische Verknüpfungen als Grundlage für Bedingungen.

• `True` / `False`, `==`, `!=`, `<`, `>`
• `and` / `or` / `not` und Kurzschlussauswertung
• Booleans in `if`-Verzweigungen nutzen

Lesson · Lesson · 15 min

Kurzer Recap: int, float, str, bool, list — und wann welcher Typ passt.

• `type()` und implizite Konvertierungen kennen
• Häufige Typfehler vermeiden (str + int)

Lesson · Lesson · 30 min

Module und Pakete einbinden: `import`, `from … import`, Aliase.

• `import math` vs. `from math import sqrt`
• Standardbibliothek vs. Drittpakete unterscheiden

Lesson · Lesson · Academy · 2 hrs

Praktische Übungen mit ausgewählten Libraries — lesen, anwenden, dokumentieren.

• Docs/Examples einer Library nutzen
• Kleine Skripte mit fremdem Code erweitern

Lesson · Lesson · Academy · 2 hrs

Fehler lesen: Tracebacks, Print-Debugging, typische Runtime- und Logikfehler.

• Traceback von unten nach oben lesen
• Hypothese → Test → Fix Zyklus
• Off-by-one und Typfehler erkennen

Project · Codio · Score-Ziel: 100 / 100

Projekt: Taschenrechner-Logik — Eingaben verarbeiten, Operationen wählen, Ergebnis zurückgeben.

• Eingabe parsen und validieren
• Funktionen für Operationen trennen
• Randfälle (Division durch 0) behandeln

Lesson · Lesson · Academy · 4 hrs 30 min

Parameter, Rückgaben, Scope und saubere Funktionsgrenzen — Grundlage für größere Programme.

• Positional vs. keyword arguments
• Lokaler vs. globaler Scope
• Eine Funktion = eine klare Verantwortung

Lesson · Lesson · 1 hr

Einstiegspunkt `main` und Aufrufkette: Skripte lesbar und testbar halten.

• `if __name__ == "__main__":` nutzen
• Logik aus `main` in Hilfsfunktionen auslagern

Lesson · Lesson · Academy · 2 hrs 40 min

Schleifen in Schleifen: Matrizen, Paare, Tabellen — und wann Nesting zu viel wird.

• Äußere/innere Laufvariable klar benennen
• Komplexität O(n²) im Blick behalten
• Früh `break`/`continue` gezielt einsetzen

Lesson · Lesson · Academy · 1 hr 30 min

Mutable vs. immutable: Listen ändern sich in-place, Strings/Tuples nicht — Seiteneffekte vermeiden.

• `list.append` ändert das Original
• Aliasing: zwei Namen, ein Objekt
• Kopien (`list(...)` / slicing) wenn nötig

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: Daten/Listen und Kontrollfluss in einem zusammenhängenden Szenario.

• Anforderungen in Funktionen zerlegen
• Tests/Score als Feedback-Loop nutzen

Lesson · Lesson · Academy · 5 hrs

Listen bauen, schneiden, sortieren, filtern — die Werkzeuge für Sequenzdaten.

• Indexing, Slicing, `append` / `extend` / `pop`
• `sorted` vs. `list.sort`
• Listenkomprehensionen lesen und schreiben

Lesson · Lesson · Academy · 4 hrs

Bedingte Wiederholung: Zähler, Sentinel-Werte, Endlosschleifen vermeiden.

• Schleifenbedingung vor jedem Durchlauf prüfen
• Update der Laufvariable nicht vergessen
• `while` vs. `for` bewusst wählen

Lesson · Lesson · Academy · 3 hrs 45 min

Key-Value-Maps: `.get`, Iteration über keys/values/items, Zähler-Muster.

• `dict.get(key, default)` statt KeyError
• Häufigkeiten mit Dict zählen
• Verschachtelte Dicts vorsichtig modellieren

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt mit Listen/Schleifen — Solution-View als Lernspiegel nach dem Versuch.

• Eigene Lösung zuerst, dann Solution vergleichen
• Edge Cases in den Tests beachten

Project · Codio · Score-Ziel: 100 / 100

Textverarbeitung: Strings zerlegen, zählen, filtern — typisches Dict/List-Training.

• `split` / `lower` / Zähler-Dict kombinieren
• Große Texte schrittweise verarbeiten

Lesson · Lesson · 10 min

Kickoff: Erwartungen, Zeitplan und Erfolgskriterien der Practice Week.

• Wochenziele priorisieren
• Hilfe holen bevor man feststeckt

Project · Codio · Score-Ziel: 100 / 100

Erstes Projekt-Milestone: Datenmodell/Features für ein Movie-Szenario umsetzen.

• Anforderungen in kleine Tickets schneiden
• Funktionen + Datenstrukturen früh festlegen
• Score als Iterationssignal nutzen

Project · Project · Codio · Submitted

Linux-Einführung im Codio-Projekt: Shell-Befehle, Verzeichnisbaum, einfache Administration.

• `pwd`, `ls`, `cd`, `mkdir`, `rm` sicher einsetzen
• Relative vs. absolute Pfade
• Berechtigungen und Prozesse grob einordnen

Project · Project · Codio · 1 hr 30 min · Optional

Klassischer Chatbot-Stil: Eingaben spiegeln, Muster erkennen, Gesprächsschleife bauen.

• While-Loop für Dialog
• String-Matching / einfache Regeln
• Zustand zwischen Turns halten

Project · Project · Codio · 1 hr 30 min · Optional

Projektfokus auf verschachtelte Schleifen — Muster erzeugen und Daten 2D durchlaufen.

• Klare äußere/innere Indizes
• Ausgabe formatieren (Tabellen/Gitter)

Project · Project · Codio · 1 hr · Optional

Telefonbuch mit Dictionary: Einträge anlegen, suchen, aktualisieren, löschen (CRUD).

• Dict als Persistenz-Modell im Speicher
• CRUD-Menü in Funktionen splitten

Lesson · Lesson · 10 min

Roadmap SE103: Coding Standards, Proficient Python, Dateien, Git/Tests und Practice Week.

• Module und Meilensteine der Unit einordnen
• Pflicht vs. optional früh unterscheiden

Lesson · Lesson · Academy · 1 hr 30 min

Namenskonventionen, Formatierung, Struktur — Code, den andere lesen können.

• Aussagekräftige Namen für Funktionen und Variablen
• Konsistente Einrückung und Modulstruktur
• Kommentar nur wo Absicht unklar bleibt

Lesson · Lesson · 20 min

Kurzreferenz: Do’s/Don’ts und typische Review-Punkte auf einen Blick.

• Cheatsheet vor Abgabe gegenprüfen
• Wiederkehrende Style-Fehler vermeiden

Lesson · Lesson · Academy · 2 hrs 30 min

Unveränderliche Sequenzen: Packing/Unpacking, als Dict-Keys, Rückgaben mehrerer Werte.

• `(a, b)` unpacking und Multiple Return Values
• Warum Tuples hashable und Listen nicht
• Wann Tuple statt List die bessere Wahl ist

Lesson · Lesson · Academy · 2 hrs 30 min · Optional

Mengen: Unique-Werte, Union/Intersection — optionaler Vertiefungsblock.

• `set()` für Duplikat-Entfernung
• `|` `&` `-` Mengenoperationen
• Ungeordnetheit und fehlende Indexierung beachten

Lesson · Lesson · 30 min

list vs. tuple vs. set vs. dict — Kriterien für die passende Struktur.

• Ordnung, Mutability, Lookup-Kosten vergleichen
• Falsche Typwahl früh korrigieren

Lesson · Lesson · Academy · 4 hrs

`try` / `except` / `finally` / `raise` — Fehlerbehandlung statt Absturz.

• Spezifische Exceptions fangen, nicht blind `Exception`
• `raise` für klare Fehlersignale
• `finally` für Cleanup (Dateien, Ressourcen)

Project · Codio · Score-Ziel: 100 / 100

Codio: bestehenden Code lesbarer machen — extrahieren, umbenennen, duplizieren vermeiden.

• Funktionen aus langen Blöcken herausziehen
• Verhalten mit Tests absichern, dann umbauen

Lesson · Lesson · 1 hr

Breakpoints, Step-Over/Into, Variableninspektion in der IDE.

• Breakpoint setzen und Call Stack lesen
• Print-Debugging durch strukturiertes Steppen ersetzen

Lesson · Lesson · 1 hr

Code über mehrere Module verteilen: Imports, `__main__`, Paketstruktur.

• Hilfsmodule vs. Einstiegsskript trennen
• Relative/absolute Imports grob einordnen

Lesson · Lesson · Academy · 4 hrs

Listen in Dicts, Dicts in Listen — verschachtelte Daten modellieren und lesen.

• Zugriffspfad `data[i]["key"]` sicher navigieren
• Struktur zuerst skizzieren, dann codieren

Lesson · Lesson · 1 hr 30 min

Verschachtelte Daten mit Schleifen durchlaufen und aggregieren.

• Äußere/innere Schleife klar benennen
• Akkumulatoren für Summen/Zähler aufbauen

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: Nested Structures + Logik in einem Lehrer-/Klassen-Szenario.

• Anforderungen in Hilfsfunktionen zerlegen
• Solution erst nach eigenem Versuch vergleichen

Lesson · Lesson · Academy · 5 hrs

Pfade, Verzeichnisse, Existenz prüfen — mit Python im Dateisystem navigieren.

• `pathlib` / `os.path` für Pfade nutzen
• Relative vs. absolute Pfade im Skriptkontext

Lesson · Lesson · Academy · 5 hrs

Vertiefung: Verzeichnisse anlegen, Dateien verschieben/löschen, Muster finden.

• Verzeichnisbäume durchlaufen
• Fehler bei fehlenden Pfaden abfangen

Lesson · Lesson · Academy · 3 hrs

Textdateien zeilenweise oder komplett lesen — Encoding und Context Manager.

• `with open(...) as f:` immer bevorzugen
• `read` / `readline` / `readlines` gezielt wählen

Lesson · Lesson · Academy · 3 hrs

Schreiben und Anhängen: Modi `w` / `a`, Flush, Überschreiben vs. ergänzen.

• Modus bewusst wählen (`w` löscht, `a` hängt an)
• Ausgabe nach dem Schreiben verifizieren

Lesson · Lesson · Academy · 2 hrs 30 min · Optional

Optional: `json.load` / `json.dump` — strukturierte Daten speichern und laden.

• Dict/List ↔ JSON-String/Datei
• Typgrenzen (kein Tuple/Set nativ) kennen

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: Daten aus Dateien lesen, auswerten, Ergebnisse schreiben.

• Pipeline: Datei → Verarbeitung → Ausgabe
• Edge Cases (leere Zeilen, fehlende Felder)

Lesson · Lesson · 30 min

Warum Tests? Arrange-Act-Assert und der Nutzen schneller Feedback-Loops.

• Regressionen früh erkennen
• Kleine, isolierte Testfälle schreiben

Lesson · Lesson · Academy · 4 hrs · Optional

Optional: `unittest`/`pytest`-Stil — Assertions, Fixtures-Idee, grüne Suite.

• `assert` und erwartete Exceptions
• Eine Assertion pro klarer Absicht

Lesson · Lesson · Codio · 4 hrs · Optional

Optional: Commit, Branch, Diff — Historie und sicheres Experimentieren.

• `status` / `add` / `commit` / `log`
• Sinnvolle Commit-Messages

Lesson · Lesson · 52 min

Remote, Push/Pull, Pull Requests — Zusammenarbeit über GitHub.

• Lokal ↔ Remote synchronisieren
• PR als Review- und Integrationsschritt

Lesson · Lesson · 48 min

Pakete installieren und strukturieren: `pip`, `requirements`, Importpfade.

• Virtuelle Umgebungen grob einordnen
• Abhängigkeiten dokumentieren

Lesson · Lesson · 1 hr 15 min · Optional

Optional: typischer Projektbaum — `src`, Tests, Config, README.

• Trennung App-Code / Tests / Docs
• Einstiegspunkte im Tree finden

Lesson · Lesson · 10 min

Kickoff SE103 Practice Week: Ziele, Zeitbudget, Abgabekriterien.

• Phase-2-Scope gegenüber Phase 1 abgrenzen
• Blocker früh eskalieren

Project · Project · Codio · 8 hrs

Erweiterung des Movie-Projekts: mehr Features, sauberere Struktur, längerer Fokusblock.

• Bestehenden Code erweitern statt neu schreiben
• Standards und Tests aus SE103 mitnehmen

Project · Project · Codio · 1 hr 30 min · Optional

Logdatei lesen, parsen, aggregieren — Zähler und Auswertungen.

• Zeilenweise parsen und filtern
• Aggregation mit Dict/Counters

Project · Project · Codio · 3 hrs · Optional

Spiel-Logik: Züge, Gewinnbedingungen, ggf. einfache Strategie.

• Spielzustand modellieren
• Schleife bis Endbedingung

Project · Project · Codio · 2 hrs · Optional

Vertiefung Shell: Pipes, Rechte, Prozesse — Anschluss an Intro to Linux.

• Befehle kombinieren (`|`, Redirects)
• Prozesse und Rechte gezielter steuern

Lesson · Lesson · 10 min

Roadmap SE104: Front-end (HTML/CSS), Practice Week, Advanced 4, HTTP/APIs.

• Web-Stack grob skizzieren
• Python bleibt Backend-Brücke (Requests/APIs)

Lesson · Lesson · 35 min

Wer macht was: UI im Browser, Logik/Daten auf dem Server, Full-Stack-Überblick.

• Client vs. Server Verantwortung
• Wo Python typischerweise sitzt (Backend/API)

Lesson · Lesson · Academy · 7 hrs

Struktur des Web: Tags, Semantik, Formulare, Links und Seitenaufbau.

• Semantische Elemente (`header`, `main`, `section`)
• Formulare und Inputs korrekt verschachteln

Lesson · Lesson · Academy · 6 hrs 30 min

Gestaltung: Selektoren, Box Model, Farben, Typografie, einfaches Layout.

• Klassen vs. Element-Selektoren
• Margin/Padding/Border (Box Model)

Lesson · Lesson · Academy · 6 hrs

Vertiefung: Flex/Grid-Ideen, Responsive-Grundlagen, wiederverwendbare Styles.

• Layout-Probleme systematisch lösen
• Wiederkehrende Utility-Muster erkennen

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: HTML/CSS-Übung — Seite nach Vorgaben gestalten.

• Vorgabe vs. eigenes Markup abgleichen
• Score als Iterationssignal

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: thematische Webseite — Struktur + Styles kombiniert.

• Inhalt und Präsentation trennen
• Solution erst nach eigenem Versuch

Lesson · Lesson · 5 min

Mini-Kickoff: Fokus der Woche und optionale Advanced-Tracks.

• Pflicht vs. Advanced 4 priorisieren
• HTTP-Modul als nächste Kernstation im Blick behalten

Project · Project · Codio · 2 hrs · Optional

Verschieben von Buchstaben: Encode/Decode mit Shift — String- und Modulo-Übung.

• Alphabet-Index und Modulo 26
• Groß-/Kleinschreibung und Nicht-Buchstaben

Project · Project · Codio · 3 hrs · Optional

Ciphertext knacken: Brute-Force über Shifts oder Häufigkeitsanalyse.

• Alle Shifts systematisch testen
• Lesbarkeit als Bewertungskriterium

Project · Project · Codio · 6 hrs · Optional

Schwierigere Chiffre: Mapping schätzen, Häufigkeiten, iterative Entschlüsselung.

• Buchstabenhäufigkeiten nutzen
• Hypothesen schrittweise verfeinern

Project · Project · Codio · Submitted · Optional

Advanced Shell/Systemthemen im Codio-Projekt — Abschluss des Linux-Tracks.

• Komplexere Shell-Workflows anwenden
• Mit Intro/Intermediate-Linux verknüpfen

Lesson · Lesson · 5 min

Kurzer Hinweis: wie Codio-Lektionen in diesem Web-Block funktionieren.

• Codio als Lern- und Übungsraum nutzen
• Fortschritt und Abgaben prüfen

Lesson · Lesson · Codio · 3 hrs

Client-Server-Modell, URLs, Browser — Fundament vor HTTP-Details.

• Request/Response-Zyklus skizzieren
• Statische vs. dynamische Seiten grob unterscheiden

Lesson · Lesson · Codio · 3 hrs

Methoden, Statuscodes, Header — und Inspektion mit Postman/Browser-DevTools.

• GET/POST und gängige Statuscodes (200, 404, 500)
• Network-Tab und Postman für manuelle Requests

Lesson · Lesson · Codio · 4 hrs

HTTP aus Python: `requests.get/post`, JSON-Body, Fehlerbehandlung.

• `response.status_code` und `.json()` prüfen
• API-Keys/Parameter sicher übergeben (keine Secrets committen)

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: Zootopia-Daten über API holen und verarbeiten/darstellen.

• API-Responses parsen und in Strukturen legen
• Fehlerhafte Responses robust behandeln

Lesson · Lesson · Academy · 4 hrs

Einstieg in objektorientiertes Denken: Klasse, Instanz, Attribute und Methoden.

• `class`, `__init__` und `self` verstehen
• Zustand in Attributen halten, Verhalten in Methoden
• Objekt vs. primitiver Datentyp abgrenzen

Lesson · Lesson · Academy · 4 hrs

Vererbung, Überschreiben und sinnvolle Klassenhierarchien ohne Over-Engineering.

• Basisklasse und Subklasse mit `super()`
• Wann Vererbung vs. Komposition passt
• Öffentliche vs. interne Attribute grob trennen

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: Shop-/Produkt-Modell mit Klassen — Inventar und Preise objektorientiert.

• Domäne in Klassen schneiden (Produkt, Lager, …)
• Methoden für Kauf/Bestand statt losem Skriptcode

Lesson · Lesson · Codio · 3 hrs · Optional

Optional: erster Flask-Server — App-Objekt, Route, Response im Browser.

• `Flask(__name__)` und `@app.route`
• Request/Response im Web-Kontext

Lesson · Lesson · 30 min

Flask lokal starten und die minimale App-Struktur nachvollziehen.

• Dev-Server starten und Route testen
• Projektordner für eine kleine Web-App anlegen

Lesson · Lesson · Codio · 4 hrs · Optional

Optional: Blueprints, Config, Fehlerseiten und robustere App-Struktur.

• Routen und Hilfslogik trennen
• Statische Dateien und Templates organisieren

Lesson · Lesson · 20 min · Optional

Optional: Jinja-Templates — Variablen, Schleifen, Vererbung von Layouts.

• `render_template` und Kontextvariablen
• Base-Template und `{% block %}`

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: Blog mit Flask — Beiträge anzeigen und serverseitig rendern.

• CRUD-Ideen für Posts in Routes abbilden
• Templates für Listen- und Detailansicht

Lesson · Lesson · Codio · 4 hrs · Optional

Optional: JSON-APIs mit Flask — Statuscodes, Serialisierung, REST-Ideen.

• `jsonify` und HTTP-Methoden (GET/POST/…)
• Ressourcen-URLs klar benennen

Lesson · Lesson · 35 min

HTML wird auf dem Server gebaut — SEO, erster Paint, klassisches Flask-Muster.

• Wann SSR sinnvoll ist
• Unterschied zu reinen JSON-APIs

Lesson · Lesson · 45 min · Optional

Optional: UI im Browser, Daten per API — SPA-Idee und Trade-offs.

• API + Frontend-Trennung
• Wann CSR Komplexität lohnt

Lesson · Lesson · 10 min · Optional

Optional: Rollen Front-end, Back-end, Full-Stack — Orientierung für den Lernpfad.

• Skill-Profile grob zuordnen
• Python/Flask im Back-end-Kontext einordnen

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: Blog-Daten als API — Endpoints, JSON, Client-Zugriff.

• API-Verträge (Payload, Status) festlegen
• Masterblog-UI und API verbinden oder parallel denken

Lesson · Lesson · Academy · 5 hrs · Optional

Tiefere OOP-Muster: Abstraktion, Interfaces-Ideen und saubere Klassendesigns.

• Verantwortung pro Klasse schärfen
• Überkomplexe Hierarchien vermeiden

Lesson · Lesson · Academy · 3 hrs · Optional

`@property`, `__str__` / `__repr__` und weitere Dunder für idiomatischen Python-Stil.

• Getter/Setter über Properties statt öffentlicher Felder
• Lesbare Objekt-Darstellung mit `__str__`

Project · Codio · Score-Ziel: 100 / 100 · Optional

Erweiterung von Best Buy: mehr Features, robustere Klassen, bessere Struktur.

• Bestehenden OOP-Code refaktorieren statt neu schreiben
• Score als Iterationssignal nutzen

Lesson · Lesson · Optional

Vorschau auf die finale Movie-Project-Phase — Scope und Erwartungen klären.

• Frühere Phasen mit Final-Scope verknüpfen
• Offene TODOs vor dem Capstone sammeln

Lesson · Lesson · 10 min

Roadmap SE106: Databases 1/2, Movie Final Phase und AI Productivity.

• SQL als neues Kernwerkzeug neben Python
• Capstone und optionale Advanced-Kurse trennen

Lesson · Lesson · 10 min

Warum Datenbanken? Persistenz, Abfragen und Abgrenzung zu Dateien/JSON.

• Tabellen vs. Dateien grob vergleichen
• Wann eine DB die bessere Speicherwahl ist

Lesson · Lesson · Academy · 3 hrs 30 min

`SELECT`, `WHERE`, `ORDER BY`, Aggregation — die tägliche SQL-Basis.

• Spalten und Zeilen in Relationen lesen
• Filter und Sortierung korrekt kombinieren

Lesson · Lesson · 1 hr · Optional

Optional: Primär-/Fremdschlüssel, Normalisierungsideen, sinnvolle Tabellen.

• Beziehungen 1:n und n:m skizzieren
• Redundanz vs. Joins abwägen

Lesson · Lesson · Academy · 5 hrs

Joins, Subqueries und komplexere Abfragen für echte Datenmodelle.

• INNER/LEFT JOIN gezielt wählen
• Aggregate mit `GROUP BY` / `HAVING`

Lesson · Lesson · 50 min

Dateibasierte DB ohne Server — ideal für Lernen und kleine Apps.

• `.db`-Datei anlegen und öffnen
• Grenzen von SQLite vs. Server-DBs kennen

Lesson · Lesson · Codio · 2 hrs 30 min · Optional

Optional: `sqlite3` in Python — Connect, Cursor, Parameterized Queries.

• SQL-Injection mit Parametern vermeiden
• Transaktionen und `commit` verstehen

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: SQL-Abfragen schreiben und Daten auswerten.

• Anforderungen in SQL-Schritte übersetzen
• Ergebnisse gegen Erwartung prüfen

Lesson · Lesson · Academy · 3 hrs

Schreibende SQL-Befehle: Daten anlegen, ändern, löschen — mit Vorsicht.

• `INSERT` / `UPDATE` / `DELETE` und WHERE-Fallen
• Backups/Transaktionen vor destruktiven Ops

Lesson · Lesson · 25 min

Tabellen als Klassen: ORM-Idee und Trade-offs gegenüber reinem SQL.

• Mapping Objekt ↔ Zeile grob skizzieren
• Wann Roh-SQL trotzdem bleibt

Lesson · Lesson · Academy · 4 hrs

Modelle, Sessions und Queries mit SQLAlchemy — der Python-ORM-Standard.

• Model-Klassen und Relationships definieren
• Session: add / commit / query

Project · Codio · Score-Ziel: 100 / 100

Codio-Projekt: Bücher-DB mit ORM — Modelle, CRUD, Abfragen.

• Domäne in SQLAlchemy-Models gießen
• ORM-Queries statt String-SQL wo sinnvoll

Lesson · Lesson

Kickoff der Final Phase: Erwartungen, Bewertung und Tipps zum Durchhalten.

• Phasen 1/2 mit Final-Anforderungen abgleichen
• Risiken und Blocker früh listen

Project · Codio · Score-Ziel: 100 / 100

Abschlussprojekt: Features integrieren, Code aufräumen, Score maximieren.

• Module aus früheren Units wiederverwenden
• Tests/Score iterativ hochziehen

Lesson · Lesson · 10 min

Was Advanced Courses bedeuten — Tempo, Tiefe und Erwartungen.

• Unterschied Core vs. Advanced
• Eigene Kapazität realistisch planen

Lesson · Lesson · 10 min

Kickoff AI Productivity: KI als Hebel für Lernen und Coding-Alltag.

• KI-Hilfe kritisch und gezielt nutzen
• Eigene Denkschritte nicht ersetzen

Lesson · Lesson · 5 min

Voraussetzungen und Checkliste vor dem Einstieg in die Hausaufgabe.

• Tools/Accounts bereithalten
• Abgabefrist und Format prüfen

Project · Project · Codio · 7 hrs · Optional

Optionale Codio-Hausaufgabe: längerer Praxisblock mit Abgabe.

• Anforderungen vollständig lesen bevor man baut
• Iteration statt Big-Bang-Abgabe

Bridge · Knowledge Hub

Tokens, Kontextfenster und praxisnahe Grenzen von Sprachmodellen.

• Wann LLMs helfen — und wann Review Pflicht ist
• Kosten/Limits grob einordnen

Bridge · Knowledge Hub

Strukturierte Prompts für Generierung, Debugging und Architektur.

• Rolle, Ziel, Constraints, Output-Format
• Iterativ einen Aspekt pro Runde ändern

Practice · Practice

Im Practice-Studio Aufgaben lösen und die KI-Hilfe für den nächsten Schritt nutzen.

• Library nachschlagen statt raten
• Keine Blind-Copy der vollen Lösung