Category: Object

Tigop Object

Here I made a small device with the makey makey that functions as a module to teach users about consent. PERFECT for Haven courses that incoming freshman must take as a requirement, now in addition to sending students the last lecture book, students will also be sent a consent module package.

I also thought about how this little module might be used to keep people who want to diet away from junk food. They can place a chocolate bar or cookie inside a box and put it under these guys.

The only downside to this is you need to wear something on your wrist to close the circuit. I would have preferred to have a way to have this happen without the thing that goes on the wrist, but that’s okay. Maybe one day.

Written by Comments Off on Tigop Object Posted in Object


I wanted to make unnecessary tweaks to an everyday object that would record and post something banal about its use. I came up with many many ideas (a motion detector for a book so that a tweet would be produced for every page turned, a motion detector for eye glasses that would post an instagram picture every time you blinked, a pressure detector for a shoe that would tweet every 100 steps). The concept behind this piece would be to (perhaps pedantically) point out the banality/self-centrist nature of posts on our social media as well as the hilarious frivolity of the internet of things, taken to an extreme. At this point, such statements are almost cliché, I realize, but I wanted to do it anyway.

I finally settled on creating a coaster that would make a facebook post every time a user picked up their drink. The post would document the place and time as well as an optimistic health-related message about staying hydrated.

Written by Comments Off on aliot-object Posted in Object


Update (Nov 29, 2016)

I (cambu) continued to work on this project with another classmate, Lucas Ochoa, in Environments Design Studio/Lab (51-265/7). See the below video for an iterated version of the project. The entire demo is working except the environmental controls (fan & projector screen). Guodu and I (cambu) will be moving forward from this second iteration for our final project. See the process blog posts for the other course at the below links (password: Environments).

For our (guodu + cambu) project, we prototyped various examples of tangible media interactions for computer input. We began our project buzzing with inspiration from Hiroshii Ishii’s lecture on Radical Atoms, intrigued to play with some basic ideas from the domain of tangible media. Our early ideas were focused around the notion of creating a flip-based “cubular” interaction that would allow the traversal of linear or 2D dimensional information spaces.




System Diagram


Code (github)

Note: there seems to be issues with the xml file getting messed up by the wordpress code embedder plugin, please look at the code on github to see it correctly.

    App Switch Right

    KeyCode::TAB, ModifierFlag::COMMAND_L


    KeyCode::TAB, ModifierFlag::COMMAND_L,                                                      

    App Switch Left

    KeyCode::TAB, ModifierFlag::COMMAND_L,ModifierFlag::SHIFT_L


    KeyCode::TAB, ModifierFlag::COMMAND_L,ModifierFlag::SHIFT_L,                                                     


Written by Comments Off on guodu-cambu-object Posted in Object

Xastol – Drewch – Object



sn34kb0t starts sneaking every time someone in the area posts a tweet. It traverses stealthily over flat terrain using two dc motors and 2 servos, and communicates with through a cloudbit.

At first, the concept we were going for was to create a terminally depressed robot that would disconnect itself from its power source after seeing lots of negative tweets (via and cloudbit). Although this was a very viable direction that we could have kept going with, we decided that littleBits weren’t the right medium for the message (too many lights, spotty connection, poor movement options, etc.).

Instead, we put a shoebox over the robot.




IFTTT applet

sneak_bot_iftt2          sneak_bot_iftt1



sn34kBot in Action


Written by Comments Off on Xastol – Drewch – Object Posted in Object

Jaqaur – Object

Screaming Monster Alarm

Okay, yes. This project was done fairly last minute, while I had no creative ideas, and it depends on the use of a CloudBit, which I didn’t have. So, all in all, I wouldn’t really call it a success.
Still, here is a little video I made showing my Baby Monster in action:

Basically, the screaming monster alarm is an alarm clock that is active between 8:00 and 8:30 (that’s the networked part) and will scream unless it sees motion with its motion sensors. I thought it would be good because it would stop me from accidentally falling back asleep after turning it off. I made the tube to cover it so it wouldn’t pick up miscellaneous other motion, like that of my roommate, because the sensor it very sensitive. I like how you can make it be quiet by covering its mouth (it was that covering action that gave me the idea to make the tube into a creature). But in retrospect, it’s really not much different from a regular alarm clock.

