Hello and welcome back to the Advent of SysML v2 – a daily, hands-on mini-course designed to bring you up to speed with the new SysML v2 standard and the modern Syside tooling that makes you productive from day one.

By the end of this lesson, we’ll recap and synthesize everything we’ve learned in the first week, showing how the concepts connect and build upon each other to form a solid foundation for systems modeling.

Links to First Week Lessons

1. What is SysML v2?
2. Navigating Textual Models
3. Definitions and usages
4. Specializations
5. Modifiers and Multiplicities
6. Version control with Git

The Paradigm Shift: Systems as Code

Week 1 began with a fundamental shift in how we think about systems modeling. SysML v2 can represent Systems as Code using a textual notation that brings Systems Engineering practices much closer to Software Engineering. This isn’t just a different syntax; it’s a complete transformation of the modeling workflow.

Unlike traditional diagram-based tools where you spend time tweaking layouts, SysML v2 lets you focus on design progress. The textual notation offers precision, expressiveness, and efficiency. Under the hood, it’s built on KerML (kernel modeling language) with extensive standard libraries and formal mathematical semantics, ensuring your models have precise, unambiguous meaning.

This foundation enables everything else we learned: professional tooling, version control, automation, and rapid iteration.

Core Modeling Concepts: Building Blocks of SysML v2

Definitions and Usages: The Fundamental Distinction

At the heart of SysML v2 lies a crucial distinction between definitions and usages. Both are types that classify things but they serve different purposes:

• Definitions classify individual things that exist independently of context. Think of them as blueprints or reusable concepts: a Car, a Marriage, an Integer, or a Procedure. You can point to instances of these regardless of where they appear.
• Usages classify things within a specific context. They describe roles, properties, or features: a car owned by someone, someone’s first marriage, or a subroutine within a larger program. You need the context to identify them.

The rule of thumb:

An important point to remember: usages are still types – they classify things in a context. They are NOT instances! This distinction is crucial for understanding how SysML v2 models work.

Specializations: Refining and Reusing Designs

Once you understand definitions and usages, specializations let you create hierarchies and refine your designs. There are four types, each serving a specific purpose:

1. Subclassification (specializes): Between definitions, creating more specialized types from general ones (e.g., SantaSleigh specializes Sleigh).

2. Subsetting (subsets): Between usages, defining subsets of usages (e.g., Rudolph as a subset of all reindeer).

3. Redefinition (redefines): Between usages, refining inherited usages in specialized contexts to make them more specific.

4. Definition relationship (defined by or :): Connects a usage to its definition, showing how usages inherit features from their definitions.

All specializations share a common principle: they restrict instances to subsets, enabling design refinement, reuse, and the creation of design alternatives.

Modifiers and Multiplicities: Precision and Control

To model real-world systems accurately, you need fine-grained control over your model elements. Modifiers give you this control:

• Abstract vs. Concrete: Abstract types are skeletons that must be specialized before use; concrete types can be instantiated directly. This applies to both definitions and usages.
• Composite vs. Referential: Composite usages mean the type owns the value (parts are destroyed with the whole); referential usages (ref modifier) are just references with no ownership implications.
• Variables vs. Constants: Variables can change over time; constants never change and cannot be changed externally.

Multiplicities control how many values a usage can have. The format [lower..upper] specifies the range, with * meaning unlimited. Understanding the default multiplicity rules is crucial – they’re not always what you might expect! For attributes, items, and ports nested in definitions or usages, the default is [1..1] (exactly one); otherwise, it’s [0..*] (zero or more).

These core concepts provide the theoretical foundation, but SysML v2’s true power comes from how easily they integrate with practical tools and workflows—thanks to its textual nature.

Professional Workflows: Working with Textual Models

The textual nature of SysML v2 unlocks powerful workflows that simply aren’t possible with binary diagram formats.

Navigation and Exploration

Syside Modeler provides professional code-editing features for SysML v2:

• Outline window: High-level overview of model structure
• Go-to-definition / Peek definition: Instantly explore types and definitions
• Peek references: See all locations where symbols are used
• Rename symbol: Safe, efficient refactoring across entire models
• Code folding: Navigate large models by collapsing sections

These features make working with complex models as straightforward as working with code in any modern IDE (Integrated Development Environment).

Formatting and Refactoring

Text-based models can be formatted instantly with a single command, ensuring consistency and readability. More importantly, you can leverage AI assistance for complex refactoring tasks – extracting common definitions, eliminating duplication, and improving model structure. This kind of rapid iteration and improvement is what makes SysML v2 so powerful for real-world engineering work.

Version Control with Git: Never Lose Work Again

Perhaps the most transformative advantage of text-based modeling is seamless Git integration. If you’ve worked with SysML v1, you know the pain: models locked in proprietary formats, machine-generated XML that’s impossible to read, and version control that’s effectively useless because you can’t see what actually changed.

SysML v2 fundamentally solves this. Your models are stored as clean, human-readable .sysml text files. This isn’t just a convenience – it enables professional workflows that were simply impossible before.

The Git workflow is remarkably simple:

• Initialize your repository
• Stage and commit your changes
• Review differences highlighted automatically

What you gain:

• Visual diffs: See exactly what changed, line by line, with color highlighting
• Commit history: Track every change with clear commit messages
• Time machine: Try different approaches knowing you can always revert to any previous state
• Collaboration: Work like software teams do with branches, merges, and clear audit trails of who changed what and why

The best part? You don’t need to touch the command line or become a Git expert. VS Code’s built-in Source Control handles everything visually. This is the “time machine” for your models: never lose work, always understand what changed, and collaborate with confidence.

Challenge for Tomorrow

Practice what you’ve learned this week!

Take the challenges from each day, merge their models into a single file, and experiment with the model data. Try refactoring, adding specializations, and applying modifiers.

As we progress further with future lessons, you will find out the SysML v2 way of managing and structuring large models – important topics for scalability and effective team work!

Summary

In Week 1, we’ve established a solid foundation:

• Understood the paradigm shift in Systems Engineering to Systems as Code, enabling software engineering practices
• Mastered core concepts: Definitions, Usages, Specializations, Modifiers, and Multiplicities
• Learned professional workflows: Navigation, formatting, refactoring, and version control
• Built real engineering habits that scale to complex projects

The foundation is set for exploring more advanced SysML v2 concepts in Week 2, where we’ll dive into connections, ports, interfaces, actions, state machines, and more. Until then, keep practicing and happy modeling!