The End of the Shale Gale

Is fracking a solved problem?

The price of Brent crude oil, the global benchmark, has been dropping for a year. This is largely the result of Saudi Arabia’s efforts, though OPEC, to kill competition from the US ‘Shale Gale’ on the global oil market (though lower demand from China is also a factor). OPEC has increased their production with the goal of driving US producers our out of business. At first US companies appeared to be weathering the rough market, but the sustained low prices are finally taking their toll. 60 oil companies have filed for bankruptcy and energy consultant IHS Inc suggests that there are up to 150 more that may follow suit. This doesn’t erase the existence of the wells are drilled already, but it does mean that pumping them and drilling new wells is not economically viable.

In order to make sure that US shale energy doesn’t strongly re-enter the market OPEC will have to keep the price of Brent crude at $50-70 a barrel, which they seem completely willing to do for the foreseeable future.

What’s next?

Petroleum products are going to be the main source of global energy for the foreseeable future (you can’t run a cargo ship on batteries), but consumer patterns are changing. Uber and Tesla are going a long way to change how people think about car ownership and fuel consumption. From what we can see now, we are a long way from the end of oil, but the conceptual groundwork is clearly being laid for consumers. We’ve gotten so used to our phones and computers running on batteries, it’s not a big conceptual leap to running our cars and homes from them as well. When the technology is ready, consumers will be ready too.

Right now, one of the most important things to do is to create demand. Look at Tesla, they are creating high end luxury cars both because the technology is still expensive and because the want to make a product that is exclusive and desirable. The more they can make people want the cars while they are rare the better. Electric cars have become the sexy alternative.

What other ways are there to introduce different energy products and energy diversity into the consumer mindset, if not the market?

Link Dump:

Tempory Expert – Wee 2 Readings

There probably isn’t one true theory of everything.

The most effective way to change someone’s mind and introduce new ideas is by talking to them.

Art is just as important as science in examining how our existence works.


One of the most important tools you have when trying to corral hearts and minds is your ground game, at least here in the US. Look at Donald Trump and the Iowa caucuses, he may have had the name recognition and crowds at his rallies but when it came to getting humans to the polls to vote for him, he fell short. Now Trump’s trying to spin this into someone else stiffing him out of a victory polls said was certain, but really there’s another lesson here. If you want people to care about something you care about enough to show up, you have to go talk them in person. When you’re winning converts, impersonal messaging only gets you so far. Ads, TV, viral campaigns, slacktivism, and all the rest may get you name recognition but it doesn’t get people to show up the way that looking them in the eye and listening to them speak does.


The law is the lowest common denominator everyone can live with, not a moral prescription. You can’t change things from the top down without some movement from the ground up.


If you want to change someone’s mind you need to be able to meet them where they are. You need to speak to them in their own language, within their own mental models.


When you’re trying to change someone’s mind about a complicated issue, don’t underestimate the value of a single story.
Nicholas Kristof: Want to Make a Difference? Tell a Compelling Story.

Temporary Expert – Week 1 Readings

Learning How to Die in the Anthropocene


“…a civilization in collapse, with a crippled infrastructure, unable to recuperate from shocks to its system.”

It’s impossible to argue that the future is going to be more unreliable and extreme than the past, but equating it to the shock and awe of the US Armed Forces in Iraq also seems excessive. It’s hard to argue against the author’s experiences, since he was on the ground in Baghdad and New Orleans, but it’s also hard for me to accept that the instability he witnessed in Baghdad and New Orleans will become the new normal. We are going through a series of rough lessons now, but it’s hard for me to imagine that we will not learn from them. The timescale of the invasion of Iraq and the creep of the Anthropocene are two totally different things.


