If you had told me 2 years ago that I’d one day watch governments fall 140 characters at a time, I’d have called you crazy. Is that really what happened? Or is Twitter just a part of a larger paradigmatic shift, taking hold in younger generations. I do not question its truth claim: it does not matter. The idea behind building a 3D immersive world of Twitter data is to offer the general public an opportunity to re-imagine their relationship with technology. The goal of the game is to find the original tweet. It’s a game of exploration.

Through a process of cultural analytics, this 3D Unity game is designed to DEFAMILIARIZE its user from what it thinks the culture of Twitter, or the culture of the Middle East, or the culture of Arab activism, revolution, and social networking might be all about.

Here are a couple of important footnotes on the art of “defamiliarization:”

P. B. Shelley in his, “Defence of Poetry” (1821), and of several modern, Russian formalist critics, made the claim it is a distinctive feature of literature, especially poetry, that it tears away what Shelley called the ‘veil of familiarity’ from the world, making us look at it afresh. 1. “A Defence of Poetry” by P.B. Shelley.

.”..it is necessary to make it strange, or defamiliarize it, in order to open its design space. Critical approaches to technology design are of both practical and social importance in the home. Home appliances are loaded with cultural associations such as the gendered division of domestic labor that are easy to overlook. Further, homes are not the same everywhere—even within a country. Peoples’ aspirations and desires differ greatly across and between cultures. The target of western domestic technology design is often not the user, but the consumer. Web refrigerators that create shopping lists, garbage cans that let advertisers know what is thrown away, cabinets that monitor their contents and order more when supplies are low are central to current images of the wireless, digital home of the future. Drawing from our research in the United States, the United Kingdom, and Asia, we provide three different narratives of defamiliarization. A historical reading of American kitchens provides a lens with which to scrutinize new technologies of domesticity, an ethnographic account of an extended social unit in England problematizes taken-for-granted domestic technologies, and a comparative ethnography of the role of information and communication technologies in the daily lives of urban Asia’s middle classes reveals the ways in which new technologies can be captured and domesticated in unexpected ways. In the final section of the article, we build on these moments of defamiliarization to suggest a broad set of challenges and strategies for design in the home. 2. From “Making by Making Strange: Defamiliarization and the Design of Domestic Technologies” By GENEVIEVE BELL, Intel Research; MARK BLYTHE, University of York, and PHOEBE SENGERS, Cornell University.

Accordingly, every design choice along the way has been a choice to defamiliarize the player. If I were to ask a sample of 100 people who live in any major city in the world about Twitter, many would at least know about it and might provide vague, ephemeral adjectives to describe what they imagine Twitter to be and how people interact with it. Perhaps a black, outer space –like, future-fantasy aesthetic would predominate the scene.

And so, in an attempt, to ‘lift the veil of familiarity’ around Twitter – I built a space that had organic things like trees and a blue sky. The choice to make the ground white seemed odd -– and gave a sense of lightness on a topic that doesn’t sound so light -– Middle East Revolutions. And the music too was chosen to make you think, “huh, that’s not what I was expecting.” What was the user expecting? And why did the user come with such expectations?

Likewise, the choice to have a human 3rd person player was a choice to make the unreal world of Twitter seem real – and give it a strong human perspective….grounded. The elevation of the ground represent the number of tweets and retweeting so that the player gets a sense of immersion in the tweets themselves – and the maneuverability was meant to be challenging.

Aesthetically, it is an attempt to transform a 2D data visualization into a 3D immersive environment. My challenge here was to make a live streaming 3D data visualization. Here is the original 2D image:

HOW TO PLAY:
The green waterfalls are Arabic tweets, the blue waterfalls are English tweets, and the red ones are French tweets. The more elevated the terrain the more retweeting occurred. Your mission is to find the original tweet in each language. The winners get access to the data.

The data itself will appear in CSV downloadable links. You will be able to download four distinct CSV files for each of the hashtags you find. The four CSV files will include (1) our statistics on the data by day; (2) our statistics on the data by hour; (3) our statistics on the data by minute; (4) the original, raw tweet data. This will appear in a database structure of rows and columns for the player to use in any imaginative way.

This shows an early version of my Wu Xing-inspired cellular automata, taking the form of a Reaction-Diffusion model.  This isn’t as commented and a little more obscure than the DLA code, but you should be able to copy/paste the code into processing and get a simple reaction/diffusion cellular automata in Processing:

class WuXingCell

{
float[] element;
}; 

int worldScale = 8;
int worldSize = 64;
int mode = 1;
WuXingCell[][] world;
WuXingCell[][] nextWorld;
color[] WuXingColor;

float waterLevel = .25;

