Relationships Assembly

LL first meta-model – ISA\LL\Elements\Relationships

Parent

Data

Elements
Aliases	Primitive
Information	This assembly put together the elementary elements shared by the Meta-model and the model. In particular, it is the place where all primitive types are defined. Basically, an Element is neither a Classifier nor an Object, but it is a Type. One can say that using Metaclasses is like doing Chemistry, and that these Elements are the elementary elements as like atoms are to Physics.

Assembly data

Edition
	Version	1
	Country	None.
	Language	None.
	Tirage	1
Dependencies	None.
Inhibit all invariants	False.
Scope	Ideas.

Diagram

Classes

Array

Information

An array of Type.

The Array Element is the way maximum multiplicity greater than 1 is implemented for individual Type.

Property

Contained type

The type on the items contained by the Array.

Constructors

Array (Initial capacity: Natural* [0..1] = 64, Contained type: ISA\LL\Metamodel\AbstractDataType [0..1])	Build an array of a given capacity for a given type. The array is initialized to point to the universal type instance ISA\LL\model\Root.
Array (Initializer: String[0..∞])	Build an array from a given list items by inferring their Type and values.

Destructor

Delete()

Decrements references count on all the objects contained by the array, and then delete the array.

Array

Element

Information

An Element is the raw elementary building blocks in LL. It is the root all Primitive types introduced in LL for efficiency reasons.
This is why they do not follow the Object Orientation paradigm of ISA. However, while not Objects, the Elements are accessible and manipulated in a similar way in LL. As using Metaclasses is like using molecules in chemistry, Elements are the elementary elements as atoms are to physic.

Element

Identifier

Information

The Identifier type is one of the most important one. It provides the features and properties expected by an Object Identifier (OID) and coming from the OO Identity axiom. This in an architecture fully distributed and scalable. This features and properties are:

Identify an object all long its technical life cycle (in memory, over the network, on stable storage).
This suppose to have versioning management including historical capabilities.
Designated it in all situations (textual link, binary address, on disk, over the network, etc.).
Help to scale in being both performing (thru technique like direct reference, partitioning or cursor) and small (this mean 64 bit memory foot print).
Help to secure in being attached to logical partitioning (organisation, universe).
Allows to search and retrieve an Object in an uniform way.
Clean: This mean not contaminated in its core by numerous peripheral information like localization or external identifiers.

The Identifier type fulfill these requirements:

Identify is the first feature. It is the Object id property role. While this is the final ID to identify an Object on any Node or state, it is complemented by its main Class, the one that never changes all long it's life: In other words, its Nature. The nature is also a property named Nature classifier id. This ID is the Object id of the Classifier the object belongs to. The algorithm to manage Object id depends of the Type.
Versioning is supported thru the Object version id property and the New version query. The algorithm to manage Object version id also depends of the Type.
Designation in memory is done just by its physical address. Getting the full Identifier is a lazy treatment done thru the Identity property of the Object class. The Class object is loaded in memory and the object has a pointer to it. A Class is a versioned object thru Edition, so its version is known.
Designation of a stored object can be done in several ways. In short, if you have the Identifier then a direct reference to the Node operating system can be done. Ask to it to provide the object whenever it resides. If you don't have the Identifier completed, a search with available criteria can be done also to the Node operating system that will make its best effort to retrieve it.
Indexing and Partitioning are key factors for efficiency. Indexing is promoted to be applied for each Class and Interface, the storage being done by Nature of Objects. Identifier fields are all indexed. Other fields can be indexed thru a use case of the Operating System.
Partitioning is supported over several axis. A Universe providing a complete isolation. A Zone allowing an organizational separation. A Group giving a functional dependent partitioning capability. It is also a use case of the O.S. Finally, archiving can also be seen as a form of partitioning where older objects are moved to slowest Nodes. Algorithms on allocating Object id and mostly Object version id can play a great role here.
While Identifier fields are available in a uniform way on every Objects, this provides a common basis to search any of them. This is the case in particular for the Business id, that can be of course composite.

Note

Kind

Explanation

Text

It is necessary to have a Nature classifier for several reasons:

