Beschreibung: Viele Entwickelnde haben erste Erfahrungen mit ChatGPT, Claude oder Gemini gesammelt und fragen sich, wie sie diese Tools effektiv in ihren Entwicklungsprozess integrieren können. Oder sie nutzen GitHub Copilot bereits - aber oft schöpfen sie nur einen Bruchteil des Potenzials aus. Dieser Intensivkurs geht weit über “Tab drücken und hoffen” hinaus: Sie lernen, wie Sie KI-Assistenten wie GitHub Copilot, Claude Code und Cursor methodisch und zielgerichtet einsetzen. Wir zeigen Ihnen, warum viele Teams mit KI-Tools scheitern und wie Sie es besser machen.

Was diesen Kurs von anderen unterscheidet: Wir arbeiten nicht mit konstruierten Beispielen oder theoretischen Szenarien, sondern entwickeln live an einem echten Projekt - mit echten Prompts, echten Herausforderungen und echten Ergebnissen. Jede vorgestellte Technik wird unmittelbar vorgeführt und validiert. Während andere Kurse KI-Vorteile nur andeuten, erleben Sie hier in Echtzeit, was funktioniert, was nicht - und vor allem warum.

Der Workshop behandelt den gesamten Entwicklungszyklus: Von der Design-Phase mit Architekturdiagrammen über die Implementierung bis hin zu Testing, Code-Reviews und CI/CD sowie dem finalen Deployment. Sie erfahren, wie Sie Ihre Codebasis “KI-ready” machen, welche Prompt-Engineering-Techniken wirklich funktionieren und wie Sie mit den Grenzen von LLMs umgehen - Halluzinationen, Confirmation Bias und das berüchtigte “70%-Problem”, bei dem KI Sie fast ans Ziel bringt, aber die letzten Schritte in Ihren Händen liegen.

Besonderer Fokus liegt auf den neuesten Entwicklungen: Custom Instructions, Prompt Files, Skills, agentenbasierte Workflows und das MCP-Protokoll - Techniken, die gerade die Art verändern, wie Teams mit KI-Assistenten arbeiten. Sie lernen nicht nur, was diese Features können, sondern wann und wie Sie sie sinnvoll einsetzen.

Sie verlassen den Workshop mit einem praxiserprobten Toolkit, das Sie nicht nur kennen, sondern live in Aktion gesehen haben - und das Sie direkt am nächsten Tag einsetzen können. Unabhängig davon, ob Sie GitHub Copilot, Claude Code oder eine andere Lösung bevorzugen – dieser Kurs vermittelt werkzeugübergreifende und -unabhängige Techniken und macht Sie somit fit für die Zukunft der Softwareentwicklung.

Schulungsziel: Nach diesem Workshop nutzen Sie KI-Assistenten nicht mehr zufällig, sondern gezielt und effizient. Sie verstehen die Stärken und Grenzen aktueller Modelle, können Ihre Codebasis für optimale KI-Unterstützung vorbereiten und wissen, welche Technik für welche Aufgabe die richtige ist. Das Ergebnis: Spürbar höhere Produktivität bei gleichbleibender Codequalität und Architekturkontrolle.

Zielgruppe: Erfahrene Entwickelnde, die über die Basics hinauswachsen und KI-Tools als echten Produktivitätshebel nutzen möchten - nicht als Spielerei, sondern als integralen Bestandteil ihres Entwicklungsalltags.

Voraussetzung: Mehrjährige Programmiererfahrung in mindestens einer Programmiersprache. GitHub Copilot oder ein vergleichbares Tool ist vorinstalliert, sowie VS Code als IDE vorhanden. Erste Erfahrungen mit KI-Assistenten sind hilfreich, aber nicht zwingend erforderlich.

---

Tag 1: Grundlagen und Workflow-Integration

1. Einführung: KI-gestützte Entwicklung

• Aktueller Stand der KI in der Softwareentwicklung
• Die Rolle von KI: Assistenz, nicht Ersatz
• Warum Firmen mit KI-Tools scheitern
• Was sind Stärken und Schwächen von KI-Tools?
• Das “70%-Problem”: KI bringt Dich 70% des Weges
• Motivation: Von AI Slop hin zu AI Enablement

2. Governance, Datenschutz und Sicherheit

• Quellcode als sensibles Gut
• Security-First Mindset bei KI-generiertem Code
• Europäische Lösungen
• Open Weight-Modelle selbst hosten: Möglichkeiten und Herausforderungen
• Lizenzierung und Datenschutz, DSGVO-Konformität
• EU AI Act - Auswirkungen auf Entwicklung und Unternehmen
• Anleitung für die Praxis: Datenschutz- und Sicherheitscheckliste für KI-Tools

3.Marktüberblick Coding-Tools & Modelle

• Überblick über populäre Tools (Github Copilot, Claude Code, Cursor etc.)
• Die Qual der Wahl: Welches Modell soll ich nutzen?
• Marktübersicht: Relevante Modelle nach Use-Case
• Typische Beispiele für den Einsatz
• Unterstützte Sprachen und Frameworks
• Praktische Übung: Eine typische Webseite mit unterschiedlichen Tools erstellen & vergleichen

4. Copilot in VS Code effektiv nutzen

• Konfigurationsmöglichkeiten, Einstellungen
• Shortcuts: Slash-Kommandos, Chat Participants und Kontextvariablen
• Unterschied: Inline-Vervollständigung, Blockvervollständigung und Chat
• Praktische Übung: “leere” Methoden mit Hilfe von Github Copilot implementieren.

5. Context Engineering: KI gezielt steuern durch Kontextaufbau und Modi

• Kontext: Welche Informationen werden herangezogen? Wie kann ich dies gezielt beeinflussen?
• Kontext aufbauen: Kommentare als Steuerungsinstrument
• Inline-Suggestions vs. Chat-Interface nutzen
• Ask vs. Edit vs. Plan vs. Agent: Welcher Modus wann und wozu
• Iteration und Verfeinerung von Vorschlägen
• Agent Mode: Ganzheitliche Unterstützung (Dateisystem, Terminal, Screenshots, …)
• Praktische Übung: Erstellen eines neuen Workspaces mit Hello-World-REST-API (Endpoint: /hello-world)

---

Tag 2: Einführung einer Methodik für konstant gute Ergebnisse

6. Jenseits von Prompt-Engineering: Plädoyer für einen Paradigmenwechsel

• Von Trial & Error zur Methodik: Warum “Tab drücken und hoffen” nicht ausreicht
• Einführung einer Methodik
• Brainstorming & Requirements mit Copilot
• Text als Universal-Interface am Beispiel: Diagramme mit Mermaid-JS
• Plan Mode: Entwurf und Abarbeitung schrittweiser Implementierungspläne
• Tests als integraler Bestandteil der Entwicklung mit KI-Unterstützung
• Unit- und Integrationstests generieren
• Testdaten mit Copilot erzeugen
• Praktische Übung: Diskussion über die Umsetzung eines Todo-REST APIs
• Praktische Übung: Erstellung eines READMEs und von Dokumentation der Endpunkte des Todo-REST APIs
• Praktische Übung: Erstellung von Architektur- und Design-Diagrammen für das Todo-REST API
• Praktische Übung: Erstellung und Implementierung eines Plans für ein Todo-REST API
• Praktische Übung: Unit- und Integrationstests für das REST-API, sowie Testdaten mit Copilot generieren und in die Test-Suite integrieren
• Praktische Übung: Weitere Funktionalität hinzufügen und dabei Tests erstellen und die Doku anpassen bzw. erweitern
• Praktische Übung: CI/CD-Pipeline mit Copilot erstellen, um die Tests automatisch auszuführen und Releases/Deployments zu automatisieren

7. Prompt Engineering für Entwickelnde

• Effiziente Promptgestaltung & Techniken zur Verbesserung der Vorschlagsqualität (z.B. präzisere Prompts, Code-Strukturierung)
• Iteratives Verbessern der Prompts
• Zero-Shot- & Multi-Shot-Prompting
• Prompt Chaining und Chain-of-Thought Prompting
• Generated-Knowledge Prompting
• System, User, Agent: “Copilot-Rollen” und das Persona Pattern
• Promptoptimierung: Prompts sukzessive verbessern, um die Qualität der Vorschläge zu steigern
• Auch KI macht mal Fehler: Beispiele für Fehler und Lösungsansätze
• Halluzinationen erkennen und vermeiden
• Sycophancy (“Schmeichelei”) / Confirmation Bias erkennen und vermeiden
• Praktische Übung: Iteratives Verbessern von Prompts für die Implementierung eines neuen API-Endpunkts

---

Tag 3: Fortgeschrittene Techniken und Unternehmenseinsatz

8. LLM-Grundlagen für Entwickelnde

• Grundlagen: Tokens, Kontext, Wahrscheinlichkeiten
• Eingabe- und Ausgabelimits verstehen
• Strategien zur Umgehung von Kontextlimits
• Kostenbewusstes Arbeiten: Umgang mit Rate Limits, Premium Requests, etc.

9. Prompt Customization & Erweiterte Techniken

• Custom Instructions effektiv nutzen
• Prompt Files: Prompts als “Funktionen” wiederverwenden
• Agent Skills: Spezialisierte Fähigkeiten erstellen und nutzen
• Custom Agents: Eigene “Chat-Modi” erstellen und Tool-Orchestrierung
• Praktische Übung: Prompt Customization Files mit Hilfe von KI erstellen
• Praktische Übung: Prompt Customization Files mit Hilfe von KI validieren, debuggen und optimieren

10. KI-freundliche Codebasis

• Voraussetzungen für eine KI-freundliche Codebasis
• Clean Code Prinzipien als KI-Enabler
• Dokumentation als Kontext-Quelle
• README, Architecture Decision Records (ADRs)
• Tests als Spezifikation
• Typensystem und klare APIs
• Anti-Patterns: Was KI behindert
• Was macht eine “KI-freundliche” Codebasis aus?

11. Das MCP-Protokoll

• Wie funktioniert MCP?
• MCP-Architektur
• Server Primitives
• Client Primitives
• Wofür kann MCP genutzt werden?
• Welche MCP-Server gibt es? Wo finde ich sie?
• Eigene MCP-Server entwickeln

Beschreibung: Dreitägiger Workshop, der Strategien, Techniken und Best Practices zur Migration von Legacy-Anwendungen mithilfe von KI-gestützten Tools wie GitHub Copilot vermittelt. Gleichzeitig vermittelt der Workshop bewährte Strategien und Techniken zur Migration von Legacy-Systemen, die mit und ohne KI-Unterstützung angewendet werden können. Die grundsätzliche Fragestellung, ob die reine Modernisierung im Sinne eines Refactorings ausreicht oder eine komplette Neuentwicklung eventuell sinnvoller ist, wird explizit behandelt und im Kontext von KI-Unterstützung neu bewertet.

Als roter Faden wird ein exemplarisches Legacy-System analysiert und anschließend modernisiert und in eine moderne Architektur überführt. Dabei werden verschiedene Migrationsstrategien wie das Strangler Fig Pattern, Modularisierung einer monolithischen Anwendung(“Modulith”), die Aufteilung in Microservices behandelt. Für Firmenschulungen können auf Anfrage auch spezifische Legacy-Systeme und Architekturen als Praxisbeispiele verwendet werden, gerne auch mittels NDA geschützte Systeme. Als Teilnehmende lernen Sie, wie Sie KI-gestützte Tools effektiv einsetzen können, um den Migrationsprozess zu beschleunigen, Fehler zu reduzieren und die Codequalität zu verbessern.