I’m just responding to personal experiences with more personal experiences, but living through Hurricane Irene, Superstorm Sandy, and the recent Snowstorm Jonas I feel like I’m watching the shift in expectation and policy that life in the Anthropocene necessitates. The public reaction to Irene and Sandy seem especially revealing. The ‘no show’ of Irene was met with frustration and incredulity about future threats to the city, but Sandy wiped that smile off of everyone’s face. I think that, in New York at least, people are more willing to accept that there are going to be extreme events and that how we think of them needs to change, both in policy and in individual behavior. Now is the time to think about how institutional policy must be changed to make it more flexible and how citizen responsibility will need to fill in the gaps. We are going to need local and national governments that are prepared for the unknowable. We are also going to need to think about how individuals and households can be prepared. The future is going to have much so more anxiety and uncertainty than the past, but it’s not like we can’t live through it.



In what ways is it possible to introduce both government flexibility and citizen self reliance into how we think about society and government?

How do we put pressure on institutions to do better, while equipping ourselves to deal on a personal, human level? (Look at digging out Queens from the recent snowstorm for example. Could the city have had a better plan with existing resources, or do we need more snowploughs?)

Are there simple, multipurpose tools that can be introduced to help? Something that is the equivalent of a good sharp shovel, a workhorse with elegant design that can be used for many different things.

What does the aftermath of a hurricane look like now in somewhere like Florida, where they are normal? How does citizen preparedness meet government efforts?


Relevant Links:



“The biggest problem we face is a philosophical one: understanding that this civilization is already dead.”

This is the part of the article that I found much more compelling. The planet is dying, how do we mourn and memorialize the world that was as it passes in front of our eyes? Who is the audience for such memorials? People now, or people in the far away future? How do you commemorate the passing of a civilization? What is the precedent for something like this? How does everyone feel?


The Challenge of Responsible Design

“The science we have, and the technology we have both are always and inevitably a function not simply of ‘reality,’ but of where our attention happens to be focused.”

This is particularly striking to me. It’s something that I know is true, but it’s good to be reminded of it. I tend to be a practical thinker, interested in what is feasible in problem solving. I often find myself limiting my options to the possible, politic decision and find myself detracting from more far out ideas as being “unreasonable”. I think this is something that starkly limits my imagination of the future, not just in design projects but generally in my day to day life.


Design + Research

A lot of good points, but this is written as insufferable academic nonsense. Why write something this way? Why not just write something in a way that people can read it? Was this translated into English from another language, or what?

It is good to have criticism in design, but I think it’s easy to go down a rabbit hole. Spending too much time on criticism can be paralyzing to action, which so much design is based around. This might not even be relevant to my practise in this class. As the authors note: “Indeed, it might be difficult for interaction design – and perhaps even for design research – to rest on any singular or stable set of foundations.” The main focus of ‘practical’ criticism seems to be to make sure that your project is fit for its purpose as you’ve defined it, and to keep revisiting the definition. Being nimble in design practise seems more relevant than anything else.


Designing Interactions

Is interaction design actually meta design?
There are a number of interesting designs from Dunne and Raby, but it’s interesting that a lot of the books and writings that they cite as inspiration are already popsci books. It’s like they’re deriving a derivative, instead of reading research directly. I mean, it’s not like they don’t go back to hard research, but I can’t help but feel like their work is a little like ‘toy’ work. I see the value of rethinking these ideas, and even doing it in an ‘unreal’ way that pushes outside of our normal thinking, but I feel like I don’t know who the audience for this work is. Other designers? Scientists? How much do ‘normal people’ encounter work like this? They mentioned recruiting people for the placebo work through ads and other everyday means, but where does the work go after that? Into a design book somewhere?  (Aside, where does any work go ‘after’?)

Sound – Floating Away

I worked with Serena Parr on this sound project. We decided to create the  experience of traveling through space, using sounds inspired by the Voyager recordings. The original idea was to recreate the sounds using our own recordings, but we quickly realized that there was no reason not to use the original recordings.

Glow Blocks Proof of Concept

Glow Box Test from coldsoup753 on Vimeo.

Other posts:

Play Testing






