This assembly is the place where are defined the language architecture and conventions LL used extensively.

Textual presentation conventions

• Normal text: Regular
• Important text or a title: Underline
• classifier: Bold
• Feature and Relationship, arguments: Italic
• Denomination or Literal value: Bold and italic
• Code: Code

LL Architecture​

OMG classification	Last Language Architecture
M3	Concepts (meta-metamodel)
M2	Metamodel		Elementary (Primitive)
M1	model
M0	World (instances)

model, Metamodel and Concepts

A regular class inheriting from object (but not of Metaclass) is instantiated at runtime as an object of the software. These classes forms the LL model.
Examples: object, Group.
They are typically instantiated at runtime as the effective representative of real World objects.

A design class inheriting from Metaclass when instantiated at design time are an object of a designer tool. These classes forms the LL Metamodel.
While also inheriting of object, a design class can also be instantiated at runtime as a metaobject of the software, to the give access to the model of the software.
Examples: class, assembly.

A  Concept defines a principle on which metaclasses rely on.
Concepts are not limited to software engineering but come from mathematics, engineering, etc.

Elementary types are the most basic building blocks in LL (primitive types). They are shared by the Model and the Metamodel.
Examples: Integer, Boolean.

Circular dependency

It can be quickly seen that there are circular dependencies between the core LL Assemblies. This is generally a symptom of a badly designed system. Why ? Because (1) it need to have all put together in order to work and (2) make consistency difficult to achieve.

This is true, but (1) is not a problem at all because in any cases the whole LL runtime needs to be there to run any thing. You always have to rely on the whole LL assembly.

The (2) is more difficult to justify.  First of all, this is real difficulty in designing LL (I can testify about it!). A simple solution could be to put every thing in a single root assembly: but it will be worse because as all introduced artifacts are needed, there will be not any scaling in complexity, not any higher level of grouping. So it is far more simple to have some well known circular dependency than to have a big bag. The magic number seven of George Miller principle detailed in the Metamodel Assembly justify why this approach is preferable.

To conclude, having internal circular dependencies at the bootstrap of the ISA system is a good compromise. The exception makes the rule.

Notation conventions

The sign $ expresses the “Value”, typically a Value Field.

The sign \ is the forward path separator. In a given context, it expresses this local context (like the this keyword on several languages).

The sign / is the backward path separator. In a given context, it expresses the parent of the local context.

The ideogram 恒 denotes a constant value (U+6052).

The symbols ▣ (U+25A3) and ◈ (U+25C8) both specifies a base constructor characteristic . The first one, ▣, is used for arguments that are limited to the declared data of the current type. While the second one, ◈, open the argument list to inheritance.
For a class with a base constructor its relationships roles are always added to base constructor if the minimal multiplicity is one or if it is an association class.

The characters Ç and Í symbolize respectively a Class and an interface requiring a hook.

This symbol ◘ specifies an historization recording.

Property versus Query

Apply the same rules as stated by Microsoft at Choosing Between Properties and Methods.

Design conventions

The normal way to convert a type A to a type B is to have a B constructor having a A argument.

There is not a couple of operations for “can do something” and “do something”, because the “can do something” role is played by preconditions. In this case, an exception is thrown in the Circumstance named Precondition. The preconditions can also be called explicitly.

Any operation that does not explicitly return a value, returns the current Object \ in order to allow the operations chaining in the same line of code.

Singular versus Plural

The general rule is to follow the usual convention to use singular or plural. So, when there are many things then use the plural, but the singular when there is only one.
Let's exam this rule usage for major metaclasses.

• Field: When a Field has a maximum multiplicity of one, then use the singular, otherwise use plural.
• Relationship: Always use a singular common name that summarize the relationship.
• Role: Same rule that Field.
• Assembly: An assembly is always expressed as a common name.
  • For an assemblage defining a single concept, use the singular. Examples: Metamodel, Model, LL.
  • For an assemblage gathering either several occurrences of a single concept; or various declination around a grouping logic, use the plural. Examples : Nominals and Metamodel\Types (gather around 1 concept), Temporals (gather around a grouping logic)