Holarch

Article

Why SysML v2 Matters for Working Systems Engineers

· Published by Holarch

  • SysML v2
  • MBSE
  • Migration
Illustration: lines of model text flowing into a block diagram of connected parts such as PowerSystem, BatteryPack, ControlUnit and DataLink
On this page
  1. 1. The model has a text form, and diagrams are views of it
  2. 2. A language with its own precise meaning
  3. 3. A standard API, not just a file format
  4. 4. Concepts that match how engineers think
  5. What it still asks of you
  6. Why now

SysML v2 is not a new coat of paint on SysML v1. It is a rebuilt language, and for the people who do the modeling every day, the changes go after the problems we actually fight.

If you have worked with SysML v1, you know the pattern. The model starts strong. A few months in, the diagrams no longer match the design, nobody is sure which block diagram is current, and the model becomes something you update for the review instead of something you use to make decisions. Part of that is discipline. A lot of it is the language and the tools we were given.

Our team works in systems engineering and builds modeling tools, and we have spent a good amount of time in SysML v2. Here is what we think it gets right, where it still asks something of you, and why we think it is worth learning now.

1. The model has a text form, and diagrams are views of it

SysML v2 defines a standard textual notation alongside the graphical one. Both describe the same model. A part, a port, a requirement or an action can be written as text, drawn in a diagram, or both, and an edit in one shows up in the other.

That sounds like a convenience. In practice it changes how a team works:

  • Reviews get precise. You can see exactly what changed between two versions of a model, line by line, instead of comparing screenshots.
  • Models live in version control. Branching, merging and history work the way software teams already expect.
  • Diagrams stop being the source of truth. A diagram becomes a view you generate for a purpose, not a hand-drawn artifact that silently goes stale.

Here is a small example. It reads almost like a specification:

part def Vehicle {
    attribute mass : Real;
    part engine : Engine;
    part wheels : Wheel[4];
}

2. A language with its own precise meaning

SysML v1 was built as a profile of UML, a language designed for software. Systems engineers spent years working around that: stereotypes on top of classes, conventions that differed between tools, and diagrams that two people could read two different ways.

SysML v2 is built on its own foundation, the Kernel Modeling Language (KerML), with formally defined semantics. In plain terms, the language says exactly what a model means, not just how it is drawn.

That matters the moment you want the model to do work for you:

  • Tools can check it. Type mismatches, unconnected ports and broken references can be caught as you model, not at the design review.
  • Analysis rests on solid ground. When the meaning is unambiguous, calculations, simulations and trade studies run against the model instead of a copy of it in a spreadsheet.
  • Two tools read the same model the same way. A precise meaning is what makes real exchange between tools possible.

3. A standard API, not just a file format

Alongside the language, the OMG standardized the Systems Modeling API and Services: a common way for software to query and update a SysML v2 model.

With SysML v1, connecting a model to anything else usually meant a tool-specific plugin or an export someone had to maintain. A standard API changes the economics:

  • Your model is not locked to one tool. Data can move between modeling tools, and from one generation of tools to the next.
  • Automation becomes ordinary. Scripts can pull requirements into a test plan, push analysis results back into the model, or check a design rule on every change.
  • The model connects to the rest of engineering. Requirements management, simulation, PLM and CAD can read from the same authoritative source instead of a pile of exports.

4. Concepts that match how engineers think

The new language is more consistent, and the consistency pays off in daily work.

  • Definitions and usages. Every concept follows one pattern: a definition (an Engine) and its usages in context (the engine in this vehicle). Parts, ports, actions, states and requirements all work the same way, so learning one teaches you the rest.
  • Variants built in. Variation points and variants are part of the language, so a product line with options can be modeled directly instead of being copied into near-duplicate models.
  • Requirements that can be checked. A requirement can carry a constraint, such as mass under 1,500 kg, and be tied to the part that must satisfy it and the verification that proves it.
  • Calculations and analysis in the model. Calculations, analysis cases and verification cases are first-class elements, so a trade study or a mass roll-up lives next to the design it evaluates.

The result is a model you can ask questions of, not just look at.

What it still asks of you

SysML v2 is not free. Three costs are worth naming plainly.

  • Tools are still maturing. Support for the full language varies from tool to tool. Check what a tool actually handles (text and diagrams, the API, analysis) before you commit a program to it.
  • Migration from v1 is real work. The concepts map, but not one to one. Plan for converting the models you need and leaving the rest in v1. Holarch does most of the conversion for you; more on that below.
  • There is a learning curve. Engineers used to drawing will need time with the textual notation, and teams will need new conventions for reviews and version control.

Our advice is to start small. Pick one subsystem, model it in v2 alongside your existing work, and run one real review from the text. You will learn more in two weeks than from any slide deck, including this article.

Why now

SysML v2 is an adopted OMG standard, and tool support is growing quickly. The teams that learn it early will set the conventions everyone else follows, and they will be the ones whose models stay useful past the first review.

The core promise is simple: a model that is precise enough to check, open enough to connect, and readable enough that engineers keep it current. That is what model-based systems engineering was supposed to be from the start.

We build Holarch, a SysML v2 modeling tool, to close the gap between the text and the diagrams. The text, the views, the tables and the inspector are all ways to edit one model. Write SysML v2 in the editor and the General, Interconnection, Action Flow, State Transition and Sequence views update at once. Change a view and the edit is written back into the text right away, checked first, so a diagram can never hold something the language does not allow. Your own formatting and comments stay as you wrote them, and renaming an element in the text keeps its place in every diagram. Engineers who think in text and engineers who think in pictures can work on the same model without either one getting out of date.

Holarch also takes most of the pain out of migrating. Export your SysML v1 model as XMI, or bring a Cameo or MagicDraw project file, and Holarch converts it to SysML v2 for you. It follows the v1-to-v2 transformation in the OMG specification and checks the result. Before anything is imported, a conversion report lists every element as converted, approximated or left out, with the reason in plain words, so you know exactly what to review instead of hunting for it. When the v1 model changes, import the newer export and the converted elements update in place, so a team can migrate gradually while work continues in v1.

If you want to try it hands-on, open the Hybrid Car demo at holarch.app.

We would like to hear from people who are already using SysML v2 on real programs. What has worked, and what has surprised you? Discuss this article on LinkedIn.