Bleecker has been pestering me to write this for a while now, but I’ve been wrestling with my point of view. Matt Webb has written a lovely piece here about the evolving notion of “product”, which has spurred me on, so let’s give it a go.

Matt Ward recently reminded me of an awkward conversation I had with BERG’s Matt Jones (there are a lot of Matt’s in here) about what constitutes a “product”. I steadfastly defended the tangible, but Jones was more fluid with his definition including services, content, the digital and the physical. I’m happy to admit that in retrospect I was wrong – clearly wrong, but why was I so inflexible? Why was I so dogmatically fixated on objects as the be-all and end-all definition of a product? My defensiveness began to bother me until I realized recently that I wasn’t defending an idea, I was defending my trade.

I like things, I make and draw things, things you can touch, hold, sit in or on. Things made of stuff, things hewn from bigger lumps of other stuff or molten stuff squeezed into holes. I’m an industrial designer at heart, and I’m saddened by what’s happened to my craft. We were once the kings of things, but for a variety of reasons I think we’re in danger of being left behind. As Bueller said “life moves pretty fast, if you don’t stop and look around once in a while you could miss it”.

In the early years of the 21st century, the Industrial Design world fell to sleep. Whilst it slept a new breed of digital designers emerged, keen to render their ideas in three dimensions. Tools developed quickly, became cheaper and more ubiquitous, and whilst the industrial designers gazed into their huge screens to interrogate the acceleration of a curve across a surface, other things began to appear. Real things made of plastic and metal, with blinking lights and power cords. But these things weren’t from the hands of industrial designers, they were from the hands of the Bay area startups, the digital design labs, hell even the ad agencies.

Making became the talk of the town, and to some extent it still is. We’re in the first stumbling days of the Internet of Things, and are increasingly seeing the paper thin definition between digital and tangible falling away. It’s all up for grabs, and some are grabbing more than others. The more groovy folks I know from the digital world fully understand the difficulties and realities of shipping products, and appreciate the unique skills of a good industrial designer, but there are many who don’t. They see a world of instantly printed, maker bot-ed, 3D sintered, laser cut products, and see no need for a separate skilled individual.

Let’s take a little step back. Remember Flash when Macromedia had the reins? Remember how excited everyone was? A generation of graphic designers found they were able to simply make things move on screen, in a browser, online. Many of them made a mental and professional leap and began referring to themselves as ‘web designers’. Some made the leap successfully, but for many the romance was short lived. The reality of actually producing content for the web was way more complex than getting text to float across the screen or making an intro animation. It was hard. It required serious programming chops, it was like a whole different profession. For this reason, many of the graphic designers I knew returned to their poster design, font development and annual reports, leaving web development to those more experienced and capable of delivering it.

Today’s emergent manufacturing tools are tantalizing indeed, and have given designers of all ilks access to manufacturing techniques hitherto out of technical or financial reach. It’s now simple for a couple of fairly inexperienced guys to feasibly produce products for sale, which is fantastic, but let’s take a critical look at a few of these products. How many of you have invested in a cool thing on Kickstarter only to receive constant emails about how expensive tooling is, or how hard it is to source PSU’s, or how the team massively under-budgeted the production? There have been many projects which simply ground to a halt because the Matter Battle was just too tough, before we even get into the debating the dubious legal position of these devices (CE mark anyone?)

Rapid prototyping techniques are to real products what the play-doh fun factory is to real manufacturing. Things need to exist with integrity rather than just to exist, there are standards which need to be maintained. A rapid printed thing is cool, but to produce a product for mass consumption requires a whole new level of thinking and experience. A good industrial designer can provide this.

Before we get carried away, this needs to be a two way deal. Industrial designers need to wake up and embrace the ebullient folks in the digital world, and work together to deliver real things well. Industrial designers have tended to shy away from the scary worlds of UI, UX, web development and programming, as if they were some alien entities. I see industrial design moving from an experimental realm and into a delivery function, where surfaces are created to ‘skin’ the doohickey spat out from an engineering or development center. That’s not good enough. As industrial designers we need to understand that what we know how to do is golden. We should join in, get involved, build ideas together with digital designers rather than steadfastly holding our corner. We need to do this soon, because the digital guys are keen, and we’re the dinosaurs.

If industrial design is to survive beyond a word of styling and surfaces it needs to embrace the joie de vivre of our digital design brethren, and if you are an Arduino tinkering, web-centric designer, I’d encourage you to look beyond those white dusty 3D things your friends are all excited about. I fully embrace the emergent era of the post-disciplinary designer, but we have to be honest with ourselves and understand specialisms.

Making things is hard. Really hard. Don’t let anyone tell you anything different.

Isla Lyddle End 2050

Isla Lyddle End Beach (Lyddle End 2050)

Isla Lyddle End Map (Lyddle End 2050)

For Russell’s speculative modelling provocation, I was sent a Hornby Jubilee Clock Tower. I quote Mr. Davies:

