nodal notes	 2002 
-----------


Fri Dec  6 13:37:05 GMT 2002

[collect from presentations/ap03 stuff/ own notebook notes]

1) some current thoughts //

a) node definition - as a flow or as a set of nodes
(encompassed/embedded) 

b) must be implemented in a (new?) language which can interpret
itself. a language on top of a compiled language with its own
interpreter. self-interpreting, self-modifying. ap02 language or
instruction set is v low level but could be a starting point as does
use I/O channels but needs to be more flexible in terms of those
channels (ie. promiscuous search for channels + user interaction with
operations + switch of self/say display)

c) thinking about graphical subsystem - would need to be integrated
with the language so language can define new ways of showing
itself/data. at same time can know about nodes externally and
interpret this (becomes external interpretation layer ... again
question of nodes collectively or individually accessing graphical
system ... parallel process of node execution(?)) // again q of new
models of program and execution .. even i suppose of language.

--incorporation of self-interpretation and flexibility into a 
graphical/I-O language (ignorant of a subsystem which can make this happen) 

d) would be nice if software implementation was not so dependent on
libraries (ap02-> sdl, sdl_image, sdl_sound, opengl, glib etc). also
interested in mobile mesh stuff as embodying nodal notions (flow) so
also good if could be cross-compiled for ipaq.

e) ****look at non-deterministic turing machines // also neural net
models of flow // also python interpreter stuff


Mon Dec  9 17:42:00 GMT 2002

[notes further ap02 stuff --> ap03]

a) 3D stuff as interpretation layer. data interpreted as 3D surfaces
or whatever - to which other data can be attached as a texture or
parameter (rather than current 4 flat surfaces)

b) multiple data sources from ap02->vapp -- to attach to functions or
buffers (use -x [number])

c) also text of instructions (cellspace shared) + diagrammatic --
ataching to ap diagram of own network via mapfile
towards ap03:

self-diagram instructions
+ more mapfile/network instructions
what is
diagram-itself function
quote-itself function
|--> copy-and-embed
		|--> layer 
--> +mutation of interpretation layer

copy//embed//become interpretation layer

instructions vs grammar/parsing

diagrams of cellular relations
cellular relations across nodes/cells

grammatical level

ap data=software sources operated on by grammatical language (layered
meta-language)

translation operation cell word/operator -> (see atoms in lisp -
divisible/indivisible)


//interpretation//mirror==vm-channels//flow//language//node


[swedish presentation notes]

AP02 DEVELOPMENT AND FUTURE AP03

1) goes some way towards decentralized model (no central list of IP
addresses) despite client-server model deeply ingrained in code
2) highly flexible -- replace over-determined instruction set with
non-brittle abstraction layer .. to bypass known givens of coding in
pre-determined languages
3) avoids closed data formats -- generic data format .. translators
data/software on level of equivalance

conceptual problems: 
1) still seperation cpu from environment
2) ... input/process/output model rather than a total environment (is
after all an application) ... 
3) instruction set to large extent based on prior computing models
(turing, van neuman) -- bit instructions, registers, logic.

4) flat cell/memory model

5) inflexible in terms of assignment of environmental channels and
flows of these channels .. how to deal with large amounts of data .. a
language to work with vast data flows (event-based)

--what is an event?

AP03 FUTURE AND POSSIBLE APPROACHS TO THESE ISSUES

building on ap02 but multiplying this model .. dissecting it also into
nodal/strata model ... globular/dynamic changing node structure of
connections, of flow and instructions -- total environment, an
operating system which dynamically re-codes itself, is recoded in
operation.

addressing: question of programming language givens
use of system models against themselves

what if instruction set and architecture of VM not borrowed from current
models - no IP/registers etc - translation of no step through -- pure
fragment (non)functional (no step through but an expansive search and
openness) event and no event reflect probable use of an architecture
sequential -- parallel against itself / of whether we are using something (a
machine) against what it is used FOR and if is a problem use FROM no use
FROM - no logic built from a logic gate undecidable switch -- standing
system of notation [of reverse question] of encoded performance system of no
logic from the very begining base level/our hardware

fictional/poetic logic for this new artistic operating system
operating system as it is not a discrete application, rather and
environment

event/data based model

node =  instruction/data/memory [re-defined in no seperation - in flow
what an instruction would be]
        set of codes (macro)/interpretation/meta-language
        full node space contained // self-reference                                               
        linkage/strength of path = pathway or route // event-flow                             
        migrating network nodes [node as instruction point / node as
machine]                                                 
	neural excitation and barrier models ->                                      
