Holarch

Für Entwickler

Holarch Language Engine

Eine Language Engine für SysML v2 und KerML, zur Lizenzierung verfügbar.

Die Engine hinter den SysML-v2-Projekten von Holarch, für Ihr eigenes Produkt. Sie parst, löst auf, prüft und wertet SysML-v2- und KerML-Text aus und läuft im Browser als WebAssembly oder auf Ihrem Server.

Die Holarch Language Engine bei der Arbeit: Ein Einheitenfehler erscheint, während ein Wert getippt wird, und verschwindet, wenn er behoben ist, Gehe zu Definition springt zu einer Part-Definition in einem anderen Paket, und ein Modell mit 250.000 Zeilen wird über die Befehlszeile geprüft, mit dem Code der Diagnose und der benötigten Zeit

Für wen sie gedacht ist

Teams, die SysML-v2-Text in ihrem eigenen Produkt wollen, ohne eine Sprachimplementierung zu schreiben und zu pflegen.

Werkzeughersteller

SysML-v2-Bearbeitung, -Prüfung und -Import in ein Modellierungs-, Diagramm- oder Architekturwerkzeug einbauen.

PLM-, Anforderungs- und Simulationsprodukte

SysML-v2-Modelle lesen, Anforderungen und Werte mit Einheiten verfolgen und Modelle mit anderen Werkzeugen austauschen.

Interne Teams für Engineering-Werkzeuge

Modelle in Review-Pipelines prüfen, Berichte erzeugen und Ingenieuren einen SysML-v2-Editor in unternehmensinternen Werkzeugen geben.

Was sie tut

Eine Engine für den ganzen Weg vom Text zum geprüften Modell, mit JSON als Ein- und Ausgabe.

Parsen

Textuelle Notation von SysML v2 und KerML, mit Fehlerbehandlung: Ein Fehler verdeckt nicht den Rest der Datei. Die Standardbibliothek wird mit der Engine geladen.

Auflösen

Namen, Importe, Aliase, Spezialisierung, Typisierung und Redefinition über Pakete und Dateien hinweg, mit Hover, Gehe zu Definition, Vervollständigung und Umbenennen.

Prüfen

135 Diagnosecodes, jeder mit Schweregrad, genauem Bereich, Meldung und einem Korrekturvorschlag, den Ihr Editor als Schnellkorrektur anbieten kann.

Auswerten

Ausdrücke mit Einheiten und Größen, etwa body + 4 * 12 [kg] zu 348 [kg], sowie Anforderungs-Constraints und Verifikationsfälle. Anforderungsschwellen und die Ziele, die sie anstreben, werden aus dem Modell gelesen.

Beim Tippen neu analysieren

Dokumentsitzungen parsen nur den geänderten Teil neu und senden Token-Deltas, sodass Editoren auch bei großen Modellen reaktionsschnell bleiben.

Text bearbeiten, ohne die Formatierung zu verlieren

Änderungen aus einem Diagramm oder Formular werden in den Text zurückgeschrieben. Unveränderter Text, Kommentare und Layout bleiben genau so, wie der Benutzer sie geschrieben hat.

Vergleichen, zusammenführen und rebasen

Zwei Versionen eines Modells als Liste von Änderungen vergleichen, sie anwenden und eine Textbearbeitung auf neuere Modelländerungen rebasen.

Varianten

Variationspunkte, Varianten und Konfigurationen werden geprüft, und jede Kombination von Varianten kann aufgelistet und gegen die Constraints des Modells bewertet werden.

Simulieren (Add-on)

Action-Abläufe und Zustandsautomaten über simulierte Zeit ausführen, als Einzelläufe, Schritt für Schritt mit Eingaben aus Ihrem Produkt oder als Monte-Carlo-Studien. Derselbe Seed liefert im Browser und auf dem Server dasselbe Ergebnis.

JSON-Austausch

SysML-v2-JSON importieren und exportieren und das Modell als einfache Datensätze mit stabilen IDs lesen. Text kann die ID jedes Elements tragen, sodass ein bearbeiteter, zurückgelesener Text die Identität jedes Elements über Umbenennungen und Verschiebungen hinweg behält.

In Holarch bewährt

Dieselbe Engine betreibt jedes SysML-v2-Projekt in Holarch: den Editor, die Ansichten und die Lebenszyklusseiten.

Add-ons