How about I get a load of Lyddle End properties and we try and build a version of what we think Lyddle End might be like in 2050? Everyone who wants one gets a little building and they have to alter it, mod it, change it, play with it, to reflect how they think the world will be in 42 years time. Then, we’ll put them all together, either physically or through the magic of photography, and see what it might tell us about our visions of the future. I can’t help thinking we might be able to build ourselves a rather intriguing speculative diorama.

After meeting Russell at Design Engaged and feeling a certain kinship around our shared interest in the old Canon A-1 and design provocation generally, I signed up to participate. My first draw was a wholly different, participatory kind of design process. One that allows speculation to involve not only thinking but making, crafting and without the usual constraints that might go into thinking about a future that’s only one product cycle out. Mid century fictional futures. Perfect. Very Design Fiction-y.

At first, I wasn’t entirely sure what the heck a Jubilee Clock Tower might be, so I asked Rhys, with whom it is my good fortune to sit adjacent to in the studio and who got a Hornbee Flower Shoppe, and he explained that these things are clocks constructed to celebrate the Golden or Diamond Jubilees of the British crown. It sat on my desk, got twirled about, mulled over, discussed, peppered up in various ways until basically I knew I’d have to do something least I fail in my mission.

Blinding insight befell. I saw a future for Lyddle End that revealed impending environmental challenges, that signaled the possibilities for vast, almost impossible to imagine cultural shifts and that was undergirded by a romantic notion I have with stalwart Britishness to make do despite overwhelming odds.

Isla Lyddle End lies on the far west of the British Archipelago. It is the largest of the western islands in what was once the continuous land mass known as Hornbyshire. Isla Lyddle End celebrates the Golden Jubilee of The Grand Iman of Britain HH Patel bin Windsor with a minaret clock tower, constructed of hard-pack, molded synthetic carbon nodules in full compliance with the Rock and Soil Conservation Act of 2038. Isla Lyddle End is only a 40 minute fan boat ride from Paddington Sea Station. Bring your Wellies! Isla Lyddle End is well-swamped twice a day, and near coastal areas submerge at the day’s first tide.

Britain in 2050 has a monarch of mixed cultural ancestry, is 98% sunk under rising seas, has traces of Spanish in its idiolect and recognizes Muslim culture in its public monuments.

Isla Lyddle End Clock Tower Minaret Sea Fort (Lyddle End 2050)

Thursday January 22 14:35

Thursday January 22 14:36

Thursday January 22 14:36

Wednesday January 21 19:21

It was a simple matter of Dremel’ng the top off of the original Jubilee Clock Tower, modeling a simple version of what I think the top of a Minaret in 2050 might look like, plastic-printing it and plopping it on top. Some photography late last night suggested that there need to be something besides sea and shore, so I put in some photos of the Maunsell Sea Forts for context. The British Archipelago map is actually an algorithmic rendering of “my” Southern California generated by GPS tracks. There’s a hunk of the westside (Venice Beach and Santa Monica), bits toward downtown and Hollywood/Silverlake/Los Feliz, little jaunts further south, and my coastal commute up the Pacific Coast Highway to the studio in Calabasas where I decided Isla Lyddle End should reside.

cf russelldavies.typepad.com/planning/2008/11/lyddleend2050….
cf lyddleend2050.tumblr.com/

Thanks for the fun project Russell!
Continue reading Isla Lyddle End 2050

Autonomous Game Controllers


Continuing on my strange pursuit of designing weird interfaces that disrupt conventional game interaction rituals, I put together a bit more of my “PSX” project. You probably don’t recall, but this is the project where I’ve created a little “dongle” that can fool a PS2 (or Playstation 3, as it turns out..) into thinking that the dongle is actually a Playstation controller. You can also hook up a real Playstation controller to it and it can “read” the controller buttons and joystick and pass that data through, or do whatever you want with it. It appears as an TWI/I2C device to anything that talks to TWI/I2C devices..like my favorite TWI/I2C talking thing — the Arduino.

You can see here that the dongle — the white box with those annoying, huge Playstation connectors on either end, one male, one female — has four wires going into it. Those are for power, ground and the TWI signals, SDA and SCL. The power and ground are necessary because the Arduino (at least this one here) and the dongle run at different voltages. The Arduino is a 5V device, while the dongle is a 3.3V device, so there’s some level shifting going on inside there.



So, that’s all fine. It works, etc. But then the question that’s actually more intriguing than building the thing..what do you do with it?

Well, I have some ideas, including hooking up a bike to it and attaching a giant human form kick-boxing dummy to play old school fighting games. For some early fun and nonsense, I connected a Wii Nunchuck up to it to control Playstation games with Wii-y gestures and stuff. Which could be cool if I find the right game, or spend a little more time thinking things through rather than just writing and revising microcontroller firmware to make a TWI controllable device, and doing Catia to CAD-up and print plastic enclosures.

