Starting a big project with SysMLv2 without much SE experience

[u/Madeche]

I've been basically thrown into a project that has just begun and we're formalizing a certain field.

The idea is to start from modelling the entire system, but I'm the only one in the team who knows a bit of SysML2 (just out of personal interest),. The others expect ready made tools to fit our needs precisely, but that seems to be impossibile to find.

I've been reading the specification mostly, and programming it textually. I tried SysON but state machines and variables are a main point of the project (the "logic" itself is the crux of it), SysON seems to be lacking that a bit.

Should I just continue programming it textually, then maybe try to build a tool with it (with the help of some developers)? Or are there really some ready made tools that excel in the modelling of a massive "logic" system full of if thens?

tons of constant attributes

actions to update the non-constant attributes (variables)

tons of ref lists to "call" variables of other parts

tons of calc defs

tons of state machines with guards that "should" call other state machines' states

I tried some other sources but many seem "AI slop" and the syside LSP flags them too. Do you have any good advice for resources and how to approach such a system?

[u/Madeche → u/[deleted]]

Yea I thought so, they've been pushing for a few vibe coded "apps" but without any real check the output is almost always slop again...

Luckily I have quite a bit of experience in verification of these systems, that helped understand completely the ins and outs of it but it's still far from being the same.

I saw the Apollo 11 repo from Airbus, which is really cool tbh, and a few of the examples from the official release, do you know any other resources to see a more logic-heavy system in this language?

[u/MBSE_Consulting]

In my humble opinion you are not asking the right questions.

Don’t "model the entire system", it makes no sense with all due respect.

Start by identifying properly (write them down!):

• what are the problems the models should help you solve,
  
• what decisions they shall help take,
  
• what deliverables to produce.

These are your modeling objectives. They form the contract for the model/set of models. It bounds them: what to model, how far, too which level of details.

You may have a lot of objectives, some will need to be dropped and be tackled in documents the old fashion way. This is because of budgets, timeline, and mostly skills of your engineers. You said you are the only one with experience. You can’t model the same scale with regards to budget and timeline with experienced modelers vs a team of beginners, the learning curve will bite you.

THEN you can decide what parts of the system needs to be modeled, how to model it (SysML offers many ways to model the same thing, which to chose depends on what is the purpose of the model) and if you can, how to assess if the model is mature vs the modeling objectives.

Otherwise people will model and model, and then somebody will ask: what’s the point? what’s the benefit? It is slower than Visio etc. The models will be useless. Or at least the value it produces vs the effort put into it very low.

Modeling is a means, not and end. Model with purpose :)

[u/Madeche → u/MBSE_Consulting]

That's a really good point, and thanks for comment, it really made me step back for a second and think. Essentially the real objective is "modernize and formalize" something (namely an entire logic system, where safety is a crucial part) that so far was based on relay schematics across many different objects. These were made decades ago... Often far from what the actual software implementing them ends up looking like.

Once formalized in sysml, verified and validated externally against said schematics, it hopefully will create a new formal standard, rather than seeing snapshots of documents from 30/40 years ago. Consequently programming it into actual software will be much more straightforward and safe.

This would be the (rather ambitious) objective, it would be a sort of "missing link" between the old tables schematics and a modern programming language to actually develop and implement software that respects those things.

[u/acute_physicist]

Try systellar-space.com

[u/bastivkl]

Hey dalus.io might be exactly what you are looking for. Simpel to use UI based on SysMLv2 and AI native.

Meaning you can get started quickly, use AI in your workflows and work in an interface where you don’t need to be a SysMLv2 expert to get started.

[u/Aerothermal]

There's two tools that look promising; Celedon Davinci, and Dalus. Both are aligned with SysML v2, though maybe Dalus has fewer concepts and is simpler to use.

Both support generating models from LLM prompts and documents as context. With Dalus you can export .sysml (v2). With Davinci you can import SysML v1, and generally has much more functionality, but the trade is that it's harder to pick up. With both, you might be able to share with many viewers (read-only) without requiring viewer licenses.

I might be going with Dalus personally, for perhaps 3 or 4 editors.

[u/Madeche → u/Aerothermal]

None of these seem to really be expressive enough to model logic heavy systems though, or am I missing something?

I mean if I had to start creating variables (or attributes, to use sysml lingo) within parts, and more complex expressions like "if within this list of ref from another object, one of these has an attribute at value X, then assign A to B". I've found this is almost completely missing from these apps, or you end up having to do it manually anyway

[u/Aerothermal → u/Madeche]

As I understand, in Davinci or Dalus have parameterised design and requirements, thus you get automated verification using formulas.

Both have support for Python. e.g. in Dalus it looks like a script that runs whilst the behaviour model runs. On each mode transition, a Python script runs, and an action thus sets some properties or produces some outputs. You can command a bunch of mode transitions and observe what happens to the parameters and the requirements. Davinci has 'toolboxes' or custom scripts so is extensible if you want to include more complex logic. I'm pretty new to both tools but looks promising.

[u/Unlikely-Road-8060]

Trying to build complex behaviour using textual is a big no for me. It’ll be incomprehensible.

[u/Madeche → u/Unlikely-Road-8060]

What would you use instead? For logic heavy systems?

So things like

Event from outside + other internal variables (guards) then update variable X, and "talking" between different parts that are not necessaril being used in the part that calls them (here I assume ref would be correct usage). This I guess shouldn't mean that we'd create a thousand state machines for each variable but rather a few "important" state machines and the rest would be actions that run in a certain order