Guida · SysML v2
Strumenti SysML v2: che cosa controllare prima di sceglierne uno
Ascolta questa guida 16 min
Una guida alla valutazione degli strumenti SysML v2: che cosa controllare in ogni candidato, come distinguere un supporto reale da una slide, una tabella di checklist con cui dare un punteggio e un piccolo modello di prova da caricare in ciascuno.
In questa pagina
- Perché gli strumenti SysML v2 richiedono una valutazione propria
- Che cosa controllare
- Copertura del linguaggio, e come sono documentate le lacune
- Notazione testuale: modifica e controllo
- Viste grafiche, e sincronizzazione tra testo e diagrammi
- Libreria standard
- La Systems Modeling API
- Scambio JSON e round trip
- Migrazione da SysML v1
- Collaborazione e controllo di versione
- Requisiti e verifica sul modello
- Analisi e valutazione con le unità
- Distribuzione: cloud o self-hosted
- Licenze e costi
- Formazione
- Una checklist di valutazione
- Un modello di prova da caricare in qualsiasi candidato
- Eseguire la valutazione
- Le risposte di Holarch alla checklist
- Provarlo in Holarch
- Dove andare dopo
Perché gli strumenti SysML v2 richiedono una valutazione propria
SysML v2 è un nuovo linguaggio, non una revisione di SysML v1 (in che cosa differiscono SysML v1 e v2 li confronta in dettaglio). Ha una notazione testuale oltre a quella grafica, una base semantica formale in KerML, una libreria standard di grandezze, unità e tipi di vista, e un’API standard per leggere e scrivere modelli. Uno strumento può dichiarare il supporto a SysML v2 e coprirne comunque solo una parte, e le parti che tralascia possono essere proprio quelle da cui dipende il proprio programma.
La specifica è ampia, e ogni strumento la implementa per gradi. È normale. Ciò che conta in una valutazione è sapere quali passi uno strumento ha compiuto, quali no, e se il fornitore lo dice chiaramente. I controlli seguenti valgono per qualsiasi strumento SysML v2, qualunque sia il suo prezzo o la sua distribuzione, e il modello di prova fornisce lo stesso input per ogni candidato.
Per trovare i candidati, partire dall’elenco degli strumenti SysML v2 tenuto dall’OMG e dal riepilogo delle capacità degli strumenti SysML v2 che INCOSE e l’OMG hanno pubblicato per sostenere il passaggio da SysML v1. Entrambi sono punti di partenza: leggerli per i nomi, poi provare personalmente ogni strumento.
Che cosa controllare
Copertura del linguaggio, e come sono documentate le lacune
Chiedere una dichiarazione di copertura: ogni area del linguaggio (pacchetti, definizioni e usi, specializzazione e ridefinizione, molteplicità, valori e unità, vincoli, struttura, azioni, stati, requisiti, casi d’uso, casi di analisi e di verifica, viste, metadati, variabilità, individui e time slice) con un livello per ciascuna. Livelli utili distinguono quattro casi:
- lo strumento analizza, controlla e usa il costrutto;
- lo fa con limiti dichiarati;
- conserva il costrutto esattamente come scritto ma non gli attribuisce alcun significato (sopravvive a un round trip ma nulla lo controlla o lo calcola);
- non lo accetta.
Un fornitore che pubblica le lacune note è più facile da pianificare di uno che elenca solo le funzionalità. Considerare sconosciuto un «supporta SysML v2» privo di tabella di copertura, e provare i costrutti usati dai propri modelli.
Notazione testuale: modifica e controllo
La notazione testuale è il punto in cui SysML v2 differisce di più da v1, ed è il punto in cui gli strumenti differiscono di più. Controllare:
- Modifica: evidenziazione della sintassi, completamento di nomi e parole chiave, vai alla definizione, ridenominazione in tutto il modello, trova e sostituisci.
- Controllo durante la digitazione: gli errori di sintassi sono il minimo. Un verificatore utile risolve anche ogni nome attraverso gli import, segnala nomi duplicati e ambigui, controlla le ridefinizioni rispetto a ciò che viene ereditato, confronta le dimensioni delle unità e confronta le direzioni di porte e flussi attraverso le connessioni.
- Il testo è il modello: dopo una modifica, ogni altra vista vede il cambiamento, oppure il testo è un file che lo strumento importa di tanto in tanto?
- Testo non scritto dallo strumento: caricare testo scritto a mano o da un altro strumento. Commenti, documentazione e impaginazione del testo dovrebbero sopravvivere.
Viste grafiche, e sincronizzazione tra testo e diagrammi
In SysML v2 una vista è un elemento del modello: dichiara che cosa espone e filtra, e lo strumento la visualizza. La libreria standard definisce le viste General, Interconnection, Action Flow, State Transition, Sequence e Grid. Controllare quali di queste lo strumento disegna, in quali permette di modificare e come gestisce il layout, che la specifica lascia allo strumento.
Il test chiave è la sincronizzazione in entrambe le direzioni. Rinominare una parte nel testo e guardare ogni diagramma che la mostra. Aggiungere una connessione in un diagramma e leggere il testo prodotto. Poi modificare entrambi i lati contemporaneamente, se due persone possono farlo, e vedere che cosa fa lo strumento con il conflitto.
Libreria standard
Gran parte del significato di SysML v2 si trova nella sua libreria standard: valori scalari, il Sistema internazionale delle grandezze, le unità SI e consuetudinarie statunitensi, le definizioni di vista standard e le librerie del kernel KerML. Uno strumento dovrebbe fornire la libreria, risolvere i nomi rispetto a essa e valutare con essa. Controllare che i tipi di grandezza ISQ e le unità SI vengano risolti, che la libreria non si possa modificare per errore e quale versione della libreria usa lo strumento.
La Systems Modeling API
La Systems Modeling API è l’interfaccia REST standard verso un repository di modelli: progetti, rami, commit ed elementi. Permette agli strumenti di scambiarsi modelli senza file, e ai propri script di leggere i modelli. Uno strumento può avere due ruoli, ciascuno dei quali può essere di sola lettura:
- Client: lo strumento legge da un altro repository che offre l’API e vi scrive.
- Server: lo strumento offre l’API in modo che altri strumenti leggano, ed eventualmente scrivano, i suoi modelli.
Chiedere quale ruolo, quali route e se sono offerti scritture, query, diff e commit precedenti. Un server di sola lettura è comunque utile per i report e per alimentare strumenti di analisi; non basta quando un altro strumento deve modificare il modello.
Scambio JSON e round trip
Oltre al testo, i modelli passano da uno strumento all’altro come JSON SysML v2: il formato degli elementi dell’API, con un id per ogni elemento. Gli id contano: il testo non ne contiene, quindi uno strumento che reimporta testo può far corrispondere gli elementi solo per nome, mentre il JSON conserva l’identità attraverso uno scambio. Provare un round trip: esportare dallo strumento A, importare nello strumento B, esportare di nuovo e importare in A. Poi confrontare il numero di elementi, i nomi, i valori con le unità e le relazioni, e leggere come ogni strumento segnala ciò che ha scartato. I tipi di elemento non supportati da uno strumento sono il punto in cui i round trip perdono dati.
Migrazione da SysML v1
Non esiste una traduzione automatica senza perdite da v1 a v2: i linguaggi differiscono per struttura, e i diagrammi v1 contengono layout e stereotipi che non hanno un unico equivalente in v2. Chiedere come lo strumento importa i modelli v1 (di solito XMI con il profilo SysML 1.x), in che cosa mappa blocchi, parti, porte, attività, macchine a stati e requisiti, e se produce un rapporto di ciò che non è stato convertito. Provarlo su uno dei propri modelli v1, non sul campione del fornitore.
Collaborazione e controllo di versione
I modelli di sistema sono lavoro di squadra. Controllare se più persone possono modificare contemporaneamente e come vengono mostrati e risolti i conflitti, quali ruoli esistono (modifica, revisione, visualizzazione), come funzionano cronologia e baseline, e se è possibile confrontare due versioni elemento per elemento e come testo. Se l’organizzazione conserva i modelli in un repository, controllare rami, unioni e come la cronologia delle versioni dello strumento si rapporta ai commit del repository.
Requisiti e verifica sul modello
SysML v2 fa di un requisito un vincolo su un soggetto, con relazioni satisfy e verify verso il progetto e i casi di verifica. Controllare che lo strumento tenga insieme il testo del requisito e il vincolo, valuti il vincolo rispetto ai valori del modello e costruisca una matrice di verifica dai collegamenti verify. Controllare anche che cosa lo strumento conserva al di fuori del linguaggio: stato dei requisiti, approvazioni, risultati dei test e collegamenti sospetti dopo una modifica. Non fanno parte del testo SysML v2, quindi chiedere dove sono memorizzati e se viaggiano con un’esportazione.
Analisi e valutazione con le unità
Ogni valore in un modello SysML v2 può avere un’unità, e le espressioni le combinano. Controllare che lo strumento valuti espressioni con unità (una massa totale da tre masse di parti, in chilogrammi), segnali un errore dimensionale come errore e valuti i vincoli dei requisiti rispetto al risultato. Poi controllare le funzionalità di analisi più ampie che servono: risoluzione parametrica, budget e aggregazioni, studi di trade-off, simulazione di flussi d’azioni o macchine a stati. Chiedere che cosa viene valutato dal modello e che cosa richiede dati aggiuntivi specifici dello strumento.
Distribuzione: cloud o self-hosted
Controllare dove risiede il modello e chi gestisce lo strumento: un servizio ospitato, un’installazione desktop o un server nel proprio ambiente. Per dati controllati o soggetti a restrizioni all’esportazione, chiedere informazioni su self-hosting, ubicazione dei dati, opzioni di accesso e su come le eventuali funzionalità di IA vengono configurate o disattivate.
Licenze e costi
Confrontare il costo totale per il proprio team, non il prezzo di listino per postazione: lettori e revisori, uso accademico o di valutazione, il costo di un’opzione API o server, e che cosa succede ai propri modelli se si smette di pagare. Controllare se un’esportazione nei formati standard è disponibile con ogni piano, così che i modelli restino propri.
Formazione
SysML v2 è nuovo per la maggior parte degli ingegneri, anche per chi conosce bene v1. Cercare documentazione di riferimento che copra la notazione così come lo strumento la supporta, esempi svolti, un modello demo da esplorare e materiale guidato per le schermate dello strumento. La formazione sul linguaggio e quella sullo strumento sono esigenze diverse; controllare che siano coperte entrambe.
Una checklist di valutazione
Valutare ogni candidato con le stesse domande e lo stesso input. «Mostrato» significa averlo visto funzionare sul modello di prova o sul proprio modello, non su una slide.
| Area | Domanda da porre | Come provarlo |
|---|---|---|
| Copertura del linguaggio | Esiste una tabella di copertura pubblicata con le lacune note? | Cercarvi i costrutti usati dai propri modelli; caricare il modello di prova |
| Notazione testuale | L’editor controlla nomi, ridefinizioni, unità e direzioni durante la digitazione? | Caricare le due prove; ciascuna dovrebbe segnalare un problema |
| Viste grafiche | Quali viste standard sono disegnate e modificabili? | Aprire una Vista di interconnessione e una Vista di transizione di stato del modello di prova |
| Sincronizzazione tra testo e diagrammi | Una modifica su un lato compare subito sull’altro? | Rinominare controller nel testo; aggiungere una connessione in un diagramma e leggere il testo |
| Libreria standard | Le grandezze ISQ, le unità SI e le viste standard vengono risolte? | Il modello di prova importa ISQ, SI e StandardViewDefinitions |
| Systems Modeling API | Client, server o entrambi? Sola lettura o lettura e scrittura? | Leggere gli elementi del modello di prova da un altro strumento o con uno script |
| Round trip JSON | Gli id degli elementi vengono conservati? Che cosa viene scartato, ed è segnalato? | Esportare, importare in un secondo strumento, esportare di nuovo, confrontare |
| Migrazione da v1 | Esiste un percorso di importazione da SysML v1, con un rapporto? | Convertire uno dei propri modelli v1 |
| Collaborazione | Modifica simultanea, ruoli, baseline, confronto? | Due persone modificano lo stesso pacchetto; confrontare con una baseline |
| Requisiti e verifica | I vincoli vengono valutati e viene costruita una matrice di verifica? | Abbassare il limite di massa a 20 kg e vedere il requisito fallire |
| Analisi con unità | I valori vengono valutati con le unità? Che cos’altro viene calcolato? | Controllare che totalMass valga 23 kg |
| Distribuzione | Ospitato, desktop, self-hosted? | Chiedere le opzioni per iscritto, con l’ubicazione dei dati |
| Licenze e costi | Costo totale per autori, revisori e lettori; esportazione con ogni piano? | Calcolare il prezzo per il proprio team, revisori compresi |
| Formazione | Riferimento del linguaggio, esempi, guide allo strumento? | Far modellare il sistema di prova a un nuovo utente basandosi solo sulla documentazione |
Un modello di prova da caricare in qualsiasi candidato
Questo modello è abbastanza piccolo da digitarlo e tocca comunque la maggior parte di ciò che serve a una valutazione: import dalla libreria standard, definizioni e usi di parte con valori ridefiniti e unità, porte coniugate, connessioni e un binding, una macchina a stati, un’azione con successioni, due requisiti con vincoli, un satisfy, un caso di verifica e due viste. Salvarlo come pump-station.sysml e caricarlo in ogni strumento.
Il sistema è una pompa per l’acqua a energia solare: un pannello alimenta un controller, il controller aziona la pompa. L’unità non deve pesare più di 25 kg, e la potenza di picco del pannello deve superare la potenza nominale della pompa di almeno il 20 %. Se la notazione è nuova, il tutorial di SysML v2 introduce ogni costrutto usato da questo modello.
package PumpStation {
doc /* A solar-powered water pump: a small probe model for evaluating SysML v2 tools. */
private import ScalarValues::*;
private import ISQ::*;
private import SI::*;
port def PowerPort {
out attribute voltage : ElectricPotentialValue;
}
port def WaterPort {
out attribute pressure : PressureValue;
}
part def SolarPanel {
attribute mass : MassValue;
attribute peakPower : PowerValue;
port powerOut : PowerPort;
}
part def Controller {
attribute mass : MassValue;
port powerIn : ~PowerPort;
port motorOut : PowerPort;
}
part def Pump {
attribute mass : MassValue;
attribute ratedPower : PowerValue;
port powerIn : ~PowerPort;
port outlet : WaterPort;
}
item def StartSignal;
item def StopSignal;
state def PumpModes {
entry; then idle;
state idle;
state pumping;
transition first idle accept StartSignal then pumping;
transition first pumping accept StopSignal then idle;
}
action def DeliverWater {
action convertSunlight;
action regulatePower;
action driveImpeller;
first start then convertSunlight;
first convertSunlight then regulatePower;
first regulatePower then driveImpeller;
first driveImpeller then done;
}
part def PumpUnit {
part panel : SolarPanel {
attribute redefines mass = 12 [kg];
attribute redefines peakPower = 400 [W];
}
part controller : Controller {
attribute redefines mass = 2 [kg];
}
part pump : Pump {
attribute redefines mass = 9 [kg];
attribute redefines ratedPower = 300 [W];
}
port outlet : WaterPort;
connect panel.powerOut to controller.powerIn;
connect controller.motorOut to pump.powerIn;
bind outlet = pump.outlet;
attribute totalMass : MassValue = panel.mass + controller.mass + pump.mass;
exhibit state modes : PumpModes;
}
part pumpUnit : PumpUnit {
perform action delivery : DeliverWater;
}
}
package PumpRequirements {
private import PumpStation::*;
private import ScalarValues::*;
private import ISQ::*;
private import SI::*;
requirement def <'PS-1'> MassLimit {
doc /* The pump unit shall weigh no more than the mass limit, so that one person can carry it. */
subject unit : PumpUnit;
attribute limit : MassValue;
require constraint { unit.totalMass <= limit }
}
requirement def <'PS-2'> PowerMargin {
doc /* The panel's peak power shall exceed the pump's rated power by at least 20 %. */
subject unit : PumpUnit;
require constraint { unit.panel.peakPower >= 1.2 * unit.pump.ratedPower }
}
requirement pumpSpec {
subject unit : PumpUnit;
requirement mass : MassLimit {
attribute redefines limit = 25 [kg];
}
requirement power : PowerMargin;
}
satisfy pumpSpec by pumpUnit;
verification def <'VC-1'> WeighUnit {
doc /* Weigh the assembled pump unit on a calibrated scale. */
subject unit : PumpUnit;
objective {
verify pumpSpec.mass;
}
return verdict : Boolean = unit.totalMass <= pumpSpec.mass.limit;
}
}
package PumpViews {
private import PumpStation::*;
private import StandardViewDefinitions::*;
view unitConnections : InterconnectionView {
expose PumpStation::PumpUnit;
}
view pumpStates : StateTransitionView {
expose PumpStation::PumpModes;
}
}
Che cosa dovrebbe mostrare uno strumento che supporta questi costrutti:
- Nessun errore e nessun avviso. Uno strumento che qui segnala problemi o non ha un costrutto o legge la libreria standard in modo diverso; chiedere quale dei due.
totalMassvale 23 kg: 12 kg + 2 kg + 9 kg.- Entrambi i requisiti sono soddisfatti: 23 kg rientrano nei 25 kg, e 400 W sono più di 1,2 × 300 W = 360 W.
unitConnectionsdisegna il pannello, il controller e la pompa con le loro porte, le due connessioni e l’uscita collegata al confine dell’unità.pumpStatesdisegna due stati con una transizione iniziale e due transizioni attivate da trigger.- Una matrice di verifica elenca
PS-1verificato daVC-1, ePS-2senza caso di verifica.
Due prove per il verificatore
Un verificatore dimostra il suo valore sugli errori. Caricare ogni prova da sola; ciascuna contiene esattamente un problema.
La prima assegna a una potenza un valore in chilogrammi. Uno strumento che controlla le dimensioni segnala un errore sul valore:
package UnitProbe {
private import ISQ::*;
private import SI::*;
part def Pump {
attribute ratedPower : PowerValue;
}
part pump : Pump {
attribute redefines ratedPower = 300 [kg];
}
}
La seconda viene analizzata e risolta senza problemi, ma il suo requisito non è soddisfatto: l’unità pesa 11 kg contro un limite di 10 kg. Uno strumento che valuta i vincoli dei requisiti lo segnala; uno che si limita all’analisi sintattica lo accetta in silenzio.
package RequirementProbe {
private import ISQ::*;
private import SI::*;
part def Pump {
attribute mass : MassValue;
}
part def Unit {
part pump : Pump {
attribute redefines mass = 9 [kg];
}
attribute totalMass : MassValue = pump.mass + 2 [kg];
}
requirement def Light {
subject unit : Unit;
require constraint { unit.totalMass <= 10 [kg] }
}
part unit : Unit;
requirement light : Light;
satisfy light by unit;
}
Entrambe le prove sono state controllate con un motore di linguaggio, come il modello di prova: il modello non dà problemi, e ciascuna prova dà esattamente il problema descritto.
Eseguire la valutazione
- Mettere per iscritto prima le proprie esigenze. Quali costrutti usano i propri modelli, quali viste leggono i revisori, quali strumenti devono scambiarsi modelli e dove possono risiedere i dati. Pesare le righe della checklist in base a questi elementi.
- Leggere la dichiarazione di copertura e le lacune note di ogni fornitore. Contrassegnare ogni riga della checklist come dichiarata, non dichiarata o non indicata.
- Caricare il modello di prova e le prove in ogni candidato. Registrare ciò che ogni strumento segnala, parola per parola.
- Caricare uno dei propri modelli. Un modello reale trova problemi che nessun campione trova: dimensioni, nomi, costrutti insoliti.
- Eseguire un round trip con lo strumento con cui si scambiano più modelli.
- Far costruire a un nuovo utente il modello di prova basandosi solo sulla documentazione dello strumento, e cronometrarlo.
Conservare le evidenze (screenshot, file esportati, i messaggi di ogni strumento) insieme ai punteggi. Un verbale di decisione che mostra che cosa è stato provato vale di più, per un comitato di revisione, di una matrice di funzionalità copiata dal materiale dei fornitori.
Le risposte di Holarch alla checklist
Holarch è lo strumento usato per gli screenshot di questa pagina, quindi ecco le sue risposte, ciascuna con la pagina che le documenta. «Parziale» e «Non ancora» significano esattamente ciò che dicono.
| Area | Livello | Holarch oggi |
|---|---|---|
| Copertura del linguaggio | Parziale | Una tabella pubblicata di ogni area con il suo livello, i limiti e le lacune note. Variabilità, individui e time slice, parole chiave definite dall’utente e metadati semantici vengono controllati e valutati; i file .kerml non vengono ancora importati; le rappresentazioni testuali in SysML e KerML vengono controllate, gli altri linguaggi conservati come testo. Copertura del linguaggio SysML v2 |
| Notazione testuale | Supportato | Un Editor che controlla durante la digitazione (sintassi, nomi, tipizzazione, molteplicità, unità, direzioni, valutazione), con completamento, vai alla definizione, ridenominazione e trova e sostituisci. L’Editor, Controlli |
| Viste grafiche | Parziale | Viste General, Interconnection, Action Flow, State Transition, Sequence e Grid, tutte modificabili. Le Viste di sequenza disegnano messaggi tra lifeline e combined fragment (alt, opt, loop e par). Viste SysML v2 |
| Sincronizzazione tra testo e diagrammi | Supportato | Un unico modello dietro il testo e ogni vista; una modifica su un lato compare sull’altro. Testo e viste restano sincronizzati |
| Libreria standard | Supportato | Caricata e di sola lettura, con le unità ISQ, SI e consuetudinarie statunitensi e le definizioni di vista standard. La libreria standard |
| Systems Modeling API | Parziale | Come client: legge da un ramo di un repository che offre l’API e vi scrive. Come server: altri strumenti leggono il modello corrente ed effettuano commit in rami di richiesta di modifica, che un approvatore applica in Holarch. Pull e push, Systems Modeling API |
| Round trip JSON | Parziale | Importazione ed esportazione JSON SysML v2 con conservazione degli id degli elementi. I tipi di elemento che Holarch non interpreta vengono conservati come importati e riscritti invariati all’esportazione. Scambiare modelli SysML v2 |
| Migrazione da v1 | Parziale | Importazione diretta di un modello SysML 1.x (.mdzip di Cameo o MagicDraw, oppure XMI da Cameo, Enterprise Architect, Rhapsody o Papyrus) in un progetto SysML v2, convertito in testo SysML v2 e controllato, con un rapporto di ciò che è stato convertito, approssimato od omesso e del perché. I diagrammi e il loro layout non vengono convertiti. Importare modelli SysML v1 |
| Collaborazione | Supportato | Modifica in tempo reale con unione membro per membro nell’Editor, ruoli, baseline che contengono il modello e confronto per elemento e per testo del pacchetto. Collaborazione, Baseline |
| Requisiti e verifica | Supportato | Vincoli dei requisiti valutati rispetto al modello, RVTM e Centro test costruiti dai collegamenti verify, approvazioni, TBD/TBR e collegamenti da rivedere. Requisiti e verifica |
| Analisi con unità | Parziale | Valutazione con unità, Viste parametriche che risolvono un’incognita per vincolo, budget, studi di trade-off e simulazione di flussi d’azioni e macchine a stati. Un caso di analisi viene valutato solo quando ogni input ha un valore. Valutazione, unità e analisi |
| Distribuzione | Supportato | Un’app web ospitata, e distribuzioni self-hosted nel proprio ambiente su richiesta. Sicurezza, Contatti |
| Licenze e costi | Supportato | Un piano Free per studenti, docenti, progetti personali e valutazione individuale; le aziende possono provare gratuitamente il piano Individual per 1 mese; piani a pagamento per l’uso commerciale; revisori e lettori gratuiti con ogni piano. Prezzi |
| Formazione | Parziale | Un riferimento nei Docs per ogni pagina SysML v2, un tutorial passo per passo, la demo Hybrid Car, nove tutorial SysML v2 guidati nell’app e una serie di video tutorial SysML v2 che costruisce il modello Hybrid Car. I percorsi di formazione video riguardano i progetti LML. Primi passi, Tutorial SysML v2, Tutorial di SysML v2 |
Provarlo in Holarch
- Salvare il modello di prova come
pump-station.sysml. - Aprire Modello → Importazione ed esportazione, scegliere In un nuovo progetto SysML v2 e trascinare il file. Si veda importare file in un nuovo progetto.
- Aprire Modello → Editor. La riga di stato indica «Nessun problema», e ogni pacchetto è un documento.
- Aprire l’elenco Diagrammi e fare clic su
unitConnectionsopumpStates. - Aprire Verifica → RVTM per vedere i requisiti con il caso che li verifica.
unitConnections: porte coniugate, due connessioni e un binding.verify del modello.Dove andare dopo
- Tutorial di SysML v2: costruire passo per passo un modello più ampio nella notazione testuale.
- SysML v1 e v2 a confronto: che cosa cambia tra i due linguaggi e che cosa comporta una migrazione.
- Copertura del linguaggio SysML v2: la tabella di copertura completa di Holarch e le lacune note.
- Progetti SysML v2 in Holarch: testo, viste e pagine di ingegneria su un unico modello.