Migrationen umfassen verschiedenste Bereiche, darunter z.B. Backend, Frontend, Datenbanken, Infrastruktur und Dokumentation. Wir behandeln eine Vielzahl von Use Cases und Migrationsszenarien, um den Teilnehmenden ein breites Spektrum an Anwendungsfällen in jedem dieser Bereiche zu vermitteln.

Demo-Legacy-System: Ein einfaches Legacy-System namens “Acme Invoice Manager” wird als Demo-System verwendet, um die Migrationsstrategien und -techniken praktisch zu demonstrieren.

Dieses System umfasst:

• eine monolithische Backend-Anwendung basierend auf Java-Servlets mit traditioneller Three-Tier-Architektur
• ein veraltetes Frontend mit serverseitigem Rendering von JSP-Templates und minimaler Interaktivität basierend auf jQuery
• eine relationale Datenbank mit kryptischen Tabellennamen und schlechtem Design, Queries werden direkt im Code ausgeführt
• eine einfache Infrastruktur mit manuell verwalteten Servern und Deployments
• eine unzureichende Dokumentation, die hauptsächlich aus Word-Dokumenten und Kommentaren im Code besteht

Das Zielsystem soll die folgenden Eigenschaften aufweisen:

• Modularisierte API-Backend-Anwendung basierend auf FastAPI (Python)
• Modernes, reaktives Frontend basierend auf React und Tailwind CSS
• Gut gestaltete relationale Datenbank (PostgreSQL) mit klaren Tabellen in Normalform und Verwendung eines ORM (SQLAlchemy)
• Containerisierte Infrastruktur mit Docker, automatisierte CI/CD-Pipeline via GitHub Actions
• Ausführliche Dokumentation in Markdown plus Inline-Dokumentation im Code

Mögliche Migrationsbeispiele für Firmenschulungen

Eine kleine Auswahl möglicher Migrationsbeispiele:

Backend:

• Wordpress-Webseite -> Astro (Static Site Generator)
• Spring JSF mit XML-Konfiguration -> Spring Boot mit Annotationen

Frontend:

• Desktop mit Swing UI -> Webanwendung
• HTML, JS & jQuery und CSS-Spaghetti -> React mit TypeScript und Tailwind

Zielgruppe: Erfahrene Software-Entwickelnde und Architekt:innen, die Legacy-Anwendungen modernisieren oder in eine moderne Architektur überführen möchten.

Voraussetzung: GitHub Copilot ist installiert und eingerichtet, VS Code als IDE vorhanden. Docker ist installiert und konfiguriert. Die Demo-Legacy-Anwendung wird mittels Docker bereitgestellt - Grundkenntnisse im Umgang mit Docker sind hilfreich, werden aber nicht zwingend benötigt. Kenntnisse im Umgang mit GitHub Copilot sowie in mindestens einer Programmiersprache und grundlegender Softwarearchitektur werden vorausgesetzt. Erfahrung mit Legacy-Systemen ist von Vorteil, aber nicht zwingend notwendig.

---

Tag 1: Grundlagen & Analyse von Legacy-Systemen

1. Überblick Legacy-Migration & essenzielle Literatur

• Was ist Legacy-Code? Definition und typische Merkmale
• Wichtige Literatur: Michael Feathers “Working Effectively with Legacy Code”, Martin Fowlers “Refactoring”, Domain-Driven Design von Eric Evans u.a.
• Rewrite vs. Refactoring: Entscheidungskriterien und Abwägungen
• Wann ist eine komplette Neuentwicklung sinnvoll?
• Wie verändert KI-Unterstützung diese Entscheidung?

2. Migrationsstrategien im Überblick

• Big Bang vs. Incremental Migration
• Strangler Fig Pattern in der Praxis
• Modularisierung einer monolithischen Anwendung (“Modulith”)
• Microservices: Wann sinnvoll, wann nicht?
• Vor- und Nachteile der verschiedenen Ansätze
• Technische Schulden: Identifikation, Bewertung und Priorisierung

3. Copilot-Grundlagen für Legacy-Migration

• Copilot Modi im Überblick: Ask, Edit, Plan, Agent
• Welcher Modus für welche Migrationsaufgabe?
• Workspace-Setup: Alt- und Neusystem zusammenbringen
• Context Engineering: Kontext gezielt aufbauen
• Umgang mit Token-Limits bei großen Legacy-Codebasen
• Text First: Nutzung textbasierter Ressourcen und Dokumentation im Kontext
• Praktische Demonstration: Analyse des “Acme Invoice Manager” mit Copilot

4. Code-Archäologie mit Copilot

• Legacy-Code verstehen: Reverse Engineering bei fehlender Dokumentation
• Umgang mit kryptischem Code und “Magic Numbers”
• Undokumentierte Geschäftsregeln identifizieren
• Business-Logik extrahieren und Edge Cases finden
• Copilot für Code-Erklärungen und Zusammenhänge nutzen
• Praktische Übung: Analyse einer Legacy-Komponente im “Acme Invoice Manager”

5. Tests als Absicherung bei Migrationen

• Seams: Grenzen im Code identifizieren
• Sensing vs. Separation
• Characterization Tests: Tests für ungetesteten Legacy-Code
• Test-Strategien bei fehlender Testabdeckung
• Warum Tests bei KI-gestützten Migrationen essenziell sind
• Copilot für Test-Generierung nutzen
• Praktische Übung: Characterization Tests für Legacy-Modul erstellen

6. Domain-Driven Design als Grundlage

• Bounded Contexts als Migrationsgrenzen
• Aggregates, Entities und Value Objects
• DDD und Seams: Zusammenhänge verstehen
• Migrationspläne basierend auf Domain-Modellen
• Praktische Übung: Domain-Modell für “Acme Invoice Manager” erstellen

---

Tag 2: Prompt Engineering & Migrationsplanung

7. Prompt Engineering für Legacy-Migrationen

• Effiziente Promptgestaltung für Migrationsaufgaben
• Zero-Shot- & Multi-Shot-Prompting
• Prompt Chaining und Chain-of-Thought
• Generated Knowledge Prompting
• Halluzinationen und Confirmation Bias vermeiden
• Prompt Templates und Wiederverwendbarkeit
• JSON & XML zur Strukturierung von Prompts
• Prompts als gelebte Dokumentation: Migrationsentscheidungen dokumentieren
• Praktische Übung: Effektive Prompts für verschiedene Migrationsszenarien erstellen

8. Migrationsplanung mit Copilot

• Einen Gesamtplan für die Migration erstellen
• Schrittweise Migration einzelner Komponenten planen
• Seams und Migrationsgrenzen mit Copilot identifizieren
• Priorisierung von Migrationsschritten (Business Value vs. Risiko)
• Risikomanagement: Datenverlust, Downtime, Rollback-Strategien
• Feature Flags für schrittweise Migration
• Praktische Übung: Migrationsplan für ein Modul erstellen

9. Backend-Migration in der Praxis

• Von Java Servlets zu FastAPI (Python)
• Code-Transformation mit Copilot durchführen
• Business-Logik extrahieren und portieren
• Umgang mit Breaking Changes und veralteten Dependencies
• Custom-Built-Lösungen vs. Standard-Libraries
• API-Design und REST-Endpoints migrieren
• Praktische Übung: Ein Backend-Modul migrieren

10. Datenbank-Migration

• Datenbankschema analysieren und verbessern
• Von kryptischen Tabellennamen zu aussagekräftigen Schemas
• Einführung eines ORM (SQLAlchemy)
• Einfacher Export/Import bei gleicher Technologie
• Ausblick: Datenqualität, Normalisierung, Zero-Downtime-Strategien
• Praktische Übung: Schema-Migration einer Tabelle mit ORM

---

Tag 3: Frontend, Dokumentation & Deployment

11. Frontend-Migration

• Von JSP/jQuery zu React und Tailwind CSS
• Serverseitiges Rendering vs. Client-seitiges Framework
• Komponenten-basierte Architektur aufbauen
• State-Management im neuen Frontend
• Copilot für UI-Code-Generierung nutzen
• Praktische Übung: Eine View zu React migrieren

12. Dokumentation & Knowledge Transfer

• Legacy-Erkenntnisse dokumentieren mit Copilot
• Architecture Decision Records (ADRs) automatisch generieren
• Markdown-Dokumentation aus Legacy-Word-Dokumenten
• Diagramme mit Mermaid erstellen
• Inline-Dokumentation im migrierten Code
• Persistentes Copilot-Wissen für das Team aufbauen
• Code Reviews des migrierten Codes mit Copilot
• Praktische Übung: Dokumentation für migriertes Modul erstellen

13. Dockerisierung & CI/CD

• Dockerfiles für das migrierte System generieren
• Docker Compose für lokale Entwicklung
• CI/CD-Pipeline mit GitHub Actions aufbauen
• Deployment-Strategien für migrierte Anwendungen
• Praktische Übung: Docker-Setup und CI/CD-Pipeline für migriertes Modul

14. Antipatterns, Fallstricke & Best Practices

• Typische Antipatterns bei Legacy-Migrationen vermeiden
• Copilot-spezifische Fallstricke und wie man sie umgeht
• Security-Aspekte bei KI-generiertem Code
• Performance-Vergleiche: alt vs. neu
• Monitoring und Observability nach der Migration
• Ausblick: MCP (Model Context Protocol) für große Codebasen

Zielgruppe: Softwareentwickelnde und Architekt:innen, die Verschlüsselung, Signaturen und sichere Kommunikation in ihren Anwendungen richtig einsetzen wollen — ob Backend, Cloud oder Embedded.

Kurzbeschreibung: Welcher Verschlüsselungsmodus ist der richtige? Wie verwalte ich Schlüssel sicher? Was muss ich bei digitalen Signaturen nach eIDAS beachten? Und wie bereite ich mich auf Quantencomputer vor? Dieser Workshop — seit über 15 Jahren kontinuierlich weiterentwickelt — gibt Ihnen fundierte Antworten — von den Grundlagen symmetrischer und asymmetrischer Verfahren über TLS und PKI bis zur Post-Quanten-Migration.

Schulungsziel: Sie können Stream Cipher, Block Cipher und Authenticated Encryption sicher einsetzen. Sie wissen, wie Schlüsselmanagement und passwortbasierte Schlüsselerzeugung funktionieren. Digitale Signaturen und die europäischen Standards (CAdES, XAdES, PAdES) sind Ihnen vertraut. Sie verstehen das TLS-Handshake, können Zertifikatsketten prüfen und kennen die NIST- und BSI-Empfehlungen zur Post-Quanten-Kryptographie.

Voraussetzung: Der Workshop ist praxisorientiert und setzt keine tiefe Mathematik voraus — grundlegende Schulmathematik genügt. Programmiererfahrung ist hilfreich, um die Code-Beispiele nachzuvollziehen. Für alle, die tiefer in die mathematischen Aspekte eintauchen möchten, biete ich weiterführende Ressourcen an.

---

Tag 1: Grundlagen der Kryptographie

1. Grundlagen

• Kerckhoffs Prinzip
• Wie ist Verschlüsselung definiert
• Definition: “Was bedeutet sicher?”
• Definition von “Perfect Secrecy” und “Semantic Security”

2. Stream Cipher und CSPRNGs

• Stream Cipher
• Kryptographisch sichere Zufallsgeneratoren (CSPRNGs)
• Stream Cipher in der Praxis: RC4, Salsa20, ChaCha20
• CSPRNGs in der Praxis: Fortuna, Yarrow, /dev/urandom
• Kritik an RC4 und warum es nicht mehr verwendet werden sollte
• Kritik an /dev/urandom und warum es in der Praxis trotzdem sicher genug ist
• Kritik an CSPRNGs im Allgemeinen und warum sie trotzdem notwendig sind

3. Block Cipher