In the end, I only got two boxes working consistently. And only one of those worked for the in class presentation. It was extremely frustrating. However, I got a lot out of the project and I’m going to continue experimenting with the idea. There are so many objects that are either delicate or intangible, existing on screens or projections. I ended up building a delicate project that couldn’t take the beating I wanted it to, but I’ve got some great next steps:

  • Experiment with other materials, especially cast foam objects.
  • Experiment with shapes other than blocks. Although this alters the original idea of building up and knocking over, other shapes could encourage more action. (Like a ball)
  • Improve the robustness of my objects.

Glow Blocks LEDs

TLC5940NT from coldsoup753 on Vimeo.

I planned on using the TLC5940NT to drive the LEDs for this project. After finding the TLC5940NT library setting up the LEDs was pretty straightforward. I wrote  sketch that would change the LEDs to a color of my choice and it seemed like it was just a matter of dropping that code into the accelerometer sketch.


However, when I combined the TLC5940NT and the ADXL345, things just didn’t work. The LEDs changed to all different colors and they did not respond to the accelerometer. My best guess was that something from the accelerometer was throwing the clock off and that change was affecting the PWM in the TLC5940NTs. Also, I noticed the colors were changing every time the ADXL345 sent an interrupt. There were some good clues to investigate, but it wasn’t something that I really understood or could get fixed before the project presentation. In the end I decided to leave out the TLC5940NT, in favor of a bare bones proof of concept that worked.

Code to change the color of the LEDs, adapted from the TLC5940NT library example code.

    Basic Pin setup:
    ------------                                  ---u----
    ARDUINO   13|-> SCLK (pin 25)           OUT1 |1     28| OUT channel 0
              12|                           OUT2 |2     27|-> GND (VPRG)
              11|-> SIN (pin 26)            OUT3 |3     26|-> SIN (pin 11)
              10|-> BLANK (pin 23)          OUT4 |4     25|-> SCLK (pin 13)
               9|-> XLAT (pin 24)             .  |5     24|-> XLAT (pin 9)
               8|                             .  |6     23|-> BLANK (pin 10)
               7|                             .  |7     22|-> GND
               6|                             .  |8     21|-> VCC (+5V)
               5|                             .  |9     20|-> 2K Resistor -> GND
               4|                             .  |10    19|-> +5V (DCPRG)
               3|-> GSCLK (pin 18)            .  |11    18|-> GSCLK (pin 3)
               2|                             .  |12    17|-> SOUT
               1|                             .  |13    16|-> XERR
               0|                           OUT14|14    15| OUT channel 15
    ------------                                  --------

    -  Put the longer leg (anode) of the LEDs in the +5V and the shorter leg
         (cathode) in OUT(0-15).
    -  +5V from Arduino -> TLC pin 21 and 19     (VCC and DCPRG)
    -  GND from Arduino -> TLC pin 22 and 27     (GND and VPRG)
    -  digital 3        -> TLC pin 18            (GSCLK)
    -  digital 9        -> TLC pin 24            (XLAT)
    -  digital 10       -> TLC pin 23            (BLANK)
    -  digital 11       -> TLC pin 26            (SIN)
    -  digital 13       -> TLC pin 25            (SCLK)
    -  The 2K resistor between TLC pin 20 and GND will let ~20mA through each
       LED.  To be precise, it's I = 39.06 / R (in ohms).  This doesn't depend
       on the LED driving voltage.
    - (Optional): put a pull-up resistor (~10k) between +5V and BLANK so that
                  all the LEDs will turn off when the Arduino is reset.

    If you are daisy-chaining more than one TLC, connect the SOUT of the first
    TLC to the SIN of the next.  All the other pins should just be connected
        BLANK on Arduino -> BLANK of TLC1 -> BLANK of TLC2 -> ...
        XLAT on Arduino  -> XLAT of TLC1  -> XLAT of TLC2  -> ...
    The one exception is that each TLC needs it's own resistor between pin 20
    and GND.

    This library uses the PWM output ability of digital pins 3, 9, 10, and 11.
    Do not use analogWrite(...) on these pins.

    This sketch does the Knight Rider strobe across a line of LEDs.

    Alex Leone , 2009-02-03 */