- barrier methods of communication (of an intensity rather than of data?)       
- flow/inhibit/excite/attract/repel. internode comms=model abstracted for       
all network comms                                                               

how far could go with these ideas ... main idea OS is expansion of
layers of abstraction -- define new languages on each layer at same
time aware of geology and physicality of these layers

users become programmers without knowing envisage viral nodes (defined
and as yet to be re-defined) attaching to the user/programmer's operations.

on a very basic level overcoming the heterogenity in terms of
formats, modes of operation and interfaces in favour of a body without
organs of extreme heterogenity 


AP03 OS

 ap03 implements a (self) re-configurable virtual machine os
for promiscuous data generation across network and external device
attachment. the os architecture is decentralised and non-hierarchical,
involving layers of virtual machines running self evolving code which is
highly determined by the environment (in contrast to current alife work such
as thomas rays tierra).

ap03 questions the givens of any operating system architecture. such givens
are necessarily interwoven with processor achitecture and instruction sets
and underlying philosophical assumptions and mathematical/logic models
(turing). diissecting such a tree of model and metaphor within a practical
project has wide reaching consequences for any understanding of contemporary
digital culture. the development of a (self) re-configurable architecture is
essential to the ap03 project, and it is of vital importance to such a
realisation that institutional assistance is obtained.

ap03 is a total (non-deterministic) hardware and software environment
characterised by promiscuity (open-ness to any data and active seeking for
data across any network), a virtual machine architecture (layers of (self)
re-configurable code interwoven with such data), reliance and
self-definition through environmental data and viral expansion through
diverse environments.


[v2 notes]

new nodal structure collected notes (more about requirements of such a
structure/code without much addressing of practical considerations)

1) event based interpretation -> change events/clusters of repetition

Q. output of event from input event:
a) need hold raw input data in nodes + event activation points
b) mirror spaces and mappings. / node points

[solution for flat data model: vmcells read and write event data but can
crossmap pure data buffers [write event data? could write template matching
pure data in crossmap scenario]]

2) instructions - new opcodes and functionality derived from conditions -
self define new operators/structures/node architectures/time flow
(ie. if we can't think of suitable structure perhaps it can be created in
process -- but needs initial flexibility to do this)

3) no external memory/data/registers. nodes dynamically assigned as
memory/register nodes without this being a total definition -- only defined
for one point/activation/time

4) operations FLEXIBLE (simultaneous functionality overlaid) DYNAMIC and
PARALLEL

5) nodal structure of points/nodes - net

node = 	instruction/data/memory
	set of codes (macro)
	full node space contained
	linkage/strength of path = pathway or route
	migrating network nodes

overlap points/nodes at micro/macro levels

6) event mapping across perspective change nodal structure
paths of resistance/excitation in parallel execution
areas of influence/of clustering
node-based instructions
attraction/repulsion
node growing structure
code moves thru cells

7) full template/node methodology -- no concept of address or reference in
methodology

8) neural excitation and barrier models ->
- barrier methods of communication (of an intensity rather than of data?)
- flow/inhibit/excite/attract/repel. internode comms=model abstracted for
all network comms

9) tree/compression structure of data overlaid on event/node structure

10) generic build of instructions dependent on context:

return/display/see/map/collide/join/split/barrier/level/induce/reduce/event/
no-event/hold/not/probable/branch/reflect/it-is/not/reverse/resonate/switch/
branch/expand/excite/logic structures

[instruction not encoded/not with an operand]

11) network of data - instructions acting on network of instructions and
data
(lisp, python questions) - Q of language implementation

12) if cease think of chunks of data or practical considerations of a
language [it devises itself]
so not really instructions for a vm anymore 

13) from older notes:

EVENT OUT - change in position/direction of a play head (in raw data) or
significant change in enacted data

EVENT IN - change/meaning significance in data eg. an alignment of data
(giving chunk size?)

// data soup structure maps different data fields onto interpretation
(range/scope/chunk) -- parameters of other data fields

14) like to go further with event-based ideas (size/decision of pattern event
-- change/trigger in/of state)
.translation raw data to events via frame-size/chunking
.translation display channels to event-based display = mapping
(re-chunking/framing. diagrammatic forms) modular (structure) event // vm //
translator // foldback (of translation parameters onto to-be-translated
data)

receive event
pattern event (?) - framesize + fuzziness
event=time-based
so stored event data = issue of time-span (frequency) -- mapping of
occurrence to data
(FFT as interpretation(?) of time-based events)
also neural event models (barrier)