• Block Cipher
• Verschlüsselungs-Modi (ECB, CBC, CTR, …)
• Was ist ein “Initialization Vector”?
• Vor- und Nachteile der verschiedenen Verschlüsselungs-Modi
• Padding-Verfahren

Tag 2: Symmetrische & Asymmetrische Verfahren, Digitale Signaturen

4. Hash-Funktionen & MACs

• Authenticated Encryption: Motivation für Message Authentication Codes
• Hash-Funktionen
• Message Authentication Codes (MACs)
• Authenticated Encryption
• Salsa20/Poly1305 als moderner Stream Cipher mit Authenticated Encryption
• AES-GCM als moderner Block Cipher mit Authenticated Encryption

5. Schlüssel- und Passwortmanagement

• Schlüssellängen
• Schlüsselerzeugung und -übergabe
• Schlüsselverwaltung
• Entropie
• Passwortbasierte Schlüsselerzeugung
• Speicherung und Verwaltung von Passwörtern

6. Asymmetrische Verschlüsselung

• Schlüsselaustausch: Motivation für asymmetrische Verschlüsselung
• Diffie-Hellman-Schlüsselaustausch
• Wozu dient ein “Public/Private Key”?
• RSA
• PKCS#1-Padding vs. PKCS#1-v2.0 (RSA-OAEP)
• Elliptische Kurven
• Empfehlungen zu Schlüssellängen und sicheren Kurven
• Warum mit asymmetrischer Verschlüsselung keine Daten verschlüsselt werden
• Die drei Anwendungsfälle für asymmetrische Verschlüsselung: Schlüsselaustausch, digitale Signaturen, Authentifizierungsprotokolle

7. Digitale Signaturen

• Motivation für digitale Signaturen
• Vergleiche mit handschriftlicher Signatur
• Die europäische Signaturverordnung (eIDAS) und ihre Anforderungen an digitale Signaturen
• Die europäischen Signaturstandards CAdES, XAdES und PAdES
• Was sind Seals, AdES, QES?
• Digitale Signaturen mittels RSA
• Digitale Signaturen mittels Elliptischen Kurven: ECDSA
• Kostenloser EU-Dienst zum Validieren von Signaturen
• Empfehlenswerte Verfahren und Schlüssellängen für digitale Signaturen

Tag 3: TLS, PKI und Post-Quanten-Kryptographie

8. Das TLS-Protokoll

• Data in Transit vs. Data at Rest
• Warum TLS meist die Lösung für Data in Transit ist
• Was TLS leisten kann und was nicht
• TLS 1.3 - Neuerungen, Vorteile, Risiken
• Das Record-Protokoll
• Das Handshake-Protokoll
• Verschlüsselte Records
• TLS Best Practices
• Tools zum Bewerten der TLS-Konfiguration von Servern
• Tools zum Debuggen von TLS-Verbindungen: OpenSSL, Wireshark

9. Public Key Infrastructure (PKI)

• Motivation für PKI
• Welche Alternativen gibt es zu PKI?
• Zertifikate und Zertifizierungsstellen (CAs)
• Die Rolle von Zertifikaten in der PKI
• Zertifikatsketten und Vertrauensanker
• Validierung von Zertifikaten
• Zertifikate sperren: CRLs & OCSP
• Key Usages und Extended Key Usages - Auswirkungen & Risiken
• Let’s Encrypt - Vorteile, Risiken, ACME-Protokoll
• Tools zum Validieren von Zertifikaten
• OpenSSL Cheatsheet mit den wichtigsten Befehlen

10. Post-Quanten-Kryptographie

• Warum Quantencomputer eine Bedrohung für die Kryptographie darstellen
• Welche kryptographischen Verfahren sind von Quantencomputern bedroht?
• Welche Ansätze gibt es für post-quanten-sichere Kryptographie?
• Hybride Kryptographie: Kombination von klassischen und post-quanten-sicheren Verfahren
• Panikmache oder berechtigte Sorge? Einschätzung der Bedrohungslage
• NIST Post-Quantum Cryptography: Standards und finale Kandidaten in FIPS 202-206, NIST SP 800-208
• NIST SP 1800-38A-C - Die offiziellen Empfehlungen zur Migration von NIST
• TR-02102: BSI-Empfehlungen zu Post-Quanten-Kryptographie
• Praxisempfehlungen: Konkrete Schritte, um sich auf die Post-Quanten-Ära vorzubereiten

Zielgruppe: Softwareentwickelnde, Architekt:innen und IT-Security-Verantwortliche, die ihre Systeme rechtzeitig auf die Post-Quanten-Ära vorbereiten wollen.

Kurzbeschreibung: Harvest Now, Decrypt Later — Angreifer sammeln schon heute verschlüsselte Daten, um sie mit zukünftigen Quantencomputern zu entschlüsseln. Dieser Workshop vermittelt Ihnen das nötige Wissen, um die Bedrohung realistisch einzuschätzen und Ihre Kryptographie-Infrastruktur gezielt zu modernisieren — von den neuen NIST-Standards über hybride Verfahren bis hin zu konkreten Migrationsschritten.

Schulungsziel: Sie verstehen, warum Quantencomputer klassische asymmetrische Verfahren bedrohen und welche Algorithmen betroffen sind. Sie kennen die neuen NIST-Post-Quanten-Standards und die BSI-Empfehlungen. Sie wissen, wie hybride Kryptographie funktioniert und können eine Migrationsstrategie für Ihre Organisation entwerfen.

Voraussetzung: Grundlegendes Verständnis von asymmetrischer Kryptographie (Public/Private Keys, Signaturen, TLS) ist hilfreich. Der Workshop erklärt die nötigen Grundlagen, sodass auch Teilnehmende ohne tiefes Kryptographie-Wissen folgen können. Mathematische Vorkenntnisse sind nicht erforderlich.

---

Tag 1: Post-Quanten-Kryptographie

1. Die Quanten-Bedrohung verstehen

• Wie Quantencomputer klassische Kryptographie angreifen: Shor- und Grover-Algorithmus
• Welche kryptographischen Verfahren sind betroffen — und welche nicht?
• Symmetrische Verfahren (AES, SHA): Warum sie weitgehend sicher bleiben
• Asymmetrische Verfahren (RSA, ECC, DH): Warum sie gebrochen werden
• Harvest Now, Decrypt Later: Warum die Bedrohung schon heute real ist
• Panikmache oder berechtigte Sorge? Eine realistische Einschätzung der Bedrohungslage
• Zeitrahmen: Wann werden kryptographisch relevante Quantencomputer erwartet?

2. Grundlagen post-quanten-sicherer Verfahren

• Welche mathematischen Probleme gelten als quanten-resistent?
• Gitter-basierte Kryptographie (Lattice-based): Das Fundament der meisten neuen Standards
• Hash-basierte Signaturen: Bewährte Sicherheit mit langer Geschichte
• Code-basierte Kryptographie: McEliece und Verwandte
• Multivariate Kryptographie: Ansätze und Herausforderungen
• Vor- und Nachteile der verschiedenen Ansätze im Vergleich

3. Die neuen NIST-Standards

• Der NIST-Standardisierungsprozess: Von 69 Einreichungen zu den finalen Standards
• ML-KEM (FIPS 203, ehemals CRYSTALS-Kyber): Der neue Standard für Schlüsselaustausch
• ML-DSA (FIPS 204, ehemals CRYSTALS-Dilithium): Der neue Standard für digitale Signaturen
• SLH-DSA (FIPS 205, ehemals SPHINCS+): Hash-basierte Signaturen als Alternative
• LMS und XMSS (NIST SP 800-208): Stateful Hash-basierte Signaturen für Firmware und Embedded
• FN-DSA (ehemals FALCON): Kompakte Signaturen auf Gitter-Basis
• Schlüssel- und Signaturgrößen im Vergleich zu RSA und ECC
• Performance-Vergleich: Wie schnell sind die neuen Verfahren?

4. Regulatorische Anforderungen und Empfehlungen

• NIST SP 1800-38A-C: Die offiziellen Empfehlungen zur Post-Quanten-Migration
• TR-02102: BSI-Empfehlungen zu Post-Quanten-Kryptographie
• Europäische Perspektive: ENISA und SOG-IS-Empfehlungen
• Branchenspezifische Anforderungen: Finanzsektor, Gesundheitswesen, kritische Infrastrukturen
• Compliance-Fristen und Übergangszeiträume

5. Hybride Kryptographie und Migrationsstrategie

• Hybride Kryptographie: Klassische und post-quanten-sichere Verfahren kombinieren
• Warum hybrid? Sicherheitsnetz gegen Schwächen in neuen Algorithmen
• Hybride Schlüsselvereinbarung in TLS 1.3
• Hybride Signaturen in Zertifikaten und Dokumenten
• Crypto-Agility: Systeme so gestalten, dass Algorithmen austauschbar sind
• Bestandsaufnahme: Kryptographische Verfahren in Ihrer Organisation inventarisieren
• Priorisierung: Welche Systeme müssen zuerst migriert werden?
• Migrationspfad: Konkrete Schritte von der Analyse bis zur Umsetzung
• Typische Fallstricke bei der Migration und wie Sie sie vermeiden

Beschreibung: Dieser zweitägige Kurs vermittelt Git nicht als bloße Sammlung von Kommandos, sondern als durchdachtes System mit klaren Konzepten – so, wie ich es seit über 15 Jahren kontinuierlich verfeinere und weiterentwickle. Der konzeptbasierte Ansatz sorgt dafür, dass Sie nicht nur einzelne Befehle beherrschen, sondern verstehen, warum Git so funktioniert wie es funktioniert - und was dabei hinter den Kulissen passiert. Aus didaktischen Gründen setze ich dabei bewusst auf die Kommandozeile (Git Bash bzw. Bash unter Linux/Mac): Das Eintippen der Befehle spricht das „Muscle Memory” an, und die Kommandos prägen sich deutlich besser ein. In zwei kompakten Tagen spannt der Kurs den Bogen von den absoluten Grundlagen – lokale Architektur, Commits, Remote-Repositories – bis hin zu Branches, Merging und einem Überblick über bewährte Team-Workflows. Theoretische Grundlagen und praxisnahe Übungen greifen dabei nahtlos ineinander.

Schulungsziel: Nach diesem Kurs sehen Sie Git mit anderen Augen: Sie kennen die zugrunde liegenden Konzepte und Datenstrukturen, können nachvollziehen, was bei jedem Git-Kommando tatsächlich passiert, und navigieren souverän zwischen Working Copy, Staging Area und Repository. Sie arbeiten sicher mit lokalen und entfernten Repositories, beherrschen Branches und Merging – inklusive Konfliktauflösung – und kennen bewährte Team-Workflows. Git ist keine „Black Box” mehr, sondern ein verstandenes Werkzeug, das Ihnen auch in unbekannten Situationen Orientierung gibt.

Zielgruppe: Entwickelnde, die Git von Grund auf lernen möchten, sowie Entscheiderinnen und Entscheider, die einen fundierten Überblick über den De-facto-Standard moderner Softwareentwicklung gewinnen wollen. Auch Umsteiger von anderen Versionskontrollsystemen (insbesondere SVN und TFS) sind herzlich willkommen.

Voraussetzung: Grundlegende Vertrautheit mit der Kommandozeile ist hilfreich. Programmierkenntnisse sind von Vorteil, aber nicht zwingend erforderlich. Vorkenntnisse in Git oder anderen Versionskontrollsystemen werden nicht erwartet.

---

Tag 1: Git-Grundlagen, Architektur, Local vs. Remote Repository

1. Einführung: Konzepte statt Kommandos

• Warum Git anders unterrichtet werden sollte: Konzepte vor Kommandos
• Die Philosophie hinter Git: Dezentral, verteilt, datenintegriert
• Grundlegende Konfiguration: Benutzername und E-Mail einrichten

