Skip to content

Sensor Network: Data Logging Test

01-Mar-10 (2 weeks ago) | 33 views

I’m working with Sebastian and Michael as “visualization” team for the sensor network assignment for this week’s Sociable Objects Workshop. It’s very challenging for the whole class to work on one single project, but so far it went on pretty well. Tasks are split and assigned and we also find ways to work with dependencies and such constraints.

Since we are just focusing on the visualization part, meaning that we take on only after all the data are aggregated at the coordinator xbee, our main effort will be data logging, mining and visualization. So the first thing we built is a pseudo data generator that feeds data in the same format as the data will be from the coordinator. We talked to the base station team and agreed that we will be getting raw API I/O RX packet and we will take care of the parsing and data storage.

I put together some simple arduino code to feed pseudo data, they could be easily replaced by a real coordinator and ideally we will not have to change the processing code on the other side which is listening to the serial channel.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#define ADDRESS_COUNT 9
int addresses[9] = {
  0x0001,
  0x0002,
  0x0003,
  0x0004,
  0x0005,
  0x0006,
  0x0007,
  0x0008,
  0x0009,
};

void setup()
{
  Serial.begin(9600);
  randomSeed(analogRead(0));
}

void loop()
{
  for (int i = 0;i < ADDRESS_COUNT;i++)
  {
    if (random(1000) > 990)
    {
      if (random(1000) > 500)
      {
        sendPseudoPackage(addresses[i], 1);
      }
      else
      {
        sendPseudoPackage(addresses[i], 0);
      }
    }

  }
  delay(50);
}


void sendPseudoPackage(int address, int value) {  // pass either a 0x4 or and 0x5 to turn the pin on or off
  Serial.print(0x7E, BYTE); // start byte
  Serial.print(0x0, BYTE); // high part of length (always zero)
  Serial.print(0x17, BYTE); // low part of length (the number of bytes that follow, not including checksum)
  Serial.print(0x92, BYTE); // 0x92 is I/O RX Packet

  //05-12:  64-bit address
  Serial.print(0x00,BYTE);
  Serial.print(0x13,BYTE);

  Serial.print(0xA2,BYTE);
  Serial.print(0x00,BYTE);

  Serial.print(0x40,BYTE);
  Serial.print(0x33,BYTE);

  int low = address & 0xFF;
  int high = (address - low) >> 2;

  Serial.print(high, BYTE);
  Serial.print(low, BYTE);


  //13-14:  16 bit of recipient or 0xFFFE if unknown
  Serial.print(0xFF, BYTE);
  Serial.print(0xFE, BYTE);

  //15:  Receive Option
  Serial.print(0x01, BYTE);

  //16:  Num Samples
  Serial.print(0x01, BYTE);

  //17-18 Digital Channel Mask
  Serial.print(0x00, BYTE);
  Serial.print(0x01, BYTE); //only Digital I/O 0

  //19:  Analog Channel Mask
  Serial.print(0x00, BYTE);

  //20-21:  Digital Samples
  Serial.print(0x00, BYTE);
  Serial.print(value, BYTE);

  //no analog samples

  // checksum is all bytes after length bytes
  long sum = 0xFF; //fake
  Serial.print( 0xFF - ( sum & 0xFF) , BYTE ); // calculate the proper checksum
  delay(10); // safety pause to avoid overwhelming the serial port (if this function is not implemented properly)
}

Then I wrote a basic processing sketch which filters the data and stores only changes to the databases. The sketch itself servers as some sort of realtime visualization on the input, and we get a feeling of how often data are changing and potentially detects sensor failures if one sensor is not active for a very long time.

The processing sketch is sending data to a website that handles data logging. The website also provides query api that returns sensor history in json format, and functions like filtering by certain address. The site itself is lightweight and fairly easy to add new functionality.

The plan is to meet tomorrow and start building a web interface upon the api for the final visualization. Hopefully we could also get to verify if the pseudo data is identical to the real format, and maybe we can get a test run with the real setup.

Stay tuned!

Using XBee Without Arduino

26-Feb-10 (2 weeks ago) | 37 views

I worked with Adi on the “Romantic Lighting Sensor” Lab for Sociable Objects Workshop. Since we do not have a photo cell at hand, we just used a normal potentiometer as the remote sensor. The code is from Rob Faludi’s course code sample page.

