Seminar Eclipse Capella Intensivseminar: Architektur, Schnittstellen und Multi-Level Engineering

Das Intensivformat bündelt Lösungsarchitektur, Daten- und Schnittstellenmodellierung, physische Realisierung, EPBS, Wiederverwendung und Subsystemübergänge. Der Schwerpunkt liegt auf konsistenten Entscheidungen über mehrere Engineering-Ebenen.

Inhaltsübersicht

1. Zielsetzung
2. Zielgruppe
3. Voraussetzungen
4. Seminarinhalte
5. Praxisübungen
6. Lernorganisation
7. Einordnung im Lernpfad

Zielsetzung

Ziel ist eine nachvollziehbare Architektur vom logischen Entwurf bis zu physischen Komponenten, Konfigurationseinheiten und Subsystemverträgen.

Zielgruppe

System-, Software- und Hardwarearchitekten, Lead Architects, Integrationsverantwortliche und erfahrene Modellierende.

Voraussetzungen

Arcadia- und System-Analysis-Kenntnisse sowie sichere Capella-Bedienung.

Seminarinhalte

1. Logische Komponentenarchitektur entwerfen

1. Schritt 1: Architekturtreiber, Qualitätsmerkmale und Lösungsalternativen sammeln.
2. Schritt 2: Logische Komponenten nach Verantwortlichkeiten und Kohäsion strukturieren.
3. Schritt 3: Logische Funktionen Komponenten zuordnen und Schnittstellenkandidaten ableiten.
4. Schritt 4: Alternativen anhand nachvollziehbarer Kriterien vergleichen und begründen.

2. Logisches Verhalten, Austausch und Szenarien verfeinern

1. Schritt 1: Logische Funktionen aus der Systemebene überführen und gezielt verfeinern.
2. Schritt 2: Komponentenaustausch aus funktionalen Austauschbeziehungen ableiten.
3. Schritt 3: Szenarien für Normal-, Ausnahme- und Degradationsfälle modellieren.
4. Schritt 4: Funktionale und strukturelle Sicht auf Konsistenz und Schnittstellenlücken prüfen.

3. Daten, Austauschobjekte und Informationsmodelle modellieren

1. Schritt 1: Grundtypen, Aufzählungen, Klassen und Sammlungen nach einer Modellierungsregel anlegen.
2. Schritt 2: Exchange Items strukturieren und geeignete Austauschmechanismen zuordnen.
3. Schritt 3: Datenbeziehungen, Multiplizitäten und Eigentumsverhältnisse konsistent definieren.
4. Schritt 4: Verwendung der Datentypen in Funktionen, Schnittstellen und Szenarien prüfen.

4. Schnittstellen und Austauschbeziehungen beherrschen

1. Schritt 1: Funktionale Exchanges, Component Exchanges, Ports und Interfaces voneinander abgrenzen.
2. Schritt 2: Austauschobjekte und Richtungen aus fachlichen Kommunikationsbedarfen ableiten.
3. Schritt 3: Schnittstellen aus zugeordneten Funktionen generieren und kontrolliert nacharbeiten.
4. Schritt 4: Konsistenz zwischen Funktions-, Komponenten- und Datensicht mit Matrizen prüfen.

5. Architekturvarianten und Trade-offs nachvollziehbar bewerten

1. Schritt 1: Entscheidungskriterien, Messgrößen und Mindestanforderungen definieren.
2. Schritt 2: Varianten im Modell eindeutig kennzeichnen und vergleichbare Sichten erzeugen.
3. Schritt 3: Eigenschaften, Risiken und Abhängigkeiten je Variante bewerten.
4. Schritt 4: Entscheidung mit Annahmen, Befunden und offenen Punkten dokumentieren.

6. Physische Architektur und Deployment ausarbeiten

1. Schritt 1: Verhaltens- und Knotensicht physischer Komponenten unterscheiden.
2. Schritt 2: Logische Verantwortlichkeiten auf reale technische Bausteine und Ressourcen abbilden.
3. Schritt 3: Physische Links, Kommunikationspfade und Hosting-Beziehungen modellieren.
4. Schritt 4: Deployment-Entscheidungen gegen Leistungs-, Sicherheits- und Integrationsanforderungen prüfen.

7. EPBS, Konfigurationseinheiten und Komponentenverträge ableiten

1. Schritt 1: Konfigurationseinheiten aus der physischen Architektur und organisatorischen Randbedingungen bestimmen.
2. Schritt 2: End-Product-Breakdown-Structure hierarchisch und verantwortungsgerecht aufbauen.
3. Schritt 3: Erwartete Funktionen, Schnittstellen, Eigenschaften und Nachweise je Einheit zusammenstellen.
4. Schritt 4: Komponentenverträge für Entwicklung, Integration und Verifikation reviewfähig dokumentieren.

