Software-Programmierkurs

Lektion 1 • Einrichten Ihrer Entwicklungsumgebung

Installiert und konfiguriert einen Code-Editor, eine Laufzeitumgebung und einen Paketmanager. Stellt sicher, dass jeder Teilnehmer über einen identischen, reproduzierbaren Arbeitsbereich verfügt, bevor er Code schreibt.

Lektion 2 • Kenntnisse in der Kommandozeile

Vermittelt Navigation, Dateibearbeitung und Prozessverwaltung in einem Terminal. Flüssige Kommandozeilenkenntnisse beschleunigen jeden nachfolgenden Arbeitsablauf im Kurs.

Lektion 3 • Versionskontrolle mit Git

Führt Git als das branchenübliche Werkzeug zum Nachverfolgen von Änderungen und zur Zusammenarbeit ein. Die Teilnehmer committen, verzweigen und pushen Code bis zum Ende dieses Abschnitts.

Lektion 1 • Sammlungen und Iterationsmuster

Führt Arrays, Listen und Dictionaries zum Speichern gruppierter Daten ein. Die Teilnehmer wenden Iterationsmuster an, um reale Datensätze effizient zu verarbeiten.

Lektion 2 • Variablen, Typen und Operatoren

Erklärt, wie Daten gespeichert, typisiert und durch Ausdrücke transformiert werden. Bietet das Vokabular, das zum Lesen und Schreiben jeder Codeanweisung benötigt wird.

Lektion 3 • Funktionen und modularer Code

Definiert Funktionen als wiederverwendbare, testbare Logikeinheiten. Modulares Design reduziert Duplizierung und ist die Grundlage aller größeren Programme in diesem Kurs.

Lektion 4 • Kontrollfluss und Entscheidungsfindung

Behandelt Bedingungen und Schleifen, die Programmlaufzeitpfade steuern. Die Teilnehmer implementieren Verzweigungslogik und iterative Algorithmen von Grund auf.

Lektion 1 • Komposition und Dependency Injection

Stellt Komposition der Vererbung gegenüber und führt Dependency Injection ein. Die Teilnehmer lernen, wann „Hat-ein“-Beziehungen gegenüber „Ist-ein“-Hierarchien zu bevorzugen sind.

Lektion 2 • Klassen und Objekte

Definiert Klassen als Baupläne und Objekte als Instanzen mit Zustand und Verhalten. Verbindet die OOP-Syntax mit den im vorherigen Kapitel eingeführten modularen Funktionen.

Lektion 3 • Vererbung und Polymorphie

Modelliert „Ist-ein“-Beziehungen durch Klassenhierarchien und Methodenüberschreibung. Die Teilnehmer schreiben polymorphen Code, der mehrere Typen über eine einzige Schnittstelle behandelt.

Lektion 4 • SOLID-Entwurfsprinzipien

Wendet fünf grundlegende OOP-Entwurfsprinzipien auf reale Codebeispiele an. Die Teilnehmer refaktorisieren schlecht strukturierte Klassen in saubere, wartbare Entwürfe.

Lektion 1 • Sortier- und Suchalgorithmen

Implementiert und vergleicht klassische Sortier- und Suchalgorithmen. Die Teilnehmer führen Benchmarks für Implementierungen durch und begründen die Algorithmenauswahl anhand der Komplexität.

Lektion 2 • Lineare Datenstrukturen

Behandelt Arrays, verkettete Listen, Stapelspeicher und Warteschlangen mit ihren Kompromissen. Die Teilnehmer implementieren jede Struktur und identifizieren geeignete Anwendungsfälle.

Lektion 3 • Komplexitätsanalyse

Führt die Big-O-Notation zur Messung der Algorithmeneffizienz ein. Die Teilnehmer bewerten die Code-Leistung, bevor sie zwischen konkurrierenden Implementierungen wählen.

Lektion 4 • Strategien für den Algorithmenentwurf

Führt Divide-and-Conquer-, dynamische Programmier- und Greedy-Ansätze ein. Die Teilnehmer zerlegen komplexe Probleme in lösbare Teilprobleme.

Lektion 1 • Grundlagen relationaler Datenbanken

Erklärt Tabellen, Schlüssel und Beziehungen als die Grundlage relationaler Datenbanken. Die Teilnehmer modellieren eine Domäne mithilfe von Entity-Relationship-Diagrammen, bevor sie SQL schreiben.