We had some problem at first with the receiver side and we didn’t find an effective to debug it. It was pretty clear that the transmitter is working fine since while I was using just xbee explorer board as receiver I can directly see the data coming from the serial channel. However I cannot get the code to work when I plugged the xbee back to arduino circuit.

I ended up using a processing sketch to print out serial data from arduino since I cannot see it directly by printing out data to the serial terminal in arduino code. So lesson learned:

1. the resister used to augment sensor output value to fit xbee’s 3.3v requirement has to be carefully handled, otherwise you do not get to use full range of the sensor output and it makes it harder to figure out the range to look for in the receiver code,

2. a processing sketch is necessary for debugging. it gives a lot of confidence while you can see what is in the data stream, at least for me.


simple remote xbee sensor


with feedback

“im-personal”: components and features

24-Feb-10 (3 weeks ago) | 33 views

Overview

My thesis project is a software program that creates generative drawings on its own, one drawing per day, and updates its own drawing blog.

The program was built on the reverse of most generative computer graphics artwork or simulation approaches that creates realistic graphics; instead of creating complex visual graphics based on intensive computational power, it is trying to simulate human drawing in a very low-level approach of recreating emotion and gestures.

Rationale

I choose not to build another program to appreciate visual complexity because it comes down to the question of the value of the work of art, which in my opinion has a lot to do with mastery of skills and efforts put in it. So for me people appreciate complex visuals in computer graphics because those visuals are extremely hard to achieve by manual effort. However it is not always true for computers and that is why I am not super excited about computer generated complex abstracts. The real effort would be assigning emotion to fully automated process, and achieve humanity in the drawings produced.

In short, I am building this program in a way that is extremely hard for the computers to do, giving up the significance that could be easily achieved (compared to human effort) by a computer program. I would like to show the slow and painful process of this computer generated drawing and its evolution towards its own aesthetics.

There are infinite number of ways to build a program that draws on itself, and I am building it to mimic my own way of drawing/doodling. From the way the brush moves on the canvas, the shape of the brush strokes, to the composition preferences and training materials feed to the program for inspirations, all implementation would be following my own subjective choice. However the machine is running all by itself without constant intervention even by myself. Ideally it could live as part of my ghost in a different shell. The program could be an extension of the body, virtually. Would it be an even closer way to communicate directly through my ghost?

Goals

The goal of this project is to create new genre of computer graphic that expresses humanity by mimicking the doodling experience and generating drawing based on emotional factors and gestures.

It is not the goal of the project to produce tradition painting through simulation of painting tools and media. Drawings produced by the program should be visually recognizable as a computer generated artwork, while the content of the drawing can be subjective, emotional and less “visually mathematical”.

Technically, I would like to show the process of how a computer program would make sense of visual inputs and produce creative result out of it. And ideally it should also be able to publish its evolution from creating basic shapes and curves to being able to produce complex compositions (but not necessarily always doing so).

Audience and Location

The project is expecting a wide audience, essentially anyone that has prior experience of using a computer and interested in computer generated graphics. It would also probably draw attention of people that has particular interest in drawings.

This project itself is a very personal expression, meaning that I decide to design the algorithm independently without too much concerns about potential audience. While I am building the project not for particular target audience, I do expect different responses from different groups of people, and there are several that I am more interested in: a) generative graphics artists, b) illustrators, c) artificial intelligence scholars or engineers.

In terms of presentation, I would like the piece to be accessible online including the whole archive of the drawings it created. It is meant to be experienced alone than in a group. While it’s most preferred to be viewed through a web browser or a downloadable application running on one’s own computer, the project could possible still be suitable for public spaces like galleries or museums.

For now it seems that a website would provide a most complete experience for this project given its non-linear nature and technical difficulty to replicate its infrastructure. If I would have enough time to release the application itself to the public or make it easily deployable to other people’s website, and the copies of this project would be able to evolve independently, the final presentation of this decentralized artificial intelligence would have to be on the internet, or at least using internet to aggregate the productions/artworks from all copies.

Core Features and Functionality

The core of the project is a software that generates drawings. Every time the program launches, it creates a drawing and terminates itself. The drawing takes inspiration from the program’s external visual memories mixed with some “live” input that adds emotional factors to it. The drawing process is monitored and supervised by the composition and aesthetics assessment algorithms. The program determines the scale of the drawing and the moment to finish drawing.