int dayBand = 0;

float natLog = 0.36787944118;
float eLog = 2.7182818284;

float growRate = .2;
float destroyRate = .11;
float insultRate = .1;

float growThresh = .1;
float destroyThresh = .2;
float insultThresh = .4;

float[] elementFlow; //how much is moved when it erodes
float[] elementStrength; //when element decides to erode
float[] elementDistScale; //distance from strongest points
float[] elementReactivity;

int dominantElement = 0;

float seaLevel = 0;

int water = 0; //we do this so the code is more readable, also showing the cyclical order
int wood = 1;
int fire = 2;
int earth = 3;
int metal = 4;

int mouseElement = 0;

float[] alchemyAmounts;
float[] alchemyAdditives;

boolean elementPoles = true;

boolean react = false;

void updateWorld()
{
for (int i = 0; i < worldSize; i++)
{
for (int j = 0; j < worldSize; j++)
{
for (int k = 0; k < 5; k++)
{
world[i][j].element[k] = nextWorld[i][j].element[k];
//print(“.”);
}
}
}
}

void ProcessWorld()
{
for (int i = 0; i < worldSize; i++)
{
for (int j = 0; j < worldSize; j++)
{
for (int k = 0; k < 5; k++) //imagine 5 buckets in each cell, we look at them and their neighbors…
{
alchemyAmounts[k] = world[i][j].element[k];

for (int adjI = -1; adjI < 2; adjI++)
{
for (int adjJ = -1; adjJ < 2; adjJ++)
{
alchemyAmounts[k] += (world[LoopVar(i + adjI)][LoopVar(j + adjJ)].element[k]) * (0.125); //0.125 = 1/8th, averaging the 8 adjacent cells
}
}
}

ProcessAlchemy(); //now that we have the amoutns, process what they do…

for (int k = 0; k < 5; k++) //a little bit of hacky averaging, and updating the old board
{
alchemyAmounts[k]/=2;
nextWorld[i][j].element[k] = alchemyAmounts[k];
}

}
}
}

void ProcessAlchemy()
{
float[] newAlchemy = new float[5];
float[] fractionOf = new float[5];
float totalAmount = 0;
for (int k = 0; k < 5; k++)
{
newAlchemy[k] = alchemyAmounts[k];
totalAmount += alchemyAmounts[k];
}

for (int k = 0; k < 5; k++)
{
fractionOf[k] = totalAmount/alchemyAmounts[k];
}

int grandParent, parent, child, grandChild;

for (int k = 0; k < 5; k++) //figure out what elements are “parent”, “child” etc. relative to the one you’re on
{
grandParent = 6;
parent = 6;
child = 6;
grandChild = 6;

if (k == water)
{
grandParent = earth;
parent = metal;
child = wood;
grandChild = fire;
}

if (k == wood)
{
grandParent = metal;
parent = water;
child = fire;
grandChild = earth;
}

if (k == fire)
{
grandParent = water;
parent = wood;
child = earth;
grandChild = metal;
}

if (k == earth)
{
grandParent = wood;
parent = fire;
child = metal;
grandChild = water;
}

if (k == metal)
{
grandParent = fire;
parent = earth;
child = water;
grandChild = wood;
}

elementReactivity[k] = 1;// *= 1.5; //how much do we react the elements (scalar, multply by this amount)
//natLog = .3;
newAlchemy[k] += (alchemyAmounts[parent] * natLog);
newAlchemy[k] -= (alchemyAmounts[child] * natLog);
if (alchemyAmounts[grandParent] > alchemyAmounts[k]) //grandfather destroys…
{
newAlchemy[k] -= (alchemyAmounts[grandParent] * natLog);
}

// else //…or it’s too big and we’re insulted
if (alchemyAmounts[grandChild] > alchemyAmounts[k])// //grandfather destroys…
{
newAlchemy[k] -= (alchemyAmounts[grandParent] * natLog);
}

if ( newAlchemy[k] > 1.0)  newAlchemy[k] = 1.0;
if ( newAlchemy[k] < 0.0)  newAlchemy[k] = 0.0;
}

for (int k = 0; k < 5; k++)
{
alchemyAmounts[k] = newAlchemy[k];
}

}

