List space

The Nodes are relatively high-level structures and at runtime within the peer-nodes they sit upon a more fundamental layer called list space in which the actual nodal change takes place in a peer.

List items

The project uses a very fundamental memory model based on binary sequences. The entire memory can be divided into groups of smaller sequences which can themselves each be referred to by a locally unique binary sequence. For example, a 16 megabyte section of RAM can be divided into two million 64-bit sequences. List-space uses blocks of binary as its local memory resource and divides the block up into smaller binary sequences called list items. Each list-item hold the same structure of content which is a sequence of three list-item-keys.

List item keys

Since binary can be treated as numbers, each of the two million sequences in the example above can itself be referred to, or addressed, by a unique binary sequence called a list-item-key. In the case of two million items, the list-item-keys are 21 bit sequences. In other words, a 16MB list-space is divided into two million list-items each formed from three 21-bit list-item-keys. The slight inefficiency of wasting one out of every 64 bits is done because of increased efficiency gained from working with sizes which are powers of two.

Three keys

Within each of the three keys common to all list-items, the first and second are used for binary traversal which allows list-item-keys to be used as associations (see key-as-reference for more details on this concept). The last key is context specific and represents a value at the end of an association, but both the association-key and the association-value are list-item-keys, references to other list-items.

List-space methods;

List Space is an environment which offers a generic set of methods which can manipulate a space of generic List-Items each addressable by a binary List-Item-Key. Each List-Item is composed of three List-Item-Keys. This simple model is rich enough to support many kinds of higher data structures such as stacks, queues, threads, loops and trees.

• listInsert()
• listRemove(subject)
• listTraverse(subject, object)
• listGetValue(subject)
• listSetValue(subject, value)
• listGetKeys(subject)

List Characteristics

There are a number of ways that list items can be linked together to form lists which gives rise to some important list-characteristics. List Space itself has no concept of kinds of list, or a lists characteristics, so this is really a summary of the way the lists can be used by higher levels such as Node Space. More exotic structures such as binary-trees can also be constructed from list-items if the prev-keys aren't forced to link back to the item linking to them with its next-key.

The Node Space only uses one list space structrue which is the Loop. Other kinds of list configurations possible with List Space are stacks, queues, axes. Lists can also have the equivalient of names.

List items

The only actual content stored in list space are list items, which are each a sequence of three binary list item keys. Since the smallest addressable unit in the List Space is the List Item, the size of a List Item Key can be based on the total number of List Items that can fit in the space, rather than the total number of bits. For simplicity and efficiency of running in current environments, ensuring the List Item size is on DWORD boundaries may be best. Maybe 32-bit List Item Keys, or maybe 64-bit List Items with 21-bit keys.

The middle key is called the data-key and its meaning and use are context-specific. The first and last keys in a List Item are the previous-key (prev) and next-key (next) allowing the formation of doubly-linked lists called Lists, and hence List Space. (List Item 0 is the Root List Item and Root-Node and indicates a null link). Lists are referred to by the List Item Key of their first List Item and such keys a referred to as List Keys. List Keys are a subset of the List Item Keys.