There will be a few peripheral components to assist the core drawing module.

a) Visual Memory Storage, an important basis for building up the aesthetics preference of the program, as well as its raw material for inspiration. The memory is prioritized based on an arbitrary “impression” algorithm that puts the program’s most favorite visuals on the top.

b) Interface for Visual Memory allows the program to accept multiple source of external graphical inputs. The source could be a streaming video feed from a live webcam on justin.tv, or a favorite image feed from my ffffound.com image bookmarking account. The sources could be used as either positive or negative training material to build up the program’s aesthetic preference. The interface should be easily configured to maintain the input feeds which the program is listening to, and whether or not they are used as training materials. Ideally it could be easily accessible on the web.

c) Aesthetic Preference database, is a set of rules that the program collectively builds up over time through the process of learning, drawing and self assessment. The database is referred to during the creation of the drawing, and will be updated through training, drawing, and feedback on the published drawings.

d) Coordination Scripts that launches the program and publishes its creation to a website. Since the program itself is designed to be modular for future portability, some coordination scripts are required to help keep the whole thing running. They would help monitoring the visual feeds and compiling any updates to the visual memory, launch the drawing module at a preconfigured time, publish
the drawing created in this iteration and collect the feedback on the drawing to reflect into the preference database.

e) A website, technically a blog, that showcases the daily creation of the program.

People will be able to browse through the drawings the program created over time. They will probably not be able to search, since there will not be enough metadata associated with the drawing for filtering. If there has to be a filter or category, it could be based on timeline, emotion, or arbitrary themes (if the program evolves to name its creation).

For individual drawings, people will be able to:

a) watch a playback of the drawing process;
b) see the inspiration of the drawing, or the pictures that the program referred to in the creation;
c) rate the drawing, the result might or might not be used as training material;
d) (optional) order a print of the drawing;

This project is not intended to be instantly interactive because I would like to show the slow and painful process of creating a drawing, not to draw people’s attention to the coolness of computer generative graphics. I would like each of the drawing the program made would take a while for people to digest. I would like people to notice and appreciate the drawings themselves as work of art without knowing that they are created by a computer. This is already a very challenging task both in AI and fine art.

The software program shares my attitude on computer generative graphic art. While it is capable of creating complex generative visuals, it chooses to (as I choose to make it ) take the hard way and to apply its own (as my own) preference of visual beauty to its creation. It is a very personal critique on current computer generative art.

The core drawing module will either be written in Processing or openFrameworks, depending on my research on the portability of each option. I would like the program to be able to executed on a command line tool that does not require user intervention in the drawing process, so that it would be easily automated after it is deployed to a linux server.

For visual memory storage, couchDB seems a competitive choice for my data structure given its document oriented concept and flexibility in data types. MySql will be a safe but second choice since I’m more familiar with it.

Housekeeping scripts will be a compilation of a set of tools written in combination of shell scripts, python and php. It is most likely that I will build the website in php or just hack around the wordpress CMS framework.

As a software program, it does not have a user interface. It should not even require an input. It could be simply described as an application that generates one drawing at a time.

The showcase website, as the final presentation of the program, does have a user interface. I have in mind a blog site with clean minimalist design, highlighting latest drawing created by the program. And it should be easy enough to navigate through the archive of drawings to see how the algorithm evolves.

Success Measures / Future Plans

The goal of this project is to achieve machine intelligence in artworks, meaning that it should essentially create drawing that is visually or emotionally appealing to its viewers. Although the concept of machine intelligence evolution made public is as important, I would like to make the project beyond just being conceptual. The diversity of the drawings that it creates and the fact whether or not people appreciate those drawings will be also very important and valuable information for me.

For thesis, of course I would like to build the whole project to its greatest completion. However given the time constraints and technical challenges, I could still sort out some of the components to be lower prioritized than others.

The core drawing module is first priority, but it does not mean that the evolving algorithm needs to be perfect. The most important thing is the self driven composition process.

Secondly important is the infrastructure that automates the program and publish the drawings. Even if the algorithm is not perfect, it still makes a lot of sense if the whole evolution procedure is online and accessible to all.

Next will be the external interface of the program to the outside world, which makes it easier to feed training materials, to supervise the training process and to apply the feedbacks.

For future I will be most interested in making it portable enough so that there could be multiple instances of this program evolving individually and people could observe how different they are becoming over time.

