Seminar Modelio – Intensivseminar Automatisierung, Erweiterung und Code Engineering

Beschreibung

Der Intensivpfad verbindet Jython, Makros, API-Navigation, transaktionale Modelländerungen, Profile, Stereotype, Studio-Konfiguration, Java-Erweiterungen, Modulpaketierung, XMI und Java Code Engineering. Ein gemeinsames Erweiterungsprojekt automatisiert Modellprüfung, Modellpflege und Code- beziehungsweise Austauschabläufe.

Formatbegründung: Fünf Tage sind die maximale und zugleich notwendige Dauer, um Skripting, Erweiterungsmetamodell, Java-Code-Engineering und Modulbereitstellung praktisch zu verbinden, ohne kritische Test-, Rollback- und Qualitätsphasen auszulassen.

Zielgruppe

Tool Engineers, Java- und Python-Entwickler, Softwarearchitekten, Methodenverantwortliche und technische Modelio-Plattformteams.

Voraussetzungen

Sehr sichere Modelio-Bedienung, gute Java-Kenntnisse, Grundlagen in Python/Jython, UML-Metamodellverständnis und Erfahrung mit Build- sowie Versionsprozessen.

Inhaltsübersicht

1. Jython-Konsole und sichere Skriptgrundlagen
2. Modelio-API und Modellnavigation
3. Makros und wiederkehrende Arbeitsabläufe
4. Transaktionale Modelländerungen
5. Automatisierte Listen, Prüfungen und Berichte
6. Metamodell, Profile und Erweiterungskonzept
7. Stereotype, Tag-Werte und Darstellung
8. Eigene Diagrammtypen, Paletten und Kommandos
9. Modelio Studio mit Java- und Jython-Erweiterungen
10. Modulstruktur, Paketierung und Bereitstellung
11. Tests, Diagnose und Wartbarkeit von Erweiterungen
12. Java-orientiertes Klassen- und Paketmodell
13. Codegenerierung und Generierungsregeln
14. Reverse Engineering aus Java-Quellcode
15. Roundtrip, Synchronisation und Konfliktregeln
16. Roundtrip-Test und Austauschabnahme

Seminarinhalte

1. Jython-Konsole und sichere Skriptgrundlagen

Skripte beginnen mit lesenden Abfragen und klarer Trennung zwischen Analyse und Modelländerung.

1. Jython-Konsole öffnen und verfügbare Kontextobjekte sowie Ausgaben prüfen.
2. Modellelemente nach Typ, Name, Paket und Eigenschaft suchen.
3. Ergebnisse strukturiert ausgeben und leere, doppelte oder unerwartete Treffer behandeln.
4. Skript mit Parametern, Fehlerbehandlung und Dry-Run-Schalter wiederverwendbar machen.

2. Modelio-API und Modellnavigation

Die API wird genutzt, um Modellinhalte zuverlässig zu lesen, zu filtern und über Beziehungen zu navigieren.

1. Einstiegspunkte für Sitzung, aktuelles Projekt, Modellservices und Metamodell einordnen.
2. Elemente typisiert abfragen und Eigenschaften sicher auslesen.
3. Besitzer-, Abhängigkeits- und Traceability-Beziehungen in beide Richtungen traversieren.
4. Abfrageergebnisse gegen die Benutzeroberfläche und ein bekanntes Referenzmodell validieren.

3. Makros und wiederkehrende Arbeitsabläufe

Häufige Modellierungs- und Prüfaufgaben werden als nachvollziehbare Makros standardisiert.

1. Geeigneten Ablauf mit klaren Eingaben, Ausgaben und Grenzen auswählen.
2. Makro für Selektion, Benennung, Statuspflege oder Berichtserzeugung entwickeln.
3. Makro an normalen, leeren und fehlerhaften Eingaben testen.
4. Bedienhinweis, Version, Verantwortlichkeit und Freigabestatus dokumentieren.

4. Transaktionale Modelländerungen

Schreibende Automatisierung wird mit Vorprüfung, Transaktion, Validierung und Rückfalloption abgesichert.