2. Lokale Git-Architektur verstehen: Die drei Bereiche

• Working Copy, Staging Area (Index) und Local Repository
• Visuelles Modell: Wo befinden sich Änderungen zu welchem Zeitpunkt?
• git init: Ein neues Repository erstellen
• git add: Änderungen zum Speichern vormerken
• git commit: Änderungen im Local Repository persistent speichern
• Die verschiedenen Zustände von Dateien: Untracked, Modified, Staged, Committed
• .gitignore: Dateien aus dem Repository ausschließen
• Der Unterschied zwischen Local und Remote Repository
• Git merkt sich lokal den Stand der Remote-Repositories
• Wichtige Erkenntnis: Fast alles in Git ist lokal
• Praktische Übung: Erste Schritte mit init, add, commit

3. Commit Etiquette: Gute Commit-Messages schreiben

• Was gehört in eine gute Commit-Message?
• Struktur: Subject, Body, Footer
• Conventional Commits als Standard
• Warum sind aussagekräftige Commit-Messages wichtig?
• Praktische Übung: Gute Commit-Messages schreiben

4. Änderungen rückgängig machen: die Basics

• git restore: Änderungen in der Working Copy verwerfen
• git reset: Einen Commit rückgängig machen
• git commit --amend: Einen Commit nachträglich ändern

5. Entfernte Git-Architektur verstehen: Remote Repositories

• Ein Remote ist auch nur ein weiteres Repository
• git remote: Ein Remote-Repository einrichten
• git push: Änderungen zu einem Remote-Repository senden
• git fetch: Änderungen von einem Remote-Repository holen
• git pull: Änderungen von einem Remote-Repository holen und integrieren
• Wann Fetch statt Pull?
• Remote-Tracking-Branches: origin/main vs. main
• git clone: Sich ein Repository “besorgen”
• Praktische Übung: Fetch und Pull im Detail beobachten

6. Forensik: Die aktuellen Änderungen und die Historie untersuchen

• git status: Den aktuellen Zustand verstehen
• git diff: Änderungen im Detail betrachten
• git show: Einzelne Commits analysieren
• git log und seine Optionen
• Visualisierung der Commit-History
• Änderungen zwischen Commits vergleichen
• Praktische Übung: Änderungen untersuchen und verstehen

---

Tag 2: Remote-Repositories, Branches und Merging

7. Branches: Isolierte Entwicklungslinien

• Branches als isolierte Entwicklungslinien
• Erlaubt “gleichzeitiges” Arbeiten an Features und Bugfixes
• Branches anlegen und verwalten: git branch, git checkout, git switch,
• Branches wieder zusammenführen: git merge
• git stash: Änderungen kurzzeitig parken
• git tag: Unverrückbare Markierungen in der Historie setzen
• Praktische Übung: Branches erstellen, wechseln und mergen

8. Blick unter die Haube: Wie Git Daten speichert & organisiert

• Praktische Exploration: Das .git-Verzeichnis (objects, refs, HEAD, config, hooks)
• Objects - die Datenstrukturen von Git: Commits, Trees, Blobs
• Die Commit-History als gerichteter azyklischer Graph (DAG)
• SHA-1-Hashes: Warum Hashes statt Sequenznummern?
• HEAD: Wo befinde ich mich gerade?
• Visualisierung: HEAD → refs/heads/main → Commit → Tree → Blobs
• Branches und Tags als Zeiger auf Commits
• Refs
• Demo: Mit Low-Level-Kommandos (cat-file, hash-object) Git-Internals erkunden
• git checkout / git switch: Was passiert beim Branch-Wechsel?

9. git merge: Mergen detailliert verstehen

• Fast-Forward-Merge vs. Three-Way-Merge
• Wann und wann nicht Fast-Forward-Merges erstrebenswert sind
• Der Merge-Algorithmus im Detail
• Visualisierung verschiedener Merge-Szenarien
• Wann entstehen Konflikte? Wie kann ich sie gezielt vermeiden?
• Welche Situationen kann Git selbstständig lösen?
• Anatomie eines Konflikts
• Konfliktauflösung Schritt für Schritt
• Praktische Übung: Mergen mit Konflikten

10. git rebase als Alternative zum Merge

• Was ist Rebasing und wie funktioniert es?
• Warum Rebase? Wann ist es sinnvoll?
• Rebase vs. Merge: Vor- und Nachteile
• Die goldene Regel: Niemals gepushte Commits rebasen

11. Workflows: Ein Überblick - vom Chaos zur Ordnung

• Criss-Cross-Merge: Warum mergt man nicht nach Bedarf “jeder von jedem”?
• Git Workflows: Warum Disziplin und Reihenfolge wichtig sind
• Central/SVN-Workflow: Probleme und Limitierungen
• GitHub-/GitLab-Flow mit Pull/Merge-Requests als Empfehlung für den Workflow-Einstieg
• Git Flow als etablierter Workflow für komplexere Projekte
• Praktische Übung: Vollständiger PR-Workflow in GitLab

Beschreibung: Git hat sich als Standard für die Versionskontrolle etabliert und ist ein unverzichtbares Werkzeug in Open-Source- und kommerziellen IT-Projekten. Mit Plattformen wie GitHub, GitLab und Bitbucket ist Git nicht nur weit verbreitet, sondern auch integraler Bestandteil moderner Entwicklungsmethoden wie GitOps. Dieses Seminar bietet Ihnen tiefe Einblicke in fortgeschrittene Git-Techniken, die weit über die alltäglichen Befehle hinausgehen. Sie lernen, wie Git im Detail funktioniert, wie Sie komplexe Probleme lösen und Ihren Workflow sowie den Ihres Teams effizienter gestalten. Praktische Übungen mit GitLab (optional GitHub oder Bitbucket) ermöglichen es Ihnen, das Gelernte sofort in die Praxis umzusetzen.

Schulungsziel: In dieser Schulung vertiefen Sie Ihre Git-Kenntnisse und lernen fortgeschrittene Konzepte kennen, um Ihren Workflow effizienter zu gestalten. Sie werden in der Lage sein, komplexe Szenarien souverän zu meistern, tiefergehende Features von Git anzuwenden und in Problemsituationen schnell Lösungen zu finden. Sie erfahren, wie Sie Ihr eigenes Arbeiten mit Git optimieren, Teamprozesse effizienter gestalten und typische Fehler schnell beheben können. Nach diesem Seminar sind Sie bestens gerüstet, auch in großen Projekten mit Git erfolgreich zu arbeiten.

Zielgruppe: Das Seminar richtet sich an Entwickler, die bereits grundlegende Git-Kenntnisse besitzen und diese nun vertiefen möchten. Auch Umsteiger von anderen Versionskontrollsystemen wie SVN, die ein tiefes Verständnis für Git aufbauen wollen, sind hier richtig.

Voraussetzung: Voraussetzung sind ein sicherer Umgang mit grundlegenden Git-Befehlen (add, commit, pull, push) sowie Erfahrung mit dem Anlegen und Verwalten von Branches.

---

Tag 1: Blick unter die Haube, Projektorganisation, Optimierung des eigenen Workflows

1. Blick unter die Haube: Eine kurze Reise durch den .git-Ordner

• Praktische Exploration: Das .git-Verzeichnis (objects, refs, HEAD, config, hooks)
• Objects - die Datenstrukturen von Git: Commits, Trees, Blobs
• Die Commit-History als gerichteter azyklischer Graph (DAG)
• SHA-1-Hashes: Warum Hashes statt Sequenznummern?
• HEAD: Wo befinde ich mich gerade?
• Visualisierung: HEAD → refs/heads/main → Commit → Tree → Blobs
• Branches und Tags als Zeiger auf Commits
• Refs
• Demo: Mit Low-Level-Kommandos (git cat-file, git hash-object) Git-Internals erkunden
• git checkout / git switch: Was passiert beim Branch-Wechsel?

2. Projekt- und Repository-Organisation

• Monorepo vs. Multirepo
• Vor- und Nachteile beider Lösungen
• Entscheidungsfindung: Welche Struktur passt zu meinem Projekt?
• Git-Submodule als Hybridlösung
• Umgang mit großen und/oder Monorepos: Sparse Checkout & Partial Clone

3. Commit Etiquette: Gute Commit-Messages schreiben

• Was gehört in eine gute Commit-Message?
• Struktur: Subject, Body, Footer
• Conventional Commits als Standard
• Warum sind aussagekräftige Commit-Messages wichtig?

4. Optimieren des eigenen Git-Workflows

• Staging Area effektiv nutzen: git add -p, git reset -p
• Paralleles Arbeiten mit git worktree
  • git worktree: Mehrere KI-Agenten gleichzeitig in einem Repository arbeiten lassen
• git rebase: Wann und wie nutzen?
  • Commits verschmelzen oder aufspalten beim interaktiven Rebase
  • git rebase --onto: Fortgeschrittene Rebase-Optionen verstehen und anwenden
  • Fehlerbehebung beim Rebase
• git cherry-pick vs. git merge vs. git rebase: Unterschiede und Abwägungen
  • Antipattern: „Cherry-Pick Everywhere” – warum Merge der Standard bleiben sollte
• Git Hooks
  • Optimierungsmöglichkeiten: Styleguides, Linting, Prettier, Whitespace, Code-Analyse
  • Frameworks für Git Hooks: pre-commit und Husky
  • Server-seitige Hooks und ihre Möglichkeiten
• Praktische Übung: “Git Workflow Bootcamp” - Wir räumen gemeinsam ein Repository auf

---

Tag 2: Optimierung des Team-Workflows und Undo-Strategien

5. Workflows: Vom Chaos zur Ordnung

• Criss-Cross-Merge: Warum mergt man nicht nach Bedarf “jeder von jedem”?
• Git Workflows: Warum Disziplin und Reihenfolge wichtig sind
• Central/SVN-Workflow: Probleme und Limitierungen
  • Einfachstmöglicher (“Un”)-Workflow
  • Nadelöhr-Problem beim Push: “Wer zuerst kommt, mahlt zuerst”
  • “Russisch Roulette” beim Pull
• Demo: Central-Workflow und seine Probleme erleben
• GitHub-/GitLab-Flow: Feature-Branches + Pull/Merge-Requests
  • Feature-Branches: Konzept und Motivation
  • Code-Review-Prozess
  • Vom Feature-Branch zum Merge-Request
• Praktische Übung: Vollständiger PR-Workflow in GitLab
• Git Flow: The Good, the Bad and the Ugly
  • Feature-Branches, Develop, Master, Release-Branches, Hotfixes
  • Vor- und Nachteile von Git Flow
  • Wann ist Git Flow sinnvoll?
  • Vom Heilsbringer zum hässlichen Entlein: Warum Git Flow zu schwerfällig sein kann
• Ausblick: Eigene Workflows entwickeln - worauf kommt es an?

6. Optimieren von Git im Team

• Mergen im Team: Best Practices und mögliche Probleme
  • Umgang mit veralteten Pull Requests und Konflikten
  • Fortgeschrittene Merge-Strategien: ort, recursive, ours/theirs
  • Umgang mit Merge-Konflikten: Strategien und Tools: git mergetool, diff3, git rerere
• Repository-Management über die Weboberfläche: Permissions, Default Branches, Protected Branches
• Tags und Releases: Best Practices
• .gitattributes: Wenn core.autocrlf nicht ausreicht
• Git ohne Netzwerk mobil nutzen: Bare Repositories und Bundles
• Umgang mit Binärdateien und Git LFS
• Praktische Übung: “Merge-Konflikte meistern” - Wir simulieren Konflikte und lösen sie gemeinsam mit verschiedenen Strategien und Tools

