SysML Kompakt: Modellierung mit Übungen und Whitepapers

Ein Use-Case-Diagramm zeigt dir, welche Dienste dein System nach außen anbietet und wer sie nutzt. Du wirst lernen, was ein Use Case ist, wie er als Vertrag zwischen dem Akteur und dem System funktioniert und wie du ihn richtig benennst.

Lerninhalt:

• Einsatz und Aufbau eines Use-Case-Diagramms

• Definition von Use Cases

• Unterscheidung zwischen primären und sekundären Akteuren

• Korrekte Benennung von Use Cases

Versetze dich in die Rolle der Akteure und sprich mit den Stakeholdern, um ihre Ziele und Bedürfnisse zu verstehen. Nutze Beobachtungen, Interviews und Umfragen, um die wichtigen Use Cases zu identifizieren. Denke daran, dass dieser Prozess iterativ ist und Flexibilität erfordert.

Lerninhalte:

• Perspektive der Akteure einnehmen

• Einbindung der Stakeholder

• Methoden zur Identifikation von Use Cases

• Iterativer Anpassungsprozess

Wir fügen die grundlegenden Elemente eines Use-Case-Diagramms hinzu: die Systemgrenze, Use Cases, Akteure und Verbindungen als Linien, die Akteure mit Use Cases verbinden.

Lerninhalte:

• Definieren der Systemgrenze

• Erstellung und Benennung von Use Cases

• Identifikation und Visualisierung von Akteuren

• Erstellung von Verbindungen zwischen Akteuren und Use Cases

Die Multiplizität zeigt, wie viele Instanzen eines Elements mit wie vielen Instanzen eines anderen verbunden sind. Zum Beispiel kann ein Kunde in einem Online-Shop mehrere Bestellungen aufgeben (Multiplizität 0..*), aber jede Bestellung gehört genau einem Kunden (Multiplizität 1). Diese Information hilft, die Vielfalt der Verbindungen in deinen Modellen klar darzustellen.

Lerninhalte:

• Bedeutung der Multiplizität im Use-Case-Diagramm

• Beispiele für verschiedene Arten von Multiplizität

• Einsatz der Multiplizität zur Spezifizierung des Detailgrads von Verbindungen

In diesem Kapitel beantworten wir zentrale Fragen zur Strukturierung von Use-Case-Diagrammen: Wie kombiniert man ähnliche Use Cases effektiv? Wann und wie werden Use Cases automatisch verknüpft? Und unter welchen Bedingungen können zusätzliche Aktionen in einem Use Case auftreten? Wir zeigen dir, wie du Generalisierungen, «Include» und «Extend» einsetzt, um deine Diagramme klar und übersichtlich zu gestalten.

Lerninhalte:

• Klarheit über den Einsatz von Generalisierungen in Use-Case-Diagrammen

• Verstehen, wann «Include»-Beziehungen nützlich sind und wie sie dargestellt werden

• Wissen, wann «Extend»-Beziehungen verwendet werden sollten

• Einsatz von Beziehungstypen zur Optimierung der Diagrammstruktur

In diesem Kapitel beantworten wir eine oft übersehene, aber wichtige Frage: Was ist der Unterschied zwischen Szenarien und Use Cases? Wir klären, warum Use Cases und Szenarien keine Synonyme sind und wie sie miteinander in Beziehung stehen. Du wirst lernen, wie Szenarien die möglichen Ablaufvarianten innerhalb eines Use Cases als konkrete Ausführungspfade beschreiben.

Kursinhalte:

• Definition und Unterscheidung von Use Cases und Szenarien

• Verständnis der Struktur und Bedeutung von Haupt-Erfolgsszenarien und alternativen Szenarien

• Einblick, warum Szenarien nicht im Use-Case-Diagramm dargestellt werden

• Die Bedeutung von Szenarien für ein vollständiges und realistisches Systemmodell

Heute klären wir, warum ein Use-Case-Diagramm allein nicht ausreicht und wie du mit einer detaillierten Use-Case-Spezifikation alle wichtigen Informationen erfassen kannst. Wir besprechen, welche Elemente in einer Spezifikation nicht fehlen dürfen: vom Namen und Scope über Akteure, Stakeholder, Vor- und Nachbedingungen bis hin zu Triggern und Szenarien. Du lernst, wie du eine vollständige und verständliche Spezifikation erstellst, die Abläufe und Anforderungen klar und präzise dokumentiert. Damit schaffst du die Grundlage für eine erfolgreiche Systementwicklung.

Kursinhalte:

• Aufbau einer vollständigen Use-Case-Spezifikation

• Wichtige Inhalte: Name, Scope, Akteure, Stakeholder, Vor- und Nachbedingungen, Trigger und Szenarien

• Unterschied zwischen Diagramm und textlicher Spezifikation

In dieser Lektion behandeln wir eine häufige Stolperfalle: Wie fein granular sollte ein Use Case eigentlich sein? Du wirst lernen, warum es wichtig ist, den Umfang nicht zu weit zu fassen, und wie du erkennst, ob dein Use Case zu groß ist. Wir zeigen dir, wie du komplexe Use Cases wie „Bestellung aufgeben“ in spezifischere und präzisere Use Cases aufteilen kannst, um Klarheit und Struktur zu schaffen. Ein Use Case ist dann optimal, wenn er genau ein Hauptszenario beschreibt – alles andere sind Ausnahmen oder Fehler.

Kursinhalte:

• Erkennen von zu umfangreichen Use Cases

• Aufteilen komplexer Use Cases in spezifische, klar definierte Einheiten

• Festlegen der optimalen Granularität eines Use Cases

• Praktische Tipps für die Erstellung effektiver Use-Case-Modelle

In dieser Lektion klären wir, wann im Lebenszyklus eines Projekts Use-Case-Diagramme erstellt werden sollten – und warum es sinnvoll ist, früh damit zu beginnen. Du wirst lernen, wie Use-Case-Diagramme helfen, das System aus der Perspektive der Nutzer zu betrachten und Missverständnisse zwischen Stakeholdern in der Anforderungsphase zu reduzieren. Außerdem betrachten wir, wie diese Diagramme später genutzt werden können, um Use Cases auf Subsysteme und Komponenten zu verteilen. Ein wertvolles Werkzeug, das dich durch das gesamte Projekt begleitet.

Kursinhalte:

