Final Project-- Liam Kirby

Final Project
Reading
teenfeelings.net/reading

            My project consists of a website, an application and an installation. The Publication proper exists as a two-part reading system, which presents a large, dynamically generated, piece of text at an accelerated speed. First an XSLT/PHP program generates text by on querying specific characters from 50 to 70 seconds of activity on the public Twitter feed (viewable at www.teenfeelings.net/tweet.php). This accumulation is then accessed by a lightweight application made in Processing, which allows a user to view said text on a word-by-word basis, rather than as a whole.

            The project was proposed as a system which would generate specific characters from Twitter and use them as unique access points to other open sources of dynamic information on the web. This became needlessly difficult, providing an extra layer of technical process, but allowing essentially the same result. My goal is to generate a piece of writing which finds its basis in both esoteric (specific use of initializing numbers and letters) and technical (the particular code and feeds accessed) logic, and using Twitter as the sole source of information fulfills both these categories. I am not particularly interested in technical systems which are impressive for being impressive technical systems. There is a general disregard for sophisticated or enhanced design throughout this project, from the lack of instructions to the default fonts (conceding, of course, that this is an affect in its own way).

            The PHP page came together fairly quickly. When approaching some kind of technical problem I try to steal as much code as possible from internet; starting with a set goal and then attempting to hack out a solution. There is no guide online for doing esoteric or generally useless tasks such as querying specific sets of characters from Twitter, but there is help for counting characters in dynamic text or some similar, utilitarian task necessary for running a normal website. It then become a process of making useful code less useful and more esoteric.

The reading application is something that would have been relatively easy to accomplish for someone with actual, hard-earned programming knowledge, but for me it was similar to bashing my head into a wall again and again. The program allows a user three options: reading text straight from the web, downloading text as a “.txt” file and loading a “.txt” file to read in the application. Once a text has been loaded (whether locally or after the 50-70 second load time) the piece is parsed and fragmented into individual sequential units separated by spaces, which are then cycled at a speed of 470 milliseconds. After struggling with the code for weeks I was able to get the application in what appears to be working condition, allowing for it to be downloaded and run easily as a distinct item on most computers (I am writing this before I have had a chance to test the program on any computer other than my own).

Both technological elements of the work present alternate views on what is, essentially, a coded reflection of a specific period of time. The webpage presents information as a dense accumulation of text, characters linked inherently to those surrounding, while the application forces a viewer into an immediate engagement with each new instantiation. As a publication (an object which has been both produced and released to some public) the work is inherently dated, offering a reflection or recollection on a period, rather than a prescient or dynamic experience. As the work is used, these temporal products begin to accumulate, allowing for a layering of physical signification. This is the key process of the work, the articulation of something larger, grasped from beyond depth.  This is a dialectical process beginning in my choice of esoteric numbers, extending to the limits and logics of PHP, Processing and Twitter and continuing into the users of said social network. Its use further complicates this process. This is why I view the publication as a tool or beginning for work, rather than an entirely compelling piece in its own right. This attitude also stems from a general mistrust of overly technical processes comprising the core of an artwork (after all, Mario Lopez says that technical logic is the logic of fascism).

The technical structure culminates in the installation, (hopefully, I’m not absolutely positive I’ll have a room to install in come Monday) which features two sets of work produced from two separate texts. Each element is positioned identically to its other. The methods developed in one set of work dictate the methods used in the creation of the other. This allows for dual tracts of sublimation, each processing separate chunks of temporal information. Importantly, the collections must be viewed in both general space and the contexts of art, forcing a puncture of implicit instrumentality (puncture, which assumes return). Ideally these structuring elements allow a floating play  of dialectic condition, ranging from the Gnostic to the technical.

            As a post-script I’d like to request that this text (blog post) not be used as description should we compile all the classes’ publications on a website or something. Like much the work itself, I’m not interested in extraneous explanation and, while the work is a publication, I have no expectations for it to be enjoyed by the public.  Enjoyed involving actual enjoyment here, not a euphemism for having accessed or witnessed or whatever.

Also, here's the code from the Processing application, in case anyone wants to do something similar and mess around with it. ::

String[] lines;

  int s = second();  

  int m = minute();  

  int h = hour();    

  int d = day();    

  int mn = month();  

  int y = year();

int i = 0;

int love = 0;

String file;

Button readbutton, loadbutton, savebutton;

PFont font;

void setup(){

  size(500,500);

  background(0,0,0);

  smooth();

  

  font = loadFont("Serif-30.vlw");

  textFont(font, 30);

  readbutton = new Button(350, 200, "Read");

  loadbutton  = new Button(100, 200, "Load");

  savebutton = new Button(100, 250, "Save");

  

  

}

void draw(){

 fill(0,0,0,255);

  rect(0,0,width,height);

  if (love == 0){

    loadbutton.draw();

readbutton.draw();

savebutton.draw();}

else{

  println(file);

  textAlign(CENTER);

   i++;

String completelin = join(lines, "");

  //println(lines[i]);

  String[] tokens = completelin.split(" ");

 println("before"+ i); 

  //fill(255,255,255);

  fill(255,255,255);

  text(tokens[i],250,250);

  

   //println(tokens[i]);

  println(tokens.length);

 if (tokens.length - 2 == i){love = 0;}

    delay(430);

}

}

void mouseReleased(){

  

  if(loadbutton.over()){

    println("load"); 

     file = selectInput(); 

    lines = loadStrings(file);

love = 1;

    

  }

    

   

  if(readbutton.over()){

    lines = loadStrings("http://www.teenfeelings.net/tweet.php");

    //file = "http://www.teenfeelings.net/tweet.php";

      love = 1;

  

    println("click");   

  }

   if(savebutton.over()){

      

    println("dl");   

    String[] downll = loadStrings("http://www.teenfeelings.net/tweet.php");

    

    saveStrings(s+m+h+d+mn+y+".txt", downll);

  }

  

}

class Button{

  int x,y;

  String label;

  Button(int x, int y, String label){

    this.x = x;

    this.y = y;

    this.label = label;

  }

  void draw(){

    fill(0);

    if(over()){

      

fill(255);

    }

    rect(x, y, textWidth(label), 25);

    fill(255);

    text(label, x, y + 20);

  }

  boolean over(){

    if(mouseX >= x && mouseY >= y && mouseX <= x + textWidth(label) && mouseY <= y + 22){

return true;

    }

    return false;

  }

}