“im-personal”: use cases

24-Feb-10 (3 weeks ago) | 29 views

I still need a name for my drawing machine. My class felt the “machine” in the name is confusing, but I keep thinking the whole application as a machine since there will be loosely coupled components, and they are assembled in a way like machines. Anyways a name would still be necessary because that will make the project itself a lot personal. A working title for now is “im-personal” because it is an impersonal machine but it is crying out and saying that “i am personal” and its creations and its own visual memories are really personal.

 
Collect training materials

 
Supervise training process


Training personal drawing style


A public online gallery showcases all creations

Thesis Workplan

24-Feb-10 (3 weeks ago) | 23 views

is here: http://bit.ly/thesis-workplan

Thesis Idea Switch

24-Feb-10 (3 weeks ago) | 32 views

So this is happening to me, and I guess sooner is better than later. I would like to have a specific idea to develop (and code!) so I am turning back to the self-evolving drawing machine idea. I realized that given the very limited time it is nearly impractical to complete my research on the online privacy issue and develop a great idea that is proper as a thesis project. I would like to save all research that I’ve already done on this matter as a theme for my future project and I’m still working on the readings that I found.

Get back to the drawing machine that learns from human drawing, I finished the brush stroke and drawing API encapsulation last semester. From now on until the end of the semester, I would like to finish the genetic algorithm for evolving machine aesthetics and the publishing module, so that I can at least setup a solid basis for this project. Even if I cannot finish all features that I planned, I will still be able to have a running platform to improve the underlying intelligence on.

Sociable Objects: a nap doorbell

15-Feb-10 (4 weeks ago) | 23 views

Nap doorbells are designed for nappers. They will not actually ring and wake you up unless it is a real emergency. This project is developed in collaboration with Adi and Asli.

Doorbell for insistent visitors from My Journey on Vimeo.

Switch Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
int BUTTON = 2;
int GREEN = 12;
int RED = 13;

void setup()
{
 pinMode(BUTTON, INPUT);
 pinMode(GREEN, OUTPUT);
 pinMode(RED, OUTPUT);
 Serial.begin(9600);
}

void loop()
{
 if (digitalRead(BUTTON) == HIGH)
 {
   Serial.print('D');
   delay(10);
 }

 if (Serial.available() > 0)
 {
   char r = Serial.read();
   if (r == 'G')
   {
     digitalWrite(GREEN, HIGH);
   }
   else if (r == 'R')
   {
     digitalWrite(RED, HIGH);
   }
 }
 else
 {
   digitalWrite(GREEN, LOW);
   digitalWrite(RED, LOW);
 }
}

Buzzer Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
int BELL = 5;
long lastReleased = -1;
long lastPressed = -1;
int counter = 0;
int offcounter = 0;

boolean pressed = false;

void setup()
{
  pinMode (BELL, OUTPUT);
  Serial.begin(9600);  
}

void loop()
{
  if((Serial.available() > 0))  
  {
    if (Serial.read() == 'D') // look for a capital D over the serial port and ring the bell if found
    {
      //Serial.println("ON");
      if (!pressed)
      {
        lastPressed = millis();
        pressed = true;
        long interval = lastPressed - lastReleased;
       
        //Serial.print("+");
        //Serial.println(counter, DEC);
        //Serial.println(interval);

        if (interval < 1000) // if this one is pressed soon enough, increase the counter
        {
          counter++;
        }
        else
        {
          counter = 0;
        }
      }

      //send feedback that message was recieved
      if (counter >= 5)
      {
        Serial.print('G');
        //ring the bell briefly
        digitalWrite(BELL, HIGH);
        delay(10);
        digitalWrite(BELL, LOW);
      }
      else
      {
        Serial.print('R');
      }
     
      offcounter = 0;
    }

  }
  else
  {
    //Serial.println("OFF");
    offcounter++;
    if (pressed && offcounter > 5000)
    {
      pressed = false;
      Serial.print("-");
      lastReleased = millis();
      offcounter = 0;
    }
  }
}

redefining privacy: a background research

14-Feb-10 (4 weeks ago) | 39 views

Although I have not yet scoped down my thesis project to a specific and executable idea, it sits in the context where new technologies and innovations in communication tools have already changed a great deal in daily human-to-human interactions. However in such situation people are not yet ready for the much more significant social norm changes that are going to happen shortly. Are technologies like ubiquitous computing going to slow down to wait for the mainstream to catch up? Or will they just move on and embrace the new generation that grow with the new technologies and leave us behind?