7. Undo-Rezepte: Fehler beheben nach Eskalationsgrad

• Allgemein: Häufige Fallen und wie man sie vermeidet
• Stufe 1: Änderungen in der Working Copy rückgängig machen
  • git restore, git checkout
• Stufe 2: Änderungen aus der Staging Area zurücknehmen
  • git restore --staged, git reset
• Stufe 3: Einen Commit rückgängig machen (lokal)
  • git reset --soft, git reset --mixed, git reset --hard
• Stufe 4: Einen Commit nachbessern (lokal)
  • git commit --amend
• Stufe 5: Mehrere Commits zusammenfassen (lokal)
  • Interactive Rebase, Squash
• Stufe 6: Einen Commit rückgängig machen (remote/public)
  • git revert
• Stufe 7: Kaputtes Repository retten
  • git reflog und Recovery-Strategien

8. Fehlersuche mit Git: Debugging und Forensik

• git bisect: Den Commit finden, der einen Fehler eingeführt hat
• git blame: Wer hat was geändert und warum?
• git diff: Änderungen zwischen Commits, Branches, Arbeitsverzeichnis
• git log: Finden und Filtern von Commits
• git grep: Textsuche in der Code-Historie
• git show: Details zu einem Commit anzeigen
• git filter-branch / git filter-repo: Historie umschreiben, z.B. zum Entfernen von Secrets
• Praktische Übung: “Git Forensics” - Mit ‘git bisect’ einen Fehler in der Historie finden

Beschreibung: Sie kennen die Grundlagen von Git und möchten nun den nächsten Schritt in Richtung Automatisierung, Stabilität und Effizienz gehen.

Sie wollen Continuous Integration und Continuous Deployment mit GitLab CI/CD nahtlos in Ihre Entwicklungs- und Betriebsprozesse einbinden. Dabei möchten Sie Ihre Builds zuverlässig in Container verpacken, um reproduzierbare Ergebnisse zu erzielen und Ihre Deployments automatisiert oder auf Knopfdruck auszurollen.

Stellen Sie sich vor, jede Änderung wird geprüft, getestet, verpackt und einsatzbereit gemacht - ohne manuelles Nacharbeiten, ohne böse Überraschungen, wenn die Anwendung in Produktion geht. Ihre Pipelines bauen Images, speichern sie in der Registry, testen Sicherheitsaspekte und deployen in unterschiedliche Umgebungen - alles mit einem einzigen Commit.

Einmal aufgesetzt, bleibt Ihre Pipeline einfach erweiterbar und wiederverwendbar. Neue Teammitglieder können ohne langwierige Vorbereitung produktiv werden - Ihre Infrastruktur bleibt konsistent und nachvollziehbar. Keine Utopie, sondern GitOps in der Praxis - mit GitLab CI und Docker. Ein umfassender Kurs über moderne GitLab CI/CD Praktiken und Docker-Containerisierung.

Schulungsziel: Lernen Sie, wie Sie GitLab CI/CD als zentrales Werkzeug für Ihre GitOps-Strategie einsetzen und Pipelines entwickeln, die Builds, Tests, Security-Checks und Deployments vollautomatisch abbilden. Sie verstehen, wie Sie Docker effektiv in Ihre Workflows integrieren, Container-Images versionieren und sicher verwalten.

Sie nutzen wiederverwendbare Templates, Self-Managed Runner und die GitLab Registry, um Ihre CI/CD-Umgebung perfekt an die Bedürfnisse Ihres Teams anzupassen. Dabei lernen Sie, moderne Best Practices für Branching, Secrets Management, statische Analysen und Infrastructure-as-Code einzusetzen.

So automatisieren Sie Ihre Entwicklungs- und Betriebsprozesse von der Code-Änderung bis zum sicheren, nachvollziehbaren Deployment - zuverlässig, reproduzierbar und teamfreundlich.

Zielgruppe: Entwickelnde, DevOps & Administratoren oder Teamleiter & Projektmanager, die mit GitLab CI/CD als zentrales Werkzeug ihre Pipelines entwickeln möchten.

Voraussetzung: Grundkenntnisse in Git werden vorausgesetzt. Sie sollten sicher im Umgang mit Commits und Branches sein und Pull Requests und Merges sollten Ihnen nicht fremd sein. Wir nutzen im Kurs Git in der Kommandozeile (Git Bash), minimale Grundkenntnisse einer Kommandozeile reichen aus. Docker-Kenntnisse sind hilfreich, werden aber nicht vorausgesetzt.

Tag 1: Die Grundlagen von GitLab CI und Docker

1. Grundlagen von GitLab CI/CD

• Syntax & Semantik von .gitlab-ci.yml
• Stages vs. Jobs, Default Stages
• Erfolg bzw. Misserfolg eines Jobs
• Strukturierung der Ablaufreihenfolge von Jobs
• Konditionale Ausführung von Jobs
• Praktische Übung: “Gitlab CI No Code” - Gitlab CI erforschen, ganz ohne Code

2. Was gehört in eine CI/CD-Pipeline?

• Integration von Tests
• Artefakte erzeugen und verfügbar machen
• vordefinierte CI/CD-Variablen
• eigene CI/CD-Variablen und Geheimnisse
• Environments
• Mit dem “Pages”-Job Artefakte automatisiert online verfügbar machen
• Gitlab-Runner: Was ist das und wie funktioniert es?
• Shared Runner vs. Self-Managed Runner
• Gitlab-Runner und Docker
• Was tun, wenn das Basis-Image alleine nicht ausreicht? Wenn weitere Software benötigt wird?
• Live-Demo: Aufsetzen eines privaten, Self-Managed Runners
• Praktische Übung: Minimalistisches aber vollwertiges Projekt, dass typische Aufgaben einer Pipeline (Tests, Code Coverage, Linting, Styleguides, Dokumentation, …) integriert

3. Einführung in Docker

• Grundlagen von Docker: Container, Images, Dockerfiles
• Podman als Alternative zu Docker
• Warum Docker und Gitlab CI wie für einander gemacht sind
• Gitlab CI mit Docker und der Gitlab-Docker-Registry
• Wiederverwendbare Schablone einer Docker-basierten CI-Pipeline
• Praktische Übung: Dockerisierung unserer minimalistischen Anwendung

Tag 2: GitLab CI mit Docker

4. GitLab CI mit Docker & Docker Compose

• Templates für gitlab-ci.yml
• GitLab CI/CD Editor: gitlab-ci.yml online editieren & validieren
• gitlab-ci.yml lokal testen
• Docker-in-Docker (DinD)
• Container-Registry & Cleanup Policies
• Praktische Übung: Dockerisierung unserer CI-Pipeline
• Docker Compose: Multi-Container-Anwendungen einfach definiert
• Entwickeln mit Docker & Docker Compose
• Ziel für Gitlab CI mit Docker: Docker-basierte Standardpipeline, die ohne Änderungen wiederverwendet werden kann
• Praktische Übungen:
  • Live Reload - Entwickeln unserer Anwendung mit Docker Compose
  • Docker Composifizierung unserer CI-Pipeline

5. Gitlab CI Advanced

• Weitere Artefakte in der Pipeline integrieren
  • Unit Test Reports
  • Code Coverage Reports
• Praktische Übung: Erweiterung unserer Pipeline um Test- und Code Coverage-Reports
• Erweiterte Pipeline-Konzepte
  • Triggered Pipelines
  • Child/Parent Pipelines
  • Pipeline Schedules
  • Manual Jobs & Approvals
  • Environments / Deployments
  • Rollbacks & Canary Deployments
  • Releases erstellen und verwalten mit GitLab CI und glab (GitLab CLI)
  • Praktische Übung: Release erstellen mit GitLab CI
• Von Gitlab bereitgestellte Jobs in der eigenen Pipeline integrieren:
  • Code Quality
  • SAST (Static Application Security Testing)
  • Secret Detection
  • Container Scanning
  • Visualisierung der Ergebnisse im Kontext von Merge Requests
• Praktische Übung: Erweiterung unserer Pipeline um Code Quality und Secret Detection

Beschreibung: Dieser intensive 3-tägige Workshop vermittelt Git nicht als bloße Sammlung von Kommandos, sondern als durchdachtes System mit klaren Konzepten. Sie lernen die zugrunde liegenden Prinzipien verstehen, auf denen moderne Software-Entwicklungsprozesse aufbauen. Durch den konzeptbasierten Ansatz entwickeln Sie ein tiefes Verständnis für Git und können es sicher und effektiv einsetzen. Der Workshop kombiniert theoretische Grundlagen mit praxisnahen Übungen und bereitet Sie darauf vor, Git im Team-Kontext mit Feature-Branches, Pull-Requests, Code-Reviews und modernem Release-Management zu nutzen.

Schulungsziel: Nach diesem Workshop verstehen Sie Git nicht nur oberflächlich, sondern kennen die zugrunde liegenden Konzepte und Datenstrukturen. Sie können Git sicher in Ihrem täglichen Entwicklungsprozess einsetzen und haben keine Hemmungen mehr vor komplexeren Operationen wie Rebase oder Reset. Sie verstehen, was bei jedem Git-Kommando tatsächlich passiert, können moderne Team-Workflows umsetzen und wissen, welche Strategien für welche Situation geeignet sind. Sicherheitskopien vor Git-Operationen gehören der Vergangenheit an.

Zielgruppe: Entwickelnde, die Git von Grund auf lernen oder ihre Kenntnisse vertiefen möchten. Auch für Umsteiger von anderen Versionsverwaltungssystemen (SVN, TFS, CVS) geeignet.

Voraussetzung: Grundlegende Programmierkenntnisse und Vertrautheit mit der Kommandozeile. Erste Berührungspunkte mit Versionsverwaltung sind hilfreich, aber nicht zwingend erforderlich.

---

Tag 1: Git-Grundlagen, Architektur, Local vs. Remote Repository

1. Einführung: Konzepte statt Kommandos

• Warum Git anders unterrichtet werden sollte: Konzepte vor Kommandos
• Die Philosophie hinter Git: Dezentral, verteilt, datenintegriert
• Überblick: Was werden wir in den drei Tagen lernen?
• Grundlegende Konfiguration: Benutzername und E-Mail einrichten

2. Lokale Git-Architektur verstehen: Die drei Bereiche

• Working Copy, Staging Area (Index) und Local Repository
• Visuelles Modell: Wo befinden sich Änderungen zu welchem Zeitpunkt?
• git init: Ein neues Repository erstellen
• git add: Änderungen zum Speichern vormerken
• git commit: Änderungen im Local Repository persistent speichern
• Die verschiedenen Zustände von Dateien: Untracked, Modified, Staged, Committed
• Der Unterschied zwischen Local und Remote Repository
• Git merkt sich lokal den Stand der Remote-Repositories
• Wichtige Erkenntnis: Fast alles in Git ist lokal
• Praktische Übung: Erste Schritte mit init, add, commit

3. Commit Etiquette: Gute Commit-Messages schreiben

• Was gehört in eine gute Commit-Message?
• Struktur: Subject, Body, Footer
• Conventional Commits als Standard
• Warum sind aussagekräftige Commit-Messages wichtig?
• Praktische Übung: Gute Commit-Messages schreiben

4. Entfernte Git-Architektur verstehen: Remote Repositories

• Ein Remote ist auch nur ein weiteres Repository
• git remote: Ein Remote-Repository einrichten
• git push: Änderungen zu einem Remote-Repository senden
• git fetch: Änderungen von einem Remote-Repository holen
• git pull: Änderungen von einem Remote-Repository holen und integrieren
• Wann Fetch statt Pull?
• Remote-Tracking-Branches: origin/main vs. main
• git clone: Sich ein Repository “besorgen”
• Praktische Übung: Fetch und Pull im Detail beobachten

