Research Methods

Thesis Statement Drafts

In emerging research and design practice, science fiction narratives are increasingly being used as modes of imagining alternative futures in a generative and critical way. With the acceleration of technological and social development, we are beginning to better understand the value of speculative design and design fiction. In hopes of creating and maintaining a sustainable future, these predictions are best examined by exploring the extrapolation techniques used to create science fiction.

With an array of speculative design geared towards sustainability and progress, science fiction has steadily predicted and influenced the technology of the future. By exploring the connections between science fiction and science fact we are able to better comprehend some of the tools in which we interact and innovate through speculative design.

Using science fiction to imagine a sustainable future, we are able to investigate the value of science fiction and bypass the stigma surrounding the collective Hollywood consciousness. By investigating speculative design through science fiction we hope to prepare for the constant flux of life and better understand the importance of futurist theory.

With the global influence of science fiction culture and speculative design, science fiction prototyping is increasingly innovating, predicting, and shaping alternate futures. Using believable fundamentals of societies, authors are able to imagine the tools useful for a sustainable world.

By using science fiction as science fact we are able to develop new technologies as well as imagine a sustainable future. The many angles provoking the evolution of science fiction are best understood by exploring the tools in which speculative design predicts and assists the sustainability of life.

This Twitter Mood Lamp seeks to visualize the mood of the city of Denver Colorado. To this end, it is an Arduino Yun controlled 3D printed lamp that glows red, green, or blue based on whether the mood of the city is perceived to be angry, happy, or sad respectively. The mood of the city is calculated by scraping the Twitter API with the help of Temboo for specific keywords that might indicate the emotional state of the tweeters. To restrict this to Denver, the latitude and longitude of the center of Denver was provided and only tweets within a 12 mile radius were retrieved. As they’re retrieved, these tweets are outputted onto the Arduino Yun’s serial monitor as well as classified under an emotional state. A running tally is kept of the mood and the lamp glows the color associated with the predominant mood. If its intended use is for an extended period of time, the tally can be enabled to forget tweets retrieved longer than an hour ago. Alternatively, it can scrape twitter at specified intervals and glow the mood associated with tweets only made it in that duration. What color is your city?  (The Code is open source and included below the pictures)

DSC02252 DSC02254 DSC02256

A promo piece I made for the Emergent Digital Practices program at the University of Denver. It is displayed on 3 monitors inside of the Shwayder Art Building.

iHippo Memory Chip is a video I made the EDP graduate program at Denver University.

Do we use technology for the right purposes?
How far will tech take us?
Will it make us smarter by expanding our minds or make us dumber by distracting our minds with selfish benefits?
How much of our privacy will we sacrifice for the sake of new technology?
Would you give up your mind to become superhuman?
Will we lose the ability of self interpretation(art)?
Do our skills and knowledge define us?
What privacy we give up in modern society is nothing compared to what we will give up in the future…



Senator Duino is a self roaming robot that uses a Ping Sonar to navigate.  The Senator is powered by an Arduino Uno and built on a Parallax robot chassis. Senator Duino recently had a conference with some concerned citizens to answer their questions. Refer to the video below to see how Senator Duino responded to the citizen’s important issues.

(Also included below is the Arduino code that makes Senator Duino work. It is an open source code.)


Partial Time-Lapse Build of Senator Duino




Arduino Code:

//Senator Duino by Chadwick Friedman//**

#include <Servo.h> // Include servo library

Servo servoLeft; // Servo object instances
Servo servoRight;
Servo servoTurret;

const int servoLeftPin = 13; // I/O Pin constants
const int servoRightPin = 12;
const int servoTurretPin = 11;
const int pingPin = 10;
const int piezoPin = 4;

const int msPerTurnDegree = 6; // For maneuvers
const int tooCloseCm = 30; // For distance decisions
const int bumpedCm = 6;
int ccwLim = 1400; // For turret servo control
int rtAngle = 900;
const int usTocm = 29; // Ping))) conversion constant

// Aequence of turret positions.
int sequence[] = {0, 2, 4, 6, 8, 10, 9, 7, 5, 3, 1};

// Declare array to store that many cm distance elements using pre-calculated
// number of elements in array.
const int elements = sizeof(sequence);
int cm[elements];

