Holarch

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
  1. Visão geral
  2. Base: um perfil UML contra a KerML
  3. Definições e usages em vez de blocos e propriedades
  4. Uma notação textual padrão
  5. Biblioteca padrão, grandezas e unidades
  6. Portas, interfaces e conexões
  7. Comportamento: ações e estados
  8. Requisitos e casos de verificação
  9. Visões em vez de diagramas desenhados
  10. A Systems Modeling API e o intercâmbio em JSON
  11. Migrar um modelo da SysML v1 para a v2
    1. O que se mapeia diretamente
    2. O que precisa ser repensado
  12. Como as listagens foram checadas
  13. Experimente no Holarch
  14. 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.

AssuntoSysML v1SysML v2
BaseUm perfil da UML 2: estereótipos sobre um subconjunto das metaclasses UMLMetamodelo próprio sobre a Kernel Modeling Language (KerML), com semântica definida em uma biblioteca formal
EstruturaBlocos com part, reference e value propertiesDefinições e usages para todo tipo de elemento: part def e part, port def e port, e assim por diante
NotaçãoGráfica (nove tipos de diagrama); nenhum texto padrão para o modelo inteiroUma notação textual padrão e uma notação gráfica padrão para o mesmo modelo
Grandezas e unidadesValue types com unidades, por meio de um modelo de unidades e bibliotecas de modelosGrandezas ISQ e unidades SI na biblioteca padrão, usadas diretamente em valores como 6.5 [kg]
InterfacesFull ports e proxy ports, interface blocks, flow properties, item flows em conectoresDefinições de porta com features direcionadas, conjugação ~, definições de interface com extremidades tipadas, flows e binding
ComportamentoAtividades, máquinas de estados e interações da UML, ligadas à estrutura por alocaçãoAções, estados e mensagens como occurrences, ligados à estrutura por perform e exhibit
RequisitosUma classe estereotipada com id e texto; as restrições ficam separadas em constraint blocksUm requisito é uma restrição com um subject; texto e uma condição checável em um só elemento
VerificaçãoCasos de teste ligados por verifyCasos de verificação com um objetivo e um veredito
DiagramasDesenhos guardados pela ferramenta; os layouts raramente passam de uma ferramenta para outraVisões são elementos do modelo que declaram o que mostram; a ferramenta as renderiza
IntercâmbioArquivos XMI, com diferenças entre ferramentasArquivos 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 v1SysML v2 nesta listagem
Bloco Pump com value propertiespart def Pump com atributos
Generalização de ElectricPump para PumpEspecialização part def ElectricPump :> Pump
Part property pump de CoolingSystem, tipada pelo blocoPart usage part pump : ElectricPump
Um valor específico do contexto por meio de um bloco especializado ou de uma instânciaattribute redefines mass = 2.4 [kg] diretamente no usage
Um valor derivado com um constraint block e um diagrama paramétricototalMass 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 : MassValue diz 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.mass soma 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 v1SysML v2
Interface block com flow propertiesport def com features in, out ou inout
Proxy port ou full port tipada pelo interface blockUsage port tipado pela definição de porta
Tipo de porta conjugada~CoolantPort
Conector, opcionalmente tipado por um association blockconnect … to …, ou um usage interface tipado por uma interface def
Binding connectorbind a = b
Item flow em um conectorUsage 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.

O 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 v1SysML v2
Atividade com ações, control flows e object flowsaction def com action usages, successions e flows
Nós de fork, join, decision e mergefork, join, decide e merge
Call behavior actionUm action usage tipado por outra definição de ação
Partition ou «allocate» da atividade para o blocoperform na parte
Máquina de estados pertencente a um blocostate def, com exhibit state na parte
Transição com trigger, guarda e efeitotransition … 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.
  • satisfy e verify mantê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 v1Visão SysML v2
Block definition, package, requirement diagramVisão geral, com filtros
Internal block diagramVisão de interconexão
Diagrama de atividadesAction Flow View
Diagrama de máquina de estadosVisão de transição de estados
Diagrama de sequênciaVisão de sequência
Diagrama paramétricoVisão geral ou Visão de interconexão das restrições e seus bindings
Diagrama de casos de usoVisã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 totalMass acima.
  • Alocação. Activity partitions e relacionamentos «allocate» do comportamento para a estrutura se tornam perform e exhibit onde 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 expose e filter.
  • 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:

  1. Crie um projeto SysML v2. Veja primeiros passos com projetos SysML v2.
  2. 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.
  3. 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