#include "Tlc5940.h"

void setup()
  /* Call Tlc.init() to setup the tlc.
     You can optionally pass an initial PWM value (0 - 4095) for all channels.*/

/* This loop will create a Knight Rider-like effect if you have LEDs plugged
   into all the TLC outputs.  NUM_TLCS is defined in "tlc_config.h" in the
   library folder.  After editing tlc_config.h for your setup, delete the
   Tlc5940.o file to save the changes. */

void loop()



void showRGB(int color)
  int redIntensity;
  int greenIntensity;
  int blueIntensity;

// This function translates a number between 0 and 767 into a
// specific color on the RGB LED. If you have this number count
// through the whole range (0 to 767), the LED will smoothly
// change color through the entire spectrum.

  // Here we'll use an "if / else" statement to determine which
  // of the three (R,G,B) zones x falls into. Each of these zones
  // spans 4095 because the Tlc5940 wants a number from 0 to 4095.

  // In each of these zones, we'll calculate the brightness
  // for each of the red, green, and blue LEDs within the RGB LED.
  // x = 4096
  // color = a number from 0 to 12287 

  if (color <= 4095)          // zone 1
    redIntensity = 4095 - color;    // red goes from on to off
    greenIntensity = color;        // green goes from off to on
    blueIntensity = 0;             // blue is always off
  else if (color <= 8191) // zone 2 { redIntensity = 0; // red is always off greenIntensity = 8191 - (color - 4096); // green on to off blueIntensity = (color - 4096); // blue off to on } else // color >= 8192       // zone 3
    redIntensity = (color - 8192);         // red off to on
    greenIntensity = 0;                   // green is always off
    blueIntensity = 8191 - (color - 8192);  // blue on to off

  // Now that the brightness values have been set, command the LED
  // to those values
  // 1
  Tlc.set(0, redIntensity);
  Tlc.set(1, blueIntensity);
  Tlc.set(2, greenIntensity);
  Tlc.set(3, redIntensity);
  Tlc.set(4, blueIntensity);
  Tlc.set(5, greenIntensity);
  Tlc.set(6, redIntensity);
  Tlc.set(7, blueIntensity);
  Tlc.set(8, greenIntensity);
  Tlc.set(9, redIntensity);
  Tlc.set(10, blueIntensity);
  Tlc.set(11, greenIntensity);
  Tlc.set(12, redIntensity);
  Tlc.set(13, blueIntensity);
  Tlc.set(14, greenIntensity);
  Tlc.set(15, redIntensity);
  Tlc.set(16, blueIntensity);
  Tlc.set(17, greenIntensity);
  Tlc.set(18, redIntensity);
  Tlc.set(19, blueIntensity);
  Tlc.set(20, greenIntensity);
  Tlc.set(21, redIntensity);
  Tlc.set(22, blueIntensity);
  Tlc.set(23, greenIntensity);
  Tlc.set(24, redIntensity);
  Tlc.set(25, blueIntensity);
  Tlc.set(26, greenIntensity);
  Tlc.set(27, redIntensity);
  Tlc.set(28, blueIntensity);
  Tlc.set(29, greenIntensity);

Glow Blocks Multiples

IMG_3199I the original plan was to make a whole bunch of boxes. I didn’t want to use an Arduino in every box, so I was going to use an ATmega328P. I couldn’t even get the Arduino bootloader onto the chip, so that did not work out at all. Also, none of the perfboard circuits I built worked either. I couldn’t find the weak or broken connection on the board, so I ended up just using the breadboard.

IMG_3198I also tried building Arduino shields. They didn’t work either. Making multiples of this project failed big time. It was very annoying.




Glow Blocks Accelerometers

