Stormpocalypse sends SMS alerts and Twitter updates with number of reported NYC outages along with estimated time of recovery. It does this through consuming a Con Edison outage feed and uses the Twilio and Twitter APIs to broadcast.

I’ve created a ruby gem for other developers to create their own apps using the Con Ed feeds: https://github.com/ckundo/coned/

Susan Stava for The New York Times

While there I met with Scott Tillitt of BEAHIVE - a coworking space with a vision to serve the local community – and Dan Weise of Open Space Gallery. Both Scott and Dan are of the “NoBro” (North Brooklyn) contingency, and were sympathetic to my ideas and interests around Hybrid Communities. In short, there is a space in Beacon for a collaboration.

The Beacon Triad (from left to right) - Main Street, Metro North, and Dia

Specifically, I’ve been considering a way to collaborate with the community to make an effort to bring in new visitors to Beacon, especially those already coming to the Dia (most of whom it seems do not make it past the Foundation during their visit). Hopefully, through a joint effort with BEAHIVE and the Beacon Citizen’s Network (a social network of Beacon residents), we can create even stronger community within Beacon through shared interest, while catalyzing the nascent cultural revival that is happening there.

Fallout 3, a favorite video game of mine

My new approach is to take the principals of resilient communities, specifically the self-sustaining qualities, and augment them with the resources that global and national infrastructures offer. I’m calling this approach “Hybrid Communities”. There is a clear analogy here with hybrid vehicles like the Toyota Prius, which operates on battery power when it can, but fires up the engine when it needs to.

Some communities are leaning towards a hybrid model already, at least in production. In Brooklyn for example, I can get locally grown produce at my local CSA, buy a handmade knitted cap down the street. These are pretty standard features of resilient communities. It gets really interesting when I can build a kitchen lamp with a MakerBot at NYC Resistor, or sell that knitted cap on Etsy (also in Brooklyn). These latter examples facilitate local production by leveraging global goods and services.

What this means for my work is that I will assume existing infrastructure (power, transportation, education, communications) and use use that to leverage the effects of local efforts.

Some parting thoughts:

• Could I sell the kitchen lamp on Etsy?
• Is the term “Agile Communities” a better way to describe what I’m talking about?
• see Wired Magazine’s recent article for more details on desktop manufacturing.

The plug computer is a mini linux server, meaning it can host website, databases, and applications. The open-mesh routers can then extend a mesh wifi network, making the shared applications available to the community.

Perhaps most intriguing aspects of this solution are the low cost and high portability/configurability. The hardware infrastructure can accomplished at under $200, depending on the desired network range (server is $100 and the routers are $30 each), and they could come already setup with the required (open-source) software, including pre-configured applications. Because the software is not proprietary or hardware specific, it could be easily distributed and modified. The hardware itself is componentized with a small form factor, so it too would be highly portable and configurable.

Lowering the technical barrier to setup would be critical to adoption, so I’m exploring what software and applications to include in a default package, how much documentation to include, and what pre-configured options to use in order to mitigate the time and cognitive overhead required to get a community network up and running.

revision: Blowing as input has been dropped in favor of a more intuitive interaction. Input is now someone brushing his/her hand over a patch of grass with embedded motion sensor or photocells. Game aspect will be augmented by a timer in the form of the cycle of the sun in the background, and “high scores” in the form of memory of past trees in the background of the viz.

Prototype Code (uses stereo headphones as input):

//Breathing Tree
//by Cameron Cundiff and Nobu Nakaguchi
import ddf.minim.*;
import processing.serial.*;     // import the Processing serial library

//Bubble object
class Being {
float redVal;
float greenVal;
float blueVal;
float alphaVal;
float xloc;
float yloc;
int age;
boolean left;
boolean right;
boolean center;
boolean isPregnant;
boolean isAlive;
int progeny;
int gestation;
float speed = 2;
char side;

Being(float xloc_, float yloc_, char side_) {

side = side_;

if(side == ‘L’ || side == ‘R’) {
redVal = 255;
greenVal = 40;
blueVal = 100;
alphaVal = 255;
}

else if(side == ‘C’) {
redVal = 50;
greenVal = 255;
blueVal = 0;
alphaVal = 255;
}

isAlive = true;

gestation = 0;
isPregnant = false;

xloc = xloc_;
yloc = yloc_;
age = 0;
}

void wander(float speed_) {
xloc += random(-speed_,speed_);
yloc += random(-speed_,speed_);
}

void incrementValues() {
age++;
redVal -= 20;
if(alphaVal > 30) {
alphaVal–;
}
}

void rest() {
isPregnant = true;
}

void checkAge() {
if(age > maxAge * 5) {
isAlive = false;
}
}

void drawMe() {
noStroke();
fill(redVal, greenVal, blueVal, alphaVal);
ellipse(xloc, yloc, 5, 5);
wander(speed);
}

}

