Holarch

Guia · SysML v2

Ferramentas SysML v2: o que checar antes de escolher uma

Ouvir este guia 16 min

Um guia de avaliação para ferramentas SysML v2: o que checar em qualquer candidata, como distinguir suporte real de um slide, uma tabela de checklist para pontuá-las e um pequeno modelo de teste para carregar em cada uma.

Nesta página
  1. Por que as ferramentas SysML v2 precisam de uma avaliação própria
  2. O que checar
    1. Cobertura da linguagem, e como as lacunas são documentadas
    2. Notação textual: edição e checagem
    3. Visões gráficas, e sincronização entre texto e diagrama
    4. Biblioteca padrão
    5. A Systems Modeling API
    6. Intercâmbio em JSON e ida e volta
    7. Migração da SysML v1
    8. Colaboração e controle de versão
    9. Requisitos e verificação no modelo
    10. Análise e avaliação com unidades
    11. Implantação: nuvem ou auto-hospedada
    12. Licenciamento e custo
    13. Treinamento
  3. Uma checklist de avaliação
  4. Um modelo de teste para carregar em qualquer candidata
    1. Duas sondas para o verificador
  5. Executar a avaliação
  6. As respostas do Holarch à checklist
  7. Experimente no Holarch
  8. Para onde ir a seguir

Por que as ferramentas SysML v2 precisam de uma avaliação própria

A SysML v2 é uma linguagem nova, não uma revisão da SysML v1 (como a SysML v1 e a v2 diferem as compara em detalhe). Ela tem uma notação textual além da gráfica, uma base semântica formal na KerML, uma biblioteca padrão de grandezas, unidades e tipos de visão, e uma API padrão para ler e gravar modelos. Uma ferramenta pode afirmar que suporta a SysML v2 e ainda cobrir só parte disso, e as partes que ela deixa de fora podem ser justamente aquelas de que seu programa depende.

A especificação é grande, e toda ferramenta a implementa em etapas. Isso é normal. O que importa em uma avaliação é que você saiba quais etapas uma ferramenta já cumpriu, quais não, e se o fornecedor diz isso com clareza. As checagens abaixo valem para qualquer ferramenta SysML v2, qualquer que seja seu preço ou forma de implantação, e o modelo de teste dá a mesma entrada para cada candidata.

Para encontrar candidatas, comece pela lista de ferramentas SysML v2 mantida pelo OMG e pelo resumo de capacidades de ferramentas SysML v2 que o INCOSE e o OMG publicaram para apoiar a passagem da SysML v1. Ambos são pontos de partida: leia-os para obter nomes e depois teste cada ferramenta você mesmo.

O que checar

Cobertura da linguagem, e como as lacunas são documentadas

Peça uma declaração de cobertura: cada área da linguagem (pacotes, definições e usages, especialização e redefinição, multiplicidades, valores e unidades, restrições, estrutura, ações, estados, requisitos, casos de uso, casos de análise e de verificação, visões, metadados, variabilidade, individuals e time slices) com um nível para cada uma. Níveis úteis separam quatro casos:

  • a ferramenta analisa, checa e usa a construção;
  • ela faz isso com limites declarados;
  • ela mantém a construção exatamente como escrita, mas não lhe dá significado (ela sobrevive a uma ida e volta, mas nada a checa ou calcula);
  • ela não a aceita.

Um fornecedor que publica as lacunas conhecidas é mais fácil de levar em conta no planejamento do que um que só lista funcionalidades. Trate “suporta SysML v2” sem uma tabela de cobertura como desconhecido, e teste as construções que seus modelos usam.

Notação textual: edição e checagem

A notação textual é onde a SysML v2 mais difere da v1, e é onde as ferramentas mais diferem. Cheque:

  • Edição: realce de sintaxe, completação de nomes e palavras-chave, ir para a definição, renomear em todo o modelo, localizar e substituir.
  • Checagem durante a digitação: erros de sintaxe são o mínimo. Um verificador útil também resolve cada nome pelos imports, relata nomes duplicados e ambíguos, checa redefinições contra o que é herdado, compara dimensões de unidades e compara as direções de portas e flows entre conexões.
  • O texto é o modelo: depois de uma edição, todas as outras visões veem a mudança, ou o texto é um arquivo que a ferramenta importa de vez em quando?
  • Texto que a ferramenta não escreveu: carregue texto escrito à mão ou por outra ferramenta. Comentários, documentação e a disposição do texto devem sobreviver.