void draw()
{

dominantElement += 1;
if (dominantElement >= 5) dominantElement = 0;

ProcessWorld();
ProcessAlchemy();

updateWorld();
background(0);
color pixelColor = color(0,0,0);

float finRed, finGreen, finBlue;

if(keyPressed) {

if (key == ’0′) {
alchemyAdditives[water] += .1;
//mouseElement = water;
}

if (key == ’1′) {
alchemyAdditives[wood] += .1;
//mouseElement = wood;
}

if (key == ’2′) {
alchemyAdditives[fire] += .1;
//mouseElement = fire;
}

if (key == ’3′) {
alchemyAdditives[earth] += .1;
//mouseElement = earth;
}

if (key == ’4′) {
alchemyAdditives[metal] += .1;
//mouseElement = metal;
}

if (key == ‘r’) {
for (int k = 0; k < 5; k++)
{
alchemyAmounts[k]= random(0,1.0);
}
}

if (key == ‘e’) {
for (int k = 0; k < 5; k++)
{
alchemyAmounts[k]= 0;
alchemyAdditives[k] = 0;
}
//mouseElement = water;
}

if (key == ‘t’) {
for (int k = 0; k < 5; k++)
{
alchemyAmounts[k] += alchemyAdditives[k];
alchemyAdditives[k] = 0;
}
//mouseElement = water;
}

}

float maxElement = 0;
int theMaxElement = 0;
int numElements = 0;

for (int i = 0; i < worldSize; i++) //do a bunch of comparisons to get colors, but we’re basically looping through the board and drawing
{
for (int j = 0; j < worldSize; j++)
{
finRed = 0;
finGreen = 0;
finBlue = 0;

maxElement = 0;
theMaxElement = 0;

numElements = 0;

for (int k = 0; k < 5; k++)
{
if (world[i][j].element[k] > maxElement)
{
maxElement = world[i][j].element[k];
theMaxElement = k;
}

if (world[i][j].element[k] > 0)
{
numElements++;
}

finRed += (red(WuXingColor[k]) * world[i][j].element[k]);
finGreen += (green(WuXingColor[k]) * world[i][j].element[k]);
finBlue += (blue(WuXingColor[k]) * world[i][j].element[k]);
}

finRed /= numElements;
finGreen /= numElements;
finBlue /= numElements;

if (((world[i][j].element[earth] + world[i][j].element[metal])/2) <= seaLevel)
{
pixelColor = color(0,0,seaLevel);
}
else
{
pixelColor = WuXingColor[theMaxElement];//color(finRed,finGreen,finBlue);
//pixelColor *= world[i][j].element[theMaxElement];
//pixelColor = color(world[i][j].element[3],world[i][j].element[2],0);
switch(theMaxElement)
{
case 0:
pixelColor = color(0,world[i][j].element[0],world[i][j].element[0]);
break;

case 1:
pixelColor = color(0,world[i][j].element[1],0);
break;

case 2:
pixelColor = color(1.0,0,0);
break;

case 3:
pixelColor = color(world[i][j].element[3],world[i][j].element[2],0);
break;

case 4:
pixelColor = color(world[i][j].element[3],world[i][j].element[3],world[i][j].element[2]);
break;
}
pixelColor = color(finRed,finGreen,finBlue);//color(finRed,finGreen,finBlue);
}

if (((world[i][j].element[earth] + world[i][j].element[earth])/2) > seaLevel)
{
//pixelColor = color(0,(world[i][j].element[earth] + world[i][j].element[earth])/2,0);
}
else
{
//pixelColor = color(0,(world[i][j].element[earth] + world[i][j].element[earth])/2,.75);
}

if (((world[i][j].element[earth] + world[i][j].element[metal])/2) <= seaLevel)
{
//pixelColor = color(0,0,seaLevel);
}
else
{
//pixelColor = color(finRed,finGreen,finBlue);
}

//    if (elementVision != 5) pixelColor = color(0,world[i][j].element[elementVision],0);
//pixelColor = color(0,world[i][j].element[metal],0);

// pixelColor = color(0,0, world[i][j].element[0] );

//pixelColor = color (world[i][j].element[0],0,0);
//set (i * 2,j * 2,pixelColor);

//set (i * 1,j * 1,pixelColor);
fill(pixelColor);
rect(i * worldScale, j * worldScale, (i * worldScale) + (worldScale – 1), (j * worldScale) + (worldScale – 1));
}
}

}

float Clamp(float tempVar, float low, float high)
{
if (tempVar < low) tempVar = low;
if (tempVar > high) tempVar = high;
return tempVar;
}

int LoopVar(int theVar) //clamps var to make sure we loop, assume error is never more than one or two “off map”
{
if (theVar < 0)
{
theVar += worldSize;
}

if (theVar >= worldSize)
{
theVar -= worldSize;
}

return theVar;
}