Lektion 2 • Datenbankintegration im Anwendungscode

Verbindet eine Anwendung mithilfe eines ORM und mit Rohabfragemustern mit einer Datenbank. Die Teilnehmer erstellen eine Repository-Schicht, die die Persistenz von der Geschäftslogik abstrahiert.

Lektion 3 • NoSQL und Dokumentenspeicher

Stellt Dokument-, Schlüssel-Wert- und spaltenorientierte Speicher relationalen Datenbanken gegenüber. Die Teilnehmer wählen das richtige Persistenzmodell für eine gegebene Datenform.

Lektion 4 • SQL-Abfragesprache

Behandelt SELECT-, INSERT-, UPDATE-, DELETE- und JOIN-Operationen. Die Teilnehmer schreiben Abfragen, die echte Geschäftsfragen anhand eines Beispieldatensatzes beantworten.

Lektion 1 • Erstellen einer RESTful API

Entwirft und implementiert REST-Endpunkte gemäß ressourcenorientierten Konventionen. Die Teilnehmer erstellen eine CRUD-API, die von der Datenbankschicht aus dem vorherigen Kapitel unterstützt wird.

Lektion 2 • Authentifizierung und Autorisierung

Implementiert tokenbasierte Authentifizierung und rollenbasierte Zugriffskontrolle. Die Teilnehmer sichern Endpunkte, sodass nur autorisierte Benutzer auf geschützte Ressourcen zugreifen können.

Lektion 3 • Konsumieren externer APIs

Führt authentifizierte HTTP-Anfragen an Drittanbieterdienste durch und verarbeitet Antworten. Die Teilnehmer integrieren eine öffentliche API unter Verwendung von Best Practices in ihre Anwendung.

Lektion 4 • HTTP und der Webanfragezyklus

Erklärt HTTP-Methoden, Statuscodes, Header und das Anfrage-Antwort-Modell. Dieses mentale Modell untermauert jede später verwendete API und jedes Web-Framework.

Lektion 1 • Integrations- und API-Tests

Testet Interaktionen zwischen Komponenten und validiert API-Verträge durchgängig. Die Teilnehmer fangen Integrationsfehler ab, die Unit-Tests nicht erkennen können.

Lektion 2 • Unit-Testing in der Praxis

Schreibt isolierte Unit-Tests für Funktionen und Klassen unter Verwendung eines Test-Frameworks. Die Teilnehmer erreichen eine hohe Abdeckung in zentralen Geschäftslogikmodulen.

Lektion 3 • Testgetriebene Entwicklung

Wendet den Red-Green-Refactor-Zyklus an, um das Design durch fehlschlagende Tests voranzutreiben. Die Teilnehmer erfahren, wie TDD einfacheren, besser testbaren Code hervorbringt.

Lektion 4 • Testgrundlagen und -strategie

Stellt die Testpyramide und die Kosten-Nutzen-Kompromisse jeder Ebene vor. Die Teilnehmer planen eine Teststrategie, bevor sie einen einzigen Testfall schreiben.

Lektion 1 • Resilienz und Fehlertoleranz

Entwirft Systeme, die unter Ausfällen durch den Einsatz von Circuit-Breakern und Wiederholungen kontrolliert degradieren. Die Teilnehmer wenden Resilienzmuster auf die in früheren Kapiteln erstellte API an.

Lektion 2 • Skalierbarkeits- und Leistungsdesign

Behandelt horizontale Skalierung, Caching-Strategien und Load Balancing auf der Designebene. Die Teilnehmer identifizieren Engpässe vor dem Schreiben von Code mithilfe der Kapazitätsplanung.

Lektion 3 • Übersicht über Architekturmuster

Bietet einen Überblick über geschichtete, ereignisgesteuerte und Microservices-Architekturen mit ihren Kompromissen. Die Teilnehmer ordnen ein Anforderungsdokument einem geeigneten Architekturstil zu.

Lektion 4 • Systemdesign-Praxis

Wendet alle Architekturkonzepte an, um ein realistisches verteiltes System durchgängig zu entwerfen. Die Teilnehmer präsentieren und verteidigen ihre Entwürfe gegenüber Skalierbarkeits- und Ausfallszenarien.