I got the sensor/buzzer part working, but I couldn’t actually get the timed aspect to work because, as I mentioned above, I didn’t really have access to a CloudBit and didn’t want to wait around for one for the sake of this project. I did create some events on “If This Then That” that WOULD activate and deactivate the cloud bit at 8:00 and 8:30 respectively, if I had one.

I have very few sketches for this project and no code to embed, due to all of the reasons above. Not my best work, but I’m glad I learned about “If This Then That,” and its always fun to play with Little Bits. Had networking our object not been part of the assignment, I would have loved to experiment with the Makey Makey. That device was definetely the my favorite thing from this last week.

Written by Comments Off on Jaqaur – Object Posted in Object


Drunken Nightlight
The Party Animals Awaken


If there’s one thing we learned from this, it’s that Keali and Kadoin are not meant for hardware.
Our plan was to make a nightlight that would activate based on the sunset time of a certain location, which would be done with the CloudBit and IFTTT’s weather applet options. This was a simple though practical idea, which meant the rest of the project became geared towards craft and the actual construction of the nightlight, which went through multiple iterations: we had rotating carousel ideas, light boxes, and planetarium-like sketches planned, but the actual reality was a more complicated process of how to get something to stand still and rotate smoothly, all the while having the littlebits stay connected and be distributed properly so that the lights would work within the tube. We went through multiple construction tests with papers, tissue papers, cardboard, clay, and finally made a platform by 3D-printing it (shoutout to John’s help), and finalized an unfortunately wonky design of a tall tube with knifed out designs that swings unevenly and tilts because Keali forgot that physics was a thing when he cut all of the landscape outlines on one side which consequently caused the entire structure to bend over (and much more so when it spins). A boxed structure was a base that contained the motor bit and set it to stand upright, while the splitter bit directed the rest of the RGB and LED lights up into the tube; clay animals were tied with string and hung from the top base of the tube. But all horror aside a final product was successfully completed (though the refinement itself is… not much a success), and we have ourselves a rotating drunken nightlight that activates once the sun sets, and halts at sunrise. We miss D3…






Written by Comments Off on Keali-Kadoin-Object Posted in Object


Claire and I made a trampoline that can dial any phone number, input as numbers corresponding to jumps by a user. The trampoline essentially functions as a keyboard to type the numbers for you. Phones are often used absentmindedly, we may feel tethered to them to stay connected, and we often lead sedentary lives sitting at laptops all day. So, here comes TrampolineDial, breaking up the monotony, and turning phone calls into an active, fun interaction!

We wrote the code using Arduino. When a user jumps, the Little Bits act as a cursor, typing in numbers that create the phone number. Apparently if we used Java.robot we could automate the calling, so that the call would be placed once the 10 digits were generated by the jumps.



Here’s the diagram:


Here’s a video of TrampDial in action! :

Written by Comments Off on Anson/Claker-NetworkedObject Posted in Object

kander + lumar – object

For our Networked Object, we decided to make one of Lumar’s long-desired ideas, a bubble wrap dispenser, under the assumption that everybody finds popping bubble wrap useful to relieve nervous energy. We improved upon it by installing a roll trigger, and every time a piece of bubble wrap is pulled out, the trigger is pulled, and the connected CloudBit activates the IFTTT Applet that posts to the slack channel called “#stresspopper (you should all subscribe). Now everybody can feel your pain!

img_1791 Diagram of the StressPopper. The power source is connected to a roll trigger, which it triggered every time a piece of bubble wrap is pulled out. The trigger is connected to a CloudBit, which activates the IFTTT Applet that posts to the #stresspopper Slack channel

We used a ceramic flower pot to house the bubble wrap, and we laser cut a top with a slit for the bubble wrap to come out of. We had to do several iterations of the top, as the first tops we made broke. We also had to figure out how to fold the bubble wrap so that pulling one piece brings the next piece out of the slit (like Kleenex), and used a little bit of rubber cement between each piece to aid in this process.


Our original idea was to create a stress ball with a push button inside, and every time the ball was squeezed, it posted to the Slack channel, but the balloons we were using kept tearing, and we were worried about the Little Bits getting crushed.

img_1779 img_1778 img_1776


Written by Comments Off on kander + lumar – object Posted in Object

Catlu – Arialy – Object

IoT – Umbrella

Physical Object Documentation:

dsc02195 dsc02209 dsc02210

If This Then That Documentation:

screen-shot-2016-11-18-at-12-05-44-pm screen-shot-2016-11-18-at-12-09-59-pm screen-shot-2016-11-18-at-12-10-45-pm screen-shot-2016-11-18-at-12-12-09-pm