• Die Bedeutung von Use-Case-Diagrammen in der frühen Projektphase

• Ihr Beitrag zur Definition und Kommunikation von Anforderungen

• Wiederverwendung der Diagramme im Architekturdesign

In dieser Lektion lernst du die Grundstruktur eines Anforderungsdiagramms in SysML kennen. Wir beginnen mit dem Rahmen (req) und seinen zentralen Elementen: den Anforderungen. Du erfährst, wie der Rahmen den Kontext des Diagramms definiert und welche Mindestattribute jede Anforderung haben muss – einschließlich Name, Beschreibung und ID. Außerdem klären wir, was genau eine Anforderung ist und welche Bedeutung sie für das System hat. Im nächsten Kapitel widmen wir uns dann den verschiedenen Anforderungstypen, die SysML unterscheidet.

Lerninhalte:

• Aufbau und Bedeutung des Rahmens (req) im Anforderungsdiagramm

• Die drei Mindestattribute einer Anforderung: Name, Beschreibung, ID

• Definition von Anforderungen in SysML

• Bedeutung eines konsistenten Anforderungsmodells im Team

In dieser Lektion klären wir den Unterschied zwischen funktionalen und nicht-funktionalen Anforderungen (NFRs). Du lernst, wie funktionale Anforderungen das Was eines Systems und NFRs das Wie eines Systems beschreiben. Außerdem zeige ich dir, wie SysML mithilfe von Stereotypen wie 'performanceRequirement', 'interfaceRequirement' und 'designConstraint' bei der Spezifikation von NFRs unterstützt, auch wenn es keine strikte Trennung vorgibt. Für funktionale Anforderungen verwenden wir den Stereotyp 'functionalRequirement', um deine Diagramme klar und konsistent zu gestalten.

Lerninhalte:

• Unterschied zwischen funktionalen und nicht-funktionalen Anforderungen (NFRs)

• Verwendung von SysML-Stereotypen zur Spezifikation von NFRs

• Best Practices für die Kennzeichnung von Anforderungen

In diesem Kapitel lernst du, wie du mit Containment Relationships komplexe Anforderungen in SysML strukturiert und übersichtlich darstellst. Am Beispiel eines sicheren Bezahlprozesses in einem Onlineshop zeige ich dir, wie du übergeordnete Anforderungen in detailliertere, untergeordnete Anforderungen herunterbrechen und diese im Anforderungsdiagramm logisch miteinander verbinden kannst. Du erfährst, wie diese Beziehungen durch eine klare Hierarchie und das Containment-Symbol visualisiert werden und welche Vorteile sie für die Strukturierung und Wirkungsanalyse bieten.

Lerninhalte:

• Definition und Darstellung von Containment Relationships in SysML

• Anwendung auf funktionale und nicht-funktionale Anforderungen

• Vorteile von Containment Relationships für Strukturierung und Wirkungsanalyse

• Best Practices: klare Hierarchie, eindeutige Zuordnung, konsistente Granularität

In dieser Lektion betrachten wir die Derive Relationship in SysML und wie sie sich von der Containment Relationship unterscheidet. Während Containment eine hierarchische Zerlegung darstellt, zeigt die Derive Relationship eine logische Abhängigkeit zwischen Anforderungen, die keine direkte Untermenge repräsentiert.

Lerninhalte:

• Unterschied zwischen Containment und Derive Relationships

• Darstellung und Anwendung der DeriveReqt Relationship in SysML

• Rückverfolgbarkeit und logische Abhängigkeiten durch Derive Relationships

• Best Practices: Wann Containment und wann Derive Relationships verwenden

In dieser Lektion geht es um die Refine Relationship in SysML, die Anforderungen durch Modellelemente wie Use Cases oder Activity Diagrams konkretisiert. Du lernst, wie diese Beziehung genutzt wird, um Anforderungen detaillierter zu beschreiben und zu spezifizieren.

Lerninhalte:

• Definition und Darstellung der Refine Relationship in SysML

• Verfeinerung von Anforderungen durch Use Cases oder Activity Diagrams

• Beispielanwendung: Verfeinerung der Produktsuche in einem Onlineshop

In dieser Lektion zeige ich dir, wie du die Satisfy Relationship in SysML nutzen kannst, um Anforderungen mit den Elementen zu verknüpfen, die sie erfüllen. Diese Beziehung verbindet Anforderungen mit Blocks, Use Cases oder Activity Diagrams, die die entsprechende Lösung oder Funktionalität bereitstellen.

Lerninhalte:

• Definition und Darstellung der Satisfy Relationship in SysML

• Verknüpfung von Anforderungen mit Blocks, Use Cases und Activity Diagrams

• Vorteile der Satisfy Relationship zur Sicherstellung von Verantwortlichkeiten

In dieser Lektion geht es um die Verify Relationship in SysML, die Anforderungen mit den Test Cases verknüpft, die ihre Erfüllung überprüfen. Du lernst, wie Test Cases im Anforderungsdiagramm dazu beitragen, sicherzustellen, dass eine Anforderung korrekt umgesetzt wurde.

Lerninhalte:

• Definition und Darstellung der Verify Relationship in SysML

• Verknüpfung von Anforderungen mit Test Cases zur Verifikation

• Bedeutung der Rückverfolgbarkeit durch die Verify Relationship

In dieser Lektion lernst du die Trace Relationship im SysML-Anforderungsdiagramm kennen. Wir betrachten, wann und warum du diese spezielle Beziehung einsetzen solltest – und warum sie manchmal nur sparsam verwendet werden sollte. Du erhältst einen Überblick darüber, wie die Trace Relationship funktioniert, welche Vor- und Nachteile sie hat und wann andere, spezifischere Beziehungen besser geeignet sind.

Lerninhalte:

• Definition der Trace Relationship und ihre Rolle in Anforderungsdiagrammen

• Darstellung und Notation der Trace Relationship in SysML

• Unterschiede zu anderen Anforderungsbeziehungen wie Containment, Refine und Satisfy

• Vor- und Nachteile der Trace Relationship

• Empfehlungen für den sinnvollen Einsatz der Trace Relationship im Modellierungsprozess

In dieser Lektion betrachten wir drei Notationstypen in SysML – Direct, Compartment und Callout Notation – die helfen, Beziehungen zwischen Elementen darzustellen. Jede Notationsart bietet spezifische Vorteile, um komplexe Diagramme zu organisieren und übersichtlich zu gestalten.