// Pre-calculate degrees per adjustment of turret servo.
const int degreesTurret = 180/(sizeof(sequence)/sizeof(int)-1);

int i = -1; // Global index
int sign = 1; // Sign of increments
int theta = -degreesTurret; // Set up initial turret angle

void setup() // Built-in initialization block
tone(piezoPin, 3000, 1000); // Play tone for 1 second
delay(1000); // Delay to finish tone

Serial.begin(9600); // Open serial connection

servoLeft.attach(servoLeftPin); // Attach left signal to pin 13
servoRight.attach(servoRightPin); // Attach right signal to pin 12
servoTurret.attach(servoTurretPin); // Attach turret signal to pin 12
maneuver(0, 0, 1000); // Stay still for 1 second
turret(0); // Set turret to 0 degrees

void loop() // Main loop auto-repeats
maneuver(200, 200); // Go full speed forward UFN
i++; // Increment turret index

// Advance turret servo to next position in sequence and wait for it to get there.
theta = sequence[i] * degreesTurret;

cm[i] = cmDistance(); // Measure cm from this turret angle

// If object in +/- 36 degrees from center is within tooCloseCm threshold…
if ((sequence[i]>=3) && (sequence[i]<=7) && (cm[i] < tooCloseCm))
maneuver(0, 0); // Stop moving
int theta = findOpening(); // Get opening (in terms of sequence element
theta *= degreesTurret; // Convert sequence element to degree angle

// Convert degree angle to time the BOE Shield-Bot wheels will have to turn to face
// direction of turret.
int turnAngleTime = (90 – theta) * msPerTurnDegree;

if(turnAngleTime < 0) // If negative turning angle,
maneuver(-200, 200, -turnAngleTime); // then rotate CCW for turningAngleTime ms
else // If positive turning angle,
maneuver(200, -200, turnAngleTime); // then rotate CW for turningAngleTime ms
maneuver(200, 200); // Start going forward again

if(i == 10) // If turret at max, go back to zero
i = -1;

* Control BOE Shield-Bot servo direction, speed, set and forget version.
* Parameters: speedLeft – left servo speed
* speedRight – right servo speed
* Backward Linear Stop Linear Forward
* -200 -100……0……100 200
void maneuver(int speedLeft, int speedRight)
// Call maneuver with just 1 ms blocking; servos will keep going indefinitely.
maneuver(speedLeft, speedRight, 1);

* Control BOE Shield-Bot servo direction, speed and maneuver duration.
* Parameters: speedLeft – left servo speed
* speedRight – right servo speed
* Backward Linear Stop Linear Forward
* -200 -100……0……100 200
* msTime – time to block code execution before another maneuver
* Source:
void maneuver(int speedLeft, int speedRight, int msTime)
servoLeft.writeMicroseconds(1500 + speedLeft); // Set Left servo speed
servoRight.writeMicroseconds(1500 – speedRight); // Set right servo speed
if(msTime==-1) // if msTime = -1
servoLeft.detach(); // Stop servo signals
delay(msTime); // Delay for msTime

* Position the horn of a Parallax Standard Servo
* Parameter: degreeVal in a range from 90 to -90 degrees.
void turret(int degreeVal)
servoTurret.writeMicroseconds(ccwLim – rtAngle + (degreeVal * 10));

* Get cm distance measurment from Ping Ultrasonic Distance Sensor
* Returns: distance measurement in cm.
int cmDistance()
int distance = 0; // Initialize distance to zero
do // Loop in case of zero measurement
int us = ping(pingPin); // Get Ping))) microsecond measurement
distance = convert(us, usTocm); // Convert to cm measurement
delay(3); // Pause before retry (if needed)
while(distance == 0);
return distance; // Return distance measurement

* Converts microsecond Ping))) round trip measurement to a useful value.
* Parameters: us – microsecond value from Ping))) echo time measurement.
* scalar – 29 for us to cm, or 74 for us to in.
* Returns: distance measurement dictated by the scalar.
int convert(int us, int scalar)
return us / scalar / 2; // Echo round trip time -> cm

