Guia · SysML v2
SysML v1 vs v2: como as duas linguagens diferem
Ouvir este guia 20 min
A SysML v1 e a SysML v2 têm o mesmo propósito e muitos nomes em comum, mas a SysML v2 é uma linguagem nova, não uma revisão. Este guia compara as duas lado a lado: a base, definições e usages, a notação textual, unidades, portas, comportamento, requisitos, visões, a API e o que envolve uma migração da v1 para a v2.
Nesta página
- Visão geral
- Base: um perfil UML contra a KerML
- Definições e usages em vez de blocos e propriedades
- Uma notação textual padrão
- Biblioteca padrão, grandezas e unidades
- Portas, interfaces e conexões
- Comportamento: ações e estados
- Requisitos e casos de verificação
- Visões em vez de diagramas desenhados
- A Systems Modeling API e o intercâmbio em JSON
- Migrar um modelo da SysML v1 para a v2
- Como as listagens foram checadas
- Experimente no Holarch
- Para onde ir a seguir
Visão geral
Quem conhece a SysML v1 vai reconhecer a maioria dos conceitos na SysML v2. O que mudou é como eles são construídos e com que precisão são definidos. A tabela resume a comparação; cada linha tem sua própria seção abaixo.
| Assunto | SysML v1 | SysML v2 |
|---|---|---|
| Base | Um perfil da UML 2: estereótipos sobre um subconjunto das metaclasses UML | Metamodelo próprio sobre a Kernel Modeling Language (KerML), com semântica definida em uma biblioteca formal |
| Estrutura | Blocos com part, reference e value properties | Definições e usages para todo tipo de elemento: part def e part, port def e port, e assim por diante |
| Notação | Gráfica (nove tipos de diagrama); nenhum texto padrão para o modelo inteiro | Uma notação textual padrão e uma notação gráfica padrão para o mesmo modelo |
| Grandezas e unidades | Value types com unidades, por meio de um modelo de unidades e bibliotecas de modelos | Grandezas ISQ e unidades SI na biblioteca padrão, usadas diretamente em valores como 6.5 [kg] |
| Interfaces | Full ports e proxy ports, interface blocks, flow properties, item flows em conectores | Definições de porta com features direcionadas, conjugação ~, definições de interface com extremidades tipadas, flows e binding |
| Comportamento | Atividades, máquinas de estados e interações da UML, ligadas à estrutura por alocação | Ações, estados e mensagens como occurrences, ligados à estrutura por perform e exhibit |
| Requisitos | Uma classe estereotipada com id e texto; as restrições ficam separadas em constraint blocks | Um requisito é uma restrição com um subject; texto e uma condição checável em um só elemento |
| Verificação | Casos de teste ligados por verify | Casos de verificação com um objetivo e um veredito |
| Diagramas | Desenhos guardados pela ferramenta; os layouts raramente passam de uma ferramenta para outra | Visões são elementos do modelo que declaram o que mostram; a ferramenta as renderiza |
| Intercâmbio | Arquivos XMI, com diferenças entre ferramentas | Arquivos de texto, JSON e a Systems Modeling API padrão |
Base: um perfil UML contra a KerML
A SysML v1 é definida como um perfil da UML 2. Ela pega um subconjunto da UML e acrescenta estereótipos: um bloco é uma classe UML com o estereótipo «block», um requisito é uma classe com «requirement», uma flow property é uma propriedade com «flowProperty». Isso tornou a SysML v1 rápida de adotar, porque ferramentas UML podiam hospedá-la, mas também significou que conceitos de sistemas foram dobrados para caber em conceitos de software, e que o significado de muitas construções vinha da semântica da UML, escrita para software.
A SysML v2 abandona a base UML. Ela é construída sobre a Kernel Modeling Language (KerML), uma linguagem menor cujo núcleo recebe significado preciso em uma biblioteca de modelos KerML. A SysML v2 acrescenta por cima os conceitos de engenharia de sistemas: partes, portas, ações, estados, requisitos, casos e visões. Toda construção SysML v2 é definida como especialização de algo nessa biblioteca. Na prática, isso significa:
- Estrutura e comportamento compartilham uma só base. Partes e ações são ambas occurrences que existem ao longo do tempo, então uma parte pode executar uma ação ou exibir um estado sem uma camada de alocação separada.
- As ferramentas concordam mais sobre o que um modelo significa, porque o significado está na especificação e em suas bibliotecas, e não na interpretação de cada ferramenta.
- Os estereótipos não são mais o mecanismo de extensão. A SysML v2 usa definições de metadados para anotações específicas de ferramenta ou de domínio.
Definições e usages em vez de blocos e propriedades
Na SysML v1 o bloco é o elemento central: um block definition diagram define blocos, e um internal block diagram mostra as partes de um bloco. Uma part property é tipada por um bloco; uma value property é tipada por um value type. Dar a uma parte um valor diferente do padrão do seu bloco, por exemplo uma bomba mais pesada em uma variante do produto, exige uma gambiarra: um bloco especializado que redefine a propriedade, um tipo específico de propriedade ou uma instance specification.
A SysML v2 generaliza isso em um só padrão para todo elemento: uma definição diz o que um tipo de coisa é, um usage é uma dessas coisas em um contexto. Usages se aninham, e um usage aninhado pode redefinir o que herda com seu próprio valor. O mesmo padrão vale para atributos, portas, ações, estados, requisitos e visões.
package CoolingLoop {
doc /* The engine cooling loop of a small generator set. */
private import ScalarValues::*;
private import ISQ::*;
private import SI::*;
part def Pump {
attribute mass : MassValue;
attribute shaftPower : PowerValue;
}
part def ElectricPump :> Pump {
attribute supplyVoltage : ElectricPotentialValue;
}
part def Radiator {
attribute mass : MassValue;
attribute heatRejection : PowerValue;
}
part def CoolingSystem {
part pump : ElectricPump {
attribute redefines mass = 2.4 [kg];
attribute redefines shaftPower = 150 [W];
attribute redefines supplyVoltage = 24 [V];
}
part radiator : Radiator {
:>> mass = 6.5 [kg];
:>> heatRejection = 18 [kW];
}
attribute totalMass : MassValue = pump.mass + radiator.mass;
}
}
| SysML v1 | SysML v2 nesta listagem |
|---|---|
Bloco Pump com value properties | part def Pump com atributos |
Generalização de ElectricPump para Pump | Especialização part def ElectricPump :> Pump |
Part property pump de CoolingSystem, tipada pelo bloco | Part usage part pump : ElectricPump |
| Um valor específico do contexto por meio de um bloco especializado ou de uma instância | attribute redefines mass = 2.4 [kg] diretamente no usage |
| Um valor derivado com um constraint block e um diagrama paramétrico | totalMass como expressão no atributo |
:>> é a forma curta de redefines. As reference properties da v1, que apontam para uma parte que pertence a outro lugar, se tornam usages ref na v2.
Uma notação textual padrão
A SysML v1 não tem uma forma textual padrão para um modelo inteiro. O modelo vive no repositório da ferramenta, as pessoas trabalham em diagramas, e os arquivos passam entre ferramentas como XMI, que é feito para máquinas, não para leitura. O texto aparece só em alguns pontos: expressões de restrição, opaque behaviors e linguagens de ação em algumas ferramentas.
A SysML v2 tem uma notação textual que cobre a linguagem inteira, ao lado de uma notação gráfica. Ambas mostram o mesmo modelo. Toda listagem nesta página está nessa notação textual; o tutorial de SysML v2 constrói um modelo completo nela passo a passo. O texto muda o modo como uma equipe pode trabalhar:
- Um modelo pode ser revisado linha por linha, comparado com um diff e mantido sob controle de versão junto com o restante dos dados de engenharia.
- Os engenheiros podem digitar um modelo rapidamente, copiar padrões entre modelos e gerar partes dele com scripts.
- Um modelo pode ser checado como código-fonte: nomes não resolvidos, unidades erradas e portas incompatíveis são relatados onde ocorrem.
A notação textual não substitui os diagramas. Ela faz do modelo o artefato principal, e os diagramas se tornam visões dele, como descrito abaixo.
Biblioteca padrão, grandezas e unidades
A SysML v1 tipa uma value property por um value type, que pode carregar uma unidade e um tipo de grandeza. A especificação inclui um modelo de grandezas e unidades, e bibliotecas de modelos para unidades comuns, mas as ferramentas diferem em quais bibliotecas trazem e até onde checam unidades em expressões.
A SysML v2 traz uma biblioteca padrão como parte da linguagem. Ela inclui o Sistema Internacional de Grandezas (ISQ), as unidades SI (SI), as unidades usuais dos EUA, tipos escalares, coleções e as definições de visão padrão. Na listagem acima:
attribute mass : MassValuediz que o atributo é uma massa, não um número.6.5 [kg]é um valor de grandeza: um número com unidade, escrito em linha.pump.mass + radiator.masssoma duas massas. Uma ferramenta que avalia unidades pode rejeitar uma expressão que soma uma massa a uma potência, ou uma massa dada em volts.
Portas, interfaces e conexões
As portas da SysML v1 passaram por vários projetos. As primeiras versões tinham standard ports e flow ports; versões posteriores as substituíram por full ports, proxy ports e interface blocks com flow properties. Uma flow property tem uma direção (in, out ou inout), uma porta pode ser conjugada para inverter as direções, e item flows em conectores dizem o que se move. Muitos modelos v1 existentes ainda misturam os tipos de porta antigos e novos.
A SysML v2 mantém as ideias e as torna uniformes. Uma definição de porta lista features direcionadas, o lado receptor usa o conjugado ~ da mesma definição, e uma definição de interface descreve um tipo de conexão com extremidades tipadas.
package CoolantInterfaces {
private import ISQ::*;
item def Coolant {
attribute temperature : ThermodynamicTemperatureValue;
}
port def CoolantPort {
out item coolant : Coolant;
}
interface def Hose {
end supply : CoolantPort;
end ret : ~CoolantPort;
}
part def Pump {
port outlet : CoolantPort;
}
part def Radiator {
port inlet : ~CoolantPort;
}
part def Loop {
part pump : Pump;
part radiator : Radiator;
interface hose : Hose connect pump.outlet to radiator.inlet;
}
}
| SysML v1 | SysML v2 |
|---|---|
| Interface block com flow properties | port def com features in, out ou inout |
| Proxy port ou full port tipada pelo interface block | Usage port tipado pela definição de porta |
| Tipo de porta conjugada | ~CoolantPort |
| Conector, opcionalmente tipado por um association block | connect … to …, ou um usage interface tipado por uma interface def |
| Binding connector | bind a = b |
| Item flow em um conector | Usage flow, ou uma item feature da porta |
Como as direções fazem parte das definições, um verificador pode avisar quando as duas extremidades de uma conexão enviam a mesma feature e nenhuma a recebe.
Loop da listagem em uma Visão de interconexão, a contrapartida em SysML v2 de um internal block diagram.Comportamento: ações e estados
A SysML v1 empresta seu comportamento da UML: atividades com semântica de fluxo de tokens, máquinas de estados e interações para diagramas de sequência. Um comportamento é ligado à estrutura que o executa por meio de alocação, muitas vezes com activity partitions (raias) ou relacionamentos «allocate».
Na SysML v2, ações e estados são occurrences, como as partes. Uma definição de ação tem parâmetros de entrada e saída; successions (first … then …) dão a ordem e flows dizem o que passa entre as etapas. Uma definição de estado tem estados e transições com triggers, guardas e efeitos. Uma parte executa uma ação com perform e exibe um estado com exhibit, então a ligação com a estrutura faz parte da linguagem, em vez de ser um relacionamento acrescentado.
package PumpBehavior {
private import ISQ::*;
item def StartCommand;
item def StopCommand;
item def Coolant;
action def Circulate {
in item cold : Coolant;
out item warm : Coolant;
}
action def CoolEngine {
action pumpCoolant : Circulate;
action rejectHeat : Circulate;
flow pumpCoolant.warm to rejectHeat.cold;
first start then pumpCoolant;
first pumpCoolant then rejectHeat;
first rejectHeat then done;
}
state def PumpModes {
entry; then off;
state off;
state running;
transition first off accept StartCommand then running;
transition first running accept StopCommand then off;
}
part def Pump {
exhibit state modes : PumpModes;
}
}
| SysML v1 | SysML v2 |
|---|---|
| Atividade com ações, control flows e object flows | action def com action usages, successions e flows |
| Nós de fork, join, decision e merge | fork, join, decide e merge |
| Call behavior action | Um action usage tipado por outra definição de ação |
| Partition ou «allocate» da atividade para o bloco | perform na parte |
| Máquina de estados pertencente a um bloco | state def, com exhibit state na parte |
| Transição com trigger, guarda e efeito | transition … accept … if … do … then … |
| Interação (diagrama de sequência) | Occurrences com messages, mostradas em uma Visão de sequência |
PumpModes em uma Visão de transição de estados, desenhada a partir do texto acima.Requisitos e casos de verificação
Um requisito SysML v1 é uma classe estereotipada com duas strings: um id e um texto. Relacionamentos o ligam ao restante do modelo: satisfy, verify, derive, refine, trace e copy. Um caso de teste é um comportamento marcado como «testCase». Checar um requisito com números exige um constraint block separado em um diagrama paramétrico, e nada na linguagem liga essa restrição ao texto do requisito.
Na SysML v2, uma definição de requisito é um tipo de definição de restrição. Ela tem um subject (aquilo de que o requisito trata), pode ter atributos como um limite, e contém a condição que deve valer. O texto doc e a condição ficam em um só elemento. Um caso de verificação declara em seu objetivo o requisito que verifica e retorna um veredito.
package CoolingRequirements {
private import ScalarValues::*;
private import ISQ::*;
private import SI::*;
part def CoolingSystem {
attribute heatRejection : PowerValue;
}
part cooling : CoolingSystem {
attribute redefines heatRejection = 18 [kW];
}
requirement def <'CR-1'> HeatRejection {
doc /* The cooling system shall reject at least the engine's waste heat at full load. */
subject system : CoolingSystem;
attribute wasteHeat : PowerValue;
require constraint { system.heatRejection >= wasteHeat }
}
requirement coolingSpec : HeatRejection {
subject system : CoolingSystem;
attribute redefines wasteHeat = 15 [kW];
}
satisfy coolingSpec by cooling;
verification def <'VC-1'> HeatRunTest {
doc /* Run the engine at full load on a test stand and measure the heat the radiator rejects. */
subject system : CoolingSystem;
objective {
verify coolingSpec;
}
return verdict : Boolean = system.heatRejection >= coolingSpec.wasteHeat;
}
verification heatRun : HeatRunTest {
subject system = cooling;
}
}
<'CR-1'>é um nome curto, o lugar na v2 do id de requisito da v1.require constrainté a forma checável do texto. Com 18 kW contra 15 kW, uma ferramenta que avalia restrições relata o requisito como atendido.satisfyeverifymantêm o significado da v1. Derive, refine e trace se mapeiam para dependências ou para requirement usages aninhados em outros requisitos; as equipes decidem como modelá-los.- A SysML v2 acrescenta aos requisitos premissas (
assume constraint), stakeholders e concerns, e casos de uso e casos de análise ao lado dos casos de verificação.
Visões em vez de diagramas desenhados
Um diagrama SysML v1 é um desenho que pertence à ferramenta: alguém escolhe quais elementos aparecem e onde. Dois diagramas do mesmo bloco podem discordar sobre o que ele contém, e os layouts de diagrama raramente sobrevivem a um intercâmbio entre ferramentas. Versões posteriores da v1 acrescentaram views e viewpoints, mas eles são usados principalmente para documentos, não para os diagramas que os engenheiros desenham todo dia.
Na SysML v2, uma visão é um elemento do modelo. Ela indica o que mostrar com expose, quais tipos de elemento incluir com filter e como qual definição de visão padrão renderizá-la. O layout fica a cargo da ferramenta; o que a visão contém está no modelo e pode ser lido no texto.
package CoolingViews {
private import StandardViewDefinitions::*;
part def Pump;
part def Radiator;
part def Loop {
part pump : Pump;
part radiator : Radiator;
connect pump to radiator;
}
view loopConnections : InterconnectionView {
expose Loop;
}
view structure : GeneralView {
filter @SysML::PartDefinition;
expose CoolingViews::*;
}
}
| Diagrama SysML v1 | Visão SysML v2 |
|---|---|
| Block definition, package, requirement diagram | Visão geral, com filtros |
| Internal block diagram | Visão de interconexão |
| Diagrama de atividades | Action Flow View |
| Diagrama de máquina de estados | Visão de transição de estados |
| Diagrama de sequência | Visão de sequência |
| Diagrama paramétrico | Visão geral ou Visão de interconexão das restrições e seus bindings |
| Diagrama de casos de uso | Visão geral de casos de uso e atores |
| Tabelas e matrizes (específicas de cada ferramenta na v1) | Visão em grade |
A Systems Modeling API e o intercâmbio em JSON
Os modelos SysML v1 passam entre ferramentas como XMI. O XMI é um padrão, mas cada ferramenta grava sua própria variante, estereótipos e dados de diagrama, então um intercâmbio normalmente precisa ser testado para cada par de ferramentas, e não há um jeito padrão de um programa consultar um modelo guardado em outra ferramenta.
A SysML v2 vem com a especificação Systems Modeling API and Services. Ela define serviços para projetos, branches, commits, elementos e consultas, e um binding REST/HTTP em que cada elemento é um objeto JSON com um @id e um @type. As consequências:
- Um script, um painel ou outra ferramenta pode ler e consultar um modelo por uma interface documentada, em vez de uma específica de fornecedor.
- Os ids dos elementos viajam com o modelo, então os vínculos entre ferramentas podem sobreviver a um intercâmbio.
- Os modelos são versionados como commits em branches, de forma muito parecida com código-fonte.
Arquivos de texto e JSON se complementam: o texto é para as pessoas lerem, revisarem e compararem; o JSON mantém os ids de que as ferramentas dependem.
Migrar um modelo da SysML v1 para a v2
Levar um modelo v1 para a v2 é uma tradução entre linguagens, não uma atualização de arquivo, e a ferramenta de destino decide quanto disso é automatizado: o que checar em uma ferramenta SysML v2 cobre a importação da v1 entre as outras checagens. Boa parte de um modelo típico se mapeia diretamente, e uma parte é melhor reconstruída do jeito da v2 do que traduzida literalmente.
O que se mapeia diretamente
- Pacotes e seu aninhamento.
- Blocos para definições de partes, part properties para part usages, reference properties para usages
ref, generalizações para especializações. - Value properties para atributos, com grandezas e unidades quando os value types da v1 tinham unidades.
- Interface blocks com flow properties para definições de porta; proxy ports e full ports para port usages; conectores para conexões ou interfaces.
- Ids e texto de requisitos para nomes curtos e
doc; relacionamentos satisfy e verify. - Máquinas de estados para definições de estado; atividades bem estruturadas para definições de ação com successions e flows.
O que precisa ser repensado
- Valores específicos do contexto. Tipos específicos de propriedade, instance specifications e redefinições feitas só para definir um valor se tornam simples redefinições em usages. Uma tradução literal mantém a gambiarra.
- Requisitos só de texto. A v2 os permite, mas o ganho vem de acrescentar a condição. Decida quais requisitos recebem um
require constraint. - Constraint blocks e diagramas paramétricos. Eles se tornam definições de restrição e de cálculo, muitas vezes escritas como expressões diretamente nos atributos, como o
totalMassacima. - Alocação. Activity partitions e relacionamentos «allocate» do comportamento para a estrutura se tornam
performeexhibitonde o significado é “esta parte faz isto”. - Tipos de porta antigos. Standard ports e flow ports de modelos v1 antigos exigem mais trabalho, já que a v2 tem um só conceito de porta.
- Perfis e estereótipos. Estereótipos personalizados e tagged values se tornam definições de metadados; seu significado precisa ser projetado de novo.
- Diagramas. Os layouts não passam. Cada diagrama que importa se torna uma visão, e seu conteúdo é declarado de novo com
exposeefilter. - Opaque behaviors e scripts de ferramenta. Código em uma linguagem de ações ou nos scripts de uma ferramenta não é traduzido; ele precisa ser reescrito ou mantido fora do modelo.
Planeje uma migração como qualquer mudança de modelo: converta primeiro um pacote representativo, revise-o com as pessoas que usam o modelo, defina os padrões de modelagem para os pontos acima e depois converta o resto. Mantenha o modelo v1 como referência até o modelo v2 ser revisado. Levar um modelo SysML v1 para SysML v2 percorre essas etapas.
Como as listagens foram checadas
Toda listagem nesta página foi analisada e checada com o Holarch Language Engine, o motor por trás do Editor SysML v2 do Holarch, com a biblioteca padrão da SysML v2 carregada, e não dá erros nem avisos. Para saber quais construções SysML v2 o motor suporta e suas lacunas conhecidas, veja Cobertura da linguagem SysML v2. Para um modelo de exemplo mais longo, veja o tutorial de SysML v2.
Experimente no Holarch
O Holarch tem projetos SysML v2, em que a notação textual e as visões editam um só modelo, e projetos LML. Para ler as listagens acima como modelo:
- Crie um projeto SysML v2. Veja primeiros passos com projetos SysML v2.
- Em Modelo → Editor, clique em + Novo package e cole uma listagem. O texto que é analisado sem erros é aplicado após uma breve pausa, e os problemas são marcados no lugar. Veja o Editor.
- Abra a lista Diagramas para ver as visões. Veja a referência de visões.
Modelos SysML v1. Um projeto SysML v2 importa um modelo SysML 1.x diretamente: em Modelo → Importar e exportar, solte um arquivo XMI (do Cameo Systems Modeler ou MagicDraw, Enterprise Architect, Rhapsody ou Papyrus) ou um projeto .mdzip do Cameo ou do MagicDraw. O Holarch o converte em texto SysML v2, checa o texto e mostra um relatório de conversão que marca cada elemento como convertido, aproximado ou deixado de fora, com o motivo, antes de qualquer mudança. Os layouts de diagrama não são convertidos, então trate o resultado como ponto de partida para a revisão de conceitos descrita acima, não como uma migração terminada. Veja importar modelos SysML v1.
Os projetos LML também importam XMI SysML 1.x e exportam o modelo de novo como XMI SysML 1.6 ou como arquivo .uml do Papyrus; um arquivo editado no Papyrus é importado de volta para o mesmo projeto e atualiza os itens no lugar pelo id XMI. Veja importar um modelo UML/SysML e ida e volta com o Papyrus.
Para onde ir a seguir
- Tutorial de SysML v2: construa um pequeno sistema passo a passo na notação textual.
- Ferramentas SysML v2: o que checar antes de escolher uma: uma checklist e um modelo de teste para qualquer ferramenta candidata.
- Projetos SysML v2 no Holarch: texto, visões e páginas de engenharia sobre um só modelo.
- Cobertura da linguagem SysML v2: o que o motor suporta e suas lacunas conhecidas.
- Intercâmbio de modelos SysML v2: texto, JSON e repositórios da Systems Modeling API.