Die Engine prüft, analysiert und bearbeitet Modelle eigenständig. Drei Add-ons erweitern sie, jedes separat lizenziert und über Ihr Lizenz-Token freigeschaltet, ohne Neubau und ohne Codeänderung.

Simulation

Action-Abläufe und Zustandsautomaten über simulierte Zeit ausführen: Einzelläufe, Schritt für Schritt mit Eingaben aus Ihrem Produkt oder Monte-Carlo-Studien. Derselbe Seed liefert im Browser und auf dem Server dasselbe Ergebnis. Modelle mit Simulationsannotationen lassen sich auch ohne das Add-on prüfen.

Migration von SysML v1 zu SysML v2

Ein SysML-v1-Modell in geprüften SysML-v2-Text umwandeln, mit einem Bericht zu jedem Element: umgewandelt, angenähert oder verworfen. So funktioniert das Migrations-Add-on.

Servernutzung

Die Engine außerhalb einer Browserseite ausführen: Node.js, Deno, Serverless-Funktionen oder die Python-Erweiterung. Modelle in Build-Pipelines prüfen, stapelweise umwandeln oder Anfragen aus Ihrem eigenen Dienst beantworten.

Add-on: Migration von SysML v1 zu SysML v2

Das Migrations-Add-on wandelt ein SysML-v1-Modell in SysML-v2-Text um, auf Grundlage der Transformation von SysML v1 zu SysML v2 in der OMG-Spezifikation SysML 2.0. Es ist der Konverter hinter dem SysML-v1-Import von Holarch und wird getrennt von der Engine lizenziert.

  • Eingabe: ein SysML-v1-Modell als JSON, in einer neutralen Form, die die API-Referenz dokumentiert. Ihr Produkt liest die XMI-Datei (aus Cameo oder MagicDraw, Enterprise Architect, Rhapsody oder Papyrus) und sendet das Modell; die Engine liest kein XML und keine Dateien.
  • Ausgabe: SysML-v2-Text, die Prüfung dieses Texts durch die Engine und ein Bericht, der jedes Element als umgewandelt, angenähert oder verworfen auflistet, mit einem stabilen Grundcode und dem SysML-v2-Namen, zu dem es wurde.
  • Wiederholbar: Dasselbe Modell wird jedes Mal in denselben Text umgewandelt.
  • Begrenzt: Modelle mit bis zu 250.000 Elementen und 8 MiB Text; ein größeres Modell erhält eine Fehlerantwort, nie ein Hängen.

Die Anfrage ist v1_convert in der API-Referenz. Ohne das Add-on beantwortet die Engine sie mit feature-not-licensed, und jede andere Anfrage funktioniert wie gewohnt.

Eine Anfrage und ihre Antwort

// Request (the model shortened)
{ "op": "v1_convert",
  "model": { "format": "holarch-xmi-model", … } }

// Answer (shortened)
{ "text": "package 'Rover Model' { … }",
  "diagnostics": [],
  "report": {
    "summary": { "elements": 31, "converted": 27,
                 "approximated": 2, "dropped": 2 },
    "items": [ { "kind": "Association",
                 "status": "dropped",
                 "reason": "association" }, … ] } }

Ein kleines Testmodell, von der Engine umgewandelt: 31 Elemente, keine Diagnosen im umgewandelten Text.

So läuft sie

Im Browser ist die Engine ein WebAssembly-Modul in einem Web Worker, sodass die Analyse die Seite nie blockiert. Eine kleine JavaScript-Integrationsschicht sendet Anfragen und gibt Antworten als Promises zurück. Ein Server-Build für Node.js oder Python ist auf Anfrage erhältlich.

How the engine fits into a browser applicationYour application calls the JavaScript integration layer with JSON requests. The layer passes them to a Web Worker that runs the WebAssembly engine with the standard library loaded, and returns JSON answers. The engine has no network or file access. Your application editor, views, pipeline JavaScript integration layer requests as promises WEB WORKER Holarch Language Engine WebAssembly, no network or file access Standard library JSON

Eine Anfrage und ihre Antwort

// Request
{ "op": "analyze",
  "text": "package P { part a : Engine; part b }" }

// Answer (tokens left out)
{ "diagnostics": [
    { "code": "syntax.expected-token",
      "args": { "expected": ";", "found": "}" },
      "range": { "from": 35, "to": 35 },
      "severity": "error" },
    { "code": "name.unresolved",
      "args": { "name": "Engine" },
      "field": "typedBy",
      "range": { "from": 21, "to": 27 },
      "severity": "error" } ] }