But, in the meantime, I decided to do an absolutely crucial bit of game science. Something that I am entirely sure is mulled over constantly, but never properly investigated. The question is best stated thusly: how long would it take the Little Prince to roll up an entire room based on a random path algorithm?

How long indeed. Well, short answer is a long time. I let it go for about 70 minutes, after which he had just 10 things to go in a particularly tricky location that required rolling across a narrow bridge. At this point, I took over..but check out the 8x speed video anyway!

Katamari Autonomy from Julian Bleecker on Vimeo

I wrote a quick little Arduino code for my PSX dongle to have the Little Prince roll forward and then, after a few moments, make a random directional change. (Or stop, take a load off and look around the world.)

This was all done by sending TWI commands to the appropriate registers in my little DIY Playstation 2 controller emulator. All the buttons and the joysticks can be emulated as to their state through a series of write-to registers. If there’s a controller stuck in the other side of the dongle, there are a complement of read-from registers so you can see if any of the buttons are pressed and how much the joysticks are displaced. (I set up an “escape” buttons sequence — pressing both L2 and R2 — to bring control back to the normal joystick so I could navigate menus or take control over, which I had to do after I realized, with four items left, the completion of cleaning the room would probably not happen before the universe ran out of steam.)

Here’s the Arduino code. Pretty straight forward Wire / TWI library stuff.

#include "nunchuck_funcs.h"

#define is_bit_clear(a, n) (0 == (a & (1<<n)))
#define is_bit_set(a, n)  (1 == (a & (1<<n))

#define is_button_pressed(a, button) is_bit_clear(a, button)
#define is_button_released(a, button) is_bit_set(a, button)

#define BTN_SELECT 0
#define BTN_L3 1
#define BTN_R3 2
#define BTN_START 3
#define BTN_UP 4
#define BTN_RIGHT 5
#define BTN_DOWN 6
#define BTN_LEFT 7
#define BTN_L2 8
#define BTN_R2 9
#define BTN_L1 10
#define BTN_R1 11
#define BTN_TRIANGLE 12
#define BTN_CIRCLE 13
#define BTN_X 14
#define BTN_SQUARE 15

// register addresses in the PSX I2C device
#define W_BUTTONS_0 0x00 // (, ^, start, R3, L3, select
#define W_BUTTONS_1 0x01 // (square, x, o, triangle, R1, L1, R2, L2)
#define W_RIGHT_X 0x02
#define W_RIGHT_Y 0x03
#define W_LEFT_X 0x04
#define W_LEFT_Y 0x05

#define R_BUTTONS_0 0x12 // (, ^, start, R3, L3, select)
#define R_BUTTONS_1 0x13 // (square, x, o, triangle, R1, L1, R2, L2)
#define R_RIGHT_X 0x14 // a value from 0x00 - 0xFF
#define R_RIGHT_Y 0x15 // a value from 0x00 - 0xFF
#define R_LEFT_X 0x16
#define R_LEFT_Y 0x17

// I2C address of the PSX dongle
int psx_dongle_addr = 0x72;
int j;
void setup()
  Wire.begin(); // join i2c bus (address optional for master)

// this is the control register. setting it to 1 means that
// we have to tell the PSX device what data to send to the
// Playstation2. Setting it to 0 means that it simply passes
// through the data from the controller to the PS2. We can
// read the state of the contorller at any time.

writeToAddress(psx_dongle_addr, 0x24, 1);

// we'll use count to figure out when to change direction
int count = 0;
int buttons;

// mode is used to indicate either "pass thru" where we can use the
// actually real human controller to control the PS2, or to generate
// data via the PSX dongle.
// pressing both L2 and R2 simultaneously toggles the mode
int mode = 1;
byte randomNumber;

void loop()
  byte val;
  //Serial.println(count, DEC);
 // 0x70 shows up as either ID $20 or ID $E0 on Propeller

  BTN_SELECT = $0001
  BTN_L3 = $0002
  BTN_R3 = $0004
  BTN_START = $0008
  BTN_UP = $0010
  BTN_RIGHT = $0020
  BTN_DOWN = $0040
  BTN_LEFT = $0080
  BTN_L2 = $0100
  BTN_R2 = $0200
  BTN_L1 = $0400
  BTN_R1 = $0800
  BTN_TRIANGLE = $1000
  BTN_CIRCLE = $2000
  BTN_X = $4000
  BTN_SQUARE = $8000

// 0x00 write to BUTTONS_0, 0x12 read from BUTTONS_0
// 0x01 write to BUTTONS_1, 0x13 read from BUTTONS_1
// 0x02 write to RIGHT_X, 0x14 read from RIGHT_X
// 0x03 write to RIGHT_Y, 0x15 read from RIGHT_Y
// 0x04 write to LEFT_X, 0x16 read from LEFT_X
// 0x05 write to LEFT_Y, 0x17 read from LEFT_Y
//Serial.println(getButtons(), HEX);
//int buttons = getButtons();
//Serial.print(buttons, BIN);
//  passThruButtons();