In my project I would like to envision in a near future how would the re-definition and the relation of private and public evolves, in either of the following ways or their combinations:

a) a narrative animation that describes the imagined situation and how the transition is going to happen;
b) a tool that exposes one’s digital identity trace;
c) a data visualization focusing on realtime data exposure;
d) an installation that explores the new social norms under this imagined circumstances;
e) a collection of objects/installations that illustrates different aspects of possible social changes;

Related Projects:

Personas
Project website: http://personas.media.mit.edu/

Personas was created by Aaron Zinman, with help from Alex Dragulescu, Yannick Assogba and Judith Donath, as a component of the Metropath(ologies) exhibit in 2009. “It uses sophisticated natural language processing and the Internet to create a data portrait of one’s aggregated online identity. In short, Personas shows you how the Internet sees you.”

Personas visualizes the process of a machine making sense of your public data on the internet. It is not meant to be utilitarian, but more to be a critique on data mining process, which is in most cases happening behind the scene.

There are a few things that I like a lot about this project.

Firstly it is taking only public data on the internet as input. Data collection wise I would also (have to) take a very similar approach as data input for my project. Even I am predicting a future in which almost all digital information would be public and transparent (not necessarily to human beings, at some point we should be taking machines into account too), that would be a most efficient way of gathering information and it well illustrates the blurred borderline between public and private information online.

Secondly it is not aiming to be a useful tool but to expose a completely automated process. This could easily be misinterpreted given its presentation online. I also find it hard to build something that 1) looks useful/practical and 2) runs in a browser to be properly interpreted in its intended context. I got it wrong at first glance too, not a lot of people will actually read the long background description. Given that it was designed originally for a museum exhibition, it is probably facing a completely different situation while being shown separately online. If an online interaction piece is the direction I would be pursuing, I should be very careful with the presentation, and try to make it looks less utilitarian.

Also worth noting is the clean elegant interface of the project. The very limited input and interaction might have a positive effect on driving people to find out more about the underlying idea.

The personas project inspires me in a sense of the possibility of tracing online identity, and it provides an interesting presentation of showing a process but not bothering the user by too much technical details.

Master Plan
Project website: http://masterplanthemovie.com/

Master Plan is a short animation directed and produced by Ozan Halici and Jürgen Mayer in 2007. The script is based on the book “What Barry Says” by Simon Robson and “The Google Story” by David A. Wise.

Master Plan is a clear alert of the seldom noticed online privacy issue back at time, and sent a very strong message through the narrative. This project is inspiring as it was the first beautifully crafted info-graphic video project I had ever seen. Not only the presentation is great, the topic is also very close to the issue that I am interested in.

While Master Plan is mostly summarizing what already happened and proposed a very open question that it did not intend to answer, I would like to predict the future that tries to answer a few questions that have been on my mind for a while. What information we considered private but is actually widely accessible thus being pseudo private? What information is pseudo public because of misinterpretation and loss of context? How will machine make sense of the mass amount of data we have been accumulating once they get smart enough to decode them? Are we human beings going to be still in control of those data by then?

If I could get a fairly clear picture through my research in next couple weeks, and if I would be able to put together a narrative that is strong enough to support a visual conversation, I would like to borrow the form of storytelling from Master Plan to be at least part of my project to tell the story.

We Feel Fine
Project website: http://wefeelfine.org

We Feel Fine is created by Jonathan Harris and Sep Kamvar in May 2006.

As far as I know, We Feel Fine remains a lot of people’s favorite ever since its launch. It is a best example of how utilizing publicly available but usually invisible information can create a powerful art project. I am not exactly enthusiastic about the technical details behind the scene, but the idea of combining their subject interest together with the user profile information of the source makes a huge change to the nature of the project. For We Feel Fine it enables the features like filtering and clustering, but for me it means that it made possible to monitor any specific person/profile and connect that to the statements they made. Any data can become sensitive while accumulating through time, it makes a big difference to people emotionally. Any web services that holds user data for a long period of time should all realize the strong attachment of these data to their originators, no matter how boring it is.

There are so much I can take from this project, not only the visuals and interactions, but also the important emotional component that an art project should feature. The method they use for data collection will also work for my case if I would like to create an interactive tool for visualizing aggregated statistics, unlike Personas’ personal perspective, I will probably need to build some infrastructure like We Feel Fine does, to support this kind of data mining.