Lernziele:

• Verstehen der Direct Notation für intuitive, visuell klare Beziehungen mit Pfeilen und Stereotypen

• Einsatz der Compartment Notation, um Beziehungen innerhalb von Elementen kompakt zu visualisieren

• Anwendung der Callout Notation, um mehrere Beziehungen desselben Typs in einem Kommentar aufzulisten

• Auswahl der passenden Notation zur Verbesserung der Diagrammlesbarkeit je nach Beziehungskomplexität

In dieser Lektion geht es um Rationales, eine SysML-Funktion zur Dokumentation von Begründungen und kontextuellen Informationen in einem Modell. Rationales werden als spezielle Art von Kommentaren erfasst und ermöglichen es, zusätzliche Einblicke an jedes Element oder jede Beziehung anzuhängen.

Lernziele:

• Verstehen von Rationales als Notizen-Kommentare zur Dokumentation von Designentscheidungen

• Einsatz von Rationales, um Ursprünge von Anforderungen, Entscheidungen oder Einschränkungen zu erklären

• Verbesserung der Klarheit und Transparenz eines Modells für komplexe Systeme oder zukünftige Weiterentwicklungen

• Ausgewogene Nutzung von Rationales, um Modelle informativ, aber nicht überladen zu gestalten

Du kannst auch die Aufgabenbeschreibung herunterladen.

In dieser Lektion betrachten wir Block Definition Diagrams (BDDs), ein zentrales Werkzeug in SysML zur Visualisierung der Systemstruktur. BDDs dienen als Baupläne, um die Komponenten deines Systems und deren Verbindungen zu definieren und allen Beteiligten einen klaren Überblick zu verschaffen.

Lernziele:

• Verstehen von BDDs als Baupläne, die Systemkomponenten und deren Beziehungen veranschaulichen

• Erkennen der Rolle von Blocks, Akteuren und Beziehungen in der Systemmodellierung

• Lernen, warum BDDs essenziell sind, um in komplexen, interdisziplinären Systemen Klarheit zu bewahren

In dieser Lektion betrachten wir Blocks, die grundlegenden Elemente von Block Definition Diagrams (BDDs) in SysML. Blocks dienen als vielseitige Vorlagen zur Darstellung von Systemkomponenten, von physischen Objekten bis hin zu Softwareelementen, und definieren die Struktur und Funktionalität eines Systems.

Lernziele:

• Verstehen von Blocks als grundlegende Elemente in SysML-BDDs zur Definition von Systementitäten

• Erkennen von Blocks als Baupläne, die Typen spezifizieren, keine Instanzen

• Identifikation der Block-Notation mit dem Stereotyp <> und Kompartments für Eigenschaften

In diesem Abschnitt werfen wir einen genaueren Blick auf die strukturellen Eigenschaften eines Blocks, insbesondere auf die Part Properties. Du lernst, wie diese Eigenschaften die internen Komponenten eines Blocks abbilden und dabei helfen, die Struktur eines Systems besser zu verstehen. Anhand eines klaren Beispiels erkläre ich dir, wie Part Properties in einem Block Definition Diagram (BDD) dargestellt werden.

Lerninhalte:

• Definition und Bedeutung von Part Properties

• Unterschied zwischen strukturellen und behavioralen Eigenschaften

• Beispiel: Part Properties in einem User-Management-Block

• Darstellung von Part Properties im Block Definition Diagram (BDD)

In dieser Lektion geht es um die strukturellen Eigenschaften in SysML, insbesondere die Reference Properties. Du lernst, wie sie korrekt in Block Definition Diagrams (BDD) dargestellt werden und welche Bedeutung sie haben. Außerdem klären wir den Unterschied zu Part Properties, da diese beiden Begriffe, besonders zu Beginn, oft verwechselt werden.

Lerninhalte:

• Was sind Reference Properties und wie werden sie notiert?

• Vergleich von Reference Properties und Part Properties

• Praktische Beispiele zur Veranschaulichung der Unterschiede

In dieser Lektion lernst du, was Value Properties in SysML sind und wie sie Daten in einem Block speichern. Du erfährst, wie du diese Eigenschaften nutzen kannst, um wichtige Systeminformationen zu modellieren.

Lerninhalte:

• Definition von Value Properties in SysML

• Unterschiede zwischen primitiven Datentypen (String, Boolean, Integer, Real)

• Verwendung von Value Properties zur Datenspeicherung und -verarbeitung

• Darstellung von Value Properties im Values-Kompartiment eines Blocks

In dieser Lektion lernst du, wie Constraints in SysML genutzt werden, um Regeln und mathematische Bedingungen in deinen Block Definition Diagrams zu definieren. Du erfährst, wie Constraint Blocks funktionieren und welche Vorteile Constraints für komplexe Modelle bieten.

Lerninhalte:

• Definition von Constraints in SysML und ihre Bedeutung

• Nutzung des Constraint-Kompartiments in Blocks

• Einführung in Constraint Blocks und ihre Anwendung

• Unterschiede zwischen einfachen und wiederverwendbaren Constraints

In dieser Lektion lernst du, wie Ports in SysML die Schnittstellen deiner Blocks definieren und die Kommunikation zwischen ihnen ermöglichen. Du erfährst, welche verschiedenen Port-Typen es gibt, wie sie funktionieren und wann welcher Port-Typ verwendet werden sollte.

Lerninhalte:

• Definition von Ports in SysML und ihre Rolle in der Interaktion zwischen Blocks

• Unterschied zwischen nicht stereotypisierten Ports, Full Ports und Proxy Ports

• Einsatz von Ports zur Steuerung von Datenflüssen und Funktionen

In dieser Lektion lernst du, wie du mit Operations das Verhalten deiner Blocks in SysML modellierst. Du erfährst, wie du Parameterlisten, Rückgabewerte und die Notation von Operations verwendest, um die Funktionalitäten eines Blocks zu definieren.

Lerninhalte:

• Definition von Operations in SysML und ihre Bedeutung für das Systemverhalten

• Notation von Parameterlisten, Rückgabewerten und Multiplizität in Operations

• Tipps für eine verständliche Benennung von Operations

• Unterschied zwischen synchroner und asynchroner Kommunikation