if(count > 512) {
  count = 0;
//Serial.println(mode, HEX);

// get the buttons
buttons = getButtons();

// mode is used to indicate either "pass thru" where we can use the
// actually real human controller to control the PS2, or to generate
// data via the PSX dongle.
// pressing both L2 and R2 simultaneously toggles the mode
  if(mode == 1 &&
     is_button_pressed(buttons, BTN_L2) && is_button_pressed(buttons, BTN_R2)) {
    mode = 0;
  } else
  if(mode == 0 &&
     is_button_pressed(buttons, BTN_L2) && is_button_pressed(buttons, BTN_R2)) {
     mode = 1;
 if(mode == 1) {
 if(mode == 0)

  writeToAddress(psx_dongle_addr, W_LEFT_Y, 0x00);
  writeToAddress(psx_dongle_addr, W_RIGHT_Y, 0x00);

  if(count == 512) {
    count = 0;

    randomNumber = random(1,5);
        Serial.print("FLIP! ");
        Serial.println(randomNumber, HEX);
    switch(randomNumber) {
      case 1: case 2: case 6:
        writeToAddress(psx_dongle_addr, W_LEFT_Y, 0x00);
        writeToAddress(psx_dongle_addr, W_RIGHT_Y, 0xAF);
      case 3: case 4: case 5:
        writeToAddress(psx_dongle_addr, W_LEFT_Y, 0xAF);
        writeToAddress(psx_dongle_addr, W_RIGHT_Y, 0x00);

writeToAddress(psx_dongle_addr, W_LEFT_X, (float)map(nunchuck_accelx(), (float)0x48, (float)0xB0,
                (float)0x00, (float)0xFF));
writeToAddress(pssx_dongle_addr, W_LEFT_Y, (float)map(nunchuck_accely(), (float)0x48, (float)0xB0,
                (float)0x00, (float)0xFF));

writeToAddress(psx_dongle_addr, W_RIGHT_Y, (float)map(nunchuck_joyy(), (float)0x1D, (float)0xDF,
                (float)0x00, (float)0xFF));
writeToAddress(psx_dongle_addr, W_RIGHT_X, (float)map(nunchuck_joyx(), (float)0x1D, (float)0xDF,
                (float)0x00, (float)0xFF));


int getButtons()
int result = 0x00;

result = readFromAddress(psx_dongle_addr, 0x13, 1);
//  Serial.print(result, HEX); Serial.print(" ");
result <> 8)); // MSB
  Wire.send((int)(addr & 0xFF)); // LSB

byte readFromAddress(int twi_addr, int addr, int bytes_to_read)
  byte rdata;
  Wire.send((int)(addr >> 8)); // MSB
  Wire.send((int)(addr & 0xFF)); // LSB
  while (Wire.available()) rdata = Wire.receive();
  return rdata;

Continue reading Autonomous Game Controllers

Drift Deck

Drift Deck. For Conflux 2008, NYC

For Analog Play (batteries not required.)

(Some production documentation above; click “Notes”.)

The Drift Deck (Analog Edition) is an algorithmic puzzle game used to navigate city streets. A deck of cards is used as instructions that guide you as you drift about the city. Each card contains an object or situation, followed by a simple action. For example, a situation might be — you see a fire hydrant, or you come across a pigeon lady. The action is meant to be performed when the object is seen, or when you come across the described situation. For example — take a photograph, or make the next right turn. The cards also contain writerly extras, quotes and inspired words meant to supplement your wandering about the city.

Processed in collaboration with Dawn Lozzi who did all of the graphic design and production.

For exhibition at the Conflux 2008 Festival, NYC, September 11-14, 2008, and hosted by Center for Architecture located at 536 LaGuardia Place, New York, NY 10012

The motivation for Drift Deck comes from the Situationist International, which was a small, international group of political and artistic agitators. Formed in 1957, the Situationist International was active in Europe through the 1960s and aspired to major social and political transformations.

Guy Debord, one of the major figures in the Situationist International, developed what he called the “Theory of the Dérive.”

“Dérives involve playful-constructive behavior and awareness of psychogeographical effects, and are thus quite different from the classic notions of journey or stroll.

In a dérive one or more persons during a certain period drop their relations, their work and leisure activities, and all their other usual motives for movement and action, and let themselves be drawn by the attractions of the terrain and the encounters they find there. Chance is a less important factor in this activity than one might think: from a dérive point of view cities have psychogeographical contours, with constant currents, fixed points and vortexes that strongly discourage entry into or exit from certain zones.”

Psychogeography was defined in 1955 by Guy Debord as the “the study of the precise laws and specific effects of the geographical environment, consciously organized or not, on the emotions and behavior of individuals.” Psychogeography includes just about anything that takes pedestrians off their predictable paths and jolts them into a new awareness of the urban landscape.” The dérive is considered by many to be one of the more important of these strategies to move one away from predictable behaviors and paths.


The cards will be available for festival visitors to borrow and return for others to use during the Conflux Festival.

Design and Implications by Julian Bleecker and Dawn Lozzi. Creative Assistance and Support from Nicolas Nova, Pascal Wever, Andrew Gartrell, Simon James, Bella Chu, Pawena Thimaporn, Duncan Burns, Raphael Grignani, Rhys Newman, Tom Arbisi, Mike Kruzeniski and Rob Bellm. Processed for Conflux Festival 2008.

Special Joker Cards featuring compositions by Jane Pinckard, Ben Cerveny, Jane McGonigal, Bruce Sterling, Katie Salen, Ian Bogost and Kevin Slavin. Joker illustrations by Rob Bellm.

Original Proposal


Part of a long, proud line of land mapping technologies that includes PDPal, Ubicam Backward Facing Camera and Battleship: Google Earth, and WiFiKu.

Continue reading Drift Deck


I’m getting closer to have a second prototype of the PSX project. Strangely, I seem to be building the breadboard prototype (lower image) simultaneous with the PCB prototype (the thing on top). I think the breadboard prototype is mostly for working on the firmware for the Propeller, which is going better than I had hoped, especially seeing as I’ve never developed for it, and that I’m mostly in Spin assembly (not so ugly, but still..bleech..) The breadboard version is basically a core Propeller with some wiring for programming and for chatting to an EEPROM for permanent firmware storage. I started playing with this PCA9306 bidirectional level-shifter, which is sitting on the right half breadboard. This is basically the same circuit as what goes on the surface mount PCB, except for the addition of a LP2985 3.3v regulator.

This is a curious approach, getting slightly ahead of things, but it’s been a circuitous, round-about project from the original “hey..wouldn’t it be cool if..?” motivation that I thought would maybe be a weekend’s work of getting an Atmega324 to emulate a PSX controller. That’s the one in the image above, from last fall. I began the design last summer thinking I’d be done in short order. It should be..I’ve just got grease in my head or something. I was anticipating perhaps some trickiness because I took the trouble to pull out the boundary scan signals to the edge of the board so I could do some JTAG debugging. What went wrong? Well, mostly timing related things. This project motivated me to get my own logic analyzer so I could figure out what the heck was going wrong. There were mostly timing-related problems that I sort of pushed to the side to pursue another possible solution, which led to this current (v07) design.

How did this all start? I thought it’d be an interesting little bit of game controller provocation to have a controller that “got tired” just as one’s avatar might in a video game. To do this, I figured I’d have to Continue reading Refining

Urbanism, Data-Driven

(Some cartogram structures and linkages Pascal created as sensor maps where the geography is an implied and driven — rather than the driving — parameter.)

Fabien Girardin, MIT brainiac and a fellow Near Future Laboratory ‘naut presented his expert and insightful trinity of themes that appear to be the main motivators behind "urban computing", a bit of cocktail party conversation related to this short essay that Kazys Varnelis and Leah Meisterlin wrote, and that Nicolas poked a stick at.

Fabien describes three prime motivators behind the “urban computing” discussion and construction projects. Bears repeating, with some commentary.

1. Creating an opportunistic and optimistic urban environment that is somehow “better” than one without some sort of underlying computational infrastructure. This is the realm of the ubiquitous computing folks. The visions are aspirational — near-future signposts always already just out of reach and endlessly deferred — perhaps this is the definition of industry and academic R&D. Provide curious near-future fictions about possible near-future worlds. Effectively science-fiction expressed through objects and scenarios and large research (instead of film and television production) budgets. (Cf ““Resistance is Futile”: Reading Science Fiction Alongside
Ubiquitous Computing”, Paul Dourish and Genevieve Bell, forthcoming in Personal and Ubiquitous Computing.)

2. Study of the impacts and implications of computational systems and operations in an urban context, performed by GIS folk and urban planners and computer science people. These are studies of the dynamics of data-people sensed in the city, mapped and used to develop insights on urban conditions, or perhaps used as contributing information for design or re-design of urban geography. In some cases the data is interpreted in real-time, such as you might expect to be done to manage loads on cellular data networks, etc.

3. The action, postulating and creative exercises of independent and undisciplinary explorers and adventurers who shuffle and interleave the interesting data points that are anchored to geographies that can be re-mapped. This has brought us such interesting tidbits as the various crime data maps, for example, or the flows of automobiles throughout cities. (Using the geeky, horribly, self-deprecatingly named “mash-ups”.) What is happening here that is most compelling to me at least is that “GIS” activities are becoming something that anyone, without a license or professional sanction can do, inexpensively (i.e. for free and a bit of time). So, anything new here and worth glorifying is this fact — we can be our own map-makers. This is significant in the Foucauldian power-knowledge sense of significant. Cartograms such as the fundraising maps, which started out as a very DIY project, are important because they create new meaning and possibilities for action, or shifts in perspective that can lead to change, rather than stagnation. (There’s a normative element, of course. Visualizations of data with geographies, in the power-knowledge realm of things, are as free to interpretation as anything that alleges to be fact, so they can’t be counted upon to prove much of anything. At worst, they can be enrolled in larger conversations, just like any good knowledge agent.)

(Some more of Pascal’s cartogram structures and linkages. Sensor maps recorded amongst a small group of us and visualized such that the geography is an implied and driven — rather than the driving — parameter.)

I’d add a bit here. How can the experience of space — urban space, just to stick to the most discussed idiom — become fruitfully and playfully data-driven? Mapping data onto geographies by their instrumentalized location in space is okay. It’s a bit knee-jerk, though. What I mean is that re-mapping data with an entirely different basis could possibly produce an entirely different urban experience that may, at worst, be curious and playful. Just to see what comes of this. The Laboratory has been working for way too long on such re-mappings that do not assume that latitude and longitude are the canonical reference points for whatever data gets built on top.

I know..I know. This is weird. And the first project I was involved with that did this — an edition of PDPal that created maps based exclusively on interpreting an “experience” — fought a losing battle. But there are some indicators that this approach is at least worth exploring.

Creating “maps” that have a spatial aspect to them, but that do not use space as the primary or explicit reference datum can then emphasize people-practices or experiences first, with the geographic datum implicit or made into a driven, rather than driving, parameter. Paulos and Goodman’s “Jabberwocky” project comes to mind, as do Twitchr and other mappings of “encounters” and actions that are not expecting to use GPS first-and-foremost.

Situationist Space (Thomas F. McDonough)

Here in the Laboratory we’ve been building several prototype devices that record Bluetooth encounters for later visualization. The first prototype was a small Python script running on a Nokia N70 phone. It was like a little data attractor that would sniff for Bluetooth devices, and then record them in a log file, and send them to a server to be persisted in a database.

Two recent editions used a small, custom-designed device that used the Bluetooth scanning mode of a radio to essentially do the same thing, storing the results in a Flash memory device to be later extracted with a simple USB interface. Lately a bunch of us in the studio have been working with a similar concept in the form of a background sensing application developed at Nokia R&D for S60 devices that does all of this, plus quite a bit more. (Currently in closed alpha, but soon to be available publicly.) The biggest challenge (besides running it on an S60 device..) is making meaning out of all of this. The strongest vectors for me, at least, lead to re-mapping and exploring possibilities playfully, with no specific expectations that there is intelligence in the maps by themselves.

# install first the following files to your phone
# (they will install automatically the needed libraries for the script below):
# aosocket-series60_v20.sis, pdis.sis
# found at: http://pdis.hiit.fi/pdis/download/pdis/

# this script was found from forum.nokia.com

import e32
import appuifw
##import aosocketnativenew
from pdis.lib.logging import *
##import httplib, urllib
from location import gsm_location
import time
import sysinfo
import select

cell = []

def tell(string):
    if e32.is_ui_thread():
        print string

# ----------------------------------
from aosocket.symbian.bt_device_discoverer import *
#from socket import * # for obex file send

def discovered(error, devices, cb_param):
    if error == 0:
        global cell
        #tell("start discovery..")
        cell = gsm_location()

        #tell("devices: " + str(devices))
        #print location.gsm_location()
        for address, name in devices:

            print location.gsm_location()
                                             ('imei', sysinfo.imei()),
                                             ('batt', sysinfo.battery()),
                                             ('signal', sysinfo.signal()),
                                             ('cell_0', cell[0]), ('cell_1', cell[1]),
                                             ('cell_2', cell[2]), ('cell_3', cell[3])]))
        tell("device discovery failure: error %d" % error)

