Software-Migrationen mit KI-Unterstützung

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.

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-SystemEin 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

Wichtig: Die oben genannten Inhalte beziehen sich auf unsere offenen Schulungstermine für Einzelteilnehmer. Wir bieten auch indviduelle Firmenworkshops an.

In unseren projektspezifischen Firmenworkshops migrieren und analysieren wir ausgewählte Module Ihrer Legacy-Software exemplarisch in eine gewünschte Zieltechnologie.

Hier ist eine kleine Auswahl möglicher Migrationsbeispiele:

Backend

• Monolith -> Microservices

• WildFly/JBoss EAP -> Quarkus

• EJB -> CDI + REST

• SOAP (JAX-WS) -> Rest

• Java Upgrade auf aktuelle LTS Version

• Spring / Spring Boot -> Jakarta EE

• native SQL -> JPA / Hibernate

• WordPress-Webseite -> Astro (Static Site Generator)

• Spring JSF mit XML-Konfiguration -> Spring Boot mit Annotationen

Frontend

• JSF -> Angular / React / Vue.

• Desktop mit Swing UI -> Webanwendung

• HTML, JS & jQuery und CSS-Spaghetti -> React mit TypeScript und Tailwind

Mobile

• Android / ioS -> React Native

• Android -> Jetpack Compose

• Android Java -> Android Kotlin

Datenbanken

• Oracle/DB 2 -> Postgres

• MySQL -> Postgres

• MySQL -> MariaDB

Infrastruktur

• Jenkins -> Gitlab CI

• Apache & Tomcat -> Docker/Kubernetes mit Traefik oder nginx

• SVN -> Git

Dokumentation

• Word, PDF, PowerPoint -> Markdown

• Visio, yEd, draw.io -> Markdown

• Visio -> Mermaid

Agenda

Tag 1: Grundlagen & Analyse von Legacy-Systemen​Ü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?

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

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

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"

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

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

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

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

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

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

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

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

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

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

Teilnehmerkreis und Voraussetzungen

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

Technische VoraussetzungenGitHub 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.

Mindestanzahl Teilnehmende: 2 Personen