In diesem Kapitel betrachten wir, wie du Receptions und Signals nutzen kannst, um asynchrone Kommunikation in einem SysML-Blockmodell zu modellieren. Du lernst, wie Blocks auf Signals reagieren können, ohne auf eine Antwort zu warten – ideal für Systeme, die effizient auf externe Ereignisse reagieren müssen. Ein praxisnahes Beispiel aus einem Onlineshop zeigt dir, wie Receptions zur asynchronen Verarbeitung von Zahlungstransaktionen eingesetzt werden.

Lerninhalte:

• Definition und Nutzung von Receptions in SysML

• Modellierung asynchroner Kommunikation mit Signals

• Notation und Parameter von Receptions

In diesem Kapitel dreht sich alles um Generalization, also die Vererbung von Eigenschaften zwischen Blocks. Du lernst, wie Blocks gemeinsame Eigenschaften durch Generalization erben und wie du damit klare Strukturen in deinem Modell schaffen kannst.

Lerninhalte:

• Definition und Verwendung von Generalization in SysML-BDDs

• Vererbung von Eigenschaften zwischen Blocks

• Darstellung der Generalization-Notation

• Vermeidung von Redundanz durch Generalization

Heute beschäftigen wir uns mit Dependencies in Block Definition Diagrams (BDDs). Ich zeige dir, wie Dependencies darstellen, dass ein Block (Client) auf einen anderen Block (Supplier) angewiesen ist, um seine Aufgaben zu erfüllen. Du lernst, wie Änderungen am Supplier den Client beeinflussen können und warum Dependencies in BDDs bewusst locker und einfach gehalten werden.

Lernziele:

• Was sind Dependencies in BDDs?

• Darstellung von Dependencies

• Loose Coupling: Vorteile und Nachteile

In BDDs repräsentieren Akteure externe Entitäten, die mit deinem System interagieren, jedoch nicht Teil davon sind. Sie können Benutzer, andere Systeme oder sogar Organisationen sein. Ich zeige dir, wie Akteure außerhalb der Systemgrenze platziert werden und wie sie mit Blocks interagieren.

Lernziele:

• Was sind Akteure in BDDs?

• Wie Akteure mit Blocks interagieren

• Verwendung von Akteuren zur Darstellung externer Benutzer und Systeme

• Entscheidung, wann Akteure in deinem BDD aufgenommen werden sollten

Du kannst auch die Jobbeschreibung herunterladen.

Nachdem wir uns mit Use Case-, Requirements- und Block Definition Diagrams beschäftigt haben, ist es nun an der Zeit, das Verhalten unseres Systems genauer zu betrachten. Aktivitätsdiagramme helfen uns, zu visualisieren, wie die Komponenten zusammenarbeiten, wobei der Fokus auf dem Fluss von Steuerung und Daten liegt. Sie sind wie Drehbücher, die die Abfolge von Aktionen, Entscheidungen und Datenaustauschen innerhalb deines Systems darstellen.

In diesem Kapitel tauchen wir in die Welt der Aktionen ein. Sie bilden den Kern eines Aktivitätsdiagramms, indem sie Prozesse und Verarbeitungsschritte innerhalb eines Systems darstellen. Ich zeige dir, wie du Aktionen sinnvoll definierst, um die Übersichtlichkeit zu bewahren, und wie sie im Diagramm dargestellt werden.

Lerninhalte:

• Was sind Aktionen in einem Aktivitätsdiagramm?

• Wie definierst du atomare Aktionen?

• Granularität von Aktionen: nicht zu grob, nicht zu fein

• Darstellung und Benennung von Aktionen im Diagramm

Um ein Aktivitätsdiagramm aussagekräftig zu gestalten, müssen wir uns mit Control Flows und Tokens beschäftigen. Ich erkläre dir, was Control Tokens sind, wie sie sich im Diagramm bewegen und wie du Control Flows nutzen kannst, um die Reihenfolge der Aktionen festzulegen.

Lerninhalte:

• Was ist ein Control Token und wie funktioniert es?

• Wie Control Tokens den Fluss im Diagramm steuern

• Verwendung von Control Flows zur Darstellung der Abfolge

• Verbindung von Aktionen durch Kanten

In dieser Lektion tauchen wir ein, wie Informationen zwischen Aktionen fließen. Du lernst den Unterschied zwischen Control Flow und Object Flow kennen und entdeckst die Rolle von Pins und Object Nodes. Schritt für Schritt zeige ich dir, wie Daten mithilfe von Object Tokens übertragen werden und wie du diesen Fluss modellierst. Am Ende wirst du verstehen, wie Pins als Schnittstellen fungieren und warum sie oft keine explizite Beschriftung benötigen.

Lernziele:

• Unterschied zwischen Control Flow und Object Flow

• Rolle von Pins und Object Nodes

• Modellierung von Datenflüssen

• Nutzung von Object Tokens zur Datenübertragung

• Notation von Pins und Object Flows

In dieser Lektion erforschen wir, wie Aktionen in SysML starten und enden. Du lernst den Initial Node kennen, der mit einem Control Token den Startpunkt einer Aktivität markiert, und wie auch Object Flows Aktivitäten auslösen können. Außerdem behandeln wir, wie eine Aktivität mit dem Activity Final Node beendet wird, der den gesamten Prozess stoppt. Am Ende wirst du die wichtigsten Konzepte für den Beginn und Abschluss von Aktionen innerhalb eines Aktivitätsdiagramms verstehen.

Lernziele:

• Verstehen des Initial Nodes und seiner Rolle beim Start von Aktivitäten

• Wie Object Tokens über Object Flows Aktionen auslösen können

• Verwendung des Activity Final Nodes zum Beenden von Aktivitäten

In dieser Lektion beschäftigst du dich mit Decision und Merge Nodes, die entscheidend für die Modellierung alternativer Abläufe in einem Prozess sind. Decision Nodes ermöglichen es dir, einen Prozess basierend auf Bedingungen aufzuteilen, während Merge Nodes diese Pfade wieder zu einem einzigen Fluss zusammenführen.

Ich zeige dir, wie du diese Nodes einsetzt, um Entscheidungslogik zu steuern und einen reibungslosen Prozessfluss sicherzustellen.

Lernziele:

• Verwendung von Decision Nodes zur Verzweigung von Prozessen

• Definition von Bedingungen (Guards) für alternative Pfade

• Anwendung von Merge Nodes zur Vereinheitlichung von Prozessflüssen