# -----------------------------------------------------------------------------

        _discoverer = BtDeviceLister()
        _discoverer.discover_all(discovered, None)
        print "scanning again"
        tell("init failure")
        appuifw.note(u"Fatal error.", "error")

Continue reading Urbanism, Data-Driven




Not knowing a heck of a lot about solenoids in practice — I know what they do, and, as an example of the sometimes impracticality of higher-ed, am fairly fluent in the E&M principles at work here. But, when it comes to the practical matter of finding one with the necessary “umph” to articulate a simple controller’s buttons, it’s all guess work.

(Parenthetically, this mechanism is a subcomponent of a larger project called “Air Guitar Hero” which uses a remote glove controller to articulate the solenoids here. Yes. It makes no practical sense. It points to “something” as an experiment, if nothing more than to learn a few things about controlling solenoids and such all. But, mostly it is a design provocation. That’d be the easiest way of describing this whole thing, for those who have asked.)

The first solenoids I used were the smallish ones on top, bought at close-out prices from Electronics Goldmine for about $2 a piece. They couldn’t push the button completely, nor with the surety of purpose the design demanded. They would actuate, but not push the button closed. The best they could do was kind of rattling things around a bit.

Not really knowing precisely how to “engineer” a solution (probably something about determining the closing force of the switch and back-stepping to an appropriate solenoid), I just bought a few different sizes. The first one to arrive was enormous and, had I been a bit more careful, I would’ve realized that the centerline to centerline spacing of a row of four of these would’ve been wider than the center to center distance between the Guitar Hero buttons. Poppa Bear is a Guardian Electric TP12X19-I-24D, push style solenoid, runs at 24 volts. Way too big. So..that one is now a paperweight on my desk.

