Glossary · OOML

Filter terms43 of 43 terms

abstract: A class property. When true, the class cannot be instantiated directly — it may only be extended. Abstract classes may still define attributes and be the target of object and class attributes.
Artefact: A separately identifiable, independently versioned unit of an OOML model. There are two kinds: classes and global attributes. Each carries its own fully qualified name and is self-describing — its identity lives inside the document rather than in surrounding infrastructure.
as: The renaming key within a use entry. Replaces an inherited attribute's exposed name for this class and every subclass beneath it — non-additive: the old name becomes unreachable, not aliased alongside the new one. Always a MAJOR (breaking) change.
Attribute: A named, typed position within a class. Every attribute has a kind — primitive, object, class, enum, list, set, map, or attribute (a reference to a global attribute) — and associated type constraints. The JSON key in the attributes object is the attribute identifier (camelCase), distinct from the human-readable name property.
attribute (kind): An attribute that reuses a standalone global attribute rather than declaring its own type inline. The kind, type and type-specific constraints come from the referenced global attribute; the importing class supplies the local name and its own required/nullable/static markers.
Attribute Identifier: The camelCase JSON key used within a class's attributes object, e.g. employeeNumber. Locally scoped to the declaring class. Distinct from the human-readable name property and from any global attribute FQN the attribute may reference.
cascade: A metadata entry control property. When true, the entry value propagates to subclasses that do not set their own value for that entry. Subclasses may override a cascaded value unless final: true is also set. Incompatible with local: true.
Class: The central construct of OOML. A versioned, named, uniquely identifiable collection of attributes. Each class is an independent artefact with its own FQN and semantic version. The class — not any grouping layer — is the unit of versioning in OOML. Class names are PascalCase.
class (kind): An attribute whose value is a reference to a class itself — the named class or any of its subtypes — a type-tag, not a record. Contrast with object (instance reference). Self-referential class-kind edges are exempt from cycle detection.
Collection kinds (list, set, map): Attributes holding multiple values. A list is ordered and permits duplicates; a set does not permit duplicates; a map holds keyed entries. Element shape is given by valueKind and valueType rather than by type; map keys may not be nested.
Dependency Graph: A directed acyclic graph (DAG) where nodes are individual versioned class and global attribute artefacts. There is no declared dependencies property — every edge is derived directly from a class's own body: extends, attribute type properties, valueType/keyType, and metadata keys. use introduces no edge of its own — it only adjusts an attribute already reachable via an existing edge. Acyclicity is only required across extends, attribute-import, and metadata edges — self-referential object, class, and enum edges are exempt, since they record identity, not structural embedding.
enum (kind): An attribute whose value is a reference to a class that is a strict subtype of the named root class — the root class itself is not a valid value. This is the enumerative selection pattern in OOML.
Enum Root: An ordinary class whose subtypes (excluding itself) serve as the valid values of an enum attribute. Enum members are real OOML classes — they can carry attributes and be independently versioned. There is no dedicated enum artefact type.
extends: A class property declaring one or more superclasses. Accepts a single FQN range string or an array of them. OOML supports multiple inheritance. Order is significant: determines MRO (depth-first, left-to-right, C3 linearisation).
final: On a class: cannot be extended. On an attribute or metadata entry: subclasses cannot shadow or further constrain it, and override.value does not apply. Renaming via use.as is still permitted — it does not change the attribute's structural contract. Combined with static: true and value, the closest OOML equivalent to a traditional constant.
FQN (Fully Qualified Name): The globally unique identity of a class or global attribute. Format: namespace/Name@version, e.g. com.example.hr/Employee@1.2.0 (class, PascalCase) or com.example.finance/salary@1.0.0 (global attribute, camelCase). Owned attributes extend the class FQN: com.example.hr/Employee@1.2.0#employeeNumber.
Global Attribute: A first-class, independently versioned OOML artefact defining a reusable typed semantic contract for an attribute, independent of any class. Named in camelCase — deliberately distinct from a class's PascalCase, since it is never instantiated or extended. Appropriate for domain concepts that are genuinely global, such as monetaryAmount or geoCoordinate.
local: A control property on attributes and metadata entries. When true, the attribute or entry is scoped to the declaring class and is not inherited by subclasses. It remains fully visible to consumers of the declaring class.
Metadata: Structured, typed, versioned annotations attached to a class or global attribute. Metadata schemas are ordinary OOML classes. Each entry in the metadata object maps a metadata schema FQN range to a typed value object with optional control properties (cascade, final, local). Each metadata key also contributes an edge to the dependency graph.
Metadata profile: A metadata model published for a shared purpose — governance, provenance, ontology generation, external mappings. A useful working term for how communities and tools extend OOML through typed metadata. Not currently normative vocabulary in the specification.
Model metadata: Structured, typed information describing a model element rather than the instances it defines: ownership, provenance, governance state, external mappings, generator instructions. Distinct from domain data. Attributes describe the domain; model metadata describes the model.
MRO (Method Resolution Order): The deterministic linearisation of a class's ancestor list used to compute its full attribute set. OOML uses a depth-first, left-to-right traversal consistent with C3 linearisation. Earlier positions in the MRO take precedence for local-name access.
Namespace: A reverse-domain organisational scope in dot notation, e.g. com.example.hr. All segments are lowercase. Governs who may publish class and global attribute names within it. There is no versioning at the namespace level — versioning applies to individual classes and global attributes.
nested (kind): An ad hoc, locally-scoped structure with no independent identity, described inline via its own attributes property rather than a type reference. Sub-attributes may nest to any depth. Introduces no edge of its own in the dependency graph — dependencies from its sub-attributes attach to the nearest containing class or global attribute.
nullable: An attribute property. When true, the value of this attribute MAY be JSON null when present. Defaults to false. Must not be combined with static: true.
object (kind): An attribute whose value is a reference to an instance of a named class — or an instance of any of its subtypes — identified by that instance's own identity. Contrast with class (reference to the class itself). Self-referential object-kind edges are exempt from cycle detection, since they record identity, not structural embedding.
OOML: Object-Oriented Modelling Language. A JSON-based schema-definition language for describing data models that borrows object-oriented abstractions — classes, inheritance, namespacing, type safety — and applies a class-level versioning and distribution model borrowed from modern software ecosystems.
override: The overriding key within a use entry. Adjusts a limited, fixed set of properties on an inherited attribute (name, description, and narrowing-only bounds like maxLength, pattern, required, or a static, non-final attribute's value) without changing its kind or type. Every override except name/description is a MAJOR change.
primitive (kind): An attribute holding a scalar value of one of OOML's built-in primitive types. Supports constraints including minLength, maxLength, pattern, minimum, maximum, precision, and scale, depending on the type.
Primitive Types: OOML's built-in scalar types: boolean; int8, int16, int32, int64; uint8, uint16, uint32, uint64; float32, float64; decimal; string; date; time; datetime; duration; uuid; uri; binary; any. Implementations must support all of them.
Rename: Replacing an inherited attribute's exposed name via use.as. Non-additive: the old name is no longer reachable from this class or its subclasses, distinguishing it from the aliasing OOML previously had, where the old name stayed available alongside the new one.
required: An attribute property. When true, instances of the class must carry a non-null value for this attribute. Defaults to false. Must not be combined with static: true.
Resolution context: The implementation-defined mechanism by which version ranges are resolved to specific artefact versions. The specification defines the structure of dependencies but deliberately leaves how they are fetched and selected to distribution systems and tooling built on OOML.
self: A reserved authoring token used in a type position to mean "the class in which this attribute is declared". Expanded to the class's own FQN range before distribution. Resolves to the declaring class, not the inheriting class.
Semantic Versioning: OOML versions use MAJOR.MINOR.TRIVIAL (semver). MAJOR: breaking changes. MINOR: non-breaking data- or query-significant additions. TRIVIAL: documentation and metadata edits only. MAJOR=0 indicates initial development; any change may be breaking.
static: An attribute property. When true, the value belongs to the class itself, not to instances. A static + final + value combination is the closest OOML equivalent to a constant. Cannot be combined with required: true or nullable: true.
Sub-attribute: An attribute declared within the attributes property of a nested-kind attribute. Has no identity of its own beyond its position within its containing artefact — no FQN, no independent dependency-graph node. May be addressed for documentation purposes via a dotted path, e.g. #homeAddress.streetName.
Subclass: A class that names one or more classes in its extends array, thereby inheriting their attributes transitively. A subclass cannot re-declare or override inherited non-local attributes.
Subtype: A class that has one or more ancestor classes anywhere in the inheritance chain (transitive closure of extends). Subtypes are substitutable wherever their supertypes are expected (Liskov Substitution Principle).
Superclass: A class whose attributes and type identity are inherited by another class (its subclass) via extends. OOML supports multiple superclasses per class.
Supertype: A class that appears anywhere in the MRO of another class (excluding the class itself). Because OOML supports multi-inheritance, the type hierarchy is a DAG rather than a tree.
use: A class property replacing OOML's earlier aliasing mechanism. Maps a bare attribute identifier (when unambiguous) or an FQN range (to disambiguate a name collision) to an entry containing as (rename), override (narrow eligible properties), or both. At any point in the hierarchy, an attribute has exactly one current name — never several.
Version Range: A semver-compatible constraint used wherever an FQN range appears: extends, attribute type/valueType/keyType, use FQN-range keys, and metadata keys. Syntax follows npm conventions: exact (1.2.3), caret (^1.2.3 — same major), tilde (~1.2.3 — same major.minor), comparison range (>=1.0.0 <2.0.0), or wildcard (*).