5. Forensik: Die aktuellen Änderungen und die Historie untersuchen

• git status: Den aktuellen Zustand verstehen
• git diff: Änderungen im Detail betrachten
• git show: Einzelne Commits analysieren
• git log und seine Optionen
• Visualisierung der Commit-History
• Änderungen zwischen Commits vergleichen
• Praktische Übung: Änderungen untersuchen und verstehen

6. Branches: Isolierte Entwicklungslinien

• Branches als isolierte Entwicklungslinien
• Erlaubt “gleichzeitiges” Arbeiten an Features und Bugfixes
• Branches anlegen und verwalten: git branch, git checkout, git switch,
• Branches wieder zusammenführen: git merge
• Praktische Übung: Branches erstellen, wechseln und mergen

---

Tag 2: Remote-Repositories, Branches und Merging

7. Blick unter die Haube: Wie Git Daten speichert & organisiert

• Praktische Exploration: Das .git-Verzeichnis (objects, refs, HEAD, config, hooks)
• Objects - die Datenstrukturen von Git: Commits, Trees, Blobs
• Die Commit-History als gerichteter azyklischer Graph (DAG)
• SHA-1-Hashes: Warum Hashes statt Sequenznummern?
• HEAD: Wo befinde ich mich gerade?
• Visualisierung: HEAD → refs/heads/main → Commit → Tree → Blobs
• Branches und Tags als Zeiger auf Commits
• Refs
• Demo: Mit Low-Level-Kommandos (cat-file, hash-object) Git-Internals erkunden
• git checkout / git switch: Was passiert beim Branch-Wechsel?

8. git merge: Mergen detailliert verstehen

• Fast-Forward-Merge vs. Three-Way-Merge
• Wann und wann nicht Fast-Forward-Merges erstrebenswert sind
• Der Merge-Algorithmus im Detail
• Visualisierung verschiedener Merge-Szenarien
• Wann entstehen Konflikte? Wie kann ich sie gezielt vermeiden?
• Welche Situationen kann Git selbstständig lösen?
• Anatomie eines Konflikts
• Konfliktauflösung Schritt für Schritt
• Praktische Übung: Mergen mit Konflikten

9. Rebase als Alternative zum Merge

• Was ist Rebasing und wie funktioniert es?
• Warum Rebase? Wann ist es sinnvoll?
• Rebase vs. Merge: Vor- und Nachteile
• Die goldene Regel: Niemals gepushte Commits rebasen
• Praktische Übung: Rebase vs. Merge vergleichen

10. Undo-Rezepte: Fehler beheben nach Eskalationsgrad

• Allgemein: Häufige Fallen und wie man sie vermeidet
• Stufe 1: Änderungen in der Working Copy rückgängig machen
  • git restore, git checkout
• Stufe 2: Änderungen aus der Staging Area zurücknehmen
  • git restore —staged, git reset
• Stufe 3: Einen Commit rückgängig machen (lokal)
  • git reset —soft, —mixed, —hard
• Stufe 4: Einen Commit nachbessern (lokal)
  • git commit —amend
• Stufe 5: Mehrere Commits zusammenfassen (lokal)
  • Interactive Rebase, Squash
• Stufe 6: Einen Commit rückgängig machen (remote/public)
  • git revert
• Stufe 7: Kaputtes Repository retten
  • git reflog und Recovery-Strategien

---

Tag 3: Git im Team, Workflows und Undo-Strategien

11. Workflows: Vom Chaos zur Ordnung

• Criss-Cross-Merge: Warum mergt man nicht nach Bedarf “jeder von jedem”?
• Git Workflows: Warum Disziplin und Reihenfolge wichtig sind
• Central/SVN-Workflow: Probleme und Limitierungen
  • Einfachstmöglicher (“Un”)-Workflow
  • Nadelöhr-Problem beim Push: “Wer zuerst kommt, mahlt zuerst”
  • “Russisch Roulette” beim Pull
• Praktische Übung: Central-Workflow und seine Probleme erleben

12. GitHub-/GitLab-Flow: Pull/Merge-Requests

• Branches als Snapshot-Isolation
• Feature-Branches: Konzept und Motivation
• Was sind Pull/Merge-Requests?
• Code-Review-Prozess
• Vom Feature-Branch zum Merge-Request
• Best Practices für Code-Reviews
• Praktische Übung: Vollständiger PR-Workflow in GitLab

13. Release-Management mit Git

• Versionierung mit Tags
• Semantic Versioning: major.minor.patch
• Feature Freeze und Release Branches
• Release Notes automatisch generieren mit git log
• Ausblick: Conventional Commits & semantic-release für automatische Versionierung

14. Der komplette Entwicklungszyklus im Überblick

• Von der Anforderung bis zum Deployment
• Issue-Tracking mit GitLab Issues
• Feature-Branches erstellen
• Code schreiben und committen
• Merge-Requests erstellen
• Code-Reviews durchführen
• Merge-Konflikte lösen
• Releases erstellen und taggen

Zielgruppe: Softwareentwickelnde und Architekt:innen, die Kotlin von Grund auf lernen oder von Java umsteigen möchten — ob für Backend-Entwicklung mit Spring Boot, Android-Apps oder Multiplatform-Projekte.

Kurzbeschreibung: Warum entscheiden sich immer mehr Teams für Kotlin? Wie nutzt man Null Safety, Extension Functions und Koroutinen idiomatisch? Und wie gelingt der Umstieg von Java, ohne bestehenden Code wegzuwerfen? Dieser Workshop gibt Ihnen fundierte Antworten — von den Sprachgrundlagen über objektorientierte und funktionale Programmierung bis hin zu fortgeschrittenen Features wie Koroutinen und DSLs.

Schulungsziel: Sie können Kotlin idiomatisch und sicher einsetzen. Sie kennen das Typsystem mit Null Safety, verstehen Klassen, Interfaces, Sealed Classes und Generics. Sie beherrschen funktionale Konzepte wie Lambdas und Collection-Operationen, können asynchronen Code mit Koroutinen schreiben und wissen, wie Sie Kotlin nahtlos mit bestehendem Java-Code kombinieren. Nach dem Workshop sind Sie in der Lage, eigenständig Kotlin-Projekte aufzusetzen, zu testen und produktiv einzusetzen.