• Strukturierung des Control Flows mit vollständigen und disjunkten Bedingungen

In dieser Lektion lernst du, wie du Parallelität in deine Prozesse einführst, indem du Fork und Join Nodes verwendest. Fork Nodes ermöglichen das gleichzeitige Ausführen mehrerer Aktionen, während Join Nodes diese synchronisieren, indem sie auf den Abschluss aller Aufgaben warten, bevor der Prozess fortgesetzt wird. Zusätzlich stelle ich den Flow Final Node vor, der spezifische Pfade beendet, ohne den gesamten Prozess zu stoppen.

Lernziele:

• Verwendung von Fork Nodes zur Erstellung paralleler Prozesspfade

• Synchronisierung von Aktionen mit Join Nodes

• Unterscheidung zwischen Merge und Join Nodes

• Anwendung von Flow Final Nodes zum Beenden einzelner Pfade

In dieser Lektion beschäftigst du dich mit Activity Partitions, auch bekannt als Swimlanes, die dabei helfen, deine Aktivitätsdiagramme zu organisieren, indem sie zeigen, wer oder was für jede Aktion verantwortlich ist. Diese Partitionen erleichtern es, die Übersicht in komplexen Systemen zu bewahren, indem sie Aufgaben nach Abteilungen, Komponenten oder anderen Strukturen gruppieren.

Lernziele:

• Organisieren von Aktionen mit Activity Partitions (Swimlanes)

• Zuweisen von Verantwortlichkeiten an Abteilungen, Komponenten oder Einzelpersonen

• Strukturierung komplexer Systeme für mehr Übersichtlichkeit

• Visualisierung von mehrstufigen Verantwortlichkeiten in Diagrammen

In dieser Lektion lernst du Call Behavior Actions kennen, mit denen du ein anderes Verhalten aufrufen kannst, wenn eine Aktion ausgelöst wird. Dadurch kannst du komplexe Prozesse in kleinere, wiederverwendbare Komponenten zerlegen, was dein Modell übersichtlich und flexibel hält. Außerdem erfährst du, wie Daten mithilfe von Object Nodes und Parametern zwischen Aktionen fließen.

Lernziele:

• Verstehen der Rolle von Call Behavior Actions in der Prozessmodellierung

• Einsatz von Call Behavior Actions zur Wiederverwendung und Modularisierung von Verhaltensweisen

• Steuerung des Datenflusses zwischen Aktionen mit Object Nodes und Parametern

• Verbesserung der Prozessübersicht und Reduzierung von Redundanz in Diagrammen

In dieser Lektion lernst du Send Signal Actions kennen, mit denen dein System Signale senden kann, ohne auf eine Antwort zu warten. Diese Aktion ist besonders nützlich für asynchrone Prozesse, bei denen Aufgaben ohne sofortiges Feedback fortgesetzt werden können. Send Signal Actions stellen sicher, dass notwendige Daten übertragen werden, während der Prozess direkt nach dem Senden des Signals weiterläuft.

Lernziele:

• Verstehen der Rolle von Send Signal Actions in der Prozessmodellierung

• Asynchrones Senden von Signalen im "Fire-and-Forget"-Stil

• Steuerung des Datenflusses bei Send Signal Actions

• Unterscheidung zwischen Send Signal Actions und anderen synchronen Aktionen

In dieser Lektion lernst du die Accept Event Action kennen, die auf spezifische Ereignisse oder Signale wartet. Sobald das Ereignis eintritt, reagiert die Aktion und übergibt die Steuerung an den nächsten Schritt. Diese Funktion ist ideal für asynchrone Prozesse, bei denen Aktionen nur ausgelöst werden, wenn bestimmte Signale empfangen werden.

Lernziele:

• Verstehen der Funktion von Accept Event Actions in der Prozessmodellierung

• Umgang mit asynchronen Ereignissen mithilfe von Accept Event Actions

• Weitergabe der Steuerung nach Empfang eines Signals im Prozessablauf

In diesem Kapitel lernst du die Wait Timer Action kennen, die einen Prozess für eine bestimmte Zeit pausiert, bevor er fortgesetzt wird. Diese Aktion wird durch ein Stundenglas-Symbol dargestellt und kann für absolute oder relative Zeitdauern eingestellt werden. Sie ist besonders nützlich für zeitbasierte Prozesse, bei denen eine Verzögerung erforderlich ist.

Lernziele:

• Verstehen der Funktion von Wait Timer Actions im Prozessablauf

• Modellierung von Zeitverzögerungen mit absoluten oder relativen Zeitdauern

• Unterscheidung zwischen Wait Timer Actions und Accept Event Actions

• Einsatz zeitbasierter Steuerung für eine effiziente Prozessverwaltung

Du kannst auch die Jobbeschreibung herunterladen.

In dieser Lektion betrachten wir, warum und wann Sequenzdiagramme eingesetzt werden sollten. Sequenzdiagramme bieten eine klare Sicht auf das dynamische Verhalten eines Systems, indem sie zeigen, wie verschiedene Komponenten im Laufe der Zeit miteinander interagieren. Sie sind besonders wertvoll, um die Kommunikation zwischen Systemteilen wie Benutzern, Servern oder Modulen zu verstehen – insbesondere in nachrichtengetriebenen Systemen wie REST-APIs.

Lernziele:

• Verstehen des Zwecks von Sequenzdiagrammen zur Modellierung dynamischen Verhaltens

• Visualisierung von Interaktionen zwischen Systemkomponenten in chronologischer Reihenfolge

In dieser Lektion lernst du die grundlegenden Komponenten eines Sequenzdiagramms kennen: Lifelines, Messages und die Timeline. Diese Elemente helfen dir, Teilnehmer einer Interaktion darzustellen, wie sie kommunizieren und in welcher Reihenfolge Ereignisse ablaufen, um das Systemverhalten klar zu visualisieren.

Lernziele:

• Verstehen von Lifelines als Repräsentationen der Teilnehmer in einem System

• Unterscheidung zwischen synchronen und asynchronen Messages

• Visualisierung der Timeline von Interaktionen in einem Sequenzdiagramm

• Anwendung dieser Elemente zur Modellierung von Kommunikation und Ereignisabläufen