We Feel Fine does not trace down to personal details, but they have all the data available to do so. This could also be an extra point that I would like o address in my project, is the easiness of data replication. Once the information is out there, there is no way back. You can take back one of your blog posts that you regret that you posted from your site, but there is no way to take it back from all kinds of crawlers all over the internet. People are not allowed to make mistakes anymore, and not a lot of people are aware of this. That changes the rule of sharing information and you probably would like to think twice before posting anything intimate to the internet. This is not to say people should be paranoid about data collection agents/devices/softwares, it is part of the mind change that I foresee in a near future, and I would like to explicitly explain in my project.

Ten Thousand Cents
Project website: http://www.tenthousandcents.com/

Ten Thousand Cents is created by Aaron Koblin in collaboration with Takashi Kawashima in 2008. The total labor cost to create the bill, the artwork being created, and the reproductions available for purchase are all $100. The work is presented as an interactive/video piece with all 10,000 parts being drawn simultaneously. The project explores the circumstances we live in, a new and uncharted combination of digital labor markets, “crowdsourcing,” “virtual economies,” and digital reproduction.

Bicycle Built For 2000
Project website: http://www.bicyclebuiltfortwothousand.com/

Bicycle Build For 2000 is created by Aaron Koblin and Daniel Massey in 2009. It is comprised of 2,088 voice recordings collected via Amazon’s Mechanical Turk web service. Workers were prompted to listen to a short sound clip, then record themselves imitating what they heard.

I am putting these two projects in the same category not just because they are from the same author but they both feature crowd-sourcing to create the final product, and the workers were not even told what exactly they are working on. There are two things that I am especially interested in, involving a large group of people, and this unconsciousness in the creation process.

If I could find a proper form of involving people to help revealing the ideas of privacy redefinition, meaning that I can find a minimized task that help me get a clue of what is on people’s mind, distributing these tasks through mechanical turk seems a great idea, and this unconsciousness will also help reinforce the idea of people creating a future without having the big picture in mind.

Track Me Not
Project website: http://mrl.nyu.edu/~dhowe/trackmenot/

TrackMeNot is a lightweight browser extension that helps protect web searchers from surveillance and data-profiling by search engines, created by Daniel C. Howe, Helen Nissenbaum in August 2006. It does so not by means of concealment or encryption (i.e. covering one’s tracks), but instead, paradoxically, by the opposite strategy: noise and obfuscation. With TrackMeNot, actual web searches, lost in a cloud of false leads, are essentially hidden in plain view.

This is a utility tool, that actually deals with the identity issue directly. It relates to my subject of interest because it is providing an answer with an effort of not changing social norms and presumptions and trying to solve a specific identity exposure case. I am not against the attempt but I see this approach as a passive way to look at our issues. My biggest problem is not with large corporates collecting data, I am more worried about not a lot of people care or even know about it.

Resources

Boyd, D. (2007, May 22). Social network sites: public, private, or what?. Retrieved from http://kt.flexiblelearning.net.au/tkt2007/edition-13/social-network-sites-public-private-or-what/

Boyd, D. (2010, January 16). Facebook’s move ain’t about changes in privacy norms. Retrieved from http://www.zephoria.org/thoughts/archives/2010/01/16/facebooks_move.html

Zimmer, M. (2010, January 12). Zuckerberg’s remarks aren’t surprising, nor new, nor true. Retrieved from http://michaelzimmer.org/2010/01/12/zuckerbergs-remarks-arent-surprising-nor-new-nor-true/

Kirkpatrick, M. (2010, January 18). The Facebook privacy debate: what you need to know. Retrieved from http://www.readwriteweb.com/archives/facebook_privacy_explanation_debate.php

Hill, D. (2008, Feburary 11). The City as a platform. Retrieved from http://www.cityofsound.com/blog/2008/02/the-street-as-p.html

Kerr, Ian, Steeves, Valerie, & Lucock, Carole. (2009).Lessons from the identity trail. Oxford University Press, USA.

Work Plan

I have not yet got to a stage where I can work on a detailed work plan. I have several milestone points that I would like to keep. Unfortunately it is not making a lot of sense to me to go more detailed than that at this point.

