What requirements would you like considered as OGC identifies a solution for a model repository?

[ghobona]

OGC is looking into options for a technology solution for storing and accessing conceptual models that are defined in OGC Standards.

Please let us know what requirements you would like considered as we identify a suitable model repository.

[sgrellet]

A versionned controlled repo where anyone can fetch the versions of the model of any standard defined by OGC (?XMI?)

[jechterhoff]

The repository solution should also support collaborative editing / development of a model.

[KathiSchleidt]

As many of us utilize UML, would be great if this would be supported. +1 on version control, anyone can access (read access), collaborative editing

[ghobona]

The solution should also support schema validation of all XML documents (instances) that are provided in the repository. Ideally, the validation would be performed before a Standards document is submitted to the TC for approval.

[jechterhoff]

@ghobona Isn't XML Schema validation of XML instance documents a different use case? ... one that could relatively simply be done with tools like oXygen XML editor (using a folder with XML files (schemas and/or instances) as validation input)?

[KathiSchleidt]

Think we're missing a meta-question here - how does OGC expect models to be represented? At present, OGC seems to support a very eclectic mix including all of the following:

• RDF/OWL
• UML
• Schemas (XSD, JSON Schema)
• NapkinML

Following a conceptual philosophy, I'd expect a split between:

• data models
• serialization options (e.g. XML (XSD), JSON (JSON Schema))

Validation is essential, but as long as we work with mainstream technologies (e.g. XML, JSON), think that aspect can be devolved to common tools (do JSON validators now exist?)

More important to my view would be how we transition from the conceptual models to various serialization options. If we have a common model repository, it would be most welcome to have integrated tools to transform the model to a schema (e.g. a stable ShapeChange configuration)

[jechterhoff]

@KathiSchleidt: Good points.

Re Validation: Validation, i.e. consistency checks, of conceptual models would be very useful indeed. With a reasoner, you can check if an ontology is consistent in itself. That an ontology adheres to a certain shape could be checked with SHACL, afaics (the actual SHACL definitions would have to be created first). UML tools can have model validation as well (e.g. Enterprise Architect). Validation of physical models, i.e. whatever is derived from the conceptual model for certain target technologies (e.g. XML, JSON) can be done with existing tools (yes, JSON Schema validators are out there; for testing purposes, I've used https://www.jsonschemavalidator.net/ in some projects).

When we talk about validation, we need to keep in mind that validation is typically not perfect, and may be lacking certain checks (e.g. co-constraints on XML encoded data not covered by the XML Schema but potentially via additional Schematron). However, validation done right gets you a long way regarding the quality of your models and data sets.

In fact, this shows that we have three categories of 'things' that can be validated: conceptual models, physical models, and actual data sets. Differentiation between the three can help defining context and scope of work.

Re Modeling Workflows: Having automated pipelines which generate/update physical model artifacts (e.g. XML and JSON Schemas) whenever a new version of the model is achieved would be very useful, as well. Who decides when that new version is actually ready is TBD. Would each and every model update that is pushed to the repository count as new version? What does that mean in case of a model hosted via EA Cloud Server? ...

[ghobona]

@jechterhoff @KathiSchleidt I take your point, that we need to distinguish between the 'things' that can be validated: conceptual models, physical models, and actual datasets. My suggestion above was more about validating datasets against a schema, so I agree - the requirement is probably out of scope.

[KathiSchleidt]

@ghobona I DO think validation is a VERY valid requirement, also fits into the conceptual modelling bubble. Just think it deserves its own issue, or is mostly covered by available SW as long as we provide well defined schemas (I'm quite relieved to hear that JSON validation is becoming available!) Where we may need additional tooling pertains to the trickier constraints we use Schematron on - is there a similar development for JSON? Making an online Schematron tool available could be worth investigating, as executing these scripts can be trickier (at least XMLSpy needs a Plugin)

@jechterhoff I'm intrigued by your statements on model validation. However, I'm still trying to understand the context in which we could utilize such functionality. At an abstract level, I totally get how SHACL and Ontologies fit together, but reality keeps pushing me back from this ideal world to UML based reality - what I can't get my brain around is how EA can validate such a model.

Where I do see potential pertains to profiles of existing models. Usually the consistency should come automatically through class derivation, but I do see a requirement for cases where the model has been creatively transposed (e.g., the SensorThings API take on O&M). I've now created #3 for investigating options for mapping between models

[jechterhoff]

@KathiSchleidt Typically I did not need to use EA validation of UML models, since the ShapeChange parsing process of the model already checks a lot of requirements for ISO 19109 application schemas. The basic EA UML validation only checks certain general UML rules, afaics. Nevertheless, it might be worth investigating the EA model validation functionality further, specifically regarding its capabilities with domain-specific requirements.

[ghobona]

OGC has stood up a Sparx Systems Pro Cloud Server at https://umltool.ogc.org

EAP files of approved and published standards can also be deployed at https://uml.opengis.net

Closing this Issue now that the repository has been set up.