In dieser Lektion beschäftigen wir uns mit Steuerstrukturen in Sequenzdiagrammen, insbesondere mit Alternativen (alt) und Optionen (opt). Diese Elemente ermöglichen es dir, flexibles Verhalten zu modellieren, indem sie verschiedene Pfade basierend auf spezifischen Bedingungen darstellen.

Lernziele:

• Verstehen von Combined Fragments und ihrer Rolle in der Steuerungslogik

• Einsatz des alt-Operators zur Modellierung alternativer Sequenzen mit Guard-Bedingungen

• Anwendung des opt-Operators für optionale Aktionen, die bedingt ausgeführt werden

• Verbesserung von Sequenzdiagrammen durch dynamische Pfade basierend auf Systemverhalten

In dieser Lektion lernst du, wie du wiederholbare Prozesse mithilfe von Schleifen in Sequenzdiagrammen modellierst. Schleifen repräsentieren Aktionen, die mehrfach wiederholt werden, und du kannst entweder die Anzahl der Iterationen festlegen oder Bedingungen definieren, um das Verhalten der Schleife zu steuern.

Lernziele:

• Verwendung des loop-Operators zur Modellierung wiederholbarer Prozesse

• Festlegung von Mindest- und Höchstanzahl an Iterationen in einer Schleife

• Hinzufügen von Bedingungen (Guards), um zu steuern, wann eine Schleife endet

In dieser Lektion lernst du, wie du parallele Prozesse mithilfe des par-Operators in Sequenzdiagrammen modellierst. Der par-Operator ermöglicht es dir, mehrere Prozesse gleichzeitig auszuführen, was dein System effizienter macht, indem unabhängige Aktionen parallel ablaufen können.

Lernziele:

• Verwendung des par-Operators zur Modellierung paralleler Prozesse

• Strukturierung paralleler Sequenzen mit gestrichelten Linien im par-Frame

• Darstellung unabhängiger Aktionen in Parallelität

• Verstehen der Effizienzvorteile von Parallelverarbeitung in Sequenzdiagrammen

In dieser Lektion lernst du Execution Specifications kennen, die klar definieren, wann eine Aktion für einen Teilnehmer in einem Sequenzdiagramm beginnt und endet. Diese sind besonders in komplexen Diagrammen nützlich, da sie eine klare visuelle Darstellung dafür bieten, wie lange eine Instanz aktiv eine Aufgabe ausführt.

Lernziele:

• Verwendung von Execution Specifications, um die Dauer von Aktionen auf einer Lifeline zu markieren

• Verstehen der Start- und Endpunkte einer Aktion durch das vertikale Rechteck

• Visualisierung aktiver Zeiträume von Teilnehmern

• Klärung von Aktionszeitlinien in komplexen Sequenzen

In dieser Lektion beschäftigen wir uns mit drei wichtigen Typen von Constraints in Sequenzdiagrammen: Zeit-Constraints, Dauer-Constraints und Zustandsinvarianten. Diese Constraints ermöglichen es, präzise zeitliche oder logische Bedingungen festzulegen, die erfüllt sein müssen, damit der Prozess gültig bleibt.

Lernziele:

• Verstehen von Zeit-Constraints und wie sie sicherstellen, dass Ereignisse innerhalb eines bestimmten Zeitrahmens stattfinden

• Verwendung von Dauer-Constraints, um einen gültigen Zeitbereich zwischen zwei Ereignissen festzulegen

• Anwendung von Zustandsinvarianten, um Bedingungen zu prüfen, die für eine Instanz wahr sein müssen, bevor der Prozess fortgesetzt wird

• Verbesserung der Kontrolle über den Ablauf und die Bedingungen in deinem System

In dieser Lektion betrachten wir Destruction Occurrences, die darstellen, wann eine Instanz in einem Sequenzdiagramm zerstört wird oder das Ende ihres Lebenszyklus erreicht. Destruction Occurrences werden durch ein „X“ am unteren Ende der Lifeline gekennzeichnet, was bedeutet, dass keine weiteren Nachrichten von der Instanz gesendet oder empfangen werden.

Lernziele:

• Verstehen, wie Destruction Occurrences das Ende des Lebenszyklus einer Instanz modellieren

• Nutzung von Destruction Occurrences zur Darstellung von Ressourcenmanagement, z. B. Freigabe von Speicher oder Schließen von Verbindungen

• Unterscheidung zwischen durch eine Nachricht ausgelöster Zerstörung und Selbstterminierung

• Visualisierung, wann eine Instanz im System nicht mehr benötigt wird

Du kannst auch die Jobbeschreibung herunterladen.

In dieser Lektion stellen wir das Internal Block Diagram (IBD) vor und erklären, wie es das Block Definition Diagram (BDD) ergänzt. Während das BDD die Gesamtstruktur und die Beziehungen zwischen Blocks definiert, konzentriert sich das IBD auf die interne Organisation und die Verbindungen dieser Blocks.

Lernziele:

• Verstehen des Zwecks und der Struktur eines Internal Block Diagrams (IBD)

• Unterscheidung zwischen der Übersicht im BDD und der Detailansicht im IBD

• Erforschen, wie Part Properties aus dem BDD im IBD verbunden und interagieren

• Wissen, wann ein IBD erstellt werden sollte, insbesondere während der Systemintegration und in der detaillierten Designphase

In dieser Lektion betrachten wir die zentralen Komponenten eines Internal Block Diagrams (IBD): Part Properties und Reference Properties. Diese Elemente helfen dir, die interne Struktur eines Blocks und seine Interaktionen mit anderen Blocks zu modellieren, sodass du einen klaren Überblick darüber erhältst, wie ein System organisiert und verbunden ist.

Lernziele:

• Verstehen von Part Properties als interne Komponenten eines Blocks

• Verwendung von Reference Properties zur Darstellung von Verbindungen zu externen Systemen

• Unterscheidung zwischen Part Properties und Reference Properties in IBDs

• Anwendung der korrekten Notation für Part und Reference Properties mit Namen, Typen und Multiplizitäten

In dieser Lektion beschäftigen wir uns mit Connectors, die entscheidend dafür sind, darzustellen, wie Teile eines Systems in einem Internal Block Diagram (IBD) interagieren. Connectors repräsentieren die Kommunikation zwischen Part Properties und Reference Properties und helfen dir, den Informationsfluss sowohl innerhalb des Systems als auch mit externen Systemen zu verstehen.

Lernziele:

• Verstehen von Connectors als Verbindungen zwischen Part und Reference Properties