Visões gráficas, e sincronização entre texto e diagrama

Na SysML v2, uma visão é um elemento do modelo: ela declara o que expõe e filtra, e a ferramenta a renderiza. A biblioteca padrão define as visões General, Interconnection, Action Flow, State Transition, Sequence e Grid. Cheque quais delas a ferramenta desenha, em quais é possível editar e como ela trata o layout, que a especificação deixa a cargo da ferramenta.

O teste-chave é a sincronização nos dois sentidos. Renomeie uma parte no texto e olhe todos os diagramas que a mostram. Acrescente uma conexão em um diagrama e leia o texto que ela produziu. Depois mude os dois lados ao mesmo tempo, se duas pessoas puderem, e veja o que a ferramenta faz com o conflito.

Biblioteca padrão

Grande parte do significado da SysML v2 está em sua biblioteca padrão: valores escalares, o Sistema Internacional de Grandezas, as unidades SI e as usuais dos EUA, as definições de visão padrão e as bibliotecas do kernel da KerML. Uma ferramenta deve trazer a biblioteca, resolver nomes contra ela e avaliar com ela. Cheque se os tipos de grandeza ISQ e as unidades SI são resolvidos, se a biblioteca não pode ser alterada por acidente e qual versão da biblioteca a ferramenta usa.

A Systems Modeling API

A Systems Modeling API é a interface REST padrão para um repositório de modelos: projetos, branches, commits e elementos. Ela permite que ferramentas troquem modelos sem arquivos, e que seus próprios scripts leiam modelos. Uma ferramenta pode assumir dois papéis, e qualquer um deles pode ser somente leitura:

  • Cliente: a ferramenta puxa de outro repositório que oferece a API e envia para ele.
  • Servidor: a ferramenta oferece a API para que outras ferramentas leiam, e talvez gravem, seus modelos.

Pergunte qual papel, quais rotas, e se gravações, consultas, diffs e commits anteriores são oferecidos. Um servidor somente leitura ainda é útil para relatórios e para alimentar ferramentas de análise; ele não basta quando outra ferramenta precisa mudar o modelo.

Intercâmbio em JSON e ida e volta

Além do texto, os modelos passam entre ferramentas como JSON SysML v2: o formato de elementos da API, com um id para cada elemento. Os ids importam: o texto não carrega nenhum, então uma ferramenta que reimporta texto só consegue casar elementos pelo nome, enquanto o JSON mantém a identidade ao longo de um intercâmbio. Teste uma ida e volta: exporte da ferramenta A, importe na ferramenta B, exporte de novo e importe na A. Depois compare contagens de elementos, nomes, valores com unidades e relacionamentos, e leia como cada ferramenta relata o que descartou. Os tipos de elemento que uma ferramenta não suporta são onde as idas e voltas perdem dados.

Migração da SysML v1

Não existe tradução automática sem perdas da v1 para a v2: as linguagens diferem em estrutura, e os diagramas v1 carregam layout e estereótipos que não têm um único equivalente na v2. Pergunte como a ferramenta traz modelos v1 (normalmente XMI com o perfil SysML 1.x), para o que ela mapeia blocos, partes, portas, atividades, máquinas de estados e requisitos, e se produz um relatório do que não foi convertido. Experimente com um dos seus próprios modelos v1, não com o exemplo do fornecedor.

Colaboração e controle de versão

Modelos de sistemas são trabalho de equipe. Cheque se várias pessoas podem editar ao mesmo tempo e como os conflitos são mostrados e resolvidos, quais papéis existem (editar, revisar, visualizar), como funcionam o histórico e as linhas de base, e se você pode comparar duas versões elemento por elemento e como texto. Se sua organização guarda modelos em um repositório, cheque branches, merges e como o histórico de versões da própria ferramenta se relaciona com os commits do repositório.

Requisitos e verificação no modelo

A SysML v2 faz de um requisito uma restrição sobre um subject, com relacionamentos satisfy e verify com o projeto e com os casos de verificação. Cheque se a ferramenta mantém juntos o texto do requisito e a restrição, avalia a restrição contra os valores do modelo e monta uma matriz de verificação a partir dos vínculos verify. Cheque também o que a ferramenta guarda fora da linguagem: status dos requisitos, aprovações, resultados de testes e vínculos suspeitos depois de uma mudança. Isso não faz parte do texto SysML v2, então pergunte onde fica armazenado e se acompanha uma exportação.