For our project, we were drawn to the idea of using the internet and the Little Bits to establish a connection between 2 people. We thought a lot about how we could use the little bits we had (mostly lights, buttons, and a speaker), to establish a relationship between different places. In the end we decided to use the sound of rain. When people are living apart from each other in different places, it’s often hard to feel connected because you do not experience things together anymore. The final idea we decided on was a set of 2 umbrellas, each of which uses a cloud bit to connect to If This Then That. Each umbrella would be set to the place where the opposite person is, so when the opposite person is experiencing rain, you will hear the rain too. Sometimes it only take a little to help establish a greater feeling of intimacy, and our project was an attempt to do so. For the umbrella, we connected a wall charger power bit to a cloud bit and an input speaker bit and an mp3 player. We then connected the cloud bit to IFTT and created an applet with that would let you set a location. If the status of the location changes to “rain,” IFTT sends a signal to the cloud bit, and the speaker will start playing the music from the mp3 player. Optimally we would have wanted something small like an Ipod Nano or Shuffle, but had to make do with a phone. Originally we also wanted to use a battery for the power supply, but the p1 battery power didn’t work with the cloud bit, which then wouldn’t connect to IFTT. We ended up using the wall charger bit and running the strip along the edge of the wall.

Written by Comments Off on Catlu – Arialy – Object Posted in Object



A compilation of some of our experimenting throughout the week. This includes playing with the sequencer, place two oscillators one after another, and also our generative melodies.


This is the view from Audition, from when we were mixing our soundcloud track together.

15139327_10211257399539860_552601983_n This is the visualizer that we used to help our debugging process. The top bar being the melody, and the bottom being the base line.

Here are some of the little bit arrangements we used.



This is our computer which is connected to the mp3 piece. The music is then manipulated through a filter and a delay, then played out the speaker which is connect to a splitter. One branch of the splitter goes to the headphones, and the other to the microphone, which is also attached to the computer. The tracks were first recorded with Audacity, then mixed with Audition. fullsizerender-1

Little Bits pieces

  • power
  • oscillator
  • mp3 out
  • midi in/out
  • synth speaker
  • filter
  • delay
  • envelope
  • keyboard
  • pulse
  • noise
  • sequencer

Initial Concept
We both immediately got excited over the Korg synth Little Bits pieces, and knew that we wanted to see how far we could push the affordances of the hardware. At the beginning we thought of only creating music collaboratively, one on the keyboard piece, and one manipulating the sound through playing with cutoffs, feedback loops, and attacks/delays. Our first instinct was to work with Makey Makey to use IFTTT. The general idea was to have a jamsesh and when we fell into a rhythm that we liked, we would hit the Makey Makey to begin recording, then hit it again to stop recording and to upload the track to Soundcloud. However, after some investigation, we realized the limitations of IFTTT and that we would rather spend time trying to learn new ways to create music, rather than to dwell over uploading issues.

2nd Iteration
Deciding to focus on the music, we discovered the mp3 Little Bits piece. This piece allowed create music through p5js, which we could then modify and manipulate the way we had been for the music generated with the Little Bits pieces. Our concept was that we could have a stream of melodies being generated through our program, and we could have a collaborative jamsesh between the coded music, and our own improvisations on the little bits pieces. After some brainstorming, we came up with an idea to translate strings, possibly scraped from places like Twitter or NYTimes, into melodies, but in a very meta way. The program would translate any letter from A-G into their corresponding note, if the character was not one of those letters, it would simply hold the previous note, or rest. If given a string such as “a ce melody“, our program would translate it into AAAACEEEEEEDD. This required us to also to lean about the p5 sound library, and also create our own scale using an array of midi numbers.

We wanted our music to have some depth so we figured we could also generate a baseline. If we were using the content of the article or the tweet as the melody, then the username or author’s name could be used for the baseline. This was when we had the pleasure of learning about Euclidean rhythms (Godfried Toussaint). Given two numbers, the algorithm can create a beat made by evenly distributing the smaller number into the larger number. Some of these patterns can be found in traditional music, such as E(3,8). “In Cuba it goes by the name of the tresillo and in the USA is often called the Habanera rhythm” [Toussaint]. We would then use the mp3 Little Bit to bring in the melody, and use the midi Little Bit for the baseline, which would enable us to manipulate the two pieces differently.