(Here’s a link to Guardian Electric that has specifications on their other tubular push/pull solenoids.)

The other two were closer, and I ended up using the “Momma Bear” solenoid — a Guardian Electric TP6X12-I-24D, also push style, with a load force of 18-0.06/2.5-0.75 Ounce-Inch. The data sheet is here.

I’m running all of these at 12 volts, which makes them less umph-y, but sufficient for what I’m doing. The solenoids have more push force at the low end of teir travel, so I designed the little supporting bridge there to hold the articulating shaft right on top of the controller button so that most of the force would be committed to pushing the button and not traveling through space.

Speaking of scale, on the left there is the breadboard prototype circuit to drive five solenoids. The right is the PCB with the same circuit (minus a bunch of Arduino icing, just a plain vanilla Atmega168 and crystal). Scaled down, the circuit is much easier to manage and cart around than the relatively fragile breadboard edition, especially cause I’m using janky, untrimmed jumpers to make connections and so forth.

For the curious, here’s the circuit’s schematic and the PCB layout pictures.

What Is Manufacturing in the Era of Design-Art-Technology?

Flavonoid Primitive Sketch

(Essay for Share Festival Catalog 2008)

(Here is my slide presentation, relate to the essay below. But, I did not read this essay at the festival, rather it was printed in the festival catalog.)