* Initiate and capture Ping))) Ultrasonic Distance Sensor’s round trip echo time.
* Parameter: pin – Digital I/O pin connected to Ping)))
* Returns: duration – The echo time in microseconds
* Source: Ping by David A. Mellis, located in File -> Examples -> Sensors
* To-Do: Double check timing against datasheet
long ping(int pin)
long duration; // Variables for calculating distance
pinMode(pin, OUTPUT); // I/O pin -> output
digitalWrite(pin, LOW); // Start low
delayMicroseconds(2); // Stay low for 2 us
digitalWrite(pin, HIGH); // Send 5 us high pulse
digitalWrite(pin, LOW);
pinMode(pin, INPUT); // Set I/O pin to input
duration = pulseIn(pin, HIGH, 25000); // Measure echo time pulse from Ping)))
return duration; // Return pulse duration

* Find an opening in system’s 180-degree field of distance detection.
* Returns: Distance measurement dictated by the scalar
* To-do: Clean up and modularize
* Incorporate constants
int findOpening()

int Ai; // Initial turret angle
int Af; // Final turret angle
int k = sequence[i]; // Copy sequence[i] to local variable
int ki = k; // Second copy of current sequence[i] int inc; // Increment/decrement variable
int dt; // Time increment
int repcnt = 0; // Repetitions count
int sMin; // Minimum distance measurement

// Increment or decrement depending on where turret is pointing
if(k <= 5)
inc = 1;
inc = -1;

// Rotate turret until an opening becomes visible. If it reaches servo limit,
// turn back to first angle of detection and try scanning toward other servo limit.
// If still no opening, rotate robot 90 degrees and try again.
repcnt++; // Increment repetition count
if(repcnt > ((sizeof(sequence) / sizeof(int)))*2)// If no opening after two scans
maneuver(-200, -200, 100); // Back up, turn, and stop to try again
maneuver(-200, 200, 90*6);
maneuver(0, 0, 1);
k += inc; // Increment/decrement k
if(k == -1) // Change inc/dec value if limit reached
k = ki;
inc = -inc;
dt = 250; // Turret will take longer to get there
if(k == 11)
k = ki;
inc = -inc;
dt = 250;
// Look for index of next turret position
i = findIn(k, sequence, sizeof(sequence)/sizeof(int));

// Set turret to next position
int theta = sequence[i] * degreesTurret;
turret(theta); // Position turret
delay(dt); // Wait for it to get there
dt = 100; // Reset for small increment turret movement

cm[i] = cmDistance(); // Take Ping))) measurement
while(cm[i] < 30); // Keep checking to edge of obstacle

sMin = 1000; // Initialize minimum distance to impossibly large value
for(int t = 0; t <= 10; t++)
if(sMin > cm[t]) sMin = cm[t]; // Use sMin to track smallest distance
if(sMin < 6) // If less than 6 cm, back up a little
maneuver(-200, -200, 350);
k = -1; // Get turret ready to start over
maneuver(0, 0); // Stay still indefinitely

// Keep rotating turret until another obstacle that’s under 30 cm is detected or the turret
// reaches the servo limit. Keep track of the maximum distance and the angle when this portion
// of the scan started and stopped.

Ai = sequence[i]; // Save initial angle when obstacle disappeared from view

k = sequence[i]; // Make a copy of the turret position again

int aMax = -2; // Initialize maximum distance measurements to impossibly small values
int cmMax = -2;

do // Loop for scan
k += inc; // Inc/dec turret position
// Look up index for turret position
i = findIn(k, sequence, sizeof(sequence)/sizeof(int));
int theta = sequence[i] * degreesTurret; // Position turret

cm[i] = cmDistance(); // Measure distance

if(cm[i]>cmMax) // Keep track of max distance and angle(max distance)
cmMax = cm[i];
aMax = sequence[i];
while((cm[i] > 30)&&(sequence[i]!=0)&&(sequence[i]!=10));
// Keep repeating while the distance measurement > 30 cm, and the turret is not near its
// mechanical limits.

Af = sequence[i]; // Record final turret position
int A = Ai + ((Af-Ai)/2); // Calculate middle of opening

// Set turret index for straight ahead in prep for turn.
i = findIn(5, sequence, sizeof(sequence)/sizeof(int));
int theta = sequence[i] * degreesTurret;

if(sMin < 7) // Turn further if too close
if (A < aMax) return aMax; else return A;
if (A < aMax) return A; else return aMax;