Voraussetzung: Programmiererfahrung in einer objektorientierten Sprache (idealerweise Java, aber auch C#, TypeScript o.ä.). Erfahrung mit einer IDE (IntelliJ IDEA empfohlen). Kenntnisse in Java sind hilfreich für die Interoperabilitäts-Themen, aber nicht zwingend erforderlich.

---

Tag 1: Einstieg in Kotlin — Sprache, Typsystem und Grundlagen

1. Warum Kotlin?

• Was ist Kotlin? Geschichte und Philosophie
• Kotlins Verhältnis zu Java: Evolution statt Revolution
• Einsatzgebiete: Server, Android, Multiplatform, Scripting
• Die Kotlin-Toolchain: Compiler, REPL, IntelliJ IDEA
• Das erste Kotlin-Programm: Von Hello World zum ersten Projekt
• Praktische Übung: Entwicklungsumgebung einrichten und erstes Programm schreiben

2. Variablen, Typen und Kontrollstrukturen

• val vs. var — Immutability als Grundprinzip
• Basistypen: Int, Long, Double, Boolean, Char, String
• Type Inference: Warum explizite Typangaben oft unnötig sind
• String Templates und Multiline Strings
• Kontrollstrukturen als Ausdrücke: if, when, try
• when — Kotlins mächtiger Ersatz für switch/case
• Schleifen: for, while, Ranges und Progressions
• Praktische Übung: Kotlins Ausdrucks-orientierte Syntax nutzen

3. Funktionen in Kotlin

• Funktionsdeklaration und benannte Parameter
• Default-Werte für Parameter
• Single-Expression Functions
• Lokale Funktionen und ihre Einsatzgebiete
• Varargs und der Spread-Operator
• Praktische Übung: Funktionen idiomatisch einsetzen

4. Null Safety — Kotlins Antwort auf die Billion-Dollar-Frage

• Das Problem mit null in Java
• Nullable und Non-Nullable Types
• Safe Calls (?.), Elvis-Operator (?:) und Non-Null Assertion (!!)
• Smart Casts und let-Scope-Funktion
• Null Safety in der Praxis: Strategien für null-freien Code
• Praktische Übung: Null Safety konsequent anwenden

---

Tag 2: Objektorientierung, Collections und funktionale Programmierung

5. Klassen und Objekte

• Klassen und Konstruktoren: Primärkonstruktor und init-Block
• Properties statt Getter/Setter
• Data Classes: Weniger Boilerplate, mehr Aussagekraft
• Enum Classes und ihre Möglichkeiten in Kotlin
• Das object-Keyword: Singletons und Companion Objects
• Praktische Übung: Domänenmodell mit Data Classes und Enums

6. Vererbung, Interfaces und Sealed Classes

• Vererbung in Kotlin: open, abstract, override
• Interfaces mit Default-Implementierungen
• Sealed Classes und Sealed Interfaces: Eingeschränkte Hierarchien
• when-Ausdrücke mit Sealed Classes: Exhaustive Pattern Matching
• Delegation mit by — Komposition statt Vererbung
• Praktische Übung: Sealed-Class-Hierarchien modellieren und matchen

7. Extension Functions und Scope Functions

• Extension Functions: Bestehende Klassen erweitern, ohne sie zu ändern
• Extension Properties
• Scope Functions im Detail: let, run, with, apply, also
• Wann welche Scope Function? Entscheidungshilfe und Best Practices
• Praktische Übung: APIs mit Extension Functions lesbarer machen

8. Collections und funktionale Operationen

• Kotlins Collection-Hierarchie: List, Set, Map — Mutable vs. Immutable
• Lambda-Ausdrücke und Higher-Order Functions
• Die wichtigsten Collection-Operationen: map, filter, flatMap, groupBy, associate
• Lazy Evaluation mit Sequences
• Destructuring Declarations
• Praktische Übung: Daten mit funktionalen Collection-Operationen transformieren

---

Tag 3: Fortgeschrittene Themen und Kotlin im Projektalltag

9. Generics

• Generische Klassen und Funktionen
• Varianz in Kotlin: in, out und Type Projections
• Reified Type Parameters in Inline Functions
• Typgebundene Constraints (where)
• Praktische Übung: Generische Datenstrukturen implementieren

10. Koroutinen — Asynchrone Programmierung mit Kotlin

• Warum Koroutinen? Motivation und Vergleich mit Threads
• suspend-Funktionen und Coroutine Builders: launch, async, runBlocking
• Structured Concurrency und Coroutine Scopes
• Flow für asynchrone Datenströme
• Fehlerbehandlung in Koroutinen
• Praktische Übung: Asynchrone Aufgaben mit Koroutinen lösen

11. Interoperabilität mit Java

• Kotlin-Code von Java aus aufrufen und umgekehrt
• Annotations für Java-Interoperabilität: @JvmStatic, @JvmField, @JvmOverloads
• Umgang mit Java-Nullabilität in Kotlin (Platform Types)
• Schrittweise Migration: Java und Kotlin im selben Projekt
• Praktische Übung: Bestehendes Java-Projekt um Kotlin erweitern

12. Kotlin im Projektalltag

• Projektaufbau mit Gradle (Kotlin DSL) und Maven
• Testen mit Kotlin: JUnit 5, AssertJ und kotlintest/Kotest
• Dokumentieren von Kotlin-Code mit KDoc
• Überblick über nützliche Libraries: kotlinx.serialization, Ktor, Arrow
• Domain-Specific Languages (DSLs) mit Kotlin: Warum Kotlin sich dafür eignet
• Ausblick: Kotlin Multiplatform und aktuelle Entwicklungen
• Praktische Übung: Ein kleines Projekt mit Tests und Build-Konfiguration aufsetzen

Zielgruppe: Softwareentwickelnde und Architekt:innen, die moderne Backend-Anwendungen mit Spring Boot entwickeln wollen — ob Einstieg in Spring oder Umstieg von älteren Spring-Boot-Versionen.

Kurzbeschreibung: Wie funktioniert Dependency Injection in Spring wirklich? Wie baue ich ein sauberes REST-API mit Validierung und Fehlerbehandlung? Wie binde ich Datenbanken an, ohne mich in JPA-Fallstricken zu verlieren? Und was bringen Virtual Threads, Native Images und die neuen Observability-Features in der Praxis? Dieser Workshop gibt Ihnen fundierte Antworten — von den Spring-Grundlagen über Spring MVC und Spring Data JPA bis hin zu Produktionsthemen wie Security, Testing und Deployment.

Schulungsziel: Sie können eigenständig Spring-Boot-4-Anwendungen entwickeln, die produktionsreif sind. Sie verstehen Dependency Injection und Auto-Configuration im Detail, bauen REST-APIs mit Spring MVC, binden Datenbanken mit Spring Data JPA an und wissen, wie Sie Ihre Anwendung absichern, testen und betreiben. Sie kennen die Neuerungen in Spring Boot 4 und Spring Framework 7 und können bestehende Projekte gezielt modernisieren.

Voraussetzung: Solide Java-Kenntnisse (ab Java 17). Erfahrung mit einer IDE (IntelliJ IDEA empfohlen). Grundlegendes Verständnis von HTTP und relationalen Datenbanken ist hilfreich. Vorkenntnisse in Spring sind nicht erforderlich.

---

Tag 1: Spring-Grundlagen und REST-APIs

1. Einführung in Spring Boot

• Spring vs. Spring Boot — was ist was?
• Die Philosophie: Convention over Configuration
• Was ist neu in Spring Boot 4 und Spring Framework 7?
• Jakarta EE: Der Umstieg von javax auf jakarta
• Ein Spring-Boot-Projekt aufsetzen: start.spring.io und Spring Boot Starters
• Projektstruktur und Aufbau einer Spring-Boot-Anwendung
• Praktische Übung: Erstes Spring-Boot-Projekt erzeugen und starten

2. Dependency Injection und Spring Beans

• Inversion of Control und Dependency Injection: Konzepte und Motivation
• Spring Beans: Deklaration, Lebenszyklus und Scopes
• Component Scan und Autowiring
• @Configuration und explizite Bean-Deklaration
• Konstruktor-Injection als Best Practice
• Konditionelle Konfiguration mit @ConditionalOn...
• Spring Boot Auto-Configuration: Was passiert beim Start?
• Probleme bei der Dependency Resolution erkennen und beheben
• Praktische Übung: Beans definieren, injizieren und Auto-Configuration nachvollziehen

3. Konfiguration und Profile

• application.properties vs. application.yml
• Externe Konfiguration: Umgebungsvariablen, Kommandozeilenargumente, Config Files
• Typensichere Konfiguration mit @ConfigurationProperties
• Profile: Umgebungsabhängige Konfiguration (dev, staging, prod)
• Praktische Übung: Konfiguration mit Profilen und @ConfigurationProperties umsetzen

4. REST-APIs mit Spring MVC

• @RestController und Request Mapping
• HTTP-Methoden umsetzen: GET, POST, PUT, DELETE
• Pfadvariablen, Query-Parameter und Request Bodies
• JSON-Serialisierung mit Jackson
• Antworten steuern: ResponseEntity und HTTP-Statuscodes
• Fehlerbehandlung mit @ExceptionHandler und Problem Details (RFC 9457)
• Praktische Übung: Ein vollständiges CRUD-REST-API implementieren

---

Tag 2: Datenbankanbindung, Validierung und Testing

5. Spring Data JPA

• Überblick: JPA, Hibernate und Spring Data — wer macht was?
• Entities modellieren: @Entity, @Id, Relationen
• Spring Data Repositories: CRUD ohne Boilerplate
• Abfragen: Derived Queries, @Query und Projections
• Paginierung und Sortierung
• Relationen in der Praxis: @OneToMany, @ManyToOne, Lazy vs. Eager Loading
• Praktische Übung: Entities und Repositories für das REST-API implementieren

6. Datenbankmanagement und Validierung

• Datenbankverbindung konfigurieren: HikariCP Connection Pool
• Datenbank-Migrationen mit Flyway
• Seed-Daten für die Entwicklung
• Bean Validation mit Jakarta Validation: Built-in- und Custom-Constraints
• Validierung im REST-API: @Valid und aussagekräftige Fehlermeldungen
• Transaktionsmanagement mit @Transactional: Fallstricke und Best Practices
• Praktische Übung: Migration, Validierung und Transaktionen einbauen

7. Testen von Spring-Boot-Anwendungen

• Die Testpyramide in Spring Boot: Unit-, Integrations- und End-to-End-Tests
• Unit-Tests für Services und Beans
• Sliced Tests: @WebMvcTest, @DataJpaTest — fokussierte Integrationstests
• @SpringBootTest: Vollständige Integrationstests
• MockMvc: REST-APIs testen ohne Server
• Testcontainers: Echte Datenbanken in Tests verwenden
• Praktische Übung: Tests für API und Datenbankschicht schreiben

8. Security-Grundlagen mit Spring Security

• Authentifizierung vs. Autorisierung
• Spring Security einbinden und konfigurieren
• Die Security Filter Chain verstehen
• HTTP Basic und formularbasierte Authentifizierung
• Endpoints absichern: Rollen und Authorities
• CORS und CSRF in der Praxis
• Praktische Übung: REST-API mit Spring Security absichern

---

Tag 3: Fortgeschrittene Themen und Produktion

9. Reactive Spring und WebFlux

• Blocking vs. Non-Blocking I/O: Wann brauche ich was?
• Einführung in Project Reactor: Mono und Flux
• Spring WebFlux: Reaktive REST-APIs
• Der reaktive WebClient für externe HTTP-Aufrufe
• Deklarative HTTP-Clients mit HTTP Interface
• Wann WebFlux, wann Spring MVC? Entscheidungshilfe
• Praktische Übung: Einen externen Service mit WebClient und HTTP Interface anbinden

10. Virtual Threads und Performance

• Virtual Threads (Project Loom): Was ändert sich für Spring-Anwendungen?
• Virtual Threads in Spring Boot 4 aktivieren und einsetzen
• Virtual Threads vs. Reactive: Wann was?
• GraalVM Native Images: Schneller Start, weniger Speicher
• AOT-Processing: Wie Spring Boot Native Images unterstützt
• Praktische Übung: Anwendung mit Virtual Threads konfigurieren

11. Observability und Actuator

• Spring Boot Actuator: Health, Info, Metrics
• Micrometer und Observability: Metrics, Tracing, Logging aus einem Guss
• Eigene Health Indicators und Metriken implementieren
• Actuator-Endpoints absichern
• Structured Logging in Spring Boot
• Praktische Übung: Health Checks und Custom Metrics einrichten

12. Produktion und Deployment

• Anwendung als JAR paketieren und ausliefern
• Docker-Images mit Spring Boot Buildpacks erstellen
• Konfiguration für verschiedene Umgebungen managen
• Graceful Shutdown und Startup Probes
• Überblick: Spring Boot mit Kubernetes
• Ausblick: Modulith — Modulare Monolithen mit Spring
• Praktische Übung: Docker-Image bauen und Produktionskonfiguration umsetzen

Zielgruppe: Erfahrene Java-Entwickelnde und Architekt:innen, die mit Java 8 vertraut sind, aber die Neuerungen der letzten Jahre nachholen oder vertiefen möchten — ob für Greenfield-Projekte oder die Modernisierung bestehender Codebases.

Kurzbeschreibung: Viele Java-Teams arbeiten noch mit Idiomen aus der Java-8-Ära, obwohl die Sprache sich seither grundlegend weiterentwickelt hat. Records ersetzen Boilerplate-Klassen, Sealed Classes ermöglichen geschlossene Typhierarchien, Pattern Matching macht Typprüfungen elegant und Virtual Threads revolutionieren die Nebenläufigkeit. Dieser Workshop führt Sie systematisch durch alle praxisrelevanten Features von Java 9 bis 25 — mit klarem Fokus darauf, was Sie ab morgen in Ihren Projekten einsetzen können.

Schulungsziel: Sie kennen alle wesentlichen Sprachfeatures, APIs und Laufzeitverbesserungen von Java 9 bis 25. Sie können Records, Sealed Classes und Pattern Matching idiomatisch einsetzen, verstehen das Modulsystem und wissen, wann es sich lohnt. Sie beherrschen Virtual Threads und Structured Concurrency für moderne Nebenläufigkeit und kennen die neuen APIs für HTTP, Datenverarbeitung und native Interoperabilität. Nach dem Workshop schreiben Sie Java-Code, der die volle Ausdruckskraft der modernen Sprache nutzt.

Voraussetzung: Solide Java-Erfahrung (mindestens Java 8, idealerweise auch Erfahrung mit Streams und Lambdas). Eine IDE mit Unterstützung für aktuelle Java-Versionen (IntelliJ IDEA empfohlen). Grundlegendes Verständnis von Nebenläufigkeit (Threads, Synchronization) ist für Tag 3 hilfreich.

---

Tag 1: Sprachevolution — Von Java 9 bis 17

1. Java nach 8: Der neue Release-Rhythmus

• Der 6-Monats-Zyklus: Feature Releases, LTS-Versionen und was das für Projekte bedeutet
• Preview Features und Incubator APIs: Wie Java neue Features erprobt
• Welche Java-Version sollte ich heute einsetzen?
• JShell: Die interaktive Java-REPL zum Experimentieren
• Praktische Übung: JShell nutzen und die eigene Java-Version auf den neuesten Stand bringen

2. Das Modulsystem (JPMS)

• Motivation: Warum der Classpath nicht mehr ausreicht
• Module deklarieren: module-info.java, requires, exports
• Starke Kapselung: Was Module besser machen als Packages
• Automatic Modules und der Unnamed Module: Migration bestehender Projekte
• Wann lohnt sich das Modulsystem — und wann nicht?
• Praktische Übung: Eine bestehende Anwendung modularisieren

3. Kleine Sprachverbesserungen (Java 9–16)

• var — Local Variable Type Inference (Java 10): Regeln und Best Practices
• Private Methoden in Interfaces (Java 9)
• Verbesserte try-with-resources (Java 9)
• Switch Expressions: Vom Statement zum Ausdruck (Java 14)
• Text Blocks: Mehrzeilige Strings ohne Escape-Chaos (Java 13/15)
• Helpful NullPointerExceptions: Endlich verständliche Fehlermeldungen (Java 14)
• Instanceof Pattern Matching: Typprüfung und Cast in einem Schritt (Java 16)
• Praktische Übung: Bestehenden Java-8-Code mit modernen Features refaktorisieren

4. Records und Sealed Classes

• Records: Unveränderliche Datenklassen ohne Boilerplate (Java 16)
• Compact Constructors und Custom Methods in Records
• Wann Records — und wann nicht? Abgrenzung zu klassischen Klassen
• Sealed Classes und Sealed Interfaces: Geschlossene Typhierarchien (Java 17)
• permits-Klausel und erlaubte Subtypen
• Sealed Classes als Grundlage für exhaustives Pattern Matching
• Records und Sealed Classes kombinieren: Algebraische Datentypen in Java
• Praktische Übung: Ein Domänenmodell mit Records und Sealed Classes entwerfen

---

Tag 2: Pattern Matching, neue APIs und modernes Java

5. Pattern Matching in der Tiefe

• Instanceof Patterns (Rückblick und Vertiefung)
• Pattern Matching in switch: Typ-Patterns, Guarded Patterns (Java 21)
• Record Patterns: Destrukturierung verschachtelter Records (Java 21)
• Exhaustiveness: Warum der Compiler jetzt auf vollständige Abdeckung prüft
• Unnamed Patterns und Variables: _ für bewusst ignorierte Werte (Java 22)
• Primitive Patterns in instanceof und switch (Java 23+)
• Pattern Matching als Paradigmenwechsel: Von if-Kaskaden zu deklarativem Code
• Praktische Übung: Komplexe Datenstrukturen mit Pattern Matching verarbeiten

6. Neue und verbesserte APIs

• Neuerungen in der Collections API: List.of(), Map.of(), List.copyOf(), Sequenced Collections (Java 21)
• Stream API: toList(), mapMulti(), teeing() und Stream Gatherers (Java 24)
• Optional-Verbesserungen: ifPresentOrElse(), or(), stream()
• String-Verbesserungen: strip(), indent(), transform(), String Templates (Ausblick)
• Process API und ProcessBuilder-Verbesserungen (Java 9)
• Die neue HTTP Client API: Moderne HTTP-Kommunikation ohne Drittbibliotheken (Java 11)
• Praktische Übung: HTTP Client und neue Collection/Stream-APIs einsetzen

7. Tooling und Laufzeitverbesserungen

• Einführung einfacher Programme: void main() und implizite Klassen (Java 24)
• Multi-File Source-Code-Programme: Java-Dateien direkt ausführen ohne Kompilierung
• jlink: Eigene schlanke Java-Runtimes schnüren
• jpackage: Native Installer für Java-Anwendungen erstellen
• Garbage Collection: Von G1 über ZGC zu Shenandoah — was wann?
• Application Class-Data Sharing (AppCDS): Schnellerer Start
• Praktische Übung: Eine Anwendung mit jlink als Custom Runtime paketieren

---

Tag 3: Nebenläufigkeit, native Interoperabilität und Migration

8. Virtual Threads

• Das Problem mit Platform Threads: Warum eine Million Threads keine gute Idee war
• Virtual Threads: Leichtgewichtige Threads auf der JVM (Java 21)
• Thread.ofVirtual(), Executors.newVirtualThreadPerTaskExecutor()
• Virtual Threads in der Praxis: Was sich ändert — und was nicht
• Pinning: Wann Virtual Threads blockiert werden und wie man es vermeidet
• Thread-Local vs. Scoped Values: Warum ThreadLocal mit Virtual Threads problematisch ist
• Praktische Übung: Eine blockierende Anwendung auf Virtual Threads umstellen

9. Structured Concurrency und Scoped Values

• Structured Concurrency: Nebenläufigkeit mit klarer Struktur (Java 24/25)
• StructuredTaskScope: Parallele Aufgaben starten, zusammenführen, abbrechen
• Strategien: ShutdownOnSuccess, ShutdownOnFailure
• Fehlerbehandlung und Cancellation in strukturierter Nebenläufigkeit
• Scoped Values: Kontextdaten sicher durch Virtual Threads weiterreichen (Java 24/25)
• Scoped Values vs. ThreadLocal: Wann was?
• Praktische Übung: Parallele API-Aufrufe mit Structured Concurrency orchestrieren

10. Foreign Function & Memory API

• Motivation: Warum JNI nicht mehr zeitgemäß ist
• Die Foreign Function & Memory API (FFM): Native Bibliotheken aus Java aufrufen (Java 22)
• MemorySegment, Arena und Linker: Die Bausteine der FFM API
• Sicherheitsmodell: Restricted Methods und --enable-native-access
• jextract: C-Header automatisch in Java-Bindings übersetzen
• Praktische Übung: Eine native C-Bibliothek aus Java aufrufen

11. Migration und Modernisierung

• Von Java 8 auf Java 21+: Die wichtigsten Stolpersteine
• Entfernte und veraltete APIs: Nashorn, Security Manager, Finalization
• Migrationspfad für Bibliotheken und Frameworks: Was ist kompatibel?
• Modularisierung bestehender Projekte: Schritt für Schritt oder Big Bang?
• Java 8-Idiome modernisieren: Vorher/Nachher-Vergleiche
• Empfehlungen: Welche Features den größten Mehrwert bringen
• Praktische Übung: Ein Java-8-Projekt auf Java 25 migrieren und modernisieren

Zielgruppe: Softwareentwickelnde und Architekt:innen, die moderne Webanwendungen mit Ruby on Rails entwickeln wollen — ob Einstieg in Rails oder Umstieg von anderen Frameworks.

Kurzbeschreibung: Wie funktioniert Convention over Configuration in der Praxis? Wie modelliere ich Datenbank-Relationen mit Active Record, ohne in N+1-Query-Fallen zu tappen? Wie baue ich Formulare, Authentifizierung und Hintergrund-Jobs? Und was bringen die neuen Rails-8-Features wie Solid Queue und Kamal? Dieser Workshop gibt Ihnen fundierte Antworten — von den Ruby-Grundlagen über MVC-Architektur und Active Record bis hin zu Testing, Turbo und Deployment.

Schulungsziel: Sie können eigenständig Rails-Anwendungen entwickeln, die produktionsreif sind. Sie verstehen das Zusammenspiel von Routes, Controllers, Models und Views, beherrschen Active Record für die Datenbankarbeit und können moderne, reaktive Oberflächen mit Hotwire bauen. Sie wissen, wie Sie Ihre Anwendung testen, absichern und deployen. Nach dem Workshop sind Sie in der Lage, Rails-Projekte von der Idee bis zum Go-Live umzusetzen.

Voraussetzung: Programmiererfahrung in einer beliebigen Sprache. Grundlegendes Verständnis von HTML und HTTP ist hilfreich. Ruby-Vorkenntnisse sind nicht erforderlich — die nötigen Grundlagen werden am ersten Tag vermittelt.

---

Tag 1: Ruby-Grundlagen und die Rails-Architektur

1. Ruby — Das Wichtigste für Rails

• Warum Ruby? Philosophie und Sprachdesign
• Alles ist ein Objekt: Klassen, Methoden, Blöcke
• Strings, Symbole, Arrays, Hashes
• Kontrollstrukturen und Iteratoren
• Blöcke, Procs und Lambdas — Rubys funktionale Seite
• Modules und Mixins: Code-Wiederverwendung ohne Vererbungsketten
• Praktische Übung: Ruby-Grundlagen in der IRB interaktiv erkunden

2. Einstieg in Ruby on Rails

• Was ist Rails? Geschichte und Philosophie
• Convention over Configuration und Don’t Repeat Yourself
• Was ist neu in Rails 8?
• Die Rails-Projektstruktur im Detail
• Der Request-Lifecycle: Vom HTTP-Request zur Response
• Generators: Schnell produktiv mit rails generate
• Praktische Übung: Eine neue Rails-Anwendung erzeugen und die Struktur verstehen

3. Routing und Controller

• RESTful Routing: Resources und die sieben Standard-Actions
• Verschachtelte Routes und Custom Routes
• Controller-Actions: Parameter, Responses, Redirects
• Strong Parameters: Eingaben sicher entgegennehmen
• Filters: before_action, around_action, after_action
• Praktische Übung: Routes und Controller für eine CRUD-Anwendung implementieren

4. Active Record — Das Herzstück von Rails

• Active Record als ORM: Konventionen und Konfiguration
• Migrations: Datenbankschema versioniert verwalten
• Validierungen: Built-in-Validierungen und Custom Validators
• Callbacks: Hooks im Model-Lifecycle
• CRUD-Operationen: Erstellen, Lesen, Aktualisieren, Löschen
• Praktische Übung: Models mit Validierungen und Migrations anlegen

---

Tag 2: Datenmodellierung, Views und modernes Frontend

5. Active Record — Relationen und Queries

• Assoziationen: belongs_to, has_many, has_many :through, polymorphe Relationen
• Scopes: Wiederverwendbare Abfragen definieren
• Eager Loading vs. Lazy Loading: N+1-Queries erkennen und vermeiden
• Query Interface im Detail: where, joins, includes, group, having
• Seed-Daten und Fixtures für die Entwicklung
• Praktische Übung: Relationen modellieren und performante Queries schreiben

6. Views und Layouts

• ERB-Templates: Ruby in HTML einbetten
• Layouts, Partials und Content Blocks
• View Helpers: Formulare, Links, Formatierungen
• Form Builder im Detail: form_with und verschachtelte Formulare
• Asset Pipeline vs. Propshaft: CSS und JavaScript einbinden
• Praktische Übung: Views mit Partials und Formularen bauen

7. Hotwire — Modernes Frontend ohne JavaScript-Framework

• Turbo Drive: Schnelle Navigation ohne Full-Page-Reloads
• Turbo Frames: Teile der Seite gezielt aktualisieren
• Turbo Streams: Echtzeit-Updates vom Server
• Stimulus: Leichtgewichtiges JavaScript für Interaktivität
• Wann reicht Hotwire — und wann brauche ich ein SPA-Framework?
• Praktische Übung: Eine interaktive Oberfläche mit Turbo Frames und Streams bauen

8. Authentifizierung und Autorisierung

• Rails 8 Authentication Generator: Authentifizierung out of the box
• Sessions, Cookies und sichere Passwort-Speicherung mit has_secure_password
• Autorisierung: Zugriffsrechte im Controller und in Views steuern
• CSRF-Schutz und Security Best Practices
• Praktische Übung: Login, Logout und rollenbasierte Zugriffskontrolle implementieren

---

Tag 3: Testing, Background Jobs und Deployment

9. Testen von Rails-Anwendungen

• Die Testpyramide in Rails: Model-, Controller- und Systemtests
• Minitest vs. RSpec: Überblick und Entscheidungshilfe
• Model-Tests: Validierungen, Scopes und Geschäftslogik testen
• Controller- und Integrationstests mit ActionDispatch
• System-Tests mit Capybara: End-to-End im Browser
• Fixtures und Factories: Testdaten effizient verwalten
• Praktische Übung: Tests für Models, Controller und eine User-Story schreiben

10. Background Jobs und E-Mail

• Active Job: Hintergrundverarbeitung in Rails
• Solid Queue: Der neue Standard-Adapter in Rails 8
• Typische Einsatzszenarien: E-Mails, Importe, Benachrichtigungen
• Action Mailer: E-Mails versenden und testen
• Action Mailbox: Eingehende E-Mails verarbeiten
• Praktische Übung: Einen Background Job mit E-Mail-Versand implementieren

11. Caching, Performance und APIs

• Solid Cache: Caching ohne Redis in Rails 8
• Fragment Caching und Russian-Doll Caching
• Datenbankabfragen optimieren: explain, bullet gem, Indexing-Strategien
• Rails als API-Backend: --api-Modus und JSON-Serialisierung
• API-Authentifizierung mit Token
• Praktische Übung: Caching einrichten und einen API-Endpoint bauen

12. Deployment und Produktion

• Kamal: Rails-8-Deployment ohne Plattform-Lock-in
• Deployment-Workflow: Von der lokalen Entwicklung auf den Server
• Datenbank-Migrationen in Produktion: Strategien und Risiken
• Umgebungskonfiguration: Credentials und verschlüsselte Secrets
• Logging, Monitoring und Fehlerbehandlung in Produktion
• Ausblick: Action Cable für WebSockets, Solid Cable und die Rails-Roadmap
• Praktische Übung: Die Workshop-Anwendung mit Kamal deployen