Unfortunately, because the melody was following patterns within the string, it wasn’t really following any rhythmic time at all. This made it difficult to align it to any baseline. Though we thoroughly enjoyed coding and learning about euclidean rhythms, we ended up not using this algorithm.

3rd Iteration
Once we had finalized our melody code, we began to set up all of our pieces. We connected Krawleb’s computer with an aux cord to the mp3 little bits piece, to play our coded melodies into the little bit. We then attached a filter and a delay to the mp3 and connect them to the speaker. We used a splitter connected to the speaker, with one branch connected to a microphone that recorded into Antar’s computer, and the other branch connected to headphones. We were really excited to start manipulating the melodies and adding in our own improvised music, but we quickly discovered the limitations of the Little Bits. Unfortunately, the audio would have these sharp clips, that sounded like the speaker was blowing out. At first we thought one of the bits was broken, but after testing each piece individually, we realized that it was not a single piece that was causing this, but rather the quantity. When we added a 10th piece to our path, no matter which piece it was, we would have this error. Unfortunately to be able to do any sort of collaboration with our generative melody, we would need to have at least 10 pieces connected. We decided to then simply record our manipulated melody, then, separately, record us creating our own music.

Through the project we felt some other limitations of the Little Bits, such as overheating, weak power, sound compression, and a fatality (a delay blew out). We spent a ton of time making really interesting music, but failed to record most of it. In retrospect, we should have began recording earlier, and much more frequently, so as to have a larger library to mix with. We should have also incorporated a simple networked component.


The Toilet Paper Printer


The Toilet Paper Printer plots data in realtime on a roll of toilet paper. It can accept data such as a simple sine wave, amplitude of noises in its surroundings, or even any data curled from the internet. Its circuit mainly consists of three littlebit DC motors and a cloudbit, while the entire structure is built with cardboard boxes, straws, and toothpicks.




I like plotters. As a kid I enjoyed ripping off the top of a printer while its printing and peaking into the machine as it worked. So when I saw all the motors we’ve got, I suggested that we can make our own plotter/printer thing.


The Print Head

We spent most of our time figuring out how to make a print head that actually works.

At first we tried to make a conveyer-belt-like mechanism to move the pen. That didn’t work because little bits motors couldn’t their change direction of rotation in real time. So I designed a logic circuit which splits the analog input to control the motors separately. This didn’t work either, because the axles are locked even when the motors are not activated.

I came up with the idea of a gear and a rack when I suddenly realized that the wavy layer in cardboards could serve perfectly as the teeth of the gears. We made both the gear and the rack out of peeled cardboard, and powered the gear with the only motor that can rotate both ways. It worked.

There is rail at the bottom of the print head, so it could slide smoothly left and right.



The Paper Feeder

We had a couple of ideas how this could look like. One is that the printer should have wheels like cars and drives back and fro on the paper. Later we decided to print onto a motor-driven toilet paper, because it’s both easy to implement, and interesting as a concept.

We made two gears, rotating in opposite directions, fixed very close to each other. Thus the paper which is placed in between them gets driven out.



Littlebits Circuit



The Software

We used cloud bits to receive data from the computer over wifi. Basically a processing program gets input from the microphone, writes it real time into a text file, which is then read in real time by an AppleScript script, which uses shell commands to communicate with the cloud bit API.




import processing.sound.*;
Amplitude amp;
AudioIn in;