1. Änderungsmenge zunächst lesend ermitteln und als Vorschau ausgeben.
2. Elemente, Beziehungen oder Eigenschaften innerhalb einer kontrollierten Transaktion ändern.
3. Fehlerbehandlung und Rollback für unvollständige Änderungen einbauen.
4. Audit ausführen und geänderte Elemente in einem Änderungsprotokoll zusammenstellen.

5. Automatisierte Listen, Prüfungen und Berichte

Skripte verbinden Modellabfragen mit reproduzierbaren Qualitäts- und Steuerungsinformationen.

1. Berichtsfrage und benötigte Felder für Elemente, Beziehungen und Status definieren.
2. Abfrage und Aggregation implementieren und sortierbare Ausgabe erzeugen.
3. Ergebnis mit manueller Stichprobe und bekannten Sollwerten prüfen.
4. Ausführung, Ausgabeformat, Ablage und Fehlerbehandlung für den Regelbetrieb festlegen.

6. Metamodell, Profile und Erweiterungskonzept

Erweiterungen werden auf fachlichen Bedarf begrenzt und sauber vom Standardmetamodell abgegrenzt.

1. Erweiterungsbedarf, Zielgruppen und nicht durch Standardmodelle abgedeckte Informationen sammeln.
2. Geeignete Metaklassen, Erweiterungspunkte und Namensräume bestimmen.
3. Profilstruktur mit Stereotypen, Eigenschaften, Enumerationen und Constraints entwerfen.
4. Konzept gegen Austausch, Dokumentation, Bedienbarkeit und langfristige Pflege prüfen.

7. Stereotype, Tag-Werte und Darstellung

Fachspezifische Begriffe werden mit kontrollierter Semantik und konsistenter Darstellung umgesetzt.

1. Stereotype mit Geltungsbereich, Bedeutung und erlaubten Basistypen definieren.
2. Tag-Werte, Datentypen, Pflichtfelder und Standardwerte anlegen.
3. Symbolik, Beschriftung und Eigenschaftsdarstellung konfigurieren.
4. Beispielmodell erzeugen und Stereotypanwendung, Validierung und Dokumentausgabe testen.

8. Eigene Diagrammtypen, Paletten und Kommandos

Spezialisierte Arbeitsoberflächen reduzieren Fehlbedienung und führen durch einen definierten Modellierungsprozess.

1. Zweck, zugelassene Elemente, Beziehungen und Diagrammregeln festlegen.
2. Diagrammtyp, Palette und Erzeugungskommandos konfigurieren.
3. Kontextmenüs, Eigenschaften und Schnellaktionen ergänzen.
4. Diagramm mit Neuaufbau, Bearbeitung, Kopie, Export und Wiederöffnung testen.

9. Modelio Studio mit Java- und Jython-Erweiterungen

Konfiguration und Programmierung werden gezielt kombiniert, um wartbare Erweiterungen zu erzeugen.

1. Funktionsumfang zwischen Profil, Studio-Konfiguration, Jython-Skript und Java-Modul aufteilen.
2. Einen prototypischen Befehl mit Modelio Studio und Jython implementieren.
3. Komplexere Logik, Services und Fehlerbehandlung in einer Java-Erweiterung strukturieren.
4. Beide Varianten auf Installation, Bedienung, Diagnose und Versionskompatibilität vergleichen.

10. Modulstruktur, Paketierung und Bereitstellung

Erweiterungen erhalten eine nachvollziehbare Versionierung, Abhängigkeiten und einen kontrollierten Auslieferungsprozess.

1. Modulmetadaten, Abhängigkeiten, Ressourcen und Versionsschema festlegen.
2. Erweiterung bauen und in einer getrennten Testinstallation einspielen.
3. Aktivierung, Aktualisierung, Deaktivierung und Entfernung prüfen.
4. Freigabepaket mit Installationshinweis, Kompatibilitätsmatrix und Rollbackplan erstellen.

11. Tests, Diagnose und Wartbarkeit von Erweiterungen

Erweiterungen werden gegen funktionale, technische und betriebliche Kriterien geprüft.