Accelerometer and LEDs from coldsoup753 on Vimeo.

I had a great deal of trouble with the accelerometers of this project. I tried the ADXL335 and the MPU-6050 (as the MPU-6050 page says, “Reading raw values is easy, the rest is not”). Both accelerometers were good at spitting out data, but it was extremely difficult to get that data to be anything other than seemingly random numbers.

Eventually I found the ADXL345, which is simply the updated version of the ADXL335, and that turned out to be exactly the part that I needed. I combined this tutorial with my RGB LED code from my RGB Pencil project to make an LED light up a specific color when the accelerometer senses a tap, double tap, free fall, and inaction.

I tested this out by strapping a breadboard to my Arduino and dropping it a whole bunch of times, and it worked just fine. I originally planned on using the TLC5940NT to drive a whole bunch of RGB LEDs, but that did not work out. I ended up simply using the remaining pins on the Arduino.


/Arduino 1.0+ Only!
//Arduino 1.0+ Only!


//Accelerometer code from here:
ADXL345 adxl; //variable adxl is an instance of the ADXL345 library

int RED_PIN = 13; //set pins for LEDs
int GREEN_PIN = 12;
int BLUE_PIN = 11;
int RED_PIN2 = 10; //set pins for LEDs
int GREEN_PIN2 = 9;
int BLUE_PIN2 = 8;
int RED_PIN3 = 7; //set pins for LEDs
int GREEN_PIN3 = 6;
int BLUE_PIN3 = 5;
int RED_PIN4 = 4; //set pins for LEDs
int GREEN_PIN4 = 3;
int BLUE_PIN4 = 2;

