What to know going into SysML version 2 from SysML v1.x

5 Key Things to Know When Starting in SysML v2 From SysML v1

1 — SysML v2 has a complete text-based language to complement the diagrammatic language

• SysML v1 functioned much more like a tool with a standard graphical interface. SysML v2 makes the complete transition to being a true language.
• What you will need to know as a modeler is that there is now a "code" or text-based representation of the model. SysML is now a complete language written from the ground up for systems engineers.

2 — SysML no longer relies on primitive diagram concepts with strict limits on what you can put in the diagrams

• Instead, SysML v2 completes the shift to views of the model. Diagrams and other visualizations are defined by what is exposed and how it is shown, instead of UML-specific rules.
• This allows the model developer to focus entirely on building a representation of the system that communicates effectively to stakeholders and other consumers of model content.

3 — SysML no longer suffers from a profoundly asymmetric metamodel of terms for typing

• Instead of having bizarre typing patterns—such as parts being typed by blocks and value properties being typed by value types—a clean terminology is introduced where all definition-based types use "def" in the name. For example, parts are typed by a part def. This pattern is consistent across the language.
• The benefit is that the overall language is much simpler to use and understand.

        part partDef11 : partDef1 {
            port port1;
            connection connection1 : connectionDef1 connect partDef11 to port1;
        }
        part def partDef1 {
            port def portDef1;
        }
        item itemDef11 : itemDef1;
        item def itemDef1;
        attribute attributeDef11 : attributeDef1;
        attribute def attributeDef1;
        connection def connectionDef1;
        end constant ;
        end constant ;
        action actionDef11 : actionDef1;
        action def actionDef1;
        state stateDef11 : stateDef1;
        state def stateDef1;
        calc calc1 : Calc1;
        calc def Calc1;

4 — SysML no longer strictly requires a type-first approach to modeling

• SysML v2 focuses heavily on the needs and practices of the systems engineering community. This resulted in a relaxation of the strict typing required in SysML v1. Parts, actions, and other modeling elements can now be authored without forcing an upfront consideration of underlying definitions.
• The benefit is that the systems engineer can now more freely model top-down problems where typing is not known upfront, or perhaps is not relevant or useful. This mirrors languages like MATLAB and Python that are extremely popular with engineers. SysML retains typing, however, so engineers now have the best of both worlds.

part p1 {
            part sub p2 {
                part sub sub p3;
            }
            port port1 {
                port 'sub port1' {
                    port 'sub sub port';
                }
            }
        }
        view 'Lazy Typing' : DS_Views::SymbolicViews::gv;
        part part1 {
            port port1;
            part part2;
        }
        connection c2 connect p1.port1.'sub port1'.'sub sub port' to part1.port1;
        connection c1 connect p1.p2.p3 to part1.part2;
        connection connection1 {
            end ;
            end ;
            part cnp1 {
                port port1;
            }
            part cnp2 {
                port port1;
            }
            view 'connection' : DS_Views::SymbolicViews::gv;
            connection connect source to cnp1;
            connection connect target to cnp2;
            connection connect cnp1 to cnp2;
        }
    }

5 — Stereotypes and profiles are replaced by libraries and other language extensions

• SysML v2 has no support for stereotypes as such. Instead, it has much richer features focused around holistic, first-class language features as part of the more comprehensive expansion of the language.
• This allows modelers to grow and expand the underlying reusability of models in terms of patterns, vocabularies, templates, frameworks, and reusability.