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