[for more real time performance system possible to map event structure onto
trigger playhead idea in buffers (triggers straight output of buffer x
data)--
means using both event[data] buffers and data buffers [2 buffers per write
channel]
micro events - granular
macro events -- // zoom of an FFT

15) event model is about reducing amount of data
-could even use neural network model here (own research notes)

16) data sequences // linked list of cells

data sequence expansion -- start from smallest sequence (example LZW
compression)
sequence AB ABC tree structure
ABC sequence is code of AB + C becomes new code for ABC

data -> tree/net structure

[but Q is each cell would need to store its own tree structure/mapping]

3) 3 layer system --> 
a) convert to 8 bit data -> mirror B
b) mirror B -> mirror C = event pointers to mirror B /or/ resequence/net of
B

conversion means analysing/flagging what sort of data we have -- file
conversion libraries eg. SDL

use event pointers to mirror or templates // templates in same space or in
mirror B space ...

so when reads or writes is dealing only with pointer/template data 

WHAT WOULD WRITE TO POINTER DATA??

only 2 real write channels which are display channels -- special case of
DISPLAY
display code itself
display mapped code
mapped code/data to events.

so event reading is really what concerned with 

read [template] searches channel data for two matching [templ] .... [templ]

and reads in data .... to register offset

4) what if instruction set and architecture of VM not borrowed from current
models
- no IP/registers etc
- translation of no step through -- pure fragment (non)functional
(no step through but an expansive search and openness)

event and no event
reflect
probable
use of an architecture sequential -- parallel against itself
/
of whether we are using something (a machine) against what it is used FOR
and if is a problem
use FROM
no use FROM - no logic built from a logic gate

undecidable switch -- standing

system of notation [of reverse question]
of encoded performance
system of no logic from the very beginning base level/our hardware

virtual machine as a network
with no one way (globular) -- no instruction pointer route through it

branch/expand // spring off points

q. of conditioning by language -- low-level

5) LZW compression example -- adds every new string of characters to table
of strings - codes increment 256_ (12 bit codes 256-4095 = substrings)
Q still of event-based = // != time-based ie. polling for events/ waiting on
events // events in static data eg. a file?


[later notes --> notebooks 19+]

1) datstreams and functionaility: web /file (own filesystem?soup) /net
datastreams /video /audio // detection/cluster

2) nodal points - expansion - mirror points defined by language - data
streams overlay between/in-process -- new stream
[self-defining max/msp pd type patachable thing]

3) nodes determine other nodes as ...

4) glue-like network/virtual mode layer to which nodes (held in
language) register and form inter/extra-machine networks of nodes

5) abstract data streams to which devices/software attaches and
re-attaches - dealt with by frame and chunks (matrices)

6) python-based nodal-reflexive interpreter / command line
expansive environmental system

7) from GEB - actor - carl hewitt (similar to smalltalk) - program as
collection of interacting actors - messages and interpreters
. meta-oop level
also hacker - gerald sussman (scheme- structure and interpretation of
computer programs)

8) (neural node) model

genetic string / protein model (GEB)

clustered micro/macro model

//

--> module node --->

<- exchange of data/structures of registartion ->

node registration by cluster; capabilities

weight and flow as part of node (or in connection/routing)

flow - weight/inhibition/excitation
-> neighbours exchanging data structure registartion

cross module/system communication
papers -> nn model

transparent model of apps/modules in/across machines spawning
apps/nodes across machines // proliferation of code and interpretative
nodes / translators /mirrors (pointers)

building a cluster infrastructure and promiscuous node structure/layer
which node/app plugs into
proliferating net architecture - self-building with each node
registering and describing/gaining description of new connections and
flow possibilities

9) 

console
   |
   V
nodal structure <-meta-languages -> self-reference of connection/flow
& interpretation

-> multiple surfaces 


10) nodes build on meta-language/ self-description of nodes

and I/O engine for nodal structure - I/O detection and node attachment
as ap02 channels . node as point with attachments 


[further work]
1) non-deterministic tm research
2) python - parser generators :- PLY and SPARK (see yacc/bison also)
+ turning input into statements for python eval etc.
3) then embed python in C code 
4) OpenGL graphics subsystem thru. further ap02 work.
5) q of monolithic/modular approach (in terms of application layer to
which mobile modules could connect)
--how mobile nodes could work -- what gluey layer would be

-- if nodes maintain independent I/O (inc network) or if handled for -->
-- all nodes but underlying layer ... that node networking should be -->
-- transparent for all nodes/machines
6) how content enters the system - mutual networked interests spawned