Análise e avaliação com unidades

Todo valor em um modelo SysML v2 pode carregar uma unidade, e as expressões os combinam. Cheque se a ferramenta avalia expressões com unidades (uma massa total a partir de três massas de partes, em quilogramas), relata um erro de dimensão como erro e avalia as restrições dos requisitos contra o resultado. Depois cheque as funcionalidades de análise mais amplas de que você precisa: resolução paramétrica, orçamentos e totalizações, estudos de trade-off, simulação de fluxos de ações ou de máquinas de estados. Pergunte o que é avaliado a partir do modelo e o que exige dados extras específicos da ferramenta.

Implantação: nuvem ou auto-hospedada

Cheque onde o modelo fica e quem executa a ferramenta: um serviço hospedado, uma instalação desktop ou um servidor no seu próprio ambiente. Para dados controlados ou sujeitos a restrições de exportação, pergunte sobre auto-hospedagem, localização dos dados, opções de login e como as funcionalidades de IA, se houver, são configuradas ou desligadas.

Licenciamento e custo

Compare o custo total para sua equipe, não o preço de tabela por licença: leitores e revisores, uso acadêmico ou de avaliação, o custo de uma opção de API ou de servidor, e o que acontece com seus modelos se você parar de pagar. Cheque se uma exportação nos formatos padrão está disponível em todos os planos, para que seus modelos continuem sendo seus.

Treinamento

A SysML v2 é nova para a maioria dos engenheiros, inclusive para os fluentes na v1. Procure documentação de referência que cubra a notação como a ferramenta a suporta, exemplos práticos, um modelo de demonstração que você possa explorar e material guiado para as telas da própria ferramenta. Treinamento na linguagem e treinamento na ferramenta são necessidades diferentes; cheque se as duas estão cobertas.

Uma checklist de avaliação

Pontue cada candidata com as mesmas perguntas e a mesma entrada. “Demonstrado” significa que você viu funcionar no modelo de teste ou no seu próprio modelo, não em um slide.

ÁreaPergunta a fazerComo testar
Cobertura da linguagemExiste uma tabela de cobertura publicada com as lacunas conhecidas?Encontre nela as construções que seus modelos usam; carregue o modelo de teste
Notação textualO editor checa nomes, redefinições, unidades e direções durante a digitação?Carregue as duas sondas; cada uma deve relatar um problema
Visões gráficasQuais visões padrão são desenhadas e editáveis?Abra uma Visão de interconexão e uma Visão de transição de estados do modelo de teste
Sincronização entre texto e diagramaUma mudança em um lado aparece no outro na hora?Renomeie controller no texto; acrescente uma conexão em um diagrama e leia o texto
Biblioteca padrãoAs grandezas ISQ, as unidades SI e as visões padrão são resolvidas?O modelo de teste importa ISQ, SI e StandardViewDefinitions
Systems Modeling APICliente, servidor ou ambos? Somente leitura ou leitura e gravação?Leia os elementos do modelo de teste a partir de outra ferramenta ou com um script
Ida e volta em JSONOs ids dos elementos são mantidos? O que é descartado, e isso é relatado?Exporte, importe em uma segunda ferramenta, exporte de novo, compare
Migração da v1Existe um caminho de importação a partir da SysML v1, com relatório?Converta um dos seus próprios modelos v1
ColaboraçãoEdição simultânea, papéis, linhas de base, comparação?Duas pessoas editam o mesmo pacote; compare com uma linha de base
Requisitos e verificaçãoAs restrições são avaliadas e uma matriz de verificação é montada?Reduza o limite de massa para 20 kg e veja o requisito falhar
Análise com unidadesOs valores são avaliados com unidades? O que mais é calculado?Cheque se totalMass resulta em 23 kg
ImplantaçãoHospedada, desktop, auto-hospedada?Peça as opções por escrito, com a localização dos dados
Licenciamento e custoCusto total para autores, revisores e leitores; exportação em todos os planos?Calcule o preço para sua equipe, incluindo os revisores
TreinamentoReferência da linguagem, exemplos, guias da ferramenta?Peça a um usuário novo que modele o sistema de teste só com a documentação