• Visualisierung der internen Kommunikation zwischen Systemkomponenten

• Modellierung externer Verbindungen mithilfe von Connectors und Ports

• Benennen und Typisieren von Connectors, um die Art der Interaktionen in deinem System zu verdeutlichen

In dieser Lektion betrachten wir Item Flows, ein zentrales Konzept in SysML, mit dem du die spezifischen Daten oder Objekte modellieren kannst, die zwischen den Teilen deines Systems fließen. Während Connectors zeigen, dass Elemente verbunden sind, liefern Item Flows Details darüber, was genau durch diese Verbindungen transportiert wird, und verbessern so die Klarheit deines Modells.

Lernziele:

• Verstehen der Rolle von Item Flows bei der Definition von Daten- oder Objektübertragungen zwischen Teilen

• Unterscheidung zwischen einfachen Verbindungen und Item Flows

• Einsatz von Ports zur Modellierung von Item Flows zwischen Systemkomponenten

• Erhöhung der Systemtransparenz durch die Spezifikation dessen, was zwischen den Teilen fließt

In dieser Lektion betrachten wir, wie du Nested Parts nutzen kannst, um die interne Struktur deines Systems darzustellen. Nested Parts ermöglichen es dir, Komponenten innerhalb anderer Komponenten zu organisieren, was besonders in komplexen Systemen einen klaren Überblick über die Verbindungen zwischen den einzelnen Elementen bietet.

Lernziele:

• Verstehen, wie Nested Parts modelliert werden, um interne Systemstrukturen darzustellen

• Einsatz von Connectors zur Darstellung der Kommunikation zwischen verschachtelten Komponenten

• Anwendung der Dot-Notation für eine kompakte Darstellung von Nested Parts

• Ausgewogene Darstellung von Klarheit und Komplexität in Diagrammen mit mehreren verschachtelten Ebenen

Du kannst auch die Jobbeschreibung herunterladen.

In dieser Lektion führen wir State Machines in SysML ein, mit denen du modellieren kannst, wie ein System auf Ereignisse reagiert und zwischen Zuständen im Zeitverlauf wechselt. State Machines helfen dir, das dynamische Verhalten eines Systems zu visualisieren und komplexe Prozesse besser zu verstehen.

Lernziele:

• Verstehen des Konzepts von Zuständen und Transitionen in State Machines

• Erkennen der Bedeutung von State Machines für die Darstellung des Systemverhaltens

• Überblick über die Komponenten von State Machines und ihre Rolle in der Systemmodellierung

In dieser Lektion vertiefen wir uns in die verschiedenen Arten von Zuständen in einer State Machine: den Initial State, Final State und Simple States. Diese Zustände definieren das Verhalten eines Systems, während es verschiedene Phasen durchläuft, wobei bei Eintritt, währenddessen und beim Verlassen eines jeden Zustands spezifische Aktionen ausgelöst werden.

Lernziele:

• Verstehen des Initial States als automatischer Startpunkt in einer State Machine

• Erkennen des Final States als Beendigung eines Prozesses ohne weitere Transitionen

• Definition von Simple States als aktueller Zustand eines Systems, der auf Ereignisse wartet, um Transitionen auszulösen

• Untersuchung von Entry-, Do- und Exit-Behaviors innerhalb von Simple States zur Modellierung von Aktionen während Zustandsübergängen

In dieser Lektion konzentrieren wir uns auf Transitionen, die beschreiben, wie ein System von einem Zustand in den nächsten wechselt. Transitionen werden durch Ereignisse ausgelöst, und manchmal müssen zusätzliche Bedingungen (sogenannte Guards) erfüllt sein, damit der Wechsel stattfinden kann.

Lernziele:

• Verstehen von Transitionen als Mechanismus für Zustandswechsel in einem System

• Identifizieren von Triggern als Ereignisse, die eine Transition auslösen

• Visualisierung von Transitionen in Diagrammen und Verständnis ihrer Rolle in der Modellierung des Systemverhaltens

In dieser Lektion betrachten wir Events, die entscheidenden Auslöser für Zustandsübergänge in einem System. Events bestimmen, wann Zustandswechsel stattfinden, und wir untersuchen vier Haupttypen: Signal Events, Call Events, Time Events und Change Events.

Lernziele:

• Verstehen, wie Events Zustandsübergänge in einem System auslösen

• Identifizieren von Signal Events als Nachrichten zwischen Systemen

• Erkennen von Call Events als Funktions- oder Methodenaufrufe, die Transitionen auslösen

• Untersuchung von Time Events, die auf Zeitintervallen oder bestimmten Zeiten basieren

• Nutzung von Change Events, um Transitionen auszulösen, wenn bestimmte Bedingungen erfüllt sind

In dieser Lektion betrachten wir Guard Conditions, zusätzliche Kriterien, die erfüllt sein müssen, damit ein Übergang zwischen Zuständen stattfinden kann. Während Events Zustandswechsel auslösen, wirken Guard Conditions wie Tore, die steuern, ob eine Transition erfolgt oder nicht.

Lernziele:

• Verstehen von Guard Conditions als Anforderungen für Zustandsübergänge

• Modellierung von Guards in Zustandsdiagrammen mit eckigen Klammern neben dem Event-Trigger

• Kombination von Events mit Guard Conditions, um sicherzustellen, dass alle Kriterien vor einem Zustandswechsel erfüllt sind

• Verwendung mehrerer Guard Conditions zur Spezifikation komplexer Kriterien für Transitionen

In dieser Lektion betrachten wir Composite States, die es ermöglichen, mehrere zusammenhängende Zustände in einer hierarchischen Struktur zu organisieren. Composite States bieten eine präzisere Kontrolle über das Verhalten eines Systems, indem sie Substates in einem übergeordneten Zustand gruppieren, was die Übersichtlichkeit verbessert und die Komplexität reduziert.

Lernziele:

• Verstehen von Composite States als Container für zusammenhängende Substates

• Hierarchische Organisation von Substates innerhalb eines Composite States

• Modellierung von Übergängen zwischen Substates innerhalb eines Composite States

• Steuerung von Übergängen, die einen Composite State verlassen, sobald alle Substates abgeschlossen sind

In dieser Lektion beschäftigen wir uns mit Pseudostates, speziellen Knoten in Zustandsdiagrammen, die Transitionen definieren und steuern. Pseudostates ermöglichen eine komplexere Kontrolllogik als Standardzustände und helfen, den Fluss zwischen Zuständen zu lenken.