void setup(){
  pinMode(RED_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
  pinMode(RED_PIN2, OUTPUT);
  pinMode(GREEN_PIN2, OUTPUT);
  pinMode(BLUE_PIN2, OUTPUT);
  pinMode(RED_PIN3, OUTPUT);
  pinMode(GREEN_PIN3, OUTPUT);
  pinMode(BLUE_PIN3, OUTPUT);
  pinMode(RED_PIN4, OUTPUT);
  pinMode(GREEN_PIN4, OUTPUT);
  pinMode(BLUE_PIN4, OUTPUT);

  //set activity/ inactivity thresholds (0-255)
  adxl.setActivityThreshold(75); //62.5mg per increment
  adxl.setInactivityThreshold(75); //62.5mg per increment
  adxl.setTimeInactivity(5); // how many seconds of no activity is inactive?
  //look of activity movement on this axes - 1 == on; 0 == off 
  //look of inactivity movement on this axes - 1 == on; 0 == off
  //look of tap movement on this axes - 1 == on; 0 == off
  //set values for what is a tap, and what is a double tap (0-255)
  adxl.setTapThreshold(50); //62.5mg per increment
  adxl.setTapDuration(15); //625μs per increment
  adxl.setDoubleTapLatency(80); //1.25ms per increment
  adxl.setDoubleTapWindow(200); //1.25ms per increment
  //set values for what is considered freefall (0-255)
  adxl.setFreeFallThreshold(5); //(5 - 9) recommended - 62.5mg per increment
  adxl.setFreeFallDuration(20); //(20 - 70) recommended - 5ms per increment
  //setting all interupts to take place on int pin 1
  //I had issues with int pin 2, was unable to reset it
  adxl.setInterruptMapping( ADXL345_INT_SINGLE_TAP_BIT,   ADXL345_INT1_PIN );
  adxl.setInterruptMapping( ADXL345_INT_DOUBLE_TAP_BIT,   ADXL345_INT1_PIN );
  adxl.setInterruptMapping( ADXL345_INT_FREE_FALL_BIT,    ADXL345_INT1_PIN );
  adxl.setInterruptMapping( ADXL345_INT_ACTIVITY_BIT,     ADXL345_INT1_PIN );
  adxl.setInterruptMapping( ADXL345_INT_INACTIVITY_BIT,   ADXL345_INT1_PIN );
  //register interupt actions - 1 == on; 0 == off  
  adxl.setInterrupt( ADXL345_INT_SINGLE_TAP_BIT, 1);
  adxl.setInterrupt( ADXL345_INT_DOUBLE_TAP_BIT, 1);
  adxl.setInterrupt( ADXL345_INT_FREE_FALL_BIT,  1);
  adxl.setInterrupt( ADXL345_INT_ACTIVITY_BIT,   1);
  adxl.setInterrupt( ADXL345_INT_INACTIVITY_BIT, 1);

void loop(){
  //Boring accelerometer stuff   
  int x,y,z;  
  adxl.readAccel(&x, &y, &z); //read the accelerometer values and store them in variables  x,y,z

  // Output x,y,z values - Commented out

  //Fun Stuff!    
  //read interrupts source and look for triggerd actions
  //getInterruptSource clears all triggered actions after returning value
  //so do not call again until you need to recheck for triggered actions
   byte interrupts = adxl.getInterruptSource();
  // freefall
  if(adxl.triggered(interrupts, ADXL345_FREE_FALL)){
  if(adxl.triggered(interrupts, ADXL345_INACTIVITY)){
  if(adxl.triggered(interrupts, ADXL345_ACTIVITY)){
  //double tap
  if(adxl.triggered(interrupts, ADXL345_DOUBLE_TAP)){
    Serial.println("double tap");
  if(adxl.triggered(interrupts, ADXL345_SINGLE_TAP)){


void showRGB(int color)
  int redIntensity;
  int greenIntensity;
  int blueIntensity;

  // Here we'll use an "if / else" statement to determine which
  // of the three (R,G,B) zones x falls into. Each of these zones
  // spans 255 because analogWrite() wants a number from 0 to 255.

  // In each of these zones, we'll calculate the brightness
  // for each of the red, green, and blue LEDs within the RGB LED.

  if (color <= 255)          // zone 1
    redIntensity = 255 - color;    // red goes from on to off
    greenIntensity = color;        // green goes from off to on
    blueIntensity = 0;             // blue is always off
  else if (color <= 511) // zone 2 { redIntensity = 0; // red is always off greenIntensity = 255 - (color - 256); // green on to off blueIntensity = (color - 256); // blue off to on } else // color >= 512       // zone 3
    redIntensity = (color - 512);         // red off to on
    greenIntensity = 0;                   // green is always off
    blueIntensity = 255 - (color - 512);  // blue on to off

  // Now that the brightness values have been set, command the LED
  // to those values

  analogWrite(RED_PIN, redIntensity);
  analogWrite(BLUE_PIN, blueIntensity);
  analogWrite(GREEN_PIN, greenIntensity);
  analogWrite(RED_PIN2, redIntensity);
  analogWrite(BLUE_PIN2, blueIntensity);
  analogWrite(GREEN_PIN2, greenIntensity);
  analogWrite(RED_PIN3, redIntensity);
  analogWrite(BLUE_PIN3, blueIntensity);
  analogWrite(GREEN_PIN3, greenIntensity);
  analogWrite(RED_PIN4, redIntensity);
  analogWrite(BLUE_PIN4, blueIntensity);
  analogWrite(GREEN_PIN4, greenIntensity);

Glow Blocks Materials

Diffusion Comparison


One of the main pieces of feedback that I got from play-testing was that the boxes seemed to delicate to really throw or kick, partially because they could see the electronics inside. So, I decided to frost the interior of the boxes. The material tests went well and the frost held up to the kicking and dropping, but not to opening and closing the boxes. The paint has no elasticity and started just flaking off.

Other material options include making the boxes from plank foam, frosting the boxes with contact paper instead of spray, or casting custom shapes from foam. I’m interested in experimenting with casting shapes, but I’d also like to try and maintain the ‘building block’ component of this idea. I’m guessing that this is going to end in a bunch of experiments and idea doodles.