1. Testfälle für normale Bedienung, Fehlerfälle, große Modelle und fehlende Abhängigkeiten definieren.
2. Protokollierung und verständliche Fehlermeldungen ergänzen.
3. Regressionstest nach Profil-, API- oder Moduländerung durchführen.
4. Offene Risiken, bekannte Einschränkungen und Wartungsverantwortung dokumentieren.

12. Java-orientiertes Klassen- und Paketmodell

Das Modell wird auf Java-Strukturen, Sichtbarkeiten, Typen und Paketierungsregeln ausgerichtet.

1. Java-Pakete, Klassen, Schnittstellen, Aufzählungen und Datentypen modellieren.
2. Attribute, Operationen, Parameter, Exceptions und Sichtbarkeiten festlegen.
3. Vererbung, Realisierung, Assoziationen und Abhängigkeiten Java-konform prüfen.
4. Modell mit einer Zielprojektstruktur und vereinbarten Coding-Regeln abgleichen.

13. Codegenerierung und Generierungsregeln

Generierung wird kontrolliert vorbereitet, damit Modellentscheidungen reproduzierbar in Quellcode überführt werden.

1. Generierungsumfang, Zielpfade, Paketstruktur und Überschreibungsregeln definieren.
2. Java-Code aus einem ausgewählten Modellbereich erzeugen.
3. Generierte Dateien, Signaturen, Kommentare und Abhängigkeiten prüfen.
4. Generierung nach Modelländerung wiederholen und unbeabsichtigte Codeänderungen ausschließen.

14. Reverse Engineering aus Java-Quellcode

Bestehender Code wird selektiv in ein analysierbares Modell überführt.

1. Quellcodebestand, Buildstruktur, Abhängigkeiten und gewünschte Modellgranularität festlegen.
2. Ausgewählte Pakete und Klassen einlesen und Importprotokoll prüfen.
3. Technische Details filtern und Architektursichten aus dem importierten Modell ableiten.
4. Import mit Stichproben gegen den Quellcode und bekannte Architekturentscheidungen validieren.

15. Roundtrip, Synchronisation und Konfliktregeln

Änderungen in Modell und Code werden mit eindeutigem Verantwortungs- und Synchronisationsverfahren abgestimmt.

1. Führende Quelle je Artefaktart und erlaubte Änderungsrichtungen definieren.
2. Modelländerung generieren und kontrollierte Codeänderung zurückführen.
3. Konflikte, Umbenennungen und gelöschte Elemente anhand einer Vergleichssicht untersuchen.
4. Synchronisationszyklus mit Review, Build und Wiederholbarkeit abschließen.

16. Roundtrip-Test und Austauschabnahme

Ein kontrollierter Hin- und Rückaustausch macht Datenverlust und semantische Verschiebung sichtbar.

1. Referenzmodell exportieren, im Ziel importieren und dort eine definierte Änderung durchführen.
2. Geändertes Modell zurückübertragen und mit dem Ausgangsmodell vergleichen.
3. Abweichungen nach Struktur, Beziehungen, Eigenschaften, Profilen und Diagrammen klassifizieren.
4. Austauschfreigabe, Einschränkungen und zulässige Nacharbeiten dokumentieren.

Praxisübungen

• Automatisierte Modellanalyse mit Bericht und Dry-Run.
• Entwicklung eines Profils mit eigenem Diagrammtyp und Kommando.
• Java-Generierung, Reverse Engineering und Roundtrip in einem Beispielprojekt.
• Paketierung, Installation, Regressionstest und Austauschabnahme.

Qualitätskriterien

• Modellelemente werden im Modellbaum eindeutig strukturiert und in Diagrammen wiederverwendet statt dupliziert.
• Beziehungen, Status, Benennung und Verantwortlichkeiten sind nachvollziehbar und entsprechen dem vereinbarten Modellierungsrahmen.
• Audit- und Reviewbefunde werden priorisiert, korrigiert und in einer erneuten Prüfung verifiziert.
• Übungsergebnisse lassen sich nach Schließen und erneutem Öffnen des Projekts reproduzierbar nachvollziehen.
• Der durchgängige Fall verbindet alle Teilgebiete in einem freigegebenen, dokumentierten Gesamtmodell.