Computer = Network

" Network is a computer " will be made by the Dynamically Distributing Operating System; " Computer is a network " will start with combining the router and the computer to be one.

Hardware : Software

I/O access = memory access ➡ hardware access = software access ➡ remote hardware access = remote software access ➡ hardware service = software service ➡ hardware distribution = software distribution

Distributing Sense

operators + operands = operation

sensed operator = sense
sensed operand = sense
sensed operation = sense

operators and operands distributing on different hardwares
= distributing operation = distributing sense

Distributed Operation

host#1'operand#1 + host#2'operand#2

+ 是1号机1号元的 operator 与其同在一号机，所以现在有2个 senses 在1号机、1个 sense 在2号机，要怎么执行这个跨机的 distributed operation ？

在2号机对1号机使用 WCF service 下这道式子会先把1号机1号元下载到2号机然后才和2号机2号元一起当作远端呼叫1号机 operator + 的 parameters 上传到1号机，1号机1号元被下载了又上传多此一举白费流量，你会说还不如传 request 给 1号机的 Web server 呼叫 Servlet 在1号机执行。但若2号机2号元的 size 大于1号机1号元与 operator + 是否就不如将 operator + 下载到2号机执行？如 Applet 的做法 ( 把 Applet 看作是一个大 operator ) 。三种架构分别，但软件在跑一下是这情况一下是那情况，这就是为何要丢掉传统架构全面采用 DDA 架构。

🤖

The cerebellar motor control has been well trained, and the brain's on-the-spot analysis of the unfamiliar environments also has to be developed. The two-legged one needs the higher balance feedback control than one with more than four legs, and the cost is higher. Although the demand of the military is the ground sneaking reptiles better than the erect humankind and even asks the joints to rotate omnidirectionally: the most perfect artificial creature is the roll ball which can extend out the omnidirectionally rotating legs, arms, and wings from the whole surface of the sphere; except the humankind can and be willing to self-modify the gene, the human-like bodies will be always needed forever. And it is not expected to connect the neural mechanical body only after the natural body is damaged, so it is necessary to redesign the axis center rotation robot to become the anexoskeleton rotation armor one like the IronMan.

Sense space

• 无论 Sense 结构如何进化，其基本都是 graphs，只要 graph 中一 node 在 memory 被 refer 到即将其第一阶链结到的 nodes 从 storage 预载到 memory，如此即确保要 refer 到的 sense 都已在 memory，因一个 sense 定是透过另一个 sense 来 refer。

• 在 memory 中的 sense 获得更新则立即更新 storage 中的 sense ，因为还有别的 memory 在 cache 相同的 storage，所以也必须一併更新所有 cache。

• 当 memory 满时由 rerefer 频率少的 sense 优先 release 腾出空间。

如此外界仅存取 memory 而不直接触及 storage，于是不再有 storage I/O 的观念。

而将网络另一端的 memory 也如对 storage 般对待，于是不再有 network I/O 的观念。

这机制让每一运算机皆为一镜像平行宇宙，每一空间发生的变化都会在其它所有镜像空间同步发生。但其实一个空间并装不下整个宇宙，每个空间实际上只存有局部视野所及的宇宙，是随着视野的移动来由其它平行空间载入其余局部而移出视野的局部实际会在该空间消失但前提是先确保消失的局部有存在另外任一平行空间，于是所有平行空间联集起来是为完整的宇宙。相同的事件在不同的平行空间发生都会有相同的结果镜像到所有的平行空间，但在不同的平行空间触发所花费的时间可能不同而最终成为整体的费时，所以要选择在费时最少的平行空间触发事件以获得最少的整体费时。事件由一组 Senses 构成，每个 Sense 的本尊只会存在其中一个平行空间，其余平行空间的皆为分身。无论本尊位何，所有 Senses 一列排开何者 loading 最大就优先到何者本尊所在之平行空间去进行事件的发生方能让镜像映射所费最少，再者优先选择 performance 最高、space 最大、bandwidth 最大的平行空间触发，那才是原始真实的发生，其余平行空间的皆为结果的镜像。而每一 Sense 本身又是由一群 Senses 组成，所以一件事情的发生实际上是在好几个平行宇宙分部进行再将镜像联集起来。