//Managing class
class World {

//instantiate objects
void spawn(int num, char side) {

for (int i = 0; i < num; i++) {

if(side == ‘L’) {
bubbles.add(new Being(leftPos, height/2, ‘C’));
}
else if(side == ‘R’) {
bubbles.add(new Being(rightPos, height/2, ‘C’));
}

else if(side == ‘C’) {
bubbles.add(new Being(centerPos, height/2, ‘C’));
}

}
}

//multiply at location
void procreate(Being being1, Being being2) {
Being b1 = being1;
Being b2 = being2;
Being b3 = new Being(b1.xloc + random(-5,5), b1.yloc + random(-5,5), ‘C’);
bubbles.add(b3);
b1.isPregnant = true;
b1.progeny++;
b2.progeny++;

}

//look for mate
void scan(Being h_) {
if(h_.age < consentAge*10 || h_.progeny > maxChildren) {
// do nothing
}
else if(h_.isPregnant) {

if(h_.gestation < gestationPeriod * 10) {
h_.gestation++;
}
else {
h_.isPregnant = false;
}
}
else {
for(int i=0; i<bubbles.size(); i++) {
for(int j=0; j<bubbles.size(); j++) {
if (i != j) {
Being b1 = (Being) bubbles.get(i);
Being b2 = (Being) bubbles.get(j);
//check proximity
if(dist(b1.xloc, b1.yloc, b2.xloc, b2.yloc) < territory && b1.side != b2.side) {
if(random(1) > chanceToScore) {
procreate(b1, b2);
}
}
}
}
}
}
}
}

Minim minim;
AudioInput in;

int consentAge = 16; //can vary
int maxAge = 2000; //chance to die before this value. increment based on population size, size life expectancy should increase with the advent of techn
float gestationPeriod = .75; //fixed to 9 months, with a 2 week buffer
float territory = 15;
int maxChildren = 2;//inverse to population size
//int maxHumans = 1000;//for debugging
float chanceToScore = .99;//inverse to population size. Fewer options equals better chance to score!

float leftPos;
float rightPos;
float centerPos;

color c1 = color(0, 0, 0);
boolean isLoud = false;

ArrayList bubbles = new ArrayList();
World bigBrother = new World();

void setup(){
size(400, 400, P3D);

leftPos = width/4;
rightPos = width – width/4;
centerPos = width/2;

// always start Minim before you do anything with it
minim = new Minim(this);
minim.debugOn();
// get a line in from Minim, default bit depth is 16
in = minim.getLineIn(Minim.STEREO, 16);
}//end setup

void draw(){

stroke(255);
smooth();

background(c1);

float leftVal = 0.0;
float rightVal = 0.0;

int multiplier = 100000;

for(int i = bubbles.size()-1; i >= 0; i–) {
Being h = (Being) bubbles.get(i);
if (!h.isAlive) {
bubbles.remove(i);
}
}

for(int i = bubbles.size()-1; i >= 0; i–) {
Being h = (Being) bubbles.get(i);
h.drawMe();
h.incrementValues();
h.checkAge();
}

for(int i = 0; i < in.bufferSize() – 1; i++) {

leftVal = in.left.get(i)*multiplier;
rightVal = in.right.get(i)*multiplier;

float n = abs(in.mix.get(i))*multiplier;

bigBrother.spawn(int(leftVal/100), ‘L’);
bigBrother.spawn(int(rightVal/100), ‘R’);

println(n);
}//end for

}//end draw

void stop()
{
// always close Minim audio classes when you are done with them
in.close();
minim.stop();

super.stop();
}//end stop