Um modelo de teste para carregar em qualquer candidata

Este modelo é pequeno o bastante para ser digitado e ainda toca a maior parte do que uma avaliação precisa: imports da biblioteca padrão, definições e usages de partes com valores redefinidos e unidades, portas conjugadas, conexões e um binding, uma máquina de estados, uma ação com successions, dois requisitos com restrições, um satisfy, um caso de verificação e duas visões. Salve-o como pump-station.sysml e carregue-o em cada ferramenta.

O sistema é uma bomba d'água movida a energia solar: um painel alimenta um controlador, e o controlador aciona a bomba. A unidade não pode pesar mais de 25 kg, e a potência de pico do painel deve superar a potência nominal da bomba em pelo menos 20 %. Se a notação for nova para você, o tutorial de SysML v2 apresenta cada construção que este modelo usa.

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;
  }
}

O que uma ferramenta que suporta essas construções deve mostrar:

  • Nenhum erro e nenhum aviso. Uma ferramenta que relata problemas aqui ou não tem alguma construção ou lê a biblioteca padrão de outro jeito; pergunte qual dos dois.
  • totalMass resulta em 23 kg: 12 kg + 2 kg + 9 kg.
  • Os dois requisitos valem: 23 kg está dentro de 25 kg, e 400 W é mais que 1,2 × 300 W = 360 W.
  • unitConnections desenha o painel, o controlador e a bomba com suas portas, as duas conexões e a saída ligada à fronteira da unidade.
  • pumpStates desenha dois estados com uma transição inicial e duas transições disparadas por triggers.
  • Uma matriz de verificação lista PS-1 verificado por VC-1, e PS-2 sem caso de verificação.

Duas sondas para o verificador

Um verificador mostra seu valor nos erros. Carregue cada sonda separadamente; cada uma contém exatamente um problema.

A primeira dá a uma potência um valor em quilogramas. Uma ferramenta que checa dimensões relata um erro no valor:

package UnitProbe {
  private import ISQ::*;
  private import SI::*;

  part def Pump {
    attribute ratedPower : PowerValue;
  }

  part pump : Pump {
    attribute redefines ratedPower = 300 [kg];
  }
}

A segunda é analisada e resolvida sem problemas, mas seu requisito não vale: a unidade pesa 11 kg contra um limite de 10 kg. Uma ferramenta que avalia restrições de requisitos o relata; uma que só faz a análise sintática o aceita em silêncio.

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;
}

As duas sondas foram checadas com um motor de linguagem, como o modelo de teste: o modelo não dá problemas, e cada sonda dá exatamente o problema descrito.

Executar a avaliação

  1. Anote primeiro suas necessidades. Quais construções seus modelos usam, quais visões seus revisores leem, quais ferramentas precisam trocar modelos e onde os dados podem ficar. Dê peso às linhas da checklist de acordo com elas.
  2. Leia a declaração de cobertura e as lacunas conhecidas de cada fornecedor. Marque cada linha da checklist como declarada, não declarada ou não informada.
  3. Carregue o modelo de teste e as sondas em todas as candidatas. Registre o que cada ferramenta relata, palavra por palavra.
  4. Carregue um dos seus próprios modelos. Um modelo real encontra problemas que nenhum exemplo encontra: tamanho, nomenclatura, construções incomuns.
  5. Faça uma ida e volta com a ferramenta com que você mais troca modelos.
  6. Peça a um usuário novo que construa o modelo de teste só com a documentação da ferramenta, e cronometre.

Guarde as evidências (capturas de tela, arquivos exportados, as mensagens que cada ferramenta deu) junto com as pontuações. Um registro de decisão que mostra o que foi testado vale mais para um comitê de revisão do que uma matriz de funcionalidades copiada do material do fornecedor.

As respostas do Holarch à checklist

O Holarch é a ferramenta usada nas capturas de tela desta página, então aqui estão as respostas dele, cada uma com a página que a comprova. “Parcial” e “Ainda não” significam exatamente isso.