在任一端将 operands 接上 operators，每一端都会立即同步这个结果，然后每一端都会因为 senses 的相接起了连锁反应也就是运算被触发跑了起来，但每一端运行速度又不一，在速度不一非同步的情况下任一端的变化又会立即更新每一端，那就大乱了，所以每一端都有一个反应前的抑制措施：每一端都各自进行哪个 sense 的 body size 最大的判断，仅在最大的那个 sense 的本尊在己端的前提下才触发。这只是决定在哪端运行的初步判断，作用是让 size 小的 sense body 缓存到 size 大的本尊所在处以使传输耗费最低，进一步还要把 performance、space、bandwidth 三个因素考虑进来，所以至此尚未确定要在此端触发运行。

把 sense 给 lock 住让 operation 进入 critical session 的方式很容易发生过长时独占导致的等待甚至 dead lock，所以当要让多端同时进行同一 operation 以达验算之效时采暂时产生一个 sense 的 clone 转而对其操作之方式在整个 operation 完成后才以 clone 去更新原 sense 然后删掉 clone。

平行空间断链没同步就会分歧出不同版本的 senses，分歧的平行空间合得回来吗？Sense 原本就可以鸟生蛋、蛋生鸟对不同的 senses 进行融合：取交集为 class sense、保留差集为 instance sense，所以并不是无解的问题。

operator ≡

The operator ≡ is used to define the replaceable linking state of the operators and operands dynamically like the function definition. If the operator can not be found in the hardware when it is asked to be allocated, it can be replaced with the other linking graph defined by the operator ≡. If the allocated graph is already in usage, it clones the other one for new usage.

operator ∏ ∑ ∫

Change the script style of the operator ∏ ∑ ∫ to be as the operator ∀.

Ex:

( ( ∀ ( x + y = x * y ) ) ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) )
just produce a collection of ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) by ( x + y = x * y )

( ( ∫ ( x + y = x * y ) ) ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) )
the same as ∑
get the sum of a collection of ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) by ( x + y = x * y )

( ( ∏ ( x + y = x * y ) ) ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) )
get the product of a collection of ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) by ( x + y = x * y )

Dynamic operators

The operators in the static language system only access the operands; the operators in the dynamic language system also access the formula.

P2P ≠ C2C

Peer 2 Peer ≠ Client 2 Client，大机和大机、大机和小机之间亦是P2P，Cloud 精髄不在 service 而在 Dynamic Distributing Allocating 。

Sen语 Ron语

Sen语持续进展中，但Sen语不是一种语，而是一种说Sen语当中亦可构建Sen语的动态语言机制，Sen语本身是由多Sen组成。Sen语若行于SenGo硬件(SenG之Go年进化版，年底才会推出)则原生即具operand与operator级的并行性无需再指定。

另一个是Ron语，不像Sen语是由概念组成的语言，Ron语基本上是signal、是pattern，或许已不算是一种言语而比较像是一种不说话的感官沟通方式，但又有部分可形成operand与operator的sense。Ron语目前尚只是想法，也还没想清楚，尚未着手开发。

动静皆宜

静态的系统没有动态系统的弹性；动态的系统没有静态系统的稳定。设计一套可静可动的系统即是咱们的任务，例如一群机动载具组成的动态网络一样是可以静下来不动使效能极致，必要时可以牺牲一点效能与稳定性动起来。

整网软件单元参照空间联为一体

整网软件单元参照空间透过交互阶层缓存联为一体，每个软件单元的参照位置是唯一，其本尊是唯一，仅存在于一处，其余处皆为缓存分身，所有的同步是以本尊为中心的树状拓扑。本尊处记载每个分身缓存处位置，这份记载也一併缓存至每个分身处，可是缓存的拓扑副本非用于与其它分身处的平时通联，是用于本尊所在处被斩首时重建新的本尊处所。为软件参照位置的唯一性只能采树状同步，但是树状拓扑又有被斩首即整网皆失的缺点，所以每处皆一併缓存每个分身处位置才不会在本尊位处丧失时亦失去对其余分身处的所知而不能重建树状拓扑。

About the user interface without editors

Just use the GUI or VRUI components except text editor component to travel the sense graph to select senses to compose a sentence to have the conversation with the space object without typing.

∀

∀ ... 🔲 ......

其实 🔲 处不用填介系词

