http://www.1010.co.uk/gdapp.html gdapp :: generic data application - should be first stage/experiment in that extend/embed with python TODO
and meet half way with fmo1
what needs to be done:
Q - just so can work from fm01 machine then should abstract out so can use dv input ?
other notes:
current state (to abstract):
a) data sources - init/+ cell functions -> parameters b) sound/video in out - multiple surfaces/layers c) ap->2 buffers currently -> cells - merged with ap. ap cells as nodes with vm interp open to re-working on the fly d) chunking (roundcopy) e) effects f) mix
1) cell structure - offset, length, lively, registers on top of vm +data (list of cells, cur_cell + list of channels -> functions, (in/out / destroy), void *data.
-> map node connections/ remote node copied to local node / node functions and node microcode
2) linkage - strength/flow/barrier/leakage - promiscuity
3) mobile nodes carry data/microcode chunks for insertion (vm/macros etc)
4) cell contains - data/code .. macros/interpreter
5) parallel node execution model (n-ary tree without top-down flow or organisation)
6) display-itself .. display internal and linkage node(s) structure ...
7) node model from ap (registers etc. in cell-space also) - linear cell-space expanded by linkage
8) garbage collection - promiscuous creation of nodes and grouping autopoeisis
9) os model also (pipes, I/O, bus - process/threads/clone/fork + space model - inhabitation/leakage what is cellular model?
10) q of OOP? model - actors model
-- how much of new gdapp could be written in python / extended
(even use fm01 code so far for console and DV input).
node infrastructure and net stuff could be in python.
parallel code instances
use python so as to:
1) load new node functionalities on the fly (except cannot reload C extension modules)
2) easy manipulation of nodes
3) embed node code/containers
question of parallel model for gdapp: given linear I/O flow
maybe inputs multiplied or chunked
todo2:
1) define language/operations to be performed - data/code in containers contains these operators abstract code which describes type and operations on data
data structures- vm - manages nodal connection and split/share vm - as node nodes present/future states - two instances to simulate parallel process
2) structures to deal with nodal instances of this code - node as instance - entire vm
--> also notion that supplied/generated data can provide/describe nodal structure or elements of that structure
what data intends
intends to be understood
<b> Wed Aug 27</b>
should scan in diagrams soon for gdapp -> gdappdiagrams?
some notes coming from diagrams:
1) coded functions applied/not applied to incoming (?) data
2) shifting work onto nodes - they manage network incoming and promiscuity
3) reflector node shows whole system (so each node must have access to this)
4) using data to describe structuring in an outward motion - this is an OUTWARD reflector node which can re-organise other nodes (linkages, weights, flow)
5) cell-space which is another view allows for leakage
6) node accesses capabilities of other nodes for linkage - also strength of link
7) input/output replaced with a neighbour relation
8) neighbours should be able swop nodes/ spawn nodes /mutate nodes/inflitrate nodes (could node be flat data structure which is decoded - or flat data structure mirrors more sensible data structure -->
cell pages/spaces which can refer to location/page of other cells
cost of operations/linkages
)
9) [[types of node) - describing functionality by way of nodes -eg. long term storage/recall node writes other nodes (data/code) to disk + recalls
10) parameters connect to chunking + sub-divide node functionalities - subnodes even (code node etc)
------------------------------------------------------------------------------->
only worry is that node types too high level - if low level instruction node can present same interface ?? as these types of node
--------------------------------------------------------------------------------
started working on gdapp-> gdappTODO?
-------------------------------------------------------
1) flat cell space contains chunks of payload data (code/information) - on node arrival copies payload to cell-space - subsequent mirrors cell/payload space + all nodes write across cell space
2) microcode ????
3) weights of links (in array / NN) - nodes can map over/influence weights