Lesson 3: The Usage Paradigm in SysML v2
Goodbye “Block,” Hello “Definition”
In SysML v1, Blocks were the dominant modeling construct. While Blocks were primarily intended to represent types, in practice even small configuration or variant differences often led to the creation of new Blocks or extended Block hierarchies. As a result, teams frequently drowned in a sea of Blocks, leading to the dreaded Block Explosion in the project browser.
SysML v2 generalizes this pattern. While v1 distinguishes Blocks (types) from Parts (properties), v2 elevates Definition and Usage to root-level concepts applicable to everything (Parts, Actions, Requirements, Ports, etc.). In practice, this means you define what a component is once, and then describe how it appears, connects, and varies only through its usages inside a system. This approach is commonly referred to as a usage-focused modeling paradigm.
The Core Distinction: What Something Is vs. How It Is Used
In SysML v2, we explicitly distinguish between what something is and how it is used:
part def(Definition): This is the blueprint or type. It describes structure, interfaces, and invariant constraints.part(Usage): This represents a role or feature. It describes how a definition is used within a specific containing context. The key idea is that the Engine definition is reused, while the system-specific structure is expressed entirely through usage. In SysML v2, features are technically Types that classify the relationship between the containing type and the instances of the feature type. By default, a part usage has a multiplicity of one, meaning every Vehicle must have exactly one Engine unless you explicitly allow otherwise.
Solving the Block Explosion Problem
In SysML v1, breaking a system into smaller parts often required moving from a Block, to a Part, and then to another Block, even when those Blocks were not intended for reuse. This made decomposition indirect and led to many one-off Blocks cluttering the model. In SysML v2, the usage-focused modeling paradigm allows for a direct parts tree:
- Build structure directly by nesting part usages.
- Introduce new definitions only when reuse is actually intended.
- Push system-specific complexity into the usage hierarchy, keeping the definition library clean and navigable. This keeps the definition library clean and pushes system-specific complexity into the usage hierarchy.
Handling Variation: Configuration in Context
If definitions are reused, how do we handle variation? What if a Vehicle needs different values or constraints for a specific configuration (for example, for a sports car)? Because Definition and Usage are separated, variation is handled at the usage level, without changing the original definition. The :>> symbol means redefines. It tells SysML that we are taking an attribute from the definition and constraining it more specifically in this context:
- The original definition remains unchanged and reusable.
- The variation is expressed locally at the usage level, scoped to that specific context. In this case, we are not changing what a Vehicle is. We are simply saying that this particular usage of Vehicle (the sports car) has a stricter maximum speed.
The Payoff: Consistency Across the Entire Language
The Definition-and-Usage pattern is not limited to physical parts. SysML v2 applies the same structure consistently across the language:
- Requirements:
requirement def(the rule) vs.requirement(the assertion). - Actions:
action def(the procedure) vs.action(the step). - Ports:
port def(the connection point spec) vs.port(the specific connection point). Once you understand how part def and part work, you already understand how requirements, actions, and ports are modeled. This consistency is one of the biggest design improvements in SysML v2.
Moving Forward
In SysML v1, Blocks were used to represent types. In SysML v2, that role is taken by part def. What used to be a Part Property is now a part, representing usage. Internal Block Diagrams are no longer separate artifacts; rather the internal structure is expressed directly inside definitions. And where v1 used Instance Specifications, v2 represents concrete occurrences as individual part usages. In the next lesson, we explore regularity. We will see how Requirements in v2 break down exactly like Parts, finally unifying the model structure.