In order to  perform an quick character prtesentation change detection on 64 bits encoded characters, a AND with 3 operands should be implemented in µP. Operands will be :

• current (current character)
• reference (previous character)
• mask on wich the AND operates

Exchange protocole
Get an objet :
Ask(asked class name, optionnal asked OID, optional asking context) : Asked object.
Send(target class name, optionnal target OID, sent object, optioanal sending context).
On an ask an other parameter is nedded, the depth. Possible vaalues: Lazy, components, aggregates, controled, extended a complète.

Color Is one of the basic types (in uP?) like pixel and canvas.
Canvas are put and get from/to display device.

O.S. UI is Just a Search engine targeting locally, a universe or the whole world.
It as favorites objects (or classes That are objects too) around.
Therefire one has Just to publish an Object in the universe he wanted.
Object published sould have properties like icon, description, summary, keywords…

For persustency one nreds:
– a notification mecznisum between Object and their vViews (bidirectionnal)
– A transaction manager That could ne distruted keepung track of all afgected Object or view.
– A location manager telling to Objects whzre they are located. The location us one property of persistant Objects.

`LL` does not have keyword, only ponctuation. Every thing is Object.
Some Ponctuation characters , . : {}[] having usual meaning in english or mathematics.

• . : End of phrase (instruction).
• : : Definition (affectation).
• { } : Enclose a complex definition expression, often composite.

Usual natural langage rules applies as soon as possible. For instance, the first character of an expression (a name for instance) is upper case when defined, but is lower case when used inside a phrase (an instruction).

Expressing a class:
{
Name:Person.
Name space:com e-CS Sample.
Base class:Class.
Properties:{
Name:Last Name.
Type:String.
Access:Get and set.
},{
Name:First names.
Type:string.
Multiplicity:One or more.
Container:Array.
}.
Methods:{
Name:Get age.
Return:integer.
Run:{
Return
}
}.


Object in memory
Object in memory starts by a sbyte. This 64bits represents its state : Persistant (have an OID), is dirty (modified), is mapped memory adress mapped to OID for the current instance execution. This last bit avoid to have an entry in the O.S. mapping table of OID to RAM adresses.

Symbols, as Unicode norm specifies, and characters, coming from the typographical world, have to be distinguished.
String of symbols are a first type of Unicode symbols represented using UTF-8 to save space.
Text of characters are a second type of 64 bits with 32 bits for typographic characteristics and one symbol using UTF-32. This low level integrated and uniform presentation could widly improve display rendering velocity by delegation to hardware components.
Space occupation is not a concern for the last case. Remember that when 7/8 bits ASCII codes were specified, before µP where only 4 or 8 bits…
More over, in documents, block of text could be defined by (a) a String for the content and by (b) one Text character for the presentation of the whole content.

To save memory occupation of an object, a 64bits fields map specify for each class what fields and properties have a value.
Then only setted bits have a corresponding 64bit value. This fields are in the class order.
Consequencies :
1/ Only 64 fields can be declared by class.
2/ If a property or a field is newly affected, the object have to be reallocated.
3/ Having many properties on the Object class is not costly.

The point 2/ impacts can be minimized by allocating a full space Object in case of new allocation (constructor) or in case of reallocation. The compiler can also prevent reallocation by its code analysis.

`LL` Consider auto allocation.
When acceding a method on an Object (O) thru a property (P) of its container Object (C), if it throw an null pointer exception, the runtime catch it, and if a defaut constructor exists, allocate automaticaly the Object (O, set the property (P) and recall the method.

This feature is useful for instance for adding on collection or relationship properties.

This avoid pollution of the code by many not null checks.

ISA Wish N°1 – Plug and play generalized

Step into

Embedded hardware and software are not a concern, exept for update.
Local ressources like power needs, connectivity needs have to  ne addressed.
Remote ressources like software download, or resquesting treatment have also to ne addressed.

Visibility in `LL`.
Visibility is a property of a class or of its members.
Possible values are: private, class and its childs, object, package and its childs, module (default value), public.

A module is a class. It gather classes and modules in properties Classes and Modules.
Module is a delivery unit. It is deployed on a node. Modules must be deployed on a single node (in a universe). It could be either downladable to other nodes or runnable on its node.
It exposes a facade made of: classes and view as public members and also operations.

Persistence management
Persistence of objects have to be transactional. Consistant read also have to be warranted.
To do that, the solution can either rely on a locking system (like in RDBMS) or on a double buffering pattern (like for video display).
The first solution with locks slows both write and read operations, and even the whole operating system.
Double buffering clearly favorise quick reads, up to near zero cost of transactions.

This kind of persistence could be done like that:
Having a partition R, with two subpartition R1 and R2 of same size.
1-a) When all reads occur on R1, the OS write validated objects (invariants checks) in a transaction Tn on R2 and update its internal indexes.
1-b) If Tn aborts on R2, objects are rollbacked by reading R1.
2) The operating system waits for running reads on R1 to complete.
3-a) Then it swap partitions : Reads are now done on R2, and writes on R1.
3-b) Objects involved in Tn residing in memory are updated.
3-c) Tn is validated.
4-a) Before processing the next transaction Tn+1, Tn is replayed on R1.
4-b) In the same time, listeners are notified of updated objects.
With this double buffering solution, reads are not impacted at all by transactions, and writes are slowed linearly by previous ones in case of large loads. This pattern scales out easily.

For objects that are mainly writing oriented, like logs objects, a dedicated partition W can be allocated. On W objects included in a Tn transaction are written directly, but consistant read is not warrantied.

`LL` Indexing of members
In LL class definition, members should be indexed by an ordering number. This index makes easy member addressing. It avoid in many case having to rely on introspection that is slow, because of its name based access.
Index adressing is directling supported by microprocessor for table. Therefore in memory, objects members can by a simple table ordered by this externalized index.
This externalized index is present in object serialization. This improved a lot deserialization.

A design time, the index property of members can be supported by IDE thru an “auto index” affectation (similar to “default value” but with an incrementation).

`LL` Historization
Have a VID that is a timestamp. Stamped by the transaction.
Mechanics of final consistency.
Complete history is reliable because link only on the OID plus the interval of duration of the version of the object, allows to know all the objects has a point in time.
The history classes have the name of the Postfix base class History. It follows the general view synchronization mecanism for update.

Historization can have a compression mechanims by only story changes, like the Historian PI.