8. Bibliotheken und wiederverwendbare Modellelemente strukturieren

1. Schritt 1: Wiederverwendungsziel, Besitz, Änderungsrecht und Gültigkeitsbereich festlegen.
2. Schritt 2: Gemeinsame Typen und Architekturbausteine in Bibliotheken auslagern.
3. Schritt 3: Abhängigkeiten zwischen Projekten prüfen und kontrolliert aktualisieren.
4. Schritt 4: Freigabestand, Version und Kompatibilität der Bibliothek dokumentieren.

9. REC/RPL-Muster für kontrollierte Wiederverwendung anwenden

1. Schritt 1: Geeigneten Modellumfang für eine Replicable Elements Collection bestimmen.
2. Schritt 2: REC erzeugen, Inhalt und Abhängigkeiten prüfen und als Muster freigeben.
3. Schritt 3: RPL in einem Zielkontext instanziieren und zulässige Anpassungen vornehmen.
4. Schritt 4: Aktualisierungen zwischen REC und RPL analysieren und kontrolliert übernehmen.

10. System-zu-Subsystem-Übergänge vorbereiten und ausführen

1. Schritt 1: Subsystemgrenze, Verantwortungsbereich und benötigte Kontextinformationen festlegen.
2. Schritt 2: Übergang konfigurieren und aus der Systemarchitektur ein Subsystemmodell erzeugen.
3. Schritt 3: Übertragene Funktionen, Schnittstellen, Akteure und Daten auf Vollständigkeit prüfen.
4. Schritt 4: Wiederholte Übergänge und Änderungen mit klaren Verantwortlichkeiten steuern.

11. Multi-Level Engineering und Modellverträge organisieren

1. Schritt 1: System-, Subsystem- und Komponentenebenen mit eindeutigen Eigentumsgrenzen definieren.
2. Schritt 2: Verträge für Funktionen, Schnittstellen, Eigenschaften und Nachweise abstimmen.
3. Schritt 3: Änderungen zwischen Ebenen als geregelte Rückkopplung behandeln.
4. Schritt 4: Abhängigkeiten, Freigaben und Integrationspunkte in einer Modelllandkarte dokumentieren.

12. Architektur mit Integration und Verifikation verknüpfen

1. Schritt 1: Fähigkeiten, funktionale Ketten und Szenarien als Grundlage für Nachweise auswählen.
2. Schritt 2: Integrationsreihenfolge und erforderliche Konfigurationseinheiten aus Abhängigkeiten ableiten.
3. Schritt 3: Prüfziele mit Funktionen, Schnittstellen, Zuständen und Anforderungen verknüpfen.
4. Schritt 4: Lücken zwischen Architekturdefinition und Verifikationsplanung sichtbar machen.

13. Validierungsregeln, Profile und Schnellkorrekturen einsetzen

1. Schritt 1: Integritäts-, Design-, Vollständigkeits- und Traceability-Prüfungen unterscheiden.
2. Schritt 2: Passendes Validierungsprofil für Modellierungsphase und Reviewziel auswählen.
3. Schritt 3: Befunde priorisieren, Ursachen analysieren und Schnellkorrekturen kontrolliert anwenden.
4. Schritt 4: Restbefunde begründen und als überprüfbare Qualitätsentscheidung dokumentieren.

Praxisübungen

• Zwei logische Architekturvarianten modellieren und anhand definierter Treiber bewerten.
• Ein logisches Szenario mit Komponenten, Funktionen und Austauschobjekten vollständig ausarbeiten.
• Ein kleines Informationsmodell erstellen und in zwei Schnittstellen konsistent verwenden.
• Eine externe und eine interne Schnittstelle einschließlich Datenobjekten vollständig spezifizieren.
• Zwei Architekturvarianten anhand von Kosten, Masse, Reife und Risiko vergleichen.
• Eine logische Architektur in eine physische Zielarchitektur mit Hosting und Links überführen.
• Für einen physischen Teilbaum eine EPBS-Struktur und einen Komponentenvertrag erstellen.
• Eine Bibliothek mit gemeinsam genutzten Datentypen und Komponenten in zwei Projekten einsetzen.

Lernorganisation

Eine vorhandene System Analysis dient als Startpunkt. Architekturvarianten, technische Realisierung und Subsystemzuschnitt werden in eng gekoppelten Modell- und Reviewphasen bearbeitet.

Einordnung im Lernpfad

Deckt die Einzelseminare zu logischer und physischer Architektur, Schnittstellen, Bibliotheken sowie System-zu-Subsystem-Übergängen in verdichteter Form ab.