There are a few things to say about manufacturing, design and digital arts. First, we’re not talking about manufacturing. Manufacuring is about making things on a large scale using machinery. Manufacturing evokes cavernous, cold, awesomely huge assembly lines with scales all out of proportion to the experiences of mere mortals. Factory floors throwing sparks, littered with metal shavings, huge overhead cranes moving impossibly large masses of steel – this is what manufacturing means. Half million ton crude oil-carrying super tankers are manufactured. The Airbus 380 is manufactured. Millions of Herman Miller Aeron Chairs are manufactured. Billions of cellular phones are manufactured. These things have meaning in the idiom of manufacturing. Manufacturing is the engine of growth and dispair of the 20th century.

If anything, we’re talking about a kind of materialization of ideas. Slick connections between an your imagination, a circuit board and a 3D printer. It’s artful for its scale and personalization. Small-scale, passionate, individual ideas made material. Why is this different from manufacturing? Because manufacturing deals in enormous scales – scales of time, material, logistics, operational fortitude, finances, consumption of natural resources. Ultimately, manufacturing endeavors are impossible imbroglios of spin-doctors and reassurances, speculation, trust and hope as much as they are supply-train logistics and CAD systems. Just ask the Boeing 787 “Dreamliner” team. Is it advanced avionics and carbon-fiber-reinforced plastic skins or spin-control and renegotiated contracts that’ll make that perpetually delayed endeavor a success?

The sad consequences of manufacturing’s scale is that it defaults to the least common denominator. Manufacturing on a mass scale can only be an effective business enterprise when you make one thing that millions and millions of people are convinced they need to buy. Customization as a manufacturing process has not moved much beyond Henry Ford’s Model T color option – you can have any color, so long as it’s black. An iPod is an iPod is an iPod, hand-painting and laser etching not withstanding. True customization means materializing one’s own designs, one’s own imagination. This is where we begin.


What we are talking about are emerging “materialization” – not manufacturing – processes. What makes it worth talking about is that it is the power of creation that manufacturing is able to achieve, but done at an entirely different scale – quicker, cheaper, individually, with fewer intermediaries and fewer incumberances. This is the crucial element – there are fewer and less awkward hurdles, deals, negotiations and alliances to be formed in the process of materializing an idea. The power of the idea and its “moment” is not lost through the trials of enrolling people, machines, enterprises, financiers into your cause. It’s as if a sketch in a notebook can materialize immediately. No more fumbling around with awkward descriptions of your weird idea – let the material object speak for you.

What else can be said about this different kind of idea-manufacturing? How does it integreate with design and digital arts? It relies on “toolkits” consisting of digital software and hardware, fab machines, CNC “Robodrills” and 3D modeling. As importantly, the toolkits are also the far-flung networked communities of craftspeople and designers, artists and technologists sharing ideas and insights. The practical tradecraft starts from the bottom and works its way up. We’re familiar with the elements of this process, and the activities taking place in various corners of the digital arts and art-technology communities. This is an emerging practice informally taken up by thoughtful designer-tinkerers. It is a practice that will find greater adoption within more formal and conservative design, engineering and art communities as its significance is refined.