void setup()
{
//worldScale = 2;
frameRate(24);
colorMode(RGB, 1.0);
size(worldSize * worldScale,worldSize * worldScale);
world = new WuXingCell[worldSize][worldSize];
nextWorld = new WuXingCell[worldSize][worldSize];

//growRate = .2;
//destroyRate = .2;
//insultRate = .1;

WuXingColor = new color[5];

WuXingColor[water] = color(0,0,1);//water
WuXingColor[wood] = color(0,1,0);//wood
WuXingColor[fire] = color(1,0,0);//fire
WuXingColor[earth] = color(1,1,0);//earth
WuXingColor[metal] = color(1,1,1);//metal

elementFlow = new float[5];
elementStrength = new float[5];
elementDistScale = new float[5];
elementReactivity = new float[5];

alchemyAmounts = new float[5];
alchemyAdditives = new float[5];

for (int k = 0; k < 5; k++)
{
elementFlow[k] = 0;
elementStrength[k] = 0;
elementDistScale[k] = 1;
elementReactivity[k] = 1;

alchemyAmounts[k] = 0.5;//random(0,1.0);
alchemyAdditives[k] = 0;
}

elementFlow[earth] = .05; //earth
elementStrength[earth] = .1;

//elementFlow[metal] = .25; //metal
//elementStrength[metal] = .3;

elementFlow[metal] = .4; //metal
elementStrength[metal] = .5;

elementFlow[fire] = .21;
elementStrength[fire] = .11;

for (int i = 0; i < worldSize; i++)
{
for (int j = 0; j < worldSize; j++)
{
world[i][j] = new WuXingCell();
world[i][j].element = new float[5];
for (int k = 0; k < 5; k++)
{
world[i][j].element[k] = random(.1,.9);//.25 + random(0,.5);//random(0.0,1.0);//.5;
// world[i][j].element[k] = 0.5;
//world[i][j].element[k]/=255;
}
//world[i][j].element[0] = .6;

//world[i][j].element[0] = .2;

nextWorld[i][j] = new WuXingCell();
nextWorld[i][j].element = new float[5];
for (int k = 0; k < 5; k++)
{
nextWorld[i][j].element[k] = 1;//random(0,1);
}

//print(” “);
//print(world[i][j].terraHeight);
}
}

//ProcessHeat();
}

Here is the Diffusion Limited Aggregation code, to make the lighting-bolt, ice-crystal patterns – I’ve had trouble posting the working Processing sketch here before but here’s the code.  Copying and pasting into a new sketch should do the trick:

int[][] world;
int[][] nextWorld;
int worldSize = 256;
float time = 0;
color black, purple, white;
int wl,wr,wt,wb; 

void setup()
{
colorMode(RGB, 1.0);
size(worldSize,worldSize);

black = color(0,0,0);
purple = color(1,0,1);
white = color(1,1,1);

//Cellular Automata usually needs two arrays, you refer to one to build the next, here
//we initialize both:

world = new int[worldSize][worldSize];
nextWorld = new int[worldSize][worldSize];

for (int i = 0; i < worldSize; i++)
{
for (int j = 0; j < worldSize; j++)
{
world[i][j] = 0;
nextWorld[i][j] = 0;
}
}
world[worldSize/2][worldSize/2] = 2;
wl = wr = wt = wb = worldSize/2;
}

void ProcessWorld() //0 = black/balnk, 1 = moving/purple, 2 = white, crystallized
{
int randDir;
int ib, jb;

for (int i = 0; i < worldSize; i++) //loop through world and compare cells
{
for (int j = 0; j < worldSize; j++)
{

if (CheckAdj(i,j,3)) //if area has something, don’t do anything, otherwise…
{
}
else //…create a wandering cell
{
if (random(0,100) < 2) nextWorld[i][j] = 1;
}

if (world[i][j] == 2) //keep the crystallized white cells
{
nextWorld[i][j] = 2;
}
if (world[i][j] == 1) //if we have a purple, wandering cell, we have a little more to do…
{
if (CheckAdj(i,j,1)) //if we’re next to a crystal cell, crystallize this one.
{
nextWorld[i][j] = 2;
if (i < wl) wl = i; //make sure the borders are ok
if (i > wr) wr = i;
if (j < wt) wt = j;
if (j > wb) wb = j;
}
else //if we’re _not_ next to a crystallized cell, we wander
{
nextWorld[i][j] = 0; //we move away from where we are, leaving it blank
randDir = (int)random(0,4); //move a random direction, North, South, East, or West…
ib = i;
jb = j;

if (ib < 1) ib = 1; //respect the boundaries, don’t move off the board!
if (ib > (worldSize – 2)) ib = worldSize – 2;

if (jb < 1) jb = 1;
if (jb > (worldSize – 2)) jb = worldSize – 2;

switch(randDir){ //here we move the purple cell to a new, blank cell
case 0:
nextWorld[(ib + 1)][jb] = 1;
break;

case 1:
nextWorld[(ib - 1)][jb] = 1;
break;

case 2:
nextWorld[ib][(jb - 1)] = 1;
break;

case 3:
nextWorld[ib][(jb + 1)] = 1;
break;
}
}
}
}
}

for (int i = 0; i < worldSize; i++) //now, we move the newly calcualted “nextWorld” back to the original, and start again…
{
for (int j = 0; j < worldSize; j++)
{
world[i][j] = nextWorld[i][j];
}
}

}