* Finds the first instance of a value in an array.
* Parameters: value to search for
* array[] to search in
* elements – number of elements to search
* Returns: index where the matching element was found
int findIn(int value, int array[], int elements)
for(int i = 0; i < elements; i++)
if(value == array[i]) return i;
return -1;


This Processing Sketch is a particle system that uses ArrayList and PVector to trace text with particles. It develops slowly over time in to the Emergent Digital Practices logo. This sketch was made specifically for a vertical 1920×1080 size monitor for the Emergent Digital Practices offices at the University of Denver. The images below show what the sketch looks like from start to finish. I have also uploaded a video so you can see the sketch in action!

Also included below the images is the code. It is an open source code developed by me.







//Chadwick Friedman**
// Self generating particle system that uses ArrayList and PVector//**
ArrayList<Particle> particles; //stores a variable number of objects (items easily added or removed and rezised dynamically)*
int[] list;
PVector axis; //sets location for particles to generate
int distance; //sets distance from each particle determining connection
PFont font; //sets font
int count, max; //maximum number of particles
char Key1 = ‘e’;
char Key2 = ‘d’;
char Key3 = ‘p’;
char Key4 = ‘*’;
char Key5 = ‘*’;

void setup() {
strokeWeight(0.25); // thickness of particles
distance = 50; //distance between particles
particles=new ArrayList<Particle>();
count=0; //sets range

font = createFont(“hurtmold-48.otf”,770); //sets font & font size
translate(width/2-140, height/2);
// For centered text use: text(Key1, 100, height/2-60);
text(Key2, 0,0);
popMatrix();//text(Key2, width/2, height/2-60);
translate(1160,220); //150
text(Key3,0,0); //text(Key3, 490, height/2-60);

text(Key4,300,825); text(Key4,365,500); text(Key4,890,190);text(Key4,290,125); text(Key4,140,325);
text(Key4,160,625); text(Key4,490,325); text(Key4,650,115);text(Key4,970,925); text(Key4,100,925);
text(Key4,1580,155); text(Key4,1770,325);text(Key4,1700,555);text(Key4,1770,925);text(Key4,1790,80);

// Iterates through ArrayList and gets each Particle
// The ArrayList also keeps track of the total number of particles.
list = new int[width*height]; //sets area for particles to trace font
for(int y = 0; y<=height-1; y++){
for(int x = 0; x<=width-1; x++){
color pb = pixels[y*width+x];
if(red(pb)<5){ list[y*width+x]=0; }
else { list[y*width+x]=1; }}}

void draw() { // creates the particle chain // change background, stroke, fill **
int i=0;
axis = new PVector(int(random(50,width)),int(random(50,height))); //axis location

if(list[int(axis.y*width+axis.x)]==0 && list[int(axis.y*width+axis.x+1)]==0 &&
list[int(axis.y*width+axis.x-1)]==0 && list[int((axis.y+1)*width+axis.x)]==0 &&
particles.add(new Particle(axis.x,axis.y)); // A new Particle object is added to the ArrayList every cycle through draw().


//stroke(130,random(160),120,900); //color of particles

for (int i = 0; i < particles.size(); i++) { //generates particles from class
Particle p=particles.get(i);
for(int j=i+1;j<particles.size();j++){
Particle pp=particles.get(j);
if (dist(p.location.x , p.location.y , pp.location.x , pp.location.y) < distance) {
line(p.location.x , p.location.y , pp.location.x , pp.location.y);

class Particle { //controls particle actions/reactions
PVector location;
PVector velocity;
Particle(float x, float y) { //function for location and speed
location = new PVector(x,y); //particle location
velocity = new PVector(random(1),1); //speed of particles // leaving out (random) in second variable adds ‘growing’ effect

void update() { //constantly updates particles
if ((list[int(location.y)*width+int(location.x+velocity.x)]==1) || (list[int(location.y)*width+int(location.x-velocity.x)]==1)) { velocity.x *= -1; }
if ((list[int(location.y+velocity.y)*width+int(location.x)]==1) || (list[int(location.y-velocity.y)*width+int(location.x)]==1)) { velocity.y *= -1; }

iHippo – Memory Chip (Direct Neural Interfacing) straight into your hippocampus!


I am a grad student in the Emergent Digital Practices program at Denver University. For my Digital Tools Concepts and Design class we had to make a video about a near digital future. My video is about a wearable watch-like device called CritBit. The device criticizes every aspect of your life.