Concepts

This document describes the concepts that are used in these pages.

Meta-Levels

Meta-level is the separation of data and type descriptions into categories based on rules they adhere to.

metalevels

Data

Data is any set of information that can be inspected at conceptual level.

Examples of documents of data:

  • index.html, index.xhtml, snowman.svg, data.xml
  • export.json
  • index.md, intro.md
  • code.cs
  • config.ini
  • export.csv
  • car_data.lex
  • forum_messages.sql
  • streets.rdf
  • export.bin

Schema

Schema is a document that gives a conceptual description, but also a formal one, when one follows ruleset of a meta-model.

For example, xhtml-schema governs xml containers to have html-like content. The xhtml-schema document itself follows rules of the meta-model xsd (xml schema definition).

Schema is nearly always tied to its specific container format, but there are exceptions such as, OPC-UA Nodeset which can be in binary and in XML. The are the exact same schema descriptions, and have the same meta-model, but are in two different containers.

Other times schemas are written to multiple meta-models, like Mimosa to OPC and SQL. Their respective data should be conceptually compatible and convertible.

Examples of schema documents:

  • xhtml-schema, svg-schema
  • Employee Record Json schema
  • SQL Table Create script for Mimosa osa-eai SQL Tables, Mimosa XML Schema, Mimosa OPC-UA Information Model
  • Opc.Ua.Adi.uanodes, Opc.Ua.Adi.NodeSet.xml
  • forum_tables.sql
  • cars_types.lex

Meta-model

Meta-model describes rules for schemas. It describes the vocabulary for describing building blocks of information.

Examples of meta-models:

  • XML Schema description (xsd)
  • JSON Schema description
  • .NET Common Type System (cts)
  • Java Type System
  • OPC-UA Type Definition
  • SQL Table Notation
  • Lex/Lxb foreknowledge file

Sometimes meta-model has rules of their own that they adhere to, a schema, which then is based on the same meta-model. This is a cyclic ruleset. For instance, C# process: an object is an instance of a class, a class is instance of Type, and Type is instance of Type.

In order to process cyclic information like this, the algorithms need to be able to handle complex cyclicity. Lexical Sdk has service engine that is specifically designed to address cyclicity cross meta-levels. It can construct request descriptions with cycles, handle them in correct sequence, and output a similarly cyclic result objects.

Container Format

Container Format is the way how bits are put together to hold content. It can be a file or multiple files, a database, or object instances in a process.

Examples of a container formats:

  • XML document(s) as files.
  • XML as DOM nodes in memory.
  • JSON document(s)
  • Markdown document(s)
  • A Java/.NET/c++ process with in-memory instances
  • Ini document(s)
  • CSV document(s)
  • Lex document(s)
  • SQL Database, .sql export(s)
  • A cloud of no-sql database nodes.
  • RDF Database, .rdf document(s)
  • Binary file serialization (.bin)

A domain can have multiple container formats. For example, XML domain has at least three container formats: .xml file, binary xml, and DOM node structure inside of a process.

Some container formats adhere to exactly one schema description, and others can to multiple schemas. For instance, an xhtml document can include many schemas such as: xhtml, svg.

In the past it used to be common that containers were of a proprietary binary format with completely implicit schemas, but nowadays it is more typical that applications use some common container type and have rules explicitly written out, at least somewhere.

The division of how data and schemas are held together is very different in different container formats.

containers

containers

containers

Domain

Domain is roof term that is used to compound one set of meta-model, schemas and container formats. For example, "XML Domain has xsd, xml schemas and .xml+DOM container formats."

containers

Binding

Binding is a library of functions that access a container. Binding abstraction model addresses the issues of broad variance in container formats. Container's meta-model is embedded into a binding by necessity. Binding can be constructed at run-time or at compile-time.

binding