boolean CheckAdj(int i, int j, int rad) //compare the adjacent cells, return if there’s a crystallized cell
{
int x = i;
int y = j;
boolean adj = false;

int ixb,iyb;

for (int ix = x – rad; ix <= x + rad; ix++)
{
for (int iy = y – rad; iy <= y + rad; iy++)
{
ixb = ix;
iyb = iy;

if (ixb < 0) ixb = 0; //make sure we stay in borders of cell, do not want to look beyond the borders…
if (iyb < 0) iyb = 0;

if (ixb > worldSize – 1) ixb = worldSize – 1;
if (iyb > worldSize – 1) iyb = worldSize – 1;

if (world[ixb][iyb] == 2)
{
adj = true;
}
}
}

return adj;
}

void draw()
{
ProcessWorld();

int ib,jb;

for (int i = 0; i < worldSize;i++)  //simply loop through and draw the array
{
for (int j = 0; j < worldSize; j++)
{

ib = i;
jb = j;

if (ib < 1) ib = 1;
if (ib > (worldSize – 2)) ib = worldSize – 2;

if (jb < 1) jb = 1;
if (jb > (worldSize – 2)) jb = worldSize – 2;

if (world[i][j] == 0) //blank cell
{
set(i,j,black);
}

if (world[i][j] == 1) //purple wanderers
{
set(i,j,purple); //comment this out and put in the next line if you want invisible wanderers
//set(i,j,black);
}

if (world[i][j] == 2) //white, crysal cell
{
set(i,j,white);
//print (“Boo!”);
}
}
}
}

Rebecca Allen’s BUSH SOUL and EMERGENCE system, designed in 1998:  ”…three interactive art installations that explore the role of human presence in a world of artificial life. A person’s “soul”, represented as a sphere of energy, enters a virtual “bush” that is alive and responsive. The world’s inhabitants are brought to life through programs that define their behaviors and desires. A force-feedback joystick provides both navigation and tactile sensations, connecting one’s physical body and virtual soul. Through the joystick one can feel the “energy” of the environment as vibrations emanating from certain creatures and significant places in the virtual world.”

More about CODEX SERAPHINIANUS here.

Mitchell Joaquim‘s generative architecture projects include an “In Vitro Meat Habitat” and Peristaltic City

For this reason, I have begun to see the revealing of Umbilicus as one told by a veteran of the space – Perhaps, like the white man in The Last King of Scotland or the sailor in Heart of Darkness, a person that has seen the soul of Umbilicus and lived to tell about it. But perhaps not that heavy; Rather, I prefer to think of it as Mowgli, sitting in a large book-filled den in England, offering a glimpse of the jungles of India to an enraptured best friend.

For Umbilicus, the central defining moment has always been the blocking of the bridge for the poor, the Oche. So I imagine this native, telling his story in a house, starting with an explanation of the bridge.

“The Bridge was everything, our connection to the jungles that provided us with food and wood. And when one side blocked the other from accessing it out of fear, the bridge became everything we were terrified of.”

Thus, I saw it fitting to imagine the view from the path of the Oche, looking up at this bridge. A might slab of rock created by the entire community, the Oche are now forced to look up at it as if it was a wall forcibly separating them from the Vilna.

From the view of the Vilna, however, the act was necessary and preventative. And the community continued to document the Oche, separating them from mentally and socially from Vilna culture, eyeing their activities with suspicion. When the Oche created a path into the jungles themselves, out of a dam they created at the foot of the bridge, the path was considered a smuggler’s route, a thing of illegality and dangerous activity. The Oche, in an act of solidarity and defiance, would light torches as they passed through the route at night, so that there could be no denying that people were traversing through it. Thus, Vilna looking at the path from the bridge would eye it frustratedly, worried about what weapons and dangers were being brought through that route, yet knowing that their government was entirely unable to address this. 

This postcard showcases several locals of Scryptyria, and tries to entice writers to come and visit. It does so in a fairly conventional way, treating the land as if it were a vacation spot. In a way, it does serve as a vacation spot, where writers take a break from writing, and try to figure out what next to write about.