electrohype2002 environmental code::


environmental code is self-reflecting. it talks and writes
itself. it's self-generating running through all the strata of the
social, physical, geological, biological and digital. it's messy and
noisy - spaghetti code at an algorithmic banquet and it's not just or
at all abaout software,

it's an idea. a nodal point; an idea of ideas, a collison of ideas
and strata creating geological upheavals across these strata. 

code as environment and environment as code

code as environment involves an examination of the inherent
physicality of code whilst at the same time understanding the vast
field of possibilities opened up by the multiplicity of code layers
inherent within software/code strata; self reference within code
defining new layers. this nodal point accesses the history of computer
science with Zuse's use of waste film strips as punched data holes --
switch of irrelevance of a material used for encoding/ hole of the
visibility/invisibility of the encoded

environment as code means taking a serious look at how software and
systems architecture is conditioned by environment (social models:
wider sense of an operating system (examined in such events as Wizards
of OS in Berlin), client-server networking model). a tool-based view
of software ignores this total environment (physical, social
conditions, givens of all levels of computer language and

interested in how environment as code/code as environment notions flip
over/collide and expand/re-write each others terms ... work has been
done in both fields narrowly described as the formal and the social
but combining two approaches gives new notion of code/of software.

software within an artistic context has in the past suffered from
being too amenable to a binary tool-based approach: hidden
performative code on the one hand generating output based on some
input. exposing code in terms of open source approach or as an
artistic strategy has gone some way to remedying the situation. but
outmoded models of artistic behaviour are still applied to code
(parody, craft, reliance on metaphor and notions of software/data,
user and programmer). opening up notion of open source in wider
context and examining code from viewpoints above especially the social
has pushed envelop further, but these concepts need now to be returned
to artistic software.

aim here to examine nodal point of environmental code within the
context of the concrete model offered by the ap02 project. real world
issues involved in the design, development and implementation of ap02
will be examined to totally elaborate a working model of environmental
code and to define the notion of an artistic operating system which
can be applied to a range of strata

[poss. first demo to break down data/software division in context of a
programmatic presentation [algorithms applied to areas such as walking
- psychogeographic]

// presentation as subject of the presentation --
presentation as/of set of nodal points which act on/expand/contract
each other (to un/form a set) - change nature and scope/framing of
each other/nodes = subject of this presentation = how this can be
achieved in software / in code = intro to ap02] DEMO speech of
presentation as code ... 

2) AP02 software:

ap02 is a virtual computer, an organism which runs on top of a host
computer. it mirrors the host machine almost exactly. it possesses a
CPU (Central Processing Unit), memory and can detect all manner of
input and provide a wide range of outputs. however, rather than
running instructions designed for speed and efficiency in
accomplishing a specific task, the ap02 virtual CPU runs a reduced and
abstracted set of instructions. and the programs this CPU runs are not
determined by a user or programmer. ap02 runs software which has been
determined entirely by its environment. in other words, the
environment has written the code which ap02 runs. this environment, a
mirror of the host computer, can consist of audio data from a
microphone or CD, video from a webcam or other input device, all the
information in the files held on the machine and all network data
recieved by the machine and on the local network. each ap02 virtual
machine also communicates with others running across the global
internet. all data is converted from disparate file formats into a
generic format for use by the ap02 system. 

this data is used to construct an initial cell space whose individual
cells will run on the virtual CPU. this cell space is constantly
examined by the software to determine new cell boundaries which
establish the identity of cells as they split and reproduce.

the set of instructions used by these cellular programs running on the
virtual CPU has been carefully chosen to match the needs of the cell
space. it allows for complex computations, reproduction and
communication. the instruction set also allows for great
flexibility. there is no incorrect series of instructions and the
virtual machine cannot crash. communication is conceived here
primarily as primitive self-display. this act is priveleged and cells
which are un-responsive within the environment are swiftly
replaced. the two key instructions used by the cells are say and
listen. listen looks for activity within the machine environment and
inserts this data into the cell body. say operates in reverse,
inserting a portion of the cell body into the environment. this
implies some form of display or a communication with cells running on
remote networked hosts. each ap02 application maintains a list of
internet hosts which are running ap02. as cells communicate remotely,
the application exchanges lists with others and adds new hosts to the
list as they arise. the network grows as applications communicate and
exchange lists. the cell environment expands.

ap02 was conceived in late 2001 and coded with the assistance of artm
baguinski at v2_lab rotterdam and subsequently by myself in
london. ap02 is expressed within three interwoven projects; as
physical self display devices, as a freely available, distributed
networked application, and as a performance-based application
interfacing to a range of hardware modules such as EEG equipment.


[DEMO: ap02: command line channels/viewer/instruction set/mapfile]

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

problems in development: 
1) arriving at de-centralized model difficult
given way internet protocols structured.
2) non-illustrative nature of software (is not software which uses
metaphor to say something --> many question meaning to work)
3) finding ways of doing things that no functional software would need
to do (except perhaps viruses etc) so working very much from scratch
security issues ... determined towards discrete functional, secure

conceptual problems: 
1) still seperation cpu from environment
2) ... input/process/output model rather than a total environment (is
after all an application) ... tho
physical devices maybe resolve this

more about these:

physical self-display devices are devices which communicate ever changing
operational codes based on external environmental data. these self-powering
tiny devices are scattered throughout any environment and do not transmit or
relay in any manner useful sensory data to any observer. they can only be
experienced within the (often remote) situation in which they are placed.
the self-reliant operational characteristics of these devices engender
open-ness and expansion in any situation.

the devices are solar powered and have been designed to operate for a
minimum of three years within harsh environments. over this time period the
devices modify their own instruction code, the program they are running, in
response to environmental changes. fragments of code are audibly
communicated between devices which can incorporate and make use of this new
code. each device displays on LCD a segment of its operational code. through
self display and communication these devices are integrated into the

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)


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

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

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
	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 

5) AP03 OS

a real world os which embodies ideas of ap -- projects/ liberation data
generation] in a performative sense is sorely lacking within the sphere of
technological systems art. much current artistic work still relies heavily
on antiquated tool (and parody) metaphors, and the limiting
notions/divisions of system, user and programmer. the much needed and
revolutionary meeting of contemporary artistic practice with the ideas of
the free software movement (to create a new as yet undefined scientific
practice) has failed to materialise again due to the over-reliance from both
sides on metaphor/non-poetic metaphor.

ap03 will provide a concrete implementation of these ideas across hardware
and software and will be fully functional(?) in both a performative and
exemplary sense. 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.