ÁreaNívelO Holarch hoje
Cobertura da linguagemParcialUma tabela publicada de todas as áreas com seu nível, limites e lacunas conhecidas. Variabilidade, individuals e time slices, palavras-chave definidas pelo usuário e metadados semânticos são checados e avaliados; arquivos .kerml ainda não são importados; representações textuais em SysML e KerML são checadas, outras linguagens são mantidas como texto. Cobertura da linguagem SysML v2
Notação textualSuportadoUm Editor que checa durante a digitação (sintaxe, nomes, tipagem, multiplicidades, unidades, direções, avaliação), com completação, ir para a definição, renomear e localizar e substituir. O Editor, Checagens
Visões gráficasParcialVisões General, Interconnection, Action Flow, State Transition, Sequence e Grid, todas editáveis. As Visões de sequência desenham mensagens entre linhas de vida e fragmentos combinados (alt, opt, loop e par). Visões SysML v2
Sincronização entre texto e diagramaSuportadoUm só modelo por trás do texto e de todas as visões; uma edição em um lado aparece no outro. Texto e visões ficam sincronizados
Biblioteca padrãoSuportadoCarregada e somente leitura, com as unidades ISQ, SI e as usuais dos EUA e as definições de visão padrão. A biblioteca padrão
Systems Modeling APIParcialComo cliente: puxa de um branch de um repositório que oferece a API e envia para ele. Como servidor: outras ferramentas leem o modelo atual e fazem commits em branches de solicitação de mudança, que um aprovador aplica no Holarch. Puxar e enviar, Systems Modeling API
Ida e volta em JSONParcialImportação e exportação de JSON SysML v2 com os ids dos elementos mantidos. Os tipos de elemento que o Holarch não interpreta são mantidos como importados e gravados de volta sem alterações na exportação. Intercâmbio de modelos SysML v2
Migração da v1ParcialImportação direta de um modelo SysML 1.x (.mdzip do Cameo ou do MagicDraw, ou XMI do Cameo, Enterprise Architect, Rhapsody ou Papyrus) em um projeto SysML v2, convertido em texto SysML v2 e checado, com um relatório do que foi convertido, aproximado ou deixado de fora e por quê. Os diagramas e seus layouts não são convertidos. Importar modelos SysML v1
ColaboraçãoSuportadoEdição ao vivo com mesclagem membro a membro no Editor, papéis, linhas de base que guardam o modelo e comparação por elemento e pelo texto do pacote. Colaboração, Linhas de base
Requisitos e verificaçãoSuportadoRestrições de requisitos avaliadas contra o modelo, a RVTM e a Central de testes montadas a partir dos vínculos verify, aprovações, TBD/TBR e vínculos a revisar. Requisitos e verificação
Análise com unidadesParcialAvaliação com unidades, Visões paramétricas que resolvem uma incógnita por restrição, orçamentos, estudos de trade-off e simulação de fluxos de ações e de máquinas de estados. Um caso de análise só é avaliado quando todas as entradas têm valor. Avaliação, unidades e análise
ImplantaçãoSuportadoUm aplicativo web hospedado, e implantações auto-hospedadas no seu próprio ambiente sob solicitação. Segurança, Contato
Licenciamento e custoSuportadoUm plano Free para estudantes, professores, projetos pessoais e avaliação individual; empresas podem experimentar o plano Individual de graça por 1 mês; planos pagos para uso comercial; revisores e leitores gratuitos em todos os planos. Preços
TreinamentoParcialUma referência na Docs para cada página SysML v2, um tutorial passo a passo, a demonstração Hybrid Car, nove tutoriais SysML v2 guiados dentro do aplicativo e uma série de tutoriais em vídeo de SysML v2 que constrói o modelo Hybrid Car. As trilhas de treinamento em vídeo cobrem projetos LML. Primeiros passos, Tutoriais de SysML v2, Tutorial de SysML v2

Experimente no Holarch

  1. Salve o modelo de teste como pump-station.sysml.
  2. Abra Modelo → Importar e exportar, escolha Em um projeto SysML v2 novo e solte o arquivo. Veja importar arquivos em um projeto novo.
  3. Abra Modelo → Editor. A linha de status diz “Nenhum problema”, e cada pacote é um documento.
  4. Abra a lista Diagramas e clique em unitConnections ou pumpStates.
  5. Abra Verificação → RVTM para ver os requisitos com o caso que os verifica.
O modelo de teste no Editor, sem problemas.
A visão unitConnections: portas conjugadas, duas conexões e um binding.
A RVTM, montada a partir do vínculo verify do modelo.

Para onde ir a seguir