If I have to switch my thesis idea, I would like to turn in another research paper and work plan by next week (Feb 17) together with new assignments.

Week 5 (Feb 17)

Finish background research, at least get to one narrowed-down but still exciting idea to work on. This is prerequisite to all other components of this project, and I have already spent a great amount of time on research. If I will not be able to nail down anything specific to work on, I would like to keep the research open but switch my thesis project to a practical idea that will fit in the timeline.

At the same time, keep working on background research of another project which I already had a firm idea and a clear vision with, so that

Week 8 (March 10)

Build a bare-bone prototype that complete the structure of the project, leaving details for polishing or working out. If it is an animation, I should have script, storyboard and graphical elements settled. If I will be working on an installation, I should have the algorithm ready, and a bare-bone software program running.

Thesis abstract draft

03-Feb-10 | 40 views

I have always been paranoid keeping my different online identities separate. It has been a while since I found it easy enough to put up several google searches and get a pretty complete profile of a person, if he or she does have an active online identity. It is not to say I think keeping a clear online identity is a bad thing. On one hand it is inevitable to maintain an active and valid identity either for clearer public recognition or promotion, just like in real life, on the other hand it is also a safer approach to have separate identity and sometimes anonymity for different online tasks, especially under circumstances where online surveillance and censorships happen a lot. However with any currently available web browser and the current way most modern websites are built, to keep a clear separation of different identities is extremely difficult and effortful. Using same username or email address leaves a clear and accurate trail of one’s online activities.

There are several different approaches out there trying to either simplify or solve the identity mess online, such as OpenID protocol, integrated user profile management in web browsers and also ongoing research on privacy models that could apply to computer programs for them to classify private information. Yet in reality there is always a balance between security and usability, and at this point most of the approaches are still geek toys that require a more advanced/simplified interface to gain wider acceptance. My personal take is just to use different browser for separate profile settings, more or less a hack on the loose cookie systems.

Nevertheless, even those approaches all successfully get to general acceptance and accomplish their goals, a wider exposure of private information remains unchanged and I do not have any problem with that. You get better control on the information online, but they are still (and should be) trackable.

One concern I really have regarding this trend, along with the very slow semantic web movement, is that while the internet is getting better and better understanding of human activity and the collective intelligence would actually gain consciousness of its own presence. I am seeing this issue not as science fiction but a practical matter and would like to see while surrendering too much information about themselves how would human beings deal with the intellectual machine(s). That would be a too broad future to predict so that I would like to start my research from how would the transition start, before this really big change actually happens.

Thesis Abstract

We are producing much more information online than ever. Ubiquitous computing is practical enough to blend the borderline between physical world and the internet. The revolution of user interface is around the corner, much more user-friendly screen-based and tangible interfaces encourage people to get connected. Whatever interface they are collected through, the data are not going nowhere. All information are stored together with trails enough to reveal people’s identity. Furthermore, the moment they are public on the internet, even just for a short period of time, they get replicated by crawlers from all kinds of search engines, aggregators and other software agents. Information could be removed from their original source, but practically they will be public on the internet, however difficult to reveal, for good. Another category of information are less publicized yet as important is the transactional data created through people’s interaction, most service providers keep these information which could be extremely valuable for marketing purposes. These information, due to the channels they are collected through, are usually much more sensitive and much easier to leak identity.

Corporates and service providers normally provide unilateral privacy policies that keep highly sensitive data out of public accessibility, organizations such as Electronic Privacy Information Center are also working hard to drive digital privacy protection through legitimate methods, technically there is still very little effective ways to prevent private information from getting into public attention, given the surprising pace how computing technology evolves. I would like to look at this problem under a slightly broader presumption that eventually much more of our personal information would reach the public, and we would have to adapt the new situation where we have to redefine what “privacy” really is.

The final product of this project would be an interactive software/installation or animation that drives awareness of this social change on privacy. At this point I am not exactly sure about the presentation of the project, but preferably I would be able to foresee the new situation and how the transition is going to happen, therefore create a convincible narrative on this topic. I would like to define the new boundary of privacy by a) studying what categories of information the majority of current online service providers are collecting, b) examining behavioral changes those services cause on people’s daily life and whether those changes are temporal or permanent, and c) creating a practical scenario in which there maintains a new balance after people are used to publicizing information that they considered private before.

Kicking off my thesis journal

02-Feb-10 | 37 views

it’s time.