From OrganicDesign Wiki
| This article is a stub. Stubs are articles that have not yet received substantial attention from the authors. They are short or insufficient pieces of information and require additions to further increase the article's usefulness. The project values stubs as useful first steps toward complete articles.
|
|
The unification of the class-hierachy and runtime-tree means that the root of a node space defines both the functionality of the system and "the work" which undergoes change and achieves self containment of the system.
The root of any particular peer is a replica of the root of any peer.... microcosm... logical network
The unification of the physical network (RAM, Filesystems and LAN/WAN)...
The first two, listSpace and nodeSpace are normal functions with normal parameters and allow direct interaction with the local nodal network. later they will all be defined as nodal logic which can be compiled into the functions below, rather than requiring them to be "hard-wired" code.
1 ListSpace
- item listInsert();
- item listRemove(item subject);
- item listTraverse(item subject, item object);
- item listGetValue(item subject);
- item listSetValue(item subject, item value);
2 NodeSpace
- node nodeGetValue(node subject,node key);
- node nodeSetValue(node subject,node key,node value);
- node nodeInsertKey(node subject,node key);
- node nodeRemoveKey(node subject,node key);
- node nodeLoopInsert(node subject,node insert);
- node nodeLoopRemove(node subject,node remove);
- node nodeTraverse(node subject,node *path);
- node nodeLoopRotate(node subject);
- void nodeReduce();
- void **nodeState(node subject,node key);
Thes next three "classes" are designed to run nodally which means that the functions available at runtime have no parameters or return values because they must interact only with nodeSpace (or listSpace if necessary).
3 Storage
- open-file
- close-file
- read
- write
4 Communications
- open-stream
- close-stream
- send
- recv
5 Interface
- create-sprite
- delete-sprite
6 Identity
- book
- query
- comsume
7 Conceptual structure
The root node which receives all executional quanta for Nodal Reduction within any peer. Root has the GUID and internal runtime index of zero. There's been a lot of difficulty in the last few months working out the conceptual (nodal) structure of this root layer, it currently consists of three abstraction layers, the beyond is what larger things this peer is currently part of and supporting with reduction energy. The within layer defines all the structure of the current dynamic state in terms of all the processes which make up each infinitesimal moment. The middle layer is the event model which consists of regular cycles of activity and spontaneous indeterminate events.
The main conceptual problem over the last few months involves tying the identity concept into this structure. Identity is as fundamental as events (storage & distribution, interface, schedule etc). If events is considered as the time aspect, then Identity fills the role of space, and the root node itself can be considered as the energy of change (Δ).
Although Identity is dealing with an abstract and potentially infinite resource (the field of integers), it is still a generic organisation like all the other event-based ones. Identity can be thought of as stock-management, where the stock being dealt with is the integer GUID's used by all nodes.
- Unification
The concepts common to all of these fundamental organisations are:
- concerned with resource allocation, eg. integer ranges, storage space, communications bandwidth, processing time
- based on "booking" ranges on regular cycles to maintain "local stock" of the resource
- divide their local stock amongst their "clients" using multiplexing (division is rectangular, clients are circular loops)
- determine booking quantity based in prior use - "budgetting"
- Functions
By unifying the underlying concepts in this way we can represent all of them by a single resource-allocation node whose instances differ only in the actual function-references in the states of their associations. But what are these functions?
8 Nodal structure
|
NOTE, current serialised ROOT content will be read in peerd.c's runtime from nodeSpace.txt
- ROOT
- Beyond "Global-ward" (tree)
- current organisations ("parents")
- Events
- Schedule (cycles/periods wrt linear timeline)
- seconds, minutes... months, years...
- storage & distribution (existing streams)
- Causal (spontaneous,indeterminate)
- input (kbd/mouse)
- storage & distribution (new streams)
- Within (list)
- items composing subjective view
|
When implemented as a reduction algorithm in a standard user interface environment, the moments within are video frames, so the root reduction loop contains the events which require very little time, then all the items of change to the current dynamic view in succession (not in a tree because they must all execute in succession as quickly as possible). Then if there's any quanta left before the next frame, they are consumed by the current large-scale needs beyond (ranging outward from applications to organisations).
- See also
