psychogeography: programming in .walk

Posted by Wilfried Hou Je bek | Sun Jan 5th 2003 1 a.m.

if you are new to generative psychogeography, you
might first want to read this

http://www.socialfiction.org/psychogeography/walk1.html
http://www.socialfiction.org/psychogeography/newbies.html
http://www.socialfiction.org/psychogeography/

the text coming up you can also find here:

http://www.socialfiction.org/psychogeography/dummies.html
--

THE TECHNOLOGY WILL FIND USES FOR THE STREET ON IT'S
OWN
programming .walk for dummies

Example 1

// Classic.walk

Repeat

{

1 st street left
2 nd street right
2 nd street left

}

This .walk example shows the classic generative
psychogeographical algorithm, that urban exploration
haiku, written down like in pseudo-computer language .

Example 2

// T = Time (in minutes)
// E = Exportcode
// C = Counter

E = 2
C = 0

Repeat

{

X = E

1 st street left
2 nd street right
X street left

When 2 agents meet

{

Exchange E

C + 1

}

Count T 0 to 60
If time = 60

{

Abort to Root
Print C to socialfiction.org

}

}

Or in straightforward English:

"Your export code is 2
Repeat the following instructions; walk the first
street left, second street right, then you take the
street left that is indicated as your export code.
Every time you meet another psychogeographer you
exchange export codes. This new code will change the
3rth turn.
Remember how often you exchange export code.
When you have walked for one hour you return to the
place your are supposed to meet.
Once arrived there report the number of encounters to
socialfiction.org."

For this simple talk this would do just as well. But
when, like in the examples coming next, the functions
the applet will have to perform are getting more
complicated a verbal explanation will require a lot
more text of a very dense nature as the instructions
must be interpretable in one way only. Symbolic logic
serves the purpose of single minded communication much
better than any natural language.

All the action happens between the { } after the
Repeat command. Also notice that in this applet
individual agents participating in an experiment are
connected through the exchange of their E (Export
code). This is a feature that was not available in the
first example but without which it would be impossible
to design a psychogeographical computer: an
interconnected bunch of small applets, called .walk
software (or if you like walkware) that runs (or
rather walks) on top of the hardware, the street grid.

Example 3

// Fibonacci .walk
// 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

Z = 1
Z(x) = 0

Repeat

{
Z Left or right

Z(y) = Z
Z = Z + Z(x)
Z(x) = Z(y)

}

In example 3 we start to see the power of writing down
the rules for algorithmic walks in symbolized rather
than plain English.
This applets differs considerably from the 2 examples
above;
First: there is no succession of turns, there is only
one turn that can be left or right depending on the
situation.
So when Z(x) = 5 the psychogeographer enters the fifth
street. When this street happens to be at a crossing
with both options available take the one you like.

Second: this applet computes it's own next turn. In
example 3 this happens according to the Fibonacci
number series.
This series is infinite & following this .walk applet
to it's logical conclusions must soon becomes
surrealistic, if not downright absurd.

Example 4

// Divide.walk
// 8/2
// C = Counter

A = 8
B = 2
C = 0
E = B
Repeat

{

If E = A
{
Abort
Print C to socialfiction.org
}

C = (C+1)

C street left or right

E = (E+B)
}

Everybody knows by heart that 8 divided by 2 gives 4,
but only Slashdot creeps can divide 19 by 6 from the
top of their head & come up with the correct answer of
3,1666... With the applet in the next example you can
just do this kind of calculations. This does mean the
introduction of decimals.

In example 4, C (counter) counts the times it take to
divide a number, that is the answer to the problem
8/2, C also determines the next turn. Every variable
could be used to determine this, but using the counter
makes this count easier to remember especially when
the outcome becomes higher this might be handy.

Example 5

// Divide.walk
// 19/6
// C = Counter

A = 19
B = 6
C = 0
Cdiv = 0
Q = 1
E = B
Turn_X = 0

Repeat

{

If E > A
{
E = (E-B)
A = (A-E)
A = (A*10)
Q = (Q*10)
E = B
Turn_X = 0
}

Cdiv = 1/Q
C = (C+Cdiv)
Turn_X = Turn_X + (Cdiv*Q)

If E = A
{
Abort
Print C to socialfiction.org
}

Turn_X street left or right

E = (E+B)

}

The walk in this case means taking sequences of turns,
first the 1st to the 3rd left or right, then the first
left or right, then infinite clusters of the 1st to
the 6th turn left or right. The comma is always behind
the first cluster.

Remember that the syntax of these .walk is not fixed.
Applets can be written in any way, can mimic any known
computer language. It would be worthwhile to think of
a way of formulating statements/rules that don't
resemble the languages used in the ordinary computer
world, this would stress that .walk is not merely an
offshoot of something that is already existing but
that it is a whole new field of research.

This last applet shows how pedestrian activity can be
made to function as a non electrical computer, able to
perform difficult calculations while the agent walking
it doesn't need any mathematical skill at all. .Walk
is not only meant to platform independent it should
also be designed in such a way that everybody can
execute any applet.
At the same time the walkware is still producing
non-intuitive routes for urban exploration that is
it's main function. By connecting different applets,
all executing their own rules, doing computations in
the meantime, a giant psychogeographical computer
emerges.

The first experiments in executing .walk software were
done with variations on example 2. The main goal was
to find out the frequency of agents crossing paths
during an experiment.
The higher the frequency the easier data generated by
the individual agents are spread through the network,
this adds speed to the processing power which is in
itself correlated to the number of agents involved at
any given time.
The pace of the psychogeographers is another crucial
factor in the speed of calculations.
From past experiments it has been determined that with
small groups (8 simultaneous applets active in
Rotterdam [Nov. 2002], 6 in Londen [Dec 2002]) the
number of encounters that take place in one hour are
rather low: only once twice, often only once & just as
often no encounters at all take place. This calls for
separate .walk applets that don't compute anything
themselves but gather & transfer data through the
different nodes of the Psychogeographical Computer.
This might be done by giving them rules that are
responding to the movement of the other agents.
Because past experiments showed that generative
psychogeographical walks doesn't result in crossing
enormous distances, but rather a circular movement
around an schizoid sort of imaginary axis, these
agents might employ the tactic of patience to locate
the others.

From here .walk can be used to construct walkware like
peripatetic databases, psychogeographical artificial
memory, or .walked calculations can be fed to software
that renders visuals, sound or behaviour. Future
tutorials will outline the concepts behind this
examples of possible use of .walk.

-----

last updated 05-01-2003

.Walk walkware is released as open source

=====
http://www.socialfiction.org | http://www.socialfiction.org/psychogeography

__________________________________________________
Do you Yahoo!?
Yahoo! Mail Plus - Powerful. Affordable. Sign up now.
http://mailplus.yahoo.com
Your Reply