Eine echte Anfrage und Antwort aus dem Integrationsleitfaden der Engine: ein Syntaxfehler und ein Name, der sich nicht auflösen lässt, jeweils mit einem stabilen Code und dem genauen Bereich im Text.

Leistung

Gemessen an einem generierten Modell mit 10.000 Zeilen:

  • 150 ms, um das ganze Modell mit 10.000 Zeilen von Grund auf zu analysieren (Parsen, Auflösen und Prüfen); 215 ms als WebAssembly in Safari.
  • 1,3 bis 6,8 ms, um das Modell mit 10.000 Zeilen nach einer Bearbeitung erneut zu prüfen (95. Perzentil); 3 bis 4 ms als WebAssembly in Safari.
  • Engine-Basis mit geladener Standardbibliothek: 17 MiB. Eine Analyse des ganzen Modells fügt etwa 29 MiB pro 10.000 Zeilen hinzu, eine ganze Bearbeitungssitzung etwa 33 MiB pro 10.000 Zeilen.
  • Etwa 0,74 MB WebAssembly, komprimiert.

Getestet mit generierten Modellen bis zu 250.000 Zeilen: Ergebnisse bei jeder Größe.

Ihre Zahlen hängen vom Modell und vom Computer ab. Mit der Evaluierung können Sie an Ihren eigenen Modellen messen.

Sicherheit

  • Kein Netzwerk- oder Dateizugriff. Das WebAssembly-Modul importiert nichts von der Seite: Es liest den Text und die Datensätze, die Sie übergeben, und gibt JSON zurück.
  • Eingabegrenzen. Eingabegröße, Zeilenlänge, Verschachtelung und Ausdruckstiefe sind begrenzt, sodass eine feindselige Datei weder den Speicher noch den Stack erschöpfen kann.
  • Gefuzzt. Die Einstiegspunkte für Anfragen, Lexer und Parser, der Simulator und die Sprachoperationen werden mit Fuzzing getestet.
  • Isoliert. Im Browser läuft sie in einem eigenen Worker. Ein Fehler stoppt nur diesen Worker, und Ihre Seite startet ihn neu.

Was Sie erhalten

  • Die Engine: der WebAssembly-Build mit der Standardbibliothek.
  • Die JavaScript-Integrationsschicht: der Worker und ein Client für Ihre Seite.
  • Entwicklerdokumentation: ein Integrationsleitfaden, die Referenz jeder Anfrage mit echten Anfragen und Antworten, die Liste der Diagnosecodes und lauffähige Beispiele (eine minimale Seite, ein Editor, ein Modellbrowser, Node.js und Python).
  • Updates für die Laufzeit der Lizenz.
  • Support per E-Mail vom Team, das sie entwickelt.

Lizenzierung

  • Jahreslizenz für jeweils ein Jahr, bepreist nach der Anzahl monatlich aktiver Benutzer der Funktionen, die die Engine in Ihrem Produkt antreibt.
  • Kostenlose 60-tägige Evaluierung auf Ihrem eigenen Computer, mit Dokumentation und Beispielen.
  • Akademische und Forschungslizenzen für Hochschulen und Forschungsgruppen.
  • Unternehmensnutzung auf Anfrage: mehrere Produkte oder große Benutzerzahlen.
  • Add-ons: Simulation, Migration von SysML v1 zu SysML v2 und Servernutzung, jeweils separat lizenziert.

Erzählen Sie uns von Ihrem Produkt und den erwarteten Benutzern, und wir senden ein Angebot.

Sprachunterstützung

Die aktuelle Version ist Holarch Language Engine 2.1.2. Sie basiert auf der OMG-Spezifikation SysML v2 und unterstützt eine Teilmenge von SysML v2 und KerML. Abdeckung der SysML-v2-Sprache listet die unterstützten Konstrukte und die bekannten Lücken auf, wie sie in Holarch funktionieren. Die Evaluierungsdokumentation enthält dieselbe Liste für die Engine.

Wie die Engine im Vergleich mit der Pilotimplementierung der OMG an den offiziellen Beispielmodellen abschneidet und wie sie mit beschädigtem Text und großen Modellen umgeht, Fehlschläge eingeschlossen: Testergebnisse der Language Engine.

Testen Sie die Engine an Ihren eigenen Modellen.

Die Evaluierung ist 60 Tage lang kostenlos.