( ∀ ... ) ......

括号內让∀优先结合得到collection'#(1~collection'#)再后接 ......

所以就用括号就行了

不用再伤脑筋这个介糸词要用何operator才不会与其它别的用途相冲突

operand operand

I would like to change my mathematic script custom that two operands side by side will be inserted an operator * in default. Restrict the operator * must be written or it will not be inserted automatically. Because it is needed to allow two noun operands side by side automatically inserted by the operator ' for compound noun. For this, I am also willing to change my English script custom about ' such as not writing "I'm", "I'd", "I'll", "I've", "It's", "isn't", "don't"...... and just writing "I m", "I d", "I ll", "I ve", "It s", "isnt", "dont" ......

operand _

An unknown object is an object without any sub-objects meaning no content. An operand _ is an unknown object without symbol as no name. In the same expression within "(" and ")", different operand _ is different unknown object. After the expression including operand _ resolving, there is a collection of possible satisfied combinations of operand _ s gotten. If more than one operand _ are needed to appoint to the same unknown object, the only way is using the named unknown object assigned with ∅ to replace the operand _ s. If there is no space among the operand _ and another characters, what matched is not an object, it is the object symbol characters match. However, each symbol and character is an object too.

The drones dynamic network

Drones remote control from the command center by broadcast ~ easy; what we want is the drones dynamic network, this is where complex.

operator ⊧ ⇒ →

Rule operator ⊧ 

A ⊧ B ≡ if A then B ≡ A causes B 

This can be used in branch control and rule proofing at the same time.

NextStep operator ⇒ 

A ⇒ B ≡ A and then B ≡ B after A 

Stint B will be enabled only when A is completed.

To operator → 

A → B ≡ A to B ≡ B has A 

The value assignment is the sub-object assignment. Operator "has" has the meaning of adding. If you want to replace what the B has or is completely, you must assign the null operand ∅ to B first as B = ∅. In a case, B may be a place and A may be a moving object.

operand _

How to get the classes of an object?

( object ∈ _ )

How to get the objects of a class?

( _ ∈ class )

Operand _ is used for finding each match.

operator ∀ ∃

∀ operand ≡ for each sub-object of the operand

∃ operand ≡ select one sub-object of the operand

Associated by the operator ∀ or ∃, the operand is regarded as a collection, and its first level sub-objects are regarded as elements of a collection.

After any formula solving, there is a collection of combinations of the assigned unknown content operands gotten. We can use the operator ∀ to produce the macro for each, or use the operator ∃ to choose one.

operator ¬ ? $

Not

¬( operand operator operand ) ≡ operand ¬operator operand

Query

?( operand operator operand ) ≡ operand ?operator operand

Associate

$( operand operator operand ) ≡ operand $operator operand

The 3 operators are little like the class default behaviors such as constructor and destroyer in the traditional object oriented system. They are the default operators of operators which also have the mechanism of inheritance little like classes.

operator ' and `

But the operator also has its sub-objects as operands and behaviors as operators, so it is necessary to separate the object oriented operator ' and the mathematical operator ' . Which one will be changed to be ` ? What I think is the mathematical operator because the transpose has the meaning of inversion and reversion, and the differential also has the negative meaning. So let us change the mathematical operator ' to operator ` .

Then:

operand ` ≡ transpose of operand

operator ` operand ≡ differential of operator(operand)

operator ' operand ≡ operand @ operator

operator ' sub-operator ≡ sub-operator @ operator

Why do we not use the operator "." for the sub-object? In case of the sub-object "integer.decimal". The value of an object are its sub-objects, and the terminal value in the end of the object collection graph is the symbol of its terminal object. The symbol of an object may be pure number, __.__ is a symbol and value, how to express a sub-object of an object? So we use the operator ' .

operator '

operand ' operand ≡ sub-object of object

operand ' operator operand ≡ ( operand ' ) ( operator operand ) ≡ ( transpose of operand ) * ( operator(operand) ) 

( operand ' ) operand ≡ ( transpose of operand ) * operand

operator ' operand ≡ differential of operator(operand)

Exponential operator

I do not write the exponent as a small word binded in the upper right corner because the nested exponent results in the upper right corner words smaller and smaller till they are hard to be written. So I use the operator ^ to bind the exponent even though handwriting not typing.