Lernziele:

• Verstehen der Rolle des Initial Pseudostates als Startpunkt einer State Machine

• Visualisierung des Initial Pseudostates als ausgefüllten Kreis ohne eingehende Transitionen

• Verwendung von Junction Pseudostates, um Transitionen basierend auf Bedingungen aufzuteilen oder zusammenzuführen

• Anwendung von Guard Conditions und „else“-Pfade auf ausgehende Transitionen für mehr Flexibilität in der Kontrolllogik

• Verbesserung der Struktur und des Flusses von State Machines durch Pseudostates für komplexe Entscheidungsfindung

In dieser Lektion betrachten wir, wie Events, Guards und Effects zusammenwirken, um Transitionen in State Machines zu steuern. Diese drei Elemente ermöglichen es dir, genau zu bestimmen, wann eine Transition stattfindet, unter welchen Bedingungen sie ausgeführt wird und welche Aktionen dabei durchgeführt werden.

Lernziele:

• Verstehen, wie Events Transitionen zwischen Zuständen auslösen

• Anwendung von Guards, um Bedingungen festzulegen, die für die Ausführung einer Transition erfüllt sein müssen

• Definition von Effects als Aktionen, die während einer Transition ausgeführt werden

• Kombination von Events, Guards und Effects, um klare und kontrollierte Transitionen in deinem Modell zu erstellen

Die Aufgabenbeschreibung kannst Du auch hier downloaden

In dieser Lektion führen wir Parametric Diagrams in SysML ein, die eine detaillierte Ansicht der in Block Definition Diagrams (BDDs) definierten Constraint Blocks bieten. Während BDDs die Struktur und die Beziehungen zwischen Blocks festlegen, helfen Parametric Diagrams dabei, die spezifischen mathematischen Regeln und Bedingungen zu visualisieren, die die Eigenschaften innerhalb eines Systems verknüpfen.

In dieser Lektion betrachten wir die Verbindung zwischen Block Definition Diagrams (BDDs) und Parametric Diagrams. Während BDDs die Blocks und Constraint Blocks definieren, die mathematische Regeln enthalten, wenden Parametric Diagrams diese Regeln an, indem sie Binding Connectors nutzen, um Wert-Eigenschaften mit Constraint-Parametern zu verknüpfen.

Lernziele:

• Verstehen, wie Parametric Diagrams BDDs erweitern, indem sie Constraint-Beziehungen detailliert darstellen

• Verwendung von Binding Connectors, um Wert-Eigenschaften mit Constraint-Block-Parametern zu verknüpfen

• Sicherstellen, dass verknüpfte Werte synchron bleiben, um präzise Berechnungen zu ermöglichen

• Visualisierung, wie mathematische Regeln in einem System durch Parametric Diagrams angewendet werden

In dieser Lektion tauchen wir in die zentralen Komponenten von Parametric Diagrams ein: Constraint Properties, Constraint Parameters und Value Properties. Diese Elemente sind essenziell, um die mathematischen Regeln und Verbindungen zu modellieren, die das Verhalten eines Systems definieren.

Lernziele:

• Verstehen von Constraint Properties als Instanzen von Constraint Blocks innerhalb höherer Blocks

• Erkennen von Constraint Parameters als Variablen, die in Constraint-Gleichungen verwendet werden

• Definition von Value Properties als Dateneingaben für Constraints

• Visualisierung, wie diese Elemente zusammenarbeiten, um mathematische Regeln innerhalb eines Systems durch Parametric Diagrams anzuwenden

In dieser Lektion führen wir Package Diagrams ein, eine spezielle Art von Strukturdiagrammen, die dazu dienen, verschiedene Entitäten in einem System logisch zu gruppieren und zu organisieren. Package Diagrams helfen dir, komplexe Systeme in funktionale Einheiten zu unterteilen, sodass dein Modell übersichtlich und klar bleibt.

Lernziele:

• Verstehen von Packages als Container zur Organisation von Elementen in einem System

• Verwendung von Packages, um zusammengehörige Elemente nach Funktion, Subsystem oder Ebene zu gruppieren

• Reduzierung der Systemkomplexität und Verbesserung der Navigation durch die Organisation von Elementen in Packages

• Wissen, wann ein Package Diagram erstellt oder aktualisiert werden sollte, um Änderungen in der Systemstruktur widerzuspiegeln

In dieser Lektion betrachten wir die logische Struktur von Package Diagrams und fokussieren uns darauf, wie Packages und Sub-Packages organisiert, geschachtelt und miteinander verbunden werden. Dies liefert einen klaren Überblick über die Beziehungen und Abhängigkeiten zwischen den verschiedenen funktionalen Einheiten eines Systems.

Lernziele:

• Verstehen des Zwecks des Package Diagram Rahmens und seiner Hauptpackages

• Verwendung der Nesting-Notation, um Sub-Packages innerhalb von Hauptpackages darzustellen

• Anwendung der Qualified Name-Notation, um hierarchische Beziehungen zwischen Packages zu repräsentieren

• Erkennen der Crosshair-Notation, um Verbindungen zwischen Packages auf derselben Ebene zu kennzeichnen

• Visualisierung von Abhängigkeitsbeziehungen, um zu zeigen, wie Packages voneinander abhängen

In dieser Lektion behandeln wir vier spezialisierte Packages in SysML, die dabei helfen, Elemente in einem Modell zu organisieren und zu verwalten: Modelle, Modellbibliotheken, Profile und Ansichten. Jeder dieser Package-Typen erfüllt eine spezifische Funktion, um die Organisation, Wiederverwendbarkeit und Klarheit des Modells zu verbessern.

Lernziele:

• Erkennen von Modellen als Wurzel der Hierarchie und Struktur eines Systems

• Verwendung von Modellbibliotheken, um wiederverwendbare Elemente projektübergreifend zu speichern

• Anwendung von Profilen, um benutzerdefinierte Stereotypen zu erstellen und Elementtypen zu erweitern

• Erstellung von Ansichten, um spezifische Anforderungen und Perspektiven von Stakeholdern zu fokussieren

• Organisation von Elementen mit spezialisierten Packages zur Verbesserung der Modellklarheit

Du kannst die Beschreibung der Übungsaufgabe auch downloaden