The Nature makes much more easier the object retrieval, because it gives a coarse grained partition of the object space (over other objects on a node, over nodes). This dramatically improve performance, and even makes the whole oo approach conceivable.
In order to generate an object id that doesn't collide with another one. Otherwise, it will be needed to have something like a GUID with 128 bits: doing things this way breaks the 64 bits principle. So it is rejected.
Therefore references an object just require a 64 bit, that is to say the minimum permitted size in ISA.
In fact having a Nature also allows to ensure that an object will not become anything along its life. A car becoming a person for instance. This improve semantic consistency

How to handle the Nature identifier ? In particular for Objects has numerous has they are. Because the object must know of which class version it belongs to. Otherwise, it will be very difficult to manage class version to run side by side or and costly to manage migrations.

The ISA solution is to be both clean and efficient. To be clean, it is needed to have separated properties for all data (this consume space). To be efficient, it is needed to have the smallest memory foot print, therefore just a sbyte of 64 bits (this is quick for processing and the smallest possible).
2 representations are foreseen:
- A sbyte reference to class object. At runtime, in memory for instance, the O.S. points to the class object memory address.
- An Identifier that is lazily loaded, containing a full identification across the Universes and their Nodes. Here the space is not a concern, on storage for instance.

The sbyte pointer to the Class is sufficient to supports versioning, because a class has an edition property (with a version). The stable classification mechanism is supported by the Category metaclass.

Fields

Zone ID

The zone ID maps to an organization.

Organization may be certified or not. In order to avoid ID collision, some rule are needed => TODO PUT THAT RULE UNDER INVARIANTS AND ADD A CERTIFICATE LINK/FIELD TO ORGANIZATION.

Certified organizations can produce a public certificate delivered by an authority. This authority is typically a country or an international organization.
In this case the Zone ID have the following format:

Bit 64: 1
Bits 51 to 63: The ISO 3166-1 numeric code (8192 rooms).
Bits 1 to 50: Number attributed by the authority.

Uncertified organization are allocated by any other organism. Typical organism are search engines.
The organism can check the validity of the Zone ID but not certify the identity.
In this case the Zone ID have the following format:

Bit 64: 0
Bits 51 to 63: Reserved to organism (8192 rooms).
Bits 1 to 50: Number attributed by the organism.

Note kind

Explanation

Text

Using a given Zone ID is not neutral. It is crucial in many cases to be able to prove that any object claiming to be of a given organization is really issued of it. That's why a Zone ID can be attributed associated with a public certificate.

In an Initializer, the hash check and encoding (at least of the hash check) with the private key ensure the objevct provenance.

Organization can also be more lax internally thru Uncertified organization, or even completly free by n ot providing Zone ID.

Object id

Object id is a sbyte. It is built by an algorithm defined for its Nature.

A post is dedicated to the generation algorithms of Object id and Object version id.

Object version id

Object version id is a sbyte. It is built by an algorithm defined for its Nature.

A post is dedicated to the generation algorithms of Object id and Object version id.

Identifier

Pair

Information

A pair of key-value is a set of two linked data items: a key, which is a unique identifier for some item of data, and the value, which is the data that is identified.

Attributes

Key

The key in the key/value pair.

Note kind

Explanation

Text

It can seems curious to rely on a sub Assembly containing the Key element type. This is due to several considerations.

The ISA LL bootstrap have justified circular dependencies (see LL Assembly).
A Key is a Single that is some where just an handler for Sbyte. So everywhere a Key appears a Sbyte could be used, but using a Key allows to have a direct textual representation for the key without needing obscure hash coding or binary. This allows humans to control the key name without any cost at runtime.

Value

The value in the key/value pair.

Constructor

Pair(◈)

Base constructor.

Pair

Sbyte

Information

A 64 bits binary word.
Sbyte means “Square byte”.This is one of the cornerstones Type because it supports the 64 bits principle of ISA.It also can be considered to be a bit field. In particular for operations dealing directly with hardware devices.

Field

$	The 64 bits word, giving a support to the Sbyte value.

Constructor