void setup() {
  size(640, 360);
  amp = new Amplitude(this);
  in = new AudioIn(this, 0);

void draw() {
  float aa = min(0.99,amp.analyze()*10);
  saveStrings("audioin.txt", new String[]{""+aa});


set p to "/Users/lingdonghuang/Documents/Processing/audioin/audioin.txt"
set f to 0
set lf to 0
set i to 0
		delay 0.2
			set f to (read p) * 100
		end try
		set d to (f - lf) * 0.4 + 50
		if d > 80 then
			set d to 80
		else if d < 20 then
			set d to 20
		end if
		set d to d - 3
		set a to do shell script "curl \"\" -X POST -H \"Authorization: b97ba2fe26cdb3de50b2ead1c2838e0c13e244f0d628a0c5a20a8ca3d6d358ab\" -H \"Content-type: application/json\" -d '{ \"percent\": " & d & ", \"duration_ms\": " & -1 & " }'"
		set lf to f
		log {d}
	end repeat
on error
	log ("STOP!")
	set a to do shell script "curl \"\" -X POST -H \"Authorization: b97ba2fe26cdb3de50b2ead1c2838e0c13e244f0d628a0c5a20a8ca3d6d358ab\" -H \"Content-type: application/json\" -d '{ \"percent\": " & 50 & ", \"duration_ms\": " & -1 & " }'"
end try

The Box

Made of laser-cut white and frosted plastic.



Little bits sucks. They might sound like a nice idea, but when you actually want to make something with them, they only “kinda works”. They make you want to trample on them and fling them out of the window. But in general we’re quite satisfied with what we’re able to achieve.

I enjoyed the process of struggling with the littlebits and the cardboards-and-straws mechanisms we had. Instead of being able to make whatever I want like coding in Processing or Python, we had to constantly take into consideration the flakiness of little bits and the straws, and challenge ourselves into coming up with more and more robust and reliable solutions.

The thing that excites me most is being able to make a working printer entirely out of trash. In the future I can probably improve the hardware and software so that it will be able to write letters and even make drawings. I’m going to publish the recipe so even beggars can own printers.



Written by Comments Off on Ngdon-Darca-Object Posted in Object



For my physical computing project I decided to create a little box to protect my chocolates from warm weather. Once the environmental (outdoor) temperature reaches 65 degrees Fahrenheit or greater, the fans kick in until the temperature drops back below 65. Who wants melted chocolate during the summer? This will keep them nice and cool, but not hardened like putting them in a fridge would.

Using the littleBits was rather simple, as Golan described. Setting up my cloudBit was a no-brainer and linking it with IFTTT was also extremely simple. Wiring up my box also did not take too much time but the connections are a bit unreliable, due to their magnetic nature. Unfortunately if the box is jolted and the cloudBit loses power, it takes 15 seconds to reboot, and will not start the fans back up if they were already on before the “power outage.” This is because on start, the cloudBit awaits a trigger from IFTTT, which wont send a new “turn on fan” one until it goes above, then back below 65 degrees.

This project was created using littleBits and a cloudBit, as well as IFTTT. Here are the recipes:


And the diagram of the bits:


Written by Comments Off on hizlik-object Posted in Object

Deliverables 09 (Due 11/18)

Part 1. Last Project Proposal

In a blog post containing just a few sentences, briefly propose what you would like to do for your Last Project. Keep in mind that you’ll only have a couple of weeks to develop this project, which is due December 9, so keep it simple. If you’re torn between a couple different things, list both. Some options for this blog post are things like:

  • “I’d like to revise an earlier project…”
  • “I’d like to experiment with…”
  • “I don’t know what to do.”

Please categorize this blog post, Proposal, and title this blog post nickname-final-proposal.

Part 2. A Networked Object

This assignment is due in the afternoon of class at 1:30pm on Friday, November 18. Please be prepared to present your project, whether live and/or in video documentation, in a 5-minute presentation to the class.

Census historian James C. Scott has pointed out that measurement is a political act. Data artist Natalie Jeremijenko collects measurements in order to prompt evidence-driven discussion. And in the weird world of quantum physics, the term “observer effect” refers to the idea that the very act of measurement itself alters the subject being measured. Each of these is an example of how measurement can be a meaningful act that alters the world and the way we see it.

Working in pairs, create an object or device that communicates with the Internet. This might be:

  • A measuring device or monitoring system, which reports on a measurement of the world at regular intervals.
  • A sensor that detects an event of interest, and sends a signal to report it online when it happens.
  • A device which physically displays or visualizes a piece of online information, or which is triggered by an online event.

Your objective is to:

  • measure or visualize something interesting, and/or
  • measure or visualize something in an interesting way, and/or
  • create a interesting provocation by bringing an uncommon measurement or piece of information to our attention.

To do this, you will use the LittleBits system of sensors and actuators, plus the IFTTT service. You may also wish to use to access interesting APIs and data streams. Please take a moment to familiarize yourself with these systems.

Some Design Considerations

Keep in mind the following design considerations:

  • Although you may use any sensor you like, remember that even a humble switch is a sensor. The most important thing is for you to conceive of something interesting that can be sensed, whether by a switch or by something else.
  • Brainstorm how to interpret your sensor. Just because you have a pressure sensor, doesn’t mean you have to measure pressure. For example, you might measure the amount of time that something is pressing the sensor. The information you report might thus be in units of seconds, not pounds of force. Or perhaps you might count the number of times that something has squeezed the sensor.
  • Your device’s choice of location is very important. Where the device is positioned will affect who encounters it, how it is perceived, and the meaning it makes in the world.
  • Are humans involved? It is up to you whether your device measures/displays human activity, or whether it measures the activity of something else in the environment (cars, animals, lights, doors, etc.). You can also decide whether you are measuring/displaying ambient, incidental, or deliberate human activity.
  • Think. Your device might be whimsical, poetic, personal, political. You might detect when a leaf detaches from a tree, or it might blink whenever a specific friend posts on Facebook.
  • Get outside the Studio. Consider places to put your object (outdoors, in your dorm room) that are not our usual meeting room.
  • Share Bits. We have one of nearly every kind of bit. But in some cases, you may need to share. Please organize on the class Slack channel to see who may be able to loan you what you need. Use substitutes or proxies while you’re waiting to borrow something.
  • Incorporate Other Materials. This project will be difficult to make without some other crafts materials. You may need to get some cardboard, paper, pipe cleaners, styrofoam, tape, popsicle sticks, Legos, etc.

Technical Considerations

To communicate with the Internet: 

One option is that we have seven LittleBits CloudBits.

  • You’ll need to register your CloudBit at (You’ll need to register for a LittleBits login ID.) I have already gotten the MAC addresses of these CloudBits whitelisted on CMU’s network. Follow the instructions and connect them to the wireless network called “CMU” (the university’s passwordless legacy wifi network).
  • There’s already a special IFTTT channel just for these CloudBits. Note that this channel only works with the CloudBit. Also, it may sometimes take a few minutes (theoretically, up to an hour worst-case) for your CloudBit signals to get processed by the IFTTT servers.
  • Please note that these require the LittleBits USB P3 power unit and will not work with a 9V battery.

There are a number of other options for communicating with your computer. For example, we also have several of the LittleBits Bluetooth BLE bits, the USB I/O bits, the MIDI bit, and the Arduino bits. We also have 5 of the MakeyMakey bits. Keep in mind that if you’re using one of these bits, you’ll need to write code to communicate with the internet and/or IFTTT; for this, I recommend IFTTT’s Maker channel.

It will probably be easiest to use the MakeyMakey bit (if you’re doing input only). Here’s some sample P5.js code for using the MakeyMakey bit to send keypresses to IFTTT’s Maker Channel:

// P5.JS code to convert LittleBits MakeyMakey signals
// into IFTTT messages, using the IFTTT Maker channel. 

var urlPrefix = "";
var urlInfix = "/with/key/";
var eventName = "MyMakeyMakeyEvent";

You'll have to set up the eventName ("MyMakeyMakeyEvent" etc.)
and your IFTTT mySecretKey, using the IFTTT Maker channel.

function keyPressed() {
  // The MakeyMakey is a tiny, funny-looking, USB keyboard. 
  // It can only send arrow keys and the space bar.
  // Note: you'll need to power the MakeyMakey with a Power Bit.

  var value1 = 0;
  if (keyCode == LEFT_ARROW) {
    value1 = "LEFT ARROW";
  } else if (keyCode == RIGHT_ARROW) {
    value1 = "RIGHT ARROW";
  } else if (key == ' '){
    value1 = "SPACE BAR"

  if (value1 != 0) {
    var value2 = millis(); 
    var value3 = "cat-door";
    // The LittleBits MakeyMakey bit can send up to 3 values.
    var myData = {
      "value1": value1,
      "value2": value2,
      "value3": value3 

    // See
    var requestUrl = urlPrefix + eventName + urlInfix + mySecretKey;
    httpPost(requestUrl, myData, "json");

function setup() {

function draw() {


The usual:

  • Make a blog post on this site. (This can be posted in one of the teammates’ accounts; it doesn’t have to be in both). Write 150-200 words about your project: what it does, how it works, why you made it.
  • Title your post: nickname1-nickname2-object. Categorize your post: Object. Be sure the blog post mentions the name of each collaborator.
  • Include some images of your project. Cell phone photos are fine; nice photos are better.
  • Include a diagram of your system. This could be hand-drawn, or you could Photoshop up images ripped from the LittleBits store website.
  • Embed a video of your system working. It’s best if the video is in-situ; i.e., if you made something that tweets when the cat goes out the cat door, show a video of your cat going out the cat door with the system in place.
  • Consider adding some copyright-free music to your documentation video.

  • Embed your code using the WP-Syntax WordPress plugin, and/or link to it on Github.


Comments Off on Deliverables 09 (Due 11/18) Posted in