The “tooling” for this practice includes open-source firmware for inexpensive microcontroller-based kits like the Arduino; hacked Nintendo Wii controllers; low-cost, rapid-turnaround printed circuit board production houses; free development environments like Processing; online knowledge sharing communities; parts suppliers with no minimum orders, and so forth.


The “manufacturing process” is a kind of extended sketching activity. Ideas are first expressed informally, perhaps with a simple “wouldn’t it be cool if..?” question at a moment of inspiration. But the question should be answered – and it can be, often enough, with a quick pen drawing, some poking around the net for practical answers or to source some parts or other material – perhaps even finding other people who have asked the same question and thereby entering into conversations with all the other similarly inspired folks out there on the networks. In short order a refined, functional technology engine is created using small-scale surface mount printed circuit board techniques so as to fit within the refined contours of a fab’d surface model. Now you have a fully functioning materialization of your idea – much easier to answer that initial question with the real-deal. You can share it, put it in other people’s hands and work through the nuances of your idea.

What does this all mean for an emerging design-art-technology practice? At present, the evidence of something compelling centered around new interactions is indicated by a richly stocked cabinet of curios – expressive artifacts and objects that, like early Net Art, stitch together inputs and create expressive outputs. Only — and this is important – they do so off the computer screen, and with no keyboard and mouse. Rather, these expressive objects form their interactivity around physical actions that may include the Nabaztag’s articulating rabbit-like ears, or Clocky the coy alarm clocks that roll away when you try to hit the snooze button, or Maywa Denki’s punch-drunk dancing BitMan character. These are distinct kinds of digital objects that mix physical space, digital technology and design.

Engelbart Mouse Patent

We know that the art of digital media continues to emphasize the screen, the keyboard, the mouse and the network. The weak signals suggest kinds of design-art-technology that are growing tired of the screen. Digital art is ready to move beyond the confines that Douglas Englebart and his contemporaries created in 1968 with their patent line drawing depicting the now canonical assembly of keyboard, screen and mouse. If there is a “new materiality” to digital arts, it will emphasize material interactions in physical space, embodied experiences and contexts beyond the typically sedentary confines of the screen/keyboard/mouse/network assemblage.

For this new process to do something new, it must become a ployglot practice steered by undisciplinary craftspeople who believe in the possibility of creating fictional, unbelieveable, even preposterous objects that say as much about what they’re moving away from – the uninspired, least-common denominator landfill-destined plastic device – as they say about what sort of near future world we could have. What is emerging is an ability to make your own stuff – not just “skinning” your mobile or modding an MP3 player. Materializing ideas is about making your own – “whatever” – unanticipated, unknow, visionary, expressive things. It is not a manufacturing process. This is a process that requires multiple perspectives and multiple skills thoroughly mixing engineering-design-art into a hybrid sensibility. It is a process that’s strictly for trouble-makers and boundary crossers. Nothing expected and everything unexpected will come from this.

Continue reading What Is Manufacturing in the Era of Design-Art-Technology?


Slow Messenger 2nd Design

Product Prototype: SlowMessenger

Slow Messenger is an instant messaging device that delivers messages exceptionally slowly. Built into the device is a messaging technology that unfolds its content based on an interface that borrows from the traditions of long-form letter writing, hand-carried mail sent through the post. The instant messaging device connects digital information channels — such as the Internets — to physical information channels — such as streets, hands and the friction of human contact.

SlowMessenger works by simply receiving the message from the message sender. Once the message is received, it is gradually displayed, one letter at a time based on two factors. The first is the relative amount of time that the device is held; the second is the amount of time the device is carried while walking. These factors — holding-by-hand and walking-with — are interaction rituals key to the conveyance of intimate messages. In “another era” that is not the “digitally networked era”, “taking the air” and “perambulating” were crucial interaction rituals for maintaining and knitting together “social network” relations. Friends and intimate couples would “walk hand-in-hand” and discuss matters on their minds. In this “other era”, in times when friends were not in proximity, perhaps because one or the other was off to war or at sea, long-form “letters” were composed to substitute for physical proximity and communication. Postal mail was used to maintain communications and “stay in touch” even if “physical touch” was not, in a literal sense, a possibility.

In this “digitally networked era” communications mechanics are designed to take advantage of the efficiencies of electronic networks. In this way, contact is perpetual and ubiquitous, often resulting in nearly meaningless communiques and dispatches. By “slowing down” the instantaneous message, the device saves time by allowing one to avoid inane drivel and focus on a meaningful connection to one special person.

Slow Messenger Flickr Set


SlowMessenger Capsule