Sbyte(Hexadecimal initializer)	The constructor of Sbyte allowing to specify a value thru a hexadecimal string.
Sbyte(Value: Integer)	The constructor of Sbyte allowing to specify a value thru an integer.
Sbyte()	The constructor of Sbyte containing a generated pseudo-random value.

Queries

⊥	Overrides the Type query. True if the Operand is a Sbyte.
=	Overrides the Type query. True if type is compatible and the $ values are equal.

Commands

∧, ⊼, ∨, ⊽, ⊻, ¬	Bits level logical operators: And, Nand, Or, Nor, Or exclusive, Not.
Increment, Decrement	Respectively add and subtract 1 to the Sbyte value.
Two complement negation	Replace the value with its two's complement. That is the operation to subtracts the value from 0.
Rotate	The bits that slide off the end of the value are fed back into the spaces. The rotation can incorporate the carry bit and be done in right of left direction.
Shift	In a logical shift instruction (also referred to as unsigned shift), the bits that slide off the end disappear (except for the last, which goes into the carry flag), and the spaces are always filled with zeros. Logical shifts are best used with unsigned numbers. In an arithmetic shift (also referred to as signed shift), like a logical shift, the bits that slide off the end disappear (except for the last, which goes into the carry flag). But in an arithmetic shift, the spaces are filled in such a way to preserve the sign of the number being slid. For this reason, arithmetic shifts are better suited for signed numbers in two's complement format. The shift can be done in right of left direction.

Sbyte

Sbytes

Information

An array of Sbyte. This mean a contiguous list of Sbyte in the addressing space, typically in the memory.

This Type can be used in several ways and typicaly as a buffer.

The first Sbyte position of the contiguous list is reserved to support the sizes: the 32 first bits are used for capacity and the 32 endian ones are for length.

The capacity count the number of rooms the buffer has. And the length count the number of used rooms at the beginning of the buffer.

Formulas:

Capacity property = capacity
Length attribute = length

Field

$	The internal buffer. The minimum size is 2, because the first room is for the sizes and a that a buffer with a capacity less that 1 room do not make sence.

Property

Capacity

The maximum number of available rooms. This property cannot be changed.

Attribute

Length	The count of used rooms. The buffer user must update this attribute accuratly.
Item(Index: Natural*)	Access to an individual item.

Constructor

Sbytes (Initial capacity, Initializer)

Build a Sbytes with an Initial capacity. If provided the Initializer is copied to the newly created Sbytes, therefore the Initial capacity must be superior or equals of these of the Initializer.

Query

Read(Start index: Natural*, End index: Natural*)

Read a part of the Sbytes as a new Sbytes.

Command

Insert(Sbyte: Sbyte, Index: Natural*)	Insert one SByte
Insert(Sbytes: Sbytes, Index: Natural*)	Insert one SBytes
Replace(Sbyte: Sbyte, Index: Natural*)	Replace by a SByte
Replace(Sbytes: Sbytes, Startindex: Natural*)	Replace by a SBytes
Remove(Startindex: Natural, Endindex: Natural)	Remove a part of the SBytes
Pack()	Pack the SBytes in order for the length to be equals to the capacity.

Sbytes

Table

Information

An associative table of Pair.

The Table Element is the way maximum multiplicity greater than 1 is implemented for Pair.

Properties

Contained type	The type on the items contained by the Table.
Count	The number of items.
Keys	The keys of the contained pairs.
Pairs	The contained pairs.

Attribute

Item	Access to an individual item.

Constructors

Table(Initial capacity: Natural* [0..1] = 64, Contained type: ISA\LL\Metamodel\AbstractDataType [0..1])	Build a table of a given capacity for a given type. The table is initialized to point to the universal type instance ISA\LL\model\Root.
Table(Initializer: String[0..∞])	Build an table from a given list items by infering their Type and values.

Commands

+ (Pair: Pair)	Add a Pair. If a Pair is already present for this Key it is replaced.
+ (Value: Type)	Add a Pair by computing a Key using the Hash code property of the Value. If a Pair is already present for this Key it is replaced.
– (Key: Key)	Remove the Pair having this Key.